diff --git a/fs/kernfs/dir.c b/fs/kernfs/dir.c
index a441e3b..800ebf5 100644
--- a/fs/kernfs/dir.c
+++ b/fs/kernfs/dir.c
@@ -19,7 +19,7 @@
 
 DEFINE_MUTEX(sysfs_mutex);
 
-#define to_sysfs_dirent(X) rb_entry((X), struct sysfs_dirent, s_rb)
+#define rb_to_kn(X) rb_entry((X), struct kernfs_node, s_rb)
 
 /**
  *	sysfs_name_hash
@@ -45,28 +45,28 @@
 }
 
 static int sysfs_name_compare(unsigned int hash, const char *name,
-			      const void *ns, const struct sysfs_dirent *sd)
+			      const void *ns, const struct kernfs_node *kn)
 {
-	if (hash != sd->s_hash)
-		return hash - sd->s_hash;
-	if (ns != sd->s_ns)
-		return ns - sd->s_ns;
-	return strcmp(name, sd->s_name);
+	if (hash != kn->s_hash)
+		return hash - kn->s_hash;
+	if (ns != kn->s_ns)
+		return ns - kn->s_ns;
+	return strcmp(name, kn->s_name);
 }
 
-static int sysfs_sd_compare(const struct sysfs_dirent *left,
-			    const struct sysfs_dirent *right)
+static int sysfs_sd_compare(const struct kernfs_node *left,
+			    const struct kernfs_node *right)
 {
 	return sysfs_name_compare(left->s_hash, left->s_name, left->s_ns,
 				  right);
 }
 
 /**
- *	sysfs_link_sibling - link sysfs_dirent into sibling rbtree
- *	@sd: sysfs_dirent of interest
+ *	sysfs_link_sibling - link kernfs_node into sibling rbtree
+ *	@kn: kernfs_node of interest
  *
- *	Link @sd into its sibling rbtree which starts from
- *	sd->s_parent->s_dir.children.
+ *	Link @kn into its sibling rbtree which starts from
+ *	@kn->s_parent->s_dir.children.
  *
  *	Locking:
  *	mutex_lock(sysfs_mutex)
@@ -74,21 +74,21 @@
  *	RETURNS:
  *	0 on susccess -EEXIST on failure.
  */
-static int sysfs_link_sibling(struct sysfs_dirent *sd)
+static int sysfs_link_sibling(struct kernfs_node *kn)
 {
-	struct rb_node **node = &sd->s_parent->s_dir.children.rb_node;
+	struct rb_node **node = &kn->s_parent->s_dir.children.rb_node;
 	struct rb_node *parent = NULL;
 
-	if (sysfs_type(sd) == SYSFS_DIR)
-		sd->s_parent->s_dir.subdirs++;
+	if (sysfs_type(kn) == SYSFS_DIR)
+		kn->s_parent->s_dir.subdirs++;
 
 	while (*node) {
-		struct sysfs_dirent *pos;
+		struct kernfs_node *pos;
 		int result;
 
-		pos = to_sysfs_dirent(*node);
+		pos = rb_to_kn(*node);
 		parent = *node;
-		result = sysfs_sd_compare(sd, pos);
+		result = sysfs_sd_compare(kn, pos);
 		if (result < 0)
 			node = &pos->s_rb.rb_left;
 		else if (result > 0)
@@ -97,168 +97,169 @@
 			return -EEXIST;
 	}
 	/* add new node and rebalance the tree */
-	rb_link_node(&sd->s_rb, parent, node);
-	rb_insert_color(&sd->s_rb, &sd->s_parent->s_dir.children);
+	rb_link_node(&kn->s_rb, parent, node);
+	rb_insert_color(&kn->s_rb, &kn->s_parent->s_dir.children);
 	return 0;
 }
 
 /**
- *	sysfs_unlink_sibling - unlink sysfs_dirent from sibling rbtree
- *	@sd: sysfs_dirent of interest
+ *	sysfs_unlink_sibling - unlink kernfs_node from sibling rbtree
+ *	@kn: kernfs_node of interest
  *
- *	Unlink @sd from its sibling rbtree which starts from
- *	sd->s_parent->s_dir.children.
+ *	Unlink @kn from its sibling rbtree which starts from
+ *	kn->s_parent->s_dir.children.
  *
  *	Locking:
  *	mutex_lock(sysfs_mutex)
  */
-static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
+static void sysfs_unlink_sibling(struct kernfs_node *kn)
 {
-	if (sysfs_type(sd) == SYSFS_DIR)
-		sd->s_parent->s_dir.subdirs--;
+	if (sysfs_type(kn) == SYSFS_DIR)
+		kn->s_parent->s_dir.subdirs--;
 
-	rb_erase(&sd->s_rb, &sd->s_parent->s_dir.children);
+	rb_erase(&kn->s_rb, &kn->s_parent->s_dir.children);
 }
 
 /**
- *	sysfs_get_active - get an active reference to sysfs_dirent
- *	@sd: sysfs_dirent to get an active reference to
+ *	sysfs_get_active - get an active reference to kernfs_node
+ *	@kn: kernfs_node to get an active reference to
  *
- *	Get an active reference of @sd.  This function is noop if @sd
+ *	Get an active reference of @kn.  This function is noop if @kn
  *	is NULL.
  *
  *	RETURNS:
- *	Pointer to @sd on success, NULL on failure.
+ *	Pointer to @kn on success, NULL on failure.
  */
-struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
+struct kernfs_node *sysfs_get_active(struct kernfs_node *kn)
 {
-	if (unlikely(!sd))
+	if (unlikely(!kn))
 		return NULL;
 
-	if (!atomic_inc_unless_negative(&sd->s_active))
+	if (!atomic_inc_unless_negative(&kn->s_active))
 		return NULL;
 
-	if (sd->s_flags & SYSFS_FLAG_LOCKDEP)
-		rwsem_acquire_read(&sd->dep_map, 0, 1, _RET_IP_);
-	return sd;
+	if (kn->s_flags & SYSFS_FLAG_LOCKDEP)
+		rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_);
+	return kn;
 }
 
 /**
- *	sysfs_put_active - put an active reference to sysfs_dirent
- *	@sd: sysfs_dirent to put an active reference to
+ *	sysfs_put_active - put an active reference to kernfs_node
+ *	@kn: kernfs_node to put an active reference to
  *
- *	Put an active reference to @sd.  This function is noop if @sd
+ *	Put an active reference to @kn.  This function is noop if @kn
  *	is NULL.
  */
-void sysfs_put_active(struct sysfs_dirent *sd)
+void sysfs_put_active(struct kernfs_node *kn)
 {
 	int v;
 
-	if (unlikely(!sd))
+	if (unlikely(!kn))
 		return;
 
-	if (sd->s_flags & SYSFS_FLAG_LOCKDEP)
-		rwsem_release(&sd->dep_map, 1, _RET_IP_);
-	v = atomic_dec_return(&sd->s_active);
+	if (kn->s_flags & SYSFS_FLAG_LOCKDEP)
+		rwsem_release(&kn->dep_map, 1, _RET_IP_);
+	v = atomic_dec_return(&kn->s_active);
 	if (likely(v != SD_DEACTIVATED_BIAS))
 		return;
 
-	/* atomic_dec_return() is a mb(), we'll always see the updated
-	 * sd->u.completion.
+	/*
+	 * atomic_dec_return() is a mb(), we'll always see the updated
+	 * kn->u.completion.
 	 */
-	complete(sd->u.completion);
+	complete(kn->u.completion);
 }
 
 /**
- *	sysfs_deactivate - deactivate sysfs_dirent
- *	@sd: sysfs_dirent to deactivate
+ *	sysfs_deactivate - deactivate kernfs_node
+ *	@kn: kernfs_node to deactivate
  *
  *	Deny new active references and drain existing ones.
  */
-static void sysfs_deactivate(struct sysfs_dirent *sd)
+static void sysfs_deactivate(struct kernfs_node *kn)
 {
 	DECLARE_COMPLETION_ONSTACK(wait);
 	int v;
 
-	BUG_ON(!(sd->s_flags & SYSFS_FLAG_REMOVED));
+	BUG_ON(!(kn->s_flags & SYSFS_FLAG_REMOVED));
 
-	if (!(sysfs_type(sd) & SYSFS_ACTIVE_REF))
+	if (!(sysfs_type(kn) & SYSFS_ACTIVE_REF))
 		return;
 
-	sd->u.completion = (void *)&wait;
+	kn->u.completion = (void *)&wait;
 
-	rwsem_acquire(&sd->dep_map, 0, 0, _RET_IP_);
+	rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_);
 	/* atomic_add_return() is a mb(), put_active() will always see
-	 * the updated sd->u.completion.
+	 * the updated kn->u.completion.
 	 */
-	v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
+	v = atomic_add_return(SD_DEACTIVATED_BIAS, &kn->s_active);
 
 	if (v != SD_DEACTIVATED_BIAS) {
-		lock_contended(&sd->dep_map, _RET_IP_);
+		lock_contended(&kn->dep_map, _RET_IP_);
 		wait_for_completion(&wait);
 	}
 
-	lock_acquired(&sd->dep_map, _RET_IP_);
-	rwsem_release(&sd->dep_map, 1, _RET_IP_);
+	lock_acquired(&kn->dep_map, _RET_IP_);
+	rwsem_release(&kn->dep_map, 1, _RET_IP_);
 }
 
 /**
- * kernfs_get - get a reference count on a sysfs_dirent
- * @sd: the target sysfs_dirent
+ * kernfs_get - get a reference count on a kernfs_node
+ * @kn: the target kernfs_node
  */
-void kernfs_get(struct sysfs_dirent *sd)
+void kernfs_get(struct kernfs_node *kn)
 {
-	if (sd) {
-		WARN_ON(!atomic_read(&sd->s_count));
-		atomic_inc(&sd->s_count);
+	if (kn) {
+		WARN_ON(!atomic_read(&kn->s_count));
+		atomic_inc(&kn->s_count);
 	}
 }
 EXPORT_SYMBOL_GPL(kernfs_get);
 
 /**
- * kernfs_put - put a reference count on a sysfs_dirent
- * @sd: the target sysfs_dirent
+ * kernfs_put - put a reference count on a kernfs_node
+ * @kn: the target kernfs_node
  *
- * Put a reference count of @sd and destroy it if it reached zero.
+ * Put a reference count of @kn and destroy it if it reached zero.
  */
-void kernfs_put(struct sysfs_dirent *sd)
+void kernfs_put(struct kernfs_node *kn)
 {
-	struct sysfs_dirent *parent_sd;
+	struct kernfs_node *parent;
 	struct kernfs_root *root;
 
-	if (!sd || !atomic_dec_and_test(&sd->s_count))
+	if (!kn || !atomic_dec_and_test(&kn->s_count))
 		return;
-	root = kernfs_root(sd);
+	root = kernfs_root(kn);
  repeat:
 	/* Moving/renaming is always done while holding reference.
-	 * sd->s_parent won't change beneath us.
+	 * kn->s_parent won't change beneath us.
 	 */
-	parent_sd = sd->s_parent;
+	parent = kn->s_parent;
 
-	WARN(!(sd->s_flags & SYSFS_FLAG_REMOVED),
+	WARN(!(kn->s_flags & SYSFS_FLAG_REMOVED),
 		"sysfs: free using entry: %s/%s\n",
-		parent_sd ? parent_sd->s_name : "", sd->s_name);
+		parent ? parent->s_name : "", kn->s_name);
 
-	if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
-		kernfs_put(sd->s_symlink.target_sd);
-	if (sysfs_type(sd) & SYSFS_COPY_NAME)
-		kfree(sd->s_name);
-	if (sd->s_iattr) {
-		if (sd->s_iattr->ia_secdata)
-			security_release_secctx(sd->s_iattr->ia_secdata,
-						sd->s_iattr->ia_secdata_len);
-		simple_xattrs_free(&sd->s_iattr->xattrs);
+	if (sysfs_type(kn) == SYSFS_KOBJ_LINK)
+		kernfs_put(kn->s_symlink.target_kn);
+	if (sysfs_type(kn) & SYSFS_COPY_NAME)
+		kfree(kn->s_name);
+	if (kn->s_iattr) {
+		if (kn->s_iattr->ia_secdata)
+			security_release_secctx(kn->s_iattr->ia_secdata,
+						kn->s_iattr->ia_secdata_len);
+		simple_xattrs_free(&kn->s_iattr->xattrs);
 	}
-	kfree(sd->s_iattr);
-	ida_simple_remove(&root->ino_ida, sd->s_ino);
-	kmem_cache_free(sysfs_dir_cachep, sd);
+	kfree(kn->s_iattr);
+	ida_simple_remove(&root->ino_ida, kn->s_ino);
+	kmem_cache_free(sysfs_dir_cachep, kn);
 
-	sd = parent_sd;
-	if (sd) {
-		if (atomic_dec_and_test(&sd->s_count))
+	kn = parent;
+	if (kn) {
+		if (atomic_dec_and_test(&kn->s_count))
 			goto repeat;
 	} else {
-		/* just released the root sd, free @root too */
+		/* just released the root kn, free @root too */
 		ida_destroy(&root->ino_ida);
 		kfree(root);
 	}
@@ -267,35 +268,35 @@
 
 static int sysfs_dentry_delete(const struct dentry *dentry)
 {
-	struct sysfs_dirent *sd = dentry->d_fsdata;
-	return !(sd && !(sd->s_flags & SYSFS_FLAG_REMOVED));
+	struct kernfs_node *kn = dentry->d_fsdata;
+	return !(kn && !(kn->s_flags & SYSFS_FLAG_REMOVED));
 }
 
 static int sysfs_dentry_revalidate(struct dentry *dentry, unsigned int flags)
 {
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 
 	if (flags & LOOKUP_RCU)
 		return -ECHILD;
 
-	sd = dentry->d_fsdata;
+	kn = dentry->d_fsdata;
 	mutex_lock(&sysfs_mutex);
 
 	/* The sysfs dirent has been deleted */
-	if (sd->s_flags & SYSFS_FLAG_REMOVED)
+	if (kn->s_flags & SYSFS_FLAG_REMOVED)
 		goto out_bad;
 
 	/* The sysfs dirent has been moved? */
-	if (dentry->d_parent->d_fsdata != sd->s_parent)
+	if (dentry->d_parent->d_fsdata != kn->s_parent)
 		goto out_bad;
 
 	/* The sysfs dirent has been renamed */
-	if (strcmp(dentry->d_name.name, sd->s_name) != 0)
+	if (strcmp(dentry->d_name.name, kn->s_name) != 0)
 		goto out_bad;
 
 	/* The sysfs dirent has been moved to a different namespace */
-	if (sd->s_parent && kernfs_ns_enabled(sd->s_parent) &&
-	    sysfs_info(dentry->d_sb)->ns != sd->s_ns)
+	if (kn->s_parent && kernfs_ns_enabled(kn->s_parent) &&
+	    sysfs_info(dentry->d_sb)->ns != kn->s_ns)
 		goto out_bad;
 
 	mutex_unlock(&sysfs_mutex);
@@ -335,11 +336,11 @@
 	.d_release	= sysfs_dentry_release,
 };
 
-struct sysfs_dirent *sysfs_new_dirent(struct kernfs_root *root,
-				      const char *name, umode_t mode, int type)
+struct kernfs_node *sysfs_new_dirent(struct kernfs_root *root,
+				     const char *name, umode_t mode, int type)
 {
 	char *dup_name = NULL;
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 	int ret;
 
 	if (type & SYSFS_COPY_NAME) {
@@ -348,38 +349,38 @@
 			return NULL;
 	}
 
-	sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
-	if (!sd)
+	kn = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
+	if (!kn)
 		goto err_out1;
 
 	ret = ida_simple_get(&root->ino_ida, 1, 0, GFP_KERNEL);
 	if (ret < 0)
 		goto err_out2;
-	sd->s_ino = ret;
+	kn->s_ino = ret;
 
-	atomic_set(&sd->s_count, 1);
-	atomic_set(&sd->s_active, 0);
+	atomic_set(&kn->s_count, 1);
+	atomic_set(&kn->s_active, 0);
 
-	sd->s_name = name;
-	sd->s_mode = mode;
-	sd->s_flags = type | SYSFS_FLAG_REMOVED;
+	kn->s_name = name;
+	kn->s_mode = mode;
+	kn->s_flags = type | SYSFS_FLAG_REMOVED;
 
-	return sd;
+	return kn;
 
  err_out2:
-	kmem_cache_free(sysfs_dir_cachep, sd);
+	kmem_cache_free(sysfs_dir_cachep, kn);
  err_out1:
 	kfree(dup_name);
 	return NULL;
 }
 
 /**
- *	sysfs_addrm_start - prepare for sysfs_dirent add/remove
+ *	sysfs_addrm_start - prepare for kernfs_node add/remove
  *	@acxt: pointer to sysfs_addrm_cxt to be used
  *
  *	This function is called when the caller is about to add or remove
- *	sysfs_dirent.  This function acquires sysfs_mutex.  @acxt is used
- *	to keep and pass context to other addrm functions.
+ *	kernfs_node.  This function acquires sysfs_mutex.  @acxt is used to
+ *	keep and pass context to other addrm functions.
  *
  *	LOCKING:
  *	Kernel thread context (may sleep).  sysfs_mutex is locked on
@@ -394,13 +395,13 @@
 }
 
 /**
- *	sysfs_add_one - add sysfs_dirent to parent without warning
+ *	sysfs_add_one - add kernfs_node to parent without warning
  *	@acxt: addrm context to use
- *	@sd: sysfs_dirent to be added
- *	@parent_sd: the parent sysfs_dirent to add @sd to
+ *	@kn: kernfs_node to be added
+ *	@parent: the parent kernfs_node to add @kn to
  *
- *	Get @parent_sd and set @sd->s_parent to it and increment nlink of
- *	the parent inode if @sd is a directory and link into the children
+ *	Get @parent and set @kn->s_parent to it and increment nlink of
+ *	the parent inode if @kn is a directory and link into the children
  *	list of the parent.
  *
  *	This function should be called between calls to
@@ -414,51 +415,51 @@
  *	0 on success, -EEXIST if entry with the given name already
  *	exists.
  */
-int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd,
-		  struct sysfs_dirent *parent_sd)
+int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct kernfs_node *kn,
+		  struct kernfs_node *parent)
 {
-	bool has_ns = kernfs_ns_enabled(parent_sd);
+	bool has_ns = kernfs_ns_enabled(parent);
 	struct sysfs_inode_attrs *ps_iattr;
 	int ret;
 
-	if (has_ns != (bool)sd->s_ns) {
+	if (has_ns != (bool)kn->s_ns) {
 		WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
 		     has_ns ? "required" : "invalid",
-		     parent_sd->s_name, sd->s_name);
+		     parent->s_name, kn->s_name);
 		return -EINVAL;
 	}
 
-	if (sysfs_type(parent_sd) != SYSFS_DIR)
+	if (sysfs_type(parent) != SYSFS_DIR)
 		return -EINVAL;
 
-	sd->s_hash = sysfs_name_hash(sd->s_name, sd->s_ns);
-	sd->s_parent = parent_sd;
-	kernfs_get(parent_sd);
+	kn->s_hash = sysfs_name_hash(kn->s_name, kn->s_ns);
+	kn->s_parent = parent;
+	kernfs_get(parent);
 
-	ret = sysfs_link_sibling(sd);
+	ret = sysfs_link_sibling(kn);
 	if (ret)
 		return ret;
 
 	/* Update timestamps on the parent */
-	ps_iattr = parent_sd->s_iattr;
+	ps_iattr = parent->s_iattr;
 	if (ps_iattr) {
 		struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
 		ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
 	}
 
 	/* Mark the entry added into directory tree */
-	sd->s_flags &= ~SYSFS_FLAG_REMOVED;
+	kn->s_flags &= ~SYSFS_FLAG_REMOVED;
 
 	return 0;
 }
 
 /**
- *	sysfs_remove_one - remove sysfs_dirent from parent
+ *	sysfs_remove_one - remove kernfs_node from parent
  *	@acxt: addrm context to use
- *	@sd: sysfs_dirent to be removed
+ *	@kn: kernfs_node to be removed
  *
- *	Mark @sd removed and drop nlink of parent inode if @sd is a
- *	directory.  @sd is unlinked from the children list.
+ *	Mark @kn removed and drop nlink of parent inode if @kn is a
+ *	directory.  @kn is unlinked from the children list.
  *
  *	This function should be called between calls to
  *	sysfs_addrm_start() and sysfs_addrm_finish() and should be
@@ -468,7 +469,7 @@
  *	Determined by sysfs_addrm_start().
  */
 static void sysfs_remove_one(struct sysfs_addrm_cxt *acxt,
-			     struct sysfs_dirent *sd)
+			     struct kernfs_node *kn)
 {
 	struct sysfs_inode_attrs *ps_iattr;
 
@@ -476,31 +477,31 @@
 	 * Removal can be called multiple times on the same node.  Only the
 	 * first invocation is effective and puts the base ref.
 	 */
-	if (sd->s_flags & SYSFS_FLAG_REMOVED)
+	if (kn->s_flags & SYSFS_FLAG_REMOVED)
 		return;
 
-	if (sd->s_parent) {
-		sysfs_unlink_sibling(sd);
+	if (kn->s_parent) {
+		sysfs_unlink_sibling(kn);
 
 		/* Update timestamps on the parent */
-		ps_iattr = sd->s_parent->s_iattr;
+		ps_iattr = kn->s_parent->s_iattr;
 		if (ps_iattr) {
 			ps_iattr->ia_iattr.ia_ctime = CURRENT_TIME;
 			ps_iattr->ia_iattr.ia_mtime = CURRENT_TIME;
 		}
 	}
 
-	sd->s_flags |= SYSFS_FLAG_REMOVED;
-	sd->u.removed_list = acxt->removed;
-	acxt->removed = sd;
+	kn->s_flags |= SYSFS_FLAG_REMOVED;
+	kn->u.removed_list = acxt->removed;
+	acxt->removed = kn;
 }
 
 /**
- *	sysfs_addrm_finish - finish up sysfs_dirent add/remove
+ *	sysfs_addrm_finish - finish up kernfs_node add/remove
  *	@acxt: addrm context to finish up
  *
- *	Finish up sysfs_dirent add/remove.  Resources acquired by
- *	sysfs_addrm_start() are released and removed sysfs_dirents are
+ *	Finish up kernfs_node add/remove.  Resources acquired by
+ *	sysfs_addrm_start() are released and removed kernfs_nodes are
  *	cleaned up.
  *
  *	LOCKING:
@@ -512,30 +513,30 @@
 	/* release resources acquired by sysfs_addrm_start() */
 	mutex_unlock(&sysfs_mutex);
 
-	/* kill removed sysfs_dirents */
+	/* kill removed kernfs_nodes */
 	while (acxt->removed) {
-		struct sysfs_dirent *sd = acxt->removed;
+		struct kernfs_node *kn = acxt->removed;
 
-		acxt->removed = sd->u.removed_list;
+		acxt->removed = kn->u.removed_list;
 
-		sysfs_deactivate(sd);
-		sysfs_unmap_bin_file(sd);
-		kernfs_put(sd);
+		sysfs_deactivate(kn);
+		sysfs_unmap_bin_file(kn);
+		kernfs_put(kn);
 	}
 }
 
 /**
- * kernfs_find_ns - find sysfs_dirent with the given name
- * @parent: sysfs_dirent to search under
+ * kernfs_find_ns - find kernfs_node with the given name
+ * @parent: kernfs_node to search under
  * @name: name to look for
  * @ns: the namespace tag to use
  *
- * Look for sysfs_dirent with name @name under @parent.  Returns pointer to
- * the found sysfs_dirent on success, %NULL on failure.
+ * Look for kernfs_node with name @name under @parent.  Returns pointer to
+ * the found kernfs_node on success, %NULL on failure.
  */
-static struct sysfs_dirent *kernfs_find_ns(struct sysfs_dirent *parent,
-					   const unsigned char *name,
-					   const void *ns)
+static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent,
+					  const unsigned char *name,
+					  const void *ns)
 {
 	struct rb_node *node = parent->s_dir.children.rb_node;
 	bool has_ns = kernfs_ns_enabled(parent);
@@ -552,42 +553,42 @@
 
 	hash = sysfs_name_hash(name, ns);
 	while (node) {
-		struct sysfs_dirent *sd;
+		struct kernfs_node *kn;
 		int result;
 
-		sd = to_sysfs_dirent(node);
-		result = sysfs_name_compare(hash, name, ns, sd);
+		kn = rb_to_kn(node);
+		result = sysfs_name_compare(hash, name, ns, kn);
 		if (result < 0)
 			node = node->rb_left;
 		else if (result > 0)
 			node = node->rb_right;
 		else
-			return sd;
+			return kn;
 	}
 	return NULL;
 }
 
 /**
- * kernfs_find_and_get_ns - find and get sysfs_dirent with the given name
- * @parent: sysfs_dirent to search under
+ * kernfs_find_and_get_ns - find and get kernfs_node with the given name
+ * @parent: kernfs_node to search under
  * @name: name to look for
  * @ns: the namespace tag to use
  *
- * Look for sysfs_dirent with name @name under @parent and get a reference
+ * Look for kernfs_node with name @name under @parent and get a reference
  * if found.  This function may sleep and returns pointer to the found
- * sysfs_dirent on success, %NULL on failure.
+ * kernfs_node on success, %NULL on failure.
  */
-struct sysfs_dirent *kernfs_find_and_get_ns(struct sysfs_dirent *parent,
-					    const char *name, const void *ns)
+struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
+					   const char *name, const void *ns)
 {
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 
 	mutex_lock(&sysfs_mutex);
-	sd = kernfs_find_ns(parent, name, ns);
-	kernfs_get(sd);
+	kn = kernfs_find_ns(parent, name, ns);
+	kernfs_get(kn);
 	mutex_unlock(&sysfs_mutex);
 
-	return sd;
+	return kn;
 }
 EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns);
 
@@ -601,7 +602,7 @@
 struct kernfs_root *kernfs_create_root(void *priv)
 {
 	struct kernfs_root *root;
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 
 	root = kzalloc(sizeof(*root), GFP_KERNEL);
 	if (!root)
@@ -609,18 +610,18 @@
 
 	ida_init(&root->ino_ida);
 
-	sd = sysfs_new_dirent(root, "", S_IFDIR | S_IRUGO | S_IXUGO, SYSFS_DIR);
-	if (!sd) {
+	kn = sysfs_new_dirent(root, "", S_IFDIR | S_IRUGO | S_IXUGO, SYSFS_DIR);
+	if (!kn) {
 		ida_destroy(&root->ino_ida);
 		kfree(root);
 		return ERR_PTR(-ENOMEM);
 	}
 
-	sd->s_flags &= ~SYSFS_FLAG_REMOVED;
-	sd->priv = priv;
-	sd->s_dir.root = root;
+	kn->s_flags &= ~SYSFS_FLAG_REMOVED;
+	kn->priv = priv;
+	kn->s_dir.root = root;
 
-	root->sd = sd;
+	root->kn = kn;
 
 	return root;
 }
@@ -634,7 +635,7 @@
  */
 void kernfs_destroy_root(struct kernfs_root *root)
 {
-	kernfs_remove(root->sd);	/* will also free @root */
+	kernfs_remove(root->kn);	/* will also free @root */
 }
 
 /**
@@ -646,33 +647,33 @@
  *
  * Returns the created node on success, ERR_PTR() value on failure.
  */
-struct sysfs_dirent *kernfs_create_dir_ns(struct sysfs_dirent *parent,
-					  const char *name, void *priv,
-					  const void *ns)
+struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
+					 const char *name, void *priv,
+					 const void *ns)
 {
 	umode_t mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
 	struct sysfs_addrm_cxt acxt;
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 	int rc;
 
 	/* allocate */
-	sd = sysfs_new_dirent(kernfs_root(parent), name, mode, SYSFS_DIR);
-	if (!sd)
+	kn = sysfs_new_dirent(kernfs_root(parent), name, mode, SYSFS_DIR);
+	if (!kn)
 		return ERR_PTR(-ENOMEM);
 
-	sd->s_dir.root = parent->s_dir.root;
-	sd->s_ns = ns;
-	sd->priv = priv;
+	kn->s_dir.root = parent->s_dir.root;
+	kn->s_ns = ns;
+	kn->priv = priv;
 
 	/* link in */
 	sysfs_addrm_start(&acxt);
-	rc = sysfs_add_one(&acxt, sd, parent);
+	rc = sysfs_add_one(&acxt, kn, parent);
 	sysfs_addrm_finish(&acxt);
 
 	if (!rc)
-		return sd;
+		return kn;
 
-	kernfs_put(sd);
+	kernfs_put(kn);
 	return ERR_PTR(rc);
 }
 
@@ -680,29 +681,28 @@
 				   unsigned int flags)
 {
 	struct dentry *ret = NULL;
-	struct dentry *parent = dentry->d_parent;
-	struct sysfs_dirent *parent_sd = parent->d_fsdata;
-	struct sysfs_dirent *sd;
+	struct kernfs_node *parent = dentry->d_parent->d_fsdata;
+	struct kernfs_node *kn;
 	struct inode *inode;
 	const void *ns = NULL;
 
 	mutex_lock(&sysfs_mutex);
 
-	if (kernfs_ns_enabled(parent_sd))
+	if (kernfs_ns_enabled(parent))
 		ns = sysfs_info(dir->i_sb)->ns;
 
-	sd = kernfs_find_ns(parent_sd, dentry->d_name.name, ns);
+	kn = kernfs_find_ns(parent, dentry->d_name.name, ns);
 
 	/* no such entry */
-	if (!sd) {
+	if (!kn) {
 		ret = ERR_PTR(-ENOENT);
 		goto out_unlock;
 	}
-	kernfs_get(sd);
-	dentry->d_fsdata = sd;
+	kernfs_get(kn);
+	dentry->d_fsdata = kn;
 
 	/* attach dentry and inode */
-	inode = sysfs_get_inode(dir->i_sb, sd);
+	inode = sysfs_get_inode(dir->i_sb, kn);
 	if (!inode) {
 		ret = ERR_PTR(-ENOMEM);
 		goto out_unlock;
@@ -726,9 +726,9 @@
 	.listxattr	= sysfs_listxattr,
 };
 
-static struct sysfs_dirent *sysfs_leftmost_descendant(struct sysfs_dirent *pos)
+static struct kernfs_node *sysfs_leftmost_descendant(struct kernfs_node *pos)
 {
-	struct sysfs_dirent *last;
+	struct kernfs_node *last;
 
 	while (true) {
 		struct rb_node *rbn;
@@ -742,7 +742,7 @@
 		if (!rbn)
 			break;
 
-		pos = to_sysfs_dirent(rbn);
+		pos = rb_to_kn(rbn);
 	}
 
 	return last;
@@ -751,14 +751,14 @@
 /**
  * sysfs_next_descendant_post - find the next descendant for post-order walk
  * @pos: the current position (%NULL to initiate traversal)
- * @root: sysfs_dirent whose descendants to walk
+ * @root: kernfs_node whose descendants to walk
  *
  * Find the next descendant to visit for post-order traversal of @root's
  * descendants.  @root is included in the iteration and the last node to be
  * visited.
  */
-static struct sysfs_dirent *sysfs_next_descendant_post(struct sysfs_dirent *pos,
-						       struct sysfs_dirent *root)
+static struct kernfs_node *sysfs_next_descendant_post(struct kernfs_node *pos,
+						      struct kernfs_node *root)
 {
 	struct rb_node *rbn;
 
@@ -775,62 +775,62 @@
 	/* if there's an unvisited sibling, visit its leftmost descendant */
 	rbn = rb_next(&pos->s_rb);
 	if (rbn)
-		return sysfs_leftmost_descendant(to_sysfs_dirent(rbn));
+		return sysfs_leftmost_descendant(rb_to_kn(rbn));
 
 	/* no sibling left, visit parent */
 	return pos->s_parent;
 }
 
 static void __kernfs_remove(struct sysfs_addrm_cxt *acxt,
-			    struct sysfs_dirent *sd)
+			    struct kernfs_node *kn)
 {
-	struct sysfs_dirent *pos, *next;
+	struct kernfs_node *pos, *next;
 
-	if (!sd)
+	if (!kn)
 		return;
 
-	pr_debug("sysfs %s: removing\n", sd->s_name);
+	pr_debug("sysfs %s: removing\n", kn->s_name);
 
 	next = NULL;
 	do {
 		pos = next;
-		next = sysfs_next_descendant_post(pos, sd);
+		next = sysfs_next_descendant_post(pos, kn);
 		if (pos)
 			sysfs_remove_one(acxt, pos);
 	} while (next);
 }
 
 /**
- * kernfs_remove - remove a sysfs_dirent recursively
- * @sd: the sysfs_dirent to remove
+ * kernfs_remove - remove a kernfs_node recursively
+ * @kn: the kernfs_node to remove
  *
- * Remove @sd along with all its subdirectories and files.
+ * Remove @kn along with all its subdirectories and files.
  */
-void kernfs_remove(struct sysfs_dirent *sd)
+void kernfs_remove(struct kernfs_node *kn)
 {
 	struct sysfs_addrm_cxt acxt;
 
 	sysfs_addrm_start(&acxt);
-	__kernfs_remove(&acxt, sd);
+	__kernfs_remove(&acxt, kn);
 	sysfs_addrm_finish(&acxt);
 }
 
 /**
- * kernfs_remove_by_name_ns - find a sysfs_dirent by name and remove it
- * @dir_sd: parent of the target
- * @name: name of the sysfs_dirent to remove
- * @ns: namespace tag of the sysfs_dirent to remove
+ * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it
+ * @parent: parent of the target
+ * @name: name of the kernfs_node to remove
+ * @ns: namespace tag of the kernfs_node to remove
  *
- * Look for the sysfs_dirent with @name and @ns under @dir_sd and remove
- * it.  Returns 0 on success, -ENOENT if such entry doesn't exist.
+ * Look for the kernfs_node with @name and @ns under @parent and remove it.
+ * Returns 0 on success, -ENOENT if such entry doesn't exist.
  */
-int kernfs_remove_by_name_ns(struct sysfs_dirent *dir_sd, const char *name,
+int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
 			     const void *ns)
 {
 	struct sysfs_addrm_cxt acxt;
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 
-	if (!dir_sd) {
+	if (!parent) {
 		WARN(1, KERN_WARNING "sysfs: can not remove '%s', no directory\n",
 			name);
 		return -ENOENT;
@@ -838,13 +838,13 @@
 
 	sysfs_addrm_start(&acxt);
 
-	sd = kernfs_find_ns(dir_sd, name, ns);
-	if (sd)
-		__kernfs_remove(&acxt, sd);
+	kn = kernfs_find_ns(parent, name, ns);
+	if (kn)
+		__kernfs_remove(&acxt, kn);
 
 	sysfs_addrm_finish(&acxt);
 
-	if (sd)
+	if (kn)
 		return 0;
 	else
 		return -ENOENT;
@@ -852,12 +852,12 @@
 
 /**
  * kernfs_rename_ns - move and rename a kernfs_node
- * @sd: target node
+ * @kn: target node
  * @new_parent: new parent to put @sd under
  * @new_name: new name
  * @new_ns: new namespace tag
  */
-int kernfs_rename_ns(struct sysfs_dirent *sd, struct sysfs_dirent *new_parent,
+int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
 		     const char *new_name, const void *new_ns)
 {
 	int error;
@@ -865,35 +865,35 @@
 	mutex_lock(&sysfs_mutex);
 
 	error = 0;
-	if ((sd->s_parent == new_parent) && (sd->s_ns == new_ns) &&
-	    (strcmp(sd->s_name, new_name) == 0))
+	if ((kn->s_parent == new_parent) && (kn->s_ns == new_ns) &&
+	    (strcmp(kn->s_name, new_name) == 0))
 		goto out;	/* nothing to rename */
 
 	error = -EEXIST;
 	if (kernfs_find_ns(new_parent, new_name, new_ns))
 		goto out;
 
-	/* rename sysfs_dirent */
-	if (strcmp(sd->s_name, new_name) != 0) {
+	/* rename kernfs_node */
+	if (strcmp(kn->s_name, new_name) != 0) {
 		error = -ENOMEM;
 		new_name = kstrdup(new_name, GFP_KERNEL);
 		if (!new_name)
 			goto out;
 
-		kfree(sd->s_name);
-		sd->s_name = new_name;
+		kfree(kn->s_name);
+		kn->s_name = new_name;
 	}
 
 	/*
 	 * Move to the appropriate place in the appropriate directories rbtree.
 	 */
-	sysfs_unlink_sibling(sd);
+	sysfs_unlink_sibling(kn);
 	kernfs_get(new_parent);
-	kernfs_put(sd->s_parent);
-	sd->s_ns = new_ns;
-	sd->s_hash = sysfs_name_hash(sd->s_name, sd->s_ns);
-	sd->s_parent = new_parent;
-	sysfs_link_sibling(sd);
+	kernfs_put(kn->s_parent);
+	kn->s_ns = new_ns;
+	kn->s_hash = sysfs_name_hash(kn->s_name, kn->s_ns);
+	kn->s_parent = new_parent;
+	sysfs_link_sibling(kn);
 
 	error = 0;
  out:
@@ -902,9 +902,9 @@
 }
 
 /* Relationship between s_mode and the DT_xxx types */
-static inline unsigned char dt_type(struct sysfs_dirent *sd)
+static inline unsigned char dt_type(struct kernfs_node *kn)
 {
-	return (sd->s_mode >> 12) & 15;
+	return (kn->s_mode >> 12) & 15;
 }
 
 static int sysfs_dir_release(struct inode *inode, struct file *filp)
@@ -913,21 +913,21 @@
 	return 0;
 }
 
-static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
-	struct sysfs_dirent *parent_sd,	loff_t hash, struct sysfs_dirent *pos)
+static struct kernfs_node *sysfs_dir_pos(const void *ns,
+	struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos)
 {
 	if (pos) {
 		int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
-			pos->s_parent == parent_sd &&
+			pos->s_parent == parent &&
 			hash == pos->s_hash;
 		kernfs_put(pos);
 		if (!valid)
 			pos = NULL;
 	}
 	if (!pos && (hash > 1) && (hash < INT_MAX)) {
-		struct rb_node *node = parent_sd->s_dir.children.rb_node;
+		struct rb_node *node = parent->s_dir.children.rb_node;
 		while (node) {
-			pos = to_sysfs_dirent(node);
+			pos = rb_to_kn(node);
 
 			if (hash < pos->s_hash)
 				node = node->rb_left;
@@ -943,22 +943,22 @@
 		if (!node)
 			pos = NULL;
 		else
-			pos = to_sysfs_dirent(node);
+			pos = rb_to_kn(node);
 	}
 	return pos;
 }
 
-static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
-	struct sysfs_dirent *parent_sd,	ino_t ino, struct sysfs_dirent *pos)
+static struct kernfs_node *sysfs_dir_next_pos(const void *ns,
+	struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos)
 {
-	pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
+	pos = sysfs_dir_pos(ns, parent, ino, pos);
 	if (pos)
 		do {
 			struct rb_node *node = rb_next(&pos->s_rb);
 			if (!node)
 				pos = NULL;
 			else
-				pos = to_sysfs_dirent(node);
+				pos = rb_to_kn(node);
 		} while (pos && pos->s_ns != ns);
 	return pos;
 }
@@ -966,20 +966,20 @@
 static int sysfs_readdir(struct file *file, struct dir_context *ctx)
 {
 	struct dentry *dentry = file->f_path.dentry;
-	struct sysfs_dirent *parent_sd = dentry->d_fsdata;
-	struct sysfs_dirent *pos = file->private_data;
+	struct kernfs_node *parent = dentry->d_fsdata;
+	struct kernfs_node *pos = file->private_data;
 	const void *ns = NULL;
 
 	if (!dir_emit_dots(file, ctx))
 		return 0;
 	mutex_lock(&sysfs_mutex);
 
-	if (kernfs_ns_enabled(parent_sd))
+	if (kernfs_ns_enabled(parent))
 		ns = sysfs_info(dentry->d_sb)->ns;
 
-	for (pos = sysfs_dir_pos(ns, parent_sd, ctx->pos, pos);
+	for (pos = sysfs_dir_pos(ns, parent, ctx->pos, pos);
 	     pos;
-	     pos = sysfs_dir_next_pos(ns, parent_sd, ctx->pos, pos)) {
+	     pos = sysfs_dir_next_pos(ns, parent, ctx->pos, pos)) {
 		const char *name = pos->s_name;
 		unsigned int type = dt_type(pos);
 		int len = strlen(name);
diff --git a/fs/kernfs/file.c b/fs/kernfs/file.c
index fa05315..1bf07de 100644
--- a/fs/kernfs/file.c
+++ b/fs/kernfs/file.c
@@ -19,9 +19,9 @@
 
 /*
  * There's one sysfs_open_file for each open file and one sysfs_open_dirent
- * for each sysfs_dirent with one or more open files.
+ * for each kernfs_node with one or more open files.
  *
- * sysfs_dirent->s_attr.open points to sysfs_open_dirent.  s_attr.open is
+ * kernfs_node->s_attr.open points to sysfs_open_dirent.  s_attr.open is
  * protected by sysfs_open_dirent_lock.
  *
  * filp->private_data points to seq_file whose ->private points to
@@ -44,14 +44,14 @@
 }
 
 /*
- * Determine the kernfs_ops for the given sysfs_dirent.  This function must
+ * Determine the kernfs_ops for the given kernfs_node.  This function must
  * be called while holding an active reference.
  */
-static const struct kernfs_ops *kernfs_ops(struct sysfs_dirent *sd)
+static const struct kernfs_ops *kernfs_ops(struct kernfs_node *kn)
 {
-	if (sd->s_flags & SYSFS_FLAG_LOCKDEP)
-		lockdep_assert_held(sd);
-	return sd->s_attr.ops;
+	if (kn->s_flags & SYSFS_FLAG_LOCKDEP)
+		lockdep_assert_held(kn);
+	return kn->s_attr.ops;
 }
 
 static void *kernfs_seq_start(struct seq_file *sf, loff_t *ppos)
@@ -64,10 +64,10 @@
 	 * the ops aren't called concurrently for the same open file.
 	 */
 	mutex_lock(&of->mutex);
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		return ERR_PTR(-ENODEV);
 
-	ops = kernfs_ops(of->sd);
+	ops = kernfs_ops(of->kn);
 	if (ops->seq_start) {
 		return ops->seq_start(sf, ppos);
 	} else {
@@ -82,7 +82,7 @@
 static void *kernfs_seq_next(struct seq_file *sf, void *v, loff_t *ppos)
 {
 	struct sysfs_open_file *of = sf->private;
-	const struct kernfs_ops *ops = kernfs_ops(of->sd);
+	const struct kernfs_ops *ops = kernfs_ops(of->kn);
 
 	if (ops->seq_next) {
 		return ops->seq_next(sf, v, ppos);
@@ -99,12 +99,12 @@
 static void kernfs_seq_stop(struct seq_file *sf, void *v)
 {
 	struct sysfs_open_file *of = sf->private;
-	const struct kernfs_ops *ops = kernfs_ops(of->sd);
+	const struct kernfs_ops *ops = kernfs_ops(of->kn);
 
 	if (ops->seq_stop)
 		ops->seq_stop(sf, v);
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	mutex_unlock(&of->mutex);
 }
 
@@ -112,9 +112,9 @@
 {
 	struct sysfs_open_file *of = sf->private;
 
-	of->event = atomic_read(&of->sd->s_attr.open->event);
+	of->event = atomic_read(&of->kn->s_attr.open->event);
 
-	return of->sd->s_attr.ops->seq_show(sf, v);
+	return of->kn->s_attr.ops->seq_show(sf, v);
 }
 
 static const struct seq_operations kernfs_seq_ops = {
@@ -147,19 +147,19 @@
 	 * the ops aren't called concurrently for the same open file.
 	 */
 	mutex_lock(&of->mutex);
-	if (!sysfs_get_active(of->sd)) {
+	if (!sysfs_get_active(of->kn)) {
 		len = -ENODEV;
 		mutex_unlock(&of->mutex);
 		goto out_free;
 	}
 
-	ops = kernfs_ops(of->sd);
+	ops = kernfs_ops(of->kn);
 	if (ops->read)
 		len = ops->read(of, buf, len, *ppos);
 	else
 		len = -EINVAL;
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	mutex_unlock(&of->mutex);
 
 	if (len < 0)
@@ -189,7 +189,7 @@
 {
 	struct sysfs_open_file *of = sysfs_of(file);
 
-	if (of->sd->s_flags & SYSFS_FLAG_HAS_SEQ_SHOW)
+	if (of->kn->s_flags & SYSFS_FLAG_HAS_SEQ_SHOW)
 		return seq_read(file, user_buf, count, ppos);
 	else
 		return kernfs_file_direct_read(of, user_buf, count, ppos);
@@ -234,19 +234,19 @@
 	 * the ops aren't called concurrently for the same open file.
 	 */
 	mutex_lock(&of->mutex);
-	if (!sysfs_get_active(of->sd)) {
+	if (!sysfs_get_active(of->kn)) {
 		mutex_unlock(&of->mutex);
 		len = -ENODEV;
 		goto out_free;
 	}
 
-	ops = kernfs_ops(of->sd);
+	ops = kernfs_ops(of->kn);
 	if (ops->write)
 		len = ops->write(of, buf, len, *ppos);
 	else
 		len = -EINVAL;
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	mutex_unlock(&of->mutex);
 
 	if (len > 0)
@@ -264,13 +264,13 @@
 	if (!of->vm_ops)
 		return;
 
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		return;
 
 	if (of->vm_ops->open)
 		of->vm_ops->open(vma);
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 }
 
 static int kernfs_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
@@ -282,14 +282,14 @@
 	if (!of->vm_ops)
 		return VM_FAULT_SIGBUS;
 
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		return VM_FAULT_SIGBUS;
 
 	ret = VM_FAULT_SIGBUS;
 	if (of->vm_ops->fault)
 		ret = of->vm_ops->fault(vma, vmf);
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	return ret;
 }
 
@@ -303,7 +303,7 @@
 	if (!of->vm_ops)
 		return VM_FAULT_SIGBUS;
 
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		return VM_FAULT_SIGBUS;
 
 	ret = 0;
@@ -312,7 +312,7 @@
 	else
 		file_update_time(file);
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	return ret;
 }
 
@@ -326,14 +326,14 @@
 	if (!of->vm_ops)
 		return -EINVAL;
 
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		return -EINVAL;
 
 	ret = -EINVAL;
 	if (of->vm_ops->access)
 		ret = of->vm_ops->access(vma, addr, buf, len, write);
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	return ret;
 }
 
@@ -348,14 +348,14 @@
 	if (!of->vm_ops)
 		return 0;
 
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		return -EINVAL;
 
 	ret = 0;
 	if (of->vm_ops->set_policy)
 		ret = of->vm_ops->set_policy(vma, new);
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	return ret;
 }
 
@@ -369,14 +369,14 @@
 	if (!of->vm_ops)
 		return vma->vm_policy;
 
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		return vma->vm_policy;
 
 	pol = vma->vm_policy;
 	if (of->vm_ops->get_policy)
 		pol = of->vm_ops->get_policy(vma, addr);
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	return pol;
 }
 
@@ -391,14 +391,14 @@
 	if (!of->vm_ops)
 		return 0;
 
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		return 0;
 
 	ret = 0;
 	if (of->vm_ops->migrate)
 		ret = of->vm_ops->migrate(vma, from, to, flags);
 
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 	return ret;
 }
 #endif
@@ -428,16 +428,16 @@
 	 * without grabbing @of->mutex by testing HAS_MMAP flag.  See the
 	 * comment in kernfs_file_open() for more details.
 	 */
-	if (!(of->sd->s_flags & SYSFS_FLAG_HAS_MMAP))
+	if (!(of->kn->s_flags & SYSFS_FLAG_HAS_MMAP))
 		return -ENODEV;
 
 	mutex_lock(&of->mutex);
 
 	rc = -ENODEV;
-	if (!sysfs_get_active(of->sd))
+	if (!sysfs_get_active(of->kn))
 		goto out_unlock;
 
-	ops = kernfs_ops(of->sd);
+	ops = kernfs_ops(of->kn);
 	rc = ops->mmap(of, vma);
 
 	/*
@@ -465,7 +465,7 @@
 	of->vm_ops = vma->vm_ops;
 	vma->vm_ops = &kernfs_vm_ops;
 out_put:
-	sysfs_put_active(of->sd);
+	sysfs_put_active(of->kn);
 out_unlock:
 	mutex_unlock(&of->mutex);
 
@@ -474,10 +474,10 @@
 
 /**
  *	sysfs_get_open_dirent - get or create sysfs_open_dirent
- *	@sd: target sysfs_dirent
+ *	@kn: target kernfs_node
  *	@of: sysfs_open_file for this instance of open
  *
- *	If @sd->s_attr.open exists, increment its reference count;
+ *	If @kn->s_attr.open exists, increment its reference count;
  *	otherwise, create one.  @of is chained to the files list.
  *
  *	LOCKING:
@@ -486,7 +486,7 @@
  *	RETURNS:
  *	0 on success, -errno on failure.
  */
-static int sysfs_get_open_dirent(struct sysfs_dirent *sd,
+static int sysfs_get_open_dirent(struct kernfs_node *kn,
 				 struct sysfs_open_file *of)
 {
 	struct sysfs_open_dirent *od, *new_od = NULL;
@@ -495,12 +495,12 @@
 	mutex_lock(&sysfs_open_file_mutex);
 	spin_lock_irq(&sysfs_open_dirent_lock);
 
-	if (!sd->s_attr.open && new_od) {
-		sd->s_attr.open = new_od;
+	if (!kn->s_attr.open && new_od) {
+		kn->s_attr.open = new_od;
 		new_od = NULL;
 	}
 
-	od = sd->s_attr.open;
+	od = kn->s_attr.open;
 	if (od) {
 		atomic_inc(&od->refcnt);
 		list_add_tail(&of->list, &od->files);
@@ -528,19 +528,19 @@
 
 /**
  *	sysfs_put_open_dirent - put sysfs_open_dirent
- *	@sd: target sysfs_dirent
+ *	@kn: target kernfs_nodet
  *	@of: associated sysfs_open_file
  *
- *	Put @sd->s_attr.open and unlink @of from the files list.  If
+ *	Put @kn->s_attr.open and unlink @of from the files list.  If
  *	reference count reaches zero, disassociate and free it.
  *
  *	LOCKING:
  *	None.
  */
-static void sysfs_put_open_dirent(struct sysfs_dirent *sd,
+static void sysfs_put_open_dirent(struct kernfs_node *kn,
 				  struct sysfs_open_file *of)
 {
-	struct sysfs_open_dirent *od = sd->s_attr.open;
+	struct sysfs_open_dirent *od = kn->s_attr.open;
 	unsigned long flags;
 
 	mutex_lock(&sysfs_open_file_mutex);
@@ -550,7 +550,7 @@
 		list_del(&of->list);
 
 	if (atomic_dec_and_test(&od->refcnt))
-		sd->s_attr.open = NULL;
+		kn->s_attr.open = NULL;
 	else
 		od = NULL;
 
@@ -562,16 +562,16 @@
 
 static int kernfs_file_open(struct inode *inode, struct file *file)
 {
-	struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+	struct kernfs_node *kn = file->f_path.dentry->d_fsdata;
 	const struct kernfs_ops *ops;
 	struct sysfs_open_file *of;
 	bool has_read, has_write, has_mmap;
 	int error = -EACCES;
 
-	if (!sysfs_get_active(attr_sd))
+	if (!sysfs_get_active(kn))
 		return -ENODEV;
 
-	ops = kernfs_ops(attr_sd);
+	ops = kernfs_ops(kn);
 
 	has_read = ops->seq_show || ops->read || ops->mmap;
 	has_write = ops->write || ops->mmap;
@@ -612,7 +612,7 @@
 	else
 		mutex_init(&of->mutex);
 
-	of->sd = attr_sd;
+	of->kn = kn;
 	of->file = file;
 
 	/*
@@ -634,12 +634,12 @@
 		file->f_mode |= FMODE_PWRITE;
 
 	/* make sure we have open dirent struct */
-	error = sysfs_get_open_dirent(attr_sd, of);
+	error = sysfs_get_open_dirent(kn, of);
 	if (error)
 		goto err_close;
 
 	/* open succeeded, put active references */
-	sysfs_put_active(attr_sd);
+	sysfs_put_active(kn);
 	return 0;
 
 err_close:
@@ -647,32 +647,32 @@
 err_free:
 	kfree(of);
 err_out:
-	sysfs_put_active(attr_sd);
+	sysfs_put_active(kn);
 	return error;
 }
 
 static int kernfs_file_release(struct inode *inode, struct file *filp)
 {
-	struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
+	struct kernfs_node *kn = filp->f_path.dentry->d_fsdata;
 	struct sysfs_open_file *of = sysfs_of(filp);
 
-	sysfs_put_open_dirent(sd, of);
+	sysfs_put_open_dirent(kn, of);
 	seq_release(inode, filp);
 	kfree(of);
 
 	return 0;
 }
 
-void sysfs_unmap_bin_file(struct sysfs_dirent *sd)
+void sysfs_unmap_bin_file(struct kernfs_node *kn)
 {
 	struct sysfs_open_dirent *od;
 	struct sysfs_open_file *of;
 
-	if (!(sd->s_flags & SYSFS_FLAG_HAS_MMAP))
+	if (!(kn->s_flags & SYSFS_FLAG_HAS_MMAP))
 		return;
 
 	spin_lock_irq(&sysfs_open_dirent_lock);
-	od = sd->s_attr.open;
+	od = kn->s_attr.open;
 	if (od)
 		atomic_inc(&od->refcnt);
 	spin_unlock_irq(&sysfs_open_dirent_lock);
@@ -686,7 +686,7 @@
 	}
 	mutex_unlock(&sysfs_open_file_mutex);
 
-	sysfs_put_open_dirent(sd, NULL);
+	sysfs_put_open_dirent(kn, NULL);
 }
 
 /* Sysfs attribute files are pollable.  The idea is that you read
@@ -705,16 +705,16 @@
 static unsigned int kernfs_file_poll(struct file *filp, poll_table *wait)
 {
 	struct sysfs_open_file *of = sysfs_of(filp);
-	struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
-	struct sysfs_open_dirent *od = attr_sd->s_attr.open;
+	struct kernfs_node *kn = filp->f_path.dentry->d_fsdata;
+	struct sysfs_open_dirent *od = kn->s_attr.open;
 
 	/* need parent for the kobj, grab both */
-	if (!sysfs_get_active(attr_sd))
+	if (!sysfs_get_active(kn))
 		goto trigger;
 
 	poll_wait(filp, &od->poll, wait);
 
-	sysfs_put_active(attr_sd);
+	sysfs_put_active(kn);
 
 	if (of->event != atomic_read(&od->event))
 		goto trigger;
@@ -727,19 +727,19 @@
 
 /**
  * kernfs_notify - notify a kernfs file
- * @sd: file to notify
+ * @kn: file to notify
  *
- * Notify @sd such that poll(2) on @sd wakes up.
+ * Notify @kn such that poll(2) on @kn wakes up.
  */
-void kernfs_notify(struct sysfs_dirent *sd)
+void kernfs_notify(struct kernfs_node *kn)
 {
 	struct sysfs_open_dirent *od;
 	unsigned long flags;
 
 	spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
 
-	if (!WARN_ON(sysfs_type(sd) != SYSFS_KOBJ_ATTR)) {
-		od = sd->s_attr.open;
+	if (!WARN_ON(sysfs_type(kn) != SYSFS_KOBJ_ATTR)) {
+		od = kn->s_attr.open;
 		if (od) {
 			atomic_inc(&od->event);
 			wake_up_interruptible(&od->poll);
@@ -773,51 +773,51 @@
  *
  * Returns the created node on success, ERR_PTR() value on error.
  */
-struct sysfs_dirent *kernfs_create_file_ns_key(struct sysfs_dirent *parent,
-					       const char *name,
-					       umode_t mode, loff_t size,
-					       const struct kernfs_ops *ops,
-					       void *priv, const void *ns,
-					       struct lock_class_key *key)
+struct kernfs_node *kernfs_create_file_ns_key(struct kernfs_node *parent,
+					      const char *name,
+					      umode_t mode, loff_t size,
+					      const struct kernfs_ops *ops,
+					      void *priv, const void *ns,
+					      struct lock_class_key *key)
 {
 	struct sysfs_addrm_cxt acxt;
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 	int rc;
 
-	sd = sysfs_new_dirent(kernfs_root(parent), name,
+	kn = sysfs_new_dirent(kernfs_root(parent), name,
 			      (mode & S_IALLUGO) | S_IFREG, SYSFS_KOBJ_ATTR);
-	if (!sd)
+	if (!kn)
 		return ERR_PTR(-ENOMEM);
 
-	sd->s_attr.ops = ops;
-	sd->s_attr.size = size;
-	sd->s_ns = ns;
-	sd->priv = priv;
+	kn->s_attr.ops = ops;
+	kn->s_attr.size = size;
+	kn->s_ns = ns;
+	kn->priv = priv;
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 	if (key) {
-		lockdep_init_map(&sd->dep_map, "s_active", key, 0);
-		sd->s_flags |= SYSFS_FLAG_LOCKDEP;
+		lockdep_init_map(&kn->dep_map, "s_active", key, 0);
+		kn->s_flags |= SYSFS_FLAG_LOCKDEP;
 	}
 #endif
 
 	/*
-	 * sd->s_attr.ops is accesible only while holding active ref.  We
+	 * kn->s_attr.ops is accesible only while holding active ref.  We
 	 * need to know whether some ops are implemented outside active
 	 * ref.  Cache their existence in flags.
 	 */
 	if (ops->seq_show)
-		sd->s_flags |= SYSFS_FLAG_HAS_SEQ_SHOW;
+		kn->s_flags |= SYSFS_FLAG_HAS_SEQ_SHOW;
 	if (ops->mmap)
-		sd->s_flags |= SYSFS_FLAG_HAS_MMAP;
+		kn->s_flags |= SYSFS_FLAG_HAS_MMAP;
 
 	sysfs_addrm_start(&acxt);
-	rc = sysfs_add_one(&acxt, sd, parent);
+	rc = sysfs_add_one(&acxt, kn, parent);
 	sysfs_addrm_finish(&acxt);
 
 	if (rc) {
-		kernfs_put(sd);
+		kernfs_put(kn);
 		return ERR_PTR(rc);
 	}
-	return sd;
+	return kn;
 }
diff --git a/fs/kernfs/inode.c b/fs/kernfs/inode.c
index 18ad431..9e74eed 100644
--- a/fs/kernfs/inode.c
+++ b/fs/kernfs/inode.c
@@ -46,36 +46,36 @@
 		panic("failed to init sysfs_backing_dev_info");
 }
 
-static struct sysfs_inode_attrs *sysfs_inode_attrs(struct sysfs_dirent *sd)
+static struct sysfs_inode_attrs *sysfs_inode_attrs(struct kernfs_node *kn)
 {
 	struct iattr *iattrs;
 
-	if (sd->s_iattr)
-		return sd->s_iattr;
+	if (kn->s_iattr)
+		return kn->s_iattr;
 
-	sd->s_iattr = kzalloc(sizeof(struct sysfs_inode_attrs), GFP_KERNEL);
-	if (!sd->s_iattr)
+	kn->s_iattr = kzalloc(sizeof(struct sysfs_inode_attrs), GFP_KERNEL);
+	if (!kn->s_iattr)
 		return NULL;
-	iattrs = &sd->s_iattr->ia_iattr;
+	iattrs = &kn->s_iattr->ia_iattr;
 
 	/* assign default attributes */
-	iattrs->ia_mode = sd->s_mode;
+	iattrs->ia_mode = kn->s_mode;
 	iattrs->ia_uid = GLOBAL_ROOT_UID;
 	iattrs->ia_gid = GLOBAL_ROOT_GID;
 	iattrs->ia_atime = iattrs->ia_mtime = iattrs->ia_ctime = CURRENT_TIME;
 
-	simple_xattrs_init(&sd->s_iattr->xattrs);
+	simple_xattrs_init(&kn->s_iattr->xattrs);
 
-	return sd->s_iattr;
+	return kn->s_iattr;
 }
 
-static int __kernfs_setattr(struct sysfs_dirent *sd, const struct iattr *iattr)
+static int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
 {
 	struct sysfs_inode_attrs *attrs;
 	struct iattr *iattrs;
 	unsigned int ia_valid = iattr->ia_valid;
 
-	attrs = sysfs_inode_attrs(sd);
+	attrs = sysfs_inode_attrs(kn);
 	if (!attrs)
 		return -ENOMEM;
 
@@ -93,24 +93,24 @@
 		iattrs->ia_ctime = iattr->ia_ctime;
 	if (ia_valid & ATTR_MODE) {
 		umode_t mode = iattr->ia_mode;
-		iattrs->ia_mode = sd->s_mode = mode;
+		iattrs->ia_mode = kn->s_mode = mode;
 	}
 	return 0;
 }
 
 /**
  * kernfs_setattr - set iattr on a node
- * @sd: target node
+ * @kn: target node
  * @iattr: iattr to set
  *
  * Returns 0 on success, -errno on failure.
  */
-int kernfs_setattr(struct sysfs_dirent *sd, const struct iattr *iattr)
+int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
 {
 	int ret;
 
 	mutex_lock(&sysfs_mutex);
-	ret = __kernfs_setattr(sd, iattr);
+	ret = __kernfs_setattr(kn, iattr);
 	mutex_unlock(&sysfs_mutex);
 	return ret;
 }
@@ -118,10 +118,10 @@
 int sysfs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
 	struct inode *inode = dentry->d_inode;
-	struct sysfs_dirent *sd = dentry->d_fsdata;
+	struct kernfs_node *kn = dentry->d_fsdata;
 	int error;
 
-	if (!sd)
+	if (!kn)
 		return -EINVAL;
 
 	mutex_lock(&sysfs_mutex);
@@ -129,7 +129,7 @@
 	if (error)
 		goto out;
 
-	error = __kernfs_setattr(sd, iattr);
+	error = __kernfs_setattr(kn, iattr);
 	if (error)
 		goto out;
 
@@ -141,14 +141,14 @@
 	return error;
 }
 
-static int sysfs_sd_setsecdata(struct sysfs_dirent *sd, void **secdata,
+static int sysfs_sd_setsecdata(struct kernfs_node *kn, void **secdata,
 			       u32 *secdata_len)
 {
 	struct sysfs_inode_attrs *attrs;
 	void *old_secdata;
 	size_t old_secdata_len;
 
-	attrs = sysfs_inode_attrs(sd);
+	attrs = sysfs_inode_attrs(kn);
 	if (!attrs)
 		return -ENOMEM;
 
@@ -166,13 +166,13 @@
 int sysfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 		size_t size, int flags)
 {
-	struct sysfs_dirent *sd = dentry->d_fsdata;
+	struct kernfs_node *kn = dentry->d_fsdata;
 	struct sysfs_inode_attrs *attrs;
 	void *secdata;
 	int error;
 	u32 secdata_len = 0;
 
-	attrs = sysfs_inode_attrs(sd);
+	attrs = sysfs_inode_attrs(kn);
 	if (!attrs)
 		return -ENOMEM;
 
@@ -188,7 +188,7 @@
 			return error;
 
 		mutex_lock(&sysfs_mutex);
-		error = sysfs_sd_setsecdata(sd, &secdata, &secdata_len);
+		error = sysfs_sd_setsecdata(kn, &secdata, &secdata_len);
 		mutex_unlock(&sysfs_mutex);
 
 		if (secdata)
@@ -204,10 +204,10 @@
 
 int sysfs_removexattr(struct dentry *dentry, const char *name)
 {
-	struct sysfs_dirent *sd = dentry->d_fsdata;
+	struct kernfs_node *kn = dentry->d_fsdata;
 	struct sysfs_inode_attrs *attrs;
 
-	attrs = sysfs_inode_attrs(sd);
+	attrs = sysfs_inode_attrs(kn);
 	if (!attrs)
 		return -ENOMEM;
 
@@ -217,10 +217,10 @@
 ssize_t sysfs_getxattr(struct dentry *dentry, const char *name, void *buf,
 		       size_t size)
 {
-	struct sysfs_dirent *sd = dentry->d_fsdata;
+	struct kernfs_node *kn = dentry->d_fsdata;
 	struct sysfs_inode_attrs *attrs;
 
-	attrs = sysfs_inode_attrs(sd);
+	attrs = sysfs_inode_attrs(kn);
 	if (!attrs)
 		return -ENOMEM;
 
@@ -229,10 +229,10 @@
 
 ssize_t sysfs_listxattr(struct dentry *dentry, char *buf, size_t size)
 {
-	struct sysfs_dirent *sd = dentry->d_fsdata;
+	struct kernfs_node *kn = dentry->d_fsdata;
 	struct sysfs_inode_attrs *attrs;
 
-	attrs = sysfs_inode_attrs(sd);
+	attrs = sysfs_inode_attrs(kn);
 	if (!attrs)
 		return -ENOMEM;
 
@@ -254,57 +254,58 @@
 	inode->i_ctime = iattr->ia_ctime;
 }
 
-static void sysfs_refresh_inode(struct sysfs_dirent *sd, struct inode *inode)
+static void sysfs_refresh_inode(struct kernfs_node *kn, struct inode *inode)
 {
-	struct sysfs_inode_attrs *attrs = sd->s_iattr;
+	struct sysfs_inode_attrs *attrs = kn->s_iattr;
 
-	inode->i_mode = sd->s_mode;
+	inode->i_mode = kn->s_mode;
 	if (attrs) {
-		/* sysfs_dirent has non-default attributes
-		 * get them from persistent copy in sysfs_dirent
+		/*
+		 * kernfs_node has non-default attributes get them from
+		 * persistent copy in kernfs_node.
 		 */
 		set_inode_attr(inode, &attrs->ia_iattr);
 		security_inode_notifysecctx(inode, attrs->ia_secdata,
 					    attrs->ia_secdata_len);
 	}
 
-	if (sysfs_type(sd) == SYSFS_DIR)
-		set_nlink(inode, sd->s_dir.subdirs + 2);
+	if (sysfs_type(kn) == SYSFS_DIR)
+		set_nlink(inode, kn->s_dir.subdirs + 2);
 }
 
 int sysfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 		  struct kstat *stat)
 {
-	struct sysfs_dirent *sd = dentry->d_fsdata;
+	struct kernfs_node *kn = dentry->d_fsdata;
 	struct inode *inode = dentry->d_inode;
 
 	mutex_lock(&sysfs_mutex);
-	sysfs_refresh_inode(sd, inode);
+	sysfs_refresh_inode(kn, inode);
 	mutex_unlock(&sysfs_mutex);
 
 	generic_fillattr(inode, stat);
 	return 0;
 }
 
-static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
+static void sysfs_init_inode(struct kernfs_node *kn, struct inode *inode)
 {
-	kernfs_get(sd);
-	inode->i_private = sd;
+	kernfs_get(kn);
+	inode->i_private = kn;
 	inode->i_mapping->a_ops = &sysfs_aops;
 	inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
 	inode->i_op = &sysfs_inode_operations;
 
-	set_default_inode_attr(inode, sd->s_mode);
-	sysfs_refresh_inode(sd, inode);
+	set_default_inode_attr(inode, kn->s_mode);
+	sysfs_refresh_inode(kn, inode);
 
 	/* initialize inode according to type */
-	switch (sysfs_type(sd)) {
+	switch (sysfs_type(kn)) {
 	case SYSFS_DIR:
 		inode->i_op = &sysfs_dir_inode_operations;
 		inode->i_fop = &sysfs_dir_operations;
 		break;
 	case SYSFS_KOBJ_ATTR:
-		inode->i_size = sd->s_attr.size;
+		inode->i_size = kn->s_attr.size;
 		inode->i_fop = &kernfs_file_operations;
 		break;
 	case SYSFS_KOBJ_LINK:
@@ -318,13 +319,13 @@
 }
 
 /**
- *	sysfs_get_inode - get inode for sysfs_dirent
+ *	sysfs_get_inode - get inode for kernfs_node
  *	@sb: super block
- *	@sd: sysfs_dirent to allocate inode for
+ *	@kn: kernfs_node to allocate inode for
  *
- *	Get inode for @sd.  If such inode doesn't exist, a new inode
- *	is allocated and basics are initialized.  New inode is
- *	returned locked.
+ *	Get inode for @kn.  If such inode doesn't exist, a new inode is
+ *	allocated and basics are initialized.  New inode is returned
+ *	locked.
  *
  *	LOCKING:
  *	Kernel thread context (may sleep).
@@ -332,44 +333,44 @@
  *	RETURNS:
  *	Pointer to allocated inode on success, NULL on failure.
  */
-struct inode *sysfs_get_inode(struct super_block *sb, struct sysfs_dirent *sd)
+struct inode *sysfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
 {
 	struct inode *inode;
 
-	inode = iget_locked(sb, sd->s_ino);
+	inode = iget_locked(sb, kn->s_ino);
 	if (inode && (inode->i_state & I_NEW))
-		sysfs_init_inode(sd, inode);
+		sysfs_init_inode(kn, inode);
 
 	return inode;
 }
 
 /*
- * The sysfs_dirent serves as both an inode and a directory entry for sysfs.
- * To prevent the sysfs inode numbers from being freed prematurely we take a
- * reference to sysfs_dirent from the sysfs inode.  A
+ * The kernfs_node serves as both an inode and a directory entry for sysfs.
+ * To prevent the sysfs inode numbers from being freed prematurely we take
+ * a reference to kernfs_node from the sysfs inode.  A
  * super_operations.evict_inode() implementation is needed to drop that
  * reference upon inode destruction.
  */
 void sysfs_evict_inode(struct inode *inode)
 {
-	struct sysfs_dirent *sd  = inode->i_private;
+	struct kernfs_node *kn = inode->i_private;
 
 	truncate_inode_pages(&inode->i_data, 0);
 	clear_inode(inode);
-	kernfs_put(sd);
+	kernfs_put(kn);
 }
 
 int sysfs_permission(struct inode *inode, int mask)
 {
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 
 	if (mask & MAY_NOT_BLOCK)
 		return -ECHILD;
 
-	sd = inode->i_private;
+	kn = inode->i_private;
 
 	mutex_lock(&sysfs_mutex);
-	sysfs_refresh_inode(sd, inode);
+	sysfs_refresh_inode(kn, inode);
 	mutex_unlock(&sysfs_mutex);
 
 	return generic_permission(inode, mask);
diff --git a/fs/kernfs/kernfs-internal.h b/fs/kernfs/kernfs-internal.h
index 910e485..b7ea76c 100644
--- a/fs/kernfs/kernfs-internal.h
+++ b/fs/kernfs/kernfs-internal.h
@@ -31,24 +31,24 @@
 /* SYSFS_TYPE_MASK and types are defined in include/linux/kernfs.h */
 
 /**
- * kernfs_root - find out the kernfs_root a sysfs_dirent belongs to
- * @sd: sysfs_dirent of interest
+ * kernfs_root - find out the kernfs_root a kernfs_node belongs to
+ * @kn: kernfs_node of interest
  *
- * Return the kernfs_root @sd belongs to.
+ * Return the kernfs_root @kn belongs to.
  */
-static inline struct kernfs_root *kernfs_root(struct sysfs_dirent *sd)
+static inline struct kernfs_root *kernfs_root(struct kernfs_node *kn)
 {
 	/* if parent exists, it's always a dir; otherwise, @sd is a dir */
-	if (sd->s_parent)
-		sd = sd->s_parent;
-	return sd->s_dir.root;
+	if (kn->s_parent)
+		kn = kn->s_parent;
+	return kn->s_dir.root;
 }
 
 /*
  * Context structure to be used while adding/removing nodes.
  */
 struct sysfs_addrm_cxt {
-	struct sysfs_dirent	*removed;
+	struct kernfs_node	*removed;
 };
 
 /*
@@ -62,10 +62,10 @@
 	struct kernfs_root	*root;
 
 	/*
-	 * Each sb is associated with one namespace tag, currently the network
-	 * namespace of the task which mounted this sysfs instance.  If multiple
-	 * tags become necessary, make the following an array and compare
-	 * sysfs_dirent tag against every entry.
+	 * Each sb is associated with one namespace tag, currently the
+	 * network namespace of the task which mounted this sysfs instance.
+	 * If multiple tags become necessary, make the following an array
+	 * and compare kernfs_node tag against every entry.
 	 */
 	const void		*ns;
 };
@@ -76,7 +76,7 @@
 /*
  * inode.c
  */
-struct inode *sysfs_get_inode(struct super_block *sb, struct sysfs_dirent *sd);
+struct inode *sysfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
 void sysfs_evict_inode(struct inode *inode);
 int sysfs_permission(struct inode *inode, int mask);
 int sysfs_setattr(struct dentry *dentry, struct iattr *iattr);
@@ -98,21 +98,21 @@
 extern const struct file_operations sysfs_dir_operations;
 extern const struct inode_operations sysfs_dir_inode_operations;
 
-struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd);
-void sysfs_put_active(struct sysfs_dirent *sd);
+struct kernfs_node *sysfs_get_active(struct kernfs_node *kn);
+void sysfs_put_active(struct kernfs_node *kn);
 void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt);
-int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd,
-		  struct sysfs_dirent *parent_sd);
+int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct kernfs_node *kn,
+		  struct kernfs_node *parent);
 void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt);
-struct sysfs_dirent *sysfs_new_dirent(struct kernfs_root *root,
-				      const char *name, umode_t mode, int type);
+struct kernfs_node *sysfs_new_dirent(struct kernfs_root *root,
+				     const char *name, umode_t mode, int type);
 
 /*
  * file.c
  */
 extern const struct file_operations kernfs_file_operations;
 
-void sysfs_unmap_bin_file(struct sysfs_dirent *sd);
+void sysfs_unmap_bin_file(struct kernfs_node *kn);
 
 /*
  * symlink.c
diff --git a/fs/kernfs/mount.c b/fs/kernfs/mount.c
index 84c83e2..9dbbf37 100644
--- a/fs/kernfs/mount.c
+++ b/fs/kernfs/mount.c
@@ -39,7 +39,7 @@
 
 	/* get root inode, initialize and unlock it */
 	mutex_lock(&sysfs_mutex);
-	inode = sysfs_get_inode(sb, info->root->sd);
+	inode = sysfs_get_inode(sb, info->root->kn);
 	mutex_unlock(&sysfs_mutex);
 	if (!inode) {
 		pr_debug("sysfs: could not get root inode\n");
@@ -52,8 +52,8 @@
 		pr_debug("%s: could not get root dentry!\n", __func__);
 		return -ENOMEM;
 	}
-	kernfs_get(info->root->sd);
-	root->d_fsdata = info->root->sd;
+	kernfs_get(info->root->kn);
+	root->d_fsdata = info->root->kn;
 	sb->s_root = root;
 	sb->s_d_op = &sysfs_dentry_ops;
 	return 0;
@@ -145,7 +145,7 @@
 void kernfs_kill_sb(struct super_block *sb)
 {
 	struct sysfs_super_info *info = sysfs_info(sb);
-	struct sysfs_dirent *root_sd = sb->s_root->d_fsdata;
+	struct kernfs_node *root_kn = sb->s_root->d_fsdata;
 
 	/*
 	 * Remove the superblock from fs_supers/s_instances
@@ -153,13 +153,13 @@
 	 */
 	kill_anon_super(sb);
 	kfree(info);
-	kernfs_put(root_sd);
+	kernfs_put(root_kn);
 }
 
 void __init kernfs_init(void)
 {
 	sysfs_dir_cachep = kmem_cache_create("sysfs_dir_cache",
-					      sizeof(struct sysfs_dirent),
+					      sizeof(struct kernfs_node),
 					      0, SLAB_PANIC, NULL);
 	sysfs_inode_init();
 }
diff --git a/fs/kernfs/symlink.c b/fs/kernfs/symlink.c
index adf2875..29dcf5e 100644
--- a/fs/kernfs/symlink.c
+++ b/fs/kernfs/symlink.c
@@ -22,50 +22,50 @@
  *
  * Returns the created node on success, ERR_PTR() value on error.
  */
-struct sysfs_dirent *kernfs_create_link(struct sysfs_dirent *parent,
-					const char *name,
-					struct sysfs_dirent *target)
+struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
+				       const char *name,
+				       struct kernfs_node *target)
 {
-	struct sysfs_dirent *sd;
+	struct kernfs_node *kn;
 	struct sysfs_addrm_cxt acxt;
 	int error;
 
-	sd = sysfs_new_dirent(kernfs_root(parent), name, S_IFLNK|S_IRWXUGO,
+	kn = sysfs_new_dirent(kernfs_root(parent), name, S_IFLNK|S_IRWXUGO,
 			      SYSFS_KOBJ_LINK);
-	if (!sd)
+	if (!kn)
 		return ERR_PTR(-ENOMEM);
 
 	if (kernfs_ns_enabled(parent))
-		sd->s_ns = target->s_ns;
-	sd->s_symlink.target_sd = target;
+		kn->s_ns = target->s_ns;
+	kn->s_symlink.target_kn = target;
 	kernfs_get(target);	/* ref owned by symlink */
 
 	sysfs_addrm_start(&acxt);
-	error = sysfs_add_one(&acxt, sd, parent);
+	error = sysfs_add_one(&acxt, kn, parent);
 	sysfs_addrm_finish(&acxt);
 
 	if (!error)
-		return sd;
+		return kn;
 
-	kernfs_put(sd);
+	kernfs_put(kn);
 	return ERR_PTR(error);
 }
 
-static int sysfs_get_target_path(struct sysfs_dirent *parent_sd,
-				 struct sysfs_dirent *target_sd, char *path)
+static int sysfs_get_target_path(struct kernfs_node *parent,
+				 struct kernfs_node *target, char *path)
 {
-	struct sysfs_dirent *base, *sd;
+	struct kernfs_node *base, *kn;
 	char *s = path;
 	int len = 0;
 
 	/* go up to the root, stop at the base */
-	base = parent_sd;
+	base = parent;
 	while (base->s_parent) {
-		sd = target_sd->s_parent;
-		while (sd->s_parent && base != sd)
-			sd = sd->s_parent;
+		kn = target->s_parent;
+		while (kn->s_parent && base != kn)
+			kn = kn->s_parent;
 
-		if (base == sd)
+		if (base == kn)
 			break;
 
 		strcpy(s, "../");
@@ -74,10 +74,10 @@
 	}
 
 	/* determine end of target string for reverse fillup */
-	sd = target_sd;
-	while (sd->s_parent && sd != base) {
-		len += strlen(sd->s_name) + 1;
-		sd = sd->s_parent;
+	kn = target;
+	while (kn->s_parent && kn != base) {
+		len += strlen(kn->s_name) + 1;
+		kn = kn->s_parent;
 	}
 
 	/* check limits */
@@ -88,16 +88,16 @@
 		return -ENAMETOOLONG;
 
 	/* reverse fillup of target string from target to base */
-	sd = target_sd;
-	while (sd->s_parent && sd != base) {
-		int slen = strlen(sd->s_name);
+	kn = target;
+	while (kn->s_parent && kn != base) {
+		int slen = strlen(kn->s_name);
 
 		len -= slen;
-		strncpy(s + len, sd->s_name, slen);
+		strncpy(s + len, kn->s_name, slen);
 		if (len)
 			s[--len] = '/';
 
-		sd = sd->s_parent;
+		kn = kn->s_parent;
 	}
 
 	return 0;
@@ -105,13 +105,13 @@
 
 static int sysfs_getlink(struct dentry *dentry, char *path)
 {
-	struct sysfs_dirent *sd = dentry->d_fsdata;
-	struct sysfs_dirent *parent_sd = sd->s_parent;
-	struct sysfs_dirent *target_sd = sd->s_symlink.target_sd;
+	struct kernfs_node *kn = dentry->d_fsdata;
+	struct kernfs_node *parent = kn->s_parent;
+	struct kernfs_node *target = kn->s_symlink.target_kn;
 	int error;
 
 	mutex_lock(&sysfs_mutex);
-	error = sysfs_get_target_path(parent_sd, target_sd, path);
+	error = sysfs_get_target_path(parent, target, path);
 	mutex_unlock(&sysfs_mutex);
 
 	return error;