kernfs: s/sysfs_dirent/kernfs_node/ and rename its friends accordingly

kernfs has just been separated out from sysfs and we're already in
full conflict mode.  Nothing can make the situation any worse.  Let's
take the chance to name things properly.

This patch performs the following renames.

* s/sysfs_elem_dir/kernfs_elem_dir/
* s/sysfs_elem_symlink/kernfs_elem_symlink/
* s/sysfs_elem_attr/kernfs_elem_file/
* s/sysfs_dirent/kernfs_node/
* s/sd/kn/ in kernfs proper
* s/parent_sd/parent/
* s/target_sd/target/
* s/dir_sd/parent/
* s/to_sysfs_dirent()/rb_to_kn()/
* misc renames of local vars when they conflict with the above

Because md, mic and gpio dig into sysfs details, this patch ends up
modifying them.  All are sysfs_dirent renames and trivial.  While we
can avoid these by introducing a dummy wrapping struct sysfs_dirent
around kernfs_node, given the limited usage outside kernfs and sysfs
proper, I don't think such workaround is called for.

This patch is strictly rename only and doesn't introduce any
functional difference.

- mic / gpio renames were missing.  Spotted by kbuild test robot.

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Neil Brown <neilb@suse.de>
Cc: Linus Walleij <linus.walleij@linaro.org>
Cc: Ashutosh Dixit <ashutosh.dixit@intel.com>
Cc: kbuild test robot <fengguang.wu@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 33 insertions, 33 deletions

diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 2fea501889e7..f1efe3df0de6 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -21,23 +21,23 @@ DEFINE_SPINLOCK(sysfs_symlink_target_lock);
 
 /**
  *      sysfs_pathname - return full path to sysfs dirent
- *      @sd: sysfs_dirent whose path we want
+ *      @kn: kernfs_node whose path we want
  *      @path: caller allocated buffer of size PATH_MAX
  *
  *      Gives the name "/" to the sysfs_root entry; any path returned
  *      is relative to wherever sysfs is mounted.
  */
-static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
+static char *sysfs_pathname(struct kernfs_node *kn, char *path)
 {
-        if (sd->s_parent) {
-                sysfs_pathname(sd->s_parent, path);
+        if (kn->s_parent) {
+                sysfs_pathname(kn->s_parent, path);
                 strlcat(path, "/", PATH_MAX);
         }
-        strlcat(path, sd->s_name, PATH_MAX);
+        strlcat(path, kn->s_name, PATH_MAX);
         return path;
 }
 
-void sysfs_warn_dup(struct sysfs_dirent *parent, const char *name)
+void sysfs_warn_dup(struct kernfs_node *parent, const char *name)
 {
         char *path;
 
@@ -61,26 +61,26 @@ void sysfs_warn_dup(struct sysfs_dirent *parent, const char *name)
  */
 int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
 {
-        struct sysfs_dirent *parent_sd, *sd;
+        struct kernfs_node *parent, *kn;
 
         BUG_ON(!kobj);
 
         if (kobj->parent)
-                parent_sd = kobj->parent->sd;
+                parent = kobj->parent->sd;
         else
-                parent_sd = sysfs_root_sd;
+                parent = sysfs_root_kn;
 
-        if (!parent_sd)
+        if (!parent)
                 return -ENOENT;
 
-        sd = kernfs_create_dir_ns(parent_sd, kobject_name(kobj), kobj, ns);
-        if (IS_ERR(sd)) {
-                if (PTR_ERR(sd) == -EEXIST)
-                        sysfs_warn_dup(parent_sd, kobject_name(kobj));
-                return PTR_ERR(sd);
+        kn = kernfs_create_dir_ns(parent, kobject_name(kobj), kobj, ns);
+        if (IS_ERR(kn)) {
+                if (PTR_ERR(kn) == -EEXIST)
+                        sysfs_warn_dup(parent, kobject_name(kobj));
+                return PTR_ERR(kn);
         }
 
-        kobj->sd = sd;
+        kobj->sd = kn;
         return 0;
 }
 
@@ -94,47 +94,47 @@ int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
  */
 void sysfs_remove_dir(struct kobject *kobj)
 {
-        struct sysfs_dirent *sd = kobj->sd;
+        struct kernfs_node *kn = kobj->sd;
 
         /*
          * In general, kboject owner is responsible for ensuring removal
          * doesn't race with other operations and sysfs doesn't provide any
          * protection; however, when @kobj is used as a symlink target, the
          * symlinking entity usually doesn't own @kobj and thus has no
-         * control over removal.  @kobj->sd may be removed anytime and
-         * symlink code may end up dereferencing an already freed sd.
+         * control over removal.  @kobj->sd may be removed anytime
+         * and symlink code may end up dereferencing an already freed node.
          *
-         * sysfs_symlink_target_lock synchronizes @kobj->sd disassociation
-         * against symlink operations so that symlink code can safely
-         * dereference @kobj->sd.
+         * sysfs_symlink_target_lock synchronizes @kobj->sd
+         * disassociation against symlink operations so that symlink code
+         * can safely dereference @kobj->sd.
          */
         spin_lock(&sysfs_symlink_target_lock);
         kobj->sd = NULL;
         spin_unlock(&sysfs_symlink_target_lock);
 
-        if (sd) {
-                WARN_ON_ONCE(sysfs_type(sd) != SYSFS_DIR);
-                kernfs_remove(sd);
+        if (kn) {
+                WARN_ON_ONCE(sysfs_type(kn) != SYSFS_DIR);
+                kernfs_remove(kn);
         }
 }
 
 int sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
                         const void *new_ns)
 {
-        struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
+        struct kernfs_node *parent = kobj->sd->s_parent;
 
-        return kernfs_rename_ns(kobj->sd, parent_sd, new_name, new_ns);
+        return kernfs_rename_ns(kobj->sd, parent, new_name, new_ns);
 }
 
 int sysfs_move_dir_ns(struct kobject *kobj, struct kobject *new_parent_kobj,
                       const void *new_ns)
 {
-        struct sysfs_dirent *sd = kobj->sd;
-        struct sysfs_dirent *new_parent_sd;
+        struct kernfs_node *kn = kobj->sd;
+        struct kernfs_node *new_parent;
 
-        BUG_ON(!sd->s_parent);
-        new_parent_sd = new_parent_kobj && new_parent_kobj->sd ?
-                new_parent_kobj->sd : sysfs_root_sd;
+        BUG_ON(!kn->s_parent);
+        new_parent = new_parent_kobj && new_parent_kobj->sd ?
+                new_parent_kobj->sd : sysfs_root_kn;
 
-        return kernfs_rename_ns(sd, new_parent_sd, sd->s_name, new_ns);
+        return kernfs_rename_ns(kn, new_parent, kn->s_name, new_ns);
 }