1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef INT_BLK_MQ_H 3 #define INT_BLK_MQ_H 4 5 #include "blk-stat.h" 6 #include "blk-mq-tag.h" 7 8 struct blk_mq_tag_set; 9 10 struct blk_mq_ctx { 11 struct { 12 spinlock_t lock; 13 struct list_head rq_list; 14 } ____cacheline_aligned_in_smp; 15 16 unsigned int cpu; 17 unsigned int index_hw; 18 19 /* incremented at dispatch time */ 20 unsigned long rq_dispatched[2]; 21 unsigned long rq_merged; 22 23 /* incremented at completion time */ 24 unsigned long ____cacheline_aligned_in_smp rq_completed[2]; 25 26 struct request_queue *queue; 27 struct kobject kobj; 28 } ____cacheline_aligned_in_smp; 29 30 /* 31 * Bits for request->gstate. The lower two bits carry MQ_RQ_* state value 32 * and the upper bits the generation number. 33 */ 34 enum mq_rq_state { 35 MQ_RQ_IDLE = 0, 36 MQ_RQ_IN_FLIGHT = 1, 37 MQ_RQ_COMPLETE = 2, 38 39 MQ_RQ_STATE_BITS = 2, 40 MQ_RQ_STATE_MASK = (1 << MQ_RQ_STATE_BITS) - 1, 41 MQ_RQ_GEN_INC = 1 << MQ_RQ_STATE_BITS, 42 }; 43 44 void blk_mq_freeze_queue(struct request_queue *q); 45 void blk_mq_free_queue(struct request_queue *q); 46 int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr); 47 void blk_mq_wake_waiters(struct request_queue *q); 48 bool blk_mq_dispatch_rq_list(struct request_queue *, struct list_head *, bool); 49 void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list); 50 bool blk_mq_get_driver_tag(struct request *rq, struct blk_mq_hw_ctx **hctx, 51 bool wait); 52 struct request *blk_mq_dequeue_from_ctx(struct blk_mq_hw_ctx *hctx, 53 struct blk_mq_ctx *start); 54 55 /* 56 * Internal helpers for allocating/freeing the request map 57 */ 58 void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, 59 unsigned int hctx_idx); 60 void blk_mq_free_rq_map(struct blk_mq_tags *tags); 61 struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, 62 unsigned int hctx_idx, 63 unsigned int nr_tags, 64 unsigned int reserved_tags); 65 int blk_mq_alloc_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, 66 unsigned int hctx_idx, unsigned int depth); 67 68 /* 69 * Internal helpers for request insertion into sw queues 70 */ 71 void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq, 72 bool at_head); 73 void blk_mq_request_bypass_insert(struct request *rq, bool run_queue); 74 void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, 75 struct list_head *list); 76 77 /* Used by blk_insert_cloned_request() to issue request directly */ 78 blk_status_t blk_mq_request_issue_directly(struct request *rq); 79 80 /* 81 * CPU -> queue mappings 82 */ 83 extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int); 84 85 static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q, 86 int cpu) 87 { 88 return q->queue_hw_ctx[q->mq_map[cpu]]; 89 } 90 91 /* 92 * sysfs helpers 93 */ 94 extern void blk_mq_sysfs_init(struct request_queue *q); 95 extern void blk_mq_sysfs_deinit(struct request_queue *q); 96 extern int __blk_mq_register_dev(struct device *dev, struct request_queue *q); 97 extern int blk_mq_sysfs_register(struct request_queue *q); 98 extern void blk_mq_sysfs_unregister(struct request_queue *q); 99 extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx); 100 101 void blk_mq_release(struct request_queue *q); 102 103 /** 104 * blk_mq_rq_state() - read the current MQ_RQ_* state of a request 105 * @rq: target request. 106 */ 107 static inline int blk_mq_rq_state(struct request *rq) 108 { 109 return READ_ONCE(rq->gstate) & MQ_RQ_STATE_MASK; 110 } 111 112 /** 113 * blk_mq_rq_update_state() - set the current MQ_RQ_* state of a request 114 * @rq: target request. 115 * @state: new state to set. 116 * 117 * Set @rq's state to @state. The caller is responsible for ensuring that 118 * there are no other updaters. A request can transition into IN_FLIGHT 119 * only from IDLE and doing so increments the generation number. 120 */ 121 static inline void blk_mq_rq_update_state(struct request *rq, 122 enum mq_rq_state state) 123 { 124 u64 old_val = READ_ONCE(rq->gstate); 125 u64 new_val = (old_val & ~MQ_RQ_STATE_MASK) | state; 126 127 if (state == MQ_RQ_IN_FLIGHT) { 128 WARN_ON_ONCE((old_val & MQ_RQ_STATE_MASK) != MQ_RQ_IDLE); 129 new_val += MQ_RQ_GEN_INC; 130 } 131 132 /* avoid exposing interim values */ 133 WRITE_ONCE(rq->gstate, new_val); 134 } 135 136 static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q, 137 unsigned int cpu) 138 { 139 return per_cpu_ptr(q->queue_ctx, cpu); 140 } 141 142 /* 143 * This assumes per-cpu software queueing queues. They could be per-node 144 * as well, for instance. For now this is hardcoded as-is. Note that we don't 145 * care about preemption, since we know the ctx's are persistent. This does 146 * mean that we can't rely on ctx always matching the currently running CPU. 147 */ 148 static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) 149 { 150 return __blk_mq_get_ctx(q, get_cpu()); 151 } 152 153 static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx) 154 { 155 put_cpu(); 156 } 157 158 struct blk_mq_alloc_data { 159 /* input parameter */ 160 struct request_queue *q; 161 blk_mq_req_flags_t flags; 162 unsigned int shallow_depth; 163 164 /* input & output parameter */ 165 struct blk_mq_ctx *ctx; 166 struct blk_mq_hw_ctx *hctx; 167 }; 168 169 static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data) 170 { 171 if (data->flags & BLK_MQ_REQ_INTERNAL) 172 return data->hctx->sched_tags; 173 174 return data->hctx->tags; 175 } 176 177 static inline bool blk_mq_hctx_stopped(struct blk_mq_hw_ctx *hctx) 178 { 179 return test_bit(BLK_MQ_S_STOPPED, &hctx->state); 180 } 181 182 static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) 183 { 184 return hctx->nr_ctx && hctx->tags; 185 } 186 187 void blk_mq_in_flight(struct request_queue *q, struct hd_struct *part, 188 unsigned int inflight[2]); 189 190 static inline void blk_mq_put_dispatch_budget(struct blk_mq_hw_ctx *hctx) 191 { 192 struct request_queue *q = hctx->queue; 193 194 if (q->mq_ops->put_budget) 195 q->mq_ops->put_budget(hctx); 196 } 197 198 static inline bool blk_mq_get_dispatch_budget(struct blk_mq_hw_ctx *hctx) 199 { 200 struct request_queue *q = hctx->queue; 201 202 if (q->mq_ops->get_budget) 203 return q->mq_ops->get_budget(hctx); 204 return true; 205 } 206 207 static inline void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx, 208 struct request *rq) 209 { 210 blk_mq_put_tag(hctx, hctx->tags, rq->mq_ctx, rq->tag); 211 rq->tag = -1; 212 213 if (rq->rq_flags & RQF_MQ_INFLIGHT) { 214 rq->rq_flags &= ~RQF_MQ_INFLIGHT; 215 atomic_dec(&hctx->nr_active); 216 } 217 } 218 219 static inline void blk_mq_put_driver_tag_hctx(struct blk_mq_hw_ctx *hctx, 220 struct request *rq) 221 { 222 if (rq->tag == -1 || rq->internal_tag == -1) 223 return; 224 225 __blk_mq_put_driver_tag(hctx, rq); 226 } 227 228 static inline void blk_mq_put_driver_tag(struct request *rq) 229 { 230 struct blk_mq_hw_ctx *hctx; 231 232 if (rq->tag == -1 || rq->internal_tag == -1) 233 return; 234 235 hctx = blk_mq_map_queue(rq->q, rq->mq_ctx->cpu); 236 __blk_mq_put_driver_tag(hctx, rq); 237 } 238 239 #endif 240