Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef INT_BLK_MQ_TAG_H
       3             : #define INT_BLK_MQ_TAG_H
       4             : 
       5             : struct blk_mq_alloc_data;
       6             : 
       7             : extern struct blk_mq_tags *blk_mq_init_tags(unsigned int nr_tags,
       8             :                                         unsigned int reserved_tags,
       9             :                                         int node, int alloc_policy);
      10             : extern void blk_mq_free_tags(struct blk_mq_tags *tags);
      11             : extern int blk_mq_init_bitmaps(struct sbitmap_queue *bitmap_tags,
      12             :                                struct sbitmap_queue *breserved_tags,
      13             :                                unsigned int queue_depth,
      14             :                                unsigned int reserved,
      15             :                                int node, int alloc_policy);
      16             : 
      17             : extern unsigned int blk_mq_get_tag(struct blk_mq_alloc_data *data);
      18             : unsigned long blk_mq_get_tags(struct blk_mq_alloc_data *data, int nr_tags,
      19             :                               unsigned int *offset);
      20             : extern void blk_mq_put_tag(struct blk_mq_tags *tags, struct blk_mq_ctx *ctx,
      21             :                            unsigned int tag);
      22             : void blk_mq_put_tags(struct blk_mq_tags *tags, int *tag_array, int nr_tags);
      23             : extern int blk_mq_tag_update_depth(struct blk_mq_hw_ctx *hctx,
      24             :                                         struct blk_mq_tags **tags,
      25             :                                         unsigned int depth, bool can_grow);
      26             : extern void blk_mq_tag_resize_shared_tags(struct blk_mq_tag_set *set,
      27             :                                              unsigned int size);
      28             : extern void blk_mq_tag_update_sched_shared_tags(struct request_queue *q);
      29             : 
      30             : extern void blk_mq_tag_wakeup_all(struct blk_mq_tags *tags, bool);
      31             : void blk_mq_queue_tag_busy_iter(struct request_queue *q, busy_tag_iter_fn *fn,
      32             :                 void *priv);
      33             : void blk_mq_all_tag_iter(struct blk_mq_tags *tags, busy_tag_iter_fn *fn,
      34             :                 void *priv);
      35             : 
      36             : static inline struct sbq_wait_state *bt_wait_ptr(struct sbitmap_queue *bt,
      37             :                                                  struct blk_mq_hw_ctx *hctx)
      38             : {
      39           0 :         if (!hctx)
      40           0 :                 return &bt->ws[0];
      41           0 :         return sbq_wait_ptr(bt, &hctx->wait_index);
      42             : }
      43             : 
      44             : enum {
      45             :         BLK_MQ_NO_TAG           = -1U,
      46             :         BLK_MQ_TAG_MIN          = 1,
      47             :         BLK_MQ_TAG_MAX          = BLK_MQ_NO_TAG - 1,
      48             : };
      49             : 
      50             : extern void __blk_mq_tag_busy(struct blk_mq_hw_ctx *);
      51             : extern void __blk_mq_tag_idle(struct blk_mq_hw_ctx *);
      52             : 
      53             : static inline void blk_mq_tag_busy(struct blk_mq_hw_ctx *hctx)
      54             : {
      55           0 :         if (hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED)
      56           0 :                 __blk_mq_tag_busy(hctx);
      57             : }
      58             : 
      59             : static inline void blk_mq_tag_idle(struct blk_mq_hw_ctx *hctx)
      60             : {
      61           0 :         if (!(hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED))
      62             :                 return;
      63             : 
      64           0 :         __blk_mq_tag_idle(hctx);
      65             : }
      66             : 
      67             : static inline bool blk_mq_tag_is_reserved(struct blk_mq_tags *tags,
      68             :                                           unsigned int tag)
      69             : {
      70             :         return tag < tags->nr_reserved_tags;
      71             : }
      72             : 
      73             : #endif