include/linux/blkdev.h

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