LU-8066 lov: Move suitable variables from procfs to sysfs

Migrate procfs files with simple output to sysfs. Create
sysfs symlinks for target_obds.

Linux-commit : cb1debff6d8b254536ec6ff642a2bdd22c86cb85

Change-Id: I97e403694fd1aab9f70363a2961beb08c6959447
Signed-off-by: Oleg Drokin <green@linuxhacker.ru>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: https://review.whamcloud.com/30960
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Dmitry Eremin <dmitry.eremin@intel.com>
Reviewed-by: Andreas Dilger <andreas.dilger@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>

diff --git a/lustre/include/obd.h b/lustre/include/obd.h
index 4e672f2..8098418 100644 (file)
--- a/lustre/include/obd.h
+++ b/lustre/include/obd.h
@@ -410,6 +410,8 @@ struct lov_obd {
        struct rw_semaphore     lov_notify_lock;
        /* Data-on-MDT: MDC array */
        struct lov_md_tgt_desc  *lov_mdc_tgts;
+
+       struct kobject          *lov_tgts_kobj;
 };
 
 struct lmv_tgt_desc {

diff --git a/lustre/lov/lov_internal.h b/lustre/lov/lov_internal.h
index 54c07a8..0c4cb57 100644 (file)
--- a/lustre/lov/lov_internal.h
+++ b/lustre/lov/lov_internal.h
@@ -305,10 +305,7 @@ void lsm_free_plain(struct lov_stripe_md *lsm);
 void dump_lsm(unsigned int level, const struct lov_stripe_md *lsm);
 
 /* lproc_lov.c */
-extern const struct file_operations lov_proc_target_fops;
-#ifdef CONFIG_PROC_FS
-extern struct lprocfs_vars lprocfs_lov_obd_vars[];
-#endif
+int lov_tunables_init(struct obd_device *obd);
 
 /* lov_cl.c */
 extern struct lu_device_type lov_device_type;

diff --git a/lustre/lov/lov_obd.c b/lustre/lov/lov_obd.c
index 51e14f5..0176c2f 100644 (file)
--- a/lustre/lov/lov_obd.c
+++ b/lustre/lov/lov_obd.c
@@ -103,6 +103,10 @@ static void lov_putref(struct obd_device *obd)
                        /* Disconnect */
                        __lov_del_obd(obd, tgt);
                }
+
+               if (lov->lov_tgts_kobj)
+                       kobject_put(lov->lov_tgts_kobj);
+
        } else {
                mutex_unlock(&lov->lov_lock);
        }
@@ -180,26 +184,17 @@ int lov_connect_obd(struct obd_device *obd, u32 index, int activate,
         CDEBUG(D_CONFIG, "Connected tgt idx %d %s (%s) %sactive\n", index,
                obd_uuid2str(tgt_uuid), tgt_obd->obd_name, activate ? "":"in");
 
-       if (lov->targets_proc_entry != NULL) {
-               struct proc_dir_entry *osc_symlink;
-               struct obd_device *osc_obd;
-
-               osc_obd = lov->lov_tgts[index]->ltd_exp->exp_obd;
-
-               LASSERT(osc_obd != NULL);
-               LASSERT(osc_obd->obd_magic == OBD_DEVICE_MAGIC);
-               LASSERT(osc_obd->obd_type->typ_name != NULL);
-
-               osc_symlink = lprocfs_add_symlink(osc_obd->obd_name,
-                                                 lov->targets_proc_entry,
-                                                 "../../../%s/%s",
-                                                 osc_obd->obd_type->typ_name,
-                                                 osc_obd->obd_name);
-               if (osc_symlink == NULL) {
-                       CERROR("cannot register LOV target "
-                              "/proc/fs/lustre/%s/%s/target_obds/%s\n",
-                              obd->obd_type->typ_name, obd->obd_name,
-                              osc_obd->obd_name);
+       if (lov->lov_tgts_kobj) {
+               /* Even if we failed, that's ok */
+               rc = sysfs_create_link(lov->lov_tgts_kobj,
+                                      &tgt_obd->obd_kset.kobj,
+                                      tgt_obd->obd_name);
+               if (rc) {
+                       CERROR("%s: can't register LOV target /sys/fs/lustre/%s/%s/target_obds/%s : rc = %d\n",
+                              obd->obd_name, obd->obd_type->typ_name,
+                              obd->obd_name,
+                              lov->lov_tgts[index]->ltd_exp->exp_obd->obd_name,
+                              rc);
                }
        }
        RETURN(0);
@@ -232,17 +227,11 @@ static int lov_connect(const struct lu_env *env,
         if (data)
                 lov->lov_ocd = *data;
 
-       lov->targets_proc_entry = lprocfs_register("target_obds",
-                                                  obd->obd_proc_entry,
-                                                  NULL, NULL);
-       if (IS_ERR(lov->targets_proc_entry)) {
-               CERROR("%s: cannot register "
-                      "/proc/fs/lustre/%s/%s/target_obds\n",
-                      obd->obd_name, obd->obd_type->typ_name, obd->obd_name);
-               lov->targets_proc_entry = NULL;
-       }
+       obd_getref(obd);
+
+       lov->lov_tgts_kobj = kobject_create_and_add("target_obds",
+                                                   &obd->obd_kset.kobj);
 
-        obd_getref(obd);
         for (i = 0; i < lov->desc.ld_tgt_count; i++) {
                 tgt = lov->lov_tgts[i];
                 if (!tgt || obd_uuid_empty(&tgt->ltd_uuid))
@@ -288,6 +277,10 @@ static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
         }
 
        if (osc_obd) {
+               if (lov->lov_tgts_kobj)
+                       sysfs_remove_link(lov->lov_tgts_kobj,
+                                         osc_obd->obd_name);
+
                /* Pass it on to our clients.
                 * XXX This should be an argument to disconnect,
                 * XXX not a back-door flag on the OBD.  Ah well.
@@ -346,9 +339,6 @@ static int lov_disconnect(struct obd_export *exp)
        }
        obd_putref(obd);
 
-       if (lov->targets_proc_entry != NULL)
-               lprocfs_remove(&lov->targets_proc_entry);
-
 out:
        rc = class_disconnect(exp); /* bz 9811 */
        RETURN(rc);
@@ -739,9 +729,6 @@ int lov_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 {
        struct lov_desc *desc;
        struct lov_obd *lov = &obd->u.lov;
-#ifdef CONFIG_PROC_FS
-       struct obd_type *type;
-#endif
        int rc;
        ENTRY;
 
@@ -795,47 +782,7 @@ int lov_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
         if (rc)
                GOTO(out, rc);
 
-       obd->obd_vars = lprocfs_lov_obd_vars;
-#ifdef CONFIG_PROC_FS
-       /* If this is true then both client (lov) and server
-        * (lod) are on the same node. The lod layer if loaded
-        * first will register the lov proc directory. In that
-        * case obd->obd_type->typ_procroot will be not set.
-        * Instead we use type->typ_procsym as the parent.
-        */
-       type = class_search_type(LUSTRE_LOD_NAME);
-       if (type && type->typ_procsym) {
-               obd->obd_proc_entry = lprocfs_register(obd->obd_name,
-                                                      type->typ_procsym,
-                                                      obd->obd_vars, obd);
-               if (IS_ERR(obd->obd_proc_entry)) {
-                       rc = PTR_ERR(obd->obd_proc_entry);
-                       CERROR("error %d setting up lprocfs for %s\n", rc,
-                              obd->obd_name);
-                       obd->obd_proc_entry = NULL;
-               }
-       }
-#endif
-
-       rc = lprocfs_obd_setup(obd, false);
-       if (rc)
-               GOTO(out, rc);
-
-       rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd", 0444,
-                               &lov_proc_target_fops, obd);
-       if (rc)
-               CWARN("%s: Error adding the target_obd file : rc %d\n",
-                     obd->obd_name, rc);
-
-       lov->lov_pool_proc_entry = lprocfs_register("pools",
-                                                   obd->obd_proc_entry,
-                                                   NULL, NULL);
-       if (IS_ERR(lov->lov_pool_proc_entry)) {
-               rc = PTR_ERR(lov->lov_pool_proc_entry);
-               CERROR("%s: error setting up ldebugfs for pools : rc %d\n",
-                      obd->obd_name, rc);
-               lov->lov_pool_proc_entry = NULL;
-       }
+       rc = lov_tunables_init(obd);
 out:
        return rc;
 }
@@ -936,15 +883,14 @@ int lov_process_config_base(struct obd_device *obd, struct lustre_cfg *lcfg,
        }
        case LCFG_PARAM: {
                struct lov_desc *desc = &(obd->u.lov.desc);
+               ssize_t count;
 
                if (!desc)
                        GOTO(out, rc = -EINVAL);
 
-               rc = class_process_proc_param(PARAM_LOV, obd->obd_vars,
-                                             lcfg, obd);
-               if (rc > 0)
-                       rc = 0;
-                GOTO(out, rc);
+               count = class_modify_config(lcfg, PARAM_LOV,
+                                           &obd->obd_kset.kobj);
+               GOTO(out, rc = count < 0 ? count : 0);
         }
         case LCFG_POOL_NEW:
         case LCFG_POOL_ADD:

diff --git a/lustre/lov/lproc_lov.c b/lustre/lov/lproc_lov.c
index a8d9b69..e93b6f2 100644 (file)
--- a/lustre/lov/lproc_lov.c
+++ b/lustre/lov/lproc_lov.c
@@ -38,7 +38,6 @@
 #include <uapi/linux/lustre/lustre_param.h>
 #include "lov_internal.h"
 
-#ifdef CONFIG_PROC_FS
 static int lov_stripesize_seq_show(struct seq_file *m, void *v)
 {
        struct obd_device *dev = (struct obd_device *)m->private;
@@ -75,29 +74,26 @@ static ssize_t lov_stripesize_seq_write(struct file *file,
 }
 LPROC_SEQ_FOPS(lov_stripesize);
 
-static int lov_stripeoffset_seq_show(struct seq_file *m, void *v)
+static ssize_t stripeoffset_show(struct kobject *kobj, struct attribute *attr,
+                                char *buf)
 {
-       struct obd_device *dev = (struct obd_device *)m->private;
-       struct lov_desc *desc;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
 
-       LASSERT(dev != NULL);
-       desc = &dev->u.lov.desc;
-       seq_printf(m, "%lld\n", desc->ld_default_stripe_offset);
-       return 0;
+       return sprintf(buf, "%llu\n", desc->ld_default_stripe_offset);
 }
 
-static ssize_t lov_stripeoffset_seq_write(struct file *file,
-                                         const char __user *buffer,
-                                         size_t count, loff_t *off)
+static ssize_t stripeoffset_store(struct kobject *kobj, struct attribute *attr,
+                                 const char *buf, size_t count)
 {
-       struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
-       struct lov_desc *desc;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
        long val;
        int rc;
 
-       LASSERT(dev != NULL);
-       desc = &dev->u.lov.desc;
-       rc = kstrtol_from_user(buffer, count, 0, &val);
+       rc = kstrtol(buf, 0, &val);
        if (rc)
                return rc;
        if (val < -1 || val > LOV_MAX_STRIPE_COUNT)
@@ -107,31 +103,28 @@ static ssize_t lov_stripeoffset_seq_write(struct file *file,
 
        return count;
 }
-LPROC_SEQ_FOPS(lov_stripeoffset);
+LUSTRE_RW_ATTR(stripeoffset);
 
-static int lov_stripetype_seq_show(struct seq_file *m, void *v)
+static ssize_t stripetype_show(struct kobject *kobj, struct attribute *attr,
+                              char *buf)
 {
-       struct obd_device* dev = (struct obd_device*)m->private;
-       struct lov_desc *desc;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
 
-       LASSERT(dev != NULL);
-       desc = &dev->u.lov.desc;
-       seq_printf(m, "%u\n", desc->ld_pattern);
-       return 0;
+       return sprintf(buf, "%u\n", desc->ld_pattern);
 }
 
-static ssize_t lov_stripetype_seq_write(struct file *file,
-                                       const char __user *buffer,
-                                       size_t count, loff_t *off)
+static ssize_t stripetype_store(struct kobject *kobj, struct attribute *attr,
+                               const char *buffer, size_t count)
 {
-       struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
-       struct lov_desc *desc;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
        u32 pattern;
        int rc;
 
-       LASSERT(dev != NULL);
-       desc = &dev->u.lov.desc;
-       rc = kstrtouint_from_user(buffer, count, 0, &pattern);
+       rc = kstrtouint(buffer, 0, &pattern);
        if (rc)
                return rc;
 
@@ -140,32 +133,29 @@ static ssize_t lov_stripetype_seq_write(struct file *file,
 
        return count;
 }
-LPROC_SEQ_FOPS(lov_stripetype);
+LUSTRE_RW_ATTR(stripetype);
 
-static int lov_stripecount_seq_show(struct seq_file *m, void *v)
+static ssize_t stripecount_show(struct kobject *kobj, struct attribute *attr,
+                               char *buf)
 {
-       struct obd_device *dev = (struct obd_device *)m->private;
-       struct lov_desc *desc;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
 
-       LASSERT(dev != NULL);
-       desc = &dev->u.lov.desc;
-       seq_printf(m, "%d\n",
-                 (__s16)(desc->ld_default_stripe_count + 1) - 1);
-       return 0;
+       return sprintf(buf, "%d\n",
+                      (__s16)(desc->ld_default_stripe_count + 1) - 1);
 }
 
-static ssize_t lov_stripecount_seq_write(struct file *file,
-                                        const char __user *buffer,
-                                        size_t count, loff_t *off)
+static ssize_t stripecount_store(struct kobject *kobj, struct attribute *attr,
+                                const char *buffer, size_t count)
 {
-       struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
-       struct lov_desc *desc;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
        int stripe_count;
        int rc;
 
-       LASSERT(dev != NULL);
-       desc = &dev->u.lov.desc;
-       rc = kstrtoint_from_user(buffer, count, 0, &stripe_count);
+       rc = kstrtoint(buffer, 0, &stripe_count);
        if (rc)
                return rc;
 
@@ -177,44 +167,42 @@ static ssize_t lov_stripecount_seq_write(struct file *file,
 
        return count;
 }
-LPROC_SEQ_FOPS(lov_stripecount);
+LUSTRE_RW_ATTR(stripecount);
 
-static int lov_numobd_seq_show(struct seq_file *m, void *v)
+static ssize_t numobd_show(struct kobject *kobj, struct attribute *attr,
+                          char *buf)
 {
-       struct obd_device *dev = (struct obd_device*)m->private;
-       struct lov_desc *desc;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
 
-       LASSERT(dev != NULL);
-       desc = &dev->u.lov.desc;
-       seq_printf(m, "%u\n", desc->ld_tgt_count);
-       return 0;
+       return sprintf(buf, "%u\n", desc->ld_tgt_count);
 }
-LPROC_SEQ_FOPS_RO(lov_numobd);
+LUSTRE_RO_ATTR(numobd);
 
-static int lov_activeobd_seq_show(struct seq_file *m, void *v)
+static ssize_t activeobd_show(struct kobject *kobj, struct attribute *attr,
+                             char *buf)
 {
-       struct obd_device* dev = (struct obd_device*)m->private;
-       struct lov_desc *desc;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
 
-       LASSERT(dev != NULL);
-       desc = &dev->u.lov.desc;
-       seq_printf(m, "%u\n", desc->ld_active_tgt_count);
-       return 0;
+       return sprintf(buf, "%u\n", desc->ld_active_tgt_count);
 }
-LPROC_SEQ_FOPS_RO(lov_activeobd);
+LUSTRE_RO_ATTR(activeobd);
 
-static int lov_desc_uuid_seq_show(struct seq_file *m, void *v)
+static ssize_t desc_uuid_show(struct kobject *kobj, struct attribute *attr,
+                             char *buf)
 {
-       struct obd_device *dev = m->private;
-       struct lov_obd *lov;
+       struct obd_device *dev = container_of(kobj, struct obd_device,
+                                             obd_kset.kobj);
+       struct lov_desc *desc = &dev->u.lov.desc;
 
-       LASSERT(dev != NULL);
-       lov = &dev->u.lov;
-       seq_printf(m, "%s\n", lov->desc.ld_uuid.uuid);
-       return 0;
+       return sprintf(buf, "%s\n", desc->ld_uuid.uuid);
 }
-LPROC_SEQ_FOPS_RO(lov_desc_uuid);
+LUSTRE_RO_ATTR(desc_uuid);
 
+#ifdef CONFIG_PROC_FS
 static void *lov_tgt_seq_start(struct seq_file *p, loff_t *pos)
 {
         struct obd_device *dev = p->private;
@@ -247,6 +235,7 @@ static void *lov_tgt_seq_next(struct seq_file *p, void *v, loff_t *pos)
 static int lov_tgt_seq_show(struct seq_file *p, void *v)
 {
         struct lov_tgt_desc *tgt = v;
+
        seq_printf(p, "%d: %s %sACTIVE\n", tgt->ltd_index,
                   obd_uuid2str(&tgt->ltd_uuid),
                   tgt->ltd_active ? "" : "IN");
@@ -265,10 +254,6 @@ static int lov_target_seq_open(struct inode *inode, struct file *file)
        struct seq_file *seq;
        int rc;
 
-       rc = LPROCFS_ENTRY_CHECK(inode);
-       if (rc < 0)
-               return rc;
-
        rc = seq_open(file, &lov_tgt_sops);
        if (rc)
                return rc;
@@ -279,20 +264,8 @@ static int lov_target_seq_open(struct inode *inode, struct file *file)
 }
 
 struct lprocfs_vars lprocfs_lov_obd_vars[] = {
-       { .name =       "stripesize",
-         .fops =       &lov_stripesize_fops    },
-       { .name =       "stripeoffset",
-         .fops =       &lov_stripeoffset_fops  },
-       { .name =       "stripecount",
-         .fops =       &lov_stripecount_fops   },
-       { .name =       "stripetype",
-         .fops =       &lov_stripetype_fops    },
-       { .name =       "numobd",
-         .fops =       &lov_numobd_fops        },
-       { .name =       "activeobd",
-         .fops =       &lov_activeobd_fops     },
-       { .name =       "desc_uuid",
-         .fops =       &lov_desc_uuid_fops     },
+       { .name =       "stripesize",
+         .fops =       &lov_stripesize_fops    },
        { NULL }
 };
 
@@ -304,3 +277,68 @@ const struct file_operations lov_proc_target_fops = {
         .release = lprocfs_seq_release,
 };
 #endif /* CONFIG_PROC_FS */
+
+static struct attribute *lov_attrs[] = {
+       &lustre_attr_activeobd.attr,
+       &lustre_attr_numobd.attr,
+       &lustre_attr_desc_uuid.attr,
+       &lustre_attr_stripeoffset.attr,
+       &lustre_attr_stripetype.attr,
+       &lustre_attr_stripecount.attr,
+       NULL,
+};
+
+int lov_tunables_init(struct obd_device *obd)
+{
+       struct lov_obd *lov = &obd->u.lov;
+#if defined(CONFIG_PROC_FS) && defined(HAVE_SERVER_SUPPORT)
+       struct obd_type *type;
+#endif
+       int rc;
+
+       obd->obd_vars = lprocfs_lov_obd_vars;
+#if defined(CONFIG_PROC_FS) && defined(HAVE_SERVER_SUPPORT)
+       /* If this is true then both client (lov) and server
+        * (lod) are on the same node. The lod layer if loaded
+        * first will register the lov proc directory. In that
+        * case obd->obd_type->typ_procroot will be not set.
+        * Instead we use type->typ_procsym as the parent.
+        */
+       type = class_search_type(LUSTRE_LOD_NAME);
+       if (type && type->typ_procsym) {
+               obd->obd_proc_entry = lprocfs_register(obd->obd_name,
+                                                      type->typ_procsym,
+                                                      obd->obd_vars, obd);
+               if (IS_ERR(obd->obd_proc_entry)) {
+                       rc = PTR_ERR(obd->obd_proc_entry);
+                       CERROR("error %d setting up lprocfs for %s\n", rc,
+                              obd->obd_name);
+                       obd->obd_proc_entry = NULL;
+               }
+       }
+#endif
+       obd->obd_ktype.default_attrs = lov_attrs;
+       rc = lprocfs_obd_setup(obd, false);
+       if (rc)
+               GOTO(out, rc);
+
+#ifdef CONFIG_PROC_FS
+       rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd", 0444,
+                               &lov_proc_target_fops, obd);
+       if (rc)
+               CWARN("%s: Error adding the target_obd file : rc %d\n",
+                     obd->obd_name, rc);
+
+       lov->lov_pool_proc_entry = lprocfs_register("pools",
+                                                   obd->obd_proc_entry,
+                                                   NULL, NULL);
+       if (IS_ERR(lov->lov_pool_proc_entry)) {
+               rc = PTR_ERR(lov->lov_pool_proc_entry);
+               CERROR("%s: error setting up debugfs for pools : rc %d\n",
+                      obd->obd_name, rc);
+               lov->lov_pool_proc_entry = NULL;
+       }
+#endif /* CONFIG_FS_PROC */
+out:
+       return rc;
+}