Re: [PATCH 4/6] VFS: rename lookup_one_len family to lookup_noperm and remove permission check

[Jeff Layton <jlayton@kernel.org>]

On Wed, 2025-03-19 at 14:01 +1100, NeilBrown wrote:
> The lookup_one_len family of functions is (now) only used internally by
> a filesystem on itself either
> - in a context where permission checking is irrelevant such as by a
>   virtual filesystem populating itself, or xfs accessing its ORPHANAGE
>   or dquota accessing the quota file; or
> - in a context where a permission check (MAY_EXEC on the parent) has just
>   been performed such as a network filesystem finding in "silly-rename"
>   file in the same directory.  This is also the context after the
>   _parentat() functions where currently lookup_one_qstr_excl() is used.
> 
> So the permission check is pointless.
> 
> The name "one_len" is unhelpful in understanding the purpose of these
> functions and should be changed.  Most of the callers pass the len as
> "strlen()" so using a qstr and QSTR() can simplify the code.
> 
> This patch renames these functions (include lookup_positive_unlocked()
> which is part of the family despite the name) to have a name based on
> "lookup_noperm".  They are changed to receive a 'struct qstr' instead
> of separate name and len.  In a few cases the use of QSTR() results in a
> new call to strlen().
> 
> try_lookup_noperm() takes a pointer to a qstr instead of the whole
> qstr.  This is consistent with d_hash_and_lookup() (which is nearly
> identical) and useful for lookup_noperm_unlocked().
> 
> The new lookup_noperm_common() doesn't take a qstr yet.  That will be
> tidied up in a subsequent patch.
> 
> Signed-off-by: NeilBrown <neil@brown.name>
> ---
>  Documentation/filesystems/porting.rst | 20 +++++++
>  arch/s390/hypfs/inode.c               |  2 +-
>  drivers/android/binderfs.c            |  4 +-
>  drivers/infiniband/hw/qib/qib_fs.c    |  4 +-
>  fs/afs/dir.c                          |  2 +-
>  fs/afs/dir_silly.c                    |  6 +-
>  fs/autofs/dev-ioctl.c                 |  3 +-
>  fs/binfmt_misc.c                      |  2 +-
>  fs/debugfs/inode.c                    |  6 +-
>  fs/ecryptfs/inode.c                   | 16 ++---
>  fs/kernfs/mount.c                     |  4 +-
>  fs/namei.c                            | 86 ++++++++++++++++-----------
>  fs/nfs/unlink.c                       | 11 ++--
>  fs/overlayfs/export.c                 |  6 +-
>  fs/overlayfs/namei.c                  |  2 +-
>  fs/quota/dquot.c                      |  2 +-
>  fs/smb/client/cached_dir.c            |  5 +-
>  fs/smb/client/cifsfs.c                |  3 +-
>  fs/tracefs/inode.c                    |  2 +-
>  fs/xfs/scrub/orphanage.c              |  3 +-
>  include/linux/namei.h                 |  8 +--
>  ipc/mqueue.c                          |  5 +-
>  kernel/bpf/inode.c                    |  2 +-
>  security/apparmor/apparmorfs.c        |  4 +-
>  security/inode.c                      |  2 +-
>  25 files changed, 123 insertions(+), 87 deletions(-)
> 
> diff --git a/Documentation/filesystems/porting.rst b/Documentation/filesystems/porting.rst
> index 06296ffd1e81..df9516cd82e0 100644
> --- a/Documentation/filesystems/porting.rst
> +++ b/Documentation/filesystems/porting.rst
> @@ -1205,3 +1205,23 @@ lookup_one(), lookup_one_unlocked(), lookup_one_positive_unlocked() now
>  take a qstr instead of a name and len.  These, not the "one_len"
>  versions, should be used whenever accessing a filesystem from outside
>  that filesysmtem, through a mount point - which will have a mnt_idmap.
> +
> +---
> +
> +** mandatory**
> +
> +Functions try_lookup_one_len(), lookup_one_len(),
> +lookup_one_len_unlocked() and lookup_positive_unlocked() have been
> +renamed to try_lookup_noperm(), lookup_noperm(),
> +lookup_noperm_unlocked(), lookup_noperm_positive_unlocked().  They now
> +take a qstr instead of separate name and length.  QSTR() can be used
> +when strlen() is needed for the length.
> +
> +For try_lookup_noperm() a reference to the qstr is passed in case the
> +hash might subsequently be needed.
> +
> +These function no longer do any permission checking - they previously
> +checked that the caller has 'X' permission on the parent.  They must
> +ONLY be used internally by a filesystem on itself when it knows that
> +permissions are irrelevant or in a context where permission checks have
> +already been performed such as after vfs_path_parent_lookup()
> diff --git a/arch/s390/hypfs/inode.c b/arch/s390/hypfs/inode.c
> index d428635abf08..2eed957393f4 100644
> --- a/arch/s390/hypfs/inode.c
> +++ b/arch/s390/hypfs/inode.c
> @@ -341,7 +341,7 @@ static struct dentry *hypfs_create_file(struct dentry *parent, const char *name,
>  	struct inode *inode;
>  
>  	inode_lock(d_inode(parent));
> -	dentry = lookup_one_len(name, parent, strlen(name));
> +	dentry = lookup_noperm(QSTR(name), parent);
>  	if (IS_ERR(dentry)) {
>  		dentry = ERR_PTR(-ENOMEM);
>  		goto fail;
> diff --git a/drivers/android/binderfs.c b/drivers/android/binderfs.c
> index bc6bae76ccaf..172e825168c8 100644
> --- a/drivers/android/binderfs.c
> +++ b/drivers/android/binderfs.c
> @@ -187,7 +187,7 @@ static int binderfs_binder_device_create(struct inode *ref_inode,
>  	inode_lock(d_inode(root));
>  
>  	/* look it up */
> -	dentry = lookup_one_len(name, root, name_len);
> +	dentry = lookup_noperm(QSTR(name), root);
>  	if (IS_ERR(dentry)) {
>  		inode_unlock(d_inode(root));
>  		ret = PTR_ERR(dentry);
> @@ -486,7 +486,7 @@ static struct dentry *binderfs_create_dentry(struct dentry *parent,
>  {
>  	struct dentry *dentry;
>  
> -	dentry = lookup_one_len(name, parent, strlen(name));
> +	dentry = lookup_noperm(QSTR(name), parent);
>  	if (IS_ERR(dentry))
>  		return dentry;
>  
> diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
> index b27791029fa9..c3aa40c3fb8f 100644
> --- a/drivers/infiniband/hw/qib/qib_fs.c
> +++ b/drivers/infiniband/hw/qib/qib_fs.c
> @@ -89,7 +89,7 @@ static int create_file(const char *name, umode_t mode,
>  	int error;
>  
>  	inode_lock(d_inode(parent));
> -	*dentry = lookup_one_len(name, parent, strlen(name));
> +	*dentry = lookup_noperm(QSTR(name), parent);
>  	if (!IS_ERR(*dentry))
>  		error = qibfs_mknod(d_inode(parent), *dentry,
>  				    mode, fops, data);
> @@ -432,7 +432,7 @@ static int remove_device_files(struct super_block *sb,
>  	char unit[10];
>  
>  	snprintf(unit, sizeof(unit), "%u", dd->unit);
> -	dir = lookup_one_len_unlocked(unit, sb->s_root, strlen(unit));
> +	dir = lookup_noperm_unlocked(QSTR(unit), sb->s_root);
>  
>  	if (IS_ERR(dir)) {
>  		pr_err("Lookup of %s failed\n", unit);
> diff --git a/fs/afs/dir.c b/fs/afs/dir.c
> index 5bddcc20786e..0e633535d2c7 100644
> --- a/fs/afs/dir.c
> +++ b/fs/afs/dir.c
> @@ -943,7 +943,7 @@ static struct dentry *afs_lookup_atsys(struct inode *dir, struct dentry *dentry)
>  		}
>  
>  		strcpy(p, name);
> -		ret = lookup_one_len(buf, dentry->d_parent, len);
> +		ret = lookup_noperm(QSTR(buf), dentry->d_parent);
>  		if (IS_ERR(ret) || d_is_positive(ret))
>  			goto out_s;
>  		dput(ret);
> diff --git a/fs/afs/dir_silly.c b/fs/afs/dir_silly.c
> index a1e581946b93..292a5c8c752a 100644
> --- a/fs/afs/dir_silly.c
> +++ b/fs/afs/dir_silly.c
> @@ -113,16 +113,14 @@ int afs_sillyrename(struct afs_vnode *dvnode, struct afs_vnode *vnode,
>  
>  	sdentry = NULL;
>  	do {
> -		int slen;
> -
>  		dput(sdentry);
>  		sillycounter++;
>  
>  		/* Create a silly name.  Note that the ".__afs" prefix is
>  		 * understood by the salvager and must not be changed.
>  		 */
> -		slen = scnprintf(silly, sizeof(silly), ".__afs%04X", sillycounter);
> -		sdentry = lookup_one_len(silly, dentry->d_parent, slen);
> +		scnprintf(silly, sizeof(silly), ".__afs%04X", sillycounter);
> +		sdentry = lookup_noperm(QSTR(silly), dentry->d_parent);
>  
>  		/* N.B. Better to return EBUSY here ... it could be dangerous
>  		 * to delete the file while it's in use.
> diff --git a/fs/autofs/dev-ioctl.c b/fs/autofs/dev-ioctl.c
> index 6d57efbb8110..a577b175c38a 100644
> --- a/fs/autofs/dev-ioctl.c
> +++ b/fs/autofs/dev-ioctl.c
> @@ -461,7 +461,8 @@ static int autofs_dev_ioctl_timeout(struct file *fp,
>  				"prevent shutdown\n");
>  
>  		inode_lock_shared(inode);
> -		dentry = try_lookup_one_len(param->path, base, path_len);
> +		dentry = try_lookup_noperm(&QSTR_LEN(param->path, path_len),
> +					   base);
>  		inode_unlock_shared(inode);
>  		if (IS_ERR_OR_NULL(dentry))
>  			return dentry ? PTR_ERR(dentry) : -ENOENT;
> diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
> index 5a7ebd160724..f0996a76ee7c 100644
> --- a/fs/binfmt_misc.c
> +++ b/fs/binfmt_misc.c
> @@ -842,7 +842,7 @@ static ssize_t bm_register_write(struct file *file, const char __user *buffer,
>  	}
>  
>  	inode_lock(d_inode(root));
> -	dentry = lookup_one_len(e->name, root, strlen(e->name));
> +	dentry = lookup_noperm(QSTR(e->name), root);
>  	err = PTR_ERR(dentry);
>  	if (IS_ERR(dentry))
>  		goto out;
> diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
> index 75715d8877ee..feb5ccb5bba8 100644
> --- a/fs/debugfs/inode.c
> +++ b/fs/debugfs/inode.c
> @@ -346,7 +346,7 @@ struct dentry *debugfs_lookup(const char *name, struct dentry *parent)
>  	if (!parent)
>  		parent = debugfs_mount->mnt_root;
>  
> -	dentry = lookup_positive_unlocked(name, parent, strlen(name));
> +	dentry = lookup_noperm_positive_unlocked(QSTR(name), parent);
>  	if (IS_ERR(dentry))
>  		return NULL;
>  	return dentry;
> @@ -388,7 +388,7 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
>  	if (unlikely(IS_DEADDIR(d_inode(parent))))
>  		dentry = ERR_PTR(-ENOENT);
>  	else
> -		dentry = lookup_one_len(name, parent, strlen(name));
> +		dentry = lookup_noperm(QSTR(name), parent);
>  	if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
>  		if (d_is_dir(dentry))
>  			pr_err("Directory '%s' with parent '%s' already present!\n",
> @@ -872,7 +872,7 @@ int __printf(2, 3) debugfs_change_name(struct dentry *dentry, const char *fmt, .
>  	}
>  	if (strcmp(old_name.name.name, new_name) == 0)
>  		goto out;
> -	target = lookup_one_len(new_name, parent, strlen(new_name));
> +	target = lookup_noperm(QSTR(new_name), parent);
>  	if (IS_ERR(target)) {
>  		error = PTR_ERR(target);
>  		goto out;
> diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
> index 51a5c54eb740..9a0d40bb43d6 100644
> --- a/fs/ecryptfs/inode.c
> +++ b/fs/ecryptfs/inode.c
> @@ -394,8 +394,8 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
>  	char *encrypted_and_encoded_name = NULL;
>  	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
>  	struct dentry *lower_dir_dentry, *lower_dentry;
> -	const char *name = ecryptfs_dentry->d_name.name;
> -	size_t len = ecryptfs_dentry->d_name.len;
> +	struct qstr qname = QSTR_INIT(ecryptfs_dentry->d_name.name,
> +				      ecryptfs_dentry->d_name.len);
>  	struct dentry *res;
>  	int rc = 0;
>  
> @@ -404,23 +404,25 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
>  	mount_crypt_stat = &ecryptfs_superblock_to_private(
>  				ecryptfs_dentry->d_sb)->mount_crypt_stat;
>  	if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
> +		size_t len = qname.len;
>  		rc = ecryptfs_encrypt_and_encode_filename(
>  			&encrypted_and_encoded_name, &len,
> -			mount_crypt_stat, name, len);
> +			mount_crypt_stat, qname.name, len);
>  		if (rc) {
>  			printk(KERN_ERR "%s: Error attempting to encrypt and encode "
>  			       "filename; rc = [%d]\n", __func__, rc);
>  			return ERR_PTR(rc);
>  		}
> -		name = encrypted_and_encoded_name;
> +		qname.name = encrypted_and_encoded_name;
> +		qname.len = len;
>  	}
>  
> -	lower_dentry = lookup_one_len_unlocked(name, lower_dir_dentry, len);
> +	lower_dentry = lookup_noperm_unlocked(qname, lower_dir_dentry);
>  	if (IS_ERR(lower_dentry)) {
> -		ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
> +		ecryptfs_printk(KERN_DEBUG, "%s: lookup_noperm() returned "
>  				"[%ld] on lower_dentry = [%s]\n", __func__,
>  				PTR_ERR(lower_dentry),
> -				name);
> +				qname.name);
>  		res = ERR_CAST(lower_dentry);
>  	} else {
>  		res = ecryptfs_lookup_interpose(ecryptfs_dentry, lower_dentry);
> diff --git a/fs/kernfs/mount.c b/fs/kernfs/mount.c
> index 1358c21837f1..46943a7fb4df 100644
> --- a/fs/kernfs/mount.c
> +++ b/fs/kernfs/mount.c
> @@ -233,8 +233,8 @@ struct dentry *kernfs_node_dentry(struct kernfs_node *kn,
>  			dput(dentry);
>  			return ERR_PTR(-EINVAL);
>  		}
> -		dtmp = lookup_positive_unlocked(kntmp->name, dentry,
> -					       strlen(kntmp->name));
> +		dtmp = lookup_noperm_positive_unlocked(QSTR(kntmp->name),
> +							 dentry);
>  		dput(dentry);
>  		if (IS_ERR(dtmp))
>  			return dtmp;
> diff --git a/fs/namei.c b/fs/namei.c
> index 75816fa80028..16605f7108c0 100644
> --- a/fs/namei.c
> +++ b/fs/namei.c
> @@ -2833,9 +2833,9 @@ int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
>  }
>  EXPORT_SYMBOL(vfs_path_lookup);
>  
> -static int lookup_one_common(struct mnt_idmap *idmap,
> -			     const char *name, struct dentry *base, int len,
> -			     struct qstr *this)
> +static int lookup_noperm_common(const char *name, struct dentry *base,
> +				  int len,
> +				  struct qstr *this)
>  {
>  	this->name = name;
>  	this->len = len;
> @@ -2860,51 +2860,59 @@ static int lookup_one_common(struct mnt_idmap *idmap,
>  		if (err < 0)
>  			return err;
>  	}
> +	return 0;
> +}
>  
> +static int lookup_one_common(struct mnt_idmap *idmap,
> +			     const char *name, struct dentry *base, int len,
> +			     struct qstr *this) {
> +	int err;
> +	err = lookup_noperm_common(name, base, len, this);
> +	if (err < 0)
> +		return err;
>  	return inode_permission(idmap, base->d_inode, MAY_EXEC);
>  }
>  
>  /**
> - * try_lookup_one_len - filesystem helper to lookup single pathname component
> - * @name:	pathname component to lookup
> + * try_lookup_noperm - filesystem helper to lookup single pathname component
> + * @name:	qstr storing pathname component to lookup
>   * @base:	base directory to lookup from
> - * @len:	maximum length @len should be interpreted to
>   *
>   * Look up a dentry by name in the dcache, returning NULL if it does not
>   * currently exist.  The function does not try to create a dentry.
>   *
>   * Note that this routine is purely a helper for filesystem usage and should
> - * not be called by generic code.
> + * not be called by generic code.  It does no permission checking.
>   *
>   * The caller must hold base->i_mutex.
>   */
> -struct dentry *try_lookup_one_len(const char *name, struct dentry *base, int len)
> +struct dentry *try_lookup_noperm(struct qstr *name, struct dentry *base)
>  {
>  	struct qstr this;
>  	int err;
>  
>  	WARN_ON_ONCE(!inode_is_locked(base->d_inode));
>  
> -	err = lookup_one_common(&nop_mnt_idmap, name, base, len, &this);
> +	err = lookup_noperm_common(name->name, base, name->len, &this);
>  	if (err)
>  		return ERR_PTR(err);
>  
> -	return lookup_dcache(&this, base, 0);
> +	name->hash = this.hash;
> +	return lookup_dcache(name, base, 0);
>  }
> -EXPORT_SYMBOL(try_lookup_one_len);
> +EXPORT_SYMBOL(try_lookup_noperm);
>  
>  /**
> - * lookup_one_len - filesystem helper to lookup single pathname component
> - * @name:	pathname component to lookup
> + * lookup_noperm - filesystem helper to lookup single pathname component
> + * @name:	qstr storing pathname component to lookup
>   * @base:	base directory to lookup from
> - * @len:	maximum length @len should be interpreted to
>   *
>   * Note that this routine is purely a helper for filesystem usage and should
> - * not be called by generic code.
> + * not be called by generic code.  It does no permission checking.
>   *
>   * The caller must hold base->i_mutex.
>   */
> -struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
> +struct dentry *lookup_noperm(struct qstr name, struct dentry *base)
>  {
>  	struct dentry *dentry;
>  	struct qstr this;
> @@ -2912,14 +2920,14 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
>  
>  	WARN_ON_ONCE(!inode_is_locked(base->d_inode));
>  
> -	err = lookup_one_common(&nop_mnt_idmap, name, base, len, &this);
> +	err = lookup_noperm_common(name.name, base, name.len, &this);
>  	if (err)
>  		return ERR_PTR(err);
>  
>  	dentry = lookup_dcache(&this, base, 0);
>  	return dentry ? dentry : __lookup_slow(&this, base, 0);
>  }
> -EXPORT_SYMBOL(lookup_one_len);
> +EXPORT_SYMBOL(lookup_noperm);
>  
>  /**
>   * lookup_one - lookup single pathname component
> @@ -2957,7 +2965,7 @@ EXPORT_SYMBOL(lookup_one);
>   *
>   * This can be used for in-kernel filesystem clients such as file servers.
>   *
> - * Unlike lookup_one_len, it should be called without the parent
> + * Unlike lookup_one, it should be called without the parent
>   * i_rwsem held, and will take the i_rwsem itself if necessary.
>   */
>  struct dentry *lookup_one_unlocked(struct mnt_idmap *idmap,
> @@ -3010,39 +3018,49 @@ struct dentry *lookup_one_positive_unlocked(struct mnt_idmap *idmap,
>  EXPORT_SYMBOL(lookup_one_positive_unlocked);
>  
>  /**
> - * lookup_one_len_unlocked - filesystem helper to lookup single pathname component
> + * lookup_noperm_unlocked - filesystem helper to lookup single pathname component
>   * @name:	pathname component to lookup
>   * @base:	base directory to lookup from
>   * @len:	maximum length @len should be interpreted to
>   *
>   * Note that this routine is purely a helper for filesystem usage and should
> - * not be called by generic code.
> + * not be called by generic code. It does no permission checking.
>   *
> - * Unlike lookup_one_len, it should be called without the parent
> - * i_mutex held, and will take the i_mutex itself if necessary.
> + * Unlike lookup_noperm, it should be called without the parent
> + * i_rwsem held, and will take the i_rwsem itself if necessary.
>   */
> -struct dentry *lookup_one_len_unlocked(const char *name,
> -				       struct dentry *base, int len)
> +struct dentry *lookup_noperm_unlocked(struct qstr name,
> +					struct dentry *base)
>  {
> -	return lookup_one_unlocked(&nop_mnt_idmap, QSTR_LEN(name, len), base);
> +	struct dentry *ret;
> +
> +	ret = try_lookup_noperm(&name, base);
> +	if (!ret)
> +		ret = lookup_slow(&name, base, 0);
> +	return ret;
>  }
> -EXPORT_SYMBOL(lookup_one_len_unlocked);
> +EXPORT_SYMBOL(lookup_noperm_unlocked);
>  
>  /*
> - * Like lookup_one_len_unlocked(), except that it yields ERR_PTR(-ENOENT)
> + * Like lookup_noperm_unlocked(), except that it yields ERR_PTR(-ENOENT)
>   * on negatives.  Returns known positive or ERR_PTR(); that's what
>   * most of the users want.  Note that pinned negative with unlocked parent
> - * _can_ become positive at any time, so callers of lookup_one_len_unlocked()
> + * _can_ become positive at any time, so callers of lookup_noperm_unlocked()
>   * need to be very careful; pinned positives have ->d_inode stable, so
>   * this one avoids such problems.
>   */
> -struct dentry *lookup_positive_unlocked(const char *name,
> -				       struct dentry *base, int len)
> +struct dentry *lookup_noperm_positive_unlocked(struct qstr name,
> +					       struct dentry *base)
>  {
> -	return lookup_one_positive_unlocked(&nop_mnt_idmap, QSTR_LEN(name, len),
> -					    base);
> +	struct dentry *ret = lookup_noperm_unlocked(name, base);
> +
> +	if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {
> +		dput(ret);
> +		ret = ERR_PTR(-ENOENT);
> +	}
> +	return ret;
>  }
> -EXPORT_SYMBOL(lookup_positive_unlocked);
> +EXPORT_SYMBOL(lookup_noperm_positive_unlocked);
>  
>  #ifdef CONFIG_UNIX98_PTYS
>  int path_pts(struct path *path)
> diff --git a/fs/nfs/unlink.c b/fs/nfs/unlink.c
> index bf77399696a7..f52e57c31ae4 100644
> --- a/fs/nfs/unlink.c
> +++ b/fs/nfs/unlink.c
> @@ -464,18 +464,17 @@ nfs_sillyrename(struct inode *dir, struct dentry *dentry)
>  
>  	sdentry = NULL;
>  	do {
> -		int slen;
>  		dput(sdentry);
>  		sillycounter++;
> -		slen = scnprintf(silly, sizeof(silly),
> -				SILLYNAME_PREFIX "%0*llx%0*x",
> -				SILLYNAME_FILEID_LEN, fileid,
> -				SILLYNAME_COUNTER_LEN, sillycounter);
> +		scnprintf(silly, sizeof(silly),
> +			  SILLYNAME_PREFIX "%0*llx%0*x",
> +			  SILLYNAME_FILEID_LEN, fileid,
> +			  SILLYNAME_COUNTER_LEN, sillycounter);
>  
>  		dfprintk(VFS, "NFS: trying to rename %pd to %s\n",
>  				dentry, silly);
>  
> -		sdentry = lookup_one_len(silly, dentry->d_parent, slen);
> +		sdentry = lookup_noperm(QSTR(silly), dentry->d_parent);
>  		/*
>  		 * N.B. Better to return EBUSY here ... it could be
>  		 * dangerous to delete the file while it's in use.
> diff --git a/fs/overlayfs/export.c b/fs/overlayfs/export.c
> index 444aeeccb6da..a51025e8b2d0 100644
> --- a/fs/overlayfs/export.c
> +++ b/fs/overlayfs/export.c
> @@ -385,11 +385,9 @@ static struct dentry *ovl_lookup_real_one(struct dentry *connected,
>  	 */
>  	take_dentry_name_snapshot(&name, real);
>  	/*
> -	 * No idmap handling here: it's an internal lookup.  Could skip
> -	 * permission checking altogether, but for now just use non-idmap
> -	 * transformed ids.
> +	 * No idmap handling here: it's an internal lookup.
>  	 */
> -	this = lookup_one_len(name.name.name, connected, name.name.len);
> +	this = lookup_noperm(name.name, connected);
>  	release_dentry_name_snapshot(&name);
>  	err = PTR_ERR(this);
>  	if (IS_ERR(this)) {
> diff --git a/fs/overlayfs/namei.c b/fs/overlayfs/namei.c
> index 6a6301e4bba5..adb4af8d08db 100644
> --- a/fs/overlayfs/namei.c
> +++ b/fs/overlayfs/namei.c
> @@ -757,7 +757,7 @@ struct dentry *ovl_get_index_fh(struct ovl_fs *ofs, struct ovl_fh *fh)
>  	if (err)
>  		return ERR_PTR(err);
>  
> -	index = lookup_positive_unlocked(name.name, ofs->workdir, name.len);
> +	index = lookup_noperm_positive_unlocked(name, ofs->workdir);
>  	kfree(name.name);
>  	if (IS_ERR(index)) {
>  		if (PTR_ERR(index) == -ENOENT)
> diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
> index 825c5c2e0962..ea426467f26b 100644
> --- a/fs/quota/dquot.c
> +++ b/fs/quota/dquot.c
> @@ -2560,7 +2560,7 @@ int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
>  	struct dentry *dentry;
>  	int error;
>  
> -	dentry = lookup_positive_unlocked(qf_name, sb->s_root, strlen(qf_name));
> +	dentry = lookup_noperm_positive_unlocked(QSTR(qf_name), sb->s_root);
>  	if (IS_ERR(dentry))
>  		return PTR_ERR(dentry);
>  
> diff --git a/fs/smb/client/cached_dir.c b/fs/smb/client/cached_dir.c
> index fe738623cf1b..854de94fc394 100644
> --- a/fs/smb/client/cached_dir.c
> +++ b/fs/smb/client/cached_dir.c
> @@ -109,7 +109,8 @@ path_to_dentry(struct cifs_sb_info *cifs_sb, const char *path)
>  		while (*s && *s != sep)
>  			s++;
>  
> -		child = lookup_positive_unlocked(p, dentry, s - p);
> +		child = lookup_noperm_positive_unlocked(QSTR_LEN(p, s-p),
> +							dentry);
>  		dput(dentry);
>  		dentry = child;
>  	} while (!IS_ERR(dentry));
> @@ -207,7 +208,7 @@ int open_cached_dir(unsigned int xid, struct cifs_tcon *tcon,
>  	spin_unlock(&cfids->cfid_list_lock);
>  
>  	/*
> -	 * Skip any prefix paths in @path as lookup_positive_unlocked() ends up
> +	 * Skip any prefix paths in @path as lookup_noperm_positive_unlocked() ends up
>  	 * calling ->lookup() which already adds those through
>  	 * build_path_from_dentry().  Also, do it earlier as we might reconnect
>  	 * below when trying to send compounded request and then potentially
> diff --git a/fs/smb/client/cifsfs.c b/fs/smb/client/cifsfs.c
> index 6a3bd652d251..71eadc0305b5 100644
> --- a/fs/smb/client/cifsfs.c
> +++ b/fs/smb/client/cifsfs.c
> @@ -925,7 +925,8 @@ cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
>  		while (*s && *s != sep)
>  			s++;
>  
> -		child = lookup_positive_unlocked(p, dentry, s - p);
> +		child = lookup_noperm_positive_unlocked(QSTR_LEN(p, s - p),
> +							dentry);
>  		dput(dentry);
>  		dentry = child;
>  	} while (!IS_ERR(dentry));
> diff --git a/fs/tracefs/inode.c b/fs/tracefs/inode.c
> index cb1af30b49f5..aa7982e9b579 100644
> --- a/fs/tracefs/inode.c
> +++ b/fs/tracefs/inode.c
> @@ -555,7 +555,7 @@ struct dentry *tracefs_start_creating(const char *name, struct dentry *parent)
>  	if (unlikely(IS_DEADDIR(d_inode(parent))))
>  		dentry = ERR_PTR(-ENOENT);
>  	else
> -		dentry = lookup_one_len(name, parent, strlen(name));
> +		dentry = lookup_noperm(QSTR(name), parent);
>  	if (!IS_ERR(dentry) && d_inode(dentry)) {
>  		dput(dentry);
>  		dentry = ERR_PTR(-EEXIST);
> diff --git a/fs/xfs/scrub/orphanage.c b/fs/xfs/scrub/orphanage.c
> index 3537f3cca6d5..987af5b2bb82 100644
> --- a/fs/xfs/scrub/orphanage.c
> +++ b/fs/xfs/scrub/orphanage.c
> @@ -153,8 +153,7 @@ xrep_orphanage_create(
>  
>  	/* Try to find the orphanage directory. */
>  	inode_lock_nested(root_inode, I_MUTEX_PARENT);
> -	orphanage_dentry = lookup_one_len(ORPHANAGE, root_dentry,
> -			strlen(ORPHANAGE));
> +	orphanage_dentry = lookup_noperm(QSTR(ORPHANAGE), root_dentry);
>  	if (IS_ERR(orphanage_dentry)) {
>  		error = PTR_ERR(orphanage_dentry);
>  		goto out_unlock_root;
> diff --git a/include/linux/namei.h b/include/linux/namei.h
> index 508dae67e3c5..befe75439d7e 100644
> --- a/include/linux/namei.h
> +++ b/include/linux/namei.h
> @@ -69,10 +69,10 @@ int vfs_path_parent_lookup(struct filename *filename, unsigned int flags,
>  int vfs_path_lookup(struct dentry *, struct vfsmount *, const char *,
>  		    unsigned int, struct path *);
>  
> -extern struct dentry *try_lookup_one_len(const char *, struct dentry *, int);
> -extern struct dentry *lookup_one_len(const char *, struct dentry *, int);
> -extern struct dentry *lookup_one_len_unlocked(const char *, struct dentry *, int);
> -extern struct dentry *lookup_positive_unlocked(const char *, struct dentry *, int);
> +extern struct dentry *try_lookup_noperm(struct qstr *, struct dentry *);
> +extern struct dentry *lookup_noperm(struct qstr, struct dentry *);
> +extern struct dentry *lookup_noperm_unlocked(struct qstr, struct dentry *);
> +extern struct dentry *lookup_noperm_positive_unlocked(struct qstr, struct dentry *);
>  struct dentry *lookup_one(struct mnt_idmap *, struct qstr, struct dentry *);
>  struct dentry *lookup_one_unlocked(struct mnt_idmap *idmap,
>  				   struct qstr name, struct dentry *base);
> diff --git a/ipc/mqueue.c b/ipc/mqueue.c
> index 35b4f8659904..f3d76c4b6013 100644
> --- a/ipc/mqueue.c
> +++ b/ipc/mqueue.c
> @@ -913,7 +913,7 @@ static int do_mq_open(const char __user *u_name, int oflag, umode_t mode,
>  
>  	ro = mnt_want_write(mnt);	/* we'll drop it in any case */
>  	inode_lock(d_inode(root));
> -	path.dentry = lookup_one_len(name->name, root, strlen(name->name));
> +	path.dentry = lookup_noperm(QSTR(name->name), root);
>  	if (IS_ERR(path.dentry)) {
>  		error = PTR_ERR(path.dentry);
>  		goto out_putfd;
> @@ -969,8 +969,7 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
>  	if (err)
>  		goto out_name;
>  	inode_lock_nested(d_inode(mnt->mnt_root), I_MUTEX_PARENT);
> -	dentry = lookup_one_len(name->name, mnt->mnt_root,
> -				strlen(name->name));
> +	dentry = lookup_noperm(QSTR(name->name), mnt->mnt_root);
>  	if (IS_ERR(dentry)) {
>  		err = PTR_ERR(dentry);
>  		goto out_unlock;
> diff --git a/kernel/bpf/inode.c b/kernel/bpf/inode.c
> index dc3aa91a6ba0..77fda4101b06 100644
> --- a/kernel/bpf/inode.c
> +++ b/kernel/bpf/inode.c
> @@ -421,7 +421,7 @@ static int bpf_iter_link_pin_kernel(struct dentry *parent,
>  	int ret;
>  
>  	inode_lock(parent->d_inode);
> -	dentry = lookup_one_len(name, parent, strlen(name));
> +	dentry = lookup_noperm(QSTR(name), parent);
>  	if (IS_ERR(dentry)) {
>  		inode_unlock(parent->d_inode);
>  		return PTR_ERR(dentry);
> diff --git a/security/apparmor/apparmorfs.c b/security/apparmor/apparmorfs.c
> index 6039afae4bfc..dfc56cec5ab5 100644
> --- a/security/apparmor/apparmorfs.c
> +++ b/security/apparmor/apparmorfs.c
> @@ -283,7 +283,7 @@ static struct dentry *aafs_create(const char *name, umode_t mode,
>  	dir = d_inode(parent);
>  
>  	inode_lock(dir);
> -	dentry = lookup_one_len(name, parent, strlen(name));
> +	dentry = lookup_noperm(QSTR(name), parent);
>  	if (IS_ERR(dentry)) {
>  		error = PTR_ERR(dentry);
>  		goto fail_lock;
> @@ -2551,7 +2551,7 @@ static int aa_mk_null_file(struct dentry *parent)
>  		return error;
>  
>  	inode_lock(d_inode(parent));
> -	dentry = lookup_one_len(NULL_FILE_NAME, parent, strlen(NULL_FILE_NAME));
> +	dentry = lookup_noperm(QSTR(NULL_FILE_NAME), parent);
>  	if (IS_ERR(dentry)) {
>  		error = PTR_ERR(dentry);
>  		goto out;
> diff --git a/security/inode.c b/security/inode.c
> index da3ab44c8e57..d04a52a52bdd 100644
> --- a/security/inode.c
> +++ b/security/inode.c
> @@ -128,7 +128,7 @@ static struct dentry *securityfs_create_dentry(const char *name, umode_t mode,
>  	dir = d_inode(parent);
>  
>  	inode_lock(dir);
> -	dentry = lookup_one_len(name, parent, strlen(name));
> +	dentry = lookup_noperm(QSTR(name), parent);
>  	if (IS_ERR(dentry))
>  		goto out;
>  

Reviewed-by: Jeff Layton <jlayton@kernel.org>