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

dnl #
dnl # 2.6.36 API change,
dnl # REQ_FAILFAST_{DEV|TRANSPORT|DRIVER}
dnl # REQ_DISCARD
dnl # REQ_FLUSH
dnl #
dnl # 4.8 - 4.9 API,
dnl # REQ_FLUSH was renamed to REQ_PREFLUSH
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_REQ], [
	ZFS_LINUX_TEST_SRC([req_failfast_mask], [
		#include <linux/bio.h>
	],[
		int flags __attribute__ ((unused));
		flags = REQ_FAILFAST_MASK;
	])

	ZFS_LINUX_TEST_SRC([req_discard], [
		#include <linux/bio.h>
	],[
		int flags __attribute__ ((unused));
		flags = REQ_DISCARD;
	])

	ZFS_LINUX_TEST_SRC([req_flush], [
		#include <linux/bio.h>
	],[
		int flags __attribute__ ((unused));
		flags = REQ_FLUSH;
	])

	ZFS_LINUX_TEST_SRC([req_preflush], [
		#include <linux/bio.h>
	],[
		int flags __attribute__ ((unused));
		flags = REQ_PREFLUSH;
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_FAILFAST_MASK], [
	AC_MSG_CHECKING([whether REQ_FAILFAST_MASK is defined])
	ZFS_LINUX_TEST_RESULT([req_failfast_mask], [
		AC_MSG_RESULT(yes)
	],[
		ZFS_LINUX_TEST_ERROR([REQ_FAILFAST_MASK])
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_DISCARD], [
	AC_MSG_CHECKING([whether REQ_DISCARD is defined])
	ZFS_LINUX_TEST_RESULT([req_discard], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_REQ_DISCARD, 1, [REQ_DISCARD is defined])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_FLUSH], [
	AC_MSG_CHECKING([whether REQ_FLUSH is defined])
	ZFS_LINUX_TEST_RESULT([req_flush], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_REQ_FLUSH, 1, [REQ_FLUSH is defined])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_PREFLUSH], [
	AC_MSG_CHECKING([whether REQ_PREFLUSH is defined])
	ZFS_LINUX_TEST_RESULT([req_preflush], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_REQ_PREFLUSH, 1, [REQ_PREFLUSH is defined])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # Linux 4.8 API,
dnl #
dnl # The bio_op() helper was introduced as a replacement for explicitly
dnl # checking the bio->bi_rw flags.  The following checks are used to
dnl # detect if a specific operation is supported.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_OPS], [
	ZFS_LINUX_TEST_SRC([req_op_discard], [
		#include <linux/blk_types.h>
	],[
		int op __attribute__ ((unused)) = REQ_OP_DISCARD;
	])

	ZFS_LINUX_TEST_SRC([req_op_secure_erase], [
		#include <linux/blk_types.h>
	],[
		int op __attribute__ ((unused)) = REQ_OP_SECURE_ERASE;
	])

	ZFS_LINUX_TEST_SRC([req_op_flush], [
		#include <linux/blk_types.h>
	],[
		int op __attribute__ ((unused)) = REQ_OP_FLUSH;
	])

	ZFS_LINUX_TEST_SRC([bio_bi_opf], [
		#include <linux/bio.h>
	],[
		struct bio bio __attribute__ ((unused));
		bio.bi_opf = 0;
	])

	ZFS_LINUX_TEST_SRC([bio_set_op_attrs], [
		#include <linux/bio.h>
	],[
		struct bio *bio __attribute__ ((unused)) = NULL;
		bio_set_op_attrs(bio, 0, 0);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_DISCARD], [
	AC_MSG_CHECKING([whether REQ_OP_DISCARD is defined])
	ZFS_LINUX_TEST_RESULT([req_op_discard], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_REQ_OP_DISCARD, 1, [REQ_OP_DISCARD is defined])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_SECURE_ERASE], [
	AC_MSG_CHECKING([whether REQ_OP_SECURE_ERASE is defined])
	ZFS_LINUX_TEST_RESULT([req_op_secure_erase], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_REQ_OP_SECURE_ERASE, 1,
		    [REQ_OP_SECURE_ERASE is defined])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_FLUSH], [
	AC_MSG_CHECKING([whether REQ_OP_FLUSH is defined])
	ZFS_LINUX_TEST_RESULT([req_op_flush], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_REQ_OP_FLUSH, 1, [REQ_OP_FLUSH is defined])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_BI_OPF], [
	AC_MSG_CHECKING([whether bio->bi_opf is defined])
	ZFS_LINUX_TEST_RESULT([bio_bi_opf], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BIO_BI_OPF, 1, [bio->bi_opf is defined])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_SET_OP_ATTRS], [
	AC_MSG_CHECKING([whether bio_set_op_attrs is available])
	ZFS_LINUX_TEST_RESULT([bio_set_op_attrs], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BIO_SET_OP_ATTRS, 1,
		    [bio_set_op_attrs is available])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # Linux 4.14 API,
dnl #
dnl # The bio_set_dev() helper macro was introduced as part of the transition
dnl # to have struct gendisk in struct bio.
dnl #
dnl # Linux 5.0 API,
dnl #
dnl # The bio_set_dev() helper macro was updated to internally depend on
dnl # bio_associate_blkg() symbol which is exported GPL-only.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SET_DEV], [
	ZFS_LINUX_TEST_SRC([bio_set_dev], [
		#include <linux/bio.h>
		#include <linux/fs.h>
	],[
		struct block_device *bdev = NULL;
		struct bio *bio = NULL;
		bio_set_dev(bio, bdev);
	], [], [ZFS_META_LICENSE])
])

dnl #
dnl # Linux 5.16 API
dnl #
dnl # bio_set_dev is no longer a helper macro and is now an inline function,
dnl # meaning that the function it calls internally can no longer be overridden
dnl # by our code
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SET_DEV_MACRO], [
	ZFS_LINUX_TEST_SRC([bio_set_dev_macro], [
		#include <linux/bio.h>
		#include <linux/fs.h>
	],[
		#ifndef bio_set_dev
		#error Not a macro
		#endif
	], [], [ZFS_META_LICENSE])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_SET_DEV], [
	AC_MSG_CHECKING([whether bio_set_dev() is available])
	ZFS_LINUX_TEST_RESULT([bio_set_dev], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BIO_SET_DEV, 1, [bio_set_dev() is available])

		AC_MSG_CHECKING([whether bio_set_dev() is GPL-only])
		ZFS_LINUX_TEST_RESULT([bio_set_dev_license], [
			AC_MSG_RESULT(no)
		],[
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_BIO_SET_DEV_GPL_ONLY, 1,
			    [bio_set_dev() GPL-only])
		])

		AC_MSG_CHECKING([whether bio_set_dev() is a macro])
		ZFS_LINUX_TEST_RESULT([bio_set_dev_macro], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_BIO_SET_DEV_MACRO, 1,
			    [bio_set_dev() is a macro])
		],[
			AC_MSG_RESULT(no)
		])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 4.3 API change
dnl # Error argument dropped from bio_endio in favor of newly introduced
dnl # bio->bi_error. This also replaces bio->bi_flags value BIO_UPTODATE.
dnl # Introduced by torvalds/linux@4246a0b63bd8f56a1469b12eafeb875b1041a451
dnl # ("block: add a bi_error field to struct bio").
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_END_IO_T_ARGS], [
	ZFS_LINUX_TEST_SRC([bio_end_io_t_args], [
		#include <linux/bio.h>
		void wanted_end_io(struct bio *bio) { return; }
		bio_end_io_t *end_io __attribute__ ((unused)) = wanted_end_io;
	], [])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_END_IO_T_ARGS], [
	AC_MSG_CHECKING([whether bio_end_io_t wants 1 arg])
	ZFS_LINUX_TEST_RESULT([bio_end_io_t_args], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_1ARG_BIO_END_IO_T, 1,
		    [bio_end_io_t wants 1 arg])
	], [
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 4.13 API change
dnl # The bio->bi_error field was replaced with bio->bi_status which is an
dnl # enum which describes all possible error types.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BI_STATUS], [
	ZFS_LINUX_TEST_SRC([bio_bi_status], [
		#include <linux/bio.h>
	], [
		struct bio bio __attribute__ ((unused));
		blk_status_t status __attribute__ ((unused)) = BLK_STS_OK;
		bio.bi_status = status;
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_BI_STATUS], [
	AC_MSG_CHECKING([whether bio->bi_status exists])
	ZFS_LINUX_TEST_RESULT([bio_bi_status], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BIO_BI_STATUS, 1, [bio->bi_status exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 3.14 API change,
dnl # Immutable biovecs. A number of fields of struct bio are moved to
dnl # struct bvec_iter.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BVEC_ITER], [
	ZFS_LINUX_TEST_SRC([bio_bvec_iter], [
		#include <linux/bio.h>
	],[
		struct bio bio;
		bio.bi_iter.bi_sector = 0;
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_BVEC_ITER], [
	AC_MSG_CHECKING([whether bio has bi_iter])
	ZFS_LINUX_TEST_RESULT([bio_bvec_iter], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BIO_BVEC_ITER, 1, [bio has bi_iter])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 4.8 API change
dnl # The rw argument has been removed from submit_bio/submit_bio_wait.
dnl # Callers are now expected to set bio->bi_rw instead of passing it in.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SUBMIT_BIO], [
	ZFS_LINUX_TEST_SRC([submit_bio], [
		#include <linux/bio.h>
	],[
		struct bio *bio = NULL;
		(void) submit_bio(bio);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_SUBMIT_BIO], [
	AC_MSG_CHECKING([whether submit_bio() wants 1 arg])
	ZFS_LINUX_TEST_RESULT([submit_bio], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_1ARG_SUBMIT_BIO, 1, [submit_bio() wants 1 arg])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 2.6.34 API change
dnl # current->bio_list
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_CURRENT_BIO_LIST], [
	ZFS_LINUX_TEST_SRC([current_bio_list], [
		#include <linux/sched.h>
	], [
		current->bio_list = (struct bio_list *) NULL;
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_CURRENT_BIO_LIST], [
	AC_MSG_CHECKING([whether current->bio_list exists])
	ZFS_LINUX_TEST_RESULT([current_bio_list], [
		AC_MSG_RESULT(yes)
	],[
		ZFS_LINUX_TEST_ERROR([bio_list])
	])
])

dnl #
dnl # Linux 5.5 API,
dnl #
dnl # The Linux 5.5 kernel updated percpu_ref_tryget() which is inlined by
dnl # blkg_tryget() to use rcu_read_lock() instead of rcu_read_lock_sched().
dnl # As a side effect the function was converted to GPL-only.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKG_TRYGET], [
	ZFS_LINUX_TEST_SRC([blkg_tryget], [
		#include <linux/blk-cgroup.h>
		#include <linux/bio.h>
		#include <linux/fs.h>
	],[
		struct blkcg_gq blkg __attribute__ ((unused)) = {};
		bool rc __attribute__ ((unused));
		rc = blkg_tryget(&blkg);
	], [], [ZFS_META_LICENSE])
])

AC_DEFUN([ZFS_AC_KERNEL_BLKG_TRYGET], [
	AC_MSG_CHECKING([whether blkg_tryget() is available])
	ZFS_LINUX_TEST_RESULT([blkg_tryget], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BLKG_TRYGET, 1, [blkg_tryget() is available])

		AC_MSG_CHECKING([whether blkg_tryget() is GPL-only])
		ZFS_LINUX_TEST_RESULT([blkg_tryget_license], [
			AC_MSG_RESULT(no)
		],[
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_BLKG_TRYGET_GPL_ONLY, 1,
			    [blkg_tryget() GPL-only])
		])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # Linux 5.12 API,
dnl #
dnl # The Linux 5.12 kernel updated struct bio to create a new bi_bdev member
dnl # and bio->bi_disk was moved to bio->bi_bdev->bd_disk
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BDEV_DISK], [
	ZFS_LINUX_TEST_SRC([bio_bdev_disk], [
		#include <linux/blk_types.h>
		#include <linux/blkdev.h>
	],[
		struct bio *b = NULL;
		struct gendisk *d = b->bi_bdev->bd_disk;
		blk_register_queue(d);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_BDEV_DISK], [
	AC_MSG_CHECKING([whether bio->bi_bdev->bd_disk exists])
	ZFS_LINUX_TEST_RESULT([bio_bdev_disk], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BIO_BDEV_DISK, 1, [bio->bi_bdev->bd_disk exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # Linux 5.16 API
dnl #
dnl # The Linux 5.16 API for submit_bio changed the return type to be
dnl # void instead of int
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BDEV_SUBMIT_BIO_RETURNS_VOID], [
	ZFS_LINUX_TEST_SRC([bio_bdev_submit_bio_void], [
		#include <linux/blkdev.h>
	],[
		struct block_device_operations *bdev = NULL;
		__attribute__((unused)) void(*f)(struct bio *) = bdev->submit_bio;
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BDEV_SUBMIT_BIO_RETURNS_VOID], [
	AC_MSG_CHECKING(
		[whether block_device_operations->submit_bio() returns void])
	ZFS_LINUX_TEST_RESULT([bio_bdev_submit_bio_void], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_BDEV_SUBMIT_BIO_RETURNS_VOID, 1,
			[block_device_operations->submit_bio() returns void])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # Linux 5.16 API
dnl #
dnl # The Linux 5.16 API moved struct blkcg_gq into linux/blk-cgroup.h, which
dnl # has been around since 2015. This test looks for the presence of that
dnl # header, so that it can be conditionally included where it exists, but
dnl # still be backward compatible with kernels that pre-date its introduction.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_CGROUP_HEADER], [
	ZFS_LINUX_TEST_SRC([blk_cgroup_header], [
		#include <linux/blk-cgroup.h>
	], [])
])

AC_DEFUN([ZFS_AC_KERNEL_BLK_CGROUP_HEADER], [
	AC_MSG_CHECKING([whether linux/blk-cgroup.h exists])
	ZFS_LINUX_TEST_RESULT([blk_cgroup_header],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_LINUX_BLK_CGROUP_HEADER, 1,
			[linux/blk-cgroup.h exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # Linux 5.18 API
dnl #
dnl # In 07888c665b405b1cd3577ddebfeb74f4717a84c4 ("block: pass a block_device and opf to bio_alloc")
dnl #   bio_alloc(gfp_t gfp_mask, unsigned short nr_iovecs)
dnl # became
dnl #   bio_alloc(struct block_device *bdev, unsigned short nr_vecs, unsigned int opf, gfp_t gfp_mask)
dnl # however
dnl # > NULL/0 can be passed, both for the
dnl # > passthrough case on a raw request_queue and to temporarily avoid
dnl # > refactoring some nasty code.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_ALLOC_4ARG], [
	ZFS_LINUX_TEST_SRC([bio_alloc_4arg], [
		#include <linux/bio.h>
	],[
		gfp_t gfp_mask = 0;
		unsigned short nr_iovecs = 0;
		struct block_device *bdev = NULL;
		unsigned int opf = 0;

		struct bio *__attribute__((unused)) allocated = bio_alloc(bdev, nr_iovecs, opf, gfp_mask);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_BIO_ALLOC_4ARG], [
	AC_MSG_CHECKING([whether bio_alloc() wants 4 args])
	ZFS_LINUX_TEST_RESULT([bio_alloc_4arg],[
		AC_MSG_RESULT(yes)
		AC_DEFINE([HAVE_BIO_ALLOC_4ARG], 1, [bio_alloc() takes 4 arguments])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO], [
	ZFS_AC_KERNEL_SRC_REQ
	ZFS_AC_KERNEL_SRC_BIO_OPS
	ZFS_AC_KERNEL_SRC_BIO_SET_DEV
	ZFS_AC_KERNEL_SRC_BIO_END_IO_T_ARGS
	ZFS_AC_KERNEL_SRC_BIO_BI_STATUS
	ZFS_AC_KERNEL_SRC_BIO_BVEC_ITER
	ZFS_AC_KERNEL_SRC_BIO_SUBMIT_BIO
	ZFS_AC_KERNEL_SRC_BIO_CURRENT_BIO_LIST
	ZFS_AC_KERNEL_SRC_BLKG_TRYGET
	ZFS_AC_KERNEL_SRC_BIO_BDEV_DISK
	ZFS_AC_KERNEL_SRC_BDEV_SUBMIT_BIO_RETURNS_VOID
	ZFS_AC_KERNEL_SRC_BIO_SET_DEV_MACRO
	ZFS_AC_KERNEL_SRC_BLK_CGROUP_HEADER
	ZFS_AC_KERNEL_SRC_BIO_ALLOC_4ARG
])

AC_DEFUN([ZFS_AC_KERNEL_BIO], [
	ZFS_AC_KERNEL_BIO_REQ_FAILFAST_MASK
	ZFS_AC_KERNEL_BIO_REQ_DISCARD
	ZFS_AC_KERNEL_BIO_REQ_FLUSH
	ZFS_AC_KERNEL_BIO_REQ_PREFLUSH

	ZFS_AC_KERNEL_BIO_REQ_OP_DISCARD
	ZFS_AC_KERNEL_BIO_REQ_OP_SECURE_ERASE
	ZFS_AC_KERNEL_BIO_REQ_OP_FLUSH
	ZFS_AC_KERNEL_BIO_BI_OPF
	ZFS_AC_KERNEL_BIO_SET_OP_ATTRS

	ZFS_AC_KERNEL_BIO_SET_DEV
	ZFS_AC_KERNEL_BIO_END_IO_T_ARGS
	ZFS_AC_KERNEL_BIO_BI_STATUS
	ZFS_AC_KERNEL_BIO_BVEC_ITER
	ZFS_AC_KERNEL_BIO_SUBMIT_BIO
	ZFS_AC_KERNEL_BIO_CURRENT_BIO_LIST
	ZFS_AC_KERNEL_BLKG_TRYGET
	ZFS_AC_KERNEL_BIO_BDEV_DISK
	ZFS_AC_KERNEL_BDEV_SUBMIT_BIO_RETURNS_VOID
	ZFS_AC_KERNEL_BLK_CGROUP_HEADER
	ZFS_AC_KERNEL_BIO_ALLOC_4ARG
])
Commit	Line	Data
066e8252 BB	1	dnl #
	2	dnl # 2.6.36 API change,
	3	dnl # REQ_FAILFAST_{DEV\|TRANSPORT\|DRIVER}
	4	dnl # REQ_DISCARD
	5	dnl # REQ_FLUSH
	6	dnl #
	7	dnl # 4.8 - 4.9 API,
	8	dnl # REQ_FLUSH was renamed to REQ_PREFLUSH
	9	dnl #
	10	AC_DEFUN([ZFS_AC_KERNEL_SRC_REQ], [
	11	ZFS_LINUX_TEST_SRC([req_failfast_mask], [
	12	#include <linux/bio.h>
	13	],[
	14	int flags __attribute__ ((unused));
	15	flags = REQ_FAILFAST_MASK;
	16	])
	17
	18	ZFS_LINUX_TEST_SRC([req_discard], [
	19	#include <linux/bio.h>
	20	],[
	21	int flags __attribute__ ((unused));
	22	flags = REQ_DISCARD;
	23	])
	24
	25	ZFS_LINUX_TEST_SRC([req_flush], [
	26	#include <linux/bio.h>
	27	],[
	28	int flags __attribute__ ((unused));
	29	flags = REQ_FLUSH;
	30	])
	31
	32	ZFS_LINUX_TEST_SRC([req_preflush], [
	33	#include <linux/bio.h>
	34	],[
	35	int flags __attribute__ ((unused));
	36	flags = REQ_PREFLUSH;
	37	])
	38	])
	39
	40	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_FAILFAST_MASK], [
	41	AC_MSG_CHECKING([whether REQ_FAILFAST_MASK is defined])
	42	ZFS_LINUX_TEST_RESULT([req_failfast_mask], [
	43	AC_MSG_RESULT(yes)
	44	],[
	45	ZFS_LINUX_TEST_ERROR([REQ_FAILFAST_MASK])
	46	])
	47	])
	48
	49	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_DISCARD], [
	50	AC_MSG_CHECKING([whether REQ_DISCARD is defined])
	51	ZFS_LINUX_TEST_RESULT([req_discard], [
	52	AC_MSG_RESULT(yes)
	53	AC_DEFINE(HAVE_REQ_DISCARD, 1, [REQ_DISCARD is defined])
	54	],[
	55	AC_MSG_RESULT(no)
	56	])
	57	])
	58
	59	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_FLUSH], [
	60	AC_MSG_CHECKING([whether REQ_FLUSH is defined])
	61	ZFS_LINUX_TEST_RESULT([req_flush], [
	62	AC_MSG_RESULT(yes)
	63	AC_DEFINE(HAVE_REQ_FLUSH, 1, [REQ_FLUSH is defined])
	64	],[
65	AC_MSG_RESULT(no)
66	])
67	])
68
69	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_PREFLUSH], [
70	AC_MSG_CHECKING([whether REQ_PREFLUSH is defined])
71	ZFS_LINUX_TEST_RESULT([req_preflush], [
72	AC_MSG_RESULT(yes)
73	AC_DEFINE(HAVE_REQ_PREFLUSH, 1, [REQ_PREFLUSH is defined])
74	],[
75	AC_MSG_RESULT(no)
76	])
77	])
78
79	dnl #
80	dnl # Linux 4.8 API,
81	dnl #
82	dnl # The bio_op() helper was introduced as a replacement for explicitly
83	dnl # checking the bio->bi_rw flags. The following checks are used to
84	dnl # detect if a specific operation is supported.
85	dnl #
86	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_OPS], [
87	ZFS_LINUX_TEST_SRC([req_op_discard], [
88	#include <linux/blk_types.h>
89	],[
90	int op __attribute__ ((unused)) = REQ_OP_DISCARD;
91	])
92
93	ZFS_LINUX_TEST_SRC([req_op_secure_erase], [
94	#include <linux/blk_types.h>
95	],[
96	int op __attribute__ ((unused)) = REQ_OP_SECURE_ERASE;
97	])
98
99	ZFS_LINUX_TEST_SRC([req_op_flush], [
100	#include <linux/blk_types.h>
101	],[
102	int op __attribute__ ((unused)) = REQ_OP_FLUSH;
103	])
104
105	ZFS_LINUX_TEST_SRC([bio_bi_opf], [
106	#include <linux/bio.h>
107	],[
108	struct bio bio __attribute__ ((unused));
109	bio.bi_opf = 0;
110	])
111
112	ZFS_LINUX_TEST_SRC([bio_set_op_attrs], [
113	#include <linux/bio.h>
114	],[
115	struct bio *bio __attribute__ ((unused)) = NULL;
116	bio_set_op_attrs(bio, 0, 0);
117	])
118	])
119
120	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_DISCARD], [
121	AC_MSG_CHECKING([whether REQ_OP_DISCARD is defined])
122	ZFS_LINUX_TEST_RESULT([req_op_discard], [
123	AC_MSG_RESULT(yes)
124	AC_DEFINE(HAVE_REQ_OP_DISCARD, 1, [REQ_OP_DISCARD is defined])
125	],[
126	AC_MSG_RESULT(no)
127	])
128	])
129
130	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_SECURE_ERASE], [
131	AC_MSG_CHECKING([whether REQ_OP_SECURE_ERASE is defined])
132	ZFS_LINUX_TEST_RESULT([req_op_secure_erase], [
133	AC_MSG_RESULT(yes)
134	AC_DEFINE(HAVE_REQ_OP_SECURE_ERASE, 1,
135	[REQ_OP_SECURE_ERASE is defined])
136	],[
137	AC_MSG_RESULT(no)
138	])
139	])
140
141	AC_DEFUN([ZFS_AC_KERNEL_BIO_REQ_OP_FLUSH], [
142	AC_MSG_CHECKING([whether REQ_OP_FLUSH is defined])
143	ZFS_LINUX_TEST_RESULT([req_op_flush], [
144	AC_MSG_RESULT(yes)
145	AC_DEFINE(HAVE_REQ_OP_FLUSH, 1, [REQ_OP_FLUSH is defined])
146	],[
147	AC_MSG_RESULT(no)
148	])
149	])
150
151	AC_DEFUN([ZFS_AC_KERNEL_BIO_BI_OPF], [
152	AC_MSG_CHECKING([whether bio->bi_opf is defined])
153	ZFS_LINUX_TEST_RESULT([bio_bi_opf], [
154	AC_MSG_RESULT(yes)
155	AC_DEFINE(HAVE_BIO_BI_OPF, 1, [bio->bi_opf is defined])
156	],[
157	AC_MSG_RESULT(no)
158	])
159	])
160
161	AC_DEFUN([ZFS_AC_KERNEL_BIO_SET_OP_ATTRS], [
162	AC_MSG_CHECKING([whether bio_set_op_attrs is available])
163	ZFS_LINUX_TEST_RESULT([bio_set_op_attrs], [
164	AC_MSG_RESULT(yes)
165	AC_DEFINE(HAVE_BIO_SET_OP_ATTRS, 1,
166	[bio_set_op_attrs is available])
167	],[
168	AC_MSG_RESULT(no)
169	])
170	])
171
172	dnl #
173	dnl # Linux 4.14 API,
174	dnl #
175	dnl # The bio_set_dev() helper macro was introduced as part of the transition
176	dnl # to have struct gendisk in struct bio.
177	dnl #
178	dnl # Linux 5.0 API,
179	dnl #
180	dnl # The bio_set_dev() helper macro was updated to internally depend on
181	dnl # bio_associate_blkg() symbol which is exported GPL-only.
182	dnl #
183	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SET_DEV], [
184	ZFS_LINUX_TEST_SRC([bio_set_dev], [
185	#include <linux/bio.h>
186	#include <linux/fs.h>
187	],[
188	struct block_device *bdev = NULL;
189	struct bio *bio = NULL;
190	bio_set_dev(bio, bdev);
c347fac5	191	], [], [ZFS_META_LICENSE])
066e8252 BB	192	])
066e8252 BB	193
d08b99ac CK	194	dnl #
	195	dnl # Linux 5.16 API
	196	dnl #
	197	dnl # bio_set_dev is no longer a helper macro and is now an inline function,
	198	dnl # meaning that the function it calls internally can no longer be overridden
	199	dnl # by our code
	200	dnl #
	201	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SET_DEV_MACRO], [
	202	ZFS_LINUX_TEST_SRC([bio_set_dev_macro], [
	203	#include <linux/bio.h>
	204	#include <linux/fs.h>
	205	],[
	206	#ifndef bio_set_dev
	207	#error Not a macro
	208	#endif
	209	], [], [ZFS_META_LICENSE])
	210	])
	211
066e8252 BB	212	AC_DEFUN([ZFS_AC_KERNEL_BIO_SET_DEV], [
	213	AC_MSG_CHECKING([whether bio_set_dev() is available])
	214	ZFS_LINUX_TEST_RESULT([bio_set_dev], [
	215	AC_MSG_RESULT(yes)
	216	AC_DEFINE(HAVE_BIO_SET_DEV, 1, [bio_set_dev() is available])
	217
	218	AC_MSG_CHECKING([whether bio_set_dev() is GPL-only])
	219	ZFS_LINUX_TEST_RESULT([bio_set_dev_license], [
	220	AC_MSG_RESULT(no)
	221	],[
	222	AC_MSG_RESULT(yes)
	223	AC_DEFINE(HAVE_BIO_SET_DEV_GPL_ONLY, 1,
	224	[bio_set_dev() GPL-only])
	225	])
d08b99ac CK	226
	227	AC_MSG_CHECKING([whether bio_set_dev() is a macro])
	228	ZFS_LINUX_TEST_RESULT([bio_set_dev_macro], [
	229	AC_MSG_RESULT(yes)
	230	AC_DEFINE(HAVE_BIO_SET_DEV_MACRO, 1,
	231	[bio_set_dev() is a macro])
	232	],[
	233	AC_MSG_RESULT(no)
	234	])
066e8252 BB	235	],[
	236	AC_MSG_RESULT(no)
	237	])
	238	])
	239
	240	dnl #
	241	dnl # 4.3 API change
	242	dnl # Error argument dropped from bio_endio in favor of newly introduced
	243	dnl # bio->bi_error. This also replaces bio->bi_flags value BIO_UPTODATE.
	244	dnl # Introduced by torvalds/linux@4246a0b63bd8f56a1469b12eafeb875b1041a451
	245	dnl # ("block: add a bi_error field to struct bio").
	246	dnl #
	247	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_END_IO_T_ARGS], [
	248	ZFS_LINUX_TEST_SRC([bio_end_io_t_args], [
	249	#include <linux/bio.h>
	250	void wanted_end_io(struct bio *bio) { return; }
	251	bio_end_io_t *end_io __attribute__ ((unused)) = wanted_end_io;
	252	], [])
	253	])
	254
	255	AC_DEFUN([ZFS_AC_KERNEL_BIO_END_IO_T_ARGS], [
	256	AC_MSG_CHECKING([whether bio_end_io_t wants 1 arg])
	257	ZFS_LINUX_TEST_RESULT([bio_end_io_t_args], [
	258	AC_MSG_RESULT(yes)
	259	AC_DEFINE(HAVE_1ARG_BIO_END_IO_T, 1,
	260	[bio_end_io_t wants 1 arg])
	261	], [
	262	AC_MSG_RESULT(no)
	263	])
	264	])
	265
	266	dnl #
	267	dnl # 4.13 API change
	268	dnl # The bio->bi_error field was replaced with bio->bi_status which is an
	269	dnl # enum which describes all possible error types.
	270	dnl #
	271	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BI_STATUS], [
	272	ZFS_LINUX_TEST_SRC([bio_bi_status], [
	273	#include <linux/bio.h>
	274	], [
	275	struct bio bio __attribute__ ((unused));
	276	blk_status_t status __attribute__ ((unused)) = BLK_STS_OK;
	277	bio.bi_status = status;
	278	])
	279	])
	280
	281	AC_DEFUN([ZFS_AC_KERNEL_BIO_BI_STATUS], [
	282	AC_MSG_CHECKING([whether bio->bi_status exists])
	283	ZFS_LINUX_TEST_RESULT([bio_bi_status], [
	284	AC_MSG_RESULT(yes)
	285	AC_DEFINE(HAVE_BIO_BI_STATUS, 1, [bio->bi_status exists])
	286	],[
	287	AC_MSG_RESULT(no)
	288	])
	289	])
	290
	291	dnl #
	292	dnl # 3.14 API change,
	293	dnl # Immutable biovecs. A number of fields of struct bio are moved to
	294	dnl # struct bvec_iter.
	295	dnl #
	296	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BVEC_ITER], [
	297	ZFS_LINUX_TEST_SRC([bio_bvec_iter], [
	298	#include <linux/bio.h>
299	],[
300	struct bio bio;
301	bio.bi_iter.bi_sector = 0;
302	])
303	])
304
305	AC_DEFUN([ZFS_AC_KERNEL_BIO_BVEC_ITER], [
306	AC_MSG_CHECKING([whether bio has bi_iter])
307	ZFS_LINUX_TEST_RESULT([bio_bvec_iter], [
308	AC_MSG_RESULT(yes)
309	AC_DEFINE(HAVE_BIO_BVEC_ITER, 1, [bio has bi_iter])
310	],[
311	AC_MSG_RESULT(no)
312	])
313	])
314
315	dnl #
316	dnl # 4.8 API change
317	dnl # The rw argument has been removed from submit_bio/submit_bio_wait.
318	dnl # Callers are now expected to set bio->bi_rw instead of passing it in.
319	dnl #
320	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_SUBMIT_BIO], [
321	ZFS_LINUX_TEST_SRC([submit_bio], [
322	#include <linux/bio.h>
323	],[
066e8252	324	struct bio *bio = NULL;
453c63e9	325	(void) submit_bio(bio);
066e8252 BB	326	])
	327	])
	328
	329	AC_DEFUN([ZFS_AC_KERNEL_BIO_SUBMIT_BIO], [
	330	AC_MSG_CHECKING([whether submit_bio() wants 1 arg])
	331	ZFS_LINUX_TEST_RESULT([submit_bio], [
	332	AC_MSG_RESULT(yes)
	333	AC_DEFINE(HAVE_1ARG_SUBMIT_BIO, 1, [submit_bio() wants 1 arg])
	334	],[
	335	AC_MSG_RESULT(no)
	336	])
	337	])
	338
	339	dnl #
	340	dnl # 2.6.34 API change
	341	dnl # current->bio_list
	342	dnl #
	343	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_CURRENT_BIO_LIST], [
	344	ZFS_LINUX_TEST_SRC([current_bio_list], [
	345	#include <linux/sched.h>
	346	], [
	347	current->bio_list = (struct bio_list *) NULL;
	348	])
	349	])
	350
	351	AC_DEFUN([ZFS_AC_KERNEL_BIO_CURRENT_BIO_LIST], [
	352	AC_MSG_CHECKING([whether current->bio_list exists])
	353	ZFS_LINUX_TEST_RESULT([current_bio_list], [
	354	AC_MSG_RESULT(yes)
	355	],[
	356	ZFS_LINUX_TEST_ERROR([bio_list])
	357	])
	358	])
	359
bd0d24e0 BB	360	dnl #
	361	dnl # Linux 5.5 API,
	362	dnl #
	363	dnl # The Linux 5.5 kernel updated percpu_ref_tryget() which is inlined by
	364	dnl # blkg_tryget() to use rcu_read_lock() instead of rcu_read_lock_sched().
	365	dnl # As a side effect the function was converted to GPL-only.
	366	dnl #
	367	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKG_TRYGET], [
	368	ZFS_LINUX_TEST_SRC([blkg_tryget], [
	369	#include <linux/blk-cgroup.h>
	370	#include <linux/bio.h>
	371	#include <linux/fs.h>
	372	],[
b3a216fb	373	struct blkcg_gq blkg __attribute__ ((unused)) = {};
bd0d24e0 BB	374	bool rc __attribute__ ((unused));
bd0d24e0 BB	375	rc = blkg_tryget(&blkg);
c347fac5	376	], [], [ZFS_META_LICENSE])
bd0d24e0 BB	377	])
	378
	379	AC_DEFUN([ZFS_AC_KERNEL_BLKG_TRYGET], [
	380	AC_MSG_CHECKING([whether blkg_tryget() is available])
	381	ZFS_LINUX_TEST_RESULT([blkg_tryget], [
	382	AC_MSG_RESULT(yes)
	383	AC_DEFINE(HAVE_BLKG_TRYGET, 1, [blkg_tryget() is available])
	384
	385	AC_MSG_CHECKING([whether blkg_tryget() is GPL-only])
	386	ZFS_LINUX_TEST_RESULT([blkg_tryget_license], [
	387	AC_MSG_RESULT(no)
	388	],[
	389	AC_MSG_RESULT(yes)
	390	AC_DEFINE(HAVE_BLKG_TRYGET_GPL_ONLY, 1,
	391	[blkg_tryget() GPL-only])
	392	])
	393	],[
	394	AC_MSG_RESULT(no)
	395	])
	396	])
	397
d939930f CK	398	dnl #
	399	dnl # Linux 5.12 API,
	400	dnl #
	401	dnl # The Linux 5.12 kernel updated struct bio to create a new bi_bdev member
	402	dnl # and bio->bi_disk was moved to bio->bi_bdev->bd_disk
	403	dnl #
	404	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_BDEV_DISK], [
	405	ZFS_LINUX_TEST_SRC([bio_bdev_disk], [
	406	#include <linux/blk_types.h>
	407	#include <linux/blkdev.h>
	408	],[
	409	struct bio *b = NULL;
	410	struct gendisk *d = b->bi_bdev->bd_disk;
	411	blk_register_queue(d);
	412	])
	413	])
	414
	415	AC_DEFUN([ZFS_AC_KERNEL_BIO_BDEV_DISK], [
	416	AC_MSG_CHECKING([whether bio->bi_bdev->bd_disk exists])
	417	ZFS_LINUX_TEST_RESULT([bio_bdev_disk], [
	418	AC_MSG_RESULT(yes)
	419	AC_DEFINE(HAVE_BIO_BDEV_DISK, 1, [bio->bi_bdev->bd_disk exists])
	420	],[
	421	AC_MSG_RESULT(no)
	422	])
	423	])
	424
435a451e CK	425	dnl #
	426	dnl # Linux 5.16 API
	427	dnl #
	428	dnl # The Linux 5.16 API for submit_bio changed the return type to be
	429	dnl # void instead of int
	430	dnl #
	431	AC_DEFUN([ZFS_AC_KERNEL_SRC_BDEV_SUBMIT_BIO_RETURNS_VOID], [
	432	ZFS_LINUX_TEST_SRC([bio_bdev_submit_bio_void], [
	433	#include <linux/blkdev.h>
	434	],[
	435	struct block_device_operations *bdev = NULL;
	436	__attribute__((unused)) void(f)(struct bio ) = bdev->submit_bio;
	437	])
	438	])
	439
	440	AC_DEFUN([ZFS_AC_KERNEL_BDEV_SUBMIT_BIO_RETURNS_VOID], [
	441	AC_MSG_CHECKING(
	442	[whether block_device_operations->submit_bio() returns void])
	443	ZFS_LINUX_TEST_RESULT([bio_bdev_submit_bio_void], [
	444	AC_MSG_RESULT(yes)
	445	AC_DEFINE(HAVE_BDEV_SUBMIT_BIO_RETURNS_VOID, 1,
	446	[block_device_operations->submit_bio() returns void])
	447	],[
	448	AC_MSG_RESULT(no)
	449	])
	450	])
	451
1e767532 CK	452	dnl #
	453	dnl # Linux 5.16 API
	454	dnl #
	455	dnl # The Linux 5.16 API moved struct blkcg_gq into linux/blk-cgroup.h, which
	456	dnl # has been around since 2015. This test looks for the presence of that
	457	dnl # header, so that it can be conditionally included where it exists, but
	458	dnl # still be backward compatible with kernels that pre-date its introduction.
	459	dnl #
	460	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_CGROUP_HEADER], [
	461	ZFS_LINUX_TEST_SRC([blk_cgroup_header], [
	462	#include <linux/blk-cgroup.h>
	463	], [])
	464	])
	465
	466	AC_DEFUN([ZFS_AC_KERNEL_BLK_CGROUP_HEADER], [
b9d98453	467	AC_MSG_CHECKING([whether linux/blk-cgroup.h exists])
1e767532 CK	468	ZFS_LINUX_TEST_RESULT([blk_cgroup_header],[
	469	AC_MSG_RESULT(yes)
	470	AC_DEFINE(HAVE_LINUX_BLK_CGROUP_HEADER, 1,
	471	[linux/blk-cgroup.h exists])
	472	],[
	473	AC_MSG_RESULT(no)
	474	])
	475	])
	476
d1325b4f AZ	477	dnl #
	478	dnl # Linux 5.18 API
	479	dnl #
	480	dnl # In 07888c665b405b1cd3577ddebfeb74f4717a84c4 ("block: pass a block_device and opf to bio_alloc")
	481	dnl # bio_alloc(gfp_t gfp_mask, unsigned short nr_iovecs)
	482	dnl # became
	483	dnl # bio_alloc(struct block_device *bdev, unsigned short nr_vecs, unsigned int opf, gfp_t gfp_mask)
	484	dnl # however
	485	dnl # > NULL/0 can be passed, both for the
	486	dnl # > passthrough case on a raw request_queue and to temporarily avoid
	487	dnl # > refactoring some nasty code.
	488	dnl #
	489	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO_ALLOC_4ARG], [
	490	ZFS_LINUX_TEST_SRC([bio_alloc_4arg], [
	491	#include <linux/bio.h>
	492	],[
	493	gfp_t gfp_mask = 0;
	494	unsigned short nr_iovecs = 0;
	495	struct block_device *bdev = NULL;
	496	unsigned int opf = 0;
	497
	498	struct bio *__attribute__((unused)) allocated = bio_alloc(bdev, nr_iovecs, opf, gfp_mask);
	499	])
	500	])
	501
	502	AC_DEFUN([ZFS_AC_KERNEL_BIO_ALLOC_4ARG], [
b9d98453	503	AC_MSG_CHECKING([whether bio_alloc() wants 4 args])
d1325b4f AZ	504	ZFS_LINUX_TEST_RESULT([bio_alloc_4arg],[
	505	AC_MSG_RESULT(yes)
	506	AC_DEFINE([HAVE_BIO_ALLOC_4ARG], 1, [bio_alloc() takes 4 arguments])
	507	],[
	508	AC_MSG_RESULT(no)
	509	])
	510	])
	511
066e8252 BB	512	AC_DEFUN([ZFS_AC_KERNEL_SRC_BIO], [
	513	ZFS_AC_KERNEL_SRC_REQ
	514	ZFS_AC_KERNEL_SRC_BIO_OPS
	515	ZFS_AC_KERNEL_SRC_BIO_SET_DEV
	516	ZFS_AC_KERNEL_SRC_BIO_END_IO_T_ARGS
	517	ZFS_AC_KERNEL_SRC_BIO_BI_STATUS
	518	ZFS_AC_KERNEL_SRC_BIO_BVEC_ITER
	519	ZFS_AC_KERNEL_SRC_BIO_SUBMIT_BIO
	520	ZFS_AC_KERNEL_SRC_BIO_CURRENT_BIO_LIST
bd0d24e0	521	ZFS_AC_KERNEL_SRC_BLKG_TRYGET
d939930f	522	ZFS_AC_KERNEL_SRC_BIO_BDEV_DISK
435a451e	523	ZFS_AC_KERNEL_SRC_BDEV_SUBMIT_BIO_RETURNS_VOID
d08b99ac	524	ZFS_AC_KERNEL_SRC_BIO_SET_DEV_MACRO
1e767532	525	ZFS_AC_KERNEL_SRC_BLK_CGROUP_HEADER
d1325b4f	526	ZFS_AC_KERNEL_SRC_BIO_ALLOC_4ARG
066e8252 BB	527	])
	528
	529	AC_DEFUN([ZFS_AC_KERNEL_BIO], [
	530	ZFS_AC_KERNEL_BIO_REQ_FAILFAST_MASK
	531	ZFS_AC_KERNEL_BIO_REQ_DISCARD
	532	ZFS_AC_KERNEL_BIO_REQ_FLUSH
	533	ZFS_AC_KERNEL_BIO_REQ_PREFLUSH
	534
	535	ZFS_AC_KERNEL_BIO_REQ_OP_DISCARD
	536	ZFS_AC_KERNEL_BIO_REQ_OP_SECURE_ERASE
	537	ZFS_AC_KERNEL_BIO_REQ_OP_FLUSH
	538	ZFS_AC_KERNEL_BIO_BI_OPF
	539	ZFS_AC_KERNEL_BIO_SET_OP_ATTRS
	540
	541	ZFS_AC_KERNEL_BIO_SET_DEV
	542	ZFS_AC_KERNEL_BIO_END_IO_T_ARGS
	543	ZFS_AC_KERNEL_BIO_BI_STATUS
	544	ZFS_AC_KERNEL_BIO_BVEC_ITER
	545	ZFS_AC_KERNEL_BIO_SUBMIT_BIO
	546	ZFS_AC_KERNEL_BIO_CURRENT_BIO_LIST
bd0d24e0	547	ZFS_AC_KERNEL_BLKG_TRYGET
d939930f	548	ZFS_AC_KERNEL_BIO_BDEV_DISK
435a451e	549	ZFS_AC_KERNEL_BDEV_SUBMIT_BIO_RETURNS_VOID
1e767532	550	ZFS_AC_KERNEL_BLK_CGROUP_HEADER
d1325b4f	551	ZFS_AC_KERNEL_BIO_ALLOC_4ARG
066e8252	552	])