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