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 : : blk_get_flush_queue(struct request_queue *q, struct blk_mq_ctx *ctx)
43 : : {
44 : 0 : return blk_mq_map_queue(q, REQ_OP_FLUSH, ctx)->fq;
45 : : }
46 : :
47 : : static inline void __blk_get_queue(struct request_queue *q)
48 : : {
49 : 10504 : kobject_get(&q->kobj);
50 : : }
51 : :
52 : : static inline bool
53 : : is_flush_rq(struct request *req, struct blk_mq_hw_ctx *hctx)
54 : : {
55 : 0 : 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 : : 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 : 3020084 : percpu_ref_get(&q->q_usage_counter);
73 : : }
74 : :
75 : 2613894 : static inline bool biovec_phys_mergeable(struct request_queue *q,
76 : : struct bio_vec *vec1, struct bio_vec *vec2)
77 : : {
78 : : unsigned long mask = queue_segment_boundary(q);
79 : 2613894 : phys_addr_t addr1 = page_to_phys(vec1->bv_page) + vec1->bv_offset;
80 : 2613894 : phys_addr_t addr2 = page_to_phys(vec2->bv_page) + vec2->bv_offset;
81 : :
82 [ + + ]: 2613894 : if (addr1 + vec1->bv_len != addr2)
83 : : return false;
84 : : if (xen_domain() && !xen_biovec_phys_mergeable(vec1, vec2->bv_page))
85 : : return false;
86 [ + - ]: 1503790 : if ((addr1 | mask) != ((addr2 + vec2->bv_len - 1) | mask))
87 : : return false;
88 : 1503790 : return true;
89 : : }
90 : :
91 : : 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 : : static inline bool bvec_gap_to_prev(struct request_queue *q,
103 : : struct bio_vec *bprv, unsigned int offset)
104 : : {
105 [ - + ]: 2225010 : if (!queue_virt_boundary(q))
106 : : return false;
107 : : return __bvec_gap_to_prev(q, bprv, offset);
108 : : }
109 : :
110 : : static inline void blk_rq_bio_prep(struct request *rq, struct bio *bio,
111 : : unsigned int nr_segs)
112 : : {
113 : 3019904 : rq->nr_phys_segments = nr_segs;
114 : 3019904 : rq->__data_len = bio->bi_iter.bi_size;
115 : 3019904 : rq->bio = rq->biotail = bio;
116 : 3019904 : rq->ioprio = bio_prio(bio);
117 : :
118 [ + + ]: 3019904 : if (bio->bi_disk)
119 : 3019878 : 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 : : static inline void blk_flush_integrity(void)
165 : : {
166 : : }
167 : : static inline bool bio_integrity_endio(struct bio *bio)
168 : : {
169 : : 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 : : static inline void elevator_exit(struct request_queue *q,
207 : : struct elevator_queue *e)
208 : : {
209 : : lockdep_assert_held(&q->sysfs_lock);
210 : :
211 : 0 : blk_mq_sched_free_requests(q);
212 : 0 : __elevator_exit(q, e);
213 : : }
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 : : static inline int blk_should_fake_timeout(struct request_queue *q)
224 : : {
225 : : 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, and
251 : : * c) it's a file system request
252 : : */
253 : 11563452 : static inline bool blk_do_io_stat(struct request *rq)
254 : : {
255 [ + + ]: 34690702 : return rq->rq_disk &&
256 [ + + + + ]: 23127346 : (rq->rq_flags & RQF_IO_STAT) &&
257 : : !blk_rq_is_passthrough(rq);
258 : : }
259 : :
260 : : static inline void req_set_nomerge(struct request_queue *q, struct request *req)
261 : : {
262 : 498 : req->cmd_flags |= REQ_NOMERGE;
263 [ # # # # : 498 : if (req == q->last_merge)
# # + + +
+ ]
264 : 242 : q->last_merge = NULL;
265 : : }
266 : :
267 : : /*
268 : : * The max size one bio can handle is UINT_MAX becasue bvec_iter.bi_size
269 : : * is defined as 'unsigned int', meantime it has to aligned to with logical
270 : : * block size which is the minimum accepted unit by hardware.
271 : : */
272 : : static inline unsigned int bio_allowed_max_sectors(struct request_queue *q)
273 : : {
274 : 0 : return round_down(UINT_MAX, queue_logical_block_size(q)) >> 9;
275 : : }
276 : :
277 : : /*
278 : : * Internal io_context interface
279 : : */
280 : : void get_io_context(struct io_context *ioc);
281 : : struct io_cq *ioc_lookup_icq(struct io_context *ioc, struct request_queue *q);
282 : : struct io_cq *ioc_create_icq(struct io_context *ioc, struct request_queue *q,
283 : : gfp_t gfp_mask);
284 : : void ioc_clear_queue(struct request_queue *q);
285 : :
286 : : int create_task_io_context(struct task_struct *task, gfp_t gfp_mask, int node);
287 : :
288 : : /**
289 : : * create_io_context - try to create task->io_context
290 : : * @gfp_mask: allocation mask
291 : : * @node: allocation node
292 : : *
293 : : * If %current->io_context is %NULL, allocate a new io_context and install
294 : : * it. Returns the current %current->io_context which may be %NULL if
295 : : * allocation failed.
296 : : *
297 : : * Note that this function can't be called with IRQ disabled because
298 : : * task_lock which protects %current->io_context is IRQ-unsafe.
299 : : */
300 : 5584528 : static inline struct io_context *create_io_context(gfp_t gfp_mask, int node)
301 : : {
302 [ - + # # ]: 5584508 : WARN_ON_ONCE(irqs_disabled());
303 [ + + ]: 5584462 : if (unlikely(!current->io_context))
304 : 92612 : create_task_io_context(current, gfp_mask, node);
305 : 5584466 : return current->io_context;
306 : : }
307 : :
308 : : /*
309 : : * Internal throttling interface
310 : : */
311 : : #ifdef CONFIG_BLK_DEV_THROTTLING
312 : : extern void blk_throtl_drain(struct request_queue *q);
313 : : extern int blk_throtl_init(struct request_queue *q);
314 : : extern void blk_throtl_exit(struct request_queue *q);
315 : : extern void blk_throtl_register_queue(struct request_queue *q);
316 : : #else /* CONFIG_BLK_DEV_THROTTLING */
317 : : static inline void blk_throtl_drain(struct request_queue *q) { }
318 : : static inline int blk_throtl_init(struct request_queue *q) { return 0; }
319 : : static inline void blk_throtl_exit(struct request_queue *q) { }
320 : : static inline void blk_throtl_register_queue(struct request_queue *q) { }
321 : : #endif /* CONFIG_BLK_DEV_THROTTLING */
322 : : #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
323 : : extern ssize_t blk_throtl_sample_time_show(struct request_queue *q, char *page);
324 : : extern ssize_t blk_throtl_sample_time_store(struct request_queue *q,
325 : : const char *page, size_t count);
326 : : extern void blk_throtl_bio_endio(struct bio *bio);
327 : : extern void blk_throtl_stat_add(struct request *rq, u64 time);
328 : : #else
329 : : static inline void blk_throtl_bio_endio(struct bio *bio) { }
330 : : static inline void blk_throtl_stat_add(struct request *rq, u64 time) { }
331 : : #endif
332 : :
333 : : #ifdef CONFIG_BOUNCE
334 : : extern int init_emergency_isa_pool(void);
335 : : extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
336 : : #else
337 : : static inline int init_emergency_isa_pool(void)
338 : : {
339 : : return 0;
340 : : }
341 : : static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
342 : : {
343 : : }
344 : : #endif /* CONFIG_BOUNCE */
345 : :
346 : : #ifdef CONFIG_BLK_CGROUP_IOLATENCY
347 : : extern int blk_iolatency_init(struct request_queue *q);
348 : : #else
349 : : static inline int blk_iolatency_init(struct request_queue *q) { return 0; }
350 : : #endif
351 : :
352 : : struct bio *blk_next_bio(struct bio *bio, unsigned int nr_pages, gfp_t gfp);
353 : :
354 : : #ifdef CONFIG_BLK_DEV_ZONED
355 : : void blk_queue_free_zone_bitmaps(struct request_queue *q);
356 : : #else
357 : : static inline void blk_queue_free_zone_bitmaps(struct request_queue *q) {}
358 : : #endif
359 : :
360 : : #endif /* BLK_INTERNAL_H */
|
