Merge branch 'master' of ssh://master.kernel.org/pub/scm/linux/kernel/git/kaber/nf-2.6

12 files changed, 427 insertions, 411 deletions

diff --git a/fs/xfs/linux-2.6/kmem.c b/fs/xfs/linux-2.6/kmem.c
index 666c9db48eb6..a907de565db3 100644
--- a/fs/xfs/linux-2.6/kmem.c
+++ b/fs/xfs/linux-2.6/kmem.c
@@ -23,6 +23,7 @@
 #include <linux/backing-dev.h>
 #include "time.h"
 #include "kmem.h"
+#include "xfs_message.h"
 
 /*
  * Greedy allocation.  May fail and may return vmalloced memory.
@@ -56,8 +57,8 @@ kmem_alloc(size_t size, unsigned int __nocast flags)
                 if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP)))
                         return ptr;
                 if (!(++retries % 100))
-                        printk(KERN_ERR "XFS: possible memory allocation "
-                                        "deadlock in %s (mode:0x%x)\n",
+                        xfs_err(NULL,
+                "possible memory allocation deadlock in %s (mode:0x%x)",
                                         __func__, lflags);
                 congestion_wait(BLK_RW_ASYNC, HZ/50);
         } while (1);
@@ -112,8 +113,8 @@ kmem_zone_alloc(kmem_zone_t *zone, unsigned int __nocast flags)
                 if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP)))
                         return ptr;
                 if (!(++retries % 100))
-                        printk(KERN_ERR "XFS: possible memory allocation "
-                                        "deadlock in %s (mode:0x%x)\n",
+                        xfs_err(NULL,
+                "possible memory allocation deadlock in %s (mode:0x%x)",
                                         __func__, lflags);
                 congestion_wait(BLK_RW_ASYNC, HZ/50);
         } while (1);
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index ec7bbb5645b6..52dbd14260ba 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -413,8 +413,7 @@ xfs_submit_ioend_bio(
         if (xfs_ioend_new_eof(ioend))
                 xfs_mark_inode_dirty(XFS_I(ioend->io_inode));
 
-        submit_bio(wbc->sync_mode == WB_SYNC_ALL ?
-                   WRITE_SYNC_PLUG : WRITE, bio);
+        submit_bio(wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE, bio);
 }
 
 STATIC struct bio *
@@ -854,7 +853,7 @@ xfs_aops_discard_page(
         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
                 goto out_invalidate;
 
-        xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
+        xfs_alert(ip->i_mount,
                 "page discard on page %p, inode 0x%llx, offset %llu.",
                         page, ip->i_ino, offset);
 
@@ -872,7 +871,7 @@ xfs_aops_discard_page(
                 if (error) {
                         /* something screwed, just bail */
                         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
-                                xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
+                                xfs_alert(ip->i_mount,
                         "page discard unable to remove delalloc mapping.");
                         }
                         break;
@@ -1411,7 +1410,7 @@ xfs_vm_write_failed(
                 if (error) {
                         /* something screwed, just bail */
                         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
-                                xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
+                                xfs_alert(ip->i_mount,
                         "xfs_vm_write_failed: unable to clean up ino %lld",
                                                 ip->i_ino);
                         }
@@ -1495,7 +1494,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 f83a4c830a65..596bb2c9de42 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -94,75 +94,6 @@ xfs_buf_vmap_len(
 }
 
 /*
- *      Page Region interfaces.
- *
- *      For pages in filesystems where the blocksize is smaller than the
- *      pagesize, we use the page->private field (long) to hold a bitmap
- *      of uptodate regions within the page.
- *
- *      Each such region is "bytes per page / bits per long" bytes long.
- *
- *      NBPPR == number-of-bytes-per-page-region
- *      BTOPR == bytes-to-page-region (rounded up)
- *      BTOPRT == bytes-to-page-region-truncated (rounded down)
- */
-#if (BITS_PER_LONG == 32)
-#define PRSHIFT         (PAGE_CACHE_SHIFT - 5)  /* (32 == 1<<5) */
-#elif (BITS_PER_LONG == 64)
-#define PRSHIFT         (PAGE_CACHE_SHIFT - 6)  /* (64 == 1<<6) */
-#else
-#error BITS_PER_LONG must be 32 or 64
-#endif
-#define NBPPR           (PAGE_CACHE_SIZE/BITS_PER_LONG)
-#define BTOPR(b)        (((unsigned int)(b) + (NBPPR - 1)) >> PRSHIFT)
-#define BTOPRT(b)       (((unsigned int)(b) >> PRSHIFT))
-
-STATIC unsigned long
-page_region_mask(
-        size_t          offset,
-        size_t          length)
-{
-        unsigned long   mask;
-        int             first, final;
-
-        first = BTOPR(offset);
-        final = BTOPRT(offset + length - 1);
-        first = min(first, final);
-
-        mask = ~0UL;
-        mask <<= BITS_PER_LONG - (final - first);
-        mask >>= BITS_PER_LONG - (final);
-
-        ASSERT(offset + length <= PAGE_CACHE_SIZE);
-        ASSERT((final - first) < BITS_PER_LONG && (final - first) >= 0);
-
-        return mask;
-}
-
-STATIC void
-set_page_region(
-        struct page     *page,
-        size_t          offset,
-        size_t          length)
-{
-        set_page_private(page,
-                page_private(page) | page_region_mask(offset, length));
-        if (page_private(page) == ~0UL)
-                SetPageUptodate(page);
-}
-
-STATIC int
-test_page_region(
-        struct page     *page,
-        size_t          offset,
-        size_t          length)
-{
-        unsigned long   mask = page_region_mask(offset, length);
-
-        return (mask && (page_private(page) & mask) == mask);
-}
-
-/*
  * xfs_buf_lru_add - add a buffer to the LRU.
  *
  * The LRU takes a new reference to the buffer so that it will only be freed
@@ -332,7 +263,7 @@ xfs_buf_free(
 
         ASSERT(list_empty(&bp->b_lru));
 
-        if (bp->b_flags & (_XBF_PAGE_CACHE|_XBF_PAGES)) {
+        if (bp->b_flags & _XBF_PAGES) {
                 uint            i;
 
                 if (xfs_buf_is_vmapped(bp))
@@ -342,25 +273,22 @@ xfs_buf_free(
                 for (i = 0; i < bp->b_page_count; i++) {
                         struct page     *page = bp->b_pages[i];
 
-                        if (bp->b_flags & _XBF_PAGE_CACHE)
-                                ASSERT(!PagePrivate(page));
-                        page_cache_release(page);
+                        __free_page(page);
                 }
-        }
+        } else if (bp->b_flags & _XBF_KMEM)
+                kmem_free(bp->b_addr);
         _xfs_buf_free_pages(bp);
         xfs_buf_deallocate(bp);
 }
 
 /*
- *      Finds all pages for buffer in question and builds it's page list.
+ * Allocates all the pages for buffer in question and builds it's page list.
  */
 STATIC int
-_xfs_buf_lookup_pages(
+xfs_buf_allocate_memory(
         xfs_buf_t               *bp,
         uint                    flags)
 {
-        struct address_space    *mapping = bp->b_target->bt_mapping;
-        size_t                  blocksize = bp->b_target->bt_bsize;
         size_t                  size = bp->b_count_desired;
         size_t                  nbytes, offset;
         gfp_t                   gfp_mask = xb_to_gfp(flags);
@@ -369,29 +297,55 @@ _xfs_buf_lookup_pages(
         xfs_off_t               end;
         int                     error;
 
+        /*
+         * for buffers that are contained within a single page, just allocate
+         * the memory from the heap - there's no need for the complexity of
+         * page arrays to keep allocation down to order 0.
+         */
+        if (bp->b_buffer_length < PAGE_SIZE) {
+                bp->b_addr = kmem_alloc(bp->b_buffer_length, xb_to_km(flags));
+                if (!bp->b_addr) {
+                        /* low memory - use alloc_page loop instead */
+                        goto use_alloc_page;
+                }
+
+                if (((unsigned long)(bp->b_addr + bp->b_buffer_length - 1) &
+                                                                PAGE_MASK) !=
+                    ((unsigned long)bp->b_addr & PAGE_MASK)) {
+                        /* b_addr spans two pages - use alloc_page instead */
+                        kmem_free(bp->b_addr);
+                        bp->b_addr = NULL;
+                        goto use_alloc_page;
+                }
+                bp->b_offset = offset_in_page(bp->b_addr);
+                bp->b_pages = bp->b_page_array;
+                bp->b_pages[0] = virt_to_page(bp->b_addr);
+                bp->b_page_count = 1;
+                bp->b_flags |= XBF_MAPPED | _XBF_KMEM;
+                return 0;
+        }
+
+use_alloc_page:
         end = bp->b_file_offset + bp->b_buffer_length;
         page_count = xfs_buf_btoc(end) - xfs_buf_btoct(bp->b_file_offset);
-
         error = _xfs_buf_get_pages(bp, page_count, flags);
         if (unlikely(error))
                 return error;
-        bp->b_flags |= _XBF_PAGE_CACHE;
 
         offset = bp->b_offset;
-        first = bp->b_file_offset >> PAGE_CACHE_SHIFT;
+        first = bp->b_file_offset >> PAGE_SHIFT;
+        bp->b_flags |= _XBF_PAGES;
 
         for (i = 0; i < bp->b_page_count; i++) {
                 struct page     *page;
                 uint            retries = 0;
-
-              retry:
-                page = find_or_create_page(mapping, first + i, gfp_mask);
+retry:
+                page = alloc_page(gfp_mask);
                 if (unlikely(page == NULL)) {
                         if (flags & XBF_READ_AHEAD) {
                                 bp->b_page_count = i;
-                                for (i = 0; i < bp->b_page_count; i++)
-                                        unlock_page(bp->b_pages[i]);
-                                return -ENOMEM;
+                                error = ENOMEM;
+                                goto out_free_pages;
                         }
 
                         /*
@@ -401,9 +355,8 @@ _xfs_buf_lookup_pages(
                          * handle buffer allocation failures we can't do much.
                          */
                         if (!(++retries % 100))
-                                printk(KERN_ERR
-                                        "XFS: possible memory allocation "
-                                        "deadlock in %s (mode:0x%x)\n",
+                                xfs_err(NULL,
+                "possible memory allocation deadlock in %s (mode:0x%x)",
                                         __func__, gfp_mask);
 
                         XFS_STATS_INC(xb_page_retries);
@@ -413,33 +366,16 @@ _xfs_buf_lookup_pages(
 
                 XFS_STATS_INC(xb_page_found);
 
-                nbytes = min_t(size_t, size, PAGE_CACHE_SIZE - offset);
+                nbytes = min_t(size_t, size, PAGE_SIZE - offset);
                 size -= nbytes;
-
-                ASSERT(!PagePrivate(page));
-                if (!PageUptodate(page)) {
-                        page_count--;
-                        if (blocksize >= PAGE_CACHE_SIZE) {
-                                if (flags & XBF_READ)
-                                        bp->b_flags |= _XBF_PAGE_LOCKED;
-                        } else if (!PagePrivate(page)) {
-                                if (test_page_region(page, offset, nbytes))
-                                        page_count++;
-                        }
-                }
-
                 bp->b_pages[i] = page;
                 offset = 0;
         }
+        return 0;
 
-        if (!(bp->b_flags & _XBF_PAGE_LOCKED)) {
-                for (i = 0; i < bp->b_page_count; i++)
-                        unlock_page(bp->b_pages[i]);
-        }
-
-        if (page_count == bp->b_page_count)
-                bp->b_flags |= XBF_DONE;
-
+out_free_pages:
+        for (i = 0; i < bp->b_page_count; i++)
+                __free_page(bp->b_pages[i]);
         return error;
 }
 
@@ -451,14 +387,23 @@ _xfs_buf_map_pages(
         xfs_buf_t               *bp,
         uint                    flags)
 {
-        /* A single page buffer is always mappable */
+        ASSERT(bp->b_flags & _XBF_PAGES);
         if (bp->b_page_count == 1) {
+                /* A single page buffer is always mappable */
                 bp->b_addr = page_address(bp->b_pages[0]) + bp->b_offset;
                 bp->b_flags |= XBF_MAPPED;
         } else if (flags & XBF_MAPPED) {
-                bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
-                                        -1, PAGE_KERNEL);
-                if (unlikely(bp->b_addr == NULL))
+                int retried = 0;
+
+                do {
+                        bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
+                                                -1, PAGE_KERNEL);
+                        if (bp->b_addr)
+                                break;
+                        vm_unmap_aliases();
+                } while (retried++ <= 1);
+
+                if (!bp->b_addr)
                         return -ENOMEM;
                 bp->b_addr += bp->b_offset;
                 bp->b_flags |= XBF_MAPPED;
@@ -569,9 +514,14 @@ found:
                 }
         }
 
+        /*
+         * if the buffer is stale, clear all the external state associated with
+         * it. We need to keep flags such as how we allocated the buffer memory
+         * intact here.
+         */
         if (bp->b_flags & XBF_STALE) {
                 ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0);
-                bp->b_flags &= XBF_MAPPED;
+                bp->b_flags &= XBF_MAPPED | _XBF_KMEM | _XBF_PAGES;
         }
 
         trace_xfs_buf_find(bp, flags, _RET_IP_);
@@ -592,7 +542,7 @@ xfs_buf_get(
         xfs_buf_flags_t         flags)
 {
         xfs_buf_t               *bp, *new_bp;
-        int                     error = 0, i;
+        int                     error = 0;
 
         new_bp = xfs_buf_allocate(flags);
         if (unlikely(!new_bp))
@@ -600,7 +550,7 @@ xfs_buf_get(
 
         bp = _xfs_buf_find(target, ioff, isize, flags, new_bp);
         if (bp == new_bp) {
-                error = _xfs_buf_lookup_pages(bp, flags);
+                error = xfs_buf_allocate_memory(bp, flags);
                 if (error)
                         goto no_buffer;
         } else {
@@ -609,14 +559,11 @@ xfs_buf_get(
                         return NULL;
         }
 
-        for (i = 0; i < bp->b_page_count; i++)
-                mark_page_accessed(bp->b_pages[i]);
-
         if (!(bp->b_flags & XBF_MAPPED)) {
                 error = _xfs_buf_map_pages(bp, flags);
                 if (unlikely(error)) {
-                        printk(KERN_WARNING "%s: failed to map pages\n",
-                                        __func__);
+                        xfs_warn(target->bt_mount,
+                                "%s: failed to map pages\n", __func__);
                         goto no_buffer;
                 }
         }
@@ -712,8 +659,7 @@ xfs_buf_readahead(
 {
         struct backing_dev_info *bdi;
 
-        bdi = target->bt_mapping->backing_dev_info;
-        if (bdi_read_congested(bdi))
+        if (bdi_read_congested(target->bt_bdi))
                 return;
 
         xfs_buf_read(target, ioff, isize,
@@ -791,10 +737,10 @@ xfs_buf_associate_memory(
         size_t                  buflen;
         int                     page_count;
 
-        pageaddr = (unsigned long)mem & PAGE_CACHE_MASK;
+        pageaddr = (unsigned long)mem & PAGE_MASK;
         offset = (unsigned long)mem - pageaddr;
-        buflen = PAGE_CACHE_ALIGN(len + offset);
-        page_count = buflen >> PAGE_CACHE_SHIFT;
+        buflen = PAGE_ALIGN(len + offset);
+        page_count = buflen >> PAGE_SHIFT;
 
         /* Free any previous set of page pointers */
         if (bp->b_pages)
@@ -811,13 +757,12 @@ xfs_buf_associate_memory(
 
         for (i = 0; i < bp->b_page_count; i++) {
                 bp->b_pages[i] = mem_to_page((void *)pageaddr);
-                pageaddr += PAGE_CACHE_SIZE;
+                pageaddr += PAGE_SIZE;
         }
 
         bp->b_count_desired = len;
         bp->b_buffer_length = buflen;
         bp->b_flags |= XBF_MAPPED;
-        bp->b_flags &= ~_XBF_PAGE_LOCKED;
 
         return 0;
 }
@@ -850,8 +795,8 @@ xfs_buf_get_uncached(
 
         error = _xfs_buf_map_pages(bp, XBF_MAPPED);
         if (unlikely(error)) {
-                printk(KERN_WARNING "%s: failed to map pages\n",
-                                __func__);
+                xfs_warn(target->bt_mount,
+                        "%s: failed to map pages\n", __func__);
                 goto fail_free_mem;
         }
 
@@ -924,20 +869,7 @@ xfs_buf_rele(
 
 
 /*
- *      Mutual exclusion on buffers.  Locking model:
- *
- *      Buffers associated with inodes for which buffer locking
- *      is not enabled are not protected by semaphores, and are
- *      assumed to be exclusively owned by the caller.  There is a
- *      spinlock in the buffer, used by the caller when concurrent
- *      access is possible.
- */
-
-/*
- *      Locks a buffer object, if it is not already locked.  Note that this in
- *      no way locks the underlying pages, so it is only useful for
- *      synchronizing concurrent use of buffer objects, not for synchronizing
- *      independent access to the underlying pages.
+ *      Lock a buffer object, if it is not already locked.
  *
  *      If we come across a stale, pinned, locked buffer, we know that we are
  *      being asked to lock a buffer that has been reallocated. Because it is
@@ -971,10 +903,7 @@ xfs_buf_lock_value(
 }
 
 /*
- *      Locks a buffer object.
- *      Note that this in no way locks the underlying pages, so it is only
- *      useful for synchronizing concurrent use of buffer objects, not for
- *      synchronizing independent access to the underlying pages.
+ *      Lock a buffer object.
  *
  *      If we come across a stale, pinned, locked buffer, we know that we
  *      are being asked to lock a buffer that has been reallocated. Because
@@ -991,7 +920,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 +964,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);
@@ -1249,10 +1176,8 @@ _xfs_buf_ioend(
         xfs_buf_t               *bp,
         int                     schedule)
 {
-        if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
-                bp->b_flags &= ~_XBF_PAGE_LOCKED;
+        if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
                 xfs_buf_ioend(bp, schedule);
-        }
 }
 
 STATIC void
@@ -1261,35 +1186,12 @@ xfs_buf_bio_end_io(
         int                     error)
 {
         xfs_buf_t               *bp = (xfs_buf_t *)bio->bi_private;
-        unsigned int            blocksize = bp->b_target->bt_bsize;
-        struct bio_vec          *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
 
         xfs_buf_ioerror(bp, -error);
 
         if (!error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
                 invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
 
-        do {
-                struct page     *page = bvec->bv_page;
-
-                ASSERT(!PagePrivate(page));
-                if (unlikely(bp->b_error)) {
-                        if (bp->b_flags & XBF_READ)
-                                ClearPageUptodate(page);
-                } else if (blocksize >= PAGE_CACHE_SIZE) {
-                        SetPageUptodate(page);
-                } else if (!PagePrivate(page) &&
-                                (bp->b_flags & _XBF_PAGE_CACHE)) {
-                        set_page_region(page, bvec->bv_offset, bvec->bv_len);
-                }
-
-                if (--bvec >= bio->bi_io_vec)
-                        prefetchw(&bvec->bv_page->flags);
-
-                if (bp->b_flags & _XBF_PAGE_LOCKED)
-                        unlock_page(page);
-        } while (bvec >= bio->bi_io_vec);
-
         _xfs_buf_ioend(bp, 1);
         bio_put(bio);
 }
@@ -1303,7 +1205,6 @@ _xfs_buf_ioapply(
         int                     offset = bp->b_offset;
         int                     size = bp->b_count_desired;
         sector_t                sector = bp->b_bn;
-        unsigned int            blocksize = bp->b_target->bt_bsize;
 
         total_nr_pages = bp->b_page_count;
         map_i = 0;
@@ -1324,29 +1225,6 @@ _xfs_buf_ioapply(
                      (bp->b_flags & XBF_READ_AHEAD) ? READA : READ;
         }
 
-        /* Special code path for reading a sub page size buffer in --
-         * we populate up the whole page, and hence the other metadata
-         * in the same page.  This optimization is only valid when the
-         * filesystem block size is not smaller than the page size.
-         */
-        if ((bp->b_buffer_length < PAGE_CACHE_SIZE) &&
-            ((bp->b_flags & (XBF_READ|_XBF_PAGE_LOCKED)) ==
-              (XBF_READ|_XBF_PAGE_LOCKED)) &&
-            (blocksize >= PAGE_CACHE_SIZE)) {
-                bio = bio_alloc(GFP_NOIO, 1);
-
-                bio->bi_bdev = bp->b_target->bt_bdev;
-                bio->bi_sector = sector - (offset >> BBSHIFT);
-                bio->bi_end_io = xfs_buf_bio_end_io;
-                bio->bi_private = bp;
-
-                bio_add_page(bio, bp->b_pages[0], PAGE_CACHE_SIZE, 0);
-                size = 0;
-
-                atomic_inc(&bp->b_io_remaining);
-
-                goto submit_io;
-        }
 
 next_chunk:
         atomic_inc(&bp->b_io_remaining);
@@ -1360,8 +1238,9 @@ next_chunk:
         bio->bi_end_io = xfs_buf_bio_end_io;
         bio->bi_private = bp;
 
+
         for (; size && nr_pages; nr_pages--, map_i++) {
-                int     rbytes, nbytes = PAGE_CACHE_SIZE - offset;
+                int     rbytes, nbytes = PAGE_SIZE - offset;
 
                 if (nbytes > size)
                         nbytes = size;
@@ -1376,7 +1255,6 @@ next_chunk:
                 total_nr_pages--;
         }
 
-submit_io:
         if (likely(bio->bi_size)) {
                 if (xfs_buf_is_vmapped(bp)) {
                         flush_kernel_vmap_range(bp->b_addr,
@@ -1386,18 +1264,7 @@ submit_io:
                 if (size)
                         goto next_chunk;
         } else {
-                /*
-                 * if we get here, no pages were added to the bio. However,
-                 * we can't just error out here - if the pages are locked then
-                 * we have to unlock them otherwise we can hang on a later
-                 * access to the page.
-                 */
                 xfs_buf_ioerror(bp, EIO);
-                if (bp->b_flags & _XBF_PAGE_LOCKED) {
-                        int i;
-                        for (i = 0; i < bp->b_page_count; i++)
-                                unlock_page(bp->b_pages[i]);
-                }
                 bio_put(bio);
         }
 }
@@ -1443,7 +1310,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_);
@@ -1461,8 +1328,8 @@ xfs_buf_offset(
                 return XFS_BUF_PTR(bp) + offset;
 
         offset += bp->b_offset;
-        page = bp->b_pages[offset >> PAGE_CACHE_SHIFT];
-        return (xfs_caddr_t)page_address(page) + (offset & (PAGE_CACHE_SIZE-1));
+        page = bp->b_pages[offset >> PAGE_SHIFT];
+        return (xfs_caddr_t)page_address(page) + (offset & (PAGE_SIZE-1));
 }
 
 /*
@@ -1484,9 +1351,9 @@ xfs_buf_iomove(
                 page = bp->b_pages[xfs_buf_btoct(boff + bp->b_offset)];
                 cpoff = xfs_buf_poff(boff + bp->b_offset);
                 csize = min_t(size_t,
-                              PAGE_CACHE_SIZE-cpoff, bp->b_count_desired-boff);
+                              PAGE_SIZE-cpoff, bp->b_count_desired-boff);
 
-                ASSERT(((csize + cpoff) <= PAGE_CACHE_SIZE));
+                ASSERT(((csize + cpoff) <= PAGE_SIZE));
 
                 switch (mode) {
                 case XBRW_ZERO:
@@ -1599,7 +1466,6 @@ xfs_free_buftarg(
         xfs_flush_buftarg(btp, 1);
         if (mp->m_flags & XFS_MOUNT_BARRIER)
                 xfs_blkdev_issue_flush(btp);
-        iput(btp->bt_mapping->host);
 
         kthread_stop(btp->bt_task);
         kmem_free(btp);
@@ -1617,21 +1483,12 @@ xfs_setsize_buftarg_flags(
         btp->bt_smask = sectorsize - 1;
 
         if (set_blocksize(btp->bt_bdev, sectorsize)) {
-                printk(KERN_WARNING
-                        "XFS: Cannot set_blocksize to %u on device %s\n",
+                xfs_warn(btp->bt_mount,
+                        "Cannot set_blocksize to %u on device %s\n",
                         sectorsize, XFS_BUFTARG_NAME(btp));
                 return EINVAL;
         }
 
-        if (verbose &&
-            (PAGE_CACHE_SIZE / BITS_PER_LONG) > sectorsize) {
-                printk(KERN_WARNING
-                        "XFS: %u byte sectors in use on device %s.  "
-                        "This is suboptimal; %u or greater is ideal.\n",
-                        sectorsize, XFS_BUFTARG_NAME(btp),
-                        (unsigned int)PAGE_CACHE_SIZE / BITS_PER_LONG);
-        }
-
         return 0;
 }
 
@@ -1646,7 +1503,7 @@ xfs_setsize_buftarg_early(
         struct block_device     *bdev)
 {
         return xfs_setsize_buftarg_flags(btp,
-                        PAGE_CACHE_SIZE, bdev_logical_block_size(bdev), 0);
+                        PAGE_SIZE, bdev_logical_block_size(bdev), 0);
 }
 
 int
@@ -1659,41 +1516,6 @@ xfs_setsize_buftarg(
 }
 
 STATIC int
-xfs_mapping_buftarg(
-        xfs_buftarg_t           *btp,
-        struct block_device     *bdev)
-{
-        struct backing_dev_info *bdi;
-        struct inode            *inode;
-        struct address_space    *mapping;
-        static const struct address_space_operations mapping_aops = {
-                .sync_page = block_sync_page,
-                .migratepage = fail_migrate_page,
-        };
-
-        inode = new_inode(bdev->bd_inode->i_sb);
-        if (!inode) {
-                printk(KERN_WARNING
-                        "XFS: Cannot allocate mapping inode for device %s\n",
-                        XFS_BUFTARG_NAME(btp));
-                return ENOMEM;
-        }
-        inode->i_ino = get_next_ino();
-        inode->i_mode = S_IFBLK;
-        inode->i_bdev = bdev;
-        inode->i_rdev = bdev->bd_dev;
-        bdi = blk_get_backing_dev_info(bdev);
-        if (!bdi)
-                bdi = &default_backing_dev_info;
-        mapping = &inode->i_data;
-        mapping->a_ops = &mapping_aops;
-        mapping->backing_dev_info = bdi;
-        mapping_set_gfp_mask(mapping, GFP_NOFS);
-        btp->bt_mapping = mapping;
-        return 0;
-}
-
-STATIC int
 xfs_alloc_delwrite_queue(
         xfs_buftarg_t           *btp,
         const char              *fsname)
@@ -1721,12 +1543,14 @@ xfs_alloc_buftarg(
         btp->bt_mount = mp;
         btp->bt_dev =  bdev->bd_dev;
         btp->bt_bdev = bdev;
+        btp->bt_bdi = blk_get_backing_dev_info(bdev);
+        if (!btp->bt_bdi)
+                goto error;
+
         INIT_LIST_HEAD(&btp->bt_lru);
         spin_lock_init(&btp->bt_lru_lock);
         if (xfs_setsize_buftarg_early(btp, bdev))
                 goto error;
-        if (xfs_mapping_buftarg(btp, bdev))
-                goto error;
         if (xfs_alloc_delwrite_queue(btp, fsname))
                 goto error;
         btp->bt_shrinker.shrink = xfs_buftarg_shrink;
@@ -1948,7 +1772,7 @@ xfsbufd(
                         count++;
                 }
                 if (count)
-                        blk_run_address_space(target->bt_mapping);
+                        blk_flush_plug(current);
 
         } while (!kthread_should_stop());
 
@@ -1996,7 +1820,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);
 
diff --git a/fs/xfs/linux-2.6/xfs_buf.h b/fs/xfs/linux-2.6/xfs_buf.h
index cbe65950e524..a9a1c4512645 100644
--- a/fs/xfs/linux-2.6/xfs_buf.h
+++ b/fs/xfs/linux-2.6/xfs_buf.h
@@ -61,30 +61,11 @@ typedef enum {
 #define XBF_DONT_BLOCK  (1 << 16)/* do not block in current thread */
 
 /* flags used only internally */
-#define _XBF_PAGE_CACHE (1 << 17)/* backed by pagecache */
 #define _XBF_PAGES      (1 << 18)/* backed by refcounted pages */
 #define _XBF_RUN_QUEUES (1 << 19)/* run block device task queue */
+#define _XBF_KMEM       (1 << 20)/* backed by heap memory */
 #define _XBF_DELWRI_Q   (1 << 21)/* buffer on delwri queue */
 
-/*
- * Special flag for supporting metadata blocks smaller than a FSB.
- *
- * In this case we can have multiple xfs_buf_t on a single page and
- * need to lock out concurrent xfs_buf_t readers as they only
- * serialise access to the buffer.
- *
- * If the FSB size >= PAGE_CACHE_SIZE case, we have no serialisation
- * between reads of the page. Hence we can have one thread read the
- * page and modify it, but then race with another thread that thinks
- * the page is not up-to-date and hence reads it again.
- *
- * The result is that the first modifcation to the page is lost.
- * This sort of AGF/AGI reading race can happen when unlinking inodes
- * that require truncation and results in the AGI unlinked list
- * modifications being lost.
- */
-#define _XBF_PAGE_LOCKED        (1 << 22)
-
 typedef unsigned int xfs_buf_flags_t;
 
 #define XFS_BUF_FLAGS \
@@ -100,12 +81,10 @@ typedef unsigned int xfs_buf_flags_t;
         { XBF_LOCK,             "LOCK" },       /* should never be set */\
         { XBF_TRYLOCK,          "TRYLOCK" },    /* ditto */\
         { XBF_DONT_BLOCK,       "DONT_BLOCK" }, /* ditto */\
-        { _XBF_PAGE_CACHE,      "PAGE_CACHE" }, \
         { _XBF_PAGES,           "PAGES" }, \
         { _XBF_RUN_QUEUES,      "RUN_QUEUES" }, \
-        { _XBF_DELWRI_Q,        "DELWRI_Q" }, \
-        { _XBF_PAGE_LOCKED,     "PAGE_LOCKED" }
-
+        { _XBF_KMEM,            "KMEM" }, \
+        { _XBF_DELWRI_Q,        "DELWRI_Q" }
 
 typedef enum {
         XBT_FORCE_SLEEP = 0,
@@ -120,7 +99,7 @@ typedef struct xfs_bufhash {
 typedef struct xfs_buftarg {
         dev_t                   bt_dev;
         struct block_device     *bt_bdev;
-        struct address_space    *bt_mapping;
+        struct backing_dev_info *bt_bdi;
         struct xfs_mount        *bt_mount;
         unsigned int            bt_bsize;
         unsigned int            bt_sshift;
@@ -139,17 +118,6 @@ typedef struct xfs_buftarg {
         unsigned int            bt_lru_nr;
 } xfs_buftarg_t;
 
-/*
- *      xfs_buf_t:  Buffer structure for pagecache-based buffers
- *
- * This buffer structure is used by the pagecache buffer management routines
- * to refer to an assembly of pages forming a logical buffer.
- *
- * The buffer structure is used on a temporary basis only, and discarded when
- * released.  The real data storage is recorded in the pagecache. Buffers are
- * hashed to the block device on which the file system resides.
- */
-
 struct xfs_buf;
 typedef void (*xfs_buf_iodone_t)(struct xfs_buf *);
 
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index a55c1b46b219..52aadfbed132 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -896,6 +896,7 @@ xfs_file_fallocate(
         xfs_flock64_t   bf;
         xfs_inode_t     *ip = XFS_I(inode);
         int             cmd = XFS_IOC_RESVSP;
+        int             attr_flags = XFS_ATTR_NOLOCK;
 
         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
                 return -EOPNOTSUPP;
@@ -918,7 +919,10 @@ xfs_file_fallocate(
                         goto out_unlock;
         }
 
-        error = -xfs_change_file_space(ip, cmd, &bf, 0, XFS_ATTR_NOLOCK);
+        if (file->f_flags & O_DSYNC)
+                attr_flags |= XFS_ATTR_SYNC;
+
+        error = -xfs_change_file_space(ip, cmd, &bf, 0, attr_flags);
         if (error)
                 goto out_unlock;
 
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 0ca0e3c024d7..acca2c5ca3fa 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -624,6 +624,10 @@ xfs_ioc_space(
 
         if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
                 attr_flags |= XFS_ATTR_NONBLOCK;
+
+        if (filp->f_flags & O_DSYNC)
+                attr_flags |= XFS_ATTR_SYNC;
+
         if (ioflags & IO_INVIS)
                 attr_flags |= XFS_ATTR_DMI;
 
diff --git a/fs/xfs/linux-2.6/xfs_linux.h b/fs/xfs/linux-2.6/xfs_linux.h
index 096494997747..244be9cbfe78 100644
--- a/fs/xfs/linux-2.6/xfs_linux.h
+++ b/fs/xfs/linux-2.6/xfs_linux.h
@@ -39,7 +39,6 @@
 #include <mrlock.h>
 #include <time.h>
 
-#include <support/debug.h>
 #include <support/uuid.h>
 
 #include <linux/semaphore.h>
@@ -86,6 +85,7 @@
 #include <xfs_aops.h>
 #include <xfs_super.h>
 #include <xfs_buf.h>
+#include <xfs_message.h>
 
 /*
  * Feature macros (disable/enable)
@@ -280,4 +280,25 @@ static inline __uint64_t howmany_64(__uint64_t x, __uint32_t y)
 #define __arch_pack
 #endif
 
+#define ASSERT_ALWAYS(expr)     \
+        (unlikely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
+
+#ifndef DEBUG
+#define ASSERT(expr)    ((void)0)
+
+#ifndef STATIC
+# define STATIC static noinline
+#endif
+
+#else /* DEBUG */
+
+#define ASSERT(expr)    \
+        (unlikely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
+
+#ifndef STATIC
+# define STATIC noinline
+#endif
+
+#endif /* DEBUG */
+
 #endif /* __XFS_LINUX__ */
diff --git a/fs/xfs/linux-2.6/xfs_message.c b/fs/xfs/linux-2.6/xfs_message.c
new file mode 100644
index 000000000000..508e06fd7d1e
--- /dev/null
+++ b/fs/xfs/linux-2.6/xfs_message.c
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2011 Red Hat, Inc.  All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "xfs.h"
+#include "xfs_fs.h"
+#include "xfs_types.h"
+#include "xfs_log.h"
+#include "xfs_inum.h"
+#include "xfs_trans.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
+#include "xfs_mount.h"
+
+/*
+ * XFS logging functions
+ */
+static int
+__xfs_printk(
+        const char              *level,
+        const struct xfs_mount  *mp,
+        struct va_format        *vaf)
+{
+        if (mp && mp->m_fsname)
+                return printk("%sXFS (%s): %pV\n", level, mp->m_fsname, vaf);
+        return printk("%sXFS: %pV\n", level, vaf);
+}
+
+int xfs_printk(
+        const char              *level,
+        const struct xfs_mount  *mp,
+        const char              *fmt, ...)
+{
+        struct va_format        vaf;
+        va_list                 args;
+        int                      r;
+
+        va_start(args, fmt);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        r = __xfs_printk(level, mp, &vaf);
+        va_end(args);
+
+        return r;
+}
+
+#define define_xfs_printk_level(func, kern_level)               \
+int func(const struct xfs_mount *mp, const char *fmt, ...)      \
+{                                                               \
+        struct va_format        vaf;                            \
+        va_list                 args;                           \
+        int                     r;                              \
+                                                                \
+        va_start(args, fmt);                                    \
+                                                                \
+        vaf.fmt = fmt;                                          \
+        vaf.va = &args;                                         \
+                                                                \
+        r = __xfs_printk(kern_level, mp, &vaf);                 \
+        va_end(args);                                           \
+                                                                \
+        return r;                                               \
+}                                                               \
+
+define_xfs_printk_level(xfs_emerg, KERN_EMERG);
+define_xfs_printk_level(xfs_alert, KERN_ALERT);
+define_xfs_printk_level(xfs_crit, KERN_CRIT);
+define_xfs_printk_level(xfs_err, KERN_ERR);
+define_xfs_printk_level(xfs_warn, KERN_WARNING);
+define_xfs_printk_level(xfs_notice, KERN_NOTICE);
+define_xfs_printk_level(xfs_info, KERN_INFO);
+#ifdef DEBUG
+define_xfs_printk_level(xfs_debug, KERN_DEBUG);
+#endif
+
+int
+xfs_alert_tag(
+        const struct xfs_mount  *mp,
+        int                     panic_tag,
+        const char              *fmt, ...)
+{
+        struct va_format        vaf;
+        va_list                 args;
+        int                     do_panic = 0;
+        int                     r;
+
+        if (xfs_panic_mask && (xfs_panic_mask & panic_tag)) {
+                xfs_printk(KERN_ALERT, mp,
+                        "XFS: Transforming an alert into a BUG.");
+                do_panic = 1;
+        }
+
+        va_start(args, fmt);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        r = __xfs_printk(KERN_ALERT, mp, &vaf);
+        va_end(args);
+
+        BUG_ON(do_panic);
+
+        return r;
+}
+
+void
+assfail(char *expr, char *file, int line)
+{
+        xfs_emerg(NULL, "Assertion failed: %s, file: %s, line: %d",
+                expr, file, line);
+        BUG();
+}
+
+void
+xfs_hex_dump(void *p, int length)
+{
+        print_hex_dump(KERN_ALERT, "", DUMP_PREFIX_ADDRESS, 16, 1, p, length, 1);
+}
diff --git a/fs/xfs/linux-2.6/xfs_message.h b/fs/xfs/linux-2.6/xfs_message.h
new file mode 100644
index 000000000000..e77ffa16745b
--- /dev/null
+++ b/fs/xfs/linux-2.6/xfs_message.h
@@ -0,0 +1,38 @@
+#ifndef __XFS_MESSAGE_H
+#define __XFS_MESSAGE_H 1
+
+struct xfs_mount;
+
+extern int xfs_printk(const char *level, const struct xfs_mount *mp,
+                      const char *fmt, ...)
+        __attribute__ ((format (printf, 3, 4)));
+extern int xfs_emerg(const struct xfs_mount *mp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int xfs_alert(const struct xfs_mount *mp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int xfs_alert_tag(const struct xfs_mount *mp, int tag,
+                         const char *fmt, ...)
+        __attribute__ ((format (printf, 3, 4)));
+extern int xfs_crit(const struct xfs_mount *mp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int xfs_err(const struct xfs_mount *mp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int xfs_warn(const struct xfs_mount *mp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int xfs_notice(const struct xfs_mount *mp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int xfs_info(const struct xfs_mount *mp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+
+#ifdef DEBUG
+extern int xfs_debug(const struct xfs_mount *mp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+#else
+#define xfs_debug(mp, fmt, ...) (0)
+#endif
+
+extern void assfail(char *expr, char *f, int l);
+
+extern void xfs_hex_dump(void *p, int length);
+
+#endif  /* __XFS_MESSAGE_H */
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 9731898083ae..1ba5c451da36 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -173,6 +173,15 @@ xfs_parseargs(
         __uint8_t               iosizelog = 0;
 
         /*
+         * set up the mount name first so all the errors will refer to the
+         * correct device.
+         */
+        mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
+        if (!mp->m_fsname)
+                return ENOMEM;
+        mp->m_fsname_len = strlen(mp->m_fsname) + 1;
+
+        /*
          * Copy binary VFS mount flags we are interested in.
          */
         if (sb->s_flags & MS_RDONLY)
@@ -189,6 +198,7 @@ xfs_parseargs(
         mp->m_flags |= XFS_MOUNT_BARRIER;
         mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
         mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
+        mp->m_flags |= XFS_MOUNT_DELAYLOG;
 
         /*
          * These can be overridden by the mount option parsing.
@@ -207,24 +217,21 @@ xfs_parseargs(
 
                 if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
                         mp->m_logbufs = simple_strtoul(value, &eov, 10);
                 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
                         mp->m_logbsize = suffix_strtoul(value, &eov, 10);
                 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -232,14 +239,12 @@ xfs_parseargs(
                         if (!mp->m_logname)
                                 return ENOMEM;
                 } else if (!strcmp(this_char, MNTOPT_MTPT)) {
-                        cmn_err(CE_WARN,
-                                "XFS: %s option not allowed on this system",
+                        xfs_warn(mp, "%s option not allowed on this system",
                                 this_char);
                         return EINVAL;
                 } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -248,8 +253,7 @@ xfs_parseargs(
                                 return ENOMEM;
                 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -257,8 +261,7 @@ xfs_parseargs(
                         iosizelog = ffs(iosize) - 1;
                 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -280,16 +283,14 @@ xfs_parseargs(
                         mp->m_flags |= XFS_MOUNT_SWALLOC;
                 } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
                         dsunit = simple_strtoul(value, &eov, 10);
                 } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
                         if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
+                                xfs_warn(mp, "%s option requires an argument",
                                         this_char);
                                 return EINVAL;
                         }
@@ -297,8 +298,7 @@ xfs_parseargs(
                 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
                         mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
 #if !XFS_BIG_INUMS
-                        cmn_err(CE_WARN,
-                                "XFS: %s option not allowed on this system",
+                        xfs_warn(mp, "%s option not allowed on this system",
                                 this_char);
                         return EINVAL;
 #endif
@@ -356,20 +356,19 @@ xfs_parseargs(
                 } else if (!strcmp(this_char, MNTOPT_NODELAYLOG)) {
                         mp->m_flags &= ~XFS_MOUNT_DELAYLOG;
                 } else if (!strcmp(this_char, "ihashsize")) {
-                        cmn_err(CE_WARN,
-        "XFS: ihashsize no longer used, option is deprecated.");
+                        xfs_warn(mp,
+        "ihashsize no longer used, option is deprecated.");
                 } else if (!strcmp(this_char, "osyncisdsync")) {
-                        cmn_err(CE_WARN,
-        "XFS: osyncisdsync has no effect, option is deprecated.");
+                        xfs_warn(mp,
+        "osyncisdsync has no effect, option is deprecated.");
                 } else if (!strcmp(this_char, "osyncisosync")) {
-                        cmn_err(CE_WARN,
-        "XFS: osyncisosync has no effect, option is deprecated.");
+                        xfs_warn(mp,
+        "osyncisosync has no effect, option is deprecated.");
                 } else if (!strcmp(this_char, "irixsgid")) {
-                        cmn_err(CE_WARN,
-        "XFS: irixsgid is now a sysctl(2) variable, option is deprecated.");
+                        xfs_warn(mp,
+        "irixsgid is now a sysctl(2) variable, option is deprecated.");
                 } else {
-                        cmn_err(CE_WARN,
-                                "XFS: unknown mount option [%s].", this_char);
+                        xfs_warn(mp, "unknown mount option [%s].", this_char);
                         return EINVAL;
                 }
         }
@@ -379,40 +378,37 @@ xfs_parseargs(
          */
         if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
             !(mp->m_flags & XFS_MOUNT_RDONLY)) {
-                cmn_err(CE_WARN, "XFS: no-recovery mounts must be read-only.");
+                xfs_warn(mp, "no-recovery mounts must be read-only.");
                 return EINVAL;
         }
 
         if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
-                cmn_err(CE_WARN,
-        "XFS: sunit and swidth options incompatible with the noalign option");
+                xfs_warn(mp,
+        "sunit and swidth options incompatible with the noalign option");
                 return EINVAL;
         }
 
 #ifndef CONFIG_XFS_QUOTA
         if (XFS_IS_QUOTA_RUNNING(mp)) {
-                cmn_err(CE_WARN,
-                        "XFS: quota support not available in this kernel.");
+                xfs_warn(mp, "quota support not available in this kernel.");
                 return EINVAL;
         }
 #endif
 
         if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
             (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) {
-                cmn_err(CE_WARN,
-                        "XFS: cannot mount with both project and group quota");
+                xfs_warn(mp, "cannot mount with both project and group quota");
                 return EINVAL;
         }
 
         if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
-                cmn_err(CE_WARN,
-                        "XFS: sunit and swidth must be specified together");
+                xfs_warn(mp, "sunit and swidth must be specified together");
                 return EINVAL;
         }
 
         if (dsunit && (dswidth % dsunit != 0)) {
-                cmn_err(CE_WARN,
-        "XFS: stripe width (%d) must be a multiple of the stripe unit (%d)",
+                xfs_warn(mp,
+        "stripe width (%d) must be a multiple of the stripe unit (%d)",
                         dswidth, dsunit);
                 return EINVAL;
         }
@@ -438,8 +434,7 @@ done:
             mp->m_logbufs != 0 &&
             (mp->m_logbufs < XLOG_MIN_ICLOGS ||
              mp->m_logbufs > XLOG_MAX_ICLOGS)) {
-                cmn_err(CE_WARN,
-                        "XFS: invalid logbufs value: %d [not %d-%d]",
+                xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
                         mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
                 return XFS_ERROR(EINVAL);
         }
@@ -448,22 +443,16 @@ done:
             (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
              mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
              !is_power_of_2(mp->m_logbsize))) {
-                cmn_err(CE_WARN,
-        "XFS: invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
+                xfs_warn(mp,
+                        "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
                         mp->m_logbsize);
                 return XFS_ERROR(EINVAL);
         }
 
-        mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
-        if (!mp->m_fsname)
-                return ENOMEM;
-        mp->m_fsname_len = strlen(mp->m_fsname) + 1;
-
         if (iosizelog) {
                 if (iosizelog > XFS_MAX_IO_LOG ||
                     iosizelog < XFS_MIN_IO_LOG) {
-                        cmn_err(CE_WARN,
-                "XFS: invalid log iosize: %d [not %d-%d]",
+                        xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
                                 iosizelog, XFS_MIN_IO_LOG,
                                 XFS_MAX_IO_LOG);
                         return XFS_ERROR(EINVAL);
@@ -610,7 +599,7 @@ xfs_blkdev_get(
                                     mp);
         if (IS_ERR(*bdevp)) {
                 error = PTR_ERR(*bdevp);
-                printk("XFS: Invalid device [%s], error=%d\n", name, error);
+                xfs_warn(mp, "Invalid device [%s], error=%d\n", name, error);
         }
 
         return -error;
@@ -664,23 +653,23 @@ xfs_mountfs_check_barriers(xfs_mount_t *mp)
         int error;
 
         if (mp->m_logdev_targp != mp->m_ddev_targp) {
-                xfs_fs_cmn_err(CE_NOTE, mp,
+                xfs_notice(mp,
                   "Disabling barriers, not supported with external log device");
                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
                 return;
         }
 
         if (xfs_readonly_buftarg(mp->m_ddev_targp)) {
-                xfs_fs_cmn_err(CE_NOTE, mp,
-                  "Disabling barriers, underlying device is readonly");
+                xfs_notice(mp,
+                        "Disabling barriers, underlying device is readonly");
                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
                 return;
         }
 
         error = xfs_barrier_test(mp);
         if (error) {
-                xfs_fs_cmn_err(CE_NOTE, mp,
-                  "Disabling barriers, trial barrier write failed");
+                xfs_notice(mp,
+                        "Disabling barriers, trial barrier write failed");
                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
                 return;
         }
@@ -743,8 +732,8 @@ xfs_open_devices(
                         goto out_close_logdev;
 
                 if (rtdev == ddev || rtdev == logdev) {
-                        cmn_err(CE_WARN,
-        "XFS: Cannot mount filesystem with identical rtdev and ddev/logdev.");
+                        xfs_warn(mp,
+        "Cannot mount filesystem with identical rtdev and ddev/logdev.");
                         error = EINVAL;
                         goto out_close_rtdev;
                 }
@@ -1089,7 +1078,7 @@ xfs_fs_write_inode(
                         error = 0;
                         goto out_unlock;
                 }
-                error = xfs_iflush(ip, 0);
+                error = xfs_iflush(ip, SYNC_TRYLOCK);
         }
 
  out_unlock:
@@ -1345,8 +1334,8 @@ xfs_fs_remount(
                          * options that we can't actually change.
                          */
 #if 0
-                        printk(KERN_INFO
-        "XFS: mount option \"%s\" not supported for remount\n", p);
+                        xfs_info(mp,
+                "mount option \"%s\" not supported for remount\n", p);
                         return -EINVAL;
 #else
                         break;
@@ -1367,8 +1356,7 @@ xfs_fs_remount(
                 if (mp->m_update_flags) {
                         error = xfs_mount_log_sb(mp, mp->m_update_flags);
                         if (error) {
-                                cmn_err(CE_WARN,
-                                        "XFS: failed to write sb changes");
+                                xfs_warn(mp, "failed to write sb changes");
                                 return error;
                         }
                         mp->m_update_flags = 0;
@@ -1452,15 +1440,15 @@ xfs_finish_flags(
                         mp->m_logbsize = mp->m_sb.sb_logsunit;
                 } else if (mp->m_logbsize > 0 &&
                            mp->m_logbsize < mp->m_sb.sb_logsunit) {
-                        cmn_err(CE_WARN,
-        "XFS: logbuf size must be greater than or equal to log stripe size");
+                        xfs_warn(mp,
+                "logbuf size must be greater than or equal to log stripe size");
                         return XFS_ERROR(EINVAL);
                 }
         } else {
                 /* Fail a mount if the logbuf is larger than 32K */
                 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
-                        cmn_err(CE_WARN,
-        "XFS: logbuf size for version 1 logs must be 16K or 32K");
+                        xfs_warn(mp,
+                "logbuf size for version 1 logs must be 16K or 32K");
                         return XFS_ERROR(EINVAL);
                 }
         }
@@ -1477,8 +1465,8 @@ xfs_finish_flags(
          * prohibit r/w mounts of read-only filesystems
          */
         if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
-                cmn_err(CE_WARN,
-        "XFS: cannot mount a read-only filesystem as read-write");
+                xfs_warn(mp,
+                        "cannot mount a read-only filesystem as read-write");
                 return XFS_ERROR(EROFS);
         }
 
@@ -1551,10 +1539,14 @@ xfs_fs_fill_super(
         if (error)
                 goto out_free_sb;
 
-        error = xfs_mountfs(mp);
-        if (error)
-                goto out_filestream_unmount;
-
+        /*
+         * we must configure the block size in the superblock before we run the
+         * full mount process as the mount process can lookup and cache inodes.
+         * For the same reason we must also initialise the syncd and register
+         * the inode cache shrinker so that inodes can be reclaimed during
+         * operations like a quotacheck that iterate all inodes in the
+         * filesystem.
+         */
         sb->s_magic = XFS_SB_MAGIC;
         sb->s_blocksize = mp->m_sb.sb_blocksize;
         sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
@@ -1562,6 +1554,16 @@ xfs_fs_fill_super(
         sb->s_time_gran = 1;
         set_posix_acl_flag(sb);
 
+        error = xfs_syncd_init(mp);
+        if (error)
+                goto out_filestream_unmount;
+
+        xfs_inode_shrinker_register(mp);
+
+        error = xfs_mountfs(mp);
+        if (error)
+                goto out_syncd_stop;
+
         root = igrab(VFS_I(mp->m_rootip));
         if (!root) {
                 error = ENOENT;
@@ -1577,14 +1579,11 @@ xfs_fs_fill_super(
                 goto fail_vnrele;
         }
 
-        error = xfs_syncd_init(mp);
-        if (error)
-                goto fail_vnrele;
-
-        xfs_inode_shrinker_register(mp);
-
         return 0;
 
+ out_syncd_stop:
+        xfs_inode_shrinker_unregister(mp);
+        xfs_syncd_stop(mp);
  out_filestream_unmount:
         xfs_filestream_unmount(mp);
  out_free_sb:
@@ -1608,6 +1607,9 @@ xfs_fs_fill_super(
         }
 
  fail_unmount:
+        xfs_inode_shrinker_unregister(mp);
+        xfs_syncd_stop(mp);
+
         /*
          * Blow away any referenced inode in the filestreams cache.
          * This can and will cause log traffic as inodes go inactive
diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index e22f0057d21f..594cd822d84d 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -425,8 +425,7 @@ xfs_quiesce_attr(
         /* Push the superblock and write an unmount record */
         error = xfs_log_sbcount(mp, 1);
         if (error)
-                xfs_fs_cmn_err(CE_WARN, mp,
-                                "xfs_attr_quiesce: failed to log sb changes. "
+                xfs_warn(mp, "xfs_attr_quiesce: failed to log sb changes. "
                                 "Frozen image may not be consistent.");
         xfs_log_unmount_write(mp);
         xfs_unmountfs_writesb(mp);
@@ -762,8 +761,10 @@ xfs_reclaim_inode(
         struct xfs_perag        *pag,
         int                     sync_mode)
 {
-        int     error = 0;
+        int     error;
 
+restart:
+        error = 0;
         xfs_ilock(ip, XFS_ILOCK_EXCL);
         if (!xfs_iflock_nowait(ip)) {
                 if (!(sync_mode & SYNC_WAIT))
@@ -789,9 +790,31 @@ xfs_reclaim_inode(
         if (xfs_inode_clean(ip))
                 goto reclaim;
 
-        /* Now we have an inode that needs flushing */
-        error = xfs_iflush(ip, sync_mode);
+        /*
+         * Now we have an inode that needs flushing.
+         *
+         * We do a nonblocking flush here even if we are doing a SYNC_WAIT
+         * reclaim as we can deadlock with inode cluster removal.
+         * xfs_ifree_cluster() can lock the inode buffer before it locks the
+         * ip->i_lock, and we are doing the exact opposite here. As a result,
+         * doing a blocking xfs_itobp() to get the cluster buffer will result
+         * in an ABBA deadlock with xfs_ifree_cluster().
+         *
+         * As xfs_ifree_cluser() must gather all inodes that are active in the
+         * cache to mark them stale, if we hit this case we don't actually want
+         * to do IO here - we want the inode marked stale so we can simply
+         * reclaim it. Hence if we get an EAGAIN error on a SYNC_WAIT flush,
+         * just unlock the inode, back off and try again. Hopefully the next
+         * pass through will see the stale flag set on the inode.
+         */
+        error = xfs_iflush(ip, SYNC_TRYLOCK | sync_mode);
         if (sync_mode & SYNC_WAIT) {
+                if (error == EAGAIN) {
+                        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+                        /* backoff longer than in xfs_ifree_cluster */
+                        delay(2);
+                        goto restart;
+                }
                 xfs_iflock(ip);
                 goto reclaim;
         }
@@ -806,7 +829,7 @@ xfs_reclaim_inode(
          * pass on the error.
          */
         if (error && error != EAGAIN && !XFS_FORCED_SHUTDOWN(ip->i_mount)) {
-                xfs_fs_cmn_err(CE_WARN, ip->i_mount,
+                xfs_warn(ip->i_mount,
                         "inode 0x%llx background reclaim flush failed with %d",
                         (long long)ip->i_ino, error);
         }
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.c b/fs/xfs/linux-2.6/xfs_sysctl.c
index ee3cee097e7e..ee2d2adaa438 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.c
+++ b/fs/xfs/linux-2.6/xfs_sysctl.c
@@ -37,7 +37,7 @@ xfs_stats_clear_proc_handler(
         ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
 
         if (!ret && write && *valp) {
-                printk("XFS Clearing xfsstats\n");
+                xfs_notice(NULL, "Clearing xfsstats");
                 for_each_possible_cpu(c) {
                         preempt_disable();
                         /* save vn_active, it's a universal truth! */