block: fix missing bio back/front segment size setting in blk_recount_segments()

[safe/jmp/linux-2.6] / block / cmd-filter.c

diff --git a/block/cmd-filter.c b/block/cmd-filter.c
index c705c33..504b275 100644 (file)
--- a/block/cmd-filter.c
+++ b/block/cmd-filter.c
@@ -20,15 +20,14 @@
 #include <linux/list.h>
 #include <linux/genhd.h>
 #include <linux/spinlock.h>
-#include <linux/parser.h>
 #include <linux/capability.h>
 #include <linux/bitops.h>
 
 #include <scsi/scsi.h>
 #include <linux/cdrom.h>
 
-int blk_verify_command(struct blk_scsi_cmd_filter *filter,
-                      unsigned char *cmd, int has_write_perm)
+int blk_verify_command(struct blk_cmd_filter *filter,
+                      unsigned char *cmd, fmode_t has_write_perm)
 {
        /* root can do any command. */
        if (capable(CAP_SYS_RAWIO))
@@ -50,8 +49,9 @@ int blk_verify_command(struct blk_scsi_cmd_filter *filter,
 }
 EXPORT_SYMBOL(blk_verify_command);
 
+#if 0
 /* and now, the sysfs stuff */
-static ssize_t rcf_cmds_show(struct blk_scsi_cmd_filter *filter, char *page,
+static ssize_t rcf_cmds_show(struct blk_cmd_filter *filter, char *page,
                             int rw)
 {
        char *npage = page;
@@ -65,8 +65,7 @@ static ssize_t rcf_cmds_show(struct blk_scsi_cmd_filter *filter, char *page,
 
        for (i = 0; i < BLK_SCSI_MAX_CMDS; i++) {
                if (test_bit(i, okbits)) {
-                       sprintf(npage, "%02x", i);
-                       npage += 2;
+                       npage += sprintf(npage, "0x%02x", i);
                        if (i < BLK_SCSI_MAX_CMDS - 1)
                                sprintf(npage++, " ");
                }
@@ -78,57 +77,65 @@ static ssize_t rcf_cmds_show(struct blk_scsi_cmd_filter *filter, char *page,
        return npage - page;
 }
 
-static ssize_t rcf_readcmds_show(struct blk_scsi_cmd_filter *filter, char *page)
+static ssize_t rcf_readcmds_show(struct blk_cmd_filter *filter, char *page)
 {
        return rcf_cmds_show(filter, page, READ);
 }
 
-static ssize_t rcf_writecmds_show(struct blk_scsi_cmd_filter *filter,
+static ssize_t rcf_writecmds_show(struct blk_cmd_filter *filter,
                                 char *page)
 {
        return rcf_cmds_show(filter, page, WRITE);
 }
 
-static ssize_t rcf_cmds_store(struct blk_scsi_cmd_filter *filter,
+static ssize_t rcf_cmds_store(struct blk_cmd_filter *filter,
                              const char *page, size_t count, int rw)
 {
-       ssize_t ret = 0;
        unsigned long okbits[BLK_SCSI_CMD_PER_LONG], *target_okbits;
-       int cmd, status, len;
-       substring_t ss;
-
-       memset(&okbits, 0, sizeof(okbits));
-
-       for (len = strlen(page); len > 0; len -= 3) {
-               if (len < 2)
-                       break;
-               ss.from = (char *) page + ret;
-               ss.to = (char *) page + ret + 2;
-               ret += 3;
-               status = match_hex(&ss, &cmd);
+       int cmd, set;
+       char *p, *status;
+
+       if (rw == READ) {
+               memcpy(&okbits, filter->read_ok, sizeof(okbits));
+               target_okbits = filter->read_ok;
+       } else {
+               memcpy(&okbits, filter->write_ok, sizeof(okbits));
+               target_okbits = filter->write_ok;
+       }
+
+       while ((p = strsep((char **)&page, " ")) != NULL) {
+               set = 1;
+
+               if (p[0] == '+') {
+                       p++;
+               } else if (p[0] == '-') {
+                       set = 0;
+                       p++;
+               }
+
+               cmd = simple_strtol(p, &status, 16);
+
                /* either of these cases means invalid input, so do nothing. */
-               if (status || cmd >= BLK_SCSI_MAX_CMDS)
+               if ((status == p) || cmd >= BLK_SCSI_MAX_CMDS)
                        return -EINVAL;
 
-               __set_bit(cmd, okbits);
+               if (set)
+                       __set_bit(cmd, okbits);
+               else
+                       __clear_bit(cmd, okbits);
        }
 
-       if (rw == READ)
-               target_okbits = filter->read_ok;
-       else
-               target_okbits = filter->write_ok;
-
-       memmove(target_okbits, okbits, sizeof(okbits));
+       memcpy(target_okbits, okbits, sizeof(okbits));
        return count;
 }
 
-static ssize_t rcf_readcmds_store(struct blk_scsi_cmd_filter *filter,
+static ssize_t rcf_readcmds_store(struct blk_cmd_filter *filter,
                                  const char *page, size_t count)
 {
        return rcf_cmds_store(filter, page, count, READ);
 }
 
-static ssize_t rcf_writecmds_store(struct blk_scsi_cmd_filter *filter,
+static ssize_t rcf_writecmds_store(struct blk_cmd_filter *filter,
                                   const char *page, size_t count)
 {
        return rcf_cmds_store(filter, page, count, WRITE);
@@ -136,8 +143,8 @@ static ssize_t rcf_writecmds_store(struct blk_scsi_cmd_filter *filter,
 
 struct rcf_sysfs_entry {
        struct attribute attr;
-       ssize_t (*show)(struct blk_scsi_cmd_filter *, char *);
-       ssize_t (*store)(struct blk_scsi_cmd_filter *, const char *, size_t);
+       ssize_t (*show)(struct blk_cmd_filter *, char *);
+       ssize_t (*store)(struct blk_cmd_filter *, const char *, size_t);
 };
 
 static struct rcf_sysfs_entry rcf_readcmds_entry = {
@@ -164,9 +171,9 @@ static ssize_t
 rcf_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
 {
        struct rcf_sysfs_entry *entry = to_rcf(attr);
-       struct blk_scsi_cmd_filter *filter;
+       struct blk_cmd_filter *filter;
 
-       filter = container_of(kobj, struct blk_scsi_cmd_filter, kobj);
+       filter = container_of(kobj, struct blk_cmd_filter, kobj);
        if (entry->show)
                return entry->show(filter, page);
 
@@ -178,7 +185,7 @@ rcf_attr_store(struct kobject *kobj, struct attribute *attr,
                        const char *page, size_t length)
 {
        struct rcf_sysfs_entry *entry = to_rcf(attr);
-       struct blk_scsi_cmd_filter *filter;
+       struct blk_cmd_filter *filter;
 
        if (!capable(CAP_SYS_RAWIO))
                return -EPERM;
@@ -186,7 +193,7 @@ rcf_attr_store(struct kobject *kobj, struct attribute *attr,
        if (!entry->store)
                return -EINVAL;
 
-       filter = container_of(kobj, struct blk_scsi_cmd_filter, kobj);
+       filter = container_of(kobj, struct blk_cmd_filter, kobj);
        return entry->store(filter, page, length);
 }
 
@@ -203,26 +210,23 @@ static struct kobj_type rcf_ktype = {
 int blk_register_filter(struct gendisk *disk)
 {
        int ret;
-       struct blk_scsi_cmd_filter *filter = &disk->queue->cmd_filter;
-       struct kobject *parent = kobject_get(disk->holder_dir->parent);
-
-       if (!parent)
-               return -ENODEV;
+       struct blk_cmd_filter *filter = &disk->queue->cmd_filter;
 
-       ret = kobject_init_and_add(&filter->kobj, &rcf_ktype, parent,
+       ret = kobject_init_and_add(&filter->kobj, &rcf_ktype,
+                                  &disk_to_dev(disk)->kobj,
                                   "%s", "cmd_filter");
-
        if (ret < 0)
                return ret;
 
        return 0;
 }
+EXPORT_SYMBOL(blk_register_filter);
 
 void blk_unregister_filter(struct gendisk *disk)
 {
-       struct blk_scsi_cmd_filter *filter = &disk->queue->cmd_filter;
+       struct blk_cmd_filter *filter = &disk->queue->cmd_filter;
 
        kobject_put(&filter->kobj);
-       kobject_put(disk->holder_dir->parent);
 }
-
+EXPORT_SYMBOL(blk_unregister_filter);
+#endif