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