block: remove per-queue plugging

Code has been converted over to the new explicit on-stack plugging,
and delay users have been converted to use the new API for that.
So lets kill off the old plugging along with aops->sync_page().

Signed-off-by: Jens Axboe <jaxboe@fusionio.com>

51 files changed, 32 insertions, 305 deletions

diff --git a/fs/adfs/inode.c b/fs/adfs/inode.c
index 65794b8fe79..1cc84b27613 100644
--- a/fs/adfs/inode.c
+++ b/fs/adfs/inode.c
@@ -73,7 +73,6 @@ static sector_t _adfs_bmap(struct address_space *mapping, sector_t block)
 static const struct address_space_operations adfs_aops = {
         .readpage       = adfs_readpage,
         .writepage      = adfs_writepage,
-        .sync_page      = block_sync_page,
         .write_begin    = adfs_write_begin,
         .write_end      = generic_write_end,
         .bmap           = _adfs_bmap
diff --git a/fs/affs/file.c b/fs/affs/file.c
index 0a90dcd46de..acf321b70fc 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -429,7 +429,6 @@ static sector_t _affs_bmap(struct address_space *mapping, sector_t block)
 const struct address_space_operations affs_aops = {
         .readpage = affs_readpage,
         .writepage = affs_writepage,
-        .sync_page = block_sync_page,
         .write_begin = affs_write_begin,
         .write_end = generic_write_end,
         .bmap = _affs_bmap
@@ -786,7 +785,6 @@ out:
 const struct address_space_operations affs_aops_ofs = {
         .readpage = affs_readpage_ofs,
         //.writepage = affs_writepage_ofs,
-        //.sync_page = affs_sync_page_ofs,
         .write_begin = affs_write_begin_ofs,
         .write_end = affs_write_end_ofs
 };
diff --git a/fs/aio.c b/fs/aio.c
index fc557a3be0a..c5ea494ea9e 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -1550,9 +1550,11 @@ static void aio_batch_free(struct hlist_head *batch_hash)
         struct hlist_node *pos, *n;
         int i;
 
+        /*
+         * TODO: kill this
+         */
         for (i = 0; i < AIO_BATCH_HASH_SIZE; i++) {
                 hlist_for_each_entry_safe(abe, pos, n, &batch_hash[i], list) {
-                        blk_run_address_space(abe->mapping);
                         iput(abe->mapping->host);
                         hlist_del(&abe->list);
                         mempool_free(abe, abe_pool);
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index b1d0c794747..06457ed8f3e 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -75,7 +75,6 @@ static const struct inode_operations befs_dir_inode_operations = {
 
 static const struct address_space_operations befs_aops = {
         .readpage       = befs_readpage,
-        .sync_page      = block_sync_page,
         .bmap           = befs_bmap,
 };
 
diff --git a/fs/bfs/file.c b/fs/bfs/file.c
index eb67edd0f8e..f20e8a71062 100644
--- a/fs/bfs/file.c
+++ b/fs/bfs/file.c
@@ -186,7 +186,6 @@ static sector_t bfs_bmap(struct address_space *mapping, sector_t block)
 const struct address_space_operations bfs_aops = {
         .readpage       = bfs_readpage,
         .writepage      = bfs_writepage,
-        .sync_page      = block_sync_page,
         .write_begin    = bfs_write_begin,
         .write_end      = generic_write_end,
         .bmap           = bfs_bmap,
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 4fb8a343153..fffc2c67239 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -1520,7 +1520,6 @@ static int blkdev_releasepage(struct page *page, gfp_t wait)
 static const struct address_space_operations def_blk_aops = {
         .readpage       = blkdev_readpage,
         .writepage      = blkdev_writepage,
-        .sync_page      = block_sync_page,
         .write_begin    = blkdev_write_begin,
         .write_end      = blkdev_write_end,
         .writepages     = generic_writepages,
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index e1aa8d607bc..ada1f6bd0a5 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -847,7 +847,6 @@ static const struct address_space_operations btree_aops = {
         .writepages     = btree_writepages,
         .releasepage    = btree_releasepage,
         .invalidatepage = btree_invalidatepage,
-        .sync_page      = block_sync_page,
 #ifdef CONFIG_MIGRATION
         .migratepage    = btree_migratepage,
 #endif
@@ -1331,82 +1330,6 @@ static int btrfs_congested_fn(void *congested_data, int bdi_bits)
 }
 
 /*
- * this unplugs every device on the box, and it is only used when page
- * is null
- */
-static void __unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
-{
-        struct btrfs_device *device;
-        struct btrfs_fs_info *info;
-
-        info = (struct btrfs_fs_info *)bdi->unplug_io_data;
-        list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
-                if (!device->bdev)
-                        continue;
-
-                bdi = blk_get_backing_dev_info(device->bdev);
-                if (bdi->unplug_io_fn)
-                        bdi->unplug_io_fn(bdi, page);
-        }
-}
-
-static void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
-{
-        struct inode *inode;
-        struct extent_map_tree *em_tree;
-        struct extent_map *em;
-        struct address_space *mapping;
-        u64 offset;
-
-        /* the generic O_DIRECT read code does this */
-        if (1 || !page) {
-                __unplug_io_fn(bdi, page);
-                return;
-        }
-
-        /*
-         * page->mapping may change at any time.  Get a consistent copy
-         * and use that for everything below
-         */
-        smp_mb();
-        mapping = page->mapping;
-        if (!mapping)
-                return;
-
-        inode = mapping->host;
-
-        /*
-         * don't do the expensive searching for a small number of
-         * devices
-         */
-        if (BTRFS_I(inode)->root->fs_info->fs_devices->open_devices <= 2) {
-                __unplug_io_fn(bdi, page);
-                return;
-        }
-
-        offset = page_offset(page);
-
-        em_tree = &BTRFS_I(inode)->extent_tree;
-        read_lock(&em_tree->lock);
-        em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
-        read_unlock(&em_tree->lock);
-        if (!em) {
-                __unplug_io_fn(bdi, page);
-                return;
-        }
-
-        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
-                free_extent_map(em);
-                __unplug_io_fn(bdi, page);
-                return;
-        }
-        offset = offset - em->start;
-        btrfs_unplug_page(&BTRFS_I(inode)->root->fs_info->mapping_tree,
-                          em->block_start + offset, page);
-        free_extent_map(em);
-}
-
-/*
  * If this fails, caller must call bdi_destroy() to get rid of the
  * bdi again.
  */
@@ -1420,8 +1343,6 @@ static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
                 return err;
 
         bdi->ra_pages   = default_backing_dev_info.ra_pages;
-        bdi->unplug_io_fn       = btrfs_unplug_io_fn;
-        bdi->unplug_io_data     = info;
         bdi->congested_fn       = btrfs_congested_fn;
         bdi->congested_data     = info;
         return 0;
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index fb9bd7832b6..462e08e724b 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -7218,7 +7218,6 @@ static const struct address_space_operations btrfs_aops = {
         .writepage      = btrfs_writepage,
         .writepages     = btrfs_writepages,
         .readpages      = btrfs_readpages,
-        .sync_page      = block_sync_page,
         .direct_IO      = btrfs_direct_IO,
         .invalidatepage = btrfs_invalidatepage,
         .releasepage    = btrfs_releasepage,
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index af7dbca1527..6e0e82a1b18 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -162,7 +162,6 @@ static noinline int run_scheduled_bios(struct btrfs_device *device)
         struct bio *cur;
         int again = 0;
         unsigned long num_run;
-        unsigned long num_sync_run;
         unsigned long batch_run = 0;
         unsigned long limit;
         unsigned long last_waited = 0;
@@ -173,11 +172,6 @@ static noinline int run_scheduled_bios(struct btrfs_device *device)
         limit = btrfs_async_submit_limit(fs_info);
         limit = limit * 2 / 3;
 
-        /* we want to make sure that every time we switch from the sync
-         * list to the normal list, we unplug
-         */
-        num_sync_run = 0;
-
 loop:
         spin_lock(&device->io_lock);
 
@@ -223,15 +217,6 @@ loop_lock:
 
         spin_unlock(&device->io_lock);
 
-        /*
-         * if we're doing the regular priority list, make sure we unplug
-         * for any high prio bios we've sent down
-         */
-        if (pending_bios == &device->pending_bios && num_sync_run > 0) {
-                num_sync_run = 0;
-                blk_run_backing_dev(bdi, NULL);
-        }
-
         while (pending) {
 
                 rmb();
@@ -259,19 +244,11 @@ loop_lock:
 
                 BUG_ON(atomic_read(&cur->bi_cnt) == 0);
 
-                if (cur->bi_rw & REQ_SYNC)
-                        num_sync_run++;
-
                 submit_bio(cur->bi_rw, cur);
                 num_run++;
                 batch_run++;
-                if (need_resched()) {
-                        if (num_sync_run) {
-                                blk_run_backing_dev(bdi, NULL);
-                                num_sync_run = 0;
-                        }
+                if (need_resched())
                         cond_resched();
-                }
 
                 /*
                  * we made progress, there is more work to do and the bdi
@@ -304,13 +281,8 @@ loop_lock:
                                  * against it before looping
                                  */
                                 last_waited = ioc->last_waited;
-                                if (need_resched()) {
-                                        if (num_sync_run) {
-                                                blk_run_backing_dev(bdi, NULL);
-                                                num_sync_run = 0;
-                                        }
+                                if (need_resched())
                                         cond_resched();
-                                }
                                 continue;
                         }
                         spin_lock(&device->io_lock);
@@ -323,22 +295,6 @@ loop_lock:
                 }
         }
 
-        if (num_sync_run) {
-                num_sync_run = 0;
-                blk_run_backing_dev(bdi, NULL);
-        }
-        /*
-         * IO has already been through a long path to get here.  Checksumming,
-         * async helper threads, perhaps compression.  We've done a pretty
-         * good job of collecting a batch of IO and should just unplug
-         * the device right away.
-         *
-         * This will help anyone who is waiting on the IO, they might have
-         * already unplugged, but managed to do so before the bio they
-         * cared about found its way down here.
-         */
-        blk_run_backing_dev(bdi, NULL);
-
         cond_resched();
         if (again)
                 goto loop;
@@ -2948,7 +2904,7 @@ static int find_live_mirror(struct map_lookup *map, int first, int num,
 static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
                              u64 logical, u64 *length,
                              struct btrfs_multi_bio **multi_ret,
-                             int mirror_num, struct page *unplug_page)
+                             int mirror_num)
 {
         struct extent_map *em;
         struct map_lookup *map;
@@ -2980,11 +2936,6 @@ again:
         em = lookup_extent_mapping(em_tree, logical, *length);
         read_unlock(&em_tree->lock);
 
-        if (!em && unplug_page) {
-                kfree(multi);
-                return 0;
-        }
-
         if (!em) {
                 printk(KERN_CRIT "unable to find logical %llu len %llu\n",
                        (unsigned long long)logical,
@@ -3040,13 +2991,13 @@ again:
                 *length = em->len - offset;
         }
 
-        if (!multi_ret && !unplug_page)
+        if (!multi_ret)
                 goto out;
 
         num_stripes = 1;
         stripe_index = 0;
         if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
-                if (unplug_page || (rw & REQ_WRITE))
+                if (rw & REQ_WRITE)
                         num_stripes = map->num_stripes;
                 else if (mirror_num)
                         stripe_index = mirror_num - 1;
@@ -3068,7 +3019,7 @@ again:
                 stripe_index = do_div(stripe_nr, factor);
                 stripe_index *= map->sub_stripes;
 
-                if (unplug_page || (rw & REQ_WRITE))
+                if (rw & REQ_WRITE)
                         num_stripes = map->sub_stripes;
                 else if (mirror_num)
                         stripe_index += mirror_num - 1;
@@ -3088,22 +3039,10 @@ again:
         BUG_ON(stripe_index >= map->num_stripes);
 
         for (i = 0; i < num_stripes; i++) {
-                if (unplug_page) {
-                        struct btrfs_device *device;
-                        struct backing_dev_info *bdi;
-
-                        device = map->stripes[stripe_index].dev;
-                        if (device->bdev) {
-                                bdi = blk_get_backing_dev_info(device->bdev);
-                                if (bdi->unplug_io_fn)
-                                        bdi->unplug_io_fn(bdi, unplug_page);
-                        }
-                } else {
-                        multi->stripes[i].physical =
-                                map->stripes[stripe_index].physical +
-                                stripe_offset + stripe_nr * map->stripe_len;
-                        multi->stripes[i].dev = map->stripes[stripe_index].dev;
-                }
+                multi->stripes[i].physical =
+                        map->stripes[stripe_index].physical +
+                        stripe_offset + stripe_nr * map->stripe_len;
+                multi->stripes[i].dev = map->stripes[stripe_index].dev;
                 stripe_index++;
         }
         if (multi_ret) {
@@ -3121,7 +3060,7 @@ int btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
                       struct btrfs_multi_bio **multi_ret, int mirror_num)
 {
         return __btrfs_map_block(map_tree, rw, logical, length, multi_ret,
-                                 mirror_num, NULL);
+                                 mirror_num);
 }
 
 int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
@@ -3189,14 +3128,6 @@ int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
         return 0;
 }
 
-int btrfs_unplug_page(struct btrfs_mapping_tree *map_tree,
-                      u64 logical, struct page *page)
-{
-        u64 length = PAGE_CACHE_SIZE;
-        return __btrfs_map_block(map_tree, READ, logical, &length,
-                                 NULL, 0, page);
-}
-
 static void end_bio_multi_stripe(struct bio *bio, int err)
 {
         struct btrfs_multi_bio *multi = bio->bi_private;
diff --git a/fs/buffer.c b/fs/buffer.c
index 2219a76e2ca..f903f2e5b4f 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -54,23 +54,15 @@ init_buffer(struct buffer_head *bh, bh_end_io_t *handler, void *private)
 }
 EXPORT_SYMBOL(init_buffer);
 
-static int sync_buffer(void *word)
+static int sleep_on_buffer(void *word)
 {
-        struct block_device *bd;
-        struct buffer_head *bh
-                = container_of(word, struct buffer_head, b_state);
-
-        smp_mb();
-        bd = bh->b_bdev;
-        if (bd)
-                blk_run_address_space(bd->bd_inode->i_mapping);
         io_schedule();
         return 0;
 }
 
 void __lock_buffer(struct buffer_head *bh)
 {
-        wait_on_bit_lock(&bh->b_state, BH_Lock, sync_buffer,
+        wait_on_bit_lock(&bh->b_state, BH_Lock, sleep_on_buffer,
                                                         TASK_UNINTERRUPTIBLE);
 }
 EXPORT_SYMBOL(__lock_buffer);
@@ -90,7 +82,7 @@ EXPORT_SYMBOL(unlock_buffer);
  */
 void __wait_on_buffer(struct buffer_head * bh)
 {
-        wait_on_bit(&bh->b_state, BH_Lock, sync_buffer, TASK_UNINTERRUPTIBLE);
+        wait_on_bit(&bh->b_state, BH_Lock, sleep_on_buffer, TASK_UNINTERRUPTIBLE);
 }
 EXPORT_SYMBOL(__wait_on_buffer);
 
@@ -749,7 +741,7 @@ static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)
 {
         struct buffer_head *bh;
         struct list_head tmp;
-        struct address_space *mapping, *prev_mapping = NULL;
+        struct address_space *mapping;
         int err = 0, err2;
 
         INIT_LIST_HEAD(&tmp);
@@ -783,10 +775,6 @@ static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)
                                  * wait_on_buffer() will do that for us
                                  * through sync_buffer().
                                  */
-                                if (prev_mapping && prev_mapping != mapping)
-                                        blk_run_address_space(prev_mapping);
-                                prev_mapping = mapping;
-
                                 brelse(bh);
                                 spin_lock(lock);
                         }
@@ -3138,17 +3126,6 @@ out:
 }
 EXPORT_SYMBOL(try_to_free_buffers);
 
-void block_sync_page(struct page *page)
-{
-        struct address_space *mapping;
-
-        smp_mb();
-        mapping = page_mapping(page);
-        if (mapping)
-                blk_run_backing_dev(mapping->backing_dev_info, page);
-}
-EXPORT_SYMBOL(block_sync_page);
-
 /*
  * There are no bdflush tunables left.  But distributions are
  * still running obsolete flush daemons, so we terminate them here.
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index e964b1cd5dd..c27d236738f 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1569,34 +1569,6 @@ int cifs_fsync(struct file *file, int datasync)
         return rc;
 }
 
-/* static void cifs_sync_page(struct page *page)
-{
-        struct address_space *mapping;
-        struct inode *inode;
-        unsigned long index = page->index;
-        unsigned int rpages = 0;
-        int rc = 0;
-
-        cFYI(1, "sync page %p", page);
-        mapping = page->mapping;
-        if (!mapping)
-                return 0;
-        inode = mapping->host;
-        if (!inode)
-                return; */
-
-/*      fill in rpages then
-        result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
-
-/*      cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
-
-#if 0
-        if (rc < 0)
-                return rc;
-        return 0;
-#endif
-} */
-
 /*
  * As file closes, flush all cached write data for this inode checking
  * for write behind errors.
@@ -2510,7 +2482,6 @@ const struct address_space_operations cifs_addr_ops = {
         .set_page_dirty = __set_page_dirty_nobuffers,
         .releasepage = cifs_release_page,
         .invalidatepage = cifs_invalidate_page,
-        /* .sync_page = cifs_sync_page, */
         /* .direct_IO = */
 };
 
@@ -2528,6 +2499,5 @@ const struct address_space_operations cifs_addr_ops_smallbuf = {
         .set_page_dirty = __set_page_dirty_nobuffers,
         .releasepage = cifs_release_page,
         .invalidatepage = cifs_invalidate_page,
-        /* .sync_page = cifs_sync_page, */
         /* .direct_IO = */
 };
diff --git a/fs/direct-io.c b/fs/direct-io.c
index b044705eedd..df709b3b860 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -1110,11 +1110,8 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
             ((rw & READ) || (dio->result == dio->size)))
                 ret = -EIOCBQUEUED;
 
-        if (ret != -EIOCBQUEUED) {
-                /* All IO is now issued, send it on its way */
-                blk_run_address_space(inode->i_mapping);
+        if (ret != -EIOCBQUEUED)
                 dio_await_completion(dio);
-        }
 
         /*
          * Sync will always be dropping the final ref and completing the
diff --git a/fs/efs/inode.c b/fs/efs/inode.c
index a8e7797b947..9c13412e6c9 100644
--- a/fs/efs/inode.c
+++ b/fs/efs/inode.c
@@ -23,7 +23,6 @@ static sector_t _efs_bmap(struct address_space *mapping, sector_t block)
 }
 static const struct address_space_operations efs_aops = {
         .readpage = efs_readpage,
-        .sync_page = block_sync_page,
         .bmap = _efs_bmap
 };
 
diff --git a/fs/exofs/inode.c b/fs/exofs/inode.c
index a7555238c41..82b94c8f5d2 100644
--- a/fs/exofs/inode.c
+++ b/fs/exofs/inode.c
@@ -795,7 +795,6 @@ const struct address_space_operations exofs_aops = {
         .direct_IO      = NULL, /* TODO: Should be trivial to do */
 
         /* With these NULL has special meaning or default is not exported */
-        .sync_page      = NULL,
         .get_xip_mem    = NULL,
         .migratepage    = NULL,
         .launder_page   = NULL,
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 40ad210a504..c47f706878b 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -860,7 +860,6 @@ const struct address_space_operations ext2_aops = {
         .readpage               = ext2_readpage,
         .readpages              = ext2_readpages,
         .writepage              = ext2_writepage,
-        .sync_page              = block_sync_page,
         .write_begin            = ext2_write_begin,
         .write_end              = ext2_write_end,
         .bmap                   = ext2_bmap,
@@ -880,7 +879,6 @@ const struct address_space_operations ext2_nobh_aops = {
         .readpage               = ext2_readpage,
         .readpages              = ext2_readpages,
         .writepage              = ext2_nobh_writepage,
-        .sync_page              = block_sync_page,
         .write_begin            = ext2_nobh_write_begin,
         .write_end              = nobh_write_end,
         .bmap                   = ext2_bmap,
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index ae94f6d949f..fe2541d250e 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -1894,7 +1894,6 @@ static const struct address_space_operations ext3_ordered_aops = {
         .readpage               = ext3_readpage,
         .readpages              = ext3_readpages,
         .writepage              = ext3_ordered_writepage,
-        .sync_page              = block_sync_page,
         .write_begin            = ext3_write_begin,
         .write_end              = ext3_ordered_write_end,
         .bmap                   = ext3_bmap,
@@ -1910,7 +1909,6 @@ static const struct address_space_operations ext3_writeback_aops = {
         .readpage               = ext3_readpage,
         .readpages              = ext3_readpages,
         .writepage              = ext3_writeback_writepage,
-        .sync_page              = block_sync_page,
         .write_begin            = ext3_write_begin,
         .write_end              = ext3_writeback_write_end,
         .bmap                   = ext3_bmap,
@@ -1926,7 +1924,6 @@ static const struct address_space_operations ext3_journalled_aops = {
         .readpage               = ext3_readpage,
         .readpages              = ext3_readpages,
         .writepage              = ext3_journalled_writepage,
-        .sync_page              = block_sync_page,
         .write_begin            = ext3_write_begin,
         .write_end              = ext3_journalled_write_end,
         .set_page_dirty         = ext3_journalled_set_page_dirty,
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 9f7f9e49914..9297ad46c46 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -3903,7 +3903,6 @@ static const struct address_space_operations ext4_ordered_aops = {
         .readpage               = ext4_readpage,
         .readpages              = ext4_readpages,
         .writepage              = ext4_writepage,
-        .sync_page              = block_sync_page,
         .write_begin            = ext4_write_begin,
         .write_end              = ext4_ordered_write_end,
         .bmap                   = ext4_bmap,
@@ -3919,7 +3918,6 @@ static const struct address_space_operations ext4_writeback_aops = {
         .readpage               = ext4_readpage,
         .readpages              = ext4_readpages,
         .writepage              = ext4_writepage,
-        .sync_page              = block_sync_page,
         .write_begin            = ext4_write_begin,
         .write_end              = ext4_writeback_write_end,
         .bmap                   = ext4_bmap,
@@ -3935,7 +3933,6 @@ static const struct address_space_operations ext4_journalled_aops = {
         .readpage               = ext4_readpage,
         .readpages              = ext4_readpages,
         .writepage              = ext4_writepage,
-        .sync_page              = block_sync_page,
         .write_begin            = ext4_write_begin,
         .write_end              = ext4_journalled_write_end,
         .set_page_dirty         = ext4_journalled_set_page_dirty,
@@ -3951,7 +3948,6 @@ static const struct address_space_operations ext4_da_aops = {
         .readpages              = ext4_readpages,
         .writepage              = ext4_writepage,
         .writepages             = ext4_da_writepages,
-        .sync_page              = block_sync_page,
         .write_begin            = ext4_da_write_begin,
         .write_end              = ext4_da_write_end,
         .bmap                   = ext4_bmap,
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 86753fe10bd..f4ff09fb79b 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -236,7 +236,6 @@ static const struct address_space_operations fat_aops = {
         .readpages      = fat_readpages,
         .writepage      = fat_writepage,
         .writepages     = fat_writepages,
-        .sync_page      = block_sync_page,
         .write_begin    = fat_write_begin,
         .write_end      = fat_write_end,
         .direct_IO      = fat_direct_IO,
diff --git a/fs/freevxfs/vxfs_subr.c b/fs/freevxfs/vxfs_subr.c
index 1429f3ae1e8..5d318c44f85 100644
--- a/fs/freevxfs/vxfs_subr.c
+++ b/fs/freevxfs/vxfs_subr.c
@@ -44,7 +44,6 @@ static sector_t		vxfs_bmap(struct address_space *, sector_t);
 const struct address_space_operations vxfs_aops = {
         .readpage =             vxfs_readpage,
         .bmap =                 vxfs_bmap,
-        .sync_page =            block_sync_page,
 };
 
 inline void
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 9e3f68cc1bd..09e8d51eeb6 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -868,7 +868,6 @@ static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
 
         fc->bdi.name = "fuse";
         fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
-        fc->bdi.unplug_io_fn = default_unplug_io_fn;
         /* fuse does it's own writeback accounting */
         fc->bdi.capabilities = BDI_CAP_NO_ACCT_WB;
 
diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index 4f36f8832b9..2f87ad27efd 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
@@ -1116,7 +1116,6 @@ static const struct address_space_operations gfs2_writeback_aops = {
         .writepages = gfs2_writeback_writepages,
         .readpage = gfs2_readpage,
         .readpages = gfs2_readpages,
-        .sync_page = block_sync_page,
         .write_begin = gfs2_write_begin,
         .write_end = gfs2_write_end,
         .bmap = gfs2_bmap,
@@ -1132,7 +1131,6 @@ static const struct address_space_operations gfs2_ordered_aops = {
         .writepage = gfs2_ordered_writepage,
         .readpage = gfs2_readpage,
         .readpages = gfs2_readpages,
-        .sync_page = block_sync_page,
         .write_begin = gfs2_write_begin,
         .write_end = gfs2_write_end,
         .set_page_dirty = gfs2_set_page_dirty,
@@ -1150,7 +1148,6 @@ static const struct address_space_operations gfs2_jdata_aops = {
         .writepages = gfs2_jdata_writepages,
         .readpage = gfs2_readpage,
         .readpages = gfs2_readpages,
-        .sync_page = block_sync_page,
         .write_begin = gfs2_write_begin,
         .write_end = gfs2_write_end,
         .set_page_dirty = gfs2_set_page_dirty,
diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 939739c7b3f..a566331db4e 100644
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -94,7 +94,6 @@ static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wb
 const struct address_space_operations gfs2_meta_aops = {
         .writepage = gfs2_aspace_writepage,
         .releasepage = gfs2_releasepage,
-        .sync_page = block_sync_page,
 };
 
 /**
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index dffb4e99664..fff16c968e6 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -150,7 +150,6 @@ static int hfs_writepages(struct address_space *mapping,
 const struct address_space_operations hfs_btree_aops = {
         .readpage       = hfs_readpage,
         .writepage      = hfs_writepage,
-        .sync_page      = block_sync_page,
         .write_begin    = hfs_write_begin,
         .write_end      = generic_write_end,
         .bmap           = hfs_bmap,
@@ -160,7 +159,6 @@ const struct address_space_operations hfs_btree_aops = {
 const struct address_space_operations hfs_aops = {
         .readpage       = hfs_readpage,
         .writepage      = hfs_writepage,
-        .sync_page      = block_sync_page,
         .write_begin    = hfs_write_begin,
         .write_end      = generic_write_end,
         .bmap           = hfs_bmap,
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index a8df651747f..b248a6cfcad 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -146,7 +146,6 @@ static int hfsplus_writepages(struct address_space *mapping,
 const struct address_space_operations hfsplus_btree_aops = {
         .readpage       = hfsplus_readpage,
         .writepage      = hfsplus_writepage,
-        .sync_page      = block_sync_page,
         .write_begin    = hfsplus_write_begin,
         .write_end      = generic_write_end,
         .bmap           = hfsplus_bmap,
@@ -156,7 +155,6 @@ const struct address_space_operations hfsplus_btree_aops = {
 const struct address_space_operations hfsplus_aops = {
         .readpage       = hfsplus_readpage,
         .writepage      = hfsplus_writepage,
-        .sync_page      = block_sync_page,
         .write_begin    = hfsplus_write_begin,
         .write_end      = generic_write_end,
         .bmap           = hfsplus_bmap,
diff --git a/fs/hpfs/file.c b/fs/hpfs/file.c
index c0340887c7e..9e84257b3ad 100644
--- a/fs/hpfs/file.c
+++ b/fs/hpfs/file.c
@@ -120,7 +120,6 @@ static sector_t _hpfs_bmap(struct address_space *mapping, sector_t block)
 const struct address_space_operations hpfs_aops = {
         .readpage = hpfs_readpage,
         .writepage = hpfs_writepage,
-        .sync_page = block_sync_page,
         .write_begin = hpfs_write_begin,
         .write_end = generic_write_end,
         .bmap = _hpfs_bmap
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index a0f3833c0db..3db5ba4568f 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -1158,7 +1158,6 @@ static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
 
 static const struct address_space_operations isofs_aops = {
         .readpage = isofs_readpage,
-        .sync_page = block_sync_page,
         .bmap = _isofs_bmap
 };
 
diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index 9978803ceed..eddbb373209 100644
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -352,7 +352,6 @@ const struct address_space_operations jfs_aops = {
         .readpages      = jfs_readpages,
         .writepage      = jfs_writepage,
         .writepages     = jfs_writepages,
-        .sync_page      = block_sync_page,
         .write_begin    = jfs_write_begin,
         .write_end      = nobh_write_end,
         .bmap           = jfs_bmap,
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index 48b44bd8267..6740d34cd82 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -583,7 +583,6 @@ static void metapage_invalidatepage(struct page *page, unsigned long offset)
 const struct address_space_operations jfs_metapage_aops = {
         .readpage       = metapage_readpage,
         .writepage      = metapage_writepage,
-        .sync_page      = block_sync_page,
         .releasepage    = metapage_releasepage,
         .invalidatepage = metapage_invalidatepage,
         .set_page_dirty = __set_page_dirty_nobuffers,
diff --git a/fs/logfs/dev_bdev.c b/fs/logfs/dev_bdev.c
index 723bc5bca09..1adc8d455f0 100644
--- a/fs/logfs/dev_bdev.c
+++ b/fs/logfs/dev_bdev.c
@@ -39,7 +39,6 @@ static int sync_request(struct page *page, struct block_device *bdev, int rw)
         bio.bi_end_io = request_complete;
 
         submit_bio(rw, &bio);
-        generic_unplug_device(bdev_get_queue(bdev));
         wait_for_completion(&complete);
         return test_bit(BIO_UPTODATE, &bio.bi_flags) ? 0 : -EIO;
 }
@@ -168,7 +167,6 @@ static void bdev_writeseg(struct super_block *sb, u64 ofs, size_t len)
         }
         len = PAGE_ALIGN(len);
         __bdev_writeseg(sb, ofs, ofs >> PAGE_SHIFT, len >> PAGE_SHIFT);
-        generic_unplug_device(bdev_get_queue(logfs_super(sb)->s_bdev));
 }
 
 
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index ae0b83f476a..adcdc0a4e18 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -399,7 +399,6 @@ static sector_t minix_bmap(struct address_space *mapping, sector_t block)
 static const struct address_space_operations minix_aops = {
         .readpage = minix_readpage,
         .writepage = minix_writepage,
-        .sync_page = block_sync_page,
         .write_begin = minix_write_begin,
         .write_end = generic_write_end,
         .bmap = minix_bmap
diff --git a/fs/nilfs2/btnode.c b/fs/nilfs2/btnode.c
index 388e9e8f528..f4f1c08807e 100644
--- a/fs/nilfs2/btnode.c
+++ b/fs/nilfs2/btnode.c
@@ -40,14 +40,10 @@ void nilfs_btnode_cache_init_once(struct address_space *btnc)
         nilfs_mapping_init_once(btnc);
 }
 
-static const struct address_space_operations def_btnode_aops = {
-        .sync_page              = block_sync_page,
-};
-
 void nilfs_btnode_cache_init(struct address_space *btnc,
                              struct backing_dev_info *bdi)
 {
-        nilfs_mapping_init(btnc, bdi, &def_btnode_aops);
+        nilfs_mapping_init(btnc, bdi);
 }
 
 void nilfs_btnode_cache_clear(struct address_space *btnc)
diff --git a/fs/nilfs2/gcinode.c b/fs/nilfs2/gcinode.c
index caf9a6a3fb5..1c2a3e23f8b 100644
--- a/fs/nilfs2/gcinode.c
+++ b/fs/nilfs2/gcinode.c
@@ -49,7 +49,6 @@
 #include "ifile.h"
 
 static const struct address_space_operations def_gcinode_aops = {
-        .sync_page              = block_sync_page,
 };
 
 /*
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 2fd440d8d6b..c89d5d1ea7c 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -262,7 +262,6 @@ nilfs_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
 const struct address_space_operations nilfs_aops = {
         .writepage              = nilfs_writepage,
         .readpage               = nilfs_readpage,
-        .sync_page              = block_sync_page,
         .writepages             = nilfs_writepages,
         .set_page_dirty         = nilfs_set_page_dirty,
         .readpages              = nilfs_readpages,
diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index 6a0e2a189f6..3fdb61d79c9 100644
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -399,7 +399,6 @@ nilfs_mdt_write_page(struct page *page, struct writeback_control *wbc)
 
 static const struct address_space_operations def_mdt_aops = {
         .writepage              = nilfs_mdt_write_page,
-        .sync_page              = block_sync_page,
 };
 
 static const struct inode_operations def_mdt_iops;
@@ -438,10 +437,6 @@ void nilfs_mdt_set_entry_size(struct inode *inode, unsigned entry_size,
         mi->mi_first_entry_offset = DIV_ROUND_UP(header_size, entry_size);
 }
 
-static const struct address_space_operations shadow_map_aops = {
-        .sync_page              = block_sync_page,
-};
-
 /**
  * nilfs_mdt_setup_shadow_map - setup shadow map and bind it to metadata file
  * @inode: inode of the metadata file
@@ -455,9 +450,9 @@ int nilfs_mdt_setup_shadow_map(struct inode *inode,
 
         INIT_LIST_HEAD(&shadow->frozen_buffers);
         nilfs_mapping_init_once(&shadow->frozen_data);
-        nilfs_mapping_init(&shadow->frozen_data, bdi, &shadow_map_aops);
+        nilfs_mapping_init(&shadow->frozen_data, bdi);
         nilfs_mapping_init_once(&shadow->frozen_btnodes);
-        nilfs_mapping_init(&shadow->frozen_btnodes, bdi, &shadow_map_aops);
+        nilfs_mapping_init(&shadow->frozen_btnodes, bdi);
         mi->mi_shadow = shadow;
         return 0;
 }
diff --git a/fs/nilfs2/page.c b/fs/nilfs2/page.c
index 0c432416cfe..3da37cc5de3 100644
--- a/fs/nilfs2/page.c
+++ b/fs/nilfs2/page.c
@@ -506,15 +506,14 @@ void nilfs_mapping_init_once(struct address_space *mapping)
 }
 
 void nilfs_mapping_init(struct address_space *mapping,
-                        struct backing_dev_info *bdi,
-                        const struct address_space_operations *aops)
+                        struct backing_dev_info *bdi)
 {
         mapping->host = NULL;
         mapping->flags = 0;
         mapping_set_gfp_mask(mapping, GFP_NOFS);
         mapping->assoc_mapping = NULL;
         mapping->backing_dev_info = bdi;
-        mapping->a_ops = aops;
+        mapping->a_ops = NULL;
 }
 
 /*
diff --git a/fs/nilfs2/page.h b/fs/nilfs2/page.h
index 622df27cd89..ba4d6fd40b0 100644
--- a/fs/nilfs2/page.h
+++ b/fs/nilfs2/page.h
@@ -63,8 +63,7 @@ void nilfs_copy_back_pages(struct address_space *, struct address_space *);
 void nilfs_clear_dirty_pages(struct address_space *);
 void nilfs_mapping_init_once(struct address_space *mapping);
 void nilfs_mapping_init(struct address_space *mapping,
-                        struct backing_dev_info *bdi,
-                        const struct address_space_operations *aops);
+                        struct backing_dev_info *bdi);
 unsigned nilfs_page_count_clean_buffers(struct page *, unsigned, unsigned);
 unsigned long nilfs_find_uncommitted_extent(struct inode *inode,
                                             sector_t start_blk,
diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index c3c2c7ac902..0b1e885b8cf 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -1543,8 +1543,6 @@ err_out:
  */
 const struct address_space_operations ntfs_aops = {
         .readpage       = ntfs_readpage,        /* Fill page with data. */
-        .sync_page      = block_sync_page,      /* Currently, just unplugs the
-                                                   disk request queue. */
 #ifdef NTFS_RW
         .writepage      = ntfs_writepage,       /* Write dirty page to disk. */
 #endif /* NTFS_RW */
@@ -1560,8 +1558,6 @@ const struct address_space_operations ntfs_aops = {
  */
 const struct address_space_operations ntfs_mst_aops = {
         .readpage       = ntfs_readpage,        /* Fill page with data. */
-        .sync_page      = block_sync_page,      /* Currently, just unplugs the
-                                                   disk request queue. */
 #ifdef NTFS_RW
         .writepage      = ntfs_writepage,       /* Write dirty page to disk. */
         .set_page_dirty = __set_page_dirty_nobuffers,   /* Set the page dirty
diff --git a/fs/ntfs/compress.c b/fs/ntfs/compress.c
index 6551c7cbad9..ef9ed854255 100644
--- a/fs/ntfs/compress.c
+++ b/fs/ntfs/compress.c
@@ -698,8 +698,7 @@ lock_retry_remap:
                                         "uptodate! Unplugging the disk queue "
                                         "and rescheduling.");
                         get_bh(tbh);
-                        blk_run_address_space(mapping);
-                        schedule();
+                        io_schedule();
                         put_bh(tbh);
                         if (unlikely(!buffer_uptodate(tbh)))
                                 goto read_err;
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 1fbb0e20131..daea0359e97 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -2043,7 +2043,6 @@ const struct address_space_operations ocfs2_aops = {
         .write_begin            = ocfs2_write_begin,
         .write_end              = ocfs2_write_end,
         .bmap                   = ocfs2_bmap,
-        .sync_page              = block_sync_page,
         .direct_IO              = ocfs2_direct_IO,
         .invalidatepage         = ocfs2_invalidatepage,
         .releasepage            = ocfs2_releasepage,
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index b108e863d8f..1adab287bd2 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -367,11 +367,7 @@ static inline void o2hb_bio_wait_dec(struct o2hb_bio_wait_ctxt *wc,
 static void o2hb_wait_on_io(struct o2hb_region *reg,
                             struct o2hb_bio_wait_ctxt *wc)
 {
-        struct address_space *mapping = reg->hr_bdev->bd_inode->i_mapping;
-
-        blk_run_address_space(mapping);
         o2hb_bio_wait_dec(wc, 1);
-
         wait_for_completion(&wc->wc_io_complete);
 }
 
diff --git a/fs/omfs/file.c b/fs/omfs/file.c
index 8a6d34fa668..d738a7e493d 100644
--- a/fs/omfs/file.c
+++ b/fs/omfs/file.c
@@ -372,7 +372,6 @@ const struct address_space_operations omfs_aops = {
         .readpages = omfs_readpages,
         .writepage = omfs_writepage,
         .writepages = omfs_writepages,
-        .sync_page = block_sync_page,
         .write_begin = omfs_write_begin,
         .write_end = generic_write_end,
         .bmap = omfs_bmap,
diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index e63b4171d58..2b0646613f5 100644
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -335,7 +335,6 @@ static sector_t qnx4_bmap(struct address_space *mapping, sector_t block)
 static const struct address_space_operations qnx4_aops = {
         .readpage       = qnx4_readpage,
         .writepage      = qnx4_writepage,
-        .sync_page      = block_sync_page,
         .write_begin    = qnx4_write_begin,
         .write_end      = generic_write_end,
         .bmap           = qnx4_bmap
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 0bae036831e..03674675f88 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -3212,7 +3212,6 @@ const struct address_space_operations reiserfs_address_space_operations = {
         .readpages = reiserfs_readpages,
         .releasepage = reiserfs_releasepage,
         .invalidatepage = reiserfs_invalidatepage,
-        .sync_page = block_sync_page,
         .write_begin = reiserfs_write_begin,
         .write_end = reiserfs_write_end,
         .bmap = reiserfs_aop_bmap,
diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index 9ca66276315..fa8d43c92bb 100644
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -488,7 +488,6 @@ static sector_t sysv_bmap(struct address_space *mapping, sector_t block)
 const struct address_space_operations sysv_aops = {
         .readpage = sysv_readpage,
         .writepage = sysv_writepage,
-        .sync_page = block_sync_page,
         .write_begin = sysv_write_begin,
         .write_end = generic_write_end,
         .bmap = sysv_bmap
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index 6e11c2975dc..81368d4d4a2 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -1979,7 +1979,6 @@ static int ubifs_fill_super(struct super_block *sb, void *data, int silent)
          */
         c->bdi.name = "ubifs",
         c->bdi.capabilities = BDI_CAP_MAP_COPY;
-        c->bdi.unplug_io_fn = default_unplug_io_fn;
         err  = bdi_init(&c->bdi);
         if (err)
                 goto out_close;
diff --git a/fs/udf/file.c b/fs/udf/file.c
index 89c78486cbb..94e4553491c 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -98,7 +98,6 @@ static int udf_adinicb_write_end(struct file *file,
 const struct address_space_operations udf_adinicb_aops = {
         .readpage       = udf_adinicb_readpage,
         .writepage      = udf_adinicb_writepage,
-        .sync_page      = block_sync_page,
         .write_begin = simple_write_begin,
         .write_end = udf_adinicb_write_end,
 };
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index c6a2e782b97..fa96fc0fe12 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -133,7 +133,6 @@ static sector_t udf_bmap(struct address_space *mapping, sector_t block)
 const struct address_space_operations udf_aops = {
         .readpage       = udf_readpage,
         .writepage      = udf_writepage,
-        .sync_page      = block_sync_page,
         .write_begin            = udf_write_begin,
         .write_end              = generic_write_end,
         .bmap           = udf_bmap,
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 2b251f2093a..83b28444eb1 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -588,7 +588,6 @@ static sector_t ufs_bmap(struct address_space *mapping, sector_t block)
 const struct address_space_operations ufs_aops = {
         .readpage = ufs_readpage,
         .writepage = ufs_writepage,
-        .sync_page = block_sync_page,
         .write_begin = ufs_write_begin,
         .write_end = generic_write_end,
         .bmap = ufs_bmap
diff --git a/fs/ufs/truncate.c b/fs/ufs/truncate.c
index a58f9155fc9..ff0e79276f2 100644
--- a/fs/ufs/truncate.c
+++ b/fs/ufs/truncate.c
@@ -481,7 +481,7 @@ int ufs_truncate(struct inode *inode, loff_t old_i_size)
                         break;
                 if (IS_SYNC(inode) && (inode->i_state & I_DIRTY))
                         ufs_sync_inode (inode);
-                blk_run_address_space(inode->i_mapping);
+                blk_flush_plug(current);
                 yield();
         }
 
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index ec7bbb5645b..83c1c20d145 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -1495,7 +1495,6 @@ const struct address_space_operations xfs_address_space_operations = {
         .readpages              = xfs_vm_readpages,
         .writepage              = xfs_vm_writepage,
         .writepages             = xfs_vm_writepages,
-        .sync_page              = block_sync_page,
         .releasepage            = xfs_vm_releasepage,
         .invalidatepage         = xfs_vm_invalidatepage,
         .write_begin            = xfs_vm_write_begin,
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index ac1c7e8378d..4f8f53c4d42 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -991,7 +991,7 @@ xfs_buf_lock(
         if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))
                 xfs_log_force(bp->b_target->bt_mount, 0);
         if (atomic_read(&bp->b_io_remaining))
-                blk_run_address_space(bp->b_target->bt_mapping);
+                blk_flush_plug(current);
         down(&bp->b_sema);
         XB_SET_OWNER(bp);
 
@@ -1035,9 +1035,7 @@ xfs_buf_wait_unpin(
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 if (atomic_read(&bp->b_pin_count) == 0)
                         break;
-                if (atomic_read(&bp->b_io_remaining))
-                        blk_run_address_space(bp->b_target->bt_mapping);
-                schedule();
+                io_schedule();
         }
         remove_wait_queue(&bp->b_waiters, &wait);
         set_current_state(TASK_RUNNING);
@@ -1443,7 +1441,7 @@ xfs_buf_iowait(
         trace_xfs_buf_iowait(bp, _RET_IP_);
 
         if (atomic_read(&bp->b_io_remaining))
-                blk_run_address_space(bp->b_target->bt_mapping);
+                blk_flush_plug(current);
         wait_for_completion(&bp->b_iowait);
 
         trace_xfs_buf_iowait_done(bp, _RET_IP_);
@@ -1667,7 +1665,6 @@ xfs_mapping_buftarg(
         struct inode            *inode;
         struct address_space    *mapping;
         static const struct address_space_operations mapping_aops = {
-                .sync_page = block_sync_page,
                 .migratepage = fail_migrate_page,
         };
 
@@ -1948,7 +1945,7 @@ xfsbufd(
                         count++;
                 }
                 if (count)
-                        blk_run_address_space(target->bt_mapping);
+                        blk_flush_plug(current);
 
         } while (!kthread_should_stop());
 
@@ -1996,7 +1993,7 @@ xfs_flush_buftarg(
 
         if (wait) {
                 /* Expedite and wait for IO to complete. */
-                blk_run_address_space(target->bt_mapping);
+                blk_flush_plug(current);
                 while (!list_empty(&wait_list)) {
                         bp = list_first_entry(&wait_list, struct xfs_buf, b_list);