Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
320ae51f JA |
2 | #ifndef INT_BLK_MQ_H |
3 | #define INT_BLK_MQ_H | |
4 | ||
cf43e6be | 5 | #include "blk-stat.h" |
244c65a3 | 6 | #include "blk-mq-tag.h" |
cf43e6be | 7 | |
24d2f903 CH |
8 | struct blk_mq_tag_set; |
9 | ||
1db4909e ML |
10 | struct blk_mq_ctxs { |
11 | struct kobject kobj; | |
12 | struct blk_mq_ctx __percpu *queue_ctx; | |
13 | }; | |
14 | ||
fe644072 LW |
15 | /** |
16 | * struct blk_mq_ctx - State for a software queue facing the submitting CPUs | |
17 | */ | |
320ae51f JA |
18 | struct blk_mq_ctx { |
19 | struct { | |
20 | spinlock_t lock; | |
c16d6b5a ML |
21 | struct list_head rq_lists[HCTX_MAX_TYPES]; |
22 | } ____cacheline_aligned_in_smp; | |
320ae51f JA |
23 | |
24 | unsigned int cpu; | |
f31967f0 | 25 | unsigned short index_hw[HCTX_MAX_TYPES]; |
8ccdf4a3 | 26 | struct blk_mq_hw_ctx *hctxs[HCTX_MAX_TYPES]; |
320ae51f | 27 | |
320ae51f | 28 | struct request_queue *queue; |
1db4909e | 29 | struct blk_mq_ctxs *ctxs; |
320ae51f | 30 | struct kobject kobj; |
4bb659b1 | 31 | } ____cacheline_aligned_in_smp; |
320ae51f | 32 | |
3e08773c | 33 | void blk_mq_submit_bio(struct bio *bio); |
5a72e899 JA |
34 | int blk_mq_poll(struct request_queue *q, blk_qc_t cookie, struct io_comp_batch *iob, |
35 | unsigned int flags); | |
c7e2d94b | 36 | void blk_mq_exit_queue(struct request_queue *q); |
e3a2b3f9 | 37 | int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr); |
aed3ea94 | 38 | void blk_mq_wake_waiters(struct request_queue *q); |
1fd40b5e ML |
39 | bool blk_mq_dispatch_rq_list(struct blk_mq_hw_ctx *hctx, struct list_head *, |
40 | unsigned int); | |
e6c98712 BVA |
41 | void blk_mq_add_to_requeue_list(struct request *rq, bool at_head, |
42 | bool kick_requeue_list); | |
2c3ad667 | 43 | void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list); |
b347689f ML |
44 | struct request *blk_mq_dequeue_from_ctx(struct blk_mq_hw_ctx *hctx, |
45 | struct blk_mq_ctx *start); | |
2e315dc0 | 46 | void blk_mq_put_rq_ref(struct request *rq); |
2c3ad667 JA |
47 | |
48 | /* | |
49 | * Internal helpers for allocating/freeing the request map | |
50 | */ | |
cc71a6f4 JA |
51 | void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, |
52 | unsigned int hctx_idx); | |
e155b0c2 | 53 | void blk_mq_free_rq_map(struct blk_mq_tags *tags); |
63064be1 JG |
54 | struct blk_mq_tags *blk_mq_alloc_map_and_rqs(struct blk_mq_tag_set *set, |
55 | unsigned int hctx_idx, unsigned int depth); | |
645db34e JG |
56 | void blk_mq_free_map_and_rqs(struct blk_mq_tag_set *set, |
57 | struct blk_mq_tags *tags, | |
58 | unsigned int hctx_idx); | |
2c3ad667 JA |
59 | /* |
60 | * Internal helpers for request insertion into sw queues | |
61 | */ | |
62 | void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq, | |
63 | bool at_head); | |
01e99aec ML |
64 | void blk_mq_request_bypass_insert(struct request *rq, bool at_head, |
65 | bool run_queue); | |
bd166ef1 JA |
66 | void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, |
67 | struct list_head *list); | |
320ae51f | 68 | |
fd9c40f6 BVA |
69 | /* Used by blk_insert_cloned_request() to issue request directly */ |
70 | blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last); | |
6ce3dd6e ML |
71 | void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, |
72 | struct list_head *list); | |
396eaf21 | 73 | |
320ae51f JA |
74 | /* |
75 | * CPU -> queue mappings | |
76 | */ | |
ed76e329 | 77 | extern int blk_mq_hw_queue_to_node(struct blk_mq_queue_map *qmap, unsigned int); |
320ae51f | 78 | |
b3c661b1 JA |
79 | /* |
80 | * blk_mq_map_queue_type() - map (hctx_type,cpu) to hardware queue | |
81 | * @q: request queue | |
e20ba6e1 | 82 | * @type: the hctx type index |
b3c661b1 JA |
83 | * @cpu: CPU |
84 | */ | |
85 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue_type(struct request_queue *q, | |
e20ba6e1 | 86 | enum hctx_type type, |
b3c661b1 | 87 | unsigned int cpu) |
7d7e0f90 | 88 | { |
e20ba6e1 | 89 | return q->queue_hw_ctx[q->tag_set->map[type].mq_map[cpu]]; |
7d7e0f90 CH |
90 | } |
91 | ||
b3c661b1 JA |
92 | /* |
93 | * blk_mq_map_queue() - map (cmd_flags,type) to hardware queue | |
94 | * @q: request queue | |
95 | * @flags: request command flags | |
d220a214 | 96 | * @ctx: software queue cpu ctx |
b3c661b1 JA |
97 | */ |
98 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q, | |
99 | unsigned int flags, | |
8ccdf4a3 | 100 | struct blk_mq_ctx *ctx) |
ff2c5660 | 101 | { |
e20ba6e1 CH |
102 | enum hctx_type type = HCTX_TYPE_DEFAULT; |
103 | ||
bb94aea1 | 104 | /* |
6ce913fe | 105 | * The caller ensure that if REQ_POLLED, poll must be enabled. |
bb94aea1 | 106 | */ |
6ce913fe | 107 | if (flags & REQ_POLLED) |
e20ba6e1 | 108 | type = HCTX_TYPE_POLL; |
bb94aea1 | 109 | else if ((flags & REQ_OP_MASK) == REQ_OP_READ) |
e20ba6e1 | 110 | type = HCTX_TYPE_READ; |
5aceaeb2 | 111 | |
8ccdf4a3 | 112 | return ctx->hctxs[type]; |
ff2c5660 JA |
113 | } |
114 | ||
67aec14c JA |
115 | /* |
116 | * sysfs helpers | |
117 | */ | |
737f98cf | 118 | extern void blk_mq_sysfs_init(struct request_queue *q); |
7ea5fe31 | 119 | extern void blk_mq_sysfs_deinit(struct request_queue *q); |
2d0364c8 | 120 | extern int __blk_mq_register_dev(struct device *dev, struct request_queue *q); |
67aec14c JA |
121 | extern int blk_mq_sysfs_register(struct request_queue *q); |
122 | extern void blk_mq_sysfs_unregister(struct request_queue *q); | |
868f2f0b | 123 | extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx); |
47c122e3 | 124 | void blk_mq_free_plug_rqs(struct blk_plug *plug); |
67aec14c | 125 | |
e09aae7e ML |
126 | void blk_mq_release(struct request_queue *q); |
127 | ||
1aecfe48 ML |
128 | static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q, |
129 | unsigned int cpu) | |
130 | { | |
131 | return per_cpu_ptr(q->queue_ctx, cpu); | |
132 | } | |
133 | ||
134 | /* | |
135 | * This assumes per-cpu software queueing queues. They could be per-node | |
136 | * as well, for instance. For now this is hardcoded as-is. Note that we don't | |
137 | * care about preemption, since we know the ctx's are persistent. This does | |
138 | * mean that we can't rely on ctx always matching the currently running CPU. | |
139 | */ | |
140 | static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) | |
141 | { | |
c05f4220 | 142 | return __blk_mq_get_ctx(q, raw_smp_processor_id()); |
1aecfe48 ML |
143 | } |
144 | ||
cb96a42c ML |
145 | struct blk_mq_alloc_data { |
146 | /* input parameter */ | |
147 | struct request_queue *q; | |
9a95e4ef | 148 | blk_mq_req_flags_t flags; |
229a9287 | 149 | unsigned int shallow_depth; |
f9afca4d | 150 | unsigned int cmd_flags; |
cb96a42c | 151 | |
47c122e3 JA |
152 | /* allocate multiple requests/tags in one go */ |
153 | unsigned int nr_tags; | |
154 | struct request **cached_rq; | |
155 | ||
cb96a42c ML |
156 | /* input & output parameter */ |
157 | struct blk_mq_ctx *ctx; | |
158 | struct blk_mq_hw_ctx *hctx; | |
159 | }; | |
160 | ||
079a2e3e | 161 | static inline bool blk_mq_is_shared_tags(unsigned int flags) |
32bc15af JG |
162 | { |
163 | return flags & BLK_MQ_F_TAG_HCTX_SHARED; | |
164 | } | |
165 | ||
4941115b JA |
166 | static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data) |
167 | { | |
42fdc5e4 | 168 | if (data->q->elevator) |
bd166ef1 JA |
169 | return data->hctx->sched_tags; |
170 | ||
4941115b JA |
171 | return data->hctx->tags; |
172 | } | |
173 | ||
5d1b25c1 BVA |
174 | static inline bool blk_mq_hctx_stopped(struct blk_mq_hw_ctx *hctx) |
175 | { | |
176 | return test_bit(BLK_MQ_S_STOPPED, &hctx->state); | |
177 | } | |
178 | ||
19c66e59 ML |
179 | static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) |
180 | { | |
181 | return hctx->nr_ctx && hctx->tags; | |
182 | } | |
183 | ||
8446fe92 CH |
184 | unsigned int blk_mq_in_flight(struct request_queue *q, |
185 | struct block_device *part); | |
186 | void blk_mq_in_flight_rw(struct request_queue *q, struct block_device *part, | |
187 | unsigned int inflight[2]); | |
f299b7c7 | 188 | |
2a5a24aa ML |
189 | static inline void blk_mq_put_dispatch_budget(struct request_queue *q, |
190 | int budget_token) | |
de148297 | 191 | { |
de148297 | 192 | if (q->mq_ops->put_budget) |
2a5a24aa | 193 | q->mq_ops->put_budget(q, budget_token); |
de148297 ML |
194 | } |
195 | ||
2a5a24aa | 196 | static inline int blk_mq_get_dispatch_budget(struct request_queue *q) |
de148297 | 197 | { |
de148297 | 198 | if (q->mq_ops->get_budget) |
65c76369 | 199 | return q->mq_ops->get_budget(q); |
2a5a24aa ML |
200 | return 0; |
201 | } | |
202 | ||
203 | static inline void blk_mq_set_rq_budget_token(struct request *rq, int token) | |
204 | { | |
205 | if (token < 0) | |
206 | return; | |
207 | ||
208 | if (rq->q->mq_ops->set_rq_budget_token) | |
209 | rq->q->mq_ops->set_rq_budget_token(rq, token); | |
210 | } | |
211 | ||
212 | static inline int blk_mq_get_rq_budget_token(struct request *rq) | |
213 | { | |
214 | if (rq->q->mq_ops->get_rq_budget_token) | |
215 | return rq->q->mq_ops->get_rq_budget_token(rq); | |
216 | return -1; | |
de148297 ML |
217 | } |
218 | ||
bccf5e26 JG |
219 | static inline void __blk_mq_inc_active_requests(struct blk_mq_hw_ctx *hctx) |
220 | { | |
079a2e3e JG |
221 | if (blk_mq_is_shared_tags(hctx->flags)) |
222 | atomic_inc(&hctx->queue->nr_active_requests_shared_tags); | |
bccf5e26 JG |
223 | else |
224 | atomic_inc(&hctx->nr_active); | |
225 | } | |
226 | ||
227 | static inline void __blk_mq_dec_active_requests(struct blk_mq_hw_ctx *hctx) | |
228 | { | |
079a2e3e JG |
229 | if (blk_mq_is_shared_tags(hctx->flags)) |
230 | atomic_dec(&hctx->queue->nr_active_requests_shared_tags); | |
bccf5e26 JG |
231 | else |
232 | atomic_dec(&hctx->nr_active); | |
233 | } | |
234 | ||
235 | static inline int __blk_mq_active_requests(struct blk_mq_hw_ctx *hctx) | |
236 | { | |
079a2e3e JG |
237 | if (blk_mq_is_shared_tags(hctx->flags)) |
238 | return atomic_read(&hctx->queue->nr_active_requests_shared_tags); | |
bccf5e26 JG |
239 | return atomic_read(&hctx->nr_active); |
240 | } | |
4e2f62e5 JA |
241 | static inline void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx, |
242 | struct request *rq) | |
243 | { | |
244 | blk_mq_put_tag(hctx->tags, rq->mq_ctx, rq->tag); | |
245 | rq->tag = BLK_MQ_NO_TAG; | |
246 | ||
247 | if (rq->rq_flags & RQF_MQ_INFLIGHT) { | |
248 | rq->rq_flags &= ~RQF_MQ_INFLIGHT; | |
bccf5e26 | 249 | __blk_mq_dec_active_requests(hctx); |
4e2f62e5 JA |
250 | } |
251 | } | |
252 | ||
253 | static inline void blk_mq_put_driver_tag(struct request *rq) | |
254 | { | |
255 | if (rq->tag == BLK_MQ_NO_TAG || rq->internal_tag == BLK_MQ_NO_TAG) | |
256 | return; | |
257 | ||
258 | __blk_mq_put_driver_tag(rq->mq_hctx, rq); | |
259 | } | |
260 | ||
61347154 JK |
261 | bool blk_mq_get_driver_tag(struct request *rq); |
262 | ||
ed76e329 | 263 | static inline void blk_mq_clear_mq_map(struct blk_mq_queue_map *qmap) |
0da73d00 MI |
264 | { |
265 | int cpu; | |
266 | ||
267 | for_each_possible_cpu(cpu) | |
ed76e329 | 268 | qmap->mq_map[cpu] = 0; |
0da73d00 MI |
269 | } |
270 | ||
b49773e7 DLM |
271 | /* |
272 | * blk_mq_plug() - Get caller context plug | |
273 | * @q: request queue | |
274 | * @bio : the bio being submitted by the caller context | |
275 | * | |
276 | * Plugging, by design, may delay the insertion of BIOs into the elevator in | |
277 | * order to increase BIO merging opportunities. This however can cause BIO | |
278 | * insertion order to change from the order in which submit_bio() is being | |
279 | * executed in the case of multiple contexts concurrently issuing BIOs to a | |
280 | * device, even if these context are synchronized to tightly control BIO issuing | |
281 | * order. While this is not a problem with regular block devices, this ordering | |
282 | * change can cause write BIO failures with zoned block devices as these | |
283 | * require sequential write patterns to zones. Prevent this from happening by | |
284 | * ignoring the plug state of a BIO issuing context if the target request queue | |
285 | * is for a zoned block device and the BIO to plug is a write operation. | |
286 | * | |
287 | * Return current->plug if the bio can be plugged and NULL otherwise | |
288 | */ | |
289 | static inline struct blk_plug *blk_mq_plug(struct request_queue *q, | |
290 | struct bio *bio) | |
291 | { | |
292 | /* | |
293 | * For regular block devices or read operations, use the context plug | |
294 | * which may be NULL if blk_start_plug() was not executed. | |
295 | */ | |
296 | if (!blk_queue_is_zoned(q) || !op_is_write(bio_op(bio))) | |
297 | return current->plug; | |
298 | ||
299 | /* Zoned block device write operation case: do not plug the BIO */ | |
300 | return NULL; | |
301 | } | |
302 | ||
fd2ef39c JK |
303 | /* Free all requests on the list */ |
304 | static inline void blk_mq_free_requests(struct list_head *list) | |
305 | { | |
306 | while (!list_empty(list)) { | |
307 | struct request *rq = list_entry_rq(list->next); | |
308 | ||
309 | list_del_init(&rq->queuelist); | |
310 | blk_mq_free_request(rq); | |
311 | } | |
312 | } | |
313 | ||
a0235d23 JG |
314 | /* |
315 | * For shared tag users, we track the number of currently active users | |
316 | * and attempt to provide a fair share of the tag depth for each of them. | |
317 | */ | |
318 | static inline bool hctx_may_queue(struct blk_mq_hw_ctx *hctx, | |
319 | struct sbitmap_queue *bt) | |
320 | { | |
321 | unsigned int depth, users; | |
322 | ||
323 | if (!hctx || !(hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED)) | |
324 | return true; | |
a0235d23 JG |
325 | |
326 | /* | |
327 | * Don't try dividing an ant | |
328 | */ | |
329 | if (bt->sb.depth == 1) | |
330 | return true; | |
331 | ||
079a2e3e | 332 | if (blk_mq_is_shared_tags(hctx->flags)) { |
f1b49fdc | 333 | struct request_queue *q = hctx->queue; |
f1b49fdc | 334 | |
2569063c | 335 | if (!test_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags)) |
f1b49fdc | 336 | return true; |
f1b49fdc JG |
337 | } else { |
338 | if (!test_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state)) | |
339 | return true; | |
f1b49fdc JG |
340 | } |
341 | ||
e155b0c2 JG |
342 | users = atomic_read(&hctx->tags->active_queues); |
343 | ||
a0235d23 JG |
344 | if (!users) |
345 | return true; | |
346 | ||
347 | /* | |
348 | * Allow at least some tags | |
349 | */ | |
350 | depth = max((bt->sb.depth + users - 1) / users, 4U); | |
bccf5e26 | 351 | return __blk_mq_active_requests(hctx) < depth; |
a0235d23 JG |
352 | } |
353 | ||
354 | ||
320ae51f | 355 | #endif |