Skip to contentSkip to conversation

Add __do_ftruncate that truncates a struct file*

PATCH Superseded Tony Solomonik 3 participants 19 messages Jan 23, 2024 2 messages not in the archive

Subsystems (3)

v2 of 9 Superseded Latest is v9 →

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): CAD62OrGa9pS6-Qgg_UD4r4d+kCSPQihq0VvtVombrbAAOroG=w@mail.gmail.com

#1 lore raw

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

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(-)
fs/open.c +31 -21
index 02dc608d40d8..b32ac430666c 100644
@@ -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;
include/linux/syscalls.h +2 -0
index fd9d12de7e92..e8c56986e751 100644
@@ -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)
Signature · 1 line
2.34.1
#2 lore raw

PATCH v2 2/2 io_uring: add support for ftruncate

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
include/uapi/linux/io_uring.h +1 -0
index f1c16f817742..be682e000c94 100644
@@ -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,
io_uring/Makefile +1 -1
index e5be47e4fc3b..4f8ed6530a29 100644
@@ -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
io_uring/opdef.c +9 -0
index 799db44283c7..7830d087d03f 100644
@@ -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)
io_uring/truncate.c new file +47 -0

47 lines not on this page · raw message

io_uring/truncate.h new file +4 -0
new file mode 100644
index 000000000000..ec088293a478
@@ -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);
Signature · 1 line
2.34.1
#3 lore raw

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

Quoted 85 lines · 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
include/uapi/linux/io_uring.h +1 -0
index f1c16f817742..be682e000c94 100644
@@ -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,
io_uring/Makefile +1 -1
index e5be47e4fc3b..4f8ed6530a29 100644
@@ -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
io_uring/opdef.c +9 -0
index 799db44283c7..7830d087d03f 100644
@@ -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)
io_uring/truncate.c new file +9 -0
new file mode 100644
index 000000000000..9d160b91949c
@@ -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>

io_uring/truncate.c line 19

Quoted 10 lines
io_uring/truncate.c new file +10 -0
+
+#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.

Quoted 38 lines
io_uring/truncate.c new file +28 -0
+	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;
+}
io_uring/truncate.h new file +4 -0
new file mode 100644
index 000000000000..ec088293a478
@@ -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);
Signature · 1 line
Gabriel Krisman Bertazi
maintainer
#4 lore raw

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

Quoted 4 lines · Gabriel Krisman Bertazi

io_uring/truncate.c line 19

Quoted 2 lines
io_uring/truncate.c new file +2 -0
+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.

Signature · 1 line
Jens Axboe
maintainer
#5 lore raw

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

In reply to Tony Solomonik

io_uring/truncate.c line 43

Quoted 8 lines · Tony Solomonik
io_uring/truncate.c new file +8 -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);

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.

Signature · 1 line
Jens Axboe
maintainer
#6 lore raw

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

In reply to Tony Solomonik

io_uring/truncate.c line 28

Quoted 6 lines · Tony Solomonik
io_uring/truncate.c new file +6 -0
+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.

Signature · 1 line
Jens Axboe
#7 lore raw

v3 cover Add ftruncate to io_uring

In reply to 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

Signature · 1 line
2.34.1
#8 lore raw

PATCH v3 1/2 Add ftruncate_file that truncates a struct file*

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.

---
 fs/internal.h |  1 +
 fs/open.c     | 51 ++++++++++++++++++++++++++++++---------------------
 2 files changed, 31 insertions(+), 21 deletions(-)
fs/internal.h +1 -0
index 58e43341aebf..78a641ebd16e 100644
@@ -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,
fs/open.c +30 -21

77 lines not on this page · raw message

Signature · 1 line
2.34.1
maintainer
#9 lore raw

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

Quoted 2 lines · Tony Solomonik

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.

Quoted 1 line

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.

Quoted 71 lines
---
 fs/internal.h |  1 +
 fs/open.c     | 51 ++++++++++++++++++++++++++++++---------------------
 2 files changed, 31 insertions(+), 21 deletions(-)
fs/internal.h +1 -0
index 58e43341aebf..78a641ebd16e 100644
@@ -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,
fs/open.c +8 -18
index 02dc608d40d8..0c505402e93d 100644
@@ -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);

fs/open.c COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length · line 189

Quoted 10 lines
fs/open.c +5 -3
+	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.

Quoted 8 lines
fs/open.c +8 -0
+long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
+{
+	struct fd f;
+	int error;
+
+	error = -EINVAL;
+	if (length < 0)
+		goto out;

fs/open.c COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length · line 209

Quoted 10 lines
fs/open.c +7 -0
+	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.

Signature · 1 line
Jens Axboe
#10 lore raw

PATCH v3 2/2 io_uring: add support for ftruncate

In reply to 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           | 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
include/uapi/linux/io_uring.h +1 -0
index f1c16f817742..be682e000c94 100644
@@ -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,
io_uring/Makefile +1 -1
index e5be47e4fc3b..4f8ed6530a29 100644
@@ -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
io_uring/opdef.c +9 -0
index 799db44283c7..7830d087d03f 100644
@@ -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)
io_uring/truncate.c new file +48 -0

48 lines not on this page · raw message

io_uring/truncate.h new file +4 -0
new file mode 100644
index 000000000000..ec088293a478
@@ -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);
Signature · 1 line
2.34.1
maintainer
#11 lore raw

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

Quoted 2 lines · 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.

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.

io_uring/opdef.c const struct io_issue_def io_issue_defs[] = { · line 478

Quoted 10 lines
io_uring/opdef.c +5 -0
@@ -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.

Quoted 60 lines
io_uring/truncate.c new file +48 -0
new file mode 100644
index 000000000000..4b48376149f9
@@ -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;
+}
io_uring/truncate.h new file +0 -0
new file mode 100644
index 000000000000..ec088293a478

io_uring/truncate.h line 4

Quoted 4 lines
io_uring/truncate.h new file +4 -0
@@ -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!

Signature · 1 line
Jens Axboe
#12 lore raw

v4 cover io_uring: add support for ftruncate

In reply to 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

Signature · 1 line
2.34.1
#13 lore raw

PATCH v4 1/2 Add ftruncate_file that truncates a struct file

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.

---
 fs/internal.h |  1 +
 fs/open.c     | 53 +++++++++++++++++++++++++++------------------------
 2 files changed, 29 insertions(+), 25 deletions(-)
fs/internal.h +1 -0
index 58e43341aebf..78a641ebd16e 100644
@@ -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,
fs/open.c +28 -25

77 lines not on this page · raw message

Signature · 1 line
2.34.1
#14 lore raw

PATCH v4 2/2 io_uring: add support for ftruncate

In reply to 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.

---
 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
include/uapi/linux/io_uring.h +1 -0
index f1c16f817742..be682e000c94 100644
@@ -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,
io_uring/Makefile +1 -1
index e5be47e4fc3b..4f8ed6530a29 100644
@@ -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
io_uring/opdef.c +10 -0
index 799db44283c7..7a83b76c6ee7 100644
@@ -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)
io_uring/truncate.c new file +48 -0

48 lines not on this page · raw message

io_uring/truncate.h new file +4 -0
new file mode 100644
index 000000000000..ec088293a478
@@ -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);
Signature · 1 line
2.34.1
maintainer
#15 lore raw

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

In reply to Tony Solomonik
Quoted 3 lines · 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.

All looks go to me now! But I think you should send out a v5 and cc [email protected] and christian Brauner <[email protected]> to get the fs internal bits reviewed and vetted.

Signature · 1 line
Jens Axboe

A message that is not in the archive (sent off-list or not yet received): CAD62OrEC62Ojh+uvMWMb7X=fNZerUVYfUWFmRHQ-49OvTJ1u4Q@mail.gmail.com

maintainer
#17 lore raw

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

Quoted 4 lines · Tony Solomonik

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...

Signature · 1 line
Jens Axboe
#18 lore raw
In reply to Tony Solomonik
Quoted 2 lines · Tony Solomonik

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

Quoted 34 lines

__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(-)
fs/open.c +2 -11
index 02dc608d40d8..b32ac430666c 100644
@@ -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)

fs/open.c COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length · line 171

Quoted 10 lines
fs/open.c +3 -3
 		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.

fs/open.c COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length · line 176

Quoted 6 lines
fs/open.c +1 -1
 	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..

Quoted 30 lines
fs/open.c +18 -6
 	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;

fs/open.c COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length · line 210

Quoted 10 lines
fs/open.c +7 -0
+	error = -EBADF;
+	f = fdget(fd);
+	if (!f.file)
+		goto out;
+
+	error = __do_ftruncate(f.file, length, small);
+
 	fdput(f);
 out:
 	return error;

Same here.

Quoted 13 lines
include/linux/syscalls.h +2 -0
index fd9d12de7e92..e8c56986e751 100644
@@ -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)
Signature · 1 line
Gabriel Krisman Bertazi
maintainer
#19 lore raw
In reply to Tony Solomonik
Quoted 81 lines · 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(-)
fs/open.c +23 -21
index 02dc608d40d8..b32ac430666c 100644
@@ -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)

fs/open.c COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path, compat_off_t, length · line 209

Quoted 10 lines
fs/open.c +8 -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.

include/linux/syscalls.h static inline long ksys_lchown(const char __user *filename, uid_t user, · line 1236

Quoted 13 lines
include/linux/syscalls.h +2 -0
index fd9d12de7e92..e8c56986e751 100644
@@ -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.

Signature · 1 line
Jens Axboe
maintainer
#20 lore raw
Quoted 8 lines · Jens Axboe
Quoted 8 lines
include/linux/syscalls.h +0 -0
index fd9d12de7e92..e8c56986e751 100644
@@ -1229,6 +1229,8 @@ static inline long ksys_lchown(const char __user *filename, uid_t user,
 			     AT_SYMLINK_NOFOLLOW);
 }
 
Quoted 7 lines

include/linux/syscalls.h static inline long ksys_lchown(const char __user *filename, uid_t user, · line 1236

Quoted 5 lines
include/linux/syscalls.h +2 -0
+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.

Signature · 1 line
Jens Axboe