add a string-to-qstr constructor

Quite a few places want to build a struct qstr by given string;
it would be convenient to have a primitive doing that, rather
than open-coding it via QSTR_INIT().

The closest approximation was in bcachefs, but that expands to
initializer list - {.len = strlen(string), .name = string}.
It would be more useful to have it as compound literal -
(struct qstr){.len = strlen(string), .name = string}.

Unlike initializer list it's a valid expression.  What's more,
it's a valid lvalue - it's an equivalent of anonymous local
variable with such initializer, so the things like
	path->dentry = d_alloc_pseudo(mnt->mnt_sb, &QSTR(name));
are valid.  It can also be used as initializer, with identical
effect -
	struct qstr x = (struct qstr){.name = s, .len = strlen(s)};
is equivalent to
	struct qstr anon_variable = {.name = s, .len = strlen(s)};
	struct qstr x = anon_variable;
	// anon_variable is never used after that point
and any even remotely sane compiler will manage to collapse that
into
	struct qstr x = {.name = s, .len = strlen(s)};

What compound literals can't be used for is initialization of
global variables, but those are covered by QSTR_INIT().

This commit lifts definition(s) of QSTR() into linux/dcache.h,
converts it to compound literal (all bcachefs users are fine
with that) and converts assorted open-coded instances to using
that.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/anon_inodes.c b/fs/anon_inodes.c
index 42bd1cb7c9cdd4af9db8617d8fbc7f7b8aa254a8..583ac81669c249bd8fe06b9b068857dec64f1da4 100644 (file)
--- a/fs/anon_inodes.c
+++ b/fs/anon_inodes.c
@@ -60,14 +60,14 @@ static struct inode *anon_inode_make_secure_inode(
        const struct inode *context_inode)
 {
        struct inode *inode;
-       const struct qstr qname = QSTR_INIT(name, strlen(name));
        int error;
 
        inode = alloc_anon_inode(anon_inode_mnt->mnt_sb);
        if (IS_ERR(inode))
                return inode;
        inode->i_flags &= ~S_PRIVATE;
-       error = security_inode_init_security_anon(inode, &qname, context_inode);
+       error = security_inode_init_security_anon(inode, &QSTR(name),
+                                                 context_inode);
        if (error) {
                iput(inode);
                return ERR_PTR(error);

diff --git a/fs/bcachefs/fsck.c b/fs/bcachefs/fsck.c
index 75c8a97a6954c6a91f8a6b9d6d28f181ac69c8e4..7b3b63ed747cf5df79765f9010655d60bccf0cf6 100644 (file)
--- a/fs/bcachefs/fsck.c
+++ b/fs/bcachefs/fsck.c
@@ -405,7 +405,7 @@ static int reattach_inode(struct btree_trans *trans, struct bch_inode_unpacked *
                return ret;
 
        struct bch_hash_info dir_hash = bch2_hash_info_init(c, &lostfound);
-       struct qstr name = (struct qstr) QSTR(name_buf);
+       struct qstr name = QSTR(name_buf);
 
        inode->bi_dir = lostfound.bi_inum;
 

diff --git a/fs/bcachefs/recovery.c b/fs/bcachefs/recovery.c
index 3c7f941dde39ad5fc934c57ff099865a394b0112..ebabba2968821bafada65079392ab86378cc5682 100644 (file)
--- a/fs/bcachefs/recovery.c
+++ b/fs/bcachefs/recovery.c
@@ -32,8 +32,6 @@
 #include <linux/sort.h>
 #include <linux/stat.h>
 
-#define QSTR(n) { { { .len = strlen(n) } }, .name = n }
-
 void bch2_btree_lost_data(struct bch_fs *c, enum btree_id btree)
 {
        if (btree >= BTREE_ID_NR_MAX)

diff --git a/fs/bcachefs/util.h b/fs/bcachefs/util.h
index fb02c1c360044352205572a4970c237239d9848b..a27f4b84fe775292b218ad60036c86debd2afa57 100644 (file)
--- a/fs/bcachefs/util.h
+++ b/fs/bcachefs/util.h
@@ -647,8 +647,6 @@ static inline int cmp_le32(__le32 l, __le32 r)
 
 #include <linux/uuid.h>
 
-#define QSTR(n) { { { .len = strlen(n) } }, .name = n }
-
 static inline bool qstr_eq(const struct qstr l, const struct qstr r)
 {
        return l.len == r.len && !memcmp(l.name, r.name, l.len);

diff --git a/fs/erofs/xattr.c b/fs/erofs/xattr.c
index a90d7d649739051db77fb543cd69090512535346..60d2cf26e837e259c5078890327aedc95513f5b7 100644 (file)
--- a/fs/erofs/xattr.c
+++ b/fs/erofs/xattr.c
@@ -407,7 +407,7 @@ int erofs_getxattr(struct inode *inode, int index, const char *name,
        }
 
        it.index = index;
-       it.name = (struct qstr)QSTR_INIT(name, strlen(name));
+       it.name = QSTR(name);
        if (it.name.len > EROFS_NAME_LEN)
                return -ERANGE;
 

diff --git a/fs/file_table.c b/fs/file_table.c
index 976736be47cb66197292b50458f84a7034cdaea6..a329623d0b421174d46c9508bb87d0b8a4884594 100644 (file)
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -351,9 +351,7 @@ static struct file *alloc_file(const struct path *path, int flags,
 static inline int alloc_path_pseudo(const char *name, struct inode *inode,
                                    struct vfsmount *mnt, struct path *path)
 {
-       struct qstr this = QSTR_INIT(name, strlen(name));
-
-       path->dentry = d_alloc_pseudo(mnt->mnt_sb, &this);
+       path->dentry = d_alloc_pseudo(mnt->mnt_sb, &QSTR(name));
        if (!path->dentry)
                return -ENOMEM;
        path->mnt = mntget(mnt);

diff --git a/fs/kernfs/file.c b/fs/kernfs/file.c
index 8502ef68459b9842d090a4ac338591778d1b3b24..0eb320617d7b18e3a8a44168fe93c7da2bbcb1f3 100644 (file)
--- a/fs/kernfs/file.c
+++ b/fs/kernfs/file.c
@@ -927,7 +927,7 @@ repeat:
                if (!inode)
                        continue;
 
-               name = (struct qstr)QSTR_INIT(kn->name, strlen(kn->name));
+               name = QSTR(kn->name);
                parent = kernfs_get_parent(kn);
                if (parent) {
                        p_inode = ilookup(info->sb, kernfs_ino(parent));

diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index bff956f7b2b984b2c7ca17728ea2cbeb6347e7d5..3d53a60145911ea1fb3d8427ace62bf4905f17ff 100644 (file)
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -57,6 +57,7 @@ struct qstr {
 };
 
 #define QSTR_INIT(n,l) { { { .len = l } }, .name = n }
+#define QSTR(n) (struct qstr)QSTR_INIT(n, strlen(n))
 
 extern const struct qstr empty_name;
 extern const struct qstr slash_name;

diff --git a/mm/secretmem.c b/mm/secretmem.c
index 399552814fd0ffaa00c598bb60f3203e5378c220..1b0a214ee5580e659148cb930d282bde4d19112b 100644 (file)
--- a/mm/secretmem.c
+++ b/mm/secretmem.c
@@ -195,14 +195,13 @@ static struct file *secretmem_file_create(unsigned long flags)
        struct file *file;
        struct inode *inode;
        const char *anon_name = "[secretmem]";
-       const struct qstr qname = QSTR_INIT(anon_name, strlen(anon_name));
        int err;
 
        inode = alloc_anon_inode(secretmem_mnt->mnt_sb);
        if (IS_ERR(inode))
                return ERR_CAST(inode);
 
-       err = security_inode_init_security_anon(inode, &qname, NULL);
+       err = security_inode_init_security_anon(inode, &QSTR(anon_name), NULL);
        if (err) {
                file = ERR_PTR(err);
                goto err_free_inode;

diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 7ce3721c06ca5b851c20e25d3ee1fcbf711b96bf..eadc00410ebc51c51774edab7dec8d64c08e4d79 100644 (file)
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -630,7 +630,7 @@ static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
 static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
                                          const char *name)
 {
-       struct qstr q = QSTR_INIT(name, strlen(name));
+       struct qstr q = QSTR(name);
        struct dentry *dentry = d_hash_and_lookup(parent, &q);
        if (!dentry) {
                dentry = d_alloc(parent, &q);
@@ -1190,8 +1190,7 @@ static const struct rpc_filelist files[] = {
 struct dentry *rpc_d_lookup_sb(const struct super_block *sb,
                               const unsigned char *dir_name)
 {
-       struct qstr dir = QSTR_INIT(dir_name, strlen(dir_name));
-       return d_hash_and_lookup(sb->s_root, &dir);
+       return d_hash_and_lookup(sb->s_root, &QSTR(dir_name));
 }
 EXPORT_SYMBOL_GPL(rpc_d_lookup_sb);
 
@@ -1300,11 +1299,9 @@ rpc_gssd_dummy_populate(struct dentry *root, struct rpc_pipe *pipe_data)
        struct dentry *gssd_dentry;
        struct dentry *clnt_dentry = NULL;
        struct dentry *pipe_dentry = NULL;
-       struct qstr q = QSTR_INIT(files[RPCAUTH_gssd].name,
-                                 strlen(files[RPCAUTH_gssd].name));
 
        /* We should never get this far if "gssd" doesn't exist */
-       gssd_dentry = d_hash_and_lookup(root, &q);
+       gssd_dentry = d_hash_and_lookup(root, &QSTR(files[RPCAUTH_gssd].name));
        if (!gssd_dentry)
                return ERR_PTR(-ENOENT);
 
@@ -1314,9 +1311,8 @@ rpc_gssd_dummy_populate(struct dentry *root, struct rpc_pipe *pipe_data)
                goto out;
        }
 
-       q.name = gssd_dummy_clnt_dir[0].name;
-       q.len = strlen(gssd_dummy_clnt_dir[0].name);
-       clnt_dentry = d_hash_and_lookup(gssd_dentry, &q);
+       clnt_dentry = d_hash_and_lookup(gssd_dentry,
+                                       &QSTR(gssd_dummy_clnt_dir[0].name));
        if (!clnt_dentry) {
                __rpc_depopulate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1);
                pipe_dentry = ERR_PTR(-ENOENT);