1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_BLK_PLUG_H
#define _LINUX_BLK_PLUG_H
#include <linux/sched.h>
struct blk_plug_cb;
typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *cb, bool from_schedule);
struct rq_list {
struct request *head;
struct request *tail;
};
#ifdef CONFIG_BLOCK
/*
* blk_plug permits building a queue of related requests by holding the I/O
* fragments for a short period. This allows merging of sequential requests
* into single larger request. As the requests are moved from a per-task list to
* the device's request_queue in a batch, this results in improved scalability
* as the lock contention for request_queue lock is reduced.
*
* It is ok not to disable preemption when adding the request to the plug list
* or when attempting a merge. For details, please see schedule() where
* blk_flush_plug() is called.
*/
struct blk_plug {
struct rq_list mq_list; /* blk-mq requests */
/* if ios_left is > 1, we can batch tag/rq allocations */
struct rq_list cached_rqs;
u64 cur_ktime;
unsigned short nr_ios;
unsigned short rq_count;
bool multiple_queues;
bool has_elevator;
struct list_head cb_list; /* md requires an unplug callback */
};
void blk_start_plug(struct blk_plug *);
void blk_start_plug_nr_ios(struct blk_plug *, unsigned short);
void blk_finish_plug(struct blk_plug *);
void __blk_flush_plug(struct blk_plug *plug, bool from_schedule);
static inline void blk_flush_plug(struct blk_plug *plug, bool async)
{
if (plug)
__blk_flush_plug(plug, async);
}
static __always_inline void blk_plug_invalidate_ts(void)
{
if (unlikely(current->flags & PF_BLOCK_TS)) {
current->plug->cur_ktime = 0;
current->flags &= ~PF_BLOCK_TS;
}
}
struct blk_plug_cb {
struct list_head list;
blk_plug_cb_fn callback;
void *data;
};
struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug, void *data,
int size);
#else /* CONFIG_BLOCK */
struct blk_plug {
};
static inline void blk_start_plug(struct blk_plug *plug)
{
}
static inline void blk_start_plug_nr_ios(struct blk_plug *plug,
unsigned short nr_ios)
{
}
static inline void blk_finish_plug(struct blk_plug *plug)
{
}
static inline void blk_flush_plug(struct blk_plug *plug, bool async)
{
}
static inline void blk_plug_invalidate_ts(void)
{
}
#endif /* CONFIG_BLOCK */
#endif /* _LINUX_BLK_PLUG_H */
|
