LU-8066 mdd: migrate from proc to sysfs

Move the ofd module from using proc for most single value files
to sysfs. The more complex proc entries are moved to debugfs.

Change-Id: I01eebf1c58f1a13c2f5e8c599a1363c80468b0bd
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: https://review.whamcloud.com/33632
Tested-by: Jenkins
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Alex Zhuravlev <bzzz@whamcloud.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/include/lustre_lfsck.h b/lustre/include/lustre_lfsck.h
index d982b1a..11409b9 100644 (file)
--- a/lustre/include/lustre_lfsck.h
+++ b/lustre/include/lustre_lfsck.h
@@ -103,7 +103,7 @@ int lfsck_query(const struct lu_env *env, struct dt_device *key,
 
 int lfsck_get_speed(struct seq_file *m, char *buf, struct dt_device *key);
 int lfsck_set_speed(struct dt_device *key, __u32 val);
 
 int lfsck_get_speed(struct seq_file *m, char *buf, struct dt_device *key);
 int lfsck_set_speed(struct dt_device *key, __u32 val);

-int lfsck_get_windows(struct seq_file *m, struct dt_device *key);
+int lfsck_get_windows(char *buf, struct dt_device *key);

 int lfsck_set_windows(struct dt_device *key, unsigned int val);
 
 int lfsck_dump(struct seq_file *m, struct dt_device *key, enum lfsck_type type);
 int lfsck_set_windows(struct dt_device *key, unsigned int val);
 
 int lfsck_dump(struct seq_file *m, struct dt_device *key, enum lfsck_type type);

diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c
index 80cb8eb..5f5860f 100644 (file)
--- a/lustre/lfsck/lfsck_lib.c
+++ b/lustre/lfsck/lfsck_lib.c
@@ -2804,7 +2804,7 @@ int lfsck_set_speed(struct dt_device *key, __u32 val)
 }
 EXPORT_SYMBOL(lfsck_set_speed);
 
 }
 EXPORT_SYMBOL(lfsck_set_speed);
 

-int lfsck_get_windows(struct seq_file *m, struct dt_device *key)
+int lfsck_get_windows(char *buf, struct dt_device *key)

 {
        struct lu_env           env;
        struct lfsck_instance  *lfsck;
 {
        struct lu_env           env;
        struct lfsck_instance  *lfsck;


@@ -2817,7 +2817,8 @@ int lfsck_get_windows(struct seq_file *m, struct dt_device *key)
 
        lfsck = lfsck_instance_find(key, true, false);
        if (likely(lfsck != NULL)) {
 
        lfsck = lfsck_instance_find(key, true, false);
        if (likely(lfsck != NULL)) {

-               seq_printf(m, "%u\n", lfsck->li_bookmark_ram.lb_async_windows);
+               rc = sprintf(buf, "%u\n",
+                            lfsck->li_bookmark_ram.lb_async_windows);

                lfsck_instance_put(&env, lfsck);
        } else {
                rc = -ENXIO;
                lfsck_instance_put(&env, lfsck);
        } else {
                rc = -ENXIO;

diff --git a/lustre/mdd/mdd_device.c b/lustre/mdd/mdd_device.c
index ac5ee30..4bf260f 100644 (file)
--- a/lustre/mdd/mdd_device.c
+++ b/lustre/mdd/mdd_device.c
@@ -1095,10 +1095,11 @@ static int mdd_process_config(const struct lu_env *env,
 
         switch (cfg->lcfg_command) {
        case LCFG_PARAM: {
 
         switch (cfg->lcfg_command) {
        case LCFG_PARAM: {

-               struct obd_device *obd = mdd2obd_dev(m);
+               ssize_t count;

 
 

-               rc = class_process_proc_param(PARAM_MDD, obd->obd_vars, cfg, m);
-               if (rc > 0 || rc == -ENOSYS)
+               count = class_modify_config(cfg, PARAM_MDD, &m->mdd_kobj);
+               rc = count > 0 ? 0 : count;
+               if (rc)

                        /* we don't understand; pass it on */
                        rc = next->ld_ops->ldo_process_config(env, next, cfg);
                break;
                        /* we don't understand; pass it on */
                        rc = next->ld_ops->ldo_process_config(env, next, cfg);
                break;


@@ -1982,7 +1983,7 @@ static int __init mdd_init(void)
        if (rc)
                return rc;
 
        if (rc)
                return rc;
 

-       rc = class_register_type(&mdd_obd_device_ops, NULL, true, NULL,
+       rc = class_register_type(&mdd_obd_device_ops, NULL, false, NULL,

                                 LUSTRE_MDD_NAME, &mdd_device_type);
        if (rc)
                lu_kmem_fini(mdd_caches);
                                 LUSTRE_MDD_NAME, &mdd_device_type);
        if (rc)
                lu_kmem_fini(mdd_caches);

diff --git a/lustre/mdd/mdd_internal.h b/lustre/mdd/mdd_internal.h
index ba43571..d1f195c 100644 (file)
--- a/lustre/mdd/mdd_internal.h
+++ b/lustre/mdd/mdd_internal.h
@@ -139,7 +139,6 @@ struct mdd_device {
        struct lu_fid                    mdd_local_root_fid;
         struct dt_device_param           mdd_dt_conf;
         struct dt_object                *mdd_orphans; /* PENDING directory */
        struct lu_fid                    mdd_local_root_fid;
         struct dt_device_param           mdd_dt_conf;
         struct dt_object                *mdd_orphans; /* PENDING directory */

-       struct proc_dir_entry            *mdd_proc_entry;

         struct mdd_changelog             mdd_cl;
        unsigned int                     mdd_changelog_gc;
        time64_t                         mdd_changelog_max_idle_time;
         struct mdd_changelog             mdd_cl;
        unsigned int                     mdd_changelog_gc;
        time64_t                         mdd_changelog_max_idle_time;


@@ -153,6 +152,9 @@ struct mdd_device {
        int                              mdd_connects;
        struct local_oid_storage        *mdd_los;
        struct mdd_generic_thread        mdd_orphan_cleanup_thread;
        int                              mdd_connects;
        struct local_oid_storage        *mdd_los;
        struct mdd_generic_thread        mdd_orphan_cleanup_thread;

+       struct kobject                   mdd_kobj;
+       struct kobj_type                 mdd_ktype;
+       struct completion                mdd_kobj_unregister;

 };
 
 enum mod_flags {
 };
 
 enum mod_flags {

diff --git a/lustre/mdd/mdd_lproc.c b/lustre/mdd/mdd_lproc.c
index 78366e3..fe3ddaa 100644 (file)
--- a/lustre/mdd/mdd_lproc.c
+++ b/lustre/mdd/mdd_lproc.c
@@ -45,31 +45,43 @@
 #include <libcfs/libcfs_string.h>
 #include "mdd_internal.h"
 
 #include <libcfs/libcfs_string.h>
 #include "mdd_internal.h"
 

-static ssize_t
-mdd_atime_diff_seq_write(struct file *file, const char __user *buffer,
-                        size_t count, loff_t *off)
+static ssize_t uuid_show(struct kobject *kobj, struct attribute *attr,
+                        char *buf)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);
+       struct obd_device *obd = mdd2obd_dev(mdd);
+
+       return sprintf(buf, "%s\n", obd->obd_uuid.uuid);
+}
+LUSTRE_RO_ATTR(uuid);
+
+static ssize_t atime_diff_show(struct kobject *kobj, struct attribute *attr,
+                              char *buf)
+{
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);
+
+       return sprintf(buf, "%lld\n", mdd->mdd_atime_diff);
+}
+
+static ssize_t atime_diff_store(struct kobject *kobj,
+                               struct attribute *attr,
+                               const char *buffer, size_t count)
+{
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        time64_t diff = 0;
        int rc;
 
        time64_t diff = 0;
        int rc;
 

-       rc = kstrtoll_from_user(buffer, count, 0, &diff);
+       rc = kstrtoll(buffer, 10, &diff);

        if (rc)
                return rc;
 
         mdd->mdd_atime_diff = diff;
         return count;
 }
        if (rc)
                return rc;
 
         mdd->mdd_atime_diff = diff;
         return count;
 }

-
-static int mdd_atime_diff_seq_show(struct seq_file *m, void *data)
-{
-       struct mdd_device *mdd = m->private;
-
-       seq_printf(m, "%lld\n", mdd->mdd_atime_diff);
-       return 0;
-}
-LPROC_SEQ_FOPS(mdd_atime_diff);
+LUSTRE_RW_ATTR(atime_diff);

 
 /**** changelogs ****/
 static int mdd_changelog_mask_seq_show(struct seq_file *m, void *data)
 
 /**** changelogs ****/
 static int mdd_changelog_mask_seq_show(struct seq_file *m, void *data)


@@ -113,7 +125,7 @@ out:
        OBD_FREE(kernbuf, PAGE_SIZE);
        return rc;
 }
        OBD_FREE(kernbuf, PAGE_SIZE);
        return rc;
 }

-LPROC_SEQ_FOPS(mdd_changelog_mask);
+LDEBUGFS_SEQ_FOPS(mdd_changelog_mask);

 
 static int lprocfs_changelog_users_cb(const struct lu_env *env,
                                      struct llog_handle *llh,
 
 static int lprocfs_changelog_users_cb(const struct lu_env *env,
                                      struct llog_handle *llh,


@@ -166,7 +178,7 @@ static int mdd_changelog_users_seq_show(struct seq_file *m, void *data)
        llog_ctxt_put(ctxt);
        return 0;
 }
        llog_ctxt_put(ctxt);
        return 0;
 }

-LPROC_SEQ_FOPS_RO(mdd_changelog_users);
+LDEBUGFS_SEQ_FOPS_RO(mdd_changelog_users);

 
 static int mdd_changelog_size_ctxt(const struct lu_env *env,
                                   struct mdd_device *mdd,
 
 static int mdd_changelog_size_ctxt(const struct lu_env *env,
                                   struct mdd_device *mdd,


@@ -193,12 +205,15 @@ static int mdd_changelog_size_ctxt(const struct lu_env *env,
        return 0;
 }
 
        return 0;
 }
 

-static int mdd_changelog_size_seq_show(struct seq_file *m, void *data)
+static ssize_t changelog_size_show(struct kobject *kobj,
+                                  struct attribute *attr,
+                                  char *buf)

 {
 {

-       struct lu_env            env;
-       struct mdd_device       *mdd = m->private;
-       __u64                    tmp = 0;
-       int                      rc;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);
+       struct lu_env env;
+       u64 tmp = 0;
+       int rc;

 
        rc = lu_env_init(&env, LCT_LOCAL);
        if (rc)
 
        rc = lu_env_init(&env, LCT_LOCAL);
        if (rc)


@@ -213,32 +228,32 @@ static int mdd_changelog_size_seq_show(struct seq_file *m, void *data)
        rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT,
                                     &tmp);
 
        rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT,
                                     &tmp);
 

-       seq_printf(m, "%llu\n", tmp);
+       rc = sprintf(buf, "%llu\n", tmp);

        lu_env_fini(&env);
        return rc;
 }
        lu_env_fini(&env);
        return rc;
 }

-LPROC_SEQ_FOPS_RO(mdd_changelog_size);
+LUSTRE_RO_ATTR(changelog_size);

 
 

-static int mdd_changelog_gc_seq_show(struct seq_file *m, void *data)
+static ssize_t changelog_gc_show(struct kobject *kobj,
+                                struct attribute *attr,
+                                char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       LASSERT(mdd != NULL);
-       seq_printf(m, "%u\n", mdd->mdd_changelog_gc);
-       return 0;
+       return sprintf(buf, "%u\n", mdd->mdd_changelog_gc);

 }
 
 }
 

-static ssize_t
-mdd_changelog_gc_seq_write(struct file *file, const char __user *buffer,
-                          size_t count, loff_t *off)
+static ssize_t changelog_gc_store(struct kobject *kobj,
+                                 struct attribute *attr,
+                                 const char *buffer, size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        bool val;
        int rc;
 
        bool val;
        int rc;
 

-       LASSERT(mdd != NULL);
-       rc = kstrtobool_from_user(buffer, count, &val);
+       rc = kstrtobool(buffer, &val);

        if (rc)
                return rc;
 
        if (rc)
                return rc;
 


@@ -246,30 +261,28 @@ mdd_changelog_gc_seq_write(struct file *file, const char __user *buffer,
 
        return count;
 }
 
        return count;
 }

-LPROC_SEQ_FOPS(mdd_changelog_gc);
+LUSTRE_RW_ATTR(changelog_gc);

 
 

-static int mdd_changelog_max_idle_time_seq_show(struct seq_file *m, void *data)
+static ssize_t changelog_max_idle_time_show(struct kobject *kobj,
+                                           struct attribute *attr,
+                                           char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       LASSERT(mdd != NULL);
-       seq_printf(m, "%lld\n", mdd->mdd_changelog_max_idle_time);
-       return 0;
+       return sprintf(buf, "%lld\n", mdd->mdd_changelog_max_idle_time);

 }
 
 }
 

-static ssize_t
-mdd_changelog_max_idle_time_seq_write(struct file *file,
-                                     const char __user *buffer, size_t count,
-                                     loff_t *off)
+static ssize_t changelog_max_idle_time_store(struct kobject *kobj,
+                                            struct attribute *attr,
+                                            const char *buffer, size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        time64_t val;
        int rc;
 
        time64_t val;
        int rc;
 

-       LASSERT(mdd != NULL);
-
-       rc = kstrtoll_from_user(buffer, count, 0, &val);
+       rc = kstrtoll(buffer, 10, &val);

        if (rc)
                return rc;
 
        if (rc)
                return rc;
 


@@ -284,30 +297,30 @@ mdd_changelog_max_idle_time_seq_write(struct file *file,
 
        return count;
 }
 
        return count;
 }

-LPROC_SEQ_FOPS(mdd_changelog_max_idle_time);
+LUSTRE_RW_ATTR(changelog_max_idle_time);

 
 

-static int mdd_changelog_max_idle_indexes_seq_show(struct seq_file *m,
-                                                  void *data)
+static ssize_t changelog_max_idle_indexes_show(struct kobject *kobj,
+                                              struct attribute *attr,
+                                              char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       LASSERT(mdd != NULL);
-       seq_printf(m, "%lu\n", mdd->mdd_changelog_max_idle_indexes);
-       return 0;
+       return sprintf(buf, "%lu\n", mdd->mdd_changelog_max_idle_indexes);

 }
 
 }
 

-static ssize_t
-mdd_changelog_max_idle_indexes_seq_write(struct file *file,
-                                        const char __user *buffer,
-                                        size_t count, loff_t *off)
+static ssize_t changelog_max_idle_indexes_store(struct kobject *kobj,
+                                               struct attribute *attr,
+                                               const char *buffer,
+                                               size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        unsigned long val;
        int rc;
 
        LASSERT(mdd != NULL);
        unsigned long val;
        int rc;
 
        LASSERT(mdd != NULL);

-       rc = kstrtoul_from_user(buffer, count, 0, &val);
+       rc = kstrtoul(buffer, 0, &val);

        if (rc)
                return rc;
 
        if (rc)
                return rc;
 


@@ -318,30 +331,29 @@ mdd_changelog_max_idle_indexes_seq_write(struct file *file,
 
        return count;
 }
 
        return count;
 }

-LPROC_SEQ_FOPS(mdd_changelog_max_idle_indexes);
+LUSTRE_RW_ATTR(changelog_max_idle_indexes);

 
 

-static int mdd_changelog_min_gc_interval_seq_show(struct seq_file *m,
-                                                 void *data)
+static ssize_t changelog_min_gc_interval_show(struct kobject *kobj,
+                                             struct attribute *attr,
+                                             char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       LASSERT(mdd != NULL);
-       seq_printf(m, "%lld\n", mdd->mdd_changelog_min_gc_interval);
-       return 0;
+       return sprintf(buf, "%lld\n", mdd->mdd_changelog_min_gc_interval);

 }
 
 }
 

-static ssize_t
-mdd_changelog_min_gc_interval_seq_write(struct file *file,
-                                       const char __user *buffer,
-                                       size_t count, loff_t *off)
+static ssize_t changelog_min_gc_interval_store(struct kobject *kobj,
+                                              struct attribute *attr,
+                                              const char *buffer,
+                                              size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        time64_t val;
        int rc;
 
        time64_t val;
        int rc;
 

-       LASSERT(mdd != NULL);
-       rc = kstrtoll_from_user(buffer, count, 0, &val);
+       rc = kstrtoll(buffer, 10, &val);

        if (rc)
                return rc;
 
        if (rc)
                return rc;
 


@@ -353,30 +365,29 @@ mdd_changelog_min_gc_interval_seq_write(struct file *file,
 
        return count;
 }
 
        return count;
 }

-LPROC_SEQ_FOPS(mdd_changelog_min_gc_interval);
+LUSTRE_RW_ATTR(changelog_min_gc_interval);

 
 

-static int mdd_changelog_min_free_cat_entries_seq_show(struct seq_file *m,
-                                                      void *data)
+static ssize_t changelog_min_free_cat_entries_show(struct kobject *kobj,
+                                                  struct attribute *attr,
+                                                  char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       LASSERT(mdd != NULL);
-       seq_printf(m, "%u\n", mdd->mdd_changelog_min_free_cat_entries);
-       return 0;
+       return sprintf(buf, "%u\n", mdd->mdd_changelog_min_free_cat_entries);

 }
 
 }
 

-static ssize_t
-mdd_changelog_min_free_cat_entries_seq_write(struct file *file,
-                                            const char __user *buffer,
-                                            size_t count, loff_t *off)
+static ssize_t changelog_min_free_cat_entries_store(struct kobject *kobj,
+                                                   struct attribute *attr,
+                                                   const char *buffer,
+                                                   size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        unsigned int val;
        int rc;
 
        unsigned int val;
        int rc;
 

-       LASSERT(mdd != NULL);
-       rc = kstrtouint_from_user(buffer, count, 0, &val);
+       rc = kstrtouint(buffer, 10, &val);

        if (rc)
                return rc;
 
        if (rc)
                return rc;
 


@@ -388,63 +399,55 @@ mdd_changelog_min_free_cat_entries_seq_write(struct file *file,
 
        return count;
 }
 
        return count;
 }

-LPROC_SEQ_FOPS(mdd_changelog_min_free_cat_entries);
+LUSTRE_RW_ATTR(changelog_min_free_cat_entries);

 
 

-static int mdd_changelog_deniednext_seq_show(struct seq_file *m, void *data)
+static ssize_t changelog_deniednext_show(struct kobject *kobj,
+                                        struct attribute *attr,
+                                        char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       seq_printf(m, "%u\n", mdd->mdd_cl.mc_deniednext);
-       return 0;
+       return sprintf(buf, "%u\n", mdd->mdd_cl.mc_deniednext);

 }
 
 }
 

-static ssize_t
-mdd_changelog_deniednext_seq_write(struct file *file, const char __user *buffer,
-                                  size_t count, loff_t *off)
+static ssize_t changelog_deniednext_store(struct kobject *kobj,
+                                         struct attribute *attr,
+                                         const char *buffer,
+                                         size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
-       char kernbuf[11];
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        unsigned int time = 0;
        int rc;
 
        unsigned int time = 0;
        int rc;
 

-       if (count > (sizeof(kernbuf) - 1))
-               return -EINVAL;
-
-       if (copy_from_user(kernbuf, buffer, count))
-               return -EFAULT;
-
-       kernbuf[count] = '\0';
-
-       rc = kstrtoul(kernbuf, 0, (unsigned long int *)&time);
+       rc = kstrtouint(buffer, 0, &time);

        if (rc)
                return rc;
 
        mdd->mdd_cl.mc_deniednext = time;
        return count;
 }
        if (rc)
                return rc;
 
        mdd->mdd_cl.mc_deniednext = time;
        return count;
 }

-LPROC_SEQ_FOPS(mdd_changelog_deniednext);
+LUSTRE_RW_ATTR(changelog_deniednext);

 
 

-static int mdd_sync_perm_seq_show(struct seq_file *m, void *data)
+static ssize_t sync_perm_show(struct kobject *kobj, struct attribute *attr,
+                             char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       LASSERT(mdd != NULL);
-       seq_printf(m, "%d\n", mdd->mdd_sync_permission);
-       return 0;
+       return sprintf(buf, "%d\n", mdd->mdd_sync_permission);

 }
 
 }
 

-static ssize_t
-mdd_sync_perm_seq_write(struct file *file, const char __user *buffer,
-                       size_t count, loff_t *off)
+static ssize_t sync_perm_store(struct kobject *kobj, struct attribute *attr,
+                              const char *buffer, size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        bool val;
        int rc;
 
        bool val;
        int rc;
 

-       LASSERT(mdd != NULL);
-       rc = kstrtobool_from_user(buffer, count, &val);
+       rc = kstrtobool(buffer, &val);

        if (rc)
                return rc;
 
        if (rc)
                return rc;
 


@@ -452,54 +455,54 @@ mdd_sync_perm_seq_write(struct file *file, const char __user *buffer,
 
        return count;
 }
 
        return count;
 }

-LPROC_SEQ_FOPS(mdd_sync_perm);
+LUSTRE_RW_ATTR(sync_perm);

 
 

-static int mdd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
+static ssize_t lfsck_speed_limit_show(struct kobject *kobj,
+                                     struct attribute *attr, char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       LASSERT(mdd != NULL);
-       return lfsck_get_speed(m, NULL, mdd->mdd_bottom);
+       return lfsck_get_speed(NULL, buf, mdd->mdd_bottom);

 }
 
 }
 

-static ssize_t
-mdd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
-                               size_t count, loff_t *off)
+static ssize_t lfsck_speed_limit_store(struct kobject *kobj,
+                                      struct attribute *attr,
+                                      const char *buffer, size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        unsigned int val;
        int rc;
 
        unsigned int val;
        int rc;
 

-       LASSERT(mdd != NULL);
-       rc = kstrtouint_from_user(buffer, count, 0, &val);
+       rc = kstrtouint(buffer, 10, &val);

        if (rc != 0)
                return rc;
 
        rc = lfsck_set_speed(mdd->mdd_bottom, val);
        return rc != 0 ? rc : count;
 }
        if (rc != 0)
                return rc;
 
        rc = lfsck_set_speed(mdd->mdd_bottom, val);
        return rc != 0 ? rc : count;
 }

-LPROC_SEQ_FOPS(mdd_lfsck_speed_limit);
+LUSTRE_RW_ATTR(lfsck_speed_limit);

 
 

-static int mdd_lfsck_async_windows_seq_show(struct seq_file *m, void *data)
+static ssize_t lfsck_async_windows_show(struct kobject *kobj,
+                                       struct attribute *attr, char *buf)

 {
 {

-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

 
 

-       LASSERT(mdd != NULL);
-       return lfsck_get_windows(m, mdd->mdd_bottom);
+       return lfsck_get_windows(buf, mdd->mdd_bottom);

 }
 
 }
 

-static ssize_t
-mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer,
-                                 size_t count, loff_t *off)
+static ssize_t lfsck_async_windows_store(struct kobject *kobj,
+                                        struct attribute *attr,
+                                        const char *buffer, size_t count)

 {
 {

-       struct seq_file *m = file->private_data;
-       struct mdd_device *mdd = m->private;
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);

        unsigned int val;
        int rc;
 
        unsigned int val;
        int rc;
 

-       LASSERT(mdd != NULL);
-       rc = kstrtouint_from_user(buffer, count, 0, &val);
+       rc = kstrtouint(buffer, 10, &val);

        if (rc)
                return rc;
 
        if (rc)
                return rc;
 


@@ -507,7 +510,7 @@ mdd_lfsck_async_windows_seq_write(struct file *file, const char __user *buffer,
 
        return rc != 0 ? rc : count;
 }
 
        return rc != 0 ? rc : count;
 }

-LPROC_SEQ_FOPS(mdd_lfsck_async_windows);
+LUSTRE_RW_ATTR(lfsck_async_windows);

 
 static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
 {
 
 static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
 {


@@ -517,7 +520,7 @@ static int mdd_lfsck_namespace_seq_show(struct seq_file *m, void *data)
 
        return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE);
 }
 
        return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_NAMESPACE);
 }

-LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace);
+LDEBUGFS_SEQ_FOPS_RO(mdd_lfsck_namespace);

 
 static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
 {
 
 static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
 {


@@ -527,35 +530,13 @@ static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data)
 
        return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT);
 }
 
        return lfsck_dump(m, mdd->mdd_bottom, LFSCK_TYPE_LAYOUT);
 }

-LPROC_SEQ_FOPS_RO(mdd_lfsck_layout);
+LDEBUGFS_SEQ_FOPS_RO(mdd_lfsck_layout);

 
 static struct lprocfs_vars lprocfs_mdd_obd_vars[] = {
 
 static struct lprocfs_vars lprocfs_mdd_obd_vars[] = {

-       { .name =       "atime_diff",
-         .fops =       &mdd_atime_diff_fops            },

        { .name =       "changelog_mask",
          .fops =       &mdd_changelog_mask_fops        },
        { .name =       "changelog_users",
          .fops =       &mdd_changelog_users_fops       },
        { .name =       "changelog_mask",
          .fops =       &mdd_changelog_mask_fops        },
        { .name =       "changelog_users",
          .fops =       &mdd_changelog_users_fops       },

-       { .name =       "changelog_size",
-         .fops =       &mdd_changelog_size_fops        },
-       { .name =       "changelog_gc",
-         .fops =       &mdd_changelog_gc_fops          },
-       { .name =       "changelog_max_idle_time",
-         .fops =       &mdd_changelog_max_idle_time_fops       },
-       { .name =       "changelog_max_idle_indexes",
-         .fops =       &mdd_changelog_max_idle_indexes_fops    },
-       { .name =       "changelog_min_gc_interval",
-         .fops =       &mdd_changelog_min_gc_interval_fops     },
-       { .name =       "changelog_min_free_cat_entries",
-         .fops =       &mdd_changelog_min_free_cat_entries_fops        },
-       { .name =       "changelog_deniednext",
-         .fops =       &mdd_changelog_deniednext_fops  },
-       { .name =       "sync_permission",
-         .fops =       &mdd_sync_perm_fops             },
-       { .name =       "lfsck_speed_limit",
-         .fops =       &mdd_lfsck_speed_limit_fops     },
-       { .name =       "lfsck_async_windows",
-         .fops =       &mdd_lfsck_async_windows_fops   },

        { .name =       "lfsck_namespace",
          .fops =       &mdd_lfsck_namespace_fops       },
        { .name =       "lfsck_layout",
        { .name =       "lfsck_namespace",
          .fops =       &mdd_lfsck_namespace_fops       },
        { .name =       "lfsck_layout",


@@ -563,42 +544,81 @@ static struct lprocfs_vars lprocfs_mdd_obd_vars[] = {
        { NULL }
 };
 
        { NULL }
 };
 

+static struct attribute *mdd_attrs[] = {
+       &lustre_attr_uuid.attr,
+       &lustre_attr_atime_diff.attr,
+       &lustre_attr_changelog_size.attr,
+       &lustre_attr_changelog_gc.attr,
+       &lustre_attr_changelog_max_idle_time.attr,
+       &lustre_attr_changelog_max_idle_indexes.attr,
+       &lustre_attr_changelog_min_gc_interval.attr,
+       &lustre_attr_changelog_min_free_cat_entries.attr,
+       &lustre_attr_changelog_deniednext.attr,
+       &lustre_attr_lfsck_async_windows.attr,
+       &lustre_attr_lfsck_speed_limit.attr,
+       &lustre_attr_sync_perm.attr,
+       NULL,
+};
+
+static void mdd_sysfs_release(struct kobject *kobj)
+{
+       struct mdd_device *mdd = container_of(kobj, struct mdd_device,
+                                             mdd_kobj);
+
+       complete(&mdd->mdd_kobj_unregister);
+}
+

 int mdd_procfs_init(struct mdd_device *mdd, const char *name)
 {
        struct obd_device *obd = mdd2obd_dev(mdd);
 int mdd_procfs_init(struct mdd_device *mdd, const char *name)
 {
        struct obd_device *obd = mdd2obd_dev(mdd);

-       struct obd_type   *type;
-       int                rc;
-       ENTRY;
+       struct obd_type *type;
+       int rc;

 
 

+       ENTRY;

        /* at the moment there is no linkage between lu_type
        /* at the moment there is no linkage between lu_type

-        * and obd_type, so we lookup obd_type this way */
+        * and obd_type, so we lookup obd_type this way
+        */

        type = class_search_type(LUSTRE_MDD_NAME);
 
        LASSERT(name != NULL);
        LASSERT(type != NULL);
        LASSERT(obd  != NULL);
 
        type = class_search_type(LUSTRE_MDD_NAME);
 
        LASSERT(name != NULL);
        LASSERT(type != NULL);
        LASSERT(obd  != NULL);
 

+       mdd->mdd_ktype.default_attrs = mdd_attrs;
+       mdd->mdd_ktype.release = mdd_sysfs_release;
+       mdd->mdd_ktype.sysfs_ops = &lustre_sysfs_ops;
+
+       init_completion(&mdd->mdd_kobj_unregister);
+       rc = kobject_init_and_add(&mdd->mdd_kobj, &mdd->mdd_ktype,
+                                 type->typ_kobj, "%s", name);
+       if (rc)
+               return rc;
+

        /* Find the type procroot and add the proc entry for this device */
        obd->obd_vars = lprocfs_mdd_obd_vars;
        /* Find the type procroot and add the proc entry for this device */
        obd->obd_vars = lprocfs_mdd_obd_vars;

-       mdd->mdd_proc_entry = lprocfs_register(name, type->typ_procroot,
-                                              obd->obd_vars, mdd);
-       if (IS_ERR(mdd->mdd_proc_entry)) {
-               rc = PTR_ERR(mdd->mdd_proc_entry);
-               CERROR("Error %d setting up lprocfs for %s\n",
+       obd->obd_debugfs_entry = ldebugfs_register(name,
+                                                  type->typ_debugfs_entry,
+                                                  obd->obd_vars, mdd);
+       if (IS_ERR_OR_NULL(obd->obd_debugfs_entry)) {
+               rc = obd->obd_debugfs_entry ? PTR_ERR(obd->obd_debugfs_entry)
+                                           : -ENOMEM;
+               CERROR("Error %d setting up debugfs for %s\n",

                       rc, name);
                       rc, name);

-               mdd->mdd_proc_entry = NULL;
-               GOTO(out, rc);
+               obd->obd_debugfs_entry = NULL;
+
+               kobject_put(&mdd->mdd_kobj);

        }
        }

-       rc = 0;
-       EXIT;
-out:
-       if (rc)
-               mdd_procfs_fini(mdd);
-       return rc;
+
+       RETURN(rc);

 }
 
 void mdd_procfs_fini(struct mdd_device *mdd)
 {
 }
 
 void mdd_procfs_fini(struct mdd_device *mdd)
 {

-       if (mdd->mdd_proc_entry)
-               lprocfs_remove(&mdd->mdd_proc_entry);
+       struct obd_device *obd = mdd2obd_dev(mdd);
+
+       kobject_put(&mdd->mdd_kobj);
+       wait_for_completion(&mdd->mdd_kobj_unregister);
+
+       if (!IS_ERR_OR_NULL(obd->obd_debugfs_entry))
+               ldebugfs_remove(&obd->obd_debugfs_entry);

 }
 }

diff --git a/lustre/utils/lustre_lfsck.c b/lustre/utils/lustre_lfsck.c
index e486000..b6bef2a 100644 (file)
--- a/lustre/utils/lustre_lfsck.c
+++ b/lustre/utils/lustre_lfsck.c
@@ -203,6 +203,7 @@ static int lfsck_get_dev_name(struct obd_ioctl_data *data, char *device,
                              int types, bool multipe_devices)
 {
        glob_t param = { 0 };
                              int types, bool multipe_devices)
 {
        glob_t param = { 0 };

+       size_t count = 0;

        char *ptr;
        int rc;
        int i;
        char *ptr;
        int rc;
        int i;


@@ -226,7 +227,16 @@ static int lfsck_get_dev_name(struct obd_ioctl_data *data, char *device,
                }
        }
 
                }
        }
 

-       if (param.gl_pathc == 1)
+       /* we have both sysfs and debugfs entries so to get the correct number
+        * of devices only count the entries in the sysfs tree
+        */
+       for (i = 0; i < param.gl_pathc; i++) {
+               if (strstr(param.gl_pathv[i], "/sys/kernel/debug/lustre"))
+                       continue;
+               count++;
+       }
+
+       if (count == 1)

                goto pack;
 
        if (!multipe_devices) {
                goto pack;
 
        if (!multipe_devices) {


@@ -245,8 +255,12 @@ static int lfsck_get_dev_name(struct obd_ioctl_data *data, char *device,
        }
 
        for (i = 1; i < param.gl_pathc; i++) {
        }
 
        for (i = 1; i < param.gl_pathc; i++) {

-               char *ptr2 = strrchr(param.gl_pathv[i], '-');
+               char *ptr2;
+
+               if (strstr(param.gl_pathv[i], "/sys/kernel/debug/lustre"))
+                       continue;

 
 

+               ptr2 = strrchr(param.gl_pathv[i], '-');

                if (ptr2 == NULL) {
                        rc = -EINVAL;
                        goto out;
                if (ptr2 == NULL) {
                        rc = -EINVAL;
                        goto out;