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

* 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6: (59 commits)
  [XFS] eagerly remove vmap mappings to avoid upsetting Xen
  [XFS] simplify validata_fields
  [XFS] no longer using io_vnode, as was remaining from 23 cherrypick
  [XFS] Remove STATIC which was missing from prior manual merge
  [XFS] Put back the QUEUE_ORDERED_NONE test in the barrier check.
  [XFS] Turn off XBF_ASYNC flag before re-reading superblock.
  [XFS] avoid race in sync_inodes() that can fail to write out all dirty data
  [XFS] This fix prevents bulkstat from spinning in an infinite loop.
  [XFS] simplify xfs_create/mknod/symlink prototype
  [XFS] avoid xfs_getattr in XFS_IOC_FSGETXATTR ioctl
  [XFS] get_bulkall() could return incorrect inode state
  [XFS] Kill unused IOMAP_EOF flag
  [XFS] fix when DMAPI mount option processing happens
  [XFS] ensure file size is logged on synchronous writes
  [XFS] growlock should be a mutex
  [XFS] replace some large xfs_log_priv.h macros by proper functions
  [XFS] kill struct bhv_vfs
  [XFS] move syncing related members from struct bhv_vfs to struct xfs_mount
  [XFS] kill the vfs_flags member in struct bhv_vfs
  [XFS] kill the vfs_fsid and vfs_altfsid members in struct bhv_vfs
  ...

1 files changed, 44 insertions, 34 deletions

diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 4c2454bcc714..9972992fd3c3 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -57,7 +57,7 @@ xfs_bulkstat_one_iget(
         xfs_bstat_t     *buf,           /* return buffer */
         int             *stat)          /* BULKSTAT_RV_... */
 {
-        xfs_dinode_core_t *dic;         /* dinode core info pointer */
+        xfs_icdinode_t  *dic;   /* dinode core info pointer */
         xfs_inode_t     *ip;            /* incore inode pointer */
         bhv_vnode_t     *vp;
         int             error;
@@ -151,37 +151,37 @@ xfs_bulkstat_one_dinode(
          * the new format. We don't change the version number so that we
          * can distinguish this from a real new format inode.
          */
-        if (INT_GET(dic->di_version, ARCH_CONVERT) == XFS_DINODE_VERSION_1) {
-                buf->bs_nlink = INT_GET(dic->di_onlink, ARCH_CONVERT);
+        if (dic->di_version == XFS_DINODE_VERSION_1) {
+                buf->bs_nlink = be16_to_cpu(dic->di_onlink);
                 buf->bs_projid = 0;
         } else {
-                buf->bs_nlink = INT_GET(dic->di_nlink, ARCH_CONVERT);
-                buf->bs_projid = INT_GET(dic->di_projid, ARCH_CONVERT);
+                buf->bs_nlink = be32_to_cpu(dic->di_nlink);
+                buf->bs_projid = be16_to_cpu(dic->di_projid);
         }
 
         buf->bs_ino = ino;
-        buf->bs_mode = INT_GET(dic->di_mode, ARCH_CONVERT);
-        buf->bs_uid = INT_GET(dic->di_uid, ARCH_CONVERT);
-        buf->bs_gid = INT_GET(dic->di_gid, ARCH_CONVERT);
-        buf->bs_size = INT_GET(dic->di_size, ARCH_CONVERT);
-        buf->bs_atime.tv_sec = INT_GET(dic->di_atime.t_sec, ARCH_CONVERT);
-        buf->bs_atime.tv_nsec = INT_GET(dic->di_atime.t_nsec, ARCH_CONVERT);
-        buf->bs_mtime.tv_sec = INT_GET(dic->di_mtime.t_sec, ARCH_CONVERT);
-        buf->bs_mtime.tv_nsec = INT_GET(dic->di_mtime.t_nsec, ARCH_CONVERT);
-        buf->bs_ctime.tv_sec = INT_GET(dic->di_ctime.t_sec, ARCH_CONVERT);
-        buf->bs_ctime.tv_nsec = INT_GET(dic->di_ctime.t_nsec, ARCH_CONVERT);
+        buf->bs_mode = be16_to_cpu(dic->di_mode);
+        buf->bs_uid = be32_to_cpu(dic->di_uid);
+        buf->bs_gid = be32_to_cpu(dic->di_gid);
+        buf->bs_size = be64_to_cpu(dic->di_size);
+        buf->bs_atime.tv_sec = be32_to_cpu(dic->di_atime.t_sec);
+        buf->bs_atime.tv_nsec = be32_to_cpu(dic->di_atime.t_nsec);
+        buf->bs_mtime.tv_sec = be32_to_cpu(dic->di_mtime.t_sec);
+        buf->bs_mtime.tv_nsec = be32_to_cpu(dic->di_mtime.t_nsec);
+        buf->bs_ctime.tv_sec = be32_to_cpu(dic->di_ctime.t_sec);
+        buf->bs_ctime.tv_nsec = be32_to_cpu(dic->di_ctime.t_nsec);
         buf->bs_xflags = xfs_dic2xflags(dic);
-        buf->bs_extsize = INT_GET(dic->di_extsize, ARCH_CONVERT) << mp->m_sb.sb_blocklog;
-        buf->bs_extents = INT_GET(dic->di_nextents, ARCH_CONVERT);
-        buf->bs_gen = INT_GET(dic->di_gen, ARCH_CONVERT);
+        buf->bs_extsize = be32_to_cpu(dic->di_extsize) << mp->m_sb.sb_blocklog;
+        buf->bs_extents = be32_to_cpu(dic->di_nextents);
+        buf->bs_gen = be32_to_cpu(dic->di_gen);
         memset(buf->bs_pad, 0, sizeof(buf->bs_pad));
-        buf->bs_dmevmask = INT_GET(dic->di_dmevmask, ARCH_CONVERT);
-        buf->bs_dmstate = INT_GET(dic->di_dmstate, ARCH_CONVERT);
-        buf->bs_aextents = INT_GET(dic->di_anextents, ARCH_CONVERT);
+        buf->bs_dmevmask = be32_to_cpu(dic->di_dmevmask);
+        buf->bs_dmstate = be16_to_cpu(dic->di_dmstate);
+        buf->bs_aextents = be16_to_cpu(dic->di_anextents);
 
-        switch (INT_GET(dic->di_format, ARCH_CONVERT)) {
+        switch (dic->di_format) {
         case XFS_DINODE_FMT_DEV:
-                buf->bs_rdev = INT_GET(dip->di_u.di_dev, ARCH_CONVERT);
+                buf->bs_rdev = be32_to_cpu(dip->di_u.di_dev);
                 buf->bs_blksize = BLKDEV_IOSIZE;
                 buf->bs_blocks = 0;
                 break;
@@ -195,7 +195,7 @@ xfs_bulkstat_one_dinode(
         case XFS_DINODE_FMT_BTREE:
                 buf->bs_rdev = 0;
                 buf->bs_blksize = mp->m_sb.sb_blocksize;
-                buf->bs_blocks = INT_GET(dic->di_nblocks, ARCH_CONVERT);
+                buf->bs_blocks = be64_to_cpu(dic->di_nblocks);
                 break;
         }
 
@@ -290,16 +290,23 @@ xfs_bulkstat_use_dinode(
                 return 1;
         dip = (xfs_dinode_t *)
                         xfs_buf_offset(bp, clustidx << mp->m_sb.sb_inodelog);
-        if (INT_GET(dip->di_core.di_magic, ARCH_CONVERT) != XFS_DINODE_MAGIC ||
-            !XFS_DINODE_GOOD_VERSION(
-                        INT_GET(dip->di_core.di_version, ARCH_CONVERT)))
+        /*
+         * Check the buffer containing the on-disk inode for di_nlink == 0.
+         * This is to prevent xfs_bulkstat from picking up just reclaimed
+         * inodes that have their in-core state initialized but not flushed
+         * to disk yet. This is a temporary hack that would require a proper
+         * fix in the future.
+         */
+        if (be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC ||
+            !XFS_DINODE_GOOD_VERSION(dip->di_core.di_version) ||
+            !dip->di_core.di_nlink)
                 return 0;
         if (flags & BULKSTAT_FG_QUICK) {
                 *dipp = dip;
                 return 1;
         }
         /* BULKSTAT_FG_INLINE: if attr fork is local, or not there, use it */
-        aformat = INT_GET(dip->di_core.di_aformat, ARCH_CONVERT);
+        aformat = dip->di_core.di_aformat;
         if ((XFS_CFORK_Q(&dip->di_core) == 0) ||
             (aformat == XFS_DINODE_FMT_LOCAL) ||
             (aformat == XFS_DINODE_FMT_EXTENTS && !dip->di_core.di_anextents)) {
@@ -612,21 +619,25 @@ xfs_bulkstat(
                                                 }
                                         }
                                 }
+                                ino = XFS_AGINO_TO_INO(mp, agno, agino);
+                                bno = XFS_AGB_TO_DADDR(mp, agno, agbno);
                                 /*
                                  * Skip if this inode is free.
                                  */
-                                if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free)
+                                if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free) {
+                                        lastino = ino;
                                         continue;
+                                }
                                 /*
                                  * Count used inodes as free so we can tell
                                  * when the chunk is used up.
                                  */
                                 irbp->ir_freecount++;
-                                ino = XFS_AGINO_TO_INO(mp, agno, agino);
-                                bno = XFS_AGB_TO_DADDR(mp, agno, agbno);
                                 if (!xfs_bulkstat_use_dinode(mp, flags, bp,
-                                                             clustidx, &dip))
+                                                             clustidx, &dip)) {
+                                        lastino = ino;
                                         continue;
+                                }
                                 /*
                                  * If we need to do an iget, cannot hold bp.
                                  * Drop it, until starting the next cluster.
@@ -687,8 +698,7 @@ xfs_bulkstat(
                         if (end_of_ag) {
                                 agno++;
                                 agino = 0;
-                        } else
-                                agino = XFS_INO_TO_AGINO(mp, lastino);
+                        }
                 } else
                         break;
         }