[PATCH 0/5] io_uring: add opcodes for current working directory

[PATCH 0/5] io_uring: add opcodes for current working directory

[Usama Arif]

This provides consistency between io_uring and the respective I/O syscall
and avoids having the user of liburing specify the cwd in sqe when working
with current working directory, for e.g. the user can directly call with
IORING_OP_RENAME instead of IORING_OP_RENAMEAT and providing AT_FDCWD in
sqe->fd and sqe->len, similar to syscall interface.

This is done for rename, unlink, mkdir, symlink and link in this
patch-series.

The tests for these opcodes in liburing are present at
https://github.com/uarif1/liburing/tree/cwd_opcodes. If the patches are
acceptable, I am happy to create a PR in above for the tests.

Thanks!

Usama Arif (5):
  io_uring: add rename opcode for current working directory
  io_uring: add unlink opcode for current working directory
  io_uring: add mkdir opcode for current working directory
  io_uring: add symlink opcode for current working directory
  io_uring: add link opcode for current working directory

 fs/io_uring.c                 | 116 ++++++++++++++++++++++++----------
 include/uapi/linux/io_uring.h |   5 ++
 2 files changed, 89 insertions(+), 32 deletions(-)

-- 
2.25.1

[PATCH 1/5] io_uring: add rename opcode for current working directory

[Usama Arif]

This provides consistency between io_uring and the respective I/O syscall
and avoids having the user of liburing specify the cwd in sqe for
IORING_OP_RENAMEAT.

Signed-off-by: Usama Arif <usama.arif@bytedance.com>
---
 fs/io_uring.c                 | 25 ++++++++++++++++++-------
 include/uapi/linux/io_uring.h |  1 +
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/fs/io_uring.c b/fs/io_uring.c
index 9f1c682d7caf..8bf56523ff7f 100644
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -1306,6 +1306,7 @@ static const struct io_op_def io_op_defs[] = {
 	[IORING_OP_SHUTDOWN] = {
 		.needs_file		= 1,
 	},
+	[IORING_OP_RENAME] = {},
 	[IORING_OP_RENAMEAT] = {},
 	[IORING_OP_UNLINKAT] = {},
 	[IORING_OP_MKDIRAT] = {},
@@ -1449,6 +1450,8 @@ const char *io_uring_get_opcode(u8 opcode)
 		return "TEE";
 	case IORING_OP_SHUTDOWN:
 		return "SHUTDOWN";
+	case IORING_OP_RENAME:
+		return "RENAME";
 	case IORING_OP_RENAMEAT:
 		return "RENAMEAT";
 	case IORING_OP_UNLINKAT:
@@ -4553,8 +4556,8 @@ static int io_write(struct io_kiocb *req, unsigned int issue_flags)
 	return ret;
 }
 
-static int io_renameat_prep(struct io_kiocb *req,
-			    const struct io_uring_sqe *sqe)
+static int io_rename_prep(struct io_kiocb *req,
+			    const struct io_uring_sqe *sqe, bool is_cwd)
 {
 	struct io_rename *ren = &req->rename;
 	const char __user *oldf, *newf;
@@ -4564,10 +4567,14 @@ static int io_renameat_prep(struct io_kiocb *req,
 	if (unlikely(req->flags & REQ_F_FIXED_FILE))
 		return -EBADF;
 
-	ren->old_dfd = READ_ONCE(sqe->fd);
+	if (is_cwd) {
+		ren->old_dfd = ren->new_dfd = AT_FDCWD;
+	} else {
+		ren->old_dfd = READ_ONCE(sqe->fd);
+		ren->new_dfd = READ_ONCE(sqe->len);
+	}
 	oldf = u64_to_user_ptr(READ_ONCE(sqe->addr));
 	newf = u64_to_user_ptr(READ_ONCE(sqe->addr2));
-	ren->new_dfd = READ_ONCE(sqe->len);
 	ren->flags = READ_ONCE(sqe->rename_flags);
 
 	ren->oldpath = getname(oldf);
@@ -4584,7 +4591,7 @@ static int io_renameat_prep(struct io_kiocb *req,
 	return 0;
 }
 
-static int io_renameat(struct io_kiocb *req, unsigned int issue_flags)
+static int io_rename(struct io_kiocb *req, unsigned int issue_flags)
 {
 	struct io_rename *ren = &req->rename;
 	int ret;
@@ -8076,8 +8083,10 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 		return io_tee_prep(req, sqe);
 	case IORING_OP_SHUTDOWN:
 		return io_shutdown_prep(req, sqe);
+	case IORING_OP_RENAME:
+		return io_rename_prep(req, sqe, 1);
 	case IORING_OP_RENAMEAT:
-		return io_renameat_prep(req, sqe);
+		return io_rename_prep(req, sqe, 0);
 	case IORING_OP_UNLINKAT:
 		return io_unlinkat_prep(req, sqe);
 	case IORING_OP_MKDIRAT:
@@ -8229,6 +8238,7 @@ static void io_clean_op(struct io_kiocb *req)
 			if (req->open.filename)
 				putname(req->open.filename);
 			break;
+		case IORING_OP_RENAME:
 		case IORING_OP_RENAMEAT:
 			putname(req->rename.oldpath);
 			putname(req->rename.newpath);
@@ -8395,8 +8405,9 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)
 	case IORING_OP_SHUTDOWN:
 		ret = io_shutdown(req, issue_flags);
 		break;
+	case IORING_OP_RENAME:
 	case IORING_OP_RENAMEAT:
-		ret = io_renameat(req, issue_flags);
+		ret = io_rename(req, issue_flags);
 		break;
 	case IORING_OP_UNLINKAT:
 		ret = io_unlinkat(req, issue_flags);
diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h
index 53e7dae92e42..73f4e1c4133d 100644
--- a/include/uapi/linux/io_uring.h
+++ b/include/uapi/linux/io_uring.h
@@ -189,6 +189,7 @@ enum io_uring_op {
 	IORING_OP_GETXATTR,
 	IORING_OP_SOCKET,
 	IORING_OP_URING_CMD,
+	IORING_OP_RENAME,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
-- 
2.25.1

[PATCH 2/5] io_uring: add unlink opcode for current working directory

[Usama Arif]

This provides consistency between io_uring and the respective I/O syscall
and avoids having the user of liburing specify the cwd in sqe for
IORING_OP_UNLINKAT.

Signed-off-by: Usama Arif <usama.arif@bytedance.com>
---
 fs/io_uring.c                 | 22 ++++++++++++++++------
 include/uapi/linux/io_uring.h |  1 +
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/fs/io_uring.c b/fs/io_uring.c
index 8bf56523ff7f..d38c5f54f6a4 100644
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -1308,6 +1308,7 @@ static const struct io_op_def io_op_defs[] = {
 	},
 	[IORING_OP_RENAME] = {},
 	[IORING_OP_RENAMEAT] = {},
+	[IORING_OP_UNLINK] = {},
 	[IORING_OP_UNLINKAT] = {},
 	[IORING_OP_MKDIRAT] = {},
 	[IORING_OP_SYMLINKAT] = {},
@@ -1454,6 +1455,8 @@ const char *io_uring_get_opcode(u8 opcode)
 		return "RENAME";
 	case IORING_OP_RENAMEAT:
 		return "RENAMEAT";
+	case IORING_OP_UNLINK:
+		return "UNLINK";
 	case IORING_OP_UNLINKAT:
 		return "UNLINKAT";
 	case IORING_OP_MKDIRAT:
@@ -4847,8 +4850,8 @@ static int io_setxattr(struct io_kiocb *req, unsigned int issue_flags)
 	return 0;
 }
 
-static int io_unlinkat_prep(struct io_kiocb *req,
-			    const struct io_uring_sqe *sqe)
+static int io_unlink_prep(struct io_kiocb *req,
+			    const struct io_uring_sqe *sqe, bool is_cwd)
 {
 	struct io_unlink *un = &req->unlink;
 	const char __user *fname;
@@ -4858,7 +4861,10 @@ static int io_unlinkat_prep(struct io_kiocb *req,
 	if (unlikely(req->flags & REQ_F_FIXED_FILE))
 		return -EBADF;
 
-	un->dfd = READ_ONCE(sqe->fd);
+	if (is_cwd)
+		un->dfd = AT_FDCWD;
+	else
+		un->dfd = READ_ONCE(sqe->fd);
 
 	un->flags = READ_ONCE(sqe->unlink_flags);
 	if (un->flags & ~AT_REMOVEDIR)
@@ -4873,7 +4879,7 @@ static int io_unlinkat_prep(struct io_kiocb *req,
 	return 0;
 }
 
-static int io_unlinkat(struct io_kiocb *req, unsigned int issue_flags)
+static int io_unlink(struct io_kiocb *req, unsigned int issue_flags)
 {
 	struct io_unlink *un = &req->unlink;
 	int ret;
@@ -8087,8 +8093,10 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 		return io_rename_prep(req, sqe, 1);
 	case IORING_OP_RENAMEAT:
 		return io_rename_prep(req, sqe, 0);
+	case IORING_OP_UNLINK:
+		return io_unlink_prep(req, sqe, 1);
 	case IORING_OP_UNLINKAT:
-		return io_unlinkat_prep(req, sqe);
+		return io_unlink_prep(req, sqe, 0);
 	case IORING_OP_MKDIRAT:
 		return io_mkdirat_prep(req, sqe);
 	case IORING_OP_SYMLINKAT:
@@ -8243,6 +8251,7 @@ static void io_clean_op(struct io_kiocb *req)
 			putname(req->rename.oldpath);
 			putname(req->rename.newpath);
 			break;
+		case IORING_OP_UNLINK:
 		case IORING_OP_UNLINKAT:
 			putname(req->unlink.filename);
 			break;
@@ -8409,8 +8418,9 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)
 	case IORING_OP_RENAMEAT:
 		ret = io_rename(req, issue_flags);
 		break;
+	case IORING_OP_UNLINK:
 	case IORING_OP_UNLINKAT:
-		ret = io_unlinkat(req, issue_flags);
+		ret = io_unlink(req, issue_flags);
 		break;
 	case IORING_OP_MKDIRAT:
 		ret = io_mkdirat(req, issue_flags);
diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h
index 73f4e1c4133d..7828b7183d01 100644
--- a/include/uapi/linux/io_uring.h
+++ b/include/uapi/linux/io_uring.h
@@ -190,6 +190,7 @@ enum io_uring_op {
 	IORING_OP_SOCKET,
 	IORING_OP_URING_CMD,
 	IORING_OP_RENAME,
+	IORING_OP_UNLINK,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
-- 
2.25.1

[PATCH 3/5] io_uring: add mkdir opcode for current working directory

[Usama Arif]

This provides consistency between io_uring and the respective I/O syscall
and avoids having the user of liburing specify the cwd in sqe for
IORING_OP_MKDIRAT.

Signed-off-by: Usama Arif <usama.arif@bytedance.com>
---
 fs/io_uring.c                 | 20 +++++++++++++++-----
 include/uapi/linux/io_uring.h |  1 +
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/fs/io_uring.c b/fs/io_uring.c
index d38c5f54f6a4..9c9fa0b3938d 100644
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -1310,6 +1310,7 @@ static const struct io_op_def io_op_defs[] = {
 	[IORING_OP_RENAMEAT] = {},
 	[IORING_OP_UNLINK] = {},
 	[IORING_OP_UNLINKAT] = {},
+	[IORING_OP_MKDIR] = {},
 	[IORING_OP_MKDIRAT] = {},
 	[IORING_OP_SYMLINKAT] = {},
 	[IORING_OP_LINKAT] = {},
@@ -1459,6 +1460,8 @@ const char *io_uring_get_opcode(u8 opcode)
 		return "UNLINK";
 	case IORING_OP_UNLINKAT:
 		return "UNLINKAT";
+	case IORING_OP_MKDIR:
+		return "MKDIR";
 	case IORING_OP_MKDIRAT:
 		return "MKDIRAT";
 	case IORING_OP_SYMLINKAT:
@@ -4897,8 +4900,8 @@ static int io_unlink(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)
+static int io_mkdir_prep(struct io_kiocb *req,
+			    const struct io_uring_sqe *sqe, bool is_cwd)
 {
 	struct io_mkdir *mkd = &req->mkdir;
 	const char __user *fname;
@@ -4908,7 +4911,10 @@ static int io_mkdirat_prep(struct io_kiocb *req,
 	if (unlikely(req->flags & REQ_F_FIXED_FILE))
 		return -EBADF;
 
-	mkd->dfd = READ_ONCE(sqe->fd);
+	if (is_cwd)
+		mkd->dfd = AT_FDCWD;
+	else
+		mkd->dfd = READ_ONCE(sqe->fd);
 	mkd->mode = READ_ONCE(sqe->len);
 
 	fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
@@ -4920,7 +4926,7 @@ static int io_mkdirat_prep(struct io_kiocb *req,
 	return 0;
 }
 
-static int io_mkdirat(struct io_kiocb *req, unsigned int issue_flags)
+static int io_mkdir(struct io_kiocb *req, unsigned int issue_flags)
 {
 	struct io_mkdir *mkd = &req->mkdir;
 	int ret;
@@ -8097,8 +8103,10 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 		return io_unlink_prep(req, sqe, 1);
 	case IORING_OP_UNLINKAT:
 		return io_unlink_prep(req, sqe, 0);
+	case IORING_OP_MKDIR:
+		return io_mkdir_prep(req, sqe, 1);
 	case IORING_OP_MKDIRAT:
-		return io_mkdirat_prep(req, sqe);
+		return io_mkdir_prep(req, sqe, 0);
 	case IORING_OP_SYMLINKAT:
 		return io_symlinkat_prep(req, sqe);
 	case IORING_OP_LINKAT:
@@ -8255,6 +8263,7 @@ static void io_clean_op(struct io_kiocb *req)
 		case IORING_OP_UNLINKAT:
 			putname(req->unlink.filename);
 			break;
+		case IORING_OP_MKDIR:
 		case IORING_OP_MKDIRAT:
 			putname(req->mkdir.filename);
 			break;
@@ -8422,6 +8431,7 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)
 	case IORING_OP_UNLINKAT:
 		ret = io_unlink(req, issue_flags);
 		break;
+	case IORING_OP_MKDIR:
 	case IORING_OP_MKDIRAT:
 		ret = io_mkdirat(req, issue_flags);
 		break;
diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h
index 7828b7183d01..58f2e0611152 100644
--- a/include/uapi/linux/io_uring.h
+++ b/include/uapi/linux/io_uring.h
@@ -191,6 +191,7 @@ enum io_uring_op {
 	IORING_OP_URING_CMD,
 	IORING_OP_RENAME,
 	IORING_OP_UNLINK,
+	IORING_OP_MKDIR,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
-- 
2.25.1

[PATCH 4/5] io_uring: add symlink opcode for current working directory

[Usama Arif]

This provides consistency between io_uring and the respective I/O syscall
and avoids having the user of liburing specify the cwd in sqe for
IORING_OP_SYMLINKAT.

Signed-off-by: Usama Arif <usama.arif@bytedance.com>
---
 fs/io_uring.c                 | 20 +++++++++++++++-----
 include/uapi/linux/io_uring.h |  1 +
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/fs/io_uring.c b/fs/io_uring.c
index 9c9fa0b3938d..4050377619d3 100644
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -1312,6 +1312,7 @@ static const struct io_op_def io_op_defs[] = {
 	[IORING_OP_UNLINKAT] = {},
 	[IORING_OP_MKDIR] = {},
 	[IORING_OP_MKDIRAT] = {},
+	[IORING_OP_SYMLINK] = {},
 	[IORING_OP_SYMLINKAT] = {},
 	[IORING_OP_LINKAT] = {},
 	[IORING_OP_MSG_RING] = {
@@ -1464,6 +1465,8 @@ const char *io_uring_get_opcode(u8 opcode)
 		return "MKDIR";
 	case IORING_OP_MKDIRAT:
 		return "MKDIRAT";
+	case IORING_OP_SYMLINK:
+		return "SYMLINK";
 	case IORING_OP_SYMLINKAT:
 		return "SYMLINKAT";
 	case IORING_OP_LINKAT:
@@ -4941,8 +4944,8 @@ static int io_mkdir(struct io_kiocb *req, unsigned int issue_flags)
 	return 0;
 }
 
-static int io_symlinkat_prep(struct io_kiocb *req,
-			    const struct io_uring_sqe *sqe)
+static int io_symlink_prep(struct io_kiocb *req,
+			    const struct io_uring_sqe *sqe, bool is_cwd)
 {
 	struct io_symlink *sl = &req->symlink;
 	const char __user *oldpath, *newpath;
@@ -4952,7 +4955,10 @@ static int io_symlinkat_prep(struct io_kiocb *req,
 	if (unlikely(req->flags & REQ_F_FIXED_FILE))
 		return -EBADF;
 
-	sl->new_dfd = READ_ONCE(sqe->fd);
+	if (is_cwd)
+		sl->new_dfd = AT_FDCWD;
+	else
+		sl->new_dfd = READ_ONCE(sqe->fd);
 	oldpath = u64_to_user_ptr(READ_ONCE(sqe->addr));
 	newpath = u64_to_user_ptr(READ_ONCE(sqe->addr2));
 
@@ -4970,7 +4976,7 @@ static int io_symlinkat_prep(struct io_kiocb *req,
 	return 0;
 }
 
-static int io_symlinkat(struct io_kiocb *req, unsigned int issue_flags)
+static int io_symlink(struct io_kiocb *req, unsigned int issue_flags)
 {
 	struct io_symlink *sl = &req->symlink;
 	int ret;
@@ -8107,8 +8113,10 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 		return io_mkdir_prep(req, sqe, 1);
 	case IORING_OP_MKDIRAT:
 		return io_mkdir_prep(req, sqe, 0);
+	case IORING_OP_SYMLINK:
+		return io_symlink_prep(req, sqe, 1);
 	case IORING_OP_SYMLINKAT:
-		return io_symlinkat_prep(req, sqe);
+		return io_symlink_prep(req, sqe, 0);
 	case IORING_OP_LINKAT:
 		return io_linkat_prep(req, sqe);
 	case IORING_OP_MSG_RING:
@@ -8267,6 +8275,7 @@ static void io_clean_op(struct io_kiocb *req)
 		case IORING_OP_MKDIRAT:
 			putname(req->mkdir.filename);
 			break;
+		case IORING_OP_SYMLINK:
 		case IORING_OP_SYMLINKAT:
 			putname(req->symlink.oldpath);
 			putname(req->symlink.newpath);
@@ -8435,6 +8444,7 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)
 	case IORING_OP_MKDIRAT:
 		ret = io_mkdirat(req, issue_flags);
 		break;
+	case IORING_OP_SYMLINK:
 	case IORING_OP_SYMLINKAT:
 		ret = io_symlinkat(req, issue_flags);
 		break;
diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h
index 58f2e0611152..74e6b70638ee 100644
--- a/include/uapi/linux/io_uring.h
+++ b/include/uapi/linux/io_uring.h
@@ -192,6 +192,7 @@ enum io_uring_op {
 	IORING_OP_RENAME,
 	IORING_OP_UNLINK,
 	IORING_OP_MKDIR,
+	IORING_OP_SYMLINK,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
-- 
2.25.1

[PATCH 5/5] io_uring: add link opcode for current working directory

[Usama Arif]

This provides consistency between io_uring and the respective I/O syscall
and avoids having the user of liburing specify the cwd in sqe for
IORING_OP_LINKAT.

Signed-off-by: Usama Arif <usama.arif@bytedance.com>
---
 fs/io_uring.c                 | 29 ++++++++++++++++++++---------
 include/uapi/linux/io_uring.h |  1 +
 2 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/fs/io_uring.c b/fs/io_uring.c
index 4050377619d3..31dfad3a7312 100644
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -1314,6 +1314,7 @@ static const struct io_op_def io_op_defs[] = {
 	[IORING_OP_MKDIRAT] = {},
 	[IORING_OP_SYMLINK] = {},
 	[IORING_OP_SYMLINKAT] = {},
+	[IORING_OP_LINK] = {},
 	[IORING_OP_LINKAT] = {},
 	[IORING_OP_MSG_RING] = {
 		.needs_file		= 1,
@@ -1469,6 +1470,8 @@ const char *io_uring_get_opcode(u8 opcode)
 		return "SYMLINK";
 	case IORING_OP_SYMLINKAT:
 		return "SYMLINKAT";
+	case IORING_OP_LINK:
+		return "LINK";
 	case IORING_OP_LINKAT:
 		return "LINKAT";
 	case IORING_OP_MSG_RING:
@@ -4991,8 +4994,8 @@ static int io_symlink(struct io_kiocb *req, unsigned int issue_flags)
 	return 0;
 }
 
-static int io_linkat_prep(struct io_kiocb *req,
-			    const struct io_uring_sqe *sqe)
+static int io_link_prep(struct io_kiocb *req,
+			    const struct io_uring_sqe *sqe, bool is_cwd)
 {
 	struct io_hardlink *lnk = &req->hardlink;
 	const char __user *oldf, *newf;
@@ -5002,8 +5005,12 @@ static int io_linkat_prep(struct io_kiocb *req,
 	if (unlikely(req->flags & REQ_F_FIXED_FILE))
 		return -EBADF;
 
-	lnk->old_dfd = READ_ONCE(sqe->fd);
-	lnk->new_dfd = READ_ONCE(sqe->len);
+	if (is_cwd) {
+		lnk->old_dfd = lnk->new_dfd = AT_FDCWD;
+	} else {
+		lnk->old_dfd = READ_ONCE(sqe->fd);
+		lnk->new_dfd = READ_ONCE(sqe->len);
+	}
 	oldf = u64_to_user_ptr(READ_ONCE(sqe->addr));
 	newf = u64_to_user_ptr(READ_ONCE(sqe->addr2));
 	lnk->flags = READ_ONCE(sqe->hardlink_flags);
@@ -5022,7 +5029,7 @@ static int io_linkat_prep(struct io_kiocb *req,
 	return 0;
 }
 
-static int io_linkat(struct io_kiocb *req, unsigned int issue_flags)
+static int io_link(struct io_kiocb *req, unsigned int issue_flags)
 {
 	struct io_hardlink *lnk = &req->hardlink;
 	int ret;
@@ -8117,8 +8124,10 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 		return io_symlink_prep(req, sqe, 1);
 	case IORING_OP_SYMLINKAT:
 		return io_symlink_prep(req, sqe, 0);
+	case IORING_OP_LINK:
+		return io_link_prep(req, sqe, 1);
 	case IORING_OP_LINKAT:
-		return io_linkat_prep(req, sqe);
+		return io_link_prep(req, sqe, 0);
 	case IORING_OP_MSG_RING:
 		return io_msg_ring_prep(req, sqe);
 	case IORING_OP_FSETXATTR:
@@ -8280,6 +8289,7 @@ static void io_clean_op(struct io_kiocb *req)
 			putname(req->symlink.oldpath);
 			putname(req->symlink.newpath);
 			break;
+		case IORING_OP_LINK:
 		case IORING_OP_LINKAT:
 			putname(req->hardlink.oldpath);
 			putname(req->hardlink.newpath);
@@ -8442,14 +8452,15 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)
 		break;
 	case IORING_OP_MKDIR:
 	case IORING_OP_MKDIRAT:
-		ret = io_mkdirat(req, issue_flags);
+		ret = io_mkdir(req, issue_flags);
 		break;
 	case IORING_OP_SYMLINK:
 	case IORING_OP_SYMLINKAT:
-		ret = io_symlinkat(req, issue_flags);
+		ret = io_symlink(req, issue_flags);
 		break;
+	case IORING_OP_LINK:
 	case IORING_OP_LINKAT:
-		ret = io_linkat(req, issue_flags);
+		ret = io_link(req, issue_flags);
 		break;
 	case IORING_OP_MSG_RING:
 		ret = io_msg_ring(req, issue_flags);
diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h
index 74e6b70638ee..41391a762ad1 100644
--- a/include/uapi/linux/io_uring.h
+++ b/include/uapi/linux/io_uring.h
@@ -193,6 +193,7 @@ enum io_uring_op {
 	IORING_OP_UNLINK,
 	IORING_OP_MKDIR,
 	IORING_OP_SYMLINK,
+	IORING_OP_LINK,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
-- 
2.25.1

Re: [PATCH 0/5] io_uring: add opcodes for current working directory

[Jens Axboe]

On 5/31/22 12:41 PM, Usama Arif wrote:
> This provides consistency between io_uring and the respective I/O syscall
> and avoids having the user of liburing specify the cwd in sqe when working
> with current working directory, for e.g. the user can directly call with
> IORING_OP_RENAME instead of IORING_OP_RENAMEAT and providing AT_FDCWD in
> sqe->fd and sqe->len, similar to syscall interface.
> 
> This is done for rename, unlink, mkdir, symlink and link in this
> patch-series.
> 
> The tests for these opcodes in liburing are present at
> https://github.com/uarif1/liburing/tree/cwd_opcodes. If the patches are
> acceptable, I am happy to create a PR in above for the tests.

Can't we just provide prep helpers for them in liburing?

-- 
Jens Axboe

Re: [External] Re: [PATCH 0/5] io_uring: add opcodes for current working directory

[Usama Arif]

On 31/05/2022 19:58, Jens Axboe wrote:
> On 5/31/22 12:41 PM, Usama Arif wrote:
>> This provides consistency between io_uring and the respective I/O syscall
>> and avoids having the user of liburing specify the cwd in sqe when working
>> with current working directory, for e.g. the user can directly call with
>> IORING_OP_RENAME instead of IORING_OP_RENAMEAT and providing AT_FDCWD in
>> sqe->fd and sqe->len, similar to syscall interface.
>>
>> This is done for rename, unlink, mkdir, symlink and link in this
>> patch-series.
>>
>> The tests for these opcodes in liburing are present at
>> https://github.com/uarif1/liburing/tree/cwd_opcodes. If the patches are
>> acceptable, I am happy to create a PR in above for the tests.
> 
> Can't we just provide prep helpers for them in liburing?
> 

We could add a io_uring_prep_unlink with IORING_OP_UNLINKAT and AT_FDCWD 
in liburing. But i guess adding in kernel adds a more consistent 
interface? and allows to make calls bypassing liburing (although i guess 
people probably don't bypass liburing that much :))

Making the changes in both kernel and liburing provides more of a 
standard interface in my opinion so maybe it looks better. But happy to 
just create a PR in liburing only with prep helpers as you suggested if 
you think that is better?

Thanks!

Re: [External] Re: [PATCH 0/5] io_uring: add opcodes for current working directory

[Jens Axboe]

On 5/31/22 1:18 PM, Usama Arif wrote:
> 
> 
> On 31/05/2022 19:58, Jens Axboe wrote:
>> On 5/31/22 12:41 PM, Usama Arif wrote:
>>> This provides consistency between io_uring and the respective I/O syscall
>>> and avoids having the user of liburing specify the cwd in sqe when working
>>> with current working directory, for e.g. the user can directly call with
>>> IORING_OP_RENAME instead of IORING_OP_RENAMEAT and providing AT_FDCWD in
>>> sqe->fd and sqe->len, similar to syscall interface.
>>>
>>> This is done for rename, unlink, mkdir, symlink and link in this
>>> patch-series.
>>>
>>> The tests for these opcodes in liburing are present at
>>> https://github.com/uarif1/liburing/tree/cwd_opcodes. If the patches are
>>> acceptable, I am happy to create a PR in above for the tests.
>>
>> Can't we just provide prep helpers for them in liburing?
>>
> 
> We could add a io_uring_prep_unlink with IORING_OP_UNLINKAT and
> AT_FDCWD in liburing. But i guess adding in kernel adds a more
> consistent interface? and allows to make calls bypassing liburing
> (although i guess people probably don't bypass liburing that much :))

I'm not really aware of much that doesn't use the library, and even
those would most likely use the liburing man pages as that's all we
have. The kernel API is raw. If you use that, I would expect you to know
that you can just use AT_FDCWD!

> Making the changes in both kernel and liburing provides more of a
> standard interface in my opinion so maybe it looks better. But happy
> to just create a PR in liburing only with prep helpers as you
> suggested if you think that is better?

I don't disagree with that, but it seems silly to waste 5 opcodes on
something that is a strict subset of something that is already there.
Hence my suggestion would be to just add io_uring_prep_link() etc
helpers to make it simpler to use, without having to add 5 extra
opcodes.

-- 
Jens Axboe

Re: [PATCH 0/5] io_uring: add opcodes for current working directory

[Usama Arif]

On 31/05/2022 20:22, Jens Axboe wrote:
> On 5/31/22 1:18 PM, Usama Arif wrote:
>>
>>
>> On 31/05/2022 19:58, Jens Axboe wrote:
>>> On 5/31/22 12:41 PM, Usama Arif wrote:
>>>> This provides consistency between io_uring and the respective I/O syscall
>>>> and avoids having the user of liburing specify the cwd in sqe when working
>>>> with current working directory, for e.g. the user can directly call with
>>>> IORING_OP_RENAME instead of IORING_OP_RENAMEAT and providing AT_FDCWD in
>>>> sqe->fd and sqe->len, similar to syscall interface.
>>>>
>>>> This is done for rename, unlink, mkdir, symlink and link in this
>>>> patch-series.
>>>>
>>>> The tests for these opcodes in liburing are present at
>>>> https://github.com/uarif1/liburing/tree/cwd_opcodes. If the patches are
>>>> acceptable, I am happy to create a PR in above for the tests.
>>>
>>> Can't we just provide prep helpers for them in liburing?
>>>
>>
>> We could add a io_uring_prep_unlink with IORING_OP_UNLINKAT and
>> AT_FDCWD in liburing. But i guess adding in kernel adds a more
>> consistent interface? and allows to make calls bypassing liburing
>> (although i guess people probably don't bypass liburing that much :))
> 
> I'm not really aware of much that doesn't use the library, and even
> those would most likely use the liburing man pages as that's all we
> have. The kernel API is raw. If you use that, I would expect you to know
> that you can just use AT_FDCWD!
> 
>> Making the changes in both kernel and liburing provides more of a
>> standard interface in my opinion so maybe it looks better. But happy
>> to just create a PR in liburing only with prep helpers as you
>> suggested if you think that is better?
> 
> I don't disagree with that, but it seems silly to waste 5 opcodes on
> something that is a strict subset of something that is already there.
> Hence my suggestion would be to just add io_uring_prep_link() etc
> helpers to make it simpler to use, without having to add 5 extra
> opcodes.
> 

Thanks, I have created a PR for it on 
https://github.com/axboe/liburing/pull/588. We can review it there if it 
makes sense!

Re: [PATCH 0/5] io_uring: add opcodes for current working directory

[Jens Axboe]

On 5/31/22 3:35 PM, Usama Arif wrote:
> 
> 
> On 31/05/2022 20:22, Jens Axboe wrote:
>> On 5/31/22 1:18 PM, Usama Arif wrote:
>>>
>>>
>>> On 31/05/2022 19:58, Jens Axboe wrote:
>>>> On 5/31/22 12:41 PM, Usama Arif wrote:
>>>>> This provides consistency between io_uring and the respective I/O syscall
>>>>> and avoids having the user of liburing specify the cwd in sqe when working
>>>>> with current working directory, for e.g. the user can directly call with
>>>>> IORING_OP_RENAME instead of IORING_OP_RENAMEAT and providing AT_FDCWD in
>>>>> sqe->fd and sqe->len, similar to syscall interface.
>>>>>
>>>>> This is done for rename, unlink, mkdir, symlink and link in this
>>>>> patch-series.
>>>>>
>>>>> The tests for these opcodes in liburing are present at
>>>>> https://github.com/uarif1/liburing/tree/cwd_opcodes. If the patches are
>>>>> acceptable, I am happy to create a PR in above for the tests.
>>>>
>>>> Can't we just provide prep helpers for them in liburing?
>>>>
>>>
>>> We could add a io_uring_prep_unlink with IORING_OP_UNLINKAT and
>>> AT_FDCWD in liburing. But i guess adding in kernel adds a more
>>> consistent interface? and allows to make calls bypassing liburing
>>> (although i guess people probably don't bypass liburing that much :))
>>
>> I'm not really aware of much that doesn't use the library, and even
>> those would most likely use the liburing man pages as that's all we
>> have. The kernel API is raw. If you use that, I would expect you to know
>> that you can just use AT_FDCWD!
>>
>>> Making the changes in both kernel and liburing provides more of a
>>> standard interface in my opinion so maybe it looks better. But happy
>>> to just create a PR in liburing only with prep helpers as you
>>> suggested if you think that is better?
>>
>> I don't disagree with that, but it seems silly to waste 5 opcodes on
>> something that is a strict subset of something that is already there.
>> Hence my suggestion would be to just add io_uring_prep_link() etc
>> helpers to make it simpler to use, without having to add 5 extra
>> opcodes.
>>
> 
> Thanks, I have created a PR for it on
> https://github.com/axboe/liburing/pull/588. We can review it there if
> it makes sense!

Sounds good, we'll move it there.

-- 
Jens Axboe