1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_BLKDEV_H 3 #define _LINUX_BLKDEV_H 4 5 #include <linux/sched.h> 6 #include <linux/genhd.h> 7 #include <linux/list.h> 8 #include <linux/llist.h> 9 #include <linux/minmax.h> 10 #include <linux/timer.h> 11 #include <linux/workqueue.h> 12 #include <linux/wait.h> 13 #include <linux/bio.h> 14 #include <linux/gfp.h> 15 #include <linux/rcupdate.h> 16 #include <linux/percpu-refcount.h> 17 #include <linux/blkzoned.h> 18 #include <linux/sbitmap.h> 19 #include <linux/srcu.h> 20 21 struct module; 22 struct request_queue; 23 struct elevator_queue; 24 struct blk_trace; 25 struct request; 26 struct sg_io_hdr; 27 struct blkcg_gq; 28 struct blk_flush_queue; 29 struct kiocb; 30 struct pr_ops; 31 struct rq_qos; 32 struct blk_queue_stats; 33 struct blk_stat_callback; 34 struct blk_crypto_profile; 35 36 /* Must be consistent with blk_mq_poll_stats_bkt() */ 37 #define BLK_MQ_POLL_STATS_BKTS 16 38 39 /* Doing classic polling */ 40 #define BLK_MQ_POLL_CLASSIC -1 41 42 /* 43 * Maximum number of blkcg policies allowed to be registered concurrently. 44 * Defined here to simplify include dependency. 45 */ 46 #define BLKCG_MAX_POLS 6 47 48 static inline int blk_validate_block_size(unsigned long bsize) 49 { 50 if (bsize < 512 || bsize > PAGE_SIZE || !is_power_of_2(bsize)) 51 return -EINVAL; 52 53 return 0; 54 } 55 56 static inline bool blk_op_is_passthrough(unsigned int op) 57 { 58 op &= REQ_OP_MASK; 59 return op == REQ_OP_DRV_IN || op == REQ_OP_DRV_OUT; 60 } 61 62 /* 63 * Zoned block device models (zoned limit). 64 * 65 * Note: This needs to be ordered from the least to the most severe 66 * restrictions for the inheritance in blk_stack_limits() to work. 67 */ 68 enum blk_zoned_model { 69 BLK_ZONED_NONE = 0, /* Regular block device */ 70 BLK_ZONED_HA, /* Host-aware zoned block device */ 71 BLK_ZONED_HM, /* Host-managed zoned block device */ 72 }; 73 74 /* 75 * BLK_BOUNCE_NONE: never bounce (default) 76 * BLK_BOUNCE_HIGH: bounce all highmem pages 77 */ 78 enum blk_bounce { 79 BLK_BOUNCE_NONE, 80 BLK_BOUNCE_HIGH, 81 }; 82 83 struct queue_limits { 84 enum blk_bounce bounce; 85 unsigned long seg_boundary_mask; 86 unsigned long virt_boundary_mask; 87 88 unsigned int max_hw_sectors; 89 unsigned int max_dev_sectors; 90 unsigned int chunk_sectors; 91 unsigned int max_sectors; 92 unsigned int max_segment_size; 93 unsigned int physical_block_size; 94 unsigned int logical_block_size; 95 unsigned int alignment_offset; 96 unsigned int io_min; 97 unsigned int io_opt; 98 unsigned int max_discard_sectors; 99 unsigned int max_hw_discard_sectors; 100 unsigned int max_write_zeroes_sectors; 101 unsigned int max_zone_append_sectors; 102 unsigned int discard_granularity; 103 unsigned int discard_alignment; 104 unsigned int zone_write_granularity; 105 106 unsigned short max_segments; 107 unsigned short max_integrity_segments; 108 unsigned short max_discard_segments; 109 110 unsigned char misaligned; 111 unsigned char discard_misaligned; 112 unsigned char raid_partial_stripes_expensive; 113 enum blk_zoned_model zoned; 114 }; 115 116 typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx, 117 void *data); 118 119 void blk_queue_set_zoned(struct gendisk *disk, enum blk_zoned_model model); 120 121 #ifdef CONFIG_BLK_DEV_ZONED 122 123 #define BLK_ALL_ZONES ((unsigned int)-1) 124 int blkdev_report_zones(struct block_device *bdev, sector_t sector, 125 unsigned int nr_zones, report_zones_cb cb, void *data); 126 unsigned int blkdev_nr_zones(struct gendisk *disk); 127 extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op, 128 sector_t sectors, sector_t nr_sectors, 129 gfp_t gfp_mask); 130 int blk_revalidate_disk_zones(struct gendisk *disk, 131 void (*update_driver_data)(struct gendisk *disk)); 132 133 extern int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode, 134 unsigned int cmd, unsigned long arg); 135 extern int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode, 136 unsigned int cmd, unsigned long arg); 137 138 #else /* CONFIG_BLK_DEV_ZONED */ 139 140 static inline unsigned int blkdev_nr_zones(struct gendisk *disk) 141 { 142 return 0; 143 } 144 145 static inline int blkdev_report_zones_ioctl(struct block_device *bdev, 146 fmode_t mode, unsigned int cmd, 147 unsigned long arg) 148 { 149 return -ENOTTY; 150 } 151 152 static inline int blkdev_zone_mgmt_ioctl(struct block_device *bdev, 153 fmode_t mode, unsigned int cmd, 154 unsigned long arg) 155 { 156 return -ENOTTY; 157 } 158 159 #endif /* CONFIG_BLK_DEV_ZONED */ 160 161 /* 162 * Independent access ranges: struct blk_independent_access_range describes 163 * a range of contiguous sectors that can be accessed using device command 164 * execution resources that are independent from the resources used for 165 * other access ranges. This is typically found with single-LUN multi-actuator 166 * HDDs where each access range is served by a different set of heads. 167 * The set of independent ranges supported by the device is defined using 168 * struct blk_independent_access_ranges. The independent ranges must not overlap 169 * and must include all sectors within the disk capacity (no sector holes 170 * allowed). 171 * For a device with multiple ranges, requests targeting sectors in different 172 * ranges can be executed in parallel. A request can straddle an access range 173 * boundary. 174 */ 175 struct blk_independent_access_range { 176 struct kobject kobj; 177 struct request_queue *queue; 178 sector_t sector; 179 sector_t nr_sectors; 180 }; 181 182 struct blk_independent_access_ranges { 183 struct kobject kobj; 184 bool sysfs_registered; 185 unsigned int nr_ia_ranges; 186 struct blk_independent_access_range ia_range[]; 187 }; 188 189 struct request_queue { 190 struct request *last_merge; 191 struct elevator_queue *elevator; 192 193 struct percpu_ref q_usage_counter; 194 195 struct blk_queue_stats *stats; 196 struct rq_qos *rq_qos; 197 198 const struct blk_mq_ops *mq_ops; 199 200 /* sw queues */ 201 struct blk_mq_ctx __percpu *queue_ctx; 202 203 unsigned int queue_depth; 204 205 /* hw dispatch queues */ 206 struct blk_mq_hw_ctx **queue_hw_ctx; 207 unsigned int nr_hw_queues; 208 209 /* 210 * The queue owner gets to use this for whatever they like. 211 * ll_rw_blk doesn't touch it. 212 */ 213 void *queuedata; 214 215 /* 216 * various queue flags, see QUEUE_* below 217 */ 218 unsigned long queue_flags; 219 /* 220 * Number of contexts that have called blk_set_pm_only(). If this 221 * counter is above zero then only RQF_PM requests are processed. 222 */ 223 atomic_t pm_only; 224 225 /* 226 * ida allocated id for this queue. Used to index queues from 227 * ioctx. 228 */ 229 int id; 230 231 spinlock_t queue_lock; 232 233 struct gendisk *disk; 234 235 /* 236 * queue kobject 237 */ 238 struct kobject kobj; 239 240 /* 241 * mq queue kobject 242 */ 243 struct kobject *mq_kobj; 244 245 #ifdef CONFIG_BLK_DEV_INTEGRITY 246 struct blk_integrity integrity; 247 #endif /* CONFIG_BLK_DEV_INTEGRITY */ 248 249 #ifdef CONFIG_PM 250 struct device *dev; 251 enum rpm_status rpm_status; 252 #endif 253 254 /* 255 * queue settings 256 */ 257 unsigned long nr_requests; /* Max # of requests */ 258 259 unsigned int dma_pad_mask; 260 unsigned int dma_alignment; 261 262 #ifdef CONFIG_BLK_INLINE_ENCRYPTION 263 struct blk_crypto_profile *crypto_profile; 264 #endif 265 266 unsigned int rq_timeout; 267 int poll_nsec; 268 269 struct blk_stat_callback *poll_cb; 270 struct blk_rq_stat *poll_stat; 271 272 struct timer_list timeout; 273 struct work_struct timeout_work; 274 275 atomic_t nr_active_requests_shared_tags; 276 277 struct blk_mq_tags *sched_shared_tags; 278 279 struct list_head icq_list; 280 #ifdef CONFIG_BLK_CGROUP 281 DECLARE_BITMAP (blkcg_pols, BLKCG_MAX_POLS); 282 struct blkcg_gq *root_blkg; 283 struct list_head blkg_list; 284 #endif 285 286 struct queue_limits limits; 287 288 unsigned int required_elevator_features; 289 290 #ifdef CONFIG_BLK_DEV_ZONED 291 /* 292 * Zoned block device information for request dispatch control. 293 * nr_zones is the total number of zones of the device. This is always 294 * 0 for regular block devices. conv_zones_bitmap is a bitmap of nr_zones 295 * bits which indicates if a zone is conventional (bit set) or 296 * sequential (bit clear). seq_zones_wlock is a bitmap of nr_zones 297 * bits which indicates if a zone is write locked, that is, if a write 298 * request targeting the zone was dispatched. All three fields are 299 * initialized by the low level device driver (e.g. scsi/sd.c). 300 * Stacking drivers (device mappers) may or may not initialize 301 * these fields. 302 * 303 * Reads of this information must be protected with blk_queue_enter() / 304 * blk_queue_exit(). Modifying this information is only allowed while 305 * no requests are being processed. See also blk_mq_freeze_queue() and 306 * blk_mq_unfreeze_queue(). 307 */ 308 unsigned int nr_zones; 309 unsigned long *conv_zones_bitmap; 310 unsigned long *seq_zones_wlock; 311 unsigned int max_open_zones; 312 unsigned int max_active_zones; 313 #endif /* CONFIG_BLK_DEV_ZONED */ 314 315 int node; 316 struct mutex debugfs_mutex; 317 #ifdef CONFIG_BLK_DEV_IO_TRACE 318 struct blk_trace __rcu *blk_trace; 319 #endif 320 /* 321 * for flush operations 322 */ 323 struct blk_flush_queue *fq; 324 325 struct list_head requeue_list; 326 spinlock_t requeue_lock; 327 struct delayed_work requeue_work; 328 329 struct mutex sysfs_lock; 330 struct mutex sysfs_dir_lock; 331 332 /* 333 * for reusing dead hctx instance in case of updating 334 * nr_hw_queues 335 */ 336 struct list_head unused_hctx_list; 337 spinlock_t unused_hctx_lock; 338 339 int mq_freeze_depth; 340 341 #ifdef CONFIG_BLK_DEV_THROTTLING 342 /* Throttle data */ 343 struct throtl_data *td; 344 #endif 345 struct rcu_head rcu_head; 346 wait_queue_head_t mq_freeze_wq; 347 /* 348 * Protect concurrent access to q_usage_counter by 349 * percpu_ref_kill() and percpu_ref_reinit(). 350 */ 351 struct mutex mq_freeze_lock; 352 353 int quiesce_depth; 354 355 struct blk_mq_tag_set *tag_set; 356 struct list_head tag_set_list; 357 struct bio_set bio_split; 358 359 struct dentry *debugfs_dir; 360 361 #ifdef CONFIG_BLK_DEBUG_FS 362 struct dentry *sched_debugfs_dir; 363 struct dentry *rqos_debugfs_dir; 364 #endif 365 366 bool mq_sysfs_init_done; 367 368 #define BLK_MAX_WRITE_HINTS 5 369 u64 write_hints[BLK_MAX_WRITE_HINTS]; 370 371 /* 372 * Independent sector access ranges. This is always NULL for 373 * devices that do not have multiple independent access ranges. 374 */ 375 struct blk_independent_access_ranges *ia_ranges; 376 377 /** 378 * @srcu: Sleepable RCU. Use as lock when type of the request queue 379 * is blocking (BLK_MQ_F_BLOCKING). Must be the last member 380 */ 381 struct srcu_struct srcu[]; 382 }; 383 384 /* Keep blk_queue_flag_name[] in sync with the definitions below */ 385 #define QUEUE_FLAG_STOPPED 0 /* queue is stopped */ 386 #define QUEUE_FLAG_DYING 1 /* queue being torn down */ 387 #define QUEUE_FLAG_HAS_SRCU 2 /* SRCU is allocated */ 388 #define QUEUE_FLAG_NOMERGES 3 /* disable merge attempts */ 389 #define QUEUE_FLAG_SAME_COMP 4 /* complete on same CPU-group */ 390 #define QUEUE_FLAG_FAIL_IO 5 /* fake timeout */ 391 #define QUEUE_FLAG_NONROT 6 /* non-rotational device (SSD) */ 392 #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */ 393 #define QUEUE_FLAG_IO_STAT 7 /* do disk/partitions IO accounting */ 394 #define QUEUE_FLAG_DISCARD 8 /* supports DISCARD */ 395 #define QUEUE_FLAG_NOXMERGES 9 /* No extended merges */ 396 #define QUEUE_FLAG_ADD_RANDOM 10 /* Contributes to random pool */ 397 #define QUEUE_FLAG_SECERASE 11 /* supports secure erase */ 398 #define QUEUE_FLAG_SAME_FORCE 12 /* force complete on same CPU */ 399 #define QUEUE_FLAG_DEAD 13 /* queue tear-down finished */ 400 #define QUEUE_FLAG_INIT_DONE 14 /* queue is initialized */ 401 #define QUEUE_FLAG_STABLE_WRITES 15 /* don't modify blks until WB is done */ 402 #define QUEUE_FLAG_POLL 16 /* IO polling enabled if set */ 403 #define QUEUE_FLAG_WC 17 /* Write back caching */ 404 #define QUEUE_FLAG_FUA 18 /* device supports FUA writes */ 405 #define QUEUE_FLAG_DAX 19 /* device supports DAX */ 406 #define QUEUE_FLAG_STATS 20 /* track IO start and completion times */ 407 #define QUEUE_FLAG_REGISTERED 22 /* queue has been registered to a disk */ 408 #define QUEUE_FLAG_QUIESCED 24 /* queue has been quiesced */ 409 #define QUEUE_FLAG_PCI_P2PDMA 25 /* device supports PCI p2p requests */ 410 #define QUEUE_FLAG_ZONE_RESETALL 26 /* supports Zone Reset All */ 411 #define QUEUE_FLAG_RQ_ALLOC_TIME 27 /* record rq->alloc_time_ns */ 412 #define QUEUE_FLAG_HCTX_ACTIVE 28 /* at least one blk-mq hctx is active */ 413 #define QUEUE_FLAG_NOWAIT 29 /* device supports NOWAIT */ 414 415 #define QUEUE_FLAG_MQ_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \ 416 (1 << QUEUE_FLAG_SAME_COMP) | \ 417 (1 << QUEUE_FLAG_NOWAIT)) 418 419 void blk_queue_flag_set(unsigned int flag, struct request_queue *q); 420 void blk_queue_flag_clear(unsigned int flag, struct request_queue *q); 421 bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q); 422 423 #define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags) 424 #define blk_queue_dying(q) test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags) 425 #define blk_queue_has_srcu(q) test_bit(QUEUE_FLAG_HAS_SRCU, &(q)->queue_flags) 426 #define blk_queue_dead(q) test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags) 427 #define blk_queue_init_done(q) test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags) 428 #define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags) 429 #define blk_queue_noxmerges(q) \ 430 test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags) 431 #define blk_queue_nonrot(q) test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags) 432 #define blk_queue_stable_writes(q) \ 433 test_bit(QUEUE_FLAG_STABLE_WRITES, &(q)->queue_flags) 434 #define blk_queue_io_stat(q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags) 435 #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags) 436 #define blk_queue_discard(q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags) 437 #define blk_queue_zone_resetall(q) \ 438 test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags) 439 #define blk_queue_secure_erase(q) \ 440 (test_bit(QUEUE_FLAG_SECERASE, &(q)->queue_flags)) 441 #define blk_queue_dax(q) test_bit(QUEUE_FLAG_DAX, &(q)->queue_flags) 442 #define blk_queue_pci_p2pdma(q) \ 443 test_bit(QUEUE_FLAG_PCI_P2PDMA, &(q)->queue_flags) 444 #ifdef CONFIG_BLK_RQ_ALLOC_TIME 445 #define blk_queue_rq_alloc_time(q) \ 446 test_bit(QUEUE_FLAG_RQ_ALLOC_TIME, &(q)->queue_flags) 447 #else 448 #define blk_queue_rq_alloc_time(q) false 449 #endif 450 451 #define blk_noretry_request(rq) \ 452 ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \ 453 REQ_FAILFAST_DRIVER)) 454 #define blk_queue_quiesced(q) test_bit(QUEUE_FLAG_QUIESCED, &(q)->queue_flags) 455 #define blk_queue_pm_only(q) atomic_read(&(q)->pm_only) 456 #define blk_queue_fua(q) test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags) 457 #define blk_queue_registered(q) test_bit(QUEUE_FLAG_REGISTERED, &(q)->queue_flags) 458 #define blk_queue_nowait(q) test_bit(QUEUE_FLAG_NOWAIT, &(q)->queue_flags) 459 460 extern void blk_set_pm_only(struct request_queue *q); 461 extern void blk_clear_pm_only(struct request_queue *q); 462 463 #define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist) 464 465 #define dma_map_bvec(dev, bv, dir, attrs) \ 466 dma_map_page_attrs(dev, (bv)->bv_page, (bv)->bv_offset, (bv)->bv_len, \ 467 (dir), (attrs)) 468 469 static inline bool queue_is_mq(struct request_queue *q) 470 { 471 return q->mq_ops; 472 } 473 474 #ifdef CONFIG_PM 475 static inline enum rpm_status queue_rpm_status(struct request_queue *q) 476 { 477 return q->rpm_status; 478 } 479 #else 480 static inline enum rpm_status queue_rpm_status(struct request_queue *q) 481 { 482 return RPM_ACTIVE; 483 } 484 #endif 485 486 static inline enum blk_zoned_model 487 blk_queue_zoned_model(struct request_queue *q) 488 { 489 if (IS_ENABLED(CONFIG_BLK_DEV_ZONED)) 490 return q->limits.zoned; 491 return BLK_ZONED_NONE; 492 } 493 494 static inline bool blk_queue_is_zoned(struct request_queue *q) 495 { 496 switch (blk_queue_zoned_model(q)) { 497 case BLK_ZONED_HA: 498 case BLK_ZONED_HM: 499 return true; 500 default: 501 return false; 502 } 503 } 504 505 static inline sector_t blk_queue_zone_sectors(struct request_queue *q) 506 { 507 return blk_queue_is_zoned(q) ? q->limits.chunk_sectors : 0; 508 } 509 510 #ifdef CONFIG_BLK_DEV_ZONED 511 static inline unsigned int blk_queue_nr_zones(struct request_queue *q) 512 { 513 return blk_queue_is_zoned(q) ? q->nr_zones : 0; 514 } 515 516 static inline unsigned int blk_queue_zone_no(struct request_queue *q, 517 sector_t sector) 518 { 519 if (!blk_queue_is_zoned(q)) 520 return 0; 521 return sector >> ilog2(q->limits.chunk_sectors); 522 } 523 524 static inline bool blk_queue_zone_is_seq(struct request_queue *q, 525 sector_t sector) 526 { 527 if (!blk_queue_is_zoned(q)) 528 return false; 529 if (!q->conv_zones_bitmap) 530 return true; 531 return !test_bit(blk_queue_zone_no(q, sector), q->conv_zones_bitmap); 532 } 533 534 static inline void blk_queue_max_open_zones(struct request_queue *q, 535 unsigned int max_open_zones) 536 { 537 q->max_open_zones = max_open_zones; 538 } 539 540 static inline unsigned int queue_max_open_zones(const struct request_queue *q) 541 { 542 return q->max_open_zones; 543 } 544 545 static inline void blk_queue_max_active_zones(struct request_queue *q, 546 unsigned int max_active_zones) 547 { 548 q->max_active_zones = max_active_zones; 549 } 550 551 static inline unsigned int queue_max_active_zones(const struct request_queue *q) 552 { 553 return q->max_active_zones; 554 } 555 #else /* CONFIG_BLK_DEV_ZONED */ 556 static inline unsigned int blk_queue_nr_zones(struct request_queue *q) 557 { 558 return 0; 559 } 560 static inline bool blk_queue_zone_is_seq(struct request_queue *q, 561 sector_t sector) 562 { 563 return false; 564 } 565 static inline unsigned int blk_queue_zone_no(struct request_queue *q, 566 sector_t sector) 567 { 568 return 0; 569 } 570 static inline unsigned int queue_max_open_zones(const struct request_queue *q) 571 { 572 return 0; 573 } 574 static inline unsigned int queue_max_active_zones(const struct request_queue *q) 575 { 576 return 0; 577 } 578 #endif /* CONFIG_BLK_DEV_ZONED */ 579 580 static inline unsigned int blk_queue_depth(struct request_queue *q) 581 { 582 if (q->queue_depth) 583 return q->queue_depth; 584 585 return q->nr_requests; 586 } 587 588 /* 589 * default timeout for SG_IO if none specified 590 */ 591 #define BLK_DEFAULT_SG_TIMEOUT (60 * HZ) 592 #define BLK_MIN_SG_TIMEOUT (7 * HZ) 593 594 /* This should not be used directly - use rq_for_each_segment */ 595 #define for_each_bio(_bio) \ 596 for (; _bio; _bio = _bio->bi_next) 597 598 599 extern int blk_register_queue(struct gendisk *disk); 600 extern void blk_unregister_queue(struct gendisk *disk); 601 void submit_bio_noacct(struct bio *bio); 602 603 extern int blk_lld_busy(struct request_queue *q); 604 extern void blk_queue_split(struct bio **); 605 extern int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags); 606 extern void blk_queue_exit(struct request_queue *q); 607 extern void blk_sync_queue(struct request_queue *q); 608 609 /* Helper to convert REQ_OP_XXX to its string format XXX */ 610 extern const char *blk_op_str(unsigned int op); 611 612 int blk_status_to_errno(blk_status_t status); 613 blk_status_t errno_to_blk_status(int errno); 614 615 /* only poll the hardware once, don't continue until a completion was found */ 616 #define BLK_POLL_ONESHOT (1 << 0) 617 /* do not sleep to wait for the expected completion time */ 618 #define BLK_POLL_NOSLEEP (1 << 1) 619 int bio_poll(struct bio *bio, struct io_comp_batch *iob, unsigned int flags); 620 int iocb_bio_iopoll(struct kiocb *kiocb, struct io_comp_batch *iob, 621 unsigned int flags); 622 623 static inline struct request_queue *bdev_get_queue(struct block_device *bdev) 624 { 625 return bdev->bd_queue; /* this is never NULL */ 626 } 627 628 #ifdef CONFIG_BLK_DEV_ZONED 629 630 /* Helper to convert BLK_ZONE_ZONE_XXX to its string format XXX */ 631 const char *blk_zone_cond_str(enum blk_zone_cond zone_cond); 632 633 static inline unsigned int bio_zone_no(struct bio *bio) 634 { 635 return blk_queue_zone_no(bdev_get_queue(bio->bi_bdev), 636 bio->bi_iter.bi_sector); 637 } 638 639 static inline unsigned int bio_zone_is_seq(struct bio *bio) 640 { 641 return blk_queue_zone_is_seq(bdev_get_queue(bio->bi_bdev), 642 bio->bi_iter.bi_sector); 643 } 644 #endif /* CONFIG_BLK_DEV_ZONED */ 645 646 static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q, 647 int op) 648 { 649 if (unlikely(op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE)) 650 return min(q->limits.max_discard_sectors, 651 UINT_MAX >> SECTOR_SHIFT); 652 653 if (unlikely(op == REQ_OP_WRITE_ZEROES)) 654 return q->limits.max_write_zeroes_sectors; 655 656 return q->limits.max_sectors; 657 } 658 659 /* 660 * Return maximum size of a request at given offset. Only valid for 661 * file system requests. 662 */ 663 static inline unsigned int blk_max_size_offset(struct request_queue *q, 664 sector_t offset, 665 unsigned int chunk_sectors) 666 { 667 if (!chunk_sectors) { 668 if (q->limits.chunk_sectors) 669 chunk_sectors = q->limits.chunk_sectors; 670 else 671 return q->limits.max_sectors; 672 } 673 674 if (likely(is_power_of_2(chunk_sectors))) 675 chunk_sectors -= offset & (chunk_sectors - 1); 676 else 677 chunk_sectors -= sector_div(offset, chunk_sectors); 678 679 return min(q->limits.max_sectors, chunk_sectors); 680 } 681 682 /* 683 * Access functions for manipulating queue properties 684 */ 685 extern void blk_cleanup_queue(struct request_queue *); 686 void blk_queue_bounce_limit(struct request_queue *q, enum blk_bounce limit); 687 extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int); 688 extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int); 689 extern void blk_queue_max_segments(struct request_queue *, unsigned short); 690 extern void blk_queue_max_discard_segments(struct request_queue *, 691 unsigned short); 692 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int); 693 extern void blk_queue_max_discard_sectors(struct request_queue *q, 694 unsigned int max_discard_sectors); 695 extern void blk_queue_max_write_zeroes_sectors(struct request_queue *q, 696 unsigned int max_write_same_sectors); 697 extern void blk_queue_logical_block_size(struct request_queue *, unsigned int); 698 extern void blk_queue_max_zone_append_sectors(struct request_queue *q, 699 unsigned int max_zone_append_sectors); 700 extern void blk_queue_physical_block_size(struct request_queue *, unsigned int); 701 void blk_queue_zone_write_granularity(struct request_queue *q, 702 unsigned int size); 703 extern void blk_queue_alignment_offset(struct request_queue *q, 704 unsigned int alignment); 705 void disk_update_readahead(struct gendisk *disk); 706 extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min); 707 extern void blk_queue_io_min(struct request_queue *q, unsigned int min); 708 extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt); 709 extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt); 710 extern void blk_set_queue_depth(struct request_queue *q, unsigned int depth); 711 extern void blk_set_default_limits(struct queue_limits *lim); 712 extern void blk_set_stacking_limits(struct queue_limits *lim); 713 extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, 714 sector_t offset); 715 extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev, 716 sector_t offset); 717 extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int); 718 extern void blk_queue_segment_boundary(struct request_queue *, unsigned long); 719 extern void blk_queue_virt_boundary(struct request_queue *, unsigned long); 720 extern void blk_queue_dma_alignment(struct request_queue *, int); 721 extern void blk_queue_update_dma_alignment(struct request_queue *, int); 722 extern void blk_queue_rq_timeout(struct request_queue *, unsigned int); 723 extern void blk_queue_write_cache(struct request_queue *q, bool enabled, bool fua); 724 725 struct blk_independent_access_ranges * 726 disk_alloc_independent_access_ranges(struct gendisk *disk, int nr_ia_ranges); 727 void disk_set_independent_access_ranges(struct gendisk *disk, 728 struct blk_independent_access_ranges *iars); 729 730 /* 731 * Elevator features for blk_queue_required_elevator_features: 732 */ 733 /* Supports zoned block devices sequential write constraint */ 734 #define ELEVATOR_F_ZBD_SEQ_WRITE (1U << 0) 735 /* Supports scheduling on multiple hardware queues */ 736 #define ELEVATOR_F_MQ_AWARE (1U << 1) 737 738 extern void blk_queue_required_elevator_features(struct request_queue *q, 739 unsigned int features); 740 extern bool blk_queue_can_use_dma_map_merging(struct request_queue *q, 741 struct device *dev); 742 743 bool __must_check blk_get_queue(struct request_queue *); 744 extern void blk_put_queue(struct request_queue *); 745 extern void blk_set_queue_dying(struct request_queue *); 746 747 #ifdef CONFIG_BLOCK 748 /* 749 * blk_plug permits building a queue of related requests by holding the I/O 750 * fragments for a short period. This allows merging of sequential requests 751 * into single larger request. As the requests are moved from a per-task list to 752 * the device's request_queue in a batch, this results in improved scalability 753 * as the lock contention for request_queue lock is reduced. 754 * 755 * It is ok not to disable preemption when adding the request to the plug list 756 * or when attempting a merge. For details, please see schedule() where 757 * blk_flush_plug() is called. 758 */ 759 struct blk_plug { 760 struct request *mq_list; /* blk-mq requests */ 761 762 /* if ios_left is > 1, we can batch tag/rq allocations */ 763 struct request *cached_rq; 764 unsigned short nr_ios; 765 766 unsigned short rq_count; 767 768 bool multiple_queues; 769 bool has_elevator; 770 bool nowait; 771 772 struct list_head cb_list; /* md requires an unplug callback */ 773 }; 774 775 struct blk_plug_cb; 776 typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool); 777 struct blk_plug_cb { 778 struct list_head list; 779 blk_plug_cb_fn callback; 780 void *data; 781 }; 782 extern struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug, 783 void *data, int size); 784 extern void blk_start_plug(struct blk_plug *); 785 extern void blk_start_plug_nr_ios(struct blk_plug *, unsigned short); 786 extern void blk_finish_plug(struct blk_plug *); 787 788 void blk_flush_plug(struct blk_plug *plug, bool from_schedule); 789 790 static inline bool blk_needs_flush_plug(struct task_struct *tsk) 791 { 792 struct blk_plug *plug = tsk->plug; 793 794 return plug && 795 (plug->mq_list || !list_empty(&plug->cb_list)); 796 } 797 798 int blkdev_issue_flush(struct block_device *bdev); 799 long nr_blockdev_pages(void); 800 #else /* CONFIG_BLOCK */ 801 struct blk_plug { 802 }; 803 804 static inline void blk_start_plug_nr_ios(struct blk_plug *plug, 805 unsigned short nr_ios) 806 { 807 } 808 809 static inline void blk_start_plug(struct blk_plug *plug) 810 { 811 } 812 813 static inline void blk_finish_plug(struct blk_plug *plug) 814 { 815 } 816 817 static inline void blk_flush_plug(struct blk_plug *plug, bool async) 818 { 819 } 820 821 static inline bool blk_needs_flush_plug(struct task_struct *tsk) 822 { 823 return false; 824 } 825 826 static inline int blkdev_issue_flush(struct block_device *bdev) 827 { 828 return 0; 829 } 830 831 static inline long nr_blockdev_pages(void) 832 { 833 return 0; 834 } 835 #endif /* CONFIG_BLOCK */ 836 837 extern void blk_io_schedule(void); 838 839 #define BLKDEV_DISCARD_SECURE (1 << 0) /* issue a secure erase */ 840 841 extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector, 842 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags); 843 extern int __blkdev_issue_discard(struct block_device *bdev, sector_t sector, 844 sector_t nr_sects, gfp_t gfp_mask, int flags, 845 struct bio **biop); 846 847 #define BLKDEV_ZERO_NOUNMAP (1 << 0) /* do not free blocks */ 848 #define BLKDEV_ZERO_NOFALLBACK (1 << 1) /* don't write explicit zeroes */ 849 850 extern int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, 851 sector_t nr_sects, gfp_t gfp_mask, struct bio **biop, 852 unsigned flags); 853 extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, 854 sector_t nr_sects, gfp_t gfp_mask, unsigned flags); 855 856 static inline int sb_issue_discard(struct super_block *sb, sector_t block, 857 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags) 858 { 859 return blkdev_issue_discard(sb->s_bdev, 860 block << (sb->s_blocksize_bits - 861 SECTOR_SHIFT), 862 nr_blocks << (sb->s_blocksize_bits - 863 SECTOR_SHIFT), 864 gfp_mask, flags); 865 } 866 static inline int sb_issue_zeroout(struct super_block *sb, sector_t block, 867 sector_t nr_blocks, gfp_t gfp_mask) 868 { 869 return blkdev_issue_zeroout(sb->s_bdev, 870 block << (sb->s_blocksize_bits - 871 SECTOR_SHIFT), 872 nr_blocks << (sb->s_blocksize_bits - 873 SECTOR_SHIFT), 874 gfp_mask, 0); 875 } 876 877 static inline bool bdev_is_partition(struct block_device *bdev) 878 { 879 return bdev->bd_partno; 880 } 881 882 enum blk_default_limits { 883 BLK_MAX_SEGMENTS = 128, 884 BLK_SAFE_MAX_SECTORS = 255, 885 BLK_DEF_MAX_SECTORS = 2560, 886 BLK_MAX_SEGMENT_SIZE = 65536, 887 BLK_SEG_BOUNDARY_MASK = 0xFFFFFFFFUL, 888 }; 889 890 static inline unsigned long queue_segment_boundary(const struct request_queue *q) 891 { 892 return q->limits.seg_boundary_mask; 893 } 894 895 static inline unsigned long queue_virt_boundary(const struct request_queue *q) 896 { 897 return q->limits.virt_boundary_mask; 898 } 899 900 static inline unsigned int queue_max_sectors(const struct request_queue *q) 901 { 902 return q->limits.max_sectors; 903 } 904 905 static inline unsigned int queue_max_bytes(struct request_queue *q) 906 { 907 return min_t(unsigned int, queue_max_sectors(q), INT_MAX >> 9) << 9; 908 } 909 910 static inline unsigned int queue_max_hw_sectors(const struct request_queue *q) 911 { 912 return q->limits.max_hw_sectors; 913 } 914 915 static inline unsigned short queue_max_segments(const struct request_queue *q) 916 { 917 return q->limits.max_segments; 918 } 919 920 static inline unsigned short queue_max_discard_segments(const struct request_queue *q) 921 { 922 return q->limits.max_discard_segments; 923 } 924 925 static inline unsigned int queue_max_segment_size(const struct request_queue *q) 926 { 927 return q->limits.max_segment_size; 928 } 929 930 static inline unsigned int queue_max_zone_append_sectors(const struct request_queue *q) 931 { 932 933 const struct queue_limits *l = &q->limits; 934 935 return min(l->max_zone_append_sectors, l->max_sectors); 936 } 937 938 static inline unsigned queue_logical_block_size(const struct request_queue *q) 939 { 940 int retval = 512; 941 942 if (q && q->limits.logical_block_size) 943 retval = q->limits.logical_block_size; 944 945 return retval; 946 } 947 948 static inline unsigned int bdev_logical_block_size(struct block_device *bdev) 949 { 950 return queue_logical_block_size(bdev_get_queue(bdev)); 951 } 952 953 static inline unsigned int queue_physical_block_size(const struct request_queue *q) 954 { 955 return q->limits.physical_block_size; 956 } 957 958 static inline unsigned int bdev_physical_block_size(struct block_device *bdev) 959 { 960 return queue_physical_block_size(bdev_get_queue(bdev)); 961 } 962 963 static inline unsigned int queue_io_min(const struct request_queue *q) 964 { 965 return q->limits.io_min; 966 } 967 968 static inline int bdev_io_min(struct block_device *bdev) 969 { 970 return queue_io_min(bdev_get_queue(bdev)); 971 } 972 973 static inline unsigned int queue_io_opt(const struct request_queue *q) 974 { 975 return q->limits.io_opt; 976 } 977 978 static inline int bdev_io_opt(struct block_device *bdev) 979 { 980 return queue_io_opt(bdev_get_queue(bdev)); 981 } 982 983 static inline unsigned int 984 queue_zone_write_granularity(const struct request_queue *q) 985 { 986 return q->limits.zone_write_granularity; 987 } 988 989 static inline unsigned int 990 bdev_zone_write_granularity(struct block_device *bdev) 991 { 992 return queue_zone_write_granularity(bdev_get_queue(bdev)); 993 } 994 995 static inline int queue_alignment_offset(const struct request_queue *q) 996 { 997 if (q->limits.misaligned) 998 return -1; 999 1000 return q->limits.alignment_offset; 1001 } 1002 1003 static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector) 1004 { 1005 unsigned int granularity = max(lim->physical_block_size, lim->io_min); 1006 unsigned int alignment = sector_div(sector, granularity >> SECTOR_SHIFT) 1007 << SECTOR_SHIFT; 1008 1009 return (granularity + lim->alignment_offset - alignment) % granularity; 1010 } 1011 1012 static inline int bdev_alignment_offset(struct block_device *bdev) 1013 { 1014 struct request_queue *q = bdev_get_queue(bdev); 1015 1016 if (q->limits.misaligned) 1017 return -1; 1018 if (bdev_is_partition(bdev)) 1019 return queue_limit_alignment_offset(&q->limits, 1020 bdev->bd_start_sect); 1021 return q->limits.alignment_offset; 1022 } 1023 1024 static inline int queue_discard_alignment(const struct request_queue *q) 1025 { 1026 if (q->limits.discard_misaligned) 1027 return -1; 1028 1029 return q->limits.discard_alignment; 1030 } 1031 1032 static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector) 1033 { 1034 unsigned int alignment, granularity, offset; 1035 1036 if (!lim->max_discard_sectors) 1037 return 0; 1038 1039 /* Why are these in bytes, not sectors? */ 1040 alignment = lim->discard_alignment >> SECTOR_SHIFT; 1041 granularity = lim->discard_granularity >> SECTOR_SHIFT; 1042 if (!granularity) 1043 return 0; 1044 1045 /* Offset of the partition start in 'granularity' sectors */ 1046 offset = sector_div(sector, granularity); 1047 1048 /* And why do we do this modulus *again* in blkdev_issue_discard()? */ 1049 offset = (granularity + alignment - offset) % granularity; 1050 1051 /* Turn it back into bytes, gaah */ 1052 return offset << SECTOR_SHIFT; 1053 } 1054 1055 static inline int bdev_discard_alignment(struct block_device *bdev) 1056 { 1057 struct request_queue *q = bdev_get_queue(bdev); 1058 1059 if (bdev_is_partition(bdev)) 1060 return queue_limit_discard_alignment(&q->limits, 1061 bdev->bd_start_sect); 1062 return q->limits.discard_alignment; 1063 } 1064 1065 static inline unsigned int bdev_write_zeroes_sectors(struct block_device *bdev) 1066 { 1067 struct request_queue *q = bdev_get_queue(bdev); 1068 1069 if (q) 1070 return q->limits.max_write_zeroes_sectors; 1071 1072 return 0; 1073 } 1074 1075 static inline enum blk_zoned_model bdev_zoned_model(struct block_device *bdev) 1076 { 1077 struct request_queue *q = bdev_get_queue(bdev); 1078 1079 if (q) 1080 return blk_queue_zoned_model(q); 1081 1082 return BLK_ZONED_NONE; 1083 } 1084 1085 static inline bool bdev_is_zoned(struct block_device *bdev) 1086 { 1087 struct request_queue *q = bdev_get_queue(bdev); 1088 1089 if (q) 1090 return blk_queue_is_zoned(q); 1091 1092 return false; 1093 } 1094 1095 static inline sector_t bdev_zone_sectors(struct block_device *bdev) 1096 { 1097 struct request_queue *q = bdev_get_queue(bdev); 1098 1099 if (q) 1100 return blk_queue_zone_sectors(q); 1101 return 0; 1102 } 1103 1104 static inline unsigned int bdev_max_open_zones(struct block_device *bdev) 1105 { 1106 struct request_queue *q = bdev_get_queue(bdev); 1107 1108 if (q) 1109 return queue_max_open_zones(q); 1110 return 0; 1111 } 1112 1113 static inline unsigned int bdev_max_active_zones(struct block_device *bdev) 1114 { 1115 struct request_queue *q = bdev_get_queue(bdev); 1116 1117 if (q) 1118 return queue_max_active_zones(q); 1119 return 0; 1120 } 1121 1122 static inline int queue_dma_alignment(const struct request_queue *q) 1123 { 1124 return q ? q->dma_alignment : 511; 1125 } 1126 1127 static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr, 1128 unsigned int len) 1129 { 1130 unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask; 1131 return !(addr & alignment) && !(len & alignment); 1132 } 1133 1134 /* assumes size > 256 */ 1135 static inline unsigned int blksize_bits(unsigned int size) 1136 { 1137 unsigned int bits = 8; 1138 do { 1139 bits++; 1140 size >>= 1; 1141 } while (size > 256); 1142 return bits; 1143 } 1144 1145 static inline unsigned int block_size(struct block_device *bdev) 1146 { 1147 return 1 << bdev->bd_inode->i_blkbits; 1148 } 1149 1150 int kblockd_schedule_work(struct work_struct *work); 1151 int kblockd_mod_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay); 1152 1153 #define MODULE_ALIAS_BLOCKDEV(major,minor) \ 1154 MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor)) 1155 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \ 1156 MODULE_ALIAS("block-major-" __stringify(major) "-*") 1157 1158 #ifdef CONFIG_BLK_INLINE_ENCRYPTION 1159 1160 bool blk_crypto_register(struct blk_crypto_profile *profile, 1161 struct request_queue *q); 1162 1163 #else /* CONFIG_BLK_INLINE_ENCRYPTION */ 1164 1165 static inline bool blk_crypto_register(struct blk_crypto_profile *profile, 1166 struct request_queue *q) 1167 { 1168 return true; 1169 } 1170 1171 #endif /* CONFIG_BLK_INLINE_ENCRYPTION */ 1172 1173 enum blk_unique_id { 1174 /* these match the Designator Types specified in SPC */ 1175 BLK_UID_T10 = 1, 1176 BLK_UID_EUI64 = 2, 1177 BLK_UID_NAA = 3, 1178 }; 1179 1180 #define NFL4_UFLG_MASK 0x0000003F 1181 1182 struct block_device_operations { 1183 void (*submit_bio)(struct bio *bio); 1184 int (*open) (struct block_device *, fmode_t); 1185 void (*release) (struct gendisk *, fmode_t); 1186 int (*rw_page)(struct block_device *, sector_t, struct page *, unsigned int); 1187 int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); 1188 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); 1189 unsigned int (*check_events) (struct gendisk *disk, 1190 unsigned int clearing); 1191 void (*unlock_native_capacity) (struct gendisk *); 1192 int (*getgeo)(struct block_device *, struct hd_geometry *); 1193 int (*set_read_only)(struct block_device *bdev, bool ro); 1194 /* this callback is with swap_lock and sometimes page table lock held */ 1195 void (*swap_slot_free_notify) (struct block_device *, unsigned long); 1196 int (*report_zones)(struct gendisk *, sector_t sector, 1197 unsigned int nr_zones, report_zones_cb cb, void *data); 1198 char *(*devnode)(struct gendisk *disk, umode_t *mode); 1199 /* returns the length of the identifier or a negative errno: */ 1200 int (*get_unique_id)(struct gendisk *disk, u8 id[16], 1201 enum blk_unique_id id_type); 1202 struct module *owner; 1203 const struct pr_ops *pr_ops; 1204 1205 /* 1206 * Special callback for probing GPT entry at a given sector. 1207 * Needed by Android devices, used by GPT scanner and MMC blk 1208 * driver. 1209 */ 1210 int (*alternative_gpt_sector)(struct gendisk *disk, sector_t *sector); 1211 }; 1212 1213 #ifdef CONFIG_COMPAT 1214 extern int blkdev_compat_ptr_ioctl(struct block_device *, fmode_t, 1215 unsigned int, unsigned long); 1216 #else 1217 #define blkdev_compat_ptr_ioctl NULL 1218 #endif 1219 1220 extern int bdev_read_page(struct block_device *, sector_t, struct page *); 1221 extern int bdev_write_page(struct block_device *, sector_t, struct page *, 1222 struct writeback_control *); 1223 1224 static inline void blk_wake_io_task(struct task_struct *waiter) 1225 { 1226 /* 1227 * If we're polling, the task itself is doing the completions. For 1228 * that case, we don't need to signal a wakeup, it's enough to just 1229 * mark us as RUNNING. 1230 */ 1231 if (waiter == current) 1232 __set_current_state(TASK_RUNNING); 1233 else 1234 wake_up_process(waiter); 1235 } 1236 1237 unsigned long disk_start_io_acct(struct gendisk *disk, unsigned int sectors, 1238 unsigned int op); 1239 void disk_end_io_acct(struct gendisk *disk, unsigned int op, 1240 unsigned long start_time); 1241 1242 unsigned long bio_start_io_acct(struct bio *bio); 1243 void bio_end_io_acct_remapped(struct bio *bio, unsigned long start_time, 1244 struct block_device *orig_bdev); 1245 1246 /** 1247 * bio_end_io_acct - end I/O accounting for bio based drivers 1248 * @bio: bio to end account for 1249 * @start: start time returned by bio_start_io_acct() 1250 */ 1251 static inline void bio_end_io_acct(struct bio *bio, unsigned long start_time) 1252 { 1253 return bio_end_io_acct_remapped(bio, start_time, bio->bi_bdev); 1254 } 1255 1256 int bdev_read_only(struct block_device *bdev); 1257 int set_blocksize(struct block_device *bdev, int size); 1258 1259 const char *bdevname(struct block_device *bdev, char *buffer); 1260 int lookup_bdev(const char *pathname, dev_t *dev); 1261 1262 void blkdev_show(struct seq_file *seqf, off_t offset); 1263 1264 #define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */ 1265 #define BDEVT_SIZE 10 /* Largest string for MAJ:MIN for blkdev */ 1266 #ifdef CONFIG_BLOCK 1267 #define BLKDEV_MAJOR_MAX 512 1268 #else 1269 #define BLKDEV_MAJOR_MAX 0 1270 #endif 1271 1272 struct block_device *blkdev_get_by_path(const char *path, fmode_t mode, 1273 void *holder); 1274 struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder); 1275 int bd_prepare_to_claim(struct block_device *bdev, void *holder); 1276 void bd_abort_claiming(struct block_device *bdev, void *holder); 1277 void blkdev_put(struct block_device *bdev, fmode_t mode); 1278 1279 /* just for blk-cgroup, don't use elsewhere */ 1280 struct block_device *blkdev_get_no_open(dev_t dev); 1281 void blkdev_put_no_open(struct block_device *bdev); 1282 1283 struct block_device *bdev_alloc(struct gendisk *disk, u8 partno); 1284 void bdev_add(struct block_device *bdev, dev_t dev); 1285 struct block_device *I_BDEV(struct inode *inode); 1286 int truncate_bdev_range(struct block_device *bdev, fmode_t mode, loff_t lstart, 1287 loff_t lend); 1288 1289 #ifdef CONFIG_BLOCK 1290 void invalidate_bdev(struct block_device *bdev); 1291 int sync_blockdev(struct block_device *bdev); 1292 int sync_blockdev_nowait(struct block_device *bdev); 1293 void sync_bdevs(bool wait); 1294 #else 1295 static inline void invalidate_bdev(struct block_device *bdev) 1296 { 1297 } 1298 static inline int sync_blockdev(struct block_device *bdev) 1299 { 1300 return 0; 1301 } 1302 static inline int sync_blockdev_nowait(struct block_device *bdev) 1303 { 1304 return 0; 1305 } 1306 static inline void sync_bdevs(bool wait) 1307 { 1308 } 1309 #endif 1310 int fsync_bdev(struct block_device *bdev); 1311 1312 int freeze_bdev(struct block_device *bdev); 1313 int thaw_bdev(struct block_device *bdev); 1314 1315 struct io_comp_batch { 1316 struct request *req_list; 1317 bool need_ts; 1318 void (*complete)(struct io_comp_batch *); 1319 }; 1320 1321 #define DEFINE_IO_COMP_BATCH(name) struct io_comp_batch name = { } 1322 1323 #endif /* _LINUX_BLKDEV_H */ 1324