diff -Nru zfs-linux-2.2.0~rc1/debian/changelog zfs-linux-2.2.0~rc1/debian/changelog --- zfs-linux-2.2.0~rc1/debian/changelog 2023-07-10 10:08:38.000000000 +0000 +++ zfs-linux-2.2.0~rc1/debian/changelog 2023-08-16 07:35:07.000000000 +0000 @@ -1,3 +1,10 @@ +zfs-linux (2.2.0~rc1-0ubuntu3) mantic; urgency=medium + + * Support linux 6.5 (LP: #2031492): + - debian/patches/4700-support-linux-6.5.patch + + -- Andrea Righi Wed, 16 Aug 2023 07:35:07 +0000 + zfs-linux (2.2.0~rc1-0ubuntu2) mantic; urgency=medium * Fixup up new symbols. diff -Nru zfs-linux-2.2.0~rc1/debian/patches/4700-support-linux-6.5.patch zfs-linux-2.2.0~rc1/debian/patches/4700-support-linux-6.5.patch --- zfs-linux-2.2.0~rc1/debian/patches/4700-support-linux-6.5.patch 1970-01-01 00:00:00.000000000 +0000 +++ zfs-linux-2.2.0~rc1/debian/patches/4700-support-linux-6.5.patch 2023-08-16 07:35:07.000000000 +0000 @@ -0,0 +1,993 @@ +From: Andrea Righi +Origin: upstream, https://github.com/openzfs/zfs.git + + META | 2 +- + config/kernel-blkdev.m4 | 138 +++++++++++++++++++++++++- + config/kernel-block-device-operations.m4 | 35 ++++++- + config/kernel-filemap-splice-read.m4 | 25 +++++ + config/kernel-register_sysctl_table.m4 | 27 +++++ + config/kernel-vfs-iov_iter.m4 | 26 ++++- + config/kernel.m4 | 4 + + include/os/linux/kernel/linux/blkdev_compat.h | 17 ++++ + include/os/linux/spl/sys/types.h | 2 +- + include/os/linux/spl/sys/uio.h | 12 +++ + include/sys/fm/fs/zfs.h | 2 - + include/sys/zio_checksum.h | 2 - + man/man8/zpool-events.8 | 4 - + module/os/linux/spl/spl-proc.c | 26 ++++- + module/os/linux/zfs/vdev_disk.c | 65 ++++++++++-- + module/os/linux/zfs/zfs_vnops_os.c | 2 +- + module/os/linux/zfs/zpl_ctldir.c | 2 +- + module/os/linux/zfs/zpl_file.c | 15 ++- + module/os/linux/zfs/zvol_os.c | 28 +++++- + module/zfs/brt.c | 6 +- + module/zfs/vdev_indirect.c | 2 +- + module/zfs/vdev_raidz.c | 2 +- + module/zfs/zfs_fm.c | 8 -- + module/zfs/zfs_vnops.c | 4 +- + module/zfs/zio_checksum.c | 2 - + 25 files changed, 399 insertions(+), 59 deletions(-) + +diff --git a/META b/META +index 5f834d5cc..827a5a0f3 100644 +--- a/META ++++ b/META +@@ -6,5 +6,5 @@ Release: rc1 + Release-Tags: relext + License: CDDL + Author: OpenZFS +-Linux-Maximum: 6.3 ++Linux-Maximum: 6.4 + Linux-Minimum: 3.10 +diff --git a/config/kernel-blkdev.m4 b/config/kernel-blkdev.m4 +index 28e536458..e04a2bd2c 100644 +--- a/config/kernel-blkdev.m4 ++++ b/config/kernel-blkdev.m4 +@@ -16,12 +16,63 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH], [ + ]) + ]) + ++dnl # ++dnl # 6.5.x API change, ++dnl # blkdev_get_by_path() takes 4 args ++dnl # ++AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH_4ARG], [ ++ ZFS_LINUX_TEST_SRC([blkdev_get_by_path_4arg], [ ++ #include ++ #include ++ ], [ ++ struct block_device *bdev __attribute__ ((unused)) = NULL; ++ const char *path = "path"; ++ fmode_t mode = 0; ++ void *holder = NULL; ++ struct blk_holder_ops h; ++ ++ bdev = blkdev_get_by_path(path, mode, holder, &h); ++ ]) ++]) ++ + AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH], [ +- AC_MSG_CHECKING([whether blkdev_get_by_path() exists]) ++ AC_MSG_CHECKING([whether blkdev_get_by_path() exists and takes 3 args]) + ZFS_LINUX_TEST_RESULT([blkdev_get_by_path], [ + AC_MSG_RESULT(yes) + ], [ +- ZFS_LINUX_TEST_ERROR([blkdev_get_by_path()]) ++ AC_MSG_RESULT(no) ++ AC_MSG_CHECKING([whether blkdev_get_by_path() exists and takes 4 args]) ++ ZFS_LINUX_TEST_RESULT([blkdev_get_by_path_4arg], [ ++ AC_DEFINE(HAVE_BLKDEV_GET_BY_PATH_4ARG, 1, ++ [blkdev_get_by_path() exists and takes 4 args]) ++ AC_MSG_RESULT(yes) ++ ], [ ++ ZFS_LINUX_TEST_ERROR([blkdev_get_by_path()]) ++ ]) ++ ]) ++]) ++ ++dnl # ++dnl # 6.5.x API change ++dnl # blk_mode_t was added as a type to supercede some places where fmode_t ++dnl # is used ++dnl # ++AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BLK_MODE_T], [ ++ ZFS_LINUX_TEST_SRC([blk_mode_t], [ ++ #include ++ #include ++ ], [ ++ blk_mode_t m __attribute((unused)) = (blk_mode_t)0; ++ ]) ++]) ++ ++AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BLK_MODE_T], [ ++ AC_MSG_CHECKING([whether blk_mode_t is defined]) ++ ZFS_LINUX_TEST_RESULT([blk_mode_t], [ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_BLK_MODE_T, 1, [blk_mode_t is defined]) ++ ], [ ++ AC_MSG_RESULT(no) + ]) + ]) + +@@ -41,12 +92,35 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PUT], [ + ]) + ]) + ++dnl # ++dnl # 6.5.x API change. ++dnl # blkdev_put() takes (void* holder) as arg 2 ++dnl # ++AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PUT_HOLDER], [ ++ ZFS_LINUX_TEST_SRC([blkdev_put_holder], [ ++ #include ++ #include ++ ], [ ++ struct block_device *bdev = NULL; ++ void *holder = NULL; ++ ++ blkdev_put(bdev, holder); ++ ]) ++]) ++ + AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_PUT], [ + AC_MSG_CHECKING([whether blkdev_put() exists]) + ZFS_LINUX_TEST_RESULT([blkdev_put], [ + AC_MSG_RESULT(yes) + ], [ +- ZFS_LINUX_TEST_ERROR([blkdev_put()]) ++ AC_MSG_CHECKING([whether blkdev_put() accepts void* as arg 2]) ++ ZFS_LINUX_TEST_RESULT([blkdev_put_holder], [ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_BLKDEV_PUT_HOLDER, 1, ++ [blkdev_put() accepts void* as arg 2]) ++ ], [ ++ ZFS_LINUX_TEST_ERROR([blkdev_put()]) ++ ]) + ]) + ]) + +@@ -103,6 +177,33 @@ AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE], [ + ]) + ]) + ++dnl # ++dnl # 6.5.x API change ++dnl # disk_check_media_change() was added ++dnl # ++AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_DISK_CHECK_MEDIA_CHANGE], [ ++ ZFS_LINUX_TEST_SRC([disk_check_media_change], [ ++ #include ++ #include ++ ], [ ++ struct block_device *bdev = NULL; ++ bool error; ++ ++ error = disk_check_media_change(bdev->bd_disk); ++ ]) ++]) ++ ++AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_DISK_CHECK_MEDIA_CHANGE], [ ++ AC_MSG_CHECKING([whether disk_check_media_change() exists]) ++ ZFS_LINUX_TEST_RESULT([disk_check_media_change], [ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_DISK_CHECK_MEDIA_CHANGE, 1, ++ [disk_check_media_change() exists]) ++ ], [ ++ AC_MSG_RESULT(no) ++ ]) ++]) ++ + dnl # + dnl # bdev_kobj() is introduced from 5.12 + dnl # +@@ -443,9 +544,34 @@ AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS], [ + ]) + ]) + ++dnl # ++dnl # 6.5.x API change ++dnl # BLK_STS_NEXUS replaced with BLK_STS_RESV_CONFLICT ++dnl # ++AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BLK_STS_RESV_CONFLICT], [ ++ ZFS_LINUX_TEST_SRC([blk_sts_resv_conflict], [ ++ #include ++ ],[ ++ blk_status_t s __attribute__ ((unused)) = BLK_STS_RESV_CONFLICT; ++ ]) ++]) ++ ++AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BLK_STS_RESV_CONFLICT], [ ++ AC_MSG_CHECKING([whether BLK_STS_RESV_CONFLICT is defined]) ++ ZFS_LINUX_TEST_RESULT([blk_sts_resv_conflict], [ ++ AC_DEFINE(HAVE_BLK_STS_RESV_CONFLICT, 1, [BLK_STS_RESV_CONFLICT is defined]) ++ AC_MSG_RESULT(yes) ++ ], [ ++ AC_MSG_RESULT(no) ++ ]) ++ ]) ++]) ++ + AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV], [ + ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH ++ ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH_4ARG + ZFS_AC_KERNEL_SRC_BLKDEV_PUT ++ ZFS_AC_KERNEL_SRC_BLKDEV_PUT_HOLDER + ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART + ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV + ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV +@@ -458,6 +584,9 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV], [ + ZFS_AC_KERNEL_SRC_BLKDEV_ISSUE_SECURE_ERASE + ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_KOBJ + ZFS_AC_KERNEL_SRC_BLKDEV_PART_TO_DEV ++ ZFS_AC_KERNEL_SRC_BLKDEV_DISK_CHECK_MEDIA_CHANGE ++ ZFS_AC_KERNEL_SRC_BLKDEV_BLK_STS_RESV_CONFLICT ++ ZFS_AC_KERNEL_SRC_BLKDEV_BLK_MODE_T + ]) + + AC_DEFUN([ZFS_AC_KERNEL_BLKDEV], [ +@@ -476,4 +605,7 @@ AC_DEFUN([ZFS_AC_KERNEL_BLKDEV], [ + ZFS_AC_KERNEL_BLKDEV_ISSUE_SECURE_ERASE + ZFS_AC_KERNEL_BLKDEV_BDEV_KOBJ + ZFS_AC_KERNEL_BLKDEV_PART_TO_DEV ++ ZFS_AC_KERNEL_BLKDEV_DISK_CHECK_MEDIA_CHANGE ++ ZFS_AC_KERNEL_BLKDEV_BLK_STS_RESV_CONFLICT ++ ZFS_AC_KERNEL_BLKDEV_BLK_MODE_T + ]) +diff --git a/config/kernel-block-device-operations.m4 b/config/kernel-block-device-operations.m4 +index 84e39dc8a..d13c1337b 100644 +--- a/config/kernel-block-device-operations.m4 ++++ b/config/kernel-block-device-operations.m4 +@@ -49,12 +49,42 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID], [ + ], [], []) + ]) + ++dnl # ++dnl # 5.9.x API change ++dnl # ++AC_DEFUN([ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_RELEASE_1ARG], [ ++ ZFS_LINUX_TEST_SRC([block_device_operations_release_void_1arg], [ ++ #include ++ ++ void blk_release(struct gendisk *g) { ++ (void) g; ++ return; ++ } ++ ++ static const struct block_device_operations ++ bops __attribute__ ((unused)) = { ++ .open = NULL, ++ .release = blk_release, ++ .ioctl = NULL, ++ .compat_ioctl = NULL, ++ }; ++ ], [], []) ++]) ++ + AC_DEFUN([ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID], [ +- AC_MSG_CHECKING([whether bops->release() is void]) ++ AC_MSG_CHECKING([whether bops->release() is void and takes 2 args]) + ZFS_LINUX_TEST_RESULT([block_device_operations_release_void], [ + AC_MSG_RESULT(yes) + ],[ +- ZFS_LINUX_TEST_ERROR([bops->release()]) ++ AC_MSG_RESULT(no) ++ AC_MSG_CHECKING([whether bops->release() is void and takes 1 arg]) ++ ZFS_LINUX_TEST_RESULT([block_device_operations_release_void_1arg], [ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE([HAVE_BLOCK_DEVICE_OPERATIONS_RELEASE_1ARG], [1], ++ [Define if release() in block_device_operations takes 1 arg]) ++ ],[ ++ ZFS_LINUX_TEST_ERROR([bops->release()]) ++ ]) + ]) + ]) + +@@ -92,6 +122,7 @@ AC_DEFUN([ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK], [ + AC_DEFUN([ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS], [ + ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_CHECK_EVENTS + ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID ++ ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_RELEASE_1ARG + ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK + ]) + +diff --git a/config/kernel-filemap-splice-read.m4 b/config/kernel-filemap-splice-read.m4 +new file mode 100644 +index 000000000..4c83b31d7 +--- /dev/null ++++ b/config/kernel-filemap-splice-read.m4 +@@ -0,0 +1,25 @@ ++AC_DEFUN([ZFS_AC_KERNEL_SRC_COPY_SPLICE_READ], [ ++ dnl # ++ dnl # Kernel 6.5 - generic_file_splice_read was removed in favor ++ dnl # of copy_splice_read for the .splice_read member of the ++ dnl # file_operations struct. ++ dnl # ++ ZFS_LINUX_TEST_SRC([has_copy_splice_read], [ ++ #include ++ ++ struct file_operations fops __attribute__((unused)) = { ++ .splice_read = copy_splice_read, ++ }; ++ ],[]) ++]) ++ ++AC_DEFUN([ZFS_AC_KERNEL_COPY_SPLICE_READ], [ ++ AC_MSG_CHECKING([whether copy_splice_read() exists]) ++ ZFS_LINUX_TEST_RESULT([has_copy_splice_read], [ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_COPY_SPLICE_READ, 1, ++ [copy_splice_read exists]) ++ ],[ ++ AC_MSG_RESULT(no) ++ ]) ++]) +diff --git a/config/kernel-register_sysctl_table.m4 b/config/kernel-register_sysctl_table.m4 +new file mode 100644 +index 000000000..a5e934f56 +--- /dev/null ++++ b/config/kernel-register_sysctl_table.m4 +@@ -0,0 +1,27 @@ ++dnl # ++dnl # Linux 6.5 removes register_sysctl_table ++dnl # ++AC_DEFUN([ZFS_AC_KERNEL_SRC_REGISTER_SYSCTL_TABLE], [ ++ ZFS_LINUX_TEST_SRC([has_register_sysctl_table], [ ++ #include ++ ++ static struct ctl_table dummy_table[] = { ++ {} ++ }; ++ ++ ],[ ++ struct ctl_table_header *h ++ __attribute((unused)) = register_sysctl_table(dummy_table); ++ ]) ++]) ++ ++AC_DEFUN([ZFS_AC_KERNEL_REGISTER_SYSCTL_TABLE], [ ++ AC_MSG_CHECKING([whether register_sysctl_table exists]) ++ ZFS_LINUX_TEST_RESULT([has_register_sysctl_table], [ ++ AC_MSG_RESULT([yes]) ++ AC_DEFINE(HAVE_REGISTER_SYSCTL_TABLE, 1, ++ [register_sysctl_table exists]) ++ ],[ ++ AC_MSG_RESULT([no]) ++ ]) ++]) +diff --git a/config/kernel-vfs-iov_iter.m4 b/config/kernel-vfs-iov_iter.m4 +index e0617faab..ff560ff3e 100644 +--- a/config/kernel-vfs-iov_iter.m4 ++++ b/config/kernel-vfs-iov_iter.m4 +@@ -6,8 +6,7 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_IOV_ITER], [ + #include + #include + ],[ +- int type __attribute__ ((unused)) = +- ITER_IOVEC | ITER_KVEC | ITER_BVEC | ITER_PIPE; ++ int type __attribute__ ((unused)) = ITER_KVEC; + ]) + + ZFS_LINUX_TEST_SRC([iov_iter_advance], [ +@@ -93,6 +92,14 @@ AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_IOV_ITER], [ + struct iov_iter iter = { 0 }; + __attribute__((unused)) enum iter_type i = iov_iter_type(&iter); + ]) ++ ++ ZFS_LINUX_TEST_SRC([iter_iov], [ ++ #include ++ #include ++ ],[ ++ struct iov_iter iter = { 0 }; ++ __attribute__((unused)) const struct iovec *iov = iter_iov(&iter); ++ ]) + ]) + + AC_DEFUN([ZFS_AC_KERNEL_VFS_IOV_ITER], [ +@@ -201,4 +208,19 @@ AC_DEFUN([ZFS_AC_KERNEL_VFS_IOV_ITER], [ + AC_DEFINE(HAVE_VFS_IOV_ITER, 1, + [All required iov_iter interfaces are available]) + ]) ++ ++ dnl # ++ dnl # Kernel 6.5 introduces the iter_iov() function that returns the ++ dnl # __iov member of an iov_iter*. The iov member was renamed to this ++ dnl # __iov member, and is intended to be accessed via the helper ++ dnl # function now. ++ dnl # ++ AC_MSG_CHECKING([whether iter_iov() is available]) ++ ZFS_LINUX_TEST_RESULT([iter_iov], [ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_ITER_IOV, 1, ++ [iter_iov() is available]) ++ ],[ ++ AC_MSG_RESULT(no) ++ ]) + ]) +diff --git a/config/kernel.m4 b/config/kernel.m4 +index cb7e736c9..650acde23 100644 +--- a/config/kernel.m4 ++++ b/config/kernel.m4 +@@ -154,6 +154,8 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_SRC], [ + ZFS_AC_KERNEL_SRC_FILEMAP + ZFS_AC_KERNEL_SRC_WRITEPAGE_T + ZFS_AC_KERNEL_SRC_RECLAIMED ++ ZFS_AC_KERNEL_SRC_REGISTER_SYSCTL_TABLE ++ ZFS_AC_KERNEL_SRC_COPY_SPLICE_READ + case "$host_cpu" in + powerpc*) + ZFS_AC_KERNEL_SRC_CPU_HAS_FEATURE +@@ -287,6 +289,8 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_RESULT], [ + ZFS_AC_KERNEL_FILEMAP + ZFS_AC_KERNEL_WRITEPAGE_T + ZFS_AC_KERNEL_RECLAIMED ++ ZFS_AC_KERNEL_REGISTER_SYSCTL_TABLE ++ ZFS_AC_KERNEL_COPY_SPLICE_READ + case "$host_cpu" in + powerpc*) + ZFS_AC_KERNEL_CPU_HAS_FEATURE +diff --git a/include/os/linux/kernel/linux/blkdev_compat.h b/include/os/linux/kernel/linux/blkdev_compat.h +index c5c6385be..f111e648c 100644 +--- a/include/os/linux/kernel/linux/blkdev_compat.h ++++ b/include/os/linux/kernel/linux/blkdev_compat.h +@@ -181,7 +181,11 @@ bi_status_to_errno(blk_status_t status) + return (ENOLINK); + case BLK_STS_TARGET: + return (EREMOTEIO); ++#ifdef HAVE_BLK_STS_RESV_CONFLICT ++ case BLK_STS_RESV_CONFLICT: ++#else + case BLK_STS_NEXUS: ++#endif + return (EBADE); + case BLK_STS_MEDIUM: + return (ENODATA); +@@ -215,7 +219,11 @@ errno_to_bi_status(int error) + case EREMOTEIO: + return (BLK_STS_TARGET); + case EBADE: ++#ifdef HAVE_BLK_STS_RESV_CONFLICT ++ return (BLK_STS_RESV_CONFLICT); ++#else + return (BLK_STS_NEXUS); ++#endif + case ENODATA: + return (BLK_STS_MEDIUM); + case EILSEQ: +@@ -337,6 +345,9 @@ zfs_check_media_change(struct block_device *bdev) + return (0); + } + #define vdev_bdev_reread_part(bdev) zfs_check_media_change(bdev) ++#elif defined(HAVE_DISK_CHECK_MEDIA_CHANGE) ++#define vdev_bdev_reread_part(bdev) disk_check_media_change(bdev->bd_disk) ++#define zfs_check_media_change(bdev) disk_check_media_change(bdev->bd_disk) + #else + /* + * This is encountered if check_disk_change() and bdev_check_media_change() +@@ -387,6 +398,12 @@ vdev_lookup_bdev(const char *path, dev_t *dev) + #endif + } + ++#if defined(HAVE_BLK_MODE_T) ++#define blk_mode_is_open_write(flag) ((flag) & BLK_OPEN_WRITE) ++#else ++#define blk_mode_is_open_write(flag) ((flag) & FMODE_WRITE) ++#endif ++ + /* + * Kernels without bio_set_op_attrs use bi_rw for the bio flags. + */ +diff --git a/include/os/linux/spl/sys/types.h b/include/os/linux/spl/sys/types.h +index a7666187e..d89a91c36 100644 +--- a/include/os/linux/spl/sys/types.h ++++ b/include/os/linux/spl/sys/types.h +@@ -38,7 +38,7 @@ typedef unsigned long ulong_t; + typedef unsigned long long u_longlong_t; + typedef long long longlong_t; + +-typedef unsigned long intptr_t; ++typedef long intptr_t; + typedef unsigned long long rlim64_t; + + typedef struct task_struct kthread_t; +diff --git a/include/os/linux/spl/sys/uio.h b/include/os/linux/spl/sys/uio.h +index fe2b5c07a..cce097e16 100644 +--- a/include/os/linux/spl/sys/uio.h ++++ b/include/os/linux/spl/sys/uio.h +@@ -173,4 +173,16 @@ zfs_uio_iov_iter_init(zfs_uio_t *uio, struct iov_iter *iter, offset_t offset, + } + #endif + ++#if defined(HAVE_ITER_IOV) ++#define zfs_uio_iter_iov(iter) iter_iov((iter)) ++#else ++#define zfs_uio_iter_iov(iter) (iter)->iov ++#endif ++ ++#if defined(HAVE_IOV_ITER_TYPE) ++#define zfs_uio_iov_iter_type(iter) iov_iter_type((iter)) ++#else ++#define zfs_uio_iov_iter_type(iter) (iter)->type ++#endif ++ + #endif /* SPL_UIO_H */ +diff --git a/include/sys/fm/fs/zfs.h b/include/sys/fm/fs/zfs.h +index b9bac7e25..e5d53d3a2 100644 +--- a/include/sys/fm/fs/zfs.h ++++ b/include/sys/fm/fs/zfs.h +@@ -102,8 +102,6 @@ extern "C" { + #define FM_EREPORT_PAYLOAD_ZFS_ZIO_TIMESTAMP "zio_timestamp" + #define FM_EREPORT_PAYLOAD_ZFS_ZIO_DELTA "zio_delta" + #define FM_EREPORT_PAYLOAD_ZFS_PREV_STATE "prev_state" +-#define FM_EREPORT_PAYLOAD_ZFS_CKSUM_EXPECTED "cksum_expected" +-#define FM_EREPORT_PAYLOAD_ZFS_CKSUM_ACTUAL "cksum_actual" + #define FM_EREPORT_PAYLOAD_ZFS_CKSUM_ALGO "cksum_algorithm" + #define FM_EREPORT_PAYLOAD_ZFS_CKSUM_BYTESWAP "cksum_byteswap" + #define FM_EREPORT_PAYLOAD_ZFS_BAD_OFFSET_RANGES "bad_ranges" +diff --git a/include/sys/zio_checksum.h b/include/sys/zio_checksum.h +index 9fb79ab4a..37fd65b7c 100644 +--- a/include/sys/zio_checksum.h ++++ b/include/sys/zio_checksum.h +@@ -94,8 +94,6 @@ typedef const struct zio_checksum_info { + } zio_checksum_info_t; + + typedef struct zio_bad_cksum { +- zio_cksum_t zbc_expected; +- zio_cksum_t zbc_actual; + const char *zbc_checksum_name; + uint8_t zbc_byteswapped; + uint8_t zbc_injected; +diff --git a/man/man8/zpool-events.8 b/man/man8/zpool-events.8 +index 341f902fe..365830bad 100644 +--- a/man/man8/zpool-events.8 ++++ b/man/man8/zpool-events.8 +@@ -305,10 +305,6 @@ The time when a given I/O request was submitted. + The time required to service a given I/O request. + .It Sy prev_state + The previous state of the vdev. +-.It Sy cksum_expected +-The expected checksum value for the block. +-.It Sy cksum_actual +-The actual checksum value for an errant block. + .It Sy cksum_algorithm + Checksum algorithm used. + See +diff --git a/module/os/linux/spl/spl-proc.c b/module/os/linux/spl/spl-proc.c +index 01f5619e1..bcc356ae5 100644 +--- a/module/os/linux/spl/spl-proc.c ++++ b/module/os/linux/spl/spl-proc.c +@@ -624,6 +624,7 @@ static struct ctl_table spl_table[] = { + .mode = 0644, + .proc_handler = &proc_dohostid, + }, ++#ifdef HAVE_REGISTER_SYSCTL_TABLE + { + .procname = "kmem", + .mode = 0555, +@@ -634,9 +635,11 @@ static struct ctl_table spl_table[] = { + .mode = 0555, + .child = spl_kstat_table, + }, ++#endif + {}, + }; + ++#ifdef HAVE_REGISTER_SYSCTL_TABLE + static struct ctl_table spl_dir[] = { + { + .procname = "spl", +@@ -648,21 +651,38 @@ static struct ctl_table spl_dir[] = { + + static struct ctl_table spl_root[] = { + { +- .procname = "kernel", +- .mode = 0555, +- .child = spl_dir, ++ .procname = "kernel", ++ .mode = 0555, ++ .child = spl_dir, + }, + {} + }; ++#endif + + int + spl_proc_init(void) + { + int rc = 0; + ++#ifdef HAVE_REGISTER_SYSCTL_TABLE + spl_header = register_sysctl_table(spl_root); + if (spl_header == NULL) + return (-EUNATCH); ++#else ++ spl_header = register_sysctl("kernel/spl", spl_table); ++ if (spl_header == NULL) ++ return (-EUNATCH); ++ ++ if (register_sysctl("kernel/spl/kmem", spl_kmem_table) == NULL) { ++ rc = -EUNATCH; ++ goto out; ++ } ++ ++ if (register_sysctl("kernel/spl/kstat", spl_kstat_table) == NULL) { ++ rc = -EUNATCH; ++ goto out; ++ } ++#endif + + proc_spl = proc_mkdir("spl", NULL); + if (proc_spl == NULL) { +diff --git a/module/os/linux/zfs/vdev_disk.c b/module/os/linux/zfs/vdev_disk.c +index 925ee9d9f..48ac55f07 100644 +--- a/module/os/linux/zfs/vdev_disk.c ++++ b/module/os/linux/zfs/vdev_disk.c +@@ -80,9 +80,22 @@ typedef struct dio_request { + + static unsigned int zfs_vdev_failfast_mask = 1; + ++#ifdef HAVE_BLK_MODE_T ++static blk_mode_t ++#else + static fmode_t ++#endif + vdev_bdev_mode(spa_mode_t spa_mode) + { ++#ifdef HAVE_BLK_MODE_T ++ blk_mode_t mode = 0; ++ ++ if (spa_mode & SPA_MODE_READ) ++ mode |= BLK_OPEN_READ; ++ ++ if (spa_mode & SPA_MODE_WRITE) ++ mode |= BLK_OPEN_WRITE; ++#else + fmode_t mode = 0; + + if (spa_mode & SPA_MODE_READ) +@@ -90,6 +103,7 @@ vdev_bdev_mode(spa_mode_t spa_mode) + + if (spa_mode & SPA_MODE_WRITE) + mode |= FMODE_WRITE; ++#endif + + return (mode); + } +@@ -197,12 +211,47 @@ vdev_disk_kobj_evt_post(vdev_t *v) + } + } + ++#if !defined(HAVE_BLKDEV_GET_BY_PATH_4ARG) ++/* ++ * Define a dummy struct blk_holder_ops for kernel versions ++ * prior to 6.5. ++ */ ++struct blk_holder_ops {}; ++#endif ++ ++static struct block_device * ++vdev_blkdev_get_by_path(const char *path, spa_mode_t mode, void *holder, ++ const struct blk_holder_ops *hops) ++{ ++#ifdef HAVE_BLKDEV_GET_BY_PATH_4ARG ++ return (blkdev_get_by_path(path, ++ vdev_bdev_mode(mode) | BLK_OPEN_EXCL, holder, hops)); ++#else ++ return (blkdev_get_by_path(path, ++ vdev_bdev_mode(mode) | FMODE_EXCL, holder)); ++#endif ++} ++ ++static void ++vdev_blkdev_put(struct block_device *bdev, spa_mode_t mode, void *holder) ++{ ++#ifdef HAVE_BLKDEV_PUT_HOLDER ++ return (blkdev_put(bdev, holder)); ++#else ++ return (blkdev_put(bdev, vdev_bdev_mode(mode) | FMODE_EXCL)); ++#endif ++} ++ + static int + vdev_disk_open(vdev_t *v, uint64_t *psize, uint64_t *max_psize, + uint64_t *logical_ashift, uint64_t *physical_ashift) + { + struct block_device *bdev; ++#ifdef HAVE_BLK_MODE_T ++ blk_mode_t mode = vdev_bdev_mode(spa_mode(v->vdev_spa)); ++#else + fmode_t mode = vdev_bdev_mode(spa_mode(v->vdev_spa)); ++#endif + hrtime_t timeout = MSEC2NSEC(zfs_vdev_open_timeout_ms); + vdev_disk_t *vd; + +@@ -252,15 +301,15 @@ vdev_disk_open(vdev_t *v, uint64_t *psize, uint64_t *max_psize, + reread_part = B_TRUE; + } + +- blkdev_put(bdev, mode | FMODE_EXCL); ++ vdev_blkdev_put(bdev, mode, zfs_vdev_holder); + } + + if (reread_part) { +- bdev = blkdev_get_by_path(disk_name, mode | FMODE_EXCL, +- zfs_vdev_holder); ++ bdev = vdev_blkdev_get_by_path(disk_name, mode, ++ zfs_vdev_holder, NULL); + if (!IS_ERR(bdev)) { + int error = vdev_bdev_reread_part(bdev); +- blkdev_put(bdev, mode | FMODE_EXCL); ++ vdev_blkdev_put(bdev, mode, zfs_vdev_holder); + if (error == 0) { + timeout = MSEC2NSEC( + zfs_vdev_open_timeout_ms * 2); +@@ -305,8 +354,8 @@ vdev_disk_open(vdev_t *v, uint64_t *psize, uint64_t *max_psize, + hrtime_t start = gethrtime(); + bdev = ERR_PTR(-ENXIO); + while (IS_ERR(bdev) && ((gethrtime() - start) < timeout)) { +- bdev = blkdev_get_by_path(v->vdev_path, mode | FMODE_EXCL, +- zfs_vdev_holder); ++ bdev = vdev_blkdev_get_by_path(v->vdev_path, mode, ++ zfs_vdev_holder, NULL); + if (unlikely(PTR_ERR(bdev) == -ENOENT)) { + /* + * There is no point of waiting since device is removed +@@ -382,8 +431,8 @@ vdev_disk_close(vdev_t *v) + return; + + if (vd->vd_bdev != NULL) { +- blkdev_put(vd->vd_bdev, +- vdev_bdev_mode(spa_mode(v->vdev_spa)) | FMODE_EXCL); ++ vdev_blkdev_put(vd->vd_bdev, spa_mode(v->vdev_spa), ++ zfs_vdev_holder); + } + + rw_destroy(&vd->vd_lock); +diff --git a/module/os/linux/zfs/zfs_vnops_os.c b/module/os/linux/zfs/zfs_vnops_os.c +index 234c4d5ef..33baac9db 100644 +--- a/module/os/linux/zfs/zfs_vnops_os.c ++++ b/module/os/linux/zfs/zfs_vnops_os.c +@@ -186,7 +186,7 @@ zfs_open(struct inode *ip, int mode, int flag, cred_t *cr) + return (error); + + /* Honor ZFS_APPENDONLY file attribute */ +- if ((mode & FMODE_WRITE) && (zp->z_pflags & ZFS_APPENDONLY) && ++ if (blk_mode_is_open_write(mode) && (zp->z_pflags & ZFS_APPENDONLY) && + ((flag & O_APPEND) == 0)) { + zfs_exit(zfsvfs, FTAG); + return (SET_ERROR(EPERM)); +diff --git a/module/os/linux/zfs/zpl_ctldir.c b/module/os/linux/zfs/zpl_ctldir.c +index 68a7de78f..7786444fe 100644 +--- a/module/os/linux/zfs/zpl_ctldir.c ++++ b/module/os/linux/zfs/zpl_ctldir.c +@@ -42,7 +42,7 @@ + static int + zpl_common_open(struct inode *ip, struct file *filp) + { +- if (filp->f_mode & FMODE_WRITE) ++ if (blk_mode_is_open_write(filp->f_mode)) + return (-EACCES); + + return (generic_file_open(ip, filp)); +diff --git a/module/os/linux/zfs/zpl_file.c b/module/os/linux/zfs/zpl_file.c +index e690525d3..c4c17f381 100644 +--- a/module/os/linux/zfs/zpl_file.c ++++ b/module/os/linux/zfs/zpl_file.c +@@ -301,15 +301,10 @@ zpl_uio_init(zfs_uio_t *uio, struct kiocb *kiocb, struct iov_iter *to, + #if defined(HAVE_VFS_IOV_ITER) + zfs_uio_iov_iter_init(uio, to, pos, count, skip); + #else +-#ifdef HAVE_IOV_ITER_TYPE +- zfs_uio_iovec_init(uio, to->iov, to->nr_segs, pos, +- iov_iter_type(to) & ITER_KVEC ? UIO_SYSSPACE : UIO_USERSPACE, ++ zfs_uio_iovec_init(uio, zfs_uio_iter_iov(to), to->nr_segs, pos, ++ zfs_uio_iov_iter_type(to) & ITER_KVEC ? ++ UIO_SYSSPACE : UIO_USERSPACE, + count, skip); +-#else +- zfs_uio_iovec_init(uio, to->iov, to->nr_segs, pos, +- to->type & ITER_KVEC ? UIO_SYSSPACE : UIO_USERSPACE, +- count, skip); +-#endif + #endif + } + +@@ -1318,7 +1313,11 @@ const struct file_operations zpl_file_operations = { + .read_iter = zpl_iter_read, + .write_iter = zpl_iter_write, + #ifdef HAVE_VFS_IOV_ITER ++#ifdef HAVE_COPY_SPLICE_READ ++ .splice_read = copy_splice_read, ++#else + .splice_read = generic_file_splice_read, ++#endif + .splice_write = iter_file_splice_write, + #endif + #else +diff --git a/module/os/linux/zfs/zvol_os.c b/module/os/linux/zfs/zvol_os.c +index 38bc8e2c4..7a95b54bd 100644 +--- a/module/os/linux/zfs/zvol_os.c ++++ b/module/os/linux/zfs/zvol_os.c +@@ -671,7 +671,11 @@ zvol_request(struct request_queue *q, struct bio *bio) + } + + static int ++#ifdef HAVE_BLK_MODE_T ++zvol_open(struct gendisk *disk, blk_mode_t flag) ++#else + zvol_open(struct block_device *bdev, fmode_t flag) ++#endif + { + zvol_state_t *zv; + int error = 0; +@@ -686,10 +690,14 @@ retry: + /* + * Obtain a copy of private_data under the zvol_state_lock to make + * sure that either the result of zvol free code path setting +- * bdev->bd_disk->private_data to NULL is observed, or zvol_os_free() ++ * disk->private_data to NULL is observed, or zvol_os_free() + * is not called on this zv because of the positive zv_open_count. + */ ++#ifdef HAVE_BLK_MODE_T ++ zv = disk->private_data; ++#else + zv = bdev->bd_disk->private_data; ++#endif + if (zv == NULL) { + rw_exit(&zvol_state_lock); + return (SET_ERROR(-ENXIO)); +@@ -769,14 +777,15 @@ retry: + } + } + +- error = -zvol_first_open(zv, !(flag & FMODE_WRITE)); ++ error = -zvol_first_open(zv, !(blk_mode_is_open_write(flag))); + + if (drop_namespace) + mutex_exit(&spa_namespace_lock); + } + + if (error == 0) { +- if ((flag & FMODE_WRITE) && (zv->zv_flags & ZVOL_RDONLY)) { ++ if ((blk_mode_is_open_write(flag)) && ++ (zv->zv_flags & ZVOL_RDONLY)) { + if (zv->zv_open_count == 0) + zvol_last_close(zv); + +@@ -791,14 +800,25 @@ retry: + rw_exit(&zv->zv_suspend_lock); + + if (error == 0) ++#ifdef HAVE_BLK_MODE_T ++ disk_check_media_change(disk); ++#else + zfs_check_media_change(bdev); ++#endif + + return (error); + } + + static void +-zvol_release(struct gendisk *disk, fmode_t mode) ++#ifdef HAVE_BLOCK_DEVICE_OPERATIONS_RELEASE_1ARG ++zvol_release(struct gendisk *disk) ++#else ++zvol_release(struct gendisk *disk, fmode_t unused) ++#endif + { ++#if !defined(HAVE_BLOCK_DEVICE_OPERATIONS_RELEASE_1ARG) ++ (void) unused; ++#endif + zvol_state_t *zv; + boolean_t drop_suspend = B_TRUE; + +diff --git a/module/zfs/brt.c b/module/zfs/brt.c +index 99bd472d6..877b503a1 100644 +--- a/module/zfs/brt.c ++++ b/module/zfs/brt.c +@@ -680,7 +680,7 @@ brt_vdev_realloc(brt_t *brt, brt_vdev_t *brtvd) + size = (vdev_get_min_asize(vd) - 1) / brt->brt_rangesize + 1; + spa_config_exit(brt->brt_spa, SCL_VDEV, FTAG); + +- entcount = kmem_zalloc(sizeof (entcount[0]) * size, KM_SLEEP); ++ entcount = vmem_zalloc(sizeof (entcount[0]) * size, KM_SLEEP); + nblocks = BRT_RANGESIZE_TO_NBLOCKS(size); + bitmap = kmem_zalloc(BT_SIZEOFMAP(nblocks), KM_SLEEP); + +@@ -709,7 +709,7 @@ brt_vdev_realloc(brt_t *brt, brt_vdev_t *brtvd) + sizeof (entcount[0]) * MIN(size, brtvd->bv_size)); + memcpy(bitmap, brtvd->bv_bitmap, MIN(BT_SIZEOFMAP(nblocks), + BT_SIZEOFMAP(brtvd->bv_nblocks))); +- kmem_free(brtvd->bv_entcount, ++ vmem_free(brtvd->bv_entcount, + sizeof (entcount[0]) * brtvd->bv_size); + kmem_free(brtvd->bv_bitmap, BT_SIZEOFMAP(brtvd->bv_nblocks)); + } +@@ -792,7 +792,7 @@ brt_vdev_dealloc(brt_t *brt, brt_vdev_t *brtvd) + ASSERT(RW_WRITE_HELD(&brt->brt_lock)); + ASSERT(brtvd->bv_initiated); + +- kmem_free(brtvd->bv_entcount, sizeof (uint16_t) * brtvd->bv_size); ++ vmem_free(brtvd->bv_entcount, sizeof (uint16_t) * brtvd->bv_size); + brtvd->bv_entcount = NULL; + kmem_free(brtvd->bv_bitmap, BT_SIZEOFMAP(brtvd->bv_nblocks)); + brtvd->bv_bitmap = NULL; +diff --git a/module/zfs/vdev_indirect.c b/module/zfs/vdev_indirect.c +index 896675853..acb725696 100644 +--- a/module/zfs/vdev_indirect.c ++++ b/module/zfs/vdev_indirect.c +@@ -1398,7 +1398,7 @@ vdev_indirect_checksum_error(zio_t *zio, + vd->vdev_stat.vs_checksum_errors++; + mutex_exit(&vd->vdev_stat_lock); + +- zio_bad_cksum_t zbc = {{{ 0 }}}; ++ zio_bad_cksum_t zbc = { 0 }; + abd_t *bad_abd = ic->ic_data; + abd_t *good_abd = is->is_good_child->ic_data; + (void) zfs_ereport_post_checksum(zio->io_spa, vd, NULL, zio, +diff --git a/module/zfs/vdev_raidz.c b/module/zfs/vdev_raidz.c +index 14b98a76b..3445fa9d3 100644 +--- a/module/zfs/vdev_raidz.c ++++ b/module/zfs/vdev_raidz.c +@@ -1785,7 +1785,7 @@ vdev_raidz_checksum_error(zio_t *zio, raidz_col_t *rc, abd_t *bad_data) + static int + raidz_checksum_verify(zio_t *zio) + { +- zio_bad_cksum_t zbc = {{{0}}}; ++ zio_bad_cksum_t zbc = {0}; + raidz_map_t *rm = zio->io_vsd; + + int ret = zio_checksum_error(zio, &zbc); +diff --git a/module/zfs/zfs_fm.c b/module/zfs/zfs_fm.c +index c42ef048d..470eaf076 100644 +--- a/module/zfs/zfs_fm.c ++++ b/module/zfs/zfs_fm.c +@@ -920,14 +920,6 @@ annotate_ecksum(nvlist_t *ereport, zio_bad_cksum_t *info, + + if (info != NULL && info->zbc_has_cksum) { + fm_payload_set(ereport, +- FM_EREPORT_PAYLOAD_ZFS_CKSUM_EXPECTED, +- DATA_TYPE_UINT64_ARRAY, +- sizeof (info->zbc_expected) / sizeof (uint64_t), +- (uint64_t *)&info->zbc_expected, +- FM_EREPORT_PAYLOAD_ZFS_CKSUM_ACTUAL, +- DATA_TYPE_UINT64_ARRAY, +- sizeof (info->zbc_actual) / sizeof (uint64_t), +- (uint64_t *)&info->zbc_actual, + FM_EREPORT_PAYLOAD_ZFS_CKSUM_ALGO, + DATA_TYPE_STRING, + info->zbc_checksum_name, +diff --git a/module/zfs/zfs_vnops.c b/module/zfs/zfs_vnops.c +index 7bdcc1639..3ebd2d0ff 100644 +--- a/module/zfs/zfs_vnops.c ++++ b/module/zfs/zfs_vnops.c +@@ -1212,7 +1212,7 @@ zfs_clone_range(znode_t *inzp, uint64_t *inoffp, znode_t *outzp, + gid = KGID_TO_SGID(ZTOGID(outzp)); + projid = outzp->z_projid; + +- bps = kmem_alloc(sizeof (bps[0]) * maxblocks, KM_SLEEP); ++ bps = vmem_alloc(sizeof (bps[0]) * maxblocks, KM_SLEEP); + + /* + * Clone the file in reasonable size chunks. Each chunk is cloned +@@ -1330,7 +1330,7 @@ zfs_clone_range(znode_t *inzp, uint64_t *inoffp, znode_t *outzp, + done += size; + } + +- kmem_free(bps, sizeof (bps[0]) * maxblocks); ++ vmem_free(bps, sizeof (bps[0]) * maxblocks); + zfs_znode_update_vfs(outzp); + + unlock: +diff --git a/module/zfs/zio_checksum.c b/module/zfs/zio_checksum.c +index 6090959c5..9de515e87 100644 +--- a/module/zfs/zio_checksum.c ++++ b/module/zfs/zio_checksum.c +@@ -515,8 +515,6 @@ zio_checksum_error_impl(spa_t *spa, const blkptr_t *bp, + } + + if (info != NULL) { +- info->zbc_expected = expected_cksum; +- info->zbc_actual = actual_cksum; + info->zbc_checksum_name = ci->ci_name; + info->zbc_byteswapped = byteswap; + info->zbc_injected = 0; diff -Nru zfs-linux-2.2.0~rc1/debian/patches/series zfs-linux-2.2.0~rc1/debian/patches/series --- zfs-linux-2.2.0~rc1/debian/patches/series 2023-07-06 17:09:30.000000000 +0000 +++ zfs-linux-2.2.0~rc1/debian/patches/series 2023-08-16 07:35:07.000000000 +0000 @@ -26,3 +26,4 @@ ubuntu/4510-silently-ignore-modprobe-failure.patch ubuntu/4751-suppress-types.patch bash-completion.patch +4700-support-linux-6.5.patch