LCOV - code coverage report
Current view: top level - include/linux - blkdev.h (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 70 119 58.8 %
Date: 2020-09-30 20:25:40 Functions: 4 6 66.7 %
Branches: 70 662 10.6 %

           Branch data     Line data    Source code
       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/sched/clock.h>
       7                 :            : 
       8                 :            : #ifdef CONFIG_BLOCK
       9                 :            : 
      10                 :            : #include <linux/major.h>
      11                 :            : #include <linux/genhd.h>
      12                 :            : #include <linux/list.h>
      13                 :            : #include <linux/llist.h>
      14                 :            : #include <linux/timer.h>
      15                 :            : #include <linux/workqueue.h>
      16                 :            : #include <linux/pagemap.h>
      17                 :            : #include <linux/backing-dev-defs.h>
      18                 :            : #include <linux/wait.h>
      19                 :            : #include <linux/mempool.h>
      20                 :            : #include <linux/pfn.h>
      21                 :            : #include <linux/bio.h>
      22                 :            : #include <linux/stringify.h>
      23                 :            : #include <linux/gfp.h>
      24                 :            : #include <linux/bsg.h>
      25                 :            : #include <linux/smp.h>
      26                 :            : #include <linux/rcupdate.h>
      27                 :            : #include <linux/percpu-refcount.h>
      28                 :            : #include <linux/scatterlist.h>
      29                 :            : #include <linux/blkzoned.h>
      30                 :            : 
      31                 :            : struct module;
      32                 :            : struct scsi_ioctl_command;
      33                 :            : 
      34                 :            : struct request_queue;
      35                 :            : struct elevator_queue;
      36                 :            : struct blk_trace;
      37                 :            : struct request;
      38                 :            : struct sg_io_hdr;
      39                 :            : struct bsg_job;
      40                 :            : struct blkcg_gq;
      41                 :            : struct blk_flush_queue;
      42                 :            : struct pr_ops;
      43                 :            : struct rq_qos;
      44                 :            : struct blk_queue_stats;
      45                 :            : struct blk_stat_callback;
      46                 :            : 
      47                 :            : #define BLKDEV_MIN_RQ   4
      48                 :            : #define BLKDEV_MAX_RQ   128     /* Default maximum */
      49                 :            : 
      50                 :            : /* Must be consistent with blk_mq_poll_stats_bkt() */
      51                 :            : #define BLK_MQ_POLL_STATS_BKTS 16
      52                 :            : 
      53                 :            : /* Doing classic polling */
      54                 :            : #define BLK_MQ_POLL_CLASSIC -1
      55                 :            : 
      56                 :            : /*
      57                 :            :  * Maximum number of blkcg policies allowed to be registered concurrently.
      58                 :            :  * Defined here to simplify include dependency.
      59                 :            :  */
      60                 :            : #define BLKCG_MAX_POLS          5
      61                 :            : 
      62                 :            : typedef void (rq_end_io_fn)(struct request *, blk_status_t);
      63                 :            : 
      64                 :            : /*
      65                 :            :  * request flags */
      66                 :            : typedef __u32 __bitwise req_flags_t;
      67                 :            : 
      68                 :            : /* elevator knows about this request */
      69                 :            : #define RQF_SORTED              ((__force req_flags_t)(1 << 0))
      70                 :            : /* drive already may have started this one */
      71                 :            : #define RQF_STARTED             ((__force req_flags_t)(1 << 1))
      72                 :            : /* may not be passed by ioscheduler */
      73                 :            : #define RQF_SOFTBARRIER         ((__force req_flags_t)(1 << 3))
      74                 :            : /* request for flush sequence */
      75                 :            : #define RQF_FLUSH_SEQ           ((__force req_flags_t)(1 << 4))
      76                 :            : /* merge of different types, fail separately */
      77                 :            : #define RQF_MIXED_MERGE         ((__force req_flags_t)(1 << 5))
      78                 :            : /* track inflight for MQ */
      79                 :            : #define RQF_MQ_INFLIGHT         ((__force req_flags_t)(1 << 6))
      80                 :            : /* don't call prep for this one */
      81                 :            : #define RQF_DONTPREP            ((__force req_flags_t)(1 << 7))
      82                 :            : /* set for "ide_preempt" requests and also for requests for which the SCSI
      83                 :            :    "quiesce" state must be ignored. */
      84                 :            : #define RQF_PREEMPT             ((__force req_flags_t)(1 << 8))
      85                 :            : /* contains copies of user pages */
      86                 :            : #define RQF_COPY_USER           ((__force req_flags_t)(1 << 9))
      87                 :            : /* vaguely specified driver internal error.  Ignored by the block layer */
      88                 :            : #define RQF_FAILED              ((__force req_flags_t)(1 << 10))
      89                 :            : /* don't warn about errors */
      90                 :            : #define RQF_QUIET               ((__force req_flags_t)(1 << 11))
      91                 :            : /* elevator private data attached */
      92                 :            : #define RQF_ELVPRIV             ((__force req_flags_t)(1 << 12))
      93                 :            : /* account into disk and partition IO statistics */
      94                 :            : #define RQF_IO_STAT             ((__force req_flags_t)(1 << 13))
      95                 :            : /* request came from our alloc pool */
      96                 :            : #define RQF_ALLOCED             ((__force req_flags_t)(1 << 14))
      97                 :            : /* runtime pm request */
      98                 :            : #define RQF_PM                  ((__force req_flags_t)(1 << 15))
      99                 :            : /* on IO scheduler merge hash */
     100                 :            : #define RQF_HASHED              ((__force req_flags_t)(1 << 16))
     101                 :            : /* track IO completion time */
     102                 :            : #define RQF_STATS               ((__force req_flags_t)(1 << 17))
     103                 :            : /* Look at ->special_vec for the actual data payload instead of the
     104                 :            :    bio chain. */
     105                 :            : #define RQF_SPECIAL_PAYLOAD     ((__force req_flags_t)(1 << 18))
     106                 :            : /* The per-zone write lock is held for this request */
     107                 :            : #define RQF_ZONE_WRITE_LOCKED   ((__force req_flags_t)(1 << 19))
     108                 :            : /* already slept for hybrid poll */
     109                 :            : #define RQF_MQ_POLL_SLEPT       ((__force req_flags_t)(1 << 20))
     110                 :            : /* ->timeout has been called, don't expire again */
     111                 :            : #define RQF_TIMED_OUT           ((__force req_flags_t)(1 << 21))
     112                 :            : 
     113                 :            : /* flags that prevent us from merging requests: */
     114                 :            : #define RQF_NOMERGE_FLAGS \
     115                 :            :         (RQF_STARTED | RQF_SOFTBARRIER | RQF_FLUSH_SEQ | RQF_SPECIAL_PAYLOAD)
     116                 :            : 
     117                 :            : /*
     118                 :            :  * Request state for blk-mq.
     119                 :            :  */
     120                 :            : enum mq_rq_state {
     121                 :            :         MQ_RQ_IDLE              = 0,
     122                 :            :         MQ_RQ_IN_FLIGHT         = 1,
     123                 :            :         MQ_RQ_COMPLETE          = 2,
     124                 :            : };
     125                 :            : 
     126                 :            : /*
     127                 :            :  * Try to put the fields that are referenced together in the same cacheline.
     128                 :            :  *
     129                 :            :  * If you modify this structure, make sure to update blk_rq_init() and
     130                 :            :  * especially blk_mq_rq_ctx_init() to take care of the added fields.
     131                 :            :  */
     132                 :            : struct request {
     133                 :            :         struct request_queue *q;
     134                 :            :         struct blk_mq_ctx *mq_ctx;
     135                 :            :         struct blk_mq_hw_ctx *mq_hctx;
     136                 :            : 
     137                 :            :         unsigned int cmd_flags;         /* op and common flags */
     138                 :            :         req_flags_t rq_flags;
     139                 :            : 
     140                 :            :         int tag;
     141                 :            :         int internal_tag;
     142                 :            : 
     143                 :            :         /* the following two fields are internal, NEVER access directly */
     144                 :            :         unsigned int __data_len;        /* total data len */
     145                 :            :         sector_t __sector;              /* sector cursor */
     146                 :            : 
     147                 :            :         struct bio *bio;
     148                 :            :         struct bio *biotail;
     149                 :            : 
     150                 :            :         struct list_head queuelist;
     151                 :            : 
     152                 :            :         /*
     153                 :            :          * The hash is used inside the scheduler, and killed once the
     154                 :            :          * request reaches the dispatch list. The ipi_list is only used
     155                 :            :          * to queue the request for softirq completion, which is long
     156                 :            :          * after the request has been unhashed (and even removed from
     157                 :            :          * the dispatch list).
     158                 :            :          */
     159                 :            :         union {
     160                 :            :                 struct hlist_node hash; /* merge hash */
     161                 :            :                 struct list_head ipi_list;
     162                 :            :         };
     163                 :            : 
     164                 :            :         /*
     165                 :            :          * The rb_node is only used inside the io scheduler, requests
     166                 :            :          * are pruned when moved to the dispatch queue. So let the
     167                 :            :          * completion_data share space with the rb_node.
     168                 :            :          */
     169                 :            :         union {
     170                 :            :                 struct rb_node rb_node; /* sort/lookup */
     171                 :            :                 struct bio_vec special_vec;
     172                 :            :                 void *completion_data;
     173                 :            :                 int error_count; /* for legacy drivers, don't use */
     174                 :            :         };
     175                 :            : 
     176                 :            :         /*
     177                 :            :          * Three pointers are available for the IO schedulers, if they need
     178                 :            :          * more they have to dynamically allocate it.  Flush requests are
     179                 :            :          * never put on the IO scheduler. So let the flush fields share
     180                 :            :          * space with the elevator data.
     181                 :            :          */
     182                 :            :         union {
     183                 :            :                 struct {
     184                 :            :                         struct io_cq            *icq;
     185                 :            :                         void                    *priv[2];
     186                 :            :                 } elv;
     187                 :            : 
     188                 :            :                 struct {
     189                 :            :                         unsigned int            seq;
     190                 :            :                         struct list_head        list;
     191                 :            :                         rq_end_io_fn            *saved_end_io;
     192                 :            :                 } flush;
     193                 :            :         };
     194                 :            : 
     195                 :            :         struct gendisk *rq_disk;
     196                 :            :         struct hd_struct *part;
     197                 :            : #ifdef CONFIG_BLK_RQ_ALLOC_TIME
     198                 :            :         /* Time that the first bio started allocating this request. */
     199                 :            :         u64 alloc_time_ns;
     200                 :            : #endif
     201                 :            :         /* Time that this request was allocated for this IO. */
     202                 :            :         u64 start_time_ns;
     203                 :            :         /* Time that I/O was submitted to the device. */
     204                 :            :         u64 io_start_time_ns;
     205                 :            : 
     206                 :            : #ifdef CONFIG_BLK_WBT
     207                 :            :         unsigned short wbt_flags;
     208                 :            : #endif
     209                 :            :         /*
     210                 :            :          * rq sectors used for blk stats. It has the same value
     211                 :            :          * with blk_rq_sectors(rq), except that it never be zeroed
     212                 :            :          * by completion.
     213                 :            :          */
     214                 :            :         unsigned short stats_sectors;
     215                 :            : 
     216                 :            :         /*
     217                 :            :          * Number of scatter-gather DMA addr+len pairs after
     218                 :            :          * physical address coalescing is performed.
     219                 :            :          */
     220                 :            :         unsigned short nr_phys_segments;
     221                 :            : 
     222                 :            : #if defined(CONFIG_BLK_DEV_INTEGRITY)
     223                 :            :         unsigned short nr_integrity_segments;
     224                 :            : #endif
     225                 :            : 
     226                 :            :         unsigned short write_hint;
     227                 :            :         unsigned short ioprio;
     228                 :            : 
     229                 :            :         unsigned int extra_len; /* length of alignment and padding */
     230                 :            : 
     231                 :            :         enum mq_rq_state state;
     232                 :            :         refcount_t ref;
     233                 :            : 
     234                 :            :         unsigned int timeout;
     235                 :            :         unsigned long deadline;
     236                 :            : 
     237                 :            :         union {
     238                 :            :                 struct __call_single_data csd;
     239                 :            :                 u64 fifo_time;
     240                 :            :         };
     241                 :            : 
     242                 :            :         /*
     243                 :            :          * completion callback.
     244                 :            :          */
     245                 :            :         rq_end_io_fn *end_io;
     246                 :            :         void *end_io_data;
     247                 :            : };
     248                 :            : 
     249                 :            : static inline bool blk_op_is_scsi(unsigned int op)
     250                 :            : {
     251                 :   12922569 :         return op == REQ_OP_SCSI_IN || op == REQ_OP_SCSI_OUT;
     252                 :            : }
     253                 :            : 
     254                 :            : static inline bool blk_op_is_private(unsigned int op)
     255                 :            : {
     256                 :   12925779 :         return op == REQ_OP_DRV_IN || op == REQ_OP_DRV_OUT;
     257                 :            : }
     258                 :            : 
     259                 :            : static inline bool blk_rq_is_scsi(struct request *rq)
     260                 :            : {
     261                 :   12922569 :         return blk_op_is_scsi(req_op(rq));
     262                 :            : }
     263                 :            : 
     264                 :            : static inline bool blk_rq_is_private(struct request *rq)
     265                 :            : {
     266                 :            :         return blk_op_is_private(req_op(rq));
     267                 :            : }
     268                 :            : 
     269                 :            : static inline bool blk_rq_is_passthrough(struct request *rq)
     270                 :            : {
     271   [ +  +  +  +  :   25848348 :         return blk_rq_is_scsi(rq) || blk_rq_is_private(rq);
          +  +  +  +  +  
          +  +  +  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     272                 :            : }
     273                 :            : 
     274                 :            : static inline bool bio_is_passthrough(struct bio *bio)
     275                 :            : {
     276                 :            :         unsigned op = bio_op(bio);
     277                 :            : 
     278                 :            :         return blk_op_is_scsi(op) || blk_op_is_private(op);
     279                 :            : }
     280                 :            : 
     281                 :            : static inline unsigned short req_get_ioprio(struct request *req)
     282                 :            : {
     283                 :            :         return req->ioprio;
     284                 :            : }
     285                 :            : 
     286                 :            : #include <linux/elevator.h>
     287                 :            : 
     288                 :            : struct blk_queue_ctx;
     289                 :            : 
     290                 :            : typedef blk_qc_t (make_request_fn) (struct request_queue *q, struct bio *bio);
     291                 :            : 
     292                 :            : struct bio_vec;
     293                 :            : typedef int (dma_drain_needed_fn)(struct request *);
     294                 :            : 
     295                 :            : enum blk_eh_timer_return {
     296                 :            :         BLK_EH_DONE,            /* drivers has completed the command */
     297                 :            :         BLK_EH_RESET_TIMER,     /* reset timer and try again */
     298                 :            : };
     299                 :            : 
     300                 :            : enum blk_queue_state {
     301                 :            :         Queue_down,
     302                 :            :         Queue_up,
     303                 :            : };
     304                 :            : 
     305                 :            : #define BLK_TAG_ALLOC_FIFO 0 /* allocate starting from 0 */
     306                 :            : #define BLK_TAG_ALLOC_RR 1 /* allocate starting from last allocated tag */
     307                 :            : 
     308                 :            : #define BLK_SCSI_MAX_CMDS       (256)
     309                 :            : #define BLK_SCSI_CMD_PER_LONG   (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
     310                 :            : 
     311                 :            : /*
     312                 :            :  * Zoned block device models (zoned limit).
     313                 :            :  */
     314                 :            : enum blk_zoned_model {
     315                 :            :         BLK_ZONED_NONE, /* Regular block device */
     316                 :            :         BLK_ZONED_HA,   /* Host-aware zoned block device */
     317                 :            :         BLK_ZONED_HM,   /* Host-managed zoned block device */
     318                 :            : };
     319                 :            : 
     320                 :            : struct queue_limits {
     321                 :            :         unsigned long           bounce_pfn;
     322                 :            :         unsigned long           seg_boundary_mask;
     323                 :            :         unsigned long           virt_boundary_mask;
     324                 :            : 
     325                 :            :         unsigned int            max_hw_sectors;
     326                 :            :         unsigned int            max_dev_sectors;
     327                 :            :         unsigned int            chunk_sectors;
     328                 :            :         unsigned int            max_sectors;
     329                 :            :         unsigned int            max_segment_size;
     330                 :            :         unsigned int            physical_block_size;
     331                 :            :         unsigned int            logical_block_size;
     332                 :            :         unsigned int            alignment_offset;
     333                 :            :         unsigned int            io_min;
     334                 :            :         unsigned int            io_opt;
     335                 :            :         unsigned int            max_discard_sectors;
     336                 :            :         unsigned int            max_hw_discard_sectors;
     337                 :            :         unsigned int            max_write_same_sectors;
     338                 :            :         unsigned int            max_write_zeroes_sectors;
     339                 :            :         unsigned int            discard_granularity;
     340                 :            :         unsigned int            discard_alignment;
     341                 :            : 
     342                 :            :         unsigned short          max_segments;
     343                 :            :         unsigned short          max_integrity_segments;
     344                 :            :         unsigned short          max_discard_segments;
     345                 :            : 
     346                 :            :         unsigned char           misaligned;
     347                 :            :         unsigned char           discard_misaligned;
     348                 :            :         unsigned char           raid_partial_stripes_expensive;
     349                 :            :         enum blk_zoned_model    zoned;
     350                 :            : };
     351                 :            : 
     352                 :            : #ifdef CONFIG_BLK_DEV_ZONED
     353                 :            : 
     354                 :            : /*
     355                 :            :  * Maximum number of zones to report with a single report zones command.
     356                 :            :  */
     357                 :            : #define BLK_ZONED_REPORT_MAX_ZONES      8192U
     358                 :            : 
     359                 :            : extern unsigned int blkdev_nr_zones(struct block_device *bdev);
     360                 :            : extern int blkdev_report_zones(struct block_device *bdev,
     361                 :            :                                sector_t sector, struct blk_zone *zones,
     362                 :            :                                unsigned int *nr_zones);
     363                 :            : extern int blkdev_reset_zones(struct block_device *bdev, sector_t sectors,
     364                 :            :                               sector_t nr_sectors, gfp_t gfp_mask);
     365                 :            : extern int blk_revalidate_disk_zones(struct gendisk *disk);
     366                 :            : 
     367                 :            : extern int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
     368                 :            :                                      unsigned int cmd, unsigned long arg);
     369                 :            : extern int blkdev_reset_zones_ioctl(struct block_device *bdev, fmode_t mode,
     370                 :            :                                     unsigned int cmd, unsigned long arg);
     371                 :            : 
     372                 :            : #else /* CONFIG_BLK_DEV_ZONED */
     373                 :            : 
     374                 :            : static inline unsigned int blkdev_nr_zones(struct block_device *bdev)
     375                 :            : {
     376                 :            :         return 0;
     377                 :            : }
     378                 :            : 
     379                 :            : static inline int blk_revalidate_disk_zones(struct gendisk *disk)
     380                 :            : {
     381                 :            :         return 0;
     382                 :            : }
     383                 :            : 
     384                 :            : static inline int blkdev_report_zones_ioctl(struct block_device *bdev,
     385                 :            :                                             fmode_t mode, unsigned int cmd,
     386                 :            :                                             unsigned long arg)
     387                 :            : {
     388                 :            :         return -ENOTTY;
     389                 :            : }
     390                 :            : 
     391                 :            : static inline int blkdev_reset_zones_ioctl(struct block_device *bdev,
     392                 :            :                                            fmode_t mode, unsigned int cmd,
     393                 :            :                                            unsigned long arg)
     394                 :            : {
     395                 :            :         return -ENOTTY;
     396                 :            : }
     397                 :            : 
     398                 :            : #endif /* CONFIG_BLK_DEV_ZONED */
     399                 :            : 
     400                 :            : struct request_queue {
     401                 :            :         struct request          *last_merge;
     402                 :            :         struct elevator_queue   *elevator;
     403                 :            : 
     404                 :            :         struct blk_queue_stats  *stats;
     405                 :            :         struct rq_qos           *rq_qos;
     406                 :            : 
     407                 :            :         make_request_fn         *make_request_fn;
     408                 :            :         dma_drain_needed_fn     *dma_drain_needed;
     409                 :            : 
     410                 :            :         const struct blk_mq_ops *mq_ops;
     411                 :            : 
     412                 :            :         /* sw queues */
     413                 :            :         struct blk_mq_ctx __percpu      *queue_ctx;
     414                 :            :         unsigned int            nr_queues;
     415                 :            : 
     416                 :            :         unsigned int            queue_depth;
     417                 :            : 
     418                 :            :         /* hw dispatch queues */
     419                 :            :         struct blk_mq_hw_ctx    **queue_hw_ctx;
     420                 :            :         unsigned int            nr_hw_queues;
     421                 :            : 
     422                 :            :         struct backing_dev_info *backing_dev_info;
     423                 :            : 
     424                 :            :         /*
     425                 :            :          * The queue owner gets to use this for whatever they like.
     426                 :            :          * ll_rw_blk doesn't touch it.
     427                 :            :          */
     428                 :            :         void                    *queuedata;
     429                 :            : 
     430                 :            :         /*
     431                 :            :          * various queue flags, see QUEUE_* below
     432                 :            :          */
     433                 :            :         unsigned long           queue_flags;
     434                 :            :         /*
     435                 :            :          * Number of contexts that have called blk_set_pm_only(). If this
     436                 :            :          * counter is above zero then only RQF_PM and RQF_PREEMPT requests are
     437                 :            :          * processed.
     438                 :            :          */
     439                 :            :         atomic_t                pm_only;
     440                 :            : 
     441                 :            :         /*
     442                 :            :          * ida allocated id for this queue.  Used to index queues from
     443                 :            :          * ioctx.
     444                 :            :          */
     445                 :            :         int                     id;
     446                 :            : 
     447                 :            :         /*
     448                 :            :          * queue needs bounce pages for pages above this limit
     449                 :            :          */
     450                 :            :         gfp_t                   bounce_gfp;
     451                 :            : 
     452                 :            :         spinlock_t              queue_lock;
     453                 :            : 
     454                 :            :         /*
     455                 :            :          * queue kobject
     456                 :            :          */
     457                 :            :         struct kobject kobj;
     458                 :            : 
     459                 :            :         /*
     460                 :            :          * mq queue kobject
     461                 :            :          */
     462                 :            :         struct kobject *mq_kobj;
     463                 :            : 
     464                 :            : #ifdef  CONFIG_BLK_DEV_INTEGRITY
     465                 :            :         struct blk_integrity integrity;
     466                 :            : #endif  /* CONFIG_BLK_DEV_INTEGRITY */
     467                 :            : 
     468                 :            : #ifdef CONFIG_PM
     469                 :            :         struct device           *dev;
     470                 :            :         int                     rpm_status;
     471                 :            :         unsigned int            nr_pending;
     472                 :            : #endif
     473                 :            : 
     474                 :            :         /*
     475                 :            :          * queue settings
     476                 :            :          */
     477                 :            :         unsigned long           nr_requests;    /* Max # of requests */
     478                 :            : 
     479                 :            :         unsigned int            dma_drain_size;
     480                 :            :         void                    *dma_drain_buffer;
     481                 :            :         unsigned int            dma_pad_mask;
     482                 :            :         unsigned int            dma_alignment;
     483                 :            : 
     484                 :            :         unsigned int            rq_timeout;
     485                 :            :         int                     poll_nsec;
     486                 :            : 
     487                 :            :         struct blk_stat_callback        *poll_cb;
     488                 :            :         struct blk_rq_stat      poll_stat[BLK_MQ_POLL_STATS_BKTS];
     489                 :            : 
     490                 :            :         struct timer_list       timeout;
     491                 :            :         struct work_struct      timeout_work;
     492                 :            : 
     493                 :            :         struct list_head        icq_list;
     494                 :            : #ifdef CONFIG_BLK_CGROUP
     495                 :            :         DECLARE_BITMAP          (blkcg_pols, BLKCG_MAX_POLS);
     496                 :            :         struct blkcg_gq         *root_blkg;
     497                 :            :         struct list_head        blkg_list;
     498                 :            : #endif
     499                 :            : 
     500                 :            :         struct queue_limits     limits;
     501                 :            : 
     502                 :            :         unsigned int            required_elevator_features;
     503                 :            : 
     504                 :            : #ifdef CONFIG_BLK_DEV_ZONED
     505                 :            :         /*
     506                 :            :          * Zoned block device information for request dispatch control.
     507                 :            :          * nr_zones is the total number of zones of the device. This is always
     508                 :            :          * 0 for regular block devices. seq_zones_bitmap is a bitmap of nr_zones
     509                 :            :          * bits which indicates if a zone is conventional (bit clear) or
     510                 :            :          * sequential (bit set). seq_zones_wlock is a bitmap of nr_zones
     511                 :            :          * bits which indicates if a zone is write locked, that is, if a write
     512                 :            :          * request targeting the zone was dispatched. All three fields are
     513                 :            :          * initialized by the low level device driver (e.g. scsi/sd.c).
     514                 :            :          * Stacking drivers (device mappers) may or may not initialize
     515                 :            :          * these fields.
     516                 :            :          *
     517                 :            :          * Reads of this information must be protected with blk_queue_enter() /
     518                 :            :          * blk_queue_exit(). Modifying this information is only allowed while
     519                 :            :          * no requests are being processed. See also blk_mq_freeze_queue() and
     520                 :            :          * blk_mq_unfreeze_queue().
     521                 :            :          */
     522                 :            :         unsigned int            nr_zones;
     523                 :            :         unsigned long           *seq_zones_bitmap;
     524                 :            :         unsigned long           *seq_zones_wlock;
     525                 :            : #endif /* CONFIG_BLK_DEV_ZONED */
     526                 :            : 
     527                 :            :         /*
     528                 :            :          * sg stuff
     529                 :            :          */
     530                 :            :         unsigned int            sg_timeout;
     531                 :            :         unsigned int            sg_reserved_size;
     532                 :            :         int                     node;
     533                 :            : #ifdef CONFIG_BLK_DEV_IO_TRACE
     534                 :            :         struct blk_trace __rcu  *blk_trace;
     535                 :            :         struct mutex            blk_trace_mutex;
     536                 :            : #endif
     537                 :            :         /*
     538                 :            :          * for flush operations
     539                 :            :          */
     540                 :            :         struct blk_flush_queue  *fq;
     541                 :            : 
     542                 :            :         struct list_head        requeue_list;
     543                 :            :         spinlock_t              requeue_lock;
     544                 :            :         struct delayed_work     requeue_work;
     545                 :            : 
     546                 :            :         struct mutex            sysfs_lock;
     547                 :            :         struct mutex            sysfs_dir_lock;
     548                 :            : 
     549                 :            :         /*
     550                 :            :          * for reusing dead hctx instance in case of updating
     551                 :            :          * nr_hw_queues
     552                 :            :          */
     553                 :            :         struct list_head        unused_hctx_list;
     554                 :            :         spinlock_t              unused_hctx_lock;
     555                 :            : 
     556                 :            :         int                     mq_freeze_depth;
     557                 :            : 
     558                 :            : #if defined(CONFIG_BLK_DEV_BSG)
     559                 :            :         struct bsg_class_device bsg_dev;
     560                 :            : #endif
     561                 :            : 
     562                 :            : #ifdef CONFIG_BLK_DEV_THROTTLING
     563                 :            :         /* Throttle data */
     564                 :            :         struct throtl_data *td;
     565                 :            : #endif
     566                 :            :         struct rcu_head         rcu_head;
     567                 :            :         wait_queue_head_t       mq_freeze_wq;
     568                 :            :         /*
     569                 :            :          * Protect concurrent access to q_usage_counter by
     570                 :            :          * percpu_ref_kill() and percpu_ref_reinit().
     571                 :            :          */
     572                 :            :         struct mutex            mq_freeze_lock;
     573                 :            :         struct percpu_ref       q_usage_counter;
     574                 :            : 
     575                 :            :         struct blk_mq_tag_set   *tag_set;
     576                 :            :         struct list_head        tag_set_list;
     577                 :            :         struct bio_set          bio_split;
     578                 :            : 
     579                 :            : #ifdef CONFIG_BLK_DEBUG_FS
     580                 :            :         struct dentry           *debugfs_dir;
     581                 :            :         struct dentry           *sched_debugfs_dir;
     582                 :            :         struct dentry           *rqos_debugfs_dir;
     583                 :            : #endif
     584                 :            : 
     585                 :            :         bool                    mq_sysfs_init_done;
     586                 :            : 
     587                 :            :         size_t                  cmd_size;
     588                 :            : 
     589                 :            :         struct work_struct      release_work;
     590                 :            : 
     591                 :            : #define BLK_MAX_WRITE_HINTS     5
     592                 :            :         u64                     write_hints[BLK_MAX_WRITE_HINTS];
     593                 :            : };
     594                 :            : 
     595                 :            : /* Keep blk_queue_flag_name[] in sync with the definitions below */
     596                 :            : #define QUEUE_FLAG_STOPPED      0       /* queue is stopped */
     597                 :            : #define QUEUE_FLAG_DYING        1       /* queue being torn down */
     598                 :            : #define QUEUE_FLAG_NOMERGES     3       /* disable merge attempts */
     599                 :            : #define QUEUE_FLAG_SAME_COMP    4       /* complete on same CPU-group */
     600                 :            : #define QUEUE_FLAG_FAIL_IO      5       /* fake timeout */
     601                 :            : #define QUEUE_FLAG_NONROT       6       /* non-rotational device (SSD) */
     602                 :            : #define QUEUE_FLAG_VIRT         QUEUE_FLAG_NONROT /* paravirt device */
     603                 :            : #define QUEUE_FLAG_IO_STAT      7       /* do disk/partitions IO accounting */
     604                 :            : #define QUEUE_FLAG_DISCARD      8       /* supports DISCARD */
     605                 :            : #define QUEUE_FLAG_NOXMERGES    9       /* No extended merges */
     606                 :            : #define QUEUE_FLAG_ADD_RANDOM   10      /* Contributes to random pool */
     607                 :            : #define QUEUE_FLAG_SECERASE     11      /* supports secure erase */
     608                 :            : #define QUEUE_FLAG_SAME_FORCE   12      /* force complete on same CPU */
     609                 :            : #define QUEUE_FLAG_DEAD         13      /* queue tear-down finished */
     610                 :            : #define QUEUE_FLAG_INIT_DONE    14      /* queue is initialized */
     611                 :            : #define QUEUE_FLAG_POLL         16      /* IO polling enabled if set */
     612                 :            : #define QUEUE_FLAG_WC           17      /* Write back caching */
     613                 :            : #define QUEUE_FLAG_FUA          18      /* device supports FUA writes */
     614                 :            : #define QUEUE_FLAG_DAX          19      /* device supports DAX */
     615                 :            : #define QUEUE_FLAG_STATS        20      /* track IO start and completion times */
     616                 :            : #define QUEUE_FLAG_POLL_STATS   21      /* collecting stats for hybrid polling */
     617                 :            : #define QUEUE_FLAG_REGISTERED   22      /* queue has been registered to a disk */
     618                 :            : #define QUEUE_FLAG_SCSI_PASSTHROUGH 23  /* queue supports SCSI commands */
     619                 :            : #define QUEUE_FLAG_QUIESCED     24      /* queue has been quiesced */
     620                 :            : #define QUEUE_FLAG_PCI_P2PDMA   25      /* device supports PCI p2p requests */
     621                 :            : #define QUEUE_FLAG_ZONE_RESETALL 26     /* supports Zone Reset All */
     622                 :            : #define QUEUE_FLAG_RQ_ALLOC_TIME 27     /* record rq->alloc_time_ns */
     623                 :            : 
     624                 :            : #define QUEUE_FLAG_MQ_DEFAULT   ((1 << QUEUE_FLAG_IO_STAT) |              \
     625                 :            :                                  (1 << QUEUE_FLAG_SAME_COMP))
     626                 :            : 
     627                 :            : void blk_queue_flag_set(unsigned int flag, struct request_queue *q);
     628                 :            : void blk_queue_flag_clear(unsigned int flag, struct request_queue *q);
     629                 :            : bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q);
     630                 :            : 
     631                 :            : #define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
     632                 :            : #define blk_queue_dying(q)      test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags)
     633                 :            : #define blk_queue_dead(q)       test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags)
     634                 :            : #define blk_queue_init_done(q)  test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags)
     635                 :            : #define blk_queue_nomerges(q)   test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
     636                 :            : #define blk_queue_noxmerges(q)  \
     637                 :            :         test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
     638                 :            : #define blk_queue_nonrot(q)     test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
     639                 :            : #define blk_queue_io_stat(q)    test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
     640                 :            : #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
     641                 :            : #define blk_queue_discard(q)    test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
     642                 :            : #define blk_queue_zone_resetall(q)      \
     643                 :            :         test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags)
     644                 :            : #define blk_queue_secure_erase(q) \
     645                 :            :         (test_bit(QUEUE_FLAG_SECERASE, &(q)->queue_flags))
     646                 :            : #define blk_queue_dax(q)        test_bit(QUEUE_FLAG_DAX, &(q)->queue_flags)
     647                 :            : #define blk_queue_scsi_passthrough(q)   \
     648                 :            :         test_bit(QUEUE_FLAG_SCSI_PASSTHROUGH, &(q)->queue_flags)
     649                 :            : #define blk_queue_pci_p2pdma(q) \
     650                 :            :         test_bit(QUEUE_FLAG_PCI_P2PDMA, &(q)->queue_flags)
     651                 :            : #ifdef CONFIG_BLK_RQ_ALLOC_TIME
     652                 :            : #define blk_queue_rq_alloc_time(q)      \
     653                 :            :         test_bit(QUEUE_FLAG_RQ_ALLOC_TIME, &(q)->queue_flags)
     654                 :            : #else
     655                 :            : #define blk_queue_rq_alloc_time(q)      false
     656                 :            : #endif
     657                 :            : 
     658                 :            : #define blk_noretry_request(rq) \
     659                 :            :         ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
     660                 :            :                              REQ_FAILFAST_DRIVER))
     661                 :            : #define blk_queue_quiesced(q)   test_bit(QUEUE_FLAG_QUIESCED, &(q)->queue_flags)
     662                 :            : #define blk_queue_pm_only(q)    atomic_read(&(q)->pm_only)
     663                 :            : #define blk_queue_fua(q)        test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags)
     664                 :            : #define blk_queue_registered(q) test_bit(QUEUE_FLAG_REGISTERED, &(q)->queue_flags)
     665                 :            : 
     666                 :            : extern void blk_set_pm_only(struct request_queue *q);
     667                 :            : extern void blk_clear_pm_only(struct request_queue *q);
     668                 :            : 
     669                 :            : static inline bool blk_account_rq(struct request *rq)
     670                 :            : {
     671                 :            :         return (rq->rq_flags & RQF_STARTED) && !blk_rq_is_passthrough(rq);
     672                 :            : }
     673                 :            : 
     674                 :            : #define list_entry_rq(ptr)      list_entry((ptr), struct request, queuelist)
     675                 :            : 
     676                 :            : #define rq_data_dir(rq)         (op_is_write(req_op(rq)) ? WRITE : READ)
     677                 :            : 
     678                 :            : #define rq_dma_dir(rq) \
     679                 :            :         (op_is_write(req_op(rq)) ? DMA_TO_DEVICE : DMA_FROM_DEVICE)
     680                 :            : 
     681                 :            : #define dma_map_bvec(dev, bv, dir, attrs) \
     682                 :            :         dma_map_page_attrs(dev, (bv)->bv_page, (bv)->bv_offset, (bv)->bv_len, \
     683                 :            :         (dir), (attrs))
     684                 :            : 
     685                 :            : static inline bool queue_is_mq(struct request_queue *q)
     686                 :            : {
     687                 :    2329154 :         return q->mq_ops;
     688                 :            : }
     689                 :            : 
     690                 :            : static inline enum blk_zoned_model
     691                 :            : blk_queue_zoned_model(struct request_queue *q)
     692                 :            : {
     693                 :    5106796 :         return q->limits.zoned;
     694                 :            : }
     695                 :            : 
     696                 :            : static inline bool blk_queue_is_zoned(struct request_queue *q)
     697                 :            : {
     698   [ +  +  +  -  :    5106796 :         switch (blk_queue_zoned_model(q)) {
                   +  + ]
     699                 :            :         case BLK_ZONED_HA:
     700                 :            :         case BLK_ZONED_HM:
     701                 :            :                 return true;
     702                 :            :         default:
     703                 :            :                 return false;
     704                 :            :         }
     705                 :            : }
     706                 :            : 
     707                 :            : static inline sector_t blk_queue_zone_sectors(struct request_queue *q)
     708                 :            : {
     709         [ #  # ]:          0 :         return blk_queue_is_zoned(q) ? q->limits.chunk_sectors : 0;
     710                 :            : }
     711                 :            : 
     712                 :            : #ifdef CONFIG_BLK_DEV_ZONED
     713                 :            : static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
     714                 :            : {
     715                 :            :         return blk_queue_is_zoned(q) ? q->nr_zones : 0;
     716                 :            : }
     717                 :            : 
     718                 :            : static inline unsigned int blk_queue_zone_no(struct request_queue *q,
     719                 :            :                                              sector_t sector)
     720                 :            : {
     721                 :            :         if (!blk_queue_is_zoned(q))
     722                 :            :                 return 0;
     723                 :            :         return sector >> ilog2(q->limits.chunk_sectors);
     724                 :            : }
     725                 :            : 
     726                 :            : static inline bool blk_queue_zone_is_seq(struct request_queue *q,
     727                 :            :                                          sector_t sector)
     728                 :            : {
     729                 :            :         if (!blk_queue_is_zoned(q) || !q->seq_zones_bitmap)
     730                 :            :                 return false;
     731                 :            :         return test_bit(blk_queue_zone_no(q, sector), q->seq_zones_bitmap);
     732                 :            : }
     733                 :            : #else /* CONFIG_BLK_DEV_ZONED */
     734                 :            : static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
     735                 :            : {
     736                 :            :         return 0;
     737                 :            : }
     738                 :            : #endif /* CONFIG_BLK_DEV_ZONED */
     739                 :            : 
     740                 :            : static inline bool rq_is_sync(struct request *rq)
     741                 :            : {
     742                 :    1161030 :         return op_is_sync(rq->cmd_flags);
     743                 :            : }
     744                 :            : 
     745                 :    4755283 : static inline bool rq_mergeable(struct request *rq)
     746                 :            : {
     747         [ +  + ]:    4755283 :         if (blk_rq_is_passthrough(rq))
     748                 :            :                 return false;
     749                 :            : 
     750         [ +  + ]:    4755291 :         if (req_op(rq) == REQ_OP_FLUSH)
     751                 :            :                 return false;
     752                 :            : 
     753         [ +  + ]:    4755269 :         if (req_op(rq) == REQ_OP_WRITE_ZEROES)
     754                 :            :                 return false;
     755                 :            : 
     756         [ +  + ]:    4755306 :         if (rq->cmd_flags & REQ_NOMERGE_FLAGS)
     757                 :            :                 return false;
     758         [ +  + ]:    4754493 :         if (rq->rq_flags & RQF_NOMERGE_FLAGS)
     759                 :            :                 return false;
     760                 :            : 
     761                 :    4754499 :         return true;
     762                 :            : }
     763                 :            : 
     764                 :          0 : static inline bool blk_write_same_mergeable(struct bio *a, struct bio *b)
     765                 :            : {
     766   [ #  #  #  # ]:          0 :         if (bio_page(a) == bio_page(b) &&
     767                 :          0 :             bio_offset(a) == bio_offset(b))
     768                 :            :                 return true;
     769                 :            : 
     770                 :          0 :         return false;
     771                 :            : }
     772                 :            : 
     773                 :            : static inline unsigned int blk_queue_depth(struct request_queue *q)
     774                 :            : {
     775                 :            :         if (q->queue_depth)
     776                 :            :                 return q->queue_depth;
     777                 :            : 
     778                 :            :         return q->nr_requests;
     779                 :            : }
     780                 :            : 
     781                 :            : extern unsigned long blk_max_low_pfn, blk_max_pfn;
     782                 :            : 
     783                 :            : /*
     784                 :            :  * standard bounce addresses:
     785                 :            :  *
     786                 :            :  * BLK_BOUNCE_HIGH      : bounce all highmem pages
     787                 :            :  * BLK_BOUNCE_ANY       : don't bounce anything
     788                 :            :  * BLK_BOUNCE_ISA       : bounce pages above ISA DMA boundary
     789                 :            :  */
     790                 :            : 
     791                 :            : #if BITS_PER_LONG == 32
     792                 :            : #define BLK_BOUNCE_HIGH         ((u64)blk_max_low_pfn << PAGE_SHIFT)
     793                 :            : #else
     794                 :            : #define BLK_BOUNCE_HIGH         -1ULL
     795                 :            : #endif
     796                 :            : #define BLK_BOUNCE_ANY          (-1ULL)
     797                 :            : #define BLK_BOUNCE_ISA          (DMA_BIT_MASK(24))
     798                 :            : 
     799                 :            : /*
     800                 :            :  * default timeout for SG_IO if none specified
     801                 :            :  */
     802                 :            : #define BLK_DEFAULT_SG_TIMEOUT  (60 * HZ)
     803                 :            : #define BLK_MIN_SG_TIMEOUT      (7 * HZ)
     804                 :            : 
     805                 :            : struct rq_map_data {
     806                 :            :         struct page **pages;
     807                 :            :         int page_order;
     808                 :            :         int nr_entries;
     809                 :            :         unsigned long offset;
     810                 :            :         int null_mapped;
     811                 :            :         int from_user;
     812                 :            : };
     813                 :            : 
     814                 :            : struct req_iterator {
     815                 :            :         struct bvec_iter iter;
     816                 :            :         struct bio *bio;
     817                 :            : };
     818                 :            : 
     819                 :            : /* This should not be used directly - use rq_for_each_segment */
     820                 :            : #define for_each_bio(_bio)              \
     821                 :            :         for (; _bio; _bio = _bio->bi_next)
     822                 :            : #define __rq_for_each_bio(_bio, rq)     \
     823                 :            :         if ((rq->bio))                       \
     824                 :            :                 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
     825                 :            : 
     826                 :            : #define rq_for_each_segment(bvl, _rq, _iter)                    \
     827                 :            :         __rq_for_each_bio(_iter.bio, _rq)                       \
     828                 :            :                 bio_for_each_segment(bvl, _iter.bio, _iter.iter)
     829                 :            : 
     830                 :            : #define rq_for_each_bvec(bvl, _rq, _iter)                       \
     831                 :            :         __rq_for_each_bio(_iter.bio, _rq)                       \
     832                 :            :                 bio_for_each_bvec(bvl, _iter.bio, _iter.iter)
     833                 :            : 
     834                 :            : #define rq_iter_last(bvec, _iter)                               \
     835                 :            :                 (_iter.bio->bi_next == NULL &&                       \
     836                 :            :                  bio_iter_last(bvec, _iter.iter))
     837                 :            : 
     838                 :            : #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
     839                 :            : # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
     840                 :            : #endif
     841                 :            : #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
     842                 :            : extern void rq_flush_dcache_pages(struct request *rq);
     843                 :            : #else
     844                 :            : static inline void rq_flush_dcache_pages(struct request *rq)
     845                 :            : {
     846                 :            : }
     847                 :            : #endif
     848                 :            : 
     849                 :            : extern int blk_register_queue(struct gendisk *disk);
     850                 :            : extern void blk_unregister_queue(struct gendisk *disk);
     851                 :            : extern blk_qc_t generic_make_request(struct bio *bio);
     852                 :            : extern blk_qc_t direct_make_request(struct bio *bio);
     853                 :            : extern void blk_rq_init(struct request_queue *q, struct request *rq);
     854                 :            : extern void blk_put_request(struct request *);
     855                 :            : extern struct request *blk_get_request(struct request_queue *, unsigned int op,
     856                 :            :                                        blk_mq_req_flags_t flags);
     857                 :            : extern int blk_lld_busy(struct request_queue *q);
     858                 :            : extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
     859                 :            :                              struct bio_set *bs, gfp_t gfp_mask,
     860                 :            :                              int (*bio_ctr)(struct bio *, struct bio *, void *),
     861                 :            :                              void *data);
     862                 :            : extern void blk_rq_unprep_clone(struct request *rq);
     863                 :            : extern blk_status_t blk_insert_cloned_request(struct request_queue *q,
     864                 :            :                                      struct request *rq);
     865                 :            : extern int blk_rq_append_bio(struct request *rq, struct bio **bio);
     866                 :            : extern void blk_queue_split(struct request_queue *, struct bio **);
     867                 :            : extern int scsi_verify_blk_ioctl(struct block_device *, unsigned int);
     868                 :            : extern int scsi_cmd_blk_ioctl(struct block_device *, fmode_t,
     869                 :            :                               unsigned int, void __user *);
     870                 :            : extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
     871                 :            :                           unsigned int, void __user *);
     872                 :            : extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
     873                 :            :                          struct scsi_ioctl_command __user *);
     874                 :            : 
     875                 :            : extern int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags);
     876                 :            : extern void blk_queue_exit(struct request_queue *q);
     877                 :            : extern void blk_sync_queue(struct request_queue *q);
     878                 :            : extern int blk_rq_map_user(struct request_queue *, struct request *,
     879                 :            :                            struct rq_map_data *, void __user *, unsigned long,
     880                 :            :                            gfp_t);
     881                 :            : extern int blk_rq_unmap_user(struct bio *);
     882                 :            : extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
     883                 :            : extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
     884                 :            :                                struct rq_map_data *, const struct iov_iter *,
     885                 :            :                                gfp_t);
     886                 :            : extern void blk_execute_rq(struct request_queue *, struct gendisk *,
     887                 :            :                           struct request *, int);
     888                 :            : extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
     889                 :            :                                   struct request *, int, rq_end_io_fn *);
     890                 :            : 
     891                 :            : /* Helper to convert REQ_OP_XXX to its string format XXX */
     892                 :            : extern const char *blk_op_str(unsigned int op);
     893                 :            : 
     894                 :            : int blk_status_to_errno(blk_status_t status);
     895                 :            : blk_status_t errno_to_blk_status(int errno);
     896                 :            : 
     897                 :            : int blk_poll(struct request_queue *q, blk_qc_t cookie, bool spin);
     898                 :            : 
     899                 :            : static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
     900                 :            : {
     901                 :    1216178 :         return bdev->bd_disk->queue;      /* this is never NULL */
     902                 :            : }
     903                 :            : 
     904                 :            : /*
     905                 :            :  * The basic unit of block I/O is a sector. It is used in a number of contexts
     906                 :            :  * in Linux (blk, bio, genhd). The size of one sector is 512 = 2**9
     907                 :            :  * bytes. Variables of type sector_t represent an offset or size that is a
     908                 :            :  * multiple of 512 bytes. Hence these two constants.
     909                 :            :  */
     910                 :            : #ifndef SECTOR_SHIFT
     911                 :            : #define SECTOR_SHIFT 9
     912                 :            : #endif
     913                 :            : #ifndef SECTOR_SIZE
     914                 :            : #define SECTOR_SIZE (1 << SECTOR_SHIFT)
     915                 :            : #endif
     916                 :            : 
     917                 :            : /*
     918                 :            :  * blk_rq_pos()                 : the current sector
     919                 :            :  * blk_rq_bytes()               : bytes left in the entire request
     920                 :            :  * blk_rq_cur_bytes()           : bytes left in the current segment
     921                 :            :  * blk_rq_err_bytes()           : bytes left till the next error boundary
     922                 :            :  * blk_rq_sectors()             : sectors left in the entire request
     923                 :            :  * blk_rq_cur_sectors()         : sectors left in the current segment
     924                 :            :  * blk_rq_stats_sectors()       : sectors of the entire request used for stats
     925                 :            :  */
     926                 :            : static inline sector_t blk_rq_pos(const struct request *rq)
     927                 :            : {
     928                 :   10903993 :         return rq->__sector;
     929                 :            : }
     930                 :            : 
     931                 :            : static inline unsigned int blk_rq_bytes(const struct request *rq)
     932                 :            : {
     933                 :    8074795 :         return rq->__data_len;
     934                 :            : }
     935                 :            : 
     936                 :            : static inline int blk_rq_cur_bytes(const struct request *rq)
     937                 :            : {
     938   [ #  #  #  #  :          0 :         return rq->bio ? bio_cur_bytes(rq->bio) : 0;
                   #  # ]
     939                 :            : }
     940                 :            : 
     941                 :            : extern unsigned int blk_rq_err_bytes(const struct request *rq);
     942                 :            : 
     943                 :            : static inline unsigned int blk_rq_sectors(const struct request *rq)
     944                 :            : {
     945                 :    7988318 :         return blk_rq_bytes(rq) >> SECTOR_SHIFT;
     946                 :            : }
     947                 :            : 
     948                 :            : static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
     949                 :            : {
     950                 :          0 :         return blk_rq_cur_bytes(rq) >> SECTOR_SHIFT;
     951                 :            : }
     952                 :            : 
     953                 :            : static inline unsigned int blk_rq_stats_sectors(const struct request *rq)
     954                 :            : {
     955                 :          0 :         return rq->stats_sectors;
     956                 :            : }
     957                 :            : 
     958                 :            : #ifdef CONFIG_BLK_DEV_ZONED
     959                 :            : static inline unsigned int blk_rq_zone_no(struct request *rq)
     960                 :            : {
     961                 :            :         return blk_queue_zone_no(rq->q, blk_rq_pos(rq));
     962                 :            : }
     963                 :            : 
     964                 :            : static inline unsigned int blk_rq_zone_is_seq(struct request *rq)
     965                 :            : {
     966                 :            :         return blk_queue_zone_is_seq(rq->q, blk_rq_pos(rq));
     967                 :            : }
     968                 :            : #endif /* CONFIG_BLK_DEV_ZONED */
     969                 :            : 
     970                 :            : /*
     971                 :            :  * Some commands like WRITE SAME have a payload or data transfer size which
     972                 :            :  * is different from the size of the request.  Any driver that supports such
     973                 :            :  * commands using the RQF_SPECIAL_PAYLOAD flag needs to use this helper to
     974                 :            :  * calculate the data transfer size.
     975                 :            :  */
     976                 :            : static inline unsigned int blk_rq_payload_bytes(struct request *rq)
     977                 :            : {
     978         [ #  # ]:          0 :         if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
     979                 :          0 :                 return rq->special_vec.bv_len;
     980                 :            :         return blk_rq_bytes(rq);
     981                 :            : }
     982                 :            : 
     983                 :            : /*
     984                 :            :  * Return the first full biovec in the request.  The caller needs to check that
     985                 :            :  * there are any bvecs before calling this helper.
     986                 :            :  */
     987                 :            : static inline struct bio_vec req_bvec(struct request *rq)
     988                 :            : {
     989                 :            :         if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
     990                 :            :                 return rq->special_vec;
     991                 :            :         return mp_bvec_iter_bvec(rq->bio->bi_io_vec, rq->bio->bi_iter);
     992                 :            : }
     993                 :            : 
     994                 :            : static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
     995                 :            :                                                      int op)
     996                 :            : {
     997   [ +  +  #  #  :    1597849 :         if (unlikely(op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE))
             #  #  #  # ]
     998                 :         32 :                 return min(q->limits.max_discard_sectors,
     999                 :            :                            UINT_MAX >> SECTOR_SHIFT);
    1000                 :            : 
    1001   [ -  +  #  #  :    1597818 :         if (unlikely(op == REQ_OP_WRITE_SAME))
             #  #  #  # ]
    1002                 :          0 :                 return q->limits.max_write_same_sectors;
    1003                 :            : 
    1004   [ -  +  #  #  :    1597818 :         if (unlikely(op == REQ_OP_WRITE_ZEROES))
             #  #  #  # ]
    1005                 :          0 :                 return q->limits.max_write_zeroes_sectors;
    1006                 :            : 
    1007                 :    1597818 :         return q->limits.max_sectors;
    1008                 :            : }
    1009                 :            : 
    1010                 :            : /*
    1011                 :            :  * Return maximum size of a request at given offset. Only valid for
    1012                 :            :  * file system requests.
    1013                 :            :  */
    1014                 :            : static inline unsigned int blk_max_size_offset(struct request_queue *q,
    1015                 :            :                                                sector_t offset)
    1016                 :            : {
    1017   [ +  -  #  # ]:    2733444 :         if (!q->limits.chunk_sectors)
    1018                 :    2733444 :                 return q->limits.max_sectors;
    1019                 :            : 
    1020                 :          0 :         return min(q->limits.max_sectors, (unsigned int)(q->limits.chunk_sectors -
    1021                 :            :                         (offset & (q->limits.chunk_sectors - 1))));
    1022                 :            : }
    1023                 :            : 
    1024                 :    1597849 : static inline unsigned int blk_rq_get_max_sectors(struct request *rq,
    1025                 :            :                                                   sector_t offset)
    1026                 :            : {
    1027                 :    1597849 :         struct request_queue *q = rq->q;
    1028                 :            : 
    1029         [ -  + ]:    1597849 :         if (blk_rq_is_passthrough(rq))
    1030                 :          0 :                 return q->limits.max_hw_sectors;
    1031                 :            : 
    1032   [ -  +  #  # ]:    1597849 :         if (!q->limits.chunk_sectors ||
    1033         [ #  # ]:          0 :             req_op(rq) == REQ_OP_DISCARD ||
    1034                 :            :             req_op(rq) == REQ_OP_SECURE_ERASE)
    1035                 :    3195698 :                 return blk_queue_get_max_sectors(q, req_op(rq));
    1036                 :            : 
    1037                 :          0 :         return min(blk_max_size_offset(q, offset),
    1038                 :            :                         blk_queue_get_max_sectors(q, req_op(rq)));
    1039                 :            : }
    1040                 :            : 
    1041                 :            : static inline unsigned int blk_rq_count_bios(struct request *rq)
    1042                 :            : {
    1043                 :            :         unsigned int nr_bios = 0;
    1044                 :            :         struct bio *bio;
    1045                 :            : 
    1046   [ #  #  #  #  :          0 :         __rq_for_each_bio(bio, rq)
             #  #  #  # ]
    1047                 :          0 :                 nr_bios++;
    1048                 :            : 
    1049                 :            :         return nr_bios;
    1050                 :            : }
    1051                 :            : 
    1052                 :            : void blk_steal_bios(struct bio_list *list, struct request *rq);
    1053                 :            : 
    1054                 :            : /*
    1055                 :            :  * Request completion related functions.
    1056                 :            :  *
    1057                 :            :  * blk_update_request() completes given number of bytes and updates
    1058                 :            :  * the request without completing it.
    1059                 :            :  */
    1060                 :            : extern bool blk_update_request(struct request *rq, blk_status_t error,
    1061                 :            :                                unsigned int nr_bytes);
    1062                 :            : 
    1063                 :            : extern void __blk_complete_request(struct request *);
    1064                 :            : extern void blk_abort_request(struct request *);
    1065                 :            : 
    1066                 :            : /*
    1067                 :            :  * Access functions for manipulating queue properties
    1068                 :            :  */
    1069                 :            : extern void blk_cleanup_queue(struct request_queue *);
    1070                 :            : extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
    1071                 :            : extern void blk_queue_bounce_limit(struct request_queue *, u64);
    1072                 :            : extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
    1073                 :            : extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
    1074                 :            : extern void blk_queue_max_segments(struct request_queue *, unsigned short);
    1075                 :            : extern void blk_queue_max_discard_segments(struct request_queue *,
    1076                 :            :                 unsigned short);
    1077                 :            : extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
    1078                 :            : extern void blk_queue_max_discard_sectors(struct request_queue *q,
    1079                 :            :                 unsigned int max_discard_sectors);
    1080                 :            : extern void blk_queue_max_write_same_sectors(struct request_queue *q,
    1081                 :            :                 unsigned int max_write_same_sectors);
    1082                 :            : extern void blk_queue_max_write_zeroes_sectors(struct request_queue *q,
    1083                 :            :                 unsigned int max_write_same_sectors);
    1084                 :            : extern void blk_queue_logical_block_size(struct request_queue *, unsigned int);
    1085                 :            : extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
    1086                 :            : extern void blk_queue_alignment_offset(struct request_queue *q,
    1087                 :            :                                        unsigned int alignment);
    1088                 :            : extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
    1089                 :            : extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
    1090                 :            : extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
    1091                 :            : extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
    1092                 :            : extern void blk_set_queue_depth(struct request_queue *q, unsigned int depth);
    1093                 :            : extern void blk_set_default_limits(struct queue_limits *lim);
    1094                 :            : extern void blk_set_stacking_limits(struct queue_limits *lim);
    1095                 :            : extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
    1096                 :            :                             sector_t offset);
    1097                 :            : extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
    1098                 :            :                             sector_t offset);
    1099                 :            : extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
    1100                 :            :                               sector_t offset);
    1101                 :            : extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
    1102                 :            : extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
    1103                 :            : extern int blk_queue_dma_drain(struct request_queue *q,
    1104                 :            :                                dma_drain_needed_fn *dma_drain_needed,
    1105                 :            :                                void *buf, unsigned int size);
    1106                 :            : extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
    1107                 :            : extern void blk_queue_virt_boundary(struct request_queue *, unsigned long);
    1108                 :            : extern void blk_queue_dma_alignment(struct request_queue *, int);
    1109                 :            : extern void blk_queue_update_dma_alignment(struct request_queue *, int);
    1110                 :            : extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
    1111                 :            : extern void blk_queue_write_cache(struct request_queue *q, bool enabled, bool fua);
    1112                 :            : extern void blk_queue_required_elevator_features(struct request_queue *q,
    1113                 :            :                                                  unsigned int features);
    1114                 :            : extern bool blk_queue_can_use_dma_map_merging(struct request_queue *q,
    1115                 :            :                                               struct device *dev);
    1116                 :            : 
    1117                 :            : /*
    1118                 :            :  * Number of physical segments as sent to the device.
    1119                 :            :  *
    1120                 :            :  * Normally this is the number of discontiguous data segments sent by the
    1121                 :            :  * submitter.  But for data-less command like discard we might have no
    1122                 :            :  * actual data segments submitted, but the driver might have to add it's
    1123                 :            :  * own special payload.  In that case we still return 1 here so that this
    1124                 :            :  * special payload will be mapped.
    1125                 :            :  */
    1126                 :            : static inline unsigned short blk_rq_nr_phys_segments(struct request *rq)
    1127                 :            : {
    1128   [ +  -  #  # ]:    1136452 :         if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
    1129                 :            :                 return 1;
    1130                 :    1136452 :         return rq->nr_phys_segments;
    1131                 :            : }
    1132                 :            : 
    1133                 :            : /*
    1134                 :            :  * Number of discard segments (or ranges) the driver needs to fill in.
    1135                 :            :  * Each discard bio merged into a request is counted as one segment.
    1136                 :            :  */
    1137                 :            : static inline unsigned short blk_rq_nr_discard_segments(struct request *rq)
    1138                 :            : {
    1139   [ #  #  #  # ]:          0 :         return max_t(unsigned short, rq->nr_phys_segments, 1);
    1140                 :            : }
    1141                 :            : 
    1142                 :            : extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
    1143                 :            : extern void blk_dump_rq_flags(struct request *, char *);
    1144                 :            : extern long nr_blockdev_pages(void);
    1145                 :            : 
    1146                 :            : bool __must_check blk_get_queue(struct request_queue *);
    1147                 :            : struct request_queue *blk_alloc_queue(gfp_t);
    1148                 :            : struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id);
    1149                 :            : extern void blk_put_queue(struct request_queue *);
    1150                 :            : extern void blk_set_queue_dying(struct request_queue *);
    1151                 :            : 
    1152                 :            : /*
    1153                 :            :  * blk_plug permits building a queue of related requests by holding the I/O
    1154                 :            :  * fragments for a short period. This allows merging of sequential requests
    1155                 :            :  * into single larger request. As the requests are moved from a per-task list to
    1156                 :            :  * the device's request_queue in a batch, this results in improved scalability
    1157                 :            :  * as the lock contention for request_queue lock is reduced.
    1158                 :            :  *
    1159                 :            :  * It is ok not to disable preemption when adding the request to the plug list
    1160                 :            :  * or when attempting a merge, because blk_schedule_flush_list() will only flush
    1161                 :            :  * the plug list when the task sleeps by itself. For details, please see
    1162                 :            :  * schedule() where blk_schedule_flush_plug() is called.
    1163                 :            :  */
    1164                 :            : struct blk_plug {
    1165                 :            :         struct list_head mq_list; /* blk-mq requests */
    1166                 :            :         struct list_head cb_list; /* md requires an unplug callback */
    1167                 :            :         unsigned short rq_count;
    1168                 :            :         bool multiple_queues;
    1169                 :            : };
    1170                 :            : #define BLK_MAX_REQUEST_COUNT 16
    1171                 :            : #define BLK_PLUG_FLUSH_SIZE (128 * 1024)
    1172                 :            : 
    1173                 :            : struct blk_plug_cb;
    1174                 :            : typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool);
    1175                 :            : struct blk_plug_cb {
    1176                 :            :         struct list_head list;
    1177                 :            :         blk_plug_cb_fn callback;
    1178                 :            :         void *data;
    1179                 :            : };
    1180                 :            : extern struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug,
    1181                 :            :                                              void *data, int size);
    1182                 :            : extern void blk_start_plug(struct blk_plug *);
    1183                 :            : extern void blk_finish_plug(struct blk_plug *);
    1184                 :            : extern void blk_flush_plug_list(struct blk_plug *, bool);
    1185                 :            : 
    1186                 :            : static inline void blk_flush_plug(struct task_struct *tsk)
    1187                 :            : {
    1188                 :        161 :         struct blk_plug *plug = tsk->plug;
    1189                 :            : 
    1190         [ +  - ]:        161 :         if (plug)
    1191                 :        161 :                 blk_flush_plug_list(plug, false);
    1192                 :            : }
    1193                 :            : 
    1194                 :            : static inline void blk_schedule_flush_plug(struct task_struct *tsk)
    1195                 :            : {
    1196                 :     903760 :         struct blk_plug *plug = tsk->plug;
    1197                 :            : 
    1198   [ +  +  +  - ]:     903771 :         if (plug)
    1199                 :       1981 :                 blk_flush_plug_list(plug, true);
    1200                 :            : }
    1201                 :            : 
    1202                 :            : static inline bool blk_needs_flush_plug(struct task_struct *tsk)
    1203                 :            : {
    1204                 :    6900805 :         struct blk_plug *plug = tsk->plug;
    1205                 :            : 
    1206   [ +  +  +  + ]:   13803558 :         return plug &&
    1207         [ -  + ]:       3885 :                  (!list_empty(&plug->mq_list) ||
    1208                 :       1937 :                  !list_empty(&plug->cb_list));
    1209                 :            : }
    1210                 :            : 
    1211                 :            : extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
    1212                 :            : extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
    1213                 :            :                 sector_t nr_sects, gfp_t gfp_mask, struct page *page);
    1214                 :            : 
    1215                 :            : #define BLKDEV_DISCARD_SECURE   (1 << 0)  /* issue a secure erase */
    1216                 :            : 
    1217                 :            : extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
    1218                 :            :                 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
    1219                 :            : extern int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,
    1220                 :            :                 sector_t nr_sects, gfp_t gfp_mask, int flags,
    1221                 :            :                 struct bio **biop);
    1222                 :            : 
    1223                 :            : #define BLKDEV_ZERO_NOUNMAP     (1 << 0)  /* do not free blocks */
    1224                 :            : #define BLKDEV_ZERO_NOFALLBACK  (1 << 1)  /* don't write explicit zeroes */
    1225                 :            : 
    1226                 :            : extern int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
    1227                 :            :                 sector_t nr_sects, gfp_t gfp_mask, struct bio **biop,
    1228                 :            :                 unsigned flags);
    1229                 :            : extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
    1230                 :            :                 sector_t nr_sects, gfp_t gfp_mask, unsigned flags);
    1231                 :            : 
    1232                 :            : static inline int sb_issue_discard(struct super_block *sb, sector_t block,
    1233                 :            :                 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
    1234                 :            : {
    1235                 :          0 :         return blkdev_issue_discard(sb->s_bdev,
    1236                 :          0 :                                     block << (sb->s_blocksize_bits -
    1237                 :            :                                               SECTOR_SHIFT),
    1238                 :            :                                     nr_blocks << (sb->s_blocksize_bits -
    1239                 :            :                                                   SECTOR_SHIFT),
    1240                 :            :                                     gfp_mask, flags);
    1241                 :            : }
    1242                 :            : static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
    1243                 :            :                 sector_t nr_blocks, gfp_t gfp_mask)
    1244                 :            : {
    1245                 :          0 :         return blkdev_issue_zeroout(sb->s_bdev,
    1246                 :          0 :                                     block << (sb->s_blocksize_bits -
    1247                 :            :                                               SECTOR_SHIFT),
    1248                 :            :                                     nr_blocks << (sb->s_blocksize_bits -
    1249                 :            :                                                   SECTOR_SHIFT),
    1250                 :            :                                     gfp_mask, 0);
    1251                 :            : }
    1252                 :            : 
    1253                 :            : extern int blk_verify_command(unsigned char *cmd, fmode_t mode);
    1254                 :            : 
    1255                 :            : enum blk_default_limits {
    1256                 :            :         BLK_MAX_SEGMENTS        = 128,
    1257                 :            :         BLK_SAFE_MAX_SECTORS    = 255,
    1258                 :            :         BLK_DEF_MAX_SECTORS     = 2560,
    1259                 :            :         BLK_MAX_SEGMENT_SIZE    = 65536,
    1260                 :            :         BLK_SEG_BOUNDARY_MASK   = 0xFFFFFFFFUL,
    1261                 :            : };
    1262                 :            : 
    1263                 :            : static inline unsigned long queue_segment_boundary(const struct request_queue *q)
    1264                 :            : {
    1265                 :    2508678 :         return q->limits.seg_boundary_mask;
    1266                 :            : }
    1267                 :            : 
    1268                 :            : static inline unsigned long queue_virt_boundary(const struct request_queue *q)
    1269                 :            : {
    1270                 :    3226654 :         return q->limits.virt_boundary_mask;
    1271                 :            : }
    1272                 :            : 
    1273                 :            : static inline unsigned int queue_max_sectors(const struct request_queue *q)
    1274                 :            : {
    1275                 :          0 :         return q->limits.max_sectors;
    1276                 :            : }
    1277                 :            : 
    1278                 :            : static inline unsigned int queue_max_hw_sectors(const struct request_queue *q)
    1279                 :            : {
    1280                 :          0 :         return q->limits.max_hw_sectors;
    1281                 :            : }
    1282                 :            : 
    1283                 :            : static inline unsigned short queue_max_segments(const struct request_queue *q)
    1284                 :            : {
    1285                 :    4331129 :         return q->limits.max_segments;
    1286                 :            : }
    1287                 :            : 
    1288                 :            : static inline unsigned short queue_max_discard_segments(const struct request_queue *q)
    1289                 :            : {
    1290                 :          0 :         return q->limits.max_discard_segments;
    1291                 :            : }
    1292                 :            : 
    1293                 :            : static inline unsigned int queue_max_segment_size(const struct request_queue *q)
    1294                 :            : {
    1295                 :    2508885 :         return q->limits.max_segment_size;
    1296                 :            : }
    1297                 :            : 
    1298                 :            : static inline unsigned queue_logical_block_size(const struct request_queue *q)
    1299                 :            : {
    1300                 :            :         int retval = 512;
    1301                 :            : 
    1302   [ +  +  +  +  :    3948086 :         if (q && q->limits.logical_block_size)
          #  #  #  #  #  
          #  #  #  +  -  
          +  -  +  -  +  
          -  +  +  +  -  
             #  #  #  # ]
    1303                 :    3947890 :                 retval = q->limits.logical_block_size;
    1304                 :            : 
    1305                 :    3941048 :         return retval;
    1306                 :            : }
    1307                 :            : 
    1308                 :            : static inline unsigned int bdev_logical_block_size(struct block_device *bdev)
    1309                 :            : {
    1310                 :            :         return queue_logical_block_size(bdev_get_queue(bdev));
    1311                 :            : }
    1312                 :            : 
    1313                 :            : static inline unsigned int queue_physical_block_size(const struct request_queue *q)
    1314                 :            : {
    1315                 :    2733444 :         return q->limits.physical_block_size;
    1316                 :            : }
    1317                 :            : 
    1318                 :            : static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
    1319                 :            : {
    1320                 :            :         return queue_physical_block_size(bdev_get_queue(bdev));
    1321                 :            : }
    1322                 :            : 
    1323                 :            : static inline unsigned int queue_io_min(const struct request_queue *q)
    1324                 :            : {
    1325                 :          0 :         return q->limits.io_min;
    1326                 :            : }
    1327                 :            : 
    1328                 :            : static inline int bdev_io_min(struct block_device *bdev)
    1329                 :            : {
    1330                 :            :         return queue_io_min(bdev_get_queue(bdev));
    1331                 :            : }
    1332                 :            : 
    1333                 :            : static inline unsigned int queue_io_opt(const struct request_queue *q)
    1334                 :            : {
    1335                 :          0 :         return q->limits.io_opt;
    1336                 :            : }
    1337                 :            : 
    1338                 :            : static inline int bdev_io_opt(struct block_device *bdev)
    1339                 :            : {
    1340                 :            :         return queue_io_opt(bdev_get_queue(bdev));
    1341                 :            : }
    1342                 :            : 
    1343                 :            : static inline int queue_alignment_offset(const struct request_queue *q)
    1344                 :            : {
    1345         [ #  # ]:          0 :         if (q->limits.misaligned)
    1346                 :            :                 return -1;
    1347                 :            : 
    1348                 :          0 :         return q->limits.alignment_offset;
    1349                 :            : }
    1350                 :            : 
    1351                 :        414 : static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
    1352                 :            : {
    1353                 :        414 :         unsigned int granularity = max(lim->physical_block_size, lim->io_min);
    1354   [ -  +  #  #  :        414 :         unsigned int alignment = sector_div(sector, granularity >> SECTOR_SHIFT)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          -  +  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  +  
                      - ]
    1355                 :            :                 << SECTOR_SHIFT;
    1356                 :            : 
    1357                 :        414 :         return (granularity + lim->alignment_offset - alignment) % granularity;
    1358                 :            : }
    1359                 :            : 
    1360                 :            : static inline int bdev_alignment_offset(struct block_device *bdev)
    1361                 :            : {
    1362                 :            :         struct request_queue *q = bdev_get_queue(bdev);
    1363                 :            : 
    1364         [ #  # ]:          0 :         if (q->limits.misaligned)
    1365                 :            :                 return -1;
    1366                 :            : 
    1367         [ #  # ]:          0 :         if (bdev != bdev->bd_contains)
    1368                 :          0 :                 return bdev->bd_part->alignment_offset;
    1369                 :            : 
    1370                 :          0 :         return q->limits.alignment_offset;
    1371                 :            : }
    1372                 :            : 
    1373                 :            : static inline int queue_discard_alignment(const struct request_queue *q)
    1374                 :            : {
    1375         [ #  # ]:          0 :         if (q->limits.discard_misaligned)
    1376                 :            :                 return -1;
    1377                 :            : 
    1378                 :          0 :         return q->limits.discard_alignment;
    1379                 :            : }
    1380                 :            : 
    1381                 :        414 : static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
    1382                 :            : {
    1383                 :            :         unsigned int alignment, granularity, offset;
    1384                 :            : 
    1385         [ +  - ]:        414 :         if (!lim->max_discard_sectors)
    1386                 :            :                 return 0;
    1387                 :            : 
    1388                 :            :         /* Why are these in bytes, not sectors? */
    1389                 :        414 :         alignment = lim->discard_alignment >> SECTOR_SHIFT;
    1390                 :        414 :         granularity = lim->discard_granularity >> SECTOR_SHIFT;
    1391         [ +  - ]:        414 :         if (!granularity)
    1392                 :            :                 return 0;
    1393                 :            : 
    1394                 :            :         /* Offset of the partition start in 'granularity' sectors */
    1395   [ -  +  #  #  :        414 :         offset = sector_div(sector, granularity);
          -  +  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  +  
                      - ]
    1396                 :            : 
    1397                 :            :         /* And why do we do this modulus *again* in blkdev_issue_discard()? */
    1398                 :        414 :         offset = (granularity + alignment - offset) % granularity;
    1399                 :            : 
    1400                 :            :         /* Turn it back into bytes, gaah */
    1401                 :        414 :         return offset << SECTOR_SHIFT;
    1402                 :            : }
    1403                 :            : 
    1404                 :            : static inline int bdev_discard_alignment(struct block_device *bdev)
    1405                 :            : {
    1406                 :            :         struct request_queue *q = bdev_get_queue(bdev);
    1407                 :            : 
    1408                 :            :         if (bdev != bdev->bd_contains)
    1409                 :            :                 return bdev->bd_part->discard_alignment;
    1410                 :            : 
    1411                 :            :         return q->limits.discard_alignment;
    1412                 :            : }
    1413                 :            : 
    1414                 :            : static inline unsigned int bdev_write_same(struct block_device *bdev)
    1415                 :            : {
    1416                 :            :         struct request_queue *q = bdev_get_queue(bdev);
    1417                 :            : 
    1418         [ #  # ]:          0 :         if (q)
    1419                 :          0 :                 return q->limits.max_write_same_sectors;
    1420                 :            : 
    1421                 :            :         return 0;
    1422                 :            : }
    1423                 :            : 
    1424                 :            : static inline unsigned int bdev_write_zeroes_sectors(struct block_device *bdev)
    1425                 :            : {
    1426                 :            :         struct request_queue *q = bdev_get_queue(bdev);
    1427                 :            : 
    1428   [ #  #  #  #  :          0 :         if (q)
                   #  # ]
    1429                 :          0 :                 return q->limits.max_write_zeroes_sectors;
    1430                 :            : 
    1431                 :            :         return 0;
    1432                 :            : }
    1433                 :            : 
    1434                 :            : static inline enum blk_zoned_model bdev_zoned_model(struct block_device *bdev)
    1435                 :            : {
    1436                 :            :         struct request_queue *q = bdev_get_queue(bdev);
    1437                 :            : 
    1438                 :            :         if (q)
    1439                 :            :                 return blk_queue_zoned_model(q);
    1440                 :            : 
    1441                 :            :         return BLK_ZONED_NONE;
    1442                 :            : }
    1443                 :            : 
    1444                 :            : static inline bool bdev_is_zoned(struct block_device *bdev)
    1445                 :            : {
    1446                 :            :         struct request_queue *q = bdev_get_queue(bdev);
    1447                 :            : 
    1448   [ +  -  #  # ]:        414 :         if (q)
    1449                 :            :                 return blk_queue_is_zoned(q);
    1450                 :            : 
    1451                 :            :         return false;
    1452                 :            : }
    1453                 :            : 
    1454                 :            : static inline sector_t bdev_zone_sectors(struct block_device *bdev)
    1455                 :            : {
    1456                 :            :         struct request_queue *q = bdev_get_queue(bdev);
    1457                 :            : 
    1458         [ #  # ]:          0 :         if (q)
    1459                 :            :                 return blk_queue_zone_sectors(q);
    1460                 :            :         return 0;
    1461                 :            : }
    1462                 :            : 
    1463                 :            : static inline int queue_dma_alignment(const struct request_queue *q)
    1464                 :            : {
    1465   [ #  #  #  # ]:          0 :         return q ? q->dma_alignment : 511;
    1466                 :            : }
    1467                 :            : 
    1468                 :            : static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
    1469                 :            :                                  unsigned int len)
    1470                 :            : {
    1471                 :          0 :         unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
    1472   [ #  #  #  # ]:          0 :         return !(addr & alignment) && !(len & alignment);
    1473                 :            : }
    1474                 :            : 
    1475                 :            : /* assumes size > 256 */
    1476                 :            : static inline unsigned int blksize_bits(unsigned int size)
    1477                 :            : {
    1478                 :            :         unsigned int bits = 8;
    1479                 :            :         do {
    1480                 :    4438611 :                 bits++;
    1481                 :    4438611 :                 size >>= 1;
    1482   [ +  +  +  +  :    4438611 :         } while (size > 256);
                   +  + ]
    1483                 :    1190244 :         return bits;
    1484                 :            : }
    1485                 :            : 
    1486                 :            : static inline unsigned int block_size(struct block_device *bdev)
    1487                 :            : {
    1488                 :        414 :         return bdev->bd_block_size;
    1489                 :            : }
    1490                 :            : 
    1491                 :            : typedef struct {struct page *v;} Sector;
    1492                 :            : 
    1493                 :            : unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
    1494                 :            : 
    1495                 :            : static inline void put_dev_sector(Sector p)
    1496                 :            : {
    1497                 :      10350 :         put_page(p.v);
    1498                 :            : }
    1499                 :            : 
    1500                 :            : int kblockd_schedule_work(struct work_struct *work);
    1501                 :            : int kblockd_schedule_work_on(int cpu, struct work_struct *work);
    1502                 :            : int kblockd_mod_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
    1503                 :            : 
    1504                 :            : #define MODULE_ALIAS_BLOCKDEV(major,minor) \
    1505                 :            :         MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
    1506                 :            : #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
    1507                 :            :         MODULE_ALIAS("block-major-" __stringify(major) "-*")
    1508                 :            : 
    1509                 :            : #if defined(CONFIG_BLK_DEV_INTEGRITY)
    1510                 :            : 
    1511                 :            : enum blk_integrity_flags {
    1512                 :            :         BLK_INTEGRITY_VERIFY            = 1 << 0,
    1513                 :            :         BLK_INTEGRITY_GENERATE          = 1 << 1,
    1514                 :            :         BLK_INTEGRITY_DEVICE_CAPABLE    = 1 << 2,
    1515                 :            :         BLK_INTEGRITY_IP_CHECKSUM       = 1 << 3,
    1516                 :            : };
    1517                 :            : 
    1518                 :            : struct blk_integrity_iter {
    1519                 :            :         void                    *prot_buf;
    1520                 :            :         void                    *data_buf;
    1521                 :            :         sector_t                seed;
    1522                 :            :         unsigned int            data_size;
    1523                 :            :         unsigned short          interval;
    1524                 :            :         const char              *disk_name;
    1525                 :            : };
    1526                 :            : 
    1527                 :            : typedef blk_status_t (integrity_processing_fn) (struct blk_integrity_iter *);
    1528                 :            : typedef void (integrity_prepare_fn) (struct request *);
    1529                 :            : typedef void (integrity_complete_fn) (struct request *, unsigned int);
    1530                 :            : 
    1531                 :            : struct blk_integrity_profile {
    1532                 :            :         integrity_processing_fn         *generate_fn;
    1533                 :            :         integrity_processing_fn         *verify_fn;
    1534                 :            :         integrity_prepare_fn            *prepare_fn;
    1535                 :            :         integrity_complete_fn           *complete_fn;
    1536                 :            :         const char                      *name;
    1537                 :            : };
    1538                 :            : 
    1539                 :            : extern void blk_integrity_register(struct gendisk *, struct blk_integrity *);
    1540                 :            : extern void blk_integrity_unregister(struct gendisk *);
    1541                 :            : extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
    1542                 :            : extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
    1543                 :            :                                    struct scatterlist *);
    1544                 :            : extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
    1545                 :            : extern bool blk_integrity_merge_rq(struct request_queue *, struct request *,
    1546                 :            :                                    struct request *);
    1547                 :            : extern bool blk_integrity_merge_bio(struct request_queue *, struct request *,
    1548                 :            :                                     struct bio *);
    1549                 :            : 
    1550                 :            : static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
    1551                 :            : {
    1552                 :            :         struct blk_integrity *bi = &disk->queue->integrity;
    1553                 :            : 
    1554                 :            :         if (!bi->profile)
    1555                 :            :                 return NULL;
    1556                 :            : 
    1557                 :            :         return bi;
    1558                 :            : }
    1559                 :            : 
    1560                 :            : static inline
    1561                 :            : struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
    1562                 :            : {
    1563                 :            :         return blk_get_integrity(bdev->bd_disk);
    1564                 :            : }
    1565                 :            : 
    1566                 :            : static inline bool blk_integrity_rq(struct request *rq)
    1567                 :            : {
    1568                 :            :         return rq->cmd_flags & REQ_INTEGRITY;
    1569                 :            : }
    1570                 :            : 
    1571                 :            : static inline void blk_queue_max_integrity_segments(struct request_queue *q,
    1572                 :            :                                                     unsigned int segs)
    1573                 :            : {
    1574                 :            :         q->limits.max_integrity_segments = segs;
    1575                 :            : }
    1576                 :            : 
    1577                 :            : static inline unsigned short
    1578                 :            : queue_max_integrity_segments(const struct request_queue *q)
    1579                 :            : {
    1580                 :            :         return q->limits.max_integrity_segments;
    1581                 :            : }
    1582                 :            : 
    1583                 :            : /**
    1584                 :            :  * bio_integrity_intervals - Return number of integrity intervals for a bio
    1585                 :            :  * @bi:         blk_integrity profile for device
    1586                 :            :  * @sectors:    Size of the bio in 512-byte sectors
    1587                 :            :  *
    1588                 :            :  * Description: The block layer calculates everything in 512 byte
    1589                 :            :  * sectors but integrity metadata is done in terms of the data integrity
    1590                 :            :  * interval size of the storage device.  Convert the block layer sectors
    1591                 :            :  * to the appropriate number of integrity intervals.
    1592                 :            :  */
    1593                 :            : static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
    1594                 :            :                                                    unsigned int sectors)
    1595                 :            : {
    1596                 :            :         return sectors >> (bi->interval_exp - 9);
    1597                 :            : }
    1598                 :            : 
    1599                 :            : static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
    1600                 :            :                                                unsigned int sectors)
    1601                 :            : {
    1602                 :            :         return bio_integrity_intervals(bi, sectors) * bi->tuple_size;
    1603                 :            : }
    1604                 :            : 
    1605                 :            : /*
    1606                 :            :  * Return the first bvec that contains integrity data.  Only drivers that are
    1607                 :            :  * limited to a single integrity segment should use this helper.
    1608                 :            :  */
    1609                 :            : static inline struct bio_vec *rq_integrity_vec(struct request *rq)
    1610                 :            : {
    1611                 :            :         if (WARN_ON_ONCE(queue_max_integrity_segments(rq->q) > 1))
    1612                 :            :                 return NULL;
    1613                 :            :         return rq->bio->bi_integrity->bip_vec;
    1614                 :            : }
    1615                 :            : 
    1616                 :            : #else /* CONFIG_BLK_DEV_INTEGRITY */
    1617                 :            : 
    1618                 :            : struct bio;
    1619                 :            : struct block_device;
    1620                 :            : struct gendisk;
    1621                 :            : struct blk_integrity;
    1622                 :            : 
    1623                 :            : static inline int blk_integrity_rq(struct request *rq)
    1624                 :            : {
    1625                 :            :         return 0;
    1626                 :            : }
    1627                 :            : static inline int blk_rq_count_integrity_sg(struct request_queue *q,
    1628                 :            :                                             struct bio *b)
    1629                 :            : {
    1630                 :            :         return 0;
    1631                 :            : }
    1632                 :            : static inline int blk_rq_map_integrity_sg(struct request_queue *q,
    1633                 :            :                                           struct bio *b,
    1634                 :            :                                           struct scatterlist *s)
    1635                 :            : {
    1636                 :            :         return 0;
    1637                 :            : }
    1638                 :            : static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
    1639                 :            : {
    1640                 :            :         return NULL;
    1641                 :            : }
    1642                 :            : static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
    1643                 :            : {
    1644                 :            :         return NULL;
    1645                 :            : }
    1646                 :            : static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
    1647                 :            : {
    1648                 :            :         return 0;
    1649                 :            : }
    1650                 :            : static inline void blk_integrity_register(struct gendisk *d,
    1651                 :            :                                          struct blk_integrity *b)
    1652                 :            : {
    1653                 :            : }
    1654                 :            : static inline void blk_integrity_unregister(struct gendisk *d)
    1655                 :            : {
    1656                 :            : }
    1657                 :            : static inline void blk_queue_max_integrity_segments(struct request_queue *q,
    1658                 :            :                                                     unsigned int segs)
    1659                 :            : {
    1660                 :            : }
    1661                 :            : static inline unsigned short queue_max_integrity_segments(const struct request_queue *q)
    1662                 :            : {
    1663                 :            :         return 0;
    1664                 :            : }
    1665                 :            : static inline bool blk_integrity_merge_rq(struct request_queue *rq,
    1666                 :            :                                           struct request *r1,
    1667                 :            :                                           struct request *r2)
    1668                 :            : {
    1669                 :            :         return true;
    1670                 :            : }
    1671                 :            : static inline bool blk_integrity_merge_bio(struct request_queue *rq,
    1672                 :            :                                            struct request *r,
    1673                 :            :                                            struct bio *b)
    1674                 :            : {
    1675                 :            :         return true;
    1676                 :            : }
    1677                 :            : 
    1678                 :            : static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
    1679                 :            :                                                    unsigned int sectors)
    1680                 :            : {
    1681                 :            :         return 0;
    1682                 :            : }
    1683                 :            : 
    1684                 :            : static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
    1685                 :            :                                                unsigned int sectors)
    1686                 :            : {
    1687                 :            :         return 0;
    1688                 :            : }
    1689                 :            : 
    1690                 :            : static inline struct bio_vec *rq_integrity_vec(struct request *rq)
    1691                 :            : {
    1692                 :            :         return NULL;
    1693                 :            : }
    1694                 :            : 
    1695                 :            : #endif /* CONFIG_BLK_DEV_INTEGRITY */
    1696                 :            : 
    1697                 :            : struct block_device_operations {
    1698                 :            :         int (*open) (struct block_device *, fmode_t);
    1699                 :            :         void (*release) (struct gendisk *, fmode_t);
    1700                 :            :         int (*rw_page)(struct block_device *, sector_t, struct page *, unsigned int);
    1701                 :            :         int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
    1702                 :            :         int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
    1703                 :            :         unsigned int (*check_events) (struct gendisk *disk,
    1704                 :            :                                       unsigned int clearing);
    1705                 :            :         /* ->media_changed() is DEPRECATED, use ->check_events() instead */
    1706                 :            :         int (*media_changed) (struct gendisk *);
    1707                 :            :         void (*unlock_native_capacity) (struct gendisk *);
    1708                 :            :         int (*revalidate_disk) (struct gendisk *);
    1709                 :            :         int (*getgeo)(struct block_device *, struct hd_geometry *);
    1710                 :            :         /* this callback is with swap_lock and sometimes page table lock held */
    1711                 :            :         void (*swap_slot_free_notify) (struct block_device *, unsigned long);
    1712                 :            :         int (*report_zones)(struct gendisk *, sector_t sector,
    1713                 :            :                             struct blk_zone *zones, unsigned int *nr_zones);
    1714                 :            :         struct module *owner;
    1715                 :            :         const struct pr_ops *pr_ops;
    1716                 :            : };
    1717                 :            : 
    1718                 :            : extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
    1719                 :            :                                  unsigned long);
    1720                 :            : extern int bdev_read_page(struct block_device *, sector_t, struct page *);
    1721                 :            : extern int bdev_write_page(struct block_device *, sector_t, struct page *,
    1722                 :            :                                                 struct writeback_control *);
    1723                 :            : 
    1724                 :            : #ifdef CONFIG_BLK_DEV_ZONED
    1725                 :            : bool blk_req_needs_zone_write_lock(struct request *rq);
    1726                 :            : void __blk_req_zone_write_lock(struct request *rq);
    1727                 :            : void __blk_req_zone_write_unlock(struct request *rq);
    1728                 :            : 
    1729                 :            : static inline void blk_req_zone_write_lock(struct request *rq)
    1730                 :            : {
    1731                 :            :         if (blk_req_needs_zone_write_lock(rq))
    1732                 :            :                 __blk_req_zone_write_lock(rq);
    1733                 :            : }
    1734                 :            : 
    1735                 :            : static inline void blk_req_zone_write_unlock(struct request *rq)
    1736                 :            : {
    1737                 :            :         if (rq->rq_flags & RQF_ZONE_WRITE_LOCKED)
    1738                 :            :                 __blk_req_zone_write_unlock(rq);
    1739                 :            : }
    1740                 :            : 
    1741                 :            : static inline bool blk_req_zone_is_write_locked(struct request *rq)
    1742                 :            : {
    1743                 :            :         return rq->q->seq_zones_wlock &&
    1744                 :            :                 test_bit(blk_rq_zone_no(rq), rq->q->seq_zones_wlock);
    1745                 :            : }
    1746                 :            : 
    1747                 :            : static inline bool blk_req_can_dispatch_to_zone(struct request *rq)
    1748                 :            : {
    1749                 :            :         if (!blk_req_needs_zone_write_lock(rq))
    1750                 :            :                 return true;
    1751                 :            :         return !blk_req_zone_is_write_locked(rq);
    1752                 :            : }
    1753                 :            : #else
    1754                 :            : static inline bool blk_req_needs_zone_write_lock(struct request *rq)
    1755                 :            : {
    1756                 :            :         return false;
    1757                 :            : }
    1758                 :            : 
    1759                 :            : static inline void blk_req_zone_write_lock(struct request *rq)
    1760                 :            : {
    1761                 :            : }
    1762                 :            : 
    1763                 :            : static inline void blk_req_zone_write_unlock(struct request *rq)
    1764                 :            : {
    1765                 :            : }
    1766                 :            : static inline bool blk_req_zone_is_write_locked(struct request *rq)
    1767                 :            : {
    1768                 :            :         return false;
    1769                 :            : }
    1770                 :            : 
    1771                 :            : static inline bool blk_req_can_dispatch_to_zone(struct request *rq)
    1772                 :            : {
    1773                 :            :         return true;
    1774                 :            : }
    1775                 :            : #endif /* CONFIG_BLK_DEV_ZONED */
    1776                 :            : 
    1777                 :            : #else /* CONFIG_BLOCK */
    1778                 :            : 
    1779                 :            : struct block_device;
    1780                 :            : 
    1781                 :            : /*
    1782                 :            :  * stubs for when the block layer is configured out
    1783                 :            :  */
    1784                 :            : #define buffer_heads_over_limit 0
    1785                 :            : 
    1786                 :            : static inline long nr_blockdev_pages(void)
    1787                 :            : {
    1788                 :            :         return 0;
    1789                 :            : }
    1790                 :            : 
    1791                 :            : struct blk_plug {
    1792                 :            : };
    1793                 :            : 
    1794                 :            : static inline void blk_start_plug(struct blk_plug *plug)
    1795                 :            : {
    1796                 :            : }
    1797                 :            : 
    1798                 :            : static inline void blk_finish_plug(struct blk_plug *plug)
    1799                 :            : {
    1800                 :            : }
    1801                 :            : 
    1802                 :            : static inline void blk_flush_plug(struct task_struct *task)
    1803                 :            : {
    1804                 :            : }
    1805                 :            : 
    1806                 :            : static inline void blk_schedule_flush_plug(struct task_struct *task)
    1807                 :            : {
    1808                 :            : }
    1809                 :            : 
    1810                 :            : 
    1811                 :            : static inline bool blk_needs_flush_plug(struct task_struct *tsk)
    1812                 :            : {
    1813                 :            :         return false;
    1814                 :            : }
    1815                 :            : 
    1816                 :            : static inline int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
    1817                 :            :                                      sector_t *error_sector)
    1818                 :            : {
    1819                 :            :         return 0;
    1820                 :            : }
    1821                 :            : 
    1822                 :            : #endif /* CONFIG_BLOCK */
    1823                 :            : 
    1824                 :          0 : static inline void blk_wake_io_task(struct task_struct *waiter)
    1825                 :            : {
    1826                 :            :         /*
    1827                 :            :          * If we're polling, the task itself is doing the completions. For
    1828                 :            :          * that case, we don't need to signal a wakeup, it's enough to just
    1829                 :            :          * mark us as RUNNING.
    1830                 :            :          */
    1831         [ #  # ]:          0 :         if (waiter == current)
    1832                 :          0 :                 __set_current_state(TASK_RUNNING);
    1833                 :            :         else
    1834                 :          0 :                 wake_up_process(waiter);
    1835                 :          0 : }
    1836                 :            : 
    1837                 :            : #endif

Generated by: LCOV version 1.14