Commit | Line | Data |
---|---|---|
320ae51f JA |
1 | #ifndef INT_BLK_MQ_H |
2 | #define INT_BLK_MQ_H | |
3 | ||
cf43e6be JA |
4 | #include "blk-stat.h" |
5 | ||
24d2f903 CH |
6 | struct blk_mq_tag_set; |
7 | ||
320ae51f JA |
8 | struct blk_mq_ctx { |
9 | struct { | |
10 | spinlock_t lock; | |
11 | struct list_head rq_list; | |
12 | } ____cacheline_aligned_in_smp; | |
13 | ||
14 | unsigned int cpu; | |
15 | unsigned int index_hw; | |
320ae51f JA |
16 | |
17 | /* incremented at dispatch time */ | |
18 | unsigned long rq_dispatched[2]; | |
19 | unsigned long rq_merged; | |
20 | ||
21 | /* incremented at completion time */ | |
22 | unsigned long ____cacheline_aligned_in_smp rq_completed[2]; | |
23 | ||
24 | struct request_queue *queue; | |
25 | struct kobject kobj; | |
4bb659b1 | 26 | } ____cacheline_aligned_in_smp; |
320ae51f | 27 | |
320ae51f | 28 | void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async); |
780db207 | 29 | void blk_mq_freeze_queue(struct request_queue *q); |
3edcc0ce | 30 | void blk_mq_free_queue(struct request_queue *q); |
e3a2b3f9 | 31 | int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr); |
aed3ea94 | 32 | void blk_mq_wake_waiters(struct request_queue *q); |
81380ca1 | 33 | bool blk_mq_dispatch_rq_list(struct request_queue *, struct list_head *); |
2c3ad667 | 34 | void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list); |
50e1dab8 | 35 | bool blk_mq_hctx_has_pending(struct blk_mq_hw_ctx *hctx); |
bd6737f1 JA |
36 | bool blk_mq_get_driver_tag(struct request *rq, struct blk_mq_hw_ctx **hctx, |
37 | bool wait); | |
2c3ad667 JA |
38 | |
39 | /* | |
40 | * Internal helpers for allocating/freeing the request map | |
41 | */ | |
cc71a6f4 JA |
42 | void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, |
43 | unsigned int hctx_idx); | |
44 | void blk_mq_free_rq_map(struct blk_mq_tags *tags); | |
45 | struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, | |
46 | unsigned int hctx_idx, | |
47 | unsigned int nr_tags, | |
48 | unsigned int reserved_tags); | |
49 | int blk_mq_alloc_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, | |
50 | unsigned int hctx_idx, unsigned int depth); | |
2c3ad667 JA |
51 | |
52 | /* | |
53 | * Internal helpers for request insertion into sw queues | |
54 | */ | |
55 | void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq, | |
56 | bool at_head); | |
bd166ef1 JA |
57 | void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, |
58 | struct list_head *list); | |
320ae51f JA |
59 | /* |
60 | * CPU hotplug helpers | |
61 | */ | |
676141e4 JA |
62 | void blk_mq_enable_hotplug(void); |
63 | void blk_mq_disable_hotplug(void); | |
320ae51f JA |
64 | |
65 | /* | |
66 | * CPU -> queue mappings | |
67 | */ | |
f14bbe77 | 68 | extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int); |
320ae51f | 69 | |
7d7e0f90 CH |
70 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q, |
71 | int cpu) | |
72 | { | |
73 | return q->queue_hw_ctx[q->mq_map[cpu]]; | |
74 | } | |
75 | ||
67aec14c JA |
76 | /* |
77 | * sysfs helpers | |
78 | */ | |
737f98cf | 79 | extern void blk_mq_sysfs_init(struct request_queue *q); |
7ea5fe31 | 80 | extern void blk_mq_sysfs_deinit(struct request_queue *q); |
67aec14c JA |
81 | extern int blk_mq_sysfs_register(struct request_queue *q); |
82 | extern void blk_mq_sysfs_unregister(struct request_queue *q); | |
868f2f0b | 83 | extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx); |
67aec14c | 84 | |
07e4fead OS |
85 | /* |
86 | * debugfs helpers | |
87 | */ | |
400f73b2 | 88 | #ifdef CONFIG_BLK_DEBUG_FS |
07e4fead OS |
89 | int blk_mq_debugfs_register(struct request_queue *q, const char *name); |
90 | void blk_mq_debugfs_unregister(struct request_queue *q); | |
91 | int blk_mq_debugfs_register_hctxs(struct request_queue *q); | |
92 | void blk_mq_debugfs_unregister_hctxs(struct request_queue *q); | |
93 | #else | |
400f73b2 OS |
94 | static inline int blk_mq_debugfs_register(struct request_queue *q, |
95 | const char *name) | |
07e4fead OS |
96 | { |
97 | return 0; | |
98 | } | |
99 | ||
400f73b2 | 100 | static inline void blk_mq_debugfs_unregister(struct request_queue *q) |
07e4fead OS |
101 | { |
102 | } | |
103 | ||
400f73b2 | 104 | static inline int blk_mq_debugfs_register_hctxs(struct request_queue *q) |
07e4fead OS |
105 | { |
106 | return 0; | |
107 | } | |
108 | ||
400f73b2 | 109 | static inline void blk_mq_debugfs_unregister_hctxs(struct request_queue *q) |
07e4fead OS |
110 | { |
111 | } | |
112 | #endif | |
113 | ||
90415837 CH |
114 | extern void blk_mq_rq_timed_out(struct request *req, bool reserved); |
115 | ||
e09aae7e ML |
116 | void blk_mq_release(struct request_queue *q); |
117 | ||
1aecfe48 ML |
118 | static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q, |
119 | unsigned int cpu) | |
120 | { | |
121 | return per_cpu_ptr(q->queue_ctx, cpu); | |
122 | } | |
123 | ||
124 | /* | |
125 | * This assumes per-cpu software queueing queues. They could be per-node | |
126 | * as well, for instance. For now this is hardcoded as-is. Note that we don't | |
127 | * care about preemption, since we know the ctx's are persistent. This does | |
128 | * mean that we can't rely on ctx always matching the currently running CPU. | |
129 | */ | |
130 | static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) | |
131 | { | |
132 | return __blk_mq_get_ctx(q, get_cpu()); | |
133 | } | |
134 | ||
135 | static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx) | |
136 | { | |
137 | put_cpu(); | |
138 | } | |
139 | ||
cb96a42c ML |
140 | struct blk_mq_alloc_data { |
141 | /* input parameter */ | |
142 | struct request_queue *q; | |
6f3b0e8b | 143 | unsigned int flags; |
cb96a42c ML |
144 | |
145 | /* input & output parameter */ | |
146 | struct blk_mq_ctx *ctx; | |
147 | struct blk_mq_hw_ctx *hctx; | |
148 | }; | |
149 | ||
4941115b JA |
150 | static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data) |
151 | { | |
bd166ef1 JA |
152 | if (data->flags & BLK_MQ_REQ_INTERNAL) |
153 | return data->hctx->sched_tags; | |
154 | ||
4941115b JA |
155 | return data->hctx->tags; |
156 | } | |
157 | ||
2c3ad667 JA |
158 | /* |
159 | * Internal helpers for request allocation/init/free | |
160 | */ | |
161 | void blk_mq_rq_ctx_init(struct request_queue *q, struct blk_mq_ctx *ctx, | |
162 | struct request *rq, unsigned int op); | |
bd166ef1 | 163 | void __blk_mq_finish_request(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, |
2c3ad667 | 164 | struct request *rq); |
bd166ef1 | 165 | void blk_mq_finish_request(struct request *rq); |
2c3ad667 JA |
166 | struct request *__blk_mq_alloc_request(struct blk_mq_alloc_data *data, |
167 | unsigned int op); | |
168 | ||
5d1b25c1 BVA |
169 | static inline bool blk_mq_hctx_stopped(struct blk_mq_hw_ctx *hctx) |
170 | { | |
171 | return test_bit(BLK_MQ_S_STOPPED, &hctx->state); | |
172 | } | |
173 | ||
19c66e59 ML |
174 | static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) |
175 | { | |
176 | return hctx->nr_ctx && hctx->tags; | |
177 | } | |
178 | ||
320ae51f | 179 | #endif |