backing-dev.c revision 875352c94224c88f5aa28cb77206f993bd31b7a2
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 14static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0); 15 16void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page) 17{ 18} 19EXPORT_SYMBOL(default_unplug_io_fn); 20 21struct backing_dev_info default_backing_dev_info = { 22 .name = "default", 23 .ra_pages = VM_MAX_READAHEAD * 1024 / PAGE_CACHE_SIZE, 24 .state = 0, 25 .capabilities = BDI_CAP_MAP_COPY, 26 .unplug_io_fn = default_unplug_io_fn, 27}; 28EXPORT_SYMBOL_GPL(default_backing_dev_info); 29 30struct backing_dev_info noop_backing_dev_info = { 31 .name = "noop", 32}; 33EXPORT_SYMBOL_GPL(noop_backing_dev_info); 34 35static struct class *bdi_class; 36 37/* 38 * bdi_lock protects updates to bdi_list and bdi_pending_list, as well as 39 * reader side protection for bdi_pending_list. bdi_list has RCU reader side 40 * locking. 41 */ 42DEFINE_SPINLOCK(bdi_lock); 43LIST_HEAD(bdi_list); 44LIST_HEAD(bdi_pending_list); 45 46static struct task_struct *sync_supers_tsk; 47static struct timer_list sync_supers_timer; 48 49static int bdi_sync_supers(void *); 50static void sync_supers_timer_fn(unsigned long); 51 52static void bdi_add_default_flusher_task(struct backing_dev_info *bdi); 53 54#ifdef CONFIG_DEBUG_FS 55#include <linux/debugfs.h> 56#include <linux/seq_file.h> 57 58static struct dentry *bdi_debug_root; 59 60static void bdi_debug_init(void) 61{ 62 bdi_debug_root = debugfs_create_dir("bdi", NULL); 63} 64 65static int bdi_debug_stats_show(struct seq_file *m, void *v) 66{ 67 struct backing_dev_info *bdi = m->private; 68 struct bdi_writeback *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, nr_wb; 73 struct inode *inode; 74 75 /* 76 * inode lock is enough here, the bdi->wb_list is protected by 77 * RCU on the reader side 78 */ 79 nr_wb = nr_dirty = nr_io = nr_more_io = 0; 80 spin_lock(&inode_lock); 81 list_for_each_entry(wb, &bdi->wb_list, list) { 82 nr_wb++; 83 list_for_each_entry(inode, &wb->b_dirty, i_list) 84 nr_dirty++; 85 list_for_each_entry(inode, &wb->b_io, i_list) 86 nr_io++; 87 list_for_each_entry(inode, &wb->b_more_io, i_list) 88 nr_more_io++; 89 } 90 spin_unlock(&inode_lock); 91 92 get_dirty_limits(&background_thresh, &dirty_thresh, &bdi_thresh, bdi); 93 94#define K(x) ((x) << (PAGE_SHIFT - 10)) 95 seq_printf(m, 96 "BdiWriteback: %8lu kB\n" 97 "BdiReclaimable: %8lu kB\n" 98 "BdiDirtyThresh: %8lu kB\n" 99 "DirtyThresh: %8lu kB\n" 100 "BackgroundThresh: %8lu kB\n" 101 "WritebackThreads: %8lu\n" 102 "b_dirty: %8lu\n" 103 "b_io: %8lu\n" 104 "b_more_io: %8lu\n" 105 "bdi_list: %8u\n" 106 "state: %8lx\n" 107 "wb_mask: %8lx\n" 108 "wb_list: %8u\n" 109 "wb_cnt: %8u\n", 110 (unsigned long) K(bdi_stat(bdi, BDI_WRITEBACK)), 111 (unsigned long) K(bdi_stat(bdi, BDI_RECLAIMABLE)), 112 K(bdi_thresh), K(dirty_thresh), 113 K(background_thresh), nr_wb, nr_dirty, nr_io, nr_more_io, 114 !list_empty(&bdi->bdi_list), bdi->state, bdi->wb_mask, 115 !list_empty(&bdi->wb_list), bdi->wb_cnt); 116#undef K 117 118 return 0; 119} 120 121static int bdi_debug_stats_open(struct inode *inode, struct file *file) 122{ 123 return single_open(file, bdi_debug_stats_show, inode->i_private); 124} 125 126static const struct file_operations bdi_debug_stats_fops = { 127 .open = bdi_debug_stats_open, 128 .read = seq_read, 129 .llseek = seq_lseek, 130 .release = single_release, 131}; 132 133static void bdi_debug_register(struct backing_dev_info *bdi, const char *name) 134{ 135 bdi->debug_dir = debugfs_create_dir(name, bdi_debug_root); 136 bdi->debug_stats = debugfs_create_file("stats", 0444, bdi->debug_dir, 137 bdi, &bdi_debug_stats_fops); 138} 139 140static void bdi_debug_unregister(struct backing_dev_info *bdi) 141{ 142 debugfs_remove(bdi->debug_stats); 143 debugfs_remove(bdi->debug_dir); 144} 145#else 146static inline void bdi_debug_init(void) 147{ 148} 149static inline void bdi_debug_register(struct backing_dev_info *bdi, 150 const char *name) 151{ 152} 153static inline void bdi_debug_unregister(struct backing_dev_info *bdi) 154{ 155} 156#endif 157 158static ssize_t read_ahead_kb_store(struct device *dev, 159 struct device_attribute *attr, 160 const char *buf, size_t count) 161{ 162 struct backing_dev_info *bdi = dev_get_drvdata(dev); 163 char *end; 164 unsigned long read_ahead_kb; 165 ssize_t ret = -EINVAL; 166 167 read_ahead_kb = simple_strtoul(buf, &end, 10); 168 if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) { 169 bdi->ra_pages = read_ahead_kb >> (PAGE_SHIFT - 10); 170 ret = count; 171 } 172 return ret; 173} 174 175#define K(pages) ((pages) << (PAGE_SHIFT - 10)) 176 177#define BDI_SHOW(name, expr) \ 178static ssize_t name##_show(struct device *dev, \ 179 struct device_attribute *attr, char *page) \ 180{ \ 181 struct backing_dev_info *bdi = dev_get_drvdata(dev); \ 182 \ 183 return snprintf(page, PAGE_SIZE-1, "%lld\n", (long long)expr); \ 184} 185 186BDI_SHOW(read_ahead_kb, K(bdi->ra_pages)) 187 188static ssize_t min_ratio_store(struct device *dev, 189 struct device_attribute *attr, const char *buf, size_t count) 190{ 191 struct backing_dev_info *bdi = dev_get_drvdata(dev); 192 char *end; 193 unsigned int ratio; 194 ssize_t ret = -EINVAL; 195 196 ratio = simple_strtoul(buf, &end, 10); 197 if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) { 198 ret = bdi_set_min_ratio(bdi, ratio); 199 if (!ret) 200 ret = count; 201 } 202 return ret; 203} 204BDI_SHOW(min_ratio, bdi->min_ratio) 205 206static ssize_t max_ratio_store(struct device *dev, 207 struct device_attribute *attr, const char *buf, size_t count) 208{ 209 struct backing_dev_info *bdi = dev_get_drvdata(dev); 210 char *end; 211 unsigned int ratio; 212 ssize_t ret = -EINVAL; 213 214 ratio = simple_strtoul(buf, &end, 10); 215 if (*buf && (end[0] == '\0' || (end[0] == '\n' && end[1] == '\0'))) { 216 ret = bdi_set_max_ratio(bdi, ratio); 217 if (!ret) 218 ret = count; 219 } 220 return ret; 221} 222BDI_SHOW(max_ratio, bdi->max_ratio) 223 224#define __ATTR_RW(attr) __ATTR(attr, 0644, attr##_show, attr##_store) 225 226static struct device_attribute bdi_dev_attrs[] = { 227 __ATTR_RW(read_ahead_kb), 228 __ATTR_RW(min_ratio), 229 __ATTR_RW(max_ratio), 230 __ATTR_NULL, 231}; 232 233static __init int bdi_class_init(void) 234{ 235 bdi_class = class_create(THIS_MODULE, "bdi"); 236 if (IS_ERR(bdi_class)) 237 return PTR_ERR(bdi_class); 238 239 bdi_class->dev_attrs = bdi_dev_attrs; 240 bdi_debug_init(); 241 return 0; 242} 243postcore_initcall(bdi_class_init); 244 245static int __init default_bdi_init(void) 246{ 247 int err; 248 249 sync_supers_tsk = kthread_run(bdi_sync_supers, NULL, "sync_supers"); 250 BUG_ON(IS_ERR(sync_supers_tsk)); 251 252 init_timer(&sync_supers_timer); 253 setup_timer(&sync_supers_timer, sync_supers_timer_fn, 0); 254 bdi_arm_supers_timer(); 255 256 err = bdi_init(&default_backing_dev_info); 257 if (!err) 258 bdi_register(&default_backing_dev_info, NULL, "default"); 259 260 return err; 261} 262subsys_initcall(default_bdi_init); 263 264static void bdi_wb_init(struct bdi_writeback *wb, struct backing_dev_info *bdi) 265{ 266 memset(wb, 0, sizeof(*wb)); 267 268 wb->bdi = bdi; 269 wb->last_old_flush = jiffies; 270 INIT_LIST_HEAD(&wb->b_dirty); 271 INIT_LIST_HEAD(&wb->b_io); 272 INIT_LIST_HEAD(&wb->b_more_io); 273} 274 275static void bdi_task_init(struct backing_dev_info *bdi, 276 struct bdi_writeback *wb) 277{ 278 struct task_struct *tsk = current; 279 280 spin_lock(&bdi->wb_lock); 281 list_add_tail_rcu(&wb->list, &bdi->wb_list); 282 spin_unlock(&bdi->wb_lock); 283 284 tsk->flags |= PF_FLUSHER | PF_SWAPWRITE; 285 set_freezable(); 286 287 /* 288 * Our parent may run at a different priority, just set us to normal 289 */ 290 set_user_nice(tsk, 0); 291} 292 293static int bdi_start_fn(void *ptr) 294{ 295 struct bdi_writeback *wb = ptr; 296 struct backing_dev_info *bdi = wb->bdi; 297 int ret; 298 299 /* 300 * Add us to the active bdi_list 301 */ 302 spin_lock_bh(&bdi_lock); 303 list_add_rcu(&bdi->bdi_list, &bdi_list); 304 spin_unlock_bh(&bdi_lock); 305 306 bdi_task_init(bdi, wb); 307 308 /* 309 * Clear pending bit and wakeup anybody waiting to tear us down 310 */ 311 clear_bit(BDI_pending, &bdi->state); 312 smp_mb__after_clear_bit(); 313 wake_up_bit(&bdi->state, BDI_pending); 314 315 ret = bdi_writeback_task(wb); 316 317 /* 318 * Remove us from the list 319 */ 320 spin_lock(&bdi->wb_lock); 321 list_del_rcu(&wb->list); 322 spin_unlock(&bdi->wb_lock); 323 324 /* 325 * Flush any work that raced with us exiting. No new work 326 * will be added, since this bdi isn't discoverable anymore. 327 */ 328 if (!list_empty(&bdi->work_list)) 329 wb_do_writeback(wb, 1); 330 331 wb->task = NULL; 332 return ret; 333} 334 335int bdi_has_dirty_io(struct backing_dev_info *bdi) 336{ 337 return wb_has_dirty_io(&bdi->wb); 338} 339 340static void bdi_flush_io(struct backing_dev_info *bdi) 341{ 342 struct writeback_control wbc = { 343 .bdi = bdi, 344 .sync_mode = WB_SYNC_NONE, 345 .older_than_this = NULL, 346 .range_cyclic = 1, 347 .nr_to_write = 1024, 348 }; 349 350 writeback_inodes_wbc(&wbc); 351} 352 353/* 354 * kupdated() used to do this. We cannot do it from the bdi_forker_task() 355 * or we risk deadlocking on ->s_umount. The longer term solution would be 356 * to implement sync_supers_bdi() or similar and simply do it from the 357 * bdi writeback tasks individually. 358 */ 359static int bdi_sync_supers(void *unused) 360{ 361 set_user_nice(current, 0); 362 363 while (!kthread_should_stop()) { 364 set_current_state(TASK_INTERRUPTIBLE); 365 schedule(); 366 367 /* 368 * Do this periodically, like kupdated() did before. 369 */ 370 sync_supers(); 371 } 372 373 return 0; 374} 375 376void bdi_arm_supers_timer(void) 377{ 378 unsigned long next; 379 380 if (!dirty_writeback_interval) 381 return; 382 383 next = msecs_to_jiffies(dirty_writeback_interval * 10) + jiffies; 384 mod_timer(&sync_supers_timer, round_jiffies_up(next)); 385} 386 387static void sync_supers_timer_fn(unsigned long unused) 388{ 389 wake_up_process(sync_supers_tsk); 390 bdi_arm_supers_timer(); 391} 392 393static int bdi_forker_task(void *ptr) 394{ 395 struct bdi_writeback *me = ptr; 396 397 bdi_task_init(me->bdi, me); 398 399 for (;;) { 400 struct backing_dev_info *bdi, *tmp; 401 struct bdi_writeback *wb; 402 403 /* 404 * Temporary measure, we want to make sure we don't see 405 * dirty data on the default backing_dev_info 406 */ 407 if (wb_has_dirty_io(me) || !list_empty(&me->bdi->work_list)) 408 wb_do_writeback(me, 0); 409 410 spin_lock_bh(&bdi_lock); 411 412 /* 413 * Check if any existing bdi's have dirty data without 414 * a thread registered. If so, set that up. 415 */ 416 list_for_each_entry_safe(bdi, tmp, &bdi_list, bdi_list) { 417 if (bdi->wb.task) 418 continue; 419 if (list_empty(&bdi->work_list) && 420 !bdi_has_dirty_io(bdi)) 421 continue; 422 423 bdi_add_default_flusher_task(bdi); 424 } 425 426 set_current_state(TASK_INTERRUPTIBLE); 427 428 if (list_empty(&bdi_pending_list)) { 429 unsigned long wait; 430 431 spin_unlock_bh(&bdi_lock); 432 wait = msecs_to_jiffies(dirty_writeback_interval * 10); 433 if (wait) 434 schedule_timeout(wait); 435 else 436 schedule(); 437 try_to_freeze(); 438 continue; 439 } 440 441 __set_current_state(TASK_RUNNING); 442 443 /* 444 * This is our real job - check for pending entries in 445 * bdi_pending_list, and create the tasks that got added 446 */ 447 bdi = list_entry(bdi_pending_list.next, struct backing_dev_info, 448 bdi_list); 449 list_del_init(&bdi->bdi_list); 450 spin_unlock_bh(&bdi_lock); 451 452 wb = &bdi->wb; 453 wb->task = kthread_run(bdi_start_fn, wb, "flush-%s", 454 dev_name(bdi->dev)); 455 /* 456 * If task creation fails, then readd the bdi to 457 * the pending list and force writeout of the bdi 458 * from this forker thread. That will free some memory 459 * and we can try again. 460 */ 461 if (IS_ERR(wb->task)) { 462 wb->task = NULL; 463 464 /* 465 * Add this 'bdi' to the back, so we get 466 * a chance to flush other bdi's to free 467 * memory. 468 */ 469 spin_lock_bh(&bdi_lock); 470 list_add_tail(&bdi->bdi_list, &bdi_pending_list); 471 spin_unlock_bh(&bdi_lock); 472 473 bdi_flush_io(bdi); 474 } 475 } 476 477 return 0; 478} 479 480static void bdi_add_to_pending(struct rcu_head *head) 481{ 482 struct backing_dev_info *bdi; 483 484 bdi = container_of(head, struct backing_dev_info, rcu_head); 485 INIT_LIST_HEAD(&bdi->bdi_list); 486 487 spin_lock(&bdi_lock); 488 list_add_tail(&bdi->bdi_list, &bdi_pending_list); 489 spin_unlock(&bdi_lock); 490 491 /* 492 * We are now on the pending list, wake up bdi_forker_task() 493 * to finish the job and add us back to the active bdi_list 494 */ 495 wake_up_process(default_backing_dev_info.wb.task); 496} 497 498/* 499 * Add the default flusher task that gets created for any bdi 500 * that has dirty data pending writeout 501 */ 502void static bdi_add_default_flusher_task(struct backing_dev_info *bdi) 503{ 504 if (!bdi_cap_writeback_dirty(bdi)) 505 return; 506 507 if (WARN_ON(!test_bit(BDI_registered, &bdi->state))) { 508 printk(KERN_ERR "bdi %p/%s is not registered!\n", 509 bdi, bdi->name); 510 return; 511 } 512 513 /* 514 * Check with the helper whether to proceed adding a task. Will only 515 * abort if we two or more simultanous calls to 516 * bdi_add_default_flusher_task() occured, further additions will block 517 * waiting for previous additions to finish. 518 */ 519 if (!test_and_set_bit(BDI_pending, &bdi->state)) { 520 list_del_rcu(&bdi->bdi_list); 521 522 /* 523 * We must wait for the current RCU period to end before 524 * moving to the pending list. So schedule that operation 525 * from an RCU callback. 526 */ 527 call_rcu(&bdi->rcu_head, bdi_add_to_pending); 528 } 529} 530 531/* 532 * Remove bdi from bdi_list, and ensure that it is no longer visible 533 */ 534static void bdi_remove_from_list(struct backing_dev_info *bdi) 535{ 536 spin_lock_bh(&bdi_lock); 537 list_del_rcu(&bdi->bdi_list); 538 spin_unlock_bh(&bdi_lock); 539 540 synchronize_rcu(); 541} 542 543int bdi_register(struct backing_dev_info *bdi, struct device *parent, 544 const char *fmt, ...) 545{ 546 va_list args; 547 int ret = 0; 548 struct device *dev; 549 550 if (bdi->dev) /* The driver needs to use separate queues per device */ 551 goto exit; 552 553 va_start(args, fmt); 554 dev = device_create_vargs(bdi_class, parent, MKDEV(0, 0), bdi, fmt, args); 555 va_end(args); 556 if (IS_ERR(dev)) { 557 ret = PTR_ERR(dev); 558 goto exit; 559 } 560 561 spin_lock_bh(&bdi_lock); 562 list_add_tail_rcu(&bdi->bdi_list, &bdi_list); 563 spin_unlock_bh(&bdi_lock); 564 565 bdi->dev = dev; 566 567 /* 568 * Just start the forker thread for our default backing_dev_info, 569 * and add other bdi's to the list. They will get a thread created 570 * on-demand when they need it. 571 */ 572 if (bdi_cap_flush_forker(bdi)) { 573 struct bdi_writeback *wb = &bdi->wb; 574 575 wb->task = kthread_run(bdi_forker_task, wb, "bdi-%s", 576 dev_name(dev)); 577 if (IS_ERR(wb->task)) { 578 wb->task = NULL; 579 ret = -ENOMEM; 580 581 bdi_remove_from_list(bdi); 582 goto exit; 583 } 584 } 585 586 bdi_debug_register(bdi, dev_name(dev)); 587 set_bit(BDI_registered, &bdi->state); 588exit: 589 return ret; 590} 591EXPORT_SYMBOL(bdi_register); 592 593int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev) 594{ 595 return bdi_register(bdi, NULL, "%u:%u", MAJOR(dev), MINOR(dev)); 596} 597EXPORT_SYMBOL(bdi_register_dev); 598 599/* 600 * Remove bdi from the global list and shutdown any threads we have running 601 */ 602static void bdi_wb_shutdown(struct backing_dev_info *bdi) 603{ 604 struct bdi_writeback *wb; 605 606 if (!bdi_cap_writeback_dirty(bdi)) 607 return; 608 609 /* 610 * If setup is pending, wait for that to complete first 611 */ 612 wait_on_bit(&bdi->state, BDI_pending, bdi_sched_wait, 613 TASK_UNINTERRUPTIBLE); 614 615 /* 616 * Make sure nobody finds us on the bdi_list anymore 617 */ 618 bdi_remove_from_list(bdi); 619 620 /* 621 * Finally, kill the kernel threads. We don't need to be RCU 622 * safe anymore, since the bdi is gone from visibility. Force 623 * unfreeze of the thread before calling kthread_stop(), otherwise 624 * it would never exet if it is currently stuck in the refrigerator. 625 */ 626 list_for_each_entry(wb, &bdi->wb_list, list) { 627 thaw_process(wb->task); 628 kthread_stop(wb->task); 629 } 630} 631 632/* 633 * This bdi is going away now, make sure that no super_blocks point to it 634 */ 635static void bdi_prune_sb(struct backing_dev_info *bdi) 636{ 637 struct super_block *sb; 638 639 spin_lock(&sb_lock); 640 list_for_each_entry(sb, &super_blocks, s_list) { 641 if (sb->s_bdi == bdi) 642 sb->s_bdi = NULL; 643 } 644 spin_unlock(&sb_lock); 645} 646 647void bdi_unregister(struct backing_dev_info *bdi) 648{ 649 if (bdi->dev) { 650 bdi_prune_sb(bdi); 651 652 if (!bdi_cap_flush_forker(bdi)) 653 bdi_wb_shutdown(bdi); 654 bdi_debug_unregister(bdi); 655 device_unregister(bdi->dev); 656 bdi->dev = NULL; 657 } 658} 659EXPORT_SYMBOL(bdi_unregister); 660 661int bdi_init(struct backing_dev_info *bdi) 662{ 663 int i, err; 664 665 bdi->dev = NULL; 666 667 bdi->min_ratio = 0; 668 bdi->max_ratio = 100; 669 bdi->max_prop_frac = PROP_FRAC_BASE; 670 spin_lock_init(&bdi->wb_lock); 671 INIT_LIST_HEAD(&bdi->bdi_list); 672 INIT_LIST_HEAD(&bdi->wb_list); 673 INIT_LIST_HEAD(&bdi->work_list); 674 675 bdi_wb_init(&bdi->wb, bdi); 676 677 /* 678 * Just one thread support for now, hard code mask and count 679 */ 680 bdi->wb_mask = 1; 681 bdi->wb_cnt = 1; 682 683 for (i = 0; i < NR_BDI_STAT_ITEMS; i++) { 684 err = percpu_counter_init(&bdi->bdi_stat[i], 0); 685 if (err) 686 goto err; 687 } 688 689 bdi->dirty_exceeded = 0; 690 err = prop_local_init_percpu(&bdi->completions); 691 692 if (err) { 693err: 694 while (i--) 695 percpu_counter_destroy(&bdi->bdi_stat[i]); 696 } 697 698 return err; 699} 700EXPORT_SYMBOL(bdi_init); 701 702void bdi_destroy(struct backing_dev_info *bdi) 703{ 704 int i; 705 706 /* 707 * Splice our entries to the default_backing_dev_info, if this 708 * bdi disappears 709 */ 710 if (bdi_has_dirty_io(bdi)) { 711 struct bdi_writeback *dst = &default_backing_dev_info.wb; 712 713 spin_lock(&inode_lock); 714 list_splice(&bdi->wb.b_dirty, &dst->b_dirty); 715 list_splice(&bdi->wb.b_io, &dst->b_io); 716 list_splice(&bdi->wb.b_more_io, &dst->b_more_io); 717 spin_unlock(&inode_lock); 718 } 719 720 bdi_unregister(bdi); 721 722 for (i = 0; i < NR_BDI_STAT_ITEMS; i++) 723 percpu_counter_destroy(&bdi->bdi_stat[i]); 724 725 prop_local_destroy_percpu(&bdi->completions); 726} 727EXPORT_SYMBOL(bdi_destroy); 728 729/* 730 * For use from filesystems to quickly init and register a bdi associated 731 * with dirty writeback 732 */ 733int bdi_setup_and_register(struct backing_dev_info *bdi, char *name, 734 unsigned int cap) 735{ 736 char tmp[32]; 737 int err; 738 739 bdi->name = name; 740 bdi->capabilities = cap; 741 err = bdi_init(bdi); 742 if (err) 743 return err; 744 745 sprintf(tmp, "%.28s%s", name, "-%d"); 746 err = bdi_register(bdi, NULL, tmp, atomic_long_inc_return(&bdi_seq)); 747 if (err) { 748 bdi_destroy(bdi); 749 return err; 750 } 751 752 return 0; 753} 754EXPORT_SYMBOL(bdi_setup_and_register); 755 756static wait_queue_head_t congestion_wqh[2] = { 757 __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[0]), 758 __WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[1]) 759 }; 760 761void clear_bdi_congested(struct backing_dev_info *bdi, int sync) 762{ 763 enum bdi_state bit; 764 wait_queue_head_t *wqh = &congestion_wqh[sync]; 765 766 bit = sync ? BDI_sync_congested : BDI_async_congested; 767 clear_bit(bit, &bdi->state); 768 smp_mb__after_clear_bit(); 769 if (waitqueue_active(wqh)) 770 wake_up(wqh); 771} 772EXPORT_SYMBOL(clear_bdi_congested); 773 774void set_bdi_congested(struct backing_dev_info *bdi, int sync) 775{ 776 enum bdi_state bit; 777 778 bit = sync ? BDI_sync_congested : BDI_async_congested; 779 set_bit(bit, &bdi->state); 780} 781EXPORT_SYMBOL(set_bdi_congested); 782 783/** 784 * congestion_wait - wait for a backing_dev to become uncongested 785 * @sync: SYNC or ASYNC IO 786 * @timeout: timeout in jiffies 787 * 788 * Waits for up to @timeout jiffies for a backing_dev (any backing_dev) to exit 789 * write congestion. If no backing_devs are congested then just wait for the 790 * next write to be completed. 791 */ 792long congestion_wait(int sync, long timeout) 793{ 794 long ret; 795 DEFINE_WAIT(wait); 796 wait_queue_head_t *wqh = &congestion_wqh[sync]; 797 798 prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE); 799 ret = io_schedule_timeout(timeout); 800 finish_wait(wqh, &wait); 801 return ret; 802} 803EXPORT_SYMBOL(congestion_wait); 804 805