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 | ||
320ae51f JA |
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; | |
320ae51f JA |
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; | |
4bb659b1 | 28 | } ____cacheline_aligned_in_smp; |
320ae51f | 29 | |
1d9bd516 TH |
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, | |
5a61c363 | 37 | MQ_RQ_COMPLETE = 2, |
1d9bd516 TH |
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 | ||
780db207 | 44 | void blk_mq_freeze_queue(struct request_queue *q); |
3edcc0ce | 45 | void blk_mq_free_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); |
de148297 | 48 | bool blk_mq_dispatch_rq_list(struct request_queue *, struct list_head *, bool); |
2c3ad667 | 49 | void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list); |
bd6737f1 JA |
50 | bool blk_mq_get_driver_tag(struct request *rq, struct blk_mq_hw_ctx **hctx, |
51 | bool wait); | |
b347689f ML |
52 | struct request *blk_mq_dequeue_from_ctx(struct blk_mq_hw_ctx *hctx, |
53 | struct blk_mq_ctx *start); | |
2c3ad667 JA |
54 | |
55 | /* | |
56 | * Internal helpers for allocating/freeing the request map | |
57 | */ | |
cc71a6f4 JA |
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); | |
2c3ad667 JA |
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); | |
b0850297 | 73 | void blk_mq_request_bypass_insert(struct request *rq, bool run_queue); |
bd166ef1 JA |
74 | void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, |
75 | struct list_head *list); | |
320ae51f | 76 | |
396eaf21 | 77 | /* Used by blk_insert_cloned_request() to issue request directly */ |
c77ff7fd | 78 | blk_status_t blk_mq_request_issue_directly(struct request *rq); |
396eaf21 | 79 | |
320ae51f JA |
80 | /* |
81 | * CPU -> queue mappings | |
82 | */ | |
f14bbe77 | 83 | extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int); |
320ae51f | 84 | |
7d7e0f90 CH |
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 | ||
67aec14c JA |
91 | /* |
92 | * sysfs helpers | |
93 | */ | |
737f98cf | 94 | extern void blk_mq_sysfs_init(struct request_queue *q); |
7ea5fe31 | 95 | extern void blk_mq_sysfs_deinit(struct request_queue *q); |
2d0364c8 | 96 | extern int __blk_mq_register_dev(struct device *dev, struct request_queue *q); |
67aec14c JA |
97 | extern int blk_mq_sysfs_register(struct request_queue *q); |
98 | extern void blk_mq_sysfs_unregister(struct request_queue *q); | |
868f2f0b | 99 | extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx); |
67aec14c | 100 | |
e09aae7e ML |
101 | void blk_mq_release(struct request_queue *q); |
102 | ||
1d9bd516 TH |
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 | ||
1aecfe48 ML |
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 | ||
cb96a42c ML |
158 | struct blk_mq_alloc_data { |
159 | /* input parameter */ | |
160 | struct request_queue *q; | |
9a95e4ef | 161 | blk_mq_req_flags_t flags; |
229a9287 | 162 | unsigned int shallow_depth; |
cb96a42c ML |
163 | |
164 | /* input & output parameter */ | |
165 | struct blk_mq_ctx *ctx; | |
166 | struct blk_mq_hw_ctx *hctx; | |
167 | }; | |
168 | ||
4941115b JA |
169 | static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data) |
170 | { | |
bd166ef1 JA |
171 | if (data->flags & BLK_MQ_REQ_INTERNAL) |
172 | return data->hctx->sched_tags; | |
173 | ||
4941115b JA |
174 | return data->hctx->tags; |
175 | } | |
176 | ||
5d1b25c1 BVA |
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 | ||
19c66e59 ML |
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 | ||
f299b7c7 JA |
187 | void blk_mq_in_flight(struct request_queue *q, struct hd_struct *part, |
188 | unsigned int inflight[2]); | |
189 | ||
de148297 ML |
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 | ||
88022d72 | 198 | static inline bool blk_mq_get_dispatch_budget(struct blk_mq_hw_ctx *hctx) |
de148297 ML |
199 | { |
200 | struct request_queue *q = hctx->queue; | |
201 | ||
202 | if (q->mq_ops->get_budget) | |
203 | return q->mq_ops->get_budget(hctx); | |
88022d72 | 204 | return true; |
de148297 ML |
205 | } |
206 | ||
244c65a3 ML |
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 | ||
320ae51f | 239 | #endif |