]>
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]; |
320ae51f JA |
26 | |
27 | /* incremented at dispatch time */ | |
28 | unsigned long rq_dispatched[2]; | |
29 | unsigned long rq_merged; | |
30 | ||
31 | /* incremented at completion time */ | |
32 | unsigned long ____cacheline_aligned_in_smp rq_completed[2]; | |
33 | ||
34 | struct request_queue *queue; | |
1db4909e | 35 | struct blk_mq_ctxs *ctxs; |
320ae51f | 36 | struct kobject kobj; |
4bb659b1 | 37 | } ____cacheline_aligned_in_smp; |
320ae51f | 38 | |
3edcc0ce | 39 | void blk_mq_free_queue(struct request_queue *q); |
e3a2b3f9 | 40 | int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr); |
aed3ea94 | 41 | void blk_mq_wake_waiters(struct request_queue *q); |
de148297 | 42 | bool blk_mq_dispatch_rq_list(struct request_queue *, struct list_head *, bool); |
2c3ad667 | 43 | void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list); |
8ab6bb9e | 44 | bool blk_mq_get_driver_tag(struct request *rq); |
b347689f ML |
45 | struct request *blk_mq_dequeue_from_ctx(struct blk_mq_hw_ctx *hctx, |
46 | struct blk_mq_ctx *start); | |
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); | |
53 | void blk_mq_free_rq_map(struct blk_mq_tags *tags); | |
54 | struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, | |
55 | unsigned int hctx_idx, | |
56 | unsigned int nr_tags, | |
57 | unsigned int reserved_tags); | |
58 | int blk_mq_alloc_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, | |
59 | unsigned int hctx_idx, unsigned int depth); | |
2c3ad667 JA |
60 | |
61 | /* | |
62 | * Internal helpers for request insertion into sw queues | |
63 | */ | |
64 | void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq, | |
65 | bool at_head); | |
b0850297 | 66 | void blk_mq_request_bypass_insert(struct request *rq, bool run_queue); |
bd166ef1 JA |
67 | void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, |
68 | struct list_head *list); | |
320ae51f | 69 | |
43d15c04 BVA |
70 | /* Used by blk_insert_cloned_request() to issue request directly */ |
71 | blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last); | |
6ce3dd6e ML |
72 | void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, |
73 | struct list_head *list); | |
396eaf21 | 74 | |
320ae51f JA |
75 | /* |
76 | * CPU -> queue mappings | |
77 | */ | |
ed76e329 | 78 | extern int blk_mq_hw_queue_to_node(struct blk_mq_queue_map *qmap, unsigned int); |
320ae51f | 79 | |
b3c661b1 JA |
80 | /* |
81 | * blk_mq_map_queue_type() - map (hctx_type,cpu) to hardware queue | |
82 | * @q: request queue | |
e20ba6e1 | 83 | * @type: the hctx type index |
b3c661b1 JA |
84 | * @cpu: CPU |
85 | */ | |
86 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue_type(struct request_queue *q, | |
e20ba6e1 | 87 | enum hctx_type type, |
b3c661b1 | 88 | unsigned int cpu) |
7d7e0f90 | 89 | { |
e20ba6e1 | 90 | return q->queue_hw_ctx[q->tag_set->map[type].mq_map[cpu]]; |
7d7e0f90 CH |
91 | } |
92 | ||
b3c661b1 JA |
93 | /* |
94 | * blk_mq_map_queue() - map (cmd_flags,type) to hardware queue | |
95 | * @q: request queue | |
96 | * @flags: request command flags | |
97 | * @cpu: CPU | |
98 | */ | |
99 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q, | |
100 | unsigned int flags, | |
101 | unsigned int cpu) | |
ff2c5660 | 102 | { |
e20ba6e1 CH |
103 | enum hctx_type type = HCTX_TYPE_DEFAULT; |
104 | ||
5aceaeb2 CH |
105 | if ((flags & REQ_HIPRI) && |
106 | q->tag_set->nr_maps > HCTX_TYPE_POLL && | |
107 | q->tag_set->map[HCTX_TYPE_POLL].nr_queues && | |
108 | test_bit(QUEUE_FLAG_POLL, &q->queue_flags)) | |
e20ba6e1 | 109 | type = HCTX_TYPE_POLL; |
b3c661b1 | 110 | |
5aceaeb2 CH |
111 | else if (((flags & REQ_OP_MASK) == REQ_OP_READ) && |
112 | q->tag_set->nr_maps > HCTX_TYPE_READ && | |
113 | q->tag_set->map[HCTX_TYPE_READ].nr_queues) | |
e20ba6e1 | 114 | type = HCTX_TYPE_READ; |
5aceaeb2 | 115 | |
e20ba6e1 | 116 | return blk_mq_map_queue_type(q, type, cpu); |
ff2c5660 JA |
117 | } |
118 | ||
67aec14c JA |
119 | /* |
120 | * sysfs helpers | |
121 | */ | |
737f98cf | 122 | extern void blk_mq_sysfs_init(struct request_queue *q); |
7ea5fe31 | 123 | extern void blk_mq_sysfs_deinit(struct request_queue *q); |
2d0364c8 | 124 | extern int __blk_mq_register_dev(struct device *dev, struct request_queue *q); |
67aec14c JA |
125 | extern int blk_mq_sysfs_register(struct request_queue *q); |
126 | extern void blk_mq_sysfs_unregister(struct request_queue *q); | |
868f2f0b | 127 | extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx); |
67aec14c | 128 | |
e09aae7e ML |
129 | void blk_mq_release(struct request_queue *q); |
130 | ||
1d9bd516 TH |
131 | /** |
132 | * blk_mq_rq_state() - read the current MQ_RQ_* state of a request | |
133 | * @rq: target request. | |
134 | */ | |
12f5b931 | 135 | static inline enum mq_rq_state blk_mq_rq_state(struct request *rq) |
1d9bd516 | 136 | { |
12f5b931 | 137 | return READ_ONCE(rq->state); |
1d9bd516 TH |
138 | } |
139 | ||
1aecfe48 ML |
140 | static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q, |
141 | unsigned int cpu) | |
142 | { | |
143 | return per_cpu_ptr(q->queue_ctx, cpu); | |
144 | } | |
145 | ||
146 | /* | |
147 | * This assumes per-cpu software queueing queues. They could be per-node | |
148 | * as well, for instance. For now this is hardcoded as-is. Note that we don't | |
149 | * care about preemption, since we know the ctx's are persistent. This does | |
150 | * mean that we can't rely on ctx always matching the currently running CPU. | |
151 | */ | |
152 | static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) | |
153 | { | |
154 | return __blk_mq_get_ctx(q, get_cpu()); | |
155 | } | |
156 | ||
157 | static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx) | |
158 | { | |
159 | put_cpu(); | |
160 | } | |
161 | ||
cb96a42c ML |
162 | struct blk_mq_alloc_data { |
163 | /* input parameter */ | |
164 | struct request_queue *q; | |
9a95e4ef | 165 | blk_mq_req_flags_t flags; |
229a9287 | 166 | unsigned int shallow_depth; |
f9afca4d | 167 | unsigned int cmd_flags; |
cb96a42c ML |
168 | |
169 | /* input & output parameter */ | |
170 | struct blk_mq_ctx *ctx; | |
171 | struct blk_mq_hw_ctx *hctx; | |
172 | }; | |
173 | ||
4941115b JA |
174 | static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data) |
175 | { | |
bd166ef1 JA |
176 | if (data->flags & BLK_MQ_REQ_INTERNAL) |
177 | return data->hctx->sched_tags; | |
178 | ||
4941115b JA |
179 | return data->hctx->tags; |
180 | } | |
181 | ||
5d1b25c1 BVA |
182 | static inline bool blk_mq_hctx_stopped(struct blk_mq_hw_ctx *hctx) |
183 | { | |
184 | return test_bit(BLK_MQ_S_STOPPED, &hctx->state); | |
185 | } | |
186 | ||
19c66e59 ML |
187 | static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) |
188 | { | |
189 | return hctx->nr_ctx && hctx->tags; | |
190 | } | |
191 | ||
e016b782 | 192 | unsigned int blk_mq_in_flight(struct request_queue *q, struct hd_struct *part); |
bf0ddaba OS |
193 | void blk_mq_in_flight_rw(struct request_queue *q, struct hd_struct *part, |
194 | unsigned int inflight[2]); | |
f299b7c7 | 195 | |
de148297 ML |
196 | static inline void blk_mq_put_dispatch_budget(struct blk_mq_hw_ctx *hctx) |
197 | { | |
198 | struct request_queue *q = hctx->queue; | |
199 | ||
200 | if (q->mq_ops->put_budget) | |
201 | q->mq_ops->put_budget(hctx); | |
202 | } | |
203 | ||
88022d72 | 204 | static inline bool blk_mq_get_dispatch_budget(struct blk_mq_hw_ctx *hctx) |
de148297 ML |
205 | { |
206 | struct request_queue *q = hctx->queue; | |
207 | ||
208 | if (q->mq_ops->get_budget) | |
209 | return q->mq_ops->get_budget(hctx); | |
88022d72 | 210 | return true; |
de148297 ML |
211 | } |
212 | ||
244c65a3 ML |
213 | static inline void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx, |
214 | struct request *rq) | |
215 | { | |
216 | blk_mq_put_tag(hctx, hctx->tags, rq->mq_ctx, rq->tag); | |
217 | rq->tag = -1; | |
218 | ||
219 | if (rq->rq_flags & RQF_MQ_INFLIGHT) { | |
220 | rq->rq_flags &= ~RQF_MQ_INFLIGHT; | |
221 | atomic_dec(&hctx->nr_active); | |
222 | } | |
223 | } | |
224 | ||
225 | static inline void blk_mq_put_driver_tag_hctx(struct blk_mq_hw_ctx *hctx, | |
226 | struct request *rq) | |
227 | { | |
228 | if (rq->tag == -1 || rq->internal_tag == -1) | |
229 | return; | |
230 | ||
231 | __blk_mq_put_driver_tag(hctx, rq); | |
232 | } | |
233 | ||
234 | static inline void blk_mq_put_driver_tag(struct request *rq) | |
235 | { | |
244c65a3 ML |
236 | if (rq->tag == -1 || rq->internal_tag == -1) |
237 | return; | |
238 | ||
ea4f995e | 239 | __blk_mq_put_driver_tag(rq->mq_hctx, rq); |
244c65a3 ML |
240 | } |
241 | ||
ed76e329 | 242 | static inline void blk_mq_clear_mq_map(struct blk_mq_queue_map *qmap) |
0da73d00 MI |
243 | { |
244 | int cpu; | |
245 | ||
246 | for_each_possible_cpu(cpu) | |
ed76e329 | 247 | qmap->mq_map[cpu] = 0; |
0da73d00 MI |
248 | } |
249 | ||
320ae51f | 250 | #endif |