[PATCH] sg version 3.5.28 for lk 2.5.64

Changelog:
   - remove hosts, host_strs and host_hdr from sg's
     procfs interface **
   - add sysfs interface for allow_dio, def_reserved_size
     and version ***
   - switch boot time and module parameters to Rusty's
     moduleparam.h interface. This means, for example,
     the boot time "sg_def_reserved_size" parameter
     changes to "sg.def_reserved_size".

** Christoph moved the host listing functionality into
    a more central sysfs position (i.e. not dependent on
    sg). However scsi_debug is the only LLD that I can
    get to post any "host" info under the new arrangement.

    Should devices, device_strs and device_hdrs also be
    moved out of sg's procfs interface?

*** I find sg's "debug" in its procfs interface very
     useful for debugging (sg itself amongst other things).
     However it does not seem suitable for sysfs. Should
     it move?

diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 91dace681ba17ee44463ff7eb3c2ebddc7f2de28..bd6d50025126184589813063f3e7190f7f700ee6 100644 (file)
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -18,10 +18,8 @@
  *
  */
 #include <linux/config.h>
-#ifdef CONFIG_PROC_FS
-static char *sg_version_str = "Version: 3.5.27 (20030130)";
-#endif
-static int sg_version_num = 30527;     /* 2 digits for each component */
+static char *sg_version_str = "3.5.28 [20030308]";
+static int sg_version_num = 30528;     /* 2 digits for each component */
 /*
  *  D. P. Gilbert (dgilbert@interlog.com, dougg@triode.net.au), notes:
  *      - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
@@ -56,6 +54,7 @@ static int sg_version_num = 30527;    /* 2 digits for each component */
 #include <linux/poll.h>
 #include <linux/vmalloc.h>
 #include <linux/smp_lock.h>
+#include <linux/moduleparam.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -1327,27 +1326,6 @@ static struct file_operations sg_fops = {
        .fasync = sg_fasync,
 };
 
-#ifndef MODULE
-static int __init
-sg_def_reserved_size_setup(char *str)
-{
-       int tmp;
-
-       if (get_option(&str, &tmp) == 1) {
-               def_reserved_size = tmp;
-               if (tmp >= 0)
-                       sg_big_buff = tmp;
-               return 1;
-       } else {
-               printk(KERN_WARNING "sg_def_reserved_size : usage "
-                      "sg_def_reserved_size=n (n could be 65536, 131072 or 262144)\n");
-               return 0;
-       }
-}
-
-__setup("sg_def_reserved_size=", sg_def_reserved_size_setup);
-#endif
-
 /* Driverfs file support */
 static ssize_t
 sg_device_kdev_read(struct device *driverfs_dev, char *page)
@@ -1564,16 +1542,77 @@ sg_detach(Scsi_Device * scsidp)
                scsi_sleep(2);  /* dirty detach so delay device destruction */
 }
 
+/* Set 'perm' (4th argument) to 0 to disable module_param's definition
+ * of sysfs parameters (which module_param doesn't yet support).
+ * Sysfs parameters defined explicitly below.
+ */
+module_param_named(def_reserved_size, def_reserved_size, int, 0);
+module_param_named(allow_dio, sg_allow_dio, int, 0);
+
 MODULE_AUTHOR("Douglas Gilbert");
 MODULE_DESCRIPTION("SCSI generic (sg) driver");
-
-#ifdef MODULE_LICENSE
 MODULE_LICENSE("GPL");
-#endif
 
-MODULE_PARM(def_reserved_size, "i");
 MODULE_PARM_DESC(def_reserved_size, "size of buffer reserved for each fd");
 
+static ssize_t sg_allow_dio_show(struct device_driver * ddp, char * buf)
+{
+       return snprintf(buf, PAGE_SIZE, "%d\n", sg_allow_dio);
+}
+static ssize_t sg_allow_dio_store(struct device_driver * ddp,
+                                 const char * buf, size_t count)
+{
+       if (1 == sscanf(buf, "%d", &sg_allow_dio)) {
+               sg_allow_dio = sg_allow_dio ? 1 : 0;
+               return count;
+       }
+       return -EINVAL;
+}
+DRIVER_ATTR(allow_dio, S_IRUGO | S_IWUSR, sg_allow_dio_show, 
+           sg_allow_dio_store)
+
+static ssize_t sg_def_reserved_show(struct device_driver * ddp, char * buf)
+{
+       return snprintf(buf, PAGE_SIZE, "%d\n", sg_big_buff);
+}
+static ssize_t sg_def_reserved_store(struct device_driver * ddp,
+                                    const char * buf, size_t count)
+{
+       if (1 == sscanf(buf, "%d", &def_reserved_size)) {
+               if (def_reserved_size >= 0) {
+                       sg_big_buff = def_reserved_size;
+                       return count;
+               }
+       }
+       return -EINVAL;
+}
+DRIVER_ATTR(def_reserved_size, S_IRUGO | S_IWUSR, sg_def_reserved_show, 
+           sg_def_reserved_store)
+
+static ssize_t sg_version_show(struct device_driver * ddp, char * buf)
+{
+       return snprintf(buf, PAGE_SIZE, "%s\n", sg_version_str);
+}
+DRIVER_ATTR(version, S_IRUGO, sg_version_show, NULL)
+
+static void do_create_driverfs_files(void)
+{
+       struct device_driver * driverfs = &sg_template.scsi_driverfs_driver;
+
+       driver_create_file(driverfs, &driver_attr_allow_dio);
+       driver_create_file(driverfs, &driver_attr_def_reserved_size);
+       driver_create_file(driverfs, &driver_attr_version);
+}
+
+static void do_remove_driverfs_files(void)
+{
+       struct device_driver * driverfs = &sg_template.scsi_driverfs_driver;
+
+       driver_remove_file(driverfs, &driver_attr_version);
+       driver_remove_file(driverfs, &driver_attr_def_reserved_size);
+       driver_remove_file(driverfs, &driver_attr_allow_dio);
+}
+
 static int __init
 init_sg(void)
 {
@@ -1591,12 +1630,14 @@ init_sg(void)
 #ifdef CONFIG_PROC_FS
        sg_proc_init();
 #endif                         /* CONFIG_PROC_FS */
+       do_create_driverfs_files();
        return 0;
 }
 
 static void __exit
 exit_sg(void)
 {
+       do_remove_driverfs_files();
 #ifdef CONFIG_PROC_FS
        sg_proc_cleanup();
 #endif                         /* CONFIG_PROC_FS */
@@ -2656,10 +2697,6 @@ sg_get_dev(int dev)
 static struct proc_dir_entry *sg_proc_sgp = NULL;
 
 static char sg_proc_sg_dirname[] = "sg";
-static const char *sg_proc_leaf_names[] = { "allow_dio", "def_reserved_size",
-       "debug", "devices", "device_hdr", "device_strs",
-       "hosts", "host_hdr", "host_strs", "version"
-};
 
 static int sg_proc_adio_read(char *buffer, char **start, off_t offset,
                             int size, int *eof, void *data);
@@ -2693,13 +2730,21 @@ static int sg_proc_version_read(char *buffer, char **start, off_t offset,
                                int size, int *eof, void *data);
 static int sg_proc_version_info(char *buffer, int *len, off_t * begin,
                                off_t offset, int size);
-static read_proc_t *sg_proc_leaf_reads[] = {
-       sg_proc_adio_read, sg_proc_dressz_read, sg_proc_debug_read,
-       sg_proc_dev_read, sg_proc_devhdr_read, sg_proc_devstrs_read,
-       sg_proc_version_read
+
+struct sg_proc_leaf {
+       const char * name;
+       read_proc_t * rf;
+       write_proc_t * wf;
 };
-static write_proc_t *sg_proc_leaf_writes[] = {
-       sg_proc_adio_write, sg_proc_dressz_write, 0, 0, 0, 0, 0, 0, 0, 0
+
+static struct sg_proc_leaf sg_proc_leaf_arr[] = {
+       {"allow_dio", sg_proc_adio_read, sg_proc_adio_write},
+       {"def_reserved_size", sg_proc_dressz_read, sg_proc_dressz_write},
+       {"debug", sg_proc_debug_read, NULL},
+       {"devices", sg_proc_dev_read, NULL},
+       {"device_hdr", sg_proc_devhdr_read, NULL},
+       {"device_strs", sg_proc_devstrs_read, NULL},
+       {"version", sg_proc_version_read, NULL}
 };
 
 #define PRINT_PROC(fmt,args...)                                 \
@@ -2729,9 +2774,10 @@ static int
 sg_proc_init()
 {
        int k, mask;
-       int leaves =
-           sizeof (sg_proc_leaf_names) / sizeof (sg_proc_leaf_names[0]);
+       int num_leaves =
+           sizeof (sg_proc_leaf_arr) / sizeof (sg_proc_leaf_arr[0]);
        struct proc_dir_entry *pdep;
+       struct sg_proc_leaf * leaf;
 
        if (!proc_scsi)
                return 1;
@@ -2739,14 +2785,14 @@ sg_proc_init()
                                        S_IFDIR | S_IRUGO | S_IXUGO, proc_scsi);
        if (!sg_proc_sgp)
                return 1;
-       for (k = 0; k < leaves; ++k) {
-               mask = sg_proc_leaf_writes[k] ? S_IRUGO | S_IWUSR : S_IRUGO;
-               pdep =
-                   create_proc_entry(sg_proc_leaf_names[k], mask, sg_proc_sgp);
+       for (k = 0; k < num_leaves; ++k) {
+               leaf = &sg_proc_leaf_arr[k];
+               mask = leaf->wf ? S_IRUGO | S_IWUSR : S_IRUGO;
+               pdep = create_proc_entry(leaf->name, mask, sg_proc_sgp);
                if (pdep) {
-                       pdep->read_proc = sg_proc_leaf_reads[k];
-                       if (sg_proc_leaf_writes[k])
-                               pdep->write_proc = sg_proc_leaf_writes[k];
+                       pdep->read_proc = leaf->rf;
+                       if (leaf->wf)
+                               pdep->write_proc = leaf->wf;
                }
        }
        return 0;
@@ -2756,13 +2802,13 @@ static void
 sg_proc_cleanup()
 {
        int k;
-       int leaves =
-           sizeof (sg_proc_leaf_names) / sizeof (sg_proc_leaf_names[0]);
+       int num_leaves =
+           sizeof (sg_proc_leaf_arr) / sizeof (sg_proc_leaf_arr[0]);
 
        if ((!proc_scsi) || (!sg_proc_sgp))
                return;
-       for (k = 0; k < leaves; ++k)
-               remove_proc_entry(sg_proc_leaf_names[k], sg_proc_sgp);
+       for (k = 0; k < num_leaves; ++k)
+               remove_proc_entry(sg_proc_leaf_arr[k].name, sg_proc_sgp);
        remove_proc_entry(sg_proc_sg_dirname, proc_scsi);
 }