kernfs: combine ino/id lookup functions into kernfs_find_and_get_node_by_id()

kernfs_find_and_get_node_by_ino() looks the kernfs_node matching the
specified ino.  On top of that, kernfs_get_node_by_id() and
kernfs_fh_get_inode() implement full ID matching by testing the rest
of ID.

On surface, confusingly, the two are slightly different in that the
latter uses 0 gen as wildcard while the former doesn't - does it mean
that the latter can't uniquely identify inodes w/ 0 gen?  In practice,
this is a distinction without a difference because generation number
starts at 1.  There are no actual IDs with 0 gen, so it can always
safely used as wildcard.

Let's simplify the code by renaming kernfs_find_and_get_node_by_ino()
to kernfs_find_and_get_node_by_id(), moving all lookup logics into it,
and removing now unnecessary kernfs_get_node_by_id().

Signed-off-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/fs/kernfs/dir.c b/fs/kernfs/dir.c
index c67afb591e5b58867122eddf9c20853243471a92..5dcf19d4adbcf5dbb21f23e2d02e5b210f4ca97e 100644 (file)
--- a/fs/kernfs/dir.c
+++ b/fs/kernfs/dir.c
@@ -696,17 +696,22 @@ struct kernfs_node *kernfs_new_node(struct kernfs_node *parent,
 }
 
 /*
- * kernfs_find_and_get_node_by_ino - get kernfs_node from inode number
+ * kernfs_find_and_get_node_by_id - get kernfs_node from node id
  * @root: the kernfs root
- * @ino: inode number
+ * @id: the target node id
+ *
+ * @id's lower 32bits encode ino and upper gen.  If the gen portion is
+ * zero, all generations are matched.
  *
  * RETURNS:
  * NULL on failure. Return a kernfs node with reference counter incremented
  */
-struct kernfs_node *kernfs_find_and_get_node_by_ino(struct kernfs_root *root,
-                                                   unsigned int ino)
+struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root,
+                                                  u64 id)
 {
        struct kernfs_node *kn;
+       ino_t ino = kernfs_id_ino(id);
+       u32 gen = kernfs_id_gen(id);
 
        spin_lock(&kernfs_idr_lock);
 
@@ -714,6 +719,10 @@ struct kernfs_node *kernfs_find_and_get_node_by_ino(struct kernfs_root *root,
        if (!kn)
                goto err_unlock;
 
+       /* 0 matches all generations */
+       if (unlikely(gen && kernfs_gen(kn) != gen))
+               goto err_unlock;
+
        /*
         * ACTIVATED is protected with kernfs_mutex but it was clear when
         * @kn was added to idr and we just wanna see it set.  No need to

diff --git a/fs/kernfs/kernfs-internal.h b/fs/kernfs/kernfs-internal.h
index 02ce570a9a3c7a4c2930d8cbefe332b435de7814..2f3c51d5526103cf982d1f0ac8a5c9c4fecabe50 100644 (file)
--- a/fs/kernfs/kernfs-internal.h
+++ b/fs/kernfs/kernfs-internal.h
@@ -109,8 +109,6 @@ struct kernfs_node *kernfs_new_node(struct kernfs_node *parent,
                                    const char *name, umode_t mode,
                                    kuid_t uid, kgid_t gid,
                                    unsigned flags);
-struct kernfs_node *kernfs_find_and_get_node_by_ino(struct kernfs_root *root,
-                                                   unsigned int ino);
 
 /*
  * file.c

diff --git a/fs/kernfs/mount.c b/fs/kernfs/mount.c
index f05d5d6f926da9bd89ceca8b8262cab255bad902..8aed2cccd002d6042f3b183266a4a95b31780bee 100644 (file)
--- a/fs/kernfs/mount.c
+++ b/fs/kernfs/mount.c
@@ -53,24 +53,6 @@ const struct super_operations kernfs_sops = {
        .show_path      = kernfs_sop_show_path,
 };
 
-/*
- * Similar to kernfs_fh_get_inode, this one gets kernfs node from inode
- * number and generation
- */
-struct kernfs_node *kernfs_get_node_by_id(struct kernfs_root *root, u64 id)
-{
-       struct kernfs_node *kn;
-
-       kn = kernfs_find_and_get_node_by_ino(root, kernfs_id_ino(id));
-       if (!kn)
-               return NULL;
-       if (kernfs_gen(kn) != kernfs_id_gen(id)) {
-               kernfs_put(kn);
-               return NULL;
-       }
-       return kn;
-}
-
 static struct inode *kernfs_fh_get_inode(struct super_block *sb,
                u64 ino, u32 generation)
 {
@@ -81,7 +63,8 @@ static struct inode *kernfs_fh_get_inode(struct super_block *sb,
        if (ino == 0)
                return ERR_PTR(-ESTALE);
 
-       kn = kernfs_find_and_get_node_by_ino(info->root, ino);
+       kn = kernfs_find_and_get_node_by_id(info->root,
+                                           ino | ((u64)generation << 32));
        if (!kn)
                return ERR_PTR(-ESTALE);
        inode = kernfs_get_inode(sb, kn);
@@ -89,11 +72,6 @@ static struct inode *kernfs_fh_get_inode(struct super_block *sb,
        if (!inode)
                return ERR_PTR(-ESTALE);
 
-       if (generation && inode->i_generation != generation) {
-               /* we didn't find the right inode.. */
-               iput(inode);
-               return ERR_PTR(-ESTALE);
-       }
        return inode;
 }
 

diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index b2fc5c8ef6d962e57c51b0294977cbe031a3966a..38267cc9420c6d8ab3a5b87fac2b4cf81d1923a2 100644 (file)
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -393,7 +393,8 @@ void kernfs_kill_sb(struct super_block *sb);
 
 void kernfs_init(void);
 
-struct kernfs_node *kernfs_get_node_by_id(struct kernfs_root *root, u64 id);
+struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root,
+                                                  u64 id);
 #else  /* CONFIG_KERNFS */
 
 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)

diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c
index c6bd1a5a1977140f17c62f6a60b25b480a4d3973..b5dcbee5aa6c813423e88b7c64fbd8a53adad52c 100644 (file)
--- a/kernel/cgroup/cgroup.c
+++ b/kernel/cgroup/cgroup.c
@@ -5790,7 +5790,7 @@ void cgroup_path_from_kernfs_id(u64 id, char *buf, size_t buflen)
 {
        struct kernfs_node *kn;
 
-       kn = kernfs_get_node_by_id(cgrp_dfl_root.kf_root, id);
+       kn = kernfs_find_and_get_node_by_id(cgrp_dfl_root.kf_root, id);
        if (!kn)
                return;
        kernfs_path(kn, buf, buflen);