[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 # 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)
	])
])

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

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
])
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
	106	dnl #
	107	dnl # 5.10 API, check_disk_change() is removed, in favor of
	108	dnl # bdev_check_media_change(), which doesn't force revalidation
	109	dnl #
	110	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
	111	ZFS_LINUX_TEST_SRC([bdev_check_media_change], [
	112	#include <linux/fs.h>
	113	#include <linux/blkdev.h>
	114	], [
	115	struct block_device *bdev = NULL;
	116	int error;
	117
	118	error = bdev_check_media_change(bdev);
	119	])
	120	])
	121
	122	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
5bee2659	123	AC_MSG_CHECKING([whether bdev_check_media_change() exists])
ae15f1c1 CK	124	ZFS_LINUX_TEST_RESULT([bdev_check_media_change], [
	125	AC_MSG_RESULT(yes)
	126	AC_DEFINE(HAVE_BDEV_CHECK_MEDIA_CHANGE, 1,
	127	[bdev_check_media_change() exists])
	128	], [
	129	AC_MSG_RESULT(no)
	130	])
	131	])
	132
066e8252 BB	133	dnl #
	134	dnl # 2.6.22 API change
	135	dnl # Single argument invalidate_bdev()
	136	dnl #
	137	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV], [
	138	ZFS_LINUX_TEST_SRC([invalidate_bdev], [
	139	#include <linux/buffer_head.h>
1823c8fe	140	#include <linux/blkdev.h>
066e8252 BB	141	],[
	142	struct block_device *bdev = NULL;
	143	invalidate_bdev(bdev);
	144	])
	145	])
	146
	147	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV], [
	148	AC_MSG_CHECKING([whether invalidate_bdev() exists])
	149	ZFS_LINUX_TEST_RESULT([invalidate_bdev], [
	150	AC_MSG_RESULT(yes)
	151	],[
	152	ZFS_LINUX_TEST_ERROR([invalidate_bdev()])
	153	])
	154	])
	155
	156	dnl #
b7281c88 BB	157	dnl # 5.11 API, lookup_bdev() takes dev_t argument.
	158	dnl # 2.6.27 API, lookup_bdev() was first exported.
	159	dnl # 4.4.0-6.21 API, lookup_bdev() on Ubuntu takes mode argument.
066e8252 BB	160	dnl #
066e8252 BB	161	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV], [
b7281c88 BB	162	ZFS_LINUX_TEST_SRC([lookup_bdev_devt], [
	163	#include <linux/blkdev.h>
	164	], [
	165	int error __attribute__ ((unused));
	166	const char path[] = "/example/path";
	167	dev_t dev;
	168
	169	error = lookup_bdev(path, &dev);
	170	])
	171
066e8252 BB	172	ZFS_LINUX_TEST_SRC([lookup_bdev_1arg], [
066e8252 BB	173	#include <linux/fs.h>
1823c8fe	174	#include <linux/blkdev.h>
066e8252	175	], [
b7281c88 BB	176	struct block_device *bdev __attribute__ ((unused));
	177	const char path[] = "/example/path";
	178
	179	bdev = lookup_bdev(path);
066e8252 BB	180	])
066e8252 BB	181
b7281c88	182	ZFS_LINUX_TEST_SRC([lookup_bdev_mode], [
066e8252 BB	183	#include <linux/fs.h>
066e8252 BB	184	], [
b7281c88 BB	185	struct block_device *bdev __attribute__ ((unused));
	186	const char path[] = "/example/path";
	187
	188	bdev = lookup_bdev(path, FMODE_READ);
066e8252 BB	189	])
	190	])
	191
	192	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV], [
b7281c88 BB	193	AC_MSG_CHECKING([whether lookup_bdev() wants dev_t arg])
b7281c88 BB	194	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_devt],
066e8252 BB	195	[lookup_bdev], [fs/block_dev.c], [
066e8252 BB	196	AC_MSG_RESULT(yes)
b7281c88 BB	197	AC_DEFINE(HAVE_DEVT_LOOKUP_BDEV, 1,
b7281c88 BB	198	[lookup_bdev() wants dev_t arg])
066e8252 BB	199	], [
	200	AC_MSG_RESULT(no)
	201
b7281c88 BB	202	AC_MSG_CHECKING([whether lookup_bdev() wants 1 arg])
b7281c88 BB	203	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_1arg],
066e8252 BB	204	[lookup_bdev], [fs/block_dev.c], [
066e8252 BB	205	AC_MSG_RESULT(yes)
b7281c88 BB	206	AC_DEFINE(HAVE_1ARG_LOOKUP_BDEV, 1,
b7281c88 BB	207	[lookup_bdev() wants 1 arg])
066e8252	208	], [
b7281c88 BB	209	AC_MSG_RESULT(no)
	210
	211	AC_MSG_CHECKING([whether lookup_bdev() wants mode arg])
	212	ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_mode],
	213	[lookup_bdev], [fs/block_dev.c], [
	214	AC_MSG_RESULT(yes)
	215	AC_DEFINE(HAVE_MODE_LOOKUP_BDEV, 1,
	216	[lookup_bdev() wants mode arg])
	217	], [
	218	ZFS_LINUX_TEST_ERROR([lookup_bdev()])
	219	])
066e8252 BB	220	])
	221	])
	222	])
	223
	224	dnl #
	225	dnl # 2.6.30 API change
	226	dnl #
	227	dnl # The bdev_physical_block_size() interface was added to provide a way
	228	dnl # to determine the smallest write which can be performed without a
	229	dnl # read-modify-write operation.
	230	dnl #
	231	dnl # Unfortunately, this interface isn't entirely reliable because
	232	dnl # drives are sometimes known to misreport this value.
	233	dnl #
	234	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
	235	ZFS_LINUX_TEST_SRC([bdev_physical_block_size], [
	236	#include <linux/blkdev.h>
	237	],[
	238	struct block_device *bdev __attribute__ ((unused)) = NULL;
	239	bdev_physical_block_size(bdev);
	240	])
	241	])
	242
	243	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
	244	AC_MSG_CHECKING([whether bdev_physical_block_size() is available])
	245	ZFS_LINUX_TEST_RESULT([bdev_physical_block_size], [
	246	AC_MSG_RESULT(yes)
	247	],[
	248	ZFS_LINUX_TEST_ERROR([bdev_physical_block_size()])
	249	])
	250	])
	251
	252	dnl #
	253	dnl # 2.6.30 API change
	254	dnl # Added bdev_logical_block_size().
	255	dnl #
	256	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
	257	ZFS_LINUX_TEST_SRC([bdev_logical_block_size], [
	258	#include <linux/blkdev.h>
	259	],[
	260	struct block_device *bdev __attribute__ ((unused)) = NULL;
	261	bdev_logical_block_size(bdev);
	262	])
	263	])
	264
	265	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
	266	AC_MSG_CHECKING([whether bdev_logical_block_size() is available])
	267	ZFS_LINUX_TEST_RESULT([bdev_logical_block_size], [
	268	AC_MSG_RESULT(yes)
	269	],[
	270	ZFS_LINUX_TEST_ERROR([bdev_logical_block_size()])
	271	])
	272	])
	273
72ba4b2a BB	274	dnl #
	275	dnl # 5.11 API change
	276	dnl # Added bdev_whole() helper.
	277	dnl #
	278	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE], [
	279	ZFS_LINUX_TEST_SRC([bdev_whole], [
	280	#include <linux/blkdev.h>
	281	],[
	282	struct block_device *bdev = NULL;
	283	bdev = bdev_whole(bdev);
	284	])
	285	])
	286
	287	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE], [
	288	AC_MSG_CHECKING([whether bdev_whole() is available])
	289	ZFS_LINUX_TEST_RESULT([bdev_whole], [
	290	AC_MSG_RESULT(yes)
	291	AC_DEFINE(HAVE_BDEV_WHOLE, 1, [bdev_whole() is available])
	292	],[
	293	AC_MSG_RESULT(no)
	294	])
	295	])
	296
bebdf52a BB	297	dnl #
	298	dnl # 5.20 API change,
	299	dnl # Removed bdevname(), snprintf(.., %pg) should be used.
	300	dnl #
	301	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEVNAME], [
	302	ZFS_LINUX_TEST_SRC([bdevname], [
	303	#include <linux/fs.h>
	304	#include <linux/blkdev.h>
	305	], [
	306	struct block_device *bdev __attribute__ ((unused)) = NULL;
	307	char path[BDEVNAME_SIZE];
	308
	309	(void) bdevname(bdev, path);
	310	])
	311	])
	312
	313	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEVNAME], [
	314	AC_MSG_CHECKING([whether bdevname() exists])
	315	ZFS_LINUX_TEST_RESULT([bdevname], [
	316	AC_DEFINE(HAVE_BDEVNAME, 1, [bdevname() is available])
	317	AC_MSG_RESULT(yes)
	318	], [
	319	AC_MSG_RESULT(no)
	320	])
	321	])
	322
a12a5cb5 BB	323	dnl #
	324	dnl # 5.19 API: blkdev_issue_secure_erase()
	325	dnl # 3.10 API: blkdev_issue_discard(..., BLKDEV_DISCARD_SECURE)
	326	dnl #
	327	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_ISSUE_SECURE_ERASE], [
	328	ZFS_LINUX_TEST_SRC([blkdev_issue_secure_erase], [
	329	#include <linux/blkdev.h>
	330	],[
	331	struct block_device *bdev = NULL;
	332	sector_t sector = 0;
	333	sector_t nr_sects = 0;
	334	int error __attribute__ ((unused));
	335
	336	error = blkdev_issue_secure_erase(bdev,
	337	sector, nr_sects, GFP_KERNEL);
	338	])
	339
	340	ZFS_LINUX_TEST_SRC([blkdev_issue_discard_flags], [
	341	#include <linux/blkdev.h>
	342	],[
	343	struct block_device *bdev = NULL;
	344	sector_t sector = 0;
	345	sector_t nr_sects = 0;
	346	unsigned long flags = 0;
	347	int error __attribute__ ((unused));
	348
	349	error = blkdev_issue_discard(bdev,
	350	sector, nr_sects, GFP_KERNEL, flags);
	351	])
	352	])
	353
	354	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_ISSUE_SECURE_ERASE], [
	355	AC_MSG_CHECKING([whether blkdev_issue_secure_erase() is available])
	356	ZFS_LINUX_TEST_RESULT([blkdev_issue_secure_erase], [
	357	AC_MSG_RESULT(yes)
	358	AC_DEFINE(HAVE_BLKDEV_ISSUE_SECURE_ERASE, 1,
	359	[blkdev_issue_secure_erase() is available])
	360	],[
	361	AC_MSG_RESULT(no)
	362
	363	AC_MSG_CHECKING([whether blkdev_issue_discard() is available])
	364	ZFS_LINUX_TEST_RESULT([blkdev_issue_discard_flags], [
	365	AC_MSG_RESULT(yes)
	366	AC_DEFINE(HAVE_BLKDEV_ISSUE_DISCARD, 1,
	367	[blkdev_issue_discard() is available])
	368	],[
	369	ZFS_LINUX_TEST_ERROR([blkdev_issue_discard()])
	370	])
	371	])
	372	])
	373
77e2756d BB	374	dnl #
	375	dnl # 5.13 API change
	376	dnl # blkdev_get_by_path() no longer handles ERESTARTSYS
	377	dnl #
	378	dnl # Unfortunately we're forced to rely solely on the kernel version
	379	dnl # number in order to determine the expected behavior. This was an
	380	dnl # internal change to blkdev_get_by_dev(), see commit a8ed1a0607.
	381	dnl #
	382	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS], [
	383	AC_MSG_CHECKING([whether blkdev_get_by_path() handles ERESTARTSYS])
	384	AS_VERSION_COMPARE([$LINUX_VERSION], [5.13.0], [
	385	AC_MSG_RESULT(yes)
	386	AC_DEFINE(HAVE_BLKDEV_GET_ERESTARTSYS, 1,
	387	[blkdev_get_by_path() handles ERESTARTSYS])
	388	],[
	389	AC_MSG_RESULT(no)
	390	],[
	391	AC_MSG_RESULT(no)
	392	])
	393	])
	394
066e8252 BB	395	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV], [
	396	ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH
	397	ZFS_AC_KERNEL_SRC_BLKDEV_PUT
	398	ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART
	399	ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV
	400	ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV
	401	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
	402	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
ae15f1c1 CK	403	ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE
ae15f1c1 CK	404	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
72ba4b2a	405	ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE
bebdf52a	406	ZFS_AC_KERNEL_SRC_BLKDEV_BDEVNAME
a12a5cb5	407	ZFS_AC_KERNEL_SRC_BLKDEV_ISSUE_SECURE_ERASE
066e8252 BB	408	])
	409
	410	AC_DEFUN([ZFS_AC_KERNEL_BLKDEV], [
	411	ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH
	412	ZFS_AC_KERNEL_BLKDEV_PUT
	413	ZFS_AC_KERNEL_BLKDEV_REREAD_PART
	414	ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV
	415	ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV
	416	ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
	417	ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
ae15f1c1 CK	418	ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE
ae15f1c1 CK	419	ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
72ba4b2a	420	ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE
bebdf52a	421	ZFS_AC_KERNEL_BLKDEV_BDEVNAME
77e2756d	422	ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS
a12a5cb5	423	ZFS_AC_KERNEL_BLKDEV_ISSUE_SECURE_ERASE
066e8252	424	])