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>

6 files changed, 185 insertions, 185 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);
 }
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index a67d1c682fed..be1cc39035bd 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -22,15 +22,15 @@
 #include "../kernfs/kernfs-internal.h"
 
 /*
- * Determine ktype->sysfs_ops for the given sysfs_dirent.  This function
+ * Determine ktype->sysfs_ops for the given kernfs_node.  This function
  * must be called while holding an active reference.
  */
-static const struct sysfs_ops *sysfs_file_ops(struct sysfs_dirent *sd)
+static const struct sysfs_ops *sysfs_file_ops(struct kernfs_node *kn)
 {
-        struct kobject *kobj = sd->s_parent->priv;
+        struct kobject *kobj = kn->s_parent->priv;
 
-        if (sd->s_flags & SYSFS_FLAG_LOCKDEP)
-                lockdep_assert_held(sd);
+        if (kn->s_flags & SYSFS_FLAG_LOCKDEP)
+                lockdep_assert_held(kn);
         return kobj->ktype ? kobj->ktype->sysfs_ops : NULL;
 }
 
@@ -42,8 +42,8 @@ static const struct sysfs_ops *sysfs_file_ops(struct sysfs_dirent *sd)
 static int sysfs_kf_seq_show(struct seq_file *sf, void *v)
 {
         struct sysfs_open_file *of = sf->private;
-        struct kobject *kobj = of->sd->s_parent->priv;
-        const struct sysfs_ops *ops = sysfs_file_ops(of->sd);
+        struct kobject *kobj = of->kn->s_parent->priv;
+        const struct sysfs_ops *ops = sysfs_file_ops(of->kn);
         ssize_t count;
         char *buf;
 
@@ -59,7 +59,7 @@ static int sysfs_kf_seq_show(struct seq_file *sf, void *v)
          * if @ops->show() isn't implemented.
          */
         if (ops->show) {
-                count = ops->show(kobj, of->sd->priv, buf);
+                count = ops->show(kobj, of->kn->priv, buf);
                 if (count < 0)
                         return count;
         }
@@ -81,8 +81,8 @@ static int sysfs_kf_seq_show(struct seq_file *sf, void *v)
 static ssize_t sysfs_kf_bin_read(struct sysfs_open_file *of, char *buf,
                                  size_t count, loff_t pos)
 {
-        struct bin_attribute *battr = of->sd->priv;
-        struct kobject *kobj = of->sd->s_parent->priv;
+        struct bin_attribute *battr = of->kn->priv;
+        struct kobject *kobj = of->kn->s_parent->priv;
         loff_t size = file_inode(of->file)->i_size;
 
         if (!count)
@@ -105,21 +105,21 @@ static ssize_t sysfs_kf_bin_read(struct sysfs_open_file *of, char *buf,
 static ssize_t sysfs_kf_write(struct sysfs_open_file *of, char *buf,
                               size_t count, loff_t pos)
 {
-        const struct sysfs_ops *ops = sysfs_file_ops(of->sd);
-        struct kobject *kobj = of->sd->s_parent->priv;
+        const struct sysfs_ops *ops = sysfs_file_ops(of->kn);
+        struct kobject *kobj = of->kn->s_parent->priv;
 
         if (!count)
                 return 0;
 
-        return ops->store(kobj, of->sd->priv, buf, count);
+        return ops->store(kobj, of->kn->priv, buf, count);
 }
 
 /* kernfs write callback for bin sysfs files */
 static ssize_t sysfs_kf_bin_write(struct sysfs_open_file *of, char *buf,
                                   size_t count, loff_t pos)
 {
-        struct bin_attribute *battr = of->sd->priv;
-        struct kobject *kobj = of->sd->s_parent->priv;
+        struct bin_attribute *battr = of->kn->priv;
+        struct kobject *kobj = of->kn->s_parent->priv;
         loff_t size = file_inode(of->file)->i_size;
 
         if (size) {
@@ -139,30 +139,30 @@ static ssize_t sysfs_kf_bin_write(struct sysfs_open_file *of, char *buf,
 static int sysfs_kf_bin_mmap(struct sysfs_open_file *of,
                              struct vm_area_struct *vma)
 {
-        struct bin_attribute *battr = of->sd->priv;
-        struct kobject *kobj = of->sd->s_parent->priv;
+        struct bin_attribute *battr = of->kn->priv;
+        struct kobject *kobj = of->kn->s_parent->priv;
 
         return battr->mmap(of->file, kobj, battr, vma);
 }
 
-void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
+void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr)
 {
-        struct sysfs_dirent *sd = k->sd, *tmp;
+        struct kernfs_node *kn = kobj->sd, *tmp;
 
-        if (sd && dir)
-                sd = kernfs_find_and_get(sd, dir);
+        if (kn && dir)
+                kn = kernfs_find_and_get(kn, dir);
         else
-                kernfs_get(sd);
+                kernfs_get(kn);
 
-        if (sd && attr) {
-                tmp = kernfs_find_and_get(sd, attr);
-                kernfs_put(sd);
-                sd = tmp;
+        if (kn && attr) {
+                tmp = kernfs_find_and_get(kn, attr);
+                kernfs_put(kn);
+                kn = tmp;
         }
 
-        if (sd) {
-                kernfs_notify(sd);
-                kernfs_put(sd);
+        if (kn) {
+                kernfs_notify(kn);
+                kernfs_put(kn);
         }
 }
 EXPORT_SYMBOL_GPL(sysfs_notify);
@@ -202,17 +202,17 @@ static const struct kernfs_ops sysfs_bin_kfops_mmap = {
         .mmap           = sysfs_kf_bin_mmap,
 };
 
-int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
+int sysfs_add_file_mode_ns(struct kernfs_node *parent,
                            const struct attribute *attr, bool is_bin,
                            umode_t mode, const void *ns)
 {
         struct lock_class_key *key = NULL;
         const struct kernfs_ops *ops;
-        struct sysfs_dirent *sd;
+        struct kernfs_node *kn;
         loff_t size;
 
         if (!is_bin) {
-                struct kobject *kobj = dir_sd->priv;
+                struct kobject *kobj = parent->priv;
                 const struct sysfs_ops *sysfs_ops = kobj->ktype->sysfs_ops;
 
                 /* every kobject with an attribute needs a ktype assigned */
@@ -252,20 +252,20 @@ int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
         if (!attr->ignore_lockdep)
                 key = attr->key ?: (struct lock_class_key *)&attr->skey;
 #endif
-        sd = kernfs_create_file_ns_key(dir_sd, attr->name, mode, size,
+        kn = kernfs_create_file_ns_key(parent, attr->name, mode, size,
                                        ops, (void *)attr, ns, key);
-        if (IS_ERR(sd)) {
-                if (PTR_ERR(sd) == -EEXIST)
-                        sysfs_warn_dup(dir_sd, attr->name);
-                return PTR_ERR(sd);
+        if (IS_ERR(kn)) {
+                if (PTR_ERR(kn) == -EEXIST)
+                        sysfs_warn_dup(parent, attr->name);
+                return PTR_ERR(kn);
         }
         return 0;
 }
 
-int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
+int sysfs_add_file(struct kernfs_node *parent, const struct attribute *attr,
                    bool is_bin)
 {
-        return sysfs_add_file_mode_ns(dir_sd, attr, is_bin, attr->mode, NULL);
+        return sysfs_add_file_mode_ns(parent, attr, is_bin, attr->mode, NULL);
 }
 
 /**
@@ -307,21 +307,21 @@ EXPORT_SYMBOL_GPL(sysfs_create_files);
 int sysfs_add_file_to_group(struct kobject *kobj,
                 const struct attribute *attr, const char *group)
 {
-        struct sysfs_dirent *dir_sd;
+        struct kernfs_node *parent;
         int error;
 
         if (group) {
-                dir_sd = kernfs_find_and_get(kobj->sd, group);
+                parent = kernfs_find_and_get(kobj->sd, group);
         } else {
-                dir_sd = kobj->sd;
-                kernfs_get(dir_sd);
+                parent = kobj->sd;
+                kernfs_get(parent);
         }
 
-        if (!dir_sd)
+        if (!parent)
                 return -ENOENT;
 
-        error = sysfs_add_file(dir_sd, attr, false);
-        kernfs_put(dir_sd);
+        error = sysfs_add_file(parent, attr, false);
+        kernfs_put(parent);
 
         return error;
 }
@@ -337,20 +337,20 @@ EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
 int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
                      umode_t mode)
 {
-        struct sysfs_dirent *sd;
+        struct kernfs_node *kn;
         struct iattr newattrs;
         int rc;
 
-        sd = kernfs_find_and_get(kobj->sd, attr->name);
-        if (!sd)
+        kn = kernfs_find_and_get(kobj->sd, attr->name);
+        if (!kn)
                 return -ENOENT;
 
-        newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
+        newattrs.ia_mode = (mode & S_IALLUGO) | (kn->s_mode & ~S_IALLUGO);
         newattrs.ia_valid = ATTR_MODE;
 
-        rc = kernfs_setattr(sd, &newattrs);
+        rc = kernfs_setattr(kn, &newattrs);
 
-        kernfs_put(sd);
+        kernfs_put(kn);
         return rc;
 }
 EXPORT_SYMBOL_GPL(sysfs_chmod_file);
@@ -366,9 +366,9 @@ EXPORT_SYMBOL_GPL(sysfs_chmod_file);
 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
                           const void *ns)
 {
-        struct sysfs_dirent *dir_sd = kobj->sd;
+        struct kernfs_node *parent = kobj->sd;
 
-        kernfs_remove_by_name_ns(dir_sd, attr->name, ns);
+        kernfs_remove_by_name_ns(parent, attr->name, ns);
 }
 EXPORT_SYMBOL_GPL(sysfs_remove_file_ns);
 
@@ -389,18 +389,18 @@ EXPORT_SYMBOL_GPL(sysfs_remove_files);
 void sysfs_remove_file_from_group(struct kobject *kobj,
                 const struct attribute *attr, const char *group)
 {
-        struct sysfs_dirent *dir_sd;
+        struct kernfs_node *parent;
 
         if (group) {
-                dir_sd = kernfs_find_and_get(kobj->sd, group);
+                parent = kernfs_find_and_get(kobj->sd, group);
         } else {
-                dir_sd = kobj->sd;
-                kernfs_get(dir_sd);
+                parent = kobj->sd;
+                kernfs_get(parent);
         }
 
-        if (dir_sd) {
-                kernfs_remove_by_name(dir_sd, attr->name);
-                kernfs_put(dir_sd);
+        if (parent) {
+                kernfs_remove_by_name(parent, attr->name);
+                kernfs_put(parent);
         }
 }
 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
diff --git a/fs/sysfs/group.c b/fs/sysfs/group.c
index 7177532b8f7b..4d00d3996477 100644
--- a/fs/sysfs/group.c
+++ b/fs/sysfs/group.c
@@ -18,7 +18,7 @@
 #include "sysfs.h"
 
 
-static void remove_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
+static void remove_files(struct kernfs_node *parent, struct kobject *kobj,
                          const struct attribute_group *grp)
 {
         struct attribute *const *attr;
@@ -26,13 +26,13 @@ static void remove_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
 
         if (grp->attrs)
                 for (attr = grp->attrs; *attr; attr++)
-                        kernfs_remove_by_name(dir_sd, (*attr)->name);
+                        kernfs_remove_by_name(parent, (*attr)->name);
         if (grp->bin_attrs)
                 for (bin_attr = grp->bin_attrs; *bin_attr; bin_attr++)
                         sysfs_remove_bin_file(kobj, *bin_attr);
 }
 
-static int create_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
+static int create_files(struct kernfs_node *parent, struct kobject *kobj,
                         const struct attribute_group *grp, int update)
 {
         struct attribute *const *attr;
@@ -49,20 +49,20 @@ static int create_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
                          * re-adding (if required) the file.
                          */
                         if (update)
-                                kernfs_remove_by_name(dir_sd, (*attr)->name);
+                                kernfs_remove_by_name(parent, (*attr)->name);
                         if (grp->is_visible) {
                                 mode = grp->is_visible(kobj, *attr, i);
                                 if (!mode)
                                         continue;
                         }
-                        error = sysfs_add_file_mode_ns(dir_sd, *attr, false,
+                        error = sysfs_add_file_mode_ns(parent, *attr, false,
                                                        (*attr)->mode | mode,
                                                        NULL);
                         if (unlikely(error))
                                 break;
                 }
                 if (error) {
-                        remove_files(dir_sd, kobj, grp);
+                        remove_files(parent, kobj, grp);
                         goto exit;
                 }
         }
@@ -76,7 +76,7 @@ static int create_files(struct sysfs_dirent *dir_sd, struct kobject *kobj,
                                 break;
                 }
                 if (error)
-                        remove_files(dir_sd, kobj, grp);
+                        remove_files(parent, kobj, grp);
         }
 exit:
         return error;
@@ -86,7 +86,7 @@ exit:
 static int internal_create_group(struct kobject *kobj, int update,
                                  const struct attribute_group *grp)
 {
-        struct sysfs_dirent *sd;
+        struct kernfs_node *kn;
         int error;
 
         BUG_ON(!kobj || (!update && !kobj->sd));
@@ -100,21 +100,21 @@ static int internal_create_group(struct kobject *kobj, int update,
                 return -EINVAL;
         }
         if (grp->name) {
-                sd = kernfs_create_dir(kobj->sd, grp->name, kobj);
-                if (IS_ERR(sd)) {
-                        if (PTR_ERR(sd) == -EEXIST)
+                kn = kernfs_create_dir(kobj->sd, grp->name, kobj);
+                if (IS_ERR(kn)) {
+                        if (PTR_ERR(kn) == -EEXIST)
                                 sysfs_warn_dup(kobj->sd, grp->name);
-                        return PTR_ERR(sd);
+                        return PTR_ERR(kn);
                 }
         } else
-                sd = kobj->sd;
-        kernfs_get(sd);
-        error = create_files(sd, kobj, grp, update);
+                kn = kobj->sd;
+        kernfs_get(kn);
+        error = create_files(kn, kobj, grp, update);
         if (error) {
                 if (grp->name)
-                        kernfs_remove(sd);
+                        kernfs_remove(kn);
         }
-        kernfs_put(sd);
+        kernfs_put(kn);
         return error;
 }
 
@@ -204,27 +204,27 @@ EXPORT_SYMBOL_GPL(sysfs_update_group);
 void sysfs_remove_group(struct kobject *kobj,
                         const struct attribute_group *grp)
 {
-        struct sysfs_dirent *dir_sd = kobj->sd;
-        struct sysfs_dirent *sd;
+        struct kernfs_node *parent = kobj->sd;
+        struct kernfs_node *kn;
 
         if (grp->name) {
-                sd = kernfs_find_and_get(dir_sd, grp->name);
-                if (!sd) {
-                        WARN(!sd, KERN_WARNING
+                kn = kernfs_find_and_get(parent, grp->name);
+                if (!kn) {
+                        WARN(!kn, KERN_WARNING
                              "sysfs group %p not found for kobject '%s'\n",
                              grp, kobject_name(kobj));
                         return;
                 }
         } else {
-                sd = dir_sd;
-                kernfs_get(sd);
+                kn = parent;
+                kernfs_get(kn);
         }
 
-        remove_files(sd, kobj, grp);
+        remove_files(kn, kobj, grp);
         if (grp->name)
-                kernfs_remove(sd);
+                kernfs_remove(kn);
 
-        kernfs_put(sd);
+        kernfs_put(kn);
 }
 EXPORT_SYMBOL_GPL(sysfs_remove_group);
 
@@ -260,22 +260,22 @@ EXPORT_SYMBOL_GPL(sysfs_remove_groups);
 int sysfs_merge_group(struct kobject *kobj,
                        const struct attribute_group *grp)
 {
-        struct sysfs_dirent *dir_sd;
+        struct kernfs_node *parent;
         int error = 0;
         struct attribute *const *attr;
         int i;
 
-        dir_sd = kernfs_find_and_get(kobj->sd, grp->name);
-        if (!dir_sd)
+        parent = kernfs_find_and_get(kobj->sd, grp->name);
+        if (!parent)
                 return -ENOENT;
 
         for ((i = 0, attr = grp->attrs); *attr && !error; (++i, ++attr))
-                error = sysfs_add_file(dir_sd, *attr, false);
+                error = sysfs_add_file(parent, *attr, false);
         if (error) {
                 while (--i >= 0)
-                        kernfs_remove_by_name(dir_sd, (*--attr)->name);
+                        kernfs_remove_by_name(parent, (*--attr)->name);
         }
-        kernfs_put(dir_sd);
+        kernfs_put(parent);
 
         return error;
 }
@@ -289,14 +289,14 @@ EXPORT_SYMBOL_GPL(sysfs_merge_group);
 void sysfs_unmerge_group(struct kobject *kobj,
                        const struct attribute_group *grp)
 {
-        struct sysfs_dirent *dir_sd;
+        struct kernfs_node *parent;
         struct attribute *const *attr;
 
-        dir_sd = kernfs_find_and_get(kobj->sd, grp->name);
-        if (dir_sd) {
+        parent = kernfs_find_and_get(kobj->sd, grp->name);
+        if (parent) {
                 for (attr = grp->attrs; *attr; ++attr)
-                        kernfs_remove_by_name(dir_sd, (*attr)->name);
-                kernfs_put(dir_sd);
+                        kernfs_remove_by_name(parent, (*attr)->name);
+                kernfs_put(parent);
         }
 }
 EXPORT_SYMBOL_GPL(sysfs_unmerge_group);
@@ -311,15 +311,15 @@ EXPORT_SYMBOL_GPL(sysfs_unmerge_group);
 int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
                             struct kobject *target, const char *link_name)
 {
-        struct sysfs_dirent *dir_sd;
+        struct kernfs_node *parent;
         int error = 0;
 
-        dir_sd = kernfs_find_and_get(kobj->sd, group_name);
-        if (!dir_sd)
+        parent = kernfs_find_and_get(kobj->sd, group_name);
+        if (!parent)
                 return -ENOENT;
 
-        error = sysfs_create_link_sd(dir_sd, target, link_name);
-        kernfs_put(dir_sd);
+        error = sysfs_create_link_sd(parent, target, link_name);
+        kernfs_put(parent);
 
         return error;
 }
@@ -334,12 +334,12 @@ EXPORT_SYMBOL_GPL(sysfs_add_link_to_group);
 void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
                                   const char *link_name)
 {
-        struct sysfs_dirent *dir_sd;
+        struct kernfs_node *parent;
 
-        dir_sd = kernfs_find_and_get(kobj->sd, group_name);
-        if (dir_sd) {
-                kernfs_remove_by_name(dir_sd, link_name);
-                kernfs_put(dir_sd);
+        parent = kernfs_find_and_get(kobj->sd, group_name);
+        if (parent) {
+                kernfs_remove_by_name(parent, link_name);
+                kernfs_put(parent);
         }
 }
 EXPORT_SYMBOL_GPL(sysfs_remove_link_from_group);
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index 8d075272cace..701a56f341c6 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -20,7 +20,7 @@
 #include "sysfs.h"
 
 static struct kernfs_root *sysfs_root;
-struct sysfs_dirent *sysfs_root_sd;
+struct kernfs_node *sysfs_root_kn;
 
 static struct dentry *sysfs_mount(struct file_system_type *fs_type,
         int flags, const char *dev_name, void *data)
@@ -66,7 +66,7 @@ int __init sysfs_init(void)
         if (IS_ERR(sysfs_root))
                 return PTR_ERR(sysfs_root);
 
-        sysfs_root_sd = sysfs_root->sd;
+        sysfs_root_kn = sysfs_root->kn;
 
         err = register_filesystem(&sysfs_fs_type);
         if (err) {
diff --git a/fs/sysfs/symlink.c b/fs/sysfs/symlink.c
index 1b8c9ed8511a..4ed3d49ad279 100644
--- a/fs/sysfs/symlink.c
+++ b/fs/sysfs/symlink.c
@@ -18,66 +18,66 @@
 
 #include "sysfs.h"
 
-static int sysfs_do_create_link_sd(struct sysfs_dirent *parent_sd,
-                                   struct kobject *target,
+static int sysfs_do_create_link_sd(struct kernfs_node *parent,
+                                   struct kobject *target_kobj,
                                    const char *name, int warn)
 {
-        struct sysfs_dirent *sd, *target_sd = NULL;
+        struct kernfs_node *kn, *target = NULL;
 
-        BUG_ON(!name || !parent_sd);
+        BUG_ON(!name || !parent);
 
         /*
-         * We don't own @target and it may be removed at any time.
+         * We don't own @target_kobj and it may be removed at any time.
          * Synchronize using sysfs_symlink_target_lock.  See
          * sysfs_remove_dir() for details.
          */
         spin_lock(&sysfs_symlink_target_lock);
-        if (target->sd) {
-                target_sd = target->sd;
-                kernfs_get(target_sd);
+        if (target_kobj->sd) {
+                target = target_kobj->sd;
+                kernfs_get(target);
         }
         spin_unlock(&sysfs_symlink_target_lock);
 
-        if (!target_sd)
+        if (!target)
                 return -ENOENT;
 
-        sd = kernfs_create_link(parent_sd, name, target_sd);
-        kernfs_put(target_sd);
+        kn = kernfs_create_link(parent, name, target);
+        kernfs_put(target);
 
-        if (!IS_ERR(sd))
+        if (!IS_ERR(kn))
                 return 0;
 
-        if (warn && PTR_ERR(sd) == -EEXIST)
-                sysfs_warn_dup(parent_sd, name);
-        return PTR_ERR(sd);
+        if (warn && PTR_ERR(kn) == -EEXIST)
+                sysfs_warn_dup(parent, name);
+        return PTR_ERR(kn);
 }
 
 /**
  *      sysfs_create_link_sd - create symlink to a given object.
- *      @sd:            directory we're creating the link in.
+ *      @kn:            directory we're creating the link in.
  *      @target:        object we're pointing to.
  *      @name:          name of the symlink.
  */
-int sysfs_create_link_sd(struct sysfs_dirent *sd, struct kobject *target,
+int sysfs_create_link_sd(struct kernfs_node *kn, struct kobject *target,
                          const char *name)
 {
-        return sysfs_do_create_link_sd(sd, target, name, 1);
+        return sysfs_do_create_link_sd(kn, target, name, 1);
 }
 
 static int sysfs_do_create_link(struct kobject *kobj, struct kobject *target,
                                 const char *name, int warn)
 {
-        struct sysfs_dirent *parent_sd = NULL;
+        struct kernfs_node *parent = NULL;
 
         if (!kobj)
-                parent_sd = sysfs_root_sd;
+                parent = sysfs_root_kn;
         else
-                parent_sd = kobj->sd;
+                parent = kobj->sd;
 
-        if (!parent_sd)
+        if (!parent)
                 return -EFAULT;
 
-        return sysfs_do_create_link_sd(parent_sd, target, name, warn);
+        return sysfs_do_create_link_sd(parent, target, name, warn);
 }
 
 /**
@@ -141,14 +141,14 @@ void sysfs_delete_link(struct kobject *kobj, struct kobject *targ,
  */
 void sysfs_remove_link(struct kobject *kobj, const char *name)
 {
-        struct sysfs_dirent *parent_sd = NULL;
+        struct kernfs_node *parent = NULL;
 
         if (!kobj)
-                parent_sd = sysfs_root_sd;
+                parent = sysfs_root_kn;
         else
-                parent_sd = kobj->sd;
+                parent = kobj->sd;
 
-        kernfs_remove_by_name(parent_sd, name);
+        kernfs_remove_by_name(parent, name);
 }
 EXPORT_SYMBOL_GPL(sysfs_remove_link);
 
@@ -165,33 +165,33 @@ EXPORT_SYMBOL_GPL(sysfs_remove_link);
 int sysfs_rename_link_ns(struct kobject *kobj, struct kobject *targ,
                          const char *old, const char *new, const void *new_ns)
 {
-        struct sysfs_dirent *parent_sd, *sd = NULL;
+        struct kernfs_node *parent, *kn = NULL;
         const void *old_ns = NULL;
         int result;
 
         if (!kobj)
-                parent_sd = sysfs_root_sd;
+                parent = sysfs_root_kn;
         else
-                parent_sd = kobj->sd;
+                parent = kobj->sd;
 
         if (targ->sd)
                 old_ns = targ->sd->s_ns;
 
         result = -ENOENT;
-        sd = kernfs_find_and_get_ns(parent_sd, old, old_ns);
-        if (!sd)
+        kn = kernfs_find_and_get_ns(parent, old, old_ns);
+        if (!kn)
                 goto out;
 
         result = -EINVAL;
-        if (sysfs_type(sd) != SYSFS_KOBJ_LINK)
+        if (sysfs_type(kn) != SYSFS_KOBJ_LINK)
                 goto out;
-        if (sd->s_symlink.target_sd->priv != targ)
+        if (kn->s_symlink.target_kn->priv != targ)
                 goto out;
 
-        result = kernfs_rename_ns(sd, parent_sd, new, new_ns);
+        result = kernfs_rename_ns(kn, parent, new, new_ns);
 
 out:
-        kernfs_put(sd);
+        kernfs_put(kn);
         return result;
 }
 EXPORT_SYMBOL_GPL(sysfs_rename_link_ns);
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index c8e395b49330..0e2f1cccb812 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -16,28 +16,28 @@
 /*
  * mount.c
  */
-extern struct sysfs_dirent *sysfs_root_sd;
+extern struct kernfs_node *sysfs_root_kn;
 
 /*
  * dir.c
  */
 extern spinlock_t sysfs_symlink_target_lock;
 
-void sysfs_warn_dup(struct sysfs_dirent *parent, const char *name);
+void sysfs_warn_dup(struct kernfs_node *parent, const char *name);
 
 /*
  * file.c
  */
-int sysfs_add_file(struct sysfs_dirent *dir_sd,
+int sysfs_add_file(struct kernfs_node *parent,
                    const struct attribute *attr, bool is_bin);
-int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
+int sysfs_add_file_mode_ns(struct kernfs_node *parent,
                            const struct attribute *attr, bool is_bin,
                            umode_t amode, const void *ns);
 
 /*
  * symlink.c
  */
-int sysfs_create_link_sd(struct sysfs_dirent *sd, struct kobject *target,
+int sysfs_create_link_sd(struct kernfs_node *kn, struct kobject *target,
                          const char *name);
 
 #endif  /* __SYSFS_INTERNAL_H */