GNU Linux-libre 4.19.211-gnu1
[releases.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 "blk-mq.h"
8
9 /* Amount of time in which a process may batch requests */
10 #define BLK_BATCH_TIME  (HZ/50UL)
11
12 /* Number of requests a "batching" process may submit */
13 #define BLK_BATCH_REQ   32
14
15 /* Max future timer expiry for timeouts */
16 #define BLK_MAX_TIMEOUT         (5 * HZ)
17
18 #ifdef CONFIG_DEBUG_FS
19 extern struct dentry *blk_debugfs_root;
20 #endif
21
22 struct blk_flush_queue {
23         unsigned int            flush_queue_delayed:1;
24         unsigned int            flush_pending_idx:1;
25         unsigned int            flush_running_idx:1;
26         blk_status_t            rq_status;
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 static inline bool
128 is_flush_rq(struct request *req, struct blk_mq_hw_ctx *hctx)
129 {
130         return hctx->fq->flush_rq == req;
131 }
132
133 struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,
134                 int node, int cmd_size, gfp_t flags);
135 void blk_free_flush_queue(struct blk_flush_queue *q);
136
137 int blk_init_rl(struct request_list *rl, struct request_queue *q,
138                 gfp_t gfp_mask);
139 void blk_exit_rl(struct request_queue *q, struct request_list *rl);
140 void blk_exit_queue(struct request_queue *q);
141 void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
142                         struct bio *bio);
143 void blk_queue_bypass_start(struct request_queue *q);
144 void blk_queue_bypass_end(struct request_queue *q);
145 void __blk_queue_free_tags(struct request_queue *q);
146 void blk_freeze_queue(struct request_queue *q);
147
148 static inline void blk_queue_enter_live(struct request_queue *q)
149 {
150         /*
151          * Given that running in generic_make_request() context
152          * guarantees that a live reference against q_usage_counter has
153          * been established, further references under that same context
154          * need not check that the queue has been frozen (marked dead).
155          */
156         percpu_ref_get(&q->q_usage_counter);
157 }
158
159 #ifdef CONFIG_BLK_DEV_INTEGRITY
160 void blk_flush_integrity(void);
161 bool __bio_integrity_endio(struct bio *);
162 static inline bool bio_integrity_endio(struct bio *bio)
163 {
164         if (bio_integrity(bio))
165                 return __bio_integrity_endio(bio);
166         return true;
167 }
168 #else
169 static inline void blk_flush_integrity(void)
170 {
171 }
172 static inline bool bio_integrity_endio(struct bio *bio)
173 {
174         return true;
175 }
176 #endif
177
178 void blk_timeout_work(struct work_struct *work);
179 unsigned long blk_rq_timeout(unsigned long timeout);
180 void blk_add_timer(struct request *req);
181 void blk_delete_timer(struct request *);
182
183
184 bool bio_attempt_front_merge(struct request_queue *q, struct request *req,
185                              struct bio *bio);
186 bool bio_attempt_back_merge(struct request_queue *q, struct request *req,
187                             struct bio *bio);
188 bool bio_attempt_discard_merge(struct request_queue *q, struct request *req,
189                 struct bio *bio);
190 bool blk_attempt_plug_merge(struct request_queue *q, struct bio *bio,
191                             unsigned int *request_count,
192                             struct request **same_queue_rq);
193 unsigned int blk_plug_queued_count(struct request_queue *q);
194
195 void blk_account_io_start(struct request *req, bool new_io);
196 void blk_account_io_completion(struct request *req, unsigned int bytes);
197 void blk_account_io_done(struct request *req, u64 now);
198
199 /*
200  * EH timer and IO completion will both attempt to 'grab' the request, make
201  * sure that only one of them succeeds. Steal the bottom bit of the
202  * __deadline field for this.
203  */
204 static inline int blk_mark_rq_complete(struct request *rq)
205 {
206         return test_and_set_bit(0, &rq->__deadline);
207 }
208
209 static inline void blk_clear_rq_complete(struct request *rq)
210 {
211         clear_bit(0, &rq->__deadline);
212 }
213
214 static inline bool blk_rq_is_complete(struct request *rq)
215 {
216         return test_bit(0, &rq->__deadline);
217 }
218
219 /*
220  * Internal elevator interface
221  */
222 #define ELV_ON_HASH(rq) ((rq)->rq_flags & RQF_HASHED)
223
224 void blk_insert_flush(struct request *rq);
225
226 static inline void elv_activate_rq(struct request_queue *q, struct request *rq)
227 {
228         struct elevator_queue *e = q->elevator;
229
230         if (e->type->ops.sq.elevator_activate_req_fn)
231                 e->type->ops.sq.elevator_activate_req_fn(q, rq);
232 }
233
234 static inline void elv_deactivate_rq(struct request_queue *q, struct request *rq)
235 {
236         struct elevator_queue *e = q->elevator;
237
238         if (e->type->ops.sq.elevator_deactivate_req_fn)
239                 e->type->ops.sq.elevator_deactivate_req_fn(q, rq);
240 }
241
242 int elevator_init(struct request_queue *);
243 int elevator_init_mq(struct request_queue *q);
244 int elevator_switch_mq(struct request_queue *q,
245                               struct elevator_type *new_e);
246 void elevator_exit(struct request_queue *, struct elevator_queue *);
247 int elv_register_queue(struct request_queue *q, bool uevent);
248 void elv_unregister_queue(struct request_queue *q);
249
250 struct hd_struct *__disk_get_part(struct gendisk *disk, int partno);
251
252 #ifdef CONFIG_FAIL_IO_TIMEOUT
253 int blk_should_fake_timeout(struct request_queue *);
254 ssize_t part_timeout_show(struct device *, struct device_attribute *, char *);
255 ssize_t part_timeout_store(struct device *, struct device_attribute *,
256                                 const char *, size_t);
257 #else
258 static inline int blk_should_fake_timeout(struct request_queue *q)
259 {
260         return 0;
261 }
262 #endif
263
264 int ll_back_merge_fn(struct request_queue *q, struct request *req,
265                      struct bio *bio);
266 int ll_front_merge_fn(struct request_queue *q, struct request *req, 
267                       struct bio *bio);
268 struct request *attempt_back_merge(struct request_queue *q, struct request *rq);
269 struct request *attempt_front_merge(struct request_queue *q, struct request *rq);
270 int blk_attempt_req_merge(struct request_queue *q, struct request *rq,
271                                 struct request *next);
272 void blk_recalc_rq_segments(struct request *rq);
273 void blk_rq_set_mixed_merge(struct request *rq);
274 bool blk_rq_merge_ok(struct request *rq, struct bio *bio);
275 enum elv_merge blk_try_merge(struct request *rq, struct bio *bio);
276
277 void blk_queue_congestion_threshold(struct request_queue *q);
278
279 int blk_dev_init(void);
280
281
282 /*
283  * Return the threshold (number of used requests) at which the queue is
284  * considered to be congested.  It include a little hysteresis to keep the
285  * context switch rate down.
286  */
287 static inline int queue_congestion_on_threshold(struct request_queue *q)
288 {
289         return q->nr_congestion_on;
290 }
291
292 /*
293  * The threshold at which a queue is considered to be uncongested
294  */
295 static inline int queue_congestion_off_threshold(struct request_queue *q)
296 {
297         return q->nr_congestion_off;
298 }
299
300 extern int blk_update_nr_requests(struct request_queue *, unsigned int);
301
302 /*
303  * Contribute to IO statistics IFF:
304  *
305  *      a) it's attached to a gendisk, and
306  *      b) the queue had IO stats enabled when this request was started, and
307  *      c) it's a file system request
308  */
309 static inline bool blk_do_io_stat(struct request *rq)
310 {
311         return rq->rq_disk &&
312                (rq->rq_flags & RQF_IO_STAT) &&
313                 !blk_rq_is_passthrough(rq);
314 }
315
316 static inline void req_set_nomerge(struct request_queue *q, struct request *req)
317 {
318         req->cmd_flags |= REQ_NOMERGE;
319         if (req == q->last_merge)
320                 q->last_merge = NULL;
321 }
322
323 /*
324  * Steal a bit from this field for legacy IO path atomic IO marking. Note that
325  * setting the deadline clears the bottom bit, potentially clearing the
326  * completed bit. The user has to be OK with this (current ones are fine).
327  */
328 static inline void blk_rq_set_deadline(struct request *rq, unsigned long time)
329 {
330         rq->__deadline = time & ~0x1UL;
331 }
332
333 static inline unsigned long blk_rq_deadline(struct request *rq)
334 {
335         return rq->__deadline & ~0x1UL;
336 }
337
338 /*
339  * The max size one bio can handle is UINT_MAX becasue bvec_iter.bi_size
340  * is defined as 'unsigned int', meantime it has to aligned to with logical
341  * block size which is the minimum accepted unit by hardware.
342  */
343 static inline unsigned int bio_allowed_max_sectors(struct request_queue *q)
344 {
345         return round_down(UINT_MAX, queue_logical_block_size(q)) >> 9;
346 }
347
348 /*
349  * Internal io_context interface
350  */
351 void get_io_context(struct io_context *ioc);
352 struct io_cq *ioc_lookup_icq(struct io_context *ioc, struct request_queue *q);
353 struct io_cq *ioc_create_icq(struct io_context *ioc, struct request_queue *q,
354                              gfp_t gfp_mask);
355 void ioc_clear_queue(struct request_queue *q);
356
357 int create_task_io_context(struct task_struct *task, gfp_t gfp_mask, int node);
358
359 /**
360  * rq_ioc - determine io_context for request allocation
361  * @bio: request being allocated is for this bio (can be %NULL)
362  *
363  * Determine io_context to use for request allocation for @bio.  May return
364  * %NULL if %current->io_context doesn't exist.
365  */
366 static inline struct io_context *rq_ioc(struct bio *bio)
367 {
368 #ifdef CONFIG_BLK_CGROUP
369         if (bio && bio->bi_ioc)
370                 return bio->bi_ioc;
371 #endif
372         return current->io_context;
373 }
374
375 /**
376  * create_io_context - try to create task->io_context
377  * @gfp_mask: allocation mask
378  * @node: allocation node
379  *
380  * If %current->io_context is %NULL, allocate a new io_context and install
381  * it.  Returns the current %current->io_context which may be %NULL if
382  * allocation failed.
383  *
384  * Note that this function can't be called with IRQ disabled because
385  * task_lock which protects %current->io_context is IRQ-unsafe.
386  */
387 static inline struct io_context *create_io_context(gfp_t gfp_mask, int node)
388 {
389         WARN_ON_ONCE(irqs_disabled());
390         if (unlikely(!current->io_context))
391                 create_task_io_context(current, gfp_mask, node);
392         return current->io_context;
393 }
394
395 /*
396  * Internal throttling interface
397  */
398 #ifdef CONFIG_BLK_DEV_THROTTLING
399 extern void blk_throtl_drain(struct request_queue *q);
400 extern int blk_throtl_init(struct request_queue *q);
401 extern void blk_throtl_exit(struct request_queue *q);
402 extern void blk_throtl_register_queue(struct request_queue *q);
403 #else /* CONFIG_BLK_DEV_THROTTLING */
404 static inline void blk_throtl_drain(struct request_queue *q) { }
405 static inline int blk_throtl_init(struct request_queue *q) { return 0; }
406 static inline void blk_throtl_exit(struct request_queue *q) { }
407 static inline void blk_throtl_register_queue(struct request_queue *q) { }
408 #endif /* CONFIG_BLK_DEV_THROTTLING */
409 #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
410 extern ssize_t blk_throtl_sample_time_show(struct request_queue *q, char *page);
411 extern ssize_t blk_throtl_sample_time_store(struct request_queue *q,
412         const char *page, size_t count);
413 extern void blk_throtl_bio_endio(struct bio *bio);
414 extern void blk_throtl_stat_add(struct request *rq, u64 time);
415 #else
416 static inline void blk_throtl_bio_endio(struct bio *bio) { }
417 static inline void blk_throtl_stat_add(struct request *rq, u64 time) { }
418 #endif
419
420 #ifdef CONFIG_BOUNCE
421 extern int init_emergency_isa_pool(void);
422 extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
423 #else
424 static inline int init_emergency_isa_pool(void)
425 {
426         return 0;
427 }
428 static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
429 {
430 }
431 #endif /* CONFIG_BOUNCE */
432
433 extern void blk_drain_queue(struct request_queue *q);
434
435 #ifdef CONFIG_BLK_CGROUP_IOLATENCY
436 extern int blk_iolatency_init(struct request_queue *q);
437 #else
438 static inline int blk_iolatency_init(struct request_queue *q) { return 0; }
439 #endif
440
441 #endif /* BLK_INTERNAL_H */