Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux

22 files changed, 165 insertions, 189 deletions

diff --git a/fs/xfs/linux-2.6/xfs_acl.c b/fs/xfs/linux-2.6/xfs_acl.c
index 115ac691953..b6c4b3795c4 100644
--- a/fs/xfs/linux-2.6/xfs_acl.c
+++ b/fs/xfs/linux-2.6/xfs_acl.c
@@ -114,6 +114,8 @@ xfs_get_acl(struct inode *inode, int type)
         if (acl != ACL_NOT_CACHED)
                 return acl;
 
+        trace_xfs_get_acl(ip);
+
         switch (type) {
         case ACL_TYPE_ACCESS:
                 ea_name = SGI_ACL_FILE;
@@ -218,42 +220,8 @@ xfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
         return error;
 }
 
-int
-xfs_check_acl(struct inode *inode, int mask, unsigned int flags)
-{
-        struct xfs_inode *ip;
-        struct posix_acl *acl;
-        int error = -EAGAIN;
-
-        ip = XFS_I(inode);
-        trace_xfs_check_acl(ip);
-
-        /*
-         * If there is no attribute fork no ACL exists on this inode and
-         * we can skip the whole exercise.
-         */
-        if (!XFS_IFORK_Q(ip))
-                return -EAGAIN;
-
-        if (flags & IPERM_FLAG_RCU) {
-                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
-                        return -ECHILD;
-                return -EAGAIN;
-        }
-
-        acl = xfs_get_acl(inode, ACL_TYPE_ACCESS);
-        if (IS_ERR(acl))
-                return PTR_ERR(acl);
-        if (acl) {
-                error = posix_acl_permission(inode, acl, mask);
-                posix_acl_release(acl);
-        }
-
-        return error;
-}
-
 static int
-xfs_set_mode(struct inode *inode, mode_t mode)
+xfs_set_mode(struct inode *inode, umode_t mode)
 {
         int error = 0;
 
@@ -297,29 +265,23 @@ posix_acl_default_exists(struct inode *inode)
  * No need for i_mutex because the inode is not yet exposed to the VFS.
  */
 int
-xfs_inherit_acl(struct inode *inode, struct posix_acl *default_acl)
+xfs_inherit_acl(struct inode *inode, struct posix_acl *acl)
 {
-        struct posix_acl *clone;
-        mode_t mode;
+        umode_t mode = inode->i_mode;
         int error = 0, inherit = 0;
 
         if (S_ISDIR(inode->i_mode)) {
-                error = xfs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl);
+                error = xfs_set_acl(inode, ACL_TYPE_DEFAULT, acl);
                 if (error)
-                        return error;
+                        goto out;
         }
 
-        clone = posix_acl_clone(default_acl, GFP_KERNEL);
-        if (!clone)
-                return -ENOMEM;
-
-        mode = inode->i_mode;
-        error = posix_acl_create_masq(clone, &mode);
+        error = posix_acl_create(&acl, GFP_KERNEL, &mode);
         if (error < 0)
-                goto out_release_clone;
+                return error;
 
         /*
-         * If posix_acl_create_masq returns a positive value we need to
+         * If posix_acl_create returns a positive value we need to
          * inherit a permission that can't be represented using the Unix
          * mode bits and we actually need to set an ACL.
          */
@@ -328,20 +290,20 @@ xfs_inherit_acl(struct inode *inode, struct posix_acl *default_acl)
 
         error = xfs_set_mode(inode, mode);
         if (error)
-                goto out_release_clone;
+                goto out;
 
         if (inherit)
-                error = xfs_set_acl(inode, ACL_TYPE_ACCESS, clone);
+                error = xfs_set_acl(inode, ACL_TYPE_ACCESS, acl);
 
- out_release_clone:
-        posix_acl_release(clone);
+out:
+        posix_acl_release(acl);
         return error;
 }
 
 int
 xfs_acl_chmod(struct inode *inode)
 {
-        struct posix_acl *acl, *clone;
+        struct posix_acl *acl;
         int error;
 
         if (S_ISLNK(inode->i_mode))
@@ -351,16 +313,12 @@ xfs_acl_chmod(struct inode *inode)
         if (IS_ERR(acl) || !acl)
                 return PTR_ERR(acl);
 
-        clone = posix_acl_clone(acl, GFP_KERNEL);
-        posix_acl_release(acl);
-        if (!clone)
-                return -ENOMEM;
-
-        error = posix_acl_chmod_masq(clone, inode->i_mode);
-        if (!error)
-                error = xfs_set_acl(inode, ACL_TYPE_ACCESS, clone);
+        error = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode);
+        if (error)
+                return error;
 
-        posix_acl_release(clone);
+        error = xfs_set_acl(inode, ACL_TYPE_ACCESS, acl);
+        posix_acl_release(acl);
         return error;
 }
 
@@ -423,7 +381,7 @@ xfs_xattr_acl_set(struct dentry *dentry, const char *name,
                 goto out_release;
 
         if (type == ACL_TYPE_ACCESS) {
-                mode_t mode = inode->i_mode;
+                umode_t mode = inode->i_mode;
                 error = posix_acl_equiv_mode(acl, &mode);
 
                 if (error <= 0) {
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 26384fe3f26..63e971e2b83 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -1329,6 +1329,9 @@ xfs_end_io_direct_write(
         } else {
                 xfs_finish_ioend_sync(ioend);
         }
+
+        /* XXX: probably should move into the real I/O completion handler */
+        inode_dio_done(ioend->io_inode);
 }
 
 STATIC ssize_t
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 6bddce40de7..c57836dc778 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -1223,6 +1223,9 @@ _xfs_buf_ioapply(
                 rw = READ;
         }
 
+        /* we only use the buffer cache for meta-data */
+        rw |= REQ_META;
+
 next_chunk:
         atomic_inc(&bp->b_io_remaining);
         nr_pages = BIO_MAX_SECTORS >> (PAGE_SHIFT - BBSHIFT);
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 8073f61efb8..7f7b42469ea 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -127,6 +127,8 @@ xfs_iozero(
 STATIC int
 xfs_file_fsync(
         struct file             *file,
+        loff_t                  start,
+        loff_t                  end,
         int                     datasync)
 {
         struct inode            *inode = file->f_mapping->host;
@@ -138,12 +140,18 @@ xfs_file_fsync(
 
         trace_xfs_file_fsync(ip);
 
+        error = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (error)
+                return error;
+
         if (XFS_FORCED_SHUTDOWN(mp))
                 return -XFS_ERROR(EIO);
 
         xfs_iflags_clear(ip, XFS_ITRUNCATED);
 
+        xfs_ilock(ip, XFS_IOLOCK_SHARED);
         xfs_ioend_wait(ip);
+        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 
         if (mp->m_flags & XFS_MOUNT_BARRIER) {
                 /*
@@ -875,18 +883,14 @@ xfs_file_aio_write(
         /* Handle various SYNC-type writes */
         if ((file->f_flags & O_DSYNC) || IS_SYNC(inode)) {
                 loff_t end = pos + ret - 1;
-                int error, error2;
+                int error;
 
                 xfs_rw_iunlock(ip, iolock);
-                error = filemap_write_and_wait_range(mapping, pos, end);
+                error = xfs_file_fsync(file, pos, end,
+                                      (file->f_flags & __O_SYNC) ? 0 : 1);
                 xfs_rw_ilock(ip, iolock);
-
-                error2 = -xfs_file_fsync(file,
-                                         (file->f_flags & __O_SYNC) ? 0 : 1);
                 if (error)
                         ret = error;
-                else if (error2)
-                        ret = error2;
         }
 
 out_unlock:
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index acca2c5ca3f..f7ce7debe14 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -265,7 +265,7 @@ xfs_open_by_handle(
                 return PTR_ERR(filp);
         }
 
-        if (inode->i_mode & S_IFREG) {
+        if (S_ISREG(inode->i_mode)) {
                 filp->f_flags |= O_NOATIME;
                 filp->f_mode |= FMODE_NOCMTIME;
         }
@@ -850,14 +850,14 @@ xfs_set_diflags(
                 di_flags |= XFS_DIFLAG_NODEFRAG;
         if (xflags & XFS_XFLAG_FILESTREAM)
                 di_flags |= XFS_DIFLAG_FILESTREAM;
-        if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
+        if (S_ISDIR(ip->i_d.di_mode)) {
                 if (xflags & XFS_XFLAG_RTINHERIT)
                         di_flags |= XFS_DIFLAG_RTINHERIT;
                 if (xflags & XFS_XFLAG_NOSYMLINKS)
                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
                 if (xflags & XFS_XFLAG_EXTSZINHERIT)
                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
-        } else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
+        } else if (S_ISREG(ip->i_d.di_mode)) {
                 if (xflags & XFS_XFLAG_REALTIME)
                         di_flags |= XFS_DIFLAG_REALTIME;
                 if (xflags & XFS_XFLAG_EXTSIZE)
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 501e4f63054..b9c172b3fbb 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -202,9 +202,9 @@ xfs_vn_mknod(
 
         if (default_acl) {
                 error = -xfs_inherit_acl(inode, default_acl);
+                default_acl = NULL;
                 if (unlikely(error))
                         goto out_cleanup_inode;
-                posix_acl_release(default_acl);
         }
 
 
@@ -1022,7 +1022,7 @@ xfs_vn_fiemap(
 }
 
 static const struct inode_operations xfs_inode_operations = {
-        .check_acl              = xfs_check_acl,
+        .get_acl                = xfs_get_acl,
         .getattr                = xfs_vn_getattr,
         .setattr                = xfs_vn_setattr,
         .setxattr               = generic_setxattr,
@@ -1048,7 +1048,7 @@ static const struct inode_operations xfs_dir_inode_operations = {
         .rmdir                  = xfs_vn_unlink,
         .mknod                  = xfs_vn_mknod,
         .rename                 = xfs_vn_rename,
-        .check_acl              = xfs_check_acl,
+        .get_acl                = xfs_get_acl,
         .getattr                = xfs_vn_getattr,
         .setattr                = xfs_vn_setattr,
         .setxattr               = generic_setxattr,
@@ -1073,7 +1073,7 @@ static const struct inode_operations xfs_dir_ci_inode_operations = {
         .rmdir                  = xfs_vn_unlink,
         .mknod                  = xfs_vn_mknod,
         .rename                 = xfs_vn_rename,
-        .check_acl              = xfs_check_acl,
+        .get_acl                = xfs_get_acl,
         .getattr                = xfs_vn_getattr,
         .setattr                = xfs_vn_setattr,
         .setxattr               = generic_setxattr,
@@ -1086,7 +1086,7 @@ static const struct inode_operations xfs_symlink_inode_operations = {
         .readlink               = generic_readlink,
         .follow_link            = xfs_vn_follow_link,
         .put_link               = xfs_vn_put_link,
-        .check_acl              = xfs_check_acl,
+        .get_acl                = xfs_get_acl,
         .getattr                = xfs_vn_getattr,
         .setattr                = xfs_vn_setattr,
         .setxattr               = generic_setxattr,
@@ -1194,6 +1194,15 @@ xfs_setup_inode(
                 break;
         }
 
+        /*
+         * If there is no attribute fork no ACL can exist on this inode,
+         * and it can't have any file capabilities attached to it either.
+         */
+        if (!XFS_IFORK_Q(ip)) {
+                inode_has_no_xattr(inode);
+                cache_no_acl(inode);
+        }
+
         xfs_iflags_clear(ip, XFS_INEW);
         barrier();
 
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 25fd2cd6c8b..9a72dda58bd 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -1024,11 +1024,6 @@ xfs_fs_put_super(
 {
         struct xfs_mount        *mp = XFS_M(sb);
 
-        /*
-         * Unregister the memory shrinker before we tear down the mount
-         * structure so we don't have memory reclaim racing with us here.
-         */
-        xfs_inode_shrinker_unregister(mp);
         xfs_syncd_stop(mp);
 
         /*
@@ -1411,8 +1406,6 @@ xfs_fs_fill_super(
         sb->s_time_gran = 1;
         set_posix_acl_flag(sb);
 
-        xfs_inode_shrinker_register(mp);
-
         error = xfs_mountfs(mp);
         if (error)
                 goto out_filestream_unmount;
@@ -1439,7 +1432,6 @@ xfs_fs_fill_super(
         return 0;
 
  out_filestream_unmount:
-        xfs_inode_shrinker_unregister(mp);
         xfs_filestream_unmount(mp);
  out_free_sb:
         xfs_freesb(mp);
@@ -1458,8 +1450,6 @@ xfs_fs_fill_super(
  out_syncd_stop:
         xfs_syncd_stop(mp);
  out_unmount:
-        xfs_inode_shrinker_unregister(mp);
-
         /*
          * Blow away any referenced inode in the filestreams cache.
          * This can and will cause log traffic as inodes go inactive
@@ -1483,6 +1473,21 @@ xfs_fs_mount(
         return mount_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super);
 }
 
+static int
+xfs_fs_nr_cached_objects(
+        struct super_block      *sb)
+{
+        return xfs_reclaim_inodes_count(XFS_M(sb));
+}
+
+static void
+xfs_fs_free_cached_objects(
+        struct super_block      *sb,
+        int                     nr_to_scan)
+{
+        xfs_reclaim_inodes_nr(XFS_M(sb), nr_to_scan);
+}
+
 static const struct super_operations xfs_super_operations = {
         .alloc_inode            = xfs_fs_alloc_inode,
         .destroy_inode          = xfs_fs_destroy_inode,
@@ -1496,6 +1501,8 @@ static const struct super_operations xfs_super_operations = {
         .statfs                 = xfs_fs_statfs,
         .remount_fs             = xfs_fs_remount,
         .show_options           = xfs_fs_show_options,
+        .nr_cached_objects      = xfs_fs_nr_cached_objects,
+        .free_cached_objects    = xfs_fs_free_cached_objects,
 };
 
 static struct file_system_type xfs_fs_type = {
diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index a8500e92ae7..4604f90f86a 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -179,6 +179,8 @@ restart:
                 if (error == EFSCORRUPTED)
                         break;
 
+                cond_resched();
+
         } while (nr_found && !done);
 
         if (skipped) {
@@ -984,6 +986,8 @@ restart:
 
                         *nr_to_scan -= XFS_LOOKUP_BATCH;
 
+                        cond_resched();
+
                 } while (nr_found && !done && *nr_to_scan > 0);
 
                 if (trylock && !done)
@@ -1001,7 +1005,7 @@ restart:
          * ensure that when we get more reclaimers than AGs we block rather
          * than spin trying to execute reclaim.
          */
-        if (trylock && skipped && *nr_to_scan > 0) {
+        if (skipped && (flags & SYNC_WAIT) && *nr_to_scan > 0) {
                 trylock = 0;
                 goto restart;
         }
@@ -1019,44 +1023,38 @@ xfs_reclaim_inodes(
 }
 
 /*
- * Inode cache shrinker.
+ * Scan a certain number of inodes for reclaim.
  *
  * When called we make sure that there is a background (fast) inode reclaim in
- * progress, while we will throttle the speed of reclaim via doiing synchronous
+ * progress, while we will throttle the speed of reclaim via doing synchronous
  * reclaim of inodes. That means if we come across dirty inodes, we wait for
  * them to be cleaned, which we hope will not be very long due to the
  * background walker having already kicked the IO off on those dirty inodes.
  */
-static int
-xfs_reclaim_inode_shrink(
-        struct shrinker *shrink,
-        struct shrink_control *sc)
+void
+xfs_reclaim_inodes_nr(
+        struct xfs_mount        *mp,
+        int                     nr_to_scan)
 {
-        struct xfs_mount *mp;
-        struct xfs_perag *pag;
-        xfs_agnumber_t  ag;
-        int             reclaimable;
-        int nr_to_scan = sc->nr_to_scan;
-        gfp_t gfp_mask = sc->gfp_mask;
-
-        mp = container_of(shrink, struct xfs_mount, m_inode_shrink);
-        if (nr_to_scan) {
-                /* kick background reclaimer and push the AIL */
-                xfs_syncd_queue_reclaim(mp);
-                xfs_ail_push_all(mp->m_ail);
+        /* kick background reclaimer and push the AIL */
+        xfs_syncd_queue_reclaim(mp);
+        xfs_ail_push_all(mp->m_ail);
 
-                if (!(gfp_mask & __GFP_FS))
-                        return -1;
+        xfs_reclaim_inodes_ag(mp, SYNC_TRYLOCK | SYNC_WAIT, &nr_to_scan);
+}
 
-                xfs_reclaim_inodes_ag(mp, SYNC_TRYLOCK | SYNC_WAIT,
-                                        &nr_to_scan);
-                /* terminate if we don't exhaust the scan */
-                if (nr_to_scan > 0)
-                        return -1;
-       }
+/*
+ * Return the number of reclaimable inodes in the filesystem for
+ * the shrinker to determine how much to reclaim.
+ */
+int
+xfs_reclaim_inodes_count(
+        struct xfs_mount        *mp)
+{
+        struct xfs_perag        *pag;
+        xfs_agnumber_t          ag = 0;
+        int                     reclaimable = 0;
 
-        reclaimable = 0;
-        ag = 0;
         while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
                 ag = pag->pag_agno + 1;
                 reclaimable += pag->pag_ici_reclaimable;
@@ -1065,18 +1063,3 @@ xfs_reclaim_inode_shrink(
         return reclaimable;
 }
 
-void
-xfs_inode_shrinker_register(
-        struct xfs_mount        *mp)
-{
-        mp->m_inode_shrink.shrink = xfs_reclaim_inode_shrink;
-        mp->m_inode_shrink.seeks = DEFAULT_SEEKS;
-        register_shrinker(&mp->m_inode_shrink);
-}
-
-void
-xfs_inode_shrinker_unregister(
-        struct xfs_mount        *mp)
-{
-        unregister_shrinker(&mp->m_inode_shrink);
-}
diff --git a/fs/xfs/linux-2.6/xfs_sync.h b/fs/xfs/linux-2.6/xfs_sync.h
index e914fd62174..941202e7ac6 100644
--- a/fs/xfs/linux-2.6/xfs_sync.h
+++ b/fs/xfs/linux-2.6/xfs_sync.h
@@ -35,6 +35,8 @@ void xfs_quiesce_attr(struct xfs_mount *mp);
 void xfs_flush_inodes(struct xfs_inode *ip);
 
 int xfs_reclaim_inodes(struct xfs_mount *mp, int mode);
+int xfs_reclaim_inodes_count(struct xfs_mount *mp);
+void xfs_reclaim_inodes_nr(struct xfs_mount *mp, int nr_to_scan);
 
 void xfs_inode_set_reclaim_tag(struct xfs_inode *ip);
 void __xfs_inode_set_reclaim_tag(struct xfs_perag *pag, struct xfs_inode *ip);
@@ -46,7 +48,4 @@ int xfs_inode_ag_iterator(struct xfs_mount *mp,
         int (*execute)(struct xfs_inode *ip, struct xfs_perag *pag, int flags),
         int flags);
 
-void xfs_inode_shrinker_register(struct xfs_mount *mp);
-void xfs_inode_shrinker_unregister(struct xfs_mount *mp);
-
 #endif
diff --git a/fs/xfs/linux-2.6/xfs_trace.h b/fs/xfs/linux-2.6/xfs_trace.h
index fda0708ef2e..690fc7a7bd7 100644
--- a/fs/xfs/linux-2.6/xfs_trace.h
+++ b/fs/xfs/linux-2.6/xfs_trace.h
@@ -571,7 +571,7 @@ DEFINE_INODE_EVENT(xfs_alloc_file_space);
 DEFINE_INODE_EVENT(xfs_free_file_space);
 DEFINE_INODE_EVENT(xfs_readdir);
 #ifdef CONFIG_XFS_POSIX_ACL
-DEFINE_INODE_EVENT(xfs_check_acl);
+DEFINE_INODE_EVENT(xfs_get_acl);
 #endif
 DEFINE_INODE_EVENT(xfs_vm_bmap);
 DEFINE_INODE_EVENT(xfs_file_ioctl);
diff --git a/fs/xfs/xfs_acl.h b/fs/xfs/xfs_acl.h
index 11dd72070cb..39632d94135 100644
--- a/fs/xfs/xfs_acl.h
+++ b/fs/xfs/xfs_acl.h
@@ -42,7 +42,6 @@ struct xfs_acl {
 #define SGI_ACL_DEFAULT_SIZE    (sizeof(SGI_ACL_DEFAULT)-1)
 
 #ifdef CONFIG_XFS_POSIX_ACL
-extern int xfs_check_acl(struct inode *inode, int mask, unsigned int flags);
 extern struct posix_acl *xfs_get_acl(struct inode *inode, int type);
 extern int xfs_inherit_acl(struct inode *inode, struct posix_acl *default_acl);
 extern int xfs_acl_chmod(struct inode *inode);
@@ -52,8 +51,10 @@ extern int posix_acl_default_exists(struct inode *inode);
 extern const struct xattr_handler xfs_xattr_acl_access_handler;
 extern const struct xattr_handler xfs_xattr_acl_default_handler;
 #else
-# define xfs_check_acl                                  NULL
-# define xfs_get_acl(inode, type)                       NULL
+static inline struct posix_acl *xfs_get_acl(struct inode *inode, int type)
+{
+        return NULL;
+}
 # define xfs_inherit_acl(inode, default_acl)            0
 # define xfs_acl_chmod(inode)                           0
 # define posix_acl_access_exists(inode)                 0
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 25cb2b2c427..452a291383a 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -414,7 +414,7 @@ xfs_bmap_add_attrfork_local(
 
         if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip))
                 return 0;
-        if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
+        if (S_ISDIR(ip->i_d.di_mode)) {
                 mp = ip->i_mount;
                 memset(&dargs, 0, sizeof(dargs));
                 dargs.dp = ip;
@@ -3344,8 +3344,7 @@ xfs_bmap_local_to_extents(
          * We don't want to deal with the case of keeping inode data inline yet.
          * So sending the data fork of a regular inode is invalid.
          */
-        ASSERT(!((ip->i_d.di_mode & S_IFMT) == S_IFREG &&
-                 whichfork == XFS_DATA_FORK));
+        ASSERT(!(S_ISREG(ip->i_d.di_mode) && whichfork == XFS_DATA_FORK));
         ifp = XFS_IFORK_PTR(ip, whichfork);
         ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
         flags = 0;
@@ -4051,7 +4050,7 @@ xfs_bmap_one_block(
 
 #ifndef DEBUG
         if (whichfork == XFS_DATA_FORK) {
-                return ((ip->i_d.di_mode & S_IFMT) == S_IFREG) ?
+                return S_ISREG(ip->i_d.di_mode) ?
                         (ip->i_size == ip->i_mount->m_sb.sb_blocksize) :
                         (ip->i_d.di_size == ip->i_mount->m_sb.sb_blocksize);
         }
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index d56ccb70965..ee9d5427fcd 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -692,6 +692,24 @@ xfs_da_join(xfs_da_state_t *state)
         return(error);
 }
 
+#ifdef  DEBUG
+static void
+xfs_da_blkinfo_onlychild_validate(struct xfs_da_blkinfo *blkinfo, __u16 level)
+{
+        __be16  magic = blkinfo->magic;
+
+        if (level == 1) {
+                ASSERT(magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
+                       magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
+        } else
+                ASSERT(magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
+        ASSERT(!blkinfo->forw);
+        ASSERT(!blkinfo->back);
+}
+#else   /* !DEBUG */
+#define xfs_da_blkinfo_onlychild_validate(blkinfo, level)
+#endif  /* !DEBUG */
+
 /*
  * We have only one entry in the root.  Copy the only remaining child of
  * the old root to block 0 as the new root node.
@@ -700,8 +718,6 @@ STATIC int
 xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk)
 {
         xfs_da_intnode_t *oldroot;
-        /* REFERENCED */
-        xfs_da_blkinfo_t *blkinfo;
         xfs_da_args_t *args;
         xfs_dablk_t child;
         xfs_dabuf_t *bp;
@@ -732,15 +748,9 @@ xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk)
         if (error)
                 return(error);
         ASSERT(bp != NULL);
-        blkinfo = bp->data;
-        if (be16_to_cpu(oldroot->hdr.level) == 1) {
-                ASSERT(blkinfo->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
-                       blkinfo->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
-        } else {
-                ASSERT(blkinfo->magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
-        }
-        ASSERT(!blkinfo->forw);
-        ASSERT(!blkinfo->back);
+        xfs_da_blkinfo_onlychild_validate(bp->data,
+                                        be16_to_cpu(oldroot->hdr.level));
+
         memcpy(root_blk->bp->data, bp->data, state->blocksize);
         xfs_da_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1);
         error = xfs_da_shrink_inode(args, child, bp);
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 4580ce00aeb..a2e27010c7f 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -121,7 +121,7 @@ xfs_dir_isempty(
 {
         xfs_dir2_sf_hdr_t       *sfp;
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         if (dp->i_d.di_size == 0)       /* might happen during shutdown. */
                 return 1;
         if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp))
@@ -179,7 +179,7 @@ xfs_dir_init(
         memset((char *)&args, 0, sizeof(args));
         args.dp = dp;
         args.trans = tp;
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         if ((error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino)))
                 return error;
         return xfs_dir2_sf_create(&args, pdp->i_ino);
@@ -202,7 +202,7 @@ xfs_dir_createname(
         int                     rval;
         int                     v;              /* type-checking value */
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum)))
                 return rval;
         XFS_STATS_INC(xs_dir_create);
@@ -278,7 +278,7 @@ xfs_dir_lookup(
         int             rval;
         int             v;              /* type-checking value */
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         XFS_STATS_INC(xs_dir_lookup);
 
         memset(&args, 0, sizeof(xfs_da_args_t));
@@ -333,7 +333,7 @@ xfs_dir_removename(
         int             rval;
         int             v;              /* type-checking value */
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         XFS_STATS_INC(xs_dir_remove);
 
         memset(&args, 0, sizeof(xfs_da_args_t));
@@ -382,7 +382,7 @@ xfs_readdir(
         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
                 return XFS_ERROR(EIO);
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
         XFS_STATS_INC(xs_dir_getdents);
 
         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
@@ -414,7 +414,7 @@ xfs_dir_replace(
         int             rval;
         int             v;              /* type-checking value */
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
 
         if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum)))
                 return rval;
@@ -464,7 +464,7 @@ xfs_dir_canenter(
         if (resblks)
                 return 0;
 
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
+        ASSERT(S_ISDIR(dp->i_d.di_mode));
 
         memset(&args, 0, sizeof(xfs_da_args_t));
         args.name = name->name;
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index 084b3247d63..0179a41d9e5 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -1564,7 +1564,7 @@ xfs_dir2_node_addname_int(
 
                         if (unlikely(xfs_dir2_db_to_fdb(mp, dbno) != fbno)) {
                                 xfs_alert(mp,
-                        "%s: dir ino " "%llu needed freesp block %lld for\n"
+                        "%s: dir ino %llu needed freesp block %lld for\n"
                         "  data block %lld, got %lld ifbno %llu lastfbno %d",
                                         __func__, (unsigned long long)dp->i_ino,
                                         (long long)xfs_dir2_db_to_fdb(mp, dbno),
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index 9124425b7f2..3ff3d9e23de 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -344,9 +344,9 @@ _xfs_filestream_update_ag(
          * Either ip is a regular file and pip is a directory, or ip is a
          * directory and pip is NULL.
          */
-        ASSERT(ip && (((ip->i_d.di_mode & S_IFREG) && pip &&
-                       (pip->i_d.di_mode & S_IFDIR)) ||
-                      ((ip->i_d.di_mode & S_IFDIR) && !pip)));
+        ASSERT(ip && ((S_ISREG(ip->i_d.di_mode) && pip &&
+                       S_ISDIR(pip->i_d.di_mode)) ||
+                      (S_ISDIR(ip->i_d.di_mode) && !pip)));
 
         mp = ip->i_mount;
         cache = mp->m_filestream;
@@ -537,7 +537,7 @@ xfs_filestream_lookup_ag(
         xfs_agnumber_t  ag;
         int             ref;
 
-        if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
+        if (!S_ISREG(ip->i_d.di_mode) && !S_ISDIR(ip->i_d.di_mode)) {
                 ASSERT(0);
                 return NULLAGNUMBER;
         }
@@ -579,9 +579,9 @@ xfs_filestream_associate(
         xfs_agnumber_t  ag, rotorstep, startag;
         int             err = 0;
 
-        ASSERT(pip->i_d.di_mode & S_IFDIR);
-        ASSERT(ip->i_d.di_mode & S_IFREG);
-        if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
+        ASSERT(S_ISDIR(pip->i_d.di_mode));
+        ASSERT(S_ISREG(ip->i_d.di_mode));
+        if (!S_ISDIR(pip->i_d.di_mode) || !S_ISREG(ip->i_d.di_mode))
                 return -EINVAL;
 
         mp = pip->i_mount;
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 76ee2c5371c..0239a7c7c88 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -368,7 +368,7 @@ xfs_iformat(
                         /*
                          * no local regular files yet
                          */
-                        if (unlikely((be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFREG)) {
+                        if (unlikely(S_ISREG(be16_to_cpu(dip->di_mode)))) {
                                 xfs_warn(ip->i_mount,
                         "corrupt inode %Lu (local format for regular file).",
                                         (unsigned long long) ip->i_ino);
@@ -1040,7 +1040,7 @@ xfs_ialloc(
 
         if (pip && XFS_INHERIT_GID(pip)) {
                 ip->i_d.di_gid = pip->i_d.di_gid;
-                if ((pip->i_d.di_mode & S_ISGID) && (mode & S_IFMT) == S_IFDIR) {
+                if ((pip->i_d.di_mode & S_ISGID) && S_ISDIR(mode)) {
                         ip->i_d.di_mode |= S_ISGID;
                 }
         }
@@ -1097,14 +1097,14 @@ xfs_ialloc(
                 if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
                         uint    di_flags = 0;
 
-                        if ((mode & S_IFMT) == S_IFDIR) {
+                        if (S_ISDIR(mode)) {
                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
                                         di_flags |= XFS_DIFLAG_RTINHERIT;
                                 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
                                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
                                         ip->i_d.di_extsize = pip->i_d.di_extsize;
                                 }
-                        } else if ((mode & S_IFMT) == S_IFREG) {
+                        } else if (S_ISREG(mode)) {
                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
                                         di_flags |= XFS_DIFLAG_REALTIME;
                                 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
@@ -1188,7 +1188,7 @@ xfs_isize_check(
         int                     nimaps;
         xfs_bmbt_irec_t         imaps[2];
 
-        if ((ip->i_d.di_mode & S_IFMT) != S_IFREG)
+        if (!S_ISREG(ip->i_d.di_mode))
                 return;
 
         if (XFS_IS_REALTIME_INODE(ip))
@@ -1828,7 +1828,7 @@ xfs_ifree(
         ASSERT(ip->i_d.di_nextents == 0);
         ASSERT(ip->i_d.di_anextents == 0);
         ASSERT((ip->i_d.di_size == 0 && ip->i_size == 0) ||
-               ((ip->i_d.di_mode & S_IFMT) != S_IFREG));
+               (!S_ISREG(ip->i_d.di_mode)));
         ASSERT(ip->i_d.di_nblocks == 0);
 
         /*
@@ -2671,7 +2671,7 @@ xfs_iflush_int(
                         __func__, ip->i_ino, ip, ip->i_d.di_magic);
                 goto corrupt_out;
         }
-        if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
+        if (S_ISREG(ip->i_d.di_mode)) {
                 if (XFS_TEST_ERROR(
                     (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
                     (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
@@ -2681,7 +2681,7 @@ xfs_iflush_int(
                                 __func__, ip->i_ino, ip);
                         goto corrupt_out;
                 }
-        } else if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
+        } else if (S_ISDIR(ip->i_d.di_mode)) {
                 if (XFS_TEST_ERROR(
                     (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
                     (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index a97644ab945..2380a4bcbec 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -263,7 +263,7 @@ typedef struct xfs_inode {
         struct inode            i_vnode;        /* embedded VFS inode */
 } xfs_inode_t;
 
-#define XFS_ISIZE(ip)   (((ip)->i_d.di_mode & S_IFMT) == S_IFREG) ? \
+#define XFS_ISIZE(ip)   S_ISREG((ip)->i_d.di_mode) ? \
                                 (ip)->i_size : (ip)->i_d.di_size;
 
 /* Convert from vfs inode to xfs inode */
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 93786e518d8..1076b7effcd 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -2277,7 +2277,7 @@ xlog_recover_inode_pass2(
         /* Take the opportunity to reset the flush iteration count */
         dicp->di_flushiter = 0;
 
-        if (unlikely((dicp->di_mode & S_IFMT) == S_IFREG)) {
+        if (unlikely(S_ISREG(dicp->di_mode))) {
                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
                     (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
                         XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
@@ -2290,7 +2290,7 @@ xlog_recover_inode_pass2(
                         error = EFSCORRUPTED;
                         goto error;
                 }
-        } else if (unlikely((dicp->di_mode & S_IFMT) == S_IFDIR)) {
+        } else if (unlikely(S_ISDIR(dicp->di_mode))) {
                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
                     (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
                     (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 49ecc170f74..0081657ad98 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -1331,7 +1331,7 @@ xfs_mountfs(
 
         ASSERT(rip != NULL);
 
-        if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) {
+        if (unlikely(!S_ISDIR(rip->i_d.di_mode))) {
                 xfs_warn(mp, "corrupted root inode %llu: not a directory",
                         (unsigned long long)rip->i_ino);
                 xfs_iunlock(rip, XFS_ILOCK_EXCL);
diff --git a/fs/xfs/xfs_rename.c b/fs/xfs/xfs_rename.c
index 77a59891734..df78c297d1a 100644
--- a/fs/xfs/xfs_rename.c
+++ b/fs/xfs/xfs_rename.c
@@ -116,7 +116,7 @@ xfs_rename(
         trace_xfs_rename(src_dp, target_dp, src_name, target_name);
 
         new_parent = (src_dp != target_dp);
-        src_is_directory = ((src_ip->i_d.di_mode & S_IFMT) == S_IFDIR);
+        src_is_directory = S_ISDIR(src_ip->i_d.di_mode);
 
         if (src_is_directory) {
                 /*
@@ -226,7 +226,7 @@ xfs_rename(
                  * target and source are directories and that target can be
                  * destroyed, or that neither is a directory.
                  */
-                if ((target_ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
+                if (S_ISDIR(target_ip->i_d.di_mode)) {
                         /*
                          * Make sure target dir is empty.
                          */
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 3ee5f8a2858..dd05360ad56 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -121,7 +121,7 @@ xfs_readlink(
 
         xfs_ilock(ip, XFS_ILOCK_SHARED);
 
-        ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFLNK);
+        ASSERT(S_ISLNK(ip->i_d.di_mode));
         ASSERT(ip->i_d.di_size <= MAXPATHLEN);
 
         pathlen = ip->i_d.di_size;
@@ -529,7 +529,7 @@ xfs_release(
         if (ip->i_d.di_nlink == 0)
                 return 0;
 
-        if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
+        if ((S_ISREG(ip->i_d.di_mode) &&
              ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
                ip->i_delayed_blks > 0)) &&
              (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
@@ -610,7 +610,7 @@ xfs_inactive(
         truncate = ((ip->i_d.di_nlink == 0) &&
             ((ip->i_d.di_size != 0) || (ip->i_size != 0) ||
              (ip->i_d.di_nextents > 0) || (ip->i_delayed_blks > 0)) &&
-            ((ip->i_d.di_mode & S_IFMT) == S_IFREG));
+            S_ISREG(ip->i_d.di_mode));
 
         mp = ip->i_mount;
 
@@ -621,7 +621,7 @@ xfs_inactive(
                 goto out;
 
         if (ip->i_d.di_nlink != 0) {
-                if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
+                if ((S_ISREG(ip->i_d.di_mode) &&
                      ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
                        ip->i_delayed_blks > 0)) &&
                       (ip->i_df.if_flags & XFS_IFEXTENTS) &&
@@ -669,7 +669,7 @@ xfs_inactive(
                         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
                         return VN_INACTIVE_CACHE;
                 }
-        } else if ((ip->i_d.di_mode & S_IFMT) == S_IFLNK) {
+        } else if (S_ISLNK(ip->i_d.di_mode)) {
 
                 /*
                  * If we get an error while cleaning up a