[Kernel-janitors] [PATCH] fix drivers/md/md.c warning when !CONFIG_PROC_FS.

hi all.

I'm getting this when CONFIG_PROC_FS=n in MD:

drivers/md/md.c: In function `md_geninit':
drivers/md/md.c:3481: warning: unused variable `p'
drivers/md/md.c: At top level:
drivers/md/md.c:3007: warning: `md_seq_fops' defined but not used

this patchs fixes it:

diff -Nru linux-2.6.0-test6-bk8/drivers/md/md.c 
linux-2.6.0-test6-bk8~/drivers/md/md.c
--- linux-2.6.0-test6-bk8/drivers/md/md.c       2003-09-27 21:50:14.000000000 
-0300
+++ linux-2.6.0-test6-bk8~/drivers/md/md.c      2003-10-06 15:59:26.000000000 
-0300
@@ -2783,234 +2783,6 @@
        md_wakeup_thread(mddev->thread);
 }
 
-/* seq_file implementation /proc/mdstat */
-
-static void status_unused(struct seq_file *seq)
-{
-       int i = 0;
-       mdk_rdev_t *rdev;
-       struct list_head *tmp;
-
-       seq_printf(seq, "unused devices: ");
-
-       ITERATE_RDEV_PENDING(rdev,tmp) {
-               char b[BDEVNAME_SIZE];
-               i++;
-               seq_printf(seq, "%s ",
-                             bdevname(rdev->bdev,b));
-       }
-       if (!i)
-               seq_printf(seq, "<none>");
-
-       seq_printf(seq, "\n");
-}
-
-
-static void status_resync(struct seq_file *seq, mddev_t * mddev)
-{
-       unsigned long max_blocks, resync, res, dt, db, rt;
-
-       resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
-       max_blocks = mddev->size;
-
-       /*
-        * Should not happen.
-        */
-       if (!max_blocks) {
-               MD_BUG();
-               return;
-       }
-       res = (resync/1024)*1000/(max_blocks/1024 + 1);
-       {
-               int i, x = res/50, y = 20-x;
-               seq_printf(seq, "[");
-               for (i = 0; i < x; i++)
-                       seq_printf(seq, "=");
-               seq_printf(seq, ">");
-               for (i = 0; i < y; i++)
-                       seq_printf(seq, ".");
-               seq_printf(seq, "] ");
-       }
-       seq_printf(seq, " %s =%3lu.%lu%% (%lu/%lu)",
-                     (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
-                      "resync" : "recovery"),
-                     res/10, res % 10, resync, max_blocks);
-
-       /*
-        * We do not want to overflow, so the order of operands and
-        * the * 100 / 100 trick are important. We do a +1 to be
-        * safe against division by zero. We only estimate anyway.
-        *
-        * dt: time from mark until now
-        * db: blocks written from mark until now
-        * rt: remaining time
-        */
-       dt = ((jiffies - mddev->resync_mark) / HZ);
-       if (!dt) dt++;
-       db = resync - (mddev->resync_mark_cnt/2);
-       rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
-
-       seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
-
-       seq_printf(seq, " speed=%ldK/sec", db/dt);
-}
-
-static void *md_seq_start(struct seq_file *seq, loff_t *pos)
-{
-       struct list_head *tmp;
-       loff_t l = *pos;
-       mddev_t *mddev;
-
-       if (l >= 0x10000)
-               return NULL;
-       if (!l--)
-               /* header */
-               return (void*)1;
-
-       spin_lock(&all_mddevs_lock);
-       list_for_each(tmp,&all_mddevs)
-               if (!l--) {
-                       mddev = list_entry(tmp, mddev_t, all_mddevs);
-                       mddev_get(mddev);
-                       spin_unlock(&all_mddevs_lock);
-                       return mddev;
-               }
-       spin_unlock(&all_mddevs_lock);
-       if (!l--)
-               return (void*)2;/* tail */
-       return NULL;
-}
-
-static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
-{
-       struct list_head *tmp;
-       mddev_t *next_mddev, *mddev = v;
-       
-       ++*pos;
-       if (v == (void*)2)
-               return NULL;
-
-       spin_lock(&all_mddevs_lock);
-       if (v == (void*)1)
-               tmp = all_mddevs.next;
-       else
-               tmp = mddev->all_mddevs.next;
-       if (tmp != &all_mddevs)
-               next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
-       else {
-               next_mddev = (void*)2;
-               *pos = 0x10000;
-       }               
-       spin_unlock(&all_mddevs_lock);
-
-       if (v != (void*)1)
-               mddev_put(mddev);
-       return next_mddev;
-
-}
-
-static void md_seq_stop(struct seq_file *seq, void *v)
-{
-       mddev_t *mddev = v;
-
-       if (mddev && v != (void*)1 && v != (void*)2)
-               mddev_put(mddev);
-}
-
-static int md_seq_show(struct seq_file *seq, void *v)
-{
-       mddev_t *mddev = v;
-       sector_t size;
-       struct list_head *tmp2;
-       mdk_rdev_t *rdev;
-       int i;
-
-       if (v == (void*)1) {
-               seq_printf(seq, "Personalities : ");
-               spin_lock(&pers_lock);
-               for (i = 0; i < MAX_PERSONALITY; i++)
-                       if (pers[i])
-                               seq_printf(seq, "[%s] ", pers[i]->name);
-
-               spin_unlock(&pers_lock);
-               seq_printf(seq, "\n");
-               return 0;
-       }
-       if (v == (void*)2) {
-               status_unused(seq);
-               return 0;
-       }
-
-       if (mddev_lock(mddev)!=0) 
-               return -EINTR;
-       if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
-               seq_printf(seq, "md%d : %sactive", mdidx(mddev),
-                                               mddev->pers ? "" : "in");
-               if (mddev->pers) {
-                       if (mddev->ro)
-                               seq_printf(seq, " (read-only)");
-                       seq_printf(seq, " %s", mddev->pers->name);
-               }
-
-               size = 0;
-               ITERATE_RDEV(mddev,rdev,tmp2) {
-                       char b[BDEVNAME_SIZE];
-                       seq_printf(seq, " %s[%d]",
-                               bdevname(rdev->bdev,b), rdev->desc_nr);
-                       if (rdev->faulty) {
-                               seq_printf(seq, "(F)");
-                               continue;
-                       }
-                       size += rdev->size;
-               }
-
-               if (!list_empty(&mddev->disks)) {
-                       if (mddev->pers)
-                               seq_printf(seq, "\n      %llu blocks",
-                                       (unsigned long long)mddev->array_size);
-                       else
-                               seq_printf(seq, "\n      %llu blocks",
-                                       (unsigned long long)size);
-               }
-
-               if (mddev->pers) {
-                       mddev->pers->status (seq, mddev);
-                       seq_printf(seq, "\n      ");
-                       if (mddev->curr_resync > 2)
-                               status_resync (seq, mddev);
-                       else if (mddev->curr_resync == 1 || mddev->curr_resync 
== 2)
-                               seq_printf(seq, "       resync=DELAYED");
-               }
-
-               seq_printf(seq, "\n");
-       }
-       mddev_unlock(mddev);
-       
-       return 0;
-}
-
-static struct seq_operations md_seq_ops = {
-       .start  = md_seq_start,
-       .next   = md_seq_next,
-       .stop   = md_seq_stop,
-       .show   = md_seq_show,
-};
-
-static int md_seq_open(struct inode *inode, struct file *file)
-{
-       int error;
-
-       error = seq_open(file, &md_seq_ops);
-       return error;
-}
-
-static struct file_operations md_seq_fops = {
-       .open           = md_seq_open,
-       .read           = seq_read,
-       .llseek         = seq_lseek,
-       .release        = seq_release,
-};
-
 int register_md_personality(int pnum, mdk_personality_t *p)
 {
        if (pnum >= MAX_PERSONALITY) {
@@ -3476,17 +3248,251 @@
        .priority       = INT_MAX, /* before any real devices */
 };
 
-static void md_geninit(void)
+#ifdef CONFIG_PROC_FS
+static void status_resync(struct seq_file *seq, mddev_t * mddev)
 {
-       struct proc_dir_entry *p;
+       unsigned long max_blocks, resync, res, dt, db, rt;
 
-       dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
+       resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
+       max_blocks = mddev->size;
+
+       /*
+        * Should not happen.
+        */
+       if (!max_blocks) {
+               MD_BUG();
+               return;
+       }
+       res = (resync/1024)*1000/(max_blocks/1024 + 1);
+       {
+               int i, x = res/50, y = 20-x;
+               seq_printf(seq, "[");
+               for (i = 0; i < x; i++)
+                       seq_printf(seq, "=");
+               seq_printf(seq, ">");
+               for (i = 0; i < y; i++)
+                       seq_printf(seq, ".");
+               seq_printf(seq, "] ");
+       }
+       seq_printf(seq, " %s =%3lu.%lu%% (%lu/%lu)",
+                     (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
+                      "resync" : "recovery"),
+                     res/10, res % 10, resync, max_blocks);
+
+       /*
+        * We do not want to overflow, so the order of operands and
+        * the * 100 / 100 trick are important. We do a +1 to be
+        * safe against division by zero. We only estimate anyway.
+        *
+        * dt: time from mark until now
+        * db: blocks written from mark until now
+        * rt: remaining time
+        */
+       dt = ((jiffies - mddev->resync_mark) / HZ);
+       if (!dt) dt++;
+       db = resync - (mddev->resync_mark_cnt/2);
+       rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
+
+       seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
+
+       seq_printf(seq, " speed=%ldK/sec", db/dt);
+}
+
+/* seq_file implementation /proc/mdstat */
+
+static void status_unused(struct seq_file *seq)
+{
+       int i = 0;
+       mdk_rdev_t *rdev;
+       struct list_head *tmp;
+
+       seq_printf(seq, "unused devices: ");
+
+       ITERATE_RDEV_PENDING(rdev,tmp) {
+               char b[BDEVNAME_SIZE];
+               i++;
+               seq_printf(seq, "%s ",
+                             bdevname(rdev->bdev,b));
+       }
+       if (!i)
+               seq_printf(seq, "<none>");
+
+       seq_printf(seq, "\n");
+}
+
+static void *md_seq_start(struct seq_file *seq, loff_t *pos)
+{
+       struct list_head *tmp;
+       loff_t l = *pos;
+       mddev_t *mddev;
+
+       if (l >= 0x10000)
+               return NULL;
+       if (!l--)
+               /* header */
+               return (void*)1;
+
+       spin_lock(&all_mddevs_lock);
+       list_for_each(tmp,&all_mddevs)
+               if (!l--) {
+                       mddev = list_entry(tmp, mddev_t, all_mddevs);
+                       mddev_get(mddev);
+                       spin_unlock(&all_mddevs_lock);
+                       return mddev;
+               }
+       spin_unlock(&all_mddevs_lock);
+       if (!l--)
+               return (void*)2;/* tail */
+       return NULL;
+}
+
+static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+       struct list_head *tmp;
+       mddev_t *next_mddev, *mddev = v;
+       
+       ++*pos;
+       if (v == (void*)2)
+               return NULL;
+
+       spin_lock(&all_mddevs_lock);
+       if (v == (void*)1)
+               tmp = all_mddevs.next;
+       else
+               tmp = mddev->all_mddevs.next;
+       if (tmp != &all_mddevs)
+               next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
+       else {
+               next_mddev = (void*)2;
+               *pos = 0x10000;
+       }               
+       spin_unlock(&all_mddevs_lock);
+
+       if (v != (void*)1)
+               mddev_put(mddev);
+       return next_mddev;
+
+}
+
+static void md_seq_stop(struct seq_file *seq, void *v)
+{
+       mddev_t *mddev = v;
+
+       if (mddev && v != (void*)1 && v != (void*)2)
+               mddev_put(mddev);
+}
+
+static int md_seq_show(struct seq_file *seq, void *v)
+{
+       mddev_t *mddev = v;
+       sector_t size;
+       struct list_head *tmp2;
+       mdk_rdev_t *rdev;
+       int i;
+
+       if (v == (void*)1) {
+               seq_printf(seq, "Personalities : ");
+               spin_lock(&pers_lock);
+               for (i = 0; i < MAX_PERSONALITY; i++)
+                       if (pers[i])
+                               seq_printf(seq, "[%s] ", pers[i]->name);
+
+               spin_unlock(&pers_lock);
+               seq_printf(seq, "\n");
+               return 0;
+       }
+       if (v == (void*)2) {
+               status_unused(seq);
+               return 0;
+       }
+
+       if (mddev_lock(mddev)!=0) 
+               return -EINTR;
+       if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
+               seq_printf(seq, "md%d : %sactive", mdidx(mddev),
+                                               mddev->pers ? "" : "in");
+               if (mddev->pers) {
+                       if (mddev->ro)
+                               seq_printf(seq, " (read-only)");
+                       seq_printf(seq, " %s", mddev->pers->name);
+               }
+
+               size = 0;
+               ITERATE_RDEV(mddev,rdev,tmp2) {
+                       char b[BDEVNAME_SIZE];
+                       seq_printf(seq, " %s[%d]",
+                               bdevname(rdev->bdev,b), rdev->desc_nr);
+                       if (rdev->faulty) {
+                               seq_printf(seq, "(F)");
+                               continue;
+                       }
+                       size += rdev->size;
+               }
+
+               if (!list_empty(&mddev->disks)) {
+                       if (mddev->pers)
+                               seq_printf(seq, "\n      %llu blocks",
+                                       (unsigned long long)mddev->array_size);
+                       else
+                               seq_printf(seq, "\n      %llu blocks",
+                                       (unsigned long long)size);
+               }
+
+               if (mddev->pers) {
+                       mddev->pers->status (seq, mddev);
+                       seq_printf(seq, "\n      ");
+                       if (mddev->curr_resync > 2)
+                               status_resync (seq, mddev);
+                       else if (mddev->curr_resync == 1 || mddev->curr_resync 
== 2)
+                               seq_printf(seq, "       resync=DELAYED");
+               }
+
+               seq_printf(seq, "\n");
+       }
+       mddev_unlock(mddev);
+       
+       return 0;
+}
+
+static struct seq_operations md_seq_ops = {
+       .start  = md_seq_start,
+       .next   = md_seq_next,
+       .stop   = md_seq_stop,
+       .show   = md_seq_show,
+};
+
+static int md_seq_open(struct inode *inode, struct file *file)
+{
+       int error;
+
+       error = seq_open(file, &md_seq_ops);
+       return error;
+}
+
+static struct file_operations md_seq_fops = {
+       .open           = md_seq_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = seq_release,
+};
+
+static void md_proc_init(void)
+{
+       struct proc_dir_entry *p;
 
-#ifdef CONFIG_PROC_FS
        p = create_proc_entry("mdstat", S_IRUGO, NULL);
        if (p)
                p->proc_fops = &md_seq_fops;
-#endif
+}
+#else
+static inline void md_proc_init(void) {}
+#endif /* CONFIG_PROC_FS */
+
+static void md_geninit(void)
+{
+       dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
+
+       md_proc_init();
 }
 
 int __init md_init(void)

-- 
Luiz Fernando N. Capitulino
<lcapitulino@xxxxxxxxxxxxxxxxxxxx>
<http://www.telecentros.sp.gov.br>