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 | ||
90110e04 | 5 | #include <linux/blk-mq.h> |
cf43e6be JA |
6 | #include "blk-stat.h" |
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 | |
bebe84eb CH |
33 | enum { |
34 | BLK_MQ_NO_TAG = -1U, | |
35 | BLK_MQ_TAG_MIN = 1, | |
36 | BLK_MQ_TAG_MAX = BLK_MQ_NO_TAG - 1, | |
37 | }; | |
38 | ||
710fa378 CH |
39 | typedef unsigned int __bitwise blk_insert_t; |
40 | #define BLK_MQ_INSERT_AT_HEAD ((__force blk_insert_t)0x01) | |
41 | ||
3e08773c | 42 | void blk_mq_submit_bio(struct bio *bio); |
5a72e899 JA |
43 | int blk_mq_poll(struct request_queue *q, blk_qc_t cookie, struct io_comp_batch *iob, |
44 | unsigned int flags); | |
c7e2d94b | 45 | void blk_mq_exit_queue(struct request_queue *q); |
e3a2b3f9 | 46 | int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr); |
aed3ea94 | 47 | void blk_mq_wake_waiters(struct request_queue *q); |
1fd40b5e ML |
48 | bool blk_mq_dispatch_rq_list(struct blk_mq_hw_ctx *hctx, struct list_head *, |
49 | unsigned int); | |
b12e5c6c | 50 | void blk_mq_add_to_requeue_list(struct request *rq, blk_insert_t insert_flags); |
2c3ad667 | 51 | void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list); |
b347689f ML |
52 | struct request *blk_mq_dequeue_from_ctx(struct blk_mq_hw_ctx *hctx, |
53 | struct blk_mq_ctx *start); | |
2e315dc0 | 54 | void blk_mq_put_rq_ref(struct request *rq); |
2c3ad667 JA |
55 | |
56 | /* | |
57 | * Internal helpers for allocating/freeing the request map | |
58 | */ | |
cc71a6f4 JA |
59 | void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, |
60 | unsigned int hctx_idx); | |
e155b0c2 | 61 | void blk_mq_free_rq_map(struct blk_mq_tags *tags); |
63064be1 JG |
62 | struct blk_mq_tags *blk_mq_alloc_map_and_rqs(struct blk_mq_tag_set *set, |
63 | unsigned int hctx_idx, unsigned int depth); | |
645db34e JG |
64 | void blk_mq_free_map_and_rqs(struct blk_mq_tag_set *set, |
65 | struct blk_mq_tags *tags, | |
66 | unsigned int hctx_idx); | |
2c3ad667 JA |
67 | /* |
68 | * Internal helpers for request insertion into sw queues | |
69 | */ | |
2b597613 | 70 | void blk_mq_request_bypass_insert(struct request *rq, blk_insert_t flags); |
396eaf21 | 71 | |
320ae51f JA |
72 | /* |
73 | * CPU -> queue mappings | |
74 | */ | |
ed76e329 | 75 | extern int blk_mq_hw_queue_to_node(struct blk_mq_queue_map *qmap, unsigned int); |
320ae51f | 76 | |
b3c661b1 JA |
77 | /* |
78 | * blk_mq_map_queue_type() - map (hctx_type,cpu) to hardware queue | |
79 | * @q: request queue | |
e20ba6e1 | 80 | * @type: the hctx type index |
b3c661b1 JA |
81 | * @cpu: CPU |
82 | */ | |
83 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue_type(struct request_queue *q, | |
e20ba6e1 | 84 | enum hctx_type type, |
b3c661b1 | 85 | unsigned int cpu) |
7d7e0f90 | 86 | { |
4e5cc99e | 87 | return xa_load(&q->hctx_table, q->tag_set->map[type].mq_map[cpu]); |
7d7e0f90 CH |
88 | } |
89 | ||
16458cf3 | 90 | static inline enum hctx_type blk_mq_get_hctx_type(blk_opf_t opf) |
ff2c5660 | 91 | { |
e20ba6e1 CH |
92 | enum hctx_type type = HCTX_TYPE_DEFAULT; |
93 | ||
bb94aea1 | 94 | /* |
6ce913fe | 95 | * The caller ensure that if REQ_POLLED, poll must be enabled. |
bb94aea1 | 96 | */ |
7e923f40 | 97 | if (opf & REQ_POLLED) |
e20ba6e1 | 98 | type = HCTX_TYPE_POLL; |
7e923f40 | 99 | else if ((opf & REQ_OP_MASK) == REQ_OP_READ) |
e20ba6e1 | 100 | type = HCTX_TYPE_READ; |
b637108a ML |
101 | return type; |
102 | } | |
103 | ||
104 | /* | |
105 | * blk_mq_map_queue() - map (cmd_flags,type) to hardware queue | |
106 | * @q: request queue | |
7e923f40 | 107 | * @opf: operation type (REQ_OP_*) and flags (e.g. REQ_POLLED). |
b637108a ML |
108 | * @ctx: software queue cpu ctx |
109 | */ | |
110 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q, | |
16458cf3 | 111 | blk_opf_t opf, |
b637108a ML |
112 | struct blk_mq_ctx *ctx) |
113 | { | |
7e923f40 | 114 | return ctx->hctxs[blk_mq_get_hctx_type(opf)]; |
ff2c5660 JA |
115 | } |
116 | ||
67aec14c JA |
117 | /* |
118 | * sysfs helpers | |
119 | */ | |
737f98cf | 120 | extern void blk_mq_sysfs_init(struct request_queue *q); |
7ea5fe31 | 121 | extern void blk_mq_sysfs_deinit(struct request_queue *q); |
8682b92e CH |
122 | int blk_mq_sysfs_register(struct gendisk *disk); |
123 | void blk_mq_sysfs_unregister(struct gendisk *disk); | |
eaa870f9 CH |
124 | int blk_mq_sysfs_register_hctxs(struct request_queue *q); |
125 | void blk_mq_sysfs_unregister_hctxs(struct request_queue *q); | |
868f2f0b | 126 | extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx); |
47c122e3 | 127 | void blk_mq_free_plug_rqs(struct blk_plug *plug); |
dbb6f764 | 128 | void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule); |
67aec14c | 129 | |
2a19b28f ML |
130 | void blk_mq_cancel_work_sync(struct request_queue *q); |
131 | ||
e09aae7e ML |
132 | void blk_mq_release(struct request_queue *q); |
133 | ||
1aecfe48 ML |
134 | static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q, |
135 | unsigned int cpu) | |
136 | { | |
137 | return per_cpu_ptr(q->queue_ctx, cpu); | |
138 | } | |
139 | ||
140 | /* | |
141 | * This assumes per-cpu software queueing queues. They could be per-node | |
142 | * as well, for instance. For now this is hardcoded as-is. Note that we don't | |
143 | * care about preemption, since we know the ctx's are persistent. This does | |
144 | * mean that we can't rely on ctx always matching the currently running CPU. | |
145 | */ | |
146 | static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) | |
147 | { | |
c05f4220 | 148 | return __blk_mq_get_ctx(q, raw_smp_processor_id()); |
1aecfe48 ML |
149 | } |
150 | ||
cb96a42c ML |
151 | struct blk_mq_alloc_data { |
152 | /* input parameter */ | |
153 | struct request_queue *q; | |
9a95e4ef | 154 | blk_mq_req_flags_t flags; |
229a9287 | 155 | unsigned int shallow_depth; |
16458cf3 | 156 | blk_opf_t cmd_flags; |
ecaf97f4 | 157 | req_flags_t rq_flags; |
cb96a42c | 158 | |
47c122e3 JA |
159 | /* allocate multiple requests/tags in one go */ |
160 | unsigned int nr_tags; | |
161 | struct request **cached_rq; | |
162 | ||
cb96a42c ML |
163 | /* input & output parameter */ |
164 | struct blk_mq_ctx *ctx; | |
165 | struct blk_mq_hw_ctx *hctx; | |
166 | }; | |
167 | ||
bebe84eb CH |
168 | struct blk_mq_tags *blk_mq_init_tags(unsigned int nr_tags, |
169 | unsigned int reserved_tags, int node, int alloc_policy); | |
170 | void blk_mq_free_tags(struct blk_mq_tags *tags); | |
171 | int blk_mq_init_bitmaps(struct sbitmap_queue *bitmap_tags, | |
172 | struct sbitmap_queue *breserved_tags, unsigned int queue_depth, | |
173 | unsigned int reserved, int node, int alloc_policy); | |
174 | ||
175 | unsigned int blk_mq_get_tag(struct blk_mq_alloc_data *data); | |
176 | unsigned long blk_mq_get_tags(struct blk_mq_alloc_data *data, int nr_tags, | |
177 | unsigned int *offset); | |
178 | void blk_mq_put_tag(struct blk_mq_tags *tags, struct blk_mq_ctx *ctx, | |
179 | unsigned int tag); | |
180 | void blk_mq_put_tags(struct blk_mq_tags *tags, int *tag_array, int nr_tags); | |
181 | int blk_mq_tag_update_depth(struct blk_mq_hw_ctx *hctx, | |
182 | struct blk_mq_tags **tags, unsigned int depth, bool can_grow); | |
183 | void blk_mq_tag_resize_shared_tags(struct blk_mq_tag_set *set, | |
184 | unsigned int size); | |
185 | void blk_mq_tag_update_sched_shared_tags(struct request_queue *q); | |
186 | ||
187 | void blk_mq_tag_wakeup_all(struct blk_mq_tags *tags, bool); | |
188 | void blk_mq_queue_tag_busy_iter(struct request_queue *q, busy_tag_iter_fn *fn, | |
189 | void *priv); | |
190 | void blk_mq_all_tag_iter(struct blk_mq_tags *tags, busy_tag_iter_fn *fn, | |
191 | void *priv); | |
192 | ||
193 | static inline struct sbq_wait_state *bt_wait_ptr(struct sbitmap_queue *bt, | |
194 | struct blk_mq_hw_ctx *hctx) | |
195 | { | |
196 | if (!hctx) | |
197 | return &bt->ws[0]; | |
198 | return sbq_wait_ptr(bt, &hctx->wait_index); | |
199 | } | |
200 | ||
201 | void __blk_mq_tag_busy(struct blk_mq_hw_ctx *); | |
202 | void __blk_mq_tag_idle(struct blk_mq_hw_ctx *); | |
203 | ||
204 | static inline void blk_mq_tag_busy(struct blk_mq_hw_ctx *hctx) | |
205 | { | |
206 | if (hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED) | |
207 | __blk_mq_tag_busy(hctx); | |
208 | } | |
209 | ||
210 | static inline void blk_mq_tag_idle(struct blk_mq_hw_ctx *hctx) | |
211 | { | |
212 | if (hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED) | |
213 | __blk_mq_tag_idle(hctx); | |
214 | } | |
215 | ||
216 | static inline bool blk_mq_tag_is_reserved(struct blk_mq_tags *tags, | |
217 | unsigned int tag) | |
218 | { | |
219 | return tag < tags->nr_reserved_tags; | |
220 | } | |
221 | ||
079a2e3e | 222 | static inline bool blk_mq_is_shared_tags(unsigned int flags) |
32bc15af JG |
223 | { |
224 | return flags & BLK_MQ_F_TAG_HCTX_SHARED; | |
225 | } | |
226 | ||
4941115b JA |
227 | static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data) |
228 | { | |
56f8da64 JA |
229 | if (!(data->rq_flags & RQF_ELV)) |
230 | return data->hctx->tags; | |
231 | return data->hctx->sched_tags; | |
4941115b JA |
232 | } |
233 | ||
5d1b25c1 BVA |
234 | static inline bool blk_mq_hctx_stopped(struct blk_mq_hw_ctx *hctx) |
235 | { | |
236 | return test_bit(BLK_MQ_S_STOPPED, &hctx->state); | |
237 | } | |
238 | ||
19c66e59 ML |
239 | static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) |
240 | { | |
241 | return hctx->nr_ctx && hctx->tags; | |
242 | } | |
243 | ||
8446fe92 CH |
244 | unsigned int blk_mq_in_flight(struct request_queue *q, |
245 | struct block_device *part); | |
246 | void blk_mq_in_flight_rw(struct request_queue *q, struct block_device *part, | |
247 | unsigned int inflight[2]); | |
f299b7c7 | 248 | |
2a5a24aa ML |
249 | static inline void blk_mq_put_dispatch_budget(struct request_queue *q, |
250 | int budget_token) | |
de148297 | 251 | { |
de148297 | 252 | if (q->mq_ops->put_budget) |
2a5a24aa | 253 | q->mq_ops->put_budget(q, budget_token); |
de148297 ML |
254 | } |
255 | ||
2a5a24aa | 256 | static inline int blk_mq_get_dispatch_budget(struct request_queue *q) |
de148297 | 257 | { |
de148297 | 258 | if (q->mq_ops->get_budget) |
65c76369 | 259 | return q->mq_ops->get_budget(q); |
2a5a24aa ML |
260 | return 0; |
261 | } | |
262 | ||
263 | static inline void blk_mq_set_rq_budget_token(struct request *rq, int token) | |
264 | { | |
265 | if (token < 0) | |
266 | return; | |
267 | ||
268 | if (rq->q->mq_ops->set_rq_budget_token) | |
269 | rq->q->mq_ops->set_rq_budget_token(rq, token); | |
270 | } | |
271 | ||
272 | static inline int blk_mq_get_rq_budget_token(struct request *rq) | |
273 | { | |
274 | if (rq->q->mq_ops->get_rq_budget_token) | |
275 | return rq->q->mq_ops->get_rq_budget_token(rq); | |
276 | return -1; | |
de148297 ML |
277 | } |
278 | ||
bccf5e26 JG |
279 | static inline void __blk_mq_inc_active_requests(struct blk_mq_hw_ctx *hctx) |
280 | { | |
079a2e3e JG |
281 | if (blk_mq_is_shared_tags(hctx->flags)) |
282 | atomic_inc(&hctx->queue->nr_active_requests_shared_tags); | |
bccf5e26 JG |
283 | else |
284 | atomic_inc(&hctx->nr_active); | |
285 | } | |
286 | ||
3b87c6ea ML |
287 | static inline void __blk_mq_sub_active_requests(struct blk_mq_hw_ctx *hctx, |
288 | int val) | |
bccf5e26 | 289 | { |
079a2e3e | 290 | if (blk_mq_is_shared_tags(hctx->flags)) |
3b87c6ea | 291 | atomic_sub(val, &hctx->queue->nr_active_requests_shared_tags); |
bccf5e26 | 292 | else |
3b87c6ea ML |
293 | atomic_sub(val, &hctx->nr_active); |
294 | } | |
295 | ||
296 | static inline void __blk_mq_dec_active_requests(struct blk_mq_hw_ctx *hctx) | |
297 | { | |
298 | __blk_mq_sub_active_requests(hctx, 1); | |
bccf5e26 JG |
299 | } |
300 | ||
301 | static inline int __blk_mq_active_requests(struct blk_mq_hw_ctx *hctx) | |
302 | { | |
079a2e3e JG |
303 | if (blk_mq_is_shared_tags(hctx->flags)) |
304 | return atomic_read(&hctx->queue->nr_active_requests_shared_tags); | |
bccf5e26 JG |
305 | return atomic_read(&hctx->nr_active); |
306 | } | |
4e2f62e5 JA |
307 | static inline void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx, |
308 | struct request *rq) | |
309 | { | |
310 | blk_mq_put_tag(hctx->tags, rq->mq_ctx, rq->tag); | |
311 | rq->tag = BLK_MQ_NO_TAG; | |
312 | ||
313 | if (rq->rq_flags & RQF_MQ_INFLIGHT) { | |
314 | rq->rq_flags &= ~RQF_MQ_INFLIGHT; | |
bccf5e26 | 315 | __blk_mq_dec_active_requests(hctx); |
4e2f62e5 JA |
316 | } |
317 | } | |
318 | ||
319 | static inline void blk_mq_put_driver_tag(struct request *rq) | |
320 | { | |
321 | if (rq->tag == BLK_MQ_NO_TAG || rq->internal_tag == BLK_MQ_NO_TAG) | |
322 | return; | |
323 | ||
324 | __blk_mq_put_driver_tag(rq->mq_hctx, rq); | |
325 | } | |
326 | ||
a808a9d5 JA |
327 | bool __blk_mq_get_driver_tag(struct blk_mq_hw_ctx *hctx, struct request *rq); |
328 | ||
329 | static inline bool blk_mq_get_driver_tag(struct request *rq) | |
330 | { | |
331 | struct blk_mq_hw_ctx *hctx = rq->mq_hctx; | |
332 | ||
333 | if (rq->tag != BLK_MQ_NO_TAG && | |
334 | !(hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED)) { | |
335 | hctx->tags->rqs[rq->tag] = rq; | |
336 | return true; | |
337 | } | |
338 | ||
339 | return __blk_mq_get_driver_tag(hctx, rq); | |
340 | } | |
61347154 | 341 | |
ed76e329 | 342 | static inline void blk_mq_clear_mq_map(struct blk_mq_queue_map *qmap) |
0da73d00 MI |
343 | { |
344 | int cpu; | |
345 | ||
346 | for_each_possible_cpu(cpu) | |
ed76e329 | 347 | qmap->mq_map[cpu] = 0; |
0da73d00 MI |
348 | } |
349 | ||
b49773e7 DLM |
350 | /* |
351 | * blk_mq_plug() - Get caller context plug | |
b49773e7 DLM |
352 | * @bio : the bio being submitted by the caller context |
353 | * | |
354 | * Plugging, by design, may delay the insertion of BIOs into the elevator in | |
355 | * order to increase BIO merging opportunities. This however can cause BIO | |
356 | * insertion order to change from the order in which submit_bio() is being | |
357 | * executed in the case of multiple contexts concurrently issuing BIOs to a | |
358 | * device, even if these context are synchronized to tightly control BIO issuing | |
359 | * order. While this is not a problem with regular block devices, this ordering | |
360 | * change can cause write BIO failures with zoned block devices as these | |
361 | * require sequential write patterns to zones. Prevent this from happening by | |
6deacb3b CH |
362 | * ignoring the plug state of a BIO issuing context if it is for a zoned block |
363 | * device and the BIO to plug is a write operation. | |
b49773e7 DLM |
364 | * |
365 | * Return current->plug if the bio can be plugged and NULL otherwise | |
366 | */ | |
6deacb3b | 367 | static inline struct blk_plug *blk_mq_plug( struct bio *bio) |
b49773e7 | 368 | { |
6deacb3b | 369 | /* Zoned block device write operation case: do not plug the BIO */ |
8cafdb5a PR |
370 | if (IS_ENABLED(CONFIG_BLK_DEV_ZONED) && |
371 | bdev_op_is_zoned_write(bio->bi_bdev, bio_op(bio))) | |
6deacb3b CH |
372 | return NULL; |
373 | ||
b49773e7 DLM |
374 | /* |
375 | * For regular block devices or read operations, use the context plug | |
376 | * which may be NULL if blk_start_plug() was not executed. | |
377 | */ | |
6deacb3b | 378 | return current->plug; |
b49773e7 DLM |
379 | } |
380 | ||
fd2ef39c JK |
381 | /* Free all requests on the list */ |
382 | static inline void blk_mq_free_requests(struct list_head *list) | |
383 | { | |
384 | while (!list_empty(list)) { | |
385 | struct request *rq = list_entry_rq(list->next); | |
386 | ||
387 | list_del_init(&rq->queuelist); | |
388 | blk_mq_free_request(rq); | |
389 | } | |
390 | } | |
391 | ||
a0235d23 JG |
392 | /* |
393 | * For shared tag users, we track the number of currently active users | |
394 | * and attempt to provide a fair share of the tag depth for each of them. | |
395 | */ | |
396 | static inline bool hctx_may_queue(struct blk_mq_hw_ctx *hctx, | |
397 | struct sbitmap_queue *bt) | |
398 | { | |
399 | unsigned int depth, users; | |
400 | ||
401 | if (!hctx || !(hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED)) | |
402 | return true; | |
a0235d23 JG |
403 | |
404 | /* | |
405 | * Don't try dividing an ant | |
406 | */ | |
407 | if (bt->sb.depth == 1) | |
408 | return true; | |
409 | ||
079a2e3e | 410 | if (blk_mq_is_shared_tags(hctx->flags)) { |
f1b49fdc | 411 | struct request_queue *q = hctx->queue; |
f1b49fdc | 412 | |
2569063c | 413 | if (!test_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags)) |
f1b49fdc | 414 | return true; |
f1b49fdc JG |
415 | } else { |
416 | if (!test_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state)) | |
417 | return true; | |
f1b49fdc JG |
418 | } |
419 | ||
e155b0c2 JG |
420 | users = atomic_read(&hctx->tags->active_queues); |
421 | ||
a0235d23 JG |
422 | if (!users) |
423 | return true; | |
424 | ||
425 | /* | |
426 | * Allow at least some tags | |
427 | */ | |
428 | depth = max((bt->sb.depth + users - 1) / users, 4U); | |
bccf5e26 | 429 | return __blk_mq_active_requests(hctx) < depth; |
a0235d23 JG |
430 | } |
431 | ||
2a904d00 | 432 | /* run the code block in @dispatch_ops with rcu/srcu read lock held */ |
41adf531 | 433 | #define __blk_mq_run_dispatch_ops(q, check_sleep, dispatch_ops) \ |
2a904d00 | 434 | do { \ |
80bd4a7a | 435 | if ((q)->tag_set->flags & BLK_MQ_F_BLOCKING) { \ |
00e885ef | 436 | struct blk_mq_tag_set *__tag_set = (q)->tag_set; \ |
2a904d00 ML |
437 | int srcu_idx; \ |
438 | \ | |
41adf531 | 439 | might_sleep_if(check_sleep); \ |
00e885ef | 440 | srcu_idx = srcu_read_lock(__tag_set->srcu); \ |
2a904d00 | 441 | (dispatch_ops); \ |
00e885ef | 442 | srcu_read_unlock(__tag_set->srcu, srcu_idx); \ |
80bd4a7a CH |
443 | } else { \ |
444 | rcu_read_lock(); \ | |
445 | (dispatch_ops); \ | |
446 | rcu_read_unlock(); \ | |
2a904d00 ML |
447 | } \ |
448 | } while (0) | |
a0235d23 | 449 | |
41adf531 ML |
450 | #define blk_mq_run_dispatch_ops(q, dispatch_ops) \ |
451 | __blk_mq_run_dispatch_ops(q, true, dispatch_ops) \ | |
452 | ||
320ae51f | 453 | #endif |