]>
Commit | Line | Data |
---|---|---|
1 | #ifndef INT_BLK_MQ_H | |
2 | #define INT_BLK_MQ_H | |
3 | ||
4 | #include "blk-stat.h" | |
5 | ||
6 | struct blk_mq_tag_set; | |
7 | ||
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; | |
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 | struct blk_rq_stat stat[2]; | |
24 | ||
25 | struct request_queue *queue; | |
26 | struct kobject kobj; | |
27 | } ____cacheline_aligned_in_smp; | |
28 | ||
29 | void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async); | |
30 | void blk_mq_freeze_queue(struct request_queue *q); | |
31 | void blk_mq_free_queue(struct request_queue *q); | |
32 | int blk_mq_update_nr_requests(struct request_queue *q, unsigned int nr); | |
33 | void blk_mq_wake_waiters(struct request_queue *q); | |
34 | bool blk_mq_dispatch_rq_list(struct blk_mq_hw_ctx *, struct list_head *); | |
35 | void blk_mq_flush_busy_ctxs(struct blk_mq_hw_ctx *hctx, struct list_head *list); | |
36 | ||
37 | /* | |
38 | * Internal helpers for allocating/freeing the request map | |
39 | */ | |
40 | void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, | |
41 | unsigned int hctx_idx); | |
42 | void blk_mq_free_rq_map(struct blk_mq_tags *tags); | |
43 | struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, | |
44 | unsigned int hctx_idx, | |
45 | unsigned int nr_tags, | |
46 | unsigned int reserved_tags); | |
47 | int blk_mq_alloc_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags, | |
48 | unsigned int hctx_idx, unsigned int depth); | |
49 | ||
50 | /* | |
51 | * Internal helpers for request insertion into sw queues | |
52 | */ | |
53 | void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq, | |
54 | bool at_head); | |
55 | /* | |
56 | * CPU hotplug helpers | |
57 | */ | |
58 | void blk_mq_enable_hotplug(void); | |
59 | void blk_mq_disable_hotplug(void); | |
60 | ||
61 | /* | |
62 | * CPU -> queue mappings | |
63 | */ | |
64 | extern int blk_mq_hw_queue_to_node(unsigned int *map, unsigned int); | |
65 | ||
66 | static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q, | |
67 | int cpu) | |
68 | { | |
69 | return q->queue_hw_ctx[q->mq_map[cpu]]; | |
70 | } | |
71 | ||
72 | /* | |
73 | * sysfs helpers | |
74 | */ | |
75 | extern int blk_mq_sysfs_register(struct request_queue *q); | |
76 | extern void blk_mq_sysfs_unregister(struct request_queue *q); | |
77 | extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx); | |
78 | ||
79 | extern void blk_mq_rq_timed_out(struct request *req, bool reserved); | |
80 | ||
81 | void blk_mq_release(struct request_queue *q); | |
82 | ||
83 | static inline struct blk_mq_ctx *__blk_mq_get_ctx(struct request_queue *q, | |
84 | unsigned int cpu) | |
85 | { | |
86 | return per_cpu_ptr(q->queue_ctx, cpu); | |
87 | } | |
88 | ||
89 | /* | |
90 | * This assumes per-cpu software queueing queues. They could be per-node | |
91 | * as well, for instance. For now this is hardcoded as-is. Note that we don't | |
92 | * care about preemption, since we know the ctx's are persistent. This does | |
93 | * mean that we can't rely on ctx always matching the currently running CPU. | |
94 | */ | |
95 | static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) | |
96 | { | |
97 | return __blk_mq_get_ctx(q, get_cpu()); | |
98 | } | |
99 | ||
100 | static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx) | |
101 | { | |
102 | put_cpu(); | |
103 | } | |
104 | ||
105 | struct blk_mq_alloc_data { | |
106 | /* input parameter */ | |
107 | struct request_queue *q; | |
108 | unsigned int flags; | |
109 | ||
110 | /* input & output parameter */ | |
111 | struct blk_mq_ctx *ctx; | |
112 | struct blk_mq_hw_ctx *hctx; | |
113 | }; | |
114 | ||
115 | static inline void blk_mq_set_alloc_data(struct blk_mq_alloc_data *data, | |
116 | struct request_queue *q, unsigned int flags, | |
117 | struct blk_mq_ctx *ctx, struct blk_mq_hw_ctx *hctx) | |
118 | { | |
119 | data->q = q; | |
120 | data->flags = flags; | |
121 | data->ctx = ctx; | |
122 | data->hctx = hctx; | |
123 | } | |
124 | ||
125 | static inline struct blk_mq_tags *blk_mq_tags_from_data(struct blk_mq_alloc_data *data) | |
126 | { | |
127 | return data->hctx->tags; | |
128 | } | |
129 | ||
130 | /* | |
131 | * Internal helpers for request allocation/init/free | |
132 | */ | |
133 | void blk_mq_rq_ctx_init(struct request_queue *q, struct blk_mq_ctx *ctx, | |
134 | struct request *rq, unsigned int op); | |
135 | void __blk_mq_free_request(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, | |
136 | struct request *rq); | |
137 | struct request *__blk_mq_alloc_request(struct blk_mq_alloc_data *data, | |
138 | unsigned int op); | |
139 | ||
140 | static inline bool blk_mq_hctx_stopped(struct blk_mq_hw_ctx *hctx) | |
141 | { | |
142 | return test_bit(BLK_MQ_S_STOPPED, &hctx->state); | |
143 | } | |
144 | ||
145 | static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) | |
146 | { | |
147 | return hctx->nr_ctx && hctx->tags; | |
148 | } | |
149 | ||
150 | #endif |