LCOV - code coverage report
Current view: top level - include/linux - blkdev.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 102 220 46.4 %
Date: 2022-04-01 13:59:58 Functions: 2 3 66.7 %
Branches: 129 409 31.5 %

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

Generated by: LCOV version 1.14