[PATCH v2 1/2] Add __do_ftruncate that truncates a struct file*

[PATCH v2 1/2] Add __do_ftruncate that truncates a struct file*

[Tony Solomonik]

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

__do_ftruncate allows for truncating a file without fgets.
---
 fs/open.c                | 52 ++++++++++++++++++++++++----------------
 include/linux/syscalls.h |  2 ++
 2 files changed, 33 insertions(+), 21 deletions(-)

diff --git a/fs/open.c b/fs/open.c
index 02dc608d40d8..b32ac430666c 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -154,47 +154,57 @@ 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 __do_ftruncate(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))
+		goto out;
 
 	error = -EINVAL;
 	/* Cannot ftruncate over 2^31 bytes without large file support */
 	if (small && length > MAX_NON_LFS)
-		goto out_putf;
+		goto out;
 
 	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)))
+		goto out;
 	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:
+
+out:
+  return error;
+}
+
+long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
+{
+	struct fd f;
+	int error;
+
+	error = -EINVAL;
+	if (length < 0)
+		goto out;
+	error = -EBADF;
+	f = fdget(fd);
+	if (!f.file)
+		goto out;
+
+	error = __do_ftruncate(f.file, length, small);
+
 	fdput(f);
 out:
 	return error;
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index fd9d12de7e92..e8c56986e751 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -1229,6 +1229,8 @@ static inline long ksys_lchown(const char __user *filename, uid_t user,
 			     AT_SYMLINK_NOFOLLOW);
 }
 
+extern long __do_ftruncate(struct file *file, loff_t length, int small);
+
 extern long do_sys_ftruncate(unsigned int fd, loff_t length, int small);
 
 static inline long ksys_ftruncate(unsigned int fd, loff_t length)
-- 
2.34.1

[PATCH v2 1/2] Add __do_ftruncate that truncates a struct file*

[Tony Solomonik]

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

__do_ftruncate allows for truncating a file without fgets.
---
 fs/open.c                | 52 ++++++++++++++++++++++++----------------
 include/linux/syscalls.h |  2 ++
 2 files changed, 33 insertions(+), 21 deletions(-)

diff --git a/fs/open.c b/fs/open.c
index 02dc608d40d8..b32ac430666c 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -154,47 +154,57 @@ 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 __do_ftruncate(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))
+		goto out;
 
 	error = -EINVAL;
 	/* Cannot ftruncate over 2^31 bytes without large file support */
 	if (small && length > MAX_NON_LFS)
-		goto out_putf;
+		goto out;
 
 	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)))
+		goto out;
 	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:
+
+out:
+  return error;
+}
+
+long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
+{
+	struct fd f;
+	int error;
+
+	error = -EINVAL;
+	if (length < 0)
+		goto out;
+	error = -EBADF;
+	f = fdget(fd);
+	if (!f.file)
+		goto out;
+
+	error = __do_ftruncate(f.file, length, small);
+
 	fdput(f);
 out:
 	return error;
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index fd9d12de7e92..e8c56986e751 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -1229,6 +1229,8 @@ static inline long ksys_lchown(const char __user *filename, uid_t user,
 			     AT_SYMLINK_NOFOLLOW);
 }
 
+extern long __do_ftruncate(struct file *file, loff_t length, int small);
+
 extern long do_sys_ftruncate(unsigned int fd, loff_t length, int small);
 
 static inline long ksys_ftruncate(unsigned int fd, loff_t length)
-- 
2.34.1

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

[Tony Solomonik]

Libraries that are built on io_uring currently need to maintain a
separate thread pool implementation when they want to truncate a file.
---
 include/uapi/linux/io_uring.h |  1 +
 io_uring/Makefile             |  2 +-
 io_uring/opdef.c              |  9 +++++++
 io_uring/truncate.c           | 47 +++++++++++++++++++++++++++++++++++
 io_uring/truncate.h           |  4 +++
 5 files changed, 62 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..7830d087d03f 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,11 @@ const struct io_issue_def io_issue_defs[] = {
 		.prep			= io_eopnotsupp_prep,
 #endif
 	},
+	[IORING_OP_FTRUNCATE] = {
+		.needs_file		= 1,
+		.prep			= io_ftruncate_prep,
+		.issue			= io_ftruncate,
+	},
 };
 
 const struct io_cold_def io_cold_defs[] = {
@@ -704,6 +710,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..9d160b91949c
--- /dev/null
+++ b/io_uring/truncate.c
@@ -0,0 +1,47 @@
+// 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->addr || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in)
+		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 = __do_ftruncate(req->file, ft->len, 1);
+
+	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 v2 1/2] Add __do_ftruncate that truncates a struct file*

[Gabriel Krisman Bertazi]

Tony Solomonik <tony.solomonik@gmail.com> writes:

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

This need to be Cc'ed to the VFS maintainers and appropriated lists.
Also, you need a signed-off-by line and cover letter.

Take a look at:

https://www.kernel.org/doc/html/v6.7/process/submitting-patches.html

>
> __do_ftruncate allows for truncating a file without fgets.
> ---
>  fs/open.c                | 52 ++++++++++++++++++++++++----------------
>  include/linux/syscalls.h |  2 ++
>  2 files changed, 33 insertions(+), 21 deletions(-)
>
> diff --git a/fs/open.c b/fs/open.c
> index 02dc608d40d8..b32ac430666c 100644
> --- a/fs/open.c
> +++ b/fs/open.c
> @@ -154,47 +154,57 @@ 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 __do_ftruncate(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))
> +		goto out;

Just return directly here. No point in jumping to 'out' just to return
immediately.

>  
>  	error = -EINVAL;
>  	/* Cannot ftruncate over 2^31 bytes without large file support */
>  	if (small && length > MAX_NON_LFS)
> -		goto out_putf;
> +		goto out;

likewise for the others..

>  
>  	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)))
> +		goto out;
>  	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:
> +
> +out:
> +  return error;
> +}
> +
> +long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
> +{
> +	struct fd f;
> +	int error;
> +
> +	error = -EINVAL;
> +	if (length < 0)
> +		goto out;
> +	error = -EBADF;
> +	f = fdget(fd);
> +	if (!f.file)
> +		goto out;
> +
> +	error = __do_ftruncate(f.file, length, small);
> +
>  	fdput(f);
>  out:
>  	return error;

Same here.

> diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
> index fd9d12de7e92..e8c56986e751 100644
> --- a/include/linux/syscalls.h
> +++ b/include/linux/syscalls.h
> @@ -1229,6 +1229,8 @@ static inline long ksys_lchown(const char __user *filename, uid_t user,
>  			     AT_SYMLINK_NOFOLLOW);
>  }
>  
> +extern long __do_ftruncate(struct file *file, loff_t length, int small);
> +
>  extern long do_sys_ftruncate(unsigned int fd, loff_t length, int small);
>  
>  static inline long ksys_ftruncate(unsigned int fd, loff_t length)

-- 
Gabriel Krisman Bertazi

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

[Gabriel Krisman Bertazi]

Tony Solomonik <tony.solomonik@gmail.com> writes:

> Libraries that are built on io_uring currently need to maintain a
> separate thread pool implementation when they want to truncate a file.
> ---
>  include/uapi/linux/io_uring.h |  1 +
>  io_uring/Makefile             |  2 +-
>  io_uring/opdef.c              |  9 +++++++
>  io_uring/truncate.c           | 47 +++++++++++++++++++++++++++++++++++
>  io_uring/truncate.h           |  4 +++
>  5 files changed, 62 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..7830d087d03f 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,11 @@ const struct io_issue_def io_issue_defs[] = {
>  		.prep			= io_eopnotsupp_prep,
>  #endif
>  	},
> +	[IORING_OP_FTRUNCATE] = {
> +		.needs_file		= 1,
> +		.prep			= io_ftruncate_prep,
> +		.issue			= io_ftruncate,
> +	},
>  };
>  
>  const struct io_cold_def io_cold_defs[] = {
> @@ -704,6 +710,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..9d160b91949c
> --- /dev/null
> +++ b/io_uring/truncate.c
> @@ -0,0 +1,47 @@
> +// 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;

This is unused in the rest of the patch.

> +	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->addr || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in)
> +		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 = __do_ftruncate(req->file, ft->len, 1);
> +
> +	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);

-- 
Gabriel Krisman Bertazi

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

[Jens Axboe]

On 1/23/24 8:01 AM, Gabriel Krisman Bertazi wrote:
>> +struct io_ftrunc {
>> +	struct file			*file;
> 
> This is unused in the rest of the patch.

It has to be there, see io_kiocb and how file is first and these are
unioned with that. See the note in tne io_kiocb definition in
io_uring_types.h.

-- 
Jens Axboe

Re: [PATCH v2 1/2] Add __do_ftruncate that truncates a struct file*

[Jens Axboe]

On 1/23/24 4:33 AM, Tony Solomonik wrote:
> do_sys_ftruncate receives a file descriptor, fgets the struct file*, and
> finally actually truncates the file.
> 
> __do_ftruncate allows for truncating a file without fgets.
> ---
>  fs/open.c                | 52 ++++++++++++++++++++++++----------------
>  include/linux/syscalls.h |  2 ++
>  2 files changed, 33 insertions(+), 21 deletions(-)
> 
> diff --git a/fs/open.c b/fs/open.c
> index 02dc608d40d8..b32ac430666c 100644
> --- a/fs/open.c
> +++ b/fs/open.c
> @@ -154,47 +154,57 @@ 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 __do_ftruncate(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))
> +		goto out;
>  
>  	error = -EINVAL;
>  	/* Cannot ftruncate over 2^31 bytes without large file support */
>  	if (small && length > MAX_NON_LFS)
> -		goto out_putf;
> +		goto out;
>  
>  	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)))
> +		goto out;
>  	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:
> +
> +out:
> +  return error;
> +}
> +
> +long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
> +{
> +	struct fd f;
> +	int error;
> +
> +	error = -EINVAL;
> +	if (length < 0)
> +		goto out;
> +	error = -EBADF;
> +	f = fdget(fd);
> +	if (!f.file)
> +		goto out;
> +
> +	error = __do_ftruncate(f.file, length, small);
> +
>  	fdput(f);
>  out:

Same comments as Gabriel for the out label, just return error.

> diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
> index fd9d12de7e92..e8c56986e751 100644
> --- a/include/linux/syscalls.h
> +++ b/include/linux/syscalls.h
> @@ -1229,6 +1229,8 @@ static inline long ksys_lchown(const char __user *filename, uid_t user,
>  			     AT_SYMLINK_NOFOLLOW);
>  }
>  
> +extern long __do_ftruncate(struct file *file, loff_t length, int small);
> +
>  extern long do_sys_ftruncate(unsigned int fd, loff_t length, int small);
>  
>  static inline long ksys_ftruncate(unsigned int fd, loff_t length)

This should go in fs/internal.h, it's not a syscall related thing.

-- 
Jens Axboe

Re: [PATCH v2 1/2] Add __do_ftruncate that truncates a struct file*

[Jens Axboe]

On 1/23/24 8:38 AM, Jens Axboe wrote:
>> diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
>> index fd9d12de7e92..e8c56986e751 100644
>> --- a/include/linux/syscalls.h
>> +++ b/include/linux/syscalls.h
>> @@ -1229,6 +1229,8 @@ static inline long ksys_lchown(const char __user *filename, uid_t user,
>>  			     AT_SYMLINK_NOFOLLOW);
>>  }
>>  
>> +extern long __do_ftruncate(struct file *file, loff_t length, int small);
>> +
>>  extern long do_sys_ftruncate(unsigned int fd, loff_t length, int small);
>>  
>>  static inline long ksys_ftruncate(unsigned int fd, loff_t length)
> 
> This should go in fs/internal.h, it's not a syscall related thing.

And while at it, let's call it ftruncate_file() as that more accurately
describes what it does.

-- 
Jens Axboe

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

[Jens Axboe]

On 1/23/24 4:33 AM, Tony Solomonik wrote:
> +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 = __do_ftruncate(req->file, ft->len, 1);

Should this not pass 0 at the end for small == 0, as this variant should
be 64-bit clean from the get-go?

Another thing to add to the test case, create a large sparse file that
is eg 8G and truncate it to 6G. That would catch an issue with that.

-- 
Jens Axboe

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

[Jens Axboe]

On 1/23/24 4:33 AM, Tony Solomonik wrote:
> +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->addr || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in)
> +		return -EINVAL;

Since you're not using len anymore, that should be included in these
checks, and addr3.

-- 
Jens Axboe

[PATCH v3 0/2] Add ftruncate to io_uring

[Tony Solomonik]

Libraries that are built on io_uring currently need to maintain a
separate thread pool implementation when they want to truncate a file.

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

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


base-commit: d3fa86b1a7b4cdc4367acacea16b72e0a200b3d7
-- 
2.34.1

[PATCH v3 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 truncating a file without fgets.

Signed-off-by: Tony Solomonik <tony.solomonik@gmail.com>
---
 fs/internal.h |  1 +
 fs/open.c     | 51 ++++++++++++++++++++++++++++++---------------------
 2 files changed, 31 insertions(+), 21 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..0c505402e93d 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -154,47 +154,56 @@ 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 error;
 
 	error = -EINVAL;
 	/* Cannot ftruncate over 2^31 bytes without large file support */
 	if (small && length > MAX_NON_LFS)
-		goto out_putf;
+		return error;
 
 	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 error;
 	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;
+
+	error = -EINVAL;
+	if (length < 0)
+		goto out;
+	error = -EBADF;
+	f = fdget(fd);
+	if (!f.file)
+		goto out;
+
+	error = ftruncate_file(f.file, length, small);
+
 	fdput(f);
 out:
 	return error;
-- 
2.34.1

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

[Tony Solomonik]

Libraries that are built on io_uring currently need to maintain a
separate thread pool implementation when they want to truncate a file.

Signed-off-by: Tony Solomonik <tony.solomonik@gmail.com>
---
 include/uapi/linux/io_uring.h |  1 +
 io_uring/Makefile             |  2 +-
 io_uring/opdef.c              |  9 +++++++
 io_uring/truncate.c           | 48 +++++++++++++++++++++++++++++++++++
 io_uring/truncate.h           |  4 +++
 5 files changed, 63 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..7830d087d03f 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,11 @@ const struct io_issue_def io_issue_defs[] = {
 		.prep			= io_eopnotsupp_prep,
 #endif
 	},
+	[IORING_OP_FTRUNCATE] = {
+		.needs_file		= 1,
+		.prep			= io_ftruncate_prep,
+		.issue			= io_ftruncate,
+	},
 };
 
 const struct io_cold_def io_cold_defs[] = {
@@ -704,6 +710,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 v3 1/2] Add ftruncate_file that truncates a struct file*

[Jens Axboe]

On 1/23/24 2:19 PM, Tony Solomonik wrote:
> do_sys_ftruncate receives a file descriptor, fgets the struct file*, and
> finally actually truncates the file.

Just do struct file and get rid of '*', kernel style would otherwise
dictate it should be struct file * but there's no point in mentioning
this is a pointer. It's the only case that makes sense.

> ftruncate_file allows for truncating a file without fgets.

I'd rephrase that last sentence, as it reads as you could do this
without holding a file reference. That is obviously not true. You
could make it:

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     | 51 ++++++++++++++++++++++++++++++---------------------
>  2 files changed, 31 insertions(+), 21 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..0c505402e93d 100644
> --- a/fs/open.c
> +++ b/fs/open.c
> @@ -154,47 +154,56 @@ 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 error;
>  
>  	error = -EINVAL;
>  	/* Cannot ftruncate over 2^31 bytes without large file support */
>  	if (small && length > MAX_NON_LFS)
> -		goto out_putf;
> +		return error;
>  
>  	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 error;
>  	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;

White space issue here with 'error'. And see below comments for error
assignment in general.

> +long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
> +{
> +	struct fd f;
> +	int error;
> +
> +	error = -EINVAL;
> +	if (length < 0)
> +		goto out;
> +	error = -EBADF;
> +	f = fdget(fd);
> +	if (!f.file)
> +		goto out;
> +
> +	error = ftruncate_file(f.file, length, small);
> +
>  	fdput(f);
>  out:
>  	return error;

No reason for the goto's here anymore, just do:

long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
{
	struct fd f;
	int error;

	if (length < 0)
		return -EINVAL;
	error = -EBADF;
	f = fdget(fd);
	if (f.file)
		error = ftruncate_file(f.file, length, small);
	fdput(f);
	return error;
}

Same for the above helper, save error for when you actually need it
rather than do:

	error = -EFOO;
	if (some_error)
		return error;

That only really makes sense when you assign error through eg calling a
function, not when you know what error you are returning. Makes it
easier to read the code as well.

-- 
Jens Axboe

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

[Jens Axboe]

On 1/23/24 2:19 PM, Tony Solomonik wrote:
> Libraries that are built on io_uring currently need to maintain a
> separate thread pool implementation when they want to truncate a file.

Since we're getting down to nit picking, this commit message is not good
at all. It states a need, but it should also mention something ala:

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.

> @@ -469,6 +470,11 @@ const struct io_issue_def io_issue_defs[] = {
>  		.prep			= io_eopnotsupp_prep,
>  #endif
>  	},
> +	[IORING_OP_FTRUNCATE] = {
> +		.needs_file		= 1,
> +		.prep			= io_ftruncate_prep,
> +		.issue			= io_ftruncate,
> +	},
>  };

Probably want to set hash_reg_file = 1 here as well, as it kind of works
like a buffered write in terms of serialization. Not strictly required,
as I can't see anything sane doing overlapping writes or truncates.

> 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);

Rest looks good to me!

-- 
Jens Axboe

[PATCH v4 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 v4 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 v4 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 v4 0/2] io_uring: add support for ftruncate

[Jens Axboe]

On 1/23/24 3:33 PM, Tony Solomonik 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.

All looks go to me now! But I think you should send out a v5 and cc
linux-fsdevel@vger.kernel.org and christian Brauner <brauner@kernel.org>
to get the fs internal bits reviewed and vetted.

-- 
Jens Axboe

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

[Jens Axboe]

On 1/23/24 4:26 PM, Tony Solomonik wrote:
> Sure I can do that tomorrow (not near my computer anymore).
> 
> By the way, why not just reply with CC to the ones you mentioned, but
> do a v5 instead?

It's harder to read the patch that way, right thing to do is really to
CC the right people from the get-go. You then also get complications of
people replying to the original patch without those folks CC'ed, and
split conversations and missed context that way.

Yeah email sucks...

-- 
Jens Axboe