fs/fs-writeback.c

   1 /*
   2  * fs/fs-writeback.c
   3  *
   4  * Copyright (C) 2002, Linus Torvalds.
   5  *
   6  * Contains all the functions related to writing back and waiting
   7  * upon dirty inodes against superblocks, and writing back dirty
   8  * pages against inodes.  ie: data writeback.  Writeout of the
   9  * inode itself is not handled here.
  10  *
  11  * 10Apr2002    akpm@zip.com.au
  12  *              Split out of fs/inode.c
  13  *              Additions for address_space-based writeback
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/spinlock.h>
  18 #include <linux/sched.h>
  19 #include <linux/fs.h>
  20 #include <linux/mm.h>
  21 #include <linux/writeback.h>
  22 #include <linux/blkdev.h>
  23 #include <linux/backing-dev.h>
  24 #include <linux/buffer_head.h>
  25
  26 extern struct super_block *blockdev_superblock;
  27
  28 /**
  29  *      __mark_inode_dirty -    internal function
  30  *      @inode: inode to mark
  31  *      @flags: what kind of dirty (i.e. I_DIRTY_SYNC)
  32  *      Mark an inode as dirty. Callers should use mark_inode_dirty or
  33  *      mark_inode_dirty_sync.
  34  *
  35  * Put the inode on the super block's dirty list.
  36  *
  37  * CAREFUL! We mark it dirty unconditionally, but move it onto the
  38  * dirty list only if it is hashed or if it refers to a blockdev.
  39  * If it was not hashed, it will never be added to the dirty list
  40  * even if it is later hashed, as it will have been marked dirty already.
  41  *
  42  * In short, make sure you hash any inodes _before_ you start marking
  43  * them dirty.
  44  *
  45  * This function *must* be atomic for the I_DIRTY_PAGES case -
  46  * set_page_dirty() is called under spinlock in several places.
  47  *
  48  * Note that for blockdevs, inode->dirtied_when represents the dirtying time of
  49  * the block-special inode (/dev/hda1) itself.  And the ->dirtied_when field of
  50  * the kernel-internal blockdev inode represents the dirtying time of the
  51  * blockdev's pages.  This is why for I_DIRTY_PAGES we always use
  52  * page->mapping->host, so the page-dirtying time is recorded in the internal
  53  * blockdev inode.
  54  */
  55 void __mark_inode_dirty(struct inode *inode, int flags)
  56 {
  57         struct super_block *sb = inode->i_sb;
  58
  59         /*
  60          * Don't do this for I_DIRTY_PAGES - that doesn't actually
  61          * dirty the inode itself
  62          */
  63         if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
  64                 if (sb->s_op->dirty_inode)
  65                         sb->s_op->dirty_inode(inode);
  66         }
  67
  68         /*
  69          * make sure that changes are seen by all cpus before we test i_state
  70          * -- mikulas
  71          */
  72         smp_mb();
  73
  74         /* avoid the locking if we can */
  75         if ((inode->i_state & flags) == flags)
  76                 return;
  77
  78         if (unlikely(block_dump))
  79                 printk("%s(%d): dirtied file\n", current->comm, current->pid);
  80
  81         spin_lock(&inode_lock);
  82         if ((inode->i_state & flags) != flags) {
  83                 const int was_dirty = inode->i_state & I_DIRTY;
  84
  85                 inode->i_state |= flags;
  86
  87                 /*
  88                  * If the inode is locked, just update its dirty state.
  89                  * The unlocker will place the inode on the appropriate
  90                  * superblock list, based upon its state.
  91                  */
  92                 if (inode->i_state & I_LOCK)
  93                         goto out;
  94
  95                 /*
  96                  * Only add valid (hashed) inodes to the superblock's
  97                  * dirty list.  Add blockdev inodes as well.
  98                  */
  99                 if (!S_ISBLK(inode->i_mode)) {
 100                         if (hlist_unhashed(&inode->i_hash))
 101                                 goto out;
 102                 }
 103                 if (inode->i_state & (I_FREEING|I_CLEAR))
 104                         goto out;
 105
 106                 /*
 107                  * If the inode was already on s_dirty or s_io, don't
 108                  * reposition it (that would break s_dirty time-ordering).
 109                  */
 110                 if (!was_dirty) {
 111                         inode->dirtied_when = jiffies;
 112                         list_move(&inode->i_list, &sb->s_dirty);
 113                 }
 114         }
 115 out:
 116         spin_unlock(&inode_lock);
 117 }
 118
 119 EXPORT_SYMBOL(__mark_inode_dirty);
 120
 121 static void write_inode(struct inode *inode, int sync)
 122 {
 123         if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode))
 124                 inode->i_sb->s_op->write_inode(inode, sync);
 125 }
 126
 127 /*
 128  * Write a single inode's dirty pages and inode data out to disk.
 129  * If `wait' is set, wait on the writeout.
 130  *
 131  * The whole writeout design is quite complex and fragile.  We want to avoid
 132  * starvation of particular inodes when others are being redirtied, prevent
 133  * livelocks, etc.
 134  *
 135  * Called under inode_lock.
 136  */
 137 static int
 138 __sync_single_inode(struct inode *inode, struct writeback_control *wbc)
 139 {
 140         unsigned dirty;
 141         struct address_space *mapping = inode->i_mapping;
 142         struct super_block *sb = inode->i_sb;
 143         int wait = wbc->sync_mode == WB_SYNC_ALL;
 144         int ret;
 145
 146         BUG_ON(inode->i_state & I_LOCK);
 147
 148         /* Set I_LOCK, reset I_DIRTY */
 149         dirty = inode->i_state & I_DIRTY;
 150         inode->i_state |= I_LOCK;
 151         inode->i_state &= ~I_DIRTY;
 152
 153         spin_unlock(&inode_lock);
 154
 155         ret = do_writepages(mapping, wbc);
 156
 157         /* Don't write the inode if only I_DIRTY_PAGES was set */
 158         if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC))
 159                 write_inode(inode, wait);
 160
 161         if (wait) {
 162                 int err = filemap_fdatawait(mapping);
 163                 if (ret == 0)
 164                         ret = err;
 165         }
 166
 167         spin_lock(&inode_lock);
 168         inode->i_state &= ~I_LOCK;
 169         if (!(inode->i_state & I_FREEING)) {
 170                 if (!(inode->i_state & I_DIRTY) &&
 171                     mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
 172                         /*
 173                          * We didn't write back all the pages.  nfs_writepages()
 174                          * sometimes bales out without doing anything. Redirty
 175                          * the inode.  It is still on sb->s_io.
 176                          */
 177                         if (wbc->for_kupdate) {
 178                                 /*
 179                                  * For the kupdate function we leave the inode
 180                                  * at the head of sb_dirty so it will get more
 181                                  * writeout as soon as the queue becomes
 182                                  * uncongested.
 183                                  */
 184                                 inode->i_state |= I_DIRTY_PAGES;
 185                                 list_move_tail(&inode->i_list, &sb->s_dirty);
 186                         } else {
 187                                 /*
 188                                  * Otherwise fully redirty the inode so that
 189                                  * other inodes on this superblock will get some
 190                                  * writeout.  Otherwise heavy writing to one
 191                                  * file would indefinitely suspend writeout of
 192                                  * all the other files.
 193                                  */
 194                                 inode->i_state |= I_DIRTY_PAGES;
 195                                 inode->dirtied_when = jiffies;
 196                                 list_move(&inode->i_list, &sb->s_dirty);
 197                         }
 198                 } else if (inode->i_state & I_DIRTY) {
 199                         /*
 200                          * Someone redirtied the inode while were writing back
 201                          * the pages: nothing to do.
 202                          */
 203                 } else if (atomic_read(&inode->i_count)) {
 204                         /*
 205                          * The inode is clean, inuse
 206                          */
 207                         list_move(&inode->i_list, &inode_in_use);
 208                 } else {
 209                         /*
 210                          * The inode is clean, unused
 211                          */
 212                         list_move(&inode->i_list, &inode_unused);
 213                 }
 214         }
 215         wake_up_inode(inode);
 216         return ret;
 217 }
 218
 219 /*
 220  * Write out an inode's dirty pages.  Called under inode_lock.
 221  */
 222 static int
 223 __writeback_single_inode(struct inode *inode,
 224                         struct writeback_control *wbc)
 225 {
 226         if ((wbc->sync_mode != WB_SYNC_ALL) && (inode->i_state & I_LOCK)) {
 227                 list_move(&inode->i_list, &inode->i_sb->s_dirty);
 228                 return 0;
 229         }
 230
 231         /*
 232          * It's a data-integrity sync.  We must wait.
 233          */
 234         while (inode->i_state & I_LOCK) {
 235                 __iget(inode);
 236                 spin_unlock(&inode_lock);
 237                 __wait_on_inode(inode);
 238                 iput(inode);
 239                 spin_lock(&inode_lock);
 240         }
 241         return __sync_single_inode(inode, wbc);
 242 }
 243
 244 /*
 245  * Write out a superblock's list of dirty inodes.  A wait will be performed
 246  * upon no inodes, all inodes or the final one, depending upon sync_mode.
 247  *
 248  * If older_than_this is non-NULL, then only write out inodes which
 249  * had their first dirtying at a time earlier than *older_than_this.
 250  *
 251  * If we're a pdlfush thread, then implement pdflush collision avoidance
 252  * against the entire list.
 253  *
 254  * WB_SYNC_HOLD is a hack for sys_sync(): reattach the inode to sb->s_dirty so
 255  * that it can be located for waiting on in __writeback_single_inode().
 256  *
 257  * Called under inode_lock.
 258  *
 259  * If `bdi' is non-zero then we're being asked to writeback a specific queue.
 260  * This function assumes that the blockdev superblock's inodes are backed by
 261  * a variety of queues, so all inodes are searched.  For other superblocks,
 262  * assume that all inodes are backed by the same queue.
 263  *
 264  * FIXME: this linear search could get expensive with many fileystems.  But
 265  * how to fix?  We need to go from an address_space to all inodes which share
 266  * a queue with that address_space.  (Easy: have a global "dirty superblocks"
 267  * list).
 268  *
 269  * The inodes to be written are parked on sb->s_io.  They are moved back onto
 270  * sb->s_dirty as they are selected for writing.  This way, none can be missed
 271  * on the writer throttling path, and we get decent balancing between many
 272  * throttled threads: we don't want them all piling up on __wait_on_inode.
 273  */
 274 static void
 275 sync_sb_inodes(struct super_block *sb, struct writeback_control *wbc)
 276 {
 277         const unsigned long start = jiffies;    /* livelock avoidance */
 278
 279         if (!wbc->for_kupdate || list_empty(&sb->s_io))
 280                 list_splice_init(&sb->s_dirty, &sb->s_io);
 281
 282         while (!list_empty(&sb->s_io)) {
 283                 struct inode *inode = list_entry(sb->s_io.prev,
 284                                                 struct inode, i_list);
 285                 struct address_space *mapping = inode->i_mapping;
 286                 struct backing_dev_info *bdi = mapping->backing_dev_info;
 287                 long pages_skipped;
 288
 289                 if (bdi->memory_backed) {
 290                         if (sb == blockdev_superblock) {
 291                                 /*
 292                                  * Dirty memory-backed blockdev: the ramdisk
 293                                  * driver does this.
 294                                  */
 295                                 list_move(&inode->i_list, &sb->s_dirty);
 296                                 continue;
 297                         }
 298                         /*
 299                          * Assume that all inodes on this superblock are memory
 300                          * backed.  Skip the superblock.
 301                          */
 302                         break;
 303                 }
 304
 305                 if (wbc->nonblocking && bdi_write_congested(bdi)) {
 306                         wbc->encountered_congestion = 1;
 307                         if (sb != blockdev_superblock)
 308                                 break;          /* Skip a congested fs */
 309                         list_move(&inode->i_list, &sb->s_dirty);
 310                         continue;               /* Skip a congested blockdev */
 311                 }
 312
 313                 if (wbc->bdi && bdi != wbc->bdi) {
 314                         if (sb != blockdev_superblock)
 315                                 break;          /* fs has the wrong queue */
 316                         list_move(&inode->i_list, &sb->s_dirty);
 317                         continue;               /* blockdev has wrong queue */
 318                 }
 319
 320                 /* Was this inode dirtied after sync_sb_inodes was called? */
 321                 if (time_after(inode->dirtied_when, start))
 322                         break;
 323
 324                 /* Was this inode dirtied too recently? */
 325                 if (wbc->older_than_this && time_after(inode->dirtied_when,
 326                                                 *wbc->older_than_this))
 327                         break;
 328
 329                 /* Is another pdflush already flushing this queue? */
 330                 if (current_is_pdflush() && !writeback_acquire(bdi))
 331                         break;
 332
 333                 BUG_ON(inode->i_state & I_FREEING);
 334                 __iget(inode);
 335                 pages_skipped = wbc->pages_skipped;
 336                 __writeback_single_inode(inode, wbc);
 337                 if (wbc->sync_mode == WB_SYNC_HOLD) {
 338                         inode->dirtied_when = jiffies;
 339                         list_move(&inode->i_list, &sb->s_dirty);
 340                 }
 341                 if (current_is_pdflush())
 342                         writeback_release(bdi);
 343                 if (wbc->pages_skipped != pages_skipped) {
 344                         /*
 345                          * writeback is not making progress due to locked
 346                          * buffers.  Skip this inode for now.
 347                          */
 348                         list_move(&inode->i_list, &sb->s_dirty);
 349                 }
 350                 spin_unlock(&inode_lock);
 351                 iput(inode);
 352                 spin_lock(&inode_lock);
 353                 if (wbc->nr_to_write <= 0)
 354                         break;
 355         }
 356         return;         /* Leave any unwritten inodes on s_io */
 357 }
 358
 359 /*
 360  * Start writeback of dirty pagecache data against all unlocked inodes.
 361  *
 362  * Note:
 363  * We don't need to grab a reference to superblock here. If it has non-empty
 364  * ->s_dirty it's hadn't been killed yet and kill_super() won't proceed
 365  * past sync_inodes_sb() until both the ->s_dirty and ->s_io lists are
 366  * empty. Since __sync_single_inode() regains inode_lock before it finally moves
 367  * inode from superblock lists we are OK.
 368  *
 369  * If `older_than_this' is non-zero then only flush inodes which have a
 370  * flushtime older than *older_than_this.
 371  *
 372  * If `bdi' is non-zero then we will scan the first inode against each
 373  * superblock until we find the matching ones.  One group will be the dirty
 374  * inodes against a filesystem.  Then when we hit the dummy blockdev superblock,
 375  * sync_sb_inodes will seekout the blockdev which matches `bdi'.  Maybe not
 376  * super-efficient but we're about to do a ton of I/O...
 377  */
 378 void
 379 writeback_inodes(struct writeback_control *wbc)
 380 {
 381         struct super_block *sb;
 382
 383         spin_lock(&inode_lock);
 384         spin_lock(&sb_lock);
 385         sb = sb_entry(super_blocks.prev);
 386         for (; sb != sb_entry(&super_blocks); sb = sb_entry(sb->s_list.prev)) {
 387                 if (!list_empty(&sb->s_dirty) || !list_empty(&sb->s_io)) {
 388                         spin_unlock(&sb_lock);
 389                         sync_sb_inodes(sb, wbc);
 390                         spin_lock(&sb_lock);
 391                 }
 392                 if (wbc->nr_to_write <= 0)
 393                         break;
 394         }
 395         spin_unlock(&sb_lock);
 396         spin_unlock(&inode_lock);
 397 }
 398
 399 /*
 400  * writeback and wait upon the filesystem's dirty inodes.  The caller will
 401  * do this in two passes - one to write, and one to wait.  WB_SYNC_HOLD is
 402  * used to park the written inodes on sb->s_dirty for the wait pass.
 403  *
 404  * A finite limit is set on the number of pages which will be written.
 405  * To prevent infinite livelock of sys_sync().
 406  *
 407  * We add in the number of potentially dirty inodes, because each inode write
 408  * can dirty pagecache in the underlying blockdev.
 409  */
 410 void sync_inodes_sb(struct super_block *sb, int wait)
 411 {
 412         struct page_state ps;
 413         struct writeback_control wbc = {
 414                 .bdi            = NULL,
 415                 .sync_mode      = wait ? WB_SYNC_ALL : WB_SYNC_HOLD,
 416                 .older_than_this = NULL,
 417                 .nr_to_write    = 0,
 418         };
 419
 420         get_page_state(&ps);
 421         wbc.nr_to_write = ps.nr_dirty + ps.nr_unstable +
 422                         (inodes_stat.nr_inodes - inodes_stat.nr_unused) +
 423                         ps.nr_dirty + ps.nr_unstable;
 424         wbc.nr_to_write += wbc.nr_to_write / 2;         /* Bit more for luck */
 425         spin_lock(&inode_lock);
 426         sync_sb_inodes(sb, &wbc);
 427         spin_unlock(&inode_lock);
 428 }
 429
 430 /*
 431  * Rather lame livelock avoidance.
 432  */
 433 static void set_sb_syncing(int val)
 434 {
 435         struct super_block *sb;
 436         spin_lock(&sb_lock);
 437         sb = sb_entry(super_blocks.prev);
 438         for (; sb != sb_entry(&super_blocks); sb = sb_entry(sb->s_list.prev)) {
 439                 sb->s_syncing = val;
 440         }
 441         spin_unlock(&sb_lock);
 442 }
 443
 444 /*
 445  * Find a superblock with inodes that need to be synced
 446  */
 447 static struct super_block *get_super_to_sync(void)
 448 {
 449         struct super_block *sb;
 450 restart:
 451         spin_lock(&sb_lock);
 452         sb = sb_entry(super_blocks.prev);
 453         for (; sb != sb_entry(&super_blocks); sb = sb_entry(sb->s_list.prev)) {
 454                 if (sb->s_syncing)
 455                         continue;
 456                 sb->s_syncing = 1;
 457                 sb->s_count++;
 458                 spin_unlock(&sb_lock);
 459                 down_read(&sb->s_umount);
 460                 if (!sb->s_root) {
 461                         drop_super(sb);
 462                         goto restart;
 463                 }
 464                 return sb;
 465         }
 466         spin_unlock(&sb_lock);
 467         return NULL;
 468 }
 469
 470 /**
 471  * sync_inodes
 472  *
 473  * sync_inodes() goes through each super block's dirty inode list, writes the
 474  * inodes out, waits on the writeout and puts the inodes back on the normal
 475  * list.
 476  *
 477  * This is for sys_sync().  fsync_dev() uses the same algorithm.  The subtle
 478  * part of the sync functions is that the blockdev "superblock" is processed
 479  * last.  This is because the write_inode() function of a typical fs will
 480  * perform no I/O, but will mark buffers in the blockdev mapping as dirty.
 481  * What we want to do is to perform all that dirtying first, and then write
 482  * back all those inode blocks via the blockdev mapping in one sweep.  So the
 483  * additional (somewhat redundant) sync_blockdev() calls here are to make
 484  * sure that really happens.  Because if we call sync_inodes_sb(wait=1) with
 485  * outstanding dirty inodes, the writeback goes block-at-a-time within the
 486  * filesystem's write_inode().  This is extremely slow.
 487  */
 488 void sync_inodes(int wait)
 489 {
 490         struct super_block *sb;
 491
 492         set_sb_syncing(0);
 493         while ((sb = get_super_to_sync()) != NULL) {
 494                 sync_inodes_sb(sb, 0);
 495                 sync_blockdev(sb->s_bdev);
 496                 drop_super(sb);
 497         }
 498         if (wait) {
 499                 set_sb_syncing(0);
 500                 while ((sb = get_super_to_sync()) != NULL) {
 501                         sync_inodes_sb(sb, 1);
 502                         sync_blockdev(sb->s_bdev);
 503                         drop_super(sb);
 504                 }
 505         }
 506 }
 507
 508 /**
 509  *      write_inode_now -       write an inode to disk
 510  *      @inode: inode to write to disk
 511  *      @sync: whether the write should be synchronous or not
 512  *
 513  *      This function commits an inode to disk immediately if it is
 514  *      dirty. This is primarily needed by knfsd.
 515  */
 516
 517 void write_inode_now(struct inode *inode, int sync)
 518 {
 519         struct writeback_control wbc = {
 520                 .nr_to_write = LONG_MAX,
 521                 .sync_mode = WB_SYNC_ALL,
 522         };
 523
 524         spin_lock(&inode_lock);
 525         __writeback_single_inode(inode, &wbc);
 526         spin_unlock(&inode_lock);
 527         if (sync)
 528                 wait_on_inode(inode);
 529 }
 530 EXPORT_SYMBOL(write_inode_now);
 531
 532 /**
 533  * sync_inode - write an inode and its pages to disk.
 534  * @inode: the inode to sync
 535  * @wbc: controls the writeback mode
 536  *
 537  * sync_inode() will write an inode and its pages to disk.  It will also
 538  * correctly update the inode on its superblock's dirty inode lists and will
 539  * update inode->i_state.
 540  *
 541  * The caller must have a ref on the inode.
 542  */
 543 int sync_inode(struct inode *inode, struct writeback_control *wbc)
 544 {
 545         int ret;
 546
 547         spin_lock(&inode_lock);
 548         ret = __writeback_single_inode(inode, wbc);
 549         spin_unlock(&inode_lock);
 550         return ret;
 551 }
 552 EXPORT_SYMBOL(sync_inode);
 553
 554 /**
 555  * generic_osync_inode - flush all dirty data for a given inode to disk
 556  * @inode: inode to write
 557  * @what:  what to write and wait upon
 558  *
 559  * This can be called by file_write functions for files which have the
 560  * O_SYNC flag set, to flush dirty writes to disk.
 561  *
 562  * @what is a bitmask, specifying which part of the inode's data should be
 563  * written and waited upon:
 564  *
 565  *    OSYNC_DATA:     i_mapping's dirty data
 566  *    OSYNC_METADATA: the buffers at i_mapping->private_list
 567  *    OSYNC_INODE:    the inode itself
 568  */
 569
 570 int generic_osync_inode(struct inode *inode, struct address_space *mapping, int what)
 571 {
 572         int err = 0;
 573         int need_write_inode_now = 0;
 574         int err2;
 575
 576         current->flags |= PF_SYNCWRITE;
 577         if (what & OSYNC_DATA)
 578                 err = filemap_fdatawrite(mapping);
 579         if (what & (OSYNC_METADATA|OSYNC_DATA)) {
 580                 err2 = sync_mapping_buffers(mapping);
 581                 if (!err)
 582                         err = err2;
 583         }
 584         if (what & OSYNC_DATA) {
 585                 err2 = filemap_fdatawait(mapping);
 586                 if (!err)
 587                         err = err2;
 588         }
 589         current->flags &= ~PF_SYNCWRITE;
 590
 591         spin_lock(&inode_lock);
 592         if ((inode->i_state & I_DIRTY) &&
 593             ((what & OSYNC_INODE) || (inode->i_state & I_DIRTY_DATASYNC)))
 594                 need_write_inode_now = 1;
 595         spin_unlock(&inode_lock);
 596
 597         if (need_write_inode_now)
 598                 write_inode_now(inode, 1);
 599         else
 600                 wait_on_inode(inode);
 601
 602         return err;
 603 }
 604
 605 EXPORT_SYMBOL(generic_osync_inode);
 606
 607 /**
 608  * writeback_acquire: attempt to get exclusive writeback access to a device
 609  * @bdi: the device's backing_dev_info structure
 610  *
 611  * It is a waste of resources to have more than one pdflush thread blocked on
 612  * a single request queue.  Exclusion at the request_queue level is obtained
 613  * via a flag in the request_queue's backing_dev_info.state.
 614  *
 615  * Non-request_queue-backed address_spaces will share default_backing_dev_info,
 616  * unless they implement their own.  Which is somewhat inefficient, as this
 617  * may prevent concurrent writeback against multiple devices.
 618  */
 619 int writeback_acquire(struct backing_dev_info *bdi)
 620 {
 621         return !test_and_set_bit(BDI_pdflush, &bdi->state);
 622 }
 623
 624 /**
 625  * writeback_in_progress: determine whether there is writeback in progress
 626  *                        against a backing device.
 627  * @bdi: the device's backing_dev_info structure.
 628  */
 629 int writeback_in_progress(struct backing_dev_info *bdi)
 630 {
 631         return test_bit(BDI_pdflush, &bdi->state);
 632 }
 633
 634 /**
 635  * writeback_release: relinquish exclusive writeback access against a device.
 636  * @bdi: the device's backing_dev_info structure
 637  */
 638 void writeback_release(struct backing_dev_info *bdi)
 639 {
 640         BUG_ON(!writeback_in_progress(bdi));
 641         clear_bit(BDI_pdflush, &bdi->state);
 642 }