kernel-bio.m4

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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);
  191         ], [], [ZFS_META_LICENSE])
  192 ])
  193 
  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 
  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                 ])
  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                 ])
  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         ],[
  324                 struct bio *bio = NULL;
  325                 (void) submit_bio(bio);
  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 
  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         ],[
  373                 struct blkcg_gq blkg __attribute__ ((unused)) = {};
  374                 bool rc __attribute__ ((unused));
  375                 rc = blkg_tryget(&blkg);
  376         ], [], [ZFS_META_LICENSE])
  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 
  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 
  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 
  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], [
  467         AC_MSG_CHECKING([whether linux/blk-cgroup.h exists])
  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 
  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], [
  503         AC_MSG_CHECKING([whether bio_alloc() wants 4 args])
  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 
  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
  521         ZFS_AC_KERNEL_SRC_BLKG_TRYGET
  522         ZFS_AC_KERNEL_SRC_BIO_BDEV_DISK
  523         ZFS_AC_KERNEL_SRC_BDEV_SUBMIT_BIO_RETURNS_VOID
  524         ZFS_AC_KERNEL_SRC_BIO_SET_DEV_MACRO
  525         ZFS_AC_KERNEL_SRC_BLK_CGROUP_HEADER
  526         ZFS_AC_KERNEL_SRC_BIO_ALLOC_4ARG
  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
  547         ZFS_AC_KERNEL_BLKG_TRYGET
  548         ZFS_AC_KERNEL_BIO_BDEV_DISK
  549         ZFS_AC_KERNEL_BDEV_SUBMIT_BIO_RETURNS_VOID
  550         ZFS_AC_KERNEL_BLK_CGROUP_HEADER
  551         ZFS_AC_KERNEL_BIO_ALLOC_4ARG
  552 ])
Cache object: 57ae76c6e5a1cd8db348fe88760f83b1
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/contrib/openzfs/config/kernel-bio.m4

FreeBSD/Linux Kernel Cross Reference
sys/contrib/openzfs/config/kernel-bio.m4
