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