Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs

* 'for-linus' of git://oss.sgi.com/xfs/xfs: (49 commits)
  xfs simplify and speed up direct I/O completions
  xfs: move aio completion after unwritten extent conversion
  direct-io: move aio_complete into ->end_io
  xfs: fix big endian build
  xfs: clean up xfs_bmap_get_bp
  xfs: simplify xfs_truncate_file
  xfs: kill the b_strat callback in xfs_buf
  xfs: remove obsolete osyncisosync mount option
  xfs: clean up filestreams helpers
  xfs: fix gcc 4.6 set but not read and unused statement warnings
  xfs: Fix build when CONFIG_XFS_POSIX_ACL=n
  xfs: fix unsigned underflow in xfs_free_eofblocks
  xfs: use GFP_NOFS for page cache allocation
  xfs: fix memory reclaim recursion deadlock on locked inode buffer
  xfs: fix xfs_trans_add_item() lockdep warnings
  xfs: simplify and remove xfs_ireclaim
  xfs: don't block on buffer read errors
  xfs: move inode shrinker unregister even earlier
  xfs: remove a dmapi leftover
  xfs: writepage always has buffers
  ...

21 files changed, 485 insertions, 889 deletions

diff --git a/fs/xfs/linux-2.6/xfs_acl.c b/fs/xfs/linux-2.6/xfs_acl.c
index 9f769b5b38fc..b2771862fd3d 100644
--- a/fs/xfs/linux-2.6/xfs_acl.c
+++ b/fs/xfs/linux-2.6/xfs_acl.c
@@ -225,7 +225,7 @@ xfs_check_acl(struct inode *inode, int mask)
         struct posix_acl *acl;
         int error = -EAGAIN;
 
-        xfs_itrace_entry(ip);
+        trace_xfs_check_acl(ip);
 
         /*
          * If there is no attribute fork no ACL exists on this inode and
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 34640d6dbdcb..d24e78f32f3e 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -21,19 +21,12 @@
 #include "xfs_inum.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir2.h"
 #include "xfs_trans.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_alloc.h"
-#include "xfs_btree.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
 #include "xfs_iomap.h"
@@ -92,18 +85,15 @@ void
 xfs_count_page_state(
         struct page             *page,
         int                     *delalloc,
-        int                     *unmapped,
         int                     *unwritten)
 {
         struct buffer_head      *bh, *head;
 
-        *delalloc = *unmapped = *unwritten = 0;
+        *delalloc = *unwritten = 0;
 
         bh = head = page_buffers(page);
         do {
-                if (buffer_uptodate(bh) && !buffer_mapped(bh))
-                        (*unmapped) = 1;
-                else if (buffer_unwritten(bh))
+                if (buffer_unwritten(bh))
                         (*unwritten) = 1;
                 else if (buffer_delay(bh))
                         (*delalloc) = 1;
@@ -212,23 +202,17 @@ xfs_setfilesize(
 }
 
 /*
- * Schedule IO completion handling on a xfsdatad if this was
- * the final hold on this ioend. If we are asked to wait,
- * flush the workqueue.
+ * Schedule IO completion handling on the final put of an ioend.
  */
 STATIC void
 xfs_finish_ioend(
-        xfs_ioend_t     *ioend,
-        int             wait)
+        struct xfs_ioend        *ioend)
 {
         if (atomic_dec_and_test(&ioend->io_remaining)) {
-                struct workqueue_struct *wq;
-
-                wq = (ioend->io_type == IO_UNWRITTEN) ?
-                        xfsconvertd_workqueue : xfsdatad_workqueue;
-                queue_work(wq, &ioend->io_work);
-                if (wait)
-                        flush_workqueue(wq);
+                if (ioend->io_type == IO_UNWRITTEN)
+                        queue_work(xfsconvertd_workqueue, &ioend->io_work);
+                else
+                        queue_work(xfsdatad_workqueue, &ioend->io_work);
         }
 }
 
@@ -272,11 +256,25 @@ xfs_end_io(
          */
         if (error == EAGAIN) {
                 atomic_inc(&ioend->io_remaining);
-                xfs_finish_ioend(ioend, 0);
+                xfs_finish_ioend(ioend);
                 /* ensure we don't spin on blocked ioends */
                 delay(1);
-        } else
+        } else {
+                if (ioend->io_iocb)
+                        aio_complete(ioend->io_iocb, ioend->io_result, 0);
                 xfs_destroy_ioend(ioend);
+        }
+}
+
+/*
+ * Call IO completion handling in caller context on the final put of an ioend.
+ */
+STATIC void
+xfs_finish_ioend_sync(
+        struct xfs_ioend        *ioend)
+{
+        if (atomic_dec_and_test(&ioend->io_remaining))
+                xfs_end_io(&ioend->io_work);
 }
 
 /*
@@ -309,6 +307,8 @@ xfs_alloc_ioend(
         atomic_inc(&XFS_I(ioend->io_inode)->i_iocount);
         ioend->io_offset = 0;
         ioend->io_size = 0;
+        ioend->io_iocb = NULL;
+        ioend->io_result = 0;
 
         INIT_WORK(&ioend->io_work, xfs_end_io);
         return ioend;
@@ -358,7 +358,7 @@ xfs_end_bio(
         bio->bi_end_io = NULL;
         bio_put(bio);
 
-        xfs_finish_ioend(ioend, 0);
+        xfs_finish_ioend(ioend);
 }
 
 STATIC void
@@ -500,7 +500,7 @@ xfs_submit_ioend(
                 }
                 if (bio)
                         xfs_submit_ioend_bio(wbc, ioend, bio);
-                xfs_finish_ioend(ioend, 0);
+                xfs_finish_ioend(ioend);
         } while ((ioend = next) != NULL);
 }
 
@@ -614,31 +614,30 @@ xfs_map_at_offset(
 STATIC unsigned int
 xfs_probe_page(
         struct page             *page,
-        unsigned int            pg_offset,
-        int                     mapped)
+        unsigned int            pg_offset)
 {
+        struct buffer_head      *bh, *head;
         int                     ret = 0;
 
         if (PageWriteback(page))
                 return 0;
+        if (!PageDirty(page))
+                return 0;
+        if (!page->mapping)
+                return 0;
+        if (!page_has_buffers(page))
+                return 0;
 
-        if (page->mapping && PageDirty(page)) {
-                if (page_has_buffers(page)) {
-                        struct buffer_head      *bh, *head;
-
-                        bh = head = page_buffers(page);
-                        do {
-                                if (!buffer_uptodate(bh))
-                                        break;
-                                if (mapped != buffer_mapped(bh))
-                                        break;
-                                ret += bh->b_size;
-                                if (ret >= pg_offset)
-                                        break;
-                        } while ((bh = bh->b_this_page) != head);
-                } else
-                        ret = mapped ? 0 : PAGE_CACHE_SIZE;
-        }
+        bh = head = page_buffers(page);
+        do {
+                if (!buffer_uptodate(bh))
+                        break;
+                if (!buffer_mapped(bh))
+                        break;
+                ret += bh->b_size;
+                if (ret >= pg_offset)
+                        break;
+        } while ((bh = bh->b_this_page) != head);
 
         return ret;
 }
@@ -648,8 +647,7 @@ xfs_probe_cluster(
         struct inode            *inode,
         struct page             *startpage,
         struct buffer_head      *bh,
-        struct buffer_head      *head,
-        int                     mapped)
+        struct buffer_head      *head)
 {
         struct pagevec          pvec;
         pgoff_t                 tindex, tlast, tloff;
@@ -658,7 +656,7 @@ xfs_probe_cluster(
 
         /* First sum forwards in this page */
         do {
-                if (!buffer_uptodate(bh) || (mapped != buffer_mapped(bh)))
+                if (!buffer_uptodate(bh) || !buffer_mapped(bh))
                         return total;
                 total += bh->b_size;
         } while ((bh = bh->b_this_page) != head);
@@ -692,7 +690,7 @@ xfs_probe_cluster(
                                 pg_offset = PAGE_CACHE_SIZE;
 
                         if (page->index == tindex && trylock_page(page)) {
-                                pg_len = xfs_probe_page(page, pg_offset, mapped);
+                                pg_len = xfs_probe_page(page, pg_offset);
                                 unlock_page(page);
                         }
 
@@ -761,7 +759,6 @@ xfs_convert_page(
         struct xfs_bmbt_irec    *imap,
         xfs_ioend_t             **ioendp,
         struct writeback_control *wbc,
-        int                     startio,
         int                     all_bh)
 {
         struct buffer_head      *bh, *head;
@@ -832,19 +829,14 @@ xfs_convert_page(
                         ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
 
                         xfs_map_at_offset(inode, bh, imap, offset);
-                        if (startio) {
-                                xfs_add_to_ioend(inode, bh, offset,
-                                                type, ioendp, done);
-                        } else {
-                                set_buffer_dirty(bh);
-                                unlock_buffer(bh);
-                                mark_buffer_dirty(bh);
-                        }
+                        xfs_add_to_ioend(inode, bh, offset, type,
+                                         ioendp, done);
+
                         page_dirty--;
                         count++;
                 } else {
                         type = IO_NEW;
-                        if (buffer_mapped(bh) && all_bh && startio) {
+                        if (buffer_mapped(bh) && all_bh) {
                                 lock_buffer(bh);
                                 xfs_add_to_ioend(inode, bh, offset,
                                                 type, ioendp, done);
@@ -859,14 +851,12 @@ xfs_convert_page(
         if (uptodate && bh == head)
                 SetPageUptodate(page);
 
-        if (startio) {
-                if (count) {
-                        wbc->nr_to_write--;
-                        if (wbc->nr_to_write <= 0)
-                                done = 1;
-                }
-                xfs_start_page_writeback(page, !page_dirty, count);
+        if (count) {
+                wbc->nr_to_write--;
+                if (wbc->nr_to_write <= 0)
+                        done = 1;
         }
+        xfs_start_page_writeback(page, !page_dirty, count);
 
         return done;
  fail_unlock_page:
@@ -886,7 +876,6 @@ xfs_cluster_write(
         struct xfs_bmbt_irec    *imap,
         xfs_ioend_t             **ioendp,
         struct writeback_control *wbc,
-        int                     startio,
         int                     all_bh,
         pgoff_t                 tlast)
 {
@@ -902,7 +891,7 @@ xfs_cluster_write(
 
                 for (i = 0; i < pagevec_count(&pvec); i++) {
                         done = xfs_convert_page(inode, pvec.pages[i], tindex++,
-                                        imap, ioendp, wbc, startio, all_bh);
+                                        imap, ioendp, wbc, all_bh);
                         if (done)
                                 break;
                 }
@@ -981,7 +970,7 @@ xfs_aops_discard_page(
                  */
                 error = xfs_bmapi(NULL, ip, offset_fsb, 1,
                                 XFS_BMAPI_ENTIRE,  NULL, 0, &imap,
-                                &nimaps, NULL, NULL);
+                                &nimaps, NULL);
 
                 if (error) {
                         /* something screwed, just bail */
@@ -1009,7 +998,7 @@ xfs_aops_discard_page(
                  */
                 xfs_bmap_init(&flist, &firstblock);
                 error = xfs_bunmapi(NULL, ip, offset_fsb, 1, 0, 1, &firstblock,
-                                        &flist, NULL, &done);
+                                        &flist, &done);
 
                 ASSERT(!flist.xbf_count && !flist.xbf_first);
                 if (error) {
@@ -1032,50 +1021,66 @@ out_invalidate:
 }
 
 /*
- * Calling this without startio set means we are being asked to make a dirty
- * page ready for freeing it's buffers.  When called with startio set then
- * we are coming from writepage.
+ * Write out a dirty page.
+ *
+ * For delalloc space on the page we need to allocate space and flush it.
+ * For unwritten space on the page we need to start the conversion to
+ * regular allocated space.
+ * For any other dirty buffer heads on the page we should flush them.
  *
- * When called with startio set it is important that we write the WHOLE
- * page if possible.
- * The bh->b_state's cannot know if any of the blocks or which block for
- * that matter are dirty due to mmap writes, and therefore bh uptodate is
- * only valid if the page itself isn't completely uptodate.  Some layers
- * may clear the page dirty flag prior to calling write page, under the
- * assumption the entire page will be written out; by not writing out the
- * whole page the page can be reused before all valid dirty data is
- * written out.  Note: in the case of a page that has been dirty'd by
- * mapwrite and but partially setup by block_prepare_write the
- * bh->b_states's will not agree and only ones setup by BPW/BCW will have
- * valid state, thus the whole page must be written out thing.
+ * If we detect that a transaction would be required to flush the page, we
+ * have to check the process flags first, if we are already in a transaction
+ * or disk I/O during allocations is off, we need to fail the writepage and
+ * redirty the page.
  */
-
 STATIC int
-xfs_page_state_convert(
-        struct inode    *inode,
-        struct page     *page,
-        struct writeback_control *wbc,
-        int             startio,
-        int             unmapped) /* also implies page uptodate */
+xfs_vm_writepage(
+        struct page             *page,
+        struct writeback_control *wbc)
 {
+        struct inode            *inode = page->mapping->host;
+        int                     delalloc, unwritten;
         struct buffer_head      *bh, *head;
         struct xfs_bmbt_irec    imap;
         xfs_ioend_t             *ioend = NULL, *iohead = NULL;
         loff_t                  offset;
-        unsigned long           p_offset = 0;
         unsigned int            type;
         __uint64_t              end_offset;
         pgoff_t                 end_index, last_index;
         ssize_t                 size, len;
         int                     flags, err, imap_valid = 0, uptodate = 1;
-        int                     page_dirty, count = 0;
-        int                     trylock = 0;
-        int                     all_bh = unmapped;
+        int                     count = 0;
+        int                     all_bh = 0;
 
-        if (startio) {
-                if (wbc->sync_mode == WB_SYNC_NONE && wbc->nonblocking)
-                        trylock |= BMAPI_TRYLOCK;
-        }
+        trace_xfs_writepage(inode, page, 0);
+
+        ASSERT(page_has_buffers(page));
+
+        /*
+         * Refuse to write the page out if we are called from reclaim context.
+         *
+         * This avoids stack overflows when called from deeply used stacks in
+         * random callers for direct reclaim or memcg reclaim.  We explicitly
+         * allow reclaim from kswapd as the stack usage there is relatively low.
+         *
+         * This should really be done by the core VM, but until that happens
+         * filesystems like XFS, btrfs and ext4 have to take care of this
+         * by themselves.
+         */
+        if ((current->flags & (PF_MEMALLOC|PF_KSWAPD)) == PF_MEMALLOC)
+                goto out_fail;
+
+        /*
+         * We need a transaction if there are delalloc or unwritten buffers
+         * on the page.
+         *
+         * If we need a transaction and the process flags say we are already
+         * in a transaction, or no IO is allowed then mark the page dirty
+         * again and leave the page as is.
+         */
+        xfs_count_page_state(page, &delalloc, &unwritten);
+        if ((current->flags & PF_FSTRANS) && (delalloc || unwritten))
+                goto out_fail;
 
         /* Is this page beyond the end of the file? */
         offset = i_size_read(inode);
@@ -1084,50 +1089,33 @@ xfs_page_state_convert(
         if (page->index >= end_index) {
                 if ((page->index >= end_index + 1) ||
                     !(i_size_read(inode) & (PAGE_CACHE_SIZE - 1))) {
-                        if (startio)
-                                unlock_page(page);
+                        unlock_page(page);
                         return 0;
                 }
         }
 
-        /*
-         * page_dirty is initially a count of buffers on the page before
-         * EOF and is decremented as we move each into a cleanable state.
-         *
-         * Derivation:
-         *
-         * End offset is the highest offset that this page should represent.
-         * If we are on the last page, (end_offset & (PAGE_CACHE_SIZE - 1))
-         * will evaluate non-zero and be less than PAGE_CACHE_SIZE and
-         * hence give us the correct page_dirty count. On any other page,
-         * it will be zero and in that case we need page_dirty to be the
-         * count of buffers on the page.
-         */
         end_offset = min_t(unsigned long long,
-                        (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT, offset);
+                        (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT,
+                        offset);
         len = 1 << inode->i_blkbits;
-        p_offset = min_t(unsigned long, end_offset & (PAGE_CACHE_SIZE - 1),
-                                        PAGE_CACHE_SIZE);
-        p_offset = p_offset ? roundup(p_offset, len) : PAGE_CACHE_SIZE;
-        page_dirty = p_offset / len;
 
         bh = head = page_buffers(page);
         offset = page_offset(page);
         flags = BMAPI_READ;
         type = IO_NEW;
 
-        /* TODO: cleanup count and page_dirty */
-
         do {
                 if (offset >= end_offset)
                         break;
                 if (!buffer_uptodate(bh))
                         uptodate = 0;
-                if (!(PageUptodate(page) || buffer_uptodate(bh)) && !startio) {
-                        /*
-                         * the iomap is actually still valid, but the ioend
-                         * isn't.  shouldn't happen too often.
-                         */
+
+                /*
+                 * A hole may still be marked uptodate because discard_buffer
+                 * leaves the flag set.
+                 */
+                if (!buffer_mapped(bh) && buffer_uptodate(bh)) {
+                        ASSERT(!buffer_dirty(bh));
                         imap_valid = 0;
                         continue;
                 }
@@ -1135,19 +1123,7 @@ xfs_page_state_convert(
                 if (imap_valid)
                         imap_valid = xfs_imap_valid(inode, &imap, offset);
 
-                /*
-                 * First case, map an unwritten extent and prepare for
-                 * extent state conversion transaction on completion.
-                 *
-                 * Second case, allocate space for a delalloc buffer.
-                 * We can return EAGAIN here in the release page case.
-                 *
-                 * Third case, an unmapped buffer was found, and we are
-                 * in a path where we need to write the whole page out.
-                 */
-                if (buffer_unwritten(bh) || buffer_delay(bh) ||
-                    ((buffer_uptodate(bh) || PageUptodate(page)) &&
-                     !buffer_mapped(bh) && (unmapped || startio))) {
+                if (buffer_unwritten(bh) || buffer_delay(bh)) {
                         int new_ioend = 0;
 
                         /*
@@ -1161,15 +1137,16 @@ xfs_page_state_convert(
                                 flags = BMAPI_WRITE | BMAPI_IGNSTATE;
                         } else if (buffer_delay(bh)) {
                                 type = IO_DELAY;
-                                flags = BMAPI_ALLOCATE | trylock;
-                        } else {
-                                type = IO_NEW;
-                                flags = BMAPI_WRITE | BMAPI_MMAP;
+                                flags = BMAPI_ALLOCATE;
+
+                                if (wbc->sync_mode == WB_SYNC_NONE &&
+                                    wbc->nonblocking)
+                                        flags |= BMAPI_TRYLOCK;
                         }
 
                         if (!imap_valid) {
                                 /*
-                                 * if we didn't have a valid mapping then we
+                                 * If we didn't have a valid mapping then we
                                  * need to ensure that we put the new mapping
                                  * in a new ioend structure. This needs to be
                                  * done to ensure that the ioends correctly
@@ -1177,14 +1154,7 @@ xfs_page_state_convert(
                                  * for unwritten extent conversion.
                                  */
                                 new_ioend = 1;
-                                if (type == IO_NEW) {
-                                        size = xfs_probe_cluster(inode,
-                                                        page, bh, head, 0);
-                                } else {
-                                        size = len;
-                                }
-
-                                err = xfs_map_blocks(inode, offset, size,
+                                err = xfs_map_blocks(inode, offset, len,
                                                 &imap, flags);
                                 if (err)
                                         goto error;
@@ -1193,19 +1163,11 @@ xfs_page_state_convert(
                         }
                         if (imap_valid) {
                                 xfs_map_at_offset(inode, bh, &imap, offset);
-                                if (startio) {
-                                        xfs_add_to_ioend(inode, bh, offset,
-                                                        type, &ioend,
-                                                        new_ioend);
-                                } else {
-                                        set_buffer_dirty(bh);
-                                        unlock_buffer(bh);
-                                        mark_buffer_dirty(bh);
-                                }
-                                page_dirty--;
+                                xfs_add_to_ioend(inode, bh, offset, type,
+                                                 &ioend, new_ioend);
                                 count++;
                         }
-                } else if (buffer_uptodate(bh) && startio) {
+                } else if (buffer_uptodate(bh)) {
                         /*
                          * we got here because the buffer is already mapped.
                          * That means it must already have extents allocated
@@ -1213,8 +1175,7 @@ xfs_page_state_convert(
                          */
                         if (!imap_valid || flags != BMAPI_READ) {
                                 flags = BMAPI_READ;
-                                size = xfs_probe_cluster(inode, page, bh,
-                                                                head, 1);
+                                size = xfs_probe_cluster(inode, page, bh, head);
                                 err = xfs_map_blocks(inode, offset, size,
                                                 &imap, flags);
                                 if (err)
@@ -1233,18 +1194,16 @@ xfs_page_state_convert(
                          */
                         type = IO_NEW;
                         if (trylock_buffer(bh)) {
-                                ASSERT(buffer_mapped(bh));
                                 if (imap_valid)
                                         all_bh = 1;
                                 xfs_add_to_ioend(inode, bh, offset, type,
                                                 &ioend, !imap_valid);
-                                page_dirty--;
                                 count++;
                         } else {
                                 imap_valid = 0;
                         }
-                } else if ((buffer_uptodate(bh) || PageUptodate(page)) &&
-                           (unmapped || startio)) {
+                } else if (PageUptodate(page)) {
+                        ASSERT(buffer_mapped(bh));
                         imap_valid = 0;
                 }
 
@@ -1256,8 +1215,7 @@ xfs_page_state_convert(
         if (uptodate && bh == head)
                 SetPageUptodate(page);
 
-        if (startio)
-                xfs_start_page_writeback(page, 1, count);
+        xfs_start_page_writeback(page, 1, count);
 
         if (ioend && imap_valid) {
                 xfs_off_t               end_index;
@@ -1275,131 +1233,27 @@ xfs_page_state_convert(
                         end_index = last_index;
 
                 xfs_cluster_write(inode, page->index + 1, &imap, &ioend,
-                                        wbc, startio, all_bh, end_index);
+                                        wbc, all_bh, end_index);
         }
 
         if (iohead)
                 xfs_submit_ioend(wbc, iohead);
 
-        return page_dirty;
+        return 0;
 
 error:
         if (iohead)
                 xfs_cancel_ioend(iohead);
 
-        /*
-         * If it's delalloc and we have nowhere to put it,
-         * throw it away, unless the lower layers told
-         * us to try again.
-         */
-        if (err != -EAGAIN) {
-                if (!unmapped)
-                        xfs_aops_discard_page(page);
-                ClearPageUptodate(page);
-        }
+        xfs_aops_discard_page(page);
+        ClearPageUptodate(page);
+        unlock_page(page);
         return err;
-}
-
-/*
- * writepage: Called from one of two places:
- *
- * 1. we are flushing a delalloc buffer head.
- *
- * 2. we are writing out a dirty page. Typically the page dirty
- *    state is cleared before we get here. In this case is it
- *    conceivable we have no buffer heads.
- *
- * For delalloc space on the page we need to allocate space and
- * flush it. For unmapped buffer heads on the page we should
- * allocate space if the page is uptodate. For any other dirty
- * buffer heads on the page we should flush them.
- *
- * If we detect that a transaction would be required to flush
- * the page, we have to check the process flags first, if we
- * are already in a transaction or disk I/O during allocations
- * is off, we need to fail the writepage and redirty the page.
- */
-
-STATIC int
-xfs_vm_writepage(
-        struct page             *page,
-        struct writeback_control *wbc)
-{
-        int                     error;
-        int                     need_trans;
-        int                     delalloc, unmapped, unwritten;
-        struct inode            *inode = page->mapping->host;
-
-        trace_xfs_writepage(inode, page, 0);
-
-        /*
-         * Refuse to write the page out if we are called from reclaim context.
-         *
-         * This is primarily to avoid stack overflows when called from deep
-         * used stacks in random callers for direct reclaim, but disabling
-         * reclaim for kswap is a nice side-effect as kswapd causes rather
-         * suboptimal I/O patters, too.
-         *
-         * This should really be done by the core VM, but until that happens
-         * filesystems like XFS, btrfs and ext4 have to take care of this
-         * by themselves.
-         */
-        if (current->flags & PF_MEMALLOC)
-                goto out_fail;
-
-        /*
-         * We need a transaction if:
-         *  1. There are delalloc buffers on the page
-         *  2. The page is uptodate and we have unmapped buffers
-         *  3. The page is uptodate and we have no buffers
-         *  4. There are unwritten buffers on the page
-         */
-
-        if (!page_has_buffers(page)) {
-                unmapped = 1;
-                need_trans = 1;
-        } else {
-                xfs_count_page_state(page, &delalloc, &unmapped, &unwritten);
-                if (!PageUptodate(page))
-                        unmapped = 0;
-                need_trans = delalloc + unmapped + unwritten;
-        }
-
-        /*
-         * If we need a transaction and the process flags say
-         * we are already in a transaction, or no IO is allowed
-         * then mark the page dirty again and leave the page
-         * as is.
-         */
-        if (current_test_flags(PF_FSTRANS) && need_trans)
-                goto out_fail;
-
-        /*
-         * Delay hooking up buffer heads until we have
-         * made our go/no-go decision.
-         */
-        if (!page_has_buffers(page))
-                create_empty_buffers(page, 1 << inode->i_blkbits, 0);
-
-        /*
-         * Convert delayed allocate, unwritten or unmapped space
-         * to real space and flush out to disk.
-         */
-        error = xfs_page_state_convert(inode, page, wbc, 1, unmapped);
-        if (error == -EAGAIN)
-                goto out_fail;
-        if (unlikely(error < 0))
-                goto out_unlock;
-
-        return 0;
 
 out_fail:
         redirty_page_for_writepage(wbc, page);
         unlock_page(page);
         return 0;
-out_unlock:
-        unlock_page(page);
-        return error;
 }
 
 STATIC int
@@ -1413,65 +1267,27 @@ xfs_vm_writepages(
 
 /*
  * Called to move a page into cleanable state - and from there
- * to be released. Possibly the page is already clean. We always
+ * to be released. The page should already be clean. We always
  * have buffer heads in this call.
  *
- * Returns 0 if the page is ok to release, 1 otherwise.
- *
- * Possible scenarios are:
- *
- * 1. We are being called to release a page which has been written
- *    to via regular I/O. buffer heads will be dirty and possibly
- *    delalloc. If no delalloc buffer heads in this case then we
- *    can just return zero.
- *
- * 2. We are called to release a page which has been written via
- *    mmap, all we need to do is ensure there is no delalloc
- *    state in the buffer heads, if not we can let the caller
- *    free them and we should come back later via writepage.
+ * Returns 1 if the page is ok to release, 0 otherwise.
  */
 STATIC int
 xfs_vm_releasepage(
         struct page             *page,
         gfp_t                   gfp_mask)
 {
-        struct inode            *inode = page->mapping->host;
-        int                     dirty, delalloc, unmapped, unwritten;
-        struct writeback_control wbc = {
-                .sync_mode = WB_SYNC_ALL,
-                .nr_to_write = 1,
-        };
+        int                     delalloc, unwritten;
 
-        trace_xfs_releasepage(inode, page, 0);
-
-        if (!page_has_buffers(page))
-                return 0;
+        trace_xfs_releasepage(page->mapping->host, page, 0);
 
-        xfs_count_page_state(page, &delalloc, &unmapped, &unwritten);
-        if (!delalloc && !unwritten)
-                goto free_buffers;
+        xfs_count_page_state(page, &delalloc, &unwritten);
 
-        if (!(gfp_mask & __GFP_FS))
+        if (WARN_ON(delalloc))
                 return 0;
-
-        /* If we are already inside a transaction or the thread cannot
-         * do I/O, we cannot release this page.
-         */
-        if (current_test_flags(PF_FSTRANS))
+        if (WARN_ON(unwritten))
                 return 0;
 
-        /*
-         * Convert delalloc space to real space, do not flush the
-         * data out to disk, that will be done by the caller.
-         * Never need to allocate space here - we will always
-         * come back to writepage in that case.
-         */
-        dirty = xfs_page_state_convert(inode, page, &wbc, 0, 0);
-        if (dirty == 0 && !unwritten)
-                goto free_buffers;
-        return 0;
-
-free_buffers:
         return try_to_free_buffers(page);
 }
 
@@ -1481,9 +1297,9 @@ __xfs_get_blocks(
         sector_t                iblock,
         struct buffer_head      *bh_result,
         int                     create,
-        int                     direct,
-        bmapi_flags_t           flags)
+        int                     direct)
 {
+        int                     flags = create ? BMAPI_WRITE : BMAPI_READ;
         struct xfs_bmbt_irec    imap;
         xfs_off_t               offset;
         ssize_t                 size;
@@ -1498,8 +1314,11 @@ __xfs_get_blocks(
         if (!create && direct && offset >= i_size_read(inode))
                 return 0;
 
-        error = xfs_iomap(XFS_I(inode), offset, size,
-                             create ? flags : BMAPI_READ, &imap, &nimap, &new);
+        if (direct && create)
+                flags |= BMAPI_DIRECT;
+
+        error = xfs_iomap(XFS_I(inode), offset, size, flags, &imap, &nimap,
+                          &new);
         if (error)
                 return -error;
         if (nimap == 0)
@@ -1579,8 +1398,7 @@ xfs_get_blocks(
         struct buffer_head      *bh_result,
         int                     create)
 {
-        return __xfs_get_blocks(inode, iblock,
-                                bh_result, create, 0, BMAPI_WRITE);
+        return __xfs_get_blocks(inode, iblock, bh_result, create, 0);
 }
 
 STATIC int
@@ -1590,61 +1408,59 @@ xfs_get_blocks_direct(
         struct buffer_head      *bh_result,
         int                     create)
 {
-        return __xfs_get_blocks(inode, iblock,
-                                bh_result, create, 1, BMAPI_WRITE|BMAPI_DIRECT);
+        return __xfs_get_blocks(inode, iblock, bh_result, create, 1);
 }
 
+/*
+ * Complete a direct I/O write request.
+ *
+ * If the private argument is non-NULL __xfs_get_blocks signals us that we
+ * need to issue a transaction to convert the range from unwritten to written
+ * extents.  In case this is regular synchronous I/O we just call xfs_end_io
+ * to do this and we are done.  But in case this was a successfull AIO
+ * request this handler is called from interrupt context, from which we
+ * can't start transactions.  In that case offload the I/O completion to
+ * the workqueues we also use for buffered I/O completion.
+ */
 STATIC void
-xfs_end_io_direct(
-        struct kiocb    *iocb,
-        loff_t          offset,
-        ssize_t         size,
-        void            *private)
+xfs_end_io_direct_write(
+        struct kiocb            *iocb,
+        loff_t                  offset,
+        ssize_t                 size,
+        void                    *private,
+        int                     ret,
+        bool                    is_async)
 {
-        xfs_ioend_t     *ioend = iocb->private;
+        struct xfs_ioend        *ioend = iocb->private;
 
         /*
-         * Non-NULL private data means we need to issue a transaction to
-         * convert a range from unwritten to written extents.  This needs
-         * to happen from process context but aio+dio I/O completion
-         * happens from irq context so we need to defer it to a workqueue.
-         * This is not necessary for synchronous direct I/O, but we do
-         * it anyway to keep the code uniform and simpler.
-         *
-         * Well, if only it were that simple. Because synchronous direct I/O
-         * requires extent conversion to occur *before* we return to userspace,
-         * we have to wait for extent conversion to complete. Look at the
-         * iocb that has been passed to us to determine if this is AIO or
-         * not. If it is synchronous, tell xfs_finish_ioend() to kick the
-         * workqueue and wait for it to complete.
-         *
-         * The core direct I/O code might be changed to always call the
-         * completion handler in the future, in which case all this can
-         * go away.
+         * blockdev_direct_IO can return an error even after the I/O
+         * completion handler was called.  Thus we need to protect
+         * against double-freeing.
          */
+        iocb->private = NULL;
+
         ioend->io_offset = offset;
         ioend->io_size = size;
-        if (ioend->io_type == IO_READ) {
-                xfs_finish_ioend(ioend, 0);
-        } else if (private && size > 0) {
-                xfs_finish_ioend(ioend, is_sync_kiocb(iocb));
-        } else {
+        if (private && size > 0)
+                ioend->io_type = IO_UNWRITTEN;
+
+        if (is_async) {
                 /*
-                 * A direct I/O write ioend starts it's life in unwritten
-                 * state in case they map an unwritten extent.  This write
-                 * didn't map an unwritten extent so switch it's completion
-                 * handler.
+                 * If we are converting an unwritten extent we need to delay
+                 * the AIO completion until after the unwrittent extent
+                 * conversion has completed, otherwise do it ASAP.
                  */
-                ioend->io_type = IO_NEW;
-                xfs_finish_ioend(ioend, 0);
+                if (ioend->io_type == IO_UNWRITTEN) {
+                        ioend->io_iocb = iocb;
+                        ioend->io_result = ret;
+                } else {
+                        aio_complete(iocb, ret, 0);
+                }
+                xfs_finish_ioend(ioend);
+        } else {
+                xfs_finish_ioend_sync(ioend);
         }
-
-        /*
-         * blockdev_direct_IO can return an error even after the I/O
-         * completion handler was called.  Thus we need to protect
-         * against double-freeing.
-         */
-        iocb->private = NULL;
 }
 
 STATIC ssize_t
@@ -1655,23 +1471,26 @@ xfs_vm_direct_IO(
         loff_t                  offset,
         unsigned long           nr_segs)
 {
-        struct file     *file = iocb->ki_filp;
-        struct inode    *inode = file->f_mapping->host;
-        struct block_device *bdev;
-        ssize_t         ret;
-
-        bdev = xfs_find_bdev_for_inode(inode);
-
-        iocb->private = xfs_alloc_ioend(inode, rw == WRITE ?
-                                        IO_UNWRITTEN : IO_READ);
-
-        ret = blockdev_direct_IO_no_locking(rw, iocb, inode, bdev, iov,
-                                            offset, nr_segs,
-                                            xfs_get_blocks_direct,
-                                            xfs_end_io_direct);
+        struct inode            *inode = iocb->ki_filp->f_mapping->host;
+        struct block_device     *bdev = xfs_find_bdev_for_inode(inode);
+        ssize_t                 ret;
+
+        if (rw & WRITE) {
+                iocb->private = xfs_alloc_ioend(inode, IO_NEW);
+
+                ret = blockdev_direct_IO_no_locking(rw, iocb, inode, bdev, iov,
+                                                    offset, nr_segs,
+                                                    xfs_get_blocks_direct,
+                                                    xfs_end_io_direct_write);
+                if (ret != -EIOCBQUEUED && iocb->private)
+                        xfs_destroy_ioend(iocb->private);
+        } else {
+                ret = blockdev_direct_IO_no_locking(rw, iocb, inode, bdev, iov,
+                                                    offset, nr_segs,
+                                                    xfs_get_blocks_direct,
+                                                    NULL);
+        }
 
-        if (unlikely(ret != -EIOCBQUEUED && iocb->private))
-                xfs_destroy_ioend(iocb->private);
         return ret;
 }
 
@@ -1686,8 +1505,8 @@ xfs_vm_write_begin(
         void                    **fsdata)
 {
         *pagep = NULL;
-        return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
-                                                                xfs_get_blocks);
+        return block_write_begin(file, mapping, pos, len, flags | AOP_FLAG_NOFS,
+                                 pagep, fsdata, xfs_get_blocks);
 }
 
 STATIC sector_t
@@ -1698,7 +1517,7 @@ xfs_vm_bmap(
         struct inode            *inode = (struct inode *)mapping->host;
         struct xfs_inode        *ip = XFS_I(inode);
 
-        xfs_itrace_entry(XFS_I(inode));
+        trace_xfs_vm_bmap(XFS_I(inode));
         xfs_ilock(ip, XFS_IOLOCK_SHARED);
         xfs_flush_pages(ip, (xfs_off_t)0, -1, 0, FI_REMAPF);
         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
diff --git a/fs/xfs/linux-2.6/xfs_aops.h b/fs/xfs/linux-2.6/xfs_aops.h
index 4cfc6ea87df8..c5057fb6237a 100644
--- a/fs/xfs/linux-2.6/xfs_aops.h
+++ b/fs/xfs/linux-2.6/xfs_aops.h
@@ -37,6 +37,8 @@ typedef struct xfs_ioend {
         size_t                  io_size;        /* size of the extent */
         xfs_off_t               io_offset;      /* offset in the file */
         struct work_struct      io_work;        /* xfsdatad work queue */
+        struct kiocb            *io_iocb;
+        int                     io_result;
 } xfs_ioend_t;
 
 extern const struct address_space_operations xfs_address_space_operations;
@@ -45,6 +47,6 @@ extern int xfs_get_blocks(struct inode *, sector_t, struct buffer_head *, int);
 extern void xfs_ioend_init(void);
 extern void xfs_ioend_wait(struct xfs_inode *);
 
-extern void xfs_count_page_state(struct page *, int *, int *, int *);
+extern void xfs_count_page_state(struct page *, int *, int *);
 
 #endif /* __XFS_AOPS_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 2ee3f7a60163..ea79072f5210 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -39,7 +39,6 @@
 #include "xfs_inum.h"
 #include "xfs_log.h"
 #include "xfs_ag.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_trace.h"
 
@@ -579,9 +578,9 @@ _xfs_buf_read(
                         XBF_READ_AHEAD | _XBF_RUN_QUEUES);
 
         status = xfs_buf_iorequest(bp);
-        if (!status && !(flags & XBF_ASYNC))
-                status = xfs_buf_iowait(bp);
-        return status;
+        if (status || XFS_BUF_ISERROR(bp) || (flags & XBF_ASYNC))
+                return status;
+        return xfs_buf_iowait(bp);
 }
 
 xfs_buf_t *
@@ -897,36 +896,6 @@ xfs_buf_unlock(
         trace_xfs_buf_unlock(bp, _RET_IP_);
 }
 
-
-/*
- *      Pinning Buffer Storage in Memory
- *      Ensure that no attempt to force a buffer to disk will succeed.
- */
-void
-xfs_buf_pin(
-        xfs_buf_t               *bp)
-{
-        trace_xfs_buf_pin(bp, _RET_IP_);
-        atomic_inc(&bp->b_pin_count);
-}
-
-void
-xfs_buf_unpin(
-        xfs_buf_t               *bp)
-{
-        trace_xfs_buf_unpin(bp, _RET_IP_);
-
-        if (atomic_dec_and_test(&bp->b_pin_count))
-                wake_up_all(&bp->b_waiters);
-}
-
-int
-xfs_buf_ispin(
-        xfs_buf_t               *bp)
-{
-        return atomic_read(&bp->b_pin_count);
-}
-
 STATIC void
 xfs_buf_wait_unpin(
         xfs_buf_t               *bp)
@@ -1018,13 +987,12 @@ xfs_bwrite(
 {
         int                     error;
 
-        bp->b_strat = xfs_bdstrat_cb;
         bp->b_mount = mp;
         bp->b_flags |= XBF_WRITE;
         bp->b_flags &= ~(XBF_ASYNC | XBF_READ);
 
         xfs_buf_delwri_dequeue(bp);
-        xfs_buf_iostrategy(bp);
+        xfs_bdstrat_cb(bp);
 
         error = xfs_buf_iowait(bp);
         if (error)
@@ -1040,7 +1008,6 @@ xfs_bdwrite(
 {
         trace_xfs_buf_bdwrite(bp, _RET_IP_);
 
-        bp->b_strat = xfs_bdstrat_cb;
         bp->b_mount = mp;
 
         bp->b_flags &= ~XBF_READ;
@@ -1075,7 +1042,6 @@ xfs_bioerror(
         XFS_BUF_UNDONE(bp);
         XFS_BUF_STALE(bp);
 
-        XFS_BUF_CLR_BDSTRAT_FUNC(bp);
         xfs_biodone(bp);
 
         return EIO;
@@ -1105,7 +1071,6 @@ xfs_bioerror_relse(
         XFS_BUF_DONE(bp);
         XFS_BUF_STALE(bp);
         XFS_BUF_CLR_IODONE_FUNC(bp);
-        XFS_BUF_CLR_BDSTRAT_FUNC(bp);
         if (!(fl & XBF_ASYNC)) {
                 /*
                  * Mark b_error and B_ERROR _both_.
@@ -1311,8 +1276,19 @@ submit_io:
                 if (size)
                         goto next_chunk;
         } else {
-                bio_put(bio);
+                /*
+                 * 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);
         }
 }
 
@@ -1804,7 +1780,7 @@ xfs_buf_delwri_split(
                 trace_xfs_buf_delwri_split(bp, _RET_IP_);
                 ASSERT(bp->b_flags & XBF_DELWRI);
 
-                if (!xfs_buf_ispin(bp) && !xfs_buf_cond_lock(bp)) {
+                if (!XFS_BUF_ISPINNED(bp) && !xfs_buf_cond_lock(bp)) {
                         if (!force &&
                             time_before(jiffies, bp->b_queuetime + age)) {
                                 xfs_buf_unlock(bp);
@@ -1889,7 +1865,7 @@ xfsbufd(
                         struct xfs_buf *bp;
                         bp = list_first_entry(&tmp, struct xfs_buf, b_list);
                         list_del_init(&bp->b_list);
-                        xfs_buf_iostrategy(bp);
+                        xfs_bdstrat_cb(bp);
                         count++;
                 }
                 if (count)
@@ -1936,7 +1912,7 @@ xfs_flush_buftarg(
                         bp->b_flags &= ~XBF_ASYNC;
                         list_add(&bp->b_list, &wait_list);
                 }
-                xfs_buf_iostrategy(bp);
+                xfs_bdstrat_cb(bp);
         }
 
         if (wait) {
diff --git a/fs/xfs/linux-2.6/xfs_buf.h b/fs/xfs/linux-2.6/xfs_buf.h
index 5fbecefa5dfd..d072e5ff923b 100644
--- a/fs/xfs/linux-2.6/xfs_buf.h
+++ b/fs/xfs/linux-2.6/xfs_buf.h
@@ -44,57 +44,57 @@ typedef enum {
         XBRW_ZERO = 3,                  /* Zero target memory */
 } xfs_buf_rw_t;
 
-typedef enum {
-        XBF_READ = (1 << 0),    /* buffer intended for reading from device */
-        XBF_WRITE = (1 << 1),   /* buffer intended for writing to device   */
-        XBF_MAPPED = (1 << 2),  /* buffer mapped (b_addr valid)            */
-        XBF_ASYNC = (1 << 4),   /* initiator will not wait for completion  */
-        XBF_DONE = (1 << 5),    /* all pages in the buffer uptodate        */
-        XBF_DELWRI = (1 << 6),  /* buffer has dirty pages                  */
-        XBF_STALE = (1 << 7),   /* buffer has been staled, do not find it  */
-        XBF_FS_MANAGED = (1 << 8),  /* filesystem controls freeing memory  */
-        XBF_ORDERED = (1 << 11),    /* use ordered writes                  */
-        XBF_READ_AHEAD = (1 << 12), /* asynchronous read-ahead             */
-        XBF_LOG_BUFFER = (1 << 13), /* this is a buffer used for the log   */
-
-        /* flags used only as arguments to access routines */
-        XBF_LOCK = (1 << 14),       /* lock requested                      */
-        XBF_TRYLOCK = (1 << 15),    /* lock requested, but do not wait     */
-        XBF_DONT_BLOCK = (1 << 16), /* do not block in current thread      */
-
-        /* flags used only internally */
-        _XBF_PAGE_CACHE = (1 << 17),/* backed by pagecache                 */
-        _XBF_PAGES = (1 << 18),     /* backed by refcounted pages          */
-        _XBF_RUN_QUEUES = (1 << 19),/* run block device task queue         */
-        _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.
-         */
-        _XBF_PAGE_LOCKED = (1 << 22),
-
-        /*
-         * If we try a barrier write, but it fails we have to communicate
-         * this to the upper layers.  Unfortunately b_error gets overwritten
-         * when the buffer is re-issued so we have to add another flag to
-         * keep this information.
-         */
-        _XFS_BARRIER_FAILED = (1 << 23),
-} xfs_buf_flags_t;
+#define XBF_READ        (1 << 0) /* buffer intended for reading from device */
+#define XBF_WRITE       (1 << 1) /* buffer intended for writing to device */
+#define XBF_MAPPED      (1 << 2) /* buffer mapped (b_addr valid) */
+#define XBF_ASYNC       (1 << 4) /* initiator will not wait for completion */
+#define XBF_DONE        (1 << 5) /* all pages in the buffer uptodate */
+#define XBF_DELWRI      (1 << 6) /* buffer has dirty pages */
+#define XBF_STALE       (1 << 7) /* buffer has been staled, do not find it */
+#define XBF_FS_MANAGED  (1 << 8) /* filesystem controls freeing memory */
+#define XBF_ORDERED     (1 << 11)/* use ordered writes */
+#define XBF_READ_AHEAD  (1 << 12)/* asynchronous read-ahead */
+#define XBF_LOG_BUFFER  (1 << 13)/* this is a buffer used for the log */
+
+/* flags used only as arguments to access routines */
+#define XBF_LOCK        (1 << 14)/* lock requested */
+#define XBF_TRYLOCK     (1 << 15)/* lock requested, but do not wait */
+#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_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)
+
+/*
+ * If we try a barrier write, but it fails we have to communicate
+ * this to the upper layers.  Unfortunately b_error gets overwritten
+ * when the buffer is re-issued so we have to add another flag to
+ * keep this information.
+ */
+#define _XFS_BARRIER_FAILED     (1 << 23)
+
+typedef unsigned int xfs_buf_flags_t;
 
 #define XFS_BUF_FLAGS \
         { XBF_READ,             "READ" }, \
@@ -187,7 +187,6 @@ typedef struct xfs_buf {
         atomic_t                b_io_remaining; /* #outstanding I/O requests */
         xfs_buf_iodone_t        b_iodone;       /* I/O completion function */
         xfs_buf_relse_t         b_relse;        /* releasing function */
-        xfs_buf_bdstrat_t       b_strat;        /* pre-write function */
         struct completion       b_iowait;       /* queue for I/O waiters */
         void                    *b_fspriv;
         void                    *b_fspriv2;
@@ -245,11 +244,6 @@ extern int xfs_buf_iowait(xfs_buf_t *);
 extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, void *,
                                 xfs_buf_rw_t);
 
-static inline int xfs_buf_iostrategy(xfs_buf_t *bp)
-{
-        return bp->b_strat ? bp->b_strat(bp) : xfs_buf_iorequest(bp);
-}
-
 static inline int xfs_buf_geterror(xfs_buf_t *bp)
 {
         return bp ? bp->b_error : ENOMEM;
@@ -258,11 +252,6 @@ static inline int xfs_buf_geterror(xfs_buf_t *bp)
 /* Buffer Utility Routines */
 extern xfs_caddr_t xfs_buf_offset(xfs_buf_t *, size_t);
 
-/* Pinning Buffer Storage in Memory */
-extern void xfs_buf_pin(xfs_buf_t *);
-extern void xfs_buf_unpin(xfs_buf_t *);
-extern int xfs_buf_ispin(xfs_buf_t *);
-
 /* Delayed Write Buffer Routines */
 extern void xfs_buf_delwri_dequeue(xfs_buf_t *);
 extern void xfs_buf_delwri_promote(xfs_buf_t *);
@@ -326,8 +315,6 @@ extern void xfs_buf_terminate(void);
 #define XFS_BUF_IODONE_FUNC(bp)                 ((bp)->b_iodone)
 #define XFS_BUF_SET_IODONE_FUNC(bp, func)       ((bp)->b_iodone = (func))
 #define XFS_BUF_CLR_IODONE_FUNC(bp)             ((bp)->b_iodone = NULL)
-#define XFS_BUF_SET_BDSTRAT_FUNC(bp, func)      ((bp)->b_strat = (func))
-#define XFS_BUF_CLR_BDSTRAT_FUNC(bp)            ((bp)->b_strat = NULL)
 
 #define XFS_BUF_FSPRIVATE(bp, type)             ((type)(bp)->b_fspriv)
 #define XFS_BUF_SET_FSPRIVATE(bp, val)          ((bp)->b_fspriv = (void*)(val))
@@ -351,7 +338,7 @@ extern void xfs_buf_terminate(void);
 #define XFS_BUF_SET_VTYPE(bp, type)             do { } while (0)
 #define XFS_BUF_SET_REF(bp, ref)                do { } while (0)
 
-#define XFS_BUF_ISPINNED(bp)    xfs_buf_ispin(bp)
+#define XFS_BUF_ISPINNED(bp)    atomic_read(&((bp)->b_pin_count))
 
 #define XFS_BUF_VALUSEMA(bp)    xfs_buf_lock_value(bp)
 #define XFS_BUF_CPSEMA(bp)      (xfs_buf_cond_lock(bp) == 0)
@@ -370,8 +357,6 @@ static inline void xfs_buf_relse(xfs_buf_t *bp)
         xfs_buf_rele(bp);
 }
 
-#define xfs_bpin(bp)            xfs_buf_pin(bp)
-#define xfs_bunpin(bp)          xfs_buf_unpin(bp)
 #define xfs_biodone(bp)         xfs_buf_ioend(bp, 0)
 
 #define xfs_biomove(bp, off, len, data, rw) \
diff --git a/fs/xfs/linux-2.6/xfs_dmapi_priv.h b/fs/xfs/linux-2.6/xfs_dmapi_priv.h
deleted file mode 100644
index a8b0b1685eed..000000000000
--- a/fs/xfs/linux-2.6/xfs_dmapi_priv.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2000-2006 Silicon Graphics, 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
- */
-#ifndef __XFS_DMAPI_PRIV_H__
-#define __XFS_DMAPI_PRIV_H__
-
-/*
- *      Based on IO_ISDIRECT, decide which i_ flag is set.
- */
-#define DM_SEM_FLAG_RD(ioflags) (((ioflags) & IO_ISDIRECT) ? \
-                              DM_FLAGS_IMUX : 0)
-#define DM_SEM_FLAG_WR  (DM_FLAGS_IALLOCSEM_WR | DM_FLAGS_IMUX)
-
-#endif /*__XFS_DMAPI_PRIV_H__*/
diff --git a/fs/xfs/linux-2.6/xfs_export.c b/fs/xfs/linux-2.6/xfs_export.c
index e7839ee49e43..3764d74790ec 100644
--- a/fs/xfs/linux-2.6/xfs_export.c
+++ b/fs/xfs/linux-2.6/xfs_export.c
@@ -23,13 +23,13 @@
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir2.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_export.h"
 #include "xfs_vnodeops.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
+#include "xfs_trace.h"
 
 /*
  * Note that we only accept fileids which are long enough rather than allow
@@ -132,8 +132,7 @@ xfs_nfs_get_inode(
          * fine and not an indication of a corrupted filesystem as clients can
          * send invalid file handles and we have to handle it gracefully..
          */
-        error = xfs_iget(mp, NULL, ino, XFS_IGET_UNTRUSTED,
-                         XFS_ILOCK_SHARED, &ip);
+        error = xfs_iget(mp, NULL, ino, XFS_IGET_UNTRUSTED, 0, &ip);
         if (error) {
                 /*
                  * EINVAL means the inode cluster doesn't exist anymore.
@@ -148,11 +147,10 @@ xfs_nfs_get_inode(
         }
 
         if (ip->i_d.di_gen != generation) {
-                xfs_iput_new(ip, XFS_ILOCK_SHARED);
+                IRELE(ip);
                 return ERR_PTR(-ENOENT);
         }
 
-        xfs_iunlock(ip, XFS_ILOCK_SHARED);
         return VFS_I(ip);
 }
 
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 257a56b127cf..ba8ad422a165 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -22,23 +22,15 @@
 #include "xfs_inum.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir2.h"
 #include "xfs_trans.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
 #include "xfs_alloc.h"
-#include "xfs_btree.h"
-#include "xfs_attr_sf.h"
-#include "xfs_dir2_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
-#include "xfs_rw.h"
 #include "xfs_vnodeops.h"
 #include "xfs_da_btree.h"
 #include "xfs_ioctl.h"
@@ -108,7 +100,7 @@ xfs_file_fsync(
         int                     error = 0;
         int                     log_flushed = 0;
 
-        xfs_itrace_entry(ip);
+        trace_xfs_file_fsync(ip);
 
         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
                 return -XFS_ERROR(EIO);
@@ -166,8 +158,7 @@ xfs_file_fsync(
                  * transaction.  So we play it safe and fire off the
                  * transaction anyway.
                  */
-                xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
-                xfs_trans_ihold(tp, ip);
+                xfs_trans_ijoin(tp, ip);
                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
                 xfs_trans_set_sync(tp);
                 error = _xfs_trans_commit(tp, 0, &log_flushed);
@@ -275,20 +266,6 @@ xfs_file_aio_read(
                 mutex_lock(&inode->i_mutex);
         xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
-        if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {
-                int dmflags = FILP_DELAY_FLAG(file) | DM_SEM_FLAG_RD(ioflags);
-                int iolock = XFS_IOLOCK_SHARED;
-
-                ret = -XFS_SEND_DATA(mp, DM_EVENT_READ, ip, iocb->ki_pos, size,
-                                        dmflags, &iolock);
-                if (ret) {
-                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
-                        if (unlikely(ioflags & IO_ISDIRECT))
-                                mutex_unlock(&inode->i_mutex);
-                        return ret;
-                }
-        }
-
         if (unlikely(ioflags & IO_ISDIRECT)) {
                 if (inode->i_mapping->nrpages) {
                         ret = -xfs_flushinval_pages(ip,
@@ -321,7 +298,6 @@ xfs_file_splice_read(
         unsigned int            flags)
 {
         struct xfs_inode        *ip = XFS_I(infilp->f_mapping->host);
-        struct xfs_mount        *mp = ip->i_mount;
         int                     ioflags = 0;
         ssize_t                 ret;
 
@@ -335,18 +311,6 @@ xfs_file_splice_read(
 
         xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
-        if (DM_EVENT_ENABLED(ip, DM_EVENT_READ) && !(ioflags & IO_INVIS)) {
-                int iolock = XFS_IOLOCK_SHARED;
-                int error;
-
-                error = XFS_SEND_DATA(mp, DM_EVENT_READ, ip, *ppos, count,
-                                        FILP_DELAY_FLAG(infilp), &iolock);
-                if (error) {
-                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
-                        return -error;
-                }
-        }
-
         trace_xfs_file_splice_read(ip, count, *ppos, ioflags);
 
         ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
@@ -367,7 +331,6 @@ xfs_file_splice_write(
 {
         struct inode            *inode = outfilp->f_mapping->host;
         struct xfs_inode        *ip = XFS_I(inode);
-        struct xfs_mount        *mp = ip->i_mount;
         xfs_fsize_t             isize, new_size;
         int                     ioflags = 0;
         ssize_t                 ret;
@@ -382,18 +345,6 @@ xfs_file_splice_write(
 
         xfs_ilock(ip, XFS_IOLOCK_EXCL);
 
-        if (DM_EVENT_ENABLED(ip, DM_EVENT_WRITE) && !(ioflags & IO_INVIS)) {
-                int iolock = XFS_IOLOCK_EXCL;
-                int error;
-
-                error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, ip, *ppos, count,
-                                        FILP_DELAY_FLAG(outfilp), &iolock);
-                if (error) {
-                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-                        return -error;
-                }
-        }
-
         new_size = *ppos + count;
 
         xfs_ilock(ip, XFS_ILOCK_EXCL);
@@ -463,7 +414,7 @@ xfs_zero_last_block(
         last_fsb = XFS_B_TO_FSBT(mp, isize);
         nimaps = 1;
         error = xfs_bmapi(NULL, ip, last_fsb, 1, 0, NULL, 0, &imap,
-                          &nimaps, NULL, NULL);
+                          &nimaps, NULL);
         if (error) {
                 return error;
         }
@@ -558,7 +509,7 @@ xfs_zero_eof(
                 nimaps = 1;
                 zero_count_fsb = end_zero_fsb - start_zero_fsb + 1;
                 error = xfs_bmapi(NULL, ip, start_zero_fsb, zero_count_fsb,
-                                  0, NULL, 0, &imap, &nimaps, NULL, NULL);
+                                  0, NULL, 0, &imap, &nimaps, NULL);
                 if (error) {
                         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_IOLOCK_EXCL));
                         return error;
@@ -627,7 +578,6 @@ xfs_file_aio_write(
         int                     ioflags = 0;
         xfs_fsize_t             isize, new_size;
         int                     iolock;
-        int                     eventsent = 0;
         size_t                  ocount = 0, count;
         int                     need_i_mutex;
 
@@ -673,33 +623,6 @@ start:
                 goto out_unlock_mutex;
         }
 
-        if ((DM_EVENT_ENABLED(ip, DM_EVENT_WRITE) &&
-            !(ioflags & IO_INVIS) && !eventsent)) {
-                int             dmflags = FILP_DELAY_FLAG(file);
-
-                if (need_i_mutex)
-                        dmflags |= DM_FLAGS_IMUX;
-
-                xfs_iunlock(ip, XFS_ILOCK_EXCL);
-                error = XFS_SEND_DATA(ip->i_mount, DM_EVENT_WRITE, ip,
-                                      pos, count, dmflags, &iolock);
-                if (error) {
-                        goto out_unlock_internal;
-                }
-                xfs_ilock(ip, XFS_ILOCK_EXCL);
-                eventsent = 1;
-
-                /*
-                 * The iolock was dropped and reacquired in XFS_SEND_DATA
-                 * so we have to recheck the size when appending.
-                 * We will only "goto start;" once, since having sent the
-                 * event prevents another call to XFS_SEND_DATA, which is
-                 * what allows the size to change in the first place.
-                 */
-                if ((file->f_flags & O_APPEND) && pos != ip->i_size)
-                        goto start;
-        }
-
         if (ioflags & IO_ISDIRECT) {
                 xfs_buftarg_t   *target =
                         XFS_IS_REALTIME_INODE(ip) ?
@@ -830,22 +753,6 @@ write_retry:
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
         }
 
-        if (ret == -ENOSPC &&
-            DM_EVENT_ENABLED(ip, DM_EVENT_NOSPACE) && !(ioflags & IO_INVIS)) {
-                xfs_iunlock(ip, iolock);
-                if (need_i_mutex)
-                        mutex_unlock(&inode->i_mutex);
-                error = XFS_SEND_NAMESP(ip->i_mount, DM_EVENT_NOSPACE, ip,
-                                DM_RIGHT_NULL, ip, DM_RIGHT_NULL, NULL, NULL,
-                                0, 0, 0); /* Delay flag intentionally  unused */
-                if (need_i_mutex)
-                        mutex_lock(&inode->i_mutex);
-                xfs_ilock(ip, iolock);
-                if (error)
-                        goto out_unlock_internal;
-                goto start;
-        }
-
         error = -ret;
         if (ret <= 0)
                 goto out_unlock_internal;
@@ -1014,9 +921,6 @@ const struct file_operations xfs_file_operations = {
         .open           = xfs_file_open,
         .release        = xfs_file_release,
         .fsync          = xfs_file_fsync,
-#ifdef HAVE_FOP_OPEN_EXEC
-        .open_exec      = xfs_file_open_exec,
-#endif
 };
 
 const struct file_operations xfs_dir_file_operations = {
diff --git a/fs/xfs/linux-2.6/xfs_fs_subr.c b/fs/xfs/linux-2.6/xfs_fs_subr.c
index b6918d76bc7b..1f279b012f94 100644
--- a/fs/xfs/linux-2.6/xfs_fs_subr.c
+++ b/fs/xfs/linux-2.6/xfs_fs_subr.c
@@ -21,10 +21,6 @@
 #include "xfs_inode.h"
 #include "xfs_trace.h"
 
-int  fs_noerr(void) { return 0; }
-int  fs_nosys(void) { return ENOSYS; }
-void fs_noval(void) { return; }
-
 /*
  * note: all filemap functions return negative error codes. These
  * need to be inverted before returning to the xfs core functions.
diff --git a/fs/xfs/linux-2.6/xfs_fs_subr.h b/fs/xfs/linux-2.6/xfs_fs_subr.h
deleted file mode 100644
index 82bb19b2599e..000000000000
--- a/fs/xfs/linux-2.6/xfs_fs_subr.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright (c) 2000,2002,2005 Silicon Graphics, 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
- */
-#ifndef __XFS_FS_SUBR_H__
-#define __XFS_FS_SUBR_H__
-
-extern int  fs_noerr(void);
-extern int  fs_nosys(void);
-extern void fs_noval(void);
-
-#endif  /* __XFS_FS_SUBR_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index e59a81062830..237f5ffb2ee8 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -23,24 +23,15 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir2.h"
 #include "xfs_alloc.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_attr_sf.h"
-#include "xfs_dir2_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_ioctl.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_itable.h"
 #include "xfs_error.h"
-#include "xfs_rw.h"
 #include "xfs_attr.h"
 #include "xfs_bmap.h"
 #include "xfs_buf_item.h"
@@ -908,7 +899,7 @@ xfs_ioctl_setattr(
         struct xfs_dquot        *olddquot = NULL;
         int                     code;
 
-        xfs_itrace_entry(ip);
+        trace_xfs_ioctl_setattr(ip);
 
         if (mp->m_flags & XFS_MOUNT_RDONLY)
                 return XFS_ERROR(EROFS);
@@ -1043,8 +1034,7 @@ xfs_ioctl_setattr(
                 }
         }
 
-        xfs_trans_ijoin(tp, ip, lock_flags);
-        xfs_trans_ihold(tp, ip);
+        xfs_trans_ijoin(tp, ip);
 
         /*
          * Change file ownership.  Must be the owner or privileged.
@@ -1116,16 +1106,7 @@ xfs_ioctl_setattr(
         xfs_qm_dqrele(udqp);
         xfs_qm_dqrele(gdqp);
 
-        if (code)
-                return code;
-
-        if (DM_EVENT_ENABLED(ip, DM_EVENT_ATTRIBUTE)) {
-                XFS_SEND_NAMESP(mp, DM_EVENT_ATTRIBUTE, ip, DM_RIGHT_NULL,
-                                NULL, DM_RIGHT_NULL, NULL, NULL, 0, 0,
-                                (mask & FSX_NONBLOCK) ? DM_FLAGS_NDELAY : 0);
-        }
-
-        return 0;
+        return code;
 
  error_return:
         xfs_qm_dqrele(udqp);
@@ -1301,7 +1282,7 @@ xfs_file_ioctl(
         if (filp->f_mode & FMODE_NOCMTIME)
                 ioflags |= IO_INVIS;
 
-        xfs_itrace_entry(ip);
+        trace_xfs_file_ioctl(ip);
 
         switch (cmd) {
         case XFS_IOC_ALLOCSP:
diff --git a/fs/xfs/linux-2.6/xfs_ioctl32.c b/fs/xfs/linux-2.6/xfs_ioctl32.c
index 52ed49e6465c..6c83f7f62dc9 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl32.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl32.c
@@ -28,12 +28,8 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir2.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
-#include "xfs_dir2_sf.h"
 #include "xfs_vnode.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
@@ -544,7 +540,7 @@ xfs_file_compat_ioctl(
         if (filp->f_mode & FMODE_NOCMTIME)
                 ioflags |= IO_INVIS;
 
-        xfs_itrace_entry(ip);
+        trace_xfs_file_compat_ioctl(ip);
 
         switch (cmd) {
         /* No size or alignment issues on any arch */
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 44f0b2de153e..536b81e63a3d 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -24,21 +24,13 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir2.h"
 #include "xfs_alloc.h"
-#include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_itable.h"
@@ -496,7 +488,7 @@ xfs_vn_getattr(
         struct xfs_inode        *ip = XFS_I(inode);
         struct xfs_mount        *mp = ip->i_mount;
 
-        xfs_itrace_entry(ip);
+        trace_xfs_getattr(ip);
 
         if (XFS_FORCED_SHUTDOWN(mp))
                 return XFS_ERROR(EIO);
diff --git a/fs/xfs/linux-2.6/xfs_linux.h b/fs/xfs/linux-2.6/xfs_linux.h
index facfb323a706..998a9d7fb9c8 100644
--- a/fs/xfs/linux-2.6/xfs_linux.h
+++ b/fs/xfs/linux-2.6/xfs_linux.h
@@ -87,7 +87,6 @@
 #include <xfs_aops.h>
 #include <xfs_super.h>
 #include <xfs_globals.h>
-#include <xfs_fs_subr.h>
 #include <xfs_buf.h>
 
 /*
diff --git a/fs/xfs/linux-2.6/xfs_quotaops.c b/fs/xfs/linux-2.6/xfs_quotaops.c
index 067cafbfc635..bfd5ac9d1f6f 100644
--- a/fs/xfs/linux-2.6/xfs_quotaops.c
+++ b/fs/xfs/linux-2.6/xfs_quotaops.c
@@ -16,7 +16,6 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
-#include "xfs_dmapi.h"
 #include "xfs_sb.h"
 #include "xfs_inum.h"
 #include "xfs_log.h"
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 80938c736c27..758df94690ed 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -25,14 +25,11 @@
 #include "xfs_ag.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
-#include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
@@ -43,7 +40,6 @@
 #include "xfs_error.h"
 #include "xfs_itable.h"
 #include "xfs_fsops.h"
-#include "xfs_rw.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
@@ -94,7 +90,6 @@ mempool_t *xfs_ioend_pool;
 #define MNTOPT_BARRIER  "barrier"       /* use writer barriers for log write and
                                          * unwritten extent conversion */
 #define MNTOPT_NOBARRIER "nobarrier"    /* .. disable */
-#define MNTOPT_OSYNCISOSYNC "osyncisosync" /* o_sync is REALLY o_sync */
 #define MNTOPT_64BITINODE   "inode64"   /* inodes can be allocated anywhere */
 #define MNTOPT_IKEEP    "ikeep"         /* do not free empty inode clusters */
 #define MNTOPT_NOIKEEP  "noikeep"       /* free empty inode clusters */
@@ -116,9 +111,6 @@ mempool_t *xfs_ioend_pool;
 #define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
 #define MNTOPT_PQUOTANOENF "pqnoenforce"/* project quota limit enforcement */
 #define MNTOPT_QUOTANOENF  "qnoenforce" /* same as uqnoenforce */
-#define MNTOPT_DMAPI    "dmapi"         /* DMI enabled (DMAPI / XDSM) */
-#define MNTOPT_XDSM     "xdsm"          /* DMI enabled (DMAPI / XDSM) */
-#define MNTOPT_DMI      "dmi"           /* DMI enabled (DMAPI / XDSM) */
 #define MNTOPT_DELAYLOG   "delaylog"    /* Delayed loging enabled */
 #define MNTOPT_NODELAYLOG "nodelaylog"  /* Delayed loging disabled */
 
@@ -172,15 +164,13 @@ suffix_strtoul(char *s, char **endp, unsigned int base)
 STATIC int
 xfs_parseargs(
         struct xfs_mount        *mp,
-        char                    *options,
-        char                    **mtpt)
+        char                    *options)
 {
         struct super_block      *sb = mp->m_super;
         char                    *this_char, *value, *eov;
         int                     dsunit = 0;
         int                     dswidth = 0;
         int                     iosize = 0;
-        int                     dmapi_implies_ikeep = 1;
         __uint8_t               iosizelog = 0;
 
         /*
@@ -243,15 +233,10 @@ xfs_parseargs(
                         if (!mp->m_logname)
                                 return ENOMEM;
                 } else if (!strcmp(this_char, MNTOPT_MTPT)) {
-                        if (!value || !*value) {
-                                cmn_err(CE_WARN,
-                                        "XFS: %s option requires an argument",
-                                        this_char);
-                                return EINVAL;
-                        }
-                        *mtpt = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
-                        if (!*mtpt)
-                                return ENOMEM;
+                        cmn_err(CE_WARN,
+                                "XFS: %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,
@@ -288,8 +273,6 @@ xfs_parseargs(
                         mp->m_flags &= ~XFS_MOUNT_GRPID;
                 } else if (!strcmp(this_char, MNTOPT_WSYNC)) {
                         mp->m_flags |= XFS_MOUNT_WSYNC;
-                } else if (!strcmp(this_char, MNTOPT_OSYNCISOSYNC)) {
-                        mp->m_flags |= XFS_MOUNT_OSYNCISOSYNC;
                 } else if (!strcmp(this_char, MNTOPT_NORECOVERY)) {
                         mp->m_flags |= XFS_MOUNT_NORECOVERY;
                 } else if (!strcmp(this_char, MNTOPT_NOALIGN)) {
@@ -329,7 +312,6 @@ xfs_parseargs(
                 } else if (!strcmp(this_char, MNTOPT_IKEEP)) {
                         mp->m_flags |= XFS_MOUNT_IKEEP;
                 } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
-                        dmapi_implies_ikeep = 0;
                         mp->m_flags &= ~XFS_MOUNT_IKEEP;
                 } else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
                         mp->m_flags &= ~XFS_MOUNT_COMPAT_IOSIZE;
@@ -370,12 +352,6 @@ xfs_parseargs(
                 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
                         mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
                         mp->m_qflags &= ~XFS_OQUOTA_ENFD;
-                } else if (!strcmp(this_char, MNTOPT_DMAPI)) {
-                        mp->m_flags |= XFS_MOUNT_DMAPI;
-                } else if (!strcmp(this_char, MNTOPT_XDSM)) {
-                        mp->m_flags |= XFS_MOUNT_DMAPI;
-                } else if (!strcmp(this_char, MNTOPT_DMI)) {
-                        mp->m_flags |= XFS_MOUNT_DMAPI;
                 } else if (!strcmp(this_char, MNTOPT_DELAYLOG)) {
                         mp->m_flags |= XFS_MOUNT_DELAYLOG;
                         cmn_err(CE_WARN,
@@ -387,9 +363,11 @@ xfs_parseargs(
                         cmn_err(CE_WARN,
         "XFS: ihashsize no longer used, option is deprecated.");
                 } else if (!strcmp(this_char, "osyncisdsync")) {
-                        /* no-op, this is now the default */
                         cmn_err(CE_WARN,
-        "XFS: osyncisdsync is now the default, option is deprecated.");
+        "XFS: 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.");
                 } else if (!strcmp(this_char, "irixsgid")) {
                         cmn_err(CE_WARN,
         "XFS: irixsgid is now a sysctl(2) variable, option is deprecated.");
@@ -430,12 +408,6 @@ xfs_parseargs(
                 return EINVAL;
         }
 
-        if ((mp->m_flags & XFS_MOUNT_DMAPI) && (!*mtpt || *mtpt[0] == '\0')) {
-                printk("XFS: %s option needs the mount point option as well\n",
-                        MNTOPT_DMAPI);
-                return EINVAL;
-        }
-
         if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
                 cmn_err(CE_WARN,
                         "XFS: sunit and swidth must be specified together");
@@ -449,18 +421,6 @@ xfs_parseargs(
                 return EINVAL;
         }
 
-        /*
-         * Applications using DMI filesystems often expect the
-         * inode generation number to be monotonically increasing.
-         * If we delete inode chunks we break this assumption, so
-         * keep unused inode chunks on disk for DMI filesystems
-         * until we come up with a better solution.
-         * Note that if "ikeep" or "noikeep" mount options are
-         * supplied, then they are honored.
-         */
-        if ((mp->m_flags & XFS_MOUNT_DMAPI) && dmapi_implies_ikeep)
-                mp->m_flags |= XFS_MOUNT_IKEEP;
-
 done:
         if (!(mp->m_flags & XFS_MOUNT_NOALIGN)) {
                 /*
@@ -539,10 +499,8 @@ xfs_showargs(
                 { XFS_MOUNT_SWALLOC,            "," MNTOPT_SWALLOC },
                 { XFS_MOUNT_NOUUID,             "," MNTOPT_NOUUID },
                 { XFS_MOUNT_NORECOVERY,         "," MNTOPT_NORECOVERY },
-                { XFS_MOUNT_OSYNCISOSYNC,       "," MNTOPT_OSYNCISOSYNC },
                 { XFS_MOUNT_ATTR2,              "," MNTOPT_ATTR2 },
                 { XFS_MOUNT_FILESTREAMS,        "," MNTOPT_FILESTREAM },
-                { XFS_MOUNT_DMAPI,              "," MNTOPT_DMAPI },
                 { XFS_MOUNT_GRPID,              "," MNTOPT_GRPID },
                 { XFS_MOUNT_DELAYLOG,           "," MNTOPT_DELAYLOG },
                 { 0, NULL }
@@ -947,7 +905,7 @@ xfs_fs_destroy_inode(
 {
         struct xfs_inode        *ip = XFS_I(inode);
 
-        xfs_itrace_entry(ip);
+        trace_xfs_destroy_inode(ip);
 
         XFS_STATS_INC(vn_reclaim);
 
@@ -1063,10 +1021,8 @@ xfs_log_inode(
          * an inode in another recent transaction.  So we play it safe and
          * fire off the transaction anyway.
          */
-        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
-        xfs_trans_ihold(tp, ip);
+        xfs_trans_ijoin(tp, ip);
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-        xfs_trans_set_sync(tp);
         error = xfs_trans_commit(tp, 0);
         xfs_ilock_demote(ip, XFS_ILOCK_EXCL);
 
@@ -1082,27 +1038,18 @@ xfs_fs_write_inode(
         struct xfs_mount        *mp = ip->i_mount;
         int                     error = EAGAIN;
 
-        xfs_itrace_entry(ip);
+        trace_xfs_write_inode(ip);
 
         if (XFS_FORCED_SHUTDOWN(mp))
                 return XFS_ERROR(EIO);
 
         if (wbc->sync_mode == WB_SYNC_ALL) {
                 /*
-                 * Make sure the inode has hit stable storage.  By using the
-                 * log and the fsync transactions we reduce the IOs we have
-                 * to do here from two (log and inode) to just the log.
-                 *
-                 * Note: We still need to do a delwri write of the inode after
-                 * this to flush it to the backing buffer so that bulkstat
-                 * works properly if this is the first time the inode has been
-                 * written.  Because we hold the ilock atomically over the
-                 * transaction commit and the inode flush we are guaranteed
-                 * that the inode is not pinned when it returns. If the flush
-                 * lock is already held, then the inode has already been
-                 * flushed once and we don't need to flush it again.  Hence
-                 * the code will only flush the inode if it isn't already
-                 * being flushed.
+                 * Make sure the inode has made it it into the log.  Instead
+                 * of forcing it all the way to stable storage using a
+                 * synchronous transaction we let the log force inside the
+                 * ->sync_fs call do that for thus, which reduces the number
+                 * of synchronous log foces dramatically.
                  */
                 xfs_ioend_wait(ip);
                 xfs_ilock(ip, XFS_ILOCK_SHARED);
@@ -1116,27 +1063,29 @@ xfs_fs_write_inode(
                  * We make this non-blocking if the inode is contended, return
                  * EAGAIN to indicate to the caller that they did not succeed.
                  * This prevents the flush path from blocking on inodes inside
-                 * another operation right now, they get caught later by xfs_sync.
+                 * another operation right now, they get caught later by
+                 * xfs_sync.
                  */
                 if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
                         goto out;
-        }
 
-        if (xfs_ipincount(ip) || !xfs_iflock_nowait(ip))
-                goto out_unlock;
+                if (xfs_ipincount(ip) || !xfs_iflock_nowait(ip))
+                        goto out_unlock;
 
-        /*
-         * Now we have the flush lock and the inode is not pinned, we can check
-         * if the inode is really clean as we know that there are no pending
-         * transaction completions, it is not waiting on the delayed write
-         * queue and there is no IO in progress.
-         */
-        if (xfs_inode_clean(ip)) {
-                xfs_ifunlock(ip);
-                error = 0;
-                goto out_unlock;
+                /*
+                 * Now we have the flush lock and the inode is not pinned, we
+                 * can check if the inode is really clean as we know that
+                 * there are no pending transaction completions, it is not
+                 * waiting on the delayed write queue and there is no IO in
+                 * progress.
+                 */
+                if (xfs_inode_clean(ip)) {
+                        xfs_ifunlock(ip);
+                        error = 0;
+                        goto out_unlock;
+                }
+                error = xfs_iflush(ip, 0);
         }
-        error = xfs_iflush(ip, 0);
 
  out_unlock:
         xfs_iunlock(ip, XFS_ILOCK_SHARED);
@@ -1156,7 +1105,8 @@ xfs_fs_clear_inode(
 {
         xfs_inode_t             *ip = XFS_I(inode);
 
-        xfs_itrace_entry(ip);
+        trace_xfs_clear_inode(ip);
+
         XFS_STATS_INC(vn_rele);
         XFS_STATS_INC(vn_remove);
         XFS_STATS_DEC(vn_active);
@@ -1193,22 +1143,13 @@ xfs_fs_put_super(
 {
         struct xfs_mount        *mp = XFS_M(sb);
 
+        /*
+         * Unregister the memory shrinker before we tear down the mount
+         * structure so we don't have memory reclaim racing with us here.
+         */
+        xfs_inode_shrinker_unregister(mp);
         xfs_syncd_stop(mp);
 
-        if (!(sb->s_flags & MS_RDONLY)) {
-                /*
-                 * XXX(hch): this should be SYNC_WAIT.
-                 *
-                 * Or more likely not needed at all because the VFS is already
-                 * calling ->sync_fs after shutting down all filestem
-                 * operations and just before calling ->put_super.
-                 */
-                xfs_sync_data(mp, 0);
-                xfs_sync_attr(mp, 0);
-        }
-
-        XFS_SEND_PREUNMOUNT(mp);
-
         /*
          * Blow away any referenced inode in the filestreams cache.
          * This can and will cause log traffic as inodes go inactive
@@ -1218,14 +1159,10 @@ xfs_fs_put_super(
 
         XFS_bflush(mp->m_ddev_targp);
 
-        XFS_SEND_UNMOUNT(mp);
-
         xfs_unmountfs(mp);
         xfs_freesb(mp);
-        xfs_inode_shrinker_unregister(mp);
         xfs_icsb_destroy_counters(mp);
         xfs_close_devices(mp);
-        xfs_dmops_put(mp);
         xfs_free_fsname(mp);
         kfree(mp);
 }
@@ -1543,7 +1480,6 @@ xfs_fs_fill_super(
         struct inode            *root;
         struct xfs_mount        *mp = NULL;
         int                     flags = 0, error = ENOMEM;
-        char                    *mtpt = NULL;
 
         mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
         if (!mp)
@@ -1559,7 +1495,7 @@ xfs_fs_fill_super(
         mp->m_super = sb;
         sb->s_fs_info = mp;
 
-        error = xfs_parseargs(mp, (char *)data, &mtpt);
+        error = xfs_parseargs(mp, (char *)data);
         if (error)
                 goto out_free_fsname;
 
@@ -1571,16 +1507,12 @@ xfs_fs_fill_super(
 #endif
         sb->s_op = &xfs_super_operations;
 
-        error = xfs_dmops_get(mp);
-        if (error)
-                goto out_free_fsname;
-
         if (silent)
                 flags |= XFS_MFSI_QUIET;
 
         error = xfs_open_devices(mp);
         if (error)
-                goto out_put_dmops;
+                goto out_free_fsname;
 
         if (xfs_icsb_init_counters(mp))
                 mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB;
@@ -1608,8 +1540,6 @@ xfs_fs_fill_super(
         if (error)
                 goto out_filestream_unmount;
 
-        XFS_SEND_MOUNT(mp, DM_RIGHT_NULL, mtpt, mp->m_fsname);
-
         sb->s_magic = XFS_SB_MAGIC;
         sb->s_blocksize = mp->m_sb.sb_blocksize;
         sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
@@ -1638,7 +1568,6 @@ xfs_fs_fill_super(
 
         xfs_inode_shrinker_register(mp);
 
-        kfree(mtpt);
         return 0;
 
  out_filestream_unmount:
@@ -1648,11 +1577,8 @@ xfs_fs_fill_super(
  out_destroy_counters:
         xfs_icsb_destroy_counters(mp);
         xfs_close_devices(mp);
- out_put_dmops:
-        xfs_dmops_put(mp);
  out_free_fsname:
         xfs_free_fsname(mp);
-        kfree(mtpt);
         kfree(mp);
  out:
         return -error;
@@ -1759,6 +1685,12 @@ xfs_init_zones(void)
         if (!xfs_trans_zone)
                 goto out_destroy_ifork_zone;
 
+        xfs_log_item_desc_zone =
+                kmem_zone_init(sizeof(struct xfs_log_item_desc),
+                               "xfs_log_item_desc");
+        if (!xfs_log_item_desc_zone)
+                goto out_destroy_trans_zone;
+
         /*
          * The size of the zone allocated buf log item is the maximum
          * size possible under XFS.  This wastes a little bit of memory,
@@ -1768,7 +1700,7 @@ xfs_init_zones(void)
                                 (((XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK) /
                                   NBWORD) * sizeof(int))), "xfs_buf_item");
         if (!xfs_buf_item_zone)
-                goto out_destroy_trans_zone;
+                goto out_destroy_log_item_desc_zone;
 
         xfs_efd_zone = kmem_zone_init((sizeof(xfs_efd_log_item_t) +
                         ((XFS_EFD_MAX_FAST_EXTENTS - 1) *
@@ -1805,6 +1737,8 @@ xfs_init_zones(void)
         kmem_zone_destroy(xfs_efd_zone);
  out_destroy_buf_item_zone:
         kmem_zone_destroy(xfs_buf_item_zone);
+ out_destroy_log_item_desc_zone:
+        kmem_zone_destroy(xfs_log_item_desc_zone);
  out_destroy_trans_zone:
         kmem_zone_destroy(xfs_trans_zone);
  out_destroy_ifork_zone:
@@ -1835,6 +1769,7 @@ xfs_destroy_zones(void)
         kmem_zone_destroy(xfs_efi_zone);
         kmem_zone_destroy(xfs_efd_zone);
         kmem_zone_destroy(xfs_buf_item_zone);
+        kmem_zone_destroy(xfs_log_item_desc_zone);
         kmem_zone_destroy(xfs_trans_zone);
         kmem_zone_destroy(xfs_ifork_zone);
         kmem_zone_destroy(xfs_dabuf_zone);
diff --git a/fs/xfs/linux-2.6/xfs_super.h b/fs/xfs/linux-2.6/xfs_super.h
index 519618e9279e..1ef4a4d2d997 100644
--- a/fs/xfs/linux-2.6/xfs_super.h
+++ b/fs/xfs/linux-2.6/xfs_super.h
@@ -56,12 +56,6 @@ extern void xfs_qm_exit(void);
 # define XFS_BIGFS_STRING
 #endif
 
-#ifdef CONFIG_XFS_DMAPI
-# define XFS_DMAPI_STRING       "dmapi support, "
-#else
-# define XFS_DMAPI_STRING
-#endif
-
 #ifdef DEBUG
 # define XFS_DBG_STRING         "debug"
 #else
@@ -72,7 +66,6 @@ extern void xfs_qm_exit(void);
                                 XFS_SECURITY_STRING \
                                 XFS_REALTIME_STRING \
                                 XFS_BIGFS_STRING \
-                                XFS_DMAPI_STRING \
                                 XFS_DBG_STRING /* DBG must be last */
 
 struct xfs_inode;
diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index a51a07c3a70c..dfcbd98d1599 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -24,25 +24,14 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir2.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_attr_sf.h"
 #include "xfs_inode.h"
 #include "xfs_dinode.h"
 #include "xfs_error.h"
-#include "xfs_mru_cache.h"
 #include "xfs_filestream.h"
 #include "xfs_vnodeops.h"
-#include "xfs_utils.h"
-#include "xfs_buf_item.h"
 #include "xfs_inode_item.h"
-#include "xfs_rw.h"
 #include "xfs_quota.h"
 #include "xfs_trace.h"
 
@@ -319,7 +308,7 @@ xfs_sync_inode_attr(
 /*
  * Write out pagecache data for the whole filesystem.
  */
-int
+STATIC int
 xfs_sync_data(
         struct xfs_mount        *mp,
         int                     flags)
@@ -340,7 +329,7 @@ xfs_sync_data(
 /*
  * Write out inode metadata (attributes) for the whole filesystem.
  */
-int
+STATIC int
 xfs_sync_attr(
         struct xfs_mount        *mp,
         int                     flags)
@@ -373,8 +362,7 @@ xfs_commit_dummy_trans(
 
         xfs_ilock(ip, XFS_ILOCK_EXCL);
 
-        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
-        xfs_trans_ihold(tp, ip);
+        xfs_trans_ijoin(tp, ip);
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
         error = xfs_trans_commit(tp, 0);
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
@@ -867,7 +855,36 @@ out:
 reclaim:
         xfs_ifunlock(ip);
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
-        xfs_ireclaim(ip);
+
+        XFS_STATS_INC(xs_ig_reclaims);
+        /*
+         * Remove the inode from the per-AG radix tree.
+         *
+         * Because radix_tree_delete won't complain even if the item was never
+         * added to the tree assert that it's been there before to catch
+         * problems with the inode life time early on.
+         */
+        write_lock(&pag->pag_ici_lock);
+        if (!radix_tree_delete(&pag->pag_ici_root,
+                                XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino)))
+                ASSERT(0);
+        write_unlock(&pag->pag_ici_lock);
+
+        /*
+         * Here we do an (almost) spurious inode lock in order to coordinate
+         * with inode cache radix tree lookups.  This is because the lookup
+         * can reference the inodes in the cache without taking references.
+         *
+         * We make that OK here by ensuring that we wait until the inode is
+         * unlocked after the lookup before we go ahead and free it.  We get
+         * both the ilock and the iolock because the code may need to drop the
+         * ilock one but will still hold the iolock.
+         */
+        xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
+        xfs_qm_dqdetach(ip);
+        xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
+
+        xfs_inode_free(ip);
         return error;
 
 }
diff --git a/fs/xfs/linux-2.6/xfs_sync.h b/fs/xfs/linux-2.6/xfs_sync.h
index e28139aaa4aa..fe78726196f8 100644
--- a/fs/xfs/linux-2.6/xfs_sync.h
+++ b/fs/xfs/linux-2.6/xfs_sync.h
@@ -35,9 +35,6 @@ typedef struct xfs_sync_work {
 int xfs_syncd_init(struct xfs_mount *mp);
 void xfs_syncd_stop(struct xfs_mount *mp);
 
-int xfs_sync_attr(struct xfs_mount *mp, int flags);
-int xfs_sync_data(struct xfs_mount *mp, int flags);
-
 int xfs_quiesce_data(struct xfs_mount *mp);
 void xfs_quiesce_attr(struct xfs_mount *mp);
 
diff --git a/fs/xfs/linux-2.6/xfs_trace.c b/fs/xfs/linux-2.6/xfs_trace.c
index d12be8470cba..88d25d4aa56e 100644
--- a/fs/xfs/linux-2.6/xfs_trace.c
+++ b/fs/xfs/linux-2.6/xfs_trace.c
@@ -24,17 +24,13 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir2.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
-#include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_ialloc.h"
 #include "xfs_itable.h"
diff --git a/fs/xfs/linux-2.6/xfs_trace.h b/fs/xfs/linux-2.6/xfs_trace.h
index 302820690904..c657cdca2cd2 100644
--- a/fs/xfs/linux-2.6/xfs_trace.h
+++ b/fs/xfs/linux-2.6/xfs_trace.h
@@ -317,8 +317,6 @@ DEFINE_BUF_EVENT(xfs_buf_init);
 DEFINE_BUF_EVENT(xfs_buf_free);
 DEFINE_BUF_EVENT(xfs_buf_hold);
 DEFINE_BUF_EVENT(xfs_buf_rele);
-DEFINE_BUF_EVENT(xfs_buf_pin);
-DEFINE_BUF_EVENT(xfs_buf_unpin);
 DEFINE_BUF_EVENT(xfs_buf_iodone);
 DEFINE_BUF_EVENT(xfs_buf_iorequest);
 DEFINE_BUF_EVENT(xfs_buf_bawrite);
@@ -541,7 +539,7 @@ DEFINE_LOCK_EVENT(xfs_ilock_nowait);
 DEFINE_LOCK_EVENT(xfs_ilock_demote);
 DEFINE_LOCK_EVENT(xfs_iunlock);
 
-DECLARE_EVENT_CLASS(xfs_iget_class,
+DECLARE_EVENT_CLASS(xfs_inode_class,
         TP_PROTO(struct xfs_inode *ip),
         TP_ARGS(ip),
         TP_STRUCT__entry(
@@ -557,16 +555,38 @@ DECLARE_EVENT_CLASS(xfs_iget_class,
                   __entry->ino)
 )
 
-#define DEFINE_IGET_EVENT(name) \
-DEFINE_EVENT(xfs_iget_class, name, \
+#define DEFINE_INODE_EVENT(name) \
+DEFINE_EVENT(xfs_inode_class, name, \
         TP_PROTO(struct xfs_inode *ip), \
         TP_ARGS(ip))
-DEFINE_IGET_EVENT(xfs_iget_skip);
-DEFINE_IGET_EVENT(xfs_iget_reclaim);
-DEFINE_IGET_EVENT(xfs_iget_found);
-DEFINE_IGET_EVENT(xfs_iget_alloc);
-
-DECLARE_EVENT_CLASS(xfs_inode_class,
+DEFINE_INODE_EVENT(xfs_iget_skip);
+DEFINE_INODE_EVENT(xfs_iget_reclaim);
+DEFINE_INODE_EVENT(xfs_iget_reclaim_fail);
+DEFINE_INODE_EVENT(xfs_iget_hit);
+DEFINE_INODE_EVENT(xfs_iget_miss);
+
+DEFINE_INODE_EVENT(xfs_getattr);
+DEFINE_INODE_EVENT(xfs_setattr);
+DEFINE_INODE_EVENT(xfs_readlink);
+DEFINE_INODE_EVENT(xfs_alloc_file_space);
+DEFINE_INODE_EVENT(xfs_free_file_space);
+DEFINE_INODE_EVENT(xfs_readdir);
+#ifdef CONFIG_XFS_POSIX_ACL
+DEFINE_INODE_EVENT(xfs_check_acl);
+#endif
+DEFINE_INODE_EVENT(xfs_vm_bmap);
+DEFINE_INODE_EVENT(xfs_file_ioctl);
+DEFINE_INODE_EVENT(xfs_file_compat_ioctl);
+DEFINE_INODE_EVENT(xfs_ioctl_setattr);
+DEFINE_INODE_EVENT(xfs_file_fsync);
+DEFINE_INODE_EVENT(xfs_destroy_inode);
+DEFINE_INODE_EVENT(xfs_write_inode);
+DEFINE_INODE_EVENT(xfs_clear_inode);
+
+DEFINE_INODE_EVENT(xfs_dquot_dqalloc);
+DEFINE_INODE_EVENT(xfs_dquot_dqdetach);
+
+DECLARE_EVENT_CLASS(xfs_iref_class,
         TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip),
         TP_ARGS(ip, caller_ip),
         TP_STRUCT__entry(
@@ -591,20 +611,71 @@ DECLARE_EVENT_CLASS(xfs_inode_class,
                   (char *)__entry->caller_ip)
 )
 
-#define DEFINE_INODE_EVENT(name) \
-DEFINE_EVENT(xfs_inode_class, name, \
+#define DEFINE_IREF_EVENT(name) \
+DEFINE_EVENT(xfs_iref_class, name, \
         TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \
         TP_ARGS(ip, caller_ip))
-DEFINE_INODE_EVENT(xfs_ihold);
-DEFINE_INODE_EVENT(xfs_irele);
-DEFINE_INODE_EVENT(xfs_inode_pin);
-DEFINE_INODE_EVENT(xfs_inode_unpin);
-DEFINE_INODE_EVENT(xfs_inode_unpin_nowait);
+DEFINE_IREF_EVENT(xfs_ihold);
+DEFINE_IREF_EVENT(xfs_irele);
+DEFINE_IREF_EVENT(xfs_inode_pin);
+DEFINE_IREF_EVENT(xfs_inode_unpin);
+DEFINE_IREF_EVENT(xfs_inode_unpin_nowait);
+
+DECLARE_EVENT_CLASS(xfs_namespace_class,
+        TP_PROTO(struct xfs_inode *dp, struct xfs_name *name),
+        TP_ARGS(dp, name),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_ino_t, dp_ino)
+                __dynamic_array(char, name, name->len)
+        ),
+        TP_fast_assign(
+                __entry->dev = VFS_I(dp)->i_sb->s_dev;
+                __entry->dp_ino = dp->i_ino;
+                memcpy(__get_str(name), name->name, name->len);
+        ),
+        TP_printk("dev %d:%d dp ino 0x%llx name %s",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->dp_ino,
+                  __get_str(name))
+)
 
-/* the old xfs_itrace_entry tracer - to be replaced by s.th. in the VFS */
-DEFINE_INODE_EVENT(xfs_inode);
-#define xfs_itrace_entry(ip)    \
-        trace_xfs_inode(ip, _THIS_IP_)
+#define DEFINE_NAMESPACE_EVENT(name) \
+DEFINE_EVENT(xfs_namespace_class, name, \
+        TP_PROTO(struct xfs_inode *dp, struct xfs_name *name), \
+        TP_ARGS(dp, name))
+DEFINE_NAMESPACE_EVENT(xfs_remove);
+DEFINE_NAMESPACE_EVENT(xfs_link);
+DEFINE_NAMESPACE_EVENT(xfs_lookup);
+DEFINE_NAMESPACE_EVENT(xfs_create);
+DEFINE_NAMESPACE_EVENT(xfs_symlink);
+
+TRACE_EVENT(xfs_rename,
+        TP_PROTO(struct xfs_inode *src_dp, struct xfs_inode *target_dp,
+                 struct xfs_name *src_name, struct xfs_name *target_name),
+        TP_ARGS(src_dp, target_dp, src_name, target_name),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_ino_t, src_dp_ino)
+                __field(xfs_ino_t, target_dp_ino)
+                __dynamic_array(char, src_name, src_name->len)
+                __dynamic_array(char, target_name, target_name->len)
+        ),
+        TP_fast_assign(
+                __entry->dev = VFS_I(src_dp)->i_sb->s_dev;
+                __entry->src_dp_ino = src_dp->i_ino;
+                __entry->target_dp_ino = target_dp->i_ino;
+                memcpy(__get_str(src_name), src_name->name, src_name->len);
+                memcpy(__get_str(target_name), target_name->name, target_name->len);
+        ),
+        TP_printk("dev %d:%d src dp ino 0x%llx target dp ino 0x%llx"
+                  " src name %s target name %s",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->src_dp_ino,
+                  __entry->target_dp_ino,
+                  __get_str(src_name),
+                  __get_str(target_name))
+)
 
 DECLARE_EVENT_CLASS(xfs_dquot_class,
         TP_PROTO(struct xfs_dquot *dqp),
@@ -684,9 +755,6 @@ DEFINE_DQUOT_EVENT(xfs_dqrele);
 DEFINE_DQUOT_EVENT(xfs_dqflush);
 DEFINE_DQUOT_EVENT(xfs_dqflush_force);
 DEFINE_DQUOT_EVENT(xfs_dqflush_done);
-/* not really iget events, but we re-use the format */
-DEFINE_IGET_EVENT(xfs_dquot_dqalloc);
-DEFINE_IGET_EVENT(xfs_dquot_dqdetach);
 
 DECLARE_EVENT_CLASS(xfs_loggrant_class,
         TP_PROTO(struct log *log, struct xlog_ticket *tic),
@@ -834,33 +902,29 @@ DECLARE_EVENT_CLASS(xfs_page_class,
                 __field(loff_t, size)
                 __field(unsigned long, offset)
                 __field(int, delalloc)
-                __field(int, unmapped)
                 __field(int, unwritten)
         ),
         TP_fast_assign(
-                int delalloc = -1, unmapped = -1, unwritten = -1;
+                int delalloc = -1, unwritten = -1;
 
                 if (page_has_buffers(page))
-                        xfs_count_page_state(page, &delalloc,
-                                             &unmapped, &unwritten);
+                        xfs_count_page_state(page, &delalloc, &unwritten);
                 __entry->dev = inode->i_sb->s_dev;
                 __entry->ino = XFS_I(inode)->i_ino;
                 __entry->pgoff = page_offset(page);
                 __entry->size = i_size_read(inode);
                 __entry->offset = off;
                 __entry->delalloc = delalloc;
-                __entry->unmapped = unmapped;
                 __entry->unwritten = unwritten;
         ),
         TP_printk("dev %d:%d ino 0x%llx pgoff 0x%lx size 0x%llx offset %lx "
-                  "delalloc %d unmapped %d unwritten %d",
+                  "delalloc %d unwritten %d",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   __entry->ino,
                   __entry->pgoff,
                   __entry->size,
                   __entry->offset,
                   __entry->delalloc,
-                  __entry->unmapped,
                   __entry->unwritten)
 )