git
/
linux
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

VFS: rename kern_path_locked() and related functions. 

kern_path_locked() is now only used to prepare for removing an object
from the filesystem (and that is the only credible reason for wanting a
positive locked dentry).  Thus it corresponds to kern_path_create() and
so should have a corresponding name.

Unfortunately the name "kern_path_create" is somewhat misleading as it
doesn't actually create anything.  The recently added
simple_start_creating() provides a better pattern I believe.  The
"start" can be matched with "end" to bracket the creating or removing.

So this patch changes names:

 kern_path_locked -> start_removing_path
 kern_path_create -> start_creating_path
 user_path_create -> start_creating_user_path
 user_path_locked_at -> start_removing_user_path_at
 done_path_create -> end_creating_path

and also introduces end_removing_path() which is identical to
end_creating_path().

__start_removing_path (which was __kern_path_locked) is enhanced to
call mnt_want_write() for consistency with the start_creating_path().

Reviewed-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: NeilBrown <neil@brown.name>
Signed-off-by: Christian Brauner <brauner@kernel.org>
This commit is contained in:
NeilBrown 2025-09-22 14:29:52 +10:00 committed by Christian Brauner
parent 76a53de6f7
commit 3d18f80ce1
No known key found for this signature in database
GPG Key ID: 91C61BC06578DCA2
11 changed files with 93 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Documentation/filesystems/porting.rst
View File

@ -1285,3 +1285,15 @@ rather than a VMA, as the VMA at this stage is not yet valid.
The vm_area_desc provides the minimum required information for a filesystem The vm_area_desc provides the minimum required information for a filesystem
to initialise state upon memory mapping of a file-backed region, and output to initialise state upon memory mapping of a file-backed region, and output
parameters for the file system to set this state. parameters for the file system to set this state.
---
**mandatory**
Several functions are renamed:
- kern_path_locked -> start_removing_path
- kern_path_create -> start_creating_path
- user_path_create -> start_creating_user_path
- user_path_locked_at -> start_removing_user_path_at
- done_path_create -> end_creating_path

4
arch/powerpc/platforms/cell/spufs/syscalls.c
View File

@ -67,11 +67,11 @@ static long do_spu_create(const char __user *pathname, unsigned int flags,
struct dentry *dentry; struct dentry *dentry;
int ret; int ret;
dentry = user_path_create(AT_FDCWD, pathname, &path, LOOKUP_DIRECTORY); dentry = start_creating_user_path(AT_FDCWD, pathname, &path, LOOKUP_DIRECTORY);
ret = PTR_ERR(dentry); ret = PTR_ERR(dentry);
if (!IS_ERR(dentry)) { if (!IS_ERR(dentry)) {
ret = spufs_create(&path, dentry, flags, mode, neighbor); ret = spufs_create(&path, dentry, flags, mode, neighbor);
done_path_create(&path, dentry); end_creating_path(&path, dentry);
} }
return ret; return ret;

22
drivers/base/devtmpfs.c
View File

@ -176,7 +176,7 @@ static int dev_mkdir(const char *name, umode_t mode)
struct dentry *dentry; struct dentry *dentry;
struct path path; struct path path;
dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY); dentry = start_creating_path(AT_FDCWD, name, &path, LOOKUP_DIRECTORY);
if (IS_ERR(dentry)) if (IS_ERR(dentry))
return PTR_ERR(dentry); return PTR_ERR(dentry);
@ -184,7 +184,7 @@ static int dev_mkdir(const char *name, umode_t mode)
if (!IS_ERR(dentry)) if (!IS_ERR(dentry))
/* mark as kernel-created inode */ /* mark as kernel-created inode */
d_inode(dentry)->i_private = &thread; d_inode(dentry)->i_private = &thread;
done_path_create(&path, dentry); end_creating_path(&path, dentry);
return PTR_ERR_OR_ZERO(dentry); return PTR_ERR_OR_ZERO(dentry);
} }
@ -222,10 +222,10 @@ static int handle_create(const char *nodename, umode_t mode, kuid_t uid,
struct path path; struct path path;
int err; int err;
dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); dentry = start_creating_path(AT_FDCWD, nodename, &path, 0);
if (dentry == ERR_PTR(-ENOENT)) { if (dentry == ERR_PTR(-ENOENT)) {
create_path(nodename); create_path(nodename);
dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); dentry = start_creating_path(AT_FDCWD, nodename, &path, 0);
} }
if (IS_ERR(dentry)) if (IS_ERR(dentry))
return PTR_ERR(dentry); return PTR_ERR(dentry);
@ -246,7 +246,7 @@ static int handle_create(const char *nodename, umode_t mode, kuid_t uid,
/* mark as kernel-created inode */ /* mark as kernel-created inode */
d_inode(dentry)->i_private = &thread; d_inode(dentry)->i_private = &thread;
} }
done_path_create(&path, dentry); end_creating_path(&path, dentry);
return err; return err;
} }
@ -256,7 +256,7 @@ static int dev_rmdir(const char *name)
struct dentry *dentry; struct dentry *dentry;
int err; int err;
dentry = kern_path_locked(name, &parent); dentry = start_removing_path(name, &parent);
if (IS_ERR(dentry)) if (IS_ERR(dentry))
return PTR_ERR(dentry); return PTR_ERR(dentry);
if (d_inode(dentry)->i_private == &thread) if (d_inode(dentry)->i_private == &thread)
@ -265,9 +265,7 @@ static int dev_rmdir(const char *name)
else else
err = -EPERM; err = -EPERM;
dput(dentry); end_removing_path(&parent, dentry);
inode_unlock(d_inode(parent.dentry));
path_put(&parent);
return err; return err;
} }
@ -325,7 +323,7 @@ static int handle_remove(const char *nodename, struct device *dev)
int deleted = 0; int deleted = 0;
int err = 0; int err = 0;
dentry = kern_path_locked(nodename, &parent); dentry = start_removing_path(nodename, &parent);
if (IS_ERR(dentry)) if (IS_ERR(dentry))
return PTR_ERR(dentry); return PTR_ERR(dentry);
@ -349,10 +347,8 @@ static int handle_remove(const char *nodename, struct device *dev)
if (!err || err == -ENOENT) if (!err || err == -ENOENT)
deleted = 1; deleted = 1;
} }
dput(dentry); end_removing_path(&parent, dentry);
inode_unlock(d_inode(parent.dentry));
path_put(&parent);
if (deleted && strchr(nodename, '/')) if (deleted && strchr(nodename, '/'))
delete_path(nodename); delete_path(nodename);
return err; return err;

10
fs/bcachefs/fs-ioctl.c
View File

@ -255,7 +255,7 @@ static long bch2_ioctl_subvolume_create(struct bch_fs *c, struct file *filp,
snapshot_src = inode_inum(to_bch_ei(src_path.dentry->d_inode)); snapshot_src = inode_inum(to_bch_ei(src_path.dentry->d_inode));
} }
dst_dentry = user_path_create(arg.dirfd, dst_dentry = start_creating_user_path(arg.dirfd,
(const char __user *)(unsigned long)arg.dst_ptr, (const char __user *)(unsigned long)arg.dst_ptr,
&dst_path, lookup_flags); &dst_path, lookup_flags);
error = PTR_ERR_OR_ZERO(dst_dentry); error = PTR_ERR_OR_ZERO(dst_dentry);
@ -314,7 +314,7 @@ static long bch2_ioctl_subvolume_create(struct bch_fs *c, struct file *filp,
d_instantiate(dst_dentry, &inode->v); d_instantiate(dst_dentry, &inode->v);
fsnotify_mkdir(dir, dst_dentry); fsnotify_mkdir(dir, dst_dentry);
err3: err3:
done_path_create(&dst_path, dst_dentry); end_creating_path(&dst_path, dst_dentry);
err2: err2:
if (arg.src_ptr) if (arg.src_ptr)
path_put(&src_path); path_put(&src_path);
@ -334,7 +334,7 @@ static long bch2_ioctl_subvolume_destroy(struct bch_fs *c, struct file *filp,
if (arg.flags) if (arg.flags)
return -EINVAL; return -EINVAL;
victim = user_path_locked_at(arg.dirfd, name, &path); victim = start_removing_user_path_at(arg.dirfd, name, &path);
if (IS_ERR(victim)) if (IS_ERR(victim))
return PTR_ERR(victim); return PTR_ERR(victim);
@ -351,9 +351,7 @@ static long bch2_ioctl_subvolume_destroy(struct bch_fs *c, struct file *filp,
d_invalidate(victim); d_invalidate(victim);
} }
err: err:
inode_unlock(dir); end_removing_path(&path, victim);
dput(victim);
path_put(&path);
return ret; return ret;
} }

17
fs/init.c
View File

@ -149,7 +149,7 @@ int __init init_mknod(const char *filename, umode_t mode, unsigned int dev)
else if (!(S_ISBLK(mode) || S_ISCHR(mode))) else if (!(S_ISBLK(mode) || S_ISCHR(mode)))
return -EINVAL; return -EINVAL;
dentry = kern_path_create(AT_FDCWD, filename, &path, 0); dentry = start_creating_path(AT_FDCWD, filename, &path, 0);
if (IS_ERR(dentry)) if (IS_ERR(dentry))
return PTR_ERR(dentry); return PTR_ERR(dentry);
@ -158,7 +158,7 @@ int __init init_mknod(const char *filename, umode_t mode, unsigned int dev)
if (!error) if (!error)
error = vfs_mknod(mnt_idmap(path.mnt), path.dentry->d_inode, error = vfs_mknod(mnt_idmap(path.mnt), path.dentry->d_inode,
dentry, mode, new_decode_dev(dev)); dentry, mode, new_decode_dev(dev));
done_path_create(&path, dentry); end_creating_path(&path, dentry);
return error; return error;
} }
@ -173,7 +173,7 @@ int __init init_link(const char *oldname, const char *newname)
if (error) if (error)
return error; return error;
new_dentry = kern_path_create(AT_FDCWD, newname, &new_path, 0); new_dentry = start_creating_path(AT_FDCWD, newname, &new_path, 0);
error = PTR_ERR(new_dentry); error = PTR_ERR(new_dentry);
if (IS_ERR(new_dentry)) if (IS_ERR(new_dentry))
goto out; goto out;
@ -191,7 +191,7 @@ int __init init_link(const char *oldname, const char *newname)
error = vfs_link(old_path.dentry, idmap, new_path.dentry->d_inode, error = vfs_link(old_path.dentry, idmap, new_path.dentry->d_inode,
new_dentry, NULL); new_dentry, NULL);
out_dput: out_dput:
done_path_create(&new_path, new_dentry); end_creating_path(&new_path, new_dentry);
out: out:
path_put(&old_path); path_put(&old_path);
return error; return error;
@ -203,14 +203,14 @@ int __init init_symlink(const char *oldname, const char *newname)
struct path path; struct path path;
int error; int error;
dentry = kern_path_create(AT_FDCWD, newname, &path, 0); dentry = start_creating_path(AT_FDCWD, newname, &path, 0);
if (IS_ERR(dentry)) if (IS_ERR(dentry))
return PTR_ERR(dentry); return PTR_ERR(dentry);
error = security_path_symlink(&path, dentry, oldname); error = security_path_symlink(&path, dentry, oldname);
if (!error) if (!error)
error = vfs_symlink(mnt_idmap(path.mnt), path.dentry->d_inode, error = vfs_symlink(mnt_idmap(path.mnt), path.dentry->d_inode,
dentry, oldname); dentry, oldname);
done_path_create(&path, dentry); end_creating_path(&path, dentry);
return error; return error;
} }
@ -225,7 +225,8 @@ int __init init_mkdir(const char *pathname, umode_t mode)
struct path path; struct path path;
int error; int error;
dentry = kern_path_create(AT_FDCWD, pathname, &path, LOOKUP_DIRECTORY); dentry = start_creating_path(AT_FDCWD, pathname, &path,
LOOKUP_DIRECTORY);
if (IS_ERR(dentry)) if (IS_ERR(dentry))
return PTR_ERR(dentry); return PTR_ERR(dentry);
mode = mode_strip_umask(d_inode(path.dentry), mode); mode = mode_strip_umask(d_inode(path.dentry), mode);
@ -236,7 +237,7 @@ int __init init_mkdir(const char *pathname, umode_t mode)
if (IS_ERR(dentry)) if (IS_ERR(dentry))
error = PTR_ERR(dentry); error = PTR_ERR(dentry);
} }
done_path_create(&path, dentry); end_creating_path(&path, dentry);
return error; return error;
} }

59
fs/namei.c
View File

@ -2758,7 +2758,8 @@ static int filename_parentat(int dfd, struct filename *name,
} }
/* does lookup, returns the object with parent locked */ /* does lookup, returns the object with parent locked */
static struct dentry *__kern_path_locked(int dfd, struct filename *name, struct path *path) static struct dentry *__start_removing_path(int dfd, struct filename *name,
struct path *path)
{ {
struct path parent_path __free(path_put) = {}; struct path parent_path __free(path_put) = {};
struct dentry *d; struct dentry *d;
@ -2770,15 +2771,26 @@ static struct dentry *__kern_path_locked(int dfd, struct filename *name, struct
return ERR_PTR(error); return ERR_PTR(error);
if (unlikely(type != LAST_NORM)) if (unlikely(type != LAST_NORM))
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
/* don't fail immediately if it's r/o, at least try to report other errors */
error = mnt_want_write(parent_path.mnt);
inode_lock_nested(parent_path.dentry->d_inode, I_MUTEX_PARENT); inode_lock_nested(parent_path.dentry->d_inode, I_MUTEX_PARENT);
d = lookup_one_qstr_excl(&last, parent_path.dentry, 0); d = lookup_one_qstr_excl(&last, parent_path.dentry, 0);
if (IS_ERR(d)) { if (IS_ERR(d))
inode_unlock(parent_path.dentry->d_inode); goto unlock;
return d; if (error)
} goto fail;
path->dentry = no_free_ptr(parent_path.dentry); path->dentry = no_free_ptr(parent_path.dentry);
path->mnt = no_free_ptr(parent_path.mnt); path->mnt = no_free_ptr(parent_path.mnt);
return d; return d;
fail:
dput(d);
d = ERR_PTR(error);
unlock:
inode_unlock(parent_path.dentry->d_inode);
if (!error)
mnt_drop_write(parent_path.mnt);
return d;
} }
/** /**
@ -2816,24 +2828,26 @@ struct dentry *kern_path_parent(const char *name, struct path *path)
return d; return d;
} }
struct dentry *kern_path_locked(const char *name, struct path *path) struct dentry *start_removing_path(const char *name, struct path *path)
{ {
struct filename *filename = getname_kernel(name); struct filename *filename = getname_kernel(name);
struct dentry *res = __kern_path_locked(AT_FDCWD, filename, path); struct dentry *res = __start_removing_path(AT_FDCWD, filename, path);
putname(filename); putname(filename);
return res; return res;
} }
struct dentry *user_path_locked_at(int dfd, const char __user *name, struct path *path) struct dentry *start_removing_user_path_at(int dfd,
const char __user *name,
struct path *path)
{ {
struct filename *filename = getname(name); struct filename *filename = getname(name);
struct dentry *res = __kern_path_locked(dfd, filename, path); struct dentry *res = __start_removing_path(dfd, filename, path);
putname(filename); putname(filename);
return res; return res;
} }
EXPORT_SYMBOL(user_path_locked_at); EXPORT_SYMBOL(start_removing_user_path_at);
int kern_path(const char *name, unsigned int flags, struct path *path) int kern_path(const char *name, unsigned int flags, struct path *path)
{ {
@ -4223,8 +4237,8 @@ out:
return dentry; return dentry;
} }
struct dentry *kern_path_create(int dfd, const char *pathname, struct dentry *start_creating_path(int dfd, const char *pathname,
struct path *path, unsigned int lookup_flags) struct path *path, unsigned int lookup_flags)
{ {
struct filename *filename = getname_kernel(pathname); struct filename *filename = getname_kernel(pathname);
struct dentry *res = filename_create(dfd, filename, path, lookup_flags); struct dentry *res = filename_create(dfd, filename, path, lookup_flags);
@ -4232,9 +4246,9 @@ struct dentry *kern_path_create(int dfd, const char *pathname,
putname(filename); putname(filename);
return res; return res;
} }
EXPORT_SYMBOL(kern_path_create); EXPORT_SYMBOL(start_creating_path);
void done_path_create(struct path *path, struct dentry *dentry) void end_creating_path(struct path *path, struct dentry *dentry)
{ {
if (!IS_ERR(dentry)) if (!IS_ERR(dentry))
dput(dentry); dput(dentry);
@ -4242,10 +4256,11 @@ void done_path_create(struct path *path, struct dentry *dentry)
mnt_drop_write(path->mnt); mnt_drop_write(path->mnt);
path_put(path); path_put(path);
} }
EXPORT_SYMBOL(done_path_create); EXPORT_SYMBOL(end_creating_path);
inline struct dentry *user_path_create(int dfd, const char __user *pathname, inline struct dentry *start_creating_user_path(
struct path *path, unsigned int lookup_flags) int dfd, const char __user *pathname,
struct path *path, unsigned int lookup_flags)
{ {
struct filename *filename = getname(pathname); struct filename *filename = getname(pathname);
struct dentry *res = filename_create(dfd, filename, path, lookup_flags); struct dentry *res = filename_create(dfd, filename, path, lookup_flags);
@ -4253,7 +4268,7 @@ inline struct dentry *user_path_create(int dfd, const char __user *pathname,
putname(filename); putname(filename);
return res; return res;
} }
EXPORT_SYMBOL(user_path_create); EXPORT_SYMBOL(start_creating_user_path);
/** /**
* vfs_mknod - create device node or file * vfs_mknod - create device node or file
@ -4361,7 +4376,7 @@ retry:
break; break;
} }
out2: out2:
done_path_create(&path, dentry); end_creating_path(&path, dentry);
if (retry_estale(error, lookup_flags)) { if (retry_estale(error, lookup_flags)) {
lookup_flags |= LOOKUP_REVAL; lookup_flags |= LOOKUP_REVAL;
goto retry; goto retry;
@ -4465,7 +4480,7 @@ retry:
if (IS_ERR(dentry)) if (IS_ERR(dentry))
error = PTR_ERR(dentry); error = PTR_ERR(dentry);
} }
done_path_create(&path, dentry); end_creating_path(&path, dentry);
if (retry_estale(error, lookup_flags)) { if (retry_estale(error, lookup_flags)) {
lookup_flags |= LOOKUP_REVAL; lookup_flags |= LOOKUP_REVAL;
goto retry; goto retry;
@ -4819,7 +4834,7 @@ retry:
if (!error) if (!error)
error = vfs_symlink(mnt_idmap(path.mnt), path.dentry->d_inode, error = vfs_symlink(mnt_idmap(path.mnt), path.dentry->d_inode,
dentry, from->name); dentry, from->name);
done_path_create(&path, dentry); end_creating_path(&path, dentry);
if (retry_estale(error, lookup_flags)) { if (retry_estale(error, lookup_flags)) {
lookup_flags |= LOOKUP_REVAL; lookup_flags |= LOOKUP_REVAL;
goto retry; goto retry;
@ -4988,7 +5003,7 @@ retry:
error = vfs_link(old_path.dentry, idmap, new_path.dentry->d_inode, error = vfs_link(old_path.dentry, idmap, new_path.dentry->d_inode,
new_dentry, &delegated_inode); new_dentry, &delegated_inode);
out_dput: out_dput:
done_path_create(&new_path, new_dentry); end_creating_path(&new_path, new_dentry);
if (delegated_inode) { if (delegated_inode) {
error = break_deleg_wait(&delegated_inode); error = break_deleg_wait(&delegated_inode);
if (!error) { if (!error) {

4
fs/ocfs2/refcounttree.c
View File

@ -4418,7 +4418,7 @@ int ocfs2_reflink_ioctl(struct inode *inode,
return error; return error;
} }
new_dentry = user_path_create(AT_FDCWD, newname, &new_path, 0); new_dentry = start_creating_user_path(AT_FDCWD, newname, &new_path, 0);
error = PTR_ERR(new_dentry); error = PTR_ERR(new_dentry);
if (IS_ERR(new_dentry)) { if (IS_ERR(new_dentry)) {
mlog_errno(error); mlog_errno(error);
@ -4435,7 +4435,7 @@ int ocfs2_reflink_ioctl(struct inode *inode,
d_inode(new_path.dentry), d_inode(new_path.dentry),
new_dentry, preserve); new_dentry, preserve);
out_dput: out_dput:
done_path_create(&new_path, new_dentry); end_creating_path(&new_path, new_dentry);
out: out:
path_put(&old_path); path_put(&old_path);

8
fs/smb/server/vfs.c
View File

@ -196,7 +196,7 @@ int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode)
pr_err("File(%s): creation failed (err:%d)\n", name, err); pr_err("File(%s): creation failed (err:%d)\n", name, err);
} }
done_path_create(&path, dentry); end_creating_path(&path, dentry);
return err; return err;
} }
@ -237,7 +237,7 @@ int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode)
if (!err && dentry != d) if (!err && dentry != d)
ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(dentry)); ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(dentry));
done_path_create(&path, dentry); end_creating_path(&path, dentry);
if (err) if (err)
pr_err("mkdir(%s): creation failed (err:%d)\n", name, err); pr_err("mkdir(%s): creation failed (err:%d)\n", name, err);
return err; return err;
@ -669,7 +669,7 @@ int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,
ksmbd_debug(VFS, "vfs_link failed err %d\n", err); ksmbd_debug(VFS, "vfs_link failed err %d\n", err);
out3: out3:
done_path_create(&newpath, dentry); end_creating_path(&newpath, dentry);
out2: out2:
path_put(&oldpath); path_put(&oldpath);
out1: out1:
@ -1325,7 +1325,7 @@ struct dentry *ksmbd_vfs_kern_path_create(struct ksmbd_work *work,
if (!abs_name) if (!abs_name)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
dent = kern_path_create(AT_FDCWD, abs_name, path, flags); dent = start_creating_path(AT_FDCWD, abs_name, path, flags);
kfree(abs_name); kfree(abs_name);
return dent; return dent;
} }

14
include/linux/namei.h
View File

@ -59,11 +59,15 @@ struct dentry *lookup_one_qstr_excl(const struct qstr *name,
extern int kern_path(const char *, unsigned, struct path *); extern int kern_path(const char *, unsigned, struct path *);
struct dentry *kern_path_parent(const char *name, struct path *parent); struct dentry *kern_path_parent(const char *name, struct path *parent);
extern struct dentry *kern_path_create(int, const char *, struct path *, unsigned int); extern struct dentry *start_creating_path(int, const char *, struct path *, unsigned int);
extern struct dentry *user_path_create(int, const char __user *, struct path *, unsigned int); extern struct dentry *start_creating_user_path(int, const char __user *, struct path *, unsigned int);
extern void done_path_create(struct path *, struct dentry *); extern void end_creating_path(struct path *, struct dentry *);
extern struct dentry *kern_path_locked(const char *, struct path *); extern struct dentry *start_removing_path(const char *, struct path *);
extern struct dentry *user_path_locked_at(int , const char __user *, struct path *); extern struct dentry *start_removing_user_path_at(int , const char __user *, struct path *);
static inline void end_removing_path(struct path *path , struct dentry *dentry)
{
end_creating_path(path, dentry);
}
int vfs_path_parent_lookup(struct filename *filename, unsigned int flags, int vfs_path_parent_lookup(struct filename *filename, unsigned int flags,
struct path *parent, struct qstr *last, int *type, struct path *parent, struct qstr *last, int *type,
const struct path *root); const struct path *root);

4
kernel/bpf/inode.c
View File

@ -442,7 +442,7 @@ static int bpf_obj_do_pin(int path_fd, const char __user *pathname, void *raw,
umode_t mode; umode_t mode;
int ret; int ret;
dentry = user_path_create(path_fd, pathname, &path, 0); dentry = start_creating_user_path(path_fd, pathname, &path, 0);
if (IS_ERR(dentry)) if (IS_ERR(dentry))
return PTR_ERR(dentry); return PTR_ERR(dentry);
@ -471,7 +471,7 @@ static int bpf_obj_do_pin(int path_fd, const char __user *pathname, void *raw,
ret = -EPERM; ret = -EPERM;
} }
out: out:
done_path_create(&path, dentry); end_creating_path(&path, dentry);
return ret; return ret;
} }

6
net/unix/af_unix.c
View File

@ -1387,7 +1387,7 @@ static int unix_bind_bsd(struct sock *sk, struct sockaddr_un *sunaddr,
* Get the parent directory, calculate the hash for last * Get the parent directory, calculate the hash for last
* component. * component.
*/ */
dentry = kern_path_create(AT_FDCWD, addr->name->sun_path, &parent, 0); dentry = start_creating_path(AT_FDCWD, addr->name->sun_path, &parent, 0);
if (IS_ERR(dentry)) { if (IS_ERR(dentry)) {
err = PTR_ERR(dentry); err = PTR_ERR(dentry);
goto out; goto out;
@ -1417,7 +1417,7 @@ static int unix_bind_bsd(struct sock *sk, struct sockaddr_un *sunaddr,
unix_table_double_unlock(net, old_hash, new_hash); unix_table_double_unlock(net, old_hash, new_hash);
unix_insert_bsd_socket(sk); unix_insert_bsd_socket(sk);
mutex_unlock(&u->bindlock); mutex_unlock(&u->bindlock);
done_path_create(&parent, dentry); end_creating_path(&parent, dentry);
return 0; return 0;
out_unlock: out_unlock:
@ -1427,7 +1427,7 @@ out_unlink:
/* failed after successful mknod? unlink what we'd created... */ /* failed after successful mknod? unlink what we'd created... */
vfs_unlink(idmap, d_inode(parent.dentry), dentry, NULL); vfs_unlink(idmap, d_inode(parent.dentry), dentry, NULL);
out_path: out_path:
done_path_create(&parent, dentry); end_creating_path(&parent, dentry);
out: out:
unix_release_addr(addr); unix_release_addr(addr);
return err == -EEXIST ? -EADDRINUSE : err; return err == -EEXIST ? -EADDRINUSE : err;