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