perf record: Combine some auxtrace initialization into a single function
[linux/fpc-iii.git] / block / blk-mq.h
blob88c558f718190f88e123bba0444b0c50b296e572
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef INT_BLK_MQ_H
3 #define INT_BLK_MQ_H
5 #include "blk-stat.h"
6 #include "blk-mq-tag.h"
8 struct blk_mq_tag_set;
10 struct blk_mq_ctx {
11 struct {
12 spinlock_t lock;
13 struct list_head rq_list;
14 } ____cacheline_aligned_in_smp;
16 unsigned int cpu;
17 unsigned int index_hw;
19 /* incremented at dispatch time */
20 unsigned long rq_dispatched[2];
21 unsigned long rq_merged;
23 /* incremented at completion time */
24 unsigned long ____cacheline_aligned_in_smp rq_completed[2];
26 struct request_queue *queue;
27 struct kobject kobj;
28 } ____cacheline_aligned_in_smp;
31 * Bits for request->gstate. The lower two bits carry MQ_RQ_* state value
32 * and the upper bits the generation number.
34 enum mq_rq_state {
35 MQ_RQ_IDLE = 0,
36 MQ_RQ_IN_FLIGHT = 1,
37 MQ_RQ_COMPLETE = 2,
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,
44 void blk_mq_freeze_queue(struct request_queue *q);
45 void blk_mq_free_queue(struct request_queue *q);
46 int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr);
47 void blk_mq_wake_waiters(struct request_queue *q);
48 bool blk_mq_dispatch_rq_list(struct request_queue *, struct list_head *, bool);
49 void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list);
50 bool blk_mq_get_driver_tag(struct request *rq, struct blk_mq_hw_ctx **hctx,
51 bool wait);
52 struct request *blk_mq_dequeue_from_ctx(struct blk_mq_hw_ctx *hctx,
53 struct blk_mq_ctx *start);
56 * Internal helpers for allocating/freeing the request map
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);
69 * Internal helpers for request insertion into sw queues
71 void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq,
72 bool at_head);
73 void blk_mq_request_bypass_insert(struct request *rq, bool run_queue);
74 void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx,
75 struct list_head *list);
77 /* Used by blk_insert_cloned_request() to issue request directly */
78 blk_status_t blk_mq_request_issue_directly(struct request *rq);
81 * CPU -> queue mappings
83 extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int);
85 static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q,
86 int cpu)
88 return q->queue_hw_ctx[q->mq_map[cpu]];
92 * sysfs helpers
94 extern void blk_mq_sysfs_init(struct request_queue *q);
95 extern void blk_mq_sysfs_deinit(struct request_queue *q);
96 extern int __blk_mq_register_dev(struct device *dev, struct request_queue *q);
97 extern int blk_mq_sysfs_register(struct request_queue *q);
98 extern void blk_mq_sysfs_unregister(struct request_queue *q);
99 extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx);
101 void blk_mq_release(struct request_queue *q);
104 * blk_mq_rq_state() - read the current MQ_RQ_* state of a request
105 * @rq: target request.
107 static inline int blk_mq_rq_state(struct request *rq)
109 return READ_ONCE(rq->gstate) & MQ_RQ_STATE_MASK;
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.
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.
121 static inline void blk_mq_rq_update_state(struct request *rq,
122 enum mq_rq_state state)
124 u64 old_val = READ_ONCE(rq->gstate);
125 u64 new_val = (old_val & ~MQ_RQ_STATE_MASK) | state;
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;
132 /* avoid exposing interim values */
133 WRITE_ONCE(rq->gstate, new_val);
136 static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q,
137 unsigned int cpu)
139 return per_cpu_ptr(q->queue_ctx, cpu);
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.
148 static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q)
150 return __blk_mq_get_ctx(q, get_cpu());
153 static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx)
155 put_cpu();
158 struct blk_mq_alloc_data {
159 /* input parameter */
160 struct request_queue *q;
161 blk_mq_req_flags_t flags;
162 unsigned int shallow_depth;
164 /* input & output parameter */
165 struct blk_mq_ctx *ctx;
166 struct blk_mq_hw_ctx *hctx;
169 static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data)
171 if (data->flags & BLK_MQ_REQ_INTERNAL)
172 return data->hctx->sched_tags;
174 return data->hctx->tags;
177 static inline bool blk_mq_hctx_stopped(struct blk_mq_hw_ctx *hctx)
179 return test_bit(BLK_MQ_S_STOPPED, &hctx->state);
182 static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx)
184 return hctx->nr_ctx && hctx->tags;
187 void blk_mq_in_flight(struct request_queue *q, struct hd_struct *part,
188 unsigned int inflight[2]);
190 static inline void blk_mq_put_dispatch_budget(struct blk_mq_hw_ctx *hctx)
192 struct request_queue *q = hctx->queue;
194 if (q->mq_ops->put_budget)
195 q->mq_ops->put_budget(hctx);
198 static inline bool blk_mq_get_dispatch_budget(struct blk_mq_hw_ctx *hctx)
200 struct request_queue *q = hctx->queue;
202 if (q->mq_ops->get_budget)
203 return q->mq_ops->get_budget(hctx);
204 return true;
207 static inline void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx,
208 struct request *rq)
210 blk_mq_put_tag(hctx, hctx->tags, rq->mq_ctx, rq->tag);
211 rq->tag = -1;
213 if (rq->rq_flags & RQF_MQ_INFLIGHT) {
214 rq->rq_flags &= ~RQF_MQ_INFLIGHT;
215 atomic_dec(&hctx->nr_active);
219 static inline void blk_mq_put_driver_tag_hctx(struct blk_mq_hw_ctx *hctx,
220 struct request *rq)
222 if (rq->tag == -1 || rq->internal_tag == -1)
223 return;
225 __blk_mq_put_driver_tag(hctx, rq);
228 static inline void blk_mq_put_driver_tag(struct request *rq)
230 struct blk_mq_hw_ctx *hctx;
232 if (rq->tag == -1 || rq->internal_tag == -1)
233 return;
235 hctx = blk_mq_map_queue(rq->q, rq->mq_ctx->cpu);
236 __blk_mq_put_driver_tag(hctx, rq);
239 #endif