[PATCH v5 0/2] io_uring: add support for ftruncate

[PATCH v5 0/2] io_uring: add support for ftruncate

[Tony Solomonik]

This patch adds support for doing truncate through io_uring, eliminating
the need for applications to roll their own thread pool or offload
mechanism to be able to do non-blocking truncates.

Tony Solomonik (2):
  Add ftruncate_file that truncates a struct file
  io_uring: add support for ftruncate

 fs/internal.h                 |  1 +
 fs/open.c                     | 53 ++++++++++++++++++-----------------
 include/uapi/linux/io_uring.h |  1 +
 io_uring/Makefile             |  2 +-
 io_uring/opdef.c              | 10 +++++++
 io_uring/truncate.c           | 48 +++++++++++++++++++++++++++++++
 io_uring/truncate.h           |  4 +++
 7 files changed, 93 insertions(+), 26 deletions(-)
 create mode 100644 io_uring/truncate.c
 create mode 100644 io_uring/truncate.h


base-commit: d3fa86b1a7b4cdc4367acacea16b72e0a200b3d7
-- 
2.34.1

[PATCH v5 1/2] Add ftruncate_file that truncates a struct file

[Tony Solomonik]

do_sys_ftruncate receives a file descriptor, fgets the struct file, and
finally actually truncates the file.

ftruncate_file allows for passing in a file directly, with the caller
already holding a reference to it.

Signed-off-by: Tony Solomonik <tony.solomonik@gmail.com>
---
 fs/internal.h |  1 +
 fs/open.c     | 53 +++++++++++++++++++++++++++------------------------
 2 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/fs/internal.h b/fs/internal.h
index 58e43341aebf..78a641ebd16e 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -182,6 +182,7 @@ extern struct open_how build_open_how(int flags, umode_t mode);
 extern int build_open_flags(const struct open_how *how, struct open_flags *op);
 extern struct file *__close_fd_get_file(unsigned int fd);
 
+long ftruncate_file(struct file *file, loff_t length, int small);
 long do_sys_ftruncate(unsigned int fd, loff_t length, int small);
 int chmod_common(const struct path *path, umode_t mode);
 int do_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group,
diff --git a/fs/open.c b/fs/open.c
index 02dc608d40d8..649d38eecfe4 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -154,49 +154,52 @@ COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length
 }
 #endif
 
-long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
+long ftruncate_file(struct file *file, loff_t length, int small)
 {
 	struct inode *inode;
 	struct dentry *dentry;
-	struct fd f;
 	int error;
 
-	error = -EINVAL;
-	if (length < 0)
-		goto out;
-	error = -EBADF;
-	f = fdget(fd);
-	if (!f.file)
-		goto out;
-
 	/* explicitly opened as large or we are on 64-bit box */
-	if (f.file->f_flags & O_LARGEFILE)
+	if (file->f_flags & O_LARGEFILE)
 		small = 0;
 
-	dentry = f.file->f_path.dentry;
+	dentry = file->f_path.dentry;
 	inode = dentry->d_inode;
-	error = -EINVAL;
-	if (!S_ISREG(inode->i_mode) || !(f.file->f_mode & FMODE_WRITE))
-		goto out_putf;
+	if (!S_ISREG(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
+		return -EINVAL;
 
-	error = -EINVAL;
 	/* Cannot ftruncate over 2^31 bytes without large file support */
 	if (small && length > MAX_NON_LFS)
-		goto out_putf;
+		return -EINVAL;
 
-	error = -EPERM;
 	/* Check IS_APPEND on real upper inode */
-	if (IS_APPEND(file_inode(f.file)))
-		goto out_putf;
+	if (IS_APPEND(file_inode(file)))
+		return -EPERM;
 	sb_start_write(inode->i_sb);
-	error = security_file_truncate(f.file);
+	error = security_file_truncate(file);
 	if (!error)
-		error = do_truncate(file_mnt_idmap(f.file), dentry, length,
-				    ATTR_MTIME | ATTR_CTIME, f.file);
+		error = do_truncate(file_mnt_idmap(file), dentry, length,
+				    ATTR_MTIME | ATTR_CTIME, file);
 	sb_end_write(inode->i_sb);
-out_putf:
+
+  return error;
+}
+
+long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
+{
+	struct fd f;
+	int error;
+
+	if (length < 0)
+		return -EINVAL;
+	f = fdget(fd);
+	if (!f.file)
+		return -EBADF;
+
+	error = ftruncate_file(f.file, length, small);
+
 	fdput(f);
-out:
 	return error;
 }
 
-- 
2.34.1

[PATCH v5 2/2] io_uring: add support for ftruncate

[Tony Solomonik]

Adds support for doing truncate through io_uring, eliminating
the need for applications to roll their own thread pool or offload
mechanism to be able to do non-blocking truncates.

Signed-off-by: Tony Solomonik <tony.solomonik@gmail.com>
---
 include/uapi/linux/io_uring.h |  1 +
 io_uring/Makefile             |  2 +-
 io_uring/opdef.c              | 10 ++++++++
 io_uring/truncate.c           | 48 +++++++++++++++++++++++++++++++++++
 io_uring/truncate.h           |  4 +++
 5 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 io_uring/truncate.c
 create mode 100644 io_uring/truncate.h

diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h
index f1c16f817742..be682e000c94 100644
--- a/include/uapi/linux/io_uring.h
+++ b/include/uapi/linux/io_uring.h
@@ -253,6 +253,7 @@ enum io_uring_op {
 	IORING_OP_FUTEX_WAIT,
 	IORING_OP_FUTEX_WAKE,
 	IORING_OP_FUTEX_WAITV,
+	IORING_OP_FTRUNCATE,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
diff --git a/io_uring/Makefile b/io_uring/Makefile
index e5be47e4fc3b..4f8ed6530a29 100644
--- a/io_uring/Makefile
+++ b/io_uring/Makefile
@@ -8,6 +8,6 @@ obj-$(CONFIG_IO_URING)		+= io_uring.o xattr.o nop.o fs.o splice.o \
 					statx.o net.o msg_ring.o timeout.o \
 					sqpoll.o fdinfo.o tctx.o poll.o \
 					cancel.o kbuf.o rsrc.o rw.o opdef.o \
-					notif.o waitid.o
+					notif.o waitid.o truncate.o
 obj-$(CONFIG_IO_WQ)		+= io-wq.o
 obj-$(CONFIG_FUTEX)		+= futex.o
diff --git a/io_uring/opdef.c b/io_uring/opdef.c
index 799db44283c7..7a83b76c6ee7 100644
--- a/io_uring/opdef.c
+++ b/io_uring/opdef.c
@@ -35,6 +35,7 @@
 #include "rw.h"
 #include "waitid.h"
 #include "futex.h"
+#include "truncate.h"
 
 static int io_no_issue(struct io_kiocb *req, unsigned int issue_flags)
 {
@@ -469,6 +470,12 @@ const struct io_issue_def io_issue_defs[] = {
 		.prep			= io_eopnotsupp_prep,
 #endif
 	},
+	[IORING_OP_FTRUNCATE] = {
+		.needs_file		= 1,
+		.hash_reg_file		= 1,
+		.prep			= io_ftruncate_prep,
+		.issue			= io_ftruncate,
+	},
 };
 
 const struct io_cold_def io_cold_defs[] = {
@@ -704,6 +711,9 @@ const struct io_cold_def io_cold_defs[] = {
 	[IORING_OP_FUTEX_WAITV] = {
 		.name			= "FUTEX_WAITV",
 	},
+	[IORING_OP_FTRUNCATE] = {
+		.name			= "FTRUNCATE",
+	},
 };
 
 const char *io_uring_get_opcode(u8 opcode)
diff --git a/io_uring/truncate.c b/io_uring/truncate.c
new file mode 100644
index 000000000000..4b48376149f9
--- /dev/null
+++ b/io_uring/truncate.c
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/file.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/syscalls.h>
+#include <linux/io_uring.h>
+
+#include <uapi/linux/io_uring.h>
+
+#include "../fs/internal.h"
+
+#include "io_uring.h"
+#include "truncate.h"
+
+struct io_ftrunc {
+	struct file			*file;
+	loff_t				len;
+};
+
+int io_ftruncate_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
+{
+	struct io_ftrunc *ft = io_kiocb_to_cmd(req, struct io_ftrunc);
+
+	if (sqe->rw_flags || sqe->addr || sqe->len || sqe->buf_index ||
+	    sqe->splice_fd_in || sqe->addr3)
+		return -EINVAL;
+
+	ft->len = READ_ONCE(sqe->off);
+
+	req->flags |= REQ_F_FORCE_ASYNC;
+	return 0;
+}
+
+int io_ftruncate(struct io_kiocb *req, unsigned int issue_flags)
+{
+	struct io_ftrunc *ft = io_kiocb_to_cmd(req, struct io_ftrunc);
+	int ret;
+
+	WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
+
+	ret = ftruncate_file(req->file, ft->len, 0);
+
+	io_req_set_res(req, ret, 0);
+	return IOU_OK;
+}
diff --git a/io_uring/truncate.h b/io_uring/truncate.h
new file mode 100644
index 000000000000..ec088293a478
--- /dev/null
+++ b/io_uring/truncate.h
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0
+
+int io_ftruncate_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe);
+int io_ftruncate(struct io_kiocb *req, unsigned int issue_flags);
-- 
2.34.1

Re: [PATCH v5 0/2] io_uring: add support for ftruncate

[Cedric Blancher]

On Wed, 24 Jan 2024 at 09:33, Tony Solomonik <tony.solomonik@gmail.com> wrote:
>
> This patch adds support for doing truncate through io_uring, eliminating
> the need for applications to roll their own thread pool or offload
> mechanism to be able to do non-blocking truncates.
>
> Tony Solomonik (2):
>   Add ftruncate_file that truncates a struct file
>   io_uring: add support for ftruncate
>
>  fs/internal.h                 |  1 +
>  fs/open.c                     | 53 ++++++++++++++++++-----------------
>  include/uapi/linux/io_uring.h |  1 +
>  io_uring/Makefile             |  2 +-
>  io_uring/opdef.c              | 10 +++++++
>  io_uring/truncate.c           | 48 +++++++++++++++++++++++++++++++
>  io_uring/truncate.h           |  4 +++
>  7 files changed, 93 insertions(+), 26 deletions(-)
>  create mode 100644 io_uring/truncate.c
>  create mode 100644 io_uring/truncate.h
>
>
> base-commit: d3fa86b1a7b4cdc4367acacea16b72e0a200b3d7

Also fallocate() to punch holes, aka sparse files, must be implemented

Ced
-- 
Cedric Blancher <cedric.blancher@gmail.com>
[https://plus.google.com/u/0/+CedricBlancher/]
Institute Pasteur

Re: [PATCH v5 0/2] io_uring: add support for ftruncate

[Jens Axboe]

On 1/24/24 1:52 AM, Cedric Blancher wrote:
> On Wed, 24 Jan 2024 at 09:33, Tony Solomonik <tony.solomonik@gmail.com> wrote:
>>
>> This patch adds support for doing truncate through io_uring, eliminating
>> the need for applications to roll their own thread pool or offload
>> mechanism to be able to do non-blocking truncates.
>>
>> Tony Solomonik (2):
>>   Add ftruncate_file that truncates a struct file
>>   io_uring: add support for ftruncate
>>
>>  fs/internal.h                 |  1 +
>>  fs/open.c                     | 53 ++++++++++++++++++-----------------
>>  include/uapi/linux/io_uring.h |  1 +
>>  io_uring/Makefile             |  2 +-
>>  io_uring/opdef.c              | 10 +++++++
>>  io_uring/truncate.c           | 48 +++++++++++++++++++++++++++++++
>>  io_uring/truncate.h           |  4 +++
>>  7 files changed, 93 insertions(+), 26 deletions(-)
>>  create mode 100644 io_uring/truncate.c
>>  create mode 100644 io_uring/truncate.h
>>
>>
>> base-commit: d3fa86b1a7b4cdc4367acacea16b72e0a200b3d7
> 
> Also fallocate() to punch holes, aka sparse files, must be implemented

fallocate has been supported for years.

-- 
Jens Axboe

Re: [PATCH v5 0/2] io_uring: add support for ftruncate

[Cedric Blancher]

On Wed, 24 Jan 2024 at 13:52, Jens Axboe <axboe@kernel.dk> wrote:
>
> On 1/24/24 1:52 AM, Cedric Blancher wrote:
> > On Wed, 24 Jan 2024 at 09:33, Tony Solomonik <tony.solomonik@gmail.com> wrote:
> >>
> >> This patch adds support for doing truncate through io_uring, eliminating
> >> the need for applications to roll their own thread pool or offload
> >> mechanism to be able to do non-blocking truncates.
> >>
> >> Tony Solomonik (2):
> >>   Add ftruncate_file that truncates a struct file
> >>   io_uring: add support for ftruncate
> >>
> >>  fs/internal.h                 |  1 +
> >>  fs/open.c                     | 53 ++++++++++++++++++-----------------
> >>  include/uapi/linux/io_uring.h |  1 +
> >>  io_uring/Makefile             |  2 +-
> >>  io_uring/opdef.c              | 10 +++++++
> >>  io_uring/truncate.c           | 48 +++++++++++++++++++++++++++++++
> >>  io_uring/truncate.h           |  4 +++
> >>  7 files changed, 93 insertions(+), 26 deletions(-)
> >>  create mode 100644 io_uring/truncate.c
> >>  create mode 100644 io_uring/truncate.h
> >>
> >>
> >> base-commit: d3fa86b1a7b4cdc4367acacea16b72e0a200b3d7
> >
> > Also fallocate() to punch holes, aka sparse files, must be implemented
>
> fallocate has been supported for years.

Does it support punching holes? Does lseek() with SEEK_HOLE and
SEEK_DATA work, with more than one hole, and/or hole at the end?

Ced
-- 
Cedric Blancher <cedric.blancher@gmail.com>
[https://plus.google.com/u/0/+CedricBlancher/]
Institute Pasteur

Re: [PATCH v5 0/2] io_uring: add support for ftruncate

[Jens Axboe]

On 1/24/24 6:35 AM, Cedric Blancher wrote:
> On Wed, 24 Jan 2024 at 13:52, Jens Axboe <axboe@kernel.dk> wrote:
>>
>> On 1/24/24 1:52 AM, Cedric Blancher wrote:
>>> On Wed, 24 Jan 2024 at 09:33, Tony Solomonik <tony.solomonik@gmail.com> wrote:
>>>>
>>>> This patch adds support for doing truncate through io_uring, eliminating
>>>> the need for applications to roll their own thread pool or offload
>>>> mechanism to be able to do non-blocking truncates.
>>>>
>>>> Tony Solomonik (2):
>>>>   Add ftruncate_file that truncates a struct file
>>>>   io_uring: add support for ftruncate
>>>>
>>>>  fs/internal.h                 |  1 +
>>>>  fs/open.c                     | 53 ++++++++++++++++++-----------------
>>>>  include/uapi/linux/io_uring.h |  1 +
>>>>  io_uring/Makefile             |  2 +-
>>>>  io_uring/opdef.c              | 10 +++++++
>>>>  io_uring/truncate.c           | 48 +++++++++++++++++++++++++++++++
>>>>  io_uring/truncate.h           |  4 +++
>>>>  7 files changed, 93 insertions(+), 26 deletions(-)
>>>>  create mode 100644 io_uring/truncate.c
>>>>  create mode 100644 io_uring/truncate.h
>>>>
>>>>
>>>> base-commit: d3fa86b1a7b4cdc4367acacea16b72e0a200b3d7
>>>
>>> Also fallocate() to punch holes, aka sparse files, must be implemented
>>
>> fallocate has been supported for years.
> 
> Does it support punching holes? Does lseek() with SEEK_HOLE and
> SEEK_DATA work, with more than one hole, and/or hole at the end?

It does anything that fallocate(2) will do.

-- 
Jens Axboe

Re: [PATCH v5 1/2] Add ftruncate_file that truncates a struct file

[Christian Brauner]

On Wed, Jan 24, 2024 at 10:33:00AM +0200, Tony Solomonik wrote:
> do_sys_ftruncate receives a file descriptor, fgets the struct file, and
> finally actually truncates the file.
> 
> ftruncate_file allows for passing in a file directly, with the caller
> already holding a reference to it.
> 
> Signed-off-by: Tony Solomonik <tony.solomonik@gmail.com>
> ---
>  fs/internal.h |  1 +
>  fs/open.c     | 53 +++++++++++++++++++++++++++------------------------
>  2 files changed, 29 insertions(+), 25 deletions(-)
> 
> diff --git a/fs/internal.h b/fs/internal.h
> index 58e43341aebf..78a641ebd16e 100644
> --- a/fs/internal.h
> +++ b/fs/internal.h
> @@ -182,6 +182,7 @@ extern struct open_how build_open_how(int flags, umode_t mode);
>  extern int build_open_flags(const struct open_how *how, struct open_flags *op);
>  extern struct file *__close_fd_get_file(unsigned int fd);
>  
> +long ftruncate_file(struct file *file, loff_t length, int small);
>  long do_sys_ftruncate(unsigned int fd, loff_t length, int small);
>  int chmod_common(const struct path *path, umode_t mode);
>  int do_fchownat(int dfd, const char __user *filename, uid_t user, gid_t group,
> diff --git a/fs/open.c b/fs/open.c
> index 02dc608d40d8..649d38eecfe4 100644
> --- a/fs/open.c
> +++ b/fs/open.c
> @@ -154,49 +154,52 @@ COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length
>  }
>  #endif
>  
> -long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
> +long ftruncate_file(struct file *file, loff_t length, int small)

All internal functions that io_uring currently calls are called do_*():

* do_rmdir()
* do_unlinkat()
* do_mkdirat()
* do_symlinkat()
* do_statx()

So I'd follow that pattern and just call that thing do_ftruncate().
Otherwise looks good to me,

Acked-by: Christian Brauner <brauner@kernel.org>

Re: [PATCH v5 1/2] Add ftruncate_file that truncates a struct file

[Matthew Wilcox]

On Wed, Jan 24, 2024 at 10:33:00AM +0200, Tony Solomonik wrote:
>  	/* explicitly opened as large or we are on 64-bit box */
> -	if (f.file->f_flags & O_LARGEFILE)
> +	if (file->f_flags & O_LARGEFILE)
>  		small = 0;
>  
[...]
>  	/* Cannot ftruncate over 2^31 bytes without large file support */
>  	if (small && length > MAX_NON_LFS)
> -		goto out_putf;
> +		return -EINVAL;

I'd leave this in do_sys_truncate().  No need for ioring to care about
this ancient problem.