Merge git://oss.sgi.com:8090/xfs/xfs-2.6

* git://oss.sgi.com:8090/xfs/xfs-2.6: (49 commits)
  [XFS] Remove v1 dir trace macro - missed in a past commit.
  [XFS] 955947: Infinite loop in xfs_bulkstat() on formatter() error
  [XFS] pv 956241, author: nathans, rv: vapo - make ino validation checks
  [XFS] pv 956240, author: nathans, rv: vapo - Minor fixes in
  [XFS] Really fix use after free in xfs_iunpin.
  [XFS] Collapse sv_init and init_sv into just the one interface.
  [XFS] standardize on one sema init macro
  [XFS] Reduce endian flipping in alloc_btree, same as was done for
  [XFS] Minor cleanup from dio locking fix, remove an extra conditional.
  [XFS] Fix kmem_zalloc_greedy warnings on 64 bit platforms.
  [XFS] pv 955157, rv bnaujok - break the loop on EFAULT formatter() error
  [XFS] pv 955157, rv bnaujok - break the loop on formatter() error
  [XFS] Fixes the leak in reservation space because we weren't ungranting
  [XFS] Add lock annotations to xfs_trans_update_ail and
  [XFS] Fix a porting botch on the realtime subvol growfs code path.
  [XFS] Minor code rearranging and cleanup to prevent some coverity false
  [XFS] Remove a no-longer-correct debug assert from dio completion
  [XFS] Add a greedy allocation interface, allocating within a min/max size
  [XFS] Improve error handling for the zero-fsblock extent detection code.
  [XFS] Be more defensive with page flags (error/private) for metadata
  ...

15 files changed, 110 insertions, 72 deletions

diff --git a/fs/xfs/linux-2.6/kmem.c b/fs/xfs/linux-2.6/kmem.c
index aba7fcf881a2..d59737589815 100644
--- a/fs/xfs/linux-2.6/kmem.c
+++ b/fs/xfs/linux-2.6/kmem.c
@@ -34,6 +34,14 @@ kmem_alloc(size_t size, unsigned int __nocast flags)
         gfp_t   lflags = kmem_flags_convert(flags);
         void    *ptr;
 
+#ifdef DEBUG
+        if (unlikely(!(flags & KM_LARGE) && (size > PAGE_SIZE))) {
+                printk(KERN_WARNING "Large %s attempt, size=%ld\n",
+                        __FUNCTION__, (long)size);
+                dump_stack();
+        }
+#endif
+
         do {
                 if (size < MAX_SLAB_SIZE || retries > MAX_VMALLOCS)
                         ptr = kmalloc(size, lflags);
@@ -60,6 +68,27 @@ kmem_zalloc(size_t size, unsigned int __nocast flags)
         return ptr;
 }
 
+void *
+kmem_zalloc_greedy(size_t *size, size_t minsize, size_t maxsize,
+                   unsigned int __nocast flags)
+{
+        void            *ptr;
+        size_t          kmsize = maxsize;
+        unsigned int    kmflags = (flags & ~KM_SLEEP) | KM_NOSLEEP;
+
+        while (!(ptr = kmem_zalloc(kmsize, kmflags))) {
+                if ((kmsize <= minsize) && (flags & KM_NOSLEEP))
+                        break;
+                if ((kmsize >>= 1) <= minsize) {
+                        kmsize = minsize;
+                        kmflags = flags;
+                }
+        }
+        if (ptr)
+                *size = kmsize;
+        return ptr;
+}
+
 void
 kmem_free(void *ptr, size_t size)
 {
diff --git a/fs/xfs/linux-2.6/kmem.h b/fs/xfs/linux-2.6/kmem.h
index 0e8293c5a32f..9ebabdf7829c 100644
--- a/fs/xfs/linux-2.6/kmem.h
+++ b/fs/xfs/linux-2.6/kmem.h
@@ -30,6 +30,7 @@
 #define KM_NOSLEEP      0x0002u
 #define KM_NOFS         0x0004u
 #define KM_MAYFAIL      0x0008u
+#define KM_LARGE        0x0010u
 
 /*
  * We use a special process flag to avoid recursive callbacks into
@@ -41,7 +42,7 @@ kmem_flags_convert(unsigned int __nocast flags)
 {
         gfp_t   lflags;
 
-        BUG_ON(flags & ~(KM_SLEEP|KM_NOSLEEP|KM_NOFS|KM_MAYFAIL));
+        BUG_ON(flags & ~(KM_SLEEP|KM_NOSLEEP|KM_NOFS|KM_MAYFAIL|KM_LARGE));
 
         if (flags & KM_NOSLEEP) {
                 lflags = GFP_ATOMIC | __GFP_NOWARN;
@@ -54,8 +55,9 @@ kmem_flags_convert(unsigned int __nocast flags)
 }
 
 extern void *kmem_alloc(size_t, unsigned int __nocast);
-extern void *kmem_realloc(void *, size_t, size_t, unsigned int __nocast);
 extern void *kmem_zalloc(size_t, unsigned int __nocast);
+extern void *kmem_zalloc_greedy(size_t *, size_t, size_t, unsigned int __nocast);
+extern void *kmem_realloc(void *, size_t, size_t, unsigned int __nocast);
 extern void  kmem_free(void *, size_t);
 
 /*
diff --git a/fs/xfs/linux-2.6/sema.h b/fs/xfs/linux-2.6/sema.h
index b25090094cca..2009e6d922ce 100644
--- a/fs/xfs/linux-2.6/sema.h
+++ b/fs/xfs/linux-2.6/sema.h
@@ -29,8 +29,6 @@
 
 typedef struct semaphore sema_t;
 
-#define init_sema(sp, val, c, d)        sema_init(sp, val)
-#define initsema(sp, val)               sema_init(sp, val)
 #define initnsema(sp, val, name)        sema_init(sp, val)
 #define psema(sp, b)                    down(sp)
 #define vsema(sp)                       up(sp)
diff --git a/fs/xfs/linux-2.6/sv.h b/fs/xfs/linux-2.6/sv.h
index 9a8ad481b008..351a8f454bd1 100644
--- a/fs/xfs/linux-2.6/sv.h
+++ b/fs/xfs/linux-2.6/sv.h
@@ -53,8 +53,6 @@ static inline void _sv_wait(sv_t *sv, spinlock_t *lock, int state,
         remove_wait_queue(&sv->waiters, &wait);
 }
 
-#define init_sv(sv,type,name,flag) \
-        init_waitqueue_head(&(sv)->waiters)
 #define sv_init(sv,flag,name) \
         init_waitqueue_head(&(sv)->waiters)
 #define sv_destroy(sv) \
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 34dcb43a7837..09360cf1e1f2 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -71,7 +71,7 @@ xfs_page_trace(
         int             tag,
         struct inode    *inode,
         struct page     *page,
-        int             mask)
+        unsigned long   pgoff)
 {
         xfs_inode_t     *ip;
         bhv_vnode_t     *vp = vn_from_inode(inode);
@@ -91,7 +91,7 @@ xfs_page_trace(
                 (void *)ip,
                 (void *)inode,
                 (void *)page,
-                (void *)((unsigned long)mask),
+                (void *)pgoff,
                 (void *)((unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff)),
                 (void *)((unsigned long)(ip->i_d.di_size & 0xffffffff)),
                 (void *)((unsigned long)((isize >> 32) & 0xffffffff)),
@@ -105,7 +105,7 @@ xfs_page_trace(
                 (void *)NULL);
 }
 #else
-#define xfs_page_trace(tag, inode, page, mask)
+#define xfs_page_trace(tag, inode, page, pgoff)
 #endif
 
 /*
@@ -1197,7 +1197,7 @@ xfs_vm_releasepage(
                 .nr_to_write = 1,
         };
 
-        xfs_page_trace(XFS_RELEASEPAGE_ENTER, inode, page, gfp_mask);
+        xfs_page_trace(XFS_RELEASEPAGE_ENTER, inode, page, 0);
 
         if (!page_has_buffers(page))
                 return 0;
@@ -1356,7 +1356,6 @@ xfs_end_io_direct(
                 ioend->io_size = size;
                 xfs_finish_ioend(ioend);
         } else {
-                ASSERT(size >= 0);
                 xfs_destroy_ioend(ioend);
         }
 
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 2af528dcfb04..9bbadafdcb00 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -318,8 +318,12 @@ xfs_buf_free(
                 if ((bp->b_flags & XBF_MAPPED) && (bp->b_page_count > 1))
                         free_address(bp->b_addr - bp->b_offset);
 
-                for (i = 0; i < bp->b_page_count; i++)
-                        page_cache_release(bp->b_pages[i]);
+                for (i = 0; i < bp->b_page_count; i++) {
+                        struct page     *page = bp->b_pages[i];
+
+                        ASSERT(!PagePrivate(page));
+                        page_cache_release(page);
+                }
                 _xfs_buf_free_pages(bp);
         } else if (bp->b_flags & _XBF_KMEM_ALLOC) {
                  /*
@@ -400,6 +404,7 @@ _xfs_buf_lookup_pages(
                 nbytes = min_t(size_t, size, PAGE_CACHE_SIZE - offset);
                 size -= nbytes;
 
+                ASSERT(!PagePrivate(page));
                 if (!PageUptodate(page)) {
                         page_count--;
                         if (blocksize >= PAGE_CACHE_SIZE) {
@@ -768,7 +773,7 @@ xfs_buf_get_noaddr(
         _xfs_buf_initialize(bp, target, 0, len, 0);
 
  try_again:
-        data = kmem_alloc(malloc_len, KM_SLEEP | KM_MAYFAIL);
+        data = kmem_alloc(malloc_len, KM_SLEEP | KM_MAYFAIL | KM_LARGE);
         if (unlikely(data == NULL))
                 goto fail_free_buf;
 
@@ -1117,10 +1122,10 @@ xfs_buf_bio_end_io(
         do {
                 struct page     *page = bvec->bv_page;
 
+                ASSERT(!PagePrivate(page));
                 if (unlikely(bp->b_error)) {
                         if (bp->b_flags & XBF_READ)
                                 ClearPageUptodate(page);
-                        SetPageError(page);
                 } else if (blocksize >= PAGE_CACHE_SIZE) {
                         SetPageUptodate(page);
                 } else if (!PagePrivate(page) &&
@@ -1156,16 +1161,16 @@ _xfs_buf_ioapply(
         total_nr_pages = bp->b_page_count;
         map_i = 0;
 
-        if (bp->b_flags & _XBF_RUN_QUEUES) {
-                bp->b_flags &= ~_XBF_RUN_QUEUES;
-                rw = (bp->b_flags & XBF_READ) ? READ_SYNC : WRITE_SYNC;
-        } else {
-                rw = (bp->b_flags & XBF_READ) ? READ : WRITE;
-        }
-
         if (bp->b_flags & XBF_ORDERED) {
                 ASSERT(!(bp->b_flags & XBF_READ));
                 rw = WRITE_BARRIER;
+        } else if (bp->b_flags & _XBF_RUN_QUEUES) {
+                ASSERT(!(bp->b_flags & XBF_READ_AHEAD));
+                bp->b_flags &= ~_XBF_RUN_QUEUES;
+                rw = (bp->b_flags & XBF_WRITE) ? WRITE_SYNC : READ_SYNC;
+        } else {
+                rw = (bp->b_flags & XBF_WRITE) ? WRITE :
+                     (bp->b_flags & XBF_READ_AHEAD) ? READA : READ;
         }
 
         /* Special code path for reading a sub page size buffer in --
@@ -1681,6 +1686,7 @@ xfsbufd(
         xfs_buf_t               *bp, *n;
         struct list_head        *dwq = &target->bt_delwrite_queue;
         spinlock_t              *dwlk = &target->bt_delwrite_lock;
+        int                     count;
 
         current->flags |= PF_MEMALLOC;
 
@@ -1696,6 +1702,7 @@ xfsbufd(
                 schedule_timeout_interruptible(
                         xfs_buf_timer_centisecs * msecs_to_jiffies(10));
 
+                count = 0;
                 age = xfs_buf_age_centisecs * msecs_to_jiffies(10);
                 spin_lock(dwlk);
                 list_for_each_entry_safe(bp, n, dwq, b_list) {
@@ -1711,9 +1718,11 @@ xfsbufd(
                                         break;
                                 }
 
-                                bp->b_flags &= ~(XBF_DELWRI|_XBF_DELWRI_Q);
+                                bp->b_flags &= ~(XBF_DELWRI|_XBF_DELWRI_Q|
+                                                 _XBF_RUN_QUEUES);
                                 bp->b_flags |= XBF_WRITE;
-                                list_move(&bp->b_list, &tmp);
+                                list_move_tail(&bp->b_list, &tmp);
+                                count++;
                         }
                 }
                 spin_unlock(dwlk);
@@ -1724,12 +1733,12 @@ xfsbufd(
 
                         list_del_init(&bp->b_list);
                         xfs_buf_iostrategy(bp);
-
-                        blk_run_address_space(target->bt_mapping);
                 }
 
                 if (as_list_len > 0)
                         purge_addresses();
+                if (count)
+                        blk_run_address_space(target->bt_mapping);
 
                 clear_bit(XBT_FORCE_FLUSH, &target->bt_flags);
         } while (!kthread_should_stop());
@@ -1767,7 +1776,7 @@ xfs_flush_buftarg(
                         continue;
                 }
 
-                list_move(&bp->b_list, &tmp);
+                list_move_tail(&bp->b_list, &tmp);
         }
         spin_unlock(dwlk);
 
@@ -1776,7 +1785,7 @@ xfs_flush_buftarg(
          */
         list_for_each_entry_safe(bp, n, &tmp, b_list) {
                 xfs_buf_lock(bp);
-                bp->b_flags &= ~(XBF_DELWRI|_XBF_DELWRI_Q);
+                bp->b_flags &= ~(XBF_DELWRI|_XBF_DELWRI_Q|_XBF_RUN_QUEUES);
                 bp->b_flags |= XBF_WRITE;
                 if (wait)
                         bp->b_flags &= ~XBF_ASYNC;
@@ -1786,6 +1795,9 @@ xfs_flush_buftarg(
                 xfs_buf_iostrategy(bp);
         }
 
+        if (wait)
+                blk_run_address_space(target->bt_mapping);
+
         /*
          * Remaining list items must be flushed before returning
          */
@@ -1797,9 +1809,6 @@ xfs_flush_buftarg(
                 xfs_buf_relse(bp);
         }
 
-        if (wait)
-                blk_run_address_space(target->bt_mapping);
-
         return pincount;
 }
 
diff --git a/fs/xfs/linux-2.6/xfs_buf.h b/fs/xfs/linux-2.6/xfs_buf.h
index 7858703ed84c..9dd235cb0107 100644
--- a/fs/xfs/linux-2.6/xfs_buf.h
+++ b/fs/xfs/linux-2.6/xfs_buf.h
@@ -298,11 +298,6 @@ extern void xfs_buf_trace(xfs_buf_t *, char *, void *, void *);
 #define XFS_BUF_UNWRITE(bp)     ((bp)->b_flags &= ~XBF_WRITE)
 #define XFS_BUF_ISWRITE(bp)     ((bp)->b_flags & XBF_WRITE)
 
-#define XFS_BUF_ISUNINITIAL(bp) (0)
-#define XFS_BUF_UNUNINITIAL(bp) (0)
-
-#define XFS_BUF_BP_ISMAPPED(bp) (1)
-
 #define XFS_BUF_IODONE_FUNC(bp)                 ((bp)->b_iodone)
 #define XFS_BUF_SET_IODONE_FUNC(bp, func)       ((bp)->b_iodone = (func))
 #define XFS_BUF_CLR_IODONE_FUNC(bp)             ((bp)->b_iodone = NULL)
@@ -393,8 +388,6 @@ static inline int XFS_bwrite(xfs_buf_t *bp)
         return error;
 }
 
-#define XFS_bdwrite(bp)         xfs_buf_iostart(bp, XBF_DELWRI | XBF_ASYNC)
-
 static inline int xfs_bdwrite(void *mp, xfs_buf_t *bp)
 {
         bp->b_strat = xfs_bdstrat_cb;
diff --git a/fs/xfs/linux-2.6/xfs_globals.c b/fs/xfs/linux-2.6/xfs_globals.c
index 6c162c3dde7e..ed3a5e1b4b67 100644
--- a/fs/xfs/linux-2.6/xfs_globals.c
+++ b/fs/xfs/linux-2.6/xfs_globals.c
@@ -34,7 +34,7 @@ xfs_param_t xfs_params = {
         .restrict_chown = {     0,              1,              1       },
         .sgid_inherit   = {     0,              0,              1       },
         .symlink_mode   = {     0,              0,              1       },
-        .panic_mask     = {     0,              0,              127     },
+        .panic_mask     = {     0,              0,              255     },
         .error_level    = {     0,              3,              11      },
         .syncd_timer    = {     1*100,          30*100,         7200*100},
         .stats_clear    = {     0,              0,              1       },
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 6e52a5dd38d8..a74f854d91e6 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -653,7 +653,7 @@ xfs_attrmulti_by_handle(
 STATIC int
 xfs_ioc_space(
         bhv_desc_t              *bdp,
-        bhv_vnode_t             *vp,
+        struct inode            *inode,
         struct file             *filp,
         int                     flags,
         unsigned int            cmd,
@@ -735,7 +735,7 @@ xfs_ioctl(
                     !capable(CAP_SYS_ADMIN))
                         return -EPERM;
 
-                return xfs_ioc_space(bdp, vp, filp, ioflags, cmd, arg);
+                return xfs_ioc_space(bdp, inode, filp, ioflags, cmd, arg);
 
         case XFS_IOC_DIOINFO: {
                 struct dioattr  da;
@@ -763,6 +763,8 @@ xfs_ioctl(
                 return xfs_ioc_fsgeometry(mp, arg);
 
         case XFS_IOC_GETVERSION:
+                return put_user(inode->i_generation, (int __user *)arg);
+
         case XFS_IOC_GETXFLAGS:
         case XFS_IOC_SETXFLAGS:
         case XFS_IOC_FSGETXATTR:
@@ -957,7 +959,7 @@ xfs_ioctl(
 STATIC int
 xfs_ioc_space(
         bhv_desc_t              *bdp,
-        bhv_vnode_t             *vp,
+        struct inode            *inode,
         struct file             *filp,
         int                     ioflags,
         unsigned int            cmd,
@@ -967,13 +969,13 @@ xfs_ioc_space(
         int                     attr_flags = 0;
         int                     error;
 
-        if (vp->v_inode.i_flags & (S_IMMUTABLE|S_APPEND))
+        if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
                 return -XFS_ERROR(EPERM);
 
         if (!(filp->f_mode & FMODE_WRITE))
                 return -XFS_ERROR(EBADF);
 
-        if (!VN_ISREG(vp))
+        if (!S_ISREG(inode->i_mode))
                 return -XFS_ERROR(EINVAL);
 
         if (copy_from_user(&bf, arg, sizeof(bf)))
@@ -1264,13 +1266,6 @@ xfs_ioc_xattr(
                 break;
         }
 
-        case XFS_IOC_GETVERSION: {
-                flags = vn_to_inode(vp)->i_generation;
-                if (copy_to_user(arg, &flags, sizeof(flags)))
-                        error = -EFAULT;
-                break;
-        }
-
         default:
                 error = -ENOTTY;
                 break;
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 22e3b714f629..3ba814ae3bba 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -623,12 +623,27 @@ xfs_vn_getattr(
 {
         struct inode    *inode = dentry->d_inode;
         bhv_vnode_t     *vp = vn_from_inode(inode);
-        int             error = 0;
+        bhv_vattr_t     vattr = { .va_mask = XFS_AT_STAT };
+        int             error;
 
-        if (unlikely(vp->v_flag & VMODIFIED))
-                error = vn_revalidate(vp);
-        if (!error)
-                generic_fillattr(inode, stat);
+        error = bhv_vop_getattr(vp, &vattr, ATTR_LAZY, NULL);
+        if (likely(!error)) {
+                stat->size = i_size_read(inode);
+                stat->dev = inode->i_sb->s_dev;
+                stat->rdev = (vattr.va_rdev == 0) ? 0 :
+                                MKDEV(sysv_major(vattr.va_rdev) & 0x1ff,
+                                      sysv_minor(vattr.va_rdev));
+                stat->mode = vattr.va_mode;
+                stat->nlink = vattr.va_nlink;
+                stat->uid = vattr.va_uid;
+                stat->gid = vattr.va_gid;
+                stat->ino = vattr.va_nodeid;
+                stat->atime = vattr.va_atime;
+                stat->mtime = vattr.va_mtime;
+                stat->ctime = vattr.va_ctime;
+                stat->blocks = vattr.va_nblocks;
+                stat->blksize = vattr.va_blocksize;
+        }
         return -error;
 }
 
diff --git a/fs/xfs/linux-2.6/xfs_linux.h b/fs/xfs/linux-2.6/xfs_linux.h
index a13f75c1a936..2b0e0018738a 100644
--- a/fs/xfs/linux-2.6/xfs_linux.h
+++ b/fs/xfs/linux-2.6/xfs_linux.h
@@ -148,11 +148,7 @@ BUFFER_FNS(PrivateStart, unwritten);
                 (current->flags = ((current->flags & ~(f)) | (*(sp) & (f))))
 
 #define NBPP            PAGE_SIZE
-#define DPPSHFT         (PAGE_SHIFT - 9)
 #define NDPP            (1 << (PAGE_SHIFT - 9))
-#define dtop(DD)        (((DD) + NDPP - 1) >> DPPSHFT)
-#define dtopt(DD)       ((DD) >> DPPSHFT)
-#define dpoff(DD)       ((DD) & (NDPP-1))
 
 #define NBBY            8               /* number of bits per byte */
 #define NBPC            PAGE_SIZE       /* Number of bytes per click */
@@ -172,8 +168,6 @@ BUFFER_FNS(PrivateStart, unwritten);
 #define btoct(x)        ((__psunsigned_t)(x)>>BPCSHIFT)
 #define btoc64(x)       (((__uint64_t)(x)+(NBPC-1))>>BPCSHIFT)
 #define btoct64(x)      ((__uint64_t)(x)>>BPCSHIFT)
-#define io_btoc(x)      (((__psunsigned_t)(x)+(IO_NBPC-1))>>IO_BPCSHIFT)
-#define io_btoct(x)     ((__psunsigned_t)(x)>>IO_BPCSHIFT)
 
 /* off_t bytes to clicks */
 #define offtoc(x)       (((__uint64_t)(x)+(NBPC-1))>>BPCSHIFT)
@@ -186,7 +180,6 @@ BUFFER_FNS(PrivateStart, unwritten);
 #define ctob(x)         ((__psunsigned_t)(x)<<BPCSHIFT)
 #define btoct(x)        ((__psunsigned_t)(x)>>BPCSHIFT)
 #define ctob64(x)       ((__uint64_t)(x)<<BPCSHIFT)
-#define io_ctob(x)      ((__psunsigned_t)(x)<<IO_BPCSHIFT)
 
 /* bytes to clicks */
 #define btoc(x)         (((__psunsigned_t)(x)+(NBPC-1))>>BPCSHIFT)
@@ -339,4 +332,11 @@ static inline __uint64_t roundup_64(__uint64_t x, __uint32_t y)
         return(x * y);
 }
 
+static inline __uint64_t howmany_64(__uint64_t x, __uint32_t y)
+{
+        x += y - 1;
+        do_div(x, y);
+        return x;
+}
+
 #endif /* __XFS_LINUX__ */
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index ee788b1cb364..55992b40353c 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -270,12 +270,12 @@ xfs_read(
                 }
         }
 
-        if (unlikely((ioflags & IO_ISDIRECT) && VN_CACHED(vp)))
-                bhv_vop_flushinval_pages(vp, ctooff(offtoct(*offset)),
-                                                -1, FI_REMAPF_LOCKED);
-
-        if (unlikely(ioflags & IO_ISDIRECT))
+        if (unlikely(ioflags & IO_ISDIRECT)) {
+                if (VN_CACHED(vp))
+                        bhv_vop_flushinval_pages(vp, ctooff(offtoct(*offset)),
+                                                 -1, FI_REMAPF_LOCKED);
                 mutex_unlock(&inode->i_mutex);
+        }
 
         xfs_rw_enter_trace(XFS_READ_ENTER, &ip->i_iocore,
                                 (void *)iovp, segs, *offset, ioflags);
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 9df9ed37d219..38c4d128a8c0 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -227,7 +227,9 @@ xfs_initialize_vnode(
                 xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
                 xfs_set_inodeops(inode);
 
+                spin_lock(&ip->i_flags_lock);
                 ip->i_flags &= ~XFS_INEW;
+                spin_unlock(&ip->i_flags_lock);
                 barrier();
 
                 unlock_new_inode(inode);
diff --git a/fs/xfs/linux-2.6/xfs_vfs.h b/fs/xfs/linux-2.6/xfs_vfs.h
index 91fc2c4b3353..da255bdf5260 100644
--- a/fs/xfs/linux-2.6/xfs_vfs.h
+++ b/fs/xfs/linux-2.6/xfs_vfs.h
@@ -79,7 +79,7 @@ typedef enum {
 #define VFS_RDONLY              0x0001  /* read-only vfs */
 #define VFS_GRPID               0x0002  /* group-ID assigned from directory */
 #define VFS_DMI                 0x0004  /* filesystem has the DMI enabled */
-#define VFS_UMOUNT              0x0008  /* unmount in progress */
+/* ---- VFS_UMOUNT ----         0x0008  -- unneeded, fixed via kthread APIs */
 #define VFS_32BITINODES         0x0010  /* do not use inums above 32 bits */
 #define VFS_END                 0x0010  /* max flag */
 
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index c42b3221b20c..515f5fdea57a 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -85,8 +85,6 @@ typedef enum {
 #define VN_BHV_HEAD(vp)                 ((bhv_head_t *)(&((vp)->v_bh)))
 #define vn_bhv_head_init(bhp,name)      bhv_head_init(bhp,name)
 #define vn_bhv_remove(bhp,bdp)          bhv_remove(bhp,bdp)
-#define vn_bhv_lookup(bhp,ops)          bhv_lookup(bhp,ops)
-#define vn_bhv_lookup_unlocked(bhp,ops) bhv_lookup_unlocked(bhp,ops)
 
 /*
  * Vnode to Linux inode mapping.