Merge tag 'pxa-dt-4.21' of https://github.com/rjarzmik/linux into next/dt
[muen/linux.git] / block / blk.h
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
10 /* Amount of time in which a process may batch requests */
11 #define BLK_BATCH_TIME  (HZ/50UL)
12
13 /* Number of requests a "batching" process may submit */
14 #define BLK_BATCH_REQ   32
15
16 /* Max future timer expiry for timeouts */
17 #define BLK_MAX_TIMEOUT         (5 * HZ)
18
19 #ifdef CONFIG_DEBUG_FS
20 extern struct dentry *blk_debugfs_root;
21 #endif
22
23 struct blk_flush_queue {
24         unsigned int            flush_queue_delayed:1;
25         unsigned int            flush_pending_idx:1;
26         unsigned int            flush_running_idx:1;
27         unsigned long           flush_pending_since;
28         struct list_head        flush_queue[2];
29         struct list_head        flush_data_in_flight;
30         struct request          *flush_rq;
31
32         /*
33          * flush_rq shares tag with this rq, both can't be active
34          * at the same time
35          */
36         struct request          *orig_rq;
37         spinlock_t              mq_flush_lock;
38 };
39
40 extern struct kmem_cache *blk_requestq_cachep;
41 extern struct kmem_cache *request_cachep;
42 extern struct kobj_type blk_queue_ktype;
43 extern struct ida blk_queue_ida;
44
45 /*
46  * @q->queue_lock is set while a queue is being initialized. Since we know
47  * that no other threads access the queue object before @q->queue_lock has
48  * been set, it is safe to manipulate queue flags without holding the
49  * queue_lock if @q->queue_lock == NULL. See also blk_alloc_queue_node() and
50  * blk_init_allocated_queue().
51  */
52 static inline void queue_lockdep_assert_held(struct request_queue *q)
53 {
54         if (q->queue_lock)
55                 lockdep_assert_held(q->queue_lock);
56 }
57
58 static inline void queue_flag_set_unlocked(unsigned int flag,
59                                            struct request_queue *q)
60 {
61         if (test_bit(QUEUE_FLAG_INIT_DONE, &q->queue_flags) &&
62             kref_read(&q->kobj.kref))
63                 lockdep_assert_held(q->queue_lock);
64         __set_bit(flag, &q->queue_flags);
65 }
66
67 static inline void queue_flag_clear_unlocked(unsigned int flag,
68                                              struct request_queue *q)
69 {
70         if (test_bit(QUEUE_FLAG_INIT_DONE, &q->queue_flags) &&
71             kref_read(&q->kobj.kref))
72                 lockdep_assert_held(q->queue_lock);
73         __clear_bit(flag, &q->queue_flags);
74 }
75
76 static inline int queue_flag_test_and_clear(unsigned int flag,
77                                             struct request_queue *q)
78 {
79         queue_lockdep_assert_held(q);
80
81         if (test_bit(flag, &q->queue_flags)) {
82                 __clear_bit(flag, &q->queue_flags);
83                 return 1;
84         }
85
86         return 0;
87 }
88
89 static inline int queue_flag_test_and_set(unsigned int flag,
90                                           struct request_queue *q)
91 {
92         queue_lockdep_assert_held(q);
93
94         if (!test_bit(flag, &q->queue_flags)) {
95                 __set_bit(flag, &q->queue_flags);
96                 return 0;
97         }
98
99         return 1;
100 }
101
102 static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
103 {
104         queue_lockdep_assert_held(q);
105         __set_bit(flag, &q->queue_flags);
106 }
107
108 static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
109 {
110         queue_lockdep_assert_held(q);
111         __clear_bit(flag, &q->queue_flags);
112 }
113
114 static inline struct blk_flush_queue *blk_get_flush_queue(
115                 struct request_queue *q, struct blk_mq_ctx *ctx)
116 {
117         if (q->mq_ops)
118                 return blk_mq_map_queue(q, ctx->cpu)->fq;
119         return q->fq;
120 }
121
122 static inline void __blk_get_queue(struct request_queue *q)
123 {
124         kobject_get(&q->kobj);
125 }
126
127 struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,
128                 int node, int cmd_size, gfp_t flags);
129 void blk_free_flush_queue(struct blk_flush_queue *q);
130
131 int blk_init_rl(struct request_list *rl, struct request_queue *q,
132                 gfp_t gfp_mask);
133 void blk_exit_rl(struct request_queue *q, struct request_list *rl);
134 void blk_exit_queue(struct request_queue *q);
135 void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
136                         struct bio *bio);
137 void blk_queue_bypass_start(struct request_queue *q);
138 void blk_queue_bypass_end(struct request_queue *q);
139 void __blk_queue_free_tags(struct request_queue *q);
140 void blk_freeze_queue(struct request_queue *q);
141
142 static inline void blk_queue_enter_live(struct request_queue *q)
143 {
144         /*
145          * Given that running in generic_make_request() context
146          * guarantees that a live reference against q_usage_counter has
147          * been established, further references under that same context
148          * need not check that the queue has been frozen (marked dead).
149          */
150         percpu_ref_get(&q->q_usage_counter);
151 }
152
153 static inline bool biovec_phys_mergeable(struct request_queue *q,
154                 struct bio_vec *vec1, struct bio_vec *vec2)
155 {
156         unsigned long mask = queue_segment_boundary(q);
157         phys_addr_t addr1 = page_to_phys(vec1->bv_page) + vec1->bv_offset;
158         phys_addr_t addr2 = page_to_phys(vec2->bv_page) + vec2->bv_offset;
159
160         if (addr1 + vec1->bv_len != addr2)
161                 return false;
162         if (xen_domain() && !xen_biovec_phys_mergeable(vec1, vec2))
163                 return false;
164         if ((addr1 | mask) != ((addr2 + vec2->bv_len - 1) | mask))
165                 return false;
166         return true;
167 }
168
169 static inline bool __bvec_gap_to_prev(struct request_queue *q,
170                 struct bio_vec *bprv, unsigned int offset)
171 {
172         return (offset & queue_virt_boundary(q)) ||
173                 ((bprv->bv_offset + bprv->bv_len) & queue_virt_boundary(q));
174 }
175
176 /*
177  * Check if adding a bio_vec after bprv with offset would create a gap in
178  * the SG list. Most drivers don't care about this, but some do.
179  */
180 static inline bool bvec_gap_to_prev(struct request_queue *q,
181                 struct bio_vec *bprv, unsigned int offset)
182 {
183         if (!queue_virt_boundary(q))
184                 return false;
185         return __bvec_gap_to_prev(q, bprv, offset);
186 }
187
188 #ifdef CONFIG_BLK_DEV_INTEGRITY
189 void blk_flush_integrity(void);
190 bool __bio_integrity_endio(struct bio *);
191 static inline bool bio_integrity_endio(struct bio *bio)
192 {
193         if (bio_integrity(bio))
194                 return __bio_integrity_endio(bio);
195         return true;
196 }
197
198 static inline bool integrity_req_gap_back_merge(struct request *req,
199                 struct bio *next)
200 {
201         struct bio_integrity_payload *bip = bio_integrity(req->bio);
202         struct bio_integrity_payload *bip_next = bio_integrity(next);
203
204         return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
205                                 bip_next->bip_vec[0].bv_offset);
206 }
207
208 static inline bool integrity_req_gap_front_merge(struct request *req,
209                 struct bio *bio)
210 {
211         struct bio_integrity_payload *bip = bio_integrity(bio);
212         struct bio_integrity_payload *bip_next = bio_integrity(req->bio);
213
214         return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
215                                 bip_next->bip_vec[0].bv_offset);
216 }
217 #else /* CONFIG_BLK_DEV_INTEGRITY */
218 static inline bool integrity_req_gap_back_merge(struct request *req,
219                 struct bio *next)
220 {
221         return false;
222 }
223 static inline bool integrity_req_gap_front_merge(struct request *req,
224                 struct bio *bio)
225 {
226         return false;
227 }
228
229 static inline void blk_flush_integrity(void)
230 {
231 }
232 static inline bool bio_integrity_endio(struct bio *bio)
233 {
234         return true;
235 }
236 #endif /* CONFIG_BLK_DEV_INTEGRITY */
237
238 void blk_timeout_work(struct work_struct *work);
239 unsigned long blk_rq_timeout(unsigned long timeout);
240 void blk_add_timer(struct request *req);
241 void blk_delete_timer(struct request *);
242
243
244 bool bio_attempt_front_merge(struct request_queue *q, struct request *req,
245                              struct bio *bio);
246 bool bio_attempt_back_merge(struct request_queue *q, struct request *req,
247                             struct bio *bio);
248 bool bio_attempt_discard_merge(struct request_queue *q, struct request *req,
249                 struct bio *bio);
250 bool blk_attempt_plug_merge(struct request_queue *q, struct bio *bio,
251                             unsigned int *request_count,
252                             struct request **same_queue_rq);
253 unsigned int blk_plug_queued_count(struct request_queue *q);
254
255 void blk_account_io_start(struct request *req, bool new_io);
256 void blk_account_io_completion(struct request *req, unsigned int bytes);
257 void blk_account_io_done(struct request *req, u64 now);
258
259 /*
260  * EH timer and IO completion will both attempt to 'grab' the request, make
261  * sure that only one of them succeeds. Steal the bottom bit of the
262  * __deadline field for this.
263  */
264 static inline int blk_mark_rq_complete(struct request *rq)
265 {
266         return test_and_set_bit(0, &rq->__deadline);
267 }
268
269 static inline void blk_clear_rq_complete(struct request *rq)
270 {
271         clear_bit(0, &rq->__deadline);
272 }
273
274 static inline bool blk_rq_is_complete(struct request *rq)
275 {
276         return test_bit(0, &rq->__deadline);
277 }
278
279 /*
280  * Internal elevator interface
281  */
282 #define ELV_ON_HASH(rq) ((rq)->rq_flags & RQF_HASHED)
283
284 void blk_insert_flush(struct request *rq);
285
286 static inline void elv_activate_rq(struct request_queue *q, struct request *rq)
287 {
288         struct elevator_queue *e = q->elevator;
289
290         if (e->type->ops.sq.elevator_activate_req_fn)
291                 e->type->ops.sq.elevator_activate_req_fn(q, rq);
292 }
293
294 static inline void elv_deactivate_rq(struct request_queue *q, struct request *rq)
295 {
296         struct elevator_queue *e = q->elevator;
297
298         if (e->type->ops.sq.elevator_deactivate_req_fn)
299                 e->type->ops.sq.elevator_deactivate_req_fn(q, rq);
300 }
301
302 int elevator_init(struct request_queue *);
303 int elevator_init_mq(struct request_queue *q);
304 int elevator_switch_mq(struct request_queue *q,
305                               struct elevator_type *new_e);
306 void elevator_exit(struct request_queue *, struct elevator_queue *);
307 int elv_register_queue(struct request_queue *q);
308 void elv_unregister_queue(struct request_queue *q);
309
310 struct hd_struct *__disk_get_part(struct gendisk *disk, int partno);
311
312 #ifdef CONFIG_FAIL_IO_TIMEOUT
313 int blk_should_fake_timeout(struct request_queue *);
314 ssize_t part_timeout_show(struct device *, struct device_attribute *, char *);
315 ssize_t part_timeout_store(struct device *, struct device_attribute *,
316                                 const char *, size_t);
317 #else
318 static inline int blk_should_fake_timeout(struct request_queue *q)
319 {
320         return 0;
321 }
322 #endif
323
324 int ll_back_merge_fn(struct request_queue *q, struct request *req,
325                      struct bio *bio);
326 int ll_front_merge_fn(struct request_queue *q, struct request *req, 
327                       struct bio *bio);
328 struct request *attempt_back_merge(struct request_queue *q, struct request *rq);
329 struct request *attempt_front_merge(struct request_queue *q, struct request *rq);
330 int blk_attempt_req_merge(struct request_queue *q, struct request *rq,
331                                 struct request *next);
332 void blk_recalc_rq_segments(struct request *rq);
333 void blk_rq_set_mixed_merge(struct request *rq);
334 bool blk_rq_merge_ok(struct request *rq, struct bio *bio);
335 enum elv_merge blk_try_merge(struct request *rq, struct bio *bio);
336
337 void blk_queue_congestion_threshold(struct request_queue *q);
338
339 int blk_dev_init(void);
340
341
342 /*
343  * Return the threshold (number of used requests) at which the queue is
344  * considered to be congested.  It include a little hysteresis to keep the
345  * context switch rate down.
346  */
347 static inline int queue_congestion_on_threshold(struct request_queue *q)
348 {
349         return q->nr_congestion_on;
350 }
351
352 /*
353  * The threshold at which a queue is considered to be uncongested
354  */
355 static inline int queue_congestion_off_threshold(struct request_queue *q)
356 {
357         return q->nr_congestion_off;
358 }
359
360 extern int blk_update_nr_requests(struct request_queue *, unsigned int);
361
362 /*
363  * Contribute to IO statistics IFF:
364  *
365  *      a) it's attached to a gendisk, and
366  *      b) the queue had IO stats enabled when this request was started, and
367  *      c) it's a file system request
368  */
369 static inline bool blk_do_io_stat(struct request *rq)
370 {
371         return rq->rq_disk &&
372                (rq->rq_flags & RQF_IO_STAT) &&
373                 !blk_rq_is_passthrough(rq);
374 }
375
376 static inline void req_set_nomerge(struct request_queue *q, struct request *req)
377 {
378         req->cmd_flags |= REQ_NOMERGE;
379         if (req == q->last_merge)
380                 q->last_merge = NULL;
381 }
382
383 /*
384  * Steal a bit from this field for legacy IO path atomic IO marking. Note that
385  * setting the deadline clears the bottom bit, potentially clearing the
386  * completed bit. The user has to be OK with this (current ones are fine).
387  */
388 static inline void blk_rq_set_deadline(struct request *rq, unsigned long time)
389 {
390         rq->__deadline = time & ~0x1UL;
391 }
392
393 static inline unsigned long blk_rq_deadline(struct request *rq)
394 {
395         return rq->__deadline & ~0x1UL;
396 }
397
398 /*
399  * The max size one bio can handle is UINT_MAX becasue bvec_iter.bi_size
400  * is defined as 'unsigned int', meantime it has to aligned to with logical
401  * block size which is the minimum accepted unit by hardware.
402  */
403 static inline unsigned int bio_allowed_max_sectors(struct request_queue *q)
404 {
405         return round_down(UINT_MAX, queue_logical_block_size(q)) >> 9;
406 }
407
408 /*
409  * Internal io_context interface
410  */
411 void get_io_context(struct io_context *ioc);
412 struct io_cq *ioc_lookup_icq(struct io_context *ioc, struct request_queue *q);
413 struct io_cq *ioc_create_icq(struct io_context *ioc, struct request_queue *q,
414                              gfp_t gfp_mask);
415 void ioc_clear_queue(struct request_queue *q);
416
417 int create_task_io_context(struct task_struct *task, gfp_t gfp_mask, int node);
418
419 /**
420  * rq_ioc - determine io_context for request allocation
421  * @bio: request being allocated is for this bio (can be %NULL)
422  *
423  * Determine io_context to use for request allocation for @bio.  May return
424  * %NULL if %current->io_context doesn't exist.
425  */
426 static inline struct io_context *rq_ioc(struct bio *bio)
427 {
428 #ifdef CONFIG_BLK_CGROUP
429         if (bio && bio->bi_ioc)
430                 return bio->bi_ioc;
431 #endif
432         return current->io_context;
433 }
434
435 /**
436  * create_io_context - try to create task->io_context
437  * @gfp_mask: allocation mask
438  * @node: allocation node
439  *
440  * If %current->io_context is %NULL, allocate a new io_context and install
441  * it.  Returns the current %current->io_context which may be %NULL if
442  * allocation failed.
443  *
444  * Note that this function can't be called with IRQ disabled because
445  * task_lock which protects %current->io_context is IRQ-unsafe.
446  */
447 static inline struct io_context *create_io_context(gfp_t gfp_mask, int node)
448 {
449         WARN_ON_ONCE(irqs_disabled());
450         if (unlikely(!current->io_context))
451                 create_task_io_context(current, gfp_mask, node);
452         return current->io_context;
453 }
454
455 /*
456  * Internal throttling interface
457  */
458 #ifdef CONFIG_BLK_DEV_THROTTLING
459 extern void blk_throtl_drain(struct request_queue *q);
460 extern int blk_throtl_init(struct request_queue *q);
461 extern void blk_throtl_exit(struct request_queue *q);
462 extern void blk_throtl_register_queue(struct request_queue *q);
463 #else /* CONFIG_BLK_DEV_THROTTLING */
464 static inline void blk_throtl_drain(struct request_queue *q) { }
465 static inline int blk_throtl_init(struct request_queue *q) { return 0; }
466 static inline void blk_throtl_exit(struct request_queue *q) { }
467 static inline void blk_throtl_register_queue(struct request_queue *q) { }
468 #endif /* CONFIG_BLK_DEV_THROTTLING */
469 #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
470 extern ssize_t blk_throtl_sample_time_show(struct request_queue *q, char *page);
471 extern ssize_t blk_throtl_sample_time_store(struct request_queue *q,
472         const char *page, size_t count);
473 extern void blk_throtl_bio_endio(struct bio *bio);
474 extern void blk_throtl_stat_add(struct request *rq, u64 time);
475 #else
476 static inline void blk_throtl_bio_endio(struct bio *bio) { }
477 static inline void blk_throtl_stat_add(struct request *rq, u64 time) { }
478 #endif
479
480 #ifdef CONFIG_BOUNCE
481 extern int init_emergency_isa_pool(void);
482 extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
483 #else
484 static inline int init_emergency_isa_pool(void)
485 {
486         return 0;
487 }
488 static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
489 {
490 }
491 #endif /* CONFIG_BOUNCE */
492
493 extern void blk_drain_queue(struct request_queue *q);
494
495 #ifdef CONFIG_BLK_CGROUP_IOLATENCY
496 extern int blk_iolatency_init(struct request_queue *q);
497 #else
498 static inline int blk_iolatency_init(struct request_queue *q) { return 0; }
499 #endif
500
501 struct bio *blk_next_bio(struct bio *bio, unsigned int nr_pages, gfp_t gfp);
502
503 #ifdef CONFIG_BLK_DEV_ZONED
504 void blk_queue_free_zone_bitmaps(struct request_queue *q);
505 #else
506 static inline void blk_queue_free_zone_bitmaps(struct request_queue *q) {}
507 #endif
508
509 #endif /* BLK_INTERNAL_H */