Commit | Line | Data |
---|---|---|
3fcfab16 AM |
1 | |
2 | #include <linux/wait.h> | |
3 | #include <linux/backing-dev.h> | |
4 | #include <linux/fs.h> | |
5 | #include <linux/sched.h> | |
6 | #include <linux/module.h> | |
cf0ca9fe PZ |
7 | #include <linux/writeback.h> |
8 | #include <linux/device.h> | |
9 | ||
10 | ||
11 | static struct class *bdi_class; | |
12 | ||
13 | static ssize_t read_ahead_kb_store(struct device *dev, | |
14 | struct device_attribute *attr, | |
15 | const char *buf, size_t count) | |
16 | { | |
17 | struct backing_dev_info *bdi = dev_get_drvdata(dev); | |
18 | char *end; | |
19 | unsigned long read_ahead_kb; | |
20 | ssize_t ret = -EINVAL; | |
21 | ||
22 | read_ahead_kb = simple_strtoul(buf, &end, 10); | |
23 | if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) { | |
24 | bdi->ra_pages = read_ahead_kb >> (PAGE_SHIFT - 10); | |
25 | ret = count; | |
26 | } | |
27 | return ret; | |
28 | } | |
29 | ||
30 | #define K(pages) ((pages) << (PAGE_SHIFT - 10)) | |
31 | ||
32 | #define BDI_SHOW(name, expr) \ | |
33 | static ssize_t name##_show(struct device *dev, \ | |
34 | struct device_attribute *attr, char *page) \ | |
35 | { \ | |
36 | struct backing_dev_info *bdi = dev_get_drvdata(dev); \ | |
37 | \ | |
38 | return snprintf(page, PAGE_SIZE-1, "%lld\n", (long long)expr); \ | |
39 | } | |
40 | ||
41 | BDI_SHOW(read_ahead_kb, K(bdi->ra_pages)) | |
42 | ||
43 | BDI_SHOW(reclaimable_kb, K(bdi_stat(bdi, BDI_RECLAIMABLE))) | |
44 | BDI_SHOW(writeback_kb, K(bdi_stat(bdi, BDI_WRITEBACK))) | |
45 | ||
46 | static inline unsigned long get_dirty(struct backing_dev_info *bdi, int i) | |
47 | { | |
48 | unsigned long thresh[3]; | |
49 | ||
50 | get_dirty_limits(&thresh[0], &thresh[1], &thresh[2], bdi); | |
51 | ||
52 | return thresh[i]; | |
53 | } | |
54 | ||
55 | BDI_SHOW(dirty_kb, K(get_dirty(bdi, 1))) | |
56 | BDI_SHOW(bdi_dirty_kb, K(get_dirty(bdi, 2))) | |
57 | ||
58 | #define __ATTR_RW(attr) __ATTR(attr, 0644, attr##_show, attr##_store) | |
59 | ||
60 | static struct device_attribute bdi_dev_attrs[] = { | |
61 | __ATTR_RW(read_ahead_kb), | |
62 | __ATTR_RO(reclaimable_kb), | |
63 | __ATTR_RO(writeback_kb), | |
64 | __ATTR_RO(dirty_kb), | |
65 | __ATTR_RO(bdi_dirty_kb), | |
66 | __ATTR_NULL, | |
67 | }; | |
68 | ||
69 | static __init int bdi_class_init(void) | |
70 | { | |
71 | bdi_class = class_create(THIS_MODULE, "bdi"); | |
72 | bdi_class->dev_attrs = bdi_dev_attrs; | |
73 | return 0; | |
74 | } | |
75 | ||
76 | core_initcall(bdi_class_init); | |
77 | ||
78 | int bdi_register(struct backing_dev_info *bdi, struct device *parent, | |
79 | const char *fmt, ...) | |
80 | { | |
81 | char *name; | |
82 | va_list args; | |
83 | int ret = 0; | |
84 | struct device *dev; | |
85 | ||
86 | va_start(args, fmt); | |
87 | name = kvasprintf(GFP_KERNEL, fmt, args); | |
88 | va_end(args); | |
89 | ||
90 | if (!name) | |
91 | return -ENOMEM; | |
92 | ||
93 | dev = device_create(bdi_class, parent, MKDEV(0, 0), name); | |
94 | if (IS_ERR(dev)) { | |
95 | ret = PTR_ERR(dev); | |
96 | goto exit; | |
97 | } | |
98 | ||
99 | bdi->dev = dev; | |
100 | dev_set_drvdata(bdi->dev, bdi); | |
101 | ||
102 | exit: | |
103 | kfree(name); | |
104 | return ret; | |
105 | } | |
106 | EXPORT_SYMBOL(bdi_register); | |
107 | ||
108 | int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev) | |
109 | { | |
110 | return bdi_register(bdi, NULL, "%u:%u", MAJOR(dev), MINOR(dev)); | |
111 | } | |
112 | EXPORT_SYMBOL(bdi_register_dev); | |
113 | ||
114 | void bdi_unregister(struct backing_dev_info *bdi) | |
115 | { | |
116 | if (bdi->dev) { | |
117 | device_unregister(bdi->dev); | |
118 | bdi->dev = NULL; | |
119 | } | |
120 | } | |
121 | EXPORT_SYMBOL(bdi_unregister); | |
3fcfab16 | 122 | |
b2e8fb6e PZ |
123 | int bdi_init(struct backing_dev_info *bdi) |
124 | { | |
4b01a0b1 | 125 | int i; |
b2e8fb6e PZ |
126 | int err; |
127 | ||
cf0ca9fe PZ |
128 | bdi->dev = NULL; |
129 | ||
b2e8fb6e PZ |
130 | for (i = 0; i < NR_BDI_STAT_ITEMS; i++) { |
131 | err = percpu_counter_init_irq(&bdi->bdi_stat[i], 0); | |
04fbfdc1 PZ |
132 | if (err) |
133 | goto err; | |
134 | } | |
135 | ||
136 | bdi->dirty_exceeded = 0; | |
137 | err = prop_local_init_percpu(&bdi->completions); | |
138 | ||
139 | if (err) { | |
140 | err: | |
4b01a0b1 | 141 | while (i--) |
04fbfdc1 | 142 | percpu_counter_destroy(&bdi->bdi_stat[i]); |
b2e8fb6e PZ |
143 | } |
144 | ||
145 | return err; | |
146 | } | |
147 | EXPORT_SYMBOL(bdi_init); | |
148 | ||
149 | void bdi_destroy(struct backing_dev_info *bdi) | |
150 | { | |
151 | int i; | |
152 | ||
cf0ca9fe PZ |
153 | bdi_unregister(bdi); |
154 | ||
b2e8fb6e PZ |
155 | for (i = 0; i < NR_BDI_STAT_ITEMS; i++) |
156 | percpu_counter_destroy(&bdi->bdi_stat[i]); | |
04fbfdc1 PZ |
157 | |
158 | prop_local_destroy_percpu(&bdi->completions); | |
b2e8fb6e PZ |
159 | } |
160 | EXPORT_SYMBOL(bdi_destroy); | |
161 | ||
3fcfab16 AM |
162 | static wait_queue_head_t congestion_wqh[2] = { |
163 | __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[0]), | |
164 | __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[1]) | |
165 | }; | |
166 | ||
167 | ||
168 | void clear_bdi_congested(struct backing_dev_info *bdi, int rw) | |
169 | { | |
170 | enum bdi_state bit; | |
171 | wait_queue_head_t *wqh = &congestion_wqh[rw]; | |
172 | ||
173 | bit = (rw == WRITE) ? BDI_write_congested : BDI_read_congested; | |
174 | clear_bit(bit, &bdi->state); | |
175 | smp_mb__after_clear_bit(); | |
176 | if (waitqueue_active(wqh)) | |
177 | wake_up(wqh); | |
178 | } | |
179 | EXPORT_SYMBOL(clear_bdi_congested); | |
180 | ||
181 | void set_bdi_congested(struct backing_dev_info *bdi, int rw) | |
182 | { | |
183 | enum bdi_state bit; | |
184 | ||
185 | bit = (rw == WRITE) ? BDI_write_congested : BDI_read_congested; | |
186 | set_bit(bit, &bdi->state); | |
187 | } | |
188 | EXPORT_SYMBOL(set_bdi_congested); | |
189 | ||
190 | /** | |
191 | * congestion_wait - wait for a backing_dev to become uncongested | |
192 | * @rw: READ or WRITE | |
193 | * @timeout: timeout in jiffies | |
194 | * | |
195 | * Waits for up to @timeout jiffies for a backing_dev (any backing_dev) to exit | |
196 | * write congestion. If no backing_devs are congested then just wait for the | |
197 | * next write to be completed. | |
198 | */ | |
199 | long congestion_wait(int rw, long timeout) | |
200 | { | |
201 | long ret; | |
202 | DEFINE_WAIT(wait); | |
203 | wait_queue_head_t *wqh = &congestion_wqh[rw]; | |
204 | ||
205 | prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE); | |
206 | ret = io_schedule_timeout(timeout); | |
207 | finish_wait(wqh, &wait); | |
208 | return ret; | |
209 | } | |
210 | EXPORT_SYMBOL(congestion_wait); | |
04fbfdc1 | 211 |