config/kernel-blkdev.m4

   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>
   8                 #include <linux/blkdev.h>
   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 dnl #
  20 dnl # 6.5.x API change,
  21 dnl # blkdev_get_by_path() takes 4 args
  22 dnl #
  23 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH_4ARG], [
  24         ZFS_LINUX_TEST_SRC([blkdev_get_by_path_4arg], [
  25                 #include <linux/fs.h>
  26                 #include <linux/blkdev.h>
  27         ], [
  28                 struct block_device *bdev __attribute__ ((unused)) = NULL;
  29                 const char *path = "path";
  30                 fmode_t mode = 0;
  31                 void *holder = NULL;
  32                 struct blk_holder_ops h;
  33
  34                 bdev = blkdev_get_by_path(path, mode, holder, &h);
  35         ])
  36 ])
  37
  38 dnl #
  39 dnl # 6.8.x API change
  40 dnl # bdev_open_by_path() replaces blkdev_get_by_path()
  41 dnl #
  42 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_OPEN_BY_PATH], [
  43         ZFS_LINUX_TEST_SRC([bdev_open_by_path], [
  44                 #include <linux/fs.h>
  45                 #include <linux/blkdev.h>
  46         ], [
  47                 struct bdev_handle *bdh __attribute__ ((unused)) = NULL;
  48                 const char *path = "path";
  49                 fmode_t mode = 0;
  50                 void *holder = NULL;
  51                 struct blk_holder_ops h;
  52
  53                 bdh = bdev_open_by_path(path, mode, holder, &h);
  54         ])
  55 ])
  56
  57 dnl #
  58 dnl # 6.9.x API change
  59 dnl # bdev_file_open_by_path() replaced bdev_open_by_path(),
  60 dnl # and returns struct file*
  61 dnl #
  62 AC_DEFUN([ZFS_AC_KERNEL_SRC_BDEV_FILE_OPEN_BY_PATH], [
  63         ZFS_LINUX_TEST_SRC([bdev_file_open_by_path], [
  64                 #include <linux/fs.h>
  65                 #include <linux/blkdev.h>
  66         ], [
  67                 struct file *file __attribute__ ((unused)) = NULL;
  68                 const char *path = "path";
  69                 fmode_t mode = 0;
  70                 void *holder = NULL;
  71                 struct blk_holder_ops h;
  72
  73                 file = bdev_file_open_by_path(path, mode, holder, &h);
  74         ])
  75 ])
  76
  77 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH], [
  78         AC_MSG_CHECKING([whether blkdev_get_by_path() exists and takes 3 args])
  79         ZFS_LINUX_TEST_RESULT([blkdev_get_by_path], [
  80                 AC_MSG_RESULT(yes)
  81         ], [
  82                 AC_MSG_RESULT(no)
  83                 AC_MSG_CHECKING([whether blkdev_get_by_path() exists and takes 4 args])
  84                 ZFS_LINUX_TEST_RESULT([blkdev_get_by_path_4arg], [
  85                         AC_DEFINE(HAVE_BLKDEV_GET_BY_PATH_4ARG, 1,
  86                                 [blkdev_get_by_path() exists and takes 4 args])
  87                         AC_MSG_RESULT(yes)
  88                 ], [
  89                         AC_MSG_RESULT(no)
  90                         AC_MSG_CHECKING([whether bdev_open_by_path() exists])
  91                         ZFS_LINUX_TEST_RESULT([bdev_open_by_path], [
  92                                 AC_DEFINE(HAVE_BDEV_OPEN_BY_PATH, 1,
  93                                         [bdev_open_by_path() exists])
  94                                 AC_MSG_RESULT(yes)
  95                         ], [
  96                                 AC_MSG_RESULT(no)
  97                                 AC_MSG_CHECKING([whether bdev_file_open_by_path() exists])
  98                                 ZFS_LINUX_TEST_RESULT([bdev_file_open_by_path], [
  99                                         AC_DEFINE(HAVE_BDEV_FILE_OPEN_BY_PATH, 1,
 100                                                 [bdev_file_open_by_path() exists])
 101                                         AC_MSG_RESULT(yes)
 102                                 ], [
 103                                         AC_MSG_RESULT(no)
 104                                         ZFS_LINUX_TEST_ERROR([blkdev_get_by_path()])
 105                                 ])
 106                         ])
 107                 ])
 108         ])
 109 ])
 110
 111 dnl #
 112 dnl # 6.5.x API change
 113 dnl # blk_mode_t was added as a type to supercede some places where fmode_t
 114 dnl # is used
 115 dnl #
 116 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BLK_MODE_T], [
 117         ZFS_LINUX_TEST_SRC([blk_mode_t], [
 118                 #include <linux/fs.h>
 119                 #include <linux/blkdev.h>
 120         ], [
 121                 blk_mode_t m __attribute((unused)) = (blk_mode_t)0;
 122         ])
 123 ])
 124
 125 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BLK_MODE_T], [
 126         AC_MSG_CHECKING([whether blk_mode_t is defined])
 127         ZFS_LINUX_TEST_RESULT([blk_mode_t], [
 128                 AC_MSG_RESULT(yes)
 129                 AC_DEFINE(HAVE_BLK_MODE_T, 1, [blk_mode_t is defined])
 130         ], [
 131                 AC_MSG_RESULT(no)
 132         ])
 133 ])
 134
 135 dnl #
 136 dnl # 2.6.38 API change,
 137 dnl # Added blkdev_put()
 138 dnl #
 139 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PUT], [
 140         ZFS_LINUX_TEST_SRC([blkdev_put], [
 141                 #include <linux/fs.h>
 142                 #include <linux/blkdev.h>
 143         ], [
 144                 struct block_device *bdev = NULL;
 145                 fmode_t mode = 0;
 146
 147                 blkdev_put(bdev, mode);
 148         ])
 149 ])
 150
 151 dnl #
 152 dnl # 6.5.x API change.
 153 dnl # blkdev_put() takes (void* holder) as arg 2
 154 dnl #
 155 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PUT_HOLDER], [
 156         ZFS_LINUX_TEST_SRC([blkdev_put_holder], [
 157                 #include <linux/fs.h>
 158                 #include <linux/blkdev.h>
 159         ], [
 160                 struct block_device *bdev = NULL;
 161                 void *holder = NULL;
 162
 163                 blkdev_put(bdev, holder);
 164         ])
 165 ])
 166
 167 dnl #
 168 dnl # 6.8.x API change
 169 dnl # bdev_release() replaces blkdev_put()
 170 dnl #
 171 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_RELEASE], [
 172         ZFS_LINUX_TEST_SRC([bdev_release], [
 173                 #include <linux/fs.h>
 174                 #include <linux/blkdev.h>
 175         ], [
 176                 struct bdev_handle *bdh = NULL;
 177                 bdev_release(bdh);
 178         ])
 179 ])
 180
 181 dnl #
 182 dnl # 6.9.x API change
 183 dnl #
 184 dnl # bdev_release() now private, but because bdev_file_open_by_path() returns
 185 dnl # struct file*, we can just use fput(). So the blkdev_put test no longer
 186 dnl # fails if not found.
 187 dnl #
 188
 189 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_PUT], [
 190         AC_MSG_CHECKING([whether blkdev_put() exists])
 191         ZFS_LINUX_TEST_RESULT([blkdev_put], [
 192                 AC_MSG_RESULT(yes)
 193                 AC_DEFINE(HAVE_BLKDEV_PUT, 1, [blkdev_put() exists])
 194         ], [
 195                 AC_MSG_RESULT(no)
 196                 AC_MSG_CHECKING([whether blkdev_put() accepts void* as arg 2])
 197                 ZFS_LINUX_TEST_RESULT([blkdev_put_holder], [
 198                         AC_MSG_RESULT(yes)
 199                         AC_DEFINE(HAVE_BLKDEV_PUT_HOLDER, 1,
 200                                 [blkdev_put() accepts void* as arg 2])
 201                 ], [
 202                         AC_MSG_RESULT(no)
 203                         AC_MSG_CHECKING([whether bdev_release() exists])
 204                         ZFS_LINUX_TEST_RESULT([bdev_release], [
 205                                 AC_MSG_RESULT(yes)
 206                                 AC_DEFINE(HAVE_BDEV_RELEASE, 1,
 207                                         [bdev_release() exists])
 208                         ], [
 209                                 AC_MSG_RESULT(no)
 210                         ])
 211                 ])
 212         ])
 213 ])
 214
 215 dnl #
 216 dnl # 4.1 API, exported blkdev_reread_part() symbol, back ported to the
 217 dnl # 3.10.0 CentOS 7.x enterprise kernels.
 218 dnl #
 219 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART], [
 220         ZFS_LINUX_TEST_SRC([blkdev_reread_part], [
 221                 #include <linux/fs.h>
 222                 #include <linux/blkdev.h>
 223         ], [
 224                 struct block_device *bdev = NULL;
 225                 int error;
 226
 227                 error = blkdev_reread_part(bdev);
 228         ])
 229 ])
 230
 231 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_REREAD_PART], [
 232         AC_MSG_CHECKING([whether blkdev_reread_part() exists])
 233         ZFS_LINUX_TEST_RESULT([blkdev_reread_part], [
 234                 AC_MSG_RESULT(yes)
 235                 AC_DEFINE(HAVE_BLKDEV_REREAD_PART, 1,
 236                     [blkdev_reread_part() exists])
 237         ], [
 238                 AC_MSG_RESULT(no)
 239         ])
 240 ])
 241
 242 dnl #
 243 dnl # check_disk_change() was removed in 5.10
 244 dnl #
 245 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE], [
 246         ZFS_LINUX_TEST_SRC([check_disk_change], [
 247                 #include <linux/fs.h>
 248                 #include <linux/blkdev.h>
 249         ], [
 250                 struct block_device *bdev = NULL;
 251                 bool error;
 252
 253                 error = check_disk_change(bdev);
 254         ])
 255 ])
 256
 257 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE], [
 258         AC_MSG_CHECKING([whether check_disk_change() exists])
 259         ZFS_LINUX_TEST_RESULT([check_disk_change], [
 260                 AC_MSG_RESULT(yes)
 261                 AC_DEFINE(HAVE_CHECK_DISK_CHANGE, 1,
 262                     [check_disk_change() exists])
 263         ], [
 264                 AC_MSG_RESULT(no)
 265         ])
 266 ])
 267
 268 dnl #
 269 dnl # 6.5.x API change
 270 dnl # disk_check_media_change() was added
 271 dnl #
 272 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_DISK_CHECK_MEDIA_CHANGE], [
 273         ZFS_LINUX_TEST_SRC([disk_check_media_change], [
 274                 #include <linux/fs.h>
 275                 #include <linux/blkdev.h>
 276         ], [
 277                 struct block_device *bdev = NULL;
 278                 bool error;
 279
 280                 error = disk_check_media_change(bdev->bd_disk);
 281         ])
 282 ])
 283
 284 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_DISK_CHECK_MEDIA_CHANGE], [
 285         AC_MSG_CHECKING([whether disk_check_media_change() exists])
 286         ZFS_LINUX_TEST_RESULT([disk_check_media_change], [
 287                 AC_MSG_RESULT(yes)
 288                 AC_DEFINE(HAVE_DISK_CHECK_MEDIA_CHANGE, 1,
 289                     [disk_check_media_change() exists])
 290         ], [
 291                 AC_MSG_RESULT(no)
 292         ])
 293 ])
 294
 295 dnl #
 296 dnl # bdev_kobj() is introduced from 5.12
 297 dnl #
 298 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_KOBJ], [
 299         ZFS_LINUX_TEST_SRC([bdev_kobj], [
 300                 #include <linux/fs.h>
 301                 #include <linux/blkdev.h>
 302                 #include <linux/kobject.h>
 303         ], [
 304                 struct block_device *bdev = NULL;
 305                 struct kobject *disk_kobj;
 306                 disk_kobj = bdev_kobj(bdev);
 307         ])
 308 ])
 309
 310 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_KOBJ], [
 311         AC_MSG_CHECKING([whether bdev_kobj() exists])
 312         ZFS_LINUX_TEST_RESULT([bdev_kobj], [
 313                 AC_MSG_RESULT(yes)
 314                 AC_DEFINE(HAVE_BDEV_KOBJ, 1,
 315                     [bdev_kobj() exists])
 316         ], [
 317                 AC_MSG_RESULT(no)
 318         ])
 319 ])
 320
 321 dnl #
 322 dnl # part_to_dev() was removed in 5.12
 323 dnl #
 324 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_PART_TO_DEV], [
 325         ZFS_LINUX_TEST_SRC([part_to_dev], [
 326                 #include <linux/fs.h>
 327                 #include <linux/blkdev.h>
 328         ], [
 329                 struct hd_struct *p = NULL;
 330                 struct device *pdev;
 331                 pdev = part_to_dev(p);
 332         ])
 333 ])
 334
 335 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_PART_TO_DEV], [
 336         AC_MSG_CHECKING([whether part_to_dev() exists])
 337         ZFS_LINUX_TEST_RESULT([part_to_dev], [
 338                 AC_MSG_RESULT(yes)
 339                 AC_DEFINE(HAVE_PART_TO_DEV, 1,
 340                     [part_to_dev() exists])
 341         ], [
 342                 AC_MSG_RESULT(no)
 343         ])
 344 ])
 345
 346 dnl #
 347 dnl # 5.10 API, check_disk_change() is removed, in favor of
 348 dnl # bdev_check_media_change(), which doesn't force revalidation
 349 dnl #
 350 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
 351         ZFS_LINUX_TEST_SRC([bdev_check_media_change], [
 352                 #include <linux/fs.h>
 353                 #include <linux/blkdev.h>
 354         ], [
 355                 struct block_device *bdev = NULL;
 356                 int error;
 357
 358                 error = bdev_check_media_change(bdev);
 359         ])
 360 ])
 361
 362 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE], [
 363         AC_MSG_CHECKING([whether bdev_check_media_change() exists])
 364         ZFS_LINUX_TEST_RESULT([bdev_check_media_change], [
 365                 AC_MSG_RESULT(yes)
 366                 AC_DEFINE(HAVE_BDEV_CHECK_MEDIA_CHANGE, 1,
 367                     [bdev_check_media_change() exists])
 368         ], [
 369                 AC_MSG_RESULT(no)
 370         ])
 371 ])
 372
 373 dnl #
 374 dnl # 2.6.22 API change
 375 dnl # Single argument invalidate_bdev()
 376 dnl #
 377 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV], [
 378         ZFS_LINUX_TEST_SRC([invalidate_bdev], [
 379                 #include <linux/buffer_head.h>
 380                 #include <linux/blkdev.h>
 381         ],[
 382                 struct block_device *bdev = NULL;
 383                 invalidate_bdev(bdev);
 384         ])
 385 ])
 386
 387 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV], [
 388         AC_MSG_CHECKING([whether invalidate_bdev() exists])
 389         ZFS_LINUX_TEST_RESULT([invalidate_bdev], [
 390                 AC_MSG_RESULT(yes)
 391         ],[
 392                 ZFS_LINUX_TEST_ERROR([invalidate_bdev()])
 393         ])
 394 ])
 395
 396 dnl #
 397 dnl # 5.11 API, lookup_bdev() takes dev_t argument.
 398 dnl # 2.6.27 API, lookup_bdev() was first exported.
 399 dnl # 4.4.0-6.21 API, lookup_bdev() on Ubuntu takes mode argument.
 400 dnl #
 401 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV], [
 402         ZFS_LINUX_TEST_SRC([lookup_bdev_devt], [
 403                 #include <linux/blkdev.h>
 404         ], [
 405                 int error __attribute__ ((unused));
 406                 const char path[] = "/example/path";
 407                 dev_t dev;
 408
 409                 error = lookup_bdev(path, &dev);
 410         ])
 411
 412         ZFS_LINUX_TEST_SRC([lookup_bdev_1arg], [
 413                 #include <linux/fs.h>
 414                 #include <linux/blkdev.h>
 415         ], [
 416                 struct block_device *bdev __attribute__ ((unused));
 417                 const char path[] = "/example/path";
 418
 419                 bdev = lookup_bdev(path);
 420         ])
 421
 422         ZFS_LINUX_TEST_SRC([lookup_bdev_mode], [
 423                 #include <linux/fs.h>
 424         ], [
 425                 struct block_device *bdev __attribute__ ((unused));
 426                 const char path[] = "/example/path";
 427
 428                 bdev = lookup_bdev(path, FMODE_READ);
 429         ])
 430 ])
 431
 432 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV], [
 433         AC_MSG_CHECKING([whether lookup_bdev() wants dev_t arg])
 434         ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_devt],
 435             [lookup_bdev], [fs/block_dev.c], [
 436                 AC_MSG_RESULT(yes)
 437                 AC_DEFINE(HAVE_DEVT_LOOKUP_BDEV, 1,
 438                     [lookup_bdev() wants dev_t arg])
 439         ], [
 440                 AC_MSG_RESULT(no)
 441
 442                 AC_MSG_CHECKING([whether lookup_bdev() wants 1 arg])
 443                 ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_1arg],
 444                     [lookup_bdev], [fs/block_dev.c], [
 445                         AC_MSG_RESULT(yes)
 446                         AC_DEFINE(HAVE_1ARG_LOOKUP_BDEV, 1,
 447                             [lookup_bdev() wants 1 arg])
 448                 ], [
 449                         AC_MSG_RESULT(no)
 450
 451                         AC_MSG_CHECKING([whether lookup_bdev() wants mode arg])
 452                         ZFS_LINUX_TEST_RESULT_SYMBOL([lookup_bdev_mode],
 453                             [lookup_bdev], [fs/block_dev.c], [
 454                                 AC_MSG_RESULT(yes)
 455                                 AC_DEFINE(HAVE_MODE_LOOKUP_BDEV, 1,
 456                                     [lookup_bdev() wants mode arg])
 457                         ], [
 458                                 ZFS_LINUX_TEST_ERROR([lookup_bdev()])
 459                         ])
 460                 ])
 461         ])
 462 ])
 463
 464 dnl #
 465 dnl # 2.6.30 API change
 466 dnl #
 467 dnl # The bdev_physical_block_size() interface was added to provide a way
 468 dnl # to determine the smallest write which can be performed without a
 469 dnl # read-modify-write operation.
 470 dnl #
 471 dnl # Unfortunately, this interface isn't entirely reliable because
 472 dnl # drives are sometimes known to misreport this value.
 473 dnl #
 474 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
 475         ZFS_LINUX_TEST_SRC([bdev_physical_block_size], [
 476                 #include <linux/blkdev.h>
 477         ],[
 478                 struct block_device *bdev __attribute__ ((unused)) = NULL;
 479                 bdev_physical_block_size(bdev);
 480         ])
 481 ])
 482
 483 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE], [
 484         AC_MSG_CHECKING([whether bdev_physical_block_size() is available])
 485         ZFS_LINUX_TEST_RESULT([bdev_physical_block_size], [
 486                 AC_MSG_RESULT(yes)
 487         ],[
 488                 ZFS_LINUX_TEST_ERROR([bdev_physical_block_size()])
 489         ])
 490 ])
 491
 492 dnl #
 493 dnl # 2.6.30 API change
 494 dnl # Added bdev_logical_block_size().
 495 dnl #
 496 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
 497         ZFS_LINUX_TEST_SRC([bdev_logical_block_size], [
 498                 #include <linux/blkdev.h>
 499         ],[
 500                 struct block_device *bdev __attribute__ ((unused)) = NULL;
 501                 bdev_logical_block_size(bdev);
 502         ])
 503 ])
 504
 505 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE], [
 506         AC_MSG_CHECKING([whether bdev_logical_block_size() is available])
 507         ZFS_LINUX_TEST_RESULT([bdev_logical_block_size], [
 508                 AC_MSG_RESULT(yes)
 509         ],[
 510                 ZFS_LINUX_TEST_ERROR([bdev_logical_block_size()])
 511         ])
 512 ])
 513
 514 dnl #
 515 dnl # 5.11 API change
 516 dnl # Added bdev_whole() helper.
 517 dnl #
 518 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE], [
 519         ZFS_LINUX_TEST_SRC([bdev_whole], [
 520                 #include <linux/blkdev.h>
 521         ],[
 522                 struct block_device *bdev = NULL;
 523                 bdev = bdev_whole(bdev);
 524         ])
 525 ])
 526
 527 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE], [
 528         AC_MSG_CHECKING([whether bdev_whole() is available])
 529         ZFS_LINUX_TEST_RESULT([bdev_whole], [
 530                 AC_MSG_RESULT(yes)
 531                 AC_DEFINE(HAVE_BDEV_WHOLE, 1, [bdev_whole() is available])
 532         ],[
 533                 AC_MSG_RESULT(no)
 534         ])
 535 ])
 536
 537 dnl #
 538 dnl # 5.20 API change,
 539 dnl # Removed bdevname(), snprintf(.., %pg) should be used.
 540 dnl #
 541 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BDEVNAME], [
 542         ZFS_LINUX_TEST_SRC([bdevname], [
 543                 #include <linux/fs.h>
 544                 #include <linux/blkdev.h>
 545         ], [
 546                 struct block_device *bdev __attribute__ ((unused)) = NULL;
 547                 char path[BDEVNAME_SIZE];
 548
 549                 (void) bdevname(bdev, path);
 550         ])
 551 ])
 552
 553 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BDEVNAME], [
 554         AC_MSG_CHECKING([whether bdevname() exists])
 555         ZFS_LINUX_TEST_RESULT([bdevname], [
 556                 AC_DEFINE(HAVE_BDEVNAME, 1, [bdevname() is available])
 557                 AC_MSG_RESULT(yes)
 558         ], [
 559                 AC_MSG_RESULT(no)
 560         ])
 561 ])
 562
 563 dnl #
 564 dnl # 5.19 API: blkdev_issue_secure_erase()
 565 dnl # 4.7  API: __blkdev_issue_discard(..., BLKDEV_DISCARD_SECURE)
 566 dnl # 3.10 API: blkdev_issue_discard(..., BLKDEV_DISCARD_SECURE)
 567 dnl #
 568 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_ISSUE_SECURE_ERASE], [
 569         ZFS_LINUX_TEST_SRC([blkdev_issue_secure_erase], [
 570                 #include <linux/blkdev.h>
 571         ],[
 572                 struct block_device *bdev = NULL;
 573                 sector_t sector = 0;
 574                 sector_t nr_sects = 0;
 575                 int error __attribute__ ((unused));
 576
 577                 error = blkdev_issue_secure_erase(bdev,
 578                     sector, nr_sects, GFP_KERNEL);
 579         ])
 580
 581         ZFS_LINUX_TEST_SRC([blkdev_issue_discard_async_flags], [
 582                 #include <linux/blkdev.h>
 583         ],[
 584                 struct block_device *bdev = NULL;
 585                 sector_t sector = 0;
 586                 sector_t nr_sects = 0;
 587                 unsigned long flags = 0;
 588                 struct bio *biop = NULL;
 589                 int error __attribute__ ((unused));
 590
 591                 error = __blkdev_issue_discard(bdev,
 592                     sector, nr_sects, GFP_KERNEL, flags, &biop);
 593         ])
 594
 595         ZFS_LINUX_TEST_SRC([blkdev_issue_discard_flags], [
 596                 #include <linux/blkdev.h>
 597         ],[
 598                 struct block_device *bdev = NULL;
 599                 sector_t sector = 0;
 600                 sector_t nr_sects = 0;
 601                 unsigned long flags = 0;
 602                 int error __attribute__ ((unused));
 603
 604                 error = blkdev_issue_discard(bdev,
 605                     sector, nr_sects, GFP_KERNEL, flags);
 606         ])
 607 ])
 608
 609 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_ISSUE_SECURE_ERASE], [
 610         AC_MSG_CHECKING([whether blkdev_issue_secure_erase() is available])
 611         ZFS_LINUX_TEST_RESULT([blkdev_issue_secure_erase], [
 612                 AC_MSG_RESULT(yes)
 613                 AC_DEFINE(HAVE_BLKDEV_ISSUE_SECURE_ERASE, 1,
 614                     [blkdev_issue_secure_erase() is available])
 615         ],[
 616                 AC_MSG_RESULT(no)
 617
 618                 AC_MSG_CHECKING([whether __blkdev_issue_discard() is available])
 619                 ZFS_LINUX_TEST_RESULT([blkdev_issue_discard_async_flags], [
 620                         AC_MSG_RESULT(yes)
 621                         AC_DEFINE(HAVE_BLKDEV_ISSUE_DISCARD_ASYNC, 1,
 622                             [__blkdev_issue_discard() is available])
 623                 ],[
 624                         AC_MSG_RESULT(no)
 625
 626                         AC_MSG_CHECKING([whether blkdev_issue_discard() is available])
 627                         ZFS_LINUX_TEST_RESULT([blkdev_issue_discard_flags], [
 628                                 AC_MSG_RESULT(yes)
 629                                 AC_DEFINE(HAVE_BLKDEV_ISSUE_DISCARD, 1,
 630                                         [blkdev_issue_discard() is available])
 631                         ],[
 632                                 ZFS_LINUX_TEST_ERROR([blkdev_issue_discard()])
 633                         ])
 634                 ])
 635         ])
 636 ])
 637
 638 dnl #
 639 dnl # 5.13 API change
 640 dnl # blkdev_get_by_path() no longer handles ERESTARTSYS
 641 dnl #
 642 dnl # Unfortunately we're forced to rely solely on the kernel version
 643 dnl # number in order to determine the expected behavior.  This was an
 644 dnl # internal change to blkdev_get_by_dev(), see commit a8ed1a0607.
 645 dnl #
 646 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS], [
 647         AC_MSG_CHECKING([whether blkdev_get_by_path() handles ERESTARTSYS])
 648         AS_VERSION_COMPARE([$LINUX_VERSION], [5.13.0], [
 649                 AC_MSG_RESULT(yes)
 650                 AC_DEFINE(HAVE_BLKDEV_GET_ERESTARTSYS, 1,
 651                         [blkdev_get_by_path() handles ERESTARTSYS])
 652         ],[
 653                 AC_MSG_RESULT(no)
 654         ],[
 655                 AC_MSG_RESULT(no)
 656         ])
 657 ])
 658
 659 dnl #
 660 dnl # 6.5.x API change
 661 dnl # BLK_STS_NEXUS replaced with BLK_STS_RESV_CONFLICT
 662 dnl #
 663 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV_BLK_STS_RESV_CONFLICT], [
 664         ZFS_LINUX_TEST_SRC([blk_sts_resv_conflict], [
 665                 #include <linux/blkdev.h>
 666         ],[
 667                 blk_status_t s __attribute__ ((unused)) = BLK_STS_RESV_CONFLICT;
 668         ])
 669 ])
 670
 671 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV_BLK_STS_RESV_CONFLICT], [
 672         AC_MSG_CHECKING([whether BLK_STS_RESV_CONFLICT is defined])
 673                 ZFS_LINUX_TEST_RESULT([blk_sts_resv_conflict], [
 674                         AC_DEFINE(HAVE_BLK_STS_RESV_CONFLICT, 1, [BLK_STS_RESV_CONFLICT is defined])
 675                         AC_MSG_RESULT(yes)
 676                 ], [
 677                         AC_MSG_RESULT(no)
 678                 ])
 679         ])
 680 ])
 681
 682 AC_DEFUN([ZFS_AC_KERNEL_SRC_BLKDEV], [
 683         ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH
 684         ZFS_AC_KERNEL_SRC_BLKDEV_GET_BY_PATH_4ARG
 685         ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_OPEN_BY_PATH
 686         ZFS_AC_KERNEL_SRC_BDEV_FILE_OPEN_BY_PATH
 687         ZFS_AC_KERNEL_SRC_BLKDEV_PUT
 688         ZFS_AC_KERNEL_SRC_BLKDEV_PUT_HOLDER
 689         ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_RELEASE
 690         ZFS_AC_KERNEL_SRC_BLKDEV_REREAD_PART
 691         ZFS_AC_KERNEL_SRC_BLKDEV_INVALIDATE_BDEV
 692         ZFS_AC_KERNEL_SRC_BLKDEV_LOOKUP_BDEV
 693         ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
 694         ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
 695         ZFS_AC_KERNEL_SRC_BLKDEV_CHECK_DISK_CHANGE
 696         ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
 697         ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_WHOLE
 698         ZFS_AC_KERNEL_SRC_BLKDEV_BDEVNAME
 699         ZFS_AC_KERNEL_SRC_BLKDEV_ISSUE_SECURE_ERASE
 700         ZFS_AC_KERNEL_SRC_BLKDEV_BDEV_KOBJ
 701         ZFS_AC_KERNEL_SRC_BLKDEV_PART_TO_DEV
 702         ZFS_AC_KERNEL_SRC_BLKDEV_DISK_CHECK_MEDIA_CHANGE
 703         ZFS_AC_KERNEL_SRC_BLKDEV_BLK_STS_RESV_CONFLICT
 704         ZFS_AC_KERNEL_SRC_BLKDEV_BLK_MODE_T
 705 ])
 706
 707 AC_DEFUN([ZFS_AC_KERNEL_BLKDEV], [
 708         ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH
 709         ZFS_AC_KERNEL_BLKDEV_PUT
 710         ZFS_AC_KERNEL_BLKDEV_REREAD_PART
 711         ZFS_AC_KERNEL_BLKDEV_INVALIDATE_BDEV
 712         ZFS_AC_KERNEL_BLKDEV_LOOKUP_BDEV
 713         ZFS_AC_KERNEL_BLKDEV_BDEV_LOGICAL_BLOCK_SIZE
 714         ZFS_AC_KERNEL_BLKDEV_BDEV_PHYSICAL_BLOCK_SIZE
 715         ZFS_AC_KERNEL_BLKDEV_CHECK_DISK_CHANGE
 716         ZFS_AC_KERNEL_BLKDEV_BDEV_CHECK_MEDIA_CHANGE
 717         ZFS_AC_KERNEL_BLKDEV_BDEV_WHOLE
 718         ZFS_AC_KERNEL_BLKDEV_BDEVNAME
 719         ZFS_AC_KERNEL_BLKDEV_GET_ERESTARTSYS
 720         ZFS_AC_KERNEL_BLKDEV_ISSUE_SECURE_ERASE
 721         ZFS_AC_KERNEL_BLKDEV_BDEV_KOBJ
 722         ZFS_AC_KERNEL_BLKDEV_PART_TO_DEV
 723         ZFS_AC_KERNEL_BLKDEV_DISK_CHECK_MEDIA_CHANGE
 724         ZFS_AC_KERNEL_BLKDEV_BLK_STS_RESV_CONFLICT
 725         ZFS_AC_KERNEL_BLKDEV_BLK_MODE_T
 726 ])