Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
8struct blk_mq_tag_set;
9
10struct 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 */
34enum 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
44void blk_mq_freeze_queue(struct request_queue *q);
45void blk_mq_free_queue(struct request_queue *q);
46int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr);
47void blk_mq_wake_waiters(struct request_queue *q);
48bool blk_mq_dispatch_rq_list(struct request_queue *, struct list_head *, bool);
49void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list);
50bool blk_mq_get_driver_tag(struct request *rq, struct blk_mq_hw_ctx **hctx,
51 bool wait);
52struct 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 */
58void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,
59 unsigned int hctx_idx);
60void blk_mq_free_rq_map(struct blk_mq_tags *tags);
61struct 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);
65int 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 */
71void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq,
72 bool at_head);
73void blk_mq_request_bypass_insert(struct request *rq, bool run_queue);
74void 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 */
78blk_status_t blk_mq_request_issue_directly(struct request *rq);
79
80/*
81 * CPU -> queue mappings
82 */
83extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int);
84
85static 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 */
94extern void blk_mq_sysfs_init(struct request_queue *q);
95extern void blk_mq_sysfs_deinit(struct request_queue *q);
96extern int __blk_mq_register_dev(struct device *dev, struct request_queue *q);
97extern int blk_mq_sysfs_register(struct request_queue *q);
98extern void blk_mq_sysfs_unregister(struct request_queue *q);
99extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx);
100
101void 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 */
107static 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 */
121static 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
136static 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 */
148static 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
153static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx)
154{
155 put_cpu();
156}
157
158struct 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
169static 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
177static 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
182static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx)
183{
184 return hctx->nr_ctx && hctx->tags;
185}
186
187void blk_mq_in_flight(struct request_queue *q, struct hd_struct *part,
188 unsigned int inflight[2]);
189
190static 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
198static 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
207static 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
219static 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
228static 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