[mirror_zfs.git] / config / kernel-blkdev.m4

dnl #
dnl # 2.6.38 API change,
dnl # Added blkdev_get_by_path()
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH], [
	ZFS_LINUX_TEST_SRC([blkdev_get_by_path], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		struct block_device *bdev __attribute__ ((unused)) = NULL;
		const char *path = "path";
		fmode_t mode = 0;
		void *holder = NULL;

		bdev = blkdev_get_by_path(path, mode, holder);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH], [
	AC_MSG_CHECKING([whether blkdev_get_by_path() exists])
	ZFS_LINUX_TEST_RESULT([blkdev_get_by_path], [
		AC_MSG_RESULT(yes)
	], [
		ZFS_LINUX_TEST_ERROR([blkdev_get_by_path()])
	])
])

dnl #
dnl # 2.6.38 API change,
dnl # Added blkdev_put()
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PUT], [
	ZFS_LINUX_TEST_SRC([blkdev_put], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		struct block_device *bdev = NULL;
		fmode_t mode = 0;

		blkdev_put(bdev, mode);
	])
])

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()])
	])
])

dnl #
dnl # 4.1 API, exported blkdev_reread_part() symbol, back ported to the
dnl # 3.10.0 CentOS 7.x enterprise kernels.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART], [
	ZFS_LINUX_TEST_SRC([blkdev_reread_part], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		struct block_device *bdev = NULL;
		int error;

		error = blkdev_reread_part(bdev);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_REREAD_PART], [
	AC_MSG_CHECKING([whether blkdev_reread_part() exists])
	ZFS_LINUX_TEST_RESULT([blkdev_reread_part], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BLKDEV_REREAD_PART, 1,
		    [blkdev_reread_part() exists])
	], [
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # check_disk_change() was removed in 5.10
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE], [
	ZFS_LINUX_TEST_SRC([check_disk_change], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		struct block_device *bdev = NULL;
		bool error;

		error = check_disk_change(bdev);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE], [
	AC_MSG_CHECKING([whether check_disk_change() exists])
	ZFS_LINUX_TEST_RESULT([check_disk_change], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_CHECK_DISK_CHANGE, 1,
		    [check_disk_change() exists])
	], [
		AC_MSG_RESULT(no)
	])
])

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 <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		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 #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_KOBJ], [
	ZFS_LINUX_TEST_SRC([bdev_kobj], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
		#include <linux/kobject.h>
	], [
		struct block_device *bdev = NULL;
		struct kobject *disk_kobj;
		disk_kobj = bdev_kobj(bdev);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_KOBJ], [
	AC_MSG_CHECKING([whether bdev_kobj() exists])
	ZFS_LINUX_TEST_RESULT([bdev_kobj], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BDEV_KOBJ, 1,
		    [bdev_kobj() exists])
	], [
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # part_to_dev() was removed in 5.12
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PART_TO_DEV], [
	ZFS_LINUX_TEST_SRC([part_to_dev], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		struct hd_struct *p = NULL;
		struct device *pdev;
		pdev = part_to_dev(p);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_PART_TO_DEV], [
	AC_MSG_CHECKING([whether part_to_dev() exists])
	ZFS_LINUX_TEST_RESULT([part_to_dev], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PART_TO_DEV, 1,
		    [part_to_dev() exists])
	], [
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 5.10 API, check_disk_change() is removed, in favor of
dnl # bdev_check_media_change(), which doesn't force revalidation
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
	ZFS_LINUX_TEST_SRC([bdev_check_media_change], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		struct block_device *bdev = NULL;
		int error;

		error = bdev_check_media_change(bdev);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
	AC_MSG_CHECKING([whether bdev_check_media_change() exists])
	ZFS_LINUX_TEST_RESULT([bdev_check_media_change], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BDEV_CHECK_MEDIA_CHANGE, 1,
		    [bdev_check_media_change() exists])
	], [
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 2.6.22 API change
dnl # Single argument invalidate_bdev()
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV], [
	ZFS_LINUX_TEST_SRC([invalidate_bdev], [
		#include <linux/buffer_head.h>
		#include <linux/blkdev.h>
	],[
		struct block_device *bdev = NULL;
		invalidate_bdev(bdev);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV], [
	AC_MSG_CHECKING([whether invalidate_bdev() exists])
	ZFS_LINUX_TEST_RESULT([invalidate_bdev], [
		AC_MSG_RESULT(yes)
	],[
		ZFS_LINUX_TEST_ERROR([invalidate_bdev()])
	])
])

dnl #
dnl # 5.11 API, lookup_bdev() takes dev_t argument.
dnl # 2.6.27 API, lookup_bdev() was first exported.
dnl # 4.4.0-6.21 API, lookup_bdev() on Ubuntu takes mode argument.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV], [
	ZFS_LINUX_TEST_SRC([lookup_bdev_devt], [
		#include <linux/blkdev.h>
	], [
		int error __attribute__ ((unused));
		const char path[] = "/example/path";
		dev_t dev;

		error = lookup_bdev(path, &dev);
	])

	ZFS_LINUX_TEST_SRC([lookup_bdev_1arg], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		struct block_device *bdev __attribute__ ((unused));
		const char path[] = "/example/path";

		bdev = lookup_bdev(path);
	])

	ZFS_LINUX_TEST_SRC([lookup_bdev_mode], [
		#include <linux/fs.h>
	], [
		struct block_device *bdev __attribute__ ((unused));
		const char path[] = "/example/path";

		bdev = lookup_bdev(path, FMODE_READ);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV], [
	AC_MSG_CHECKING([whether lookup_bdev() wants dev_t arg])
	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_devt],
	    [lookup_bdev], [fs/block_dev.c], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_DEVT_LOOKUP_BDEV, 1,
		    [lookup_bdev() wants dev_t arg])
	], [
		AC_MSG_RESULT(no)

		AC_MSG_CHECKING([whether lookup_bdev() wants 1 arg])
		ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_1arg],
		    [lookup_bdev], [fs/block_dev.c], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_1ARG_LOOKUP_BDEV, 1,
			    [lookup_bdev() wants 1 arg])
		], [
			AC_MSG_RESULT(no)

			AC_MSG_CHECKING([whether lookup_bdev() wants mode arg])
			ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_mode],
			    [lookup_bdev], [fs/block_dev.c], [
				AC_MSG_RESULT(yes)
				AC_DEFINE(HAVE_MODE_LOOKUP_BDEV, 1,
				    [lookup_bdev() wants mode arg])
			], [
				ZFS_LINUX_TEST_ERROR([lookup_bdev()])
			])
		])
	])
])

dnl #
dnl # 2.6.30 API change
dnl #
dnl # The bdev_physical_block_size() interface was added to provide a way
dnl # to determine the smallest write which can be performed without a
dnl # read-modify-write operation.
dnl #
dnl # Unfortunately, this interface isn't entirely reliable because
dnl # drives are sometimes known to misreport this value.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
	ZFS_LINUX_TEST_SRC([bdev_physical_block_size], [
		#include <linux/blkdev.h>
	],[
		struct block_device *bdev __attribute__ ((unused)) = NULL;
		bdev_physical_block_size(bdev);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
	AC_MSG_CHECKING([whether bdev_physical_block_size() is available])
	ZFS_LINUX_TEST_RESULT([bdev_physical_block_size], [
		AC_MSG_RESULT(yes)
	],[
		ZFS_LINUX_TEST_ERROR([bdev_physical_block_size()])
	])
])

dnl #
dnl # 2.6.30 API change
dnl # Added bdev_logical_block_size().
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
	ZFS_LINUX_TEST_SRC([bdev_logical_block_size], [
		#include <linux/blkdev.h>
	],[
		struct block_device *bdev __attribute__ ((unused)) = NULL;
		bdev_logical_block_size(bdev);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
	AC_MSG_CHECKING([whether bdev_logical_block_size() is available])
	ZFS_LINUX_TEST_RESULT([bdev_logical_block_size], [
		AC_MSG_RESULT(yes)
	],[
		ZFS_LINUX_TEST_ERROR([bdev_logical_block_size()])
	])
])

dnl #
dnl # 5.11 API change
dnl # Added bdev_whole() helper.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE], [
	ZFS_LINUX_TEST_SRC([bdev_whole], [
		#include <linux/blkdev.h>
	],[
		struct block_device *bdev = NULL;
		bdev = bdev_whole(bdev);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE], [
	AC_MSG_CHECKING([whether bdev_whole() is available])
	ZFS_LINUX_TEST_RESULT([bdev_whole], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BDEV_WHOLE, 1, [bdev_whole() is available])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 5.20 API change,
dnl # Removed bdevname(), snprintf(.., %pg) should be used.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEVNAME], [
	ZFS_LINUX_TEST_SRC([bdevname], [
		#include <linux/fs.h>
		#include <linux/blkdev.h>
	], [
		struct block_device *bdev __attribute__ ((unused)) = NULL;
		char path[BDEVNAME_SIZE];

		(void) bdevname(bdev, path);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEVNAME], [
	AC_MSG_CHECKING([whether bdevname() exists])
	ZFS_LINUX_TEST_RESULT([bdevname], [
		AC_DEFINE(HAVE_BDEVNAME, 1, [bdevname() is available])
		AC_MSG_RESULT(yes)
	], [
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 5.19 API: blkdev_issue_secure_erase()
dnl # 3.10 API: blkdev_issue_discard(..., BLKDEV_DISCARD_SECURE)
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_ISSUE_SECURE_ERASE], [
	ZFS_LINUX_TEST_SRC([blkdev_issue_secure_erase], [
		#include <linux/blkdev.h>
	],[
		struct block_device *bdev = NULL;
		sector_t sector = 0;
		sector_t nr_sects = 0;
		int error __attribute__ ((unused));

		error = blkdev_issue_secure_erase(bdev,
		    sector, nr_sects, GFP_KERNEL);
	])

	ZFS_LINUX_TEST_SRC([blkdev_issue_discard_flags], [
		#include <linux/blkdev.h>
	],[
		struct block_device *bdev = NULL;
		sector_t sector = 0;
		sector_t nr_sects = 0;
		unsigned long flags = 0;
		int error __attribute__ ((unused));

		error = blkdev_issue_discard(bdev,
		    sector, nr_sects, GFP_KERNEL, flags);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_ISSUE_SECURE_ERASE], [
	AC_MSG_CHECKING([whether blkdev_issue_secure_erase() is available])
	ZFS_LINUX_TEST_RESULT([blkdev_issue_secure_erase], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BLKDEV_ISSUE_SECURE_ERASE, 1,
		    [blkdev_issue_secure_erase() is available])
	],[
		AC_MSG_RESULT(no)

		AC_MSG_CHECKING([whether blkdev_issue_discard() is available])
		ZFS_LINUX_TEST_RESULT([blkdev_issue_discard_flags], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_BLKDEV_ISSUE_DISCARD, 1,
			    [blkdev_issue_discard() is available])
		],[
			ZFS_LINUX_TEST_ERROR([blkdev_issue_discard()])
		])
	])
])

dnl #
dnl # 5.13 API change
dnl # blkdev_get_by_path() no longer handles ERESTARTSYS
dnl #
dnl # Unfortunately we're forced to rely solely on the kernel version
dnl # number in order to determine the expected behavior.  This was an
dnl # internal change to blkdev_get_by_dev(), see commit a8ed1a0607.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS], [
	AC_MSG_CHECKING([whether blkdev_get_by_path() handles ERESTARTSYS])
	AS_VERSION_COMPARE([$LINUX_VERSION], [5.13.0], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BLKDEV_GET_ERESTARTSYS, 1,
			[blkdev_get_by_path() handles ERESTARTSYS])
	],[
		AC_MSG_RESULT(no)
	],[
		AC_MSG_RESULT(no)
	])
])

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 <linux/blkdev.h>
	],[
		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_PUT
	ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART
	ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV
	ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
	ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE
	ZFS_AC_KERNEL_SRC_BLKDEV_BDEVNAME
	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
])

AC_DEFUN([ZFS_AC_KERNEL_BLKDEV], [
	ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH
	ZFS_AC_KERNEL_BLKDEV_PUT
	ZFS_AC_KERNEL_BLKDEV_REREAD_PART
	ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV
	ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV
	ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
	ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
	ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE
	ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
	ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE
	ZFS_AC_KERNEL_BLKDEV_BDEVNAME
	ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS
	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
])
Commit	Line	Data
066e8252 BB	1	dnl #
	2	dnl # 2.6.38 API change,
	3	dnl # Added blkdev_get_by_path()
	4	dnl #
	5	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH], [
	6	ZFS_LINUX_TEST_SRC([blkdev_get_by_path], [
	7	#include <linux/fs.h>
1823c8fe	8	#include <linux/blkdev.h>
066e8252 BB	9	], [
	10	struct block_device *bdev __attribute__ ((unused)) = NULL;
	11	const char *path = "path";
	12	fmode_t mode = 0;
	13	void *holder = NULL;
	14
	15	bdev = blkdev_get_by_path(path, mode, holder);
	16	])
	17	])
	18
	19	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH], [
	20	AC_MSG_CHECKING([whether blkdev_get_by_path() exists])
	21	ZFS_LINUX_TEST_RESULT([blkdev_get_by_path], [
	22	AC_MSG_RESULT(yes)
	23	], [
	24	ZFS_LINUX_TEST_ERROR([blkdev_get_by_path()])
	25	])
	26	])
	27
	28	dnl #
	29	dnl # 2.6.38 API change,
	30	dnl # Added blkdev_put()
	31	dnl #
	32	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PUT], [
	33	ZFS_LINUX_TEST_SRC([blkdev_put], [
	34	#include <linux/fs.h>
1823c8fe	35	#include <linux/blkdev.h>
066e8252 BB	36	], [
	37	struct block_device *bdev = NULL;
	38	fmode_t mode = 0;
	39
	40	blkdev_put(bdev, mode);
	41	])
	42	])
	43
	44	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_PUT], [
	45	AC_MSG_CHECKING([whether blkdev_put() exists])
	46	ZFS_LINUX_TEST_RESULT([blkdev_put], [
	47	AC_MSG_RESULT(yes)
	48	], [
	49	ZFS_LINUX_TEST_ERROR([blkdev_put()])
	50	])
	51	])
	52
	53	dnl #
	54	dnl # 4.1 API, exported blkdev_reread_part() symbol, back ported to the
	55	dnl # 3.10.0 CentOS 7.x enterprise kernels.
	56	dnl #
	57	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART], [
	58	ZFS_LINUX_TEST_SRC([blkdev_reread_part], [
	59	#include <linux/fs.h>
1823c8fe	60	#include <linux/blkdev.h>
066e8252 BB	61	], [
	62	struct block_device *bdev = NULL;
	63	int error;
	64
	65	error = blkdev_reread_part(bdev);
	66	])
	67	])
	68
	69	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_REREAD_PART], [
	70	AC_MSG_CHECKING([whether blkdev_reread_part() exists])
	71	ZFS_LINUX_TEST_RESULT([blkdev_reread_part], [
	72	AC_MSG_RESULT(yes)
	73	AC_DEFINE(HAVE_BLKDEV_REREAD_PART, 1,
	74	[blkdev_reread_part() exists])
	75	], [
	76	AC_MSG_RESULT(no)
	77	])
	78	])
	79
ae15f1c1 CK	80	dnl #
	81	dnl # check_disk_change() was removed in 5.10
	82	dnl #
	83	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE], [
	84	ZFS_LINUX_TEST_SRC([check_disk_change], [
	85	#include <linux/fs.h>
	86	#include <linux/blkdev.h>
	87	], [
	88	struct block_device *bdev = NULL;
	89	bool error;
	90
	91	error = check_disk_change(bdev);
	92	])
	93	])
	94
	95	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE], [
	96	AC_MSG_CHECKING([whether check_disk_change() exists])
	97	ZFS_LINUX_TEST_RESULT([check_disk_change], [
	98	AC_MSG_RESULT(yes)
	99	AC_DEFINE(HAVE_CHECK_DISK_CHANGE, 1,
	100	[check_disk_change() exists])
	101	], [
	102	AC_MSG_RESULT(no)
	103	])
	104	])
	105
74f8ce4c CK	106	dnl #
	107	dnl # 6.5.x API change
	108	dnl # disk_check_media_change() was added
	109	dnl #
	110	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_DISK_CHECK_MEDIA_CHANGE], [
	111	ZFS_LINUX_TEST_SRC([disk_check_media_change], [
	112	#include <linux/fs.h>
	113	#include <linux/blkdev.h>
	114	], [
	115	struct block_device *bdev = NULL;
	116	bool error;
	117
	118	error = disk_check_media_change(bdev->bd_disk);
	119	])
	120	])
	121
	122	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_DISK_CHECK_MEDIA_CHANGE], [
	123	AC_MSG_CHECKING([whether disk_check_media_change() exists])
	124	ZFS_LINUX_TEST_RESULT([disk_check_media_change], [
	125	AC_MSG_RESULT(yes)
	126	AC_DEFINE(HAVE_DISK_CHECK_MEDIA_CHANGE, 1,
	127	[disk_check_media_change() exists])
	128	], [
	129	AC_MSG_RESULT(no)
	130	])
	131	])
	132
55c12724 AH	133	dnl #
	134	dnl # bdev_kobj() is introduced from 5.12
	135	dnl #
	136	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_KOBJ], [
	137	ZFS_LINUX_TEST_SRC([bdev_kobj], [
	138	#include <linux/fs.h>
	139	#include <linux/blkdev.h>
	140	#include <linux/kobject.h>
	141	], [
	142	struct block_device *bdev = NULL;
	143	struct kobject *disk_kobj;
	144	disk_kobj = bdev_kobj(bdev);
	145	])
	146	])
	147
	148	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_KOBJ], [
	149	AC_MSG_CHECKING([whether bdev_kobj() exists])
	150	ZFS_LINUX_TEST_RESULT([bdev_kobj], [
	151	AC_MSG_RESULT(yes)
	152	AC_DEFINE(HAVE_BDEV_KOBJ, 1,
	153	[bdev_kobj() exists])
	154	], [
	155	AC_MSG_RESULT(no)
	156	])
	157	])
	158
	159	dnl #
	160	dnl # part_to_dev() was removed in 5.12
	161	dnl #
	162	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PART_TO_DEV], [
	163	ZFS_LINUX_TEST_SRC([part_to_dev], [
	164	#include <linux/fs.h>
	165	#include <linux/blkdev.h>
	166	], [
	167	struct hd_struct *p = NULL;
	168	struct device *pdev;
	169	pdev = part_to_dev(p);
	170	])
	171	])
	172
	173	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_PART_TO_DEV], [
	174	AC_MSG_CHECKING([whether part_to_dev() exists])
	175	ZFS_LINUX_TEST_RESULT([part_to_dev], [
	176	AC_MSG_RESULT(yes)
	177	AC_DEFINE(HAVE_PART_TO_DEV, 1,
	178	[part_to_dev() exists])
	179	], [
	180	AC_MSG_RESULT(no)
	181	])
	182	])
	183
ae15f1c1 CK	184	dnl #
	185	dnl # 5.10 API, check_disk_change() is removed, in favor of
	186	dnl # bdev_check_media_change(), which doesn't force revalidation
	187	dnl #
	188	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
	189	ZFS_LINUX_TEST_SRC([bdev_check_media_change], [
	190	#include <linux/fs.h>
	191	#include <linux/blkdev.h>
	192	], [
	193	struct block_device *bdev = NULL;
	194	int error;
	195
	196	error = bdev_check_media_change(bdev);
	197	])
	198	])
	199
	200	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
5bee2659	201	AC_MSG_CHECKING([whether bdev_check_media_change() exists])
ae15f1c1 CK	202	ZFS_LINUX_TEST_RESULT([bdev_check_media_change], [
	203	AC_MSG_RESULT(yes)
	204	AC_DEFINE(HAVE_BDEV_CHECK_MEDIA_CHANGE, 1,
	205	[bdev_check_media_change() exists])
	206	], [
	207	AC_MSG_RESULT(no)
	208	])
	209	])
	210
066e8252 BB	211	dnl #
	212	dnl # 2.6.22 API change
	213	dnl # Single argument invalidate_bdev()
	214	dnl #
	215	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV], [
	216	ZFS_LINUX_TEST_SRC([invalidate_bdev], [
	217	#include <linux/buffer_head.h>
1823c8fe	218	#include <linux/blkdev.h>
066e8252 BB	219	],[
	220	struct block_device *bdev = NULL;
	221	invalidate_bdev(bdev);
	222	])
	223	])
	224
	225	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV], [
	226	AC_MSG_CHECKING([whether invalidate_bdev() exists])
	227	ZFS_LINUX_TEST_RESULT([invalidate_bdev], [
	228	AC_MSG_RESULT(yes)
	229	],[
	230	ZFS_LINUX_TEST_ERROR([invalidate_bdev()])
	231	])
	232	])
	233
	234	dnl #
b7281c88 BB	235	dnl # 5.11 API, lookup_bdev() takes dev_t argument.
	236	dnl # 2.6.27 API, lookup_bdev() was first exported.
	237	dnl # 4.4.0-6.21 API, lookup_bdev() on Ubuntu takes mode argument.
066e8252 BB	238	dnl #
066e8252 BB	239	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV], [
b7281c88 BB	240	ZFS_LINUX_TEST_SRC([lookup_bdev_devt], [
	241	#include <linux/blkdev.h>
	242	], [
	243	int error __attribute__ ((unused));
	244	const char path[] = "/example/path";
	245	dev_t dev;
	246
	247	error = lookup_bdev(path, &dev);
	248	])
	249
066e8252 BB	250	ZFS_LINUX_TEST_SRC([lookup_bdev_1arg], [
066e8252 BB	251	#include <linux/fs.h>
1823c8fe	252	#include <linux/blkdev.h>
066e8252	253	], [
b7281c88 BB	254	struct block_device *bdev __attribute__ ((unused));
	255	const char path[] = "/example/path";
	256
	257	bdev = lookup_bdev(path);
066e8252 BB	258	])
066e8252 BB	259
b7281c88	260	ZFS_LINUX_TEST_SRC([lookup_bdev_mode], [
066e8252 BB	261	#include <linux/fs.h>
066e8252 BB	262	], [
b7281c88 BB	263	struct block_device *bdev __attribute__ ((unused));
	264	const char path[] = "/example/path";
	265
	266	bdev = lookup_bdev(path, FMODE_READ);
066e8252 BB	267	])
	268	])
	269
	270	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV], [
b7281c88 BB	271	AC_MSG_CHECKING([whether lookup_bdev() wants dev_t arg])
b7281c88 BB	272	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_devt],
066e8252 BB	273	[lookup_bdev], [fs/block_dev.c], [
066e8252 BB	274	AC_MSG_RESULT(yes)
b7281c88 BB	275	AC_DEFINE(HAVE_DEVT_LOOKUP_BDEV, 1,
b7281c88 BB	276	[lookup_bdev() wants dev_t arg])
066e8252 BB	277	], [
	278	AC_MSG_RESULT(no)
	279
b7281c88 BB	280	AC_MSG_CHECKING([whether lookup_bdev() wants 1 arg])
b7281c88 BB	281	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_1arg],
066e8252 BB	282	[lookup_bdev], [fs/block_dev.c], [
066e8252 BB	283	AC_MSG_RESULT(yes)
b7281c88 BB	284	AC_DEFINE(HAVE_1ARG_LOOKUP_BDEV, 1,
b7281c88 BB	285	[lookup_bdev() wants 1 arg])
066e8252	286	], [
b7281c88 BB	287	AC_MSG_RESULT(no)
	288
	289	AC_MSG_CHECKING([whether lookup_bdev() wants mode arg])
	290	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_mode],
	291	[lookup_bdev], [fs/block_dev.c], [
	292	AC_MSG_RESULT(yes)
	293	AC_DEFINE(HAVE_MODE_LOOKUP_BDEV, 1,
	294	[lookup_bdev() wants mode arg])
	295	], [
	296	ZFS_LINUX_TEST_ERROR([lookup_bdev()])
	297	])
066e8252 BB	298	])
	299	])
	300	])
	301
	302	dnl #
	303	dnl # 2.6.30 API change
	304	dnl #
	305	dnl # The bdev_physical_block_size() interface was added to provide a way
	306	dnl # to determine the smallest write which can be performed without a
	307	dnl # read-modify-write operation.
	308	dnl #
	309	dnl # Unfortunately, this interface isn't entirely reliable because
	310	dnl # drives are sometimes known to misreport this value.
	311	dnl #
	312	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
	313	ZFS_LINUX_TEST_SRC([bdev_physical_block_size], [
	314	#include <linux/blkdev.h>
	315	],[
	316	struct block_device *bdev __attribute__ ((unused)) = NULL;
	317	bdev_physical_block_size(bdev);
	318	])
	319	])
	320
	321	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
	322	AC_MSG_CHECKING([whether bdev_physical_block_size() is available])
	323	ZFS_LINUX_TEST_RESULT([bdev_physical_block_size], [
	324	AC_MSG_RESULT(yes)
	325	],[
	326	ZFS_LINUX_TEST_ERROR([bdev_physical_block_size()])
	327	])
	328	])
	329
	330	dnl #
	331	dnl # 2.6.30 API change
	332	dnl # Added bdev_logical_block_size().
	333	dnl #
	334	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
	335	ZFS_LINUX_TEST_SRC([bdev_logical_block_size], [
	336	#include <linux/blkdev.h>
	337	],[
	338	struct block_device *bdev __attribute__ ((unused)) = NULL;
	339	bdev_logical_block_size(bdev);
	340	])
	341	])
	342
	343	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
	344	AC_MSG_CHECKING([whether bdev_logical_block_size() is available])
	345	ZFS_LINUX_TEST_RESULT([bdev_logical_block_size], [
	346	AC_MSG_RESULT(yes)
	347	],[
	348	ZFS_LINUX_TEST_ERROR([bdev_logical_block_size()])
	349	])
	350	])
	351
72ba4b2a BB	352	dnl #
	353	dnl # 5.11 API change
	354	dnl # Added bdev_whole() helper.
	355	dnl #
	356	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE], [
	357	ZFS_LINUX_TEST_SRC([bdev_whole], [
	358	#include <linux/blkdev.h>
	359	],[
	360	struct block_device *bdev = NULL;
	361	bdev = bdev_whole(bdev);
	362	])
	363	])
	364
	365	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE], [
	366	AC_MSG_CHECKING([whether bdev_whole() is available])
	367	ZFS_LINUX_TEST_RESULT([bdev_whole], [
	368	AC_MSG_RESULT(yes)
	369	AC_DEFINE(HAVE_BDEV_WHOLE, 1, [bdev_whole() is available])
	370	],[
	371	AC_MSG_RESULT(no)
	372	])
	373	])
	374
bebdf52a BB	375	dnl #
	376	dnl # 5.20 API change,
	377	dnl # Removed bdevname(), snprintf(.., %pg) should be used.
	378	dnl #
	379	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEVNAME], [
	380	ZFS_LINUX_TEST_SRC([bdevname], [
	381	#include <linux/fs.h>
	382	#include <linux/blkdev.h>
	383	], [
	384	struct block_device *bdev __attribute__ ((unused)) = NULL;
	385	char path[BDEVNAME_SIZE];
	386
	387	(void) bdevname(bdev, path);
	388	])
	389	])
	390
	391	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEVNAME], [
	392	AC_MSG_CHECKING([whether bdevname() exists])
	393	ZFS_LINUX_TEST_RESULT([bdevname], [
	394	AC_DEFINE(HAVE_BDEVNAME, 1, [bdevname() is available])
	395	AC_MSG_RESULT(yes)
	396	], [
	397	AC_MSG_RESULT(no)
	398	])
	399	])
	400
a12a5cb5 BB	401	dnl #
	402	dnl # 5.19 API: blkdev_issue_secure_erase()
	403	dnl # 3.10 API: blkdev_issue_discard(..., BLKDEV_DISCARD_SECURE)
	404	dnl #
	405	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_ISSUE_SECURE_ERASE], [
	406	ZFS_LINUX_TEST_SRC([blkdev_issue_secure_erase], [
	407	#include <linux/blkdev.h>
	408	],[
	409	struct block_device *bdev = NULL;
	410	sector_t sector = 0;
	411	sector_t nr_sects = 0;
	412	int error __attribute__ ((unused));
	413
	414	error = blkdev_issue_secure_erase(bdev,
	415	sector, nr_sects, GFP_KERNEL);
	416	])
	417
	418	ZFS_LINUX_TEST_SRC([blkdev_issue_discard_flags], [
	419	#include <linux/blkdev.h>
	420	],[
	421	struct block_device *bdev = NULL;
	422	sector_t sector = 0;
	423	sector_t nr_sects = 0;
	424	unsigned long flags = 0;
	425	int error __attribute__ ((unused));
	426
	427	error = blkdev_issue_discard(bdev,
	428	sector, nr_sects, GFP_KERNEL, flags);
	429	])
	430	])
	431
	432	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_ISSUE_SECURE_ERASE], [
	433	AC_MSG_CHECKING([whether blkdev_issue_secure_erase() is available])
	434	ZFS_LINUX_TEST_RESULT([blkdev_issue_secure_erase], [
	435	AC_MSG_RESULT(yes)
	436	AC_DEFINE(HAVE_BLKDEV_ISSUE_SECURE_ERASE, 1,
	437	[blkdev_issue_secure_erase() is available])
	438	],[
	439	AC_MSG_RESULT(no)
	440
	441	AC_MSG_CHECKING([whether blkdev_issue_discard() is available])
	442	ZFS_LINUX_TEST_RESULT([blkdev_issue_discard_flags], [
	443	AC_MSG_RESULT(yes)
	444	AC_DEFINE(HAVE_BLKDEV_ISSUE_DISCARD, 1,
	445	[blkdev_issue_discard() is available])
	446	],[
	447	ZFS_LINUX_TEST_ERROR([blkdev_issue_discard()])
	448	])
	449	])
	450	])
	451
77e2756d BB	452	dnl #
	453	dnl # 5.13 API change
	454	dnl # blkdev_get_by_path() no longer handles ERESTARTSYS
	455	dnl #
	456	dnl # Unfortunately we're forced to rely solely on the kernel version
	457	dnl # number in order to determine the expected behavior. This was an
	458	dnl # internal change to blkdev_get_by_dev(), see commit a8ed1a0607.
	459	dnl #
	460	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS], [
	461	AC_MSG_CHECKING([whether blkdev_get_by_path() handles ERESTARTSYS])
	462	AS_VERSION_COMPARE([$LINUX_VERSION], [5.13.0], [
	463	AC_MSG_RESULT(yes)
	464	AC_DEFINE(HAVE_BLKDEV_GET_ERESTARTSYS, 1,
	465	[blkdev_get_by_path() handles ERESTARTSYS])
	466	],[
	467	AC_MSG_RESULT(no)
	468	],[
	469	AC_MSG_RESULT(no)
	470	])
	471	])
	472
d3d63cac CK	473	dnl #
	474	dnl # 6.5.x API change
	475	dnl # BLK_STS_NEXUS replaced with BLK_STS_RESV_CONFLICT
	476	dnl #
	477	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BLK_STS_RESV_CONFLICT], [
	478	ZFS_LINUX_TEST_SRC([blk_sts_resv_conflict], [
	479	#include <linux/blkdev.h>
	480	],[
	481	blk_status_t s __attribute__ ((unused)) = BLK_STS_RESV_CONFLICT;
	482	])
	483	])
	484
	485	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BLK_STS_RESV_CONFLICT], [
	486	AC_MSG_CHECKING([whether BLK_STS_RESV_CONFLICT is defined])
	487	ZFS_LINUX_TEST_RESULT([blk_sts_resv_conflict], [
	488	AC_DEFINE(HAVE_BLK_STS_RESV_CONFLICT, 1, [BLK_STS_RESV_CONFLICT is defined])
	489	AC_MSG_RESULT(yes)
	490	], [
	491	AC_MSG_RESULT(no)
	492	])
	493	])
	494	])
	495
066e8252 BB	496	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV], [
	497	ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH
	498	ZFS_AC_KERNEL_SRC_BLKDEV_PUT
	499	ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART
	500	ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV
	501	ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV
	502	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
	503	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
ae15f1c1 CK	504	ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE
ae15f1c1 CK	505	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
72ba4b2a	506	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE
bebdf52a	507	ZFS_AC_KERNEL_SRC_BLKDEV_BDEVNAME
a12a5cb5	508	ZFS_AC_KERNEL_SRC_BLKDEV_ISSUE_SECURE_ERASE
55c12724 AH	509	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_KOBJ
55c12724 AH	510	ZFS_AC_KERNEL_SRC_BLKDEV_PART_TO_DEV
74f8ce4c	511	ZFS_AC_KERNEL_SRC_BLKDEV_DISK_CHECK_MEDIA_CHANGE
d3d63cac	512	ZFS_AC_KERNEL_SRC_BLKDEV_BLK_STS_RESV_CONFLICT
066e8252 BB	513	])
	514
	515	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV], [
	516	ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH
	517	ZFS_AC_KERNEL_BLKDEV_PUT
	518	ZFS_AC_KERNEL_BLKDEV_REREAD_PART
	519	ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV
	520	ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV
	521	ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
	522	ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
ae15f1c1 CK	523	ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE
ae15f1c1 CK	524	ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
72ba4b2a	525	ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE
bebdf52a	526	ZFS_AC_KERNEL_BLKDEV_BDEVNAME
77e2756d	527	ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS
a12a5cb5	528	ZFS_AC_KERNEL_BLKDEV_ISSUE_SECURE_ERASE
55c12724 AH	529	ZFS_AC_KERNEL_BLKDEV_BDEV_KOBJ
55c12724 AH	530	ZFS_AC_KERNEL_BLKDEV_PART_TO_DEV
74f8ce4c	531	ZFS_AC_KERNEL_BLKDEV_DISK_CHECK_MEDIA_CHANGE
d3d63cac	532	ZFS_AC_KERNEL_BLKDEV_BLK_STS_RESV_CONFLICT
066e8252	533	])