Commit 643e2e25 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-6.13-rc6-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux 

Pull btrfs fixes from David Sterba:
 "A few more fixes.

  Besides the one-liners in Btrfs there's fix to the io_uring and
  encoded read integration (added in this development cycle). The update
  to io_uring provides more space for the ongoing command that is then
  used in Btrfs to handle some cases.

   - io_uring and encoded read:
       - provide stable storage for io_uring command data
       - make a copy of encoded read ioctl call, reuse that in case the
         call would block and will be called again

   - properly initialize zlib context for hardware compression on s390

   - fix max extent size calculation on filesystems with non-zoned
     devices

   - fix crash in scrub on crafted image due to invalid extent tree"

* tag 'for-6.13-rc6-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
  btrfs: zlib: fix avail_in bytes for s390 zlib HW compression path
  btrfs: zoned: calculate max_extent_size properly on non-zoned setup
  btrfs: avoid NULL pointer dereference if no valid extent tree
  btrfs: don't read from userspace twice in btrfs_uring_encoded_read()
  io_uring: add io_uring_cmd_get_async_data helper
  io_uring/cmd: add per-op data to struct io_uring_cmd_data
  io_uring/cmd: rename struct uring_cache to io_uring_cmd_data
parents eea6e4b4 0ee4736c

fs/btrfs/ioctl.c

+65 −57
Original line number Diff line number Diff line
@@ -4878,25 +4878,29 @@ static int btrfs_uring_read_extent(struct kiocb *iocb, struct iov_iter *iter, 
	return ret;

}



struct btrfs_uring_encoded_data {

	struct btrfs_ioctl_encoded_io_args args;

	struct iovec iovstack[UIO_FASTIOV];

	struct iovec *iov;

	struct iov_iter iter;

};



static int btrfs_uring_encoded_read(struct io_uring_cmd *cmd, unsigned int issue_flags)

{

	size_t copy_end_kernel = offsetofend(struct btrfs_ioctl_encoded_io_args, flags);

	size_t copy_end;

	struct btrfs_ioctl_encoded_io_args args = { 0 };

	int ret;

	u64 disk_bytenr, disk_io_size;

	struct file *file;

	struct btrfs_inode *inode;

	struct btrfs_fs_info *fs_info;

	struct extent_io_tree *io_tree;

	struct iovec iovstack[UIO_FASTIOV];

	struct iovec *iov = iovstack;

	struct iov_iter iter;

	loff_t pos;

	struct kiocb kiocb;

	struct extent_state *cached_state = NULL;

	u64 start, lockend;

	void __user *sqe_addr;

	struct btrfs_uring_encoded_data *data = io_uring_cmd_get_async_data(cmd)->op_data;



	if (!capable(CAP_SYS_ADMIN)) {

		ret = -EPERM;
@@ -4908,45 +4912,66 @@ static int btrfs_uring_encoded_read(struct io_uring_cmd *cmd, unsigned int issue 
	io_tree = &inode->io_tree;

	sqe_addr = u64_to_user_ptr(READ_ONCE(cmd->sqe->addr));



	if (issue_flags & IO_URING_F_COMPAT) {

#if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)

		copy_end = offsetofend(struct btrfs_ioctl_encoded_io_args_32, flags);

#else

		return -ENOTTY;

#endif

	} else {

		copy_end = copy_end_kernel;

	}



	if (!data) {

		data = kzalloc(sizeof(*data), GFP_NOFS);

		if (!data) {

			ret = -ENOMEM;

			goto out_acct;

		}



		io_uring_cmd_get_async_data(cmd)->op_data = data;



		if (issue_flags & IO_URING_F_COMPAT) {

#if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)

			struct btrfs_ioctl_encoded_io_args_32 args32;



		copy_end = offsetofend(struct btrfs_ioctl_encoded_io_args_32, flags);

			if (copy_from_user(&args32, sqe_addr, copy_end)) {

				ret = -EFAULT;

				goto out_acct;

			}

		args.iov = compat_ptr(args32.iov);

		args.iovcnt = args32.iovcnt;

		args.offset = args32.offset;

		args.flags = args32.flags;

#else

		return -ENOTTY;



			data->args.iov = compat_ptr(args32.iov);

			data->args.iovcnt = args32.iovcnt;

			data->args.offset = args32.offset;

			data->args.flags = args32.flags;

#endif

		} else {

		copy_end = copy_end_kernel;

		if (copy_from_user(&args, sqe_addr, copy_end)) {

			if (copy_from_user(&data->args, sqe_addr, copy_end)) {

				ret = -EFAULT;

				goto out_acct;

			}

		}



	if (args.flags != 0)

		return -EINVAL;

		if (data->args.flags != 0) {

			ret = -EINVAL;

			goto out_acct;

		}



	ret = import_iovec(ITER_DEST, args.iov, args.iovcnt, ARRAY_SIZE(iovstack),

			   &iov, &iter);

		data->iov = data->iovstack;

		ret = import_iovec(ITER_DEST, data->args.iov, data->args.iovcnt,

				   ARRAY_SIZE(data->iovstack), &data->iov,

				   &data->iter);

		if (ret < 0)

			goto out_acct;



	if (iov_iter_count(&iter) == 0) {

		if (iov_iter_count(&data->iter) == 0) {

			ret = 0;

			goto out_free;

		}

	}



	pos = args.offset;

	ret = rw_verify_area(READ, file, &pos, args.len);

	pos = data->args.offset;

	ret = rw_verify_area(READ, file, &pos, data->args.len);

	if (ret < 0)

		goto out_free;
@@ -4959,15 +4984,16 @@ static int btrfs_uring_encoded_read(struct io_uring_cmd *cmd, unsigned int issue 
	start = ALIGN_DOWN(pos, fs_info->sectorsize);

	lockend = start + BTRFS_MAX_UNCOMPRESSED - 1;



	ret = btrfs_encoded_read(&kiocb, &iter, &args, &cached_state,

	ret = btrfs_encoded_read(&kiocb, &data->iter, &data->args, &cached_state,

				 &disk_bytenr, &disk_io_size);

	if (ret < 0 && ret != -EIOCBQUEUED)

		goto out_free;



	file_accessed(file);



	if (copy_to_user(sqe_addr + copy_end, (const char *)&args + copy_end_kernel,

			 sizeof(args) - copy_end_kernel)) {

	if (copy_to_user(sqe_addr + copy_end,

			 (const char *)&data->args + copy_end_kernel,

			 sizeof(data->args) - copy_end_kernel)) {

		if (ret == -EIOCBQUEUED) {

			unlock_extent(io_tree, start, lockend, &cached_state);

			btrfs_inode_unlock(inode, BTRFS_ILOCK_SHARED);
@@ -4977,40 +5003,22 @@ static int btrfs_uring_encoded_read(struct io_uring_cmd *cmd, unsigned int issue 
	}



	if (ret == -EIOCBQUEUED) {

		u64 count;



		/*

		 * If we've optimized things by storing the iovecs on the stack,

		 * undo this.

		 */

		if (!iov) {

			iov = kmalloc(sizeof(struct iovec) * args.iovcnt, GFP_NOFS);

			if (!iov) {

				unlock_extent(io_tree, start, lockend, &cached_state);

				btrfs_inode_unlock(inode, BTRFS_ILOCK_SHARED);

				ret = -ENOMEM;

				goto out_acct;

			}



			memcpy(iov, iovstack, sizeof(struct iovec) * args.iovcnt);

		}



		count = min_t(u64, iov_iter_count(&iter), disk_io_size);

		u64 count = min_t(u64, iov_iter_count(&data->iter), disk_io_size);



		/* Match ioctl by not returning past EOF if uncompressed. */

		if (!args.compression)

			count = min_t(u64, count, args.len);

		if (!data->args.compression)

			count = min_t(u64, count, data->args.len);



		ret = btrfs_uring_read_extent(&kiocb, &iter, start, lockend,

					      cached_state, disk_bytenr,

					      disk_io_size, count,

					      args.compression, iov, cmd);

		ret = btrfs_uring_read_extent(&kiocb, &data->iter, start, lockend,

					      cached_state, disk_bytenr, disk_io_size,

					      count, data->args.compression,

					      data->iov, cmd);



		goto out_acct;

	}



out_free:

	kfree(iov);

	kfree(data->iov);



out_acct:

	if (ret > 0)

fs/btrfs/scrub.c

+4 −0
Original line number Diff line number Diff line
@@ -1541,6 +1541,10 @@ static int scrub_find_fill_first_stripe(struct btrfs_block_group *bg, 
	u64 extent_gen;

	int ret;



	if (unlikely(!extent_root)) {

		btrfs_err(fs_info, "no valid extent root for scrub");

		return -EUCLEAN;

	}

	memset(stripe->sectors, 0, sizeof(struct scrub_sector_verification) *

				   stripe->nr_sectors);

	scrub_stripe_reset_bitmaps(stripe);

fs/btrfs/zlib.c

+2 −2
Original line number Diff line number Diff line
@@ -174,10 +174,10 @@ int zlib_compress_folios(struct list_head *ws, struct address_space *mapping, 
					copy_page(workspace->buf + i * PAGE_SIZE,

						  data_in);

					start += PAGE_SIZE;

					workspace->strm.avail_in =

						(in_buf_folios << PAGE_SHIFT);

				}

				workspace->strm.next_in = workspace->buf;

				workspace->strm.avail_in = min(bytes_left,

							       in_buf_folios << PAGE_SHIFT);

			} else {

				unsigned int pg_off;

				unsigned int cur_len;

fs/btrfs/zoned.c

+3 −2
Original line number Diff line number Diff line
@@ -748,8 +748,9 @@ int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info) 
		     (u64)lim->max_segments << PAGE_SHIFT),

		fs_info->sectorsize);

	fs_info->fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_ZONED;

	if (fs_info->max_zone_append_size < fs_info->max_extent_size)

		fs_info->max_extent_size = fs_info->max_zone_append_size;



	fs_info->max_extent_size = min_not_zero(fs_info->max_extent_size,

						fs_info->max_zone_append_size);



	/*

	 * Check mount options here, because we might change fs_info->zoned

include/linux/io_uring/cmd.h

+10 −0
Original line number Diff line number Diff line
@@ -18,6 +18,11 @@ struct io_uring_cmd { 
	u8		pdu[32]; /* available inline for free use */

};



struct io_uring_cmd_data {

	struct io_uring_sqe	sqes[2];

	void			*op_data;

};



static inline const void *io_uring_sqe_cmd(const struct io_uring_sqe *sqe)

{

	return sqe->cmd;
@@ -113,4 +118,9 @@ static inline struct task_struct *io_uring_cmd_get_task(struct io_uring_cmd *cmd 
	return cmd_to_io_kiocb(cmd)->tctx->task;

}



static inline struct io_uring_cmd_data *io_uring_cmd_get_async_data(struct io_uring_cmd *cmd)

{

	return cmd_to_io_kiocb(cmd)->async_data;

}



#endif /* _LINUX_IO_URING_CMD_H */