- [sparc32] grsec disabled.

[packages/kernel.git] / linux-2.6-xfs-cvs-20040102.patch

diff -urN linux.org/fs/xfs/linux/xfs_aops.c linux/fs/xfs/linux/xfs_aops.c
--- linux.org/fs/xfs/linux/xfs_aops.c   2003-12-31 05:48:20.000000000 +0100
+++ linux/fs/xfs/linux/xfs_aops.c       2004-01-02 04:21:43.000000000 +0100
@@ -51,10 +51,11 @@
 #include "xfs_inode.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
+#include "xfs_iomap.h"
 #include <linux/mpage.h>
 
 STATIC void convert_page(struct inode *, struct page *,
-                       page_buf_bmap_t *, void *, int, int);
+                       xfs_iomap_t *, void *, int, int);
 
 void
 linvfs_unwritten_done(
@@ -85,11 +86,9 @@
        vnode_t         *vp = XFS_BUF_FSPRIVATE(bp, vnode_t *);
        int             error;
 
-       if (atomic_read(&bp->pb_hold) < 1) 
-               BUG();
-
+       BUG_ON(atomic_read(&bp->pb_hold) < 1);
        VOP_BMAP(vp, XFS_BUF_OFFSET(bp), XFS_BUF_SIZE(bp),
-                       BMAP_UNWRITTEN, NULL, NULL, error);
+                       BMAPI_UNWRITTEN, NULL, NULL, error);
        XFS_BUF_SET_FSPRIVATE(bp, NULL);
        XFS_BUF_CLR_IODONE_FUNC(bp);
        XFS_BUF_UNDATAIO(bp);
@@ -117,7 +116,7 @@
                vnode_t *vp = LINVFS_GET_VP(inode);
                int     error;
 
-               VOP_BMAP(vp, offset, size, BMAP_UNWRITTEN, NULL, NULL, error);
+               VOP_BMAP(vp, offset, size, BMAPI_UNWRITTEN, NULL, NULL, error);
        }
 }
 
@@ -126,26 +125,26 @@
        struct inode            *inode,
        loff_t                  offset,
        ssize_t                 count,
-       page_buf_bmap_t         *pbmapp,
+       xfs_iomap_t             *iomapp,
        int                     flags)
 {
        vnode_t                 *vp = LINVFS_GET_VP(inode);
-       int                     error, nmaps = 1;
+       int                     error, niomaps = 1;
 
-       if (((flags & (BMAP_DIRECT|BMAP_SYNC)) == BMAP_DIRECT) &&
+       if (((flags & (BMAPI_DIRECT|BMAPI_SYNC)) == BMAPI_DIRECT) &&
            (offset >= i_size_read(inode)))
                count = max_t(ssize_t, count, XFS_WRITE_IO_LOG);
 retry:
-       VOP_BMAP(vp, offset, count, flags, pbmapp, &nmaps, error);
+       VOP_BMAP(vp, offset, count, flags, iomapp, &niomaps, error);
        if ((error == EAGAIN) || (error == EIO))
                return -error;
-       if (unlikely((flags & (BMAP_WRITE|BMAP_DIRECT)) ==
-                                       (BMAP_WRITE|BMAP_DIRECT) && nmaps &&
-                                       (pbmapp->pbm_flags & PBMF_DELAY))) {
-               flags = BMAP_ALLOCATE;
+       if (unlikely((flags & (BMAPI_WRITE|BMAPI_DIRECT)) ==
+                                       (BMAPI_WRITE|BMAPI_DIRECT) && niomaps &&
+                                       (iomapp->iomap_flags & IOMAP_DELAY))) {
+               flags = BMAPI_ALLOCATE;
                goto retry;
        }
-       if (flags & (BMAP_WRITE|BMAP_ALLOCATE)) {
+       if (flags & (BMAPI_WRITE|BMAPI_ALLOCATE)) {
                VMODIFY(vp);
        }
        return -error;
@@ -156,10 +155,10 @@
  * Finds the corresponding mapping in block @map array of the
  * given @offset within a @page.
  */
-STATIC page_buf_bmap_t *
+STATIC xfs_iomap_t *
 match_offset_to_mapping(
        struct page             *page,
-       page_buf_bmap_t         *map,
+       xfs_iomap_t             *iomapp,
        unsigned long           offset)
 {
        loff_t                  full_offset;    /* offset from start of file */
@@ -170,10 +169,10 @@
        full_offset <<= PAGE_CACHE_SHIFT;       /* offset from file start */
        full_offset += offset;                  /* offset from page start */
 
-       if (full_offset < map->pbm_offset)
+       if (full_offset < iomapp->iomap_offset)
                return NULL;
-       if (map->pbm_offset + map->pbm_bsize > full_offset)
-               return map;
+       if (iomapp->iomap_offset + iomapp->iomap_bsize > full_offset)
+               return iomapp;
        return NULL;
 }
 
@@ -183,30 +182,30 @@
        struct buffer_head      *bh,
        unsigned long           offset,
        int                     block_bits,
-       page_buf_bmap_t         *mp)
+       xfs_iomap_t             *iomapp)
 {
-       page_buf_daddr_t        bn;
+       xfs_daddr_t             bn;
        loff_t                  delta;
        int                     sector_shift;
 
-       ASSERT(!(mp->pbm_flags & PBMF_HOLE));
-       ASSERT(!(mp->pbm_flags & PBMF_DELAY));
-       ASSERT(mp->pbm_bn != PAGE_BUF_DADDR_NULL);
+       ASSERT(!(iomapp->iomap_flags & IOMAP_HOLE));
+       ASSERT(!(iomapp->iomap_flags & IOMAP_DELAY));
+       ASSERT(iomapp->iomap_bn != IOMAP_DADDR_NULL);
 
        delta = page->index;
        delta <<= PAGE_CACHE_SHIFT;
        delta += offset;
-       delta -= mp->pbm_offset;
+       delta -= iomapp->iomap_offset;
        delta >>= block_bits;
 
        sector_shift = block_bits - BBSHIFT;
-       bn = mp->pbm_bn >> sector_shift;
+       bn = iomapp->iomap_bn >> sector_shift;
        bn += delta;
-       ASSERT((bn << sector_shift) >= mp->pbm_bn);
+       ASSERT((bn << sector_shift) >= iomapp->iomap_bn);
 
        lock_buffer(bh);
        bh->b_blocknr = bn;
-       bh->b_bdev = mp->pbm_target->pbr_bdev;
+       bh->b_bdev = iomapp->iomap_target->pbr_bdev;
        set_buffer_mapped(bh);
        clear_buffer_delay(bh);
 }
@@ -222,7 +221,7 @@
 probe_unwritten_page(
        struct address_space    *mapping,
        unsigned long           index,
-       page_buf_bmap_t         *mp,
+       xfs_iomap_t             *iomapp,
        page_buf_t              *pb,
        unsigned long           max_offset,
        unsigned long           *fsbs,
@@ -245,11 +244,11 @@
                do {
                        if (!buffer_unwritten(bh))
                                break;
-                       if (!match_offset_to_mapping(page, mp, p_offset))
+                       if (!match_offset_to_mapping(page, iomapp, p_offset))
                                break;
                        if (p_offset >= max_offset)
                                break;
-                       map_buffer_at_offset(page, bh, p_offset, bbits, mp);
+                       map_buffer_at_offset(page, bh, p_offset, bbits, iomapp);
                        set_buffer_unwritten_io(bh);
                        bh->b_private = pb;
                        p_offset += bh->b_size;
@@ -394,11 +393,12 @@
        struct buffer_head      *curr,
        unsigned long           p_offset,
        int                     block_bits,
-       page_buf_bmap_t         *mp,
+       xfs_iomap_t             *iomapp,
+       int                     startio,
        int                     all_bh)
 {
        struct buffer_head      *bh = curr;
-       page_buf_bmap_t         *tmp;
+       xfs_iomap_t             *tmp;
        page_buf_t              *pb;
        loff_t                  offset, size;
        unsigned long           nblocks = 0;
@@ -407,8 +407,8 @@
        offset <<= PAGE_CACHE_SHIFT;
        offset += p_offset;
 
-       pb = pagebuf_lookup(mp->pbm_target,
-                           mp->pbm_offset, mp->pbm_bsize, 0);
+       pb = pagebuf_lookup(iomapp->iomap_target,
+                           iomapp->iomap_offset, iomapp->iomap_bsize, 0);
        if (!pb)
                return -EAGAIN;
 
@@ -433,10 +433,10 @@
        do {
                if (!buffer_unwritten(bh))
                        break;
-               tmp = match_offset_to_mapping(start_page, mp, p_offset);
+               tmp = match_offset_to_mapping(start_page, iomapp, p_offset);
                if (!tmp)
                        break;
-               map_buffer_at_offset(start_page, bh, p_offset, block_bits, mp);
+               map_buffer_at_offset(start_page, bh, p_offset, block_bits, iomapp);
                set_buffer_unwritten_io(bh);
                bh->b_private = pb;
                p_offset += bh->b_size;
@@ -444,8 +444,8 @@
        } while ((bh = bh->b_this_page) != head);
 
        if (unlikely(nblocks == 0)) {
-               printk("XFS: bad unwritten extent map: bh=0x%p, mp=0x%p\n",
-                       curr, mp);
+               printk("XFS: bad unwritten extent map: bh=0x%p, iomapp=0x%p\n",
+                      curr, iomapp);
                BUG();
        }
 
@@ -461,26 +461,26 @@
                struct page             *page;
 
                tlast = i_size_read(inode) >> PAGE_CACHE_SHIFT;
-               tloff = (mp->pbm_offset + mp->pbm_bsize) >> PAGE_CACHE_SHIFT;
+               tloff = (iomapp->iomap_offset + iomapp->iomap_bsize) >> PAGE_CACHE_SHIFT;
                tloff = min(tlast, tloff);
                for (tindex = start_page->index + 1; tindex < tloff; tindex++) {
-                       page = probe_unwritten_page(mapping, tindex, mp, pb,
+                       page = probe_unwritten_page(mapping, tindex, iomapp, pb,
                                                PAGE_CACHE_SIZE, &bs, bbits);
                        if (!page)
                                break;
                        nblocks += bs;
                        atomic_add(bs, &pb->pb_io_remaining);
-                       convert_page(inode, page, mp, pb, 1, all_bh);
+                       convert_page(inode, page, iomapp, pb, startio, all_bh);
                }
 
                if (tindex == tlast &&
                    (tloff = (i_size_read(inode) & (PAGE_CACHE_SIZE - 1)))) {
-                       page = probe_unwritten_page(mapping, tindex, mp, pb,
+                       page = probe_unwritten_page(mapping, tindex, iomapp, pb,
                                                        tloff, &bs, bbits);
                        if (page) {
                                nblocks += bs;
                                atomic_add(bs, &pb->pb_io_remaining);
-                               convert_page(inode, page, mp, pb, 1, all_bh);
+                               convert_page(inode, page, iomapp, pb, startio, all_bh);
                        }
                }
        }
@@ -542,13 +542,13 @@
 convert_page(
        struct inode            *inode,
        struct page             *page,
-       page_buf_bmap_t         *maps,
+       xfs_iomap_t             *iomapp,
        void                    *private,
        int                     startio,
        int                     all_bh)
 {
        struct buffer_head      *bh_arr[MAX_BUF_PER_PAGE], *bh, *head;
-       page_buf_bmap_t         *mp = maps, *tmp;
+       xfs_iomap_t             *mp = iomapp, *tmp;
        unsigned long           end, offset, end_index;
        int                     i = 0, index = 0;
        int                     bbits = inode->i_blkbits;
@@ -575,17 +575,17 @@
                tmp = match_offset_to_mapping(page, mp, offset);
                if (!tmp)
                        continue;
-               ASSERT(!(tmp->pbm_flags & PBMF_HOLE));
-               ASSERT(!(tmp->pbm_flags & PBMF_DELAY));
+               ASSERT(!(tmp->iomap_flags & IOMAP_HOLE));
+               ASSERT(!(tmp->iomap_flags & IOMAP_DELAY));
 
                /* If this is a new unwritten extent buffer (i.e. one
                 * that we haven't passed in private data for, we must
                 * now map this buffer too.
                 */
                if (buffer_unwritten(bh) && !bh->b_end_io) {
-                       ASSERT(tmp->pbm_flags & PBMF_UNWRITTEN);
+                       ASSERT(tmp->iomap_flags & IOMAP_UNWRITTEN);
                        map_unwritten(inode, page, head, bh,
-                                               offset, bbits, tmp, all_bh);
+                                       offset, bbits, tmp, startio, all_bh);
                } else if (! (buffer_unwritten(bh) && buffer_locked(bh))) {
                        map_buffer_at_offset(page, bh, offset, bbits, tmp);
                        if (buffer_unwritten(bh)) {
@@ -618,19 +618,19 @@
 cluster_write(
        struct inode            *inode,
        unsigned long           tindex,
-       page_buf_bmap_t         *mp,
+       xfs_iomap_t             *iomapp,
        int                     startio,
        int                     all_bh)
 {
        unsigned long           tlast;
        struct page             *page;
 
-       tlast = (mp->pbm_offset + mp->pbm_bsize) >> PAGE_CACHE_SHIFT;
+       tlast = (iomapp->iomap_offset + iomapp->iomap_bsize) >> PAGE_CACHE_SHIFT;
        for (; tindex < tlast; tindex++) {
                page = probe_delalloc_page(inode, tindex);
                if (!page)
                        break;
-               convert_page(inode, page, mp, NULL, startio, all_bh);
+               convert_page(inode, page, iomapp, NULL, startio, all_bh);
        }
 }
 
@@ -661,20 +661,21 @@
        int             unmapped) /* also implies page uptodate */
 {
        struct buffer_head      *bh_arr[MAX_BUF_PER_PAGE], *bh, *head;
-       page_buf_bmap_t         *mp, map;
+       xfs_iomap_t             *iomp, iomap;
        unsigned long           p_offset = 0, end_index;
        loff_t                  offset, end_offset;
        int                     len, err, i, cnt = 0, uptodate = 1;
-       int                     flags = startio ? 0 : BMAP_TRYLOCK;
+       int                     flags = startio ? 0 : BMAPI_TRYLOCK;
        int                     page_dirty = 1;
 
 
        /* Are we off the end of the file ? */
        end_index = i_size_read(inode) >> PAGE_CACHE_SHIFT;
        if (page->index >= end_index) {
-               unsigned remaining = i_size_read(inode) & (PAGE_CACHE_SIZE-1);
-               if ((page->index >= end_index+1) || !remaining) {
-                       return -EIO;
+               if ((page->index >= end_index + 1) ||
+                   !(i_size_read(inode) & (PAGE_CACHE_SIZE - 1))) {
+                       err = -EIO;
+                       goto error;
                }
        }
 
@@ -684,16 +685,19 @@
                end_offset = i_size_read(inode);
 
        bh = head = page_buffers(page);
-       mp = NULL;
+       iomp = NULL;
 
        len = bh->b_size;
        do {
-               if (!(PageUptodate(page) || buffer_uptodate(bh)) && !startio) {
-                       goto next_bh;
-               }
+               if (offset >= end_offset)
+                       break;
+               if (!buffer_uptodate(bh))
+                       uptodate = 0;
+               if (!(PageUptodate(page) || buffer_uptodate(bh)) && !startio)
+                       continue;
 
-               if (mp) {
-                       mp = match_offset_to_mapping(page, &map, p_offset);
+               if (iomp) {
+                       iomp = match_offset_to_mapping(page, &iomap, p_offset);
                }
 
                /*
@@ -701,21 +705,21 @@
                 * extent state conversion transaction on completion.
                 */
                if (buffer_unwritten(bh)) {
-                       if (!mp) {
-                               err = map_blocks(inode, offset, len, &map,
-                                               BMAP_READ|BMAP_IGNSTATE);
+                       if (!iomp) {
+                               err = map_blocks(inode, offset, len, &iomap,
+                                               BMAPI_READ|BMAPI_IGNSTATE);
                                if (err) {
                                        goto error;
                                }
-                               mp = match_offset_to_mapping(page, &map,
+                               iomp = match_offset_to_mapping(page, &iomap,
                                                                p_offset);
                        }
-                       if (mp) {
+                       if (iomp) {
                                if (!bh->b_end_io) {
                                        err = map_unwritten(inode, page,
                                                        head, bh, p_offset,
-                                                       inode->i_blkbits,
-                                                       mp, unmapped);
+                                                       inode->i_blkbits, iomp,
+                                                       startio, unmapped);
                                        if (err) {
                                                goto error;
                                        }
@@ -734,18 +738,18 @@
                 * We can return EAGAIN here in the release page case.
                 */
                } else if (buffer_delay(bh)) {
-                       if (!mp) {
-                               err = map_blocks(inode, offset, len, &map,
-                                       BMAP_ALLOCATE | flags);
+                       if (!iomp) {
+                               err = map_blocks(inode, offset, len, &iomap,
+                                       BMAPI_ALLOCATE | flags);
                                if (err) {
                                        goto error;
                                }
-                               mp = match_offset_to_mapping(page, &map,
+                               iomp = match_offset_to_mapping(page, &iomap,
                                                                p_offset);
                        }
-                       if (mp) {
+                       if (iomp) {
                                map_buffer_at_offset(page, bh, p_offset,
-                                       inode->i_blkbits, mp);
+                                       inode->i_blkbits, iomp);
                                if (startio) {
                                        bh_arr[cnt++] = bh;
                                } else {
@@ -766,22 +770,22 @@
                                 * was found, and we are in a path where we
                                 * need to write the whole page out.
                                 */
-                               if (!mp) {
+                               if (!iomp) {
                                        size = probe_unmapped_cluster(
                                                        inode, page, bh, head);
                                        err = map_blocks(inode, offset,
-                                               size, &map,
-                                               BMAP_WRITE | BMAP_MMAP);
+                                               size, &iomap,
+                                               BMAPI_WRITE | BMAPI_MMAP);
                                        if (err) {
                                                goto error;
                                        }
-                                       mp = match_offset_to_mapping(page, &map,
+                                       iomp = match_offset_to_mapping(page, &iomap,
                                                                     p_offset);
                                }
-                               if (mp) {
+                               if (iomp) {
                                        map_buffer_at_offset(page,
                                                        bh, p_offset,
-                                                       inode->i_blkbits, mp);
+                                                       inode->i_blkbits, iomp);
                                        if (startio) {
                                                bh_arr[cnt++] = bh;
                                        } else {
@@ -799,14 +803,8 @@
                                }
                        }
                }
-
-next_bh:
-               if (!buffer_uptodate(bh))
-                       uptodate = 0;
-               offset += len;
-               p_offset += len;
-               bh = bh->b_this_page;
-       } while (offset < end_offset);
+       } while (offset += len, p_offset += len,
+               ((bh = bh->b_this_page) != head));
 
        if (uptodate && bh == head)
                SetPageUptodate(page);
@@ -814,8 +812,8 @@
        if (startio)
                submit_page(page, bh_arr, cnt);
 
-       if (mp)
-               cluster_write(inode, page->index + 1, mp, startio, unmapped);
+       if (iomp)
+               cluster_write(inode, page->index + 1, iomp, startio, unmapped);
 
        return page_dirty;
 
@@ -849,7 +847,7 @@
        bmapi_flags_t           flags)
 {
        vnode_t                 *vp = LINVFS_GET_VP(inode);
-       page_buf_bmap_t         pbmap;
+       xfs_iomap_t             iomap;
        int                     retpbbm = 1;
        int                     error;
        ssize_t                 size;
@@ -866,32 +864,32 @@
                size = 1 << inode->i_blkbits;
 
        VOP_BMAP(vp, offset, size,
-               create ? flags : BMAP_READ, &pbmap, &retpbbm, error);
+               create ? flags : BMAPI_READ, &iomap, &retpbbm, error);
        if (error)
                return -error;
 
        if (retpbbm == 0)
                return 0;
 
-       if (pbmap.pbm_bn != PAGE_BUF_DADDR_NULL) {
-               page_buf_daddr_t        bn;
+       if (iomap.iomap_bn != IOMAP_DADDR_NULL) {
+               xfs_daddr_t             bn;
                loff_t                  delta;
 
                /* For unwritten extents do not report a disk address on
                 * the read case.
                 */
-               if (create || ((pbmap.pbm_flags & PBMF_UNWRITTEN) == 0)) {
-                       delta = offset - pbmap.pbm_offset;
+               if (create || ((iomap.iomap_flags & IOMAP_UNWRITTEN) == 0)) {
+                       delta = offset - iomap.iomap_offset;
                        delta >>= inode->i_blkbits;
 
-                       bn = pbmap.pbm_bn >> (inode->i_blkbits - BBSHIFT);
+                       bn = iomap.iomap_bn >> (inode->i_blkbits - BBSHIFT);
                        bn += delta;
 
                        bh_result->b_blocknr = bn;
-                       bh_result->b_bdev = pbmap.pbm_target->pbr_bdev;
+                       bh_result->b_bdev = iomap.iomap_target->pbr_bdev;
                        set_buffer_mapped(bh_result);
                }
-               if (pbmap.pbm_flags & PBMF_UNWRITTEN) {
+               if (iomap.iomap_flags & IOMAP_UNWRITTEN) {
                        if (create) {
                                if (direct)
                                        bh_result->b_private = inode;
@@ -902,29 +900,32 @@
                }
        }
 
+       /* If this is a realtime file, data might be on a new device */
+       bh_result->b_bdev = iomap.iomap_target->pbr_bdev;
+
        /* If we previously allocated a block out beyond eof and
         * we are now coming back to use it then we will need to
         * flag it as new even if it has a disk address.
         */
        if (create &&
            ((!buffer_mapped(bh_result) && !buffer_uptodate(bh_result)) ||
-            (offset >= i_size_read(inode)) || (pbmap.pbm_flags & PBMF_NEW))) {
+            (offset >= i_size_read(inode)) || (iomap.iomap_flags & IOMAP_NEW))) {
                set_buffer_new(bh_result);
        }
 
-       if (pbmap.pbm_flags & PBMF_DELAY) {
+       if (iomap.iomap_flags & IOMAP_DELAY) {
                if (unlikely(direct))
                        BUG();
                if (create) {
                        set_buffer_mapped(bh_result);
                        set_buffer_uptodate(bh_result);
                }
-               bh_result->b_bdev = pbmap.pbm_target->pbr_bdev;
+               bh_result->b_bdev = iomap.iomap_target->pbr_bdev;
                set_buffer_delay(bh_result);
        }
 
        if (blocks) {
-               size = (pbmap.pbm_bsize - pbmap.pbm_delta); 
+               size = (iomap.iomap_bsize - iomap.iomap_delta); 
                bh_result->b_size = min_t(ssize_t, size, blocks << inode->i_blkbits);
        }
 
@@ -939,7 +940,7 @@
        int                     create)
 {
        return linvfs_get_block_core(inode, iblock, 0, bh_result,
-                                       create, 0, BMAP_WRITE);
+                                       create, 0, BMAPI_WRITE);
 }
 
 STATIC int
@@ -950,7 +951,7 @@
        int                     create)
 {
        return linvfs_get_block_core(inode, iblock, 0, bh_result,
-                                       create, 0, BMAP_SYNC|BMAP_WRITE);
+                                       create, 0, BMAPI_SYNC|BMAPI_WRITE);
 }
 
 STATIC int
@@ -962,7 +963,7 @@
        int                     create)
 {
        return linvfs_get_block_core(inode, iblock, max_blocks, bh_result,
-                                       create, 1, BMAP_WRITE|BMAP_DIRECT);
+                                       create, 1, BMAPI_WRITE|BMAPI_DIRECT);
 }
 
 STATIC int
@@ -976,15 +977,15 @@
        struct file     *file = iocb->ki_filp;
        struct inode    *inode = file->f_dentry->d_inode->i_mapping->host;
        vnode_t         *vp = LINVFS_GET_VP(inode);
-       page_buf_bmap_t pbmap;
+       xfs_iomap_t     iomap;
        int             maps = 1;
        int             error;
 
-       VOP_BMAP(vp, offset, 0, BMAP_DEVICE, &pbmap, &maps, error);
+       VOP_BMAP(vp, offset, 0, BMAPI_DEVICE, &iomap, &maps, error);
        if (error)
                return -error;
 
-        return blockdev_direct_IO(rw, iocb, inode, pbmap.pbm_target->pbr_bdev,
+       return blockdev_direct_IO(rw, iocb, inode, iomap.iomap_target->pbr_bdev,
                iov, offset, nr_segs,
                linvfs_get_blocks_direct,
                linvfs_unwritten_convert_direct);
diff -urN linux.org/fs/xfs/linux/xfs_globals.c linux/fs/xfs/linux/xfs_globals.c
--- linux.org/fs/xfs/linux/xfs_globals.c        2003-12-31 05:47:44.000000000 +0100
+++ linux/fs/xfs/linux/xfs_globals.c    2004-01-02 04:21:43.000000000 +0100
@@ -36,9 +36,57 @@
  */
 
 #include "xfs.h"
+
+#include "xfs_fs.h"
+#include "xfs_buf.h"
+#include "xfs_inum.h"
+#include "xfs_log.h"
+#include "xfs_clnt.h"
+#include "xfs_trans.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
+#include "xfs_dir.h"
+#include "xfs_dir2.h"
+#include "xfs_imap.h"
+#include "xfs_alloc.h"
+#include "xfs_dmapi.h"
+#include "xfs_quota.h"
+#include "xfs_mount.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_ialloc_btree.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
+#include "xfs_bmap.h"
 #include "xfs_bit.h"
+#include "xfs_rtalloc.h"
+#include "xfs_error.h"
+#include "xfs_itable.h"
 #include "xfs_rw.h"
+#include "xfs_da_btree.h"
+#include "xfs_dir_leaf.h"
+#include "xfs_dir2_data.h"
+#include "xfs_dir2_leaf.h"
+#include "xfs_dir2_block.h"
+#include "xfs_dir2_node.h"
+#include "xfs_dir2_trace.h"
+#include "xfs_acl.h"
+#include "xfs_cap.h"
+#include "xfs_mac.h"
+#include "xfs_attr.h"
+#include "xfs_attr_leaf.h"
+#include "xfs_inode_item.h"
+#include "xfs_buf_item.h"
+#include "xfs_extfree_item.h"
+#include "xfs_log_priv.h"
+#include "xfs_trans_priv.h"
+#include "xfs_trans_space.h"
+#include "xfs_utils.h"
 
 /*
  * System memory size - used to scale certain data structures in XFS.
@@ -69,10 +117,34 @@
  */
 cred_t sys_cred_val, *sys_cred = &sys_cred_val;
 
-/* Export XFS symbols used by xfsidbg */
+/*
+ * Export symbols used for XFS debugging
+ */
 EXPORT_SYMBOL(xfs_next_bit);
 EXPORT_SYMBOL(xfs_contig_bits);
 EXPORT_SYMBOL(xfs_bmbt_get_all);
 #if ARCH_CONVERT != ARCH_NOCONVERT
 EXPORT_SYMBOL(xfs_bmbt_disk_get_all);
 #endif
+
+/*
+ * Export symbols used for XFS tracing
+ */
+#ifdef XFS_ALLOC_TRACE
+EXPORT_SYMBOL(xfs_alloc_trace_buf);
+#endif
+#ifdef XFS_BMAP_TRACE
+EXPORT_SYMBOL(xfs_bmap_trace_buf);
+#endif
+#ifdef XFS_BMBT_TRACE
+EXPORT_SYMBOL(xfs_bmbt_trace_buf);
+#endif
+#ifdef XFS_ATTR_TRACE
+EXPORT_SYMBOL(xfs_attr_trace_buf);
+#endif  
+#ifdef XFS_DIR2_TRACE
+EXPORT_SYMBOL(xfs_dir2_trace_buf);
+#endif   
+#ifdef XFS_DIR_TRACE
+EXPORT_SYMBOL(xfs_dir_trace_buf);
+#endif
diff -urN linux.org/fs/xfs/linux/xfs_ioctl.c linux/fs/xfs/linux/xfs_ioctl.c
--- linux.org/fs/xfs/linux/xfs_ioctl.c  2003-12-31 05:48:05.000000000 +0100
+++ linux/fs/xfs/linux/xfs_ioctl.c      2004-01-02 04:21:43.000000000 +0100
@@ -943,7 +943,7 @@
                                        bulkreq.ubuffer, &done);
                } else {
                        error = xfs_bulkstat(mp, NULL, &inlast, &count,
-                               (bulkstat_one_pf)xfs_bulkstat_one,
+                               (bulkstat_one_pf)xfs_bulkstat_one, NULL,
                                sizeof(xfs_bstat_t), bulkreq.ubuffer,
                                BULKSTAT_FG_QUICK, &done);
                }
diff -urN linux.org/fs/xfs/linux/xfs_iomap.c linux/fs/xfs/linux/xfs_iomap.c
--- linux.org/fs/xfs/linux/xfs_iomap.c  2003-12-31 05:47:27.000000000 +0100
+++ linux/fs/xfs/linux/xfs_iomap.c      2004-01-02 04:21:43.000000000 +0100
@@ -67,6 +67,7 @@
 #include "xfs_buf_item.h"
 #include "xfs_trans_space.h"
 #include "xfs_utils.h"
+#include "xfs_iomap.h"
 
 #define XFS_WRITEIO_ALIGN(mp,off)      (((off) >> mp->m_writeio_log) \
                                                << mp->m_writeio_log)
@@ -74,14 +75,14 @@
 #define XFS_WRITE_IMAPS                XFS_BMAP_MAX_NMAP
 
 STATIC int
-_xfs_imap_to_bmap(
+xfs_imap_to_bmap(
        xfs_iocore_t    *io,
        xfs_off_t       offset,
-       int             new,
        xfs_bmbt_irec_t *imap,
-       page_buf_bmap_t *pbmapp,
+       xfs_iomap_t     *iomapp,
        int             imaps,                  /* Number of imap entries */
-       int             pbmaps)                 /* Number of pbmap entries */
+       int             iomaps,                 /* Number of iomap entries */
+       int             flags)
 {
        xfs_mount_t     *mp;
        xfs_fsize_t     nisize;
@@ -93,35 +94,32 @@
        if (io->io_new_size > nisize)
                nisize = io->io_new_size;
 
-       for (pbm = 0; imaps && pbm < pbmaps; imaps--, pbmapp++, imap++, pbm++) {
-               pbmapp->pbm_target = io->io_flags & XFS_IOCORE_RT ?
+       for (pbm = 0; imaps && pbm < iomaps; imaps--, iomapp++, imap++, pbm++) {
+               iomapp->iomap_target = io->io_flags & XFS_IOCORE_RT ?
                        mp->m_rtdev_targp : mp->m_ddev_targp;
-               pbmapp->pbm_offset = XFS_FSB_TO_B(mp, imap->br_startoff);
-               pbmapp->pbm_delta = offset - pbmapp->pbm_offset;
-               pbmapp->pbm_bsize = XFS_FSB_TO_B(mp, imap->br_blockcount);
-               pbmapp->pbm_flags = 0;
+               iomapp->iomap_offset = XFS_FSB_TO_B(mp, imap->br_startoff);
+               iomapp->iomap_delta = offset - iomapp->iomap_offset;
+               iomapp->iomap_bsize = XFS_FSB_TO_B(mp, imap->br_blockcount);
+               iomapp->iomap_flags = flags;
 
                start_block = imap->br_startblock;
                if (start_block == HOLESTARTBLOCK) {
-                       pbmapp->pbm_bn = PAGE_BUF_DADDR_NULL;
-                       pbmapp->pbm_flags = PBMF_HOLE;
+                       iomapp->iomap_bn = IOMAP_DADDR_NULL;
+                       iomapp->iomap_flags = IOMAP_HOLE;
                } else if (start_block == DELAYSTARTBLOCK) {
-                       pbmapp->pbm_bn = PAGE_BUF_DADDR_NULL;
-                       pbmapp->pbm_flags = PBMF_DELAY;
+                       iomapp->iomap_bn = IOMAP_DADDR_NULL;
+                       iomapp->iomap_flags = IOMAP_DELAY;
                } else {
-                       pbmapp->pbm_bn = XFS_FSB_TO_DB_IO(io, start_block);
+                       iomapp->iomap_bn = XFS_FSB_TO_DB_IO(io, start_block);
                        if (ISUNWRITTEN(imap))
-                               pbmapp->pbm_flags |= PBMF_UNWRITTEN;
+                               iomapp->iomap_flags |= IOMAP_UNWRITTEN;
                }
 
-               if ((pbmapp->pbm_offset + pbmapp->pbm_bsize) >= nisize) {
-                       pbmapp->pbm_flags |= PBMF_EOF;
+               if ((iomapp->iomap_offset + iomapp->iomap_bsize) >= nisize) {
+                       iomapp->iomap_flags |= IOMAP_EOF;
                }
 
-               if (new)
-                       pbmapp->pbm_flags |= PBMF_NEW;
-
-               offset += pbmapp->pbm_bsize - pbmapp->pbm_delta;
+               offset += iomapp->iomap_bsize - iomapp->iomap_delta;
        }
        return pbm;     /* Return the number filled */
 }
@@ -132,54 +130,54 @@
        xfs_off_t       offset,
        ssize_t         count,
        int             flags,
-       page_buf_bmap_t *pbmapp,
-       int             *npbmaps)
+       xfs_iomap_t     *iomapp,
+       int             *niomaps)
 {
        xfs_mount_t     *mp = io->io_mount;
        xfs_fileoff_t   offset_fsb, end_fsb;
        int             error = 0;
-       int             new = 0;
        int             lockmode = 0;
        xfs_bmbt_irec_t imap;
        int             nimaps = 1;
-       int             bmap_flags = 0;
+       int             bmapi_flags = 0;
+       int             iomap_flags = 0;
 
        if (XFS_FORCED_SHUTDOWN(mp))
-               return -XFS_ERROR(EIO);
+               return XFS_ERROR(EIO);
 
        switch (flags &
-               (BMAP_READ | BMAP_WRITE | BMAP_ALLOCATE |
-                BMAP_UNWRITTEN | BMAP_DEVICE)) {
-       case BMAP_READ:
+               (BMAPI_READ | BMAPI_WRITE | BMAPI_ALLOCATE |
+                BMAPI_UNWRITTEN | BMAPI_DEVICE)) {
+       case BMAPI_READ:
                lockmode = XFS_LCK_MAP_SHARED(mp, io);
-               bmap_flags = XFS_BMAPI_ENTIRE;
-               if (flags & BMAP_IGNSTATE)
-                       bmap_flags |= XFS_BMAPI_IGSTATE;
+               bmapi_flags = XFS_BMAPI_ENTIRE;
+               if (flags & BMAPI_IGNSTATE)
+                       bmapi_flags |= XFS_BMAPI_IGSTATE;
                break;
-       case BMAP_WRITE:
+       case BMAPI_WRITE:
                lockmode = XFS_ILOCK_EXCL|XFS_EXTSIZE_WR;
-               bmap_flags = 0;
+               bmapi_flags = 0;
                XFS_ILOCK(mp, io, lockmode);
                break;
-       case BMAP_ALLOCATE:
+       case BMAPI_ALLOCATE:
                lockmode = XFS_ILOCK_SHARED|XFS_EXTSIZE_RD;
-               bmap_flags = XFS_BMAPI_ENTIRE;
+               bmapi_flags = XFS_BMAPI_ENTIRE;
                /* Attempt non-blocking lock */
-               if (flags & BMAP_TRYLOCK) {
+               if (flags & BMAPI_TRYLOCK) {
                        if (!XFS_ILOCK_NOWAIT(mp, io, lockmode))
                                return XFS_ERROR(EAGAIN);
                } else {
                        XFS_ILOCK(mp, io, lockmode);
                }
                break;
-       case BMAP_UNWRITTEN:
+       case BMAPI_UNWRITTEN:
                goto phase2;
-       case BMAP_DEVICE:
+       case BMAPI_DEVICE:
                lockmode = XFS_LCK_MAP_SHARED(mp, io);
-               pbmapp->pbm_target = io->io_flags & XFS_IOCORE_RT ?
+               iomapp->iomap_target = io->io_flags & XFS_IOCORE_RT ?
                        mp->m_rtdev_targp : mp->m_ddev_targp;
                error = 0;
-               *npbmaps = 1;
+               *niomaps = 1;
                goto out;
        default:
                BUG();
@@ -192,30 +190,30 @@
        offset_fsb = XFS_B_TO_FSBT(mp, offset);
 
        error = XFS_BMAPI(mp, NULL, io, offset_fsb,
-                       (xfs_filblks_t)(end_fsb - offset_fsb) ,
-                       bmap_flags,  NULL, 0, &imap,
+                       (xfs_filblks_t)(end_fsb - offset_fsb),
+                       bmapi_flags,  NULL, 0, &imap,
                        &nimaps, NULL);
 
        if (error)
                goto out;
 
 phase2:
-       switch (flags & (BMAP_WRITE|BMAP_ALLOCATE|BMAP_UNWRITTEN)) {
-       case BMAP_WRITE:
+       switch (flags & (BMAPI_WRITE|BMAPI_ALLOCATE|BMAPI_UNWRITTEN)) {
+       case BMAPI_WRITE:
                /* If we found an extent, return it */
                if (nimaps && (imap.br_startblock != HOLESTARTBLOCK))
                        break;
 
-               if (flags & (BMAP_DIRECT|BMAP_MMAP)) {
+               if (flags & (BMAPI_DIRECT|BMAPI_MMAP)) {
                        error = XFS_IOMAP_WRITE_DIRECT(mp, io, offset,
                                        count, flags, &imap, &nimaps, nimaps);
                } else {
                        error = XFS_IOMAP_WRITE_DELAY(mp, io, offset, count,
                                        flags, &imap, &nimaps);
                }
-               new = 1;
+               iomap_flags = IOMAP_NEW;
                break;
-       case BMAP_ALLOCATE:
+       case BMAPI_ALLOCATE:
                /* If we found an extent, return it */
                XFS_IUNLOCK(mp, io, lockmode);
                lockmode = 0;
@@ -225,7 +223,7 @@
 
                error = XFS_IOMAP_WRITE_ALLOCATE(mp, io, &imap, &nimaps);
                break;
-       case BMAP_UNWRITTEN:
+       case BMAPI_UNWRITTEN:
                lockmode = 0;
                error = XFS_IOMAP_WRITE_UNWRITTEN(mp, io, offset, count);
                nimaps = 0;
@@ -233,10 +231,10 @@
        }
 
        if (nimaps) {
-               *npbmaps = _xfs_imap_to_bmap(io, offset, new, &imap,
-                                       pbmapp, nimaps, *npbmaps);
-       } else if (npbmaps) {
-               *npbmaps = 0;
+               *niomaps = xfs_imap_to_bmap(io, offset, &imap,
+                                       iomapp, nimaps, *niomaps, iomap_flags);
+       } else if (niomaps) {
+               *niomaps = 0;
        }
 
 out:
@@ -251,29 +249,25 @@
        int             *fsynced,
        int             *ioflags)
 {
-       vnode_t         *vp = XFS_ITOV(ip);
-
        switch (*fsynced) {
        case 0:
                if (ip->i_delayed_blks) {
                        xfs_iunlock(ip, XFS_ILOCK_EXCL);
-                       filemap_fdatawrite(LINVFS_GET_IP(vp)->i_mapping);
+                       xfs_flush_inode(ip);
                        xfs_ilock(ip, XFS_ILOCK_EXCL);
                        *fsynced = 1;
                } else {
-                       *ioflags |= BMAP_SYNC;
+                       *ioflags |= BMAPI_SYNC;
                        *fsynced = 2;
                }
                return 0;
        case 1:
                *fsynced = 2;
-               *ioflags |= BMAP_SYNC;
+               *ioflags |= BMAPI_SYNC;
                return 0;
        case 2:
                xfs_iunlock(ip, XFS_ILOCK_EXCL);
-               sync_blockdev(vp->v_vfsp->vfs_super->s_bdev);
-               xfs_log_force(ip->i_mount, (xfs_lsn_t)0,
-                                               XFS_LOG_FORCE|XFS_LOG_SYNC);
+               xfs_flush_device(ip);
                xfs_ilock(ip, XFS_ILOCK_EXCL);
                *fsynced = 3;
                return 0;
@@ -400,7 +394,7 @@
        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
        xfs_trans_ihold(tp, ip);
 
-       if (!(flags & BMAP_MMAP) && (offset < ip->i_d.di_size || rt))
+       if (!(flags & BMAPI_MMAP) && (offset < ip->i_d.di_size || rt))
                bmapi_flag |= XFS_BMAPI_PREALLOC;
 
        /*
@@ -499,7 +493,7 @@
         * We don't bother with this for sync writes, because we need
         * to minimize the amount we write for good performance.
         */
-       if (!(ioflag & BMAP_SYNC) && ((offset + count) > ip->i_d.di_size)) {
+       if (!(ioflag & BMAPI_SYNC) && ((offset + count) > ip->i_d.di_size)) {
                xfs_off_t       aligned_offset;
                unsigned int    iosize;
                xfs_fileoff_t   ioalign;
diff -urN linux.org/fs/xfs/linux/xfs_iops.c linux/fs/xfs/linux/xfs_iops.c
--- linux.org/fs/xfs/linux/xfs_iops.c   2003-12-31 05:46:55.000000000 +0100
+++ linux/fs/xfs/linux/xfs_iops.c       2004-01-02 04:21:43.000000000 +0100
@@ -110,7 +110,7 @@
        vattr_t         va;
        vnode_t         *vp = NULL, *dvp = LINVFS_GET_VP(dir);
        xfs_acl_t       *default_acl = NULL;
-       xattr_exists_t  test_default_acl = _ACL_DEFAULT_EXISTS;
+       attrexists_t    test_default_acl = _ACL_DEFAULT_EXISTS;
        int             error;
 
        /*
@@ -552,61 +552,6 @@
        block_truncate_page(inode->i_mapping, inode->i_size, linvfs_get_block);
 }
 
-
-
-/*
- * Extended attributes interfaces
- */
-
-#define SYSTEM_NAME    "system."       /* VFS shared names/values */
-#define ROOT_NAME      "trusted."      /* root's own names/values */
-#define USER_NAME      "user."         /* user's own names/values */
-STATIC xattr_namespace_t xfs_namespace_array[] = {
-       { .name= SYSTEM_NAME,   .namelen= sizeof(SYSTEM_NAME)-1,.exists= NULL },
-       { .name= ROOT_NAME,     .namelen= sizeof(ROOT_NAME)-1,  .exists= NULL },
-       { .name= USER_NAME,     .namelen= sizeof(USER_NAME)-1,  .exists= NULL },
-       { .name= NULL }
-};
-xattr_namespace_t *xfs_namespaces = &xfs_namespace_array[0];
-
-#define POSIXACL_ACCESS                "posix_acl_access"
-#define POSIXACL_ACCESS_SIZE   (sizeof(POSIXACL_ACCESS)-1)
-#define POSIXACL_DEFAULT       "posix_acl_default"
-#define POSIXACL_DEFAULT_SIZE  (sizeof(POSIXACL_DEFAULT)-1)
-#define POSIXCAP               "posix_capabilities"
-#define POSIXCAP_SIZE          (sizeof(POSIXCAP)-1)
-#define POSIXMAC               "posix_mac"
-#define POSIXMAC_SIZE          (sizeof(POSIXMAC)-1)
-STATIC xattr_namespace_t sys_namespace_array[] = {
-       { .name= POSIXACL_ACCESS,
-               .namelen= POSIXACL_ACCESS_SIZE,  .exists= _ACL_ACCESS_EXISTS },
-       { .name= POSIXACL_DEFAULT,
-               .namelen= POSIXACL_DEFAULT_SIZE, .exists= _ACL_DEFAULT_EXISTS },
-       { .name= POSIXCAP,
-               .namelen= POSIXCAP_SIZE,         .exists= _CAP_EXISTS },
-       { .name= POSIXMAC,
-               .namelen= POSIXMAC_SIZE,         .exists= _MAC_EXISTS },
-       { .name= NULL }
-};
-
-/*
- * Some checks to prevent people abusing EAs to get over quota:
- * - Don't allow modifying user EAs on devices/symlinks;
- * - Don't allow modifying user EAs if sticky bit set;
- */
-STATIC int
-capable_user_xattr(
-       struct inode    *inode)
-{
-       if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode) &&
-           !capable(CAP_SYS_ADMIN))
-               return 0;
-       if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
-           (current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
-               return 0;
-       return 1;
-}
-
 STATIC int
 linvfs_setxattr(
        struct dentry   *dentry,
@@ -615,59 +560,27 @@
        size_t          size,
        int             flags)
 {
-       struct inode    *inode = dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
-       char            *p = (char *)name;
+       vnode_t         *vp = LINVFS_GET_VP(dentry->d_inode);
+       char            *attr = (char *)name;
+       attrnames_t     *namesp;
        int             xflags = 0;
        int             error;
 
-       if (strncmp(name, xfs_namespaces[SYSTEM_NAMES].name,
-                       xfs_namespaces[SYSTEM_NAMES].namelen) == 0) {
-               error = -EINVAL;
-               if (flags & XATTR_CREATE)
-                        return error;
-               error = -EOPNOTSUPP;
-               p += xfs_namespaces[SYSTEM_NAMES].namelen;
-               if (strcmp(p, POSIXACL_ACCESS) == 0)
-                       error = xfs_acl_vset(vp, (void *) data, size,
-                                               _ACL_TYPE_ACCESS);
-               else if (strcmp(p, POSIXACL_DEFAULT) == 0)
-                       error = xfs_acl_vset(vp, (void *) data, size,
-                                               _ACL_TYPE_DEFAULT);
-               else if (strcmp(p, POSIXCAP) == 0)
-                       error = xfs_cap_vset(vp, (void *) data, size);
-               if (!error)
-                       error = vn_revalidate(vp);
+       namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
+       if (!namesp)
+               return -EOPNOTSUPP;
+       attr += namesp->attr_namelen;
+       error = namesp->attr_capable(vp, NULL);
+       if (error)
                return error;
-       }
-
-       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
-               return -EPERM;
 
        /* Convert Linux syscall to XFS internal ATTR flags */
        if (flags & XATTR_CREATE)
                xflags |= ATTR_CREATE;
        if (flags & XATTR_REPLACE)
                xflags |= ATTR_REPLACE;
-
-       if (strncmp(name, xfs_namespaces[ROOT_NAMES].name,
-                       xfs_namespaces[ROOT_NAMES].namelen) == 0) {
-               if (!capable(CAP_SYS_ADMIN))
-                       return -EPERM;
-               xflags |= ATTR_ROOT;
-               p += xfs_namespaces[ROOT_NAMES].namelen;
-               VOP_ATTR_SET(vp, p, (void *) data, size, xflags, NULL, error);
-               return -error;
-       }
-       if (strncmp(name, xfs_namespaces[USER_NAMES].name,
-                       xfs_namespaces[USER_NAMES].namelen) == 0) {
-               if (!capable_user_xattr(inode))
-                       return -EPERM;
-               p += xfs_namespaces[USER_NAMES].namelen;
-               VOP_ATTR_SET(vp, p, (void *) data, size, xflags, NULL, error);
-               return -error;
-       }
-       return -EOPNOTSUPP;
+       xflags |= namesp->attr_flag;
+       return namesp->attr_set(vp, attr, (void *)data, size, xflags);
 }
 
 STATIC ssize_t
@@ -677,53 +590,27 @@
        void            *data,
        size_t          size)
 {
-       struct inode    *inode = dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
-       char            *p = (char *)name;
+       vnode_t         *vp = LINVFS_GET_VP(dentry->d_inode);
+       char            *attr = (char *)name;
+       attrnames_t     *namesp;
        int             xflags = 0;
        ssize_t         error;
 
-       if (strncmp(name, xfs_namespaces[SYSTEM_NAMES].name,
-                       xfs_namespaces[SYSTEM_NAMES].namelen) == 0) {
-               error = -EOPNOTSUPP;
-               p += xfs_namespaces[SYSTEM_NAMES].namelen;
-               if (strcmp(p, POSIXACL_ACCESS) == 0)
-                       error = xfs_acl_vget(vp, data, size, _ACL_TYPE_ACCESS);
-               else if (strcmp(p, POSIXACL_DEFAULT) == 0)
-                       error = xfs_acl_vget(vp, data, size, _ACL_TYPE_DEFAULT);
-               else if (strcmp(p, POSIXCAP) == 0)
-                       error = xfs_cap_vget(vp, data, size);
+       namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
+       if (!namesp)
+               return -EOPNOTSUPP;
+       attr += namesp->attr_namelen;
+       error = namesp->attr_capable(vp, NULL);
+       if (error)
                return error;
-       }
 
        /* Convert Linux syscall to XFS internal ATTR flags */
        if (!size) {
                xflags |= ATTR_KERNOVAL;
                data = NULL;
        }
-
-       if (strncmp(name, xfs_namespaces[ROOT_NAMES].name,
-                       xfs_namespaces[ROOT_NAMES].namelen) == 0) {
-               if (!capable(CAP_SYS_ADMIN))
-                       return -EPERM;
-               xflags |= ATTR_ROOT;
-               p += xfs_namespaces[ROOT_NAMES].namelen;
-               VOP_ATTR_GET(vp, p, data, (int *)&size, xflags, NULL, error);
-               if (!error)
-                       error = -size;
-               return -error;
-       }
-       if (strncmp(name, xfs_namespaces[USER_NAMES].name,
-                       xfs_namespaces[USER_NAMES].namelen) == 0) {
-               p += xfs_namespaces[USER_NAMES].namelen;
-               if (!capable_user_xattr(inode))
-                       return -EPERM;
-               VOP_ATTR_GET(vp, p, data, (int *)&size, xflags, NULL, error);
-               if (!error)
-                       error = -size;
-               return -error;
-       }
-       return -EOPNOTSUPP;
+       xflags |= namesp->attr_flag;
+       return namesp->attr_get(vp, attr, (void *)data, size, xflags);
 }
 
 STATIC ssize_t
@@ -732,40 +619,18 @@
        char                    *data,
        size_t                  size)
 {
-       attrlist_cursor_kern_t  cursor;
-       xattr_namespace_t       *sys;
        vnode_t                 *vp = LINVFS_GET_VP(dentry->d_inode);
-       char                    *k = data;
-       int                     xflags = ATTR_KERNAMELS;
-       int                     result = 0;
-       ssize_t                 error;
+       int                     error, xflags = ATTR_KERNAMELS;
+       ssize_t                 result;
 
        if (!size)
                xflags |= ATTR_KERNOVAL;
        if (capable(CAP_SYS_ADMIN))
                xflags |= ATTR_KERNFULLS;
 
-       memset(&cursor, 0, sizeof(cursor));
-       VOP_ATTR_LIST(vp, data, size, xflags, &cursor, NULL, error);
-       if (error > 0)
-               return -error;
-       result += -error;
-
-       k += result;            /* advance start of our buffer */
-       for (sys = &sys_namespace_array[0]; sys->name != NULL; sys++) {
-               if (sys->exists == NULL || !sys->exists(vp))
-                       continue;
-               result += xfs_namespaces[SYSTEM_NAMES].namelen;
-               result += sys->namelen + 1;
-               if (size) {
-                       if (result > size)
-                               return -ERANGE;
-                       strcpy(k, xfs_namespaces[SYSTEM_NAMES].name);
-                       k += xfs_namespaces[SYSTEM_NAMES].namelen;
-                       strcpy(k, sys->name);
-                       k += sys->namelen + 1;
-               }
-       }
+       error = attr_generic_list(vp, data, size, xflags, &result);
+       if (error < 0)
+               return error;
        return result;
 }
 
@@ -774,51 +639,25 @@
        struct dentry   *dentry,
        const char      *name)
 {
-       struct inode    *inode = dentry->d_inode;
-       vnode_t         *vp = LINVFS_GET_VP(inode);
-       char            *p = (char *)name;
+       vnode_t         *vp = LINVFS_GET_VP(dentry->d_inode);
+       char            *attr = (char *)name;
+       attrnames_t     *namesp;
        int             xflags = 0;
        int             error;
 
-       if (strncmp(name, xfs_namespaces[SYSTEM_NAMES].name,
-                       xfs_namespaces[SYSTEM_NAMES].namelen) == 0) {
-               error = -EOPNOTSUPP;
-               p += xfs_namespaces[SYSTEM_NAMES].namelen;
-               if (strcmp(p, POSIXACL_ACCESS) == 0)
-                       error = xfs_acl_vremove(vp, _ACL_TYPE_ACCESS);
-               else if (strcmp(p, POSIXACL_DEFAULT) == 0)
-                       error = xfs_acl_vremove(vp, _ACL_TYPE_DEFAULT);
-               else if (strcmp(p, POSIXCAP) == 0)
-                       error = xfs_cap_vremove(vp);
+       namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
+       if (!namesp)
+               return -EOPNOTSUPP;
+       attr += namesp->attr_namelen;
+       error = namesp->attr_capable(vp, NULL);
+       if (error)
                return error;
-       }
-
-        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
-               return -EPERM;
-
-       if (strncmp(name, xfs_namespaces[ROOT_NAMES].name,
-                       xfs_namespaces[ROOT_NAMES].namelen) == 0) {
-               if (!capable(CAP_SYS_ADMIN))
-                       return -EPERM;
-               xflags |= ATTR_ROOT;
-               p += xfs_namespaces[ROOT_NAMES].namelen;
-               VOP_ATTR_REMOVE(vp, p, xflags, NULL, error);
-               return -error;
-       }
-       if (strncmp(name, xfs_namespaces[USER_NAMES].name,
-                       xfs_namespaces[USER_NAMES].namelen) == 0) {
-               p += xfs_namespaces[USER_NAMES].namelen;
-               if (!capable_user_xattr(inode))
-                       return -EPERM;
-               VOP_ATTR_REMOVE(vp, p, xflags, NULL, error);
-               return -error;
-       }
-       return -EOPNOTSUPP;
+       xflags |= namesp->attr_flag;
+       return namesp->attr_remove(vp, attr, xflags);
 }
 
 
-struct inode_operations linvfs_file_inode_operations =
-{
+struct inode_operations linvfs_file_inode_operations = {
        .permission             = linvfs_permission,
        .truncate               = linvfs_truncate,
        .getattr                = linvfs_getattr,
@@ -829,8 +668,7 @@
        .removexattr            = linvfs_removexattr,
 };
 
-struct inode_operations linvfs_dir_inode_operations =
-{
+struct inode_operations linvfs_dir_inode_operations = {
        .create                 = linvfs_create,
        .lookup                 = linvfs_lookup,
        .link                   = linvfs_link,
@@ -849,8 +687,7 @@
        .removexattr            = linvfs_removexattr,
 };
 
-struct inode_operations linvfs_symlink_inode_operations =
-{
+struct inode_operations linvfs_symlink_inode_operations = {
        .readlink               = linvfs_readlink,
        .follow_link            = linvfs_follow_link,
        .permission             = linvfs_permission,
diff -urN linux.org/fs/xfs/linux/xfs_iops.h linux/fs/xfs/linux/xfs_iops.h
--- linux.org/fs/xfs/linux/xfs_iops.h   2003-12-31 05:47:32.000000000 +0100
+++ linux/fs/xfs/linux/xfs_iops.h       2004-01-02 04:21:43.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -32,30 +32,6 @@
 #ifndef __XFS_IOPS_H__
 #define __XFS_IOPS_H__
 
-/*
- * Extended system attributes.
- * So far only POSIX ACLs are supported, but this will need to
- * grow in time (capabilities, mandatory access control, etc).
- */
-#define XFS_SYSTEM_NAMESPACE   SYSTEM_POSIXACL
-
-/*
- * Define a table of the namespaces XFS supports
- */
-typedef int (*xattr_exists_t)(vnode_t *);
-
-typedef struct xattr_namespace {
-       char            *name;
-       unsigned int    namelen;
-       xattr_exists_t  exists;
-} xattr_namespace_t;
-
-#define SYSTEM_NAMES   0
-#define ROOT_NAMES     1
-#define USER_NAMES     2
-extern struct xattr_namespace *xfs_namespaces;
-
-
 extern struct inode_operations linvfs_file_inode_operations;
 extern struct inode_operations linvfs_dir_inode_operations;
 extern struct inode_operations linvfs_symlink_inode_operations;
@@ -69,4 +45,7 @@
 extern int linvfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 extern void linvfs_unwritten_done(struct buffer_head *, int);
 
+extern int xfs_ioctl(struct bhv_desc *, struct inode *, struct file *,
+                        int, unsigned int, unsigned long);
+
 #endif /* __XFS_IOPS_H__ */
diff -urN linux.org/fs/xfs/linux/xfs_linux.h linux/fs/xfs/linux/xfs_linux.h
--- linux.org/fs/xfs/linux/xfs_linux.h  2003-12-31 05:46:20.000000000 +0100
+++ linux/fs/xfs/linux/xfs_linux.h      2004-01-02 04:21:43.000000000 +0100
@@ -47,6 +47,7 @@
 #include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/proc_fs.h>
+#include <linux/version.h>
 
 #include <asm/page.h>
 #include <asm/div64.h>
@@ -69,9 +70,11 @@
 
 #include <pagebuf/page_buf.h>
 
-#ifndef STATIC
-#define STATIC static
-#endif
+/*
+ * Feature macros (disable/enable)
+ */
+#undef  HAVE_REFCACHE  /* reference cache not needed for NFS in 2.6 */
+#define HAVE_SENDFILE  /* sendfile(2) exists in 2.6, but not in 2.4 */
 
 /*
  * State flag for unwritten extent buffers.
@@ -100,6 +103,11 @@
 #define xfs_inherit_nodump     xfs_params.inherit_nodump.val
 #define xfs_inherit_noatime    xfs_params.inherit_noatim.val
 
+#define current_cpu()          smp_processor_id()
+#define current_pid()          (current->pid)
+#define current_fsuid(cred)    (current->fsuid)
+#define current_fsgid(cred)    (current->fsgid)
+
 #define NBPP           PAGE_SIZE
 #define DPPSHFT                (PAGE_SHIFT - 9)
 #define NDPP           (1 << (PAGE_SHIFT - 9))
@@ -200,6 +208,11 @@
 #define howmany(x, y)  (((x)+((y)-1))/(y))
 #define roundup(x, y)  ((((x)+((y)-1))/(y))*(y))
 
+static inline void xfs_stack_trace(void)
+{
+       dump_stack();
+}
+
 /* Move the kernel do_div definition off to one side */
 
 #if defined __i386__
diff -urN linux.org/fs/xfs/linux/xfs_lrw.c linux/fs/xfs/linux/xfs_lrw.c
--- linux.org/fs/xfs/linux/xfs_lrw.c    2003-12-31 05:46:18.000000000 +0100
+++ linux/fs/xfs/linux/xfs_lrw.c        2004-01-02 04:21:43.000000000 +0100
@@ -71,10 +71,76 @@
 #include "xfs_inode_item.h"
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
+#include "xfs_iomap.h"
 
 #include <linux/capability.h>
 
 
+#if defined(XFS_RW_TRACE)
+void
+xfs_rw_enter_trace(
+       int                     tag,
+       xfs_iocore_t            *io,
+       const struct iovec      *iovp,
+       size_t                  segs,
+       loff_t                  offset,
+       int                     ioflags)
+{
+       xfs_inode_t     *ip = XFS_IO_INODE(io);
+
+       if (ip->i_rwtrace == NULL)
+               return;
+       ktrace_enter(ip->i_rwtrace,
+               (void *)(unsigned long)tag,
+               (void *)ip,
+               (void *)((unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(ip->i_d.di_size & 0xffffffff)),
+               (void *)(__psint_t)iovp,
+               (void *)((unsigned long)segs),
+               (void *)((unsigned long)((offset >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(offset & 0xffffffff)),
+               (void *)((unsigned long)ioflags),
+               (void *)((unsigned long)((io->io_new_size >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(io->io_new_size & 0xffffffff)),
+               (void *)NULL,
+               (void *)NULL,
+               (void *)NULL,
+               (void *)NULL,
+               (void *)NULL);
+}
+
+void
+xfs_inval_cached_trace(
+       xfs_iocore_t    *io,
+       xfs_off_t       offset,
+       xfs_off_t       len,
+       xfs_off_t       first,
+       xfs_off_t       last)
+{
+       xfs_inode_t     *ip = XFS_IO_INODE(io);
+
+       if (ip->i_rwtrace == NULL)
+               return;
+       ktrace_enter(ip->i_rwtrace,
+               (void *)(__psint_t)XFS_INVAL_CACHED,
+               (void *)ip,
+               (void *)((unsigned long)((offset >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(offset & 0xffffffff)),
+               (void *)((unsigned long)((len >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(len & 0xffffffff)),
+               (void *)((unsigned long)((first >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(first & 0xffffffff)),
+               (void *)((unsigned long)((last >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(last & 0xffffffff)),
+               (void *)NULL,
+               (void *)NULL,
+               (void *)NULL,
+               (void *)NULL,
+               (void *)NULL,
+               (void *)NULL);
+}
+#endif
+
 /*
  *     xfs_iozero
  *
@@ -142,6 +208,59 @@
        return (-status);
 }
 
+/*
+ * xfs_inval_cached_pages
+ * 
+ * This routine is responsible for keeping direct I/O and buffered I/O
+ * somewhat coherent.  From here we make sure that we're at least
+ * temporarily holding the inode I/O lock exclusively and then call
+ * the page cache to flush and invalidate any cached pages.  If there
+ * are no cached pages this routine will be very quick.
+ */
+void
+xfs_inval_cached_pages(
+       vnode_t         *vp,
+       xfs_iocore_t    *io,
+       xfs_off_t       offset,
+       int             write,
+       int             relock)
+{
+       xfs_mount_t     *mp;
+
+       if (!VN_CACHED(vp)) {
+               return;
+       }
+
+       mp = io->io_mount;
+
+       /*
+        * We need to get the I/O lock exclusively in order
+        * to safely invalidate pages and mappings.
+        */
+       if (relock) {
+               XFS_IUNLOCK(mp, io, XFS_IOLOCK_SHARED);
+               XFS_ILOCK(mp, io, XFS_IOLOCK_EXCL);
+       }
+
+       /* Writing beyond EOF creates a hole that must be zeroed */
+       if (write && (offset > XFS_SIZE(mp, io))) {
+               xfs_fsize_t     isize;
+
+               XFS_ILOCK(mp, io, XFS_ILOCK_EXCL|XFS_EXTSIZE_RD);
+               isize = XFS_SIZE(mp, io);
+               if (offset > isize) {
+                       xfs_zero_eof(vp, io, offset, isize, offset);
+               }
+               XFS_IUNLOCK(mp, io, XFS_ILOCK_EXCL|XFS_EXTSIZE_RD);
+       }
+
+       xfs_inval_cached_trace(io, offset, -1, ctooff(offtoct(offset)), -1);
+       VOP_FLUSHINVAL_PAGES(vp, ctooff(offtoct(offset)), -1, FI_REMAPF_LOCKED);
+       if (relock) {
+               XFS_ILOCK_DEMOTE(mp, io, XFS_IOLOCK_EXCL);
+       }
+}
+
 ssize_t                        /* bytes read, or (-)  error */
 xfs_read(
        bhv_desc_t              *bdp,
@@ -211,7 +330,8 @@
         * does not really happen here, but is scheduled 
         * later?
         */
-       xfs_ilock(ip, XFS_IOLOCK_SHARED);
+       if (!(ioflags & IO_ISLOCKED))
+               xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
        if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ) &&
            !(ioflags & IO_INVIS)) {
@@ -221,13 +341,15 @@
                error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp), *offset, size,
                                      FILP_DELAY_FLAG(file), &locktype);
                if (error) {
-                       xfs_iunlock(ip, XFS_IOLOCK_SHARED);
+                       if (!(ioflags & IO_ISLOCKED))
+                               xfs_iunlock(ip, XFS_IOLOCK_SHARED);
                        return -error;
                }
        }
 
        ret = __generic_file_aio_read(iocb, iovp, segs, offset);
-       xfs_iunlock(ip, XFS_IOLOCK_SHARED);
+       if (!(ioflags & IO_ISLOCKED))
+               xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 
        if (ret > 0)
                XFS_STATS_ADD(xs_read_bytes, ret);
@@ -272,7 +394,8 @@
        if (XFS_FORCED_SHUTDOWN(ip->i_mount))
                return -EIO;
 
-       xfs_ilock(ip, XFS_IOLOCK_SHARED);
+       if (!(ioflags & IO_ISLOCKED))
+               xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
        if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ) &&
            (!(ioflags & IO_INVIS))) {
@@ -282,12 +405,14 @@
                error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp), *offset, count,
                                      FILP_DELAY_FLAG(filp), &locktype);
                if (error) {
-                       xfs_iunlock(ip, XFS_IOLOCK_SHARED);
+                       if (!(ioflags & IO_ISLOCKED))
+                               xfs_iunlock(ip, XFS_IOLOCK_SHARED);
                        return -error;
                }
        }
        ret = generic_file_sendfile(filp, offset, count, actor, target);
-       xfs_iunlock(ip, XFS_IOLOCK_SHARED);
+       if (!(ioflags & IO_ISLOCKED))
+               xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 
        XFS_STATS_ADD(xs_read_bytes, ret);
        xfs_ichgtime(ip, XFS_ICHGTIME_ACC);
@@ -584,6 +709,9 @@
                locktype = VRWLOCK_WRITE;
        }
 
+       if (ioflags & IO_ISLOCKED)
+               iolock = 0;
+
        xfs_ilock(xip, XFS_ILOCK_EXCL|iolock);
 
        isize = xip->i_d.di_size;
@@ -616,7 +744,7 @@
                                      *offset, size,
                                      FILP_DELAY_FLAG(file), &locktype);
                if (error) {
-                       xfs_iunlock(xip, iolock);
+                       if (iolock) xfs_iunlock(xip, iolock);
                        return -error;
                }
                xfs_ilock(xip, XFS_ILOCK_EXCL);
@@ -684,9 +812,13 @@
 
 retry:
        if (ioflags & IO_ISDIRECT) {
-               xfs_inval_cached_pages(vp, &xip->i_iocore, *offset, 1, 1);
+               xfs_inval_cached_pages(vp, io, *offset, 1, 1);
+               xfs_rw_enter_trace(XFS_DIOWR_ENTER,
+                               io, iovp, segs, *offset, ioflags);
+       } else {
+               xfs_rw_enter_trace(XFS_WRITE_ENTER,
+                               io, iovp, segs, *offset, ioflags);
        }
-
        ret = generic_file_aio_write_nolock(iocb, iovp, segs, offset);
 
        if ((ret == -ENOSPC) &&
@@ -702,7 +834,6 @@
                xfs_rwlock(bdp, locktype);
                *offset = xip->i_d.di_size;
                goto retry;
-
        }
 
        if (*offset > xip->i_d.di_size) {
@@ -806,7 +937,9 @@
                }
        } /* (ioflags & O_SYNC) */
 
-       xfs_rwunlock(bdp, locktype);
+       if (iolock)
+               xfs_rwunlock(bdp, locktype);
+
        return(ret);
 }
 
@@ -846,8 +979,8 @@
        xfs_off_t       offset,
        ssize_t         count,
        int             flags,
-       page_buf_bmap_t *pbmapp,
-       int             *npbmaps)
+       xfs_iomap_t     *iomapp,
+       int             *niomaps)
 {
        xfs_inode_t     *ip = XFS_BHVTOI(bdp);
        xfs_iocore_t    *io = &ip->i_iocore;
@@ -856,7 +989,7 @@
        ASSERT(((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) != 0) ==
               ((ip->i_iocore.io_flags & XFS_IOCORE_RT) != 0));
 
-       return xfs_iomap(io, offset, count, flags, pbmapp, npbmaps);
+       return xfs_iomap(io, offset, count, flags, iomapp, niomaps);
 }
 
 /*
diff -urN linux.org/fs/xfs/linux/xfs_lrw.h linux/fs/xfs/linux/xfs_lrw.h
--- linux.org/fs/xfs/linux/xfs_lrw.h    2003-12-31 05:46:25.000000000 +0100
+++ linux/fs/xfs/linux/xfs_lrw.h        2004-01-02 04:21:43.000000000 +0100
@@ -39,21 +39,59 @@
 struct xfs_inode;
 struct xfs_bmbt_irec;
 struct page_buf_s;
-struct page_buf_bmap_s;
+struct xfs_iomap;
 
+#if defined(XFS_RW_TRACE)
+/*
+ * Defines for the trace mechanisms in xfs_lrw.c.
+ */
+#define        XFS_RW_KTRACE_SIZE      64
+#define        XFS_STRAT_KTRACE_SIZE   64
+#define        XFS_STRAT_GTRACE_SIZE   512
+
+#define        XFS_READ_ENTER          1
+#define        XFS_WRITE_ENTER         2
 #define XFS_IOMAP_READ_ENTER   3
+#define        XFS_IOMAP_WRITE_ENTER   4
+#define        XFS_IOMAP_READ_MAP      5
+#define        XFS_IOMAP_WRITE_MAP     6
+#define        XFS_IOMAP_WRITE_NOSPACE 7
+#define        XFS_ITRUNC_START        8
+#define        XFS_ITRUNC_FINISH1      9
+#define        XFS_ITRUNC_FINISH2      10
+#define        XFS_CTRUNC1             11
+#define        XFS_CTRUNC2             12
+#define        XFS_CTRUNC3             13
+#define        XFS_CTRUNC4             14
+#define        XFS_CTRUNC5             15
+#define        XFS_CTRUNC6             16
+#define        XFS_BUNMAPI             17
+#define        XFS_INVAL_CACHED        18
+#define        XFS_DIORD_ENTER         19
+#define        XFS_DIOWR_ENTER         20
+extern void xfs_rw_enter_trace(int, struct xfs_iocore *,
+                       const struct iovec *, size_t, loff_t, int);
+extern void xfs_inval_cached_trace(struct xfs_iocore *,
+                       xfs_off_t, xfs_off_t, xfs_off_t, xfs_off_t);
+#else
+#define xfs_rw_enter_trace(tag, io, iovec, segs, offset, ioflags)
+#define xfs_inval_cached_trace(io, offset, len, first, last)
+#endif
+
 /*
  * Maximum count of bmaps used by read and write paths.
  */
 #define        XFS_MAX_RW_NBMAPS       4
 
 extern int xfs_bmap(struct bhv_desc *, xfs_off_t, ssize_t, int,
-                       struct page_buf_bmap_s *, int *);
+                       struct xfs_iomap *, int *);
 extern int xfsbdstrat(struct xfs_mount *, struct page_buf_s *);
 extern int xfs_bdstrat_cb(struct page_buf_s *);
 
 extern int xfs_zero_eof(struct vnode *, struct xfs_iocore *, xfs_off_t,
                                xfs_fsize_t, xfs_fsize_t);
+extern void xfs_inval_cached_pages(struct vnode        *, struct xfs_iocore *,
+                               xfs_off_t, int, int);
 extern ssize_t xfs_read(struct bhv_desc *, struct kiocb *,
                                const struct iovec *, unsigned int,
                                loff_t *, int, struct cred *);
@@ -64,16 +102,6 @@
                                loff_t *, int, size_t, read_actor_t,
                                void *, struct cred *);
 
-extern int xfs_iomap(struct xfs_iocore *, xfs_off_t, ssize_t, int,
-                               struct page_buf_bmap_s *, int *);
-extern int xfs_iomap_write_direct(struct xfs_inode *, loff_t, size_t,
-                               int, struct xfs_bmbt_irec *, int *, int);
-extern int xfs_iomap_write_delay(struct xfs_inode *, loff_t, size_t,
-                               int, struct xfs_bmbt_irec *, int *);
-extern int xfs_iomap_write_allocate(struct xfs_inode *,
-                               struct xfs_bmbt_irec *, int *);
-extern int xfs_iomap_write_unwritten(struct xfs_inode *, loff_t, size_t);
-
 extern int xfs_dev_is_read_only(struct xfs_mount *, char *);
 
 #define XFS_FSB_TO_DB_IO(io,fsb) \
diff -urN linux.org/fs/xfs/linux/xfs_super.c linux/fs/xfs/linux/xfs_super.c
--- linux.org/fs/xfs/linux/xfs_super.c  2003-12-31 05:48:23.000000000 +0100
+++ linux/fs/xfs/linux/xfs_super.c      2004-01-02 04:21:43.000000000 +0100
@@ -120,7 +120,7 @@
         */
 
 #if BITS_PER_LONG == 32
-# if defined(HAVE_SECTOR_T)
+# if defined(CONFIG_LBD)
        ASSERT(sizeof(sector_t) == 8);
        pagefactor = PAGE_CACHE_SIZE;
        bitshift = BITS_PER_LONG;
@@ -241,6 +241,36 @@
        }
 }
 
+struct inode *
+xfs_get_inode(
+       bhv_desc_t      *bdp,
+       xfs_ino_t       ino,
+       int             flags)
+{
+       struct vfs      *vfsp = bhvtovfs(bdp);
+
+       if (flags & IGET_NOALLOC)
+               return ilookup(vfsp->vfs_super, ino);
+       return iget_locked(vfsp->vfs_super, ino);
+}
+
+void
+xfs_flush_inode(
+       xfs_inode_t     *ip)
+{
+       struct inode    *inode = LINVFS_GET_IP(XFS_ITOV(ip));
+
+       filemap_fdatawrite(inode->i_mapping);
+}
+
+void
+xfs_flush_device(
+       xfs_inode_t     *ip)
+{
+       sync_blockdev(XFS_ITOV(ip)->v_vfsp->vfs_super->s_bdev);
+       xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
+}
+
 int
 xfs_blkdev_get(
        xfs_mount_t             *mp,
@@ -860,15 +890,16 @@
 {
        int                     error;
        struct sysinfo          si;
-       static char             message[] __initdata =
-               KERN_INFO "SGI XFS " XFS_VERSION_STRING " with "
-               XFS_BUILD_OPTIONS " enabled\n";
+       static char             message[] __initdata = KERN_INFO \
+               XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";
 
        printk(message);
 
        si_meminfo(&si);
        xfs_physmem = si.totalram;
 
+       ktrace_init(64);
+
        error = init_inodecache();
        if (error < 0)
                goto undo_inodecache;
@@ -907,12 +938,12 @@
        vfs_exitdmapi();
        pagebuf_terminate();
        destroy_inodecache();
+       ktrace_uninit();
 }
 
 module_init(init_xfs_fs);
 module_exit(exit_xfs_fs);
 
 MODULE_AUTHOR("Silicon Graphics, Inc.");
-MODULE_DESCRIPTION(
-       "SGI XFS " XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
+MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
 MODULE_LICENSE("GPL");
diff -urN linux.org/fs/xfs/linux/xfs_super.h linux/fs/xfs/linux/xfs_super.h
--- linux.org/fs/xfs/linux/xfs_super.h  2003-12-31 05:46:52.000000000 +0100
+++ linux/fs/xfs/linux/xfs_super.h      2004-01-02 04:21:43.000000000 +0100
@@ -76,10 +76,10 @@
 # define XFS_BIGFS_STRING
 #endif
 
-#ifdef CONFIG_XFS_VNODE_TRACING
-# define XFS_VNTRACE_STRING    "VN-trace, "
+#ifdef CONFIG_XFS_TRACE
+# define XFS_TRACE_STRING      "tracing, "
 #else
-# define XFS_VNTRACE_STRING
+# define XFS_TRACE_STRING
 #endif
 
 #ifdef XFSDEBUG
@@ -91,7 +91,7 @@
 #define XFS_BUILD_OPTIONS      XFS_ACL_STRING \
                                XFS_REALTIME_STRING \
                                XFS_BIGFS_STRING \
-                               XFS_VNTRACE_STRING \
+                               XFS_TRACE_STRING \
                                XFS_DBG_STRING /* DBG must be last */
 
 #define LINVFS_GET_VFS(s) \
@@ -99,14 +99,19 @@
 #define LINVFS_SET_VFS(s, vfsp) \
        ((s)->s_fs_info = vfsp)
 
+struct xfs_inode;
 struct xfs_mount;
 struct pb_target;
 struct block_device;
 
 extern __uint64_t xfs_max_file_offset(unsigned int);
 
+extern struct inode *xfs_get_inode(bhv_desc_t *, xfs_ino_t, int);
 extern void xfs_initialize_vnode(bhv_desc_t *, vnode_t *, bhv_desc_t *, int);
 
+extern void xfs_flush_inode(struct xfs_inode *);
+extern void xfs_flush_device(struct xfs_inode *);
+
 extern int  xfs_blkdev_get(struct xfs_mount *, const char *,
                                struct block_device **);
 extern void xfs_blkdev_put(struct block_device *);
diff -urN linux.org/fs/xfs/linux/xfs_sysctl.c linux/fs/xfs/linux/xfs_sysctl.c
--- linux.org/fs/xfs/linux/xfs_sysctl.c 2003-12-31 05:48:56.000000000 +0100
+++ linux/fs/xfs/linux/xfs_sysctl.c     2004-01-02 04:21:44.000000000 +0100
@@ -51,7 +51,7 @@
        int             c, ret, *valp = ctl->data;
        __uint32_t      vn_active;
 
-       ret = proc_doulongvec_minmax(ctl, write, filp, buffer, lenp);
+       ret = proc_dointvec_minmax(ctl, write, filp, buffer, lenp);
 
        if (!ret && write && *valp) {
                printk("XFS Clearing xfsstats\n");
diff -urN linux.org/fs/xfs/linux/xfs_version.h linux/fs/xfs/linux/xfs_version.h
--- linux.org/fs/xfs/linux/xfs_version.h        2003-12-31 05:48:35.000000000 +0100
+++ linux/fs/xfs/linux/xfs_version.h    2004-01-02 04:21:44.000000000 +0100
@@ -39,6 +39,6 @@
 #ifndef __XFS_VERSION_H__
 #define __XFS_VERSION_H__
 
-#define XFS_VERSION_STRING "for Linux"
+#define XFS_VERSION_STRING "SGI-XFS CVS-2004-01-01_06:00_UTC"
 
 #endif /* __XFS_VERSION_H__ */
diff -urN linux.org/fs/xfs/linux/xfs_vfs.c linux/fs/xfs/linux/xfs_vfs.c
--- linux.org/fs/xfs/linux/xfs_vfs.c    2003-12-31 05:46:21.000000000 +0100
+++ linux/fs/xfs/linux/xfs_vfs.c        2004-01-02 04:21:44.000000000 +0100
@@ -134,7 +134,7 @@
 int
 vfs_statvfs(
        struct bhv_desc         *bdp,
-       struct kstatfs          *sp,
+       xfs_statfs_t            *sp,
        struct vnode            *vp)
 {
        struct bhv_desc         *next = bdp;
@@ -201,6 +201,19 @@
        return ((*bhvtovfsops(next)->vfs_quotactl)(next, cmd, id, addr));
 }
 
+struct inode *
+vfs_get_inode(
+       struct bhv_desc         *bdp,
+       xfs_ino_t               ino,
+       int                     fl)
+{
+       struct bhv_desc         *next = bdp;
+
+       while (! (bhvtovfsops(next))->vfs_get_inode)
+               next = BHV_NEXTNULL(next);
+       return ((*bhvtovfsops(next)->vfs_get_inode)(next, ino, fl));
+}
+
 void
 vfs_init_vnode(
        struct bhv_desc         *bdp,
diff -urN linux.org/fs/xfs/linux/xfs_vfs.h linux/fs/xfs/linux/xfs_vfs.h
--- linux.org/fs/xfs/linux/xfs_vfs.h    2003-12-31 05:46:23.000000000 +0100
+++ linux/fs/xfs/linux/xfs_vfs.h        2004-01-02 04:21:44.000000000 +0100
@@ -33,6 +33,7 @@
 #define __XFS_VFS_H__
 
 #include <linux/vfs.h>
+#include "xfs_fs.h"
 
 struct fid;
 struct cred;
@@ -42,10 +43,12 @@
 struct super_block;
 struct xfs_mount_args;
 
+typedef struct kstatfs xfs_statfs_t;
+
 typedef struct vfs {
        u_int                   vfs_flag;       /* flags */
-       fsid_t                  vfs_fsid;       /* file system ID */
-       fsid_t                  *vfs_altfsid;   /* An ID fixed for life of FS */
+       xfs_fsid_t              vfs_fsid;       /* file system ID */
+       xfs_fsid_t              *vfs_altfsid;   /* An ID fixed for life of FS */
        bhv_head_t              vfs_bh;         /* head of vfs behavior chain */
        struct super_block      *vfs_super;     /* Linux superblock structure */
        struct task_struct      *vfs_sync_task;
@@ -92,6 +95,8 @@
 #define SYNC_REFCACHE          0x0040  /* prune some of the nfs ref cache */
 #define SYNC_REMOUNT           0x0080  /* remount readonly, no dummy LRs */
 
+#define IGET_NOALLOC           0x0001  /* vfs_get_inode may return NULL */
+
 typedef int    (*vfs_mount_t)(bhv_desc_t *,
                                struct xfs_mount_args *, struct cred *);
 typedef int    (*vfs_parseargs_t)(bhv_desc_t *, char *,
@@ -101,7 +106,7 @@
 typedef int    (*vfs_mntupdate_t)(bhv_desc_t *, int *,
                                struct xfs_mount_args *);
 typedef int    (*vfs_root_t)(bhv_desc_t *, struct vnode **);
-typedef int    (*vfs_statvfs_t)(bhv_desc_t *, struct kstatfs *, struct vnode *);
+typedef int    (*vfs_statvfs_t)(bhv_desc_t *, xfs_statfs_t *, struct vnode *);
 typedef int    (*vfs_sync_t)(bhv_desc_t *, int, struct cred *);
 typedef int    (*vfs_vget_t)(bhv_desc_t *, struct vnode **, struct fid *);
 typedef int    (*vfs_dmapiops_t)(bhv_desc_t *, caddr_t);
@@ -109,6 +114,7 @@
 typedef void   (*vfs_init_vnode_t)(bhv_desc_t *,
                                struct vnode *, bhv_desc_t *, int);
 typedef void   (*vfs_force_shutdown_t)(bhv_desc_t *, int, char *, int);
+typedef        struct inode * (*vfs_get_inode_t)(bhv_desc_t *, xfs_ino_t, int);
 
 typedef struct vfsops {
        bhv_position_t          vf_position;    /* behavior chain position */
@@ -123,6 +129,7 @@
        vfs_vget_t              vfs_vget;       /* get vnode from fid */
        vfs_dmapiops_t          vfs_dmapiops;   /* data migration */
        vfs_quotactl_t          vfs_quotactl;   /* disk quota */
+       vfs_get_inode_t         vfs_get_inode;  /* bhv specific iget */
        vfs_init_vnode_t        vfs_init_vnode; /* initialize a new vnode */
        vfs_force_shutdown_t    vfs_force_shutdown;     /* crash and burn */
 } vfsops_t;
@@ -142,6 +149,7 @@
 #define VFS_VGET(v, vpp,fidp, rv)      ((rv) = vfs_vget(VHEAD(v), vpp,fidp))
 #define VFS_DMAPIOPS(v, p, rv)         ((rv) = vfs_dmapiops(VHEAD(v), p))
 #define VFS_QUOTACTL(v, c,id,p, rv)    ((rv) = vfs_quotactl(VHEAD(v), c,id,p))
+#define VFS_GET_INODE(v, ino, fl)      ( vfs_get_inode(VHEAD(v), ino,fl) )
 #define VFS_INIT_VNODE(v, vp,b,ul)     ( vfs_init_vnode(VHEAD(v), vp,b,ul) )
 #define VFS_FORCE_SHUTDOWN(v, fl,f,l)  ( vfs_force_shutdown(VHEAD(v), fl,f,l) )
 
@@ -159,6 +167,7 @@
 #define PVFS_VGET(b, vpp,fidp, rv)     ((rv) = vfs_vget(b, vpp,fidp))
 #define PVFS_DMAPIOPS(b, p, rv)                ((rv) = vfs_dmapiops(b, p))
 #define PVFS_QUOTACTL(b, c,id,p, rv)   ((rv) = vfs_quotactl(b, c,id,p))
+#define PVFS_GET_INODE(b, ino,fl)      ( vfs_get_inode(b, ino,fl) )
 #define PVFS_INIT_VNODE(b, vp,b2,ul)   ( vfs_init_vnode(b, vp,b2,ul) )
 #define PVFS_FORCE_SHUTDOWN(b, fl,f,l) ( vfs_force_shutdown(b, fl,f,l) )
 
@@ -168,11 +177,12 @@
 extern int vfs_unmount(bhv_desc_t *, int, struct cred *);
 extern int vfs_mntupdate(bhv_desc_t *, int *, struct xfs_mount_args *);
 extern int vfs_root(bhv_desc_t *, struct vnode **);
-extern int vfs_statvfs(bhv_desc_t *, struct kstatfs *, struct vnode *);
+extern int vfs_statvfs(bhv_desc_t *, xfs_statfs_t *, struct vnode *);
 extern int vfs_sync(bhv_desc_t *, int, struct cred *);
 extern int vfs_vget(bhv_desc_t *, struct vnode **, struct fid *);
 extern int vfs_dmapiops(bhv_desc_t *, caddr_t);
 extern int vfs_quotactl(bhv_desc_t *, int, int, caddr_t);
+extern struct inode *vfs_get_inode(bhv_desc_t *, xfs_ino_t, int);
 extern void vfs_init_vnode(bhv_desc_t *, struct vnode *, bhv_desc_t *, int);
 extern void vfs_force_shutdown(bhv_desc_t *, int, char *, int);
 
diff -urN linux.org/fs/xfs/linux/xfs_vnode.c linux/fs/xfs/linux/xfs_vnode.c
--- linux.org/fs/xfs/linux/xfs_vnode.c  2003-12-31 05:46:55.000000000 +0100
+++ linux/fs/xfs/linux/xfs_vnode.c      2004-01-02 04:21:44.000000000 +0100
@@ -98,7 +98,7 @@
        vp->v_type = VNON;
        vp->v_fbhv = NULL;
 
-#ifdef CONFIG_XFS_VNODE_TRACING
+#ifdef XFS_VNODE_TRACE
        ktrace_free(vp->v_trace);
        vp->v_trace = NULL;
 #endif
@@ -154,9 +154,10 @@
        /* Initialize the first behavior and the behavior chain head. */
        vn_bhv_head_init(VN_BHV_HEAD(vp), "vnode");
 
-#ifdef CONFIG_XFS_VNODE_TRACING
+#ifdef XFS_VNODE_TRACE
        vp->v_trace = ktrace_alloc(VNODE_TRACE_SIZE, KM_SLEEP);
-#endif /* CONFIG_XFS_VNODE_TRACING */
+       printk("Allocated VNODE_TRACE at 0x%p\n", vp->v_trace);
+#endif /* XFS_VNODE_TRACE */
 
        vn_trace_exit(vp, "vn_initialize", (inst_t *)__return_address);
        return vp;
@@ -177,7 +178,7 @@
        if (inode->i_state & I_FREEING)
                return NULL;
 
-       inode = ilookup(vmap->v_vfsp->vfs_super, vmap->v_ino);
+       inode = VFS_GET_INODE(vmap->v_vfsp, vmap->v_ino, IGET_NOALLOC);
        if (!inode)     /* Inode not present */
                return NULL;
 
@@ -392,7 +393,7 @@
 }
 
 
-#ifdef CONFIG_XFS_VNODE_TRACING
+#ifdef XFS_VNODE_TRACE
 
 #define KTRACE_ENTER(vp, vk, s, line, ra)                      \
        ktrace_enter(   (vp)->v_trace,                          \
@@ -439,4 +440,4 @@
 {
        KTRACE_ENTER(vp, VNODE_KTRACE_RELE, file, line, ra);
 }
-#endif /* CONFIG_XFS_VNODE_TRACING */
+#endif /* XFS_VNODE_TRACE */
diff -urN linux.org/fs/xfs/linux/xfs_vnode.h linux/fs/xfs/linux/xfs_vnode.h
--- linux.org/fs/xfs/linux/xfs_vnode.h  2003-12-31 05:48:46.000000000 +0100
+++ linux/fs/xfs/linux/xfs_vnode.h      2004-01-02 04:21:44.000000000 +0100
@@ -62,7 +62,7 @@
 struct uio;
 struct file;
 struct vattr;
-struct page_buf_bmap_s;
+struct xfs_iomap;
 struct attrlist_cursor_kern;
 
 /*
@@ -87,7 +87,7 @@
        vn_bhv_head_t   v_bh;                   /* behavior head */
        spinlock_t      v_lock;                 /* VN_LOCK/VN_UNLOCK */
        struct inode    v_inode;                /* Linux inode */
-#ifdef CONFIG_XFS_VNODE_TRACING
+#ifdef XFS_VNODE_TRACE
        struct ktrace   *v_trace;               /* trace header structure    */
 #endif
 } vnode_t;
@@ -225,8 +225,10 @@
 typedef int    (*vop_release_t)(bhv_desc_t *);
 typedef int    (*vop_rwlock_t)(bhv_desc_t *, vrwlock_t);
 typedef void   (*vop_rwunlock_t)(bhv_desc_t *, vrwlock_t);
+typedef        int     (*vop_frlock_t)(bhv_desc_t *, int, struct file_lock *,int,
+                               xfs_off_t, struct cred *);
 typedef int    (*vop_bmap_t)(bhv_desc_t *, xfs_off_t, ssize_t, int,
-                               struct page_buf_bmap_s *, int *);
+                               struct xfs_iomap *, int *);
 typedef int    (*vop_reclaim_t)(bhv_desc_t *);
 typedef int    (*vop_attr_get_t)(bhv_desc_t *, char *, char *, int *, int,
                                struct cred *);
@@ -269,6 +271,7 @@
        vop_fid2_t              vop_fid2;
        vop_rwlock_t            vop_rwlock;
        vop_rwunlock_t          vop_rwunlock;
+       vop_frlock_t            vop_frlock;
        vop_bmap_t              vop_bmap;
        vop_reclaim_t           vop_reclaim;
        vop_attr_get_t          vop_attr_get;
@@ -381,6 +384,7 @@
  */
 #define IO_ISDIRECT    0x00004         /* bypass page cache */
 #define IO_INVIS       0x00020         /* don't update inode timestamps */
+#define IO_ISLOCKED    0x00800         /* don't do inode locking */
 
 /*
  * Flags for VOP_IFLUSH call
@@ -545,21 +549,17 @@
 extern vnode_t *vn_hold(struct vnode *);
 extern void    vn_rele(struct vnode *);
 
-#if defined(CONFIG_XFS_VNODE_TRACING)
-
+#if defined(XFS_VNODE_TRACE)
 #define VN_HOLD(vp)            \
-       ((void)vn_hold(vp), \
+       ((void)vn_hold(vp),     \
          vn_trace_hold(vp, __FILE__, __LINE__, (inst_t *)__return_address))
 #define VN_RELE(vp)            \
          (vn_trace_rele(vp, __FILE__, __LINE__, (inst_t *)__return_address), \
           iput(LINVFS_GET_IP(vp)))
-
-#else  /* ! (defined(CONFIG_XFS_VNODE_TRACING)) */
-
+#else
 #define VN_HOLD(vp)            ((void)vn_hold(vp))
 #define VN_RELE(vp)            (iput(LINVFS_GET_IP(vp)))
-
-#endif /* ! (defined(CONFIG_XFS_VNODE_TRACING)) */
+#endif
 
 /*
  * Vname handling macros.
@@ -591,6 +591,13 @@
 }
 
 /*
+ * Update modify/access/change times on the vnode
+ */
+#define VN_MTIMESET(vp, tvp)   (LINVFS_GET_IP(vp)->i_mtime = *(tvp))
+#define VN_ATIMESET(vp, tvp)   (LINVFS_GET_IP(vp)->i_atime = *(tvp))
+#define VN_CTIMESET(vp, tvp)   (LINVFS_GET_IP(vp)->i_ctime = *(tvp))
+
+/*
  * Some useful predicates.
  */
 #define VN_MAPPED(vp)  \
@@ -617,13 +624,12 @@
 #define FSYNC_INVAL    0x2     /* flush and invalidate cached data */
 #define FSYNC_DATA     0x4     /* synchronous fsync of data only */
 
-#if (defined(CONFIG_XFS_VNODE_TRACING))
-
-#define        VNODE_TRACE_SIZE        16              /* number of trace entries */
-
 /*
- * Tracing entries.
+ * Tracking vnode activity.
  */
+#if defined(XFS_VNODE_TRACE)
+
+#define        VNODE_TRACE_SIZE        16              /* number of trace entries */
 #define        VNODE_KTRACE_ENTRY      1
 #define        VNODE_KTRACE_EXIT       2
 #define        VNODE_KTRACE_HOLD       3
@@ -635,18 +641,16 @@
 extern void vn_trace_hold(struct vnode *, char *, int, inst_t *);
 extern void vn_trace_ref(struct vnode *, char *, int, inst_t *);
 extern void vn_trace_rele(struct vnode *, char *, int, inst_t *);
+
 #define        VN_TRACE(vp)            \
        vn_trace_ref(vp, __FILE__, __LINE__, (inst_t *)__return_address)
-
-#else  /* ! (defined(CONFIG_XFS_VNODE_TRACING)) */
-
+#else
 #define        vn_trace_entry(a,b,c)
 #define        vn_trace_exit(a,b,c)
 #define        vn_trace_hold(a,b,c,d)
 #define        vn_trace_ref(a,b,c,d)
 #define        vn_trace_rele(a,b,c,d)
 #define        VN_TRACE(vp)
-
-#endif /* ! (defined(CONFIG_XFS_VNODE_TRACING)) */
+#endif
 
 #endif /* __XFS_VNODE_H__ */
diff -urN linux.org/fs/xfs/Makefile linux/fs/xfs/Makefile
--- linux.org/fs/xfs/Makefile   2003-12-31 05:47:58.000000000 +0100
+++ linux/fs/xfs/Makefile       2004-01-02 04:21:42.000000000 +0100
@@ -34,13 +34,45 @@
 
 ifeq ($(CONFIG_XFS_DEBUG),y)
        EXTRA_CFLAGS += -g -DSTATIC="" -DDEBUG -DXFSDEBUG
+       EXTRA_CFLAGS += -DPAGEBUF_LOCK_TRACKING
 endif
-ifeq ($(CONFIG_PAGEBUF_DEBUG),y)
+ifeq ($(CONFIG_XFS_TRACE),y)
+       EXTRA_CFLAGS += -DXFS_ALLOC_TRACE
+       EXTRA_CFLAGS += -DXFS_ATTR_TRACE
+       EXTRA_CFLAGS += -DXFS_BLI_TRACE
+       EXTRA_CFLAGS += -DXFS_BMAP_TRACE
+       EXTRA_CFLAGS += -DXFS_BMBT_TRACE
+       EXTRA_CFLAGS += -DXFS_DIR_TRACE
+       EXTRA_CFLAGS += -DXFS_DIR2_TRACE
+       EXTRA_CFLAGS += -DXFS_DQUOT_TRACE
+       EXTRA_CFLAGS += -DXFS_ILOCK_TRACE
+       EXTRA_CFLAGS += -DXFS_LOG_TRACE
+       EXTRA_CFLAGS += -DXFS_RW_TRACE
        EXTRA_CFLAGS += -DPAGEBUF_TRACE
+       # EXTRA_CFLAGS += -DXFS_VNODE_TRACE
 endif
 
 obj-$(CONFIG_XFS_FS)           += xfs.o
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ifneq ($(CONFIG_XFS_DMAPI),y)
+xfs-y                          += xfs_dmops.o
+endif
 
 xfs-$(CONFIG_XFS_QUOTA)                += $(addprefix quota/, \
                                   xfs_dquot.o \
@@ -49,9 +81,10 @@
                                   xfs_qm_syscalls.o \
                                   xfs_qm_bhv.o \
                                   xfs_qm.o)
-
 ifeq ($(CONFIG_XFS_QUOTA),y)
 xfs-$(CONFIG_PROC_FS)          += quota/xfs_qm_stats.o
+else
+xfs-y                          += xfs_qmops.o
 endif
 
 xfs-$(CONFIG_XFS_RT)           += xfs_rtalloc.o
@@ -79,7 +112,6 @@
                                   xfs_dir2_leaf.o \
                                   xfs_dir2_node.o \
                                   xfs_dir2_sf.o \
-                                  xfs_dir2_trace.o \
                                   xfs_dir_leaf.o \
                                   xfs_error.o \
                                   xfs_extfree_item.o \
@@ -108,10 +140,10 @@
                                   xfs_vnodeops.o \
                                   xfs_rw.o
 
+xfs-$(CONFIG_XFS_TRACE)                += xfs_dir2_trace.o
+
 # Objects in pagebuf/
-xfs-y                          += $(addprefix pagebuf/, \
-                                  page_buf.o \
-                                  page_buf_locking.o)
+xfs-y                          += pagebuf/page_buf.o
 
 # Objects in linux/
 xfs-y                          += $(addprefix linux/, \
@@ -131,15 +163,12 @@
 # Objects in support/
 xfs-y                          += $(addprefix support/, \
                                   debug.o \
-                                  ktrace.o \
                                   move.o \
                                   mrlock.o \
                                   qsort.o \
                                   uuid.o)
 
-# Quota and DMAPI stubs
-xfs-y                          += xfs_dmops.o \
-                                  xfs_qmops.o
+xfs-$(CONFIG_XFS_TRACE)                += support/ktrace.o
 
 # If both xfs and kdb modules are built in then xfsidbg is built in.  If xfs is
 # a module and kdb modules are being compiled then xfsidbg must be a module, to
diff -urN linux.org/fs/xfs/pagebuf/page_buf.c linux/fs/xfs/pagebuf/page_buf.c
--- linux.org/fs/xfs/pagebuf/page_buf.c 2003-12-31 05:46:24.000000000 +0100
+++ linux/fs/xfs/pagebuf/page_buf.c     2004-01-02 04:21:44.000000000 +0100
@@ -58,11 +58,13 @@
 #include <linux/proc_fs.h>
 #include <linux/workqueue.h>
 #include <linux/suspend.h>
+#include <linux/percpu.h>
 
+#include <support/ktrace.h>
 #include <support/debug.h>
 #include <support/kmem.h>
 
-#include "page_buf_internal.h"
+#include "page_buf.h"
 
 #define BBSHIFT                9
 #define BN_ALIGN_MASK  ((1 << (PAGE_CACHE_SHIFT - BBSHIFT)) - 1)
@@ -72,50 +74,7 @@
 #endif
 
 /*
- * Debug code
- */
-
-#ifdef PAGEBUF_TRACE
-static spinlock_t              pb_trace_lock = SPIN_LOCK_UNLOCKED;
-struct pagebuf_trace_buf       pb_trace;
-EXPORT_SYMBOL(pb_trace);
-EXPORT_SYMBOL(pb_trace_func);
-#define CIRC_INC(i)    (((i) + 1) & (PB_TRACE_BUFSIZE - 1))
-
-void
-pb_trace_func(
-       page_buf_t      *pb,
-       int             event,
-       void            *misc,
-       void            *ra)
-{
-       int             j;
-       unsigned long   flags;
-
-       if (!pb_params.debug.val) return;
-
-       if (ra == NULL) ra = (void *)__builtin_return_address(0);
-
-       spin_lock_irqsave(&pb_trace_lock, flags);
-       j = pb_trace.start;
-       pb_trace.start = CIRC_INC(j);
-       spin_unlock_irqrestore(&pb_trace_lock, flags);
-
-       pb_trace.buf[j].pb = (unsigned long) pb;
-       pb_trace.buf[j].event = event;
-       pb_trace.buf[j].flags = pb->pb_flags;
-       pb_trace.buf[j].hold = pb->pb_hold.counter;
-       pb_trace.buf[j].lock_value = pb->pb_sema.count.counter;
-       pb_trace.buf[j].task = (void *)current;
-       pb_trace.buf[j].misc = misc;
-       pb_trace.buf[j].ra = ra;
-       pb_trace.buf[j].offset = pb->pb_file_offset;
-       pb_trace.buf[j].size = pb->pb_buffer_length;
-}
-#endif /* PAGEBUF_TRACE */
-
-/*
- *     File wide globals
+ * File wide globals
  */
 
 STATIC kmem_cache_t *pagebuf_cache;
@@ -129,7 +88,20 @@
  * /proc/sys/vm/pagebuf
  */
 
-pagebuf_param_t pb_params = {
+typedef struct pb_sysctl_val {
+       int     min;
+       int     val;
+       int     max;
+} pb_sysctl_val_t;
+
+struct {
+       pb_sysctl_val_t flush_interval; /* interval between runs of the
+                                        * delwri flush daemon.  */
+       pb_sysctl_val_t age_buffer;     /* time for buffer to age before
+                                        * we flush it.  */
+       pb_sysctl_val_t stats_clear;    /* clear the pagebuf stats */
+       pb_sysctl_val_t debug;          /* debug tracing on or off */
+} pb_params = {
                          /*    MIN     DFLT    MAX     */
        .flush_interval = {     HZ/2,   HZ,     30*HZ   },
        .age_buffer     = {     1*HZ,   15*HZ,  300*HZ  },
@@ -137,12 +109,79 @@
        .debug          = {     0,      0,      1       },
 };
 
+enum {
+       PB_FLUSH_INT = 1,
+       PB_FLUSH_AGE = 2,
+       PB_STATS_CLEAR = 3,
+       PB_DEBUG = 4,
+};
+
 /*
  * Pagebuf statistics variables
  */
 
+struct pbstats {
+       u_int32_t       pb_get;
+       u_int32_t       pb_create;
+       u_int32_t       pb_get_locked;
+       u_int32_t       pb_get_locked_waited;
+       u_int32_t       pb_busy_locked;
+       u_int32_t       pb_miss_locked;
+       u_int32_t       pb_page_retries;
+       u_int32_t       pb_page_found;
+       u_int32_t       pb_get_read;
+} pbstats;
 DEFINE_PER_CPU(struct pbstats, pbstats);
 
+/* We don't disable preempt, not too worried about poking the
+ * wrong cpu's stat for now */
+#define PB_STATS_INC(count)    (__get_cpu_var(pbstats).count++)
+
+/*
+ * Pagebuf debugging
+ */
+
+#ifdef PAGEBUF_TRACE
+void
+pagebuf_trace(
+       page_buf_t      *pb,
+       char            *id,
+       void            *data,
+       void            *ra)
+{
+       if (!pb_params.debug.val)
+               return;
+       ktrace_enter(pagebuf_trace_buf,
+               pb, id,
+               (void *)(unsigned long)pb->pb_flags,
+               (void *)(unsigned long)pb->pb_hold.counter,
+               (void *)(unsigned long)pb->pb_sema.count.counter,
+               (void *)current,
+               data, ra,
+               (void *)(unsigned long)((pb->pb_file_offset>>32) & 0xffffffff),
+               (void *)(unsigned long)(pb->pb_file_offset & 0xffffffff),
+               (void *)(unsigned long)pb->pb_buffer_length,
+               NULL, NULL, NULL, NULL, NULL);
+}
+ktrace_t *pagebuf_trace_buf;
+EXPORT_SYMBOL(pagebuf_trace_buf);
+#define PAGEBUF_TRACE_SIZE     4096
+#define PB_TRACE(pb, id, data) \
+       pagebuf_trace(pb, id, (void *)data, (void *)__builtin_return_address(0))
+#else
+#define PB_TRACE(pb, id, data) do { } while (0)
+#endif
+
+#ifdef PAGEBUF_LOCK_TRACKING
+# define PB_SET_OWNER(pb)      ((pb)->pb_last_holder = current->pid)
+# define PB_CLEAR_OWNER(pb)    ((pb)->pb_last_holder = -1)
+# define PB_GET_OWNER(pb)      ((pb)->pb_last_holder)
+#else
+# define PB_SET_OWNER(pb)      do { } while (0)
+# define PB_CLEAR_OWNER(pb)    do { } while (0)
+# define PB_GET_OWNER(pb)      do { } while (0)
+#endif
+
 /*
  * Pagebuf allocation / freeing.
  */
@@ -198,11 +237,11 @@
        void            *vm_addr;
        struct a_list   *next;
 } a_list_t;
+
 STATIC a_list_t                *as_free_head;
 STATIC int             as_list_len;
 STATIC spinlock_t      as_lock = SPIN_LOCK_UNLOCKED;
 
-
 /*
  * Try to batch vunmaps because they are costly.
  */
@@ -247,16 +286,6 @@
 }
 
 /*
- *     Locking model:
- *
- *     Buffers associated with inodes for which buffer locking
- *     is not enabled are not protected by semaphores, and are
- *     assumed to be exclusively owned by the caller.  There is
- *     spinlock in the buffer, for use by the caller when concurrent
- *     access is possible.
- */
-
-/*
  *     Internal pagebuf object manipulation
  */
 
@@ -294,7 +323,7 @@
        init_waitqueue_head(&pb->pb_waiters);
 
        PB_STATS_INC(pb_create);
-       PB_TRACE(pb, PB_TRACE_REC(get), target);
+       PB_TRACE(pb, "initialize", target);
 }
 
 /*
@@ -343,9 +372,6 @@
                        page_cache_release(page);
                }
        }
-
-       if (pb->pb_pages != pb->pb_page_array)
-               kfree(pb->pb_pages);
 }
 
 /*
@@ -361,7 +387,7 @@
 {
        page_buf_flags_t        pb_flags = pb->pb_flags;
 
-       PB_TRACE(pb, PB_TRACE_REC(free_obj), 0);
+       PB_TRACE(pb, "free_object", 0);
        pb->pb_flags |= PBF_FREED;
 
        if (hash) {
@@ -384,20 +410,17 @@
                if (pb->pb_flags & _PBF_MEM_ALLOCATED) {
                        if (pb->pb_pages) {
                                /* release the pages in the address list */
-                               if (pb->pb_pages[0] &&
-                                   PageSlab(pb->pb_pages[0])) {
-                                       /*
-                                        * This came from the slab
-                                        * allocator free it as such
-                                        */
+                               if ((pb->pb_pages[0]) &&
+                                   (pb->pb_flags & _PBF_MEM_SLAB)) {
                                        kfree(pb->pb_addr);
                                } else {
                                        _pagebuf_freepages(pb);
                                }
-
+                               if (pb->pb_pages != pb->pb_page_array)
+                                       kfree(pb->pb_pages);
                                pb->pb_pages = NULL;
                        }
-                       pb->pb_flags &= ~_PBF_MEM_ALLOCATED;
+                       pb->pb_flags &= ~(_PBF_MEM_ALLOCATED|_PBF_MEM_SLAB);
                }
        }
 
@@ -572,7 +595,7 @@
                }
        }
 
-       PB_TRACE(pb, PB_TRACE_REC(look_pg), good_pages);
+       PB_TRACE(pb, "lookup_pages", (long)good_pages);
 
        return rval;
 }
@@ -663,7 +686,7 @@
        if (not_locked) {
                if (!(flags & PBF_TRYLOCK)) {
                        /* wait for buffer ownership */
-                       PB_TRACE(pb, PB_TRACE_REC(get_lk), 0);
+                       PB_TRACE(pb, "get_lock", 0);
                        pagebuf_lock(pb);
                        PB_STATS_INC(pb_get_locked_waited);
                } else {
@@ -689,8 +712,9 @@
                                _PBF_LOCKABLE | \
                                _PBF_ALL_PAGES_MAPPED | \
                                _PBF_ADDR_ALLOCATED | \
-                               _PBF_MEM_ALLOCATED;
-       PB_TRACE(pb, PB_TRACE_REC(got_lk), 0);
+                               _PBF_MEM_ALLOCATED | \
+                               _PBF_MEM_SLAB;
+       PB_TRACE(pb, "got_lock", 0);
        PB_STATS_INC(pb_get_locked);
        return (pb);
 }
@@ -765,10 +789,11 @@
 
        if (flags & PBF_READ) {
                if (PBF_NOT_DONE(pb)) {
-                       PB_TRACE(pb, PB_TRACE_REC(get_read), flags);
+                       PB_TRACE(pb, "get_read", (unsigned long)flags);
                        PB_STATS_INC(pb_get_read);
                        pagebuf_iostart(pb, flags);
                } else if (flags & PBF_ASYNC) {
+                       PB_TRACE(pb, "get_read_async", (unsigned long)flags);
                        /*
                         * Read ahead call which is already satisfied,
                         * drop the buffer
@@ -778,12 +803,13 @@
                        pagebuf_rele(pb);
                        return NULL;
                } else {
+                       PB_TRACE(pb, "get_read_done", (unsigned long)flags);
                        /* We do not want read in the flags */
                        pb->pb_flags &= ~PBF_READ;
                }
+       } else {
+               PB_TRACE(pb, "get_write", (unsigned long)flags);
        }
-
-       PB_TRACE(pb, PB_TRACE_REC(get_obj), flags);
        return (pb);
 }
 
@@ -916,8 +942,8 @@
        page_buf_t              *pb;
        size_t                  tlen = 0;
 
-       if (len > 0x20000)
-               return(NULL);
+       if (unlikely(len > 0x20000))
+               return NULL;
 
        pb = pagebuf_allocate(flags);
        if (!pb)
@@ -944,11 +970,11 @@
                return NULL;
        }
        /* otherwise pagebuf_free just ignores it */
-       pb->pb_flags |= _PBF_MEM_ALLOCATED;
+       pb->pb_flags |= (_PBF_MEM_ALLOCATED | _PBF_MEM_SLAB);
        PB_CLEAR_OWNER(pb);
        up(&pb->pb_sema);       /* Return unlocked pagebuf */
 
-       PB_TRACE(pb, PB_TRACE_REC(no_daddr), rmem);
+       PB_TRACE(pb, "no_daddr", rmem);
 
        return pb;
 }
@@ -967,7 +993,7 @@
        page_buf_t              *pb)
 {
        atomic_inc(&pb->pb_hold);
-       PB_TRACE(pb, PB_TRACE_REC(hold), 0);
+       PB_TRACE(pb, "hold", 0);
 }
 
 /*
@@ -1002,7 +1028,7 @@
 {
        pb_hash_t               *h;
 
-       PB_TRACE(pb, PB_TRACE_REC(rele), pb->pb_relse);
+       PB_TRACE(pb, "rele", pb->pb_relse);
        if (pb->pb_flags & _PBF_LOCKABLE) {
                h = pb_hash(pb);
                spin_lock(&h->pb_hash_lock);
@@ -1043,6 +1069,95 @@
 
 
 /*
+ *     Mutual exclusion on buffers.  Locking model:
+ *
+ *     Buffers associated with inodes for which buffer locking
+ *     is not enabled are not protected by semaphores, and are
+ *     assumed to be exclusively owned by the caller.  There is a
+ *     spinlock in the buffer, used by the caller when concurrent
+ *     access is possible.
+ */
+
+/*
+ *     pagebuf_cond_lock
+ *
+ *     pagebuf_cond_lock locks a buffer object, if it is not already locked.
+ *     Note that this in no way
+ *     locks the underlying pages, so it is only useful for synchronizing
+ *     concurrent use of page buffer objects, not for synchronizing independent
+ *     access to the underlying pages.
+ */
+int
+pagebuf_cond_lock(                     /* lock buffer, if not locked   */
+                                       /* returns -EBUSY if locked)    */
+       page_buf_t              *pb)
+{
+       int                     locked;
+
+       ASSERT(pb->pb_flags & _PBF_LOCKABLE);
+       locked = down_trylock(&pb->pb_sema) == 0;
+       if (locked) {
+               PB_SET_OWNER(pb);
+       }
+       PB_TRACE(pb, "cond_lock", (long)locked);
+       return(locked ? 0 : -EBUSY);
+}
+
+/*
+ *     pagebuf_lock_value
+ *
+ *     Return lock value for a pagebuf
+ */
+int
+pagebuf_lock_value(
+       page_buf_t              *pb)
+{
+       ASSERT(pb->pb_flags & _PBF_LOCKABLE);
+       return(atomic_read(&pb->pb_sema.count));
+}
+
+/*
+ *     pagebuf_lock
+ *
+ *     pagebuf_lock locks a buffer object.  Note that this in no way
+ *     locks the underlying pages, so it is only useful for synchronizing
+ *     concurrent use of page buffer objects, not for synchronizing independent
+ *     access to the underlying pages.
+ */
+int
+pagebuf_lock(
+       page_buf_t              *pb)
+{
+       ASSERT(pb->pb_flags & _PBF_LOCKABLE);
+
+       PB_TRACE(pb, "lock", 0);
+       if (atomic_read(&pb->pb_io_remaining))
+               blk_run_queues();
+       down(&pb->pb_sema);
+       PB_SET_OWNER(pb);
+       PB_TRACE(pb, "locked", 0);
+       return 0;
+}
+
+/*
+ *     pagebuf_unlock
+ *
+ *     pagebuf_unlock releases the lock on the buffer object created by
+ *     pagebuf_lock or pagebuf_cond_lock (not any
+ *     pinning of underlying pages created by pagebuf_pin).
+ */
+void
+pagebuf_unlock(                                /* unlock buffer                */
+       page_buf_t              *pb)    /* buffer to unlock             */
+{
+       ASSERT(pb->pb_flags & _PBF_LOCKABLE);
+       PB_CLEAR_OWNER(pb);
+       up(&pb->pb_sema);
+       PB_TRACE(pb, "unlock", 0);
+}
+
+
+/*
  *     Pinning Buffer Storage in Memory
  */
 
@@ -1065,7 +1180,7 @@
        page_buf_t              *pb)
 {
        atomic_inc(&pb->pb_pin_count);
-       PB_TRACE(pb, PB_TRACE_REC(pin), pb->pb_pin_count.counter);
+       PB_TRACE(pb, "pin", (long)pb->pb_pin_count.counter);
 }
 
 /*
@@ -1082,7 +1197,7 @@
        if (atomic_dec_and_test(&pb->pb_pin_count)) {
                wake_up_all(&pb->pb_waiters);
        }
-       PB_TRACE(pb, PB_TRACE_REC(unpin), pb->pb_pin_count.counter);
+       PB_TRACE(pb, "unpin", (long)pb->pb_pin_count.counter);
 }
 
 int
@@ -1161,7 +1276,7 @@
                pb->pb_flags &= ~(PBF_PARTIAL | PBF_NONE);
        }
 
-       PB_TRACE(pb, PB_TRACE_REC(done), pb->pb_iodone);
+       PB_TRACE(pb, "iodone", pb->pb_iodone);
 
        if ((pb->pb_iodone) || (pb->pb_flags & PBF_ASYNC)) {
                if (schedule) {
@@ -1187,7 +1302,7 @@
        unsigned int            error)  /* error to store (0 if none)   */
 {
        pb->pb_error = error;
-       PB_TRACE(pb, PB_TRACE_REC(ioerror), error);
+       PB_TRACE(pb, "ioerror", (unsigned long)error);
 }
 
 /*
@@ -1211,7 +1326,7 @@
 {
        int                     status = 0;
 
-       PB_TRACE(pb, PB_TRACE_REC(iostart), flags);
+       PB_TRACE(pb, "iostart", (unsigned long)flags);
 
        if (flags & PBF_DELWRI) {
                pb->pb_flags &= ~(PBF_READ | PBF_WRITE | PBF_ASYNC);
@@ -1444,7 +1554,7 @@
 pagebuf_iorequest(                     /* start real I/O               */
        page_buf_t              *pb)    /* buffer to convey to device   */
 {
-       PB_TRACE(pb, PB_TRACE_REC(ioreq), 0);
+       PB_TRACE(pb, "iorequest", 0);
 
        if (pb->pb_flags & PBF_DELWRI) {
                pagebuf_delwri_queue(pb, 1);
@@ -1480,11 +1590,11 @@
 pagebuf_iowait(
        page_buf_t              *pb)
 {
-       PB_TRACE(pb, PB_TRACE_REC(iowait), 0);
+       PB_TRACE(pb, "iowait", 0);
        if (atomic_read(&pb->pb_io_remaining))
                blk_run_queues();
        down(&pb->pb_iodonesema);
-       PB_TRACE(pb, PB_TRACE_REC(iowaited), (int)pb->pb_error);
+       PB_TRACE(pb, "iowaited", (long)pb->pb_error);
        return pb->pb_error;
 }
 
@@ -1575,7 +1685,7 @@
        page_buf_t              *pb,
        int                     unlock)
 {
-       PB_TRACE(pb, PB_TRACE_REC(delwri_q), unlock);
+       PB_TRACE(pb, "delwri_q", (long)unlock);
        spin_lock(&pbd_delwrite_lock);
        /* If already in the queue, dequeue and place at tail */
        if (!list_empty(&pb->pb_list)) {
@@ -1598,7 +1708,7 @@
 pagebuf_delwri_dequeue(
        page_buf_t              *pb)
 {
-       PB_TRACE(pb, PB_TRACE_REC(delwri_uq), 0);
+       PB_TRACE(pb, "delwri_uq", 0);
        spin_lock(&pbd_delwrite_lock);
        list_del_init(&pb->pb_list);
        pb->pb_flags &= ~PBF_DELWRI;
@@ -1665,7 +1775,7 @@
                list_for_each_safe(curr, next, &pbd_delwrite_queue) {
                        pb = list_entry(curr, page_buf_t, pb_list);
 
-                       PB_TRACE(pb, PB_TRACE_REC(walkq1), pagebuf_ispin(pb));
+                       PB_TRACE(pb, "walkq1", (long)pagebuf_ispin(pb));
 
                        if ((pb->pb_flags & PBF_DELWRI) && !pagebuf_ispin(pb) &&
                            (((pb->pb_flags & _PBF_LOCKABLE) == 0) ||
@@ -1738,7 +1848,7 @@
                        continue;
                }
 
-               PB_TRACE(pb, PB_TRACE_REC(walkq2), pagebuf_ispin(pb));
+               PB_TRACE(pb, "walkq2", (long)pagebuf_ispin(pb));
                if (pagebuf_ispin(pb)) {
                        pincount++;
                        continue;
@@ -1839,7 +1949,7 @@
        int                     c, ret;
        int                     *valp = ctl->data;
 
-       ret = proc_doulongvec_minmax(ctl, write, filp, buffer, lenp);
+       ret = proc_dointvec_minmax(ctl, write, filp, buffer, lenp);
 
        if (!ret && write && *valp) {
                printk("XFS Clearing pbstats\n");
@@ -1960,11 +2070,7 @@
        }
 
 #ifdef PAGEBUF_TRACE
-       pb_trace.buf = (pagebuf_trace_t *)kmalloc(
-                       PB_TRACE_BUFSIZE * sizeof(pagebuf_trace_t), GFP_KERNEL);
-       memset(pb_trace.buf, 0, PB_TRACE_BUFSIZE * sizeof(pagebuf_trace_t));
-       pb_trace.start = 0;
-       pb_trace.end = PB_TRACE_BUFSIZE - 1;
+       pagebuf_trace_buf = ktrace_alloc(PAGEBUF_TRACE_SIZE, KM_SLEEP);
 #endif
 
        pagebuf_daemon_start();
@@ -1996,3 +2102,6 @@
  *     Module management (for kernel debugger module)
  */
 EXPORT_SYMBOL(pagebuf_offset);
+#ifdef DEBUG
+EXPORT_SYMBOL(pbd_delwrite_queue);
+#endif
diff -urN linux.org/fs/xfs/pagebuf/page_buf.h linux/fs/xfs/pagebuf/page_buf.h
--- linux.org/fs/xfs/pagebuf/page_buf.h 2003-12-31 05:47:38.000000000 +0100
+++ linux/fs/xfs/pagebuf/page_buf.h     2004-01-02 04:21:44.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -48,11 +48,6 @@
 #include <linux/uio.h>
 
 /*
- * Turn this on to get pagebuf lock ownership
-#define PAGEBUF_LOCK_TRACKING
-*/
-
-/*
  *     Base types
  */
 
@@ -61,8 +56,6 @@
 
 #define PAGE_BUF_DADDR_NULL ((page_buf_daddr_t) (-1LL))
 
-typedef size_t page_buf_dsize_t;               /* size of buffer in blocks */
-
 #define page_buf_ctob(pp)      ((pp) * PAGE_CACHE_SIZE)
 #define page_buf_btoc(dd)      (((dd) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT)
 #define page_buf_btoct(dd)     ((dd) >> PAGE_CACHE_SHIFT)
@@ -74,29 +67,6 @@
        PBRW_ZERO = 3                   /* Zero target memory */
 } page_buf_rw_t;
 
-typedef enum {                         /* pbm_flags values */
-       PBMF_EOF =              0x01,   /* mapping contains EOF         */
-       PBMF_HOLE =             0x02,   /* mapping covers a hole        */
-       PBMF_DELAY =            0x04,   /* mapping covers delalloc region  */
-       PBMF_UNWRITTEN =        0x20,   /* mapping covers allocated     */
-                                       /* but uninitialized file data  */
-       PBMF_NEW =              0x40    /* just allocated               */
-} bmap_flags_t;
-
-typedef enum {
-       /* base extent manipulation calls */
-       BMAP_READ = (1 << 0),           /* read extents */
-       BMAP_WRITE = (1 << 1),          /* create extents */
-       BMAP_ALLOCATE = (1 << 2),       /* delayed allocate to real extents */
-       BMAP_UNWRITTEN  = (1 << 3),     /* unwritten extents to real extents */
-       /* modifiers */
-       BMAP_IGNSTATE = (1 << 4),       /* ignore unwritten state on read */
-       BMAP_DIRECT = (1 << 5),         /* direct instead of buffered write */
-       BMAP_MMAP = (1 << 6),           /* allocate for mmap write */
-       BMAP_SYNC = (1 << 7),           /* sync write */
-       BMAP_TRYLOCK = (1 << 8),        /* non-blocking request */
-       BMAP_DEVICE = (1 << 9),         /* we only want to know the device */
-} bmapi_flags_t;
 
 typedef enum page_buf_flags_e {                /* pb_flags values */
        PBF_READ = (1 << 0),    /* buffer intended for reading from device */
@@ -123,12 +93,13 @@
        _PBF_PRIVATE_BH = (1 << 17), /* do not use public buffer heads     */
        _PBF_ALL_PAGES_MAPPED = (1 << 18), /* all pages in range mapped    */
        _PBF_ADDR_ALLOCATED = (1 << 19), /* pb_addr space was allocated    */
-       _PBF_MEM_ALLOCATED = (1 << 20), /* pb_mem+underlying pages alloc'd */
+       _PBF_MEM_ALLOCATED = (1 << 20), /* underlying pages are allocated  */
+       _PBF_MEM_SLAB = (1 << 21), /* underlying pages are slab allocated  */
 
-       PBF_FORCEIO = (1 << 21),
-       PBF_FLUSH = (1 << 22),  /* flush disk write cache                  */
-       PBF_READ_AHEAD = (1 << 23),
-       PBF_RUN_QUEUES = (1 << 24), /* run block device task queue         */
+       PBF_FORCEIO = (1 << 22), /* ignore any cache state                 */
+       PBF_FLUSH = (1 << 23),  /* flush disk write cache                  */
+       PBF_READ_AHEAD = (1 << 24), /* asynchronous read-ahead             */
+       PBF_RUN_QUEUES = (1 << 25), /* run block device task queue         */
 
 } page_buf_flags_t;
 
@@ -146,36 +117,6 @@
 } pb_target_t;
 
 /*
- *     page_buf_bmap_t:  File system I/O map
- *
- * The pbm_bn, pbm_offset and pbm_length fields are expressed in disk blocks.
- * The pbm_length field specifies the size of the underlying backing store
- * for the particular mapping.
- *
- * The pbm_bsize, pbm_size and pbm_delta fields are in bytes and indicate
- * the size of the mapping, the number of bytes that are valid to access
- * (read or write), and the offset into the mapping, given the offset
- * supplied to the file I/O map routine.  pbm_delta is the offset of the
- * desired data from the beginning of the mapping.
- *
- * When a request is made to read beyond the logical end of the object,
- * pbm_size may be set to 0, but pbm_offset and pbm_length should be set to
- * the actual amount of underlying storage that has been allocated, if any.
- */
-
-typedef struct page_buf_bmap_s {
-       page_buf_daddr_t pbm_bn;        /* block number in file system      */
-       pb_target_t     *pbm_target;    /* device to do I/O to              */
-       loff_t          pbm_offset;     /* byte offset of mapping in file   */
-       size_t          pbm_delta;      /* offset of request into bmap      */
-       size_t          pbm_bsize;      /* size of this mapping in bytes    */
-       bmap_flags_t    pbm_flags;      /* options flags for mapping        */
-} page_buf_bmap_t;
-
-typedef page_buf_bmap_t pb_bmap_t;
-
-
-/*
  *     page_buf_t:  Buffer structure for page cache-based buffers
  *
  * This buffer structure is used by the page cache buffer management routines
@@ -381,4 +322,19 @@
 extern int pagebuf_init(void);
 extern void pagebuf_terminate(void);
 
+
+#ifdef PAGEBUF_TRACE
+extern ktrace_t *pagebuf_trace_buf;
+extern void pagebuf_trace(
+               page_buf_t *,           /* buffer being traced          */
+               char *,                 /* description of operation     */
+               void *,                 /* arbitrary diagnostic value   */
+               void *);                /* return address               */
+#else
+# define pagebuf_trace(pb, id, ptr, ra)        do { } while (0)
+#endif
+
+#define pagebuf_target_name(target)    \
+       ({ char __b[BDEVNAME_SIZE]; bdevname((target)->pbr_bdev, __b); __b; })
+
 #endif /* __PAGE_BUF_H__ */
diff -urN linux.org/fs/xfs/pagebuf/page_buf_internal.h linux/fs/xfs/pagebuf/page_buf_internal.h
--- linux.org/fs/xfs/pagebuf/page_buf_internal.h        2003-12-31 05:47:14.000000000 +0100
+++ linux/fs/xfs/pagebuf/page_buf_internal.h    1970-01-01 01:00:00.000000000 +0100
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2002 Silicon Graphics, Inc.  All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 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.
- *
- * Further, this software is distributed without any warranty that it is
- * free of the rightful claim of any third person regarding infringement
- * or the like.  Any license provided herein, whether implied or
- * otherwise, applies only to this software file.  Patent licenses, if
- * any, provided herein do not apply to combinations of this program with
- * other software, or any other product whatsoever.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write the Free Software Foundation, Inc., 59
- * Temple Place - Suite 330, Boston MA 02111-1307, USA.
- *
- * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
- * Mountain View, CA  94043, or:
- *
- * http://www.sgi.com
- *
- * For further information regarding this notice, see:
- *
- * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
- */
-
-/*
- * Written by Steve Lord at SGI
- */
-
-#ifndef __PAGE_BUF_PRIVATE_H__
-#define __PAGE_BUF_PRIVATE_H__
-
-#include <linux/percpu.h>
-#include "page_buf.h"
-
-#define _PAGE_BUF_INTERNAL_
-#define PB_DEFINE_TRACES
-#include "page_buf_trace.h"
-
-#ifdef PAGEBUF_LOCK_TRACKING
-#define PB_SET_OWNER(pb)       (pb->pb_last_holder = current->pid)
-#define PB_CLEAR_OWNER(pb)     (pb->pb_last_holder = -1)
-#define PB_GET_OWNER(pb)       (pb->pb_last_holder)
-#else
-#define PB_SET_OWNER(pb)
-#define PB_CLEAR_OWNER(pb)
-#define PB_GET_OWNER(pb)
-#endif /* PAGEBUF_LOCK_TRACKING */
-
-/* Tracing utilities for pagebuf */
-typedef struct {
-       int                     event;
-       unsigned long           pb;
-       page_buf_flags_t        flags;
-       unsigned short          hold;
-       unsigned short          lock_value;
-       void                    *task;
-       void                    *misc;
-       void                    *ra;
-       loff_t                  offset;
-       size_t                  size;
-} pagebuf_trace_t;
-
-struct pagebuf_trace_buf {
-       pagebuf_trace_t         *buf;
-       volatile int            start;
-       volatile int            end;
-};
-
-#define PB_TRACE_BUFSIZE       1024
-#define CIRC_INC(i)     (((i) + 1) & (PB_TRACE_BUFSIZE - 1))
-
-/*
- * Tunable pagebuf parameters
- */
-
-typedef struct pb_sysctl_val {
-       int min;
-       int val;
-       int max;
-} pb_sysctl_val_t;
-
-typedef struct pagebuf_param {
-       pb_sysctl_val_t flush_interval; /* interval between runs of the
-                                        * delwri flush daemon.  */
-       pb_sysctl_val_t age_buffer;     /* time for buffer to age before
-                                        * we flush it.  */
-       pb_sysctl_val_t stats_clear;    /* clear the pagebuf stats */
-       pb_sysctl_val_t debug;          /* debug tracing on or off */
-} pagebuf_param_t;
-
-enum {
-       PB_FLUSH_INT = 1,
-       PB_FLUSH_AGE = 2,
-       PB_STATS_CLEAR = 3,
-       PB_DEBUG = 4
-};
-
-extern pagebuf_param_t pb_params;
-
-/*
- * Pagebuf statistics
- */
-
-struct pbstats {
-       u_int32_t       pb_get;
-       u_int32_t       pb_create;
-       u_int32_t       pb_get_locked;
-       u_int32_t       pb_get_locked_waited;
-       u_int32_t       pb_busy_locked;
-       u_int32_t       pb_miss_locked;
-       u_int32_t       pb_page_retries;
-       u_int32_t       pb_page_found;
-       u_int32_t       pb_get_read;
-};
-
-DECLARE_PER_CPU(struct pbstats, pbstats);
-
-/* We don't disable preempt, not too worried about poking the
- * wrong cpu's stat for now */
-#define PB_STATS_INC(count)    (__get_cpu_var(pbstats).count++)
-
-#ifndef STATIC
-# define STATIC        static
-#endif
-
-#endif /* __PAGE_BUF_PRIVATE_H__ */
diff -urN linux.org/fs/xfs/pagebuf/page_buf_locking.c linux/fs/xfs/pagebuf/page_buf_locking.c
--- linux.org/fs/xfs/pagebuf/page_buf_locking.c 2003-12-31 05:47:32.000000000 +0100
+++ linux/fs/xfs/pagebuf/page_buf_locking.c     1970-01-01 01:00:00.000000000 +0100
@@ -1,139 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 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.
- *
- * Further, this software is distributed without any warranty that it is
- * free of the rightful claim of any third person regarding infringement
- * or the like.  Any license provided herein, whether implied or
- * otherwise, applies only to this software file.  Patent licenses, if
- * any, provided herein do not apply to combinations of this program with
- * other software, or any other product whatsoever.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write the Free Software Foundation, Inc., 59
- * Temple Place - Suite 330, Boston MA 02111-1307, USA.
- *
- * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
- * Mountain View, CA  94043, or:
- *
- * http://www.sgi.com
- *
- * For further information regarding this notice, see:
- *
- * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
- */
-
-/*
- *     page_buf_locking.c
- *
- *     The page_buf module provides an abstract buffer cache model on top of
- *     the Linux page cache.  Cached metadata blocks for a file system are
- *     hashed to the inode for the block device.  The page_buf module
- *     assembles buffer (page_buf_t) objects on demand to aggregate such
- *     cached pages for I/O.  The page_buf_locking module adds support for
- *     locking such page buffers.
- *
- *      Written by Steve Lord at SGI
- *
- */
-
-#include <linux/stddef.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/bitops.h>
-#include <linux/string.h>
-#include <linux/pagemap.h>
-#include <linux/init.h>
-#include <linux/major.h>
-
-#include <support/debug.h>
-
-#include "page_buf_internal.h"
-
-/*
- *     pagebuf_cond_lock
- *
- *     pagebuf_cond_lock locks a buffer object, if it is not already locked.
- *     Note that this in no way
- *     locks the underlying pages, so it is only useful for synchronizing
- *     concurrent use of page buffer objects, not for synchronizing independent
- *     access to the underlying pages.
- */
-int
-pagebuf_cond_lock(                     /* lock buffer, if not locked   */
-                                       /* returns -EBUSY if locked)    */
-       page_buf_t              *pb)
-{
-       int                     locked;
-
-       ASSERT(pb->pb_flags & _PBF_LOCKABLE);
-
-       locked = down_trylock(&pb->pb_sema) == 0;
-       if (locked) {
-               PB_SET_OWNER(pb);
-       }
-
-       PB_TRACE(pb, PB_TRACE_REC(condlck), locked);
-
-       return(locked ? 0 : -EBUSY);
-}
-
-/*
- *     pagebuf_lock_value
- *
- *     Return lock value for a pagebuf
- */
-int
-pagebuf_lock_value(
-       page_buf_t              *pb)
-{
-       ASSERT(pb->pb_flags & _PBF_LOCKABLE);
-       return(atomic_read(&pb->pb_sema.count));
-}
-
-/*
- *     pagebuf_lock
- *
- *     pagebuf_lock locks a buffer object.  Note that this in no way
- *     locks the underlying pages, so it is only useful for synchronizing
- *     concurrent use of page buffer objects, not for synchronizing independent
- *     access to the underlying pages.
- */
-int
-pagebuf_lock(
-       page_buf_t              *pb)
-{
-       ASSERT(pb->pb_flags & _PBF_LOCKABLE);
-
-       PB_TRACE(pb, PB_TRACE_REC(lock), 0);
-       if (atomic_read(&pb->pb_io_remaining))
-               blk_run_queues();
-       down(&pb->pb_sema);
-       PB_SET_OWNER(pb);
-       PB_TRACE(pb, PB_TRACE_REC(locked), 0);
-       return 0;
-}
-
-/*
- *     pagebuf_unlock
- *
- *     pagebuf_unlock releases the lock on the buffer object created by
- *     pagebuf_lock or pagebuf_cond_lock (not any
- *     pinning of underlying pages created by pagebuf_pin).
- */
-void
-pagebuf_unlock(                                /* unlock buffer                */
-       page_buf_t              *pb)    /* buffer to unlock             */
-{
-       ASSERT(pb->pb_flags & _PBF_LOCKABLE);
-       PB_CLEAR_OWNER(pb);
-       up(&pb->pb_sema);
-       PB_TRACE(pb, PB_TRACE_REC(unlock), 0);
-}
diff -urN linux.org/fs/xfs/pagebuf/page_buf_trace.h linux/fs/xfs/pagebuf/page_buf_trace.h
--- linux.org/fs/xfs/pagebuf/page_buf_trace.h   2003-12-31 05:47:37.000000000 +0100
+++ linux/fs/xfs/pagebuf/page_buf_trace.h       1970-01-01 01:00:00.000000000 +0100
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 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.
- *
- * Further, this software is distributed without any warranty that it is
- * free of the rightful claim of any third person regarding infringement
- * or the like.  Any license provided herein, whether implied or
- * otherwise, applies only to this software file.  Patent licenses, if
- * any, provided herein do not apply to combinations of this program with
- * other software, or any other product whatsoever.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write the Free Software Foundation, Inc., 59
- * Temple Place - Suite 330, Boston MA 02111-1307, USA.
- *
- * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
- * Mountain View, CA  94043, or:
- *
- * http://www.sgi.com
- *
- * For further information regarding this notice, see:
- *
- * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
- */
-
-#ifndef __PAGEBUF_TRACE__
-#define __PAGEBUF_TRACE__
-
-#ifdef PB_DEFINE_TRACES
-#define PB_TRACE_START typedef enum {
-#define PB_TRACE_REC(x)        pb_trace_point_##x
-#define PB_TRACE_END   } pb_trace_var_t;
-#else
-#define PB_TRACE_START static char     *event_names[] = {
-#define PB_TRACE_REC(x)        #x
-#define PB_TRACE_END   };
-#endif
-
-PB_TRACE_START
-PB_TRACE_REC(get),
-PB_TRACE_REC(get_obj),
-PB_TRACE_REC(free_obj),
-PB_TRACE_REC(look_pg),
-PB_TRACE_REC(get_read),
-PB_TRACE_REC(no_daddr),
-PB_TRACE_REC(hold),
-PB_TRACE_REC(rele),
-PB_TRACE_REC(done),
-PB_TRACE_REC(ioerror),
-PB_TRACE_REC(iostart),
-PB_TRACE_REC(end_io),
-PB_TRACE_REC(do_io),
-PB_TRACE_REC(ioreq),
-PB_TRACE_REC(iowait),
-PB_TRACE_REC(iowaited),
-PB_TRACE_REC(free_lk),
-PB_TRACE_REC(freed_l),
-PB_TRACE_REC(cmp),
-PB_TRACE_REC(get_lk),
-PB_TRACE_REC(got_lk),
-PB_TRACE_REC(skip),
-PB_TRACE_REC(lock),
-PB_TRACE_REC(locked),
-PB_TRACE_REC(unlock),
-PB_TRACE_REC(avl_ret),
-PB_TRACE_REC(condlck),
-PB_TRACE_REC(avl_ins),
-PB_TRACE_REC(walkq1),
-PB_TRACE_REC(walkq2),
-PB_TRACE_REC(walkq3),
-PB_TRACE_REC(delwri_q),
-PB_TRACE_REC(delwri_uq),
-PB_TRACE_REC(pin),
-PB_TRACE_REC(unpin),
-PB_TRACE_REC(file_write),
-PB_TRACE_REC(external),
-PB_TRACE_END
-
-extern void pb_trace_func(page_buf_t *, int, void *, void *);
-#ifdef PAGEBUF_TRACE
-# define PB_TRACE(pb, event, misc)             \
-       pb_trace_func(pb, event, (void *) misc, \
-                       (void *)__builtin_return_address(0))
-#else
-# define PB_TRACE(pb, event, misc)     do { } while (0)
-#endif
-
-#endif /* __PAGEBUF_TRACE__ */
diff -urN linux.org/fs/xfs/quota/xfs_dquot.c linux/fs/xfs/quota/xfs_dquot.c
--- linux.org/fs/xfs/quota/xfs_dquot.c  2003-12-31 05:47:13.000000000 +0100
+++ linux/fs/xfs/quota/xfs_dquot.c      2004-01-02 04:21:44.000000000 +0100
@@ -124,7 +124,7 @@
                initnsema(&dqp->q_flock, 1, "fdq");
                sv_init(&dqp->q_pinwait, SV_DEFAULT, "pdq");
 
-#ifdef DQUOT_TRACING
+#ifdef XFS_DQUOT_TRACE
                dqp->q_trace = ktrace_alloc(DQUOT_TRACE_SIZE, KM_SLEEP);
                xfs_dqtrace_entry(dqp, "DQINIT");
 #endif
@@ -148,7 +148,7 @@
                 dqp->q_hash = 0;
                 ASSERT(dqp->dq_flnext == dqp->dq_flprev);
 
-#ifdef DQUOT_TRACING
+#ifdef XFS_DQUOT_TRACE
                 ASSERT(dqp->q_trace);
                 xfs_dqtrace_entry(dqp, "DQRECLAIMED_INIT");
 #endif
@@ -173,7 +173,7 @@
        freesema(&dqp->q_flock);
        sv_destroy(&dqp->q_pinwait);
 
-#ifdef DQUOT_TRACING
+#ifdef XFS_DQUOT_TRACE
        if (dqp->q_trace)
             ktrace_free(dqp->q_trace);
        dqp->q_trace = NULL;
@@ -201,20 +201,20 @@
 }
 
 
-#ifdef DQUOT_TRACING
+#ifdef XFS_DQUOT_TRACE
 /*
  * Dquot tracing for debugging.
  */
 /* ARGSUSED */
 void
-xfs_dqtrace_entry__(
-       xfs_dquot_t *dqp,
-       char *func,
-       void *retaddr,
-       xfs_inode_t *ip)
+__xfs_dqtrace_entry(
+       xfs_dquot_t     *dqp,
+       char            *func,
+       void            *retaddr,
+       xfs_inode_t     *ip)
 {
-       xfs_dquot_t *udqp = NULL;
-       int ino;
+       xfs_dquot_t     *udqp = NULL;
+       xfs_ino_t       ino = 0;
 
        ASSERT(dqp->q_trace);
        if (ip) {
@@ -227,13 +227,19 @@
                     (void *)(__psint_t)dqp->q_nrefs,
                     (void *)(__psint_t)dqp->dq_flags,
                     (void *)(__psint_t)dqp->q_res_bcount,
-                    (void *)(__psint_t)INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT),
-                    (void *)(__psint_t)INT_GET(dqp->q_core.d_icount, ARCH_CONVERT),
-                    (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT),
-                    (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT),
-                    (void *)(__psint_t)INT_GET(dqp->q_core.d_ino_hardlimit, ARCH_CONVERT),
-                    (void *)(__psint_t)INT_GET(dqp->q_core.d_ino_softlimit, ARCH_CONVERT),
-                    (void *)(__psint_t)INT_GET(dqp->q_core.d_id, ARCH_CONVERT), /* 11 */
+                    (void *)(__psint_t)INT_GET(dqp->q_core.d_bcount,
+                                               ARCH_CONVERT),
+                    (void *)(__psint_t)INT_GET(dqp->q_core.d_icount,
+                                               ARCH_CONVERT),
+                    (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_hardlimit,
+                                               ARCH_CONVERT),
+                    (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_softlimit,
+                                               ARCH_CONVERT),
+                    (void *)(__psint_t)INT_GET(dqp->q_core.d_ino_hardlimit,
+                                               ARCH_CONVERT),
+                    (void *)(__psint_t)INT_GET(dqp->q_core.d_ino_softlimit,
+                                               ARCH_CONVERT),
+                    (void *)(__psint_t)INT_GET(dqp->q_core.d_id, ARCH_CONVERT),
                     (void *)(__psint_t)current_pid(),
                     (void *)(__psint_t)ino,
                     (void *)(__psint_t)retaddr,
@@ -751,7 +757,6 @@
        }
 
        *O_dqpp = dqp;
-       ASSERT(! XFS_DQ_IS_LOCKED(dqp));
        return (0);
 
  error0:
@@ -1000,7 +1005,6 @@
        /*
         * Dquot lock comes after hashlock in the lock ordering
         */
-       ASSERT(! XFS_DQ_IS_LOCKED(dqp));
        if (ip) {
                xfs_ilock(ip, XFS_ILOCK_EXCL);
                if (! XFS_IS_DQTYPE_ON(mp, type)) {
@@ -1504,7 +1508,7 @@
         */
        ASSERT(XFS_DQ_IS_ON_FREELIST(dqp));
 
-       dqp->q_mount = NULL;;
+       dqp->q_mount = NULL;
        dqp->q_hash = NULL;
        dqp->dq_flags = XFS_DQ_INACTIVE;
        memset(&dqp->q_core, 0, sizeof(dqp->q_core));
diff -urN linux.org/fs/xfs/quota/xfs_dquot.h linux/fs/xfs/quota/xfs_dquot.h
--- linux.org/fs/xfs/quota/xfs_dquot.h  2003-12-31 05:48:42.000000000 +0100
+++ linux/fs/xfs/quota/xfs_dquot.h      2004-01-02 04:21:44.000000000 +0100
@@ -99,7 +99,7 @@
        sema_t           q_flock;       /* flush lock */
        uint             q_pincount;    /* pin count for this dquot */
        sv_t             q_pinwait;     /* sync var for pinning */
-#ifdef DQUOT_TRACING
+#ifdef XFS_DQUOT_TRACE
        struct ktrace   *q_trace;       /* trace header structure */
 #endif
 } xfs_dquot_t;
@@ -175,23 +175,25 @@
 #define XFS_IS_THIS_QUOTA_OFF(d) (! (XFS_QM_ISUDQ(d) ? \
                                     (XFS_IS_UQUOTA_ON((d)->q_mount)) : \
                                     (XFS_IS_GQUOTA_ON((d)->q_mount))))
-#ifdef DQUOT_TRACING
+
+#ifdef XFS_DQUOT_TRACE
 /*
  * Dquot Tracing stuff.
  */
 #define DQUOT_TRACE_SIZE       64
 #define DQUOT_KTRACE_ENTRY     1
 
+extern void            __xfs_dqtrace_entry(xfs_dquot_t *dqp, char *func,
+                                           void *, xfs_inode_t *);
 #define xfs_dqtrace_entry_ino(a,b,ip) \
-xfs_dqtrace_entry__((a), (b), (void*)__return_address, (ip))
+               __xfs_dqtrace_entry((a), (b), (void*)__return_address, (ip))
 #define xfs_dqtrace_entry(a,b) \
-xfs_dqtrace_entry__((a), (b), (void*)__return_address, NULL)
-extern void            xfs_dqtrace_entry__(xfs_dquot_t *dqp, char *func,
-                                           void *, xfs_inode_t *);
+               __xfs_dqtrace_entry((a), (b), (void*)__return_address, NULL)
 #else
 #define xfs_dqtrace_entry(a,b)
 #define xfs_dqtrace_entry_ino(a,b,ip)
 #endif
+
 #ifdef QUOTADEBUG
 extern void            xfs_qm_dqprint(xfs_dquot_t *);
 #else
diff -urN linux.org/fs/xfs/quota/xfs_qm.c linux/fs/xfs/quota/xfs_qm.c
--- linux.org/fs/xfs/quota/xfs_qm.c     2003-12-31 05:46:24.000000000 +0100
+++ linux/fs/xfs/quota/xfs_qm.c 2004-01-02 04:21:44.000000000 +0100
@@ -82,6 +82,7 @@
 
 kmem_zone_t    *qm_dqzone;
 kmem_zone_t    *qm_dqtrxzone;
+kmem_shaker_t  xfs_qm_shaker;
 
 STATIC void    xfs_qm_list_init(xfs_dqlist_t *, char *, int);
 STATIC void    xfs_qm_list_destroy(xfs_dqlist_t *);
@@ -112,8 +113,6 @@
 #define XQM_LIST_PRINT(l, NXT, title) do { } while (0)
 #endif
 
-struct shrinker *xfs_qm_shrinker;
-
 /*
  * Initialize the XQM structure.
  * Note that there is not one quota manager per file system.
@@ -163,7 +162,7 @@
        } else
                xqm->qm_dqzone = qm_dqzone;
 
-       xfs_qm_shrinker = set_shrinker(DEFAULT_SEEKS, xfs_qm_shake);
+       xfs_qm_shaker = kmem_shake_register(xfs_qm_shake);
 
        /*
         * The t_dqinfo portion of transactions.
@@ -195,8 +194,7 @@
 
        ASSERT(xqm != NULL);
        ASSERT(xqm->qm_nrefs == 0);
-
-       remove_shrinker(xfs_qm_shrinker);
+       kmem_shake_deregister(xfs_qm_shaker);
        hsize = xqm->qm_dqhashmask + 1;
        for (i = 0; i < hsize; i++) {
                xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
@@ -806,7 +804,6 @@
        ASSERT(XFS_DQ_IS_LOCKED(dqp));
        if (! dolock) {
                xfs_dqunlock(dqp);
-               ASSERT(!udqhint || !XFS_DQ_IS_LOCKED(udqhint));
                goto done;
        }
        if (! udqhint)
@@ -814,7 +811,6 @@
 
        ASSERT(udqhint);
        ASSERT(dolock);
-       ASSERT(! XFS_DQ_IS_LOCKED(udqhint));
        ASSERT(XFS_DQ_IS_LOCKED(dqp));
        if (! xfs_qm_dqlock_nowait(udqhint)) {
                xfs_dqunlock(dqp);
@@ -826,14 +822,10 @@
        if (udqhint) {
                if (dolock)
                        ASSERT(XFS_DQ_IS_LOCKED(udqhint));
-               else
-                       ASSERT(! XFS_DQ_IS_LOCKED(udqhint));
        }
        if (! error) {
                if (dolock)
                        ASSERT(XFS_DQ_IS_LOCKED(dqp));
-               else
-                       ASSERT(! XFS_DQ_IS_LOCKED(dqp));
        }
 #endif
        return (error);
@@ -860,9 +852,6 @@
        if (locked) {
                ASSERT(XFS_DQ_IS_LOCKED(udq));
                ASSERT(XFS_DQ_IS_LOCKED(gdq));
-       } else {
-               ASSERT(! XFS_DQ_IS_LOCKED(udq));
-               ASSERT(! XFS_DQ_IS_LOCKED(gdq));
        }
 #endif
        if (! locked)
@@ -890,15 +879,12 @@
                 */
                xfs_qm_dqrele(tmp);
 
-               ASSERT(! XFS_DQ_IS_LOCKED(udq));
-               ASSERT(! XFS_DQ_IS_LOCKED(gdq));
                xfs_dqlock(udq);
                xfs_dqlock(gdq);
 
        } else {
                ASSERT(XFS_DQ_IS_LOCKED(udq));
                if (! locked) {
-                       ASSERT(! XFS_DQ_IS_LOCKED(gdq));
                        xfs_dqlock(gdq);
                }
        }
@@ -1006,14 +992,10 @@
                if (ip->i_udquot) {
                        if (flags & XFS_QMOPT_DQLOCK)
                                ASSERT(XFS_DQ_IS_LOCKED(ip->i_udquot));
-                       else
-                               ASSERT(! XFS_DQ_IS_LOCKED(ip->i_udquot));
                }
                if (ip->i_gdquot) {
                        if (flags & XFS_QMOPT_DQLOCK)
                                ASSERT(XFS_DQ_IS_LOCKED(ip->i_gdquot));
-                       else
-                               ASSERT(! XFS_DQ_IS_LOCKED(ip->i_gdquot));
                }
                if (XFS_IS_UQUOTA_ON(mp))
                        ASSERT(ip->i_udquot);
@@ -1756,7 +1738,10 @@
        xfs_trans_t     *tp,            /* transaction pointer - NULL */
        xfs_ino_t       ino,            /* inode number to get data for */
        void            *buffer,        /* not used */
+       int             ubsize,         /* not used */
+       void            *private_data,  /* not used */
        xfs_daddr_t     bno,            /* starting block of inode cluster */
+       int             *ubused,        /* not used */
        void            *dip,           /* on-disk inode pointer (not used) */
        int             *res)           /* result code value */
 {
@@ -1920,7 +1905,7 @@
                 * adjusting the corresponding dquot counters in core.
                 */
                if ((error = xfs_bulkstat(mp, NULL, &lastino, &count,
-                                    xfs_qm_dqusage_adjust,
+                                    xfs_qm_dqusage_adjust, NULL,
                                     structsz, NULL,
                                     BULKSTAT_FG_IGET|BULKSTAT_FG_VFSLOCKED,
                                     &done)))
@@ -2091,7 +2076,7 @@
                        xfs_dqunlock(dqp);
                        xfs_qm_freelist_unlock(xfs_Gqm);
                        if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
-                               goto out;
+                               return (nreclaimed);
                        XQM_STATS_INC(xqmstats.xs_qm_dqwants);
                        goto tryagain;
                }
@@ -2166,7 +2151,7 @@
                        XFS_DQ_HASH_UNLOCK(hash);
                        xfs_qm_freelist_unlock(xfs_Gqm);
                        if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
-                               goto out;
+                               return (nreclaimed);
                        goto tryagain;
                }
                xfs_dqtrace_entry(dqp, "DQSHAKE: UNLINKING");
@@ -2191,14 +2176,12 @@
                dqp = nextdqp;
        }
        xfs_qm_freelist_unlock(xfs_Gqm);
- out:
-       return nreclaimed;
+       return (nreclaimed);
 }
 
 
 /*
- * The shake manager routine called by shaked() when memory is
- * running low.
+ * The kmem_shake interface is invoked when memory is running low.
  */
 /* ARGSUSED */
 STATIC int
@@ -2206,10 +2189,10 @@
 {
        int     ndqused, nfree, n;
 
-       if (!(gfp_mask & __GFP_WAIT))
-               return 0;
+       if (!kmem_shake_allow(gfp_mask))
+               return (0);
        if (!xfs_Gqm)
-               return 0;
+               return (0);
 
        nfree = xfs_Gqm->qm_dqfreelist.qh_nelems; /* free dquots */
        /* incore dquots in all f/s's */
@@ -2218,7 +2201,7 @@
        ASSERT(ndqused >= 0);
 
        if (nfree <= ndqused && nfree < ndquot)
-               return 0;
+               return (0);
 
        ndqused *= xfs_Gqm->qm_dqfree_ratio;    /* target # of free dquots */
        n = nfree - ndqused - ndquot;           /* # over target */
diff -urN linux.org/fs/xfs/quota/xfs_qm_syscalls.c linux/fs/xfs/quota/xfs_qm_syscalls.c
--- linux.org/fs/xfs/quota/xfs_qm_syscalls.c    2003-12-31 05:47:47.000000000 +0100
+++ linux/fs/xfs/quota/xfs_qm_syscalls.c        2004-01-02 04:21:44.000000000 +0100
@@ -1301,7 +1301,10 @@
        xfs_trans_t     *tp,            /* transaction pointer */
        xfs_ino_t       ino,            /* inode number to get data for */
        void            *buffer,        /* not used */
+       int             ubsize,         /* not used */
+       void            *private_data,  /* not used */
        xfs_daddr_t     bno,            /* starting block of inode cluster */
+       int             *ubused,        /* not used */
        void            *dip,           /* not used */
        int             *res)           /* bulkstat result code */
 {
@@ -1403,7 +1406,7 @@
                 * adjusting the corresponding dquot counters
                 */
                if ((error = xfs_bulkstat(mp, NULL, &lastino, &count,
-                                xfs_qm_internalqcheck_adjust,
+                                xfs_qm_internalqcheck_adjust, NULL,
                                 0, NULL, BULKSTAT_FG_IGET, &done))) {
                        break;
                }
diff -urN linux.org/fs/xfs/quota/xfs_trans_dquot.c linux/fs/xfs/quota/xfs_trans_dquot.c
--- linux.org/fs/xfs/quota/xfs_trans_dquot.c    2003-12-31 05:46:41.000000000 +0100
+++ linux/fs/xfs/quota/xfs_trans_dquot.c        2004-01-02 04:21:44.000000000 +0100
@@ -835,13 +835,6 @@
        ASSERT(ip->i_ino != mp->m_sb.sb_uquotino);
        ASSERT(ip->i_ino != mp->m_sb.sb_gquotino);
 
-#ifdef QUOTADEBUG
-       if (ip->i_udquot)
-               ASSERT(! XFS_DQ_IS_LOCKED(ip->i_udquot));
-       if (ip->i_gdquot)
-               ASSERT(! XFS_DQ_IS_LOCKED(ip->i_gdquot));
-#endif
-
        ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
        ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
        ASSERT((type & ~XFS_QMOPT_FORCE_RES) == XFS_TRANS_DQ_RES_RTBLKS ||
diff -urN linux.org/fs/xfs/support/debug.h linux/fs/xfs/support/debug.h
--- linux.org/fs/xfs/support/debug.h    2003-12-31 05:48:49.000000000 +0100
+++ linux/fs/xfs/support/debug.h        2004-01-02 04:21:44.000000000 +0100
@@ -44,6 +44,10 @@
 extern void icmn_err(int, char *, va_list);
 extern void cmn_err(int, char *, ...);
 
+#ifndef STATIC
+# define STATIC static
+#endif
+
 #ifdef DEBUG
 # ifdef lint
 #  define ASSERT(EX)   ((void)0) /* avoid "constant in conditional" babble */
diff -urN linux.org/fs/xfs/support/kmem.h linux/fs/xfs/support/kmem.h
--- linux.org/fs/xfs/support/kmem.h     2003-12-31 05:48:56.000000000 +0100
+++ linux/fs/xfs/support/kmem.h 2004-01-02 04:21:44.000000000 +0100
@@ -165,4 +165,25 @@
        kmem_cache_free(zone, ptr);
 }
 
+typedef struct shrinker *kmem_shaker_t;
+typedef int (*kmem_shake_func_t)(int, unsigned int);
+
+static __inline kmem_shaker_t
+kmem_shake_register(kmem_shake_func_t sfunc)
+{
+       return set_shrinker(DEFAULT_SEEKS, sfunc);
+}
+
+static __inline void
+kmem_shake_deregister(kmem_shaker_t shrinker)
+{
+       remove_shrinker(shrinker);
+}
+
+static __inline int
+kmem_shake_allow(unsigned int gfp_mask)
+{
+       return (gfp_mask & __GFP_WAIT);
+}
+
 #endif /* __XFS_SUPPORT_KMEM_H__ */
diff -urN linux.org/fs/xfs/support/ktrace.c linux/fs/xfs/support/ktrace.c
--- linux.org/fs/xfs/support/ktrace.c   2003-12-31 05:47:09.000000000 +0100
+++ linux/fs/xfs/support/ktrace.c       2004-01-02 04:21:44.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -40,8 +40,6 @@
 #include "debug.h"
 #include "ktrace.h"
 
-#if    (defined(DEBUG) || defined(CONFIG_XFS_VNODE_TRACING))
-
 static kmem_zone_t *ktrace_hdr_zone;
 static kmem_zone_t *ktrace_ent_zone;
 static int          ktrace_zentries;
@@ -121,7 +119,6 @@
        ktp->kt_nentries = nentries;
        ktp->kt_index    = 0;
        ktp->kt_rollover = 0;
-
        return ktp;
 }
 
@@ -182,6 +179,7 @@
        void            *val15)
 {
        static lock_t   wrap_lock = SPIN_LOCK_UNLOCKED;
+       unsigned long   flags;
        int             index;
        ktrace_entry_t  *ktep;
 
@@ -190,11 +188,11 @@
        /*
         * Grab an entry by pushing the index up to the next one.
         */
-       spin_lock(&wrap_lock);
+       spin_lock_irqsave(&wrap_lock, flags);
        index = ktp->kt_index;
        if (++ktp->kt_index == ktp->kt_nentries)
                ktp->kt_index = 0;
-       spin_unlock(&wrap_lock);
+       spin_unlock_irqrestore(&wrap_lock, flags);
 
        if (!ktp->kt_rollover && index == ktp->kt_nentries - 1)
                ktp->kt_rollover = 1;
@@ -235,7 +233,6 @@
        return (ktp->kt_rollover ? ktp->kt_nentries : ktp->kt_index);
 }
 
-
 /*
  * ktrace_first()
  *
@@ -276,7 +273,7 @@
        }
        return ktep;
 }
-
+EXPORT_SYMBOL(ktrace_first);
 
 /*
  * ktrace_next()
@@ -311,11 +308,7 @@
 
        return ktep;
 }
-
-#if    (defined(DEBUG) || defined(CONFIG_XFS_VNODE_TRACING))
-EXPORT_SYMBOL(ktrace_first);
 EXPORT_SYMBOL(ktrace_next);
-#endif
 
 /*
  * ktrace_skip()
@@ -323,7 +316,6 @@
  * Skip the next "count" entries and return the entry after that.
  * Return NULL if this causes us to iterate past the beginning again.
  */
-
 ktrace_entry_t *
 ktrace_skip(
        ktrace_t        *ktp,
@@ -362,18 +354,3 @@
        }
        return ktep;
 }
-
-#else
-
-ktrace_t *
-ktrace_alloc(int nentries, int sleep)
-{
-       /*
-        * KM_SLEEP callers don't expect failure.
-        */
-       if (sleep & KM_SLEEP)
-               panic("ktrace_alloc: NULL memory on KM_SLEEP request!");
-
-       return NULL;
-}
-#endif
diff -urN linux.org/fs/xfs/support/ktrace.h linux/fs/xfs/support/ktrace.h
--- linux.org/fs/xfs/support/ktrace.h   2003-12-31 05:47:26.000000000 +0100
+++ linux/fs/xfs/support/ktrace.h       2004-01-02 04:21:44.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -32,6 +32,7 @@
 #ifndef __XFS_SUPPORT_KTRACE_H__
 #define __XFS_SUPPORT_KTRACE_H__
 
+#include <support/spin.h>
 
 /*
  * Trace buffer entry structure.
@@ -59,16 +60,13 @@
        int             ks_index;       /* current index */
 } ktrace_snap_t;
 
-/*
- * Exported interfaces.
- */
-extern ktrace_t *ktrace_alloc(int, int);
 
-#if    (defined(DEBUG) || defined(CONFIG_XFS_VNODE_TRACING))
+#ifdef CONFIG_XFS_TRACE
 
 extern void ktrace_init(int zentries);
 extern void ktrace_uninit(void);
 
+extern ktrace_t *ktrace_alloc(int, int);
 extern void ktrace_free(ktrace_t *);
 
 extern void ktrace_enter(
@@ -96,10 +94,8 @@
 extern ktrace_entry_t   *ktrace_skip(ktrace_t *, int, ktrace_snap_t *);
 
 #else
+#define ktrace_init(x) do { } while (0)
+#define ktrace_uninit()        do { } while (0)
+#endif /* CONFIG_XFS_TRACE */
 
-#define        ktrace_free(ktp)
-#define        ktrace_enter(ktp,v0,v1,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11,v12,v13,v14,v15)
-
-#endif
-
-#endif /* __XFS_SUPPORT_KTRACE_H__ */
+#endif /* __XFS_SUPPORT_KTRACE_H__ */
diff -urN linux.org/fs/xfs/support/qsort.c linux/fs/xfs/support/qsort.c
--- linux.org/fs/xfs/support/qsort.c    2003-12-31 05:48:26.000000000 +0100
+++ linux/fs/xfs/support/qsort.c        2004-01-02 04:21:44.000000000 +0100
@@ -1,243 +1,155 @@
-/* Copyright (C) 1991, 1992, 1996, 1997, 1999 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, write to the Free
-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-   02111-1307 USA.  */
-
-/* If you consider tuning this algorithm, you should consult first:
-   Engineering a sort function; Jon Bentley and M. Douglas McIlroy;
-   Software - Practice and Experience; Vol. 23 (11), 1249-1265, 1993.  */
+/*
+ * Copyright (c) 1992, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
 
 #include <linux/kernel.h>
 #include <linux/string.h>
 
-/* Byte-wise swap two items of size SIZE. */
-#define SWAP(a, b, size)                                                     \
-  do                                                                         \
-    {                                                                        \
-      register size_t __size = (size);                                       \
-      register char *__a = (a), *__b = (b);                                  \
-      do                                                                     \
-       {                                                                     \
-         char __tmp = *__a;                                                  \
-         *__a++ = *__b;                                                      \
-         *__b++ = __tmp;                                                     \
-       } while (--__size > 0);                                               \
-    } while (0)
-
-/* Discontinue quicksort algorithm when partition gets below this size.
-   This particular magic number was chosen to work best on a Sun 4/260. */
-#define MAX_THRESH 4
-
-/* Stack node declarations used to store unfulfilled partition obligations. */
-typedef struct
-  {
-    char *lo;
-    char *hi;
-  } stack_node;
-
-/* The next 4 #defines implement a very fast in-line stack abstraction. */
-/* The stack needs log (total_elements) entries (we could even subtract
-   log(MAX_THRESH)).  Since total_elements has type size_t, we get as
-   upper bound for log (total_elements):
-   bits per byte (CHAR_BIT) * sizeof(size_t).  */
-#define STACK_SIZE     (8 * sizeof(unsigned long int))
-#define PUSH(low, high)        ((void) ((top->lo = (low)), (top->hi = (high)), ++top))
-#define        POP(low, high)  ((void) (--top, (low = top->lo), (high = top->hi)))
-#define        STACK_NOT_EMPTY (stack < top)
-
-
-/* Order size using quicksort.  This implementation incorporates
-   four optimizations discussed in Sedgewick:
-
-   1. Non-recursive, using an explicit stack of pointer that store the
-      next array partition to sort.  To save time, this maximum amount
-      of space required to store an array of SIZE_MAX is allocated on the
-      stack.  Assuming a 32-bit (64 bit) integer for size_t, this needs
-      only 32 * sizeof(stack_node) == 256 bytes (for 64 bit: 1024 bytes).
-      Pretty cheap, actually.
-
-   2. Chose the pivot element using a median-of-three decision tree.
-      This reduces the probability of selecting a bad pivot value and
-      eliminates certain extraneous comparisons.
-
-   3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving
-      insertion sort to order the MAX_THRESH items within each partition.
-      This is a big win, since insertion sort is faster for small, mostly
-      sorted array segments.
-
-   4. The larger of the two sub-partitions is always pushed onto the
-      stack first, with the algorithm then concentrating on the
-      smaller partition.  This *guarantees* no more than log (total_elems)
-      stack size is needed (actually O(1) in this case)!  */
+/*
+ * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
+ */
+#define swapcode(TYPE, parmi, parmj, n) {              \
+       long i = (n) / sizeof (TYPE);                   \
+       register TYPE *pi = (TYPE *) (parmi);           \
+       register TYPE *pj = (TYPE *) (parmj);           \
+       do {                                            \
+               register TYPE   t = *pi;                \
+               *pi++ = *pj;                            \
+               *pj++ = t;                              \
+        } while (--i > 0);                             \
+}
 
-void
-qsort (void *const pbase, size_t total_elems, size_t size,
-       int (*cmp)(const void *, const void *))
+#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
+       es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
+
+static __inline void
+swapfunc(char *a, char *b, int n, int swaptype)
 {
-  register char *base_ptr = (char *) pbase;
+       if (swaptype <= 1) 
+               swapcode(long, a, b, n)
+       else
+               swapcode(char, a, b, n)
+}
 
-  const size_t max_thresh = MAX_THRESH * size;
+#define swap(a, b)                                     \
+       if (swaptype == 0) {                            \
+               long t = *(long *)(a);                  \
+               *(long *)(a) = *(long *)(b);            \
+               *(long *)(b) = t;                       \
+       } else                                          \
+               swapfunc(a, b, es, swaptype)
 
-  if (total_elems == 0)
-    /* Avoid lossage with unsigned arithmetic below.  */
-    return;
-
-  if (total_elems > MAX_THRESH)
-    {
-      char *lo = base_ptr;
-      char *hi = &lo[size * (total_elems - 1)];
-      stack_node stack[STACK_SIZE];
-      stack_node *top = stack + 1;
-
-      while (STACK_NOT_EMPTY)
-       {
-         char *left_ptr;
-         char *right_ptr;
-
-         /* Select median value from among LO, MID, and HI. Rearrange
-            LO and HI so the three values are sorted. This lowers the
-            probability of picking a pathological pivot value and
-            skips a comparison for both the LEFT_PTR and RIGHT_PTR in
-            the while loops. */
-
-         char *mid = lo + size * ((hi - lo) / size >> 1);
-
-         if ((*cmp) ((void *) mid, (void *) lo) < 0)
-           SWAP (mid, lo, size);
-         if ((*cmp) ((void *) hi, (void *) mid) < 0)
-           SWAP (mid, hi, size);
-         else
-           goto jump_over;
-         if ((*cmp) ((void *) mid, (void *) lo) < 0)
-           SWAP (mid, lo, size);
-       jump_over:;
-
-         left_ptr  = lo + size;
-         right_ptr = hi - size;
-
-         /* Here's the famous ``collapse the walls'' section of quicksort.
-            Gotta like those tight inner loops!  They are the main reason
-            that this algorithm runs much faster than others. */
-         do
-           {
-             while ((*cmp) ((void *) left_ptr, (void *) mid) < 0)
-               left_ptr += size;
-
-             while ((*cmp) ((void *) mid, (void *) right_ptr) < 0)
-               right_ptr -= size;
-
-             if (left_ptr < right_ptr)
-               {
-                 SWAP (left_ptr, right_ptr, size);
-                 if (mid == left_ptr)
-                   mid = right_ptr;
-                 else if (mid == right_ptr)
-                   mid = left_ptr;
-                 left_ptr += size;
-                 right_ptr -= size;
-               }
-             else if (left_ptr == right_ptr)
-               {
-                 left_ptr += size;
-                 right_ptr -= size;
-                 break;
+#define vecswap(a, b, n)       if ((n) > 0) swapfunc(a, b, n, swaptype)
+
+static __inline char *
+med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
+{
+       return cmp(a, b) < 0 ?
+              (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
+              :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
+}
+
+void
+qsort(void *aa, size_t n, size_t es, int (*cmp)(const void *, const void *))
+{
+       char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
+       int d, r, swaptype, swap_cnt;
+       register char *a = aa;
+
+loop:  SWAPINIT(a, es);
+       swap_cnt = 0;
+       if (n < 7) {
+               for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es)
+                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
+                            pl -= es)
+                               swap(pl, pl - es);
+               return;
+       }
+       pm = (char *)a + (n / 2) * es;
+       if (n > 7) {
+               pl = (char *)a;
+               pn = (char *)a + (n - 1) * es;
+               if (n > 40) {
+                       d = (n / 8) * es;
+                       pl = med3(pl, pl + d, pl + 2 * d, cmp);
+                       pm = med3(pm - d, pm, pm + d, cmp);
+                       pn = med3(pn - 2 * d, pn - d, pn, cmp);
                }
-           }
-         while (left_ptr <= right_ptr);
+               pm = med3(pl, pm, pn, cmp);
+       }
+       swap(a, pm);
+       pa = pb = (char *)a + es;
 
-         /* Set up pointers for next iteration.  First determine whether
-            left and right partitions are below the threshold size.  If so,
-            ignore one or both.  Otherwise, push the larger partition's
-            bounds on the stack and continue sorting the smaller one. */
-
-         if ((size_t) (right_ptr - lo) <= max_thresh)
-           {
-             if ((size_t) (hi - left_ptr) <= max_thresh)
-               /* Ignore both small partitions. */
-               POP (lo, hi);
-             else
-               /* Ignore small left partition. */
-               lo = left_ptr;
-           }
-         else if ((size_t) (hi - left_ptr) <= max_thresh)
-           /* Ignore small right partition. */
-           hi = right_ptr;
-         else if ((right_ptr - lo) > (hi - left_ptr))
-           {
-             /* Push larger left partition indices. */
-             PUSH (lo, right_ptr);
-             lo = left_ptr;
-           }
-         else
-           {
-             /* Push larger right partition indices. */
-             PUSH (left_ptr, hi);
-             hi = right_ptr;
-           }
+       pc = pd = (char *)a + (n - 1) * es;
+       for (;;) {
+               while (pb <= pc && (r = cmp(pb, a)) <= 0) {
+                       if (r == 0) {
+                               swap_cnt = 1;
+                               swap(pa, pb);
+                               pa += es;
+                       }
+                       pb += es;
+               }
+               while (pb <= pc && (r = cmp(pc, a)) >= 0) {
+                       if (r == 0) {
+                               swap_cnt = 1;
+                               swap(pc, pd);
+                               pd -= es;
+                       }
+                       pc -= es;
+               }
+               if (pb > pc)
+                       break;
+               swap(pb, pc);
+               swap_cnt = 1;
+               pb += es;
+               pc -= es;
+       }
+       if (swap_cnt == 0) {  /* Switch to insertion sort */
+               for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
+                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; 
+                            pl -= es)
+                               swap(pl, pl - es);
+               return;
        }
-    }
 
-  /* Once the BASE_PTR array is partially sorted by quicksort the rest
-     is completely sorted using insertion sort, since this is efficient
-     for partitions below MAX_THRESH size. BASE_PTR points to the beginning
-     of the array to sort, and END_PTR points at the very last element in
-     the array (*not* one beyond it!). */
-  {
-    char *const end_ptr = &base_ptr[size * (total_elems - 1)];
-    char *tmp_ptr = base_ptr;
-    char *const thresh = min_t(char *const, end_ptr, base_ptr + max_thresh);
-    register char *run_ptr;
-
-    /* Find smallest element in first threshold and place it at the
-       array's beginning.  This is the smallest array element,
-       and the operation speeds up insertion sort's inner loop. */
-
-    for (run_ptr = tmp_ptr + size; run_ptr <= thresh; run_ptr += size)
-      if ((*cmp) ((void *) run_ptr, (void *) tmp_ptr) < 0)
-       tmp_ptr = run_ptr;
-
-    if (tmp_ptr != base_ptr)
-      SWAP (tmp_ptr, base_ptr, size);
-
-    /* Insertion sort, running from left-hand-side up to right-hand-side.  */
-
-    run_ptr = base_ptr + size;
-    while ((run_ptr += size) <= end_ptr)
-      {
-       tmp_ptr = run_ptr - size;
-       while ((*cmp) ((void *) run_ptr, (void *) tmp_ptr) < 0)
-         tmp_ptr -= size;
-
-       tmp_ptr += size;
-       if (tmp_ptr != run_ptr)
-         {
-           char *trav;
-
-           trav = run_ptr + size;
-           while (--trav >= run_ptr)
-             {
-               char c = *trav;
-               char *hi, *lo;
-
-               for (hi = lo = trav; (lo -= size) >= tmp_ptr; hi = lo)
-                 *hi = *lo;
-               *hi = c;
-             }
-         }
-      }
-  }
+       pn = (char *)a + n * es;
+       r = min(pa - (char *)a, pb - pa);
+       vecswap(a, pb - r, r);
+       r = min((long)(pd - pc), (long)(pn - pd - es));
+       vecswap(pb, pn - r, r);
+       if ((r = pb - pa) > es)
+               qsort(a, r / es, es, cmp);
+       if ((r = pd - pc) > es) { 
+               /* Iterate rather than recurse to save stack space */
+               a = pn - r;
+               n = r / es;
+               goto loop;
+       }
+/*             qsort(pn - r, r / es, es, cmp);*/
 }
diff -urN linux.org/fs/xfs/xfs_acl.h linux/fs/xfs/xfs_acl.h
--- linux.org/fs/xfs/xfs_acl.h  2003-12-31 05:47:08.000000000 +0100
+++ linux/fs/xfs/xfs_acl.h      2004-01-02 04:21:42.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2001-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -102,6 +102,8 @@
 #define xfs_acl_vset(v,p,sz,t) (-EOPNOTSUPP)
 #define xfs_acl_vget(v,p,sz,t) (-EOPNOTSUPP)
 #define xfs_acl_vremove(v,t)   (-EOPNOTSUPP)
+#define xfs_acl_vhasacl_access(v)      (0)
+#define xfs_acl_vhasacl_default(v)     (0)
 #define _ACL_DECL(a)           ((void)0)
 #define _ACL_ALLOC(a)          (1)     /* successfully allocate nothing */
 #define _ACL_FREE(a)           ((void)0)
diff -urN linux.org/fs/xfs/xfs_alloc.c linux/fs/xfs/xfs_alloc.c
--- linux.org/fs/xfs/xfs_alloc.c        2003-12-31 05:46:44.000000000 +0100
+++ linux/fs/xfs/xfs_alloc.c    2004-01-02 04:21:42.000000000 +0100
@@ -54,13 +54,6 @@
 #include "xfs_error.h"
 
 
-#if defined(DEBUG)
-/*
- * Allocation tracing.
- */
-ktrace_t       *xfs_alloc_trace_buf;
-#endif
-
 #define XFS_ABSDIFF(a,b)       (((a) <= (b)) ? ((b) - (a)) : ((a) - (b)))
 
 #define        XFSA_FIXUP_BNO_OK       1
@@ -73,6 +66,8 @@
                    xfs_extlen_t len);
 
 #if defined(XFS_ALLOC_TRACE)
+ktrace_t *xfs_alloc_trace_buf;
+
 #define        TRACE_ALLOC(s,a)        \
        xfs_alloc_trace_alloc(fname, s, a, __LINE__)
 #define        TRACE_FREE(s,a,b,x,f)   \
@@ -85,8 +80,6 @@
        xfs_alloc_trace_busy(fname, s, mp, ag, -1, -1, sl, tp, XFS_ALLOC_KTRACE_UNBUSY, __LINE__)
 #define        TRACE_BUSYSEARCH(fname,s,ag,agb,l,sl,tp)        \
        xfs_alloc_trace_busy(fname, s, mp, ag, agb, l, sl, tp, XFS_ALLOC_KTRACE_BUSYSEARCH, __LINE__)
-
-
 #else
 #define        TRACE_ALLOC(s,a)
 #define        TRACE_FREE(s,a,b,x,f)
diff -urN linux.org/fs/xfs/xfs_alloc.h linux/fs/xfs/xfs_alloc.h
--- linux.org/fs/xfs/xfs_alloc.h        2003-12-31 05:46:56.000000000 +0100
+++ linux/fs/xfs/xfs_alloc.h    2004-01-02 04:21:42.000000000 +0100
@@ -95,6 +95,13 @@
 
 #ifdef __KERNEL__
 
+#if defined(XFS_ALLOC_TRACE)
+/*
+ * Allocation tracing buffer size.
+ */
+#define        XFS_ALLOC_TRACE_SIZE    4096
+extern ktrace_t *xfs_alloc_trace_buf;
+
 /*
  * Types for alloc tracing.
  */
@@ -104,26 +111,9 @@
 #define        XFS_ALLOC_KTRACE_BUSY   4
 #define        XFS_ALLOC_KTRACE_UNBUSY 5
 #define        XFS_ALLOC_KTRACE_BUSYSEARCH     6
-
-
-/*
- * Allocation tracing buffer size.
- */
-#define        XFS_ALLOC_TRACE_SIZE    4096
-
-#ifdef XFS_ALL_TRACE
-#define        XFS_ALLOC_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_ALLOC_TRACE
 #endif
 
 /*
- * Prototypes for visible xfs_alloc.c routines
- */
-
-/*
  * Compute and fill in value of m_ag_maxlevels.
  */
 void
diff -urN linux.org/fs/xfs/xfs_arch.h linux/fs/xfs/xfs_arch.h
--- linux.org/fs/xfs/xfs_arch.h 2003-12-31 05:48:14.000000000 +0100
+++ linux/fs/xfs/xfs_arch.h     2004-01-02 04:21:42.000000000 +0100
@@ -53,16 +53,18 @@
 
 #define ARCH_NOCONVERT 1
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-#define ARCH_CONVERT   0
+# define ARCH_CONVERT  0
 #else
-#define ARCH_CONVERT   ARCH_NOCONVERT
+# define ARCH_CONVERT  ARCH_NOCONVERT
 #endif
 
 /* generic swapping macros */
 
+#ifndef HAVE_SWABMACROS
 #define INT_SWAP16(type,var) ((typeof(type))(__swab16((__u16)(var))))
 #define INT_SWAP32(type,var) ((typeof(type))(__swab32((__u32)(var))))
 #define INT_SWAP64(type,var) ((typeof(type))(__swab64((__u64)(var))))
+#endif
 
 #define INT_SWAP(type, var) \
     ((sizeof(type) == 8) ? INT_SWAP64(type,var) : \
diff -urN linux.org/fs/xfs/xfs_attr.c linux/fs/xfs/xfs_attr.c
--- linux.org/fs/xfs/xfs_attr.c 2003-12-31 05:47:38.000000000 +0100
+++ linux/fs/xfs/xfs_attr.c     2004-01-02 04:21:42.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -63,6 +63,7 @@
 #include "xfs_quota.h"
 #include "xfs_rw.h"
 #include "xfs_trans_space.h"
+#include "xfs_acl.h"
 
 /*
  * xfs_attr.c
@@ -2234,7 +2235,8 @@
                (__psunsigned_t)context->count,
                (__psunsigned_t)context->firstu,
                (__psunsigned_t)
-                       (context->count > 0)
+                       ((context->count > 0) &&
+                       !(context->flags & (ATTR_KERNAMELS|ATTR_KERNOVAL)))
                                ? (ATTR_ENTRY(context->alist,
                                              context->count-1)->a_valuelen)
                                : 0,
@@ -2262,7 +2264,8 @@
                (__psunsigned_t)context->count,
                (__psunsigned_t)context->firstu,
                (__psunsigned_t)
-                       (context->count > 0)
+                       ((context->count > 0) &&
+                       !(context->flags & (ATTR_KERNAMELS|ATTR_KERNOVAL)))
                                ? (ATTR_ENTRY(context->alist,
                                              context->count-1)->a_valuelen)
                                : 0,
@@ -2290,7 +2293,8 @@
                (__psunsigned_t)context->count,
                (__psunsigned_t)context->firstu,
                (__psunsigned_t)
-                       (context->count > 0)
+                       ((context->count > 0) &&
+                       !(context->flags & (ATTR_KERNAMELS|ATTR_KERNOVAL)))
                                ? (ATTR_ENTRY(context->alist,
                                              context->count-1)->a_valuelen)
                                : 0,
@@ -2318,7 +2322,8 @@
                (__psunsigned_t)context->count,
                (__psunsigned_t)context->firstu,
                (__psunsigned_t)
-                       (context->count > 0)
+                       ((context->count > 0) &&
+                       !(context->flags & (ATTR_KERNAMELS|ATTR_KERNOVAL)))
                                ? (ATTR_ENTRY(context->alist,
                                              context->count-1)->a_valuelen)
                                : 0,
@@ -2353,3 +2358,307 @@
                                         (void *)a14, (void *)a15);
 }
 #endif /* XFS_ATTR_TRACE */
+
+
+/*========================================================================
+ * System (pseudo) namespace attribute interface routines.
+ *========================================================================*/
+
+STATIC int
+posix_acl_access_set(
+       vnode_t *vp, char *name, void *data, size_t size, int xflags)
+{
+       return xfs_acl_vset(vp, data, size, _ACL_TYPE_ACCESS);
+}
+
+STATIC int
+posix_acl_access_remove(
+       struct vnode *vp, char *name, int xflags)
+{
+       return xfs_acl_vremove(vp, _ACL_TYPE_ACCESS);
+}
+
+STATIC int
+posix_acl_access_get(
+       vnode_t *vp, char *name, void *data, size_t size, int xflags)
+{
+       return xfs_acl_vget(vp, data, size, _ACL_TYPE_ACCESS);
+}
+
+STATIC int
+posix_acl_access_exists(
+       vnode_t *vp)
+{
+       return xfs_acl_vhasacl_access(vp);
+}
+
+STATIC int
+posix_acl_default_set(
+       vnode_t *vp, char *name, void *data, size_t size, int xflags)
+{
+       return xfs_acl_vset(vp, data, size, _ACL_TYPE_DEFAULT);
+}
+
+STATIC int
+posix_acl_default_get(
+       vnode_t *vp, char *name, void *data, size_t size, int xflags)
+{
+       return xfs_acl_vget(vp, data, size, _ACL_TYPE_DEFAULT);
+}
+
+STATIC int
+posix_acl_default_remove(
+       struct vnode *vp, char *name, int xflags)
+{
+       return xfs_acl_vremove(vp, _ACL_TYPE_DEFAULT);
+}
+
+STATIC int
+posix_acl_default_exists(
+       vnode_t *vp)
+{
+       return xfs_acl_vhasacl_default(vp);
+}
+
+struct attrnames posix_acl_access = {
+       .attr_name      = "posix_acl_access",
+       .attr_namelen   = sizeof("posix_acl_access") - 1,
+       .attr_get       = posix_acl_access_get,
+       .attr_set       = posix_acl_access_set,
+       .attr_remove    = posix_acl_access_remove,
+       .attr_exists    = posix_acl_access_exists,
+};
+
+struct attrnames posix_acl_default = {
+       .attr_name      = "posix_acl_default",
+       .attr_namelen   = sizeof("posix_acl_default") - 1,
+       .attr_get       = posix_acl_default_get,
+       .attr_set       = posix_acl_default_set,
+       .attr_remove    = posix_acl_default_remove,
+       .attr_exists    = posix_acl_default_exists,
+};
+
+struct attrnames *attr_system_names[] =
+       { &posix_acl_access, &posix_acl_default };
+
+
+/*========================================================================
+ * Namespace-prefix-style attribute name interface routines.
+ *========================================================================*/
+
+STATIC int
+attr_generic_set(
+       struct vnode *vp, char *name, void *data, size_t size, int xflags)
+{
+       int     error;
+
+       VOP_ATTR_SET(vp, name, data, size, xflags, NULL, error);
+       return -error;
+}
+
+STATIC int
+attr_generic_get(
+       struct vnode *vp, char *name, void *data, size_t size, int xflags)
+{
+       int     error, asize = size;
+
+       VOP_ATTR_GET(vp, name, data, &asize, xflags, NULL, error);
+       if (!error)
+               return asize;
+       return -error;
+}
+
+STATIC int
+attr_generic_remove(
+       struct vnode *vp, char *name, int xflags)
+{
+       int     error;
+
+       VOP_ATTR_REMOVE(vp, name, xflags, NULL, error);
+       return -error;
+}
+
+STATIC int
+attr_generic_listadd(
+       attrnames_t             *prefix,
+       attrnames_t             *namesp,
+       void                    *data,
+       size_t                  size,
+       ssize_t                 *result)
+{
+       char                    *p = data + *result;
+
+       *result += prefix->attr_namelen;
+       *result += namesp->attr_namelen + 1;
+       if (!size)
+               return 0;
+       if (*result > size)
+               return -ERANGE;
+       strcpy(p, prefix->attr_name);
+       p += prefix->attr_namelen;
+       strcpy(p, namesp->attr_name);
+       p += namesp->attr_namelen + 1;
+       return 0;
+}
+
+STATIC int
+attr_system_list(
+       struct vnode            *vp,
+       void                    *data,
+       size_t                  size,
+       ssize_t                 *result)
+{
+       attrnames_t             *namesp;
+       int                     i, error = 0;
+
+       for (i = 0; i < ATTR_SYSCOUNT; i++) {
+               namesp = attr_system_names[i];
+               if (!namesp->attr_exists || !namesp->attr_exists(vp))
+                       continue;
+               error = attr_generic_listadd(&attr_system, namesp,
+                                               data, size, result);
+               if (error)
+                       break;
+       }
+       return error;
+}
+
+int
+attr_generic_list(
+       struct vnode *vp, void *data, size_t size, int xflags, ssize_t *result)
+{
+       attrlist_cursor_kern_t  cursor = { 0 };
+       int                     error;
+
+       VOP_ATTR_LIST(vp, data, size, xflags, &cursor, NULL, error);
+       if (error > 0)
+               return -error;
+       *result = -error;
+       return attr_system_list(vp, data, size, result);
+}
+
+attrnames_t *
+attr_lookup_namespace(
+       char                    *name,
+       struct attrnames        **names,
+       int                     nnames)
+{
+       int                     i;
+
+       for (i = 0; i < nnames; i++)
+               if (!strncmp(name, names[i]->attr_name, names[i]->attr_namelen))
+                       return names[i];
+       return NULL;
+}
+
+/*
+ * Some checks to prevent people abusing EAs to get over quota:
+ * - Don't allow modifying user EAs on devices/symlinks;
+ * - Don't allow modifying user EAs if sticky bit set;
+ */
+STATIC int
+attr_user_capable(
+       struct vnode    *vp,
+       cred_t          *cred)
+{
+       struct inode    *inode = LINVFS_GET_IP(vp);
+
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
+               return -EPERM;
+       if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode) &&
+           !capable(CAP_SYS_ADMIN))
+               return -EPERM;
+       if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
+           (current_fsuid(cred) != inode->i_uid) && !capable(CAP_FOWNER))
+               return -EPERM;
+       return 0;
+}
+
+STATIC int
+attr_trusted_capable(
+       struct vnode    *vp,
+       cred_t          *cred)
+{
+       struct inode    *inode = LINVFS_GET_IP(vp);
+
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
+               return -EPERM;
+       if (!capable(CAP_SYS_ADMIN))
+               return -EPERM;
+       return 0;
+}
+
+STATIC int
+attr_system_set(
+       struct vnode *vp, char *name, void *data, size_t size, int xflags)
+{
+       attrnames_t     *namesp;
+       int             error;
+
+       if (xflags & ATTR_CREATE)
+               return -EINVAL;
+
+       namesp = attr_lookup_namespace(name, attr_system_names, ATTR_SYSCOUNT);
+       if (!namesp)
+               return -EOPNOTSUPP;
+       error = namesp->attr_set(vp, name, data, size, xflags);
+       if (!error)
+               error = vn_revalidate(vp);
+       return error;
+}
+
+STATIC int
+attr_system_get(
+       struct vnode *vp, char *name, void *data, size_t size, int xflags)
+{
+       attrnames_t     *namesp;
+
+       namesp = attr_lookup_namespace(name, attr_system_names, ATTR_SYSCOUNT);
+       if (!namesp)
+               return -EOPNOTSUPP;
+       return namesp->attr_get(vp, name, data, size, xflags);
+}
+
+STATIC int
+attr_system_remove(
+       struct vnode *vp, char *name, int xflags)
+{
+       attrnames_t     *namesp;
+
+       namesp = attr_lookup_namespace(name, attr_system_names, ATTR_SYSCOUNT);
+       if (!namesp)
+               return -EOPNOTSUPP;
+       return namesp->attr_remove(vp, name, xflags);
+}
+
+struct attrnames attr_system = {
+       .attr_name      = "system.",
+       .attr_namelen   = sizeof("system.") - 1,
+       .attr_flag      = ATTR_SYSTEM,
+       .attr_get       = attr_system_get,
+       .attr_set       = attr_system_set,
+       .attr_remove    = attr_system_remove,
+       .attr_capable   = (attrcapable_t)fs_noerr,
+};
+
+struct attrnames attr_trusted = {
+       .attr_name      = "trusted.",
+       .attr_namelen   = sizeof("trusted.") - 1,
+       .attr_flag      = ATTR_ROOT,
+       .attr_get       = attr_generic_get,
+       .attr_set       = attr_generic_set,
+       .attr_remove    = attr_generic_remove,
+       .attr_capable   = attr_trusted_capable,
+};
+
+struct attrnames attr_user = {
+       .attr_name      = "user.",
+       .attr_namelen   = sizeof("user.") - 1,
+       .attr_get       = attr_generic_get,
+       .attr_set       = attr_generic_set,
+       .attr_remove    = attr_generic_remove,
+       .attr_capable   = attr_user_capable,
+};
+
+struct attrnames *attr_namespaces[] =
+       { &attr_system, &attr_trusted, &attr_user };
diff -urN linux.org/fs/xfs/xfs_attr.h linux/fs/xfs/xfs_attr.h
--- linux.org/fs/xfs/xfs_attr.h 2003-12-31 05:46:42.000000000 +0100
+++ linux/fs/xfs/xfs_attr.h     2004-01-02 04:21:42.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000, 2002-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -45,22 +45,50 @@
  * as possible so as to fit into the literal area of the inode.
  */
 
-#ifdef XFS_ALL_TRACE
-#define        XFS_ATTR_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_ATTR_TRACE
-#endif
-
-
 /*========================================================================
  * External interfaces
  *========================================================================*/
 
-#define ATTR_ROOT      0x0002  /* use attrs in root namespace, not user */
+struct cred;
+struct vnode;
+
+typedef int (*attrset_t)(struct vnode *, char *, void *, size_t, int);
+typedef int (*attrget_t)(struct vnode *, char *, void *, size_t, int);
+typedef int (*attrremove_t)(struct vnode *, char *, int);
+typedef int (*attrexists_t)(struct vnode *);
+typedef int (*attrcapable_t)(struct vnode *, struct cred *);
+
+typedef struct attrnames {
+       char *          attr_name;
+       unsigned int    attr_namelen;
+       unsigned int    attr_flag;
+       attrget_t       attr_get;
+       attrset_t       attr_set;
+       attrremove_t    attr_remove;
+       attrexists_t    attr_exists;
+       attrcapable_t   attr_capable;
+} attrnames_t;
+
+#define ATTR_NAMECOUNT 3
+extern struct attrnames attr_user;
+extern struct attrnames attr_system;
+extern struct attrnames attr_trusted;
+extern struct attrnames *attr_namespaces[ATTR_NAMECOUNT];
+
+#define ATTR_SYSCOUNT  2
+extern struct attrnames posix_acl_access;
+extern struct attrnames posix_acl_default;
+extern struct attrnames *attr_system_names[ATTR_SYSCOUNT];
+
+extern attrnames_t *attr_lookup_namespace(char *, attrnames_t **, int);
+extern int attr_generic_list(struct vnode *, void *, size_t, int, ssize_t *);
+
+#define ATTR_DONTFOLLOW        0x0001  /* -- unused, from IRIX -- */
+#define ATTR_ROOT      0x0002  /* use attrs in root (trusted) namespace */
+#define ATTR_TRUST     0x0004  /* -- unused, from IRIX -- */
 #define ATTR_CREATE    0x0010  /* pure create: fail if attr already exists */
 #define ATTR_REPLACE   0x0020  /* pure set: fail if attr does not exist */
+#define ATTR_SYSTEM    0x0100  /* use attrs in system (pseudo) namespace */
 #define ATTR_KERNOTIME 0x1000  /* [kernel] don't update inode timestamps */
 #define ATTR_KERNOVAL  0x2000  /* [kernel] get attr size only, not value */
 #define ATTR_KERNAMELS 0x4000  /* [kernel] list attr names (simple list) */
@@ -135,11 +163,8 @@
  * Function prototypes for the kernel.
  *========================================================================*/
 
-struct cred;
-struct vnode;
 struct xfs_inode;
 struct attrlist_cursor_kern;
-struct xfs_ext_attr;
 struct xfs_da_args;
 
 /*
diff -urN linux.org/fs/xfs/xfs_attr_leaf.c linux/fs/xfs/xfs_attr_leaf.c
--- linux.org/fs/xfs/xfs_attr_leaf.c    2003-12-31 05:47:15.000000000 +0100
+++ linux/fs/xfs/xfs_attr_leaf.c        2004-01-02 04:21:42.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -444,8 +444,10 @@
                                                        < context->bufsize) {
                for (i = 0, sfe = &sf->list[0];
                                i < INT_GET(sf->hdr.count, ARCH_CONVERT); i++) {
-                       int ns = (sfe->flags & XFS_ATTR_ROOT)?
-                                               ROOT_NAMES : USER_NAMES;
+                       attrnames_t     *namesp;
+
+                       namesp = (sfe->flags & XFS_ATTR_ROOT) ? &attr_trusted :
+                                 &attr_user;
                        if (((context->flags & ATTR_ROOT) != 0) !=
                            ((sfe->flags & XFS_ATTR_ROOT) != 0) &&
                            !(context->flags & ATTR_KERNFULLS)) {
@@ -454,11 +456,11 @@
                        }
                        if (context->flags & ATTR_KERNOVAL) {
                                ASSERT(context->flags & ATTR_KERNAMELS);
-                               context->count += xfs_namespaces[ns].namelen +
+                               context->count += namesp->attr_namelen +
                                        INT_GET(sfe->namelen, ARCH_CONVERT) + 1;
                        }
                        else {
-                               if (xfs_attr_put_listent(context, ns,
+                               if (xfs_attr_put_listent(context, namesp,
                                                   (char *)sfe->nameval,
                                                   (int)sfe->namelen,
                                                   (int)INT_GET(sfe->valuelen,
@@ -544,18 +546,22 @@
         * Loop putting entries into the user buffer.
         */
        for ( ; i < nsbuf; i++, sbp++) {
-               int ns = (sbp->flags & XFS_ATTR_ROOT)? ROOT_NAMES:USER_NAMES;
+               attrnames_t     *namesp;
+
+               namesp = (sfe->flags & XFS_ATTR_ROOT) ? &attr_trusted :
+                         &attr_user;
+
                if (cursor->hashval != INT_GET(sbp->hash, ARCH_CONVERT)) {
                        cursor->hashval = INT_GET(sbp->hash, ARCH_CONVERT);
                        cursor->offset = 0;
                }
                if (context->flags & ATTR_KERNOVAL) {
                        ASSERT(context->flags & ATTR_KERNAMELS);
-                       context->count += xfs_namespaces[ns].namelen
-                                       + sbp->namelen + 1;
+                       context->count += namesp->attr_namelen +
+                                               sbp->namelen + 1;
                }
                else {
-                       if (xfs_attr_put_listent(context, ns,
+                       if (xfs_attr_put_listent(context, namesp,
                                        sbp->name, sbp->namelen,
                                        INT_GET(sbp->valuelen, ARCH_CONVERT)))
                                break;
@@ -2270,7 +2276,7 @@
        retval = 0;
        for (  ; (i < INT_GET(leaf->hdr.count, ARCH_CONVERT))
             && (retval == 0); entry++, i++) {
-               int ns = (entry->flags & XFS_ATTR_ROOT)? ROOT_NAMES:USER_NAMES;
+               attrnames_t     *namesp;
 
                if (INT_GET(entry->hashval, ARCH_CONVERT) != cursor->hashval) {
                        cursor->hashval = INT_GET(entry->hashval, ARCH_CONVERT);
@@ -2284,14 +2290,17 @@
                    !(context->flags & ATTR_KERNFULLS))
                        continue;               /* skip non-matching entries */
 
+               namesp = (entry->flags & XFS_ATTR_ROOT) ? &attr_trusted :
+                         &attr_user;
+
                if (entry->flags & XFS_ATTR_LOCAL) {
                        name_loc = XFS_ATTR_LEAF_NAME_LOCAL(leaf, i);
                        if (context->flags & ATTR_KERNOVAL) {
                                ASSERT(context->flags & ATTR_KERNAMELS);
-                               context->count += xfs_namespaces[ns].namelen
-                                               + (int)name_loc->namelen + 1;
+                               context->count += namesp->attr_namelen +
+                                               (int)name_loc->namelen + 1;
                        } else {
-                               retval = xfs_attr_put_listent(context, ns,
+                               retval = xfs_attr_put_listent(context, namesp,
                                        (char *)name_loc->nameval,
                                        (int)name_loc->namelen,
                                        (int)INT_GET(name_loc->valuelen,
@@ -2301,10 +2310,10 @@
                        name_rmt = XFS_ATTR_LEAF_NAME_REMOTE(leaf, i);
                        if (context->flags & ATTR_KERNOVAL) {
                                ASSERT(context->flags & ATTR_KERNAMELS);
-                               context->count += xfs_namespaces[ns].namelen
-                                               + (int)name_rmt->namelen + 1;
+                               context->count += namesp->attr_namelen +
+                                               (int)name_rmt->namelen + 1;
                        } else {
-                               retval = xfs_attr_put_listent(context, ns,
+                               retval = xfs_attr_put_listent(context, namesp,
                                        (char *)name_rmt->name,
                                        (int)name_rmt->namelen,
                                        (int)INT_GET(name_rmt->valuelen,
@@ -2333,7 +2342,7 @@
 /*ARGSUSED*/
 int
 xfs_attr_put_listent(xfs_attr_list_context_t *context,
-                    int ns, char *name, int namelen, int valuelen)
+                    attrnames_t *namesp, char *name, int namelen, int valuelen)
 {
        attrlist_ent_t *aep;
        int arraytop;
@@ -2341,23 +2350,21 @@
        ASSERT(!(context->flags & ATTR_KERNOVAL));
        if (context->flags & ATTR_KERNAMELS) {
                char *offset;
-               xattr_namespace_t *nsp;
 
                ASSERT(context->count >= 0);
 
-               nsp = &xfs_namespaces[ns];
-               arraytop = context->count + nsp->namelen + namelen+1;
+               arraytop = context->count + namesp->attr_namelen + namelen + 1;
                if (arraytop > context->firstu) {
                        context->count = -1;    /* insufficient space */
                        return(1);
                }
                offset = (char *)context->alist + context->count;
-               strncpy(offset, nsp->name, nsp->namelen);       /* namespace */
-               offset += nsp->namelen;
+               strncpy(offset, namesp->attr_name, namesp->attr_namelen);
+               offset += namesp->attr_namelen;
                strncpy(offset, name, namelen);                 /* real name */
                offset += namelen;
                *offset = '\0';
-               context->count += nsp->namelen + namelen + 1;
+               context->count += namesp->attr_namelen + namelen + 1;
                return(0);
        }
 
diff -urN linux.org/fs/xfs/xfs_attr_leaf.h linux/fs/xfs/xfs_attr_leaf.h
--- linux.org/fs/xfs/xfs_attr_leaf.h    2003-12-31 05:46:18.000000000 +0100
+++ linux/fs/xfs/xfs_attr_leaf.h        2004-01-02 04:21:42.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000, 2002-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -44,6 +44,7 @@
 
 struct attrlist;
 struct attrlist_cursor_kern;
+struct attrnames;
 struct xfs_dabuf;
 struct xfs_da_args;
 struct xfs_da_state;
@@ -128,7 +129,7 @@
  * on the system call, they are "or"ed together for various operations.
  */
 #define        XFS_ATTR_LOCAL_BIT      0       /* attr is stored locally */
-#define        XFS_ATTR_ROOT_BIT       1       /* limit access to attr to userid 0 */
+#define        XFS_ATTR_ROOT_BIT       1       /* limit access to trusted attrs */
 #define        XFS_ATTR_INCOMPLETE_BIT 7       /* attr in middle of create/delete */
 #define XFS_ATTR_LOCAL         (1 << XFS_ATTR_LOCAL_BIT)
 #define XFS_ATTR_ROOT          (1 << XFS_ATTR_ROOT_BIT)
@@ -299,7 +300,8 @@
                                        int *local);
 int    xfs_attr_leaf_entsize(struct xfs_attr_leafblock *leaf, int index);
 int    xfs_attr_put_listent(struct xfs_attr_list_context *context,
-                            int ns, char *name, int namelen, int valuelen);
+                            struct attrnames *, char *name, int namelen,
+                            int valuelen);
 int    xfs_attr_rolltrans(struct xfs_trans **transp, struct xfs_inode *dp);
 
 #endif /* __XFS_ATTR_LEAF_H__ */
diff -urN linux.org/fs/xfs/xfs_attr_sf.h linux/fs/xfs/xfs_attr_sf.h
--- linux.org/fs/xfs/xfs_attr_sf.h      2003-12-31 05:46:54.000000000 +0100
+++ linux/fs/xfs/xfs_attr_sf.h  2004-01-02 04:21:42.000000000 +0100
@@ -104,14 +104,7 @@
        (INT_GET(((xfs_attr_shortform_t *)((dp)->i_afp->if_u1.if_data))->hdr.totsize, ARCH_CONVERT))
 #endif
 
-#ifdef XFS_ALL_TRACE
-#define        XFS_ATTR_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_ATTR_TRACE
-#endif
-
+#if defined(XFS_ATTR_TRACE)
 /*
  * Kernel tracing support for attribute lists
  */
@@ -121,6 +114,7 @@
 struct xfs_attr_leafblock;
 
 #define        XFS_ATTR_TRACE_SIZE     4096    /* size of global trace buffer */
+extern ktrace_t        *xfs_attr_trace_buf;
 
 /*
  * Trace record types.
@@ -130,8 +124,6 @@
 #define        XFS_ATTR_KTRACE_L_CB    3       /* context, btree */
 #define        XFS_ATTR_KTRACE_L_CL    4       /* context, leaf */
 
-#if defined(XFS_ATTR_TRACE)
-
 void xfs_attr_trace_l_c(char *where, struct xfs_attr_list_context *context);
 void xfs_attr_trace_l_cn(char *where, struct xfs_attr_list_context *context,
                              struct xfs_da_intnode *node);
diff -urN linux.org/fs/xfs/xfs_bmap_btree.c linux/fs/xfs/xfs_bmap_btree.c
--- linux.org/fs/xfs/xfs_bmap_btree.c   2003-12-31 05:47:31.000000000 +0100
+++ linux/fs/xfs/xfs_bmap_btree.c       2004-01-02 04:21:42.000000000 +0100
@@ -81,6 +81,13 @@
 
 
 #if defined(XFS_BMBT_TRACE)
+
+static char    ARGS[] = "args";
+static char    ENTRY[] = "entry";
+static char    ERROR[] = "error";
+#undef EXIT
+static char    EXIT[] = "exit";
+
 /*
  * Add a trace buffer entry for the arguments given to the routine,
  * generic form.
@@ -305,11 +312,6 @@
        xfs_bmbt_trace_argik(fname, c, i, k, __LINE__)
 #define        XFS_BMBT_TRACE_CURSOR(c,s)      \
        xfs_bmbt_trace_cursor(fname, c, s, __LINE__)
-static char    ARGS[] = "args";
-static char    ENTRY[] = "entry";
-static char    ERROR[] = "error";
-#undef EXIT
-static char    EXIT[] = "exit";
 #else
 #define        XFS_BMBT_TRACE_ARGBI(c,b,i)
 #define        XFS_BMBT_TRACE_ARGBII(c,b,i,j)
diff -urN linux.org/fs/xfs/xfs_bmap_btree.h linux/fs/xfs/xfs_bmap_btree.h
--- linux.org/fs/xfs/xfs_bmap_btree.h   2003-12-31 05:47:25.000000000 +0100
+++ linux/fs/xfs/xfs_bmap_btree.h       2004-01-02 04:21:43.000000000 +0100
@@ -435,6 +435,10 @@
         INT_GET((bb)->bb_numrecs, ARCH_CONVERT) <= (mp)->m_bmap_dmxr[(level) != 0])
 #endif
 
+
+#ifdef __KERNEL__
+
+#if defined(XFS_BMBT_TRACE)
 /*
  * Trace buffer entry types.
  */
@@ -449,18 +453,9 @@
 
 #define XFS_BMBT_TRACE_SIZE    4096    /* size of global trace buffer */
 #define XFS_BMBT_KTRACE_SIZE   32      /* size of per-inode trace buffer */
-
-#if defined(XFS_ALL_TRACE)
-#define XFS_BMBT_TRACE
+extern ktrace_t        *xfs_bmbt_trace_buf;
 #endif
 
-#if !defined(DEBUG)
-#undef XFS_BMBT_TRACE
-#endif
-
-
-#ifdef __KERNEL__
-
 /*
  * Prototypes for xfs_bmap.c to call.
  */
diff -urN linux.org/fs/xfs/xfs_bmap.c linux/fs/xfs/xfs_bmap.c
--- linux.org/fs/xfs/xfs_bmap.c 2003-12-31 05:48:24.000000000 +0100
+++ linux/fs/xfs/xfs_bmap.c     2004-01-02 04:21:42.000000000 +0100
@@ -68,9 +68,6 @@
 #include "xfs_trans_space.h"
 #include "xfs_buf_item.h"
 
-#ifdef DEBUG
-ktrace_t       *xfs_bmap_trace_buf;
-#endif
 
 #ifdef XFSDEBUG
 STATIC void
@@ -404,7 +401,7 @@
 #define        xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap)
 #endif /* DEBUG */
 
-#if defined(DEBUG) && defined(XFS_RW_TRACE)
+#if defined(XFS_RW_TRACE)
 STATIC void
 xfs_bunmap_trace(
        xfs_inode_t             *ip,
@@ -414,7 +411,7 @@
        inst_t                  *ra);
 #else
 #define        xfs_bunmap_trace(ip, bno, len, flags, ra)
-#endif /* DEBUG && XFS_RW_TRACE */
+#endif /* XFS_RW_TRACE */
 
 STATIC int
 xfs_bmap_count_tree(
@@ -3543,6 +3540,8 @@
 
 
 #ifdef XFS_BMAP_TRACE
+ktrace_t       *xfs_bmap_trace_buf;
+
 /*
  * Add a bmap trace buffer entry.  Base routine for the others.
  */
@@ -3575,14 +3574,14 @@
                (void *)(__psint_t)cnt,
                (void *)(__psunsigned_t)(ip->i_ino >> 32),
                (void *)(__psunsigned_t)(unsigned)ip->i_ino,
-               (void *)(__psunsigned_t)(INT_GET(r1->l0, ARCH_CONVERT) >> 32),
-               (void *)(__psunsigned_t)(unsigned)(INT_GET(r1->l0, ARCH_CONVERT)),
-               (void *)(__psunsigned_t)(INT_GET(r1->l1, ARCH_CONVERT) >> 32),
-               (void *)(__psunsigned_t)(unsigned)(INT_GET(r1->l1, ARCH_CONVERT)),
-               (void *)(__psunsigned_t)(INT_GET(r2->l0, ARCH_CONVERT) >> 32),
-               (void *)(__psunsigned_t)(unsigned)(INT_GET(r2->l0, ARCH_CONVERT)),
-               (void *)(__psunsigned_t)(INT_GET(r2->l1, ARCH_CONVERT) >> 32),
-               (void *)(__psunsigned_t)(unsigned)(INT_GET(r2->l1, ARCH_CONVERT))
+               (void *)(__psunsigned_t)(r1->l0 >> 32),
+               (void *)(__psunsigned_t)(unsigned)(r1->l0),
+               (void *)(__psunsigned_t)(r1->l1 >> 32),
+               (void *)(__psunsigned_t)(unsigned)(r1->l1),
+               (void *)(__psunsigned_t)(r2->l0 >> 32),
+               (void *)(__psunsigned_t)(unsigned)(r2->l0),
+               (void *)(__psunsigned_t)(r2->l1 >> 32),
+               (void *)(__psunsigned_t)(unsigned)(r2->l1)
                );
        ASSERT(ip->i_xtrace);
        ktrace_enter(ip->i_xtrace,
@@ -3592,14 +3591,14 @@
                (void *)(__psint_t)cnt,
                (void *)(__psunsigned_t)(ip->i_ino >> 32),
                (void *)(__psunsigned_t)(unsigned)ip->i_ino,
-               (void *)(__psunsigned_t)(INT_GET(r1->l0, ARCH_CONVERT) >> 32),
-               (void *)(__psunsigned_t)(unsigned)(INT_GET(r1->l0, ARCH_CONVERT)),
-               (void *)(__psunsigned_t)(INT_GET(r1->l1, ARCH_CONVERT) >> 32),
-               (void *)(__psunsigned_t)(unsigned)(INT_GET(r1->l1, ARCH_CONVERT)),
-               (void *)(__psunsigned_t)(INT_GET(r2->l0, ARCH_CONVERT) >> 32),
-               (void *)(__psunsigned_t)(unsigned)(INT_GET(r2->l0, ARCH_CONVERT)),
-               (void *)(__psunsigned_t)(INT_GET(r2->l1, ARCH_CONVERT) >> 32),
-               (void *)(__psunsigned_t)(unsigned)(INT_GET(r2->l1, ARCH_CONVERT))
+               (void *)(__psunsigned_t)(r1->l0 >> 32),
+               (void *)(__psunsigned_t)(unsigned)(r1->l0),
+               (void *)(__psunsigned_t)(r1->l1 >> 32),
+               (void *)(__psunsigned_t)(unsigned)(r1->l1),
+               (void *)(__psunsigned_t)(r2->l0 >> 32),
+               (void *)(__psunsigned_t)(unsigned)(r2->l0),
+               (void *)(__psunsigned_t)(r2->l1 >> 32),
+               (void *)(__psunsigned_t)(unsigned)(r2->l1)
                );
 }
 
@@ -3722,7 +3721,7 @@
        return rval;
 }
 
-#if defined(DEBUG) && defined(XFS_RW_TRACE)
+#if defined(XFS_RW_TRACE)
 STATIC void
 xfs_bunmap_trace(
        xfs_inode_t             *ip,
@@ -3742,7 +3741,7 @@
                (void *)(__psint_t)((xfs_dfiloff_t)bno & 0xffffffff),
                (void *)(__psint_t)len,
                (void *)(__psint_t)flags,
-               (void *)(__psint_t)private.p_cpuid,
+               (void *)(unsigned long)current_cpu(),
                (void *)ra,
                (void *)0,
                (void *)0,
diff -urN linux.org/fs/xfs/xfs_bmap.h linux/fs/xfs/xfs_bmap.h
--- linux.org/fs/xfs/xfs_bmap.h 2003-12-31 05:46:44.000000000 +0100
+++ linux/fs/xfs/xfs_bmap.h     2004-01-02 04:21:42.000000000 +0100
@@ -90,26 +90,6 @@
 #define        DELAYSTARTBLOCK         ((xfs_fsblock_t)-1LL)
 #define        HOLESTARTBLOCK          ((xfs_fsblock_t)-2LL)
 
-/*
- * Trace operations for bmap extent tracing
- */
-#define        XFS_BMAP_KTRACE_DELETE  1
-#define        XFS_BMAP_KTRACE_INSERT  2
-#define        XFS_BMAP_KTRACE_PRE_UP  3
-#define        XFS_BMAP_KTRACE_POST_UP 4
-
-#define        XFS_BMAP_TRACE_SIZE     4096    /* size of global trace buffer */
-#define        XFS_BMAP_KTRACE_SIZE    32      /* size of per-inode trace buffer */
-
-#if defined(XFS_ALL_TRACE)
-#define        XFS_BMAP_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_BMAP_TRACE
-#endif
-
-
 #if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_INIT)
 void xfs_bmap_init(xfs_bmap_free_t *flp, xfs_fsblock_t *fbp);
 #define        XFS_BMAP_INIT(flp,fbp)  xfs_bmap_init(flp,fbp)
@@ -142,6 +122,33 @@
 } xfs_bmalloca_t;
 
 #ifdef __KERNEL__
+
+#if defined(XFS_BMAP_TRACE)
+/*
+ * Trace operations for bmap extent tracing
+ */
+#define        XFS_BMAP_KTRACE_DELETE  1
+#define        XFS_BMAP_KTRACE_INSERT  2
+#define        XFS_BMAP_KTRACE_PRE_UP  3
+#define        XFS_BMAP_KTRACE_POST_UP 4
+
+#define        XFS_BMAP_TRACE_SIZE     4096    /* size of global trace buffer */
+#define        XFS_BMAP_KTRACE_SIZE    32      /* size of per-inode trace buffer */
+extern ktrace_t        *xfs_bmap_trace_buf;
+
+/*
+ * Add bmap trace insert entries for all the contents of the extent list.
+ */
+void
+xfs_bmap_trace_exlist(
+       char                    *fname,         /* function name */
+       struct xfs_inode        *ip,            /* incore inode pointer */
+       xfs_extnum_t            cnt,            /* count of entries in list */
+       int                     whichfork);     /* data or attr fork */
+#else
+#define        xfs_bmap_trace_exlist(f,ip,c,w)
+#endif
+
 /*
  * Convert inode from non-attributed to attributed.
  * Must not be in a transaction, ip must not be locked.
@@ -260,20 +267,6 @@
        struct xfs_inode        *ip,            /* incore inode */
        int                     whichfork);     /* data or attr fork */
 
-#if defined(XFS_BMAP_TRACE)
-/*
- * Add bmap trace insert entries for all the contents of the extent list.
- */
-void
-xfs_bmap_trace_exlist(
-       char                    *fname,         /* function name */
-       struct xfs_inode        *ip,            /* incore inode pointer */
-       xfs_extnum_t            cnt,            /* count of entries in list */
-       int                     whichfork);     /* data or attr fork */
-#else
-#define        xfs_bmap_trace_exlist(f,ip,c,w)
-#endif
-
 /*
  * Map file blocks to filesystem blocks.
  * File range is given by the bno/len pair.
@@ -375,7 +368,7 @@
 int
 xfs_bmap_count_blocks(
        xfs_trans_t             *tp,
-       xfs_inode_t             *ip,
+       struct xfs_inode        *ip,
        int                     whichfork,
        int                     *count);
 
diff -urN linux.org/fs/xfs/xfs_buf.h linux/fs/xfs/xfs_buf.h
--- linux.org/fs/xfs/xfs_buf.h  2003-12-31 05:48:37.000000000 +0100
+++ linux/fs/xfs/xfs_buf.h      2004-01-02 04:21:43.000000000 +0100
@@ -181,7 +181,7 @@
 #define XFS_BUF_SET_VTYPE(bp, type)
 #define XFS_BUF_SET_REF(bp, ref)
 
-#define XFS_BUF_ISPINNED(bp)   pagebuf_ispin(bp)
+#define XFS_BUF_ISPINNED(bp)   pagebuf_ispin(bp)
 
 #define XFS_BUF_VALUSEMA(bp)   pagebuf_lock_value(bp)
 #define XFS_BUF_CPSEMA(bp)     (pagebuf_cond_lock(bp) == 0)
@@ -191,13 +191,11 @@
 
 /* setup the buffer target from a buftarg structure */
 #define XFS_BUF_SET_TARGET(bp, target) \
-       (bp)->pb_target = (target)
-
+               (bp)->pb_target = (target)
 #define XFS_BUF_TARGET(bp)     ((bp)->pb_target)
+#define XFS_BUFTARG_NAME(target)       \
+               pagebuf_target_name(target)
 
-#define XFS_BUFTARG_NAME(target) \
-       ({ char __b[BDEVNAME_SIZE]; bdevname((target->pbr_bdev), __b); __b; })
-       
 #define XFS_BUF_SET_VTYPE_REF(bp, type, ref)
 #define XFS_BUF_SET_VTYPE(bp, type)
 #define XFS_BUF_SET_REF(bp, ref)
@@ -231,18 +229,11 @@
        pagebuf_rele(bp);
 }
 
-
 #define xfs_bpin(bp)           pagebuf_pin(bp)
 #define xfs_bunpin(bp)         pagebuf_unpin(bp)
 
-#ifdef PAGEBUF_TRACE
-# define PB_DEFINE_TRACES
-# include <pagebuf/page_buf_trace.h>
-# define xfs_buftrace(id, bp)  PB_TRACE(bp, PB_TRACE_REC(external), (void *)id)
-#else
-# define xfs_buftrace(id, bp)  do { } while (0)
-#endif
-
+#define xfs_buftrace(id, bp)   \
+           pagebuf_trace(bp, id, NULL, (void *)__builtin_return_address(0))
 
 #define xfs_biodone(pb)                    \
            pagebuf_iodone(pb, (pb->pb_flags & PBF_FS_DATAIOD), 0)
diff -urN linux.org/fs/xfs/xfs_buf_item.c linux/fs/xfs/xfs_buf_item.c
--- linux.org/fs/xfs/xfs_buf_item.c     2003-12-31 05:46:23.000000000 +0100
+++ linux/fs/xfs/xfs_buf_item.c 2004-01-02 04:21:43.000000000 +0100
@@ -1207,13 +1207,14 @@
                     (void *)((unsigned long)bip->bli_flags),
                     (void *)((unsigned long)bip->bli_recur),
                     (void *)((unsigned long)atomic_read(&bip->bli_refcount)),
-                    (void *)XFS_BUF_ADDR(bp),
+                    (void *)((unsigned long)
+                               (0xFFFFFFFF & XFS_BUF_ADDR(bp) >> 32)),
+                    (void *)((unsigned long)(0xFFFFFFFF & XFS_BUF_ADDR(bp))),
                     (void *)((unsigned long)XFS_BUF_COUNT(bp)),
-                    (void *)((unsigned long)(0xFFFFFFFF & (XFS_BFLAGS(bp) >> 32))),
-                    (void *)((unsigned long)(0xFFFFFFFF & XFS_BFLAGS(bp))),
+                    (void *)((unsigned long)XFS_BUF_BFLAGS(bp)),
                     XFS_BUF_FSPRIVATE(bp, void *),
                     XFS_BUF_FSPRIVATE2(bp, void *),
-                    (void *)((unsigned long)bp->b_pincount),
+                    (void *)(unsigned long)XFS_BUF_ISPINNED(bp),
                     (void *)XFS_BUF_IODONE_FUNC(bp),
                     (void *)((unsigned long)(XFS_BUF_VALUSEMA(bp))),
                     (void *)bip->bli_item.li_desc,
diff -urN linux.org/fs/xfs/xfs_buf_item.h linux/fs/xfs/xfs_buf_item.h
--- linux.org/fs/xfs/xfs_buf_item.h     2003-12-31 05:48:00.000000000 +0100
+++ linux/fs/xfs/xfs_buf_item.h 2004-01-02 04:21:43.000000000 +0100
@@ -104,6 +104,15 @@
 struct xfs_buf;
 struct ktrace;
 struct xfs_mount;
+struct xfs_buf_log_item;
+
+#if defined(XFS_BLI_TRACE)
+#define        XFS_BLI_TRACE_SIZE      32
+
+void   xfs_buf_item_trace(char *, struct xfs_buf_log_item *);
+#else
+#define        xfs_buf_item_trace(id, bip)
+#endif
 
 /*
  * This is the in core log item structure used to track information
@@ -116,7 +125,7 @@
        unsigned int            bli_flags;      /* misc flags */
        unsigned int            bli_recur;      /* lock recursion count */
        atomic_t                bli_refcount;   /* cnt of tp refs */
-#ifdef DEBUG
+#ifdef XFS_BLI_TRACE
        struct ktrace           *bli_trace;     /* event trace buf */
 #endif
 #ifdef XFS_TRANS_DEBUG
@@ -137,23 +146,6 @@
        struct xfs_buf_cancel   *bc_next;
 } xfs_buf_cancel_t;
 
-#define        XFS_BLI_TRACE_SIZE      32
-
-
-#if defined(XFS_ALL_TRACE)
-#define        XFS_BLI_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_BLI_TRACE
-#endif
-
-#if defined(XFS_BLI_TRACE)
-void   xfs_buf_item_trace(char *, xfs_buf_log_item_t *);
-#else
-#define        xfs_buf_item_trace(id, bip)
-#endif
-
 void   xfs_buf_item_init(struct xfs_buf *, struct xfs_mount *);
 void   xfs_buf_item_relse(struct xfs_buf *);
 void   xfs_buf_item_log(xfs_buf_log_item_t *, uint, uint);
diff -urN linux.org/fs/xfs/xfs_da_btree.c linux/fs/xfs/xfs_da_btree.c
--- linux.org/fs/xfs/xfs_da_btree.c     2003-12-31 05:48:06.000000000 +0100
+++ linux/fs/xfs/xfs_da_btree.c 2004-01-02 04:21:43.000000000 +0100
@@ -66,13 +66,6 @@
 #include "xfs_error.h"
 #include "xfs_bit.h"
 
-#if defined(XFSDEBUG) && defined(CONFIG_KDB)
-#undef xfs_buftrace
-#define xfs_buftrace(A,B) \
-       printk("    xfs_buftrace : %s (0x%p)\n", A, B); \
-       BUG();
-#endif
-
 /*
  * xfs_da_btree.c
  *
diff -urN linux.org/fs/xfs/xfs_dfrag.c linux/fs/xfs/xfs_dfrag.c
--- linux.org/fs/xfs/xfs_dfrag.c        2003-12-31 05:46:28.000000000 +0100
+++ linux/fs/xfs/xfs_dfrag.c    2004-01-02 04:21:43.000000000 +0100
@@ -153,12 +153,12 @@
        if ((error = _MAC_XFS_IACCESS(tip, MACWRITE, NULL))) {
                goto error0;
        }
-       if ((current->fsuid != ip->i_d.di_uid) &&
+       if ((current_fsuid(cred) != ip->i_d.di_uid) &&
            (error = xfs_iaccess(ip, S_IWUSR, NULL)) &&
            !capable_cred(NULL, CAP_FOWNER)) {
                goto error0;
        }
-       if ((current->fsuid != tip->i_d.di_uid) &&
+       if ((current_fsuid(cred) != tip->i_d.di_uid) &&
            (error = xfs_iaccess(tip, S_IWUSR, NULL)) &&
            !capable_cred(NULL, CAP_FOWNER)) {
                goto error0;
diff -urN linux.org/fs/xfs/xfs_dir2_trace.c linux/fs/xfs/xfs_dir2_trace.c
--- linux.org/fs/xfs/xfs_dir2_trace.c   2003-12-31 05:48:09.000000000 +0100
+++ linux/fs/xfs/xfs_dir2_trace.c       2004-01-02 04:21:44.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2001 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -64,36 +64,37 @@
        char            *where,
        char            *name,
        int             namelen,
-       __psunsigned_t  a0,
-       __psunsigned_t  a1,
-       __psunsigned_t  a2,
-       __psunsigned_t  a3,
-       __psunsigned_t  a4,
-       __psunsigned_t  a5,
-       __psunsigned_t  a6)
+       void            *a0,
+       void            *a1,
+       void            *a2,
+       void            *a3,
+       void            *a4,
+       void            *a5,
+       void            *a6,
+       void            *a7)
 {
-       __psunsigned_t  n[6];
+       void            *n[5];
 
        ASSERT(xfs_dir2_trace_buf);
        ASSERT(dp->i_dir_trace);
        if (name)
-               memcpy(n, name, min(sizeof(n), namelen));
+               memcpy(n, name, min((int)sizeof(n), namelen));
        else
                memset((char *)n, 0, sizeof(n));
        ktrace_enter(xfs_dir2_trace_buf,
-               (void *)(__psunsigned_t)type, (void *)where,
+               (void *)(long)type, (void *)where,
                (void *)a0, (void *)a1, (void *)a2, (void *)a3,
-               (void *)a4, (void *)a5, (void *)a6,
-               (void *)(__psunsigned_t)namelen,
+               (void *)a4, (void *)a5, (void *)a6, (void *)a7,
+               (void *)(long)namelen,
                (void *)n[0], (void *)n[1], (void *)n[2],
-               (void *)n[3], (void *)n[4], (void *)n[5]);
+               (void *)n[3], (void *)n[4]);
        ktrace_enter(dp->i_dir_trace,
-               (void *)(__psunsigned_t)type, (void *)where,
+               (void *)(long)type, (void *)where,
                (void *)a0, (void *)a1, (void *)a2, (void *)a3,
-               (void *)a4, (void *)a5, (void *)a6,
-               (void *)(__psunsigned_t)namelen,
+               (void *)a4, (void *)a5, (void *)a6, (void *)a7,
+               (void *)(long)namelen,
                (void *)n[0], (void *)n[1], (void *)n[2],
-               (void *)n[3], (void *)n[4], (void *)n[5]);
+               (void *)n[3], (void *)n[4]);
 }
 
 void
@@ -103,9 +104,11 @@
 {
        xfs_dir2_trace_enter(args->dp, XFS_DIR2_KTRACE_ARGS, where,
                (char *)args->name, (int)args->namelen,
-               (__psunsigned_t)args->hashval, (__psunsigned_t)args->inumber,
-               (__psunsigned_t)args->dp, (__psunsigned_t)args->trans,
-               (__psunsigned_t)args->justcheck, 0, 0);
+               (void *)(unsigned long)args->hashval,
+               (void *)((unsigned long)(args->inumber >> 32)),
+               (void *)((unsigned long)(args->inumber & 0xFFFFFFFF)),
+               (void *)args->dp, (void *)args->trans,
+               (void *)(unsigned long)args->justcheck, NULL, NULL);
 }
 
 void
@@ -116,10 +119,12 @@
 {
        xfs_dir2_trace_enter(args->dp, XFS_DIR2_KTRACE_ARGS_B, where,
                (char *)args->name, (int)args->namelen,
-               (__psunsigned_t)args->hashval, (__psunsigned_t)args->inumber,
-               (__psunsigned_t)args->dp, (__psunsigned_t)args->trans,
-               (__psunsigned_t)args->justcheck,
-               (__psunsigned_t)(bp ? bp->bps[0] : NULL), 0);
+               (void *)(unsigned long)args->hashval,
+               (void *)((unsigned long)(args->inumber >> 32)),
+               (void *)((unsigned long)(args->inumber & 0xFFFFFFFF)),
+               (void *)args->dp, (void *)args->trans,
+               (void *)(unsigned long)args->justcheck,
+               (void *)(bp ? bp->bps[0] : NULL), NULL);
 }
 
 void
@@ -131,11 +136,13 @@
 {
        xfs_dir2_trace_enter(args->dp, XFS_DIR2_KTRACE_ARGS_BB, where,
                (char *)args->name, (int)args->namelen,
-               (__psunsigned_t)args->hashval, (__psunsigned_t)args->inumber,
-               (__psunsigned_t)args->dp, (__psunsigned_t)args->trans,
-               (__psunsigned_t)args->justcheck,
-               (__psunsigned_t)(lbp ? lbp->bps[0] : NULL),
-               (__psunsigned_t)(dbp ? dbp->bps[0] : NULL));
+               (void *)(unsigned long)args->hashval,
+               (void *)((unsigned long)(args->inumber >> 32)),
+               (void *)((unsigned long)(args->inumber & 0xFFFFFFFF)),
+               (void *)args->dp, (void *)args->trans,
+               (void *)(unsigned long)args->justcheck,
+               (void *)(lbp ? lbp->bps[0] : NULL),
+               (void *)(dbp ? dbp->bps[0] : NULL));
 }
 
 void
@@ -148,12 +155,14 @@
        int             sd,
        int             c)
 {
+       xfs_buf_t       *bpbs = bs ? bs->bps[0] : NULL;
+       xfs_buf_t       *bpbd = bd ? bd->bps[0] : NULL;
+
        xfs_dir2_trace_enter(args->dp, XFS_DIR2_KTRACE_ARGS_BIBII, where,
                (char *)args->name, (int)args->namelen,
-               (__psunsigned_t)args->dp, (__psunsigned_t)args->trans,
-               (__psunsigned_t)(bs ? bs->bps[0] : NULL), (__psunsigned_t)ss,
-               (__psunsigned_t)(bd ? bd->bps[0] : NULL), (__psunsigned_t)sd,
-               (__psunsigned_t)c);
+               (void *)args->dp, (void *)args->trans,
+               (void *)bpbs, (void *)(long)ss, (void *)bpbd, (void *)(long)sd,
+               (void *)(long)c, NULL);
 }
 
 void
@@ -163,12 +172,16 @@
        xfs_dir2_db_t   db,
        xfs_dabuf_t     *bp)
 {
+       xfs_buf_t       *dbp = bp ? bp->bps[0] : NULL;
+
        xfs_dir2_trace_enter(args->dp, XFS_DIR2_KTRACE_ARGS_DB, where,
                (char *)args->name, (int)args->namelen,
-               (__psunsigned_t)args->hashval, (__psunsigned_t)args->inumber,
-               (__psunsigned_t)args->dp, (__psunsigned_t)args->trans,
-               (__psunsigned_t)args->justcheck, (__psunsigned_t)db,
-               (__psunsigned_t)(bp ? bp->bps[0] : NULL));
+               (void *)(unsigned long)args->hashval,
+               (void *)((unsigned long)(args->inumber >> 32)),
+               (void *)((unsigned long)(args->inumber & 0xFFFFFFFF)),
+               (void *)args->dp, (void *)args->trans,
+               (void *)(unsigned long)args->justcheck, (void *)(long)db,
+               (void *)dbp);
 }
 
 void
@@ -179,9 +192,13 @@
 {
        xfs_dir2_trace_enter(args->dp, XFS_DIR2_KTRACE_ARGS_I, where,
                (char *)args->name, (int)args->namelen,
-               (__psunsigned_t)args->hashval, (__psunsigned_t)args->inumber,
-               (__psunsigned_t)args->dp, (__psunsigned_t)args->trans,
-               (__psunsigned_t)args->justcheck, (__psunsigned_t)i, 0);
+               (void *)(unsigned long)args->hashval,
+               (void *)((unsigned long)(args->inumber >> 32)),
+               (void *)((unsigned long)(args->inumber & 0xFFFFFFFF)),
+               (void *)args->dp, (void *)args->trans,
+               (void *)(unsigned long)args->justcheck,
+               (void *)((unsigned long)(i >> 32)),
+               (void *)((unsigned long)(i & 0xFFFFFFFF)));
 }
 
 void
@@ -192,9 +209,11 @@
 {
        xfs_dir2_trace_enter(args->dp, XFS_DIR2_KTRACE_ARGS_S, where,
                (char *)args->name, (int)args->namelen,
-               (__psunsigned_t)args->hashval, (__psunsigned_t)args->inumber,
-               (__psunsigned_t)args->dp, (__psunsigned_t)args->trans,
-               (__psunsigned_t)args->justcheck, (__psunsigned_t)s, 0);
+               (void *)(unsigned long)args->hashval,
+               (void *)((unsigned long)(args->inumber >> 32)),
+               (void *)((unsigned long)(args->inumber & 0xFFFFFFFF)),
+               (void *)args->dp, (void *)args->trans,
+               (void *)(unsigned long)args->justcheck, (void *)(long)s, 0);
 }
 
 void
@@ -204,11 +223,15 @@
        int             s,
        xfs_dabuf_t     *bp)
 {
+       xfs_buf_t       *dbp = bp ? bp->bps[0] : NULL;
+
        xfs_dir2_trace_enter(args->dp, XFS_DIR2_KTRACE_ARGS_SB, where,
                (char *)args->name, (int)args->namelen,
-               (__psunsigned_t)args->hashval, (__psunsigned_t)args->inumber,
-               (__psunsigned_t)args->dp, (__psunsigned_t)args->trans,
-               (__psunsigned_t)args->justcheck, (__psunsigned_t)s,
-               (__psunsigned_t)(bp ? bp->bps[0] : NULL));
+               (void *)(unsigned long)args->hashval,
+               (void *)((unsigned long)(args->inumber >> 32)),
+               (void *)((unsigned long)(args->inumber & 0xFFFFFFFF)),
+               (void *)args->dp, (void *)args->trans,
+               (void *)(unsigned long)args->justcheck, (void *)(long)s,
+               (void *)dbp);
 }
 #endif /* XFS_DIR2_TRACE */
diff -urN linux.org/fs/xfs/xfs_dir2_trace.h linux/fs/xfs/xfs_dir2_trace.h
--- linux.org/fs/xfs/xfs_dir2_trace.h   2003-12-31 05:46:56.000000000 +0100
+++ linux/fs/xfs/xfs_dir2_trace.h       2004-01-02 04:21:44.000000000 +0100
@@ -36,20 +36,15 @@
  * Tracing for xfs v2 directories.
  */
 
+#if defined(XFS_DIR2_TRACE)
+
 struct ktrace;
 struct xfs_dabuf;
 struct xfs_da_args;
 
-#ifdef XFS_ALL_TRACE
-#define XFS_DIR2_TRACE
-#endif /* XFS_ALL_TRACE */
-
-#if !defined(DEBUG)
-#undef XFS_DIR2_TRACE
-#endif /* !DEBUG */
-
 #define        XFS_DIR2_GTRACE_SIZE            4096    /* global buffer */
 #define        XFS_DIR2_KTRACE_SIZE            32      /* per-inode buffer */
+extern struct ktrace *xfs_dir2_trace_buf;
 
 #define        XFS_DIR2_KTRACE_ARGS            1       /* args only */
 #define        XFS_DIR2_KTRACE_ARGS_B          2       /* args + buffer */
@@ -60,8 +55,6 @@
 #define        XFS_DIR2_KTRACE_ARGS_SB         7       /* args, int, buffer */
 #define        XFS_DIR2_KTRACE_ARGS_BIBII      8       /* args, buf/int/buf/int/int */
 
-#ifdef XFS_DIR2_TRACE
-
 void xfs_dir2_trace_args(char *where, struct xfs_da_args *args);
 void xfs_dir2_trace_args_b(char *where, struct xfs_da_args *args,
                           struct xfs_dabuf *bp);
@@ -90,6 +83,4 @@
 
 #endif /* XFS_DIR2_TRACE */
 
-extern struct ktrace *xfs_dir2_trace_buf;
-
 #endif /* __XFS_DIR2_TRACE_H__ */
diff -urN linux.org/fs/xfs/xfs_dir.c linux/fs/xfs/xfs_dir.c
--- linux.org/fs/xfs/xfs_dir.c  2003-12-31 05:46:43.000000000 +0100
+++ linux/fs/xfs/xfs_dir.c      2004-01-02 04:21:43.000000000 +0100
@@ -1093,10 +1093,10 @@
 xfs_dir_trace_g_du(char *where, xfs_inode_t *dp, uio_t *uio)
 {
        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DU, where,
-                    (__psunsigned_t)dp, (__psunsigned_t)dp->i_mount,
-                    (__psunsigned_t)(uio->uio_offset >> 32),
-                    (__psunsigned_t)(uio->uio_offset & 0xFFFFFFFF),
-                    (__psunsigned_t)uio->uio_resid,
+                    (void *)dp, (void *)dp->i_mount,
+                    (void *)((unsigned long)(uio->uio_offset >> 32)),
+                    (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
+                    (void *)(unsigned long)uio->uio_resid,
                     NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
@@ -1107,11 +1107,11 @@
 xfs_dir_trace_g_dub(char *where, xfs_inode_t *dp, uio_t *uio, xfs_dablk_t bno)
 {
        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUB, where,
-                    (__psunsigned_t)dp, (__psunsigned_t)dp->i_mount,
-                    (__psunsigned_t)(uio->uio_offset >> 32),
-                    (__psunsigned_t)(uio->uio_offset & 0xFFFFFFFF),
-                    (__psunsigned_t)uio->uio_resid,
-                    (__psunsigned_t)bno,
+                    (void *)dp, (void *)dp->i_mount,
+                    (void *)((unsigned long)(uio->uio_offset >> 32)),
+                    (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
+                    (void *)(unsigned long)uio->uio_resid,
+                    (void *)(unsigned long)bno,
                     NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
@@ -1122,15 +1122,21 @@
 xfs_dir_trace_g_dun(char *where, xfs_inode_t *dp, uio_t *uio,
                        xfs_da_intnode_t *node)
 {
+       int     last = INT_GET(node->hdr.count, ARCH_CONVERT) - 1;
+
        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUN, where,
-                    (__psunsigned_t)dp, (__psunsigned_t)dp->i_mount,
-                    (__psunsigned_t)(uio->uio_offset >> 32),
-                    (__psunsigned_t)(uio->uio_offset & 0xFFFFFFFF),
-                    (__psunsigned_t)uio->uio_resid,
-                    (__psunsigned_t)INT_GET(node->hdr.info.forw, ARCH_CONVERT),
-                    (__psunsigned_t)INT_GET(node->hdr.count, ARCH_CONVERT),
-                    (__psunsigned_t)INT_GET(node->btree[0].hashval, ARCH_CONVERT),
-                    (__psunsigned_t)INT_GET(node->btree[INT_GET(node->hdr.count, ARCH_CONVERT)-1].hashval, ARCH_CONVERT),
+                    (void *)dp, (void *)dp->i_mount,
+                    (void *)((unsigned long)(uio->uio_offset >> 32)),
+                    (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
+                    (void *)(unsigned long)uio->uio_resid,
+                    (void *)(unsigned long)
+                       INT_GET(node->hdr.info.forw, ARCH_CONVERT),
+                    (void *)(unsigned long)
+                       INT_GET(node->hdr.count, ARCH_CONVERT),
+                    (void *)(unsigned long)
+                       INT_GET(node->btree[0].hashval, ARCH_CONVERT),
+                    (void *)(unsigned long)
+                       INT_GET(node->btree[last].hashval, ARCH_CONVERT),
                     NULL, NULL, NULL);
 }
 
@@ -1141,15 +1147,21 @@
 xfs_dir_trace_g_dul(char *where, xfs_inode_t *dp, uio_t *uio,
                        xfs_dir_leafblock_t *leaf)
 {
+       int     last = INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1;
+
        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUL, where,
-                    (__psunsigned_t)dp, (__psunsigned_t)dp->i_mount,
-                    (__psunsigned_t)(uio->uio_offset >> 32),
-                    (__psunsigned_t)(uio->uio_offset & 0xFFFFFFFF),
-                    (__psunsigned_t)uio->uio_resid,
-                    (__psunsigned_t)INT_GET(leaf->hdr.info.forw, ARCH_CONVERT),
-                    (__psunsigned_t)INT_GET(leaf->hdr.count, ARCH_CONVERT),
-                    (__psunsigned_t)INT_GET(leaf->entries[0].hashval, ARCH_CONVERT),
-                    (__psunsigned_t)INT_GET(leaf->entries[ INT_GET(leaf->hdr.count, ARCH_CONVERT)-1 ].hashval, ARCH_CONVERT),
+                    (void *)dp, (void *)dp->i_mount,
+                    (void *)((unsigned long)(uio->uio_offset >> 32)),
+                    (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
+                    (void *)(unsigned long)uio->uio_resid,
+                    (void *)(unsigned long)
+                       INT_GET(leaf->hdr.info.forw, ARCH_CONVERT),
+                    (void *)(unsigned long)
+                       INT_GET(leaf->hdr.count, ARCH_CONVERT),
+                    (void *)(unsigned long)
+                       INT_GET(leaf->entries[0].hashval, ARCH_CONVERT),
+                    (void *)(unsigned long)
+                       INT_GET(leaf->entries[last].hashval, ARCH_CONVERT),
                     NULL, NULL, NULL);
 }
 
@@ -1161,11 +1173,12 @@
                        xfs_dir_leaf_entry_t *entry)
 {
        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUE, where,
-                    (__psunsigned_t)dp, (__psunsigned_t)dp->i_mount,
-                    (__psunsigned_t)(uio->uio_offset >> 32),
-                    (__psunsigned_t)(uio->uio_offset & 0xFFFFFFFF),
-                    (__psunsigned_t)uio->uio_resid,
-                    (__psunsigned_t)INT_GET(entry->hashval, ARCH_CONVERT),
+                    (void *)dp, (void *)dp->i_mount,
+                    (void *)((unsigned long)(uio->uio_offset >> 32)),
+                    (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
+                    (void *)(unsigned long)uio->uio_resid,
+                    (void *)(unsigned long)
+                       INT_GET(entry->hashval, ARCH_CONVERT),
                     NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
@@ -1176,12 +1189,12 @@
 xfs_dir_trace_g_duc(char *where, xfs_inode_t *dp, uio_t *uio, xfs_off_t cookie)
 {
        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUC, where,
-                    (__psunsigned_t)dp, (__psunsigned_t)dp->i_mount,
-                    (__psunsigned_t)(uio->uio_offset >> 32),
-                    (__psunsigned_t)(uio->uio_offset & 0xFFFFFFFF),
-                    (__psunsigned_t)uio->uio_resid,
-                    (__psunsigned_t)(cookie >> 32),
-                    (__psunsigned_t)(cookie & 0xFFFFFFFF),
+                    (void *)dp, (void *)dp->i_mount,
+                    (void *)((unsigned long)(uio->uio_offset >> 32)),
+                    (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
+                    (void *)(unsigned long)uio->uio_resid,
+                    (void *)((unsigned long)(cookie >> 32)),
+                    (void *)((unsigned long)(cookie & 0xFFFFFFFF)),
                     NULL, NULL, NULL, NULL, NULL);
 }
 
@@ -1191,15 +1204,15 @@
  */
 void
 xfs_dir_trace_enter(int type, char *where,
-                       __psunsigned_t a0, __psunsigned_t a1,
-                       __psunsigned_t a2, __psunsigned_t a3,
-                       __psunsigned_t a4, __psunsigned_t a5,
-                       __psunsigned_t a6, __psunsigned_t a7,
-                       __psunsigned_t a8, __psunsigned_t a9,
-                       __psunsigned_t a10, __psunsigned_t a11)
+                       void * a0, void * a1,
+                       void * a2, void * a3,
+                       void * a4, void * a5,
+                       void * a6, void * a7,
+                       void * a8, void * a9,
+                       void * a10, void * a11)
 {
        ASSERT(xfs_dir_trace_buf);
-       ktrace_enter(xfs_dir_trace_buf, (void *)((__psunsigned_t)type),
+       ktrace_enter(xfs_dir_trace_buf, (void *)(unsigned long)type,
                                        (void *)where,
                                        (void *)a0, (void *)a1, (void *)a2,
                                        (void *)a3, (void *)a4, (void *)a5,
diff -urN linux.org/fs/xfs/xfs_dir.h linux/fs/xfs/xfs_dir.h
--- linux.org/fs/xfs/xfs_dir.h  2003-12-31 05:46:52.000000000 +0100
+++ linux/fs/xfs/xfs_dir.h      2004-01-02 04:21:43.000000000 +0100
@@ -43,14 +43,6 @@
  * as possible so as to fit into the literal area of the inode.
  */
 
-#ifdef XFS_ALL_TRACE
-#define        XFS_DIR_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_DIR_TRACE
-#endif
-
 /*========================================================================
  * Function prototypes for the kernel.
  *========================================================================*/
diff -urN linux.org/fs/xfs/xfs_dir_sf.h linux/fs/xfs/xfs_dir_sf.h
--- linux.org/fs/xfs/xfs_dir_sf.h       2003-12-31 05:47:55.000000000 +0100
+++ linux/fs/xfs/xfs_dir_sf.h   2004-01-02 04:21:44.000000000 +0100
@@ -126,13 +126,7 @@
               ((uint)sizeof(xfs_dir_sf_entry_t)-1)*(count) + (totallen))
 #endif
 
-#ifdef XFS_ALL_TRACE
-#define        XFS_DIR_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_DIR_TRACE
-#endif
+#if defined(XFS_DIR_TRACE)
 
 /*
  * Kernel tracing support for directories.
@@ -145,6 +139,7 @@
 struct xfs_dir_leaf_entry;
 
 #define        XFS_DIR_TRACE_SIZE      4096    /* size of global trace buffer */
+extern ktrace_t        *xfs_dir_trace_buf;
 
 /*
  * Trace record types.
@@ -156,8 +151,6 @@
 #define        XFS_DIR_KTRACE_G_DUE    5       /* dp, uio, leaf entry */
 #define        XFS_DIR_KTRACE_G_DUC    6       /* dp, uio, cookie */
 
-#if defined(XFS_DIR_TRACE)
-
 void xfs_dir_trace_g_du(char *where, struct xfs_inode *dp, struct uio *uio);
 void xfs_dir_trace_g_dub(char *where, struct xfs_inode *dp, struct uio *uio,
                              xfs_dablk_t bno);
@@ -170,12 +163,9 @@
 void xfs_dir_trace_g_duc(char *where, struct xfs_inode *dp, struct uio *uio,
                              xfs_off_t cookie);
 void xfs_dir_trace_enter(int type, char *where,
-                            __psunsigned_t a0, __psunsigned_t a1,
-                            __psunsigned_t a2, __psunsigned_t a3,
-                            __psunsigned_t a4, __psunsigned_t a5,
-                            __psunsigned_t a6, __psunsigned_t a7,
-                            __psunsigned_t a8, __psunsigned_t a9,
-                            __psunsigned_t a10, __psunsigned_t a11);
+                            void *a0, void *a1, void *a2, void *a3,
+                            void *a4, void *a5, void *a6, void *a7,
+                            void *a8, void *a9, void *a10, void *a11);
 #else
 #define        xfs_dir_trace_g_du(w,d,u)
 #define        xfs_dir_trace_g_dub(w,d,u,b)
diff -urN linux.org/fs/xfs/xfs_dmapi.h linux/fs/xfs/xfs_dmapi.h
--- linux.org/fs/xfs/xfs_dmapi.h        2003-12-31 05:48:36.000000000 +0100
+++ linux/fs/xfs/xfs_dmapi.h    2004-01-02 04:21:44.000000000 +0100
@@ -175,14 +175,6 @@
                        DM_FLAGS_NDELAY : 0)
 #define AT_DELAY_FLAG(f) ((f&ATTR_NONBLOCK) ? DM_FLAGS_NDELAY : 0)
 
-/*
- *     Macros to turn caller specified delay/block flags into
- *     dm_send_xxxx_event flag DM_FLAGS_NDELAY.
- */
-
-#define FILP_DELAY_FLAG(filp) ((filp->f_flags&(O_NDELAY|O_NONBLOCK)) ? \
-                       DM_FLAGS_NDELAY : 0)
-
 
 extern struct bhv_vfsops xfs_dmops;
 
diff -urN linux.org/fs/xfs/xfs_dmops.c linux/fs/xfs/xfs_dmops.c
--- linux.org/fs/xfs/xfs_dmops.c        2003-12-31 05:48:36.000000000 +0100
+++ linux/fs/xfs/xfs_dmops.c    2004-01-02 04:21:44.000000000 +0100
@@ -43,8 +43,6 @@
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 
-
-#ifndef CONFIG_XFS_DMAPI
 xfs_dmops_t    xfs_dmcore_xfs = {
        .xfs_send_data          = (xfs_send_data_t)fs_nosys,
        .xfs_send_mmap          = (xfs_send_mmap_t)fs_noerr,
@@ -52,4 +50,3 @@
        .xfs_send_namesp        = (xfs_send_namesp_t)fs_nosys,
        .xfs_send_unmount       = (xfs_send_unmount_t)fs_noval,
 };
-#endif /* CONFIG_XFS_DMAPI */
diff -urN linux.org/fs/xfs/xfs_error.c linux/fs/xfs/xfs_error.c
--- linux.org/fs/xfs/xfs_error.c        2003-12-31 05:48:26.000000000 +0100
+++ linux/fs/xfs/xfs_error.c    2004-01-02 04:21:44.000000000 +0100
@@ -102,7 +102,7 @@
        if (random() % randfactor)
                return 0;
 
-       memcpy(&fsid, fsidp, sizeof(fsid_t));
+       memcpy(&fsid, fsidp, sizeof(xfs_fsid_t));
 
        for (i = 0; i < XFS_NUM_INJECT_ERROR; i++)  {
                if (xfs_etest[i] == error_tag && xfs_etest_fsid[i] == fsid) {
@@ -123,7 +123,7 @@
        int len;
        int64_t fsid;
 
-       memcpy(&fsid, mp->m_fixedfsid, sizeof(fsid_t));
+       memcpy(&fsid, mp->m_fixedfsid, sizeof(xfs_fsid_t));
 
        for (i = 0; i < XFS_NUM_INJECT_ERROR; i++)  {
                if (xfs_etest_fsid[i] == fsid && xfs_etest[i] == error_tag) {
@@ -156,7 +156,7 @@
        int i;
        int64_t fsid;
 
-       memcpy(&fsid, mp->m_fixedfsid, sizeof(fsid_t));
+       memcpy(&fsid, mp->m_fixedfsid, sizeof(xfs_fsid_t));
 
        for (i = 0; i < XFS_NUM_INJECT_ERROR; i++) {
                if (xfs_etest_fsid[i] == fsid && xfs_etest[i] == error_tag) {
@@ -209,7 +209,7 @@
 {
        int64_t fsid;
 
-       memcpy(&fsid, mp->m_fixedfsid, sizeof(fsid_t));
+       memcpy(&fsid, mp->m_fixedfsid, sizeof(xfs_fsid_t));
 
        return xfs_errortag_clearall_umount(fsid, mp->m_fsname, 1);
 }
@@ -258,12 +258,6 @@
 }
 
 void
-xfs_stack_trace(void)
-{
-       dump_stack();
-}
-
-void
 xfs_error_report(
        char            *tag,
        int             level,
diff -urN linux.org/fs/xfs/xfs_fsops.c linux/fs/xfs/xfs_fsops.c
--- linux.org/fs/xfs/xfs_fsops.c        2003-12-31 05:48:18.000000000 +0100
+++ linux/fs/xfs/xfs_fsops.c    2004-01-02 04:21:42.000000000 +0100
@@ -51,6 +51,7 @@
 #include "xfs_fsops.h"
 #include "xfs_itable.h"
 #include "xfs_rw.h"
+#include "xfs_refcache.h"
 #include "xfs_trans_space.h"
 #include "xfs_rtalloc.h"
 #include "xfs_dir2.h"
@@ -593,6 +594,9 @@
        /* Stop new writers */
        xfs_start_freeze(mp, XFS_FREEZE_WRITE);
 
+       /* Flush the refcache */
+       xfs_refcache_purge_mp(mp);
+
        /* Flush delalloc and delwri data */
        VFS_SYNC(vfsp, SYNC_DELWRI|SYNC_WAIT, NULL, error);
 
diff -urN linux.org/fs/xfs/xfsidbg.c linux/fs/xfs/xfsidbg.c
--- linux.org/fs/xfs/xfsidbg.c  2003-12-31 05:48:07.000000000 +0100
+++ linux/fs/xfs/xfsidbg.c      2004-01-02 04:21:43.000000000 +0100
@@ -31,7 +31,6 @@
  */
 
 #include "xfs.h"
-#include "pagebuf/page_buf_internal.h"
 
 #include <linux/ctype.h>
 #include <linux/kdb.h>
@@ -61,9 +60,11 @@
 #include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_dir2_trace.h"
 #include "xfs_dinode.h"
-#include "xfs_inode.h"
+#include "xfs_rw.h"
 #include "xfs_bmap.h"
+#include "xfs_inode.h"
 #include "xfs_da_btree.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
@@ -72,18 +73,66 @@
 #include "xfs_dir2_leaf.h"
 #include "xfs_dir2_block.h"
 #include "xfs_dir2_node.h"
-#include "xfs_dir2_trace.h"
 #include "xfs_log_priv.h"
 #include "xfs_log_recover.h"
-#include "xfs_rw.h"
 #include "xfs_bit.h"
 #include "xfs_quota.h"
 #include "quota/xfs_qm.h"
+#include "xfs_iomap.h"
 
 MODULE_AUTHOR("Silicon Graphics, Inc.");
 MODULE_DESCRIPTION("Additional kdb commands for debugging XFS");
 MODULE_LICENSE("GPL");
 
+#define qprintf        kdb_printf
+
+/*
+ * Command table functions. (tracing)
+ */
+#ifdef XFS_ALLOC_TRACE
+static void    xfsidbg_xalatrace(int);
+static void    xfsidbg_xalbtrace(xfs_agblock_t);
+static void    xfsidbg_xalgtrace(xfs_agnumber_t);
+static void    xfsidbg_xalmtrace(xfs_mount_t *);
+static void    xfsidbg_xalttrace(int);
+#endif
+#ifdef XFS_ATTR_TRACE
+static void    xfsidbg_xattrtrace(int);
+#endif
+#ifdef XFS_BLI_TRACE
+static void    xfsidbg_xblitrace(xfs_buf_log_item_t *);
+#endif
+#ifdef XFS_BMAP_TRACE
+static void    xfsidbg_xbmatrace(int);
+static void    xfsidbg_xbmitrace(xfs_inode_t *);
+static void    xfsidbg_xbmstrace(xfs_inode_t *);
+static void    xfsidbg_xbxatrace(int);
+static void    xfsidbg_xbxitrace(xfs_inode_t *);
+static void    xfsidbg_xbxstrace(xfs_inode_t *);
+#endif
+#ifdef XFS_ILOCK_TRACE
+static void    xfsidbg_xilock_trace(xfs_inode_t *);
+static void    xfsidbg_xailock_trace(int);
+#endif
+#ifdef XFS_DIR_TRACE
+static void    xfsidbg_xdirtrace(int);
+#endif
+#ifdef XFS_DIR2_TRACE
+static void    xfsidbg_xdir2atrace(int);
+static void    xfsidbg_xdir2itrace(xfs_inode_t *);
+#endif
+#ifdef XFS_LOG_TRACE
+static void    xfsidbg_xiclogtrace(xlog_in_core_t *);
+static void    xfsidbg_xlog_granttrace(xlog_t *);
+#endif
+#ifdef XFS_DQUOT_TRACE
+static void    xfsidbg_xqm_dqtrace(xfs_dquot_t *);
+#endif
+#ifdef XFS_RW_TRACE
+static void    xfsidbg_xrwtrace(xfs_inode_t *);
+#endif
+
+
 /*
  * Command table functions.
  */
@@ -91,9 +140,6 @@
 static void    xfsidbg_xagi(xfs_agi_t *);
 static void    xfsidbg_xaildump(xfs_mount_t *);
 static void    xfsidbg_xalloc(xfs_alloc_arg_t *);
-#ifdef DEBUG
-static void    xfsidbg_xalmtrace(xfs_mount_t *);
-#endif
 static void    xfsidbg_xattrcontext(xfs_attr_list_context_t *);
 static void    xfsidbg_xattrleaf(xfs_attr_leafblock_t *);
 static void    xfsidbg_xattrsf(xfs_attr_shortform_t *);
@@ -105,6 +151,8 @@
 static void    xfsidbg_xbtcur(xfs_btree_cur_t *);
 static void    xfsidbg_xbuf(xfs_buf_t *);
 static void    xfsidbg_xbuf_real(xfs_buf_t *, int);
+static void    xfsidbg_xarg(int);
+static void    xfsidbg_xchksum(uint *);
 static void    xfsidbg_xchash(xfs_mount_t *mp);
 static void    xfsidbg_xchashlist(xfs_chashlist_t *chl);
 static void    xfsidbg_xdaargs(xfs_da_args_t *);
@@ -144,13 +192,18 @@
 static void    xfsidbg_xsb(xfs_sb_t *, int convert);
 static void    xfsidbg_xtp(xfs_trans_t *);
 static void    xfsidbg_xtrans_res(xfs_mount_t *);
-#ifdef CONFIG_XFS_QUOTA
+#ifdef CONFIG_XFS_QUOTA
 static void    xfsidbg_xqm(void);
 static void    xfsidbg_xqm_htab(void);
 static void    xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title);
 static void    xfsidbg_xqm_freelist(void);
 #endif
 
+#ifdef XFS_BMAP_TRACE
+static void    xfs_convert_extent(xfs_bmbt_rec_32_t *, xfs_dfiloff_t *,
+                               xfs_dfsbno_t *, xfs_dfilblks_t *, int *);
+#endif
+
 /* kdb wrappers */
 
 static int     kdbm_xfs_xagf(
@@ -216,7 +269,8 @@
        return 0;
 }
 
-static int     kdbm_xfs_xalloc(
+#ifdef XFS_ALLOC_TRACE
+static int     kdbm_xfs_xalatrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -226,19 +280,19 @@
        int nextarg = 1;
        long offset = 0;
        int diag;
-
+       
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xalloc((xfs_alloc_arg_t *) addr);
+       xfsidbg_xalatrace((int) addr);
        return 0;
 }
 
-#ifdef DEBUG
-static int     kdbm_xfs_xalmtrace(
+static int     kdbm_xfs_xalbtrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -251,16 +305,16 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xalmtrace((xfs_mount_t *) addr);
+       xfsidbg_xalbtrace((xfs_agblock_t) addr);
        return 0;
 }
-#endif /* DEBUG */
 
-static int     kdbm_xfs_xattrcontext(
+static int     kdbm_xfs_xalgtrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -273,15 +327,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xattrcontext((xfs_attr_list_context_t *) addr);
+       xfsidbg_xalgtrace((xfs_agnumber_t) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xattrleaf(
+#ifdef XFS_ATTR_TRACE
+static int     kdbm_xfs_xattrtrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -294,15 +351,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xattrleaf((xfs_attr_leafblock_t *) addr);
+       xfsidbg_xattrtrace((int) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xattrsf(
+#ifdef XFS_BLI_TRACE
+static int     kdbm_xfs_xblitrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -315,15 +375,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xattrsf((xfs_attr_shortform_t *) addr);
+       xfsidbg_xblitrace((xfs_buf_log_item_t *) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xbirec(
+#ifdef XFS_BMAP_TRACE
+static int     kdbm_xfs_xbmatrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -336,15 +399,16 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xbirec((xfs_bmbt_irec_t *) addr);
+       xfsidbg_xbmatrace((int) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xbmalla(
+static int     kdbm_xfs_xbmitrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -357,15 +421,16 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xbmalla((xfs_bmalloca_t *)addr);
+       xfsidbg_xbmitrace((xfs_inode_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xbrec(
+static int     kdbm_xfs_xbmstrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -378,15 +443,16 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xbrec((xfs_bmbt_rec_64_t *) addr);
+       xfsidbg_xbmstrace((xfs_inode_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xbroot(
+static int     kdbm_xfs_xbxatrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -399,15 +465,16 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xbroot((xfs_inode_t *) addr);
+       xfsidbg_xbxatrace((int) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xbroota(
+static int     kdbm_xfs_xbxitrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -420,15 +487,16 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xbroota((xfs_inode_t *) addr);
+       xfsidbg_xbxitrace((xfs_inode_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xbtcur(
+static int     kdbm_xfs_xbxstrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -441,15 +509,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xbtcur((xfs_btree_cur_t *) addr);
+       xfsidbg_xbxstrace((xfs_inode_t *) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xbuf(
+#ifdef XFS_DIR2_TRACE
+static int     kdbm_xfs_xdir2atrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -462,16 +533,16 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xbuf((xfs_buf_t *) addr);
+       xfsidbg_xdir2atrace((int) addr);
        return 0;
 }
 
-
-static int     kdbm_xfs_xchash(
+static int     kdbm_xfs_xdir2itrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -484,15 +555,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xchash((xfs_mount_t *) addr);
+       xfsidbg_xdir2itrace((xfs_inode_t *) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xchashlist(
+#ifdef XFS_DIR_TRACE
+static int     kdbm_xfs_xdirtrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -505,16 +579,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xchashlist((xfs_chashlist_t *) addr);
+       xfsidbg_xdirtrace((int) addr);
        return 0;
 }
+#endif
 
-
-static int     kdbm_xfs_xdaargs(
+#ifdef XFS_LOG_TRACE
+static int     kdbm_xfs_xiclogtrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -527,15 +603,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xdaargs((xfs_da_args_t *) addr);
+       xfsidbg_xiclogtrace((xlog_in_core_t *) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xdabuf(
+#ifdef XFS_ILOCK_TRACE
+static int     kdbm_xfs_xilock_trace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -548,15 +627,16 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xdabuf((xfs_dabuf_t *) addr);
+       xfsidbg_xilock_trace((xfs_inode_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xdanode(
+static int     kdbm_xfs_xailock_trace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -569,15 +649,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xdanode((xfs_da_intnode_t *) addr);
+       xfsidbg_xailock_trace((int) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xdastate(
+#ifdef XFS_LOG_TRACE
+static int     kdbm_xfs_xlog_granttrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -590,15 +673,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xdastate((xfs_da_state_t *) addr);
+       xfsidbg_xlog_granttrace((xlog_t *) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xdirleaf(
+#ifdef XFS_DQUOT_TRACE
+static int     kdbm_xfs_xqm_dqtrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -611,15 +697,18 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xdirleaf((xfs_dir_leafblock_t *) addr);
+       xfsidbg_xqm_dqtrace((xfs_dquot_t *) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xdirsf(
+#ifdef XFS_RW_TRACE
+static int     kdbm_xfs_xrwtrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -632,15 +721,17 @@
 
        if (argc != 1)
                return KDB_ARGCOUNT;
+
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
        if (diag)
                return diag;
 
-       xfsidbg_xdirsf((xfs_dir_shortform_t *) addr);
+       xfsidbg_xrwtrace((xfs_inode_t *) addr);
        return 0;
 }
+#endif
 
-static int     kdbm_xfs_xdir2free(
+static int     kdbm_xfs_xalloc(
        int     argc,
        const char **argv,
        const char **envp,
@@ -657,11 +748,12 @@
        if (diag)
                return diag;
 
-       xfsidbg_xdir2free((xfs_dir2_free_t *) addr);
+       xfsidbg_xalloc((xfs_alloc_arg_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xdir2sf(
+#ifdef XFS_ALLOC_TRACE
+static int     kdbm_xfs_xalmtrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -678,11 +770,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xdir2sf((xfs_dir2_sf_t *) addr);
+       xfsidbg_xalmtrace((xfs_mount_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xexlist(
+static int     kdbm_xfs_xalttrace(
        int     argc,
        const char **argv,
        const char **envp,
@@ -699,11 +791,12 @@
        if (diag)
                return diag;
 
-       xfsidbg_xexlist((xfs_inode_t *) addr);
+       xfsidbg_xalttrace((int) addr);
        return 0;
 }
+#endif /* XFS_ALLOC_TRACE */
 
-static int     kdbm_xfs_xflist(
+static int     kdbm_xfs_xattrcontext(
        int     argc,
        const char **argv,
        const char **envp,
@@ -720,24 +813,32 @@
        if (diag)
                return diag;
 
-       xfsidbg_xflist((xfs_bmap_free_t *) addr);
+       xfsidbg_xattrcontext((xfs_attr_list_context_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xhelp(
+static int     kdbm_xfs_xattrleaf(
        int     argc,
        const char **argv,
        const char **envp,
        struct pt_regs *regs)
 {
-       if (argc != 0)
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
                return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
 
-       xfsidbg_xhelp();
+       xfsidbg_xattrleaf((xfs_attr_leafblock_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xiclog(
+static int     kdbm_xfs_xattrsf(
        int     argc,
        const char **argv,
        const char **envp,
@@ -754,11 +855,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xiclog((xlog_in_core_t *) addr);
+       xfsidbg_xattrsf((xfs_attr_shortform_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xiclogall(
+static int     kdbm_xfs_xbirec(
        int     argc,
        const char **argv,
        const char **envp,
@@ -775,11 +876,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xiclogall((xlog_in_core_t *) addr);
+       xfsidbg_xbirec((xfs_bmbt_irec_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xiclogcb(
+static int     kdbm_xfs_xbmalla(
        int     argc,
        const char **argv,
        const char **envp,
@@ -796,11 +897,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xiclogcb((xlog_in_core_t *) addr);
+       xfsidbg_xbmalla((xfs_bmalloca_t *)addr);
        return 0;
 }
 
-static int     kdbm_xfs_xihash(
+static int     kdbm_xfs_xbrec(
        int     argc,
        const char **argv,
        const char **envp,
@@ -817,11 +918,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xihash((xfs_mount_t *) addr);
+       xfsidbg_xbrec((xfs_bmbt_rec_64_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xinodes(
+static int     kdbm_xfs_xbroot(
        int     argc,
        const char **argv,
        const char **envp,
@@ -838,11 +939,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xinodes((xfs_mount_t *) addr);
+       xfsidbg_xbroot((xfs_inode_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_delayed_blocks(
+static int     kdbm_xfs_xbroota(
        int     argc,
        const char **argv,
        const char **envp,
@@ -859,12 +960,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_delayed_blocks((xfs_mount_t *) addr);
+       xfsidbg_xbroota((xfs_inode_t *) addr);
        return 0;
 }
 
-
-static int     kdbm_xfs_xinodes_quiesce(
+static int     kdbm_xfs_xbtcur(
        int     argc,
        const char **argv,
        const char **envp,
@@ -881,11 +981,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xinodes_quiesce((xfs_mount_t *) addr);
+       xfsidbg_xbtcur((xfs_btree_cur_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xlog(
+static int     kdbm_xfs_xbuf(
        int     argc,
        const char **argv,
        const char **envp,
@@ -902,11 +1002,12 @@
        if (diag)
                return diag;
 
-       xfsidbg_xlog((xlog_t *) addr);
+       xfsidbg_xbuf((xfs_buf_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xlog_ritem(
+
+static int     kdbm_xfs_xarg(
        int     argc,
        const char **argv,
        const char **envp,
@@ -923,11 +1024,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xlog_ritem((xlog_recover_item_t *) addr);
+       xfsidbg_xarg((int) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xlog_rtrans(
+static int     kdbm_xfs_xchksum(
        int     argc,
        const char **argv,
        const char **envp,
@@ -944,11 +1045,12 @@
        if (diag)
                return diag;
 
-       xfsidbg_xlog_rtrans((xlog_recover_t *) addr);
+       xfsidbg_xchksum((uint *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xlog_rtrans_entire(
+
+static int     kdbm_xfs_xchash(
        int     argc,
        const char **argv,
        const char **envp,
@@ -965,11 +1067,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xlog_rtrans_entire((xlog_recover_t *) addr);
+       xfsidbg_xchash((xfs_mount_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xlog_tic(
+static int     kdbm_xfs_xchashlist(
        int     argc,
        const char **argv,
        const char **envp,
@@ -986,11 +1088,12 @@
        if (diag)
                return diag;
 
-       xfsidbg_xlog_tic((xlog_ticket_t *) addr);
+       xfsidbg_xchashlist((xfs_chashlist_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xlogitem(
+
+static int     kdbm_xfs_xdaargs(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1007,11 +1110,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xlogitem((xfs_log_item_t *) addr);
+       xfsidbg_xdaargs((xfs_da_args_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xmount(
+static int     kdbm_xfs_xdabuf(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1028,11 +1131,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xmount((xfs_mount_t *) addr);
+       xfsidbg_xdabuf((xfs_dabuf_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xnode(
+static int     kdbm_xfs_xdanode(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1049,11 +1152,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xnode((xfs_inode_t *) addr);
+       xfsidbg_xdanode((xfs_da_intnode_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xcore(
+static int     kdbm_xfs_xdastate(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1070,11 +1173,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xcore((xfs_iocore_t *) addr);
+       xfsidbg_xdastate((xfs_da_state_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xperag(
+static int     kdbm_xfs_xdirleaf(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1091,11 +1194,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xperag((xfs_mount_t *) addr);
+       xfsidbg_xdirleaf((xfs_dir_leafblock_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xqm_diskdq(
+static int     kdbm_xfs_xdirsf(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1112,11 +1215,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xqm_diskdq((xfs_disk_dquot_t *) addr);
+       xfsidbg_xdirsf((xfs_dir_shortform_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xqm_dqattached_inos(
+static int     kdbm_xfs_xdir2free(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1133,11 +1236,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xqm_dqattached_inos((xfs_mount_t *) addr);
+       xfsidbg_xdir2free((xfs_dir2_free_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xqm_dquot(
+static int     kdbm_xfs_xdir2sf(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1154,38 +1257,53 @@
        if (diag)
                return diag;
 
-       xfsidbg_xqm_dquot((xfs_dquot_t *) addr);
+       xfsidbg_xdir2sf((xfs_dir2_sf_t *) addr);
        return 0;
 }
 
-#ifdef CONFIG_XFS_QUOTA
-static int     kdbm_xfs_xqm(
+static int     kdbm_xfs_xexlist(
        int     argc,
        const char **argv,
        const char **envp,
        struct pt_regs *regs)
 {
-       if (argc != 0)
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
                return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
 
-       xfsidbg_xqm();
+       xfsidbg_xexlist((xfs_inode_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xqm_freelist(
+static int     kdbm_xfs_xflist(
        int     argc,
        const char **argv,
        const char **envp,
        struct pt_regs *regs)
 {
-       if (argc != 0)
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
                return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
 
-       xfsidbg_xqm_freelist();
+       xfsidbg_xflist((xfs_bmap_free_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xqm_htab(
+static int     kdbm_xfs_xhelp(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1194,12 +1312,11 @@
        if (argc != 0)
                return KDB_ARGCOUNT;
 
-       xfsidbg_xqm_htab();
+       xfsidbg_xhelp();
        return 0;
 }
-#endif
 
-static int     kdbm_xfs_xqm_mplist(
+static int     kdbm_xfs_xiclog(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1216,11 +1333,11 @@
        if (diag)
                return diag;
 
-       xfsidbg_xqm_mplist((xfs_mount_t *) addr);
+       xfsidbg_xiclog((xlog_in_core_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xqm_qinfo(
+static int     kdbm_xfs_xiclogall(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1237,11 +1354,473 @@
        if (diag)
                return diag;
 
-       xfsidbg_xqm_qinfo((xfs_mount_t *) addr);
+       xfsidbg_xiclogall((xlog_in_core_t *) addr);
        return 0;
 }
 
-static int     kdbm_xfs_xqm_tpdqinfo(
+static int     kdbm_xfs_xiclogcb(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xiclogcb((xlog_in_core_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xihash(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xihash((xfs_mount_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xinodes(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xinodes((xfs_mount_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_delayed_blocks(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_delayed_blocks((xfs_mount_t *) addr);
+       return 0;
+}
+
+
+static int     kdbm_xfs_xinodes_quiesce(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xinodes_quiesce((xfs_mount_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xlog(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xlog((xlog_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xlog_ritem(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xlog_ritem((xlog_recover_item_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xlog_rtrans(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xlog_rtrans((xlog_recover_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xlog_rtrans_entire(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xlog_rtrans_entire((xlog_recover_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xlog_tic(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xlog_tic((xlog_ticket_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xlogitem(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xlogitem((xfs_log_item_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xmount(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xmount((xfs_mount_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xnode(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xnode((xfs_inode_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xcore(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xcore((xfs_iocore_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xperag(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xperag((xfs_mount_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xqm_diskdq(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xqm_diskdq((xfs_disk_dquot_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xqm_dqattached_inos(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xqm_dqattached_inos((xfs_mount_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xqm_dquot(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xqm_dquot((xfs_dquot_t *) addr);
+       return 0;
+}
+
+#ifdef CONFIG_XFS_QUOTA
+static int     kdbm_xfs_xqm(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       if (argc != 0)
+               return KDB_ARGCOUNT;
+
+       xfsidbg_xqm();
+       return 0;
+}
+
+static int     kdbm_xfs_xqm_freelist(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       if (argc != 0)
+               return KDB_ARGCOUNT;
+
+       xfsidbg_xqm_freelist();
+       return 0;
+}
+
+static int     kdbm_xfs_xqm_htab(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       if (argc != 0)
+               return KDB_ARGCOUNT;
+
+       xfsidbg_xqm_htab();
+       return 0;
+}
+#endif
+
+static int     kdbm_xfs_xqm_mplist(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xqm_mplist((xfs_mount_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xqm_qinfo(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+       if (diag)
+               return diag;
+
+       xfsidbg_xqm_qinfo((xfs_mount_t *) addr);
+       return 0;
+}
+
+static int     kdbm_xfs_xqm_tpdqinfo(
        int     argc,
        const char **argv,
        const char **envp,
@@ -1404,45 +1983,52 @@
 }
 
 
-static void    printvnode(vnode_t *vp)
+static void printbhv(bhv_desc_t *bdp)
 {
-       bhv_desc_t      *bh;
        kdb_symtab_t     symtab;
 
+       if (bdp == NULL) {
+               kdb_printf("NULL bhv\n");
+               return;
+       }
+
+       kdb_printf("bhv at 0x%p\n", bdp);
+       while (bdp) {
+               if (kdbnearsym((unsigned long)bdp->bd_ops, &symtab))
+                       kdb_printf("  ops %s", symtab.sym_name);
+               else
+                       kdb_printf("  ops %s/0x%p", "???", (void *)bdp->bd_ops);
+
+               kdb_printf(" vobj 0x%p pdata 0x%p next 0x%p\n",
+                          bdp->bd_vobj, bdp->bd_pdata, bdp->bd_next);
+
+               bdp = bdp->bd_next;
+       }
+}
 
-       kdb_printf("vnode: 0x%p type ", vp);
+
+static void    printvnode(vnode_t *vp, unsigned long addr)
+{
+       kdb_printf("vnode: 0x%lx type ", addr);
        if ((size_t)vp->v_type >= sizeof(vnode_type)/sizeof(vnode_type[0]))
                kdb_printf("out of range 0x%x", vp->v_type);
        else
                kdb_printf("%s", vnode_type[vp->v_type]);
-       kdb_printf(" v_bh %p\n", &vp->v_bh);
+       kdb_printf(" v_bh 0x%p\n", &vp->v_bh);
 
-       if ((bh = vp->v_bh.bh_first)) {
-               kdb_printf("   v_inode 0x%p v_bh->bh_first 0x%p pobj 0x%p\n",
-                                       LINVFS_GET_IP(vp), bh, bh->bd_pdata);
-
-               if (kdbnearsym((unsigned long)bh->bd_ops, &symtab))
-                       kdb_printf("   ops %s ", symtab.sym_name);
-               else
-                       kdb_printf("   ops %s/0x%p ",
-                                               "???", (void *)bh->bd_ops);
-       } else {
-               kdb_printf("   v_inode 0x%p v_bh->bh_first = NULLBHV ",
-                                       LINVFS_GET_IP(vp));
-       }
+       printbhv(vp->v_fbhv);
 
        printflags((__psunsigned_t)vp->v_flag, tab_vflags, "flag =");
        kdb_printf("\n");
 
-#ifdef CONFIG_XFS_VNODE_TRACING
+#ifdef XFS_VNODE_TRACE
        kdb_printf("   v_trace 0x%p\n", vp->v_trace);
-#endif /* CONFIG_XFS_VNODE_TRACING */
+#endif /* XFS_VNODE_TRACE */
 
-       kdb_printf("   v_vfsp 0x%p v_number %Lx\n",
-               vp->v_vfsp, vp->v_number);
+       kdb_printf("   v_vfsp 0x%p v_number 0x%llx\n",
+               vp->v_vfsp, (unsigned long long)vp->v_number);
 }
 
-
 static int     kdbm_vnode(
        int     argc,
        const char **argv,
@@ -1453,9 +2039,7 @@
        int nextarg = 1;
        long offset = 0;
        int diag;
-       vnode_t         *vp;
-/*     bhv_desc_t      *bh; */
-/*     kdb_symtab_t     symtab;*/
+       vnode_t         vp;
 
        if (argc != 1)
                return KDB_ARGCOUNT;
@@ -1465,14 +2049,82 @@
        if (diag)
                return diag;
 
-       vp = (vnode_t *)addr;
+       if ((diag = kdb_getarea(vp, addr)))
+               return diag;
+
+       printvnode(&vp, addr);
+
+       return 0;
+}
+
+static void
+print_vfs(vfs_t        *vfs, unsigned long addr)
+{
+       kdb_printf("vfsp at 0x%lx", addr);
+       kdb_printf(" vfs_flag 0x%x\n", vfs->vfs_flag);
+       kdb_printf(" vfs_super 0x%p", vfs->vfs_super);
+       kdb_printf(" vfs_bh 0x%p\n", &vfs->vfs_bh);
+
+       printbhv(vfs->vfs_fbhv);
+}
+
+static int     kdbm_bhv(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+       bhv_desc_t      *bh;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+
+       if (diag)
+               return diag;
+
+       bh = (bhv_desc_t *)addr;
+
+       printbhv(bh);
+
+       return 0;
+}
+
+static int     kdbm_vfs(
+       int     argc,
+       const char **argv,
+       const char **envp,
+       struct pt_regs *regs)
+{
+       unsigned long addr;
+       int nextarg = 1;
+       long offset = 0;
+       int diag;
+       vfs_t           vfs;
+
+       if (argc != 1)
+               return KDB_ARGCOUNT;
+
+       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+
+       if (diag)
+               return diag;
+
+       if ((diag = kdb_getarea(vfs, addr)))
+               return diag;
 
-       printvnode(vp);
+       print_vfs(&vfs, addr);
 
        return 0;
 }
 
-#ifdef CONFIG_XFS_VNODE_TRACING
+
+#ifdef XFS_VNODE_TRACE
 /*
  * Print a vnode trace entry.
  */
@@ -1668,7 +2320,7 @@
 
        return 0;
 }
-#endif /* CONFIG_XFS_VNODE_TRACING */
+#endif /* XFS_VNODE_TRACE */
 
 
 static void    printinode(struct inode *ip)
@@ -1682,16 +2334,21 @@
        kdb_printf(" i_ino = %lu i_count = %u i_size %Ld\n",
                                        ip->i_ino, atomic_read(&ip->i_count),
                                        ip->i_size);
-
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
        kdb_printf(
-               " i_mode = 0x%x  i_nlink = %d  i_rdev = %u:%u i_state = 0x%lx\n",
+               " i_mode = 0x%x  i_nlink = %d  i_rdev = 0x%x i_state = 0x%lx\n",
                                        ip->i_mode, ip->i_nlink,
-                                       MAJOR(ip->i_rdev),
-                                       MINOR(ip->i_rdev),
-                                       ip->i_state);
-
-       kdb_printf(" i_hash.nxt = 0x%p i_hash.prv = 0x%p\n",
-                                       ip->i_hash.next, ip->i_hash.prev);
+                                       kdev_t_to_nr(ip->i_rdev), ip->i_state);
+       kdb_printf(" i_hash.nxt = 0x%p i_hash.pprv = 0x%p\n",
+                                        ip->i_hash.next, ip->i_hash.prev);
+#else
+       kdb_printf(
+               " i_mode = 0x%x  i_nlink = %d  i_rdev = 0x%x i_state = 0x%lx\n",
+                                       ip->i_mode, ip->i_nlink,
+                                       ip->i_rdev, ip->i_state);
+       kdb_printf(" i_hash.nxt = 0x%p i_hash.pprv = 0x%p\n",
+                                        ip->i_hash.next, ip->i_hash.pprev);
+#endif
        kdb_printf(" i_list.nxt = 0x%p i_list.prv = 0x%p\n",
                                        ip->i_list.next, ip->i_list.prev);
        kdb_printf(" i_dentry.nxt = 0x%p i_dentry.prv = 0x%p\n",
@@ -1717,52 +2374,44 @@
 {
        int             diag;
        int             nextarg = 1;
-/*     char            *symname; */
        long            offset = 0;
        unsigned long   addr;
        struct inode    *ip;
-/*     bhv_desc_t      *bh; */
-#ifdef CONFIG_XFS_VNODE_TRACING
+       vnode_t         vp;
+#ifdef XFS_VNODE_TRACE
        ktrace_entry_t  *ktep;
        ktrace_snap_t   kts;
 #endif
-       vnode_t         *vp;
 
        if (argc != 1)
                return KDB_ARGCOUNT;
 
        diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
-
        if (diag)
                return diag;
 
-       vp = (vnode_t *)addr;
-
-       ip = LINVFS_GET_IP(vp);
+       if ((diag = kdb_getarea(vp, addr)))
+               return diag;
 
+       ip = LINVFS_GET_IP((vnode_t *)addr);
        kdb_printf("--> Inode @ 0x%p\n", ip);
        printinode(ip);
 
-       kdb_printf("--> Vnode @ 0x%p\n", vp);
-       printvnode(vp);
-
-#ifdef CONFIG_XFS_VNODE_TRACING
+       kdb_printf("--> Vnode @ 0x%lx\n", addr);
+       printvnode(&vp, addr);
 
-       kdb_printf("--> Vntrace @ 0x%p/0x%p\n", vp, vp->v_trace);
-
-       if (vp->v_trace == NULL)
+#ifdef XFS_VNODE_TRACE
+       kdb_printf("--> Vntrace @ 0x%lx/0x%p\n", addr, vp.v_trace);
+       if (vp.v_trace == NULL)
                return 0;
-
-       ktep = ktrace_first(vp->v_trace, &kts);
-
+       ktep = ktrace_first(vp.v_trace, &kts);
        while (ktep != NULL) {
                if (vn_trace_pr_entry(ktep))
                        kdb_printf("\n");
 
-               ktep = ktrace_next(vp->v_trace, &kts);
+               ktep = ktrace_next(vp.v_trace, &kts);
        }
-#endif /* CONFIG_XFS_VNODE_TRACING */
-
+#endif /* XFS_VNODE_TRACE */
        return 0;
 }
 
@@ -1772,15 +2421,15 @@
 static char    *pb_flag_vals[] = {
 /*  0 */ "READ", "WRITE", "MAPPED", "PARTIAL", "ASYNC",
 /*  5 */ "NONE", "DELWRI", "FREED", "SYNC", "MAPPABLE",
-/* 10 */ "STALE", "FS_MANAGED", "INVALID12", "LOCK", "TRYLOCK",
+/* 10 */ "STALE", "FS_MANAGED", "FS_DATAIOD", "LOCK", "TRYLOCK",
 /* 15 */ "DONT_BLOCK", "LOCKABLE", "PRIVATE_BH", "ALL_PAGES_MAPPED", 
         "ADDR_ALLOCATED",
 /* 20 */ "MEM_ALLOCATED", "FORCEIO", "FLUSH", "READ_AHEAD",
         NULL };
 
-static char    *pbm_flag_vals[] = {
+static char    *iomap_flag_vals[] = {
        "EOF", "HOLE", "DELAY", "INVALID0x08",
-       "INVALID0x10", "UNWRITTEN", "INVALID0x40", "INVALID0x80",
+       "INVALID0x10", "UNWRITTEN", "NEW", "INVALID0x80",
        NULL };
 
 
@@ -1795,7 +2444,7 @@
        for (index = 0; flags && mapping[index]; flags >>= 1, index++) {
                if (flags & 1) {
                        if ((offset + strlen(mapping[index]) + 1) >= 80) {
-                               strcat(buffer, "\n            ");
+                               strcat(buffer, "\n          ");
                                offset = 12;
                        } else if (offset > 12) {
                                strcat(buffer, " ");
@@ -1832,6 +2481,48 @@
        return 0;
 }
 
+static void
+print_pagebuf(
+       page_buf_t      *pb,
+       unsigned long addr)
+{
+       kdb_printf("page_buf_t at 0x%lx\n", addr);
+       kdb_printf("  pb_flags %s\n", pb_flags(pb->pb_flags));
+       kdb_printf("  pb_target 0x%p pb_hold %d pb_next 0x%p pb_prev 0x%p\n",
+                  pb->pb_target, pb->pb_hold.counter,
+                  list_entry(pb->pb_list.next, page_buf_t, pb_list),
+                  list_entry(pb->pb_list.prev, page_buf_t, pb_list));
+       kdb_printf("  pb_hash_index %d pb_hash_next 0x%p pb_hash_prev 0x%p\n",
+                  pb->pb_hash_index,
+                  list_entry(pb->pb_hash_list.next, page_buf_t, pb_hash_list),
+                  list_entry(pb->pb_hash_list.prev, page_buf_t, pb_hash_list));
+       kdb_printf("  pb_file_offset 0x%llx pb_buffer_length 0x%llx pb_addr 0x%p\n",
+                  (unsigned long long) pb->pb_file_offset,
+                  (unsigned long long) pb->pb_buffer_length,
+                  pb->pb_addr);
+       kdb_printf("  pb_bn 0x%Lx pb_count_desired 0x%lx pb_locked %d\n",
+                  pb->pb_bn,
+                  (unsigned long) pb->pb_count_desired, (int)pb->pb_locked);
+       kdb_printf("  pb_flushtime %ld (%ld) pb_io_remaining %d pb_error %u\n",
+                  pb->pb_flushtime, pb->pb_flushtime - jiffies,
+                  pb->pb_io_remaining.counter, pb->pb_error);
+       kdb_printf("  pb_page_count %u pb_offset 0x%x pb_pages 0x%p\n",
+               pb->pb_page_count, pb->pb_offset,
+               pb->pb_pages);
+       kdb_printf("  pb_iodonesema (%d,%d) pb_sema (%d,%d) pincount (%d)\n",
+                  pb->pb_iodonesema.count.counter,
+                  pb->pb_iodonesema.sleepers,
+                  pb->pb_sema.count.counter, pb->pb_sema.sleepers,
+                  pb->pb_pin_count.counter);
+#ifdef PAGEBUF_LOCK_TRACKING
+       kdb_printf("  last holder %d\n", pb->pb_last_holder);
+#endif
+       if (pb->pb_fspriv || pb->pb_fspriv2) {
+               kdb_printf(  "  pb_fspriv 0x%p pb_fspriv2 0x%p\n",
+                          pb->pb_fspriv, pb->pb_fspriv2);
+       }
+}
+
 static int
 kdbm_pb(int argc, const char **argv, const char **envp, struct pt_regs *regs)
 {
@@ -1849,109 +2540,64 @@
            (diag = kdb_getarea(bp, addr)))
                return diag;
 
-       kdb_printf("page_buf_t at 0x%lx\n", addr);
-       kdb_printf("  pb_flags %s\n", pb_flags(bp.pb_flags));
-       kdb_printf("  pb_target 0x%p pb_hold %d pb_next 0x%p pb_prev 0x%p\n",
-                  bp.pb_target, bp.pb_hold.counter,
-                  bp.pb_list.next, bp.pb_list.prev);
-       kdb_printf("  pb_hash_index %d pb_hash_next 0x%p pb_hash_prev 0x%p\n",
-                  bp.pb_hash_index,
-                  bp.pb_hash_list.next,
-                  bp.pb_hash_list.prev);
-       kdb_printf("  pb_file_offset 0x%llx pb_buffer_length 0x%llx pb_addr 0x%p\n",
-                  (unsigned long long) bp.pb_file_offset,
-                  (unsigned long long) bp.pb_buffer_length,
-                  bp.pb_addr);
-       kdb_printf("  pb_bn 0x%Lx pb_count_desired 0x%lx\n",
-                  bp.pb_bn,
-                  (unsigned long) bp.pb_count_desired);
-       kdb_printf("  pb_io_remaining %d pb_error %u\n",
-                  bp.pb_io_remaining.counter,
-                  bp.pb_error);
-       kdb_printf("  pb_page_count %u pb_offset 0x%x pb_pages 0x%p\n",
-               bp.pb_page_count, bp.pb_offset,
-               bp.pb_pages);
-#ifdef PAGEBUF_LOCK_TRACKING
-       kdb_printf("  pb_iodonesema (%d,%d) pb_sema (%d,%d) pincount (%d) last holder %d\n",
-                  bp.pb_iodonesema.count.counter,
-                  bp.pb_iodonesema.sleepers,
-                  bp.pb_sema.count.counter, bp.pb_sema.sleepers,
-                  bp.pb_pin_count.counter, bp.pb_last_holder);
-#else
-       kdb_printf("  pb_iodonesema (%d,%d) pb_sema (%d,%d) pincount (%d)\n",
-                  bp.pb_iodonesema.count.counter,
-                  bp.pb_iodonesema.sleepers,
-                  bp.pb_sema.count.counter, bp.pb_sema.sleepers,
-                  bp.pb_pin_count.counter);
-#endif
-       if (bp.pb_fspriv || bp.pb_fspriv2) {
-               kdb_printf(  "pb_fspriv 0x%p pb_fspriv2 0x%p\n",
-                          bp.pb_fspriv, bp.pb_fspriv2);
-       }
+       print_pagebuf(&bp, addr);
 
        return 0;
 }
 
-/* XXXXXXXXXXXXXXXXXXXXXX */
-/* The start of this deliberately looks like a read_descriptor_t in layout */
-typedef struct {
-       read_descriptor_t io_rdesc;
-
-       /* 0x10 */
-       page_buf_rw_t io_dir;   /* read or write */
-       loff_t io_offset;       /* Starting offset of I/O */
-       int io_iovec_nr;        /* Number of entries in iovec */
-
-       /* 0x20 */
-       struct iovec **io_iovec;        /* iovec list indexed by iovec_index */
-       loff_t io_iovec_offset; /* offset into current iovec. */
-       int io_iovec_index;     /* current iovec being processed */
-       unsigned int io_sshift; /* sector bit shift */
-       loff_t io_i_size;       /* size of the file */
-} pb_io_desc_t;
-
 static int
-kdbm_pbiodesc(int argc, const char **argv, const char **envp,
+kdbm_pbdelay(int argc, const char **argv, const char **envp,
        struct pt_regs *regs)
 {
-       pb_io_desc_t    pbio;
+#ifdef DEBUG
+       unsigned long   verbose = 0;
+       int     count = 0;
+       struct list_head        *curr, *next;
+       page_buf_t      bp;
        unsigned long addr;
-       long    offset=0;
-       int nextarg;
        int diag;
+       extern struct list_head pbd_delwrite_queue;
 
-       if (argc != 1)
+       if (argc > 1)
                return KDB_ARGCOUNT;
 
-       nextarg = 1;
-       if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)) ||
-           (diag = kdb_getarea(pbio, addr)))
-
-       kdb_printf("pb_io_desc_t at 0x%lx\n", addr);
-       kdb_printf("  io_rdesc [ written 0x%lx count 0x%lx buf 0x%p error %d ]\n",
-                       (unsigned long) pbio.io_rdesc.written,
-                       (unsigned long) pbio.io_rdesc.count,
-                       pbio.io_rdesc.buf, pbio.io_rdesc.error);
-
-       kdb_printf("  io_dir %d io_offset 0x%Lx io_iovec_nr 0x%d\n",
-                       pbio.io_dir, pbio.io_offset, pbio.io_iovec_nr);
+       if (argc == 1) {
+               if ((diag = kdbgetularg(argv[1], &verbose))) {
+                       return diag;
+               }
+       }
 
-       kdb_printf("  io_iovec 0x%p io_iovec_offset 0x%Lx io_iovec_index 0x%d\n",
-               pbio.io_iovec, pbio.io_iovec_offset, pbio.io_iovec_index);
+       if (!verbose) {
+               kdb_printf("index pb       pin   flushtime\n");
+       }
 
-       kdb_printf("  io_sshift 0x%d io_i_size 0x%Lx\n",
-               pbio.io_sshift, pbio.io_i_size);
+       list_for_each_safe(curr, next, &pbd_delwrite_queue) {
+               addr = (unsigned long)list_entry(curr, page_buf_t, pb_list);
+               if ((diag = kdb_getarea(bp, addr)))
+                       return diag;
 
+               if (verbose) {
+                       print_pagebuf(&bp, addr);
+               } else {
+                       kdb_printf("%4d  0x%lx   %d   %ld\n",
+                               count++, addr, 
+                               bp.pb_pin_count.counter,
+                               bp.pb_flushtime - jiffies);
+               }
+       }
+#else
+       kdb_printf("pbd_delwrite_queue inaccessible (non-debug)\n");
+#endif
        return 0;
 }
 
 static int
-kdbm_pbmap(int argc, const char **argv, const char **envp,
+kdbm_iomap(int argc, const char **argv, const char **envp,
        struct pt_regs *regs)
 {
-       page_buf_bmap_t pbm;
+       xfs_iomap_t iomap;
        unsigned long addr;
-       long    offset=0;
+       long offset=0;
        int nextarg;
        int diag;
 
@@ -1960,113 +2606,49 @@
 
        nextarg = 1;
        if ((diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs)) ||
-           (diag = kdb_getarea(pbm, addr)))
+           (diag = kdb_getarea(iomap, addr)))
 
-       kdb_printf("page_buf_bmap_t at 0x%lx\n", addr);
-       kdb_printf("  pbm_bn 0x%llx pbm_offset 0x%Lx pbm_delta 0x%lx pbm_bsize 0x%lx\n",
-               (long long) pbm.pbm_bn, pbm.pbm_offset,
-               (unsigned long) pbm.pbm_delta, (unsigned long) pbm.pbm_bsize);
+       kdb_printf("iomap_t at 0x%lx\n", addr);
+       kdb_printf("  iomap_bn 0x%llx iomap_offset 0x%Lx iomap_delta 0x%lx iomap_bsize 0x%lx\n",
+               (long long) iomap.iomap_bn, iomap.iomap_offset,
+               (unsigned long) iomap.iomap_delta, (unsigned long) iomap.iomap_bsize);
 
-       kdb_printf("  pbm_flags %s\n", map_flags(pbm.pbm_flags, pbm_flag_vals));
+       kdb_printf("  iomap_flags %s\n", map_flags(iomap.iomap_flags, iomap_flag_vals));
 
        return 0;
 }
 
 #ifdef PAGEBUF_TRACE
-# ifdef __PAGEBUF_TRACE__
-# undef __PAGEBUF_TRACE__
-# undef PB_DEFINE_TRACES
-# undef PB_TRACE_START
-# undef PB_TRACE_REC
-# undef PB_TRACE_END
-# endif
-#include "pagebuf/page_buf_trace.h"
-
-#define EV_SIZE        (sizeof(event_names)/sizeof(char *))
-
-void
-pb_trace_core(
-       unsigned long match,
-       char    *event_match,
-       unsigned long long offset,
-       long long mask)
-{
-       extern struct pagebuf_trace_buf pb_trace;
-       int i, total, end;
-       pagebuf_trace_t *trace;
-       char    *event;
-       char    value[10];
-
-       end = pb_trace.start - 1;
-       if (end < 0)
-               end = PB_TRACE_BUFSIZE - 1;
-
-       if (match && (match < PB_TRACE_BUFSIZE)) {
-               for (i = pb_trace.start, total = 0; i != end; i = CIRC_INC(i)) {
-                       trace = &pb_trace.buf[i];
-                       if (trace->pb == 0)
-                               continue;
-                       total++;
-               }
-               total = total - match;
-               for (i = pb_trace.start; i != end && total; i = CIRC_INC(i)) {
-                       trace = &pb_trace.buf[i];
-                       if (trace->pb == 0)
-                               continue;
-                       total--;
-               }
-               match = 0;
-       } else
-               i = pb_trace.start;
-       for ( ; i != end; i = CIRC_INC(i)) {
-               trace = &pb_trace.buf[i];
-
-               if (offset) {
-                       if ((trace->offset & ~mask) != offset)
-                               continue;
-               }
-
-               if (trace->pb == 0)
-                       continue;
-
-               if ((match != 0) && (trace->pb != match))
-                       continue;
-
-               if ((trace->event < EV_SIZE-1) && event_names[trace->event]) {
-                       event = event_names[trace->event];
-               } else if (trace->event == EV_SIZE-1) {
-                       event = (char *)trace->misc;
-               } else {
-                       event = value;
-                       sprintf(value, "%8d", trace->event);
-               }
-
-               if (event_match && strcmp(event, event_match)) {
-                       continue;
-               }
+static int pagebuf_trace_entry(ktrace_entry_t *ktep)
+{
+       unsigned long long daddr;
 
+       daddr = ((unsigned long long)(unsigned long)ktep->val[8] << 32)
+               | ((unsigned long long)(unsigned long)ktep->val[9]);
 
-               kdb_printf("pb 0x%lx [%s] (hold %u lock %d) misc 0x%p",
-                          trace->pb, event,
-                          trace->hold, trace->lock_value,
-                          trace->misc);
-               kdb_symbol_print((unsigned int)trace->ra, NULL,
-                       KDB_SP_SPACEB|KDB_SP_PAREN|KDB_SP_NEWLINE);
-               kdb_printf("    offset 0x%Lx size 0x%x task 0x%p\n",
-                          trace->offset, trace->size, trace->task);
-               kdb_printf("    flags: %s\n",
-                          pb_flags(trace->flags));
-       }
+       kdb_printf("pb 0x%p [%s] (hold %lu lock %ld) data 0x%p",
+               ktep->val[0],
+               (char *)ktep->val[1],
+               (unsigned long)ktep->val[3],
+               (long)ktep->val[4],
+               ktep->val[6]);
+       kdb_symbol_print((unsigned long)ktep->val[7], NULL,
+               KDB_SP_SPACEB|KDB_SP_PAREN|KDB_SP_NEWLINE);
+       kdb_printf("    offset 0x%llx size 0x%lx task 0x%p\n",
+               daddr, (long)ktep->val[10], ktep->val[5]);
+       kdb_printf("    flags: %s\n", pb_flags((int)(long)ktep->val[2]));
+       return 1;
 }
 
-
 static int
 kdbm_pbtrace_offset(int argc, const char **argv, const char **envp,
        struct pt_regs *regs)
 {
-       long mask = 0;
-       unsigned long offset = 0;
-       int diag;
+       long            mask = 0;
+       unsigned long   offset = 0;
+       int             diag;
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
 
        if (argc > 2)
                return KDB_ARGCOUNT;
@@ -2078,13 +2660,23 @@
        }
 
        if (argc > 1) {
-               diag = kdbgetularg(argv[1], &mask);
+               diag = kdbgetularg(argv[1], &mask);     /* sign extent mask */
                if (diag)
                        return diag;
        }
 
-       pb_trace_core(0, NULL, (unsigned long long)offset,
-                              (long long)mask);        /* sign extent mask */
+       ktep = ktrace_first(pagebuf_trace_buf, &kts);
+       while (ktep != NULL) {
+               unsigned long long daddr;
+
+               daddr = ((unsigned long long)(unsigned long)ktep->val[8] << 32)
+                       | ((unsigned long long)(unsigned long)ktep->val[9]);
+               if (offset && ((daddr & ~mask) != offset))
+                       continue;
+               if (pagebuf_trace_entry(ktep))
+                       kdb_printf("\n");
+               ktep = ktrace_next(pagebuf_trace_buf, &kts);
+       }
        return 0;
 }
 
@@ -2092,10 +2684,12 @@
 kdbm_pbtrace(int argc, const char **argv, const char **envp,
        struct pt_regs *regs)
 {
-       unsigned long addr = 0;
-       int diag, nextarg;
-       long offset = 0;
-       char    *event_match = NULL;
+       unsigned long   addr = 0;
+       int             diag, nextarg;
+       long            offset = 0;
+       char            *event_match = NULL;
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
 
        if (argc > 1)
                return KDB_ARGCOUNT;
@@ -2103,69 +2697,102 @@
        if (argc == 1) {
                if (isupper(argv[1][0]) || islower(argv[1][0])) {
                        event_match = (char *)argv[1];
-                       printk("event match on \"%s\"\n", event_match);
+                       kdb_printf("event match on \"%s\"\n", event_match);
                        argc = 0;
                } else {
                        nextarg = 1;
-                       diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs);
+                       diag = kdbgetaddrarg(argc, argv,
+                                       &nextarg, &addr, &offset, NULL, regs);
                        if (diag) {
-                               printk("failed to parse %s as a number\n",
-                                                               argv[1]);
+                               kdb_printf("non-numeric arg: %s\n", argv[1]);
                                return diag;
                        }
                }
        }
 
-       pb_trace_core(addr, event_match, 0LL, 0LL);
-       return 0;
-}
-
-#else  /* PAGEBUF_TRACE */
-static int
-kdbm_pbtrace(int argc, const char **argv, const char **envp,
-       struct pt_regs *regs)
-{
-       kdb_printf("pagebuf tracing not compiled in\n");
-
+       ktep = ktrace_first(pagebuf_trace_buf, &kts);
+       while (ktep != NULL) {
+               if (addr && (ktep->val[0] != (void *)addr))
+                       continue;
+               if (event_match && strcmp((char *)ktep->val[1], event_match))
+                       continue;
+               if (pagebuf_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(pagebuf_trace_buf, &kts);
+       }
        return 0;
 }
-#endif /* PAGEBUF_TRACE */
+#endif
 
-static struct xif {
+struct xif {
        char    *name;
        int     (*func)(int, const char **, const char **, struct pt_regs *);
        char    *args;
        char    *help;
-} xfsidbg_funcs[] = {
+};
+
+static struct xif xfsidbg_funcs[] = {
+  {  "bhv",    kdbm_bhv,       "<bhv>", "Dump bhv chain"},
   {  "vn",     kdbm_vn,        "<vnode>", "Dump inode/vnode/trace"},
   {  "vnode",  kdbm_vnode,     "<vnode>", "Dump vnode"},
-#ifdef CONFIG_XFS_VNODE_TRACING
+  {  "vfs",    kdbm_vfs,       "<vfs>", "Dump vfs"},
+#ifdef XFS_VNODE_TRACE
   {  "vntrace",        kdbm_vntrace,   "<vntrace>", "Dump vnode Trace"},
-  {  "vntraceaddr",    kdbm_vntraceaddr, "<vntrace>", "Dump vnode Trace by Address"},
-#endif /* CONFIG_XFS_VNODE_TRACING */
+  {  "vntraceaddr",    kdbm_vntraceaddr, "<vntrace>",
+                               "Dump vnode Trace by Address"},
+#endif
   {  "xagf",   kdbm_xfs_xagf,  "<agf>",
                                "Dump XFS allocation group freespace" },
   {  "xagi",   kdbm_xfs_xagi,  "<agi>",
                                "Dump XFS allocation group inode" },
   {  "xail",   kdbm_xfs_xaildump,      "<xfs_mount_t>",
                                "Dump XFS AIL for a mountpoint" },
+#ifdef XFS_ALLOC_TRACE
+  {  "xalatrc",        kdbm_xfs_xalatrace,     "<count>",
+                               "Dump XFS alloc count trace" },
+  {  "xalbtrc",        kdbm_xfs_xalbtrace,     "<xfs_agblock_t>",
+                               "Dump XFS alloc block trace" },
+  {  "xalgtrc",        kdbm_xfs_xalgtrace,     "<xfs_agnumber_t>",
+                               "Dump XFS alloc alloc-group trace" },
+#endif
+
   {  "xalloc", kdbm_xfs_xalloc,        "<xfs_alloc_arg_t>",
                                "Dump XFS allocation args structure" },
-#ifdef DEBUG
+#ifdef XFS_ALLOC_TRACE
   {  "xalmtrc",        kdbm_xfs_xalmtrace,     "<xfs_mount_t>",
                                "Dump XFS alloc mount-point trace" },
+  {  "xalttrc",        kdbm_xfs_xalttrace,     "<tag>",
+                               "Dump XFS alloc trace by tag number" },
 #endif
+  {  "xarg",   kdbm_xfs_xarg,          "<value>",
+                               "Input XFS argument for next function" },
   {  "xattrcx",        kdbm_xfs_xattrcontext,  "<xfs_attr_list_context_t>",
                                "Dump XFS attr_list context struct"},
   {  "xattrlf",        kdbm_xfs_xattrleaf,     "<xfs_attr_leafblock_t>",
                                "Dump XFS attribute leaf block"},
   {  "xattrsf",        kdbm_xfs_xattrsf,       "<xfs_attr_shortform_t>",
                                "Dump XFS attribute shortform"},
+#ifdef XFS_ATTR_TRACE
+  {  "xattrtr",        kdbm_xfs_xattrtrace,    "<count>",
+                               "Dump XFS attribute attr_list() trace" },
+#endif
   {  "xbirec", kdbm_xfs_xbirec,        "<xfs_bmbt_irec_t",
                                "Dump XFS bmap incore record"},
+#ifdef XFS_BLI_TRACE
+  {  "xblitrc",        kdbm_xfs_xblitrace,     "<xfs_buf_log_item_t>",
+                               "Dump XFS buf log item trace" },
+#endif
   {  "xbmalla",        kdbm_xfs_xbmalla,       "<xfs_bmalloca_t>",
                                "Dump XFS bmalloc args structure"},
-  {  "xbrec",  kdbm_xfs_xbrec,         "<xfs_bmbt_rec_64_t",
+#ifdef XFS_BMAP_TRACE
+  {  "xbmatrc",        kdbm_xfs_xbmatrace,     "<count>",
+                               "Dump XFS bmap btree count trace" },
+  {  "xbmitrc",        kdbm_xfs_xbmitrace,     "<xfs_inode_t>",
+                               "Dump XFS bmap btree per-inode trace" },
+  {  "xbmstrc",        kdbm_xfs_xbmstrace,     "<xfs_inode_t>",
+                               "Dump XFS bmap btree inode trace" },
+#endif
+  {  "xbrec",  kdbm_xfs_xbrec,         "<xfs_bmbt_rec_64_t>",
                                "Dump XFS bmap record"},
   {  "xbroot", kdbm_xfs_xbroot,        "<xfs_inode_t>",
                                "Dump XFS bmap btree root (data)"},
@@ -2175,12 +2802,29 @@
                                "Dump XFS btree cursor"},
   {  "xbuf",   kdbm_xfs_xbuf,          "<xfs_buf_t>",
                                "Dump XFS data from a buffer"},
+#ifdef XFS_BMAP_TRACE
+  {  "xbxatrc",        kdbm_xfs_xbxatrace,     "<count>",
+                               "Dump XFS bmap extent count trace" },
+  {  "xbxitrc",        kdbm_xfs_xbxitrace,     "<xfs_inode_t>",
+                               "Dump XFS bmap extent per-inode trace" },
+  {  "xbxstrc",        kdbm_xfs_xbxstrace,     "<xfs_inode_t>",
+                               "Dump XFS bmap extent inode trace" },
+#endif
   {  "xchash", kdbm_xfs_xchash,        "<xfs_mount_t>",
                                "Dump XFS cluster hash"},
   {  "xchlist",        kdbm_xfs_xchashlist,    "<xfs_chashlist_t>",
                                "Dump XFS cluster hash list"},
+  {  "xchksum",        kdbm_xfs_xchksum,       "<addr>", "Dump chksum" },
+#ifdef XFS_DIR2_TRACE
+  {  "xd2atrc",        kdbm_xfs_xdir2atrace,   "<count>",
+                               "Dump XFS directory v2 count trace" },
+#endif
   {  "xd2free",        kdbm_xfs_xdir2free,     "<xfs_dir2_free_t>",
                                "Dump XFS directory v2 freemap"},
+#ifdef XFS_DIR2_TRACE
+  {  "xd2itrc",        kdbm_xfs_xdir2itrace,   "<xfs_inode_t>",
+                               "Dump XFS directory v2 per-inode trace" },
+#endif
   {  "xdaargs",        kdbm_xfs_xdaargs,       "<xfs_da_args_t>",
                                "Dump XFS dir/attr args structure"},
   {  "xdabuf", kdbm_xfs_xdabuf,        "<xfs_dabuf_t>",
@@ -2197,12 +2841,20 @@
                                "Dump XFS directory shortform"},
   {  "xdir2sf",        kdbm_xfs_xdir2sf,       "<xfs_dir2_sf_t>",
                                "Dump XFS directory v2 shortform"},
+#ifdef XFS_DIR_TRACE
+  {  "xdirtrc",        kdbm_xfs_xdirtrace,     "<count>",
+                               "Dump XFS directory getdents() trace" },
+#endif
   {  "xdiskdq",        kdbm_xfs_xqm_diskdq,    "<xfs_disk_dquot_t>",
                                "Dump XFS ondisk dquot (quota) struct"},
   {  "xdqatt", kdbm_xfs_xqm_dqattached_inos,   "<xfs_mount_t>",
                                 "All incore inodes with dquots"},
   {  "xdqinfo",        kdbm_xfs_xqm_tpdqinfo,  "<xfs_trans_t>",
                                "Dump dqinfo structure of a trans"},
+#ifdef XFS_DQUOT_TRACE
+  {  "xdqtrace",kdbm_xfs_xqm_dqtrace,  "<xfs_dquot_t>",
+                               "Dump trace of a given dquot" },
+#endif
   {  "xdquot", kdbm_xfs_xqm_dquot,     "<xfs_dquot_t>",
                                "Dump XFS dquot (quota) structure"},
   {  "xexlist",        kdbm_xfs_xexlist,       "<xfs_inode_t>",
@@ -2215,12 +2867,26 @@
                                "Dump All XFS in-core logs"},
   {  "xiclog", kdbm_xfs_xiclog,        "<xlog_in_core_t>",
                                "Dump XFS in-core log"},
+#ifdef XFS_LOG_TRACE
+  {  "xictrc", kdbm_xfs_xiclogtrace,   "<xlog_in_core_t>",
+                               "Dump XFS in-core log trace" },
+#endif
   {  "xihash", kdbm_xfs_xihash,        "<xfs_mount_t>",
                                "Dump XFS inode hash statistics"},
+#ifdef XFS_ILOCK_TRACE
+  {  "xilocktrc",kdbm_xfs_xilock_trace,        "<xfs_inode_t>",
+                               "Dump XFS ilock trace" },
+  {  "xailcktrc",kdbm_xfs_xailock_trace,"<count>",
+                               "Dump XFS global ilock trace" },
+#endif
   {  "xinodes",        kdbm_xfs_xinodes,       "<xfs_mount_t>",
                                "Dump XFS inodes per mount"},
   {  "xquiesce",kdbm_xfs_xinodes_quiesce, "<xfs_mount_t>",
                                "Dump non-quiesced XFS inodes per mount"},
+#ifdef XFS_LOG_TRACE
+  {  "xl_grtr",        kdbm_xfs_xlog_granttrace,       "<xlog_t>",
+                               "Dump XFS log grant trace" },
+#endif
   {  "xl_rcit",        kdbm_xfs_xlog_ritem,    "<xlog_recover_item_t>",
                                "Dump XFS recovery item"},
   {  "xl_rctr",        kdbm_xfs_xlog_rtrans,   "<xlog_recover_t>",
@@ -2255,6 +2921,10 @@
 #endif /* CONFIG_XFS_QUOTA */
   {  "xqmplist",kdbm_xfs_xqm_mplist,   "<xfs_mount_t>",
                                "Dump XFS all dquots of a f/s"},
+#ifdef XFS_RW_TRACE
+  {  "xrwtrc", kdbm_xfs_xrwtrace,      "<xfs_inode_t>",
+                               "Dump XFS inode read/write trace" },
+#endif
   {  "xsb",    kdbm_xfs_xsb,           "<xfs_sb_t> <cnv>",
                                "Dump XFS superblock"},
   {  "xtp",    kdbm_xfs_xtp,           "<xfs_trans_t>",
@@ -2264,6 +2934,18 @@
   {  0,                0,      0 }
 };
 
+static struct xif pb_funcs[] = {
+  {  "pb",     kdbm_pb,        "<vaddr>",      "Display page_buf_t" },
+  {  "pbflags",        kdbm_pb_flags,  "<flags>",      "Display page_buf flags" },
+  {  "iomapap",        kdbm_iomap,     "<iomap_t *>",  "Display IOmap" },
+  {  "pbdelay",        kdbm_pbdelay,   "0|1",          "Display delwri pagebufs" },
+#ifdef PAGEBUF_TRACE
+  {  "pbtrace",        kdbm_pbtrace,   "<vaddr>|<count>",      "page_buf_t trace" },
+  {  "pboffset",kdbm_pbtrace_offset, "<daddr> [<mask>]","page_buf_t trace" },
+#endif
+  {  0,                0,      0 }
+};
+
 static int
 __init xfsidbg_init(void)
 {
@@ -2271,20 +2953,8 @@
 
        for (p = xfsidbg_funcs; p->name; p++)
                kdb_register(p->name, p->func, p->args, p->help, 0);
-
-       kdb_register("pb", kdbm_pb, "<vaddr>", "Display page_buf_t", 0);
-       kdb_register("pbflags", kdbm_pb_flags, "<flags>",
-                                       "Display page buf flags", 0);
-       kdb_register("pbiodesc", kdbm_pbiodesc, "<pb_io_desc_t *>",
-                                       "Display I/O Descriptor", 0);
-       kdb_register("pbmap", kdbm_pbmap, "<page_buf_bmap_t *>",
-                                       "Display Bmap", 0);
-       kdb_register("pbtrace", kdbm_pbtrace, "<vaddr>|<count>",
-                                       "page_buf_t trace", 0);
-#ifdef PAGEBUF_TRACE
-       kdb_register("pboffset", kdbm_pbtrace_offset, "<addr> [<mask>]",
-                                       "page_buf_t trace", 0);
-#endif
+       for (p = pb_funcs; p->name; p++)
+               kdb_register(p->name, p->func, p->args, p->help, 0);
        return 0;
 }
 
@@ -2295,16 +2965,8 @@
 
        for (p = xfsidbg_funcs; p->name; p++)
                kdb_unregister(p->name);
-
-       kdb_unregister("pb");
-       kdb_unregister("pbflags");
-       kdb_unregister("pbmap");
-       kdb_unregister("pbiodesc");
-       kdb_unregister("pbtrace");
-#ifdef PAGEBUF_TRACE
-       kdb_unregister("pboffset");
-#endif
-
+       for (p = pb_funcs; p->name; p++)
+               kdb_unregister(p->name);
 }
 
 /*
@@ -2315,19 +2977,35 @@
        "start_bno", "near_bno", "this_bno"
 };
 
+static int xargument = 0;
 
 /*
  * Prototypes for static functions.
  */
-#ifdef DEBUG
+#ifdef XFS_ALLOC_TRACE
 static int xfs_alloc_trace_entry(ktrace_entry_t *ktep);
 #endif
+#ifdef XFS_ATTR_TRACE
+static int xfs_attr_trace_entry(ktrace_entry_t *ktep);
+#endif
+#ifdef XFS_BMAP_TRACE
+static int xfs_bmap_trace_entry(ktrace_entry_t *ktep);
+#endif
+#ifdef XFS_BMAP_TRACE
+static int xfs_bmbt_trace_entry(ktrace_entry_t *ktep);
+#endif
 static void xfs_broot(xfs_inode_t *ip, xfs_ifork_t *f);
 static void xfs_btalloc(xfs_alloc_block_t *bt, int bsz);
 static void xfs_btbmap(xfs_bmbt_block_t *bt, int bsz);
 static void xfs_btino(xfs_inobt_block_t *bt, int bsz);
 static void xfs_buf_item_print(xfs_buf_log_item_t *blip, int summary);
 static void xfs_dastate_path(xfs_da_state_path_t *p);
+#ifdef XFS_DIR_TRACE
+static int xfs_dir_trace_entry(ktrace_entry_t *ktep);
+#endif
+#ifdef XFS_DIR2_TRACE
+static int xfs_dir2_trace_entry(ktrace_entry_t *ktep);
+#endif
 static void xfs_dir2data(void *addr, int size);
 static void xfs_dir2leaf(xfs_dir2_leaf_t *leaf, int size);
 static void xfs_dquot_item_print(xfs_dq_logitem_t *lip, int summary);
@@ -2345,6 +3023,10 @@
 static void xfs_prdinode(xfs_dinode_t *di, int coreonly, int convert);
 static void xfs_prdinode_core(xfs_dinode_core_t *dip, int convert);
 static void xfs_qoff_item_print(xfs_qoff_logitem_t *lip, int summary);
+#ifdef XFS_RW_TRACE
+static void xfs_rw_enter_trace_entry(ktrace_entry_t *ktep);
+static int xfs_rw_trace_entry(ktrace_entry_t *ktep);
+#endif
 static void xfs_xexlist_fork(xfs_inode_t *ip, int whichfork);
 static void xfs_xnode_fork(char *name, xfs_ifork_t *f);
 
@@ -2352,7 +3034,7 @@
  * Static functions.
  */
 
-#ifdef DEBUG
+#ifdef XFS_ALLOC_TRACE
 /*
  * Print xfs alloc trace buffer entry.
  */
@@ -2378,24 +3060,24 @@
                return 0;
        switch ((long)ktep->val[0] & 0xffffL) {
        case XFS_ALLOC_KTRACE_ALLOC:
-               kdb_printf("alloc %s[%s %d] mp 0x%p\n",
+               kdb_printf("alloc %s[%s %ld] mp 0x%p\n",
                        (char *)ktep->val[1],
                        ktep->val[2] ? (char *)ktep->val[2] : "",
-                       (__psint_t)ktep->val[0] >> 16,
+                       (long)ktep->val[0] >> 16,
                        (xfs_mount_t *)ktep->val[3]);
                kdb_printf(
-       "agno %d agbno %d minlen %d maxlen %d mod %d prod %d minleft %d\n",
-                       (__psunsigned_t)ktep->val[4],
-                       (__psunsigned_t)ktep->val[5],
-                       (__psunsigned_t)ktep->val[6],
-                       (__psunsigned_t)ktep->val[7],
-                       (__psunsigned_t)ktep->val[8],
-                       (__psunsigned_t)ktep->val[9],
-                       (__psunsigned_t)ktep->val[10]);
-               kdb_printf("total %d alignment %d len %d type %s otype %s\n",
-                       (__psunsigned_t)ktep->val[11],
-                       (__psunsigned_t)ktep->val[12],
-                       (__psunsigned_t)ktep->val[13],
+       "agno %ld agbno %ld minlen %ld maxlen %ld mod %ld prod %ld minleft %ld\n",
+                       (long)ktep->val[4],
+                       (long)ktep->val[5],
+                       (long)ktep->val[6],
+                       (long)ktep->val[7],
+                       (long)ktep->val[8],
+                       (long)ktep->val[9],
+                       (long)ktep->val[10]);
+               kdb_printf("total %ld alignment %ld len %ld type %s otype %s\n",
+                       (long)ktep->val[11],
+                       (long)ktep->val[12],
+                       (long)ktep->val[13],
                        xfs_alloctype[((__psint_t)ktep->val[14]) >> 16],
                        xfs_alloctype[((__psint_t)ktep->val[14]) & 0xffff]);
                kdb_printf("wasdel %d wasfromfl %d isfl %d userdata %d\n",
@@ -2405,76 +3087,76 @@
                        ((__psint_t)ktep->val[15] & (1 << 0)) != 0);
                break;
        case XFS_ALLOC_KTRACE_FREE:
-               kdb_printf("free %s[%s %d] mp 0x%p\n",
+               kdb_printf("free %s[%s %ld] mp 0x%p\n",
                        (char *)ktep->val[1],
                        ktep->val[2] ? (char *)ktep->val[2] : "",
-                       (__psint_t)ktep->val[0] >> 16,
+                       (long)ktep->val[0] >> 16,
                        (xfs_mount_t *)ktep->val[3]);
-               kdb_printf("agno %d agbno %d len %d isfl %d\n",
-                       (__psunsigned_t)ktep->val[4],
-                       (__psunsigned_t)ktep->val[5],
-                       (__psunsigned_t)ktep->val[6],
-                       (__psint_t)ktep->val[7]);
+               kdb_printf("agno %ld agbno %ld len %ld isfl %d\n",
+                       (long)ktep->val[4],
+                       (long)ktep->val[5],
+                       (long)ktep->val[6],
+                       (__psint_t)ktep->val[7] != 0);
                break;
        case XFS_ALLOC_KTRACE_MODAGF:
-               kdb_printf("modagf %s[%s %d] mp 0x%p\n",
+               kdb_printf("modagf %s[%s %ld] mp 0x%p\n",
                        (char *)ktep->val[1],
                        ktep->val[2] ? (char *)ktep->val[2] : "",
-                       (__psint_t)ktep->val[0] >> 16,
+                       (long)ktep->val[0] >> 16,
                        (xfs_mount_t *)ktep->val[3]);
                printflags((__psint_t)ktep->val[4], modagf_flags, "modified");
-               kdb_printf("seqno %d length %d roots b %d c %d\n",
-                       (__psunsigned_t)ktep->val[5],
-                       (__psunsigned_t)ktep->val[6],
-                       (__psunsigned_t)ktep->val[7],
-                       (__psunsigned_t)ktep->val[8]);
-               kdb_printf("levels b %d c %d flfirst %d fllast %d flcount %d\n",
-                       (__psunsigned_t)ktep->val[9],
-                       (__psunsigned_t)ktep->val[10],
-                       (__psunsigned_t)ktep->val[11],
-                       (__psunsigned_t)ktep->val[12],
-                       (__psunsigned_t)ktep->val[13]);
-               kdb_printf("freeblks %d longest %d\n",
-                       (__psunsigned_t)ktep->val[14],
-                       (__psunsigned_t)ktep->val[15]);
+               kdb_printf("seqno %lu length %lu roots b %lu c %lu\n",
+                       (unsigned long)ktep->val[5],
+                       (unsigned long)ktep->val[6],
+                       (unsigned long)ktep->val[7],
+                       (unsigned long)ktep->val[8]);
+               kdb_printf("levels b %lu c %lu flfirst %lu fllast %lu flcount %lu\n",
+                       (unsigned long)ktep->val[9],
+                       (unsigned long)ktep->val[10],
+                       (unsigned long)ktep->val[11],
+                       (unsigned long)ktep->val[12],
+                       (unsigned long)ktep->val[13]);
+               kdb_printf("freeblks %lu longest %lu\n",
+                       (unsigned long)ktep->val[14],
+                       (unsigned long)ktep->val[15]);
                break;
 
        case XFS_ALLOC_KTRACE_UNBUSY:
-               kdb_printf("unbusy %s [%s %d] mp 0x%p\n",
+               kdb_printf("unbusy %s [%s %ld] mp 0x%p\n",
                        (char *)ktep->val[1],
                        ktep->val[2] ? (char *)ktep->val[2] : "",
-                       (__psint_t)ktep->val[0] >> 16,
+                       (long)ktep->val[0] >> 16,
                        (xfs_mount_t *)ktep->val[3]);
-               kdb_printf("      agno %d slot %d tp 0x%x\n",
-                       (__psunsigned_t)ktep->val[4],
-                       (__psunsigned_t)ktep->val[7],
-                       (__psunsigned_t)ktep->val[8]);
+               kdb_printf("      agno %lu slot %lu tp 0x%p\n",
+                       (unsigned long)ktep->val[4],
+                       (unsigned long)ktep->val[7],
+                       (xfs_trans_t *)ktep->val[8]);
                break;
        case XFS_ALLOC_KTRACE_BUSY:
-               kdb_printf("busy %s [%s %d] mp 0x%p\n",
+               kdb_printf("busy %s [%s %ld] mp 0x%p\n",
                        (char *)ktep->val[1],
                        ktep->val[2] ? (char *)ktep->val[2] : "",
-                       (__psint_t)ktep->val[0] >> 16,
+                       (long)ktep->val[0] >> 16,
                        (xfs_mount_t *)ktep->val[3]);
-               kdb_printf("      agno %d agbno %d len %d slot %d tp 0x%x\n",
-                       (__psunsigned_t)ktep->val[4],
-                       (__psunsigned_t)ktep->val[5],
-                       (__psunsigned_t)ktep->val[6],
-                       (__psunsigned_t)ktep->val[7],
-                       (__psunsigned_t)ktep->val[8]);
+               kdb_printf("      agno %lu agbno %lu len %lu slot %lu tp 0x%p\n",
+                       (unsigned long)ktep->val[4],
+                       (unsigned long)ktep->val[5],
+                       (unsigned long)ktep->val[6],
+                       (unsigned long)ktep->val[7],
+                       (xfs_trans_t *)ktep->val[8]);
                break;
        case XFS_ALLOC_KTRACE_BUSYSEARCH:
-               kdb_printf("busy-search %s [%s %d] mp 0x%p\n",
+               kdb_printf("busy-search %s [%s %ld] mp 0x%p\n",
                        (char *)ktep->val[1],
                        ktep->val[2] ? (char *)ktep->val[2] : "",
-                       (__psint_t)ktep->val[0] >> 16,
+                       (long)ktep->val[0] >> 16,
                        (xfs_mount_t *)ktep->val[3]);
-               kdb_printf("      agno %d agbno %d len %d slot %d tp 0x%x\n",
-                       (__psunsigned_t)ktep->val[4],
-                       (__psunsigned_t)ktep->val[5],
-                       (__psunsigned_t)ktep->val[6],
-                       (__psunsigned_t)ktep->val[7],
-                       (__psunsigned_t)ktep->val[8]);
+               kdb_printf("      agno %ld agbno %ld len %ld slot %ld tp 0x%p\n",
+                       (unsigned long)ktep->val[4],
+                       (unsigned long)ktep->val[5],
+                       (unsigned long)ktep->val[6],
+                       (unsigned long)ktep->val[7],
+                       (xfs_trans_t *)ktep->val[8]);
                break;
        default:
                kdb_printf("unknown alloc trace record\n");
@@ -2482,7 +3164,242 @@
        }
        return 1;
 }
-#endif /* DEBUG */
+#endif /* XFS_ALLOC_TRACE */
+
+#ifdef XFS_ATTR_TRACE
+/*
+ * Print an attribute trace buffer entry.
+ */
+static int
+xfs_attr_trace_entry(ktrace_entry_t *ktep)
+{
+       static char *attr_arg_flags[] = {
+               "DONTFOLLOW",   /* 0x0001 */
+               "ROOT",         /* 0x0002 */
+               "TRUSTED",      /* 0x0004 */
+               "?",            /* 0x0008 */
+               "CREATE",       /* 0x0010 */
+               "REPLACE",      /* 0x0020 */
+               "?",            /* 0x0040 */
+               "?",            /* 0x0080 */
+               "SYSTEM",       /* 0x0100 */
+               "?",            /* 0x0200 */
+               "?",            /* 0x0400 */
+               "?",            /* 0x0800 */
+               "KERNOTIME",    /* 0x1000 */
+               "KERNOVAL",     /* 0x2000 */
+               "KERNAMELS",    /* 0x4000 */
+               "KERNFULLS",    /* 0x8000 */
+               NULL
+       };
+
+       if (!ktep->val[0])
+               return 0;
+
+       qprintf("-- %s: cursor h/b/o 0x%lx/0x%lx/%lu, dupcnt %lu, dp 0x%p\n",
+                (char *)ktep->val[1],
+                (unsigned long)ktep->val[3],
+                (unsigned long)ktep->val[4],
+                (unsigned long)ktep->val[5],
+                (unsigned long)ktep->val[11],
+                (xfs_inode_t *)ktep->val[2]);
+       qprintf("   alist 0x%p, size %lu, count %lu, firstu %lu, Llen %lu",
+                (attrlist_t *)ktep->val[6],
+                (unsigned long)ktep->val[7],
+                (unsigned long)ktep->val[8],
+                (unsigned long)ktep->val[9],
+                (unsigned long)ktep->val[10]);
+       printflags((__psunsigned_t)(ktep->val[12]), attr_arg_flags, ", flags");
+       qprintf("\n");
+
+       switch ((__psint_t)ktep->val[0]) {
+       case XFS_ATTR_KTRACE_L_C:
+               break;
+       case XFS_ATTR_KTRACE_L_CN:
+               qprintf("   node: count %lu, 1st hash 0x%lx, last hash 0x%lx\n",
+                        (unsigned long)ktep->val[13],
+                        (unsigned long)ktep->val[14],
+                        (unsigned long)ktep->val[15]);
+               break;
+       case XFS_ATTR_KTRACE_L_CB:
+               qprintf("   btree: hash 0x%lx, blkno 0x%lx\n",
+                        (unsigned long)ktep->val[13],
+                        (unsigned long)ktep->val[14]);
+               break;
+       case XFS_ATTR_KTRACE_L_CL:
+               qprintf("   leaf: count %ld, 1st hash 0x%lx, last hash 0x%lx\n",
+                        (unsigned long)ktep->val[13],
+                        (unsigned long)ktep->val[14],
+                        (unsigned long)ktep->val[15]);
+               break;
+       default:
+               qprintf("   unknown attr trace record format\n");
+               break;
+       }
+       return 1;
+}
+#endif /* XFS_ATTR_TRACE */
+
+#ifdef XFS_BMAP_TRACE
+/*
+ * Print xfs bmap extent trace buffer entry.
+ */
+static int
+xfs_bmap_trace_entry(ktrace_entry_t *ktep)
+{
+       xfs_dfsbno_t        b;
+       xfs_dfilblks_t    c;
+       xfs_inode_t          *ip;
+       xfs_ino_t              ino;
+       xfs_dfiloff_t      o;
+       int                  flag;
+       int                  opcode;
+       static char          *ops[] = { "del", "ins", "pre", "post" };
+       xfs_bmbt_rec_32_t       r;
+       int                  whichfork;
+
+       opcode = ((__psint_t)ktep->val[0]) & 0xffff;
+       if (opcode == 0)
+               return 0;
+       whichfork = ((__psint_t)ktep->val[0]) >> 16;
+       ip = (xfs_inode_t *)ktep->val[3];
+       ino = ((xfs_ino_t)(unsigned long)ktep->val[6] << 32) |
+               ((xfs_ino_t)(unsigned long)ktep->val[7]);
+       qprintf("%s %s:%s ip %p ino %s %cf\n",
+               ops[opcode - 1], (char *)ktep->val[1],
+               (char *)ktep->val[2], ip, xfs_fmtino(ino, ip->i_mount),
+               "da"[whichfork]);
+       r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[8];
+       r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[9];
+       r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[10];
+       r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[11];
+       xfs_convert_extent(&r, &o, &b, &c, &flag);
+       qprintf(" idx %ld offset %lld block %s",
+               (long)ktep->val[4], o,
+               xfs_fmtfsblock((xfs_fsblock_t)b, ip->i_mount));
+       qprintf(" count %lld flag %d\n", c, flag);
+       if ((__psint_t)ktep->val[5] != 2)
+               return 1;
+       r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[12];
+       r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[13];
+       r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[14];
+       r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[15];
+       xfs_convert_extent(&r, &o, &b, &c, &flag);
+       qprintf(" offset %lld block %s", o,
+               xfs_fmtfsblock((xfs_fsblock_t)b, ip->i_mount));
+       qprintf(" count %lld flag %d\n", c, flag);
+       return 1;
+}
+
+/*
+ * Print xfs bmap btree trace buffer entry.
+ */
+static int
+xfs_bmbt_trace_entry(
+       ktrace_entry_t    *ktep)
+{
+       int                     line;
+       xfs_bmbt_rec_32_t       r;
+       xfs_bmbt_irec_t         s;
+       int                     type;
+       int                     whichfork;
+
+       type = (__psint_t)ktep->val[0] & 0xff;
+       if (type == 0)
+               return 0;
+       whichfork = ((__psint_t)ktep->val[0] >> 8) & 0xff;
+       line = ((__psint_t)ktep->val[0] >> 16) & 0xffff;
+       qprintf("%s[%s@%d] ip 0x%p %cf cur 0x%p\n",
+               (char *)ktep->val[1],
+               (char *)ktep->val[2],
+               line,
+               (xfs_inode_t *)ktep->val[3],
+               "da"[whichfork],
+               (xfs_btree_cur_t *)ktep->val[4]);
+       switch (type) {
+       case XFS_BMBT_KTRACE_ARGBI:
+               qprintf(" buf 0x%p i %ld\n",
+                       (xfs_buf_t *)ktep->val[5],
+                       (long)ktep->val[6]);
+               break;
+       case XFS_BMBT_KTRACE_ARGBII:
+               qprintf(" buf 0x%p i0 %ld i1 %ld\n",
+                       (xfs_buf_t *)ktep->val[5],
+                       (long)ktep->val[6],
+                       (long)ktep->val[7]);
+               break;
+       case XFS_BMBT_KTRACE_ARGFFFI:
+               qprintf(" o 0x%x%08x b 0x%x%08x i 0x%x%08x j %ld\n",
+                       (unsigned int)(long)ktep->val[5],
+                       (unsigned int)(long)ktep->val[6],
+                       (unsigned int)(long)ktep->val[7],
+                       (unsigned int)(long)ktep->val[8],
+                       (unsigned int)(long)ktep->val[9],
+                       (unsigned int)(long)ktep->val[10],
+                       (long)ktep->val[11]);
+               break;
+       case XFS_BMBT_KTRACE_ARGI:
+               qprintf(" i 0x%lx\n",
+                       (long)ktep->val[5]);
+               break;
+       case XFS_BMBT_KTRACE_ARGIFK:
+               qprintf(" i 0x%lx f 0x%x%08x o 0x%x%08x\n",
+                       (long)ktep->val[5],
+                       (unsigned int)(long)ktep->val[6],
+                       (unsigned int)(long)ktep->val[7],
+                       (unsigned int)(long)ktep->val[8],
+                       (unsigned int)(long)ktep->val[9]);
+               break;
+       case XFS_BMBT_KTRACE_ARGIFR:
+               qprintf(" i 0x%lx f 0x%x%08x ",
+                       (long)ktep->val[5],
+                       (unsigned int)(long)ktep->val[6],
+                       (unsigned int)(long)ktep->val[7]);
+               s.br_startoff = (xfs_fileoff_t)
+                       (((xfs_dfiloff_t)(unsigned long)ktep->val[8] << 32) |
+                               (xfs_dfiloff_t)(unsigned long)ktep->val[9]);
+               s.br_startblock = (xfs_fsblock_t)
+                       (((xfs_dfsbno_t)(unsigned long)ktep->val[10] << 32) |
+                               (xfs_dfsbno_t)(unsigned long)ktep->val[11]);
+               s.br_blockcount = (xfs_filblks_t)
+                       (((xfs_dfilblks_t)(unsigned long)ktep->val[12] << 32) |
+                               (xfs_dfilblks_t)(unsigned long)ktep->val[13]);
+               xfsidbg_xbirec(&s);
+               break;
+       case XFS_BMBT_KTRACE_ARGIK:
+               qprintf(" i 0x%lx o 0x%x%08x\n",
+                       (long)ktep->val[5],
+                       (unsigned int)(long)ktep->val[6],
+                       (unsigned int)(long)ktep->val[7]);
+               break;
+       case XFS_BMBT_KTRACE_CUR:
+               qprintf(" nlevels %ld flags %ld allocated %ld ",
+                       ((long)ktep->val[5] >> 24) & 0xff,
+                       ((long)ktep->val[5] >> 16) & 0xff,
+                       (long)ktep->val[5] & 0xffff);
+               r.l0 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[6];
+               r.l1 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[7];
+               r.l2 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[8];
+               r.l3 = (xfs_bmbt_rec_base_t)(unsigned long)ktep->val[9];
+               xfsidbg_xbrec((xfs_bmbt_rec_64_t *)&r);
+               qprintf(" bufs 0x%p 0x%p 0x%p 0x%p ",
+                       (xfs_buf_t *)ktep->val[10],
+                       (xfs_buf_t *)ktep->val[11],
+                       (xfs_buf_t *)ktep->val[12],
+                       (xfs_buf_t *)ktep->val[13]);
+               qprintf("ptrs %ld %ld %ld %ld\n",
+                       (long)ktep->val[14] >> 16,
+                       (long)ktep->val[14] & 0xffff,
+                       (long)ktep->val[15] >> 16,
+                       (long)ktep->val[15] & 0xffff);
+               break;
+       default:
+               qprintf("unknown bmbt trace record\n");
+               break;
+       }
+       return 1;
+}
+#endif
 
 /*
  * Print an xfs in-inode bmap btree root.
@@ -2603,8 +3520,11 @@
        int i;
 
        kdb_printf("magic 0x%x level %d numrecs %d leftsib 0x%x rightsib 0x%x\n",
-               INT_GET(bt->bb_magic, ARCH_CONVERT), INT_GET(bt->bb_level, ARCH_CONVERT), INT_GET(bt->bb_numrecs, ARCH_CONVERT),
-               INT_GET(bt->bb_leftsib, ARCH_CONVERT), INT_GET(bt->bb_rightsib, ARCH_CONVERT));
+               INT_GET(bt->bb_magic, ARCH_CONVERT),
+               INT_GET(bt->bb_level, ARCH_CONVERT),
+               INT_GET(bt->bb_numrecs, ARCH_CONVERT),
+               INT_GET(bt->bb_leftsib, ARCH_CONVERT),
+               INT_GET(bt->bb_rightsib, ARCH_CONVERT));
        if (INT_ISZERO(bt->bb_level, ARCH_CONVERT)) {
 
                for (i = 1; i <= INT_GET(bt->bb_numrecs, ARCH_CONVERT); i++) {
@@ -2612,7 +3532,8 @@
 
                        r = XFS_BTREE_REC_ADDR(bsz, xfs_inobt, bt, i, 0);
                        kdb_printf("rec %d startino 0x%x freecount %d, free %Lx\n",
-                               i, INT_GET(r->ir_startino, ARCH_CONVERT), INT_GET(r->ir_freecount, ARCH_CONVERT),
+                               i, INT_GET(r->ir_startino, ARCH_CONVERT),
+                               INT_GET(r->ir_freecount, ARCH_CONVERT),
                                INT_GET(r->ir_free, ARCH_CONVERT));
                }
        } else {
@@ -2626,7 +3547,8 @@
                        k = XFS_BTREE_KEY_ADDR(bsz, xfs_inobt, bt, i, mxr);
                        p = XFS_BTREE_PTR_ADDR(bsz, xfs_inobt, bt, i, mxr);
                        kdb_printf("key %d startino 0x%x ptr 0x%x\n",
-                               i, INT_GET(k->ir_startino, ARCH_CONVERT), INT_GET(*p, ARCH_CONVERT));
+                               i, INT_GET(k->ir_startino, ARCH_CONVERT),
+                               INT_GET(*p, ARCH_CONVERT));
                }
        }
 }
@@ -2678,30 +3600,199 @@
        kdb_printf("\n");
 }
 
+#ifdef XFS_BMAP_TRACE
+/*
+ * Convert an external extent descriptor to internal form.
+ */
+static void
+xfs_convert_extent(xfs_bmbt_rec_32_t *rp, xfs_dfiloff_t *op, xfs_dfsbno_t *sp,
+                  xfs_dfilblks_t *cp, int *fp)
+{
+       xfs_dfiloff_t o;
+       xfs_dfsbno_t s;
+       xfs_dfilblks_t c;
+       int flag;
+
+       flag = (((xfs_dfiloff_t)rp->l0) >> 31) & 1;
+       o = ((((xfs_dfiloff_t)rp->l0) & 0x7fffffff) << 23) |
+           (((xfs_dfiloff_t)rp->l1) >> 9);
+       s = (((xfs_dfsbno_t)(rp->l1 & 0x000001ff)) << 43) |
+           (((xfs_dfsbno_t)rp->l2) << 11) |
+           (((xfs_dfsbno_t)rp->l3) >> 21);
+       c = (xfs_dfilblks_t)(rp->l3 & 0x001fffff);
+       *op = o;
+       *sp = s;
+       *cp = c;
+       *fp = flag;
+}
+#endif
+
+#ifdef XFS_RW_TRACE
+/*
+ * Print itrunc entry trace.
+ */
+static void
+xfs_ctrunc_trace_entry(ktrace_entry_t  *ktep)
+{
+       qprintf("ip 0x%p cpu %ld\n",
+               (xfs_inode_t *)(unsigned long)ktep->val[1], (long)ktep->val[2]);
+}
+#endif
+
+/*
+ * Print an xfs_da_state_path structure.
+ */
+static void
+xfs_dastate_path(xfs_da_state_path_t *p)
+{
+       int i;
+
+       kdb_printf("active %d\n", p->active);
+       for (i = 0; i < XFS_DA_NODE_MAXDEPTH; i++) {
+               kdb_printf(" blk %d bp 0x%p blkno 0x%x",
+                       i, p->blk[i].bp, p->blk[i].blkno);
+               kdb_printf(" index %d hashval 0x%x ",
+                       p->blk[i].index, (uint_t)p->blk[i].hashval);
+               switch(p->blk[i].magic) {
+               case XFS_DA_NODE_MAGIC:         kdb_printf("NODE\n");   break;
+               case XFS_DIR_LEAF_MAGIC:        kdb_printf("DIR\n");    break;
+               case XFS_ATTR_LEAF_MAGIC:       kdb_printf("ATTR\n");   break;
+               case XFS_DIR2_LEAFN_MAGIC:      kdb_printf("DIR2\n");   break;
+               default:                        kdb_printf("type ?\n"); break;
+               }
+       }
+}
+
+#ifdef XFS_DIR_TRACE
+/*
+ * Print a xfs directory trace buffer entry.
+ */
+static int
+xfs_dir_trace_entry(ktrace_entry_t *ktep)
+{
+       xfs_mount_t *mp;
+       __uint32_t hash;
+       xfs_off_t cookie;
+
+       if (!ktep->val[0] || !ktep->val[1])
+               return 0;
+
+       mp = (xfs_mount_t *)ktep->val[3];
+       cookie = (__psunsigned_t)ktep->val[4];
+       cookie <<= 32;
+       cookie |= (__psunsigned_t)ktep->val[5];
+       qprintf("%s -- dp=0x%p b/e/h=%ld/%ld/0x%08lx resid=0x%lx ",
+                   (char *)ktep->val[1],
+                   (xfs_inode_t *)ktep->val[2],
+                   (long)XFS_DA_COOKIE_BNO(mp, cookie),
+                   (long)XFS_DA_COOKIE_ENTRY(mp, cookie),
+                   (unsigned long)XFS_DA_COOKIE_HASH(mp, cookie),
+                   (long)ktep->val[6]);
+
+       switch ((__psint_t)ktep->val[0]) {
+       case XFS_DIR_KTRACE_G_DU:
+               break;
+       case XFS_DIR_KTRACE_G_DUB:
+               qprintf("bno=%ld", (long)ktep->val[7]);
+               break;
+       case XFS_DIR_KTRACE_G_DUN:
+               qprintf("forw=%ld, cnt=%ld, 0x%08lx - 0x%08lx",
+                             (long)ktep->val[7],
+                             (long)ktep->val[8],
+                             (unsigned long)ktep->val[9],
+                             (unsigned long)ktep->val[10]);
+               break;
+       case XFS_DIR_KTRACE_G_DUL:
+               qprintf("forw=%ld, cnt=%ld, 0x%08lx - 0x%08lx",
+                             (long)ktep->val[7],
+                             (long)ktep->val[8],
+                             (unsigned long)ktep->val[9],
+                             (unsigned long)ktep->val[10]);
+               break;
+       case XFS_DIR_KTRACE_G_DUE:
+               qprintf("entry hashval 0x%08lx", (unsigned long)ktep->val[7]);
+               break;
+       case XFS_DIR_KTRACE_G_DUC:
+               cookie = (__psunsigned_t)ktep->val[7];
+               cookie <<= 32;
+               cookie |= (__psunsigned_t)ktep->val[8];
+               hash = XFS_DA_COOKIE_HASH(mp, cookie);
+               qprintf("b/e/h=%ld/%ld/0x%08x",
+                   (long)XFS_DA_COOKIE_BNO(mp, cookie),
+                   (long)XFS_DA_COOKIE_ENTRY(mp, cookie),
+                   hash);
+               break;
+       default:
+               qprintf("unknown dir trace record format");
+               break;
+       }
+       return 1;
+}
+#endif
+
+#ifdef XFS_DIR2_TRACE
 /*
- * Print an xfs_da_state_path structure.
+ * Print a xfs v2 directory trace buffer entry.
  */
-static void
-xfs_dastate_path(xfs_da_state_path_t *p)
+static int
+xfs_dir2_trace_entry(ktrace_entry_t *ktep)
 {
-       int i;
+       char        *cp;
+       int          i;
+       int          len;
 
-       kdb_printf("active %d\n", p->active);
-       for (i = 0; i < XFS_DA_NODE_MAXDEPTH; i++) {
-               kdb_printf(" blk %d bp 0x%p blkno 0x%x",
-                       i, p->blk[i].bp, p->blk[i].blkno);
-               kdb_printf(" index %d hashval 0x%x ",
-                       p->blk[i].index, (uint_t)p->blk[i].hashval);
-               switch(p->blk[i].magic) {
-               case XFS_DA_NODE_MAGIC:         kdb_printf("NODE\n");   break;
-               case XFS_DIR_LEAF_MAGIC:        kdb_printf("DIR\n");    break;
-               case XFS_ATTR_LEAF_MAGIC:       kdb_printf("ATTR\n");   break;
-               case XFS_DIR2_LEAFN_MAGIC:      kdb_printf("DIR2\n");   break;
-               default:                        kdb_printf("type ??\n");        break;
-               }
+       if (!ktep->val[0])
+               return 0;
+       cp = (char *)&ktep->val[10];
+       qprintf("%s: '", (char *)ktep->val[1]);
+       len = min((__psint_t)ktep->val[9], (__psint_t)sizeof(ktep->val[10])*6);
+       for (i = 0; i < len; i++)
+               qprintf("%c", cp[i]);
+       qprintf("'(%ld)", (long)ktep->val[9]);
+       if ((__psunsigned_t)ktep->val[0] != XFS_DIR2_KTRACE_ARGS_BIBII)
+               qprintf(" hashval 0x%llx inumber %lld dp 0x%p tp 0x%p check %d",
+                       (__uint64_t)(unsigned long)ktep->val[2],
+                       (__int64_t)(unsigned long)ktep->val[3],
+                       ktep->val[4], ktep->val[5],
+                       (int)(__psint_t)ktep->val[6]);
+       switch ((__psunsigned_t)ktep->val[0]) {
+       case XFS_DIR2_KTRACE_ARGS:
+               break;
+       case XFS_DIR2_KTRACE_ARGS_B:
+               qprintf(" bp 0x%p", ktep->val[7]);
+               break;
+       case XFS_DIR2_KTRACE_ARGS_BB:
+               qprintf(" lbp 0x%p dbp 0x%p", ktep->val[7], ktep->val[8]);
+               break;
+       case XFS_DIR2_KTRACE_ARGS_BIBII:
+               qprintf(" dp 0x%p tp 0x%p srcbp 0x%p srci %d dstbp 0x%p dsti %d count %d",
+                       ktep->val[2], ktep->val[3], ktep->val[4],
+                       (int)(__psint_t)ktep->val[5], ktep->val[6],
+                       (int)(__psint_t)ktep->val[7],
+                       (int)(__psint_t)ktep->val[8]);
+               break;
+       case XFS_DIR2_KTRACE_ARGS_DB:
+               qprintf(" db 0x%x bp 0x%p",
+                       (xfs_dir2_db_t)(unsigned long)ktep->val[7],
+                       ktep->val[8]);
+               break;
+       case XFS_DIR2_KTRACE_ARGS_I:
+               qprintf(" i 0x%lx", (unsigned long)ktep->val[7]);
+               break;
+       case XFS_DIR2_KTRACE_ARGS_S:
+               qprintf(" s 0x%x", (int)(__psint_t)ktep->val[7]);
+               break;
+       case XFS_DIR2_KTRACE_ARGS_SB:
+               qprintf(" s 0x%x bp 0x%p", (int)(__psint_t)ktep->val[7],
+                       ktep->val[8]);
+               break;
+       default:
+               qprintf("unknown dirv2 trace record format");
+               break;
        }
+       return 1;
 }
-
+#endif
 
 /*
  * Print an efd log item.
@@ -2847,19 +3938,19 @@
        static char rval[16];
 
        sprintf(rval, "%c%c%c%c%c%c%c%c%c%c%c%c%c",
-               "?fc?dxb?r?l?S?m?"[(m & IFMT) >> 12],
-               m & ISUID ? 'u' : '-',
-               m & ISGID ? 'g' : '-',
-               m & ISVTX ? 'v' : '-',
-               m & IREAD ? 'r' : '-',
-               m & IWRITE ? 'w' : '-',
-               m & IEXEC ? 'x' : '-',
-               m & (IREAD >> 3) ? 'r' : '-',
-               m & (IWRITE >> 3) ? 'w' : '-',
-               m & (IEXEC >> 3) ? 'x' : '-',
-               m & (IREAD >> 6) ? 'r' : '-',
-               m & (IWRITE >> 6) ? 'w' : '-',
-               m & (IEXEC >> 6) ? 'x' : '-');
+               "?fc?dxb?r?l?S?m?"[(m & S_IFMT) >> 12],
+               m & S_ISUID ? 'u' : '-',
+               m & S_ISGID ? 'g' : '-',
+               m & S_ISVTX ? 'v' : '-',
+               m & S_IRUSR ? 'r' : '-',
+               m & S_IWUSR ? 'w' : '-',
+               m & S_IXUSR ? 'x' : '-',
+               m & S_IRGRP ? 'r' : '-',
+               m & S_IWGRP ? 'w' : '-',
+               m & S_IXGRP ? 'x' : '-',
+               m & S_IROTH ? 'r' : '-',
+               m & S_IWOTH ? 'w' : '-',
+               m & S_IXOTH ? 'x' : '-');
        return rval;
 }
 
@@ -2883,9 +3974,9 @@
 xfs_fmtuuid(uuid_t *uu)
 {
        static char rval[40];
-       char        *o          = rval;
-       char        *i          = (unsigned char*)uu;
-       int         b;
+       char    *o        = rval;
+       char    *i        = (unsigned char*)uu;
+       int      b;
 
        for (b=0;b<16;b++) {
            o+=sprintf(o, "%02x", *i++);
@@ -2930,9 +4021,9 @@
                kdb_printf("\n");
                return;
        }
-       kdb_printf("inode 0x%p ino 0x%llu logged %d flags: ",
+       kdb_printf("inode 0x%p ino 0x%llu pushbuf %d logged %d flags: ",
                ilip->ili_inode, (unsigned long long) ilip->ili_format.ilf_ino,
-               ilip->ili_logged);
+               ilip->ili_pushbuf_flag, ilip->ili_logged);
        printflags(ilip->ili_flags, ili_flags, NULL);
        kdb_printf("\n");
        kdb_printf("ilock recur %d iolock recur %d ext buf 0x%p\n",
@@ -2942,10 +4033,9 @@
        kdb_printf("root bytes %d root orig 0x%x\n",
                ilip->ili_root_size, ilip->ili_orig_root);
 #endif
-       kdb_printf("size %d fields: ", ilip->ili_format.ilf_size);
-       printflags(ilip->ili_format.ilf_fields, ilf_fields, "formatfield");
-       kdb_printf(" last fields: ");
-       printflags(ilip->ili_last_fields, ilf_fields, "lastfield");
+       kdb_printf("size %d ", ilip->ili_format.ilf_size);
+       printflags(ilip->ili_format.ilf_fields, ilf_fields, "fields:");
+       printflags(ilip->ili_last_fields, ilf_fields, " last fields: ");
        kdb_printf("\n");
        kdb_printf(" flush lsn %s last lsn %s\n",
                xfs_fmtlsn(&(ilip->ili_flush_lsn)),
@@ -3001,6 +4091,129 @@
        }
 }
 
+#ifdef XFS_RW_TRACE
+/*
+ * Print iomap entry trace.
+ */
+static void
+xfs_iomap_enter_trace_entry(ktrace_entry_t *ktep)
+{
+       qprintf("ip 0x%p size 0x%x%x offset 0x%x%x count 0x%x\n",
+               ktep->val[1],
+               (unsigned int)(long)ktep->val[2],
+               (unsigned int)(long)ktep->val[3],
+               (unsigned int)(long)ktep->val[4],
+               (unsigned int)(long)ktep->val[5],
+               (unsigned int)(long)ktep->val[6]);
+       qprintf("next offset 0x%x%x io offset 0x%x%x\n",
+               (unsigned int)(long)ktep->val[7],
+               (unsigned int)(long)ktep->val[8],
+               (unsigned int)(long)ktep->val[9],
+               (unsigned int)(long)ktep->val[10]);
+       qprintf("io size 0x%x last req sz 0x%x new size 0x%x%x\n",
+               (unsigned int)(long)ktep->val[11],
+               (unsigned int)(long)ktep->val[12],
+               (unsigned int)(long)ktep->val[13],
+               (unsigned int)(long)ktep->val[14]);
+}
+
+/*
+ * Print iomap map trace.
+ */
+static void
+xfs_iomap_map_trace_entry(ktrace_entry_t *ktep)
+{
+       qprintf("ip 0x%p size 0x%x%x offset 0x%x%x count 0x%x\n",
+               ktep->val[1],
+               (unsigned int)(long)ktep->val[2],
+               (unsigned int)(long)ktep->val[3],
+               (unsigned int)(long)ktep->val[4],
+               (unsigned int)(long)ktep->val[5],
+               (unsigned int)(long)ktep->val[6]);
+       qprintf("bmap off 0x%x%x len 0x%x pboff 0x%x pbsize 0x%x bno 0x%x\n",
+               (unsigned int)(long)ktep->val[7],
+               (unsigned int)(long)ktep->val[8],
+               (unsigned int)(long)ktep->val[9],
+               (unsigned int)(long)ktep->val[10],
+               (unsigned int)(long)ktep->val[11],
+               (unsigned int)(long)ktep->val[12]);
+       qprintf("imap off 0x%x count 0x%x block 0x%x\n",
+               (unsigned int)(long)ktep->val[13],
+               (unsigned int)(long)ktep->val[14],
+               (unsigned int)(long)ktep->val[15]);
+}
+
+/*
+ * Print itrunc entry trace.
+ */
+static void
+xfs_itrunc_trace_entry(ktrace_entry_t   *ktep)
+{
+       qprintf("ip 0x%p size 0x%x%x flag %ld new size 0x%x%x\n",
+               ktep->val[1],
+               (unsigned int)(long)ktep->val[2],
+               (unsigned int)(long)ktep->val[3],
+               (long)ktep->val[4],
+               (unsigned int)(long)ktep->val[5],
+               (unsigned int)(long)ktep->val[6]);
+       qprintf("toss start 0x%x%x toss finish 0x%x%x cpu id %ld\n",
+               (unsigned int)(long)ktep->val[7],
+               (unsigned int)(long)ktep->val[8],
+               (unsigned int)(long)ktep->val[9],
+               (unsigned int)(long)ktep->val[10],
+               (long)ktep->val[11]);
+}
+
+/*
+ * Print bunmap entry trace.
+ */
+static void
+xfs_bunmap_trace_entry(ktrace_entry_t   *ktep)
+{
+       static char *bunmapi_flags[] = {
+               "write",        /* 0x01 */
+               "delay",        /* 0x02 */
+               "entire",       /* 0x04 */
+               "metadata",     /* 0x08 */
+               "exact",        /* 0x10 */
+               "attrfork",     /* 0x20 */
+               "async",        /* 0x40 */
+               "rsvblocks",    /* 0x80 */
+               0
+       };
+
+       qprintf("ip 0x%p size 0x%x%x bno 0x%x%x len 0x%x cpu id %ld\n",
+               ktep->val[1],
+               (unsigned int)(long)ktep->val[2],
+               (unsigned int)(long)ktep->val[3],
+               (unsigned int)(long)ktep->val[4],
+               (unsigned int)(long)ktep->val[5],
+               (unsigned int)(long)ktep->val[6],
+               (long)ktep->val[8]);
+       qprintf("ra 0x%p ", ktep->val[9]);
+       printflags((__psint_t)ktep->val[7], bunmapi_flags, "flags");
+       qprintf("\n");
+}
+
+/*
+ * Print inval_cached_pages entry trace.
+ */
+static void
+xfs_inval_cached_trace_entry(ktrace_entry_t     *ktep)
+{
+       qprintf("ip 0x%p offset 0x%x%x len 0x%x%x first 0x%x%x last 0x%x%x\n",
+               ktep->val[1],
+               (unsigned int)(long)ktep->val[2],
+               (unsigned int)(long)ktep->val[3],
+               (unsigned int)(long)ktep->val[4],
+               (unsigned int)(long)ktep->val[5],
+               (unsigned int)(long)ktep->val[6],
+               (unsigned int)(long)ktep->val[7],
+               (unsigned int)(long)ktep->val[8],
+               (unsigned int)(long)ktep->val[9]);
+}
+#endif
+
 
 /*
  * Print disk inode.
@@ -3047,14 +4260,14 @@
                INT_GET(dip->di_gid, convert),
                (uint)INT_GET(dip->di_projid, convert),
                (uint)INT_GET(dip->di_flushiter, convert));
-       kdb_printf("atime 0x%x:%x mtime 0x%x:%x ctime 0x%x:%x\n",
+       kdb_printf("atime %u:%u mtime %ud:%u ctime %u:%u\n",
                INT_GET(dip->di_atime.t_sec, convert),
                INT_GET(dip->di_atime.t_nsec, convert),
                INT_GET(dip->di_mtime.t_sec, convert),
                INT_GET(dip->di_mtime.t_nsec, convert),
                INT_GET(dip->di_ctime.t_sec, convert),
                INT_GET(dip->di_ctime.t_nsec, convert));
-       kdb_printf("size 0x%Lx ", INT_GET(dip->di_size, convert));
+       kdb_printf("size %Ld ", INT_GET(dip->di_size, convert));
        kdb_printf("nblocks %Ld extsize 0x%x nextents 0x%x anextents 0x%x\n",
                INT_GET(dip->di_nblocks, convert),
                INT_GET(dip->di_extsize, convert),
@@ -3071,6 +4284,129 @@
        kdb_printf("gen 0x%x\n", INT_GET(dip->di_gen, convert));
 }
 
+#ifdef XFS_RW_TRACE
+/*
+ * Print read/write entry trace.
+ */
+static void
+xfs_rw_enter_trace_entry(ktrace_entry_t *ktep)
+{
+       qprintf("ip 0x%p size 0x%x%x uio offset 0x%x%x uio count 0x%x\n",
+               ktep->val[1],
+               (unsigned int)(long)ktep->val[2],
+               (unsigned int)(long)ktep->val[3],
+               (unsigned int)(long)ktep->val[4],
+               (unsigned int)(long)ktep->val[5],
+               (unsigned int)(long)ktep->val[6]);
+       qprintf("ioflags 0x%x next offset 0x%x%x io offset 0x%x%x\n",
+               (unsigned int)(long)ktep->val[7],
+               (unsigned int)(long)ktep->val[8],
+               (unsigned int)(long)ktep->val[9],
+               (unsigned int)(long)ktep->val[10],
+               (unsigned int)(long)ktep->val[11]);
+       qprintf("io size 0x%x last req sz 0x%x new size 0x%x%x\n",
+               (unsigned int)(long)ktep->val[12],
+               (unsigned int)(long)ktep->val[13],
+               (unsigned int)(long)ktep->val[14],
+               (unsigned int)(long)ktep->val[15]);
+}
+
+/*
+ * Print read/write trace entry.
+ */
+static int
+xfs_rw_trace_entry(ktrace_entry_t *ktep)
+{
+       switch ( (long)ktep->val[0] ) {
+       case XFS_READ_ENTER:
+               qprintf("READ ENTER:\n");
+               xfs_rw_enter_trace_entry(ktep);
+               break;
+       case XFS_WRITE_ENTER:
+               qprintf("WRITE ENTER:\n");
+               xfs_rw_enter_trace_entry(ktep);
+               break;
+       case XFS_IOMAP_READ_ENTER:
+               qprintf("IOMAP READ ENTER:\n");
+               xfs_iomap_enter_trace_entry(ktep);
+               break;
+       case XFS_IOMAP_WRITE_ENTER:
+               qprintf("IOMAP WRITE ENTER:\n");
+               xfs_iomap_enter_trace_entry(ktep);
+               break;
+       case XFS_IOMAP_WRITE_NOSPACE:
+               qprintf("IOMAP WRITE NOSPACE:\n");
+               xfs_iomap_enter_trace_entry(ktep);
+               break;
+       case XFS_IOMAP_READ_MAP:
+               qprintf("IOMAP READ MAP:\n");
+               xfs_iomap_map_trace_entry(ktep);
+               break;
+       case XFS_IOMAP_WRITE_MAP:
+               qprintf("IOMAP WRITE MAP:\n");
+               xfs_iomap_map_trace_entry(ktep);
+               break;
+       case XFS_ITRUNC_START:
+               qprintf("ITRUNC START:\n");
+               xfs_itrunc_trace_entry(ktep);
+               break;
+       case XFS_ITRUNC_FINISH1:
+               qprintf("ITRUNC FINISH1:\n");
+               xfs_itrunc_trace_entry(ktep);
+               break;
+       case XFS_ITRUNC_FINISH2:
+               qprintf("ITRUNC FINISH2:\n");
+               xfs_itrunc_trace_entry(ktep);
+               break;
+       case XFS_CTRUNC1:
+               qprintf("CTRUNC1:\n");
+               xfs_ctrunc_trace_entry(ktep);
+               break;
+       case XFS_CTRUNC2:
+               qprintf("CTRUNC2:\n");
+               xfs_ctrunc_trace_entry(ktep);
+               break;
+       case XFS_CTRUNC3:
+               qprintf("CTRUNC3:\n");
+               xfs_ctrunc_trace_entry(ktep);
+               break;
+       case XFS_CTRUNC4:
+               qprintf("CTRUNC4:\n");
+               xfs_ctrunc_trace_entry(ktep);
+               break;
+       case XFS_CTRUNC5:
+               qprintf("CTRUNC5:\n");
+               xfs_ctrunc_trace_entry(ktep);
+               break;
+       case XFS_CTRUNC6:
+               qprintf("CTRUNC6:\n");
+               xfs_ctrunc_trace_entry(ktep);
+               break;
+       case XFS_BUNMAPI:
+               qprintf("BUNMAPI:\n");
+               xfs_bunmap_trace_entry(ktep);
+               break;
+       case XFS_INVAL_CACHED:
+               qprintf("INVAL CACHED:\n");
+               xfs_inval_cached_trace_entry(ktep);
+               break;
+       case XFS_DIORD_ENTER:
+               qprintf("DIORD ENTER:\n");
+               xfs_rw_enter_trace_entry(ktep);
+               break;
+       case XFS_DIOWR_ENTER:
+               qprintf("DIOWR ENTER:\n");
+               xfs_rw_enter_trace_entry(ktep);
+               break;
+
+       default:
+               return 0;
+       }
+
+       return 1;
+}
+#endif
+
 /*
  * Print xfs extent list for a fork.
  */
@@ -3194,6 +4530,109 @@
        }
 }
 
+#ifdef XFS_ALLOC_TRACE
+/*
+ * Print out the last "count" entries in the allocation trace buffer.
+ */
+static void
+xfsidbg_xalatrace(int count)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       int          nentries;
+       int          skip_entries;
+
+       if (xfs_alloc_trace_buf == NULL) {
+               qprintf("The xfs alloc trace buffer is not initialized\n");
+               return;
+       }
+       nentries = ktrace_nentries(xfs_alloc_trace_buf);
+       if (count == -1) {
+               count = nentries;
+       }
+       if ((count <= 0) || (count > nentries)) {
+               qprintf("Invalid count.  There are %d entries.\n", nentries);
+               return;
+       }
+
+       ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
+       if (count != nentries) {
+               /*
+                * Skip the total minus the number to look at minus one
+                * for the entry returned by ktrace_first().
+                */
+               skip_entries = nentries - count - 1;
+               ktep = ktrace_skip(xfs_alloc_trace_buf, skip_entries, &kts);
+               if (ktep == NULL) {
+                       qprintf("Skipped them all\n");
+                       return;
+               }
+       }
+       while (ktep != NULL) {
+               if (xfs_alloc_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
+       }
+}
+
+/*
+ * Print out all the entries in the alloc trace buf corresponding
+ * to the given block number.
+ */
+static void
+xfsidbg_xalbtrace(xfs_agblock_t bno)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+
+       if (xfs_alloc_trace_buf == NULL) {
+               qprintf("The xfs alloc trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
+       while (ktep != NULL) {
+               switch ((__psint_t)ktep->val[0]) {
+               case XFS_ALLOC_KTRACE_ALLOC:
+               case XFS_ALLOC_KTRACE_FREE:
+                       if (bno >= (xfs_agblock_t)((__psint_t)ktep->val[5]) &&
+                           bno < (xfs_agblock_t)((__psint_t)ktep->val[5]) +
+                                 (xfs_extlen_t)((__psint_t)ktep->val[13])) {
+                               (void)xfs_alloc_trace_entry(ktep);
+                               qprintf("\n");
+                       }
+                       break;
+               }
+               ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
+       }
+}
+
+/*
+ * Print out all the entries in the alloc trace buf corresponding
+ * to the given allocation group.
+ */
+static void
+xfsidbg_xalgtrace(xfs_agnumber_t agno)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+
+       if (xfs_alloc_trace_buf == NULL) {
+               qprintf("The xfs alloc trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
+       while (ktep != NULL) {
+               if (  (__psint_t)ktep->val[0] &&
+                     ((xfs_agnumber_t)((__psint_t)ktep->val[4])) == agno ) {
+                       (void)xfs_alloc_trace_entry(ktep);
+                       qprintf("\n");
+               }
+               ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
+       }
+}
+#endif
 
 /*
  * Print an allocation argument structure for XFS.
@@ -3215,7 +4654,7 @@
                args->wasfromfl, args->isfl, args->userdata);
 }
 
-#ifdef DEBUG
+#ifdef XFS_ALLOC_TRACE
 /*
  * Print out all the entries in the alloc trace buf corresponding
  * to the given mount point.
@@ -3225,7 +4664,6 @@
 {
        ktrace_entry_t  *ktep;
        ktrace_snap_t   kts;
-       extern ktrace_t *xfs_alloc_trace_buf;
 
        if (xfs_alloc_trace_buf == NULL) {
                kdb_printf("The xfs alloc trace buffer is not initialized\n");
@@ -3234,14 +4672,53 @@
 
        ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
        while (ktep != NULL) {
-               if ((__psint_t)ktep->val[0] && (xfs_mount_t *)ktep->val[3] == mp) {
+               if ((__psint_t)ktep->val[0] &&
+                   (xfs_mount_t *)ktep->val[3] == mp) {
                        (void)xfs_alloc_trace_entry(ktep);
                        kdb_printf("\n");
                }
                ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
        }
 }
-#endif /* DEBUG */
+
+/*
+ * Print out all the entries in the alloc trace buf corresponding
+ * to the given entry type.
+ */
+static void
+xfsidbg_xalttrace(int tag)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+
+       if (xfs_alloc_trace_buf == NULL) {
+               qprintf("The xfs alloc trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(xfs_alloc_trace_buf, &kts);
+       while (ktep != NULL) {
+               if ((__psint_t)ktep->val[0] &&
+                   ((long)ktep->val[0] & 0xffffL) == (long)tag) {
+                       (void)xfs_alloc_trace_entry(ktep);
+                       qprintf("\n");
+               }
+               ktep = ktrace_next(xfs_alloc_trace_buf, &kts);
+       }
+}
+#endif
+
+/*
+ * Set xtra argument, used by xchksum.
+ */
+static void
+xfsidbg_xarg(int xarg)
+{
+       if (xarg == -1)
+               qprintf("xargument: %d\n", xargument);
+       else
+               xargument = xarg;
+}       /* xfsidbg_xarg */
 
 /*
  * Print an attr_list() context structure.
@@ -3368,41 +4845,232 @@
        }
 }
 
-
+#ifdef XFS_ATTR_TRACE
+/*
+ * Print out the last "count" entries in the attribute trace buffer.
+ */
+static void
+xfsidbg_xattrtrace(int count)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       int          nentries;
+       int          skip_entries;
+
+       if (xfs_attr_trace_buf == NULL) {
+               qprintf("The xfs attribute trace buffer is not initialized\n");
+               return;
+       }
+       nentries = ktrace_nentries(xfs_attr_trace_buf);
+       if (count == -1) {
+               count = nentries;
+       }
+       if ((count <= 0) || (count > nentries)) {
+               qprintf("Invalid count.  There are %d entries.\n", nentries);
+               return;
+       }
+
+       ktep = ktrace_first(xfs_attr_trace_buf, &kts);
+       if (count != nentries) {
+               /*
+                * Skip the total minus the number to look at minus one
+                * for the entry returned by ktrace_first().
+                */
+               skip_entries = nentries - count - 1;
+               ktep = ktrace_skip(xfs_attr_trace_buf, skip_entries, &kts);
+               if (ktep == NULL) {
+                       qprintf("Skipped them all\n");
+                       return;
+               }
+       }
+       while (ktep != NULL) {
+               xfs_attr_trace_entry(ktep);
+               ktep = ktrace_next(xfs_attr_trace_buf, &kts);
+       }
+}
+#endif
+
+/*
+ * Print xfs bmap internal record
+ */
+static void
+xfsidbg_xbirec(xfs_bmbt_irec_t *r)
+{
+       kdb_printf(
+       "startoff %Ld startblock %Lx blockcount %Ld state %Ld\n",
+               (__uint64_t)r->br_startoff,
+               (__uint64_t)r->br_startblock,
+               (__uint64_t)r->br_blockcount,
+               (__uint64_t)r->br_state);
+}
+
+#ifdef XFS_BLI_TRACE
+/*
+ * Print out the buf log item trace for the given buf log item.
+ */
+static void
+xfsidbg_xblitrace(xfs_buf_log_item_t *bip)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       uint64_t        flags;
+       static char *xbli_flags[] = {
+               "hold",         /* 0x01 */
+               "dirty",        /* 0x02 */
+               "stale",        /* 0x04 */
+               "logged",       /* 0x08 */
+               0
+               };
+       static char *xli_flags[] = {
+               "in ail",       /* 0x1 */
+               0
+               };
+
+       if (bip->bli_trace == NULL) {
+               qprintf("The bli trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(bip->bli_trace, &kts);
+       while (ktep != NULL) {
+               qprintf("%s bp 0x%p flags ",
+                       (char *)ktep->val[0], ktep->val[1]);
+               printflags((__psint_t)(ktep->val[2]), xbli_flags, "xbli");
+               qprintf("\n");
+               qprintf("recur %ld refcount %ld blkno 0x%lx bcount 0x%lx\n",
+                       (long)ktep->val[3], (long)ktep->val[4],
+                       (unsigned long)ktep->val[5],
+                       (unsigned long)ktep->val[6]);
+               flags = (((uint64_t)(unsigned long)ktep->val[7] << 32) &
+                                       0xFFFFFFFF00000000ULL) |
+                       (((uint64_t)(unsigned long)ktep->val[8]) &
+                                       0x00000000FFFFFFFFULL);
+               qprintf("bp flags ");
+               printflags(flags, pb_flag_vals, 0);
+               qprintf("\n");
+               qprintf("fspriv 0x%p fspriv2 0x%p pincount %ld iodone 0x%p\n",
+                       ktep->val[9], ktep->val[10],
+                       (long)ktep->val[11], ktep->val[12]);
+               qprintf("lockval %ld lid 0x%lx log item flags ",
+                       (long)ktep->val[13], (unsigned long)ktep->val[14]);
+               printflags((__psint_t)(ktep->val[15]), xli_flags, "xli");
+               qprintf("\n");
+
+               ktep = ktrace_next(bip->bli_trace, &kts);
+       }
+}
+#endif
+
+/*
+ * Print a bmap alloc argument structure for XFS.
+ */
+static void
+xfsidbg_xbmalla(xfs_bmalloca_t *a)
+{
+       kdb_printf("tp 0x%p ip 0x%p eof %d prevp 0x%p\n",
+               a->tp, a->ip, a->eof, a->prevp);
+       kdb_printf("gotp 0x%p firstblock %s alen %d total %d\n",
+               a->gotp, xfs_fmtfsblock(a->firstblock, a->ip->i_mount),
+               a->alen, a->total);
+       kdb_printf("off %s wasdel %d userdata %d minlen %d\n",
+               xfs_fmtfsblock(a->off, a->ip->i_mount), a->wasdel,
+               a->userdata, a->minlen);
+       kdb_printf("minleft %d low %d rval %s aeof %d\n",
+               a->minleft, a->low, xfs_fmtfsblock(a->rval, a->ip->i_mount),
+               a->aeof);
+}
+
+#ifdef XFS_BMAP_TRACE
+/*
+ * Print out the last "count" entries in the bmap btree trace buffer.
+ * The "a" is for "all" inodes.
+ */
+static void
+xfsidbg_xbmatrace(int count)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       int          nentries;
+       int          skip_entries;
+
+       if (xfs_bmbt_trace_buf == NULL) {
+               qprintf("The xfs bmap btree trace buffer is not initialized\n");                return;
+       }
+       nentries = ktrace_nentries(xfs_bmbt_trace_buf);
+       if (count == -1) {
+               count = nentries;
+       }
+       if ((count <= 0) || (count > nentries)) {
+               qprintf("Invalid count.  There are %d entries.\n", nentries);
+               return;
+       }
+
+       ktep = ktrace_first(xfs_bmbt_trace_buf, &kts);
+       if (count != nentries) {
+               /*
+                * Skip the total minus the number to look at minus one
+                * for the entry returned by ktrace_first().
+                */
+               skip_entries = nentries - count - 1;
+               ktep = ktrace_skip(xfs_bmbt_trace_buf, skip_entries, &kts);
+               if (ktep == NULL) {
+                       qprintf("Skipped them all\n");
+                       return;
+               }
+       }
+       while (ktep != NULL) {
+               if (xfs_bmbt_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(xfs_bmbt_trace_buf, &kts);
+       }
+}
+
 /*
- * Print xfs bmap internal record
+ * Print out the bmap btree trace buffer attached to the given inode.
  */
 static void
-xfsidbg_xbirec(xfs_bmbt_irec_t *r)
+xfsidbg_xbmitrace(xfs_inode_t *ip)
 {
-       kdb_printf(
-       "startoff %Ld startblock %Lx blockcount %Ld state %Ld\n",
-               (__uint64_t)r->br_startoff,
-               (__uint64_t)r->br_startblock,
-               (__uint64_t)r->br_blockcount,
-               (__uint64_t)r->br_state);
-}
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
 
+       if (ip->i_btrace == NULL) {
+               qprintf("The inode trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(ip->i_btrace, &kts);
+       while (ktep != NULL) {
+               if (xfs_bmbt_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(ip->i_btrace, &kts);
+       }
+}
 
 /*
- * Print a bmap alloc argument structure for XFS.
+ * Print out all the entries in the bmap btree trace buf corresponding
+ * to the given inode.  The "s" is for "single" inode.
  */
 static void
-xfsidbg_xbmalla(xfs_bmalloca_t *a)
+xfsidbg_xbmstrace(xfs_inode_t *ip)
 {
-       kdb_printf("tp 0x%p ip 0x%p eof %d prevp 0x%p\n",
-               a->tp, a->ip, a->eof, a->prevp);
-       kdb_printf("gotp 0x%p firstblock %s alen %d total %d\n",
-               a->gotp, xfs_fmtfsblock(a->firstblock, a->ip->i_mount),
-               a->alen, a->total);
-       kdb_printf("off %s wasdel %d userdata %d minlen %d\n",
-               xfs_fmtfsblock(a->off, a->ip->i_mount), a->wasdel,
-               a->userdata, a->minlen);
-       kdb_printf("minleft %d low %d rval %s aeof %d\n",
-               a->minleft, a->low, xfs_fmtfsblock(a->rval, a->ip->i_mount),
-               a->aeof);
-}
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
 
+       if (xfs_bmbt_trace_buf == NULL) {
+               qprintf("The xfs bmap btree trace buffer is not initialized\n");                return;
+       }
+
+       ktep = ktrace_first(xfs_bmbt_trace_buf, &kts);
+       while (ktep != NULL) {
+               if ((xfs_inode_t *)(ktep->val[2]) == ip) {
+                       if (xfs_bmbt_trace_entry(ktep))
+                               qprintf("\n");
+               }
+               ktep = ktrace_next(xfs_bmbt_trace_buf, &kts);
+       }
+}
+#endif
 
 /*
  * Print xfs bmap record
@@ -3667,6 +5335,286 @@
        }
 }
 
+#ifdef XFS_BMAP_TRACE
+/*
+ * Print out the last "count" entries in the bmap extent trace buffer.
+ * The "a" is for "all" inodes.
+ */
+static void
+xfsidbg_xbxatrace(int count)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       int          nentries;
+       int          skip_entries;
+
+       if (xfs_bmap_trace_buf == NULL) {
+               qprintf("The xfs bmap extent trace buffer is not initialized\n");
+               return;
+       }
+       nentries = ktrace_nentries(xfs_bmap_trace_buf);
+       if (count == -1) {
+               count = nentries;
+       }
+       if ((count <= 0) || (count > nentries)) {
+               qprintf("Invalid count.  There are %d entries.\n", nentries);
+               return;
+       }
+
+       ktep = ktrace_first(xfs_bmap_trace_buf, &kts);
+       if (count != nentries) {
+               /*
+                * Skip the total minus the number to look at minus one
+                * for the entry returned by ktrace_first().
+                */
+               skip_entries = nentries - count - 1;
+               ktep = ktrace_skip(xfs_bmap_trace_buf, skip_entries, &kts);
+               if (ktep == NULL) {
+                       qprintf("Skipped them all\n");
+                       return;
+               }
+       }
+       while (ktep != NULL) {
+               if (xfs_bmap_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(xfs_bmap_trace_buf, &kts);
+       }
+}
+
+/*
+ * Print out the bmap extent trace buffer attached to the given inode.
+ */
+static void
+xfsidbg_xbxitrace(xfs_inode_t *ip)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       if (ip->i_xtrace == NULL) {
+               qprintf("The inode trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(ip->i_xtrace, &kts);
+       while (ktep != NULL) {
+               if (xfs_bmap_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(ip->i_xtrace, &kts);
+       }
+}
+
+/*
+ * Print out all the entries in the bmap extent trace buf corresponding
+ * to the given inode.  The "s" is for "single" inode.
+ */
+static void
+xfsidbg_xbxstrace(xfs_inode_t *ip)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+
+       if (xfs_bmap_trace_buf == NULL) {
+               qprintf("The xfs bmap extent trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(xfs_bmap_trace_buf, &kts);
+       while (ktep != NULL) {
+               if ((xfs_inode_t *)(ktep->val[3]) == ip) {
+                       if (xfs_bmap_trace_entry(ktep))
+                               qprintf("\n");
+               }
+               ktep = ktrace_next(xfs_bmap_trace_buf, &kts);
+       }
+}
+#endif
+
+#ifdef XFS_ILOCK_TRACE
+/*
+ * Print out the ilock trace buffer attached to the given inode.
+ */
+static void
+xfsidbg_xilock_trace_entry(ktrace_entry_t *ktep)
+{
+       static char     *xiflags[] = {
+               "IOLOCK_EXCL",
+               "IOLOCK_SHAR",
+               "ILOCK_EXCL",
+               "ILOCK_SHAR",
+               "IUNLK_NONOT",
+               0
+       };
+
+       if ((__psint_t)ktep->val[0] &&
+            (__psint_t)ktep->val[7] == 0) {
+                printflags((__psint_t)ktep->val[2], xiflags,"Flags ");
+               if ((__psint_t)ktep->val[1] == 1)
+                        qprintf("LOCK\n");
+               else if ((__psint_t)ktep->val[1] == 2)
+                        qprintf("LOCK SHARED\n");
+               else if ((__psint_t)ktep->val[1] == 3)
+                        qprintf("UNLOCK\n");
+               qprintf("ip 0x%p %llx %ld\n",
+                       ktep->val[0],
+                       (unsigned long long)((xfs_inode_t*)ktep->val[0])->i_ino,
+                       (long)ktep->val[6]);
+               qprintf("raddr 0x%p\n", ktep->val[3]);
+               qprintf("  Pid %ld, cpu %ld\n",
+                        (long)ktep->val[5],
+                        (long)ktep->val[4]);
+               qprintf("-----------------------\n");
+
+       } else if ((__psint_t)ktep->val[7] == 1) {
+               if ((__psint_t)ktep->val[1] == 1)
+                       qprintf("FlushLOCK ");
+               else if ((__psint_t)ktep->val[1] == 2)
+                       qprintf("FlushTRYLOCK %ld ",
+                               (long)ktep->val[2]);
+               else if ((__psint_t)ktep->val[1] == 3)
+                       qprintf("FlushUNLOCK ");
+               else if ((__psint_t)ktep->val[1] == 4)
+                       qprintf("FlushInode 0x%p",
+                               ktep->val[2]);
+               else if ((__psint_t)ktep->val[1] == 5)
+                       qprintf("FlushInodeInt ");
+               else     qprintf("FlushUNKNOWN ");
+               qprintf("ip 0x%p ino %llx @ %ld\n",
+                       ktep->val[0],
+                       (unsigned long long)((xfs_inode_t*)ktep->val[0])->i_ino,
+                       (long)ktep->val[6]);
+               qprintf("raddr 0x%p\n", ktep->val[3]);
+               qprintf("  Pid %ld, cpu %ld\n",
+                       (long)ktep->val[5],
+                       (long)ktep->val[4]);
+               qprintf("-----------------------\n");
+       }
+}
+
+static void
+xfsidbg_xilock_trace(xfs_inode_t *ip)
+{
+       static char *xiflags[] = {
+               "IOLOCK_EXCL",
+               "IOLOCK_SHAR",
+               "ILOCK_EXCL",
+               "ILOCK_SHAR",
+               "IUNLK_NONOT",
+               0
+       };
+
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       if (ip->i_lock_trace == NULL) {
+               qprintf("The inode ilock trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(ip->i_lock_trace, &kts);
+       while (ktep != NULL) {
+                if ((__psint_t)ktep->val[0] &&
+                    (__psint_t)ktep->val[7] == 0) {
+                        printflags((__psint_t)ktep->val[2], xiflags,"Flags ");
+                        if ((__psint_t)ktep->val[1] == 1)
+                                qprintf("LOCK\n");
+                        else if ((__psint_t)ktep->val[1] == 2)
+                                qprintf("LOCK SHARED\n");
+                        else if ((__psint_t)ktep->val[1] == 3)
+                                qprintf("UNLOCK\n");
+                       qprintf("ip 0x%p %lld %ld\n",
+                               ktep->val[0], (unsigned long long)
+                               ((xfs_inode_t*)ktep->val[0])->i_ino,
+                               (long)ktep->val[6]);
+                        qprintf("raddr 0x%p\n", ktep->val[3]);
+                        qprintf("  Pid %ld, cpu %ld\n",
+                                (long)ktep->val[5],
+                                (long)ktep->val[4]);
+                        qprintf("-----------------------\n");
+                } else if ((__psint_t)ktep->val[7] == 1) {
+                       if ((__psint_t)ktep->val[1] == 1)
+                               qprintf("LOCK ");
+                       else if ((__psint_t)ktep->val[1] == 2)
+                               qprintf("TRYLOCK %ld ",
+                                       (long)ktep->val[2]);
+                       else if ((__psint_t)ktep->val[1] == 3)
+                               qprintf("UNLOCK ");
+                       else     qprintf("UNKNOWN ");
+                       qprintf("ip 0x%p %lld %ld\n",
+                               ktep->val[0], (unsigned long long)
+                               ((xfs_inode_t*)ktep->val[0])->i_ino,
+                               (long)ktep->val[6]);
+                       qprintf("raddr 0x%p\n", ktep->val[3]);
+                       qprintf("  Pid %ld, cpu %ld\n",
+                               (long)ktep->val[5],
+                               (long)ktep->val[4]);
+                       qprintf("-----------------------\n");
+                }
+
+                ktep = ktrace_next(ip->i_lock_trace, &kts);
+       }
+}
+
+/*
+ * Print out the last "count" entries in the inode lock trace buffer.
+ * The "a" is for "all" entries.
+ */
+static void
+xfsidbg_xailock_trace(int count)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       int          nentries;
+       int          skip_entries;
+
+       if (xfs_ilock_trace_buf == NULL) {
+               qprintf("The xfs inode lock trace buffer is not initialized\n");                return;
+       }
+       nentries = ktrace_nentries(xfs_ilock_trace_buf);
+       if (count == -1) {
+               count = nentries;
+       }
+       if ((count <= 0) || (count > nentries)) {
+               qprintf("Invalid count.  There are %d entries.\n", nentries);
+               return;
+       }
+
+       ktep = ktrace_first(xfs_ilock_trace_buf, &kts);
+       if (count != nentries) {
+               /*
+                * Skip the total minus the number to look at minus one
+                * for the entry returned by ktrace_first().
+                */
+               skip_entries = nentries - count - 1;
+               ktep = ktrace_skip(xfs_ilock_trace_buf, skip_entries, &kts);
+               if (ktep == NULL) {
+                       qprintf("Skipped them all\n");
+                       return;
+               }
+       }
+       while (ktep != NULL) {
+               xfsidbg_xilock_trace_entry(ktep);
+               ktep = ktrace_next(xfs_ilock_trace_buf, &kts);
+       }
+}
+#endif
+
+/*
+ * Compute & print buffer's checksum.
+ */
+static void
+xfsidbg_xchksum(uint *addr)
+{
+       uint i, chksum = 0;
+
+       if (((__psint_t)addr) == ((__psint_t)-1)) {
+               qprintf("USAGE xchksum <address>\n");
+               qprintf("       length is set with xarg\n");
+       } else {
+               for (i=0; i<xargument; i++) {
+                       chksum ^= *addr;
+                       addr++;
+               }
+               qprintf("chksum (0x%x)  length (%d)\n", chksum, xargument);
+       }
+}       /* xfsidbg_xchksum */
 
 /*
  * Print an xfs_da_args structure.
@@ -3740,9 +5688,8 @@
                kdb_printf(" %d:0x%p", i, dabuf->bps[i]);
        kdb_printf("\n");
 #ifdef XFS_DABUF_DEBUG
-       kdb_printf(" ra 0x%x prev 0x%x next 0x%x dev %s blkno 0x%x\n",
-               dabuf->ra, dabuf->prev, dabuf->next,
-               XFS_BUFTARG_NAME(dabuf->dev), dabuf->blkno);
+       kdb_printf(" ra 0x%x prev 0x%x next 0x%x dev 0x%x blkno 0x%x\n",
+               dabuf->ra, dabuf->prev, dabuf->next, dabuf->dev, dabuf->blkno);
 #endif
 }
 
@@ -4012,6 +5959,119 @@
        }
 }
 
+#ifdef XFS_DIR_TRACE
+/*
+ * Print out the last "count" entries in the directory trace buffer.
+ */
+static void
+xfsidbg_xdirtrace(int count)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       int          nentries;
+       int          skip_entries;
+
+       if (xfs_dir_trace_buf == NULL) {
+               qprintf("The xfs directory trace buffer is not initialized\n");
+               return;
+       }
+       nentries = ktrace_nentries(xfs_dir_trace_buf);
+       if (count == -1) {
+               count = nentries;
+       }
+       if ((count <= 0) || (count > nentries)) {
+               qprintf("Invalid count.  There are %d entries.\n", nentries);
+               return;
+       }
+
+       ktep = ktrace_first(xfs_dir_trace_buf, &kts);
+       if (count != nentries) {
+               /*
+                * Skip the total minus the number to look at minus one
+                * for the entry returned by ktrace_first().
+                */
+               skip_entries = nentries - count - 1;
+               ktep = ktrace_skip(xfs_dir_trace_buf, skip_entries, &kts);
+               if (ktep == NULL) {
+                       qprintf("Skipped them all\n");
+                       return;
+               }
+       }
+       while (ktep != NULL) {
+               if (xfs_dir_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(xfs_dir_trace_buf, &kts);
+       }
+}
+#endif
+
+#ifdef XFS_DIR2_TRACE
+/*
+ * Print out the last "count" entries in the directory v2 trace buffer.
+ */
+static void
+xfsidbg_xdir2atrace(int count)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       int          nentries;
+       int          skip_entries;
+
+       if (xfs_dir2_trace_buf == NULL) {
+               qprintf("The xfs dirv2 trace buffer is not initialized\n");
+               return;
+       }
+       nentries = ktrace_nentries(xfs_dir2_trace_buf);
+       if (count == -1) {
+               count = nentries;
+       }
+       if ((count <= 0) || (count > nentries)) {
+               qprintf("Invalid count.  There are %d entries.\n", nentries);
+               return;
+       }
+
+       ktep = ktrace_first(xfs_dir2_trace_buf, &kts);
+       if (count != nentries) {
+               /*
+                * Skip the total minus the number to look at minus one
+                * for the entry returned by ktrace_first().
+                */
+               skip_entries = nentries - count - 1;
+               ktep = ktrace_skip(xfs_dir2_trace_buf, skip_entries, &kts);
+               if (ktep == NULL) {
+                       qprintf("Skipped them all\n");
+                       return;
+               }
+       }
+       while (ktep != NULL) {
+               if (xfs_dir2_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(xfs_dir2_trace_buf, &kts);
+       }
+}
+
+/*
+ * Print out the directory v2 trace buffer attached to the given inode.
+ */
+static void
+xfsidbg_xdir2itrace(xfs_inode_t *ip)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+
+       if (ip->i_dir_trace == NULL) {
+               qprintf("The inode trace buffer is not initialized\n");
+               return;
+       }
+
+       ktep = ktrace_first(ip->i_dir_trace, &kts);
+       while (ktep != NULL) {
+               if (xfs_dir2_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(ip->i_dir_trace, &kts);
+       }
+}
+#endif
 
 /*
  * Print xfs extent list.
@@ -4095,13 +6155,18 @@
        kdb_printf("log: 0x%p  callb: 0x%p  callb_tail: 0x%p  roundoff: %d\n",
                iclog->ic_log, iclog->ic_callback, iclog->ic_callback_tail,
                iclog->ic_roundoff);
-       kdb_printf("size: %d (OFFSET: %d) refcnt: %d  bwritecnt: %d",
+       kdb_printf("size: %d (OFFSET: %d) trace: 0x%p refcnt: %d bwritecnt: %d",
                iclog->ic_size, iclog->ic_offset,
+#ifdef XFS_LOG_TRACE
+               iclog->ic_trace,
+#else
+               NULL,
+#endif
                iclog->ic_refcnt, iclog->ic_bwritecnt);
        if (iclog->ic_state & XLOG_STATE_ALL)
-               printflags(iclog->ic_state, ic_flags, "state:");
+               printflags(iclog->ic_state, ic_flags, " state:");
        else
-               kdb_printf("state: INVALID 0x%x", iclog->ic_state);
+               kdb_printf(" state: INVALID 0x%x", iclog->ic_state);
        kdb_printf("\n");
 }      /* xfsidbg_xiclog */
 
@@ -4150,6 +6215,44 @@
        }
 }
 
+#ifdef XFS_LOG_TRACE
+/*
+ * Print trace from incore log.
+ */
+static void
+xfsidbg_xiclogtrace(xlog_in_core_t *iclog)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       ktrace_t        *kt = iclog->ic_trace;
+
+       qprintf("iclog->ic_trace 0x%p\n", kt);
+       ktep = ktrace_first(kt, &kts);
+       while (ktep != NULL) {
+               switch ((__psint_t)ktep->val[0]) {
+                   case XLOG_TRACE_GRAB_FLUSH: {
+                           qprintf("grabbing semaphore\n");
+                           break;
+                   }
+                   case XLOG_TRACE_REL_FLUSH: {
+                           qprintf("releasing semaphore\n");
+                           break;
+                   }
+                   case XLOG_TRACE_SLEEP_FLUSH: {
+                           qprintf("sleeping on semaphore\n");
+                           break;
+                   }
+                   case XLOG_TRACE_WAKE_FLUSH: {
+                           qprintf("waking up on semaphore\n");
+                           break;
+                   }
+                   default: {
+                   }
+               }
+               ktep = ktrace_next(kt, &kts);
+       }
+}       /* xfsidbg_xiclogtrace */
+#endif
 
 /*
  * Print all of the inodes attached to the given mount structure.
@@ -4270,8 +6373,8 @@
                        xfsidbg_get_cstate(log->l_covered_state));
        kdb_printf("flags: ");
        printflags(log->l_flags, t_flags,"log");
-       kdb_printf("  dev: %s logBBstart: %lld logsize: %d logBBsize: %d\n",
-               XFS_BUFTARG_NAME(log->l_targ), (long long) log->l_logBBstart,
+       kdb_printf("  logBBstart: %lld logsize: %d logBBsize: %d\n",
+               (long long) log->l_logBBstart,
                log->l_logsize,log->l_logBBsize);
        kdb_printf("curr_cycle: %d  prev_cycle: %d  curr_block: %d  prev_block: %d\n",
             log->l_curr_cycle, log->l_prev_cycle, log->l_curr_block,
@@ -4290,11 +6393,50 @@
                log->l_grant_write_cycle, log->l_grant_write_bytes);
        rbytes = log->l_grant_reserve_bytes + log->l_roundoff;
        wbytes = log->l_grant_write_bytes + log->l_roundoff;
-       kdb_printf("GResBlocks: %d  GResRemain: %d  GWrBlocks: %d  GWrRemain: %d\n",
+       qprintf("GResBlocks: %d GResRemain: %d  GWrBlocks: %d GWrRemain: %d\n",
               rbytes / BBSIZE, rbytes % BBSIZE,
               wbytes / BBSIZE, wbytes % BBSIZE);
+#ifdef XFS_LOG_TRACE
+       qprintf("trace: 0x%p  grant_trace: use xlog value\n", log->l_trace);
+#endif
 }      /* xfsidbg_xlog */
 
+#ifdef XFS_LOG_TRACE
+/*
+ * Print grant trace for a log.
+ */
+static void
+xfsidbg_xlog_granttrace(xlog_t *log)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       ktrace_t        *kt;
+
+       if (((__psint_t)log) == ((__psint_t)-1)) {
+               qprintf("Usage: xl_grtr <log>\n");
+               return;
+       }
+       if ((kt = log->l_grant_trace))
+               qprintf("log->l_grant_trace 0x%p\n", kt);
+       else {
+               qprintf("log->l_grant_trace is empty!\n");
+               return;
+       }
+       ktep = ktrace_first(kt, &kts);
+       while (ktep != NULL) {
+               qprintf("%s\n", (char *)ktep->val[11]);
+               qprintf("  tic:0x%p resQ:0x%p wrQ:0x%p ",
+                       ktep->val[0], ktep->val[1], ktep->val[2]);
+               qprintf("  GrResC:%ld GrResB:%ld GrWrC:%ld GrWrB:%ld \n",
+                       (long)ktep->val[3], (long)ktep->val[4],
+                       (long)ktep->val[5], (long)ktep->val[6]);
+               qprintf("  HeadC:%ld HeadB:%ld TailC:%ld TailB:%ld\n",
+                       (long)ktep->val[7], (long)ktep->val[8],
+                       (long)ktep->val[9], (long)ktep->val[10]);
+               ktep = ktrace_next(kt, &kts);
+       }
+}       /* xfsidbg_xlog_granttrace */
+#endif
 
 /*
  * Print out an XFS recovery transaction
@@ -4488,10 +6630,10 @@
                lip->li_mountp);
        printflags((uint)(lip->li_flags), li_flags,"log");
        kdb_printf("\n");
-       kdb_printf("ail forw 0x%p ail back 0x%p lsn %s desc %p ops 0x%p\n",
+       kdb_printf("ail forw 0x%p ail back 0x%p lsn %s\ndesc %p ops 0x%p",
                lip->li_ail.ail_forw, lip->li_ail.ail_back,
                xfs_fmtlsn(&(lip->li_lsn)), lip->li_desc, lip->li_ops);
-       kdb_printf("iodonefunc &0x%p\n", lip->li_cb);
+       kdb_printf(" iodonefunc &0x%p\n", lip->li_cb);
        if (lip->li_type == XFS_LI_BUF) {
                bio_lip = lip->li_bio_list;
                if (bio_lip != NULL) {
@@ -4547,7 +6689,7 @@
                "6-1-buf",      /* 7 */
                "inode",        /* 8 */
                "buf",          /* 9 */
-               "dquot",        /* 10 */
+               "dquot",        /* 10 */
                0
                };
        static char *li_flags[] = {
@@ -4609,7 +6751,7 @@
        static char *xmount_flags[] = {
                "WSYNC",        /* 0x0001 */
                "INO64",        /* 0x0002 */
-               "RQCHK",        /* 0x0004 */
+               "RQCHK",        /* 0x0004 */
                "FSCLEAN",      /* 0x0008 */
                "FSSHUTDN",     /* 0x0010 */
                "NOATIME",      /* 0x0020 */
@@ -4646,14 +6788,11 @@
                XFS_MTOVFS(mp), mp->m_tid, &mp->m_ail_lock, &mp->m_ail);
        kdb_printf("ail_gen 0x%x &sb 0x%p\n",
                mp->m_ail_gen, &mp->m_sb);
-       kdb_printf("sb_lock 0x%p sb_bp 0x%p dev %s logdev %s rtdev %s\n",
+       kdb_printf("sb_lock 0x%p sb_bp 0x%p dev 0x%x logdev 0x%x rtdev 0x%x\n",
                &mp->m_sb_lock, mp->m_sb_bp,
-               mp->m_ddev_targp ?
-                       XFS_BUFTARG_NAME(mp->m_ddev_targp) : "none",
-               mp->m_logdev_targp ?
-                       XFS_BUFTARG_NAME(mp->m_logdev_targp) : "none",
-               mp->m_rtdev_targp ?
-                       XFS_BUFTARG_NAME(mp->m_rtdev_targp) : "none");
+               mp->m_ddev_targp ? mp->m_ddev_targp->pbr_dev : 0,
+               mp->m_logdev_targp ? mp->m_logdev_targp->pbr_dev : 0,
+               mp->m_rtdev_targp ? mp->m_rtdev_targp->pbr_dev : 0);
        kdb_printf("bsize %d agfrotor %d agirotor %d ihash 0x%p ihsize %d\n",
                mp->m_bsize, mp->m_agfrotor, mp->m_agirotor,
                mp->m_ihash, mp->m_ihsize);
@@ -4825,8 +6964,8 @@
                ip->i_mnext,
                ip->i_mprev,
                XFS_ITOV_NULL(ip));
-       kdb_printf("dev %s ino %s\n",
-               XFS_BUFTARG_NAME(ip->i_mount->m_ddev_targp),
+       kdb_printf("dev %x ino %s\n",
+               ip->i_mount->m_dev,
                xfs_fmtino(ip->i_ino, ip->i_mount));
        kdb_printf("blkno 0x%llx len 0x%x boffset 0x%x\n",
                (long long) ip->i_blkno,
@@ -4835,7 +6974,7 @@
        kdb_printf("transp 0x%p &itemp 0x%p\n",
                ip->i_transp,
                ip->i_itemp);
-       kdb_printf("&lock 0x%p &iolock 0x%p",
+       kdb_printf("&lock 0x%p &iolock 0x%p ",
                &ip->i_lock,
                &ip->i_iolock);
        kdb_printf("&flock 0x%p (%d) pincount 0x%x\n",
@@ -4843,14 +6982,29 @@
                xfs_ipincount(ip));
        kdb_printf("udquotp 0x%p gdquotp 0x%p\n",
                ip->i_udquot, ip->i_gdquot);
-       kdb_printf("new_size %Lx\n", ip->i_iocore.io_new_size);
+       kdb_printf("new_size %Ld\n", ip->i_iocore.io_new_size);
        printflags((int)ip->i_flags, tab_flags, "flags");
        kdb_printf("\n");
-       kdb_printf("update_core 0x%x update size 0x%x\n",
+       kdb_printf("update_core %d update size %d\n",
                (int)(ip->i_update_core), (int) ip->i_update_size);
        kdb_printf("gen 0x%x delayed blks %d",
                ip->i_gen,
                ip->i_delayed_blks);
+#ifdef XFS_BMAP_TRACE
+       qprintf(" bmap_trace 0x%p\n", ip->i_xtrace);
+#endif
+#ifdef XFS_BMBT_TRACE
+       qprintf(" bmbt trace 0x%p\n", ip->i_btrace);
+#endif  
+#ifdef XFS_RW_TRACE
+       qprintf(" rw trace 0x%p\n", ip->i_rwtrace);
+#endif  
+#ifdef XFS_ILOCK_TRACE
+       qprintf(" ilock trace 0x%p\n", ip->i_lock_trace);
+#endif
+#ifdef XFS_DIR2_TRACE
+       qprintf(" dir trace 0x%p\n", ip->i_dir_trace);
+#endif  
        kdb_printf("\n");
        kdb_printf("chash 0x%p cnext 0x%p cprev 0x%p\n",
                ip->i_chash,
@@ -5032,6 +7186,9 @@
                &dqp->q_flock,
                (valusema(&dqp->q_flock) <= 0) ? "LCK" : "UNLKD",
                dqp->q_pincount);
+#ifdef XFS_DQUOT_TRACE
+       qprintf("dqtrace 0x%p\n", dqp->q_trace);
+#endif
        kdb_printf("disk-dquot 0x%p\n", &dqp->q_core);
        xfsidbg_xqm_diskdq(&dqp->q_core);
 
@@ -5076,7 +7233,7 @@
        kdb_printf("\nNumber of inodes with dquots attached: %d\n", n);
 }
 
-#ifdef CONFIG_XFS_QUOTA
+#ifdef CONFIG_XFS_QUOTA
 static void
 xfsidbg_xqm_freelist_print(xfs_frlist_t *qlist, char *title)
 {
@@ -5130,6 +7287,80 @@
 }
 #endif
 
+#ifdef XFS_DQUOT_TRACE
+static int
+xfsidbg_xqm_pr_dqentry(ktrace_entry_t *ktep)
+{
+       static char *xdq_flags[] = {
+               "USR",    /* 0x1 */
+               "PRJ",    /* 0x2 */
+               "LCKD",  /* 0x4 */
+               "GRP",    /* 0x8 */
+               "FLOCKD",       /* 0x08 */
+               "DIRTY",        /* 0x10 */
+               "WANT",  /* 0x20 */
+               "INACT",        /* 0x40 */
+               "MARKER",       /* 0x80 */
+               0
+       };
+
+       if ((__psint_t)ktep->val[0] == 0)
+               return 0;
+       switch ((__psint_t)ktep->val[0]) {
+             case DQUOT_KTRACE_ENTRY:
+               qprintf("[%ld] %s\t",
+                       (long)ktep->val[12], /* pid */
+                       (char *)ktep->val[1]);
+               printflags((__psint_t)ktep->val[3], xdq_flags,"flgs ");
+               qprintf("\nnrefs = %u, "
+                       "flags = 0x%x, "
+                       "id = %d, "
+                       "res_bc = 0x%x\n"
+                       "bcnt = 0x%x [0x%x | 0x%x], "
+                       "icnt = 0x%x [0x%x | 0x%x]\n"
+                       "@ %ld\n",
+                       (unsigned int)(long)ktep->val[2], /* nrefs */
+                       (unsigned int)(long)ktep->val[3], /* flags */
+                       (unsigned int)(long)ktep->val[11], /* ID */
+                       (unsigned int)(long)ktep->val[4], /* res_bc */
+                       (unsigned int)(long)ktep->val[5], /* bcnt */
+                       (unsigned int)(long)ktep->val[8], /* bsoft */
+                       (unsigned int)(long)ktep->val[7], /* bhard */
+                       (unsigned int)(long)ktep->val[6], /* icnt */
+                       (unsigned int)(long)ktep->val[10], /* isoft */
+                       (unsigned int)(long)ktep->val[9], /* ihard */
+                       (long) ktep->val[13] /* time */
+                       );
+               break;
+
+             default:
+               qprintf("unknown dqtrace record\n");
+               break;
+       }
+       return (1);
+}
+
+void
+xfsidbg_xqm_dqtrace(xfs_dquot_t *dqp)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+
+       if (dqp->q_trace == NULL) {
+               qprintf("The xfs dquot trace buffer is not initialized\n");
+               return;
+       }
+       qprintf("xdqtrace dquot 0x%p\n", dqp);
+
+       ktep = ktrace_first(dqp->q_trace, &kts);
+       while (ktep != NULL) {
+               if (xfsidbg_xqm_pr_dqentry(ktep))
+                       qprintf("---------------------------------\n");
+               ktep = ktrace_next(dqp->q_trace, &kts);
+       }
+}
+#endif
+
 static void
 xfsidbg_xqm_mplist(xfs_mount_t *mp)
 {
@@ -5206,7 +7437,54 @@
 
 }
 
+#ifdef XFS_RW_TRACE
+/*
+ * Print out the read/write trace buffer attached to the given inode.
+ */
+static void
+xfsidbg_xrwtrace(xfs_inode_t *ip)
+{
+       ktrace_entry_t  *ktep;
+       ktrace_snap_t   kts;
+       int             nentries;
+       int             skip_entries;
+       int             count = xargument;
+
+       if (ip->i_rwtrace == NULL) {
+               qprintf("The inode trace buffer is not initialized\n");
+               return;
+       }
+       qprintf("i_rwtrace = 0x%p\n", ip->i_rwtrace);
+
+       nentries = ktrace_nentries(ip->i_rwtrace);
+       if (count == -1) {
+               count = nentries;
+       }
+       if ((count <= 0) || (count > nentries)) {
+               qprintf("Invalid count.  There are %d entries.\n", nentries);
+               return;
+       }
 
+       ktep = ktrace_first(ip->i_rwtrace, &kts);
+       if (count != nentries) {
+               /*
+                * Skip the total minus the number to look at minus one
+                * for the entry returned by ktrace_first().
+                */
+               skip_entries = count - nentries - 1;
+               ktep = ktrace_skip(ip->i_rwtrace, skip_entries, &kts);
+               if (ktep == NULL) {
+                       qprintf("Skipped them all\n");
+                       return;
+               }
+       }
+       while (ktep != NULL) {
+               if (xfs_rw_trace_entry(ktep))
+                       qprintf("\n");
+               ktep = ktrace_next(ip->i_rwtrace, &kts);
+       }
+}
+#endif
 
 /*
  * Print xfs superblock.
@@ -5284,7 +7562,7 @@
                "dirty",        /* 0x1 */
                "sb_dirty",     /* 0x2 */
                "perm_log_res", /* 0x4 */
-               "sync",         /* 0x08 */
+               "sync",          /* 0x08 */
                "dq_dirty",     /* 0x10 */
                0
                };
@@ -5298,7 +7576,7 @@
 
        kdb_printf("tp 0x%p type ", tp);
        switch (tp->t_type) {
-       case XFS_TRANS_SETATTR_NOT_SIZE: kdb_printf("SETATTR_NOT_SIZE");        break;
+       case XFS_TRANS_SETATTR_NOT_SIZE: kdb_printf("SETATTR_NOT_SIZE");break;
        case XFS_TRANS_SETATTR_SIZE:    kdb_printf("SETATTR_SIZE");     break;
        case XFS_TRANS_INACTIVE:        kdb_printf("INACTIVE");         break;
        case XFS_TRANS_CREATE:          kdb_printf("CREATE");           break;
@@ -5310,32 +7588,31 @@
        case XFS_TRANS_MKDIR:           kdb_printf("MKDIR");            break;
        case XFS_TRANS_RMDIR:           kdb_printf("RMDIR");            break;
        case XFS_TRANS_SYMLINK:         kdb_printf("SYMLINK");          break;
-       case XFS_TRANS_SET_DMATTRS:     kdb_printf("SET_DMATTRS");              break;
+       case XFS_TRANS_SET_DMATTRS:     kdb_printf("SET_DMATTRS");      break;
        case XFS_TRANS_GROWFS:          kdb_printf("GROWFS");           break;
-       case XFS_TRANS_STRAT_WRITE:     kdb_printf("STRAT_WRITE");              break;
+       case XFS_TRANS_STRAT_WRITE:     kdb_printf("STRAT_WRITE");      break;
        case XFS_TRANS_DIOSTRAT:        kdb_printf("DIOSTRAT");         break;
-       case XFS_TRANS_WRITE_SYNC:      kdb_printf("WRITE_SYNC");               break;
+       case XFS_TRANS_WRITE_SYNC:      kdb_printf("WRITE_SYNC");       break;
        case XFS_TRANS_WRITEID:         kdb_printf("WRITEID");          break;
        case XFS_TRANS_ADDAFORK:        kdb_printf("ADDAFORK");         break;
-       case XFS_TRANS_ATTRINVAL:       kdb_printf("ATTRINVAL");                break;
-       case XFS_TRANS_ATRUNCATE:       kdb_printf("ATRUNCATE");                break;
+       case XFS_TRANS_ATTRINVAL:       kdb_printf("ATTRINVAL");        break;
+       case XFS_TRANS_ATRUNCATE:       kdb_printf("ATRUNCATE");        break;
        case XFS_TRANS_ATTR_SET:        kdb_printf("ATTR_SET");         break;
        case XFS_TRANS_ATTR_RM:         kdb_printf("ATTR_RM");          break;
-       case XFS_TRANS_ATTR_FLAG:       kdb_printf("ATTR_FLAG");                break;
-       case XFS_TRANS_CLEAR_AGI_BUCKET:  kdb_printf("CLEAR_AGI_BUCKET");       break;
+       case XFS_TRANS_ATTR_FLAG:       kdb_printf("ATTR_FLAG");        break;
+       case XFS_TRANS_CLEAR_AGI_BUCKET:kdb_printf("CLEAR_AGI_BUCKET"); break;
        case XFS_TRANS_QM_SBCHANGE:     kdb_printf("QM_SBCHANGE");      break;
        case XFS_TRANS_QM_QUOTAOFF:     kdb_printf("QM_QUOTAOFF");      break;
-       case XFS_TRANS_QM_DQALLOC:      kdb_printf("QM_DQALLOC");               break;
-       case XFS_TRANS_QM_SETQLIM:      kdb_printf("QM_SETQLIM");               break;
+       case XFS_TRANS_QM_DQALLOC:      kdb_printf("QM_DQALLOC");       break;
+       case XFS_TRANS_QM_SETQLIM:      kdb_printf("QM_SETQLIM");       break;
        case XFS_TRANS_QM_DQCLUSTER:    kdb_printf("QM_DQCLUSTER");     break;
        case XFS_TRANS_QM_QINOCREATE:   kdb_printf("QM_QINOCREATE");    break;
-       case XFS_TRANS_QM_QUOTAOFF_END: kdb_printf("QM_QOFF_END");              break;
+       case XFS_TRANS_QM_QUOTAOFF_END: kdb_printf("QM_QOFF_END");      break;
        case XFS_TRANS_SB_UNIT:         kdb_printf("SB_UNIT");          break;
        case XFS_TRANS_FSYNC_TS:        kdb_printf("FSYNC_TS");         break;
        case XFS_TRANS_GROWFSRT_ALLOC:  kdb_printf("GROWFSRT_ALLOC");   break;
        case XFS_TRANS_GROWFSRT_ZERO:   kdb_printf("GROWFSRT_ZERO");    break;
        case XFS_TRANS_GROWFSRT_FREE:   kdb_printf("GROWFSRT_FREE");    break;
-
        default:                        kdb_printf("0x%x", tp->t_type); break;
        }
        kdb_printf(" mount 0x%p\n", tp->t_mountp);
diff -urN linux.org/fs/xfs/xfs_iget.c linux/fs/xfs/xfs_iget.c
--- linux.org/fs/xfs/xfs_iget.c 2003-12-31 05:48:38.000000000 +0100
+++ linux/fs/xfs/xfs_iget.c     2004-01-02 04:21:44.000000000 +0100
@@ -445,18 +445,17 @@
 retry:
        XFS_STATS_INC(xs_ig_attempts);
 
-       if ((inode = iget_locked(XFS_MTOVFS(mp)->vfs_super, ino))) {
+       if ((inode = VFS_GET_INODE(XFS_MTOVFS(mp), ino, 0))) {
                bhv_desc_t      *bdp;
                xfs_inode_t     *ip;
                int             newnode;
 
-
                vp = LINVFS_GET_VP(inode);
                if (inode->i_state & I_NEW) {
 inode_allocate:
                        vn_initialize(inode);
                        error = xfs_iget_core(vp, mp, tp, ino,
-                                                       lock_flags, ipp, bno);
+                                               lock_flags, ipp, bno);
                        if (error) {
                                make_bad_inode(inode);
                                if (inode->i_state & I_NEW)
@@ -506,9 +505,6 @@
        mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
                     "xfsino", (long)vp->v_number);
        mrlock_init(&ip->i_iolock, MRLOCK_BARRIER, "xfsio", vp->v_number);
-#ifdef NOTYET
-       mutex_init(&ip->i_range_lock.r_spinlock, MUTEX_SPIN, "xrange");
-#endif /* NOTYET */
        init_waitqueue_head(&ip->i_ipin_wait);
        atomic_set(&ip->i_pincount, 0);
        init_sema(&ip->i_flock, 1, "xfsfino", vp->v_number);
@@ -830,9 +826,7 @@
        } else if (lock_flags & XFS_ILOCK_SHARED) {
                mraccess(&ip->i_lock);
        }
-#ifdef XFS_ILOCK_TRACE
-       xfs_ilock_trace(ip, 1, lock_flags, (inst_t *)return_address);
-#endif
+       xfs_ilock_trace(ip, 1, lock_flags, (inst_t *)__return_address);
 }
 
 /*
@@ -895,9 +889,7 @@
                        return 0;
                }
        }
-#ifdef XFS_ILOCK_TRACE
        xfs_ilock_trace(ip, 2, lock_flags, (inst_t *)__return_address);
-#endif
        return 1;
 }
 
@@ -955,9 +947,7 @@
                                                (xfs_log_item_t*)(ip->i_itemp));
                }
        }
-#ifdef XFS_ILOCK_TRACE
        xfs_ilock_trace(ip, 3, lock_flags, (inst_t *)__return_address);
-#endif
 }
 
 /*
diff -urN linux.org/fs/xfs/xfs_inode.c linux/fs/xfs/xfs_inode.c
--- linux.org/fs/xfs/xfs_inode.c        2003-12-31 05:48:38.000000000 +0100
+++ linux/fs/xfs/xfs_inode.c    2004-01-02 04:21:44.000000000 +0100
@@ -908,9 +908,6 @@
 #ifdef XFS_RW_TRACE
        ip->i_rwtrace = ktrace_alloc(XFS_RW_KTRACE_SIZE, KM_SLEEP);
 #endif
-#ifdef XFS_STRAT_TRACE
-       ip->i_strat_trace = ktrace_alloc(XFS_STRAT_KTRACE_SIZE, KM_SLEEP);
-#endif
 #ifdef XFS_ILOCK_TRACE
        ip->i_lock_trace = ktrace_alloc(XFS_ILOCK_KTRACE_SIZE, KM_SLEEP);
 #endif
@@ -1144,8 +1141,8 @@
        ip->i_d.di_onlink = 0;
        ip->i_d.di_nlink = nlink;
        ASSERT(ip->i_d.di_nlink == nlink);
-       ip->i_d.di_uid = current->fsuid;
-       ip->i_d.di_gid = current->fsgid;
+       ip->i_d.di_uid = current_fsuid(cr);
+       ip->i_d.di_gid = current_fsgid(cr);
        ip->i_d.di_projid = prid;
        memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
 
@@ -1362,16 +1359,16 @@
        ktrace_enter(ip->i_rwtrace,
                     (void*)((long)tag),
                     (void*)ip,
-                    (void*)((ip->i_d.di_size >> 32) & 0xffffffff),
-                    (void*)(ip->i_d.di_size & 0xffffffff),
+                    (void*)(unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff),
+                    (void*)(unsigned long)(ip->i_d.di_size & 0xffffffff),
                     (void*)((long)flag),
-                    (void*)((new_size >> 32) & 0xffffffff),
-                    (void*)(new_size & 0xffffffff),
-                    (void*)((toss_start >> 32) & 0xffffffff),
-                    (void*)(toss_start & 0xffffffff),
-                    (void*)((toss_finish >> 32) & 0xffffffff),
-                    (void*)(toss_finish & 0xffffffff),
-                    (void*)((long)private.p_cpuid),
+                    (void*)(unsigned long)((new_size >> 32) & 0xffffffff),
+                    (void*)(unsigned long)(new_size & 0xffffffff),
+                    (void*)(unsigned long)((toss_start >> 32) & 0xffffffff),
+                    (void*)(unsigned long)(toss_start & 0xffffffff),
+                    (void*)(unsigned long)((toss_finish >> 32) & 0xffffffff),
+                    (void*)(unsigned long)(toss_finish & 0xffffffff),
+                    (void*)(unsigned long)current_cpu(),
                     (void*)0,
                     (void*)0,
                     (void*)0,
@@ -2755,17 +2752,8 @@
        }
        if (ip->i_afp)
                xfs_idestroy_fork(ip, XFS_ATTR_FORK);
-#ifdef NOTYET
-       if (ip->i_range_lock.r_sleep != NULL) {
-               freesema(ip->i_range_lock.r_sleep);
-               kmem_free(ip->i_range_lock.r_sleep, sizeof(sema_t));
-       }
-#endif /* NOTYET */
        mrfree(&ip->i_lock);
        mrfree(&ip->i_iolock);
-#ifdef NOTYET
-       mutex_destroy(&ip->i_range_lock.r_spinlock);
-#endif /* NOTYET */
        freesema(&ip->i_flock);
 #ifdef XFS_BMAP_TRACE
        ktrace_free(ip->i_xtrace);
@@ -2776,9 +2764,6 @@
 #ifdef XFS_RW_TRACE
        ktrace_free(ip->i_rwtrace);
 #endif
-#ifdef XFS_STRAT_TRACE
-       ktrace_free(ip->i_strat_trace);
-#endif
 #ifdef XFS_ILOCK_TRACE
        ktrace_free(ip->i_lock_trace);
 #endif
@@ -3707,7 +3692,7 @@
        if ((error = _ACL_XFS_IACCESS(ip, mode, cr)) != -1)
                return error ? XFS_ERROR(error) : 0;
 
-       if (current->fsuid != ip->i_d.di_uid) {
+       if (current_fsuid(cr) != ip->i_d.di_uid) {
                mode >>= 3;
                if (!in_group_p((gid_t)ip->i_d.di_gid))
                        mode >>= 3;
@@ -3814,7 +3799,7 @@
         * We're not supposed to change timestamps in readonly-mounted
         * filesystems.  Throw it away if anyone asks us.
         */
-       if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
+       if (unlikely(vp->v_vfsp->vfs_flag & VFS_RDONLY))
                return;
 
        /*
@@ -3828,17 +3813,17 @@
 
        nanotime(&tv);
        if (flags & XFS_ICHGTIME_MOD) {
-               inode->i_mtime = tv;
+               VN_MTIMESET(vp, &tv);
                ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
                ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
        }
        if (flags & XFS_ICHGTIME_ACC) {
-               inode->i_atime  = tv;
+               VN_ATIMESET(vp, &tv);
                ip->i_d.di_atime.t_sec = (__int32_t)tv.tv_sec;
                ip->i_d.di_atime.t_nsec = (__int32_t)tv.tv_nsec;
        }
        if (flags & XFS_ICHGTIME_CHG) {
-               inode->i_ctime  = tv;
+               VN_CTIMESET(vp, &tv);
                ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
                ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
        }
@@ -3859,17 +3844,18 @@
 }
 
 #ifdef XFS_ILOCK_TRACE
+ktrace_t       *xfs_ilock_trace_buf;
+
 void
 xfs_ilock_trace(xfs_inode_t *ip, int lock, unsigned int lockflags, inst_t *ra)
 {
        ktrace_enter(ip->i_lock_trace,
                     (void *)ip,
-                     (void *)(__psint_t)lock,          /* 1 = LOCK, 3=UNLOCK, etc */
-                    (void *)(__psint_t)lockflags,      /* XFS_ILOCK_EXCL etc */
-                    (void *)ra,                        /* caller of ilock */
-                    (void *)(__psint_t)cpuid(),
-                    (void *)(__psint_t)current_pid(),
+                    (void *)(unsigned long)lock, /* 1 = LOCK, 3=UNLOCK, etc */
+                    (void *)(unsigned long)lockflags, /* XFS_ILOCK_EXCL etc */
+                    (void *)ra,                /* caller of ilock */
+                    (void *)(unsigned long)current_cpu(),
+                    (void *)(unsigned long)current_pid(),
                     0,0,0,0,0,0,0,0,0,0);
-
 }
-#endif /* ILOCK_TRACE */
+#endif
diff -urN linux.org/fs/xfs/xfs_inode.h linux/fs/xfs/xfs_inode.h
--- linux.org/fs/xfs/xfs_inode.h        2003-12-31 05:48:01.000000000 +0100
+++ linux/fs/xfs/xfs_inode.h    2004-01-02 04:21:44.000000000 +0100
@@ -99,6 +99,13 @@
 struct xfs_trans;
 struct xfs_dquot;
 
+#if defined(XFS_ILOCK_TRACE)
+#define XFS_ILOCK_KTRACE_SIZE  32
+extern ktrace_t *xfs_ilock_trace_buf;
+extern void xfs_ilock_trace(struct xfs_inode *, int, unsigned int, inst_t *);
+#else
+#define        xfs_ilock_trace(i,n,f,ra)
+#endif
 
 /*
  * This structure is used to communicate which extents of a file
@@ -264,7 +271,10 @@
        sema_t                  i_flock;        /* inode flush lock */
        atomic_t                i_pincount;     /* inode pin count */
        wait_queue_head_t       i_ipin_wait;    /* inode pinning wait queue */
-
+#ifdef HAVE_REFCACHE
+       struct xfs_inode        **i_refcache;   /* ptr to entry in ref cache */
+       struct xfs_inode        *i_release;     /* inode to unref */
+#endif
        /* I/O state */
        xfs_iocore_t            i_iocore;       /* I/O core */
 
@@ -280,15 +290,22 @@
        struct xfs_inode        *i_cnext;       /* cluster hash link forward */
        struct xfs_inode        *i_cprev;       /* cluster hash link backward */
 
-#ifdef DEBUG
        /* Trace buffers per inode. */
+#ifdef XFS_BMAP_TRACE
        struct ktrace           *i_xtrace;      /* inode extent list trace */
+#endif
+#ifdef XFS_BMBT_TRACE
        struct ktrace           *i_btrace;      /* inode bmap btree trace */
+#endif
+#ifdef XFS_RW_TRACE
        struct ktrace           *i_rwtrace;     /* inode read/write trace */
-       struct ktrace           *i_strat_trace; /* inode strat_write trace */
+#endif
+#ifdef XFS_ILOCK_TRACE
        struct ktrace           *i_lock_trace;  /* inode lock/unlock trace */
+#endif
+#ifdef XFS_DIR2_TRACE
        struct ktrace           *i_dir_trace;   /* inode directory trace */
-#endif /* DEBUG */
+#endif
 } xfs_inode_t;
 
 #endif /* __KERNEL__ */
@@ -536,12 +553,6 @@
 extern struct kmem_zone        *xfs_ili_zone;
 extern struct vnodeops xfs_vnodeops;
 
-#ifdef XFS_ILOCK_TRACE
-#define XFS_ILOCK_KTRACE_SIZE  32
-void   xfs_ilock_trace(xfs_inode_t *ip, int lock, unsigned int lockflags,
-                       inst_t *ra);
-#endif
-
 #endif /* __KERNEL__ */
 
 #endif /* __XFS_INODE_H__ */
diff -urN linux.org/fs/xfs/xfs_iocore.c linux/fs/xfs/xfs_iocore.c
--- linux.org/fs/xfs/xfs_iocore.c       2003-12-31 05:48:05.000000000 +0100
+++ linux/fs/xfs/xfs_iocore.c   2004-01-02 04:21:44.000000000 +0100
@@ -61,6 +61,7 @@
 #include "xfs_rw.h"
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
+#include "xfs_iomap.h"
 
 
 STATIC xfs_fsize_t
diff -urN linux.org/fs/xfs/xfs_iomap.h linux/fs/xfs/xfs_iomap.h
--- linux.org/fs/xfs/xfs_iomap.h        1970-01-01 01:00:00.000000000 +0100
+++ linux/fs/xfs/xfs_iomap.h    2004-01-02 04:21:44.000000000 +0100
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2003 Silicon Graphics, Inc.  All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 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.
+ *
+ * Further, this software is distributed without any warranty that it is
+ * free of the rightful claim of any third person regarding infringement
+ * or the like.  Any license provided herein, whether implied or
+ * otherwise, applies only to this software file.  Patent licenses, if
+ * any, provided herein do not apply to combinations of this program with
+ * other software, or any other product whatsoever.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write the Free Software Foundation, Inc., 59
+ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
+ *
+ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
+ * Mountain View, CA  94043, or:
+ *
+ * http://www.sgi.com
+ *
+ * For further information regarding this notice, see:
+ *
+ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
+ */
+
+
+
+#ifndef __XFS_IOMAP_H__
+#define __XFS_IOMAP_H__
+
+#define IOMAP_DADDR_NULL ((xfs_daddr_t) (-1LL))
+
+
+typedef enum {                         /* iomap_flags values */
+       IOMAP_EOF =             0x01,   /* mapping contains EOF   */
+       IOMAP_HOLE =            0x02,   /* mapping covers a hole  */
+       IOMAP_DELAY =           0x04,   /* mapping covers delalloc region  */
+       IOMAP_UNWRITTEN =       0x20,   /* mapping covers allocated */
+                                       /* but uninitialized file data  */
+       IOMAP_NEW =             0x40    /* just allocate */
+} iomap_flags_t;
+
+typedef enum {
+       /* base extent manipulation calls */
+       BMAPI_READ = (1 << 0),          /* read extents */
+       BMAPI_WRITE = (1 << 1),         /* create extents */
+       BMAPI_ALLOCATE = (1 << 2),      /* delayed allocate to real extents */
+       BMAPI_UNWRITTEN  = (1 << 3),    /* unwritten extents to real extents */
+       /* modifiers */
+       BMAPI_IGNSTATE = (1 << 4),      /* ignore unwritten state on read */
+       BMAPI_DIRECT = (1 << 5),                /* direct instead of buffered write */
+       BMAPI_MMAP = (1 << 6),          /* allocate for mmap write */
+       BMAPI_SYNC = (1 << 7),          /* sync write */
+       BMAPI_TRYLOCK = (1 << 8),       /* non-blocking request */
+       BMAPI_DEVICE = (1 << 9),        /* we only want to know the device */
+} bmapi_flags_t;
+
+
+/*
+ * xfs_iomap_t:  File system I/O map
+ *
+ * The iomap_bn, iomap_offset and iomap_length fields are expressed in disk blocks.
+ * The iomap_length field specifies the size of the underlying backing store
+ * for the particular mapping.
+ *
+ * The iomap_bsize, iomap_size and iomap_delta fields are in bytes and indicate
+ * the size of the mapping, the number of bytes that are valid to access
+ * (read or write), and the offset into the mapping, given the offset
+ * supplied to the file I/O map routine.  iomap_delta is the offset of the
+ * desired data from the beginning of the mapping.
+ *
+ * When a request is made to read beyond the logical end of the object,
+ * iomap_size may be set to 0, but iomap_offset and iomap_length should be set to
+ * the actual amount of underlying storage that has been allocated, if any.
+ */
+
+typedef struct xfs_iomap {
+       xfs_daddr_t             iomap_bn;
+       xfs_buftarg_t           *iomap_target;
+       loff_t                  iomap_offset;
+       size_t                  iomap_delta;
+       size_t                  iomap_bsize;
+       iomap_flags_t           iomap_flags;
+} xfs_iomap_t;
+
+struct xfs_iocore;
+struct xfs_inode;
+struct xfs_bmbt_irec;
+
+extern int xfs_iomap(struct xfs_iocore *, xfs_off_t, ssize_t, int,
+                    struct xfs_iomap *, int *);
+extern int xfs_iomap_write_direct(struct xfs_inode *, loff_t, size_t,
+                                 int, struct xfs_bmbt_irec *, int *, int);
+extern int xfs_iomap_write_delay(struct xfs_inode *, loff_t, size_t, int,
+                                struct xfs_bmbt_irec *, int *);
+extern int xfs_iomap_write_allocate(struct xfs_inode *,
+                               struct xfs_bmbt_irec *, int *);
+extern int xfs_iomap_write_unwritten(struct xfs_inode *, loff_t, size_t);
+
+#endif /* __XFS_IOMAP_H__*/
diff -urN linux.org/fs/xfs/xfs_itable.c linux/fs/xfs/xfs_itable.c
--- linux.org/fs/xfs/xfs_itable.c       2003-12-31 05:46:26.000000000 +0100
+++ linux/fs/xfs/xfs_itable.c   2004-01-02 04:21:44.000000000 +0100
@@ -65,7 +65,10 @@
        xfs_trans_t     *tp,            /* transaction pointer */
        xfs_ino_t       ino,            /* inode number to get data for */
        void            *buffer,        /* buffer to place output in */
+       int             ubsize,         /* size of buffer */
+       void            *private_data,  /* my private data */
        xfs_daddr_t     bno,            /* starting bno of inode cluster */
+       int             *ubused,        /* bytes used by me */
        void            *dibuff,        /* on-disk inode buffer */
        int             *stat)          /* BULKSTAT_RV_... */
 {
@@ -86,6 +89,10 @@
                *stat = BULKSTAT_RV_NOTHING;
                return XFS_ERROR(EINVAL);
        }
+       if (ubsize < sizeof(*buf)) {
+               *stat = BULKSTAT_RV_NOTHING;
+               return XFS_ERROR(ENOMEM);
+       }
 
        if (dip == NULL) {
                /* We're not being passed a pointer to a dinode.  This happens
@@ -218,6 +225,8 @@
        }
 
        *stat = BULKSTAT_RV_DIDONE;
+       if (ubused)
+               *ubused = sizeof(*buf);
        return 0;
 }
 
@@ -231,6 +240,7 @@
        xfs_ino_t               *lastinop, /* last inode returned */
        int                     *ubcountp, /* size of buffer/count returned */
        bulkstat_one_pf         formatter, /* func that'd fill a single buf */
+       void                    *private_data,/* private data for formatter */
        size_t                  statstruct_size, /* sizeof struct filling */
        xfs_caddr_t             ubuffer, /* buffer with inode stats */
        int                     flags,  /* defined in xfs_itable.h */
@@ -265,8 +275,10 @@
        int                     rval;   /* return value error code */
        int                     tmp;    /* result value from btree calls */
        int                     ubcount; /* size of user's buffer */
-       int                     ubleft; /* spaces left in user's buffer */
+       int                     ubleft; /* bytes left in user's buffer */
        xfs_caddr_t             ubufp;  /* current pointer into user's buffer */
+       int                     ubelem; /* spaces used in user's buffer */
+       int                     ubused; /* bytes used by formatter */
        xfs_buf_t               *bp;    /* ptr to on-disk inode cluster buf */
        xfs_dinode_t            *dip;   /* ptr into bp for specific inode */
        xfs_inode_t             *ip;    /* ptr to in-core inode struct */
@@ -284,8 +296,9 @@
                *ubcountp = 0;
                return 0;
        }
-       ubcount = ubleft = *ubcountp;
-       *ubcountp = 0;
+       ubcount = *ubcountp; /* statstruct's */
+       ubleft = ubcount * statstruct_size; /* bytes */
+       *ubcountp = ubelem = 0;
        *done = 0;
        fmterror = 0;
        ubufp = ubuffer;
@@ -317,7 +330,7 @@
         * inode returned; 0 means start of the allocation group.
         */
        rval = 0;
-       while (ubleft > 0 && agno < mp->m_sb.sb_agcount) {
+       while ((ubleft/statstruct_size) > 0 && agno < mp->m_sb.sb_agcount) {
                bp = NULL;
                down_read(&mp->m_peraglock);
                error = xfs_ialloc_read_agi(mp, tp, agno, &agbp);
@@ -402,7 +415,7 @@
                 * Loop through inode btree records in this ag,
                 * until we run out of inodes or space in the buffer.
                 */
-               while (irbp < irbufend && icount < ubcount) {
+               while (irbp < irbufend && icount < (ubleft/statstruct_size)) {
                        /*
                         * Loop as long as we're unable to read the
                         * inode btree.
@@ -453,7 +466,8 @@
                 * Now format all the good inodes into the user's buffer.
                 */
                irbufend = irbp;
-               for (irbp = irbuf; irbp < irbufend && ubleft > 0; irbp++) {
+               for (irbp = irbuf;
+                    irbp < irbufend && (ubleft/statstruct_size) > 0; irbp++) {
                        /*
                         * Read-ahead the next chunk's worth of inodes.
                         */
@@ -561,14 +575,19 @@
                                 * Get the inode and fill in a single buffer.
                                 * BULKSTAT_FG_QUICK uses dip to fill it in.
                                 * BULKSTAT_FG_IGET uses igets.
-                                * See: xfs_bulkstat_one & dm_bulkstat_one.
+                                * See: xfs_bulkstat_one & xfs_dm_bulkstat_one.
                                 * This is also used to count inodes/blks, etc
                                 * in xfs_qm_quotacheck.
                                 */
-                               error = formatter(mp, tp, ino, ubufp, bno, dip,
-                                       &fmterror);
-                               if (fmterror == BULKSTAT_RV_NOTHING)
+                               ubused = statstruct_size;
+                               error = formatter(mp, tp, ino, ubufp,
+                                               ubleft, private_data,
+                                               bno, &ubused, dip, &fmterror);
+                               if (fmterror == BULKSTAT_RV_NOTHING) {
+                                       if (error == ENOMEM)
+                                               ubleft = 0;
                                        continue;
+                               }
                                if (fmterror == BULKSTAT_RV_GIVEUP) {
                                        ubleft = 0;
                                        ASSERT(error);
@@ -576,8 +595,9 @@
                                        break;
                                }
                                if (ubufp)
-                                       ubufp += statstruct_size;
-                               ubleft--;
+                                       ubufp += ubused;
+                               ubleft -= ubused;
+                               ubelem++;
                                lastino = ino;
                        }
                }
@@ -605,7 +625,7 @@
        if (ubuffer)
                unuseracc(ubuffer, ubcount * statstruct_size, (B_READ|B_PHYS));
 #endif
-       *ubcountp = ubcount - ubleft;
+       *ubcountp = ubelem;
        if (agno >= mp->m_sb.sb_agcount) {
                /*
                 * If we ran out of filesystem, mark lastino as off
@@ -647,7 +667,8 @@
         */
 
        ino = (xfs_ino_t)*lastinop;
-       error = xfs_bulkstat_one(mp, NULL, ino, &bstat, 0, 0, &res);
+       error = xfs_bulkstat_one(mp, NULL, ino, &bstat, sizeof(bstat),
+                                NULL, 0, NULL, NULL, &res);
        if (error) {
                /*
                 * Special case way failed, do it the "long" way
@@ -656,6 +677,7 @@
                (*lastinop)--;
                count = 1;
                if (xfs_bulkstat(mp, NULL, lastinop, &count, xfs_bulkstat_one,
+                               NULL,
                                sizeof(bstat), buffer, BULKSTAT_FG_IGET, done))
                        return error;
                if (count == 0 || (xfs_ino_t)*lastinop != ino)
diff -urN linux.org/fs/xfs/xfs_itable.h linux/fs/xfs/xfs_itable.h
--- linux.org/fs/xfs/xfs_itable.h       2003-12-31 05:48:36.000000000 +0100
+++ linux/fs/xfs/xfs_itable.h   2004-01-02 04:21:42.000000000 +0100
@@ -36,15 +36,19 @@
  * xfs_bulkstat() is used to fill in xfs_bstat structures as well as dm_stat
  * structures (by the dmi library). This is a pointer to a formatter function
  * that will iget the inode and fill in the appropriate structure.
- * see xfs_bulkstat_one() and dm_bulkstat_one() in dmi_xfs.c
+ * see xfs_bulkstat_one() and xfs_dm_bulkstat_one() in dmapi_xfs.c
  */
 typedef int (*bulkstat_one_pf)(struct xfs_mount        *mp,
                               struct xfs_trans *tp,
                               xfs_ino_t        ino,
                               void             *buffer,
+                              int              ubsize,
+                              void             *private_data,
                               xfs_daddr_t      bno,
+                              int              *ubused,
                               void             *dip,
                               int              *stat);
+
 /*
  * Values for stat return value.
  */
@@ -69,6 +73,7 @@
        xfs_ino_t       *lastino,       /* last inode returned */
        int             *count,         /* size of buffer/count returned */
        bulkstat_one_pf formatter,      /* func that'd fill a single buf */
+       void            *private_data,  /* private data for formatter */
        size_t          statstruct_size,/* sizeof struct that we're filling */
        xfs_caddr_t     ubuffer,        /* buffer with inode stats */
        int             flags,          /* flag to control access method */
@@ -87,7 +92,10 @@
        xfs_trans_t             *tp,
        xfs_ino_t               ino,
        void                    *buffer,
+       int                     ubsize,
+       void                    *private_data,
        xfs_daddr_t             bno,
+       int                     *ubused,
        void                    *dibuff,
        int                     *stat);
 
diff -urN linux.org/fs/xfs/xfs_log.c linux/fs/xfs/xfs_log.c
--- linux.org/fs/xfs/xfs_log.c  2003-12-31 05:48:47.000000000 +0100
+++ linux/fs/xfs/xfs_log.c      2004-01-02 04:21:42.000000000 +0100
@@ -159,11 +159,15 @@
 #endif
 
 #if defined(XFS_LOG_TRACE)
+
 void
 xlog_trace_loggrant(xlog_t *log, xlog_ticket_t *tic, xfs_caddr_t string)
 {
-       if (! log->l_grant_trace)
-               log->l_grant_trace = ktrace_alloc(1024, KM_SLEEP);
+       if (! log->l_grant_trace) {
+               log->l_grant_trace = ktrace_alloc(1024, KM_NOSLEEP);
+               if (! log->l_grant_trace)
+                       return;
+       }
 
        ktrace_enter(log->l_grant_trace,
                     (void *)tic,
@@ -185,31 +189,6 @@
 }
 
 void
-xlog_trace_tic(xlog_t *log, xlog_ticket_t *tic)
-{
-       if (! log->l_trace)
-               log->l_trace = ktrace_alloc(256, KM_SLEEP);
-
-       ktrace_enter(log->l_trace,
-                    (void *)tic,
-                    (void *)((unsigned long)tic->t_curr_res),
-                    (void *)((unsigned long)tic->t_unit_res),
-                    (void *)((unsigned long)tic->t_ocnt),
-                    (void *)((unsigned long)tic->t_cnt),
-                    (void *)((unsigned long)tic->t_flags),
-                    (void *)((unsigned long)7),
-                    (void *)((unsigned long)8),
-                    (void *)((unsigned long)9),
-                    (void *)((unsigned long)10),
-                    (void *)((unsigned long)11),
-                    (void *)((unsigned long)12),
-                    (void *)((unsigned long)13),
-                    (void *)((unsigned long)14),
-                    (void *)((unsigned long)15),
-                    (void *)((unsigned long)16));
-}
-
-void
 xlog_trace_iclog(xlog_in_core_t *iclog, uint state)
 {
        pid_t pid;
@@ -1044,7 +1023,6 @@
  *
  * If the filesystem blocksize is too large, we may need to choose a
  * larger size since the directory code currently logs entire blocks.
- * XXXmiken XXXcurtis
  */
 
 STATIC void
@@ -1059,7 +1037,7 @@
         * When logbufs == 0, someone has disabled the log from the FSTAB
         * file.  This is not a documented feature.  We need to set xlog_debug
         * to zero (this deactivates the log) and set xlog_target to the
-        * appropriate dev_t.  Only one filesystem may be affected as such
+        * appropriate device.  Only one filesystem may be affected as such
         * since this is just a performance hack to test what we might be able
         * to get if the log were not present.
         */
@@ -1078,7 +1056,7 @@
                        if (xfs_physmem <= btoc(128*1024*1024)) { 
                                log->l_iclog_bufs = XLOG_MIN_ICLOGS; 
                        } else if (xfs_physmem <= btoc(400*1024*1024)) { 
-                               log->l_iclog_bufs = XLOG_MED_ICLOGS;; 
+                               log->l_iclog_bufs = XLOG_MED_ICLOGS; 
                        } else {
                                /* 256K with 32K bufs */
                                log->l_iclog_bufs = XLOG_MAX_ICLOGS;
@@ -1087,9 +1065,9 @@
                        log->l_iclog_bufs = mp->m_logbufs;
 
 #if defined(DEBUG) || defined(XLOG_NOLOG)
-               /* We are reactivating a filesystem after it was active */
+               /* We are reactivating a filesystem after it was inactive */
                if (log->l_targ == xlog_target) {
-                       xlog_target = 1; /* XXX(hch): WTF? */
+                       xlog_target = NULL;
                        xlog_debug = 1;
                }
 #endif
@@ -1578,7 +1556,7 @@
                sv_destroy(&iclog->ic_forcesema);
                sv_destroy(&iclog->ic_writesema);
                xfs_buf_free(iclog->ic_bp);
-#ifdef DEBUG
+#ifdef XFS_LOG_TRACE
                if (iclog->ic_trace != NULL) {
                        ktrace_free(iclog->ic_trace);
                }
@@ -1609,7 +1587,7 @@
                }
        }
        xfs_buf_free(log->l_xbuf);
-#ifdef DEBUG
+#ifdef XFS_LOG_TRACE
        if (log->l_trace != NULL) {
                ktrace_free(log->l_trace);
        }
diff -urN linux.org/fs/xfs/xfs_log.h linux/fs/xfs/xfs_log.h
--- linux.org/fs/xfs/xfs_log.h  2003-12-31 05:48:56.000000000 +0100
+++ linux/fs/xfs/xfs_log.h      2004-01-02 04:21:42.000000000 +0100
@@ -53,8 +53,8 @@
  * endian issues in treating two 32 bit numbers as one 64 bit number
  */
 static
-#if defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 95)
-__attribute__((unused))        /* gcc 2.95 miscompiles this when inlined */
+#if defined(__GNUC__) && (__GNUC__ == 2) && ( (__GNUC_MINOR__ == 95) || (__GNUC_MINOR__ == 96))
+__attribute__((unused))        /* gcc 2.95, 2.96 miscompile this when inlined */
 #else
 __inline__
 #endif
diff -urN linux.org/fs/xfs/xfs_log_priv.h linux/fs/xfs/xfs_log_priv.h
--- linux.org/fs/xfs/xfs_log_priv.h     2003-12-31 05:46:29.000000000 +0100
+++ linux/fs/xfs/xfs_log_priv.h 2004-01-02 04:21:42.000000000 +0100
@@ -32,14 +32,6 @@
 #ifndef        __XFS_LOG_PRIV_H__
 #define __XFS_LOG_PRIV_H__
 
-#if defined(XFS_ALL_TRACE)
-#define        XFS_LOG_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_LOG_TRACE
-#endif
-
 struct xfs_buf;
 struct ktrace;
 struct log;
@@ -109,6 +101,7 @@
 
 
 #ifdef __KERNEL__
+
 /*
  * get client id from packed copy.
  *
@@ -434,7 +427,7 @@
        struct log              *ic_log;
        xfs_log_callback_t      *ic_callback;
        xfs_log_callback_t      **ic_callback_tail;
-#ifdef DEBUG
+#ifdef XFS_LOG_TRACE
        struct ktrace           *ic_trace;
 #endif
        int                     ic_size;
@@ -531,7 +524,7 @@
        int                     l_grant_write_bytes;
 
        /* The following fields don't need locking */
-#ifdef DEBUG
+#ifdef XFS_LOG_TRACE
        struct ktrace           *l_trace;
        struct ktrace           *l_grant_trace;
 #endif
diff -urN linux.org/fs/xfs/xfs_mount.c linux/fs/xfs/xfs_mount.c
--- linux.org/fs/xfs/xfs_mount.c        2003-12-31 05:46:55.000000000 +0100
+++ linux/fs/xfs/xfs_mount.c    2004-01-02 04:21:42.000000000 +0100
@@ -903,7 +903,7 @@
         *  File systems that don't support user level file handles (i.e.
         *  all of them except for XFS) will leave vfs_altfsid as NULL.
         */
-       vfsp->vfs_altfsid = (fsid_t *)mp->m_fixedfsid;
+       vfsp->vfs_altfsid = (xfs_fsid_t *)mp->m_fixedfsid;
        mp->m_dmevmask = 0;     /* not persistent; set after each mount */
 
        /*
diff -urN linux.org/fs/xfs/xfs_qmops.c linux/fs/xfs/xfs_qmops.c
--- linux.org/fs/xfs/xfs_qmops.c        2003-12-31 05:46:56.000000000 +0100
+++ linux/fs/xfs/xfs_qmops.c    2004-01-02 04:21:43.000000000 +0100
@@ -44,7 +44,6 @@
 #include "xfs_mount.h"
 
 
-#ifndef CONFIG_XFS_QUOTA
 STATIC struct xfs_dquot *
 xfs_dqvopchown_default(
        struct xfs_trans        *tp,
@@ -70,4 +69,3 @@
        .xfs_dqvopchown         = xfs_dqvopchown_default,
        .xfs_dqvopchownresv     = (xfs_dqvopchownresv_t) fs_noerr,
 };
-#endif /* CONFIG_XFS_QUOTA */
diff -urN linux.org/fs/xfs/xfs_refcache.c linux/fs/xfs/xfs_refcache.c
--- linux.org/fs/xfs/xfs_refcache.c     1970-01-01 01:00:00.000000000 +0100
+++ linux/fs/xfs/xfs_refcache.c 2004-01-02 04:21:43.000000000 +0100
@@ -0,0 +1,439 @@
+/*
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 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.
+ *
+ * Further, this software is distributed without any warranty that it is
+ * free of the rightful claim of any third person regarding infringement
+ * or the like.  Any license provided herein, whether implied or
+ * otherwise, applies only to this software file.  Patent licenses, if
+ * any, provided herein do not apply to combinations of this program with
+ * other software, or any other product whatsoever.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write the Free Software Foundation, Inc., 59
+ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
+ *
+ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
+ * Mountain View, CA  94043, or:
+ *
+ * http://www.sgi.com
+ *
+ * For further information regarding this notice, see:
+ *
+ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
+ */
+
+#include "xfs.h"
+#include "xfs_macros.h"
+#include "xfs_types.h"
+#include "xfs_inum.h"
+#include "xfs_log.h"
+#include "xfs_trans.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
+#include "xfs_dir.h"
+#include "xfs_dir2.h"
+#include "xfs_dmapi.h"
+#include "xfs_mount.h"
+#include "xfs_alloc_btree.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_ialloc_btree.h"
+#include "xfs_itable.h"
+#include "xfs_btree.h"
+#include "xfs_alloc.h"
+#include "xfs_ialloc.h"
+#include "xfs_attr.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode_item.h"
+#include "xfs_inode.h"
+#include "xfs_bmap.h"
+#include "xfs_error.h"
+#include "xfs_buf_item.h"
+#include "xfs_refcache.h"
+
+STATIC spinlock_t      xfs_refcache_lock = SPIN_LOCK_UNLOCKED;
+STATIC xfs_inode_t     **xfs_refcache;
+STATIC int             xfs_refcache_index;
+STATIC int             xfs_refcache_busy;
+STATIC int             xfs_refcache_count;
+
+/*
+ * Insert the given inode into the reference cache.
+ */
+void
+xfs_refcache_insert(
+       xfs_inode_t     *ip)
+{
+       vnode_t         *vp;
+       xfs_inode_t     *release_ip;
+       xfs_inode_t     **refcache;
+
+       ASSERT(ismrlocked(&(ip->i_iolock), MR_UPDATE));
+
+       /*
+        * If an unmount is busy blowing entries out of the cache,
+        * then don't bother.
+        */
+       if (xfs_refcache_busy) {
+               return;
+       }
+
+       /*
+        * If we tuned the refcache down to zero, don't do anything.
+        */
+        if (!xfs_refcache_size) {
+               return;
+       }
+
+       /*
+        * The inode is already in the refcache, so don't bother
+        * with it.
+        */
+       if (ip->i_refcache != NULL) {
+               return;
+       }
+
+       vp = XFS_ITOV(ip);
+       /* ASSERT(vp->v_count > 0); */
+       VN_HOLD(vp);
+
+       /*
+        * We allocate the reference cache on use so that we don't
+        * waste the memory on systems not being used as NFS servers.
+        */
+       if (xfs_refcache == NULL) {
+               refcache = (xfs_inode_t **)kmem_zalloc(XFS_REFCACHE_SIZE_MAX *
+                                                      sizeof(xfs_inode_t *),
+                                                      KM_SLEEP);
+       } else {
+               refcache = NULL;
+       }
+
+       spin_lock(&xfs_refcache_lock);
+
+       /*
+        * If we allocated memory for the refcache above and it still
+        * needs it, then use the memory we allocated.  Otherwise we'll
+        * free the memory below.
+        */
+       if (refcache != NULL) {
+               if (xfs_refcache == NULL) {
+                       xfs_refcache = refcache;
+                       refcache = NULL;
+               }
+       }
+
+       /*
+        * If an unmount is busy clearing out the cache, don't add new
+        * entries to it.
+        */
+       if (xfs_refcache_busy) {
+               spin_unlock(&xfs_refcache_lock);
+               VN_RELE(vp);
+               /*
+                * If we allocated memory for the refcache above but someone
+                * else beat us to using it, then free the memory now.
+                */
+               if (refcache != NULL) {
+                       kmem_free(refcache,
+                                 XFS_REFCACHE_SIZE_MAX * sizeof(xfs_inode_t *));
+               }
+               return;
+       }
+       release_ip = xfs_refcache[xfs_refcache_index];
+       if (release_ip != NULL) {
+               release_ip->i_refcache = NULL;
+               xfs_refcache_count--;
+               ASSERT(xfs_refcache_count >= 0);
+       }
+       xfs_refcache[xfs_refcache_index] = ip;
+       ASSERT(ip->i_refcache == NULL);
+       ip->i_refcache = &(xfs_refcache[xfs_refcache_index]);
+       xfs_refcache_count++;
+       ASSERT(xfs_refcache_count <= xfs_refcache_size);
+       xfs_refcache_index++;
+       if (xfs_refcache_index == xfs_refcache_size) {
+               xfs_refcache_index = 0;
+       }
+       spin_unlock(&xfs_refcache_lock);
+
+       /*
+        * Save the pointer to the inode to be released so that we can
+        * VN_RELE it once we've dropped our inode locks in xfs_rwunlock().
+        * The pointer may be NULL, but that's OK.
+        */
+       ip->i_release = release_ip;
+
+       /*
+        * If we allocated memory for the refcache above but someone
+        * else beat us to using it, then free the memory now.
+        */
+       if (refcache != NULL) {
+               kmem_free(refcache,
+                         XFS_REFCACHE_SIZE_MAX * sizeof(xfs_inode_t *));
+       }
+}
+
+
+/*
+ * If the given inode is in the reference cache, purge its entry and
+ * release the reference on the vnode.
+ */
+void
+xfs_refcache_purge_ip(
+       xfs_inode_t     *ip)
+{
+       vnode_t *vp;
+       int     error;
+
+       /*
+        * If we're not pointing to our entry in the cache, then
+        * we must not be in the cache.
+        */
+       if (ip->i_refcache == NULL) {
+               return;
+       }
+
+       spin_lock(&xfs_refcache_lock);
+       if (ip->i_refcache == NULL) {
+               spin_unlock(&xfs_refcache_lock);
+               return;
+       }
+
+       /*
+        * Clear both our pointer to the cache entry and its pointer
+        * back to us.
+        */
+       ASSERT(*(ip->i_refcache) == ip);
+       *(ip->i_refcache) = NULL;
+       ip->i_refcache = NULL;
+       xfs_refcache_count--;
+       ASSERT(xfs_refcache_count >= 0);
+       spin_unlock(&xfs_refcache_lock);
+
+       vp = XFS_ITOV(ip);
+       /* ASSERT(vp->v_count > 1); */
+       VOP_RELEASE(vp, error);
+       VN_RELE(vp);
+}
+
+
+/*
+ * This is called from the XFS unmount code to purge all entries for the
+ * given mount from the cache.  It uses the refcache busy counter to
+ * make sure that new entries are not added to the cache as we purge them.
+ */
+void
+xfs_refcache_purge_mp(
+       xfs_mount_t     *mp)
+{
+       vnode_t         *vp;
+       int             error, i;
+       xfs_inode_t     *ip;
+
+       if (xfs_refcache == NULL) {
+               return;
+       }
+
+       spin_lock(&xfs_refcache_lock);
+       /*
+        * Bumping the busy counter keeps new entries from being added
+        * to the cache.  We use a counter since multiple unmounts could
+        * be in here simultaneously.
+        */
+       xfs_refcache_busy++;
+
+       for (i = 0; i < xfs_refcache_size; i++) {
+               ip = xfs_refcache[i];
+               if ((ip != NULL) && (ip->i_mount == mp)) {
+                       xfs_refcache[i] = NULL;
+                       ip->i_refcache = NULL;
+                       xfs_refcache_count--;
+                       ASSERT(xfs_refcache_count >= 0);
+                       spin_unlock(&xfs_refcache_lock);
+                       vp = XFS_ITOV(ip);
+                       VOP_RELEASE(vp, error);
+                       VN_RELE(vp);
+                       spin_lock(&xfs_refcache_lock);
+               }
+       }
+
+       xfs_refcache_busy--;
+       ASSERT(xfs_refcache_busy >= 0);
+       spin_unlock(&xfs_refcache_lock);
+}
+
+
+/*
+ * This is called from the XFS sync code to ensure that the refcache
+ * is emptied out over time.  We purge a small number of entries with
+ * each call.
+ */
+void
+xfs_refcache_purge_some(xfs_mount_t *mp)
+{
+       int             error, i;
+       xfs_inode_t     *ip;
+       int             iplist_index;
+       xfs_inode_t     **iplist;
+
+       if ((xfs_refcache == NULL) || (xfs_refcache_count == 0)) {
+               return;
+       }
+
+       iplist_index = 0;
+       iplist = (xfs_inode_t **)kmem_zalloc(xfs_refcache_purge_count *
+                                         sizeof(xfs_inode_t *), KM_SLEEP);
+
+       spin_lock(&xfs_refcache_lock);
+
+       /*
+        * Store any inodes we find in the next several entries
+        * into the iplist array to be released after dropping
+        * the spinlock.  We always start looking from the currently
+        * oldest place in the cache.  We move the refcache index
+        * forward as we go so that we are sure to eventually clear
+        * out the entire cache when the system goes idle.
+        */
+       for (i = 0; i < xfs_refcache_purge_count; i++) {
+               ip = xfs_refcache[xfs_refcache_index];
+               if (ip != NULL) {
+                       xfs_refcache[xfs_refcache_index] = NULL;
+                       ip->i_refcache = NULL;
+                       xfs_refcache_count--;
+                       ASSERT(xfs_refcache_count >= 0);
+                       iplist[iplist_index] = ip;
+                       iplist_index++;
+               }
+               xfs_refcache_index++;
+               if (xfs_refcache_index == xfs_refcache_size) {
+                       xfs_refcache_index = 0;
+               }
+       }
+
+       spin_unlock(&xfs_refcache_lock);
+
+       /*
+        * Now drop the inodes we collected.
+        */
+       for (i = 0; i < iplist_index; i++) {
+               VOP_RELEASE(XFS_ITOV(iplist[i]), error);
+               VN_RELE(XFS_ITOV(iplist[i]));
+       }
+
+       kmem_free(iplist, xfs_refcache_purge_count *
+                         sizeof(xfs_inode_t *));
+}
+
+/*
+ * This is called when the refcache is dynamically resized
+ * via a sysctl.
+ *
+ * If the new size is smaller than the old size, purge all
+ * entries in slots greater than the new size, and move
+ * the index if necessary.
+ *
+ * If the refcache hasn't even been allocated yet, or the
+ * new size is larger than the old size, just set the value
+ * of xfs_refcache_size.
+ */
+
+void
+xfs_refcache_resize(int xfs_refcache_new_size)
+{
+       int             i;
+       xfs_inode_t     *ip;
+       int             iplist_index = 0;
+       xfs_inode_t     **iplist;
+       int             error;
+
+       /*
+        * If the new size is smaller than the current size,
+        * purge entries to create smaller cache, and
+        * reposition index if necessary.
+        * Don't bother if no refcache yet.
+        */
+       if (xfs_refcache && (xfs_refcache_new_size < xfs_refcache_size)) {
+
+               iplist = (xfs_inode_t **)kmem_zalloc(XFS_REFCACHE_SIZE_MAX *
+                               sizeof(xfs_inode_t *), KM_SLEEP);
+
+               spin_lock(&xfs_refcache_lock);
+
+               for (i = xfs_refcache_new_size; i < xfs_refcache_size; i++) {
+                       ip = xfs_refcache[i];
+                       if (ip != NULL) {
+                               xfs_refcache[i] = NULL;
+                               ip->i_refcache = NULL;
+                               xfs_refcache_count--;
+                               ASSERT(xfs_refcache_count >= 0);
+                               iplist[iplist_index] = ip;
+                               iplist_index++;
+                       }
+               }
+
+               xfs_refcache_size = xfs_refcache_new_size;
+
+               /*
+                * Move index to beginning of cache if it's now past the end
+                */
+               if (xfs_refcache_index >= xfs_refcache_new_size)
+                       xfs_refcache_index = 0;
+
+               spin_unlock(&xfs_refcache_lock);
+
+               /*
+                * Now drop the inodes we collected.
+                */
+               for (i = 0; i < iplist_index; i++) {
+                       VOP_RELEASE(XFS_ITOV(iplist[i]), error);
+                       VN_RELE(XFS_ITOV(iplist[i]));
+               }
+
+               kmem_free(iplist, XFS_REFCACHE_SIZE_MAX *
+                                 sizeof(xfs_inode_t *));
+       } else {
+               spin_lock(&xfs_refcache_lock);
+               xfs_refcache_size = xfs_refcache_new_size;
+               spin_unlock(&xfs_refcache_lock);
+       }
+}
+
+void
+xfs_refcache_iunlock(
+       xfs_inode_t     *ip,
+       uint            lock_flags)
+{
+       xfs_inode_t     *release_ip;
+       int             error;
+
+       release_ip = ip->i_release;
+       ip->i_release = NULL;
+
+       xfs_iunlock(ip, lock_flags);
+
+       if (release_ip != NULL) {
+               VOP_RELEASE(XFS_ITOV(release_ip), error);
+               VN_RELE(XFS_ITOV(release_ip));
+       }
+}
+
+void
+xfs_refcache_destroy(void)
+{
+       if (xfs_refcache) {
+               kmem_free(xfs_refcache,
+                       XFS_REFCACHE_SIZE_MAX * sizeof(xfs_inode_t *));
+               xfs_refcache = NULL;
+       }
+}
diff -urN linux.org/fs/xfs/xfs_refcache.h linux/fs/xfs/xfs_refcache.h
--- linux.org/fs/xfs/xfs_refcache.h     1970-01-01 01:00:00.000000000 +0100
+++ linux/fs/xfs/xfs_refcache.h 2004-01-02 04:21:43.000000000 +0100
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 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.
+ *
+ * Further, this software is distributed without any warranty that it is
+ * free of the rightful claim of any third person regarding infringement
+ * or the like.  Any license provided herein, whether implied or
+ * otherwise, applies only to this software file.  Patent licenses, if
+ * any, provided herein do not apply to combinations of this program with
+ * other software, or any other product whatsoever.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write the Free Software Foundation, Inc., 59
+ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
+ *
+ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
+ * Mountain View, CA  94043, or:
+ *
+ * http://www.sgi.com
+ *
+ * For further information regarding this notice, see:
+ *
+ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
+ */
+#ifndef __XFS_REFCACHE_H__
+#define __XFS_REFCACHE_H__
+
+#ifdef HAVE_REFCACHE
+/*
+ * Maximum size (in inodes) for the NFS reference cache
+ */
+#define XFS_REFCACHE_SIZE_MAX  512
+
+struct xfs_inode;
+struct xfs_mount;
+
+extern void xfs_refcache_insert(struct xfs_inode *);
+extern void xfs_refcache_purge_ip(struct xfs_inode *);
+extern void xfs_refcache_purge_mp(struct xfs_mount *);
+extern void xfs_refcache_purge_some(struct xfs_mount *);
+extern void xfs_refcache_resize(int);
+extern void xfs_refcache_destroy(void);
+
+extern void xfs_refcache_iunlock(struct xfs_inode *, uint);
+
+#else
+
+#define xfs_refcache_insert(ip)                do { } while (0)
+#define xfs_refcache_purge_ip(ip)      do { } while (0)
+#define xfs_refcache_purge_mp(mp)      do { } while (0)
+#define xfs_refcache_purge_some(mp)    do { } while (0)
+#define xfs_refcache_resize(size)      do { } while (0)
+#define xfs_refcache_destroy()         do { } while (0)
+
+#define xfs_refcache_iunlock(ip, flags)        xfs_iunlock(ip, flags)
+
+#endif
+
+#endif /* __XFS_REFCACHE_H__ */
diff -urN linux.org/fs/xfs/xfs_rename.c linux/fs/xfs/xfs_rename.c
--- linux.org/fs/xfs/xfs_rename.c       2003-12-31 05:47:23.000000000 +0100
+++ linux/fs/xfs/xfs_rename.c   2004-01-02 04:21:43.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -51,7 +51,7 @@
 #include "xfs_bmap.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
-#include "xfs_rw.h"
+#include "xfs_refcache.h"
 #include "xfs_utils.h"
 #include "xfs_trans_space.h"
 #include "xfs_da_btree.h"
@@ -343,8 +343,7 @@
        src_is_directory = ((src_ip->i_d.di_mode & S_IFMT) == S_IFDIR);
 
        /*
-        * Drop the locks on our inodes so that we can do the ancestor
-        * check if necessary and start the transaction.
+        * Drop the locks on our inodes so that we can start the transaction.
         */
        xfs_rename_unlock4(inodes, XFS_ILOCK_SHARED);
 
@@ -486,7 +485,7 @@
                error = xfs_droplink(tp, target_ip);
                if (error) {
                        rename_which_error_return = __LINE__;
-                       goto abort_return;;
+                       goto abort_return;
                }
                target_ip_dropped = 1;
 
@@ -627,6 +626,7 @@
         */
        error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES, NULL);
        if (target_ip != NULL) {
+               xfs_refcache_purge_ip(target_ip);
                IRELE(target_ip);
        }
        /*
diff -urN linux.org/fs/xfs/xfs_rw.c linux/fs/xfs/xfs_rw.c
--- linux.org/fs/xfs/xfs_rw.c   2003-12-31 05:48:40.000000000 +0100
+++ linux/fs/xfs/xfs_rw.c       2004-01-02 04:21:43.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -149,6 +149,9 @@
                xfs_cmn_err(XFS_PTAG_SHUTDOWN_CORRUPT, CE_ALERT, mp,
     "Corruption of in-memory data detected.  Shutting down filesystem: %s",
                        mp->m_fsname);
+               if (XFS_ERRLEVEL_HIGH <= xfs_error_level) {
+                       xfs_stack_trace();
+               }
        } else if (!(flags & XFS_FORCE_UMOUNT)) {
                if (logerror) {
                        xfs_cmn_err(XFS_PTAG_SHUTDOWN_LOGERROR, CE_ALERT, mp,
@@ -351,54 +354,3 @@
        }
        return (error);
 }
-
-/*
- * xfs_inval_cached_pages()
- * This routine is responsible for keeping direct I/O and buffered I/O
- * somewhat coherent.  From here we make sure that we're at least
- * temporarily holding the inode I/O lock exclusively and then call
- * the page cache to flush and invalidate any cached pages.  If there
- * are no cached pages this routine will be very quick.
- */
-void
-xfs_inval_cached_pages(
-       vnode_t         *vp,
-       xfs_iocore_t    *io,
-       xfs_off_t       offset,
-       int             write,
-       int             relock)
-{
-       xfs_mount_t     *mp;
-
-       if (!VN_CACHED(vp)) {
-               return;
-       }
-
-       mp = io->io_mount;
-
-       /*
-        * We need to get the I/O lock exclusively in order
-        * to safely invalidate pages and mappings.
-        */
-       if (relock) {
-               XFS_IUNLOCK(mp, io, XFS_IOLOCK_SHARED);
-               XFS_ILOCK(mp, io, XFS_IOLOCK_EXCL);
-       }
-
-       /* Writing beyond EOF creates a hole that must be zeroed */
-       if (write && (offset > XFS_SIZE(mp, io))) {
-               xfs_fsize_t     isize;
-
-               XFS_ILOCK(mp, io, XFS_ILOCK_EXCL|XFS_EXTSIZE_RD);
-               isize = XFS_SIZE(mp, io);
-               if (offset > isize) {
-                       xfs_zero_eof(vp, io, offset, isize, offset);
-               }
-               XFS_IUNLOCK(mp, io, XFS_ILOCK_EXCL|XFS_EXTSIZE_RD);
-       }
-
-       VOP_FLUSHINVAL_PAGES(vp, ctooff(offtoct(offset)), -1, FI_REMAPF_LOCKED);
-       if (relock) {
-               XFS_ILOCK_DEMOTE(mp, io, XFS_IOLOCK_EXCL);
-       }
-}
diff -urN linux.org/fs/xfs/xfs_rw.h linux/fs/xfs/xfs_rw.h
--- linux.org/fs/xfs/xfs_rw.h   2003-12-31 05:46:29.000000000 +0100
+++ linux/fs/xfs/xfs_rw.h       2004-01-02 04:21:43.000000000 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
@@ -32,16 +32,9 @@
 #ifndef        __XFS_RW_H__
 #define        __XFS_RW_H__
 
-struct bhv_desc;
-struct bmapval;
 struct xfs_buf;
-struct cred;
-struct uio;
-struct vnode;
 struct xfs_inode;
-struct xfs_iocore;
 struct xfs_mount;
-struct xfs_trans;
 
 /*
  * Maximum count of bmaps used by read and write paths.
@@ -91,44 +84,6 @@
                 XFS_FSB_TO_DADDR((io)->io_mount, (fsb)))
 
 /*
- * Defines for the trace mechanisms in xfs_rw.c.
- */
-#define        XFS_RW_KTRACE_SIZE      64
-#define        XFS_STRAT_KTRACE_SIZE   64
-#define        XFS_STRAT_GTRACE_SIZE   512
-
-#define        XFS_READ_ENTER          1
-#define        XFS_WRITE_ENTER         2
-#define XFS_IOMAP_READ_ENTER   3
-#define        XFS_IOMAP_WRITE_ENTER   4
-#define        XFS_IOMAP_READ_MAP      5
-#define        XFS_IOMAP_WRITE_MAP     6
-#define        XFS_IOMAP_WRITE_NOSPACE 7
-#define        XFS_ITRUNC_START        8
-#define        XFS_ITRUNC_FINISH1      9
-#define        XFS_ITRUNC_FINISH2      10
-#define        XFS_CTRUNC1             11
-#define        XFS_CTRUNC2             12
-#define        XFS_CTRUNC3             13
-#define        XFS_CTRUNC4             14
-#define        XFS_CTRUNC5             15
-#define        XFS_CTRUNC6             16
-#define        XFS_BUNMAPI             17
-#define        XFS_INVAL_CACHED        18
-#define        XFS_DIORD_ENTER         19
-#define        XFS_DIOWR_ENTER         20
-
-#if defined(XFS_ALL_TRACE)
-#define        XFS_RW_TRACE
-#define        XFS_STRAT_TRACE
-#endif
-
-#if !defined(DEBUG)
-#undef XFS_RW_TRACE
-#undef XFS_STRAT_TRACE
-#endif
-
-/*
  * Prototypes for functions in xfs_rw.c.
  */
 
@@ -141,14 +96,6 @@
        struct xfs_mount        *mp,
        struct xfs_buf          *bp);
 
-void
-xfs_inval_cached_pages(
-       struct vnode            *vp,
-       struct xfs_iocore       *io,
-       xfs_off_t               offset,
-       int                     write,
-       int                     relock);
-
 int
 xfs_bioerror(
        struct xfs_buf          *b);
diff -urN linux.org/fs/xfs/xfs_trans.c linux/fs/xfs/xfs_trans.c
--- linux.org/fs/xfs/xfs_trans.c        2003-12-31 05:47:13.000000000 +0100
+++ linux/fs/xfs/xfs_trans.c    2004-01-02 04:21:43.000000000 +0100
@@ -142,9 +142,9 @@
        uint            type)
 {
        xfs_trans_t     *tp;
+
        ASSERT(xfs_trans_zone != NULL);
        tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
-       tp->t_dqinfo = NULL;
 
        /*
         * Initialize the transaction structure.
diff -urN linux.org/fs/xfs/xfs_vfsops.c linux/fs/xfs/xfs_vfsops.c
--- linux.org/fs/xfs/xfs_vfsops.c       2003-12-31 05:46:41.000000000 +0100
+++ linux/fs/xfs/xfs_vfsops.c   2004-01-02 04:21:43.000000000 +0100
@@ -60,6 +60,7 @@
 #include "xfs_bmap.h"
 #include "xfs_da_btree.h"
 #include "xfs_rw.h"
+#include "xfs_refcache.h"
 #include "xfs_buf_item.h"
 #include "xfs_extfree_item.h"
 #include "xfs_quota.h"
@@ -74,24 +75,11 @@
 int
 xfs_init(void)
 {
-       extern kmem_zone_t      *xfs_da_state_zone;
        extern kmem_zone_t      *xfs_bmap_free_item_zone;
        extern kmem_zone_t      *xfs_btree_cur_zone;
-       extern kmem_zone_t      *xfs_inode_zone;
-       extern kmem_zone_t      *xfs_chashlist_zone;
        extern kmem_zone_t      *xfs_trans_zone;
        extern kmem_zone_t      *xfs_buf_item_zone;
-       extern kmem_zone_t      *xfs_efd_zone;
-       extern kmem_zone_t      *xfs_efi_zone;
        extern kmem_zone_t      *xfs_dabuf_zone;
-#ifdef DEBUG_NOT
-       extern ktrace_t         *xfs_alloc_trace_buf;
-       extern ktrace_t         *xfs_bmap_trace_buf;
-       extern ktrace_t         *xfs_bmbt_trace_buf;
-       extern ktrace_t         *xfs_dir_trace_buf;
-       extern ktrace_t         *xfs_attr_trace_buf;
-       extern ktrace_t         *xfs_dir2_trace_buf;
-#endif /* DEBUG */
 #ifdef XFS_DABUF_DEBUG
        extern lock_t           xfs_dabuf_global_lock;
        spinlock_init(&xfs_dabuf_global_lock, "xfsda");
@@ -132,14 +120,6 @@
                                            "xfs_chashlist");
        _ACL_ZONE_INIT(xfs_acl_zone, "xfs_acl");
 
-#ifdef CONFIG_XFS_VNODE_TRACING
-       ktrace_init(VNODE_TRACE_SIZE);
-#else
-#ifdef DEBUG
-       ktrace_init(64);
-#endif
-#endif
-
        /*
         * Allocate global trace buffers.
         */
@@ -189,6 +169,7 @@
 
        xfs_cleanup_procfs();
        xfs_sysctl_unregister();
+       xfs_refcache_destroy();
 
        kmem_cache_destroy(xfs_bmap_free_item_zone);
        kmem_cache_destroy(xfs_btree_cur_zone);
@@ -203,9 +184,6 @@
        kmem_cache_destroy(xfs_ili_zone);
        kmem_cache_destroy(xfs_chashlist_zone);
        _ACL_ZONE_DESTROY(xfs_acl_zone);
-#if  (defined(DEBUG) || defined(CONFIG_XFS_VNODE_TRACING))
-       ktrace_uninit();
-#endif
 }
 
 /*
@@ -547,6 +525,12 @@
                                        0 : DM_FLAGS_UNWANTED;
        }
 
+       /*
+        * First blow any referenced inode from this file system
+        * out of the reference cache, and delete the timer.
+        */
+       xfs_refcache_purge_mp(mp);
+
        XFS_bflush(mp->m_ddev_targp);
        error = xfs_unmount_flush(mp, 0);
        if (error)
@@ -617,6 +601,7 @@
        }
 
        if (*flags & MS_RDONLY) {
+               xfs_refcache_purge_mp(mp);
                pagebuf_delwri_flush(mp->m_ddev_targp, 0, NULL);
                xfs_finish_reclaim_all(mp, 0);
 
@@ -758,7 +743,7 @@
 STATIC int
 xfs_statvfs(
        bhv_desc_t      *bdp,
-       struct kstatfs  *statp,
+       xfs_statfs_t    *statp,
        vnode_t         *vp)
 {
        __uint64_t      fakeinos;
@@ -766,7 +751,6 @@
        xfs_mount_t     *mp;
        xfs_sb_t        *sbp;
        unsigned long   s;
-       u64 id;
 
        mp = XFS_BHVTOM(bdp);
        sbp = &(mp->m_sb);
@@ -793,9 +777,8 @@
        statp->f_ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree);
        XFS_SB_UNLOCK(mp, s);
 
-       id = huge_encode_dev(mp->m_dev);
-       statp->f_fsid.val[0] = (u32)id;
-       statp->f_fsid.val[1] = (u32)(id >> 32);
+       statp->f_fsid.val[0] = mp->m_dev;
+       statp->f_fsid.val[1] = 0;
        statp->f_namelen = MAXNAMELEN - 1;
 
        return 0;
@@ -1489,8 +1472,18 @@
        }
 
        /*
+        * If this is the periodic sync, then kick some entries out of
+        * the reference cache.  This ensures that idle entries are
+        * eventually kicked out of the cache.
+        */
+       if (flags & SYNC_REFCACHE) {
+               xfs_refcache_purge_some(mp);
+       }
+
+       /*
         * Now check to see if the log needs a "dummy" transaction.
         */
+
        if (!(flags & SYNC_REMOUNT) && xfs_log_need_covered(mp)) {
                xfs_trans_t *tp;
                xfs_inode_t *ip;
@@ -1784,10 +1782,14 @@
                char    *str;
        } xfs_info[] = {
                /* the few simple ones we can get from the mount struct */
+               { XFS_MOUNT_WSYNC,              "," MNTOPT_WSYNC },
+               { XFS_MOUNT_INO64,              "," MNTOPT_INO64 },
                { XFS_MOUNT_NOALIGN,            "," MNTOPT_NOALIGN },
+               { XFS_MOUNT_NOUUID,             "," MNTOPT_NOUUID },
                { XFS_MOUNT_NORECOVERY,         "," MNTOPT_NORECOVERY },
                { XFS_MOUNT_OSYNCISOSYNC,       "," MNTOPT_OSYNCISOSYNC },
-               { XFS_MOUNT_NOUUID,             "," MNTOPT_NOUUID },
+               { XFS_MOUNT_NOLOGFLUSH,         "," MNTOPT_NOLOGFLUSH },
+               { XFS_MOUNT_IDELETE,            "," MNTOPT_NOIKEEP },
                { 0, NULL }
        };
        struct proc_xfs_info    *xfs_infop;
@@ -1823,6 +1825,9 @@
                seq_printf(m, "," MNTOPT_SWIDTH "=%d",
                                (int)XFS_FSB_TO_BB(mp, mp->m_swidth));
 
+       if (!(mp->m_flags & XFS_MOUNT_32BITINOOPT))
+               seq_printf(m, "," MNTOPT_64BITINODE);
+       
        return 0;
 }
 
@@ -1840,6 +1845,7 @@
        .vfs_vget               = xfs_vget,
        .vfs_dmapiops           = (vfs_dmapiops_t)fs_nosys,
        .vfs_quotactl           = (vfs_quotactl_t)fs_nosys,
+       .vfs_get_inode          = xfs_get_inode,
        .vfs_init_vnode         = xfs_initialize_vnode,
        .vfs_force_shutdown     = xfs_do_force_shutdown,
 };
diff -urN linux.org/fs/xfs/xfs_vnodeops.c linux/fs/xfs/xfs_vnodeops.c
--- linux.org/fs/xfs/xfs_vnodeops.c     2003-12-31 05:48:49.000000000 +0100
+++ linux/fs/xfs/xfs_vnodeops.c 2004-01-02 04:21:43.000000000 +0100
@@ -59,6 +59,7 @@
 #include "xfs_da_btree.h"
 #include "xfs_attr.h"
 #include "xfs_rw.h"
+#include "xfs_refcache.h"
 #include "xfs_error.h"
 #include "xfs_bit.h"
 #include "xfs_rtalloc.h"
@@ -77,10 +78,6 @@
  */
 #define SYMLINK_MAPS 2
 
-extern int xfs_ioctl(bhv_desc_t *, struct inode *, struct file *,
-                       int, unsigned int, unsigned long);
-
-
 /*
  * For xfs, we check that the file isn't too big to be opened by this kernel.
  * No other open action is required for regular files.  Devices are handled
@@ -434,7 +431,7 @@
        }
 
        /* boolean: are we the file owner? */
-       file_owner = (current->fsuid == ip->i_d.di_uid);
+       file_owner = (current_fsuid(credp) == ip->i_d.di_uid);
 
        /*
         * Change various properties of a file.
@@ -1660,6 +1657,12 @@
        if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
                return 0;
 
+#ifdef HAVE_REFCACHE
+       /* If we are in the NFS reference cache then don't do this now */
+       if (ip->i_refcache)
+               return 0;
+#endif
+
        mp = ip->i_mount;
 
        if (ip->i_d.di_nlink != 0) {
@@ -2004,7 +2007,8 @@
        /*
         * Make sure that we have allocated dquot(s) on disk.
         */
-       error = XFS_QM_DQVOPALLOC(mp, dp, current->fsuid, current->fsgid,
+       error = XFS_QM_DQVOPALLOC(mp, dp,
+                       current_fsuid(credp), current_fsgid(credp),
                        XFS_QMOPT_QUOTALL|XFS_QMOPT_INHERIT, &udqp, &gdqp);
        if (error)
                goto std_return;
@@ -2613,6 +2617,14 @@
                goto std_return;
        }
 
+       /*
+        * Before we drop our extra reference to the inode, purge it
+        * from the refcache if it is there.  By waiting until afterwards
+        * to do the IRELE, we ensure that we won't go inactive in the
+        * xfs_refcache_purge_ip routine (although that would be OK).
+        */
+       xfs_refcache_purge_ip(ip);
+
        vn_trace_exit(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
 
        /*
@@ -2652,6 +2664,14 @@
        cancel_flags |= XFS_TRANS_ABORT;
        xfs_trans_cancel(tp, cancel_flags);
 
+       /*
+        * Before we drop our extra reference to the inode, purge it
+        * from the refcache if it is there.  By waiting until afterwards
+        * to do the IRELE, we ensure that we won't go inactive in the
+        * xfs_refcache_purge_ip routine (although that would be OK).
+        */
+       xfs_refcache_purge_ip(ip);
+
        IRELE(ip);
 
        goto std_return;
@@ -2899,7 +2919,8 @@
        /*
         * Make sure that we have allocated dquot(s) on disk.
         */
-       error = XFS_QM_DQVOPALLOC(mp, dp, current->fsuid, current->fsgid,
+       error = XFS_QM_DQVOPALLOC(mp, dp,
+                       current_fsuid(credp), current_fsgid(credp),
                        XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
        if (error)
                goto std_return;
@@ -3456,7 +3477,8 @@
        /*
         * Make sure that we have allocated dquot(s) on disk.
         */
-       error = XFS_QM_DQVOPALLOC(mp, dp, current->fsuid, current->fsgid,
+       error = XFS_QM_DQVOPALLOC(mp, dp,
+                       current_fsuid(credp), current_fsgid(credp),
                        XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
        if (error)
                goto std_return;
@@ -3743,7 +3765,14 @@
                return;
        ip = XFS_BHVTOI(bdp);
        if (locktype == VRWLOCK_WRITE) {
-               xfs_iunlock (ip, XFS_IOLOCK_EXCL);
+               /*
+                * In the write case, we may have added a new entry to
+                * the reference cache.  This might store a pointer to
+                * an inode to be released in this inode.  If it is there,
+                * clear the pointer and release the inode after unlocking
+                * this one.
+                */
+               xfs_refcache_iunlock(ip, XFS_IOLOCK_EXCL);
        } else {
                ASSERT((locktype == VRWLOCK_READ) ||
                       (locktype == VRWLOCK_WRITE_DIRECT));
@@ -4738,7 +4767,9 @@
        BHV_IDENTITY_INIT(VN_BHV_XFS,VNODE_POSITION_XFS),
        .vop_open               = xfs_open,
        .vop_read               = xfs_read,
+#ifdef HAVE_SENDFILE
        .vop_sendfile           = xfs_sendfile,
+#endif
        .vop_write              = xfs_write,
        .vop_ioctl              = xfs_ioctl,
        .vop_getattr            = xfs_getattr,