Root/mm/backing-dev.c

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
15static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0);
16
17struct 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};
23EXPORT_SYMBOL_GPL(default_backing_dev_info);
24
25struct backing_dev_info noop_backing_dev_info = {
26    .name = "noop",
27    .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
28};
29EXPORT_SYMBOL_GPL(noop_backing_dev_info);
30
31static struct class *bdi_class;
32
33/*
34 * bdi_lock protects updates to bdi_list and bdi_pending_list, as well as
35 * reader side protection for bdi_pending_list. bdi_list has RCU reader side
36 * locking.
37 */
38DEFINE_SPINLOCK(bdi_lock);
39LIST_HEAD(bdi_list);
40LIST_HEAD(bdi_pending_list);
41
42void bdi_lock_two(struct bdi_writeback *wb1, struct bdi_writeback *wb2)
43{
44    if (wb1 < wb2) {
45        spin_lock(&wb1->list_lock);
46        spin_lock_nested(&wb2->list_lock, 1);
47    } else {
48        spin_lock(&wb2->list_lock);
49        spin_lock_nested(&wb1->list_lock, 1);
50    }
51}
52
53#ifdef CONFIG_DEBUG_FS
54#include <linux/debugfs.h>
55#include <linux/seq_file.h>
56
57static struct dentry *bdi_debug_root;
58
59static void bdi_debug_init(void)
60{
61    bdi_debug_root = debugfs_create_dir("bdi", NULL);
62}
63
64static int bdi_debug_stats_show(struct seq_file *m, void *v)
65{
66    struct backing_dev_info *bdi = m->private;
67    struct bdi_writeback *wb = &bdi->wb;
68    unsigned long background_thresh;
69    unsigned long dirty_thresh;
70    unsigned long bdi_thresh;
71    unsigned long nr_dirty, nr_io, nr_more_io;
72    struct inode *inode;
73
74    nr_dirty = nr_io = nr_more_io = 0;
75    spin_lock(&wb->list_lock);
76    list_for_each_entry(inode, &wb->b_dirty, i_wb_list)
77        nr_dirty++;
78    list_for_each_entry(inode, &wb->b_io, i_wb_list)
79        nr_io++;
80    list_for_each_entry(inode, &wb->b_more_io, i_wb_list)
81        nr_more_io++;
82    spin_unlock(&wb->list_lock);
83
84    global_dirty_limits(&background_thresh, &dirty_thresh);
85    bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
86
87#define K(x) ((x) << (PAGE_SHIFT - 10))
88    seq_printf(m,
89           "BdiWriteback: %10lu kB\n"
90           "BdiReclaimable: %10lu kB\n"
91           "BdiDirtyThresh: %10lu kB\n"
92           "DirtyThresh: %10lu kB\n"
93           "BackgroundThresh: %10lu kB\n"
94           "BdiDirtied: %10lu kB\n"
95           "BdiWritten: %10lu kB\n"
96           "BdiWriteBandwidth: %10lu kBps\n"
97           "b_dirty: %10lu\n"
98           "b_io: %10lu\n"
99           "b_more_io: %10lu\n"
100           "bdi_list: %10u\n"
101           "state: %10lx\n",
102           (unsigned long) K(bdi_stat(bdi, BDI_WRITEBACK)),
103           (unsigned long) K(bdi_stat(bdi, BDI_RECLAIMABLE)),
104           K(bdi_thresh),
105           K(dirty_thresh),
106           K(background_thresh),
107           (unsigned long) K(bdi_stat(bdi, BDI_DIRTIED)),
108           (unsigned long) K(bdi_stat(bdi, BDI_WRITTEN)),
109           (unsigned long) K(bdi->write_bandwidth),
110           nr_dirty,
111           nr_io,
112           nr_more_io,
113           !list_empty(&bdi->bdi_list), bdi->state);
114#undef K
115
116    return 0;
117}
118
119static int bdi_debug_stats_open(struct inode *inode, struct file *file)
120{
121    return single_open(file, bdi_debug_stats_show, inode->i_private);
122}
123
124static const struct file_operations bdi_debug_stats_fops = {
125    .open = bdi_debug_stats_open,
126    .read = seq_read,
127    .llseek = seq_lseek,
128    .release = single_release,
129};
130
131static void bdi_debug_register(struct backing_dev_info *bdi, const char *name)
132{
133    bdi->debug_dir = debugfs_create_dir(name, bdi_debug_root);
134    bdi->debug_stats = debugfs_create_file("stats", 0444, bdi->debug_dir,
135                           bdi, &bdi_debug_stats_fops);
136}
137
138static void bdi_debug_unregister(struct backing_dev_info *bdi)
139{
140    debugfs_remove(bdi->debug_stats);
141    debugfs_remove(bdi->debug_dir);
142}
143#else
144static inline void bdi_debug_init(void)
145{
146}
147static inline void bdi_debug_register(struct backing_dev_info *bdi,
148                      const char *name)
149{
150}
151static inline void bdi_debug_unregister(struct backing_dev_info *bdi)
152{
153}
154#endif
155
156static ssize_t read_ahead_kb_store(struct device *dev,
157                  struct device_attribute *attr,
158                  const char *buf, size_t count)
159{
160    struct backing_dev_info *bdi = dev_get_drvdata(dev);
161    char *end;
162    unsigned long read_ahead_kb;
163    ssize_t ret = -EINVAL;
164
165    read_ahead_kb = simple_strtoul(buf, &end, 10);
166    if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) {
167        bdi->ra_pages = read_ahead_kb >> (PAGE_SHIFT - 10);
168        ret = count;
169    }
170    return ret;
171}
172
173#define K(pages) ((pages) << (PAGE_SHIFT - 10))
174
175#define BDI_SHOW(name, expr) \
176static ssize_t name##_show(struct device *dev, \
177               struct device_attribute *attr, char *page) \
178{ \
179    struct backing_dev_info *bdi = dev_get_drvdata(dev); \
180                                    \
181    return snprintf(page, PAGE_SIZE-1, "%lld\n", (long long)expr); \
182}
183
184BDI_SHOW(read_ahead_kb, K(bdi->ra_pages))
185
186static ssize_t min_ratio_store(struct device *dev,
187        struct device_attribute *attr, const char *buf, size_t count)
188{
189    struct backing_dev_info *bdi = dev_get_drvdata(dev);
190    char *end;
191    unsigned int ratio;
192    ssize_t ret = -EINVAL;
193
194    ratio = simple_strtoul(buf, &end, 10);
195    if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) {
196        ret = bdi_set_min_ratio(bdi, ratio);
197        if (!ret)
198            ret = count;
199    }
200    return ret;
201}
202BDI_SHOW(min_ratio, bdi->min_ratio)
203
204static ssize_t max_ratio_store(struct device *dev,
205        struct device_attribute *attr, const char *buf, size_t count)
206{
207    struct backing_dev_info *bdi = dev_get_drvdata(dev);
208    char *end;
209    unsigned int ratio;
210    ssize_t ret = -EINVAL;
211
212    ratio = simple_strtoul(buf, &end, 10);
213    if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) {
214        ret = bdi_set_max_ratio(bdi, ratio);
215        if (!ret)
216            ret = count;
217    }
218    return ret;
219}
220BDI_SHOW(max_ratio, bdi->max_ratio)
221
222#define __ATTR_RW(attr) __ATTR(attr, 0644, attr##_show, attr##_store)
223
224static struct device_attribute bdi_dev_attrs[] = {
225    __ATTR_RW(read_ahead_kb),
226    __ATTR_RW(min_ratio),
227    __ATTR_RW(max_ratio),
228    __ATTR_NULL,
229};
230
231static __init int bdi_class_init(void)
232{
233    bdi_class = class_create(THIS_MODULE, "bdi");
234    if (IS_ERR(bdi_class))
235        return PTR_ERR(bdi_class);
236
237    bdi_class->dev_attrs = bdi_dev_attrs;
238    bdi_debug_init();
239    return 0;
240}
241postcore_initcall(bdi_class_init);
242
243static int __init default_bdi_init(void)
244{
245    int err;
246
247    err = bdi_init(&default_backing_dev_info);
248    if (!err)
249        bdi_register(&default_backing_dev_info, NULL, "default");
250    err = bdi_init(&noop_backing_dev_info);
251
252    return err;
253}
254subsys_initcall(default_bdi_init);
255
256int bdi_has_dirty_io(struct backing_dev_info *bdi)
257{
258    return wb_has_dirty_io(&bdi->wb);
259}
260
261static void wakeup_timer_fn(unsigned long data)
262{
263    struct backing_dev_info *bdi = (struct backing_dev_info *)data;
264
265    spin_lock_bh(&bdi->wb_lock);
266    if (bdi->wb.task) {
267        trace_writeback_wake_thread(bdi);
268        wake_up_process(bdi->wb.task);
269    } else if (bdi->dev) {
270        /*
271         * When bdi tasks are inactive for long time, they are killed.
272         * In this case we have to wake-up the forker thread which
273         * should create and run the bdi thread.
274         */
275        trace_writeback_wake_forker_thread(bdi);
276        wake_up_process(default_backing_dev_info.wb.task);
277    }
278    spin_unlock_bh(&bdi->wb_lock);
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 */
292void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi)
293{
294    unsigned long timeout;
295
296    timeout = msecs_to_jiffies(dirty_writeback_interval * 10);
297    mod_timer(&bdi->wb.wakeup_timer, jiffies + timeout);
298}
299
300/*
301 * Calculate the longest interval (jiffies) bdi threads are allowed to be
302 * inactive.
303 */
304static unsigned long bdi_longest_inactive(void)
305{
306    unsigned long interval;
307
308    interval = msecs_to_jiffies(dirty_writeback_interval * 10);
309    return max(5UL * 60 * HZ, interval);
310}
311
312/*
313 * Clear pending bit and wakeup anybody waiting for flusher thread creation or
314 * shutdown
315 */
316static void bdi_clear_pending(struct backing_dev_info *bdi)
317{
318    clear_bit(BDI_pending, &bdi->state);
319    smp_mb__after_clear_bit();
320    wake_up_bit(&bdi->state, BDI_pending);
321}
322
323static int bdi_forker_thread(void *ptr)
324{
325    struct bdi_writeback *me = ptr;
326
327    current->flags |= PF_SWAPWRITE;
328    set_freezable();
329
330    /*
331     * Our parent may run at a different priority, just set us to normal
332     */
333    set_user_nice(current, 0);
334
335    for (;;) {
336        struct task_struct *task = NULL;
337        struct backing_dev_info *bdi;
338        enum {
339            NO_ACTION, /* Nothing to do */
340            FORK_THREAD, /* Fork bdi thread */
341            KILL_THREAD, /* Kill inactive bdi thread */
342        } action = NO_ACTION;
343
344        /*
345         * Temporary measure, we want to make sure we don't see
346         * dirty data on the default backing_dev_info
347         */
348        if (wb_has_dirty_io(me) || !list_empty(&me->bdi->work_list)) {
349            del_timer(&me->wakeup_timer);
350            wb_do_writeback(me, 0);
351        }
352
353        spin_lock_bh(&bdi_lock);
354        /*
355         * In the following loop we are going to check whether we have
356         * some work to do without any synchronization with tasks
357         * waking us up to do work for them. Set the task state here
358         * so that we don't miss wakeups after verifying conditions.
359         */
360        set_current_state(TASK_INTERRUPTIBLE);
361
362        list_for_each_entry(bdi, &bdi_list, bdi_list) {
363            bool have_dirty_io;
364
365            if (!bdi_cap_writeback_dirty(bdi) ||
366                 bdi_cap_flush_forker(bdi))
367                continue;
368
369            WARN(!test_bit(BDI_registered, &bdi->state),
370                 "bdi %p/%s is not registered!\n", bdi, bdi->name);
371
372            have_dirty_io = !list_empty(&bdi->work_list) ||
373                    wb_has_dirty_io(&bdi->wb);
374
375            /*
376             * If the bdi has work to do, but the thread does not
377             * exist - create it.
378             */
379            if (!bdi->wb.task && have_dirty_io) {
380                /*
381                 * Set the pending bit - if someone will try to
382                 * unregister this bdi - it'll wait on this bit.
383                 */
384                set_bit(BDI_pending, &bdi->state);
385                action = FORK_THREAD;
386                break;
387            }
388
389            spin_lock(&bdi->wb_lock);
390
391            /*
392             * If there is no work to do and the bdi thread was
393             * inactive long enough - kill it. The wb_lock is taken
394             * to make sure no-one adds more work to this bdi and
395             * wakes the bdi thread up.
396             */
397            if (bdi->wb.task && !have_dirty_io &&
398                time_after(jiffies, bdi->wb.last_active +
399                        bdi_longest_inactive())) {
400                task = bdi->wb.task;
401                bdi->wb.task = NULL;
402                spin_unlock(&bdi->wb_lock);
403                set_bit(BDI_pending, &bdi->state);
404                action = KILL_THREAD;
405                break;
406            }
407            spin_unlock(&bdi->wb_lock);
408        }
409        spin_unlock_bh(&bdi_lock);
410
411        /* Keep working if default bdi still has things to do */
412        if (!list_empty(&me->bdi->work_list))
413            __set_current_state(TASK_RUNNING);
414
415        switch (action) {
416        case FORK_THREAD:
417            __set_current_state(TASK_RUNNING);
418            task = kthread_create(bdi_writeback_thread, &bdi->wb,
419                          "flush-%s", dev_name(bdi->dev));
420            if (IS_ERR(task)) {
421                /*
422                 * If thread creation fails, force writeout of
423                 * the bdi from the thread. Hopefully 1024 is
424                 * large enough for efficient IO.
425                 */
426                writeback_inodes_wb(&bdi->wb, 1024,
427                            WB_REASON_FORKER_THREAD);
428            } else {
429                /*
430                 * The spinlock makes sure we do not lose
431                 * wake-ups when racing with 'bdi_queue_work()'.
432                 * And as soon as the bdi thread is visible, we
433                 * can start it.
434                 */
435                spin_lock_bh(&bdi->wb_lock);
436                bdi->wb.task = task;
437                spin_unlock_bh(&bdi->wb_lock);
438                wake_up_process(task);
439            }
440            bdi_clear_pending(bdi);
441            break;
442
443        case KILL_THREAD:
444            __set_current_state(TASK_RUNNING);
445            kthread_stop(task);
446            bdi_clear_pending(bdi);
447            break;
448
449        case NO_ACTION:
450            if (!wb_has_dirty_io(me) || !dirty_writeback_interval)
451                /*
452                 * There are no dirty data. The only thing we
453                 * should now care about is checking for
454                 * inactive bdi threads and killing them. Thus,
455                 * let's sleep for longer time, save energy and
456                 * be friendly for battery-driven devices.
457                 */
458                schedule_timeout(bdi_longest_inactive());
459            else
460                schedule_timeout(msecs_to_jiffies(dirty_writeback_interval * 10));
461            try_to_freeze();
462            break;
463        }
464    }
465
466    return 0;
467}
468
469/*
470 * Remove bdi from bdi_list, and ensure that it is no longer visible
471 */
472static void bdi_remove_from_list(struct backing_dev_info *bdi)
473{
474    spin_lock_bh(&bdi_lock);
475    list_del_rcu(&bdi->bdi_list);
476    spin_unlock_bh(&bdi_lock);
477
478    synchronize_rcu_expedited();
479}
480
481int bdi_register(struct backing_dev_info *bdi, struct device *parent,
482        const char *fmt, ...)
483{
484    va_list args;
485    struct device *dev;
486
487    if (bdi->dev) /* The driver needs to use separate queues per device */
488        return 0;
489
490    va_start(args, fmt);
491    dev = device_create_vargs(bdi_class, parent, MKDEV(0, 0), bdi, fmt, args);
492    va_end(args);
493    if (IS_ERR(dev))
494        return PTR_ERR(dev);
495
496    bdi->dev = dev;
497
498    /*
499     * Just start the forker thread for our default backing_dev_info,
500     * and add other bdi's to the list. They will get a thread created
501     * on-demand when they need it.
502     */
503    if (bdi_cap_flush_forker(bdi)) {
504        struct bdi_writeback *wb = &bdi->wb;
505
506        wb->task = kthread_run(bdi_forker_thread, wb, "bdi-%s",
507                        dev_name(dev));
508        if (IS_ERR(wb->task))
509            return PTR_ERR(wb->task);
510    }
511
512    bdi_debug_register(bdi, dev_name(dev));
513    set_bit(BDI_registered, &bdi->state);
514
515    spin_lock_bh(&bdi_lock);
516    list_add_tail_rcu(&bdi->bdi_list, &bdi_list);
517    spin_unlock_bh(&bdi_lock);
518
519    trace_writeback_bdi_register(bdi);
520    return 0;
521}
522EXPORT_SYMBOL(bdi_register);
523
524int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev)
525{
526    return bdi_register(bdi, NULL, "%u:%u", MAJOR(dev), MINOR(dev));
527}
528EXPORT_SYMBOL(bdi_register_dev);
529
530/*
531 * Remove bdi from the global list and shutdown any threads we have running
532 */
533static void bdi_wb_shutdown(struct backing_dev_info *bdi)
534{
535    struct task_struct *task;
536
537    if (!bdi_cap_writeback_dirty(bdi))
538        return;
539
540    /*
541     * Make sure nobody finds us on the bdi_list anymore
542     */
543    bdi_remove_from_list(bdi);
544
545    /*
546     * If setup is pending, wait for that to complete first
547     */
548    wait_on_bit(&bdi->state, BDI_pending, bdi_sched_wait,
549            TASK_UNINTERRUPTIBLE);
550
551    /*
552     * Finally, kill the kernel thread. We don't need to be RCU
553     * safe anymore, since the bdi is gone from visibility.
554     */
555    spin_lock_bh(&bdi->wb_lock);
556    task = bdi->wb.task;
557    bdi->wb.task = NULL;
558    spin_unlock_bh(&bdi->wb_lock);
559
560    if (task)
561        kthread_stop(task);
562}
563
564/*
565 * This bdi is going away now, make sure that no super_blocks point to it
566 */
567static void bdi_prune_sb(struct backing_dev_info *bdi)
568{
569    struct super_block *sb;
570
571    spin_lock(&sb_lock);
572    list_for_each_entry(sb, &super_blocks, s_list) {
573        if (sb->s_bdi == bdi)
574            sb->s_bdi = &default_backing_dev_info;
575    }
576    spin_unlock(&sb_lock);
577}
578
579void bdi_unregister(struct backing_dev_info *bdi)
580{
581    struct device *dev = bdi->dev;
582
583    if (dev) {
584        bdi_set_min_ratio(bdi, 0);
585        trace_writeback_bdi_unregister(bdi);
586        bdi_prune_sb(bdi);
587        del_timer_sync(&bdi->wb.wakeup_timer);
588
589        if (!bdi_cap_flush_forker(bdi))
590            bdi_wb_shutdown(bdi);
591        bdi_debug_unregister(bdi);
592
593        spin_lock_bh(&bdi->wb_lock);
594        bdi->dev = NULL;
595        spin_unlock_bh(&bdi->wb_lock);
596
597        device_unregister(dev);
598    }
599}
600EXPORT_SYMBOL(bdi_unregister);
601
602static void bdi_wb_init(struct bdi_writeback *wb, struct backing_dev_info *bdi)
603{
604    memset(wb, 0, sizeof(*wb));
605
606    wb->bdi = bdi;
607    wb->last_old_flush = jiffies;
608    INIT_LIST_HEAD(&wb->b_dirty);
609    INIT_LIST_HEAD(&wb->b_io);
610    INIT_LIST_HEAD(&wb->b_more_io);
611    spin_lock_init(&wb->list_lock);
612    setup_timer(&wb->wakeup_timer, wakeup_timer_fn, (unsigned long)bdi);
613}
614
615/*
616 * Initial write bandwidth: 100 MB/s
617 */
618#define INIT_BW (100 << (20 - PAGE_SHIFT))
619
620int bdi_init(struct backing_dev_info *bdi)
621{
622    int i, err;
623
624    bdi->dev = NULL;
625
626    bdi->min_ratio = 0;
627    bdi->max_ratio = 100;
628    bdi->max_prop_frac = FPROP_FRAC_BASE;
629    spin_lock_init(&bdi->wb_lock);
630    INIT_LIST_HEAD(&bdi->bdi_list);
631    INIT_LIST_HEAD(&bdi->work_list);
632
633    bdi_wb_init(&bdi->wb, bdi);
634
635    for (i = 0; i < NR_BDI_STAT_ITEMS; i++) {
636        err = percpu_counter_init(&bdi->bdi_stat[i], 0);
637        if (err)
638            goto err;
639    }
640
641    bdi->dirty_exceeded = 0;
642
643    bdi->bw_time_stamp = jiffies;
644    bdi->written_stamp = 0;
645
646    bdi->balanced_dirty_ratelimit = INIT_BW;
647    bdi->dirty_ratelimit = INIT_BW;
648    bdi->write_bandwidth = INIT_BW;
649    bdi->avg_write_bandwidth = INIT_BW;
650
651    err = fprop_local_init_percpu(&bdi->completions);
652
653    if (err) {
654err:
655        while (i--)
656            percpu_counter_destroy(&bdi->bdi_stat[i]);
657    }
658
659    return err;
660}
661EXPORT_SYMBOL(bdi_init);
662
663void bdi_destroy(struct backing_dev_info *bdi)
664{
665    int i;
666
667    /*
668     * Splice our entries to the default_backing_dev_info, if this
669     * bdi disappears
670     */
671    if (bdi_has_dirty_io(bdi)) {
672        struct bdi_writeback *dst = &default_backing_dev_info.wb;
673
674        bdi_lock_two(&bdi->wb, dst);
675        list_splice(&bdi->wb.b_dirty, &dst->b_dirty);
676        list_splice(&bdi->wb.b_io, &dst->b_io);
677        list_splice(&bdi->wb.b_more_io, &dst->b_more_io);
678        spin_unlock(&bdi->wb.list_lock);
679        spin_unlock(&dst->list_lock);
680    }
681
682    bdi_unregister(bdi);
683
684    /*
685     * If bdi_unregister() had already been called earlier, the
686     * wakeup_timer could still be armed because bdi_prune_sb()
687     * can race with the bdi_wakeup_thread_delayed() calls from
688     * __mark_inode_dirty().
689     */
690    del_timer_sync(&bdi->wb.wakeup_timer);
691
692    for (i = 0; i < NR_BDI_STAT_ITEMS; i++)
693        percpu_counter_destroy(&bdi->bdi_stat[i]);
694
695    fprop_local_destroy_percpu(&bdi->completions);
696}
697EXPORT_SYMBOL(bdi_destroy);
698
699/*
700 * For use from filesystems to quickly init and register a bdi associated
701 * with dirty writeback
702 */
703int bdi_setup_and_register(struct backing_dev_info *bdi, char *name,
704               unsigned int cap)
705{
706    char tmp[32];
707    int err;
708
709    bdi->name = name;
710    bdi->capabilities = cap;
711    err = bdi_init(bdi);
712    if (err)
713        return err;
714
715    sprintf(tmp, "%.28s%s", name, "-%d");
716    err = bdi_register(bdi, NULL, tmp, atomic_long_inc_return(&bdi_seq));
717    if (err) {
718        bdi_destroy(bdi);
719        return err;
720    }
721
722    return 0;
723}
724EXPORT_SYMBOL(bdi_setup_and_register);
725
726static wait_queue_head_t congestion_wqh[2] = {
727        __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[0]),
728        __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[1])
729    };
730static atomic_t nr_bdi_congested[2];
731
732void clear_bdi_congested(struct backing_dev_info *bdi, int sync)
733{
734    enum bdi_state bit;
735    wait_queue_head_t *wqh = &congestion_wqh[sync];
736
737    bit = sync ? BDI_sync_congested : BDI_async_congested;
738    if (test_and_clear_bit(bit, &bdi->state))
739        atomic_dec(&nr_bdi_congested[sync]);
740    smp_mb__after_clear_bit();
741    if (waitqueue_active(wqh))
742        wake_up(wqh);
743}
744EXPORT_SYMBOL(clear_bdi_congested);
745
746void set_bdi_congested(struct backing_dev_info *bdi, int sync)
747{
748    enum bdi_state bit;
749
750    bit = sync ? BDI_sync_congested : BDI_async_congested;
751    if (!test_and_set_bit(bit, &bdi->state))
752        atomic_inc(&nr_bdi_congested[sync]);
753}
754EXPORT_SYMBOL(set_bdi_congested);
755
756/**
757 * congestion_wait - wait for a backing_dev to become uncongested
758 * @sync: SYNC or ASYNC IO
759 * @timeout: timeout in jiffies
760 *
761 * Waits for up to @timeout jiffies for a backing_dev (any backing_dev) to exit
762 * write congestion. If no backing_devs are congested then just wait for the
763 * next write to be completed.
764 */
765long congestion_wait(int sync, long timeout)
766{
767    long ret;
768    unsigned long start = jiffies;
769    DEFINE_WAIT(wait);
770    wait_queue_head_t *wqh = &congestion_wqh[sync];
771
772    prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
773    ret = io_schedule_timeout(timeout);
774    finish_wait(wqh, &wait);
775
776    trace_writeback_congestion_wait(jiffies_to_usecs(timeout),
777                    jiffies_to_usecs(jiffies - start));
778
779    return ret;
780}
781EXPORT_SYMBOL(congestion_wait);
782
783/**
784 * wait_iff_congested - Conditionally wait for a backing_dev to become uncongested or a zone to complete writes
785 * @zone: A zone to check if it is heavily congested
786 * @sync: SYNC or ASYNC IO
787 * @timeout: timeout in jiffies
788 *
789 * In the event of a congested backing_dev (any backing_dev) and the given
790 * @zone has experienced recent congestion, this waits for up to @timeout
791 * jiffies for either a BDI to exit congestion of the given @sync queue
792 * or a write to complete.
793 *
794 * In the absence of zone congestion, cond_resched() is called to yield
795 * the processor if necessary but otherwise does not sleep.
796 *
797 * The return value is 0 if the sleep is for the full timeout. Otherwise,
798 * it is the number of jiffies that were still remaining when the function
799 * returned. return_value == timeout implies the function did not sleep.
800 */
801long wait_iff_congested(struct zone *zone, int sync, long timeout)
802{
803    long ret;
804    unsigned long start = jiffies;
805    DEFINE_WAIT(wait);
806    wait_queue_head_t *wqh = &congestion_wqh[sync];
807
808    /*
809     * If there is no congestion, or heavy congestion is not being
810     * encountered in the current zone, yield if necessary instead
811     * of sleeping on the congestion queue
812     */
813    if (atomic_read(&nr_bdi_congested[sync]) == 0 ||
814            !zone_is_reclaim_congested(zone)) {
815        cond_resched();
816
817        /* In case we scheduled, work out time remaining */
818        ret = timeout - (jiffies - start);
819        if (ret < 0)
820            ret = 0;
821
822        goto out;
823    }
824
825    /* Sleep until uncongested or a write happens */
826    prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
827    ret = io_schedule_timeout(timeout);
828    finish_wait(wqh, &wait);
829
830out:
831    trace_writeback_wait_iff_congested(jiffies_to_usecs(timeout),
832                    jiffies_to_usecs(jiffies - start));
833
834    return ret;
835}
836EXPORT_SYMBOL(wait_iff_congested);
837
838int pdflush_proc_obsolete(struct ctl_table *table, int write,
839            void __user *buffer, size_t *lenp, loff_t *ppos)
840{
841    char kbuf[] = "0\n";
842
843    if (*ppos) {
844        *lenp = 0;
845        return 0;
846    }
847
848    if (copy_to_user(buffer, kbuf, sizeof(kbuf)))
849        return -EFAULT;
850    printk_once(KERN_WARNING "%s exported in /proc is scheduled for removal\n",
851            table->procname);
852
853    *lenp = 2;
854    *ppos += *lenp;
855    return 2;
856}
857

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive