Skip to contentSkip to conversation

io_uring: add mkdirat support

PATCH Superseded Dmitry Kadashev 3 participants 15 messages Mar 30, 2021 – May 14, 2021

Subsystems (3)

v3 of 9 Superseded Latest is v9 →

lore
Share & tools
lore
#0 lore raw

v3 cover io_uring: add mkdirat support

This adds mkdirat support to io_uring and is heavily based on recently added renameat() / unlinkat() support.

The first patch is preparation with no functional changes, makes do_mkdirat accept struct filename pointer rather than the user string.

The second one leverages that to implement mkdirat in io_uring.

Based on for-5.13/io_uring.

Changes since v2:
- rebase

Changes since v1:
- do not mess with struct filename's refcount in do_mkdirat, instead add and use __filename_create() that does not drop the name on success;

Dmitry Kadashev (2):
fs: make do_mkdirat() take struct filename
io_uring: add support for IORING_OP_MKDIRAT

 fs/internal.h                 |  1 +
 fs/io_uring.c                 | 55 +++++++++++++++++++++++++++++++++++
 fs/namei.c                    | 25 ++++++++++++----
 include/uapi/linux/io_uring.h |  1 +
 4 files changed, 76 insertions(+), 6 deletions(-)
Signature · 1 line
2.30.2
#1 lore raw

PATCH v3 1/2 fs: make do_mkdirat() take struct filename

Pass in the struct filename pointers instead of the user string, and update the three callers to do the same. This is heavily based on commit dbea8d345177 ("fs: make do_renameat2() take struct filename").

This behaves like do_unlinkat() and do_renameat2().

---
 fs/internal.h |  1 +
 fs/namei.c    | 25 +++++++++++++++++++------
 2 files changed, 20 insertions(+), 6 deletions(-)
fs/internal.h +1 -0
index 6aeae7ef3380..848e165ef0f1 100644
@@ -77,6 +77,7 @@ long do_unlinkat(int dfd, struct filename *name);
 int may_linkat(struct user_namespace *mnt_userns, struct path *link);
 int do_renameat2(int olddfd, struct filename *oldname, int newdfd,
 		 struct filename *newname, unsigned int flags);
+long do_mkdirat(int dfd, struct filename *name, umode_t mode);
 
 /*
  * namespace.c
fs/namei.c +19 -6
index 216f16e74351..bfdc3128bf8d 100644
@@ -3560,7 +3560,7 @@ struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
 	return file;
 }
 
-static struct dentry *filename_create(int dfd, struct filename *name,
+static struct dentry *__filename_create(int dfd, struct filename *name,
 				struct path *path, unsigned int lookup_flags)
 {
 	struct dentry *dentry = ERR_PTR(-EEXIST);
@@ -3616,7 +3616,6 @@ static struct dentry *filename_create(int dfd, struct filename *name,
 		error = err2;
 		goto fail;
 	}
-	putname(name);
 	return dentry;
 fail:
 	dput(dentry);
@@ -3631,6 +3630,16 @@ static struct dentry *filename_create(int dfd, struct filename *name,
 	return dentry;
 }
 
+static inline struct dentry *filename_create(int dfd, struct filename *name,
+				struct path *path, unsigned int lookup_flags)
+{
+	struct dentry *res = __filename_create(dfd, name, path, lookup_flags);
+
+	if (!IS_ERR(res))
+		putname(name);
+	return res;
+}
+
 struct dentry *kern_path_create(int dfd, const char *pathname,
 				struct path *path, unsigned int lookup_flags)
 {
@@ -3821,15 +3830,18 @@ int vfs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
 }
 EXPORT_SYMBOL(vfs_mkdir);
 
-static long do_mkdirat(int dfd, const char __user *pathname, umode_t mode)
+long do_mkdirat(int dfd, struct filename *name, umode_t mode)
 {
 	struct dentry *dentry;
 	struct path path;
 	int error;
 	unsigned int lookup_flags = LOOKUP_DIRECTORY;
 
+	if (IS_ERR(name))
+		return PTR_ERR(name);
+
 retry:
-	dentry = user_path_create(dfd, pathname, &path, lookup_flags);
+	dentry = __filename_create(dfd, name, &path, lookup_flags);
 	if (IS_ERR(dentry))
 		return PTR_ERR(dentry);
 
@@ -3847,17 +3859,18 @@ static long do_mkdirat(int dfd, const char __user *pathname, umode_t mode)
 		lookup_flags |= LOOKUP_REVAL;
 		goto retry;
 	}
+	putname(name);
 	return error;
 }
 
 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
 {
-	return do_mkdirat(dfd, pathname, mode);
+	return do_mkdirat(dfd, getname(pathname), mode);
 }
 
 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
 {
-	return do_mkdirat(AT_FDCWD, pathname, mode);
+	return do_mkdirat(AT_FDCWD, getname(pathname), mode);
 }
 
 /**
Signature · 1 line
2.30.2
#2 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 4 lines · Dmitry Kadashev

Pass in the struct filename pointers instead of the user string, and update the three callers to do the same. This is heavily based on commit dbea8d345177 ("fs: make do_renameat2() take struct filename").

Quoted 8 lines

This behaves like do_unlinkat() and do_renameat2().

---
 fs/internal.h |  1 +
 fs/namei.c    | 25 +++++++++++++++++++------
 2 files changed, 20 insertions(+), 6 deletions(-)

The only thing that is a bit unpleasant here is that this change breaks the consistency between the creation helpers:

do_mkdirat()
do_symlinkat()
do_linkat()
do_mknodat()

All but of them currently take
const char __user *pathname
and call
user_path_create()
with that do_mkdirat() change that's no longer true. One of the major benefits over the recent years in this code is naming and type consistency. And since it's just matter of time until io_uring will also gain support for do_{symlinkat,linkat,mknodat} I would think switching all of them to take a struct filename
and then have all do_* helpers call getname() might just be nicer in the long run.

Christian

#3 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 8 lines · Christian Brauner

The only thing that is a bit unpleasant here is that this change breaks the consistency between the creation helpers:

do_mkdirat()
do_symlinkat()
do_linkat()
do_mknodat()

Quoted 11 lines

All but of them currently take
const char __user *pathname
and call
user_path_create()
with that do_mkdirat() change that's no longer true. One of the major benefits over the recent years in this code is naming and type consistency. And since it's just matter of time until io_uring will also gain support for do_{symlinkat,linkat,mknodat} I would think switching all of them to take a struct filename
and then have all do_* helpers call getname() might just be nicer in the long run.

OK, I can change the rest of them in the next version if no one objects.

Signature · 1 line
Dmitry Kadashev
#4 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

In reply to Christian Brauner
Quoted 8 lines · Christian Brauner

The only thing that is a bit unpleasant here is that this change breaks the consistency between the creation helpers:

do_mkdirat()
do_symlinkat()
do_linkat()
do_mknodat()

Quoted 11 lines

All but of them currently take
const char __user *pathname
and call
user_path_create()
with that do_mkdirat() change that's no longer true. One of the major benefits over the recent years in this code is naming and type consistency. And since it's just matter of time until io_uring will also gain support for do_{symlinkat,linkat,mknodat} I would think switching all of them to take a struct filename
and then have all do_* helpers call getname() might just be nicer in the long run.

So, I've finally got some time to look into this. do_mknodat() and do_symlinkat() are easy. But do_linkat() is more complicated, I could use some hints as to what's the reasonable way to implement the change.

The problem is linkat() requires CAP_DAC_READ_SEARCH capability if AT_EMPTY_PATH flag is passed. Right now do_linkat checks the capability before calling getname_flags (essentially). If do_linkat is changed to accept struct filename then there is no bulletproof way to force CAP_DAC_READ_SEARCH presence (e.g. if for whatever reason AT_EMPTY_PATH is not in flags passed to do_linkat). Also, it means that the caller is responsible to process AT_EMPTY_PATH in the first place, which means logic duplication.

Any ideas what's the best way to approach this?

Thanks.

Signature · 1 line
Dmitry Kadashev
#5 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 35 lines · Dmitry Kadashev
Quoted 8 lines · Christian Brauner

The only thing that is a bit unpleasant here is that this change breaks the consistency between the creation helpers:

do_mkdirat()
do_symlinkat()
do_linkat()
do_mknodat()

Quoted 11 lines

All but of them currently take
const char __user *pathname
and call
user_path_create()
with that do_mkdirat() change that's no longer true. One of the major benefits over the recent years in this code is naming and type consistency. And since it's just matter of time until io_uring will also gain support for do_{symlinkat,linkat,mknodat} I would think switching all of them to take a struct filename
and then have all do_* helpers call getname() might just be nicer in the long run.

So, I've finally got some time to look into this. do_mknodat() and do_symlinkat() are easy. But do_linkat() is more complicated, I could use some hints as to what's the reasonable way to implement the change.

The problem is linkat() requires CAP_DAC_READ_SEARCH capability if AT_EMPTY_PATH flag is passed. Right now do_linkat checks the capability before calling getname_flags (essentially). If do_linkat is changed to accept struct filename then there is no bulletproof way to force CAP_DAC_READ_SEARCH presence (e.g. if for whatever reason AT_EMPTY_PATH is not in flags passed to do_linkat). Also, it means that the caller is responsible to process AT_EMPTY_PATH in the first place, which means logic duplication.

Quoted 1 line

Any ideas what's the best way to approach this?

Ping. If someone can see how we can avoid making do_linkat() callers ensure the process has CAP_DAC_READ_SEARCH capability if AT_EMPTY_PATH was passed then the hints would be really appreciated.

The best I could come up with is something like getname_linkat(), which could be used by the do_linkat callers, but this sounds error prone and ugly.

Jens, do you want to keep the mkdir change out of 5.13 because of this?

Signature · 1 line
Dmitry Kadashev
Quoted 41 lines · Dmitry Kadashev
Quoted 8 lines · Christian Brauner

The only thing that is a bit unpleasant here is that this change breaks the consistency between the creation helpers:

do_mkdirat()
do_symlinkat()
do_linkat()
do_mknodat()

Quoted 11 lines

All but of them currently take
const char __user *pathname
and call
user_path_create()
with that do_mkdirat() change that's no longer true. One of the major benefits over the recent years in this code is naming and type consistency. And since it's just matter of time until io_uring will also gain support for do_{symlinkat,linkat,mknodat} I would think switching all of them to take a struct filename
and then have all do_* helpers call getname() might just be nicer in the long run.

So, I've finally got some time to look into this. do_mknodat() and do_symlinkat() are easy. But do_linkat() is more complicated, I could use some hints as to what's the reasonable way to implement the change.

The problem is linkat() requires CAP_DAC_READ_SEARCH capability if AT_EMPTY_PATH flag is passed. Right now do_linkat checks the capability before calling getname_flags (essentially). If do_linkat is changed to accept struct filename then there is no bulletproof way to force CAP_DAC_READ_SEARCH presence (e.g. if for whatever reason AT_EMPTY_PATH is not in flags passed to do_linkat). Also, it means that the caller is responsible to process AT_EMPTY_PATH in the first place, which means logic duplication.

Any ideas what's the best way to approach this?

Thanks.

--
Dmitry Kadashev

#6 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 36 lines · Dmitry Kadashev
Quoted 35 lines · Dmitry Kadashev
Quoted 8 lines · Christian Brauner

The only thing that is a bit unpleasant here is that this change breaks the consistency between the creation helpers:

do_mkdirat()
do_symlinkat()
do_linkat()
do_mknodat()

Quoted 11 lines

All but of them currently take
const char __user *pathname
and call
user_path_create()
with that do_mkdirat() change that's no longer true. One of the major benefits over the recent years in this code is naming and type consistency. And since it's just matter of time until io_uring will also gain support for do_{symlinkat,linkat,mknodat} I would think switching all of them to take a struct filename
and then have all do_* helpers call getname() might just be nicer in the long run.

So, I've finally got some time to look into this. do_mknodat() and do_symlinkat() are easy. But do_linkat() is more complicated, I could use some hints as to what's the reasonable way to implement the change.

The problem is linkat() requires CAP_DAC_READ_SEARCH capability if AT_EMPTY_PATH flag is passed. Right now do_linkat checks the capability before calling getname_flags (essentially). If do_linkat is changed to accept struct filename then there is no bulletproof way to force CAP_DAC_READ_SEARCH presence (e.g. if for whatever reason AT_EMPTY_PATH is not in flags passed to do_linkat). Also, it means that the caller is responsible to process AT_EMPTY_PATH in the first place, which means logic duplication.

Quoted 5 lines
Quoted 1 line

Any ideas what's the best way to approach this?

Ping. If someone can see how we can avoid making do_linkat() callers ensure the process has CAP_DAC_READ_SEARCH capability if AT_EMPTY_PATH was passed then the hints would be really appreciated.

Would something like this help?

From 7adeec2fe4a954e4e4b8a158a4d9fe705b82b978 Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Thu, 15 Apr 2021 12:03:42 +0200
Subject: [PATCH] namei: add getname_uflags()

There are a couple of places where we already open-code the (flags & AT_EMPTY_PATH) check and io_uring will likely add another one in the future. Let's just add a simple helper getname_uflags() that handles this directly and use it.
getname_flags() itself doesn't need access to lookup flags other than LOOKUP_EMPTY so this is basically just a boolean already so be honest about it.

---
 fs/exec.c          | 10 ++--------
 fs/fsopen.c        |  6 +++---
 fs/namei.c         |  6 +++---
 include/linux/fs.h |  4 ++++
 4 files changed, 12 insertions(+), 14 deletions(-)
fs/exec.c +2 -8
index 18594f11c31f..53c633f69f4a 100644
@@ -2069,10 +2069,7 @@ SYSCALL_DEFINE5(execveat,
 		const char __user *const __user *, envp,
 		int, flags)
 {
-	int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;
-
-	return do_execveat(fd,
-			   getname_flags(filename, lookup_flags, NULL),
+	return do_execveat(fd, getname_uflags(filename, flags),
 			   argv, envp, flags);
 }
 
@@ -2090,10 +2087,7 @@ COMPAT_SYSCALL_DEFINE5(execveat, int, fd,
 		       const compat_uptr_t __user *, envp,
 		       int,  flags)
 {
-	int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;
-
-	return compat_do_execveat(fd,
-				  getname_flags(filename, lookup_flags, NULL),
+	return compat_do_execveat(fd, getname_uflags(filename, flags),
 				  argv, envp, flags);
 }
 #endif
fs/fsopen.c +3 -3
index 27a890aa493a..00906abaf466 100644
@@ -321,7 +321,7 @@ SYSCALL_DEFINE5(fsconfig,
 	struct fs_context *fc;
 	struct fd f;
 	int ret;
-	int lookup_flags = 0;
+	bool lookup_empty = false;
 
 	struct fs_parameter param = {
 		.type	= fs_value_is_undefined,
@@ -411,11 +411,11 @@ SYSCALL_DEFINE5(fsconfig,
 		}
 		break;
 	case FSCONFIG_SET_PATH_EMPTY:
-		lookup_flags = LOOKUP_EMPTY;
+		lookup_empty = true;
 		fallthrough;
 	case FSCONFIG_SET_PATH:
 		param.type = fs_value_is_filename;
-		param.name = getname_flags(_value, lookup_flags, NULL);
+		param.name = getname_flags(_value, lookup_empty, NULL);
 		if (IS_ERR(param.name)) {
 			ret = PTR_ERR(param.name);
 			goto out_key;
fs/namei.c +3 -3
index 216f16e74351..7694f6bcd711 100644
@@ -125,7 +125,7 @@
 #define EMBEDDED_NAME_MAX	(PATH_MAX - offsetof(struct filename, iname))
 
 struct filename *
-getname_flags(const char __user *filename, int flags, int *empty)
+getname_flags(const char __user *filename, bool lookup_empty, int *empty)
 {
 	struct filename *result;
 	char *kname;
@@ -191,7 +191,7 @@ getname_flags(const char __user *filename, int flags, int *empty)
 	if (unlikely(!len)) {
 		if (empty)
 			*empty = 1;
-		if (!(flags & LOOKUP_EMPTY)) {
+		if (lookup_empty) {
 			putname(result);
 			return ERR_PTR(-ENOENT);
 		}
@@ -206,7 +206,7 @@ getname_flags(const char __user *filename, int flags, int *empty)
 struct filename *
 getname(const char __user * filename)
 {
-	return getname_flags(filename, 0, NULL);
+	return getname_flags(filename, false, NULL);
 }
 
 struct filename *
include/linux/fs.h +4 -0
index ec8f3ddf4a6a..6dbd629ece04 100644
@@ -2644,6 +2644,10 @@ static inline struct file *file_clone_open(struct file *file)
 extern int filp_close(struct file *, fl_owner_t id);
 
 extern struct filename *getname_flags(const char __user *, int, int *);
+extern struct filename *getname_uflags(const char __user *filename, int uflags)
+{
+	return getname_flags(filename, (flags & AT_EMPTY_PATH), NULL);
+}
 extern struct filename *getname(const char __user *);
 extern struct filename *getname_kernel(const char *);
 extern void putname(struct filename *name);
Signature · 1 line
2.27.0
#7 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 37 lines · Christian Brauner
Quoted 36 lines · Dmitry Kadashev
Quoted 35 lines · Dmitry Kadashev
Quoted 8 lines · Christian Brauner

The only thing that is a bit unpleasant here is that this change breaks the consistency between the creation helpers:

do_mkdirat()
do_symlinkat()
do_linkat()
do_mknodat()

Quoted 11 lines

All but of them currently take
const char __user *pathname
and call
user_path_create()
with that do_mkdirat() change that's no longer true. One of the major benefits over the recent years in this code is naming and type consistency. And since it's just matter of time until io_uring will also gain support for do_{symlinkat,linkat,mknodat} I would think switching all of them to take a struct filename
and then have all do_* helpers call getname() might just be nicer in the long run.

So, I've finally got some time to look into this. do_mknodat() and do_symlinkat() are easy. But do_linkat() is more complicated, I could use some hints as to what's the reasonable way to implement the change.

The problem is linkat() requires CAP_DAC_READ_SEARCH capability if AT_EMPTY_PATH flag is passed. Right now do_linkat checks the capability before calling getname_flags (essentially). If do_linkat is changed to accept struct filename then there is no bulletproof way to force CAP_DAC_READ_SEARCH presence (e.g. if for whatever reason AT_EMPTY_PATH is not in flags passed to do_linkat). Also, it means that the caller is responsible to process AT_EMPTY_PATH in the first place, which means logic duplication.

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

Any ideas what's the best way to approach this?

Ping. If someone can see how we can avoid making do_linkat() callers ensure the process has CAP_DAC_READ_SEARCH capability if AT_EMPTY_PATH was passed then the hints would be really appreciated.

Would something like this help?

Because I always forget this:
_Completely_ untested.

(And sorry for the late reply. Just a lot of mail.)

Quoted 125 lines

From 7adeec2fe4a954e4e4b8a158a4d9fe705b82b978 Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Thu, 15 Apr 2021 12:03:42 +0200
Subject: [PATCH] namei: add getname_uflags()

There are a couple of places where we already open-code the (flags & AT_EMPTY_PATH) check and io_uring will likely add another one in the future. Let's just add a simple helper getname_uflags() that handles this directly and use it.
getname_flags() itself doesn't need access to lookup flags other than LOOKUP_EMPTY so this is basically just a boolean already so be honest about it.

---
 fs/exec.c          | 10 ++--------
 fs/fsopen.c        |  6 +++---
 fs/namei.c         |  6 +++---
 include/linux/fs.h |  4 ++++
 4 files changed, 12 insertions(+), 14 deletions(-)
fs/exec.c +2 -8
index 18594f11c31f..53c633f69f4a 100644
@@ -2069,10 +2069,7 @@ SYSCALL_DEFINE5(execveat,
 		const char __user *const __user *, envp,
 		int, flags)
 {
-	int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;
-
-	return do_execveat(fd,
-			   getname_flags(filename, lookup_flags, NULL),
+	return do_execveat(fd, getname_uflags(filename, flags),
 			   argv, envp, flags);
 }
 
@@ -2090,10 +2087,7 @@ COMPAT_SYSCALL_DEFINE5(execveat, int, fd,
 		       const compat_uptr_t __user *, envp,
 		       int,  flags)
 {
-	int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;
-
-	return compat_do_execveat(fd,
-				  getname_flags(filename, lookup_flags, NULL),
+	return compat_do_execveat(fd, getname_uflags(filename, flags),
 				  argv, envp, flags);
 }
 #endif
fs/fsopen.c +3 -3
index 27a890aa493a..00906abaf466 100644
@@ -321,7 +321,7 @@ SYSCALL_DEFINE5(fsconfig,
 	struct fs_context *fc;
 	struct fd f;
 	int ret;
-	int lookup_flags = 0;
+	bool lookup_empty = false;
 
 	struct fs_parameter param = {
 		.type	= fs_value_is_undefined,
@@ -411,11 +411,11 @@ SYSCALL_DEFINE5(fsconfig,
 		}
 		break;
 	case FSCONFIG_SET_PATH_EMPTY:
-		lookup_flags = LOOKUP_EMPTY;
+		lookup_empty = true;
 		fallthrough;
 	case FSCONFIG_SET_PATH:
 		param.type = fs_value_is_filename;
-		param.name = getname_flags(_value, lookup_flags, NULL);
+		param.name = getname_flags(_value, lookup_empty, NULL);
 		if (IS_ERR(param.name)) {
 			ret = PTR_ERR(param.name);
 			goto out_key;
fs/namei.c +3 -3
index 216f16e74351..7694f6bcd711 100644
@@ -125,7 +125,7 @@
 #define EMBEDDED_NAME_MAX	(PATH_MAX - offsetof(struct filename, iname))
 
 struct filename *
-getname_flags(const char __user *filename, int flags, int *empty)
+getname_flags(const char __user *filename, bool lookup_empty, int *empty)
 {
 	struct filename *result;
 	char *kname;
@@ -191,7 +191,7 @@ getname_flags(const char __user *filename, int flags, int *empty)
 	if (unlikely(!len)) {
 		if (empty)
 			*empty = 1;
-		if (!(flags & LOOKUP_EMPTY)) {
+		if (lookup_empty) {
 			putname(result);
 			return ERR_PTR(-ENOENT);
 		}
@@ -206,7 +206,7 @@ getname_flags(const char __user *filename, int flags, int *empty)
 struct filename *
 getname(const char __user * filename)
 {
-	return getname_flags(filename, 0, NULL);
+	return getname_flags(filename, false, NULL);
 }
 
 struct filename *
include/linux/fs.h +4 -0
index ec8f3ddf4a6a..6dbd629ece04 100644
@@ -2644,6 +2644,10 @@ static inline struct file *file_clone_open(struct file *file)
 extern int filp_close(struct file *, fl_owner_t id);
 
 extern struct filename *getname_flags(const char __user *, int, int *);
+extern struct filename *getname_uflags(const char __user *filename, int uflags)
+{
+	return getname_flags(filename, (flags & AT_EMPTY_PATH), NULL);
+}
 extern struct filename *getname(const char __user *);
 extern struct filename *getname_kernel(const char *);
 extern void putname(struct filename *name);
Signature · 1 line
2.27.0
#8 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 3 lines · Christian Brauner
Quoted 1 line · Christian Brauner

Would something like this help?

Thanks for the reply, Christian!

But it's not the AT_EMPTY_PATH / LOOKUP_EMPTY part that is tricky, it's the fact that do_linkat() allows AT_EMPTY_PATH only if the process has CAP_DAC_READ_SEARCH capability. But AT_EMPTY_PATH is processed during getname(), so if do_linkat() accepts struct filename* then there is no bullet-proof way to force the capability.

We could do something like this:

do_linkat(oldfd, getname_uflags(oldname, flags), newfd,

          getname(newname), flags);

I.e. call getname_uflags() without checking the capability and rely on the fact that do_linkat() will do the checking. But this is fragile if somehow someone passes different flags to getname_uflags and do_linkat. And there is no way (that I know of) for do_linkat to actually check that AT_EMPTY_PATH was not used if it gets struct filename.

Or am I creating extra problems and the thing above is OK?

--
Dmitry Kadashev

#9 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 19 lines · Dmitry Kadashev
Quoted 3 lines · Christian Brauner
Quoted 1 line · Christian Brauner

Would something like this help?

Thanks for the reply, Christian!

But it's not the AT_EMPTY_PATH / LOOKUP_EMPTY part that is tricky, it's the fact that do_linkat() allows AT_EMPTY_PATH only if the process has CAP_DAC_READ_SEARCH capability. But AT_EMPTY_PATH is processed during getname(), so if do_linkat() accepts struct filename* then there is no bullet-proof way to force the capability.

We could do something like this:

do_linkat(oldfd, getname_uflags(oldname, flags), newfd,

          getname(newname), flags);
Quoted 7 lines

I.e. call getname_uflags() without checking the capability and rely on the fact that do_linkat() will do the checking. But this is fragile if somehow someone passes different flags to getname_uflags and do_linkat. And there is no way (that I know of) for do_linkat to actually check that AT_EMPTY_PATH was not used if it gets struct filename.

Or am I creating extra problems and the thing above is OK?

Hm, I get your point but if you e.g. look at fs/exec.c we already do have that problem today:

SYSCALL_DEFINE5(execveat,
int, fd, const char __user *, filename, const char __user *const __user *, argv, const char __user *const __user *, envp, int, flags)

{
	int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;

	return do_execveat(fd,
			   getname_flags(filename, lookup_flags, NULL),
			   argv, envp, flags);
}

The new simple flag helper would simplify things because right now it pretends that it cares about multiple flags where it actually just cares about whether or not empty pathnames are allowed and it forces callers to translate between flags too.

(Note, just my opinion this might get shot to hell.)

Christian

#10 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 16 lines · Christian Brauner

Hm, I get your point but if you e.g. look at fs/exec.c we already do have that problem today:

SYSCALL_DEFINE5(execveat,
int, fd, const char __user *, filename, const char __user *const __user *, argv, const char __user *const __user *, envp, int, flags)

{
        int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;

        return do_execveat(fd,
                           getname_flags(filename, lookup_flags, NULL),
                           argv, envp, flags);
}
Quoted 4 lines

The new simple flag helper would simplify things because right now it pretends that it cares about multiple flags where it actually just cares about whether or not empty pathnames are allowed and it forces callers to translate between flags too.

Hi Christian,

Sorry for the long silence, I got overwhelmed by the primary job and life stuff. I've finally carved out some time to work on this. I left out the "make getname_flags accept a single boolean instead of flags" bit to make the change smaller. If you think it's something that definitely should be in this patch set then let me know, I'll put it back in. I'm still somewhat concerned about the separation of the capability check and the actual logic to get the name, but I guess I'll just post what I have and collect comments.

I'll send the v4 soon.

Signature · 1 line
Dmitry Kadashev
#11 lore raw

Re: [PATCH v3 1/2] fs: make do_mkdirat() take struct filename

Quoted 23 lines · Dmitry Kadashev
Quoted 16 lines · Christian Brauner

Hm, I get your point but if you e.g. look at fs/exec.c we already do have that problem today:

SYSCALL_DEFINE5(execveat,
int, fd, const char __user *, filename, const char __user *const __user *, argv, const char __user *const __user *, envp, int, flags)

{
        int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;

        return do_execveat(fd,
                           getname_flags(filename, lookup_flags, NULL),
                           argv, envp, flags);
}
Quoted 4 lines

The new simple flag helper would simplify things because right now it pretends that it cares about multiple flags where it actually just cares about whether or not empty pathnames are allowed and it forces callers to translate between flags too.

Quoted 4 lines

Hi Christian,

Sorry for the long silence, I got overwhelmed by the primary job and life stuff. I've finally carved out some time to work on this. I left out the

No problem at all! Yeah, I can relate. :)

Quoted 6 lines

"make getname_flags accept a single boolean instead of flags" bit to make the change smaller. If you think it's something that definitely should be in this patch set then let me know, I'll put it back in. I'm still somewhat concerned about the separation of the capability check and the actual logic to get the name, but I guess I'll just post what I have and collect comments.

Sounds good!

Christian

#12 lore raw

PATCH v3 2/2 io_uring: add support for IORING_OP_MKDIRAT

In reply to Dmitry Kadashev

IORING_OP_MKDIRAT behaves like mkdirat(2) and takes the same flags and arguments.

---
 fs/io_uring.c                 | 55 +++++++++++++++++++++++++++++++++++
 include/uapi/linux/io_uring.h |  1 +
 2 files changed, 56 insertions(+)
fs/io_uring.c +55 -0
index 9a1a02fb3c9a..d9c100ed6132 100644
@@ -663,6 +663,13 @@ struct io_unlink {
 	struct filename			*filename;
 };
 
+struct io_mkdir {
+	struct file			*file;
+	int				dfd;
+	umode_t				mode;
+	struct filename			*filename;
+};
+
 struct io_completion {
 	struct file			*file;
 	struct list_head		list;
@@ -803,6 +810,7 @@ struct io_kiocb {
 		struct io_shutdown	shutdown;
 		struct io_rename	rename;
 		struct io_unlink	unlink;
+		struct io_mkdir		mkdir;
 		/* use only after cleaning per-op data, see io_clean_op() */
 		struct io_completion	compl;
 	};
@@ -1016,6 +1024,7 @@ static const struct io_op_def io_op_defs[] = {
 	},
 	[IORING_OP_RENAMEAT] = {},
 	[IORING_OP_UNLINKAT] = {},
+	[IORING_OP_MKDIRAT] = {},
 };
 
 static bool io_disarm_next(struct io_kiocb *req);
@@ -3523,6 +3532,44 @@ static int io_unlinkat(struct io_kiocb *req, unsigned int issue_flags)
 	return 0;
 }
 
+static int io_mkdirat_prep(struct io_kiocb *req,
+			    const struct io_uring_sqe *sqe)
+{
+	struct io_mkdir *mkd = &req->mkdir;
+	const char __user *fname;
+
+	if (unlikely(req->flags & REQ_F_FIXED_FILE))
+		return -EBADF;
+
+	mkd->dfd = READ_ONCE(sqe->fd);
+	mkd->mode = READ_ONCE(sqe->len);
+
+	fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
+	mkd->filename = getname(fname);
+	if (IS_ERR(mkd->filename))
+		return PTR_ERR(mkd->filename);
+
+	req->flags |= REQ_F_NEED_CLEANUP;
+	return 0;
+}
+
+static int io_mkdirat(struct io_kiocb *req, int issue_flags)
+{
+	struct io_mkdir *mkd = &req->mkdir;
+	int ret;
+
+	if (issue_flags & IO_URING_F_NONBLOCK)
+		return -EAGAIN;
+
+	ret = do_mkdirat(mkd->dfd, mkd->filename, mkd->mode);
+
+	req->flags &= ~REQ_F_NEED_CLEANUP;
+	if (ret < 0)
+		req_set_fail_links(req);
+	io_req_complete(req, ret);
+	return 0;
+}
+
 static int io_shutdown_prep(struct io_kiocb *req,
 			    const struct io_uring_sqe *sqe)
 {
@@ -5942,6 +5989,8 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 		return io_renameat_prep(req, sqe);
 	case IORING_OP_UNLINKAT:
 		return io_unlinkat_prep(req, sqe);
+	case IORING_OP_MKDIRAT:
+		return io_mkdirat_prep(req, sqe);
 	}
 
 	printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
@@ -6083,6 +6132,9 @@ static void io_clean_op(struct io_kiocb *req)
 		case IORING_OP_UNLINKAT:
 			putname(req->unlink.filename);
 			break;
+		case IORING_OP_MKDIRAT:
+			putname(req->mkdir.filename);
+			break;
 		}
 		req->flags &= ~REQ_F_NEED_CLEANUP;
 	}
@@ -6198,6 +6250,9 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)
 	case IORING_OP_UNLINKAT:
 		ret = io_unlinkat(req, issue_flags);
 		break;
+	case IORING_OP_MKDIRAT:
+		ret = io_mkdirat(req, issue_flags);
+		break;
 	default:
 		ret = -EINVAL;
 		break;
include/uapi/linux/io_uring.h +1 -0
index 5beaa6bbc6db..cf26a94ab880 100644
@@ -137,6 +137,7 @@ enum {
 	IORING_OP_SHUTDOWN,
 	IORING_OP_RENAMEAT,
 	IORING_OP_UNLINKAT,
+	IORING_OP_MKDIRAT,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
Signature · 1 line
2.30.2
maintainer
#13 lore raw

Re: [PATCH v3 2/2] io_uring: add support for IORING_OP_MKDIRAT

Quoted 2 lines · Dmitry Kadashev

IORING_OP_MKDIRAT behaves like mkdirat(2) and takes the same flags and arguments.

had the questions about interplay with audit been resolved?

#14 lore raw

Re: [PATCH v3 2/2] io_uring: add support for IORING_OP_MKDIRAT

Quoted 1 line · Al Viro

had the questions about interplay with audit been resolved?

Not to my knowledge. It's just Jens asked to rebase on for-5.13. I'll defer to Jens to discuss / decide whether adding new ops before the audit side is fixed worth it or not.

Signature · 1 line
Dmitry Kadashev