Branch data Line data Source code
1 : :
2 : : #include <linux/wait.h>
3 : : #include <linux/backing-dev.h>
4 : : #include <linux/kthread.h>
5 : : #include <linux/freezer.h>
6 : : #include <linux/fs.h>
7 : : #include <linux/pagemap.h>
8 : : #include <linux/mm.h>
9 : : #include <linux/sched.h>
10 : : #include <linux/module.h>
11 : : #include <linux/writeback.h>
12 : : #include <linux/device.h>
13 : : #include <trace/events/writeback.h>
14 : :
15 : : static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0);
16 : :
17 : : struct backing_dev_info default_backing_dev_info = {
18 : : .name = "default",
19 : : .ra_pages = VM_MAX_READAHEAD * 1024 / PAGE_CACHE_SIZE,
20 : : .state = 0,
21 : : .capabilities = BDI_CAP_MAP_COPY,
22 : : };
23 : : EXPORT_SYMBOL_GPL(default_backing_dev_info);
24 : :
25 : : struct backing_dev_info noop_backing_dev_info = {
26 : : .name = "noop",
27 : : .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
28 : : };
29 : : EXPORT_SYMBOL_GPL(noop_backing_dev_info);
30 : :
31 : : static struct class *bdi_class;
32 : :
33 : : /*
34 : : * bdi_lock protects updates to bdi_list. bdi_list has RCU reader side
35 : : * locking.
36 : : */
37 : : DEFINE_SPINLOCK(bdi_lock);
38 : : LIST_HEAD(bdi_list);
39 : :
40 : : /* bdi_wq serves all asynchronous writeback tasks */
41 : : struct workqueue_struct *bdi_wq;
42 : :
43 : 0 : void bdi_lock_two(struct bdi_writeback *wb1, struct bdi_writeback *wb2)
44 : : {
45 [ # # ]: 0 : if (wb1 < wb2) {
46 : : spin_lock(&wb1->list_lock);
47 : 0 : spin_lock_nested(&wb2->list_lock, 1);
48 : : } else {
49 : : spin_lock(&wb2->list_lock);
50 : 0 : spin_lock_nested(&wb1->list_lock, 1);
51 : : }
52 : 0 : }
53 : :
54 : : #ifdef CONFIG_DEBUG_FS
55 : : #include <linux/debugfs.h>
56 : : #include <linux/seq_file.h>
57 : :
58 : : static struct dentry *bdi_debug_root;
59 : :
60 : : static void bdi_debug_init(void)
61 : : {
62 : 0 : bdi_debug_root = debugfs_create_dir("bdi", NULL);
63 : : }
64 : :
65 : 0 : static int bdi_debug_stats_show(struct seq_file *m, void *v)
66 : : {
67 : 0 : struct backing_dev_info *bdi = m->private;
68 : : struct bdi_writeback *wb = &bdi->wb;
69 : : unsigned long background_thresh;
70 : : unsigned long dirty_thresh;
71 : : unsigned long bdi_thresh;
72 : : unsigned long nr_dirty, nr_io, nr_more_io;
73 : : struct inode *inode;
74 : :
75 : : nr_dirty = nr_io = nr_more_io = 0;
76 : : spin_lock(&wb->list_lock);
77 [ # # ]: 0 : list_for_each_entry(inode, &wb->b_dirty, i_wb_list)
78 : 0 : nr_dirty++;
79 [ # # ]: 0 : list_for_each_entry(inode, &wb->b_io, i_wb_list)
80 : 0 : nr_io++;
81 [ # # ]: 0 : list_for_each_entry(inode, &wb->b_more_io, i_wb_list)
82 : 0 : nr_more_io++;
83 : : spin_unlock(&wb->list_lock);
84 : :
85 : 0 : global_dirty_limits(&background_thresh, &dirty_thresh);
86 : 0 : bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
87 : :
88 : : #define K(x) ((x) << (PAGE_SHIFT - 10))
89 : 0 : seq_printf(m,
90 : : "BdiWriteback: %10lu kB\n"
91 : : "BdiReclaimable: %10lu kB\n"
92 : : "BdiDirtyThresh: %10lu kB\n"
93 : : "DirtyThresh: %10lu kB\n"
94 : : "BackgroundThresh: %10lu kB\n"
95 : : "BdiDirtied: %10lu kB\n"
96 : : "BdiWritten: %10lu kB\n"
97 : : "BdiWriteBandwidth: %10lu kBps\n"
98 : : "b_dirty: %10lu\n"
99 : : "b_io: %10lu\n"
100 : : "b_more_io: %10lu\n"
101 : : "bdi_list: %10u\n"
102 : : "state: %10lx\n",
103 : : (unsigned long) K(bdi_stat(bdi, BDI_WRITEBACK)),
104 : : (unsigned long) K(bdi_stat(bdi, BDI_RECLAIMABLE)),
105 : : K(bdi_thresh),
106 : : K(dirty_thresh),
107 : : K(background_thresh),
108 : : (unsigned long) K(bdi_stat(bdi, BDI_DIRTIED)),
109 : : (unsigned long) K(bdi_stat(bdi, BDI_WRITTEN)),
110 : 0 : (unsigned long) K(bdi->write_bandwidth),
111 : : nr_dirty,
112 : : nr_io,
113 : : nr_more_io,
114 : 0 : !list_empty(&bdi->bdi_list), bdi->state);
115 : : #undef K
116 : :
117 : 0 : return 0;
118 : : }
119 : :
120 : 0 : static int bdi_debug_stats_open(struct inode *inode, struct file *file)
121 : : {
122 : 0 : return single_open(file, bdi_debug_stats_show, inode->i_private);
123 : : }
124 : :
125 : : static const struct file_operations bdi_debug_stats_fops = {
126 : : .open = bdi_debug_stats_open,
127 : : .read = seq_read,
128 : : .llseek = seq_lseek,
129 : : .release = single_release,
130 : : };
131 : :
132 : 0 : static void bdi_debug_register(struct backing_dev_info *bdi, const char *name)
133 : : {
134 : 0 : bdi->debug_dir = debugfs_create_dir(name, bdi_debug_root);
135 : 0 : bdi->debug_stats = debugfs_create_file("stats", 0444, bdi->debug_dir,
136 : : bdi, &bdi_debug_stats_fops);
137 : 0 : }
138 : :
139 : : static void bdi_debug_unregister(struct backing_dev_info *bdi)
140 : : {
141 : 0 : debugfs_remove(bdi->debug_stats);
142 : 0 : debugfs_remove(bdi->debug_dir);
143 : : }
144 : : #else
145 : : static inline void bdi_debug_init(void)
146 : : {
147 : : }
148 : : static inline void bdi_debug_register(struct backing_dev_info *bdi,
149 : : const char *name)
150 : : {
151 : : }
152 : : static inline void bdi_debug_unregister(struct backing_dev_info *bdi)
153 : : {
154 : : }
155 : : #endif
156 : :
157 : 0 : static ssize_t read_ahead_kb_store(struct device *dev,
158 : : struct device_attribute *attr,
159 : : const char *buf, size_t count)
160 : : {
161 : 0 : struct backing_dev_info *bdi = dev_get_drvdata(dev);
162 : : unsigned long read_ahead_kb;
163 : : ssize_t ret;
164 : :
165 : : ret = kstrtoul(buf, 10, &read_ahead_kb);
166 [ # # ]: 0 : if (ret < 0)
167 : : return ret;
168 : :
169 : 0 : bdi->ra_pages = read_ahead_kb >> (PAGE_SHIFT - 10);
170 : :
171 : 0 : return count;
172 : : }
173 : :
174 : : #define K(pages) ((pages) << (PAGE_SHIFT - 10))
175 : :
176 : : #define BDI_SHOW(name, expr) \
177 : : static ssize_t name##_show(struct device *dev, \
178 : : struct device_attribute *attr, char *page) \
179 : : { \
180 : : struct backing_dev_info *bdi = dev_get_drvdata(dev); \
181 : : \
182 : : return snprintf(page, PAGE_SIZE-1, "%lld\n", (long long)expr); \
183 : : } \
184 : : static DEVICE_ATTR_RW(name);
185 : :
186 : 0 : BDI_SHOW(read_ahead_kb, K(bdi->ra_pages))
187 : :
188 : 0 : static ssize_t min_ratio_store(struct device *dev,
189 : : struct device_attribute *attr, const char *buf, size_t count)
190 : : {
191 : 0 : struct backing_dev_info *bdi = dev_get_drvdata(dev);
192 : : unsigned int ratio;
193 : : ssize_t ret;
194 : :
195 : 0 : ret = kstrtouint(buf, 10, &ratio);
196 [ # # ]: 0 : if (ret < 0)
197 : : return ret;
198 : :
199 : 0 : ret = bdi_set_min_ratio(bdi, ratio);
200 [ # # ]: 0 : if (!ret)
201 : 0 : ret = count;
202 : :
203 : 0 : return ret;
204 : : }
205 : 0 : BDI_SHOW(min_ratio, bdi->min_ratio)
206 : :
207 : 0 : static ssize_t max_ratio_store(struct device *dev,
208 : : struct device_attribute *attr, const char *buf, size_t count)
209 : : {
210 : 0 : struct backing_dev_info *bdi = dev_get_drvdata(dev);
211 : : unsigned int ratio;
212 : : ssize_t ret;
213 : :
214 : 0 : ret = kstrtouint(buf, 10, &ratio);
215 [ # # ]: 0 : if (ret < 0)
216 : : return ret;
217 : :
218 : 0 : ret = bdi_set_max_ratio(bdi, ratio);
219 [ # # ]: 0 : if (!ret)
220 : 0 : ret = count;
221 : :
222 : 0 : return ret;
223 : : }
224 : 0 : BDI_SHOW(max_ratio, bdi->max_ratio)
225 : :
226 : 0 : static ssize_t stable_pages_required_show(struct device *dev,
227 : : struct device_attribute *attr,
228 : : char *page)
229 : : {
230 : 0 : struct backing_dev_info *bdi = dev_get_drvdata(dev);
231 : :
232 : 0 : return snprintf(page, PAGE_SIZE-1, "%d\n",
233 : : bdi_cap_stable_pages_required(bdi) ? 1 : 0);
234 : : }
235 : : static DEVICE_ATTR_RO(stable_pages_required);
236 : :
237 : : static struct attribute *bdi_dev_attrs[] = {
238 : : &dev_attr_read_ahead_kb.attr,
239 : : &dev_attr_min_ratio.attr,
240 : : &dev_attr_max_ratio.attr,
241 : : &dev_attr_stable_pages_required.attr,
242 : : NULL,
243 : : };
244 : : ATTRIBUTE_GROUPS(bdi_dev);
245 : :
246 : 0 : static __init int bdi_class_init(void)
247 : : {
248 : 0 : bdi_class = class_create(THIS_MODULE, "bdi");
249 [ # # ]: 0 : if (IS_ERR(bdi_class))
250 : 0 : return PTR_ERR(bdi_class);
251 : :
252 : 0 : bdi_class->dev_groups = bdi_dev_groups;
253 : : bdi_debug_init();
254 : 0 : return 0;
255 : : }
256 : : postcore_initcall(bdi_class_init);
257 : :
258 : 0 : static int __init default_bdi_init(void)
259 : : {
260 : : int err;
261 : :
262 : 0 : bdi_wq = alloc_workqueue("writeback", WQ_MEM_RECLAIM | WQ_FREEZABLE |
263 : : WQ_UNBOUND | WQ_SYSFS, 0);
264 [ # # ]: 0 : if (!bdi_wq)
265 : : return -ENOMEM;
266 : :
267 : 0 : err = bdi_init(&default_backing_dev_info);
268 [ # # ]: 0 : if (!err)
269 : 0 : bdi_register(&default_backing_dev_info, NULL, "default");
270 : 0 : err = bdi_init(&noop_backing_dev_info);
271 : :
272 : 0 : return err;
273 : : }
274 : : subsys_initcall(default_bdi_init);
275 : :
276 : 0 : int bdi_has_dirty_io(struct backing_dev_info *bdi)
277 : : {
278 : 0 : return wb_has_dirty_io(&bdi->wb);
279 : : }
280 : :
281 : : /*
282 : : * This function is used when the first inode for this bdi is marked dirty. It
283 : : * wakes-up the corresponding bdi thread which should then take care of the
284 : : * periodic background write-out of dirty inodes. Since the write-out would
285 : : * starts only 'dirty_writeback_interval' centisecs from now anyway, we just
286 : : * set up a timer which wakes the bdi thread up later.
287 : : *
288 : : * Note, we wouldn't bother setting up the timer, but this function is on the
289 : : * fast-path (used by '__mark_inode_dirty()'), so we save few context switches
290 : : * by delaying the wake-up.
291 : : */
292 : 0 : void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi)
293 : : {
294 : : unsigned long timeout;
295 : :
296 : 1551 : timeout = msecs_to_jiffies(dirty_writeback_interval * 10);
297 : 1551 : mod_delayed_work(bdi_wq, &bdi->wb.dwork, timeout);
298 : 1551 : }
299 : :
300 : : /*
301 : : * Remove bdi from bdi_list, and ensure that it is no longer visible
302 : : */
303 : 0 : static void bdi_remove_from_list(struct backing_dev_info *bdi)
304 : : {
305 : : spin_lock_bh(&bdi_lock);
306 : : list_del_rcu(&bdi->bdi_list);
307 : : spin_unlock_bh(&bdi_lock);
308 : :
309 : 0 : synchronize_rcu_expedited();
310 : :
311 : : /* bdi_list is now unused, clear it to mark @bdi dying */
312 : 0 : INIT_LIST_HEAD(&bdi->bdi_list);
313 : 0 : }
314 : :
315 : 0 : int bdi_register(struct backing_dev_info *bdi, struct device *parent,
316 : : const char *fmt, ...)
317 : : {
318 : : va_list args;
319 : : struct device *dev;
320 : :
321 [ # # ]: 0 : if (bdi->dev) /* The driver needs to use separate queues per device */
322 : : return 0;
323 : :
324 : 0 : va_start(args, fmt);
325 : 0 : dev = device_create_vargs(bdi_class, parent, MKDEV(0, 0), bdi, fmt, args);
326 : 0 : va_end(args);
327 [ # # ]: 0 : if (IS_ERR(dev))
328 : 0 : return PTR_ERR(dev);
329 : :
330 : 0 : bdi->dev = dev;
331 : :
332 : 0 : bdi_debug_register(bdi, dev_name(dev));
333 : 0 : set_bit(BDI_registered, &bdi->state);
334 : :
335 : : spin_lock_bh(&bdi_lock);
336 : 0 : list_add_tail_rcu(&bdi->bdi_list, &bdi_list);
337 : : spin_unlock_bh(&bdi_lock);
338 : :
339 : : trace_writeback_bdi_register(bdi);
340 : : return 0;
341 : : }
342 : : EXPORT_SYMBOL(bdi_register);
343 : :
344 : 0 : int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev)
345 : : {
346 : 0 : return bdi_register(bdi, NULL, "%u:%u", MAJOR(dev), MINOR(dev));
347 : : }
348 : : EXPORT_SYMBOL(bdi_register_dev);
349 : :
350 : : /*
351 : : * Remove bdi from the global list and shutdown any threads we have running
352 : : */
353 : 0 : static void bdi_wb_shutdown(struct backing_dev_info *bdi)
354 : : {
355 [ # # ]: 0 : if (!bdi_cap_writeback_dirty(bdi))
356 : 0 : return;
357 : :
358 : : /*
359 : : * Make sure nobody finds us on the bdi_list anymore
360 : : */
361 : 0 : bdi_remove_from_list(bdi);
362 : :
363 : : /*
364 : : * Drain work list and shutdown the delayed_work. At this point,
365 : : * @bdi->bdi_list is empty telling bdi_Writeback_workfn() that @bdi
366 : : * is dying and its work_list needs to be drained no matter what.
367 : : */
368 : 0 : mod_delayed_work(bdi_wq, &bdi->wb.dwork, 0);
369 : 0 : flush_delayed_work(&bdi->wb.dwork);
370 [ # # ]: 0 : WARN_ON(!list_empty(&bdi->work_list));
371 : :
372 : : /*
373 : : * This shouldn't be necessary unless @bdi for some reason has
374 : : * unflushed dirty IO after work_list is drained. Do it anyway
375 : : * just in case.
376 : : */
377 : 0 : cancel_delayed_work_sync(&bdi->wb.dwork);
378 : : }
379 : :
380 : : /*
381 : : * This bdi is going away now, make sure that no super_blocks point to it
382 : : */
383 : 0 : static void bdi_prune_sb(struct backing_dev_info *bdi)
384 : : {
385 : : struct super_block *sb;
386 : :
387 : : spin_lock(&sb_lock);
388 [ # # ]: 0 : list_for_each_entry(sb, &super_blocks, s_list) {
389 [ # # ]: 0 : if (sb->s_bdi == bdi)
390 : 0 : sb->s_bdi = &default_backing_dev_info;
391 : : }
392 : : spin_unlock(&sb_lock);
393 : 0 : }
394 : :
395 : 0 : void bdi_unregister(struct backing_dev_info *bdi)
396 : : {
397 : 0 : struct device *dev = bdi->dev;
398 : :
399 [ # # ]: 0 : if (dev) {
400 : 0 : bdi_set_min_ratio(bdi, 0);
401 : : trace_writeback_bdi_unregister(bdi);
402 : 0 : bdi_prune_sb(bdi);
403 : :
404 : 0 : bdi_wb_shutdown(bdi);
405 : : bdi_debug_unregister(bdi);
406 : :
407 : : spin_lock_bh(&bdi->wb_lock);
408 : 0 : bdi->dev = NULL;
409 : : spin_unlock_bh(&bdi->wb_lock);
410 : :
411 : 0 : device_unregister(dev);
412 : : }
413 : 0 : }
414 : : EXPORT_SYMBOL(bdi_unregister);
415 : :
416 : 0 : static void bdi_wb_init(struct bdi_writeback *wb, struct backing_dev_info *bdi)
417 : : {
418 : 0 : memset(wb, 0, sizeof(*wb));
419 : :
420 : 0 : wb->bdi = bdi;
421 : 0 : wb->last_old_flush = jiffies;
422 : 0 : INIT_LIST_HEAD(&wb->b_dirty);
423 : 0 : INIT_LIST_HEAD(&wb->b_io);
424 : 0 : INIT_LIST_HEAD(&wb->b_more_io);
425 : 0 : spin_lock_init(&wb->list_lock);
426 : 0 : INIT_DELAYED_WORK(&wb->dwork, bdi_writeback_workfn);
427 : 0 : }
428 : :
429 : : /*
430 : : * Initial write bandwidth: 100 MB/s
431 : : */
432 : : #define INIT_BW (100 << (20 - PAGE_SHIFT))
433 : :
434 : 0 : int bdi_init(struct backing_dev_info *bdi)
435 : : {
436 : : int i, err;
437 : :
438 : 0 : bdi->dev = NULL;
439 : :
440 : 0 : bdi->min_ratio = 0;
441 : 0 : bdi->max_ratio = 100;
442 : 0 : bdi->max_prop_frac = FPROP_FRAC_BASE;
443 : 0 : spin_lock_init(&bdi->wb_lock);
444 : 0 : INIT_LIST_HEAD(&bdi->bdi_list);
445 : 0 : INIT_LIST_HEAD(&bdi->work_list);
446 : :
447 : 0 : bdi_wb_init(&bdi->wb, bdi);
448 : :
449 [ # # ]: 0 : for (i = 0; i < NR_BDI_STAT_ITEMS; i++) {
450 : 0 : err = percpu_counter_init(&bdi->bdi_stat[i], 0);
451 [ # # ]: 0 : if (err)
452 : : goto err;
453 : : }
454 : :
455 : 0 : bdi->dirty_exceeded = 0;
456 : :
457 : 0 : bdi->bw_time_stamp = jiffies;
458 : 0 : bdi->written_stamp = 0;
459 : :
460 : 0 : bdi->balanced_dirty_ratelimit = INIT_BW;
461 : 0 : bdi->dirty_ratelimit = INIT_BW;
462 : 0 : bdi->write_bandwidth = INIT_BW;
463 : 0 : bdi->avg_write_bandwidth = INIT_BW;
464 : :
465 : 0 : err = fprop_local_init_percpu(&bdi->completions);
466 : :
467 [ # # ]: 0 : if (err) {
468 : : err:
469 [ # # ]: 0 : while (i--)
470 : 0 : percpu_counter_destroy(&bdi->bdi_stat[i]);
471 : : }
472 : :
473 : 0 : return err;
474 : : }
475 : : EXPORT_SYMBOL(bdi_init);
476 : :
477 : 0 : void bdi_destroy(struct backing_dev_info *bdi)
478 : : {
479 : : int i;
480 : :
481 : : /*
482 : : * Splice our entries to the default_backing_dev_info, if this
483 : : * bdi disappears
484 : : */
485 [ # # ]: 0 : if (bdi_has_dirty_io(bdi)) {
486 : : struct bdi_writeback *dst = &default_backing_dev_info.wb;
487 : :
488 : 0 : bdi_lock_two(&bdi->wb, dst);
489 : : list_splice(&bdi->wb.b_dirty, &dst->b_dirty);
490 : 0 : list_splice(&bdi->wb.b_io, &dst->b_io);
491 : 0 : list_splice(&bdi->wb.b_more_io, &dst->b_more_io);
492 : : spin_unlock(&bdi->wb.list_lock);
493 : : spin_unlock(&dst->list_lock);
494 : : }
495 : :
496 : 0 : bdi_unregister(bdi);
497 : :
498 : : /*
499 : : * If bdi_unregister() had already been called earlier, the dwork
500 : : * could still be pending because bdi_prune_sb() can race with the
501 : : * bdi_wakeup_thread_delayed() calls from __mark_inode_dirty().
502 : : */
503 : 0 : cancel_delayed_work_sync(&bdi->wb.dwork);
504 : :
505 [ # # ]: 0 : for (i = 0; i < NR_BDI_STAT_ITEMS; i++)
506 : 0 : percpu_counter_destroy(&bdi->bdi_stat[i]);
507 : :
508 : 0 : fprop_local_destroy_percpu(&bdi->completions);
509 : 0 : }
510 : : EXPORT_SYMBOL(bdi_destroy);
511 : :
512 : : /*
513 : : * For use from filesystems to quickly init and register a bdi associated
514 : : * with dirty writeback
515 : : */
516 : 0 : int bdi_setup_and_register(struct backing_dev_info *bdi, char *name,
517 : : unsigned int cap)
518 : : {
519 : : int err;
520 : :
521 : 0 : bdi->name = name;
522 : 0 : bdi->capabilities = cap;
523 : 0 : err = bdi_init(bdi);
524 [ # # ]: 0 : if (err)
525 : : return err;
526 : :
527 : 0 : err = bdi_register(bdi, NULL, "%.28s-%ld", name,
528 : : atomic_long_inc_return(&bdi_seq));
529 [ # # ]: 0 : if (err) {
530 : 0 : bdi_destroy(bdi);
531 : 0 : return err;
532 : : }
533 : :
534 : : return 0;
535 : : }
536 : : EXPORT_SYMBOL(bdi_setup_and_register);
537 : :
538 : : static wait_queue_head_t congestion_wqh[2] = {
539 : : __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[0]),
540 : : __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[1])
541 : : };
542 : : static atomic_t nr_bdi_congested[2];
543 : :
544 : 0 : void clear_bdi_congested(struct backing_dev_info *bdi, int sync)
545 : : {
546 : : enum bdi_state bit;
547 : 421277 : wait_queue_head_t *wqh = &congestion_wqh[sync];
548 : :
549 [ + + ]: 421277 : bit = sync ? BDI_sync_congested : BDI_async_congested;
550 [ + + ]: 421277 : if (test_and_clear_bit(bit, &bdi->state))
551 : 49 : atomic_dec(&nr_bdi_congested[sync]);
552 : 421277 : smp_mb__after_clear_bit();
553 [ + + ]: 421277 : if (waitqueue_active(wqh))
554 : 9 : wake_up(wqh);
555 : 421277 : }
556 : : EXPORT_SYMBOL(clear_bdi_congested);
557 : :
558 : 0 : void set_bdi_congested(struct backing_dev_info *bdi, int sync)
559 : : {
560 : : enum bdi_state bit;
561 : :
562 [ + + ]: 13102 : bit = sync ? BDI_sync_congested : BDI_async_congested;
563 [ + + ]: 13102 : if (!test_and_set_bit(bit, &bdi->state))
564 : 49 : atomic_inc(&nr_bdi_congested[sync]);
565 : 13102 : }
566 : : EXPORT_SYMBOL(set_bdi_congested);
567 : :
568 : : /**
569 : : * congestion_wait - wait for a backing_dev to become uncongested
570 : : * @sync: SYNC or ASYNC IO
571 : : * @timeout: timeout in jiffies
572 : : *
573 : : * Waits for up to @timeout jiffies for a backing_dev (any backing_dev) to exit
574 : : * write congestion. If no backing_devs are congested then just wait for the
575 : : * next write to be completed.
576 : : */
577 : 0 : long congestion_wait(int sync, long timeout)
578 : : {
579 : : long ret;
580 : 16 : unsigned long start = jiffies;
581 : 32 : DEFINE_WAIT(wait);
582 : 16 : wait_queue_head_t *wqh = &congestion_wqh[sync];
583 : :
584 : 16 : prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
585 : 16 : ret = io_schedule_timeout(timeout);
586 : 16 : finish_wait(wqh, &wait);
587 : :
588 : 16 : trace_writeback_congestion_wait(jiffies_to_usecs(timeout),
589 : : jiffies_to_usecs(jiffies - start));
590 : :
591 : 0 : return ret;
592 : : }
593 : : EXPORT_SYMBOL(congestion_wait);
594 : :
595 : : /**
596 : : * wait_iff_congested - Conditionally wait for a backing_dev to become uncongested or a zone to complete writes
597 : : * @zone: A zone to check if it is heavily congested
598 : : * @sync: SYNC or ASYNC IO
599 : : * @timeout: timeout in jiffies
600 : : *
601 : : * In the event of a congested backing_dev (any backing_dev) and the given
602 : : * @zone has experienced recent congestion, this waits for up to @timeout
603 : : * jiffies for either a BDI to exit congestion of the given @sync queue
604 : : * or a write to complete.
605 : : *
606 : : * In the absence of zone congestion, cond_resched() is called to yield
607 : : * the processor if necessary but otherwise does not sleep.
608 : : *
609 : : * The return value is 0 if the sleep is for the full timeout. Otherwise,
610 : : * it is the number of jiffies that were still remaining when the function
611 : : * returned. return_value == timeout implies the function did not sleep.
612 : : */
613 : 0 : long wait_iff_congested(struct zone *zone, int sync, long timeout)
614 : : {
615 : : long ret;
616 : 38212 : unsigned long start = jiffies;
617 : 76424 : DEFINE_WAIT(wait);
618 : 38212 : wait_queue_head_t *wqh = &congestion_wqh[sync];
619 : :
620 : : /*
621 : : * If there is no congestion, or heavy congestion is not being
622 : : * encountered in the current zone, yield if necessary instead
623 : : * of sleeping on the congestion queue
624 : : */
625 [ - + ][ # # ]: 38212 : if (atomic_read(&nr_bdi_congested[sync]) == 0 ||
626 : : !zone_is_reclaim_congested(zone)) {
627 : 38212 : cond_resched();
628 : :
629 : : /* In case we scheduled, work out time remaining */
630 : 38212 : ret = timeout - (jiffies - start);
631 [ - + ]: 38212 : if (ret < 0)
632 : : ret = 0;
633 : :
634 : : goto out;
635 : : }
636 : :
637 : : /* Sleep until uncongested or a write happens */
638 : 0 : prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
639 : 0 : ret = io_schedule_timeout(timeout);
640 : 0 : finish_wait(wqh, &wait);
641 : :
642 : : out:
643 : 38212 : trace_writeback_wait_iff_congested(jiffies_to_usecs(timeout),
644 : : jiffies_to_usecs(jiffies - start));
645 : :
646 : 0 : return ret;
647 : : }
648 : : EXPORT_SYMBOL(wait_iff_congested);
649 : :
650 : 0 : int pdflush_proc_obsolete(struct ctl_table *table, int write,
651 : : void __user *buffer, size_t *lenp, loff_t *ppos)
652 : : {
653 : 2 : char kbuf[] = "0\n";
654 : :
655 [ + + ][ - + ]: 2 : if (*ppos || *lenp < sizeof(kbuf)) {
656 : 1 : *lenp = 0;
657 : 1 : return 0;
658 : : }
659 : :
660 [ + - ]: 1 : if (copy_to_user(buffer, kbuf, sizeof(kbuf)))
661 : : return -EFAULT;
662 [ + - ]: 1 : printk_once(KERN_WARNING "%s exported in /proc is scheduled for removal\n",
663 : : table->procname);
664 : :
665 : 1 : *lenp = 2;
666 : 1 : *ppos += *lenp;
667 : 1 : return 2;
668 : : }
|
