Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #ifndef BLK_INTERNAL_H
3 : : #define BLK_INTERNAL_H
4 : :
5 : : #include <linux/idr.h>
6 : : #include <linux/blk-mq.h>
7 : : #include <xen/xen.h>
8 : : #include "blk-mq.h"
9 : : #include "blk-mq-sched.h"
10 : :
11 : : /* Max future timer expiry for timeouts */
12 : : #define BLK_MAX_TIMEOUT (5 * HZ)
13 : :
14 : : #ifdef CONFIG_DEBUG_FS
15 : : extern struct dentry *blk_debugfs_root;
16 : : #endif
17 : :
18 : : struct blk_flush_queue {
19 : : unsigned int flush_queue_delayed:1;
20 : : unsigned int flush_pending_idx:1;
21 : : unsigned int flush_running_idx:1;
22 : : blk_status_t rq_status;
23 : : unsigned long flush_pending_since;
24 : : struct list_head flush_queue[2];
25 : : struct list_head flush_data_in_flight;
26 : : struct request *flush_rq;
27 : :
28 : : /*
29 : : * flush_rq shares tag with this rq, both can't be active
30 : : * at the same time
31 : : */
32 : : struct request *orig_rq;
33 : : struct lock_class_key key;
34 : : spinlock_t mq_flush_lock;
35 : : };
36 : :
37 : : extern struct kmem_cache *blk_requestq_cachep;
38 : : extern struct kobj_type blk_queue_ktype;
39 : : extern struct ida blk_queue_ida;
40 : :
41 : : static inline struct blk_flush_queue *
42 : 450 : blk_get_flush_queue(struct request_queue *q, struct blk_mq_ctx *ctx)
43 : : {
44 [ + - + - ]: 450 : return blk_mq_map_queue(q, REQ_OP_FLUSH, ctx)->fq;
45 : : }
46 : :
47 : 195 : static inline void __blk_get_queue(struct request_queue *q)
48 : : {
49 : 195 : kobject_get(&q->kobj);
50 : : }
51 : :
52 : : static inline bool
53 : 130 : is_flush_rq(struct request *req, struct blk_mq_hw_ctx *hctx)
54 : : {
55 [ - + ]: 130 : return hctx->fq->flush_rq == req;
56 : : }
57 : :
58 : : struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,
59 : : int node, int cmd_size, gfp_t flags);
60 : : void blk_free_flush_queue(struct blk_flush_queue *q);
61 : :
62 : : void blk_freeze_queue(struct request_queue *q);
63 : :
64 : 14720 : static inline void blk_queue_enter_live(struct request_queue *q)
65 : : {
66 : : /*
67 : : * Given that running in generic_make_request() context
68 : : * guarantees that a live reference against q_usage_counter has
69 : : * been established, further references under that same context
70 : : * need not check that the queue has been frozen (marked dead).
71 : : */
72 : 14720 : percpu_ref_get(&q->q_usage_counter);
73 : : }
74 : :
75 : 7221 : static inline bool biovec_phys_mergeable(struct request_queue *q,
76 : : struct bio_vec *vec1, struct bio_vec *vec2)
77 : : {
78 [ + + ]: 7221 : unsigned long mask = queue_segment_boundary(q);
79 : 7221 : phys_addr_t addr1 = page_to_phys(vec1->bv_page) + vec1->bv_offset;
80 : 7221 : phys_addr_t addr2 = page_to_phys(vec2->bv_page) + vec2->bv_offset;
81 : :
82 [ + + ]: 7221 : if (addr1 + vec1->bv_len != addr2)
83 : : return false;
84 : 1971 : if (xen_domain() && !xen_biovec_phys_mergeable(vec1, vec2->bv_page))
85 : : return false;
86 [ + + ]: 1971 : if ((addr1 | mask) != ((addr2 + vec2->bv_len - 1) | mask))
87 : 72 : return false;
88 : : return true;
89 : : }
90 : :
91 : 0 : static inline bool __bvec_gap_to_prev(struct request_queue *q,
92 : : struct bio_vec *bprv, unsigned int offset)
93 : : {
94 [ # # # # : 0 : return (offset & queue_virt_boundary(q)) ||
# # # # ]
95 [ # # # # ]: 0 : ((bprv->bv_offset + bprv->bv_len) & queue_virt_boundary(q));
96 : : }
97 : :
98 : : /*
99 : : * Check if adding a bio_vec after bprv with offset would create a gap in
100 : : * the SG list. Most drivers don't care about this, but some do.
101 : : */
102 : 23933 : static inline bool bvec_gap_to_prev(struct request_queue *q,
103 : : struct bio_vec *bprv, unsigned int offset)
104 : : {
105 [ - + ]: 23933 : if (!queue_virt_boundary(q))
106 : : return false;
107 [ # # ]: 0 : return __bvec_gap_to_prev(q, bprv, offset);
108 : : }
109 : :
110 : 14499 : static inline void blk_rq_bio_prep(struct request *rq, struct bio *bio,
111 : : unsigned int nr_segs)
112 : : {
113 : 14499 : rq->nr_phys_segments = nr_segs;
114 : 14499 : rq->__data_len = bio->bi_iter.bi_size;
115 : 14499 : rq->bio = rq->biotail = bio;
116 : 14499 : rq->ioprio = bio_prio(bio);
117 : :
118 [ + + ]: 14499 : if (bio->bi_disk)
119 : 12965 : rq->rq_disk = bio->bi_disk;
120 : : }
121 : :
122 : : #ifdef CONFIG_BLK_DEV_INTEGRITY
123 : : void blk_flush_integrity(void);
124 : : bool __bio_integrity_endio(struct bio *);
125 : : void bio_integrity_free(struct bio *bio);
126 : : static inline bool bio_integrity_endio(struct bio *bio)
127 : : {
128 : : if (bio_integrity(bio))
129 : : return __bio_integrity_endio(bio);
130 : : return true;
131 : : }
132 : :
133 : : static inline bool integrity_req_gap_back_merge(struct request *req,
134 : : struct bio *next)
135 : : {
136 : : struct bio_integrity_payload *bip = bio_integrity(req->bio);
137 : : struct bio_integrity_payload *bip_next = bio_integrity(next);
138 : :
139 : : return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
140 : : bip_next->bip_vec[0].bv_offset);
141 : : }
142 : :
143 : : static inline bool integrity_req_gap_front_merge(struct request *req,
144 : : struct bio *bio)
145 : : {
146 : : struct bio_integrity_payload *bip = bio_integrity(bio);
147 : : struct bio_integrity_payload *bip_next = bio_integrity(req->bio);
148 : :
149 : : return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
150 : : bip_next->bip_vec[0].bv_offset);
151 : : }
152 : : #else /* CONFIG_BLK_DEV_INTEGRITY */
153 : : static inline bool integrity_req_gap_back_merge(struct request *req,
154 : : struct bio *next)
155 : : {
156 : : return false;
157 : : }
158 : : static inline bool integrity_req_gap_front_merge(struct request *req,
159 : : struct bio *bio)
160 : : {
161 : : return false;
162 : : }
163 : :
164 : 0 : static inline void blk_flush_integrity(void)
165 : : {
166 : 0 : }
167 : 21577 : static inline bool bio_integrity_endio(struct bio *bio)
168 : : {
169 [ + + ]: 21577 : return true;
170 : : }
171 : : static inline void bio_integrity_free(struct bio *bio)
172 : : {
173 : : }
174 : : #endif /* CONFIG_BLK_DEV_INTEGRITY */
175 : :
176 : : unsigned long blk_rq_timeout(unsigned long timeout);
177 : : void blk_add_timer(struct request *req);
178 : :
179 : : bool bio_attempt_front_merge(struct request *req, struct bio *bio,
180 : : unsigned int nr_segs);
181 : : bool bio_attempt_back_merge(struct request *req, struct bio *bio,
182 : : unsigned int nr_segs);
183 : : bool bio_attempt_discard_merge(struct request_queue *q, struct request *req,
184 : : struct bio *bio);
185 : : bool blk_attempt_plug_merge(struct request_queue *q, struct bio *bio,
186 : : unsigned int nr_segs, struct request **same_queue_rq);
187 : :
188 : : void blk_account_io_start(struct request *req, bool new_io);
189 : : void blk_account_io_completion(struct request *req, unsigned int bytes);
190 : : void blk_account_io_done(struct request *req, u64 now);
191 : :
192 : : /*
193 : : * Internal elevator interface
194 : : */
195 : : #define ELV_ON_HASH(rq) ((rq)->rq_flags & RQF_HASHED)
196 : :
197 : : void blk_insert_flush(struct request *rq);
198 : :
199 : : void elevator_init_mq(struct request_queue *q);
200 : : int elevator_switch_mq(struct request_queue *q,
201 : : struct elevator_type *new_e);
202 : : void __elevator_exit(struct request_queue *, struct elevator_queue *);
203 : : int elv_register_queue(struct request_queue *q, bool uevent);
204 : : void elv_unregister_queue(struct request_queue *q);
205 : :
206 : 0 : static inline void elevator_exit(struct request_queue *q,
207 : : struct elevator_queue *e)
208 : : {
209 : 0 : lockdep_assert_held(&q->sysfs_lock);
210 : :
211 : 0 : blk_mq_sched_free_requests(q);
212 : 0 : __elevator_exit(q, e);
213 : 0 : }
214 : :
215 : : struct hd_struct *__disk_get_part(struct gendisk *disk, int partno);
216 : :
217 : : #ifdef CONFIG_FAIL_IO_TIMEOUT
218 : : int blk_should_fake_timeout(struct request_queue *);
219 : : ssize_t part_timeout_show(struct device *, struct device_attribute *, char *);
220 : : ssize_t part_timeout_store(struct device *, struct device_attribute *,
221 : : const char *, size_t);
222 : : #else
223 : 14647 : static inline int blk_should_fake_timeout(struct request_queue *q)
224 : : {
225 : 14647 : return 0;
226 : : }
227 : : #endif
228 : :
229 : : void __blk_queue_split(struct request_queue *q, struct bio **bio,
230 : : unsigned int *nr_segs);
231 : : int ll_back_merge_fn(struct request *req, struct bio *bio,
232 : : unsigned int nr_segs);
233 : : int ll_front_merge_fn(struct request *req, struct bio *bio,
234 : : unsigned int nr_segs);
235 : : struct request *attempt_back_merge(struct request_queue *q, struct request *rq);
236 : : struct request *attempt_front_merge(struct request_queue *q, struct request *rq);
237 : : int blk_attempt_req_merge(struct request_queue *q, struct request *rq,
238 : : struct request *next);
239 : : unsigned int blk_recalc_rq_segments(struct request *rq);
240 : : void blk_rq_set_mixed_merge(struct request *rq);
241 : : bool blk_rq_merge_ok(struct request *rq, struct bio *bio);
242 : : enum elv_merge blk_try_merge(struct request *rq, struct bio *bio);
243 : :
244 : : int blk_dev_init(void);
245 : :
246 : : /*
247 : : * Contribute to IO statistics IFF:
248 : : *
249 : : * a) it's attached to a gendisk, and
250 : : * b) the queue had IO stats enabled when this request was started
251 : : */
252 : 48045 : static inline bool blk_do_io_stat(struct request *rq)
253 : : {
254 [ + + - + : 49683 : return rq->rq_disk && (rq->rq_flags & RQF_IO_STAT);
+ + + - -
+ + - + -
- + + - ]
255 : : }
256 : :
257 : 0 : static inline void req_set_nomerge(struct request_queue *q, struct request *req)
258 : : {
259 : 0 : req->cmd_flags |= REQ_NOMERGE;
260 [ # # # # : 0 : if (req == q->last_merge)
# # # # #
# ]
261 : 0 : q->last_merge = NULL;
262 : : }
263 : :
264 : : /*
265 : : * The max size one bio can handle is UINT_MAX becasue bvec_iter.bi_size
266 : : * is defined as 'unsigned int', meantime it has to aligned to with logical
267 : : * block size which is the minimum accepted unit by hardware.
268 : : */
269 : 0 : static inline unsigned int bio_allowed_max_sectors(struct request_queue *q)
270 : : {
271 [ # # # # ]: 0 : return round_down(UINT_MAX, queue_logical_block_size(q)) >> 9;
272 : : }
273 : :
274 : : /*
275 : : * Internal io_context interface
276 : : */
277 : : void get_io_context(struct io_context *ioc);
278 : : struct io_cq *ioc_lookup_icq(struct io_context *ioc, struct request_queue *q);
279 : : struct io_cq *ioc_create_icq(struct io_context *ioc, struct request_queue *q,
280 : : gfp_t gfp_mask);
281 : : void ioc_clear_queue(struct request_queue *q);
282 : :
283 : : int create_task_io_context(struct task_struct *task, gfp_t gfp_mask, int node);
284 : :
285 : : /**
286 : : * create_io_context - try to create task->io_context
287 : : * @gfp_mask: allocation mask
288 : : * @node: allocation node
289 : : *
290 : : * If %current->io_context is %NULL, allocate a new io_context and install
291 : : * it. Returns the current %current->io_context which may be %NULL if
292 : : * allocation failed.
293 : : *
294 : : * Note that this function can't be called with IRQ disabled because
295 : : * task_lock which protects %current->io_context is IRQ-unsafe.
296 : : */
297 : 20043 : static inline struct io_context *create_io_context(gfp_t gfp_mask, int node)
298 : : {
299 [ - + ]: 20043 : WARN_ON_ONCE(irqs_disabled());
300 [ + + ]: 20043 : if (unlikely(!current->io_context))
301 : 1048 : create_task_io_context(current, gfp_mask, node);
302 : 20043 : return current->io_context;
303 : : }
304 : :
305 : : /*
306 : : * Internal throttling interface
307 : : */
308 : : #ifdef CONFIG_BLK_DEV_THROTTLING
309 : : extern void blk_throtl_drain(struct request_queue *q);
310 : : extern int blk_throtl_init(struct request_queue *q);
311 : : extern void blk_throtl_exit(struct request_queue *q);
312 : : extern void blk_throtl_register_queue(struct request_queue *q);
313 : : #else /* CONFIG_BLK_DEV_THROTTLING */
314 : : static inline void blk_throtl_drain(struct request_queue *q) { }
315 : : static inline int blk_throtl_init(struct request_queue *q) { return 0; }
316 : : static inline void blk_throtl_exit(struct request_queue *q) { }
317 : 156 : static inline void blk_throtl_register_queue(struct request_queue *q) { }
318 : : #endif /* CONFIG_BLK_DEV_THROTTLING */
319 : : #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
320 : : extern ssize_t blk_throtl_sample_time_show(struct request_queue *q, char *page);
321 : : extern ssize_t blk_throtl_sample_time_store(struct request_queue *q,
322 : : const char *page, size_t count);
323 : : extern void blk_throtl_bio_endio(struct bio *bio);
324 : : extern void blk_throtl_stat_add(struct request *rq, u64 time);
325 : : #else
326 [ + + ]: 21577 : static inline void blk_throtl_bio_endio(struct bio *bio) { }
327 : 0 : static inline void blk_throtl_stat_add(struct request *rq, u64 time) { }
328 : : #endif
329 : :
330 : : #ifdef CONFIG_BOUNCE
331 : : extern int init_emergency_isa_pool(void);
332 : : extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
333 : : #else
334 : : static inline int init_emergency_isa_pool(void)
335 : : {
336 : : return 0;
337 : : }
338 : : static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
339 : : {
340 : : }
341 : : #endif /* CONFIG_BOUNCE */
342 : :
343 : : #ifdef CONFIG_BLK_CGROUP_IOLATENCY
344 : : extern int blk_iolatency_init(struct request_queue *q);
345 : : #else
346 : : static inline int blk_iolatency_init(struct request_queue *q) { return 0; }
347 : : #endif
348 : :
349 : : struct bio *blk_next_bio(struct bio *bio, unsigned int nr_pages, gfp_t gfp);
350 : :
351 : : #ifdef CONFIG_BLK_DEV_ZONED
352 : : void blk_queue_free_zone_bitmaps(struct request_queue *q);
353 : : #else
354 [ # # ]: 0 : static inline void blk_queue_free_zone_bitmaps(struct request_queue *q) {}
355 : : #endif
356 : :
357 : : #endif /* BLK_INTERNAL_H */
|
