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

[platform/adaptation/renesas_rcar/renesas_kernel.git] / fs / sysfs / dir.c

diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index e5c4e71..f1efe3d 100644 (file)
--- 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;
+               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;
+       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);
 }