116 files changed, 2252 insertions, 2044 deletions

diff --git a/Documentation/ABI/testing/sysfs-fs-xfs b/Documentation/ABI/testing/sysfs-fs-xfs
new file mode 100644
index 000000000000..ea0cc8c42093
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-fs-xfs
@@ -0,0 +1,39 @@
+What:           /sys/fs/xfs/<disk>/log/log_head_lsn
+Date:           July 2014
+KernelVersion:  3.17
+Contact:        xfs@oss.sgi.com
+Description:
+                The log sequence number (LSN) of the current head of the
+                log. The LSN is exported in "cycle:basic block" format.
+Users:          xfstests
+
+What:           /sys/fs/xfs/<disk>/log/log_tail_lsn
+Date:           July 2014
+KernelVersion:  3.17
+Contact:        xfs@oss.sgi.com
+Description:
+                The log sequence number (LSN) of the current tail of the
+                log. The LSN is exported in "cycle:basic block" format.
+
+What:           /sys/fs/xfs/<disk>/log/reserve_grant_head
+Date:           July 2014
+KernelVersion:  3.17
+Contact:        xfs@oss.sgi.com
+Description:
+                The current state of the log reserve grant head. It
+                represents the total log reservation of all currently
+                outstanding transactions. The grant head is exported in
+                "cycle:bytes" format.
+Users:          xfstests
+
+What:           /sys/fs/xfs/<disk>/log/write_grant_head
+Date:           July 2014
+KernelVersion:  3.17
+Contact:        xfs@oss.sgi.com
+Description:
+                The current state of the log write grant head. It
+                represents the total log reservation of all currently
+                oustanding transactions, including regrants due to
+                rolling transactions. The grant head is exported in
+                "cycle:bytes" format.
+Users:          xfstests
diff --git a/fs/xfs/Kconfig b/fs/xfs/Kconfig
index 399e8cec6e60..5d47b4df61ea 100644
--- a/fs/xfs/Kconfig
+++ b/fs/xfs/Kconfig
@@ -1,6 +1,7 @@
 config XFS_FS
         tristate "XFS filesystem support"
         depends on BLOCK
+        depends on (64BIT || LBDAF)
         select EXPORTFS
         select LIBCRC32C
         help
diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index c21f43506661..d61799949580 100644
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -17,6 +17,7 @@
 #
 
 ccflags-y += -I$(src)                   # needed for trace events
+ccflags-y += -I$(src)/libxfs
 
 ccflags-$(CONFIG_XFS_DEBUG) += -g
 
@@ -25,6 +26,39 @@ obj-$(CONFIG_XFS_FS)		+= xfs.o
 # this one should be compiled first, as the tracing macros can easily blow up
 xfs-y                           += xfs_trace.o
 
+# build the libxfs code first
+xfs-y                           += $(addprefix libxfs/, \
+                                   xfs_alloc.o \
+                                   xfs_alloc_btree.o \
+                                   xfs_attr.o \
+                                   xfs_attr_leaf.o \
+                                   xfs_attr_remote.o \
+                                   xfs_bmap.o \
+                                   xfs_bmap_btree.o \
+                                   xfs_btree.o \
+                                   xfs_da_btree.o \
+                                   xfs_da_format.o \
+                                   xfs_dir2.o \
+                                   xfs_dir2_block.o \
+                                   xfs_dir2_data.o \
+                                   xfs_dir2_leaf.o \
+                                   xfs_dir2_node.o \
+                                   xfs_dir2_sf.o \
+                                   xfs_dquot_buf.o \
+                                   xfs_ialloc.o \
+                                   xfs_ialloc_btree.o \
+                                   xfs_inode_fork.o \
+                                   xfs_inode_buf.o \
+                                   xfs_log_rlimit.o \
+                                   xfs_sb.o \
+                                   xfs_symlink_remote.o \
+                                   xfs_trans_resv.o \
+                                   )
+# xfs_rtbitmap is shared with libxfs
+xfs-$(CONFIG_XFS_RT)            += $(addprefix libxfs/, \
+                                   xfs_rtbitmap.o \
+                                   )
+
 # highlevel code
 xfs-y                           += xfs_aops.o \
                                    xfs_attr_inactive.o \
@@ -45,53 +79,27 @@ xfs-y				+= xfs_aops.o \
                                    xfs_ioctl.o \
                                    xfs_iomap.o \
                                    xfs_iops.o \
+                                   xfs_inode.o \
                                    xfs_itable.o \
                                    xfs_message.o \
                                    xfs_mount.o \
                                    xfs_mru_cache.o \
                                    xfs_super.o \
                                    xfs_symlink.o \
+                                   xfs_sysfs.o \
                                    xfs_trans.o \
                                    xfs_xattr.o \
                                    kmem.o \
                                    uuid.o
 
-# code shared with libxfs
-xfs-y                           += xfs_alloc.o \
-                                   xfs_alloc_btree.o \
-                                   xfs_attr.o \
-                                   xfs_attr_leaf.o \
-                                   xfs_attr_remote.o \
-                                   xfs_bmap.o \
-                                   xfs_bmap_btree.o \
-                                   xfs_btree.o \
-                                   xfs_da_btree.o \
-                                   xfs_da_format.o \
-                                   xfs_dir2.o \
-                                   xfs_dir2_block.o \
-                                   xfs_dir2_data.o \
-                                   xfs_dir2_leaf.o \
-                                   xfs_dir2_node.o \
-                                   xfs_dir2_sf.o \
-                                   xfs_dquot_buf.o \
-                                   xfs_ialloc.o \
-                                   xfs_ialloc_btree.o \
-                                   xfs_icreate_item.o \
-                                   xfs_inode.o \
-                                   xfs_inode_fork.o \
-                                   xfs_inode_buf.o \
-                                   xfs_log_recover.o \
-                                   xfs_log_rlimit.o \
-                                   xfs_sb.o \
-                                   xfs_symlink_remote.o \
-                                   xfs_trans_resv.o
-
 # low-level transaction/log code
 xfs-y                           += xfs_log.o \
                                    xfs_log_cil.o \
                                    xfs_buf_item.o \
                                    xfs_extfree_item.o \
+                                   xfs_icreate_item.o \
                                    xfs_inode_item.o \
+                                   xfs_log_recover.o \
                                    xfs_trans_ail.o \
                                    xfs_trans_buf.o \
                                    xfs_trans_extfree.o \
@@ -107,8 +115,7 @@ xfs-$(CONFIG_XFS_QUOTA)		+= xfs_dquot.o \
                                    xfs_quotaops.o
 
 # xfs_rtbitmap is shared with libxfs
-xfs-$(CONFIG_XFS_RT)            += xfs_rtalloc.o \
-                                   xfs_rtbitmap.o
+xfs-$(CONFIG_XFS_RT)            += xfs_rtalloc.o
 
 xfs-$(CONFIG_XFS_POSIX_ACL)     += xfs_acl.o
 xfs-$(CONFIG_PROC_FS)           += xfs_stats.o
diff --git a/fs/xfs/xfs_ag.h b/fs/xfs/libxfs/xfs_ag.h
index 6e247a99f5db..6e247a99f5db 100644
--- a/fs/xfs/xfs_ag.h
+++ b/fs/xfs/libxfs/xfs_ag.h
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index d43813267a80..4bffffe038a1 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -483,9 +483,9 @@ xfs_agfl_read_verify(
                 return;
 
         if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_agfl_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -503,7 +503,7 @@ xfs_agfl_write_verify(
                 return;
 
         if (!xfs_agfl_verify(bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
@@ -559,7 +559,7 @@ xfs_alloc_update_counters(
         xfs_trans_agblocks_delta(tp, len);
         if (unlikely(be32_to_cpu(agf->agf_freeblks) >
                      be32_to_cpu(agf->agf_length)))
-                return EFSCORRUPTED;
+                return -EFSCORRUPTED;
 
         xfs_alloc_log_agf(tp, agbp, XFS_AGF_FREEBLKS);
         return 0;
@@ -2234,11 +2234,11 @@ xfs_agf_read_verify(
 
         if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (XFS_TEST_ERROR(!xfs_agf_verify(mp, bp), mp,
                                 XFS_ERRTAG_ALLOC_READ_AGF,
                                 XFS_RANDOM_ALLOC_READ_AGF))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -2252,7 +2252,7 @@ xfs_agf_write_verify(
         struct xfs_buf_log_item *bip = bp->b_fspriv;
 
         if (!xfs_agf_verify(mp, bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
@@ -2601,11 +2601,11 @@ xfs_free_extent(
          */
         args.agno = XFS_FSB_TO_AGNO(args.mp, bno);
         if (args.agno >= args.mp->m_sb.sb_agcount)
-                return EFSCORRUPTED;
+                return -EFSCORRUPTED;
 
         args.agbno = XFS_FSB_TO_AGBNO(args.mp, bno);
         if (args.agbno >= args.mp->m_sb.sb_agblocks)
-                return EFSCORRUPTED;
+                return -EFSCORRUPTED;
 
         args.pag = xfs_perag_get(args.mp, args.agno);
         ASSERT(args.pag);
@@ -2617,7 +2617,7 @@ xfs_free_extent(
         /* validate the extent size is legal now we have the agf locked */
         if (args.agbno + len >
                         be32_to_cpu(XFS_BUF_TO_AGF(args.agbp)->agf_length)) {
-                error = EFSCORRUPTED;
+                error = -EFSCORRUPTED;
                 goto error0;
         }
 
diff --git a/fs/xfs/xfs_alloc.h b/fs/xfs/libxfs/xfs_alloc.h
index feacb061bab7..feacb061bab7 100644
--- a/fs/xfs/xfs_alloc.h
+++ b/fs/xfs/libxfs/xfs_alloc.h
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/libxfs/xfs_alloc_btree.c
index 8358f1ded94d..e0e83e24d3ef 100644
--- a/fs/xfs/xfs_alloc_btree.c
+++ b/fs/xfs/libxfs/xfs_alloc_btree.c
@@ -355,9 +355,9 @@ xfs_allocbt_read_verify(
         struct xfs_buf  *bp)
 {
         if (!xfs_btree_sblock_verify_crc(bp))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_allocbt_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error) {
                 trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -371,7 +371,7 @@ xfs_allocbt_write_verify(
 {
         if (!xfs_allocbt_verify(bp)) {
                 trace_xfs_btree_corrupt(bp, _RET_IP_);
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
diff --git a/fs/xfs/xfs_alloc_btree.h b/fs/xfs/libxfs/xfs_alloc_btree.h
index 45e189e7e81c..45e189e7e81c 100644
--- a/fs/xfs/xfs_alloc_btree.h
+++ b/fs/xfs/libxfs/xfs_alloc_btree.h
diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index bfe36fc2cdc2..353fb425faef 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -85,7 +85,7 @@ xfs_attr_args_init(
 {
 
         if (!name)
-                return EINVAL;
+                return -EINVAL;
 
         memset(args, 0, sizeof(*args));
         args->geo = dp->i_mount->m_attr_geo;
@@ -95,7 +95,7 @@ xfs_attr_args_init(
         args->name = name;
         args->namelen = strlen((const char *)name);
         if (args->namelen >= MAXNAMELEN)
-                return EFAULT;          /* match IRIX behaviour */
+                return -EFAULT;         /* match IRIX behaviour */
 
         args->hashval = xfs_da_hashname(args->name, args->namelen);
         return 0;
@@ -131,10 +131,10 @@ xfs_attr_get(
         XFS_STATS_INC(xs_attr_get);
 
         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
-                return EIO;
+                return -EIO;
 
         if (!xfs_inode_hasattr(ip))
-                return ENOATTR;
+                return -ENOATTR;
 
         error = xfs_attr_args_init(&args, ip, name, flags);
         if (error)
@@ -145,7 +145,7 @@ xfs_attr_get(
 
         lock_mode = xfs_ilock_attr_map_shared(ip);
         if (!xfs_inode_hasattr(ip))
-                error = ENOATTR;
+                error = -ENOATTR;
         else if (ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL)
                 error = xfs_attr_shortform_getvalue(&args);
         else if (xfs_bmap_one_block(ip, XFS_ATTR_FORK))
@@ -155,7 +155,7 @@ xfs_attr_get(
         xfs_iunlock(ip, lock_mode);
 
         *valuelenp = args.valuelen;
-        return error == EEXIST ? 0 : error;
+        return error == -EEXIST ? 0 : error;
 }
 
 /*
@@ -213,7 +213,7 @@ xfs_attr_set(
         XFS_STATS_INC(xs_attr_set);
 
         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-                return EIO;
+                return -EIO;
 
         error = xfs_attr_args_init(&args, dp, name, flags);
         if (error)
@@ -304,7 +304,7 @@ xfs_attr_set(
                  * the inode.
                  */
                 error = xfs_attr_shortform_addname(&args);
-                if (error != ENOSPC) {
+                if (error != -ENOSPC) {
                         /*
                          * Commit the shortform mods, and we're done.
                          * NOTE: this is also the error path (EEXIST, etc).
@@ -419,10 +419,10 @@ xfs_attr_remove(
         XFS_STATS_INC(xs_attr_remove);
 
         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-                return EIO;
+                return -EIO;
 
         if (!xfs_inode_hasattr(dp))
-                return ENOATTR;
+                return -ENOATTR;
 
         error = xfs_attr_args_init(&args, dp, name, flags);
         if (error)
@@ -477,7 +477,7 @@ xfs_attr_remove(
         xfs_trans_ijoin(args.trans, dp, 0);
 
         if (!xfs_inode_hasattr(dp)) {
-                error = XFS_ERROR(ENOATTR);
+                error = -ENOATTR;
         } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
                 ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
                 error = xfs_attr_shortform_remove(&args);
@@ -534,28 +534,28 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)
         trace_xfs_attr_sf_addname(args);
 
         retval = xfs_attr_shortform_lookup(args);
-        if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
-                return(retval);
-        } else if (retval == EEXIST) {
+        if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
+                return retval;
+        } else if (retval == -EEXIST) {
                 if (args->flags & ATTR_CREATE)
-                        return(retval);
+                        return retval;
                 retval = xfs_attr_shortform_remove(args);
                 ASSERT(retval == 0);
         }
 
         if (args->namelen >= XFS_ATTR_SF_ENTSIZE_MAX ||
             args->valuelen >= XFS_ATTR_SF_ENTSIZE_MAX)
-                return(XFS_ERROR(ENOSPC));
+                return -ENOSPC;
 
         newsize = XFS_ATTR_SF_TOTSIZE(args->dp);
         newsize += XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
 
         forkoff = xfs_attr_shortform_bytesfit(args->dp, newsize);
         if (!forkoff)
-                return(XFS_ERROR(ENOSPC));
+                return -ENOSPC;
 
         xfs_attr_shortform_add(args, forkoff);
-        return(0);
+        return 0;
 }
 
 
@@ -592,10 +592,10 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
          * the given flags produce an error or call for an atomic rename.
          */
         retval = xfs_attr3_leaf_lookup_int(bp, args);
-        if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
+        if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
                 xfs_trans_brelse(args->trans, bp);
                 return retval;
-        } else if (retval == EEXIST) {
+        } else if (retval == -EEXIST) {
                 if (args->flags & ATTR_CREATE) {        /* pure create op */
                         xfs_trans_brelse(args->trans, bp);
                         return retval;
@@ -626,7 +626,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
          * if required.
          */
         retval = xfs_attr3_leaf_add(bp, args);
-        if (retval == ENOSPC) {
+        if (retval == -ENOSPC) {
                 /*
                  * Promote the attribute list to the Btree format, then
                  * Commit that transaction so that the node_addname() call
@@ -642,7 +642,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                         ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
-                        return(error);
+                        return error;
                 }
 
                 /*
@@ -658,13 +658,13 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                  */
                 error = xfs_trans_roll(&args->trans, dp);
                 if (error)
-                        return (error);
+                        return error;
 
                 /*
                  * Fob the whole rest of the problem off on the Btree code.
                  */
                 error = xfs_attr_node_addname(args);
-                return(error);
+                return error;
         }
 
         /*
@@ -673,7 +673,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
          */
         error = xfs_trans_roll(&args->trans, dp);
         if (error)
-                return (error);
+                return error;
 
         /*
          * If there was an out-of-line value, allocate the blocks we
@@ -684,7 +684,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
         if (args->rmtblkno > 0) {
                 error = xfs_attr_rmtval_set(args);
                 if (error)
-                        return(error);
+                        return error;
         }
 
         /*
@@ -700,7 +700,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                  */
                 error = xfs_attr3_leaf_flipflags(args);
                 if (error)
-                        return(error);
+                        return error;
 
                 /*
                  * Dismantle the "old" attribute/value pair by removing
@@ -714,7 +714,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                 if (args->rmtblkno) {
                         error = xfs_attr_rmtval_remove(args);
                         if (error)
-                                return(error);
+                                return error;
                 }
 
                 /*
@@ -744,7 +744,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                                 ASSERT(committed);
                                 args->trans = NULL;
                                 xfs_bmap_cancel(args->flist);
-                                return(error);
+                                return error;
                         }
 
                         /*
@@ -795,7 +795,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
                 return error;
 
         error = xfs_attr3_leaf_lookup_int(bp, args);
-        if (error == ENOATTR) {
+        if (error == -ENOATTR) {
                 xfs_trans_brelse(args->trans, bp);
                 return error;
         }
@@ -850,7 +850,7 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
                 return error;
 
         error = xfs_attr3_leaf_lookup_int(bp, args);
-        if (error != EEXIST)  {
+        if (error != -EEXIST)  {
                 xfs_trans_brelse(args->trans, bp);
                 return error;
         }
@@ -906,9 +906,9 @@ restart:
                 goto out;
         blk = &state->path.blk[ state->path.active-1 ];
         ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
-        if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
+        if ((args->flags & ATTR_REPLACE) && (retval == -ENOATTR)) {
                 goto out;
-        } else if (retval == EEXIST) {
+        } else if (retval == -EEXIST) {
                 if (args->flags & ATTR_CREATE)
                         goto out;
 
@@ -933,7 +933,7 @@ restart:
         }
 
         retval = xfs_attr3_leaf_add(blk->bp, state->args);
-        if (retval == ENOSPC) {
+        if (retval == -ENOSPC) {
                 if (state->path.active == 1) {
                         /*
                          * Its really a single leaf node, but it had
@@ -1031,7 +1031,7 @@ restart:
         if (args->rmtblkno > 0) {
                 error = xfs_attr_rmtval_set(args);
                 if (error)
-                        return(error);
+                        return error;
         }
 
         /*
@@ -1061,7 +1061,7 @@ restart:
                 if (args->rmtblkno) {
                         error = xfs_attr_rmtval_remove(args);
                         if (error)
-                                return(error);
+                                return error;
                 }
 
                 /*
@@ -1134,8 +1134,8 @@ out:
         if (state)
                 xfs_da_state_free(state);
         if (error)
-                return(error);
-        return(retval);
+                return error;
+        return retval;
 }
 
 /*
@@ -1168,7 +1168,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
          * Search to see if name exists, and get back a pointer to it.
          */
         error = xfs_da3_node_lookup_int(state, &retval);
-        if (error || (retval != EEXIST)) {
+        if (error || (retval != -EEXIST)) {
                 if (error == 0)
                         error = retval;
                 goto out;
@@ -1297,7 +1297,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
 
 out:
         xfs_da_state_free(state);
-        return(error);
+        return error;
 }
 
 /*
@@ -1345,7 +1345,7 @@ xfs_attr_fillstate(xfs_da_state_t *state)
                 }
         }
 
-        return(0);
+        return 0;
 }
 
 /*
@@ -1376,7 +1376,7 @@ xfs_attr_refillstate(xfs_da_state_t *state)
                                                 blk->blkno, blk->disk_blkno,
                                                 &blk->bp, XFS_ATTR_FORK);
                         if (error)
-                                return(error);
+                                return error;
                 } else {
                         blk->bp = NULL;
                 }
@@ -1395,13 +1395,13 @@ xfs_attr_refillstate(xfs_da_state_t *state)
                                                 blk->blkno, blk->disk_blkno,
                                                 &blk->bp, XFS_ATTR_FORK);
                         if (error)
-                                return(error);
+                                return error;
                 } else {
                         blk->bp = NULL;
                 }
         }
 
-        return(0);
+        return 0;
 }
 
 /*
@@ -1431,7 +1431,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
         error = xfs_da3_node_lookup_int(state, &retval);
         if (error) {
                 retval = error;
-        } else if (retval == EEXIST) {
+        } else if (retval == -EEXIST) {
                 blk = &state->path.blk[ state->path.active-1 ];
                 ASSERT(blk->bp != NULL);
                 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
@@ -1455,5 +1455,5 @@ xfs_attr_node_get(xfs_da_args_t *args)
         }
 
         xfs_da_state_free(state);
-        return(retval);
+        return retval;
 }
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 28712d29e43c..b1f73dbbf3d8 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -214,7 +214,7 @@ xfs_attr3_leaf_write_verify(
         struct xfs_attr3_leaf_hdr *hdr3 = bp->b_addr;
 
         if (!xfs_attr3_leaf_verify(bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
@@ -242,9 +242,9 @@ xfs_attr3_leaf_read_verify(
 
         if (xfs_sb_version_hascrc(&mp->m_sb) &&
              !xfs_buf_verify_cksum(bp, XFS_ATTR3_LEAF_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_attr3_leaf_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -547,7 +547,7 @@ xfs_attr_shortform_remove(xfs_da_args_t *args)
                 break;
         }
         if (i == end)
-                return(XFS_ERROR(ENOATTR));
+                return -ENOATTR;
 
         /*
          * Fix up the attribute fork data, covering the hole
@@ -582,7 +582,7 @@ xfs_attr_shortform_remove(xfs_da_args_t *args)
 
         xfs_sbversion_add_attr2(mp, args->trans);
 
-        return(0);
+        return 0;
 }
 
 /*
@@ -611,9 +611,9 @@ xfs_attr_shortform_lookup(xfs_da_args_t *args)
                         continue;
                 if (!xfs_attr_namesp_match(args->flags, sfe->flags))
                         continue;
-                return(XFS_ERROR(EEXIST));
+                return -EEXIST;
         }
-        return(XFS_ERROR(ENOATTR));
+        return -ENOATTR;
 }
 
 /*
@@ -640,18 +640,18 @@ xfs_attr_shortform_getvalue(xfs_da_args_t *args)
                         continue;
                 if (args->flags & ATTR_KERNOVAL) {
                         args->valuelen = sfe->valuelen;
-                        return(XFS_ERROR(EEXIST));
+                        return -EEXIST;
                 }
                 if (args->valuelen < sfe->valuelen) {
                         args->valuelen = sfe->valuelen;
-                        return(XFS_ERROR(ERANGE));
+                        return -ERANGE;
                 }
                 args->valuelen = sfe->valuelen;
                 memcpy(args->value, &sfe->nameval[args->namelen],
                                                     args->valuelen);
-                return(XFS_ERROR(EEXIST));
+                return -EEXIST;
         }
-        return(XFS_ERROR(ENOATTR));
+        return -ENOATTR;
 }
 
 /*
@@ -691,7 +691,7 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
                  * If we hit an IO error middle of the transaction inside
                  * grow_inode(), we may have inconsistent data. Bail out.
                  */
-                if (error == EIO)
+                if (error == -EIO)
                         goto out;
                 xfs_idata_realloc(dp, size, XFS_ATTR_FORK);     /* try to put */
                 memcpy(ifp->if_u1.if_data, tmpbuffer, size);    /* it back */
@@ -730,9 +730,9 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
                                                 sfe->namelen);
                 nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(sfe->flags);
                 error = xfs_attr3_leaf_lookup_int(bp, &nargs); /* set a->index */
-                ASSERT(error == ENOATTR);
+                ASSERT(error == -ENOATTR);
                 error = xfs_attr3_leaf_add(bp, &nargs);
-                ASSERT(error != ENOSPC);
+                ASSERT(error != -ENOSPC);
                 if (error)
                         goto out;
                 sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
@@ -741,7 +741,7 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
 
 out:
         kmem_free(tmpbuffer);
-        return(error);
+        return error;
 }
 
 /*
@@ -769,12 +769,12 @@ xfs_attr_shortform_allfit(
                 if (entry->flags & XFS_ATTR_INCOMPLETE)
                         continue;               /* don't copy partial entries */
                 if (!(entry->flags & XFS_ATTR_LOCAL))
-                        return(0);
+                        return 0;
                 name_loc = xfs_attr3_leaf_name_local(leaf, i);
                 if (name_loc->namelen >= XFS_ATTR_SF_ENTSIZE_MAX)
-                        return(0);
+                        return 0;
                 if (be16_to_cpu(name_loc->valuelen) >= XFS_ATTR_SF_ENTSIZE_MAX)
-                        return(0);
+                        return 0;
                 bytes += sizeof(struct xfs_attr_sf_entry) - 1
                                 + name_loc->namelen
                                 + be16_to_cpu(name_loc->valuelen);
@@ -809,7 +809,7 @@ xfs_attr3_leaf_to_shortform(
 
         tmpbuffer = kmem_alloc(args->geo->blksize, KM_SLEEP);
         if (!tmpbuffer)
-                return ENOMEM;
+                return -ENOMEM;
 
         memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);
 
@@ -1017,10 +1017,10 @@ xfs_attr3_leaf_split(
         ASSERT(oldblk->magic == XFS_ATTR_LEAF_MAGIC);
         error = xfs_da_grow_inode(state->args, &blkno);
         if (error)
-                return(error);
+                return error;
         error = xfs_attr3_leaf_create(state->args, blkno, &newblk->bp);
         if (error)
-                return(error);
+                return error;
         newblk->blkno = blkno;
         newblk->magic = XFS_ATTR_LEAF_MAGIC;
 
@@ -1031,7 +1031,7 @@ xfs_attr3_leaf_split(
         xfs_attr3_leaf_rebalance(state, oldblk, newblk);
         error = xfs_da3_blk_link(state, oldblk, newblk);
         if (error)
-                return(error);
+                return error;
 
         /*
          * Save info on "old" attribute for "atomic rename" ops, leaf_add()
@@ -1053,7 +1053,7 @@ xfs_attr3_leaf_split(
          */
         oldblk->hashval = xfs_attr_leaf_lasthash(oldblk->bp, NULL);
         newblk->hashval = xfs_attr_leaf_lasthash(newblk->bp, NULL);
-        return(error);
+        return error;
 }
 
 /*
@@ -1108,7 +1108,7 @@ xfs_attr3_leaf_add(
          * no good and we should just give up.
          */
         if (!ichdr.holes && sum < entsize)
-                return XFS_ERROR(ENOSPC);
+                return -ENOSPC;
 
         /*
          * Compact the entries to coalesce free space.
@@ -1121,7 +1121,7 @@ xfs_attr3_leaf_add(
          * free region, in freemap[0].  If it is not big enough, give up.
          */
         if (ichdr.freemap[0].size < (entsize + sizeof(xfs_attr_leaf_entry_t))) {
-                tmp = ENOSPC;
+                tmp = -ENOSPC;
                 goto out_log_hdr;
         }
 
@@ -1692,7 +1692,7 @@ xfs_attr3_leaf_toosmall(
                 ichdr.usedbytes;
         if (bytes > (state->args->geo->blksize >> 1)) {
                 *action = 0;    /* blk over 50%, don't try to join */
-                return(0);
+                return 0;
         }
 
         /*
@@ -1711,7 +1711,7 @@ xfs_attr3_leaf_toosmall(
                 error = xfs_da3_path_shift(state, &state->altpath, forward,
                                                  0, &retval);
                 if (error)
-                        return(error);
+                        return error;
                 if (retval) {
                         *action = 0;
                 } else {
@@ -1740,7 +1740,7 @@ xfs_attr3_leaf_toosmall(
                 error = xfs_attr3_leaf_read(state->args->trans, state->args->dp,
                                         blkno, -1, &bp);
                 if (error)
-                        return(error);
+                        return error;
 
                 xfs_attr3_leaf_hdr_from_disk(&ichdr2, bp->b_addr);
 
@@ -1757,7 +1757,7 @@ xfs_attr3_leaf_toosmall(
         }
         if (i >= 2) {
                 *action = 0;
-                return(0);
+                return 0;
         }
 
         /*
@@ -1773,13 +1773,13 @@ xfs_attr3_leaf_toosmall(
                                                  0, &retval);
         }
         if (error)
-                return(error);
+                return error;
         if (retval) {
                 *action = 0;
         } else {
                 *action = 1;
         }
-        return(0);
+        return 0;
 }
 
 /*
@@ -2123,7 +2123,7 @@ xfs_attr3_leaf_lookup_int(
         }
         if (probe == ichdr.count || be32_to_cpu(entry->hashval) != hashval) {
                 args->index = probe;
-                return XFS_ERROR(ENOATTR);
+                return -ENOATTR;
         }
 
         /*
@@ -2152,7 +2152,7 @@ xfs_attr3_leaf_lookup_int(
                         if (!xfs_attr_namesp_match(args->flags, entry->flags))
                                 continue;
                         args->index = probe;
-                        return XFS_ERROR(EEXIST);
+                        return -EEXIST;
                 } else {
                         name_rmt = xfs_attr3_leaf_name_remote(leaf, probe);
                         if (name_rmt->namelen != args->namelen)
@@ -2168,11 +2168,11 @@ xfs_attr3_leaf_lookup_int(
                         args->rmtblkcnt = xfs_attr3_rmt_blocks(
                                                         args->dp->i_mount,
                                                         args->rmtvaluelen);
-                        return XFS_ERROR(EEXIST);
+                        return -EEXIST;
                 }
         }
         args->index = probe;
-        return XFS_ERROR(ENOATTR);
+        return -ENOATTR;
 }
 
 /*
@@ -2208,7 +2208,7 @@ xfs_attr3_leaf_getvalue(
                 }
                 if (args->valuelen < valuelen) {
                         args->valuelen = valuelen;
-                        return XFS_ERROR(ERANGE);
+                        return -ERANGE;
                 }
                 args->valuelen = valuelen;
                 memcpy(args->value, &name_loc->nameval[args->namelen], valuelen);
@@ -2226,7 +2226,7 @@ xfs_attr3_leaf_getvalue(
                 }
                 if (args->valuelen < args->rmtvaluelen) {
                         args->valuelen = args->rmtvaluelen;
-                        return XFS_ERROR(ERANGE);
+                        return -ERANGE;
                 }
                 args->valuelen = args->rmtvaluelen;
         }
@@ -2481,7 +2481,7 @@ xfs_attr3_leaf_clearflag(
          */
         error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
         if (error)
-                return(error);
+                return error;
 
         leaf = bp->b_addr;
         entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
@@ -2548,7 +2548,7 @@ xfs_attr3_leaf_setflag(
          */
         error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
         if (error)
-                return(error);
+                return error;
 
         leaf = bp->b_addr;
 #ifdef DEBUG
diff --git a/fs/xfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
index e2929da7c3ba..e2929da7c3ba 100644
--- a/fs/xfs/xfs_attr_leaf.h
+++ b/fs/xfs/libxfs/xfs_attr_leaf.h
diff --git a/fs/xfs/xfs_attr_remote.c b/fs/xfs/libxfs/xfs_attr_remote.c
index b5adfecbb8ee..7510ab8058a4 100644
--- a/fs/xfs/xfs_attr_remote.c
+++ b/fs/xfs/libxfs/xfs_attr_remote.c
@@ -138,11 +138,11 @@ xfs_attr3_rmt_read_verify(
 
         while (len > 0) {
                 if (!xfs_verify_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF)) {
-                        xfs_buf_ioerror(bp, EFSBADCRC);
+                        xfs_buf_ioerror(bp, -EFSBADCRC);
                         break;
                 }
                 if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-                        xfs_buf_ioerror(bp, EFSCORRUPTED);
+                        xfs_buf_ioerror(bp, -EFSCORRUPTED);
                         break;
                 }
                 len -= blksize;
@@ -178,7 +178,7 @@ xfs_attr3_rmt_write_verify(
 
         while (len > 0) {
                 if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
-                        xfs_buf_ioerror(bp, EFSCORRUPTED);
+                        xfs_buf_ioerror(bp, -EFSCORRUPTED);
                         xfs_verifier_error(bp);
                         return;
                 }
@@ -257,7 +257,7 @@ xfs_attr_rmtval_copyout(
                                 xfs_alert(mp,
 "remote attribute header mismatch bno/off/len/owner (0x%llx/0x%x/Ox%x/0x%llx)",
                                         bno, *offset, byte_cnt, ino);
-                                return EFSCORRUPTED;
+                                return -EFSCORRUPTED;
                         }
                         hdr_size = sizeof(struct xfs_attr3_rmt_hdr);
                 }
@@ -452,7 +452,7 @@ xfs_attr_rmtval_set(
                         ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
-                        return(error);
+                        return error;
                 }
 
                 /*
@@ -473,7 +473,7 @@ xfs_attr_rmtval_set(
                  */
                 error = xfs_trans_roll(&args->trans, dp);
                 if (error)
-                        return (error);
+                        return error;
         }
 
         /*
@@ -498,7 +498,7 @@ xfs_attr_rmtval_set(
                                        blkcnt, &map, &nmap,
                                        XFS_BMAPI_ATTRFORK);
                 if (error)
-                        return(error);
+                        return error;
                 ASSERT(nmap == 1);
                 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
                        (map.br_startblock != HOLESTARTBLOCK));
@@ -508,7 +508,7 @@ xfs_attr_rmtval_set(
 
                 bp = xfs_buf_get(mp->m_ddev_targp, dblkno, dblkcnt, 0);
                 if (!bp)
-                        return ENOMEM;
+                        return -ENOMEM;
                 bp->b_ops = &xfs_attr3_rmt_buf_ops;
 
                 xfs_attr_rmtval_copyin(mp, bp, args->dp->i_ino, &offset,
@@ -563,7 +563,7 @@ xfs_attr_rmtval_remove(
                 error = xfs_bmapi_read(args->dp, (xfs_fileoff_t)lblkno,
                                        blkcnt, &map, &nmap, XFS_BMAPI_ATTRFORK);
                 if (error)
-                        return(error);
+                        return error;
                 ASSERT(nmap == 1);
                 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
                        (map.br_startblock != HOLESTARTBLOCK));
@@ -622,7 +622,7 @@ xfs_attr_rmtval_remove(
                  */
                 error = xfs_trans_roll(&args->trans, args->dp);
                 if (error)
-                        return (error);
+                        return error;
         }
-        return(0);
+        return 0;
 }
diff --git a/fs/xfs/xfs_attr_remote.h b/fs/xfs/libxfs/xfs_attr_remote.h
index 5a9acfa156d7..5a9acfa156d7 100644
--- a/fs/xfs/xfs_attr_remote.h
+++ b/fs/xfs/libxfs/xfs_attr_remote.h
diff --git a/fs/xfs/xfs_attr_sf.h b/fs/xfs/libxfs/xfs_attr_sf.h
index 919756e3ba53..919756e3ba53 100644
--- a/fs/xfs/xfs_attr_sf.h
+++ b/fs/xfs/libxfs/xfs_attr_sf.h
diff --git a/fs/xfs/xfs_bit.h b/fs/xfs/libxfs/xfs_bit.h
index e1649c0d3e02..e1649c0d3e02 100644
--- a/fs/xfs/xfs_bit.h
+++ b/fs/xfs/libxfs/xfs_bit.h
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 75c3fe5f3d9d..de2d26d32844 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -392,7 +392,7 @@ xfs_bmap_check_leaf_extents(
         pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
         bno = be64_to_cpu(*pp);
 
-        ASSERT(bno != NULLDFSBNO);
+        ASSERT(bno != NULLFSBLOCK);
         ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
         ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
 
@@ -1033,7 +1033,7 @@ xfs_bmap_add_attrfork_btree(
                         goto error0;
                 if (stat == 0) {
                         xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
                 }
                 *firstblock = cur->bc_private.b.firstblock;
                 cur->bc_private.b.allocated = 0;
@@ -1115,7 +1115,7 @@ xfs_bmap_add_attrfork_local(
 
         /* should only be called for types that support local format data */
         ASSERT(0);
-        return EFSCORRUPTED;
+        return -EFSCORRUPTED;
 }
 
 /*
@@ -1192,7 +1192,7 @@ xfs_bmap_add_attrfork(
                 break;
         default:
                 ASSERT(0);
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto trans_cancel;
         }
 
@@ -1299,7 +1299,7 @@ xfs_bmap_read_extents(
         ASSERT(level > 0);
         pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
         bno = be64_to_cpu(*pp);
-        ASSERT(bno != NULLDFSBNO);
+        ASSERT(bno != NULLFSBLOCK);
         ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
         ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
         /*
@@ -1399,7 +1399,7 @@ xfs_bmap_read_extents(
         return 0;
 error0:
         xfs_trans_brelse(tp, bp);
-        return XFS_ERROR(EFSCORRUPTED);
+        return -EFSCORRUPTED;
 }
 
 
@@ -1429,11 +1429,7 @@ xfs_bmap_search_multi_extents(
         gotp->br_startoff = 0xffa5a5a5a5a5a5a5LL;
         gotp->br_blockcount = 0xa55a5a5a5a5a5a5aLL;
         gotp->br_state = XFS_EXT_INVALID;
-#if XFS_BIG_BLKNOS
         gotp->br_startblock = 0xffffa5a5a5a5a5a5LL;
-#else
-        gotp->br_startblock = 0xffffa5a5;
-#endif
         prevp->br_startoff = NULLFILEOFF;
 
         ep = xfs_iext_bno_to_ext(ifp, bno, &lastx);
@@ -1576,7 +1572,7 @@ xfs_bmap_last_before(
         if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
             XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
             XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL)
-               return XFS_ERROR(EIO);
+               return -EIO;
         if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
                 *last_block = 0;
                 return 0;
@@ -1690,7 +1686,7 @@ xfs_bmap_last_offset(
 
         if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
             XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
-               return XFS_ERROR(EIO);
+               return -EIO;
 
         error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
         if (error || is_empty)
@@ -3323,7 +3319,7 @@ xfs_bmap_extsize_align(
                 if (orig_off < align_off ||
                     orig_end > align_off + align_alen ||
                     align_alen - temp < orig_alen)
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 /*
                  * Try to fix it by moving the start up.
                  */
@@ -3348,7 +3344,7 @@ xfs_bmap_extsize_align(
                  * Result doesn't cover the request, fail it.
                  */
                 if (orig_off < align_off || orig_end > align_off + align_alen)
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
         } else {
                 ASSERT(orig_off >= align_off);
                 ASSERT(orig_end <= align_off + align_alen);
@@ -4051,11 +4047,11 @@ xfs_bmapi_read(
              XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
              mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
                 XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         XFS_STATS_INC(xs_blk_mapr);
 
@@ -4246,11 +4242,11 @@ xfs_bmapi_delay(
              XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE),
              mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
                 XFS_ERROR_REPORT("xfs_bmapi_delay", XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         XFS_STATS_INC(xs_blk_mapw);
 
@@ -4469,7 +4465,7 @@ xfs_bmapi_convert_unwritten(
          * so generate another request.
          */
         if (mval->br_blockcount < len)
-                return EAGAIN;
+                return -EAGAIN;
         return 0;
 }
 
@@ -4540,11 +4536,11 @@ xfs_bmapi_write(
              XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
              mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
                 XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         ifp = XFS_IFORK_PTR(ip, whichfork);
 
@@ -4620,7 +4616,7 @@ xfs_bmapi_write(
 
                 /* Execute unwritten extent conversion if necessary */
                 error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags);
-                if (error == EAGAIN)
+                if (error == -EAGAIN)
                         continue;
                 if (error)
                         goto error0;
@@ -4922,7 +4918,7 @@ xfs_bmap_del_extent(
                                         goto done;
                                 cur->bc_rec.b = new;
                                 error = xfs_btree_insert(cur, &i);
-                                if (error && error != ENOSPC)
+                                if (error && error != -ENOSPC)
                                         goto done;
                                 /*
                                  * If get no-space back from btree insert,
@@ -4930,7 +4926,7 @@ xfs_bmap_del_extent(
                                  * block reservation.
                                  * Fix up our state and return the error.
                                  */
-                                if (error == ENOSPC) {
+                                if (error == -ENOSPC) {
                                         /*
                                          * Reset the cursor, don't trust
                                          * it after any insert operation.
@@ -4958,7 +4954,7 @@ xfs_bmap_del_extent(
                                         xfs_bmbt_set_blockcount(ep,
                                                 got.br_blockcount);
                                         flags = 0;
-                                        error = XFS_ERROR(ENOSPC);
+                                        error = -ENOSPC;
                                         goto done;
                                 }
                                 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
@@ -5076,11 +5072,11 @@ xfs_bunmapi(
             XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
                 XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW,
                                  ip->i_mount);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         mp = ip->i_mount;
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
         ASSERT(len > 0);
@@ -5325,7 +5321,7 @@ xfs_bunmapi(
                     del.br_startoff > got.br_startoff &&
                     del.br_startoff + del.br_blockcount <
                     got.br_startoff + got.br_blockcount) {
-                        error = XFS_ERROR(ENOSPC);
+                        error = -ENOSPC;
                         goto error0;
                 }
                 error = xfs_bmap_del_extent(ip, tp, &lastx, flist, cur, &del,
@@ -5449,11 +5445,11 @@ xfs_bmap_shift_extents(
              mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
                 XFS_ERROR_REPORT("xfs_bmap_shift_extents",
                                  XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         ASSERT(current_ext != NULL);
 
@@ -5516,14 +5512,14 @@ xfs_bmap_shift_extents(
                                                 *current_ext - 1), &left);
 
                         if (startoff < left.br_startoff + left.br_blockcount)
-                                error = XFS_ERROR(EINVAL);
+                                error = -EINVAL;
                 } else if (offset_shift_fsb > got.br_startoff) {
                         /*
                          * When first extent is shifted, offset_shift_fsb
                          * should be less than the stating offset of
                          * the first extent.
                          */
-                        error = XFS_ERROR(EINVAL);
+                        error = -EINVAL;
                 }
 
                 if (error)
diff --git a/fs/xfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
index b879ca56a64c..b879ca56a64c 100644
--- a/fs/xfs/xfs_bmap.h
+++ b/fs/xfs/libxfs/xfs_bmap.h
diff --git a/fs/xfs/xfs_bmap_btree.c b/fs/xfs/libxfs/xfs_bmap_btree.c
index 948836c4fd90..fba753308f31 100644
--- a/fs/xfs/xfs_bmap_btree.c
+++ b/fs/xfs/libxfs/xfs_bmap_btree.c
@@ -111,23 +111,8 @@ __xfs_bmbt_get_all(
         ext_flag = (int)(l0 >> (64 - BMBT_EXNTFLAG_BITLEN));
         s->br_startoff = ((xfs_fileoff_t)l0 &
                            xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
-#if XFS_BIG_BLKNOS
         s->br_startblock = (((xfs_fsblock_t)l0 & xfs_mask64lo(9)) << 43) |
                            (((xfs_fsblock_t)l1) >> 21);
-#else
-#ifdef DEBUG
-        {
-                xfs_dfsbno_t    b;
-
-                b = (((xfs_dfsbno_t)l0 & xfs_mask64lo(9)) << 43) |
-                    (((xfs_dfsbno_t)l1) >> 21);
-                ASSERT((b >> 32) == 0 || isnulldstartblock(b));
-                s->br_startblock = (xfs_fsblock_t)b;
-        }
-#else   /* !DEBUG */
-        s->br_startblock = (xfs_fsblock_t)(((xfs_dfsbno_t)l1) >> 21);
-#endif  /* DEBUG */
-#endif  /* XFS_BIG_BLKNOS */
         s->br_blockcount = (xfs_filblks_t)(l1 & xfs_mask64lo(21));
         /* This is xfs_extent_state() in-line */
         if (ext_flag) {
@@ -163,21 +148,8 @@ xfs_fsblock_t
 xfs_bmbt_get_startblock(
         xfs_bmbt_rec_host_t     *r)
 {
-#if XFS_BIG_BLKNOS
         return (((xfs_fsblock_t)r->l0 & xfs_mask64lo(9)) << 43) |
                (((xfs_fsblock_t)r->l1) >> 21);
-#else
-#ifdef DEBUG
-        xfs_dfsbno_t    b;
-
-        b = (((xfs_dfsbno_t)r->l0 & xfs_mask64lo(9)) << 43) |
-            (((xfs_dfsbno_t)r->l1) >> 21);
-        ASSERT((b >> 32) == 0 || isnulldstartblock(b));
-        return (xfs_fsblock_t)b;
-#else   /* !DEBUG */
-        return (xfs_fsblock_t)(((xfs_dfsbno_t)r->l1) >> 21);
-#endif  /* DEBUG */
-#endif  /* XFS_BIG_BLKNOS */
 }
 
 /*
@@ -241,7 +213,6 @@ xfs_bmbt_set_allf(
         ASSERT((startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)) == 0);
         ASSERT((blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
 
-#if XFS_BIG_BLKNOS
         ASSERT((startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)) == 0);
 
         r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
@@ -250,23 +221,6 @@ xfs_bmbt_set_allf(
         r->l1 = ((xfs_bmbt_rec_base_t)startblock << 21) |
                 ((xfs_bmbt_rec_base_t)blockcount &
                 (xfs_bmbt_rec_base_t)xfs_mask64lo(21));
-#else   /* !XFS_BIG_BLKNOS */
-        if (isnullstartblock(startblock)) {
-                r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
-                        ((xfs_bmbt_rec_base_t)startoff << 9) |
-                         (xfs_bmbt_rec_base_t)xfs_mask64lo(9);
-                r->l1 = xfs_mask64hi(11) |
-                          ((xfs_bmbt_rec_base_t)startblock << 21) |
-                          ((xfs_bmbt_rec_base_t)blockcount &
-                           (xfs_bmbt_rec_base_t)xfs_mask64lo(21));
-        } else {
-                r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
-                        ((xfs_bmbt_rec_base_t)startoff << 9);
-                r->l1 = ((xfs_bmbt_rec_base_t)startblock << 21) |
-                         ((xfs_bmbt_rec_base_t)blockcount &
-                         (xfs_bmbt_rec_base_t)xfs_mask64lo(21));
-        }
-#endif  /* XFS_BIG_BLKNOS */
 }
 
 /*
@@ -298,8 +252,6 @@ xfs_bmbt_disk_set_allf(
         ASSERT(state == XFS_EXT_NORM || state == XFS_EXT_UNWRITTEN);
         ASSERT((startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)) == 0);
         ASSERT((blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
-
-#if XFS_BIG_BLKNOS
         ASSERT((startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)) == 0);
 
         r->l0 = cpu_to_be64(
@@ -310,26 +262,6 @@ xfs_bmbt_disk_set_allf(
                 ((xfs_bmbt_rec_base_t)startblock << 21) |
                  ((xfs_bmbt_rec_base_t)blockcount &
                   (xfs_bmbt_rec_base_t)xfs_mask64lo(21)));
-#else   /* !XFS_BIG_BLKNOS */
-        if (isnullstartblock(startblock)) {
-                r->l0 = cpu_to_be64(
-                        ((xfs_bmbt_rec_base_t)extent_flag << 63) |
-                         ((xfs_bmbt_rec_base_t)startoff << 9) |
-                          (xfs_bmbt_rec_base_t)xfs_mask64lo(9));
-                r->l1 = cpu_to_be64(xfs_mask64hi(11) |
-                          ((xfs_bmbt_rec_base_t)startblock << 21) |
-                          ((xfs_bmbt_rec_base_t)blockcount &
-                           (xfs_bmbt_rec_base_t)xfs_mask64lo(21)));
-        } else {
-                r->l0 = cpu_to_be64(
-                        ((xfs_bmbt_rec_base_t)extent_flag << 63) |
-                         ((xfs_bmbt_rec_base_t)startoff << 9));
-                r->l1 = cpu_to_be64(
-                        ((xfs_bmbt_rec_base_t)startblock << 21) |
-                         ((xfs_bmbt_rec_base_t)blockcount &
-                          (xfs_bmbt_rec_base_t)xfs_mask64lo(21)));
-        }
-#endif  /* XFS_BIG_BLKNOS */
 }
 
 /*
@@ -365,24 +297,11 @@ xfs_bmbt_set_startblock(
         xfs_bmbt_rec_host_t *r,
         xfs_fsblock_t   v)
 {
-#if XFS_BIG_BLKNOS
         ASSERT((v & xfs_mask64hi(12)) == 0);
         r->l0 = (r->l0 & (xfs_bmbt_rec_base_t)xfs_mask64hi(55)) |
                   (xfs_bmbt_rec_base_t)(v >> 43);
         r->l1 = (r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64lo(21)) |
                   (xfs_bmbt_rec_base_t)(v << 21);
-#else   /* !XFS_BIG_BLKNOS */
-        if (isnullstartblock(v)) {
-                r->l0 |= (xfs_bmbt_rec_base_t)xfs_mask64lo(9);
-                r->l1 = (xfs_bmbt_rec_base_t)xfs_mask64hi(11) |
-                          ((xfs_bmbt_rec_base_t)v << 21) |
-                          (r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64lo(21));
-        } else {
-                r->l0 &= ~(xfs_bmbt_rec_base_t)xfs_mask64lo(9);
-                r->l1 = ((xfs_bmbt_rec_base_t)v << 21) |
-                          (r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64lo(21));
-        }
-#endif  /* XFS_BIG_BLKNOS */
 }
 
 /*
@@ -438,8 +357,8 @@ xfs_bmbt_to_bmdr(
                        cpu_to_be64(XFS_BUF_DADDR_NULL));
         } else
                 ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_MAGIC));
-        ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO));
-        ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO));
+        ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK));
+        ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK));
         ASSERT(rblock->bb_level != 0);
         dblock->bb_level = rblock->bb_level;
         dblock->bb_numrecs = rblock->bb_numrecs;
@@ -554,7 +473,7 @@ xfs_bmbt_alloc_block(
         args.minlen = args.maxlen = args.prod = 1;
         args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL;
         if (!args.wasdel && xfs_trans_get_block_res(args.tp) == 0) {
-                error = XFS_ERROR(ENOSPC);
+                error = -ENOSPC;
                 goto error0;
         }
         error = xfs_alloc_vextent(&args);
@@ -763,11 +682,11 @@ xfs_bmbt_verify(
 
         /* sibling pointer verification */
         if (!block->bb_u.l.bb_leftsib ||
-            (block->bb_u.l.bb_leftsib != cpu_to_be64(NULLDFSBNO) &&
+            (block->bb_u.l.bb_leftsib != cpu_to_be64(NULLFSBLOCK) &&
              !XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_leftsib))))
                 return false;
         if (!block->bb_u.l.bb_rightsib ||
-            (block->bb_u.l.bb_rightsib != cpu_to_be64(NULLDFSBNO) &&
+            (block->bb_u.l.bb_rightsib != cpu_to_be64(NULLFSBLOCK) &&
              !XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_rightsib))))
                 return false;
 
@@ -779,9 +698,9 @@ xfs_bmbt_read_verify(
         struct xfs_buf  *bp)
 {
         if (!xfs_btree_lblock_verify_crc(bp))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_bmbt_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error) {
                 trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -795,7 +714,7 @@ xfs_bmbt_write_verify(
 {
         if (!xfs_bmbt_verify(bp)) {
                 trace_xfs_btree_corrupt(bp, _RET_IP_);
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
@@ -959,7 +878,7 @@ xfs_bmbt_change_owner(
 
         cur = xfs_bmbt_init_cursor(ip->i_mount, tp, ip, whichfork);
         if (!cur)
-                return ENOMEM;
+                return -ENOMEM;
 
         error = xfs_btree_change_owner(cur, new_owner, buffer_list);
         xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
diff --git a/fs/xfs/xfs_bmap_btree.h b/fs/xfs/libxfs/xfs_bmap_btree.h
index 819a8a4dee95..819a8a4dee95 100644
--- a/fs/xfs/xfs_bmap_btree.h
+++ b/fs/xfs/libxfs/xfs_bmap_btree.h
diff --git a/fs/xfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index cf893bc1e373..8fe6a93ff473 100644
--- a/fs/xfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -78,11 +78,11 @@ xfs_btree_check_lblock(
                 be16_to_cpu(block->bb_numrecs) <=
                         cur->bc_ops->get_maxrecs(cur, level) &&
                 block->bb_u.l.bb_leftsib &&
-                (block->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO) ||
+                (block->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK) ||
                  XFS_FSB_SANITY_CHECK(mp,
                         be64_to_cpu(block->bb_u.l.bb_leftsib))) &&
                 block->bb_u.l.bb_rightsib &&
-                (block->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO) ||
+                (block->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK) ||
                  XFS_FSB_SANITY_CHECK(mp,
                         be64_to_cpu(block->bb_u.l.bb_rightsib)));
 
@@ -92,7 +92,7 @@ xfs_btree_check_lblock(
                 if (bp)
                         trace_xfs_btree_corrupt(bp, _RET_IP_);
                 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         return 0;
 }
@@ -140,7 +140,7 @@ xfs_btree_check_sblock(
                 if (bp)
                         trace_xfs_btree_corrupt(bp, _RET_IP_);
                 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         return 0;
 }
@@ -167,12 +167,12 @@ xfs_btree_check_block(
 int                                     /* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lptr(
         struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_dfsbno_t            bno,    /* btree block disk address */
+        xfs_fsblock_t           bno,    /* btree block disk address */
         int                     level)  /* btree block level */
 {
         XFS_WANT_CORRUPTED_RETURN(
                 level > 0 &&
-                bno != NULLDFSBNO &&
+                bno != NULLFSBLOCK &&
                 XFS_FSB_SANITY_CHECK(cur->bc_mp, bno));
         return 0;
 }
@@ -595,7 +595,7 @@ xfs_btree_islastblock(
         block = xfs_btree_get_block(cur, level, &bp);
         xfs_btree_check_block(cur, block, level, bp);
         if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
-                return block->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO);
+                return block->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK);
         else
                 return block->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK);
 }
@@ -771,16 +771,16 @@ xfs_btree_readahead_lblock(
         struct xfs_btree_block  *block)
 {
         int                     rval = 0;
-        xfs_dfsbno_t            left = be64_to_cpu(block->bb_u.l.bb_leftsib);
-        xfs_dfsbno_t            right = be64_to_cpu(block->bb_u.l.bb_rightsib);
+        xfs_fsblock_t           left = be64_to_cpu(block->bb_u.l.bb_leftsib);
+        xfs_fsblock_t           right = be64_to_cpu(block->bb_u.l.bb_rightsib);
 
-        if ((lr & XFS_BTCUR_LEFTRA) && left != NULLDFSBNO) {
+        if ((lr & XFS_BTCUR_LEFTRA) && left != NULLFSBLOCK) {
                 xfs_btree_reada_bufl(cur->bc_mp, left, 1,
                                      cur->bc_ops->buf_ops);
                 rval++;
         }
 
-        if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLDFSBNO) {
+        if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLFSBLOCK) {
                 xfs_btree_reada_bufl(cur->bc_mp, right, 1,
                                      cur->bc_ops->buf_ops);
                 rval++;
@@ -852,7 +852,7 @@ xfs_btree_ptr_to_daddr(
         union xfs_btree_ptr     *ptr)
 {
         if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
-                ASSERT(ptr->l != cpu_to_be64(NULLDFSBNO));
+                ASSERT(ptr->l != cpu_to_be64(NULLFSBLOCK));
 
                 return XFS_FSB_TO_DADDR(cur->bc_mp, be64_to_cpu(ptr->l));
         } else {
@@ -900,9 +900,9 @@ xfs_btree_setbuf(
 
         b = XFS_BUF_TO_BLOCK(bp);
         if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
-                if (b->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO))
+                if (b->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK))
                         cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
-                if (b->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO))
+                if (b->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK))
                         cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
         } else {
                 if (b->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK))
@@ -918,7 +918,7 @@ xfs_btree_ptr_is_null(
         union xfs_btree_ptr     *ptr)
 {
         if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
-                return ptr->l == cpu_to_be64(NULLDFSBNO);
+                return ptr->l == cpu_to_be64(NULLFSBLOCK);
         else
                 return ptr->s == cpu_to_be32(NULLAGBLOCK);
 }
@@ -929,7 +929,7 @@ xfs_btree_set_ptr_null(
         union xfs_btree_ptr     *ptr)
 {
         if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
-                ptr->l = cpu_to_be64(NULLDFSBNO);
+                ptr->l = cpu_to_be64(NULLFSBLOCK);
         else
                 ptr->s = cpu_to_be32(NULLAGBLOCK);
 }
@@ -997,8 +997,8 @@ xfs_btree_init_block_int(
         buf->bb_numrecs = cpu_to_be16(numrecs);
 
         if (flags & XFS_BTREE_LONG_PTRS) {
-                buf->bb_u.l.bb_leftsib = cpu_to_be64(NULLDFSBNO);
-                buf->bb_u.l.bb_rightsib = cpu_to_be64(NULLDFSBNO);
+                buf->bb_u.l.bb_leftsib = cpu_to_be64(NULLFSBLOCK);
+                buf->bb_u.l.bb_rightsib = cpu_to_be64(NULLFSBLOCK);
                 if (flags & XFS_BTREE_CRC_BLOCKS) {
                         buf->bb_u.l.bb_blkno = cpu_to_be64(blkno);
                         buf->bb_u.l.bb_owner = cpu_to_be64(owner);
@@ -1140,7 +1140,7 @@ xfs_btree_get_buf_block(
                                  mp->m_bsize, flags);
 
         if (!*bpp)
-                return ENOMEM;
+                return -ENOMEM;
 
         (*bpp)->b_ops = cur->bc_ops->buf_ops;
         *block = XFS_BUF_TO_BLOCK(*bpp);
@@ -1498,7 +1498,7 @@ xfs_btree_increment(
                 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
                         goto out0;
                 ASSERT(0);
-                error = EFSCORRUPTED;
+                error = -EFSCORRUPTED;
                 goto error0;
         }
         ASSERT(lev < cur->bc_nlevels);
@@ -1597,7 +1597,7 @@ xfs_btree_decrement(
                 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
                         goto out0;
                 ASSERT(0);
-                error = EFSCORRUPTED;
+                error = -EFSCORRUPTED;
                 goto error0;
         }
         ASSERT(lev < cur->bc_nlevels);
@@ -4018,7 +4018,7 @@ xfs_btree_block_change_owner(
         /* now read rh sibling block for next iteration */
         xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
         if (xfs_btree_ptr_is_null(cur, &rptr))
-                return ENOENT;
+                return -ENOENT;
 
         return xfs_btree_lookup_get_block(cur, level, &rptr, &block);
 }
@@ -4061,7 +4061,7 @@ xfs_btree_change_owner(
                                                              buffer_list);
                 } while (!error);
 
-                if (error != ENOENT)
+                if (error != -ENOENT)
                         return error;
         }
 
diff --git a/fs/xfs/xfs_btree.h b/fs/xfs/libxfs/xfs_btree.h
index a04b69422f67..8f18bab73ea5 100644
--- a/fs/xfs/xfs_btree.h
+++ b/fs/xfs/libxfs/xfs_btree.h
@@ -258,7 +258,7 @@ xfs_btree_check_block(
 int                                     /* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lptr(
         struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_dfsbno_t            ptr,    /* btree block disk address */
+        xfs_fsblock_t           ptr,    /* btree block disk address */
         int                     level); /* btree block level */
 
 /*
diff --git a/fs/xfs/xfs_cksum.h b/fs/xfs/libxfs/xfs_cksum.h
index fad1676ad8cd..fad1676ad8cd 100644
--- a/fs/xfs/xfs_cksum.h
+++ b/fs/xfs/libxfs/xfs_cksum.h
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index a514ab616650..2c42ae28d027 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -185,7 +185,7 @@ xfs_da3_node_write_verify(
         struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
 
         if (!xfs_da3_node_verify(bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
@@ -214,13 +214,13 @@ xfs_da3_node_read_verify(
         switch (be16_to_cpu(info->magic)) {
                 case XFS_DA3_NODE_MAGIC:
                         if (!xfs_buf_verify_cksum(bp, XFS_DA3_NODE_CRC_OFF)) {
-                                xfs_buf_ioerror(bp, EFSBADCRC);
+                                xfs_buf_ioerror(bp, -EFSBADCRC);
                                 break;
                         }
                         /* fall through */
                 case XFS_DA_NODE_MAGIC:
                         if (!xfs_da3_node_verify(bp)) {
-                                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                                 break;
                         }
                         return;
@@ -315,7 +315,7 @@ xfs_da3_node_create(
 
         error = xfs_da_get_buf(tp, dp, blkno, -1, &bp, whichfork);
         if (error)
-                return(error);
+                return error;
         bp->b_ops = &xfs_da3_node_buf_ops;
         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DA_NODE_BUF);
         node = bp->b_addr;
@@ -337,7 +337,7 @@ xfs_da3_node_create(
                 XFS_DA_LOGRANGE(node, &node->hdr, dp->d_ops->node_hdr_size));
 
         *bpp = bp;
-        return(0);
+        return 0;
 }
 
 /*
@@ -385,8 +385,8 @@ xfs_da3_split(
                 switch (oldblk->magic) {
                 case XFS_ATTR_LEAF_MAGIC:
                         error = xfs_attr3_leaf_split(state, oldblk, newblk);
-                        if ((error != 0) && (error != ENOSPC)) {
-                                return(error);  /* GROT: attr is inconsistent */
+                        if ((error != 0) && (error != -ENOSPC)) {
+                                return error;   /* GROT: attr is inconsistent */
                         }
                         if (!error) {
                                 addblk = newblk;
@@ -408,7 +408,7 @@ xfs_da3_split(
                                                             &state->extrablk);
                         }
                         if (error)
-                                return(error);  /* GROT: attr inconsistent */
+                                return error;   /* GROT: attr inconsistent */
                         addblk = newblk;
                         break;
                 case XFS_DIR2_LEAFN_MAGIC:
@@ -422,7 +422,7 @@ xfs_da3_split(
                                                          max - i, &action);
                         addblk->bp = NULL;
                         if (error)
-                                return(error);  /* GROT: dir is inconsistent */
+                                return error;   /* GROT: dir is inconsistent */
                         /*
                          * Record the newly split block for the next time thru?
                          */
@@ -439,7 +439,7 @@ xfs_da3_split(
                 xfs_da3_fixhashpath(state, &state->path);
         }
         if (!addblk)
-                return(0);
+                return 0;
 
         /*
          * Split the root node.
@@ -449,7 +449,7 @@ xfs_da3_split(
         error = xfs_da3_root_split(state, oldblk, addblk);
         if (error) {
                 addblk->bp = NULL;
-                return(error);  /* GROT: dir is inconsistent */
+                return error;   /* GROT: dir is inconsistent */
         }
 
         /*
@@ -492,7 +492,7 @@ xfs_da3_split(
                     sizeof(node->hdr.info)));
         }
         addblk->bp = NULL;
-        return(0);
+        return 0;
 }
 
 /*
@@ -670,18 +670,18 @@ xfs_da3_node_split(
                  */
                 error = xfs_da_grow_inode(state->args, &blkno);
                 if (error)
-                        return(error);  /* GROT: dir is inconsistent */
+                        return error;   /* GROT: dir is inconsistent */
 
                 error = xfs_da3_node_create(state->args, blkno, treelevel,
                                            &newblk->bp, state->args->whichfork);
                 if (error)
-                        return(error);  /* GROT: dir is inconsistent */
+                        return error;   /* GROT: dir is inconsistent */
                 newblk->blkno = blkno;
                 newblk->magic = XFS_DA_NODE_MAGIC;
                 xfs_da3_node_rebalance(state, oldblk, newblk);
                 error = xfs_da3_blk_link(state, oldblk, newblk);
                 if (error)
-                        return(error);
+                        return error;
                 *result = 1;
         } else {
                 *result = 0;
@@ -721,7 +721,7 @@ xfs_da3_node_split(
                 }
         }
 
-        return(0);
+        return 0;
 }
 
 /*
@@ -963,9 +963,9 @@ xfs_da3_join(
                 case XFS_ATTR_LEAF_MAGIC:
                         error = xfs_attr3_leaf_toosmall(state, &action);
                         if (error)
-                                return(error);
+                                return error;
                         if (action == 0)
-                                return(0);
+                                return 0;
                         xfs_attr3_leaf_unbalance(state, drop_blk, save_blk);
                         break;
                 case XFS_DIR2_LEAFN_MAGIC:
@@ -985,7 +985,7 @@ xfs_da3_join(
                         xfs_da3_fixhashpath(state, &state->path);
                         error = xfs_da3_node_toosmall(state, &action);
                         if (error)
-                                return(error);
+                                return error;
                         if (action == 0)
                                 return 0;
                         xfs_da3_node_unbalance(state, drop_blk, save_blk);
@@ -995,12 +995,12 @@ xfs_da3_join(
                 error = xfs_da3_blk_unlink(state, drop_blk, save_blk);
                 xfs_da_state_kill_altpath(state);
                 if (error)
-                        return(error);
+                        return error;
                 error = xfs_da_shrink_inode(state->args, drop_blk->blkno,
                                                          drop_blk->bp);
                 drop_blk->bp = NULL;
                 if (error)
-                        return(error);
+                        return error;
         }
         /*
          * We joined all the way to the top.  If it turns out that
@@ -1010,7 +1010,7 @@ xfs_da3_join(
         xfs_da3_node_remove(state, drop_blk);
         xfs_da3_fixhashpath(state, &state->path);
         error = xfs_da3_root_join(state, &state->path.blk[0]);
-        return(error);
+        return error;
 }
 
 #ifdef  DEBUG
@@ -1099,7 +1099,7 @@ xfs_da3_root_join(
         xfs_trans_log_buf(args->trans, root_blk->bp, 0,
                           args->geo->blksize - 1);
         error = xfs_da_shrink_inode(args, child, bp);
-        return(error);
+        return error;
 }
 
 /*
@@ -1142,7 +1142,7 @@ xfs_da3_node_toosmall(
         dp->d_ops->node_hdr_from_disk(&nodehdr, node);
         if (nodehdr.count > (state->args->geo->node_ents >> 1)) {
                 *action = 0;    /* blk over 50%, don't try to join */
-                return(0);      /* blk over 50%, don't try to join */
+                return 0;       /* blk over 50%, don't try to join */
         }
 
         /*
@@ -1161,13 +1161,13 @@ xfs_da3_node_toosmall(
                 error = xfs_da3_path_shift(state, &state->altpath, forward,
                                                  0, &retval);
                 if (error)
-                        return(error);
+                        return error;
                 if (retval) {
                         *action = 0;
                 } else {
                         *action = 2;
                 }
-                return(0);
+                return 0;
         }
 
         /*
@@ -1194,7 +1194,7 @@ xfs_da3_node_toosmall(
                 error = xfs_da3_node_read(state->args->trans, dp,
                                         blkno, -1, &bp, state->args->whichfork);
                 if (error)
-                        return(error);
+                        return error;
 
                 node = bp->b_addr;
                 dp->d_ops->node_hdr_from_disk(&thdr, node);
@@ -1486,7 +1486,7 @@ xfs_da3_node_lookup_int(
                 if (error) {
                         blk->blkno = 0;
                         state->path.active--;
-                        return(error);
+                        return error;
                 }
                 curr = blk->bp->b_addr;
                 blk->magic = be16_to_cpu(curr->magic);
@@ -1579,25 +1579,25 @@ xfs_da3_node_lookup_int(
                         args->blkno = blk->blkno;
                 } else {
                         ASSERT(0);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
-                if (((retval == ENOENT) || (retval == ENOATTR)) &&
+                if (((retval == -ENOENT) || (retval == -ENOATTR)) &&
                     (blk->hashval == args->hashval)) {
                         error = xfs_da3_path_shift(state, &state->path, 1, 1,
                                                          &retval);
                         if (error)
-                                return(error);
+                                return error;
                         if (retval == 0) {
                                 continue;
                         } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
                                 /* path_shift() gives ENOENT */
-                                retval = XFS_ERROR(ENOATTR);
+                                retval = -ENOATTR;
                         }
                 }
                 break;
         }
         *result = retval;
-        return(0);
+        return 0;
 }
 
 /*========================================================================
@@ -1692,7 +1692,7 @@ xfs_da3_blk_link(
                                                 be32_to_cpu(old_info->back),
                                                 -1, &bp, args->whichfork);
                         if (error)
-                                return(error);
+                                return error;
                         ASSERT(bp != NULL);
                         tmp_info = bp->b_addr;
                         ASSERT(tmp_info->magic == old_info->magic);
@@ -1713,7 +1713,7 @@ xfs_da3_blk_link(
                                                 be32_to_cpu(old_info->forw),
                                                 -1, &bp, args->whichfork);
                         if (error)
-                                return(error);
+                                return error;
                         ASSERT(bp != NULL);
                         tmp_info = bp->b_addr;
                         ASSERT(tmp_info->magic == old_info->magic);
@@ -1726,7 +1726,7 @@ xfs_da3_blk_link(
 
         xfs_trans_log_buf(args->trans, old_blk->bp, 0, sizeof(*tmp_info) - 1);
         xfs_trans_log_buf(args->trans, new_blk->bp, 0, sizeof(*tmp_info) - 1);
-        return(0);
+        return 0;
 }
 
 /*
@@ -1772,7 +1772,7 @@ xfs_da3_blk_unlink(
                                                 be32_to_cpu(drop_info->back),
                                                 -1, &bp, args->whichfork);
                         if (error)
-                                return(error);
+                                return error;
                         ASSERT(bp != NULL);
                         tmp_info = bp->b_addr;
                         ASSERT(tmp_info->magic == save_info->magic);
@@ -1789,7 +1789,7 @@ xfs_da3_blk_unlink(
                                                 be32_to_cpu(drop_info->forw),
                                                 -1, &bp, args->whichfork);
                         if (error)
-                                return(error);
+                                return error;
                         ASSERT(bp != NULL);
                         tmp_info = bp->b_addr;
                         ASSERT(tmp_info->magic == save_info->magic);
@@ -1801,7 +1801,7 @@ xfs_da3_blk_unlink(
         }
 
         xfs_trans_log_buf(args->trans, save_blk->bp, 0, sizeof(*save_info) - 1);
-        return(0);
+        return 0;
 }
 
 /*
@@ -1859,9 +1859,9 @@ xfs_da3_path_shift(
                 }
         }
         if (level < 0) {
-                *result = XFS_ERROR(ENOENT);    /* we're out of our tree */
+                *result = -ENOENT;      /* we're out of our tree */
                 ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
-                return(0);
+                return 0;
         }
 
         /*
@@ -1883,7 +1883,7 @@ xfs_da3_path_shift(
                 error = xfs_da3_node_read(args->trans, dp, blkno, -1,
                                         &blk->bp, args->whichfork);
                 if (error)
-                        return(error);
+                        return error;
                 info = blk->bp->b_addr;
                 ASSERT(info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
                        info->magic == cpu_to_be16(XFS_DA3_NODE_MAGIC) ||
@@ -2004,7 +2004,7 @@ xfs_da_grow_inode_int(
         struct xfs_trans        *tp = args->trans;
         struct xfs_inode        *dp = args->dp;
         int                     w = args->whichfork;
-        xfs_drfsbno_t           nblks = dp->i_d.di_nblocks;
+        xfs_rfsblock_t          nblks = dp->i_d.di_nblocks;
         struct xfs_bmbt_irec    map, *mapp;
         int                     nmap, error, got, i, mapi;
 
@@ -2068,7 +2068,7 @@ xfs_da_grow_inode_int(
         if (got != count || mapp[0].br_startoff != *bno ||
             mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount !=
             *bno + count) {
-                error = XFS_ERROR(ENOSPC);
+                error = -ENOSPC;
                 goto out_free_map;
         }
 
@@ -2158,7 +2158,7 @@ xfs_da3_swap_lastblock(
         if (unlikely(lastoff == 0)) {
                 XFS_ERROR_REPORT("xfs_da_swap_lastblock(1)", XFS_ERRLEVEL_LOW,
                                  mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         /*
          * Read the last block in the btree space.
@@ -2209,7 +2209,7 @@ xfs_da3_swap_lastblock(
                     sib_info->magic != dead_info->magic)) {
                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(2)",
                                          XFS_ERRLEVEL_LOW, mp);
-                        error = XFS_ERROR(EFSCORRUPTED);
+                        error = -EFSCORRUPTED;
                         goto done;
                 }
                 sib_info->forw = cpu_to_be32(dead_blkno);
@@ -2231,7 +2231,7 @@ xfs_da3_swap_lastblock(
                        sib_info->magic != dead_info->magic)) {
                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(3)",
                                          XFS_ERRLEVEL_LOW, mp);
-                        error = XFS_ERROR(EFSCORRUPTED);
+                        error = -EFSCORRUPTED;
                         goto done;
                 }
                 sib_info->back = cpu_to_be32(dead_blkno);
@@ -2254,7 +2254,7 @@ xfs_da3_swap_lastblock(
                 if (level >= 0 && level != par_hdr.level + 1) {
                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(4)",
                                          XFS_ERRLEVEL_LOW, mp);
-                        error = XFS_ERROR(EFSCORRUPTED);
+                        error = -EFSCORRUPTED;
                         goto done;
                 }
                 level = par_hdr.level;
@@ -2267,7 +2267,7 @@ xfs_da3_swap_lastblock(
                 if (entno == par_hdr.count) {
                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(5)",
                                          XFS_ERRLEVEL_LOW, mp);
-                        error = XFS_ERROR(EFSCORRUPTED);
+                        error = -EFSCORRUPTED;
                         goto done;
                 }
                 par_blkno = be32_to_cpu(btree[entno].before);
@@ -2294,7 +2294,7 @@ xfs_da3_swap_lastblock(
                 if (unlikely(par_blkno == 0)) {
                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(6)",
                                          XFS_ERRLEVEL_LOW, mp);
-                        error = XFS_ERROR(EFSCORRUPTED);
+                        error = -EFSCORRUPTED;
                         goto done;
                 }
                 error = xfs_da3_node_read(tp, dp, par_blkno, -1, &par_buf, w);
@@ -2305,7 +2305,7 @@ xfs_da3_swap_lastblock(
                 if (par_hdr.level != level) {
                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(7)",
                                          XFS_ERRLEVEL_LOW, mp);
-                        error = XFS_ERROR(EFSCORRUPTED);
+                        error = -EFSCORRUPTED;
                         goto done;
                 }
                 btree = dp->d_ops->node_tree_p(par_node);
@@ -2359,7 +2359,7 @@ xfs_da_shrink_inode(
                 error = xfs_bunmapi(tp, dp, dead_blkno, count,
                                     xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
                                     0, args->firstblock, args->flist, &done);
-                if (error == ENOSPC) {
+                if (error == -ENOSPC) {
                         if (w != XFS_DATA_FORK)
                                 break;
                         error = xfs_da3_swap_lastblock(args, &dead_blkno,
@@ -2427,7 +2427,7 @@ xfs_buf_map_from_irec(
                 map = kmem_zalloc(nirecs * sizeof(struct xfs_buf_map),
                                   KM_SLEEP | KM_NOFS);
                 if (!map)
-                        return ENOMEM;
+                        return -ENOMEM;
                 *mapp = map;
         }
 
@@ -2500,8 +2500,8 @@ xfs_dabuf_map(
         }
 
         if (!xfs_da_map_covers_blocks(nirecs, irecs, bno, nfsb)) {
-                error = mappedbno == -2 ? -1 : XFS_ERROR(EFSCORRUPTED);
-                if (unlikely(error == EFSCORRUPTED)) {
+                error = mappedbno == -2 ? -1 : -EFSCORRUPTED;
+                if (unlikely(error == -EFSCORRUPTED)) {
                         if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
                                 int i;
                                 xfs_alert(mp, "%s: bno %lld dir: inode %lld",
@@ -2561,7 +2561,7 @@ xfs_da_get_buf(
 
         bp = xfs_trans_get_buf_map(trans, dp->i_mount->m_ddev_targp,
                                     mapp, nmap, 0);
-        error = bp ? bp->b_error : XFS_ERROR(EIO);
+        error = bp ? bp->b_error : -EIO;
         if (error) {
                 xfs_trans_brelse(trans, bp);
                 goto out_free;
diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/libxfs/xfs_da_btree.h
index 6e153e399a77..6e153e399a77 100644
--- a/fs/xfs/xfs_da_btree.h
+++ b/fs/xfs/libxfs/xfs_da_btree.h
diff --git a/fs/xfs/xfs_da_format.c b/fs/xfs/libxfs/xfs_da_format.c
index c9aee52a37e2..c9aee52a37e2 100644
--- a/fs/xfs/xfs_da_format.c
+++ b/fs/xfs/libxfs/xfs_da_format.c
diff --git a/fs/xfs/xfs_da_format.h b/fs/xfs/libxfs/xfs_da_format.h
index 0a49b0286372..0a49b0286372 100644
--- a/fs/xfs/xfs_da_format.h
+++ b/fs/xfs/libxfs/xfs_da_format.h
diff --git a/fs/xfs/xfs_dinode.h b/fs/xfs/libxfs/xfs_dinode.h
index 623bbe8fd921..623bbe8fd921 100644
--- a/fs/xfs/xfs_dinode.h
+++ b/fs/xfs/libxfs/xfs_dinode.h
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index 79670cda48ae..6cef22152fd6 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -108,7 +108,7 @@ xfs_da_mount(
         if (!mp->m_dir_geo || !mp->m_attr_geo) {
                 kmem_free(mp->m_dir_geo);
                 kmem_free(mp->m_attr_geo);
-                return ENOMEM;
+                return -ENOMEM;
         }
 
         /* set up directory geometry */
@@ -202,7 +202,7 @@ xfs_dir_ino_validate(
                 xfs_warn(mp, "Invalid inode number 0x%Lx",
                                 (unsigned long long) ino);
                 XFS_ERROR_REPORT("xfs_dir_ino_validate", XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         return 0;
 }
@@ -226,7 +226,7 @@ xfs_dir_init(
 
         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
         if (!args)
-                return ENOMEM;
+                return -ENOMEM;
 
         args->geo = dp->i_mount->m_dir_geo;
         args->dp = dp;
@@ -261,7 +261,7 @@ xfs_dir_createname(
 
         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
         if (!args)
-                return ENOMEM;
+                return -ENOMEM;
 
         args->geo = dp->i_mount->m_dir_geo;
         args->name = name->name;
@@ -314,18 +314,18 @@ xfs_dir_cilookup_result(
         int             len)
 {
         if (args->cmpresult == XFS_CMP_DIFFERENT)
-                return ENOENT;
+                return -ENOENT;
         if (args->cmpresult != XFS_CMP_CASE ||
                                         !(args->op_flags & XFS_DA_OP_CILOOKUP))
-                return EEXIST;
+                return -EEXIST;
 
         args->value = kmem_alloc(len, KM_NOFS | KM_MAYFAIL);
         if (!args->value)
-                return ENOMEM;
+                return -ENOMEM;
 
         memcpy(args->value, name, len);
         args->valuelen = len;
-        return EEXIST;
+        return -EEXIST;
 }
 
 /*
@@ -392,7 +392,7 @@ xfs_dir_lookup(
                 rval = xfs_dir2_node_lookup(args);
 
 out_check_rval:
-        if (rval == EEXIST)
+        if (rval == -EEXIST)
                 rval = 0;
         if (!rval) {
                 *inum = args->inumber;
@@ -428,7 +428,7 @@ xfs_dir_removename(
 
         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
         if (!args)
-                return ENOMEM;
+                return -ENOMEM;
 
         args->geo = dp->i_mount->m_dir_geo;
         args->name = name->name;
@@ -493,7 +493,7 @@ xfs_dir_replace(
 
         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
         if (!args)
-                return ENOMEM;
+                return -ENOMEM;
 
         args->geo = dp->i_mount->m_dir_geo;
         args->name = name->name;
@@ -555,7 +555,7 @@ xfs_dir_canenter(
 
         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
         if (!args)
-                return ENOMEM;
+                return -ENOMEM;
 
         args->geo = dp->i_mount->m_dir_geo;
         args->name = name->name;
diff --git a/fs/xfs/xfs_dir2.h b/fs/xfs/libxfs/xfs_dir2.h
index c8e86b0b5e99..c8e86b0b5e99 100644
--- a/fs/xfs/xfs_dir2.h
+++ b/fs/xfs/libxfs/xfs_dir2.h
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/libxfs/xfs_dir2_block.c
index c7cd3154026a..9628ceccfa02 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/libxfs/xfs_dir2_block.c
@@ -91,9 +91,9 @@ xfs_dir3_block_read_verify(
 
         if (xfs_sb_version_hascrc(&mp->m_sb) &&
              !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_dir3_block_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -108,7 +108,7 @@ xfs_dir3_block_write_verify(
         struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
         if (!xfs_dir3_block_verify(bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
@@ -392,7 +392,7 @@ xfs_dir2_block_addname(
         if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
                 xfs_trans_brelse(tp, bp);
                 if (!dup)
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
                 return 0;
         }
 
@@ -402,7 +402,7 @@ xfs_dir2_block_addname(
         if (!dup) {
                 /* Don't have a space reservation: return no-space.  */
                 if (args->total == 0)
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
                 /*
                  * Convert to the next larger format.
                  * Then add the new entry in that format.
@@ -647,7 +647,7 @@ xfs_dir2_block_lookup(
         args->filetype = dp->d_ops->data_get_ftype(dep);
         error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
         xfs_trans_brelse(args->trans, bp);
-        return XFS_ERROR(error);
+        return error;
 }
 
 /*
@@ -703,7 +703,7 @@ xfs_dir2_block_lookup_int(
                 if (low > high) {
                         ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
                         xfs_trans_brelse(tp, bp);
-                        return XFS_ERROR(ENOENT);
+                        return -ENOENT;
                 }
         }
         /*
@@ -751,7 +751,7 @@ xfs_dir2_block_lookup_int(
          * No match, release the buffer and return ENOENT.
          */
         xfs_trans_brelse(tp, bp);
-        return XFS_ERROR(ENOENT);
+        return -ENOENT;
 }
 
 /*
@@ -1091,7 +1091,7 @@ xfs_dir2_sf_to_block(
          */
         if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         oldsfp = (xfs_dir2_sf_hdr_t *)ifp->if_u1.if_data;
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/libxfs/xfs_dir2_data.c
index 8c2f6422648e..fdd803fecb8e 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/libxfs/xfs_dir2_data.c
@@ -100,7 +100,7 @@ __xfs_dir3_data_check(
                 break;
         default:
                 XFS_ERROR_REPORT("Bad Magic", XFS_ERRLEVEL_LOW, mp);
-                return EFSCORRUPTED;
+                return -EFSCORRUPTED;
         }
 
         /*
@@ -256,7 +256,7 @@ xfs_dir3_data_reada_verify(
                 xfs_dir3_data_verify(bp);
                 return;
         default:
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 break;
         }
@@ -270,9 +270,9 @@ xfs_dir3_data_read_verify(
 
         if (xfs_sb_version_hascrc(&mp->m_sb) &&
              !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
-                 xfs_buf_ioerror(bp, EFSBADCRC);
+                 xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_dir3_data_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -287,7 +287,7 @@ xfs_dir3_data_write_verify(
         struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
         if (!xfs_dir3_data_verify(bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/libxfs/xfs_dir2_leaf.c
index fb0aad4440c1..a19174eb3cb2 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/libxfs/xfs_dir2_leaf.c
@@ -183,9 +183,9 @@ __read_verify(
 
         if (xfs_sb_version_hascrc(&mp->m_sb) &&
              !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_dir3_leaf_verify(bp, magic))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -201,7 +201,7 @@ __write_verify(
         struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
 
         if (!xfs_dir3_leaf_verify(bp, magic)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
@@ -731,7 +731,7 @@ xfs_dir2_leaf_addname(
                 if ((args->op_flags & XFS_DA_OP_JUSTCHECK) ||
                                                         args->total == 0) {
                         xfs_trans_brelse(tp, lbp);
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
                 }
                 /*
                  * Convert to node form.
@@ -755,7 +755,7 @@ xfs_dir2_leaf_addname(
          */
         if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
                 xfs_trans_brelse(tp, lbp);
-                return use_block == -1 ? XFS_ERROR(ENOSPC) : 0;
+                return use_block == -1 ? -ENOSPC : 0;
         }
         /*
          * If no allocations are allowed, return now before we've
@@ -763,7 +763,7 @@ xfs_dir2_leaf_addname(
          */
         if (args->total == 0 && use_block == -1) {
                 xfs_trans_brelse(tp, lbp);
-                return XFS_ERROR(ENOSPC);
+                return -ENOSPC;
         }
         /*
          * Need to compact the leaf entries, removing stale ones.
@@ -1198,7 +1198,7 @@ xfs_dir2_leaf_lookup(
         error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
         xfs_trans_brelse(tp, dbp);
         xfs_trans_brelse(tp, lbp);
-        return XFS_ERROR(error);
+        return error;
 }
 
 /*
@@ -1327,13 +1327,13 @@ xfs_dir2_leaf_lookup_int(
                 return 0;
         }
         /*
-         * No match found, return ENOENT.
+         * No match found, return -ENOENT.
          */
         ASSERT(cidb == -1);
         if (dbp)
                 xfs_trans_brelse(tp, dbp);
         xfs_trans_brelse(tp, lbp);
-        return XFS_ERROR(ENOENT);
+        return -ENOENT;
 }
 
 /*
@@ -1440,7 +1440,7 @@ xfs_dir2_leaf_removename(
                          * Just go on, returning success, leaving the
                          * empty block in place.
                          */
-                        if (error == ENOSPC && args->total == 0)
+                        if (error == -ENOSPC && args->total == 0)
                                 error = 0;
                         xfs_dir3_leaf_check(dp, lbp);
                         return error;
@@ -1641,7 +1641,7 @@ xfs_dir2_leaf_trim_data(
          * Get rid of the data block.
          */
         if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
-                ASSERT(error != ENOSPC);
+                ASSERT(error != -ENOSPC);
                 xfs_trans_brelse(tp, dbp);
                 return error;
         }
@@ -1815,7 +1815,7 @@ xfs_dir2_node_to_leaf(
                  * punching out the middle of an extent, and this is an
                  * isolated block.
                  */
-                ASSERT(error != ENOSPC);
+                ASSERT(error != -ENOSPC);
                 return error;
         }
         fbp = NULL;
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/libxfs/xfs_dir2_node.c
index da43d304fca2..2ae6ac2c11ae 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -117,9 +117,9 @@ xfs_dir3_free_read_verify(
 
         if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_dir3_free_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -134,7 +134,7 @@ xfs_dir3_free_write_verify(
         struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;
 
         if (!xfs_dir3_free_verify(bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
@@ -406,7 +406,7 @@ xfs_dir2_leafn_add(
          * into other peoples memory
          */
         if (index < 0)
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
 
         /*
          * If there are already the maximum number of leaf entries in
@@ -417,7 +417,7 @@ xfs_dir2_leafn_add(
 
         if (leafhdr.count == dp->d_ops->leaf_max_ents(args->geo)) {
                 if (!leafhdr.stale)
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
                 compact = leafhdr.stale > 1;
         } else
                 compact = 0;
@@ -629,7 +629,7 @@ xfs_dir2_leafn_lookup_for_addname(
                                                         XFS_ERRLEVEL_LOW, mp);
                                 if (curfdb != newfdb)
                                         xfs_trans_brelse(tp, curbp);
-                                return XFS_ERROR(EFSCORRUPTED);
+                                return -EFSCORRUPTED;
                         }
                         curfdb = newfdb;
                         if (be16_to_cpu(bests[fi]) >= length)
@@ -660,7 +660,7 @@ out:
          * Return the index, that will be the insertion point.
          */
         *indexp = index;
-        return XFS_ERROR(ENOENT);
+        return -ENOENT;
 }
 
 /*
@@ -789,7 +789,7 @@ xfs_dir2_leafn_lookup_for_entry(
                         curbp->b_ops = &xfs_dir3_data_buf_ops;
                         xfs_trans_buf_set_type(tp, curbp, XFS_BLFT_DIR_DATA_BUF);
                         if (cmp == XFS_CMP_EXACT)
-                                return XFS_ERROR(EEXIST);
+                                return -EEXIST;
                 }
         }
         ASSERT(index == leafhdr.count || (args->op_flags & XFS_DA_OP_OKNOENT));
@@ -812,7 +812,7 @@ xfs_dir2_leafn_lookup_for_entry(
                 state->extravalid = 0;
         }
         *indexp = index;
-        return XFS_ERROR(ENOENT);
+        return -ENOENT;
 }
 
 /*
@@ -1133,7 +1133,7 @@ xfs_dir3_data_block_free(
                 if (error == 0) {
                         fbp = NULL;
                         logfree = 0;
-                } else if (error != ENOSPC || args->total != 0)
+                } else if (error != -ENOSPC || args->total != 0)
                         return error;
                 /*
                  * It's possible to get ENOSPC if there is no
@@ -1287,7 +1287,7 @@ xfs_dir2_leafn_remove(
                          * In this case just drop the buffer and some one else
                          * will eventually get rid of the empty block.
                          */
-                        else if (!(error == ENOSPC && args->total == 0))
+                        else if (!(error == -ENOSPC && args->total == 0))
                                 return error;
                 }
                 /*
@@ -1599,7 +1599,7 @@ xfs_dir2_node_addname(
         error = xfs_da3_node_lookup_int(state, &rval);
         if (error)
                 rval = error;
-        if (rval != ENOENT) {
+        if (rval != -ENOENT) {
                 goto done;
         }
         /*
@@ -1628,7 +1628,7 @@ xfs_dir2_node_addname(
                  * It didn't work, we need to split the leaf block.
                  */
                 if (args->total == 0) {
-                        ASSERT(rval == ENOSPC);
+                        ASSERT(rval == -ENOSPC);
                         goto done;
                 }
                 /*
@@ -1815,7 +1815,7 @@ xfs_dir2_node_addname_int(
                  * Not allowed to allocate, return failure.
                  */
                 if ((args->op_flags & XFS_DA_OP_JUSTCHECK) || args->total == 0)
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
 
                 /*
                  * Allocate and initialize the new data block.
@@ -1876,7 +1876,7 @@ xfs_dir2_node_addname_int(
                                 }
                                 XFS_ERROR_REPORT("xfs_dir2_node_addname_int",
                                                  XFS_ERRLEVEL_LOW, mp);
-                                return XFS_ERROR(EFSCORRUPTED);
+                                return -EFSCORRUPTED;
                         }
 
                         /*
@@ -2042,8 +2042,8 @@ xfs_dir2_node_lookup(
         error = xfs_da3_node_lookup_int(state, &rval);
         if (error)
                 rval = error;
-        else if (rval == ENOENT && args->cmpresult == XFS_CMP_CASE) {
-                /* If a CI match, dup the actual name and return EEXIST */
+        else if (rval == -ENOENT && args->cmpresult == XFS_CMP_CASE) {
+                /* If a CI match, dup the actual name and return -EEXIST */
                 xfs_dir2_data_entry_t   *dep;
 
                 dep = (xfs_dir2_data_entry_t *)
@@ -2096,7 +2096,7 @@ xfs_dir2_node_removename(
                 goto out_free;
 
         /* Didn't find it, upper layer screwed up. */
-        if (rval != EEXIST) {
+        if (rval != -EEXIST) {
                 error = rval;
                 goto out_free;
         }
@@ -2169,7 +2169,7 @@ xfs_dir2_node_replace(
          * It should be found, since the vnodeops layer has looked it up
          * and locked it.  But paranoia is good.
          */
-        if (rval == EEXIST) {
+        if (rval == -EEXIST) {
                 struct xfs_dir2_leaf_entry *ents;
                 /*
                  * Find the leaf entry.
@@ -2272,7 +2272,7 @@ xfs_dir2_node_trim_free(
                  * space reservation, when breaking up an extent into two
                  * pieces.  This is the last block of an extent.
                  */
-                ASSERT(error != ENOSPC);
+                ASSERT(error != -ENOSPC);
                 xfs_trans_brelse(tp, bp);
                 return error;
         }
diff --git a/fs/xfs/xfs_dir2_priv.h b/fs/xfs/libxfs/xfs_dir2_priv.h
index 27ce0794d196..27ce0794d196 100644
--- a/fs/xfs/xfs_dir2_priv.h
+++ b/fs/xfs/libxfs/xfs_dir2_priv.h
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/libxfs/xfs_dir2_sf.c
index 53c3be619db5..5079e051ef08 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -51,10 +51,9 @@ static void xfs_dir2_sf_check(xfs_da_args_t *args);
 #else
 #define xfs_dir2_sf_check(args)
 #endif /* DEBUG */
-#if XFS_BIG_INUMS
+
 static void xfs_dir2_sf_toino4(xfs_da_args_t *args);
 static void xfs_dir2_sf_toino8(xfs_da_args_t *args);
-#endif /* XFS_BIG_INUMS */
 
 /*
  * Given a block directory (dp/block), calculate its size as a shortform (sf)
@@ -117,10 +116,10 @@ xfs_dir2_block_sfsize(
                 isdotdot =
                         dep->namelen == 2 &&
                         dep->name[0] == '.' && dep->name[1] == '.';
-#if XFS_BIG_INUMS
+
                 if (!isdot)
                         i8count += be64_to_cpu(dep->inumber) > XFS_DIR2_MAX_SHORT_INUM;
-#endif
+
                 /* take into account the file type field */
                 if (!isdot && !isdotdot) {
                         count++;
@@ -251,7 +250,7 @@ xfs_dir2_block_to_sf(
         logflags = XFS_ILOG_CORE;
         error = xfs_dir2_shrink_inode(args, args->geo->datablk, bp);
         if (error) {
-                ASSERT(error != ENOSPC);
+                ASSERT(error != -ENOSPC);
                 goto out;
         }
 
@@ -299,7 +298,7 @@ xfs_dir2_sf_addname(
 
         trace_xfs_dir2_sf_addname(args);
 
-        ASSERT(xfs_dir2_sf_lookup(args) == ENOENT);
+        ASSERT(xfs_dir2_sf_lookup(args) == -ENOENT);
         dp = args->dp;
         ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
         /*
@@ -307,7 +306,7 @@ xfs_dir2_sf_addname(
          */
         if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                 ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
         ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
@@ -318,7 +317,7 @@ xfs_dir2_sf_addname(
          */
         incr_isize = dp->d_ops->sf_entsize(sfp, args->namelen);
         objchange = 0;
-#if XFS_BIG_INUMS
+
         /*
          * Do we have to change to 8 byte inodes?
          */
@@ -332,7 +331,7 @@ xfs_dir2_sf_addname(
                          (uint)sizeof(xfs_dir2_ino4_t));
                 objchange = 1;
         }
-#endif
+
         new_isize = (int)dp->i_d.di_size + incr_isize;
         /*
          * Won't fit as shortform any more (due to size),
@@ -345,7 +344,7 @@ xfs_dir2_sf_addname(
                  * Just checking or no space reservation, it doesn't fit.
                  */
                 if ((args->op_flags & XFS_DA_OP_JUSTCHECK) || args->total == 0)
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
                 /*
                  * Convert to block form then add the name.
                  */
@@ -370,10 +369,8 @@ xfs_dir2_sf_addname(
          */
         else {
                 ASSERT(pick == 2);
-#if XFS_BIG_INUMS
                 if (objchange)
                         xfs_dir2_sf_toino8(args);
-#endif
                 xfs_dir2_sf_addname_hard(args, objchange, new_isize);
         }
         xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
@@ -425,10 +422,8 @@ xfs_dir2_sf_addname_easy(
          * Update the header and inode.
          */
         sfp->count++;
-#if XFS_BIG_INUMS
         if (args->inumber > XFS_DIR2_MAX_SHORT_INUM)
                 sfp->i8count++;
-#endif
         dp->i_d.di_size = new_isize;
         xfs_dir2_sf_check(args);
 }
@@ -516,10 +511,8 @@ xfs_dir2_sf_addname_hard(
         dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
         dp->d_ops->sf_put_ftype(sfep, args->filetype);
         sfp->count++;
-#if XFS_BIG_INUMS
         if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && !objchange)
                 sfp->i8count++;
-#endif
         /*
          * If there's more left to copy, do that.
          */
@@ -593,13 +586,8 @@ xfs_dir2_sf_addname_pick(
         /*
          * If changing the inode number size, do it the hard way.
          */
-#if XFS_BIG_INUMS
-        if (objchange) {
+        if (objchange)
                 return 2;
-        }
-#else
-        ASSERT(objchange == 0);
-#endif
         /*
          * If it won't fit at the end then do it the hard way (use the hole).
          */
@@ -650,7 +638,6 @@ xfs_dir2_sf_check(
                 ASSERT(dp->d_ops->sf_get_ftype(sfep) < XFS_DIR3_FT_MAX);
         }
         ASSERT(i8count == sfp->i8count);
-        ASSERT(XFS_BIG_INUMS || i8count == 0);
         ASSERT((char *)sfep - (char *)sfp == dp->i_d.di_size);
         ASSERT(offset +
                (sfp->count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t) +
@@ -738,7 +725,7 @@ xfs_dir2_sf_lookup(
          */
         if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                 ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
         ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
@@ -751,7 +738,7 @@ xfs_dir2_sf_lookup(
                 args->inumber = dp->i_ino;
                 args->cmpresult = XFS_CMP_EXACT;
                 args->filetype = XFS_DIR3_FT_DIR;
-                return XFS_ERROR(EEXIST);
+                return -EEXIST;
         }
         /*
          * Special case for ..
@@ -761,7 +748,7 @@ xfs_dir2_sf_lookup(
                 args->inumber = dp->d_ops->sf_get_parent_ino(sfp);
                 args->cmpresult = XFS_CMP_EXACT;
                 args->filetype = XFS_DIR3_FT_DIR;
-                return XFS_ERROR(EEXIST);
+                return -EEXIST;
         }
         /*
          * Loop over all the entries trying to match ours.
@@ -781,20 +768,20 @@ xfs_dir2_sf_lookup(
                         args->inumber = dp->d_ops->sf_get_ino(sfp, sfep);
                         args->filetype = dp->d_ops->sf_get_ftype(sfep);
                         if (cmp == XFS_CMP_EXACT)
-                                return XFS_ERROR(EEXIST);
+                                return -EEXIST;
                         ci_sfep = sfep;
                 }
         }
         ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
         /*
          * Here, we can only be doing a lookup (not a rename or replace).
-         * If a case-insensitive match was not found, return ENOENT.
+         * If a case-insensitive match was not found, return -ENOENT.
          */
         if (!ci_sfep)
-                return XFS_ERROR(ENOENT);
+                return -ENOENT;
         /* otherwise process the CI match as required by the caller */
         error = xfs_dir_cilookup_result(args, ci_sfep->name, ci_sfep->namelen);
-        return XFS_ERROR(error);
+        return error;
 }
 
 /*
@@ -824,7 +811,7 @@ xfs_dir2_sf_removename(
          */
         if (oldsize < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                 ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
         ASSERT(dp->i_df.if_bytes == oldsize);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
@@ -847,7 +834,7 @@ xfs_dir2_sf_removename(
          * Didn't find it.
          */
         if (i == sfp->count)
-                return XFS_ERROR(ENOENT);
+                return -ENOENT;
         /*
          * Calculate sizes.
          */
@@ -870,7 +857,6 @@ xfs_dir2_sf_removename(
          */
         xfs_idata_realloc(dp, newsize - oldsize, XFS_DATA_FORK);
         sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
-#if XFS_BIG_INUMS
         /*
          * Are we changing inode number size?
          */
@@ -880,7 +866,6 @@ xfs_dir2_sf_removename(
                 else
                         sfp->i8count--;
         }
-#endif
         xfs_dir2_sf_check(args);
         xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
         return 0;
@@ -895,12 +880,8 @@ xfs_dir2_sf_replace(
 {
         xfs_inode_t             *dp;            /* incore directory inode */
         int                     i;              /* entry index */
-#if XFS_BIG_INUMS || defined(DEBUG)
         xfs_ino_t               ino=0;          /* entry old inode number */
-#endif
-#if XFS_BIG_INUMS
         int                     i8elevated;     /* sf_toino8 set i8count=1 */
-#endif
         xfs_dir2_sf_entry_t     *sfep;          /* shortform directory entry */
         xfs_dir2_sf_hdr_t       *sfp;           /* shortform structure */
 
@@ -914,13 +895,13 @@ xfs_dir2_sf_replace(
          */
         if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                 ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
         ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
         sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
         ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
-#if XFS_BIG_INUMS
+
         /*
          * New inode number is large, and need to convert to 8-byte inodes.
          */
@@ -951,17 +932,15 @@ xfs_dir2_sf_replace(
                 sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
         } else
                 i8elevated = 0;
-#endif
+
         ASSERT(args->namelen != 1 || args->name[0] != '.');
         /*
          * Replace ..'s entry.
          */
         if (args->namelen == 2 &&
             args->name[0] == '.' && args->name[1] == '.') {
-#if XFS_BIG_INUMS || defined(DEBUG)
                 ino = dp->d_ops->sf_get_parent_ino(sfp);
                 ASSERT(args->inumber != ino);
-#endif
                 dp->d_ops->sf_put_parent_ino(sfp, args->inumber);
         }
         /*
@@ -972,10 +951,8 @@ xfs_dir2_sf_replace(
                      i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
                         if (xfs_da_compname(args, sfep->name, sfep->namelen) ==
                                                                 XFS_CMP_EXACT) {
-#if XFS_BIG_INUMS || defined(DEBUG)
                                 ino = dp->d_ops->sf_get_ino(sfp, sfep);
                                 ASSERT(args->inumber != ino);
-#endif
                                 dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
                                 dp->d_ops->sf_put_ftype(sfep, args->filetype);
                                 break;
@@ -986,14 +963,11 @@ xfs_dir2_sf_replace(
                  */
                 if (i == sfp->count) {
                         ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
-#if XFS_BIG_INUMS
                         if (i8elevated)
                                 xfs_dir2_sf_toino4(args);
-#endif
-                        return XFS_ERROR(ENOENT);
+                        return -ENOENT;
                 }
         }
-#if XFS_BIG_INUMS
         /*
          * See if the old number was large, the new number is small.
          */
@@ -1020,13 +994,11 @@ xfs_dir2_sf_replace(
                 if (!i8elevated)
                         sfp->i8count++;
         }
-#endif
         xfs_dir2_sf_check(args);
         xfs_trans_log_inode(args->trans, dp, XFS_ILOG_DDATA);
         return 0;
 }
 
-#if XFS_BIG_INUMS
 /*
  * Convert from 8-byte inode numbers to 4-byte inode numbers.
  * The last 8-byte inode number is gone, but the count is still 1.
@@ -1181,4 +1153,3 @@ xfs_dir2_sf_toino8(
         dp->i_d.di_size = newsize;
         xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
 }
-#endif  /* XFS_BIG_INUMS */
diff --git a/fs/xfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index c2ac0c611ad8..bb969337efc8 100644
--- a/fs/xfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -257,9 +257,9 @@ xfs_dquot_buf_read_verify(
         struct xfs_mount        *mp = bp->b_target->bt_mount;
 
         if (!xfs_dquot_buf_verify_crc(mp, bp))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_dquot_buf_verify(mp, bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -277,7 +277,7 @@ xfs_dquot_buf_write_verify(
         struct xfs_mount        *mp = bp->b_target->bt_mount;
 
         if (!xfs_dquot_buf_verify(mp, bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
diff --git a/fs/xfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index 34d85aca3058..7e42bba9a420 100644
--- a/fs/xfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -68,11 +68,7 @@ struct xfs_ifork;
 #define XFS_RTLOBIT(w)  xfs_lowbit32(w)
 #define XFS_RTHIBIT(w)  xfs_highbit32(w)
 
-#if XFS_BIG_BLKNOS
 #define XFS_RTBLOCKLOG(b)       xfs_highbit64(b)
-#else
-#define XFS_RTBLOCKLOG(b)       xfs_highbit32(b)
-#endif
 
 /*
  * Dquot and dquot block format definitions
@@ -304,23 +300,15 @@ typedef struct xfs_bmbt_rec_host {
  * Values and macros for delayed-allocation startblock fields.
  */
 #define STARTBLOCKVALBITS       17
-#define STARTBLOCKMASKBITS      (15 + XFS_BIG_BLKNOS * 20)
-#define DSTARTBLOCKMASKBITS     (15 + 20)
+#define STARTBLOCKMASKBITS      (15 + 20)
 #define STARTBLOCKMASK          \
         (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
-#define DSTARTBLOCKMASK         \
-        (((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 
 static inline int isnullstartblock(xfs_fsblock_t x)
 {
         return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
 }
 
-static inline int isnulldstartblock(xfs_dfsbno_t x)
-{
-        return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
-}
-
 static inline xfs_fsblock_t nullstartblock(int k)
 {
         ASSERT(k < (1 << STARTBLOCKVALBITS));
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 5960e5593fe0..b62771f1f4b5 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -292,7 +292,7 @@ xfs_ialloc_inode_init(
                                          mp->m_bsize * blks_per_cluster,
                                          XBF_UNMAPPED);
                 if (!fbuf)
-                        return ENOMEM;
+                        return -ENOMEM;
 
                 /* Initialize the inode buffers and log them appropriately. */
                 fbuf->b_ops = &xfs_inode_buf_ops;
@@ -380,7 +380,7 @@ xfs_ialloc_ag_alloc(
         newlen = args.mp->m_ialloc_inos;
         if (args.mp->m_maxicount &&
             args.mp->m_sb.sb_icount + newlen > args.mp->m_maxicount)
-                return XFS_ERROR(ENOSPC);
+                return -ENOSPC;
         args.minlen = args.maxlen = args.mp->m_ialloc_blks;
         /*
          * First try to allocate inodes contiguous with the last-allocated
@@ -1385,7 +1385,7 @@ xfs_dialloc(
                 if (error) {
                         xfs_trans_brelse(tp, agbp);
 
-                        if (error != ENOSPC)
+                        if (error != -ENOSPC)
                                 goto out_error;
 
                         xfs_perag_put(pag);
@@ -1416,7 +1416,7 @@ nextag:
                         agno = 0;
                 if (agno == start_agno) {
                         *inop = NULLFSINO;
-                        return noroom ? ENOSPC : 0;
+                        return noroom ? -ENOSPC : 0;
                 }
         }
 
@@ -1425,7 +1425,7 @@ out_alloc:
         return xfs_dialloc_ag(tp, agbp, parent, inop);
 out_error:
         xfs_perag_put(pag);
-        return XFS_ERROR(error);
+        return error;
 }
 
 STATIC int
@@ -1682,7 +1682,7 @@ xfs_difree(
                 xfs_warn(mp, "%s: agno >= mp->m_sb.sb_agcount (%d >= %d).",
                         __func__, agno, mp->m_sb.sb_agcount);
                 ASSERT(0);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
         agino = XFS_INO_TO_AGINO(mp, inode);
         if (inode != XFS_AGINO_TO_INO(mp, agno, agino))  {
@@ -1690,14 +1690,14 @@ xfs_difree(
                         __func__, (unsigned long long)inode,
                         (unsigned long long)XFS_AGINO_TO_INO(mp, agno, agino));
                 ASSERT(0);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
         agbno = XFS_AGINO_TO_AGBNO(mp, agino);
         if (agbno >= mp->m_sb.sb_agblocks)  {
                 xfs_warn(mp, "%s: agbno >= mp->m_sb.sb_agblocks (%d >= %d).",
                         __func__, agbno, mp->m_sb.sb_agblocks);
                 ASSERT(0);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
         /*
          * Get the allocation group header.
@@ -1769,7 +1769,7 @@ xfs_imap_lookup(
                 if (i)
                         error = xfs_inobt_get_rec(cur, &rec, &i);
                 if (!error && i == 0)
-                        error = EINVAL;
+                        error = -EINVAL;
         }
 
         xfs_trans_brelse(tp, agbp);
@@ -1780,12 +1780,12 @@ xfs_imap_lookup(
         /* check that the returned record contains the required inode */
         if (rec.ir_startino > agino ||
             rec.ir_startino + mp->m_ialloc_inos <= agino)
-                return EINVAL;
+                return -EINVAL;
 
         /* for untrusted inodes check it is allocated first */
         if ((flags & XFS_IGET_UNTRUSTED) &&
             (rec.ir_free & XFS_INOBT_MASK(agino - rec.ir_startino)))
-                return EINVAL;
+                return -EINVAL;
 
         *chunk_agbno = XFS_AGINO_TO_AGBNO(mp, rec.ir_startino);
         *offset_agbno = agbno - *chunk_agbno;
@@ -1829,7 +1829,7 @@ xfs_imap(
                  * as they can be invalid without implying corruption.
                  */
                 if (flags & XFS_IGET_UNTRUSTED)
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 if (agno >= mp->m_sb.sb_agcount) {
                         xfs_alert(mp,
                                 "%s: agno (%d) >= mp->m_sb.sb_agcount (%d)",
@@ -1849,7 +1849,7 @@ xfs_imap(
                 }
                 xfs_stack_trace();
 #endif /* DEBUG */
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         blks_per_cluster = xfs_icluster_size_fsb(mp);
@@ -1922,7 +1922,7 @@ out_map:
                         __func__, (unsigned long long) imap->im_blkno,
                         (unsigned long long) imap->im_len,
                         XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
         return 0;
 }
@@ -2072,11 +2072,11 @@ xfs_agi_read_verify(
 
         if (xfs_sb_version_hascrc(&mp->m_sb) &&
             !xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (XFS_TEST_ERROR(!xfs_agi_verify(bp), mp,
                                 XFS_ERRTAG_IALLOC_READ_AGI,
                                 XFS_RANDOM_IALLOC_READ_AGI))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -2090,7 +2090,7 @@ xfs_agi_write_verify(
         struct xfs_buf_log_item *bip = bp->b_fspriv;
 
         if (!xfs_agi_verify(bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
diff --git a/fs/xfs/xfs_ialloc.h b/fs/xfs/libxfs/xfs_ialloc.h
index 95ad1c002d60..95ad1c002d60 100644
--- a/fs/xfs/xfs_ialloc.h
+++ b/fs/xfs/libxfs/xfs_ialloc.h
diff --git a/fs/xfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index 726f83a681a5..c9b06f30fe86 100644
--- a/fs/xfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -272,9 +272,9 @@ xfs_inobt_read_verify(
         struct xfs_buf  *bp)
 {
         if (!xfs_btree_sblock_verify_crc(bp))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_inobt_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error) {
                 trace_xfs_btree_corrupt(bp, _RET_IP_);
@@ -288,7 +288,7 @@ xfs_inobt_write_verify(
 {
         if (!xfs_inobt_verify(bp)) {
                 trace_xfs_btree_corrupt(bp, _RET_IP_);
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
diff --git a/fs/xfs/xfs_ialloc_btree.h b/fs/xfs/libxfs/xfs_ialloc_btree.h
index d7ebea72c2d0..d7ebea72c2d0 100644
--- a/fs/xfs/xfs_ialloc_btree.h
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.h
diff --git a/fs/xfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index cb35ae41d4a1..f18fd2da49f7 100644
--- a/fs/xfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -101,7 +101,7 @@ xfs_inode_buf_verify(
                                 return;
                         }
 
-                        xfs_buf_ioerror(bp, EFSCORRUPTED);
+                        xfs_buf_ioerror(bp, -EFSCORRUPTED);
                         xfs_verifier_error(bp);
 #ifdef DEBUG
                         xfs_alert(mp,
@@ -174,14 +174,14 @@ xfs_imap_to_bp(
                                    (int)imap->im_len, buf_flags, &bp,
                                    &xfs_inode_buf_ops);
         if (error) {
-                if (error == EAGAIN) {
+                if (error == -EAGAIN) {
                         ASSERT(buf_flags & XBF_TRYLOCK);
                         return error;
                 }
 
-                if (error == EFSCORRUPTED &&
+                if (error == -EFSCORRUPTED &&
                     (iget_flags & XFS_IGET_UNTRUSTED))
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
 
                 xfs_warn(mp, "%s: xfs_trans_read_buf() returned error %d.",
                         __func__, error);
@@ -390,7 +390,7 @@ xfs_iread(
                                 __func__, ip->i_ino);
 
                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, dip);
-                error = XFS_ERROR(EFSCORRUPTED);
+                error = -EFSCORRUPTED;
                 goto out_brelse;
         }
 
diff --git a/fs/xfs/xfs_inode_buf.h b/fs/xfs/libxfs/xfs_inode_buf.h
index 9308c47f2a52..9308c47f2a52 100644
--- a/fs/xfs/xfs_inode_buf.h
+++ b/fs/xfs/libxfs/xfs_inode_buf.h
diff --git a/fs/xfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c
index b031e8d0d928..6a00f7fed69d 100644
--- a/fs/xfs/xfs_inode_fork.c
+++ b/fs/xfs/libxfs/xfs_inode_fork.c
@@ -102,7 +102,7 @@ xfs_iformat_fork(
                                 be64_to_cpu(dip->di_nblocks));
                 XFS_CORRUPTION_ERROR("xfs_iformat(1)", XFS_ERRLEVEL_LOW,
                                      ip->i_mount, dip);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         if (unlikely(dip->di_forkoff > ip->i_mount->m_sb.sb_inodesize)) {
@@ -111,7 +111,7 @@ xfs_iformat_fork(
                         dip->di_forkoff);
                 XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW,
                                      ip->i_mount, dip);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         if (unlikely((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) &&
@@ -121,7 +121,7 @@ xfs_iformat_fork(
                         ip->i_ino);
                 XFS_CORRUPTION_ERROR("xfs_iformat(realtime)",
                                      XFS_ERRLEVEL_LOW, ip->i_mount, dip);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         switch (ip->i_d.di_mode & S_IFMT) {
@@ -132,7 +132,7 @@ xfs_iformat_fork(
                 if (unlikely(dip->di_format != XFS_DINODE_FMT_DEV)) {
                         XFS_CORRUPTION_ERROR("xfs_iformat(3)", XFS_ERRLEVEL_LOW,
                                               ip->i_mount, dip);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
                 ip->i_d.di_size = 0;
                 ip->i_df.if_u2.if_rdev = xfs_dinode_get_rdev(dip);
@@ -153,7 +153,7 @@ xfs_iformat_fork(
                                 XFS_CORRUPTION_ERROR("xfs_iformat(4)",
                                                      XFS_ERRLEVEL_LOW,
                                                      ip->i_mount, dip);
-                                return XFS_ERROR(EFSCORRUPTED);
+                                return -EFSCORRUPTED;
                         }
 
                         di_size = be64_to_cpu(dip->di_size);
@@ -166,7 +166,7 @@ xfs_iformat_fork(
                                 XFS_CORRUPTION_ERROR("xfs_iformat(5)",
                                                      XFS_ERRLEVEL_LOW,
                                                      ip->i_mount, dip);
-                                return XFS_ERROR(EFSCORRUPTED);
+                                return -EFSCORRUPTED;
                         }
 
                         size = (int)di_size;
@@ -181,13 +181,13 @@ xfs_iformat_fork(
                 default:
                         XFS_ERROR_REPORT("xfs_iformat(6)", XFS_ERRLEVEL_LOW,
                                          ip->i_mount);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
                 break;
 
         default:
                 XFS_ERROR_REPORT("xfs_iformat(7)", XFS_ERRLEVEL_LOW, ip->i_mount);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         if (error) {
                 return error;
@@ -211,7 +211,7 @@ xfs_iformat_fork(
                         XFS_CORRUPTION_ERROR("xfs_iformat(8)",
                                              XFS_ERRLEVEL_LOW,
                                              ip->i_mount, dip);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
 
                 error = xfs_iformat_local(ip, dip, XFS_ATTR_FORK, size);
@@ -223,7 +223,7 @@ xfs_iformat_fork(
                 error = xfs_iformat_btree(ip, dip, XFS_ATTR_FORK);
                 break;
         default:
-                error = XFS_ERROR(EFSCORRUPTED);
+                error = -EFSCORRUPTED;
                 break;
         }
         if (error) {
@@ -266,7 +266,7 @@ xfs_iformat_local(
                         XFS_DFORK_SIZE(dip, ip->i_mount, whichfork));
                 XFS_CORRUPTION_ERROR("xfs_iformat_local", XFS_ERRLEVEL_LOW,
                                      ip->i_mount, dip);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         ifp = XFS_IFORK_PTR(ip, whichfork);
         real_size = 0;
@@ -322,7 +322,7 @@ xfs_iformat_extents(
                         (unsigned long long) ip->i_ino, nex);
                 XFS_CORRUPTION_ERROR("xfs_iformat_extents(1)", XFS_ERRLEVEL_LOW,
                                      ip->i_mount, dip);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         ifp->if_real_bytes = 0;
@@ -350,7 +350,7 @@ xfs_iformat_extents(
                                         XFS_ERROR_REPORT("xfs_iformat_extents(2)",
                                                          XFS_ERRLEVEL_LOW,
                                                          ip->i_mount);
-                                        return XFS_ERROR(EFSCORRUPTED);
+                                        return -EFSCORRUPTED;
                                 }
         }
         ifp->if_flags |= XFS_IFEXTENTS;
@@ -399,7 +399,7 @@ xfs_iformat_btree(
                                         (unsigned long long) ip->i_ino);
                 XFS_CORRUPTION_ERROR("xfs_iformat_btree", XFS_ERRLEVEL_LOW,
                                          mp, dip);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         ifp->if_broot_bytes = size;
@@ -436,7 +436,7 @@ xfs_iread_extents(
         if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
                 XFS_ERROR_REPORT("xfs_iread_extents", XFS_ERRLEVEL_LOW,
                                  ip->i_mount);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         nextents = XFS_IFORK_NEXTENTS(ip, whichfork);
         ifp = XFS_IFORK_PTR(ip, whichfork);
@@ -528,7 +528,7 @@ xfs_iroot_realloc(
                 ifp->if_broot_bytes = (int)new_size;
                 ASSERT(XFS_BMAP_BMDR_SPACE(ifp->if_broot) <=
                         XFS_IFORK_SIZE(ip, whichfork));
-                memmove(np, op, cur_max * (uint)sizeof(xfs_dfsbno_t));
+                memmove(np, op, cur_max * (uint)sizeof(xfs_fsblock_t));
                 return;
         }
 
@@ -575,7 +575,7 @@ xfs_iroot_realloc(
                                                      ifp->if_broot_bytes);
                 np = (char *)XFS_BMAP_BROOT_PTR_ADDR(mp, new_broot, 1,
                                                      (int)new_size);
-                memcpy(np, op, new_max * (uint)sizeof(xfs_dfsbno_t));
+                memcpy(np, op, new_max * (uint)sizeof(xfs_fsblock_t));
         }
         kmem_free(ifp->if_broot);
         ifp->if_broot = new_broot;
@@ -1692,7 +1692,7 @@ xfs_iext_idx_to_irec(
         }
         *idxp = page_idx;
         *erp_idxp = erp_idx;
-        return(erp);
+        return erp;
 }
 
 /*
diff --git a/fs/xfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index 7d3b1ed6dcbe..7d3b1ed6dcbe 100644
--- a/fs/xfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
diff --git a/fs/xfs/xfs_inum.h b/fs/xfs/libxfs/xfs_inum.h
index 90efdaf1706f..4ff2278e147a 100644
--- a/fs/xfs/xfs_inum.h
+++ b/fs/xfs/libxfs/xfs_inum.h
@@ -54,11 +54,7 @@ struct xfs_mount;
 #define XFS_OFFBNO_TO_AGINO(mp,b,o)     \
         ((xfs_agino_t)(((b) << XFS_INO_OFFSET_BITS(mp)) | (o)))
 
-#if XFS_BIG_INUMS
 #define XFS_MAXINUMBER          ((xfs_ino_t)((1ULL << 56) - 1ULL))
-#else
-#define XFS_MAXINUMBER          ((xfs_ino_t)((1ULL << 32) - 1ULL))
-#endif
 #define XFS_MAXINUMBER_32       ((xfs_ino_t)((1ULL << 32) - 1ULL))
 
 #endif  /* __XFS_INUM_H__ */
diff --git a/fs/xfs/xfs_log_format.h b/fs/xfs/libxfs/xfs_log_format.h
index f0969c77bdbe..aff12f2d4428 100644
--- a/fs/xfs/xfs_log_format.h
+++ b/fs/xfs/libxfs/xfs_log_format.h
@@ -380,7 +380,7 @@ typedef struct xfs_icdinode {
         xfs_ictimestamp_t di_mtime;     /* time last modified */
         xfs_ictimestamp_t di_ctime;     /* time created/inode modified */
         xfs_fsize_t     di_size;        /* number of bytes in file */
-        xfs_drfsbno_t   di_nblocks;     /* # of direct & btree blocks used */
+        xfs_rfsblock_t  di_nblocks;     /* # of direct & btree blocks used */
         xfs_extlen_t    di_extsize;     /* basic/minimum extent size for file */
         xfs_extnum_t    di_nextents;    /* number of extents in data fork */
         xfs_aextnum_t   di_anextents;   /* number of extents in attribute fork*/
@@ -516,7 +516,7 @@ xfs_blft_from_flags(struct xfs_buf_log_format *blf)
  * EFI/EFD log format definitions
  */
 typedef struct xfs_extent {
-        xfs_dfsbno_t    ext_start;
+        xfs_fsblock_t   ext_start;
         xfs_extlen_t    ext_len;
 } xfs_extent_t;
 
diff --git a/fs/xfs/xfs_log_recover.h b/fs/xfs/libxfs/xfs_log_recover.h
index 1c55ccbb379d..1c55ccbb379d 100644
--- a/fs/xfs/xfs_log_recover.h
+++ b/fs/xfs/libxfs/xfs_log_recover.h
diff --git a/fs/xfs/xfs_log_rlimit.c b/fs/xfs/libxfs/xfs_log_rlimit.c
index ee7e0e80246b..ee7e0e80246b 100644
--- a/fs/xfs/xfs_log_rlimit.c
+++ b/fs/xfs/libxfs/xfs_log_rlimit.c
diff --git a/fs/xfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index 137e20937077..1b0a08379759 100644
--- a/fs/xfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -98,8 +98,6 @@ typedef __uint16_t	xfs_qwarncnt_t;
 #define XFS_IS_QUOTA_ON(mp)     ((mp)->m_qflags & (XFS_UQUOTA_ACTIVE | \
                                                    XFS_GQUOTA_ACTIVE | \
                                                    XFS_PQUOTA_ACTIVE))
-#define XFS_IS_OQUOTA_ON(mp)    ((mp)->m_qflags & (XFS_GQUOTA_ACTIVE | \
-                                                   XFS_PQUOTA_ACTIVE))
 #define XFS_IS_UQUOTA_ON(mp)    ((mp)->m_qflags & XFS_UQUOTA_ACTIVE)
 #define XFS_IS_GQUOTA_ON(mp)    ((mp)->m_qflags & XFS_GQUOTA_ACTIVE)
 #define XFS_IS_PQUOTA_ON(mp)    ((mp)->m_qflags & XFS_PQUOTA_ACTIVE)
diff --git a/fs/xfs/xfs_rtbitmap.c b/fs/xfs/libxfs/xfs_rtbitmap.c
index f4dd697cac08..f4dd697cac08 100644
--- a/fs/xfs/xfs_rtbitmap.c
+++ b/fs/xfs/libxfs/xfs_rtbitmap.c
diff --git a/fs/xfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index 7703fa6770ff..ad525a5623a4 100644
--- a/fs/xfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -186,13 +186,13 @@ xfs_mount_validate_sb(
          */
         if (sbp->sb_magicnum != XFS_SB_MAGIC) {
                 xfs_warn(mp, "bad magic number");
-                return XFS_ERROR(EWRONGFS);
+                return -EWRONGFS;
         }
 
 
         if (!xfs_sb_good_version(sbp)) {
                 xfs_warn(mp, "bad version");
-                return XFS_ERROR(EWRONGFS);
+                return -EWRONGFS;
         }
 
         /*
@@ -220,7 +220,7 @@ xfs_mount_validate_sb(
                                 xfs_warn(mp,
 "Attempted to mount read-only compatible filesystem read-write.\n"
 "Filesystem can only be safely mounted read only.");
-                                return XFS_ERROR(EINVAL);
+                                return -EINVAL;
                         }
                 }
                 if (xfs_sb_has_incompat_feature(sbp,
@@ -230,7 +230,7 @@ xfs_mount_validate_sb(
 "Filesystem can not be safely mounted by this kernel.",
                                 (sbp->sb_features_incompat &
                                                 XFS_SB_FEAT_INCOMPAT_UNKNOWN));
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
         }
 
@@ -238,13 +238,13 @@ xfs_mount_validate_sb(
                 if (sbp->sb_qflags & (XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD)) {
                         xfs_notice(mp,
                            "Version 5 of Super block has XFS_OQUOTA bits.");
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
         } else if (sbp->sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD |
                                 XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD)) {
                         xfs_notice(mp,
 "Superblock earlier than Version 5 has XFS_[PQ]UOTA_{ENFD|CHKD} bits.");
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
         }
 
         if (unlikely(
@@ -252,7 +252,7 @@ xfs_mount_validate_sb(
                 xfs_warn(mp,
                 "filesystem is marked as having an external log; "
                 "specify logdev on the mount command line.");
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         if (unlikely(
@@ -260,7 +260,7 @@ xfs_mount_validate_sb(
                 xfs_warn(mp,
                 "filesystem is marked as having an internal log; "
                 "do not specify logdev on the mount command line.");
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         /*
@@ -294,7 +294,7 @@ xfs_mount_validate_sb(
             sbp->sb_dblocks < XFS_MIN_DBLOCKS(sbp)                      ||
             sbp->sb_shared_vn != 0)) {
                 xfs_notice(mp, "SB sanity check failed");
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         /*
@@ -305,7 +305,7 @@ xfs_mount_validate_sb(
                 "File system with blocksize %d bytes. "
                 "Only pagesize (%ld) or less will currently work.",
                                 sbp->sb_blocksize, PAGE_SIZE);
-                return XFS_ERROR(ENOSYS);
+                return -ENOSYS;
         }
 
         /*
@@ -320,19 +320,19 @@ xfs_mount_validate_sb(
         default:
                 xfs_warn(mp, "inode size of %d bytes not supported",
                                 sbp->sb_inodesize);
-                return XFS_ERROR(ENOSYS);
+                return -ENOSYS;
         }
 
         if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) ||
             xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) {
                 xfs_warn(mp,
                 "file system too large to be mounted on this system.");
-                return XFS_ERROR(EFBIG);
+                return -EFBIG;
         }
 
         if (check_inprogress && sbp->sb_inprogress) {
                 xfs_warn(mp, "Offline file system operation in progress!");
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         return 0;
 }
@@ -386,10 +386,11 @@ xfs_sb_quota_from_disk(struct xfs_sb *sbp)
         }
 }
 
-void
-xfs_sb_from_disk(
+static void
+__xfs_sb_from_disk(
         struct xfs_sb   *to,
-        xfs_dsb_t       *from)
+        xfs_dsb_t       *from,
+        bool            convert_xquota)
 {
         to->sb_magicnum = be32_to_cpu(from->sb_magicnum);
         to->sb_blocksize = be32_to_cpu(from->sb_blocksize);
@@ -445,6 +446,17 @@ xfs_sb_from_disk(
         to->sb_pad = 0;
         to->sb_pquotino = be64_to_cpu(from->sb_pquotino);
         to->sb_lsn = be64_to_cpu(from->sb_lsn);
+        /* Convert on-disk flags to in-memory flags? */
+        if (convert_xquota)
+                xfs_sb_quota_from_disk(to);
+}
+
+void
+xfs_sb_from_disk(
+        struct xfs_sb   *to,
+        xfs_dsb_t       *from)
+{
+        __xfs_sb_from_disk(to, from, true);
 }
 
 static inline void
@@ -577,7 +589,11 @@ xfs_sb_verify(
         struct xfs_mount *mp = bp->b_target->bt_mount;
         struct xfs_sb   sb;
 
-        xfs_sb_from_disk(&sb, XFS_BUF_TO_SBP(bp));
+        /*
+         * Use call variant which doesn't convert quota flags from disk 
+         * format, because xfs_mount_validate_sb checks the on-disk flags.
+         */
+        __xfs_sb_from_disk(&sb, XFS_BUF_TO_SBP(bp), false);
 
         /*
          * Only check the in progress field for the primary superblock as
@@ -620,7 +636,7 @@ xfs_sb_read_verify(
                         /* Only fail bad secondaries on a known V5 filesystem */
                         if (bp->b_bn == XFS_SB_DADDR ||
                             xfs_sb_version_hascrc(&mp->m_sb)) {
-                                error = EFSBADCRC;
+                                error = -EFSBADCRC;
                                 goto out_error;
                         }
                 }
@@ -630,7 +646,7 @@ xfs_sb_read_verify(
 out_error:
         if (error) {
                 xfs_buf_ioerror(bp, error);
-                if (error == EFSCORRUPTED || error == EFSBADCRC)
+                if (error == -EFSCORRUPTED || error == -EFSBADCRC)
                         xfs_verifier_error(bp);
         }
 }
@@ -653,7 +669,7 @@ xfs_sb_quiet_read_verify(
                 return;
         }
         /* quietly fail */
-        xfs_buf_ioerror(bp, EWRONGFS);
+        xfs_buf_ioerror(bp, -EWRONGFS);
 }
 
 static void
diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/libxfs/xfs_sb.h
index c43c2d609a24..2e739708afd3 100644
--- a/fs/xfs/xfs_sb.h
+++ b/fs/xfs/libxfs/xfs_sb.h
@@ -87,11 +87,11 @@ struct xfs_trans;
 typedef struct xfs_sb {
         __uint32_t      sb_magicnum;    /* magic number == XFS_SB_MAGIC */
         __uint32_t      sb_blocksize;   /* logical block size, bytes */
-        xfs_drfsbno_t   sb_dblocks;     /* number of data blocks */
-        xfs_drfsbno_t   sb_rblocks;     /* number of realtime blocks */
-        xfs_drtbno_t    sb_rextents;    /* number of realtime extents */
+        xfs_rfsblock_t  sb_dblocks;     /* number of data blocks */
+        xfs_rfsblock_t  sb_rblocks;     /* number of realtime blocks */
+        xfs_rtblock_t   sb_rextents;    /* number of realtime extents */
         uuid_t          sb_uuid;        /* file system unique id */
-        xfs_dfsbno_t    sb_logstart;    /* starting block of log if internal */
+        xfs_fsblock_t   sb_logstart;    /* starting block of log if internal */
         xfs_ino_t       sb_rootino;     /* root inode number */
         xfs_ino_t       sb_rbmino;      /* bitmap inode for realtime extents */
         xfs_ino_t       sb_rsumino;     /* summary inode for rt bitmap */
diff --git a/fs/xfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
index 82404da2ca67..82404da2ca67 100644
--- a/fs/xfs/xfs_shared.h
+++ b/fs/xfs/libxfs/xfs_shared.h
diff --git a/fs/xfs/xfs_symlink_remote.c b/fs/xfs/libxfs/xfs_symlink_remote.c
index 23c2f2577c8d..5782f037eab4 100644
--- a/fs/xfs/xfs_symlink_remote.c
+++ b/fs/xfs/libxfs/xfs_symlink_remote.c
@@ -133,9 +133,9 @@ xfs_symlink_read_verify(
                 return;
 
         if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF))
-                xfs_buf_ioerror(bp, EFSBADCRC);
+                xfs_buf_ioerror(bp, -EFSBADCRC);
         else if (!xfs_symlink_verify(bp))
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
 
         if (bp->b_error)
                 xfs_verifier_error(bp);
@@ -153,7 +153,7 @@ xfs_symlink_write_verify(
                 return;
 
         if (!xfs_symlink_verify(bp)) {
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
                 xfs_verifier_error(bp);
                 return;
         }
diff --git a/fs/xfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
index f2bda7c76b8a..f2bda7c76b8a 100644
--- a/fs/xfs/xfs_trans_resv.c
+++ b/fs/xfs/libxfs/xfs_trans_resv.c
diff --git a/fs/xfs/xfs_trans_resv.h b/fs/xfs/libxfs/xfs_trans_resv.h
index 1097d14cd583..1097d14cd583 100644
--- a/fs/xfs/xfs_trans_resv.h
+++ b/fs/xfs/libxfs/xfs_trans_resv.h
diff --git a/fs/xfs/xfs_trans_space.h b/fs/xfs/libxfs/xfs_trans_space.h
index bf9c4579334d..bf9c4579334d 100644
--- a/fs/xfs/xfs_trans_space.h
+++ b/fs/xfs/libxfs/xfs_trans_space.h
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 6888ad886ff6..a65fa5dde6e9 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -152,7 +152,7 @@ xfs_get_acl(struct inode *inode, int type)
         if (!xfs_acl)
                 return ERR_PTR(-ENOMEM);
 
-        error = -xfs_attr_get(ip, ea_name, (unsigned char *)xfs_acl,
+        error = xfs_attr_get(ip, ea_name, (unsigned char *)xfs_acl,
                                                         &len, ATTR_ROOT);
         if (error) {
                 /*
@@ -210,7 +210,7 @@ __xfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
                 len -= sizeof(struct xfs_acl_entry) *
                          (XFS_ACL_MAX_ENTRIES(ip->i_mount) - acl->a_count);
 
-                error = -xfs_attr_set(ip, ea_name, (unsigned char *)xfs_acl,
+                error = xfs_attr_set(ip, ea_name, (unsigned char *)xfs_acl,
                                 len, ATTR_ROOT);
 
                 kmem_free(xfs_acl);
@@ -218,7 +218,7 @@ __xfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
                 /*
                  * A NULL ACL argument means we want to remove the ACL.
                  */
-                error = -xfs_attr_remove(ip, ea_name, ATTR_ROOT);
+                error = xfs_attr_remove(ip, ea_name, ATTR_ROOT);
 
                 /*
                  * If the attribute didn't exist to start with that's fine.
@@ -244,7 +244,7 @@ xfs_set_mode(struct inode *inode, umode_t mode)
                 iattr.ia_mode = mode;
                 iattr.ia_ctime = current_fs_time(inode->i_sb);
 
-                error = -xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL);
+                error = xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL);
         }
 
         return error;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index faaf716e2080..11e9b4caa54f 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -240,7 +240,7 @@ xfs_end_io(
 
 done:
         if (error)
-                ioend->io_error = -error;
+                ioend->io_error = error;
         xfs_destroy_ioend(ioend);
 }
 
@@ -308,14 +308,14 @@ xfs_map_blocks(
         int                     nimaps = 1;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return -XFS_ERROR(EIO);
+                return -EIO;
 
         if (type == XFS_IO_UNWRITTEN)
                 bmapi_flags |= XFS_BMAPI_IGSTATE;
 
         if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
                 if (nonblocking)
-                        return -XFS_ERROR(EAGAIN);
+                        return -EAGAIN;
                 xfs_ilock(ip, XFS_ILOCK_SHARED);
         }
 
@@ -332,14 +332,14 @@ xfs_map_blocks(
         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 
         if (error)
-                return -XFS_ERROR(error);
+                return error;
 
         if (type == XFS_IO_DELALLOC &&
             (!nimaps || isnullstartblock(imap->br_startblock))) {
                 error = xfs_iomap_write_allocate(ip, offset, imap);
                 if (!error)
                         trace_xfs_map_blocks_alloc(ip, offset, count, type, imap);
-                return -XFS_ERROR(error);
+                return error;
         }
 
 #ifdef DEBUG
@@ -502,7 +502,7 @@ xfs_submit_ioend(
                  * time.
                  */
                 if (fail) {
-                        ioend->io_error = -fail;
+                        ioend->io_error = fail;
                         xfs_finish_ioend(ioend);
                         continue;
                 }
@@ -1253,7 +1253,7 @@ __xfs_get_blocks(
         int                     new = 0;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return -XFS_ERROR(EIO);
+                return -EIO;
 
         offset = (xfs_off_t)iblock << inode->i_blkbits;
         ASSERT(bh_result->b_size >= (1 << inode->i_blkbits));
@@ -1302,7 +1302,7 @@ __xfs_get_blocks(
                         error = xfs_iomap_write_direct(ip, offset, size,
                                                        &imap, nimaps);
                         if (error)
-                                return -error;
+                                return error;
                         new = 1;
                 } else {
                         /*
@@ -1415,7 +1415,7 @@ __xfs_get_blocks(
 
 out_unlock:
         xfs_iunlock(ip, lockmode);
-        return -error;
+        return error;
 }
 
 int
diff --git a/fs/xfs/xfs_attr_inactive.c b/fs/xfs/xfs_attr_inactive.c
index 09480c57f069..aa2a8b1838a2 100644
--- a/fs/xfs/xfs_attr_inactive.c
+++ b/fs/xfs/xfs_attr_inactive.c
@@ -76,7 +76,7 @@ xfs_attr3_leaf_freextent(
                 error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
                                        &map, &nmap, XFS_BMAPI_ATTRFORK);
                 if (error) {
-                        return(error);
+                        return error;
                 }
                 ASSERT(nmap == 1);
                 ASSERT(map.br_startblock != DELAYSTARTBLOCK);
@@ -95,21 +95,21 @@ xfs_attr3_leaf_freextent(
                                         dp->i_mount->m_ddev_targp,
                                         dblkno, dblkcnt, 0);
                         if (!bp)
-                                return ENOMEM;
+                                return -ENOMEM;
                         xfs_trans_binval(*trans, bp);
                         /*
                          * Roll to next transaction.
                          */
                         error = xfs_trans_roll(trans, dp);
                         if (error)
-                                return (error);
+                                return error;
                 }
 
                 tblkno += map.br_blockcount;
                 tblkcnt -= map.br_blockcount;
         }
 
-        return(0);
+        return 0;
 }
 
 /*
@@ -227,7 +227,7 @@ xfs_attr3_node_inactive(
          */
         if (level > XFS_DA_NODE_MAXDEPTH) {
                 xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         node = bp->b_addr;
@@ -256,7 +256,7 @@ xfs_attr3_node_inactive(
                 error = xfs_da3_node_read(*trans, dp, child_fsb, -2, &child_bp,
                                                 XFS_ATTR_FORK);
                 if (error)
-                        return(error);
+                        return error;
                 if (child_bp) {
                                                 /* save for re-read later */
                         child_blkno = XFS_BUF_ADDR(child_bp);
@@ -277,7 +277,7 @@ xfs_attr3_node_inactive(
                                                         child_bp);
                                 break;
                         default:
-                                error = XFS_ERROR(EIO);
+                                error = -EIO;
                                 xfs_trans_brelse(*trans, child_bp);
                                 break;
                         }
@@ -360,7 +360,7 @@ xfs_attr3_root_inactive(
                 error = xfs_attr3_leaf_inactive(trans, dp, bp);
                 break;
         default:
-                error = XFS_ERROR(EIO);
+                error = -EIO;
                 xfs_trans_brelse(*trans, bp);
                 break;
         }
@@ -414,7 +414,7 @@ xfs_attr_inactive(xfs_inode_t *dp)
         error = xfs_trans_reserve(trans, &M_RES(mp)->tr_attrinval, 0, 0);
         if (error) {
                 xfs_trans_cancel(trans, 0);
-                return(error);
+                return error;
         }
         xfs_ilock(dp, XFS_ILOCK_EXCL);
 
@@ -443,10 +443,10 @@ xfs_attr_inactive(xfs_inode_t *dp)
         error = xfs_trans_commit(trans, XFS_TRANS_RELEASE_LOG_RES);
         xfs_iunlock(dp, XFS_ILOCK_EXCL);
 
-        return(error);
+        return error;
 
 out:
         xfs_trans_cancel(trans, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
         xfs_iunlock(dp, XFS_ILOCK_EXCL);
-        return(error);
+        return error;
 }
diff --git a/fs/xfs/xfs_attr_list.c b/fs/xfs/xfs_attr_list.c
index 90e2eeb21207..62db83ab6cbc 100644
--- a/fs/xfs/xfs_attr_list.c
+++ b/fs/xfs/xfs_attr_list.c
@@ -50,11 +50,11 @@ xfs_attr_shortform_compare(const void *a, const void *b)
         sa = (xfs_attr_sf_sort_t *)a;
         sb = (xfs_attr_sf_sort_t *)b;
         if (sa->hash < sb->hash) {
-                return(-1);
+                return -1;
         } else if (sa->hash > sb->hash) {
-                return(1);
+                return 1;
         } else {
-                return(sa->entno - sb->entno);
+                return sa->entno - sb->entno;
         }
 }
 
@@ -86,7 +86,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
         sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
         ASSERT(sf != NULL);
         if (!sf->hdr.count)
-                return(0);
+                return 0;
         cursor = context->cursor;
         ASSERT(cursor != NULL);
 
@@ -124,7 +124,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
                         sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
                 }
                 trace_xfs_attr_list_sf_all(context);
-                return(0);
+                return 0;
         }
 
         /* do no more for a search callback */
@@ -150,7 +150,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
                                              XFS_ERRLEVEL_LOW,
                                              context->dp->i_mount, sfe);
                         kmem_free(sbuf);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
 
                 sbp->entno = i;
@@ -188,7 +188,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
         }
         if (i == nsbuf) {
                 kmem_free(sbuf);
-                return(0);
+                return 0;
         }
 
         /*
@@ -213,7 +213,7 @@ xfs_attr_shortform_list(xfs_attr_list_context_t *context)
         }
 
         kmem_free(sbuf);
-        return(0);
+        return 0;
 }
 
 STATIC int
@@ -243,8 +243,8 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
         if (cursor->blkno > 0) {
                 error = xfs_da3_node_read(NULL, dp, cursor->blkno, -1,
                                               &bp, XFS_ATTR_FORK);
-                if ((error != 0) && (error != EFSCORRUPTED))
-                        return(error);
+                if ((error != 0) && (error != -EFSCORRUPTED))
+                        return error;
                 if (bp) {
                         struct xfs_attr_leaf_entry *entries;
 
@@ -295,7 +295,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                                                       cursor->blkno, -1, &bp,
                                                       XFS_ATTR_FORK);
                         if (error)
-                                return(error);
+                                return error;
                         node = bp->b_addr;
                         magic = be16_to_cpu(node->hdr.info.magic);
                         if (magic == XFS_ATTR_LEAF_MAGIC ||
@@ -308,7 +308,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                                                      context->dp->i_mount,
                                                      node);
                                 xfs_trans_brelse(NULL, bp);
-                                return XFS_ERROR(EFSCORRUPTED);
+                                return -EFSCORRUPTED;
                         }
 
                         dp->d_ops->node_hdr_from_disk(&nodehdr, node);
@@ -496,11 +496,11 @@ xfs_attr_leaf_list(xfs_attr_list_context_t *context)
         context->cursor->blkno = 0;
         error = xfs_attr3_leaf_read(NULL, context->dp, 0, -1, &bp);
         if (error)
-                return XFS_ERROR(error);
+                return error;
 
         error = xfs_attr3_leaf_list_int(bp, context);
         xfs_trans_brelse(NULL, bp);
-        return XFS_ERROR(error);
+        return error;
 }
 
 int
@@ -514,7 +514,7 @@ xfs_attr_list_int(
         XFS_STATS_INC(xs_attr_list);
 
         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-                return EIO;
+                return -EIO;
 
         /*
          * Decide on what work routines to call based on the inode size.
@@ -616,16 +616,16 @@ xfs_attr_list(
          * Validate the cursor.
          */
         if (cursor->pad1 || cursor->pad2)
-                return(XFS_ERROR(EINVAL));
+                return -EINVAL;
         if ((cursor->initted == 0) &&
             (cursor->hashval || cursor->blkno || cursor->offset))
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         /*
          * Check for a properly aligned buffer.
          */
         if (((long)buffer) & (sizeof(int)-1))
-                return XFS_ERROR(EFAULT);
+                return -EFAULT;
         if (flags & ATTR_KERNOVAL)
                 bufsize = 0;
 
@@ -648,6 +648,6 @@ xfs_attr_list(
         alist->al_offset[0] = context.bufsize;
 
         error = xfs_attr_list_int(&context);
-        ASSERT(error >= 0);
+        ASSERT(error <= 0);
         return error;
 }
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 64731ef3324d..2f1e30d39a35 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -133,7 +133,7 @@ xfs_bmap_finish(
                         mp = ntp->t_mountp;
                         if (!XFS_FORCED_SHUTDOWN(mp))
                                 xfs_force_shutdown(mp,
-                                                   (error == EFSCORRUPTED) ?
+                                                   (error == -EFSCORRUPTED) ?
                                                    SHUTDOWN_CORRUPT_INCORE :
                                                    SHUTDOWN_META_IO_ERROR);
                         return error;
@@ -365,7 +365,7 @@ xfs_bmap_count_tree(
                         xfs_trans_brelse(tp, bp);
                         XFS_ERROR_REPORT("xfs_bmap_count_tree(1)",
                                          XFS_ERRLEVEL_LOW, mp);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
                 xfs_trans_brelse(tp, bp);
         } else {
@@ -425,14 +425,14 @@ xfs_bmap_count_blocks(
         ASSERT(level > 0);
         pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
         bno = be64_to_cpu(*pp);
-        ASSERT(bno != NULLDFSBNO);
+        ASSERT(bno != NULLFSBLOCK);
         ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
         ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
 
         if (unlikely(xfs_bmap_count_tree(mp, tp, ifp, bno, level, count) < 0)) {
                 XFS_ERROR_REPORT("xfs_bmap_count_blocks(2)", XFS_ERRLEVEL_LOW,
                                  mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         return 0;
@@ -524,13 +524,13 @@ xfs_getbmap(
                         if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS &&
                             ip->i_d.di_aformat != XFS_DINODE_FMT_BTREE &&
                             ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)
-                                return XFS_ERROR(EINVAL);
+                                return -EINVAL;
                 } else if (unlikely(
                            ip->i_d.di_aformat != 0 &&
                            ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS)) {
                         XFS_ERROR_REPORT("xfs_getbmap", XFS_ERRLEVEL_LOW,
                                          ip->i_mount);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
 
                 prealloced = 0;
@@ -539,7 +539,7 @@ xfs_getbmap(
                 if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS &&
                     ip->i_d.di_format != XFS_DINODE_FMT_BTREE &&
                     ip->i_d.di_format != XFS_DINODE_FMT_LOCAL)
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
 
                 if (xfs_get_extsz_hint(ip) ||
                     ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC|XFS_DIFLAG_APPEND)){
@@ -559,26 +559,26 @@ xfs_getbmap(
                 bmv->bmv_entries = 0;
                 return 0;
         } else if (bmv->bmv_length < 0) {
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         nex = bmv->bmv_count - 1;
         if (nex <= 0)
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         bmvend = bmv->bmv_offset + bmv->bmv_length;
 
 
         if (bmv->bmv_count > ULONG_MAX / sizeof(struct getbmapx))
-                return XFS_ERROR(ENOMEM);
+                return -ENOMEM;
         out = kmem_zalloc_large(bmv->bmv_count * sizeof(struct getbmapx), 0);
         if (!out)
-                return XFS_ERROR(ENOMEM);
+                return -ENOMEM;
 
         xfs_ilock(ip, XFS_IOLOCK_SHARED);
         if (whichfork == XFS_DATA_FORK) {
                 if (!(iflags & BMV_IF_DELALLOC) &&
                     (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_d.di_size)) {
-                        error = -filemap_write_and_wait(VFS_I(ip)->i_mapping);
+                        error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
                         if (error)
                                 goto out_unlock_iolock;
 
@@ -611,7 +611,7 @@ xfs_getbmap(
         /*
          * Allocate enough space to handle "subnex" maps at a time.
          */
-        error = ENOMEM;
+        error = -ENOMEM;
         subnex = 16;
         map = kmem_alloc(subnex * sizeof(*map), KM_MAYFAIL | KM_NOFS);
         if (!map)
@@ -809,7 +809,7 @@ xfs_can_free_eofblocks(struct xfs_inode *ip, bool force)
          * have speculative prealloc/delalloc blocks to remove.
          */
         if (VFS_I(ip)->i_size == 0 &&
-            VN_CACHED(VFS_I(ip)) == 0 &&
+            VFS_I(ip)->i_mapping->nrpages == 0 &&
             ip->i_delayed_blks == 0)
                 return false;
 
@@ -882,7 +882,7 @@ xfs_free_eofblocks(
                 if (need_iolock) {
                         if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
                                 xfs_trans_cancel(tp, 0);
-                                return EAGAIN;
+                                return -EAGAIN;
                         }
                 }
 
@@ -955,14 +955,14 @@ xfs_alloc_file_space(
         trace_xfs_alloc_file_space(ip);
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         error = xfs_qm_dqattach(ip, 0);
         if (error)
                 return error;
 
         if (len <= 0)
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         rt = XFS_IS_REALTIME_INODE(ip);
         extsz = xfs_get_extsz_hint(ip);
@@ -1028,7 +1028,7 @@ xfs_alloc_file_space(
                         /*
                          * Free the transaction structure.
                          */
-                        ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
+                        ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp));
                         xfs_trans_cancel(tp, 0);
                         break;
                 }
@@ -1065,7 +1065,7 @@ xfs_alloc_file_space(
                 allocated_fsb = imapp->br_blockcount;
 
                 if (nimaps == 0) {
-                        error = XFS_ERROR(ENOSPC);
+                        error = -ENOSPC;
                         break;
                 }
 
@@ -1126,7 +1126,7 @@ xfs_zero_remaining_bytes(
                                         mp->m_rtdev_targp : mp->m_ddev_targp,
                                   BTOBB(mp->m_sb.sb_blocksize), 0);
         if (!bp)
-                return XFS_ERROR(ENOMEM);
+                return -ENOMEM;
 
         xfs_buf_unlock(bp);
 
@@ -1158,7 +1158,7 @@ xfs_zero_remaining_bytes(
                 XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
 
                 if (XFS_FORCED_SHUTDOWN(mp)) {
-                        error = XFS_ERROR(EIO);
+                        error = -EIO;
                         break;
                 }
                 xfs_buf_iorequest(bp);
@@ -1176,7 +1176,7 @@ xfs_zero_remaining_bytes(
                 XFS_BUF_WRITE(bp);
 
                 if (XFS_FORCED_SHUTDOWN(mp)) {
-                        error = XFS_ERROR(EIO);
+                        error = -EIO;
                         break;
                 }
                 xfs_buf_iorequest(bp);
@@ -1234,7 +1234,7 @@ xfs_free_file_space(
 
         rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
         ioffset = offset & ~(rounding - 1);
-        error = -filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
+        error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
                                               ioffset, -1);
         if (error)
                 goto out;
@@ -1315,7 +1315,7 @@ xfs_free_file_space(
                         /*
                          * Free the transaction structure.
                          */
-                        ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
+                        ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp));
                         xfs_trans_cancel(tp, 0);
                         break;
                 }
@@ -1557,14 +1557,14 @@ xfs_swap_extents_check_format(
         /* Should never get a local format */
         if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL ||
             tip->i_d.di_format == XFS_DINODE_FMT_LOCAL)
-                return EINVAL;
+                return -EINVAL;
 
         /*
          * if the target inode has less extents that then temporary inode then
          * why did userspace call us?
          */
         if (ip->i_d.di_nextents < tip->i_d.di_nextents)
-                return EINVAL;
+                return -EINVAL;
 
         /*
          * if the target inode is in extent form and the temp inode is in btree
@@ -1573,19 +1573,19 @@ xfs_swap_extents_check_format(
          */
         if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
             tip->i_d.di_format == XFS_DINODE_FMT_BTREE)
-                return EINVAL;
+                return -EINVAL;
 
         /* Check temp in extent form to max in target */
         if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
             XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) >
                         XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
-                return EINVAL;
+                return -EINVAL;
 
         /* Check target in extent form to max in temp */
         if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
             XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) >
                         XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
-                return EINVAL;
+                return -EINVAL;
 
         /*
          * If we are in a btree format, check that the temp root block will fit
@@ -1599,26 +1599,50 @@ xfs_swap_extents_check_format(
         if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
                 if (XFS_IFORK_BOFF(ip) &&
                     XFS_BMAP_BMDR_SPACE(tip->i_df.if_broot) > XFS_IFORK_BOFF(ip))
-                        return EINVAL;
+                        return -EINVAL;
                 if (XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <=
                     XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
-                        return EINVAL;
+                        return -EINVAL;
         }
 
         /* Reciprocal target->temp btree format checks */
         if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
                 if (XFS_IFORK_BOFF(tip) &&
                     XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > XFS_IFORK_BOFF(tip))
-                        return EINVAL;
+                        return -EINVAL;
                 if (XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <=
                     XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
-                        return EINVAL;
+                        return -EINVAL;
         }
 
         return 0;
 }
 
 int
+xfs_swap_extent_flush(
+        struct xfs_inode        *ip)
+{
+        int     error;
+
+        error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
+        if (error)
+                return error;
+        truncate_pagecache_range(VFS_I(ip), 0, -1);
+
+        /* Verify O_DIRECT for ftmp */
+        if (VFS_I(ip)->i_mapping->nrpages)
+                return -EINVAL;
+
+        /*
+         * Don't try to swap extents on mmap()d files because we can't lock
+         * out races against page faults safely.
+         */
+        if (mapping_mapped(VFS_I(ip)->i_mapping))
+                return -EBUSY;
+        return 0;
+}
+
+int
 xfs_swap_extents(
         xfs_inode_t     *ip,    /* target inode */
         xfs_inode_t     *tip,   /* tmp inode */
@@ -1633,51 +1657,57 @@ xfs_swap_extents(
         int             aforkblks = 0;
         int             taforkblks = 0;
         __uint64_t      tmp;
+        int             lock_flags;
 
         tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
         if (!tempifp) {
-                error = XFS_ERROR(ENOMEM);
+                error = -ENOMEM;
                 goto out;
         }
 
         /*
-         * we have to do two separate lock calls here to keep lockdep
-         * happy. If we try to get all the locks in one call, lock will
-         * report false positives when we drop the ILOCK and regain them
-         * below.
+         * Lock up the inodes against other IO and truncate to begin with.
+         * Then we can ensure the inodes are flushed and have no page cache
+         * safely. Once we have done this we can take the ilocks and do the rest
+         * of the checks.
          */
+        lock_flags = XFS_IOLOCK_EXCL;
         xfs_lock_two_inodes(ip, tip, XFS_IOLOCK_EXCL);
-        xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
 
         /* Verify that both files have the same format */
         if ((ip->i_d.di_mode & S_IFMT) != (tip->i_d.di_mode & S_IFMT)) {
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_unlock;
         }
 
         /* Verify both files are either real-time or non-realtime */
         if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_unlock;
         }
 
-        error = -filemap_write_and_wait(VFS_I(tip)->i_mapping);
+        error = xfs_swap_extent_flush(ip);
+        if (error)
+                goto out_unlock;
+        error = xfs_swap_extent_flush(tip);
         if (error)
                 goto out_unlock;
-        truncate_pagecache_range(VFS_I(tip), 0, -1);
 
-        /* Verify O_DIRECT for ftmp */
-        if (VN_CACHED(VFS_I(tip)) != 0) {
-                error = XFS_ERROR(EINVAL);
+        tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
+        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
+        if (error) {
+                xfs_trans_cancel(tp, 0);
                 goto out_unlock;
         }
+        xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
+        lock_flags |= XFS_ILOCK_EXCL;
 
         /* Verify all data are being swapped */
         if (sxp->sx_offset != 0 ||
             sxp->sx_length != ip->i_d.di_size ||
             sxp->sx_length != tip->i_d.di_size) {
-                error = XFS_ERROR(EFAULT);
-                goto out_unlock;
+                error = -EFAULT;
+                goto out_trans_cancel;
         }
 
         trace_xfs_swap_extent_before(ip, 0);
@@ -1689,7 +1719,7 @@ xfs_swap_extents(
                 xfs_notice(mp,
                     "%s: inode 0x%llx format is incompatible for exchanging.",
                                 __func__, ip->i_ino);
-                goto out_unlock;
+                goto out_trans_cancel;
         }
 
         /*
@@ -1703,43 +1733,9 @@ xfs_swap_extents(
             (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
             (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
             (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
-                error = XFS_ERROR(EBUSY);
-                goto out_unlock;
-        }
-
-        /* We need to fail if the file is memory mapped.  Once we have tossed
-         * all existing pages, the page fault will have no option
-         * but to go to the filesystem for pages. By making the page fault call
-         * vop_read (or write in the case of autogrow) they block on the iolock
-         * until we have switched the extents.
-         */
-        if (VN_MAPPED(VFS_I(ip))) {
-                error = XFS_ERROR(EBUSY);
-                goto out_unlock;
-        }
-
-        xfs_iunlock(ip, XFS_ILOCK_EXCL);
-        xfs_iunlock(tip, XFS_ILOCK_EXCL);
-
-        /*
-         * There is a race condition here since we gave up the
-         * ilock.  However, the data fork will not change since
-         * we have the iolock (locked for truncation too) so we
-         * are safe.  We don't really care if non-io related
-         * fields change.
-         */
-        truncate_pagecache_range(VFS_I(ip), 0, -1);
-
-        tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
-        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
-        if (error) {
-                xfs_iunlock(ip,  XFS_IOLOCK_EXCL);
-                xfs_iunlock(tip, XFS_IOLOCK_EXCL);
-                xfs_trans_cancel(tp, 0);
-                goto out;
+                error = -EBUSY;
+                goto out_trans_cancel;
         }
-        xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
-
         /*
          * Count the number of extended attribute blocks
          */
@@ -1757,8 +1753,8 @@ xfs_swap_extents(
                         goto out_trans_cancel;
         }
 
-        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
-        xfs_trans_ijoin(tp, tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
+        xfs_trans_ijoin(tp, ip, lock_flags);
+        xfs_trans_ijoin(tp, tip, lock_flags);
 
         /*
          * Before we've swapped the forks, lets set the owners of the forks
@@ -1887,8 +1883,8 @@ out:
         return error;
 
 out_unlock:
-        xfs_iunlock(ip,  XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
-        xfs_iunlock(tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
+        xfs_iunlock(ip, lock_flags);
+        xfs_iunlock(tip, lock_flags);
         goto out;
 
 out_trans_cancel:
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 7a34a1ae6552..cd7b8ca9b064 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -130,7 +130,7 @@ xfs_buf_get_maps(
         bp->b_maps = kmem_zalloc(map_count * sizeof(struct xfs_buf_map),
                                 KM_NOFS);
         if (!bp->b_maps)
-                return ENOMEM;
+                return -ENOMEM;
         return 0;
 }
 
@@ -344,7 +344,7 @@ retry:
                 if (unlikely(page == NULL)) {
                         if (flags & XBF_READ_AHEAD) {
                                 bp->b_page_count = i;
-                                error = ENOMEM;
+                                error = -ENOMEM;
                                 goto out_free_pages;
                         }
 
@@ -465,7 +465,7 @@ _xfs_buf_find(
         eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_sb.sb_dblocks);
         if (blkno >= eofs) {
                 /*
-                 * XXX (dgc): we should really be returning EFSCORRUPTED here,
+                 * XXX (dgc): we should really be returning -EFSCORRUPTED here,
                  * but none of the higher level infrastructure supports
                  * returning a specific error on buffer lookup failures.
                  */
@@ -1052,8 +1052,8 @@ xfs_buf_ioerror(
         xfs_buf_t               *bp,
         int                     error)
 {
-        ASSERT(error >= 0 && error <= 0xffff);
-        bp->b_error = (unsigned short)error;
+        ASSERT(error <= 0 && error >= -1000);
+        bp->b_error = error;
         trace_xfs_buf_ioerror(bp, error, _RET_IP_);
 }
 
@@ -1064,7 +1064,7 @@ xfs_buf_ioerror_alert(
 {
         xfs_alert(bp->b_target->bt_mount,
 "metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
-                (__uint64_t)XFS_BUF_ADDR(bp), func, bp->b_error, bp->b_length);
+                (__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
 }
 
 /*
@@ -1083,7 +1083,7 @@ xfs_bioerror(
         /*
          * No need to wait until the buffer is unpinned, we aren't flushing it.
          */
-        xfs_buf_ioerror(bp, EIO);
+        xfs_buf_ioerror(bp, -EIO);
 
         /*
          * We're calling xfs_buf_ioend, so delete XBF_DONE flag.
@@ -1094,7 +1094,7 @@ xfs_bioerror(
 
         xfs_buf_ioend(bp, 0);
 
-        return EIO;
+        return -EIO;
 }
 
 /*
@@ -1127,13 +1127,13 @@ xfs_bioerror_relse(
                  * There's no reason to mark error for
                  * ASYNC buffers.
                  */
-                xfs_buf_ioerror(bp, EIO);
+                xfs_buf_ioerror(bp, -EIO);
                 complete(&bp->b_iowait);
         } else {
                 xfs_buf_relse(bp);
         }
 
-        return EIO;
+        return -EIO;
 }
 
 STATIC int
@@ -1199,7 +1199,7 @@ xfs_buf_bio_end_io(
          * buffers that require multiple bios to complete.
          */
         if (!bp->b_error)
-                xfs_buf_ioerror(bp, -error);
+                xfs_buf_ioerror(bp, error);
 
         if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
                 invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
@@ -1286,7 +1286,7 @@ next_chunk:
                  * because the caller (xfs_buf_iorequest) holds a count itself.
                  */
                 atomic_dec(&bp->b_io_remaining);
-                xfs_buf_ioerror(bp, EIO);
+                xfs_buf_ioerror(bp, -EIO);
                 bio_put(bio);
         }
 
@@ -1330,6 +1330,20 @@ _xfs_buf_ioapply(
                                                    SHUTDOWN_CORRUPT_INCORE);
                                 return;
                         }
+                } else if (bp->b_bn != XFS_BUF_DADDR_NULL) {
+                        struct xfs_mount *mp = bp->b_target->bt_mount;
+
+                        /*
+                         * non-crc filesystems don't attach verifiers during
+                         * log recovery, so don't warn for such filesystems.
+                         */
+                        if (xfs_sb_version_hascrc(&mp->m_sb)) {
+                                xfs_warn(mp,
+                                        "%s: no ops on block 0x%llx/0x%x",
+                                        __func__, bp->b_bn, bp->b_length);
+                                xfs_hex_dump(bp->b_addr, 64);
+                                dump_stack();
+                        }
                 }
         } else if (bp->b_flags & XBF_READ_AHEAD) {
                 rw = READA;
@@ -1628,7 +1642,7 @@ xfs_setsize_buftarg(
                 xfs_warn(btp->bt_mount,
                         "Cannot set_blocksize to %u on device %s",
                         sectorsize, name);
-                return EINVAL;
+                return -EINVAL;
         }
 
         /* Set up device logical sector size mask */
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 3a7a5523d3dc..c753183900b3 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -178,7 +178,7 @@ typedef struct xfs_buf {
         atomic_t                b_io_remaining; /* #outstanding I/O requests */
         unsigned int            b_page_count;   /* size of page array */
         unsigned int            b_offset;       /* page offset in first page */
-        unsigned short          b_error;        /* error code on I/O */
+        int                     b_error;        /* error code on I/O */
         const struct xfs_buf_ops        *b_ops;
 
 #ifdef XFS_BUF_LOCK_TRACKING
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 4654338b03fc..76007deed31f 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -488,7 +488,7 @@ xfs_buf_item_unpin(
                 xfs_buf_lock(bp);
                 xfs_buf_hold(bp);
                 bp->b_flags |= XBF_ASYNC;
-                xfs_buf_ioerror(bp, EIO);
+                xfs_buf_ioerror(bp, -EIO);
                 XFS_BUF_UNDONE(bp);
                 xfs_buf_stale(bp);
                 xfs_buf_ioend(bp, 0);
@@ -725,7 +725,7 @@ xfs_buf_item_get_format(
         bip->bli_formats = kmem_zalloc(count * sizeof(struct xfs_buf_log_format),
                                 KM_SLEEP);
         if (!bip->bli_formats)
-                return ENOMEM;
+                return -ENOMEM;
         return 0;
 }
 
diff --git a/fs/xfs/xfs_dir2_readdir.c b/fs/xfs/xfs_dir2_readdir.c
index 48e99afb9cb0..f1b69edcdf31 100644
--- a/fs/xfs/xfs_dir2_readdir.c
+++ b/fs/xfs/xfs_dir2_readdir.c
@@ -95,7 +95,7 @@ xfs_dir2_sf_getdents(
          */
         if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
                 ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
@@ -677,7 +677,7 @@ xfs_readdir(
         trace_xfs_readdir(dp);
 
         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         ASSERT(S_ISDIR(dp->i_d.di_mode));
         XFS_STATS_INC(xs_dir_getdents);
diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c
index 4f11ef011139..13d08a1b390e 100644
--- a/fs/xfs/xfs_discard.c
+++ b/fs/xfs/xfs_discard.c
@@ -124,7 +124,7 @@ xfs_trim_extents(
                 }
 
                 trace_xfs_discard_extent(mp, agno, fbno, flen);
-                error = -blkdev_issue_discard(bdev, dbno, dlen, GFP_NOFS, 0);
+                error = blkdev_issue_discard(bdev, dbno, dlen, GFP_NOFS, 0);
                 if (error)
                         goto out_del_cursor;
                 *blocks_trimmed += flen;
@@ -166,11 +166,11 @@ xfs_ioc_trim(
         int                     error, last_error = 0;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
         if (!blk_queue_discard(q))
-                return -XFS_ERROR(EOPNOTSUPP);
+                return -EOPNOTSUPP;
         if (copy_from_user(&range, urange, sizeof(range)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         /*
          * Truncating down the len isn't actually quite correct, but using
@@ -182,7 +182,7 @@ xfs_ioc_trim(
         if (range.start >= XFS_FSB_TO_B(mp, mp->m_sb.sb_dblocks) ||
             range.minlen > XFS_FSB_TO_B(mp, XFS_ALLOC_AG_MAX_USABLE(mp)) ||
             range.len < mp->m_sb.sb_blocksize)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         start = BTOBB(range.start);
         end = start + BTOBBT(range.len) - 1;
@@ -195,7 +195,7 @@ xfs_ioc_trim(
         end_agno = xfs_daddr_to_agno(mp, end);
 
         for (agno = start_agno; agno <= end_agno; agno++) {
-                error = -xfs_trim_extents(mp, agno, start, end, minlen,
+                error = xfs_trim_extents(mp, agno, start, end, minlen,
                                           &blocks_trimmed);
                 if (error)
                         last_error = error;
@@ -206,7 +206,7 @@ xfs_ioc_trim(
 
         range.len = XFS_FSB_TO_B(mp, blocks_trimmed);
         if (copy_to_user(urange, &range, sizeof(range)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -222,11 +222,11 @@ xfs_discard_extents(
                 trace_xfs_discard_extent(mp, busyp->agno, busyp->bno,
                                          busyp->length);
 
-                error = -blkdev_issue_discard(mp->m_ddev_targp->bt_bdev,
+                error = blkdev_issue_discard(mp->m_ddev_targp->bt_bdev,
                                 XFS_AGB_TO_DADDR(mp, busyp->agno, busyp->bno),
                                 XFS_FSB_TO_BB(mp, busyp->length),
                                 GFP_NOFS, 0);
-                if (error && error != EOPNOTSUPP) {
+                if (error && error != -EOPNOTSUPP) {
                         xfs_info(mp,
          "discard failed for extent [0x%llu,%u], error %d",
                                  (unsigned long long)busyp->bno,
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 3ee0cd43edc0..63c2de49f61d 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -327,7 +327,7 @@ xfs_qm_dqalloc(
          */
         if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
                 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
-                return (ESRCH);
+                return -ESRCH;
         }
 
         xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
@@ -354,7 +354,7 @@ xfs_qm_dqalloc(
                                mp->m_quotainfo->qi_dqchunklen,
                                0);
         if (!bp) {
-                error = ENOMEM;
+                error = -ENOMEM;
                 goto error1;
         }
         bp->b_ops = &xfs_dquot_buf_ops;
@@ -400,7 +400,7 @@ xfs_qm_dqalloc(
       error0:
         xfs_iunlock(quotip, XFS_ILOCK_EXCL);
 
-        return (error);
+        return error;
 }
 
 STATIC int
@@ -426,7 +426,7 @@ xfs_qm_dqrepair(
 
         if (error) {
                 ASSERT(*bpp == NULL);
-                return XFS_ERROR(error);
+                return error;
         }
         (*bpp)->b_ops = &xfs_dquot_buf_ops;
 
@@ -442,7 +442,7 @@ xfs_qm_dqrepair(
                 if (error) {
                         /* repair failed, we're screwed */
                         xfs_trans_brelse(tp, *bpp);
-                        return XFS_ERROR(EIO);
+                        return -EIO;
                 }
         }
 
@@ -480,7 +480,7 @@ xfs_qm_dqtobp(
                  * didn't have the quota inode lock.
                  */
                 xfs_iunlock(quotip, lock_mode);
-                return ESRCH;
+                return -ESRCH;
         }
 
         /*
@@ -508,7 +508,7 @@ xfs_qm_dqtobp(
                  * We don't allocate unless we're asked to
                  */
                 if (!(flags & XFS_QMOPT_DQALLOC))
-                        return ENOENT;
+                        return -ENOENT;
 
                 ASSERT(tp);
                 error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
@@ -530,7 +530,7 @@ xfs_qm_dqtobp(
                                            mp->m_quotainfo->qi_dqchunklen,
                                            0, &bp, &xfs_dquot_buf_ops);
 
-                if (error == EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) {
+                if (error == -EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) {
                         xfs_dqid_t firstid = (xfs_dqid_t)map.br_startoff *
                                                 mp->m_quotainfo->qi_dqperchunk;
                         ASSERT(bp == NULL);
@@ -539,7 +539,7 @@ xfs_qm_dqtobp(
 
                 if (error) {
                         ASSERT(bp == NULL);
-                        return XFS_ERROR(error);
+                        return error;
                 }
         }
 
@@ -547,7 +547,7 @@ xfs_qm_dqtobp(
         *O_bpp = bp;
         *O_ddpp = bp->b_addr + dqp->q_bufoffset;
 
-        return (0);
+        return 0;
 }
 
 
@@ -715,7 +715,7 @@ xfs_qm_dqget(
         if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
             (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
             (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
-                return (ESRCH);
+                return -ESRCH;
         }
 
 #ifdef DEBUG
@@ -723,7 +723,7 @@ xfs_qm_dqget(
                 if ((xfs_dqerror_target == mp->m_ddev_targp) &&
                     (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
                         xfs_debug(mp, "Returning error in dqget");
-                        return (EIO);
+                        return -EIO;
                 }
         }
 
@@ -796,14 +796,14 @@ restart:
                 } else {
                         /* inode stays locked on return */
                         xfs_qm_dqdestroy(dqp);
-                        return XFS_ERROR(ESRCH);
+                        return -ESRCH;
                 }
         }
 
         mutex_lock(&qi->qi_tree_lock);
-        error = -radix_tree_insert(tree, id, dqp);
+        error = radix_tree_insert(tree, id, dqp);
         if (unlikely(error)) {
-                WARN_ON(error != EEXIST);
+                WARN_ON(error != -EEXIST);
 
                 /*
                  * Duplicate found. Just throw away the new dquot and start
@@ -829,7 +829,7 @@ restart:
         ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
         trace_xfs_dqget_miss(dqp);
         *O_dqpp = dqp;
-        return (0);
+        return 0;
 }
 
 /*
@@ -966,7 +966,7 @@ xfs_qm_dqflush(
                                              SHUTDOWN_CORRUPT_INCORE);
                 else
                         spin_unlock(&mp->m_ail->xa_lock);
-                error = XFS_ERROR(EIO);
+                error = -EIO;
                 goto out_unlock;
         }
 
@@ -974,7 +974,8 @@ xfs_qm_dqflush(
          * Get the buffer containing the on-disk dquot
          */
         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
-                                   mp->m_quotainfo->qi_dqchunklen, 0, &bp, NULL);
+                                   mp->m_quotainfo->qi_dqchunklen, 0, &bp,
+                                   &xfs_dquot_buf_ops);
         if (error)
                 goto out_unlock;
 
@@ -992,7 +993,7 @@ xfs_qm_dqflush(
                 xfs_buf_relse(bp);
                 xfs_dqfunlock(dqp);
                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         /* This is the only portion of data that needs to persist */
@@ -1045,7 +1046,7 @@ xfs_qm_dqflush(
 
 out_unlock:
         xfs_dqfunlock(dqp);
-        return XFS_ERROR(EIO);
+        return -EIO;
 }
 
 /*
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 68a68f704837..c24c67e22a2a 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -139,6 +139,21 @@ static inline xfs_dquot_t *xfs_inode_dquot(struct xfs_inode *ip, int type)
         }
 }
 
+/*
+ * Check whether a dquot is under low free space conditions. We assume the quota
+ * is enabled and enforced.
+ */
+static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
+{
+        int64_t freesp;
+
+        freesp = be64_to_cpu(dqp->q_core.d_blk_hardlimit) - dqp->q_res_bcount;
+        if (freesp < dqp->q_low_space[XFS_QLOWSP_1_PCNT])
+                return true;
+
+        return false;
+}
+
 #define XFS_DQ_IS_LOCKED(dqp)   (mutex_is_locked(&((dqp)->q_qlock)))
 #define XFS_DQ_IS_DIRTY(dqp)    ((dqp)->dq_flags & XFS_DQ_DIRTY)
 #define XFS_QM_ISUDQ(dqp)       ((dqp)->dq_flags & XFS_DQ_USER)
diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index edac5b057d28..b92fd7bc49e3 100644
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -27,29 +27,6 @@
 
 #ifdef DEBUG
 
-int     xfs_etrap[XFS_ERROR_NTRAP] = {
-        0,
-};
-
-int
-xfs_error_trap(int e)
-{
-        int i;
-
-        if (!e)
-                return 0;
-        for (i = 0; i < XFS_ERROR_NTRAP; i++) {
-                if (xfs_etrap[i] == 0)
-                        break;
-                if (e != xfs_etrap[i])
-                        continue;
-                xfs_notice(NULL, "%s: error %d", __func__, e);
-                BUG();
-                break;
-        }
-        return e;
-}
-
 int     xfs_etest[XFS_NUM_INJECT_ERROR];
 int64_t xfs_etest_fsid[XFS_NUM_INJECT_ERROR];
 char *  xfs_etest_fsname[XFS_NUM_INJECT_ERROR];
@@ -190,7 +167,7 @@ xfs_verifier_error(
         struct xfs_mount *mp = bp->b_target->bt_mount;
 
         xfs_alert(mp, "Metadata %s detected at %pF, block 0x%llx",
-                  bp->b_error == EFSBADCRC ? "CRC error" : "corruption",
+                  bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
                   __return_address, bp->b_bn);
 
         xfs_alert(mp, "Unmount and run xfs_repair");
diff --git a/fs/xfs/xfs_error.h b/fs/xfs/xfs_error.h
index c1c57d4a4b5d..279a76e52791 100644
--- a/fs/xfs/xfs_error.h
+++ b/fs/xfs/xfs_error.h
@@ -18,15 +18,6 @@
 #ifndef __XFS_ERROR_H__
 #define __XFS_ERROR_H__
 
-#ifdef DEBUG
-#define XFS_ERROR_NTRAP 10
-extern int      xfs_etrap[XFS_ERROR_NTRAP];
-extern int      xfs_error_trap(int);
-#define XFS_ERROR(e)    xfs_error_trap(e)
-#else
-#define XFS_ERROR(e)    (e)
-#endif
-
 struct xfs_mount;
 
 extern void xfs_error_report(const char *tag, int level, struct xfs_mount *mp,
@@ -56,7 +47,7 @@ extern void xfs_verifier_error(struct xfs_buf *bp);
                 if (unlikely(!fs_is_ok)) { \
                         XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_GOTO", \
                                          XFS_ERRLEVEL_LOW, NULL); \
-                        error = XFS_ERROR(EFSCORRUPTED); \
+                        error = -EFSCORRUPTED; \
                         goto l; \
                 } \
         }
@@ -68,7 +59,7 @@ extern void xfs_verifier_error(struct xfs_buf *bp);
                 if (unlikely(!fs_is_ok)) { \
                         XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_RETURN", \
                                          XFS_ERRLEVEL_LOW, NULL); \
-                        return XFS_ERROR(EFSCORRUPTED); \
+                        return -EFSCORRUPTED; \
                 } \
         }
 
diff --git a/fs/xfs/xfs_export.c b/fs/xfs/xfs_export.c
index 753e467aa1a5..5a6bd5d8779a 100644
--- a/fs/xfs/xfs_export.c
+++ b/fs/xfs/xfs_export.c
@@ -147,9 +147,9 @@ xfs_nfs_get_inode(
                  * We don't use ESTALE directly down the chain to not
                  * confuse applications using bulkstat that expect EINVAL.
                  */
-                if (error == EINVAL || error == ENOENT)
-                        error = ESTALE;
-                return ERR_PTR(-error);
+                if (error == -EINVAL || error == -ENOENT)
+                        error = -ESTALE;
+                return ERR_PTR(error);
         }
 
         if (ip->i_d.di_gen != generation) {
@@ -217,7 +217,7 @@ xfs_fs_get_parent(
 
         error = xfs_lookup(XFS_I(child->d_inode), &xfs_name_dotdot, &cip, NULL);
         if (unlikely(error))
-                return ERR_PTR(-error);
+                return ERR_PTR(error);
 
         return d_obtain_alias(VFS_I(cip));
 }
@@ -237,7 +237,7 @@ xfs_fs_nfs_commit_metadata(
 
         if (!lsn)
                 return 0;
-        return -_xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
+        return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
 }
 
 const struct export_operations xfs_export_operations = {
diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
index fb7a4c1ce1c5..c4327419dc5c 100644
--- a/fs/xfs/xfs_extfree_item.c
+++ b/fs/xfs/xfs_extfree_item.c
@@ -298,7 +298,7 @@ xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
                 }
                 return 0;
         }
-        return EFSCORRUPTED;
+        return -EFSCORRUPTED;
 }
 
 /*
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 1f66779d7a46..076b1708d134 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -38,6 +38,7 @@
 #include "xfs_trace.h"
 #include "xfs_log.h"
 #include "xfs_dinode.h"
+#include "xfs_icache.h"
 
 #include <linux/aio.h>
 #include <linux/dcache.h>
@@ -155,7 +156,7 @@ xfs_dir_fsync(
 
         if (!lsn)
                 return 0;
-        return -_xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
+        return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
 }
 
 STATIC int
@@ -179,7 +180,7 @@ xfs_file_fsync(
                 return error;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return -XFS_ERROR(EIO);
+                return -EIO;
 
         xfs_iflags_clear(ip, XFS_ITRUNCATED);
 
@@ -225,7 +226,7 @@ xfs_file_fsync(
             !log_flushed)
                 xfs_blkdev_issue_flush(mp->m_ddev_targp);
 
-        return -error;
+        return error;
 }
 
 STATIC ssize_t
@@ -246,11 +247,11 @@ xfs_file_read_iter(
         XFS_STATS_INC(xs_read_calls);
 
         if (unlikely(file->f_flags & O_DIRECT))
-                ioflags |= IO_ISDIRECT;
+                ioflags |= XFS_IO_ISDIRECT;
         if (file->f_mode & FMODE_NOCMTIME)
-                ioflags |= IO_INVIS;
+                ioflags |= XFS_IO_INVIS;
 
-        if (unlikely(ioflags & IO_ISDIRECT)) {
+        if (unlikely(ioflags & XFS_IO_ISDIRECT)) {
                 xfs_buftarg_t   *target =
                         XFS_IS_REALTIME_INODE(ip) ?
                                 mp->m_rtdev_targp : mp->m_ddev_targp;
@@ -258,7 +259,7 @@ xfs_file_read_iter(
                 if ((pos | size) & target->bt_logical_sectormask) {
                         if (pos == i_size_read(inode))
                                 return 0;
-                        return -XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
         }
 
@@ -283,7 +284,7 @@ xfs_file_read_iter(
          * proceeed concurrently without serialisation.
          */
         xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
-        if ((ioflags & IO_ISDIRECT) && inode->i_mapping->nrpages) {
+        if ((ioflags & XFS_IO_ISDIRECT) && inode->i_mapping->nrpages) {
                 xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
                 xfs_rw_ilock(ip, XFS_IOLOCK_EXCL);
 
@@ -325,7 +326,7 @@ xfs_file_splice_read(
         XFS_STATS_INC(xs_read_calls);
 
         if (infilp->f_mode & FMODE_NOCMTIME)
-                ioflags |= IO_INVIS;
+                ioflags |= XFS_IO_INVIS;
 
         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
                 return -EIO;
@@ -524,7 +525,7 @@ restart:
                         xfs_rw_ilock(ip, *iolock);
                         goto restart;
                 }
-                error = -xfs_zero_eof(ip, *pos, i_size_read(inode));
+                error = xfs_zero_eof(ip, *pos, i_size_read(inode));
                 if (error)
                         return error;
         }
@@ -594,7 +595,7 @@ xfs_file_dio_aio_write(
 
         /* DIO must be aligned to device logical sector size */
         if ((pos | count) & target->bt_logical_sectormask)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         /* "unaligned" here means not aligned to a filesystem block */
         if ((pos & mp->m_blockmask) || ((pos + count) & mp->m_blockmask))
@@ -689,14 +690,28 @@ write_retry:
         ret = generic_perform_write(file, from, pos);
         if (likely(ret >= 0))
                 iocb->ki_pos = pos + ret;
+
         /*
-         * If we just got an ENOSPC, try to write back all dirty inodes to
-         * convert delalloc space to free up some of the excess reserved
-         * metadata space.
+         * If we hit a space limit, try to free up some lingering preallocated
+         * space before returning an error. In the case of ENOSPC, first try to
+         * write back all dirty inodes to free up some of the excess reserved
+         * metadata space. This reduces the chances that the eofblocks scan
+         * waits on dirty mappings. Since xfs_flush_inodes() is serialized, this
+         * also behaves as a filter to prevent too many eofblocks scans from
+         * running at the same time.
          */
-        if (ret == -ENOSPC && !enospc) {
+        if (ret == -EDQUOT && !enospc) {
+                enospc = xfs_inode_free_quota_eofblocks(ip);
+                if (enospc)
+                        goto write_retry;
+        } else if (ret == -ENOSPC && !enospc) {
+                struct xfs_eofblocks eofb = {0};
+
                 enospc = 1;
                 xfs_flush_inodes(ip->i_mount);
+                eofb.eof_scan_owner = ip->i_ino; /* for locking */
+                eofb.eof_flags = XFS_EOF_FLAGS_SYNC;
+                xfs_icache_free_eofblocks(ip->i_mount, &eofb);
                 goto write_retry;
         }
 
@@ -772,7 +787,7 @@ xfs_file_fallocate(
                 unsigned blksize_mask = (1 << inode->i_blkbits) - 1;
 
                 if (offset & blksize_mask || len & blksize_mask) {
-                        error = EINVAL;
+                        error = -EINVAL;
                         goto out_unlock;
                 }
 
@@ -781,7 +796,7 @@ xfs_file_fallocate(
                  * in which case it is effectively a truncate operation
                  */
                 if (offset + len >= i_size_read(inode)) {
-                        error = EINVAL;
+                        error = -EINVAL;
                         goto out_unlock;
                 }
 
@@ -794,7 +809,7 @@ xfs_file_fallocate(
                 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
                     offset + len > i_size_read(inode)) {
                         new_size = offset + len;
-                        error = -inode_newsize_ok(inode, new_size);
+                        error = inode_newsize_ok(inode, new_size);
                         if (error)
                                 goto out_unlock;
                 }
@@ -844,7 +859,7 @@ xfs_file_fallocate(
 
 out_unlock:
         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-        return -error;
+        return error;
 }
 
 
@@ -889,7 +904,7 @@ xfs_file_release(
         struct inode    *inode,
         struct file     *filp)
 {
-        return -xfs_release(XFS_I(inode));
+        return xfs_release(XFS_I(inode));
 }
 
 STATIC int
@@ -918,7 +933,7 @@ xfs_file_readdir(
 
         error = xfs_readdir(ip, ctx, bufsize);
         if (error)
-                return -error;
+                return error;
         return 0;
 }
 
@@ -1184,7 +1199,7 @@ xfs_seek_data(
 
         isize = i_size_read(inode);
         if (start >= isize) {
-                error = ENXIO;
+                error = -ENXIO;
                 goto out_unlock;
         }
 
@@ -1206,7 +1221,7 @@ xfs_seek_data(
 
                 /* No extents at given offset, must be beyond EOF */
                 if (nmap == 0) {
-                        error = ENXIO;
+                        error = -ENXIO;
                         goto out_unlock;
                 }
 
@@ -1237,7 +1252,7 @@ xfs_seek_data(
                  * we are reading after EOF if nothing in map[1].
                  */
                 if (nmap == 1) {
-                        error = ENXIO;
+                        error = -ENXIO;
                         goto out_unlock;
                 }
 
@@ -1250,7 +1265,7 @@ xfs_seek_data(
                 fsbno = map[i - 1].br_startoff + map[i - 1].br_blockcount;
                 start = XFS_FSB_TO_B(mp, fsbno);
                 if (start >= isize) {
-                        error = ENXIO;
+                        error = -ENXIO;
                         goto out_unlock;
                 }
         }
@@ -1262,7 +1277,7 @@ out_unlock:
         xfs_iunlock(ip, lock);
 
         if (error)
-                return -error;
+                return error;
         return offset;
 }
 
@@ -1282,13 +1297,13 @@ xfs_seek_hole(
         int                     error;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return -XFS_ERROR(EIO);
+                return -EIO;
 
         lock = xfs_ilock_data_map_shared(ip);
 
         isize = i_size_read(inode);
         if (start >= isize) {
-                error = ENXIO;
+                error = -ENXIO;
                 goto out_unlock;
         }
 
@@ -1307,7 +1322,7 @@ xfs_seek_hole(
 
                 /* No extents at given offset, must be beyond EOF */
                 if (nmap == 0) {
-                        error = ENXIO;
+                        error = -ENXIO;
                         goto out_unlock;
                 }
 
@@ -1370,7 +1385,7 @@ out_unlock:
         xfs_iunlock(ip, lock);
 
         if (error)
-                return -error;
+                return error;
         return offset;
 }
 
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index 8ec81bed7992..e92730c1d3ca 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -258,7 +258,7 @@ next_ag:
         if (*agp == NULLAGNUMBER)
                 return 0;
 
-        err = ENOMEM;
+        err = -ENOMEM;
         item = kmem_alloc(sizeof(*item), KM_MAYFAIL);
         if (!item)
                 goto out_put_ag;
@@ -268,7 +268,7 @@ next_ag:
 
         err = xfs_mru_cache_insert(mp->m_filestream, ip->i_ino, &item->mru);
         if (err) {
-                if (err == EEXIST)
+                if (err == -EEXIST)
                         err = 0;
                 goto out_free_item;
         }
diff --git a/fs/xfs/xfs_fs.h b/fs/xfs/xfs_fs.h
index d34703dbcb42..18dc721ca19f 100644
--- a/fs/xfs/xfs_fs.h
+++ b/fs/xfs/xfs_fs.h
@@ -255,8 +255,8 @@ typedef struct xfs_fsop_resblks {
         ((2 * 1024 * 1024 * 1024ULL) - XFS_MIN_LOG_BYTES)
 
 /* Used for sanity checks on superblock */
-#define XFS_MAX_DBLOCKS(s) ((xfs_drfsbno_t)(s)->sb_agcount * (s)->sb_agblocks)
-#define XFS_MIN_DBLOCKS(s) ((xfs_drfsbno_t)((s)->sb_agcount - 1) *      \
+#define XFS_MAX_DBLOCKS(s) ((xfs_rfsblock_t)(s)->sb_agcount * (s)->sb_agblocks)
+#define XFS_MIN_DBLOCKS(s) ((xfs_rfsblock_t)((s)->sb_agcount - 1) *     \
                          (s)->sb_agblocks + XFS_MIN_AG_BLOCKS)
 
 /*
@@ -375,6 +375,9 @@ struct xfs_fs_eofblocks {
 #define XFS_EOF_FLAGS_GID               (1 << 2) /* filter by gid */
 #define XFS_EOF_FLAGS_PRID              (1 << 3) /* filter by project id */
 #define XFS_EOF_FLAGS_MINFILESIZE       (1 << 4) /* filter by min file size */
+#define XFS_EOF_FLAGS_UNION             (1 << 5) /* union filter algorithm;
+                                                  * kernel only, not included in
+                                                  * valid mask */
 #define XFS_EOF_FLAGS_VALID     \
         (XFS_EOF_FLAGS_SYNC |   \
          XFS_EOF_FLAGS_UID |    \
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index d2295561570a..f91de1ef05e1 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -168,7 +168,7 @@ xfs_growfs_data_private(
         nb = in->newblocks;
         pct = in->imaxpct;
         if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
                 return error;
         dpct = pct - mp->m_sb.sb_imax_pct;
@@ -176,7 +176,7 @@ xfs_growfs_data_private(
                                 XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
                                 XFS_FSS_TO_BB(mp, 1), 0, NULL);
         if (!bp)
-                return EIO;
+                return -EIO;
         if (bp->b_error) {
                 error = bp->b_error;
                 xfs_buf_relse(bp);
@@ -191,7 +191,7 @@ xfs_growfs_data_private(
                 nagcount--;
                 nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
                 if (nb < mp->m_sb.sb_dblocks)
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
         }
         new = nb - mp->m_sb.sb_dblocks;
         oagcount = mp->m_sb.sb_agcount;
@@ -229,7 +229,7 @@ xfs_growfs_data_private(
                                 XFS_FSS_TO_BB(mp, 1), 0,
                                 &xfs_agf_buf_ops);
                 if (!bp) {
-                        error = ENOMEM;
+                        error = -ENOMEM;
                         goto error0;
                 }
 
@@ -270,7 +270,7 @@ xfs_growfs_data_private(
                                 XFS_FSS_TO_BB(mp, 1), 0,
                                 &xfs_agfl_buf_ops);
                 if (!bp) {
-                        error = ENOMEM;
+                        error = -ENOMEM;
                         goto error0;
                 }
 
@@ -298,7 +298,7 @@ xfs_growfs_data_private(
                                 XFS_FSS_TO_BB(mp, 1), 0,
                                 &xfs_agi_buf_ops);
                 if (!bp) {
-                        error = ENOMEM;
+                        error = -ENOMEM;
                         goto error0;
                 }
 
@@ -336,7 +336,7 @@ xfs_growfs_data_private(
                                 &xfs_allocbt_buf_ops);
 
                 if (!bp) {
-                        error = ENOMEM;
+                        error = -ENOMEM;
                         goto error0;
                 }
 
@@ -365,7 +365,7 @@ xfs_growfs_data_private(
                                 BTOBB(mp->m_sb.sb_blocksize), 0,
                                 &xfs_allocbt_buf_ops);
                 if (!bp) {
-                        error = ENOMEM;
+                        error = -ENOMEM;
                         goto error0;
                 }
 
@@ -395,7 +395,7 @@ xfs_growfs_data_private(
                                 BTOBB(mp->m_sb.sb_blocksize), 0,
                                 &xfs_inobt_buf_ops);
                 if (!bp) {
-                        error = ENOMEM;
+                        error = -ENOMEM;
                         goto error0;
                 }
 
@@ -420,7 +420,7 @@ xfs_growfs_data_private(
                                 BTOBB(mp->m_sb.sb_blocksize), 0,
                                 &xfs_inobt_buf_ops);
                         if (!bp) {
-                                error = ENOMEM;
+                                error = -ENOMEM;
                                 goto error0;
                         }
 
@@ -531,7 +531,7 @@ xfs_growfs_data_private(
                                 bp->b_ops = &xfs_sb_buf_ops;
                                 xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
                         } else
-                                error = ENOMEM;
+                                error = -ENOMEM;
                 }
 
                 /*
@@ -576,17 +576,17 @@ xfs_growfs_log_private(
 
         nb = in->newblocks;
         if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         if (nb == mp->m_sb.sb_logblocks &&
             in->isint == (mp->m_sb.sb_logstart != 0))
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         /*
          * Moving the log is hard, need new interfaces to sync
          * the log first, hold off all activity while moving it.
          * Can have shorter or longer log in the same space,
          * or transform internal to external log or vice versa.
          */
-        return XFS_ERROR(ENOSYS);
+        return -ENOSYS;
 }
 
 /*
@@ -604,9 +604,9 @@ xfs_growfs_data(
         int error;
 
         if (!capable(CAP_SYS_ADMIN))
-                return XFS_ERROR(EPERM);
+                return -EPERM;
         if (!mutex_trylock(&mp->m_growlock))
-                return XFS_ERROR(EWOULDBLOCK);
+                return -EWOULDBLOCK;
         error = xfs_growfs_data_private(mp, in);
         mutex_unlock(&mp->m_growlock);
         return error;
@@ -620,9 +620,9 @@ xfs_growfs_log(
         int error;
 
         if (!capable(CAP_SYS_ADMIN))
-                return XFS_ERROR(EPERM);
+                return -EPERM;
         if (!mutex_trylock(&mp->m_growlock))
-                return XFS_ERROR(EWOULDBLOCK);
+                return -EWOULDBLOCK;
         error = xfs_growfs_log_private(mp, in);
         mutex_unlock(&mp->m_growlock);
         return error;
@@ -674,7 +674,7 @@ xfs_reserve_blocks(
         /* If inval is null, report current values and return */
         if (inval == (__uint64_t *)NULL) {
                 if (!outval)
-                        return EINVAL;
+                        return -EINVAL;
                 outval->resblks = mp->m_resblks;
                 outval->resblks_avail = mp->m_resblks_avail;
                 return 0;
@@ -757,7 +757,7 @@ out:
                 int error;
                 error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
                                                  fdblks_delta, 0);
-                if (error == ENOSPC)
+                if (error == -ENOSPC)
                         goto retry;
         }
         return 0;
@@ -818,7 +818,7 @@ xfs_fs_goingdown(
                                 SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
                 break;
         default:
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         return 0;
diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index c48df5f25b9f..981b2cf51985 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -33,6 +33,9 @@
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_bmap_util.h"
+#include "xfs_quota.h"
+#include "xfs_dquot_item.h"
+#include "xfs_dquot.h"
 
 #include <linux/kthread.h>
 #include <linux/freezer.h>
@@ -158,7 +161,7 @@ xfs_iget_cache_hit(
         if (ip->i_ino != ino) {
                 trace_xfs_iget_skip(ip);
                 XFS_STATS_INC(xs_ig_frecycle);
-                error = EAGAIN;
+                error = -EAGAIN;
                 goto out_error;
         }
 
@@ -176,7 +179,7 @@ xfs_iget_cache_hit(
         if (ip->i_flags & (XFS_INEW|XFS_IRECLAIM)) {
                 trace_xfs_iget_skip(ip);
                 XFS_STATS_INC(xs_ig_frecycle);
-                error = EAGAIN;
+                error = -EAGAIN;
                 goto out_error;
         }
 
@@ -184,7 +187,7 @@ xfs_iget_cache_hit(
          * If lookup is racing with unlink return an error immediately.
          */
         if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
-                error = ENOENT;
+                error = -ENOENT;
                 goto out_error;
         }
 
@@ -206,7 +209,7 @@ xfs_iget_cache_hit(
                 spin_unlock(&ip->i_flags_lock);
                 rcu_read_unlock();
 
-                error = -inode_init_always(mp->m_super, inode);
+                error = inode_init_always(mp->m_super, inode);
                 if (error) {
                         /*
                          * Re-initializing the inode failed, and we are in deep
@@ -243,7 +246,7 @@ xfs_iget_cache_hit(
                 /* If the VFS inode is being torn down, pause and try again. */
                 if (!igrab(inode)) {
                         trace_xfs_iget_skip(ip);
-                        error = EAGAIN;
+                        error = -EAGAIN;
                         goto out_error;
                 }
 
@@ -285,7 +288,7 @@ xfs_iget_cache_miss(
 
         ip = xfs_inode_alloc(mp, ino);
         if (!ip)
-                return ENOMEM;
+                return -ENOMEM;
 
         error = xfs_iread(mp, tp, ip, flags);
         if (error)
@@ -294,7 +297,7 @@ xfs_iget_cache_miss(
         trace_xfs_iget_miss(ip);
 
         if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
-                error = ENOENT;
+                error = -ENOENT;
                 goto out_destroy;
         }
 
@@ -305,7 +308,7 @@ xfs_iget_cache_miss(
          * recurse into the file system.
          */
         if (radix_tree_preload(GFP_NOFS)) {
-                error = EAGAIN;
+                error = -EAGAIN;
                 goto out_destroy;
         }
 
@@ -341,7 +344,7 @@ xfs_iget_cache_miss(
         if (unlikely(error)) {
                 WARN_ON(error != -EEXIST);
                 XFS_STATS_INC(xs_ig_dup);
-                error = EAGAIN;
+                error = -EAGAIN;
                 goto out_preload_end;
         }
         spin_unlock(&pag->pag_ici_lock);
@@ -408,7 +411,7 @@ xfs_iget(
 
         /* reject inode numbers outside existing AGs */
         if (!ino || XFS_INO_TO_AGNO(mp, ino) >= mp->m_sb.sb_agcount)
-                return EINVAL;
+                return -EINVAL;
 
         /* get the perag structure and ensure that it's inode capable */
         pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ino));
@@ -445,7 +448,7 @@ again:
         return 0;
 
 out_error_or_again:
-        if (error == EAGAIN) {
+        if (error == -EAGAIN) {
                 delay(1);
                 goto again;
         }
@@ -489,18 +492,18 @@ xfs_inode_ag_walk_grab(
 
         /* nothing to sync during shutdown */
         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
-                return EFSCORRUPTED;
+                return -EFSCORRUPTED;
 
         /* If we can't grab the inode, it must on it's way to reclaim. */
         if (!igrab(inode))
-                return ENOENT;
+                return -ENOENT;
 
         /* inode is valid */
         return 0;
 
 out_unlock_noent:
         spin_unlock(&ip->i_flags_lock);
-        return ENOENT;
+        return -ENOENT;
 }
 
 STATIC int
@@ -583,16 +586,16 @@ restart:
                                 continue;
                         error = execute(batch[i], flags, args);
                         IRELE(batch[i]);
-                        if (error == EAGAIN) {
+                        if (error == -EAGAIN) {
                                 skipped++;
                                 continue;
                         }
-                        if (error && last_error != EFSCORRUPTED)
+                        if (error && last_error != -EFSCORRUPTED)
                                 last_error = error;
                 }
 
                 /* bail out if the filesystem is corrupted.  */
-                if (error == EFSCORRUPTED)
+                if (error == -EFSCORRUPTED)
                         break;
 
                 cond_resched();
@@ -652,11 +655,11 @@ xfs_inode_ag_iterator(
                 xfs_perag_put(pag);
                 if (error) {
                         last_error = error;
-                        if (error == EFSCORRUPTED)
+                        if (error == -EFSCORRUPTED)
                                 break;
                 }
         }
-        return XFS_ERROR(last_error);
+        return last_error;
 }
 
 int
@@ -680,11 +683,11 @@ xfs_inode_ag_iterator_tag(
                 xfs_perag_put(pag);
                 if (error) {
                         last_error = error;
-                        if (error == EFSCORRUPTED)
+                        if (error == -EFSCORRUPTED)
                                 break;
                 }
         }
-        return XFS_ERROR(last_error);
+        return last_error;
 }
 
 /*
@@ -944,7 +947,7 @@ restart:
          * see the stale flag set on the inode.
          */
         error = xfs_iflush(ip, &bp);
-        if (error == EAGAIN) {
+        if (error == -EAGAIN) {
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
                 /* backoff longer than in xfs_ifree_cluster */
                 delay(2);
@@ -997,7 +1000,7 @@ out:
         xfs_iflags_clear(ip, XFS_IRECLAIM);
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
         /*
-         * We could return EAGAIN here to make reclaim rescan the inode tree in
+         * We could return -EAGAIN here to make reclaim rescan the inode tree in
          * a short while. However, this just burns CPU time scanning the tree
          * waiting for IO to complete and the reclaim work never goes back to
          * the idle state. Instead, return 0 to let the next scheduled
@@ -1100,7 +1103,7 @@ restart:
                                 if (!batch[i])
                                         continue;
                                 error = xfs_reclaim_inode(batch[i], pag, flags);
-                                if (error && last_error != EFSCORRUPTED)
+                                if (error && last_error != -EFSCORRUPTED)
                                         last_error = error;
                         }
 
@@ -1129,7 +1132,7 @@ restart:
                 trylock = 0;
                 goto restart;
         }
-        return XFS_ERROR(last_error);
+        return last_error;
 }
 
 int
@@ -1203,6 +1206,30 @@ xfs_inode_match_id(
         return 1;
 }
 
+/*
+ * A union-based inode filtering algorithm. Process the inode if any of the
+ * criteria match. This is for global/internal scans only.
+ */
+STATIC int
+xfs_inode_match_id_union(
+        struct xfs_inode        *ip,
+        struct xfs_eofblocks    *eofb)
+{
+        if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
+            uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
+                return 1;
+
+        if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
+            gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
+                return 1;
+
+        if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
+            xfs_get_projid(ip) == eofb->eof_prid)
+                return 1;
+
+        return 0;
+}
+
 STATIC int
 xfs_inode_free_eofblocks(
         struct xfs_inode        *ip,
@@ -1211,6 +1238,10 @@ xfs_inode_free_eofblocks(
 {
         int ret;
         struct xfs_eofblocks *eofb = args;
+        bool need_iolock = true;
+        int match;
+
+        ASSERT(!eofb || (eofb && eofb->eof_scan_owner != 0));
 
         if (!xfs_can_free_eofblocks(ip, false)) {
                 /* inode could be preallocated or append-only */
@@ -1228,19 +1259,31 @@ xfs_inode_free_eofblocks(
                 return 0;
 
         if (eofb) {
-                if (!xfs_inode_match_id(ip, eofb))
+                if (eofb->eof_flags & XFS_EOF_FLAGS_UNION)
+                        match = xfs_inode_match_id_union(ip, eofb);
+                else
+                        match = xfs_inode_match_id(ip, eofb);
+                if (!match)
                         return 0;
 
                 /* skip the inode if the file size is too small */
                 if (eofb->eof_flags & XFS_EOF_FLAGS_MINFILESIZE &&
                     XFS_ISIZE(ip) < eofb->eof_min_file_size)
                         return 0;
+
+                /*
+                 * A scan owner implies we already hold the iolock. Skip it in
+                 * xfs_free_eofblocks() to avoid deadlock. This also eliminates
+                 * the possibility of EAGAIN being returned.
+                 */
+                if (eofb->eof_scan_owner == ip->i_ino)
+                        need_iolock = false;
         }
 
-        ret = xfs_free_eofblocks(ip->i_mount, ip, true);
+        ret = xfs_free_eofblocks(ip->i_mount, ip, need_iolock);
 
         /* don't revisit the inode if we're not waiting */
-        if (ret == EAGAIN && !(flags & SYNC_WAIT))
+        if (ret == -EAGAIN && !(flags & SYNC_WAIT))
                 ret = 0;
 
         return ret;
@@ -1260,6 +1303,55 @@ xfs_icache_free_eofblocks(
                                          eofb, XFS_ICI_EOFBLOCKS_TAG);
 }
 
+/*
+ * Run eofblocks scans on the quotas applicable to the inode. For inodes with
+ * multiple quotas, we don't know exactly which quota caused an allocation
+ * failure. We make a best effort by including each quota under low free space
+ * conditions (less than 1% free space) in the scan.
+ */
+int
+xfs_inode_free_quota_eofblocks(
+        struct xfs_inode *ip)
+{
+        int scan = 0;
+        struct xfs_eofblocks eofb = {0};
+        struct xfs_dquot *dq;
+
+        ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
+
+        /*
+         * Set the scan owner to avoid a potential livelock. Otherwise, the scan
+         * can repeatedly trylock on the inode we're currently processing. We
+         * run a sync scan to increase effectiveness and use the union filter to
+         * cover all applicable quotas in a single scan.
+         */
+        eofb.eof_scan_owner = ip->i_ino;
+        eofb.eof_flags = XFS_EOF_FLAGS_UNION|XFS_EOF_FLAGS_SYNC;
+
+        if (XFS_IS_UQUOTA_ENFORCED(ip->i_mount)) {
+                dq = xfs_inode_dquot(ip, XFS_DQ_USER);
+                if (dq && xfs_dquot_lowsp(dq)) {
+                        eofb.eof_uid = VFS_I(ip)->i_uid;
+                        eofb.eof_flags |= XFS_EOF_FLAGS_UID;
+                        scan = 1;
+                }
+        }
+
+        if (XFS_IS_GQUOTA_ENFORCED(ip->i_mount)) {
+                dq = xfs_inode_dquot(ip, XFS_DQ_GROUP);
+                if (dq && xfs_dquot_lowsp(dq)) {
+                        eofb.eof_gid = VFS_I(ip)->i_gid;
+                        eofb.eof_flags |= XFS_EOF_FLAGS_GID;
+                        scan = 1;
+                }
+        }
+
+        if (scan)
+                xfs_icache_free_eofblocks(ip->i_mount, &eofb);
+
+        return scan;
+}
+
 void
 xfs_inode_set_eofblocks_tag(
         xfs_inode_t     *ip)
diff --git a/fs/xfs/xfs_icache.h b/fs/xfs/xfs_icache.h
index 9cf017b899be..46748b86b12f 100644
--- a/fs/xfs/xfs_icache.h
+++ b/fs/xfs/xfs_icache.h
@@ -27,6 +27,7 @@ struct xfs_eofblocks {
         kgid_t          eof_gid;
         prid_t          eof_prid;
         __u64           eof_min_file_size;
+        xfs_ino_t       eof_scan_owner;
 };
 
 #define SYNC_WAIT               0x0001  /* wait for i/o to complete */
@@ -57,6 +58,7 @@ void xfs_inode_set_reclaim_tag(struct xfs_inode *ip);
 void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip);
 void xfs_inode_clear_eofblocks_tag(struct xfs_inode *ip);
 int xfs_icache_free_eofblocks(struct xfs_mount *, struct xfs_eofblocks *);
+int xfs_inode_free_quota_eofblocks(struct xfs_inode *ip);
 void xfs_eofblocks_worker(struct work_struct *);
 
 int xfs_inode_ag_iterator(struct xfs_mount *mp,
@@ -72,31 +74,32 @@ xfs_fs_eofblocks_from_user(
         struct xfs_eofblocks            *dst)
 {
         if (src->eof_version != XFS_EOFBLOCKS_VERSION)
-                return EINVAL;
+                return -EINVAL;
 
         if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
-                return EINVAL;
+                return -EINVAL;
 
         if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
             memchr_inv(src->pad64, 0, sizeof(src->pad64)))
-                return EINVAL;
+                return -EINVAL;
 
         dst->eof_flags = src->eof_flags;
         dst->eof_prid = src->eof_prid;
         dst->eof_min_file_size = src->eof_min_file_size;
+        dst->eof_scan_owner = NULLFSINO;
 
         dst->eof_uid = INVALID_UID;
         if (src->eof_flags & XFS_EOF_FLAGS_UID) {
                 dst->eof_uid = make_kuid(current_user_ns(), src->eof_uid);
                 if (!uid_valid(dst->eof_uid))
-                        return EINVAL;
+                        return -EINVAL;
         }
 
         dst->eof_gid = INVALID_GID;
         if (src->eof_flags & XFS_EOF_FLAGS_GID) {
                 dst->eof_gid = make_kgid(current_user_ns(), src->eof_gid);
                 if (!gid_valid(dst->eof_gid))
-                        return EINVAL;
+                        return -EINVAL;
         }
         return 0;
 }
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index a6115fe1ac94..fea3c92fb3f0 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -583,7 +583,7 @@ xfs_lookup(
         trace_xfs_lookup(dp, name);
 
         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         lock_mode = xfs_ilock_data_map_shared(dp);
         error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
@@ -893,7 +893,7 @@ xfs_dir_ialloc(
         }
         if (!ialloc_context && !ip) {
                 *ipp = NULL;
-                return XFS_ERROR(ENOSPC);
+                return -ENOSPC;
         }
 
         /*
@@ -1088,7 +1088,7 @@ xfs_create(
         trace_xfs_create(dp, name);
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         prid = xfs_get_initial_prid(dp);
 
@@ -1125,12 +1125,12 @@ xfs_create(
          */
         tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
         error = xfs_trans_reserve(tp, &tres, resblks, 0);
-        if (error == ENOSPC) {
+        if (error == -ENOSPC) {
                 /* flush outstanding delalloc blocks and retry */
                 xfs_flush_inodes(mp);
                 error = xfs_trans_reserve(tp, &tres, resblks, 0);
         }
-        if (error == ENOSPC) {
+        if (error == -ENOSPC) {
                 /* No space at all so try a "no-allocation" reservation */
                 resblks = 0;
                 error = xfs_trans_reserve(tp, &tres, 0, 0);
@@ -1165,7 +1165,7 @@ xfs_create(
         error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
                                prid, resblks > 0, &ip, &committed);
         if (error) {
-                if (error == ENOSPC)
+                if (error == -ENOSPC)
                         goto out_trans_cancel;
                 goto out_trans_abort;
         }
@@ -1184,7 +1184,7 @@ xfs_create(
                                         &first_block, &free_list, resblks ?
                                         resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
         if (error) {
-                ASSERT(error != ENOSPC);
+                ASSERT(error != -ENOSPC);
                 goto out_trans_abort;
         }
         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
@@ -1274,7 +1274,7 @@ xfs_create_tmpfile(
         uint                    resblks;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         prid = xfs_get_initial_prid(dp);
 
@@ -1293,7 +1293,7 @@ xfs_create_tmpfile(
 
         tres = &M_RES(mp)->tr_create_tmpfile;
         error = xfs_trans_reserve(tp, tres, resblks, 0);
-        if (error == ENOSPC) {
+        if (error == -ENOSPC) {
                 /* No space at all so try a "no-allocation" reservation */
                 resblks = 0;
                 error = xfs_trans_reserve(tp, tres, 0, 0);
@@ -1311,7 +1311,7 @@ xfs_create_tmpfile(
         error = xfs_dir_ialloc(&tp, dp, mode, 1, 0,
                                 prid, resblks > 0, &ip, NULL);
         if (error) {
-                if (error == ENOSPC)
+                if (error == -ENOSPC)
                         goto out_trans_cancel;
                 goto out_trans_abort;
         }
@@ -1382,7 +1382,7 @@ xfs_link(
         ASSERT(!S_ISDIR(sip->i_d.di_mode));
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         error = xfs_qm_dqattach(sip, 0);
         if (error)
@@ -1396,7 +1396,7 @@ xfs_link(
         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
         resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_link, resblks, 0);
-        if (error == ENOSPC) {
+        if (error == -ENOSPC) {
                 resblks = 0;
                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_link, 0, 0);
         }
@@ -1417,7 +1417,7 @@ xfs_link(
          */
         if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
                      (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
-                error = XFS_ERROR(EXDEV);
+                error = -EXDEV;
                 goto error_return;
         }
 
@@ -1635,8 +1635,8 @@ xfs_release(
                 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
                 if (truncated) {
                         xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
-                        if (VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0) {
-                                error = -filemap_flush(VFS_I(ip)->i_mapping);
+                        if (ip->i_delayed_blks > 0) {
+                                error = filemap_flush(VFS_I(ip)->i_mapping);
                                 if (error)
                                         return error;
                         }
@@ -1673,7 +1673,7 @@ xfs_release(
                         return 0;
 
                 error = xfs_free_eofblocks(mp, ip, true);
-                if (error && error != EAGAIN)
+                if (error && error != -EAGAIN)
                         return error;
 
                 /* delalloc blocks after truncation means it really is dirty */
@@ -1772,7 +1772,7 @@ xfs_inactive_ifree(
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ifree,
                                   XFS_IFREE_SPACE_RES(mp), 0);
         if (error) {
-                if (error == ENOSPC) {
+                if (error == -ENOSPC) {
                         xfs_warn_ratelimited(mp,
                         "Failed to remove inode(s) from unlinked list. "
                         "Please free space, unmount and run xfs_repair.");
@@ -2219,7 +2219,7 @@ xfs_ifree_cluster(
                                         XBF_UNMAPPED);
 
                 if (!bp)
-                        return ENOMEM;
+                        return -ENOMEM;
 
                 /*
                  * This buffer may not have been correctly initialised as we
@@ -2491,7 +2491,7 @@ xfs_remove(
         trace_xfs_remove(dp, name);
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         error = xfs_qm_dqattach(dp, 0);
         if (error)
@@ -2521,12 +2521,12 @@ xfs_remove(
          */
         resblks = XFS_REMOVE_SPACE_RES(mp);
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_remove, resblks, 0);
-        if (error == ENOSPC) {
+        if (error == -ENOSPC) {
                 resblks = 0;
                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_remove, 0, 0);
         }
         if (error) {
-                ASSERT(error != ENOSPC);
+                ASSERT(error != -ENOSPC);
                 cancel_flags = 0;
                 goto out_trans_cancel;
         }
@@ -2543,11 +2543,11 @@ xfs_remove(
         if (is_dir) {
                 ASSERT(ip->i_d.di_nlink >= 2);
                 if (ip->i_d.di_nlink != 2) {
-                        error = XFS_ERROR(ENOTEMPTY);
+                        error = -ENOTEMPTY;
                         goto out_trans_cancel;
                 }
                 if (!xfs_dir_isempty(ip)) {
-                        error = XFS_ERROR(ENOTEMPTY);
+                        error = -ENOTEMPTY;
                         goto out_trans_cancel;
                 }
 
@@ -2582,7 +2582,7 @@ xfs_remove(
         error = xfs_dir_removename(tp, dp, name, ip->i_ino,
                                         &first_block, &free_list, resblks);
         if (error) {
-                ASSERT(error != ENOENT);
+                ASSERT(error != -ENOENT);
                 goto out_bmap_cancel;
         }
 
@@ -2702,7 +2702,7 @@ xfs_rename(
         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
         spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_rename, spaceres, 0);
-        if (error == ENOSPC) {
+        if (error == -ENOSPC) {
                 spaceres = 0;
                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_rename, 0, 0);
         }
@@ -2747,7 +2747,7 @@ xfs_rename(
          */
         if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
                      (xfs_get_projid(target_dp) != xfs_get_projid(src_ip)))) {
-                error = XFS_ERROR(EXDEV);
+                error = -EXDEV;
                 goto error_return;
         }
 
@@ -2770,7 +2770,7 @@ xfs_rename(
                 error = xfs_dir_createname(tp, target_dp, target_name,
                                                 src_ip->i_ino, &first_block,
                                                 &free_list, spaceres);
-                if (error == ENOSPC)
+                if (error == -ENOSPC)
                         goto error_return;
                 if (error)
                         goto abort_return;
@@ -2795,7 +2795,7 @@ xfs_rename(
                          */
                         if (!(xfs_dir_isempty(target_ip)) ||
                             (target_ip->i_d.di_nlink > 2)) {
-                                error = XFS_ERROR(EEXIST);
+                                error = -EEXIST;
                                 goto error_return;
                         }
                 }
@@ -2847,7 +2847,7 @@ xfs_rename(
                 error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
                                         target_dp->i_ino,
                                         &first_block, &free_list, spaceres);
-                ASSERT(error != EEXIST);
+                ASSERT(error != -EEXIST);
                 if (error)
                         goto abort_return;
         }
@@ -3055,7 +3055,7 @@ cluster_corrupt_out:
                 if (bp->b_iodone) {
                         XFS_BUF_UNDONE(bp);
                         xfs_buf_stale(bp);
-                        xfs_buf_ioerror(bp, EIO);
+                        xfs_buf_ioerror(bp, -EIO);
                         xfs_buf_ioend(bp, 0);
                 } else {
                         xfs_buf_stale(bp);
@@ -3069,7 +3069,7 @@ cluster_corrupt_out:
         xfs_iflush_abort(iq, false);
         kmem_free(ilist);
         xfs_perag_put(pag);
-        return XFS_ERROR(EFSCORRUPTED);
+        return -EFSCORRUPTED;
 }
 
 /*
@@ -3124,7 +3124,7 @@ xfs_iflush(
          * as we wait for an empty AIL as part of the unmount process.
          */
         if (XFS_FORCED_SHUTDOWN(mp)) {
-                error = XFS_ERROR(EIO);
+                error = -EIO;
                 goto abort_out;
         }
 
@@ -3167,7 +3167,7 @@ corrupt_out:
         xfs_buf_relse(bp);
         xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 cluster_corrupt_out:
-        error = XFS_ERROR(EFSCORRUPTED);
+        error = -EFSCORRUPTED;
 abort_out:
         /*
          * Unlocks the flush lock
@@ -3331,5 +3331,5 @@ xfs_iflush_int(
         return 0;
 
 corrupt_out:
-        return XFS_ERROR(EFSCORRUPTED);
+        return -EFSCORRUPTED;
 }
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index f72bffa67266..c10e3fadd9af 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -398,4 +398,14 @@ do { \
 
 extern struct kmem_zone *xfs_inode_zone;
 
+/*
+ * Flags for read/write calls
+ */
+#define XFS_IO_ISDIRECT 0x00001         /* bypass page cache */
+#define XFS_IO_INVIS    0x00002         /* don't update inode timestamps */
+
+#define XFS_IO_FLAGS \
+        { XFS_IO_ISDIRECT,      "DIRECT" }, \
+        { XFS_IO_INVIS,         "INVIS"}
+
 #endif  /* __XFS_INODE_H__ */
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index a640137b3573..de5a7be36e60 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -788,5 +788,5 @@ xfs_inode_item_format_convert(
                 in_f->ilf_boffset = in_f64->ilf_boffset;
                 return 0;
         }
-        return EFSCORRUPTED;
+        return -EFSCORRUPTED;
 }
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 8bc1bbce7451..3799695b9249 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -207,7 +207,7 @@ xfs_open_by_handle(
         struct path             path;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
 
         dentry = xfs_handlereq_to_dentry(parfilp, hreq);
         if (IS_ERR(dentry))
@@ -216,7 +216,7 @@ xfs_open_by_handle(
 
         /* Restrict xfs_open_by_handle to directories & regular files. */
         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
-                error = -XFS_ERROR(EPERM);
+                error = -EPERM;
                 goto out_dput;
         }
 
@@ -228,18 +228,18 @@ xfs_open_by_handle(
         fmode = OPEN_FMODE(permflag);
         if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
             (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
-                error = -XFS_ERROR(EPERM);
+                error = -EPERM;
                 goto out_dput;
         }
 
         if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
-                error = -XFS_ERROR(EACCES);
+                error = -EACCES;
                 goto out_dput;
         }
 
         /* Can't write directories. */
         if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
-                error = -XFS_ERROR(EISDIR);
+                error = -EISDIR;
                 goto out_dput;
         }
 
@@ -282,7 +282,7 @@ xfs_readlink_by_handle(
         int                     error;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
 
         dentry = xfs_handlereq_to_dentry(parfilp, hreq);
         if (IS_ERR(dentry))
@@ -290,22 +290,22 @@ xfs_readlink_by_handle(
 
         /* Restrict this handle operation to symlinks only. */
         if (!S_ISLNK(dentry->d_inode->i_mode)) {
-                error = -XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_dput;
         }
 
         if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
-                error = -XFS_ERROR(EFAULT);
+                error = -EFAULT;
                 goto out_dput;
         }
 
         link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
         if (!link) {
-                error = -XFS_ERROR(ENOMEM);
+                error = -ENOMEM;
                 goto out_dput;
         }
 
-        error = -xfs_readlink(XFS_I(dentry->d_inode), link);
+        error = xfs_readlink(XFS_I(dentry->d_inode), link);
         if (error)
                 goto out_kfree;
         error = readlink_copy(hreq->ohandle, olen, link);
@@ -330,10 +330,10 @@ xfs_set_dmattrs(
         int             error;
 
         if (!capable(CAP_SYS_ADMIN))
-                return XFS_ERROR(EPERM);
+                return -EPERM;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
@@ -364,9 +364,9 @@ xfs_fssetdm_by_handle(
         struct dentry           *dentry;
 
         if (!capable(CAP_MKNOD))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
         if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         error = mnt_want_write_file(parfilp);
         if (error)
@@ -379,16 +379,16 @@ xfs_fssetdm_by_handle(
         }
 
         if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
-                error = -XFS_ERROR(EPERM);
+                error = -EPERM;
                 goto out;
         }
 
         if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
-                error = -XFS_ERROR(EFAULT);
+                error = -EFAULT;
                 goto out;
         }
 
-        error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
+        error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
                                  fsd.fsd_dmstate);
 
  out:
@@ -409,18 +409,18 @@ xfs_attrlist_by_handle(
         char                    *kbuf;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
         if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         if (al_hreq.buflen < sizeof(struct attrlist) ||
             al_hreq.buflen > XATTR_LIST_MAX)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         /*
          * Reject flags, only allow namespaces.
          */
         if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
         if (IS_ERR(dentry))
@@ -431,7 +431,7 @@ xfs_attrlist_by_handle(
                 goto out_dput;
 
         cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-        error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
+        error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
                                         al_hreq.flags, cursor);
         if (error)
                 goto out_kfree;
@@ -455,20 +455,20 @@ xfs_attrmulti_attr_get(
         __uint32_t              flags)
 {
         unsigned char           *kbuf;
-        int                     error = EFAULT;
+        int                     error = -EFAULT;
 
         if (*len > XATTR_SIZE_MAX)
-                return EINVAL;
+                return -EINVAL;
         kbuf = kmem_zalloc_large(*len, KM_SLEEP);
         if (!kbuf)
-                return ENOMEM;
+                return -ENOMEM;
 
         error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
         if (error)
                 goto out_kfree;
 
         if (copy_to_user(ubuf, kbuf, *len))
-                error = EFAULT;
+                error = -EFAULT;
 
 out_kfree:
         kmem_free(kbuf);
@@ -484,20 +484,17 @@ xfs_attrmulti_attr_set(
         __uint32_t              flags)
 {
         unsigned char           *kbuf;
-        int                     error = EFAULT;
 
         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
-                return EPERM;
+                return -EPERM;
         if (len > XATTR_SIZE_MAX)
-                return EINVAL;
+                return -EINVAL;
 
         kbuf = memdup_user(ubuf, len);
         if (IS_ERR(kbuf))
                 return PTR_ERR(kbuf);
 
-        error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
-
-        return error;
+        return xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
 }
 
 int
@@ -507,7 +504,7 @@ xfs_attrmulti_attr_remove(
         __uint32_t              flags)
 {
         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
-                return EPERM;
+                return -EPERM;
         return xfs_attr_remove(XFS_I(inode), name, flags);
 }
 
@@ -524,9 +521,9 @@ xfs_attrmulti_by_handle(
         unsigned char           *attr_name;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
         if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         /* overflow check */
         if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
@@ -536,18 +533,18 @@ xfs_attrmulti_by_handle(
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
-        error = E2BIG;
+        error = -E2BIG;
         size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
         if (!size || size > 16 * PAGE_SIZE)
                 goto out_dput;
 
         ops = memdup_user(am_hreq.ops, size);
         if (IS_ERR(ops)) {
-                error = -PTR_ERR(ops);
+                error = PTR_ERR(ops);
                 goto out_dput;
         }
 
-        error = ENOMEM;
+        error = -ENOMEM;
         attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
         if (!attr_name)
                 goto out_kfree_ops;
@@ -557,7 +554,7 @@ xfs_attrmulti_by_handle(
                 ops[i].am_error = strncpy_from_user((char *)attr_name,
                                 ops[i].am_attrname, MAXNAMELEN);
                 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
-                        error = ERANGE;
+                        error = -ERANGE;
                 if (ops[i].am_error < 0)
                         break;
 
@@ -588,19 +585,19 @@ xfs_attrmulti_by_handle(
                         mnt_drop_write_file(parfilp);
                         break;
                 default:
-                        ops[i].am_error = EINVAL;
+                        ops[i].am_error = -EINVAL;
                 }
         }
 
         if (copy_to_user(am_hreq.ops, ops, size))
-                error = XFS_ERROR(EFAULT);
+                error = -EFAULT;
 
         kfree(attr_name);
  out_kfree_ops:
         kfree(ops);
  out_dput:
         dput(dentry);
-        return -error;
+        return error;
 }
 
 int
@@ -625,16 +622,16 @@ xfs_ioc_space(
          */
         if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
             !capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
 
         if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
 
         if (!(filp->f_mode & FMODE_WRITE))
-                return -XFS_ERROR(EBADF);
+                return -EBADF;
 
         if (!S_ISREG(inode->i_mode))
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         error = mnt_want_write_file(filp);
         if (error)
@@ -652,7 +649,7 @@ xfs_ioc_space(
                 bf->l_start += XFS_ISIZE(ip);
                 break;
         default:
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_unlock;
         }
 
@@ -669,7 +666,7 @@ xfs_ioc_space(
         case XFS_IOC_UNRESVSP:
         case XFS_IOC_UNRESVSP64:
                 if (bf->l_len <= 0) {
-                        error = XFS_ERROR(EINVAL);
+                        error = -EINVAL;
                         goto out_unlock;
                 }
                 break;
@@ -682,7 +679,7 @@ xfs_ioc_space(
             bf->l_start > mp->m_super->s_maxbytes ||
             bf->l_start + bf->l_len < 0 ||
             bf->l_start + bf->l_len >= mp->m_super->s_maxbytes) {
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_unlock;
         }
 
@@ -723,7 +720,7 @@ xfs_ioc_space(
                 break;
         default:
                 ASSERT(0);
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
         }
 
         if (error)
@@ -739,7 +736,7 @@ xfs_ioc_space(
         xfs_ilock(ip, XFS_ILOCK_EXCL);
         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 
-        if (!(ioflags & IO_INVIS)) {
+        if (!(ioflags & XFS_IO_INVIS)) {
                 ip->i_d.di_mode &= ~S_ISUID;
                 if (ip->i_d.di_mode & S_IXGRP)
                         ip->i_d.di_mode &= ~S_ISGID;
@@ -759,7 +756,7 @@ xfs_ioc_space(
 out_unlock:
         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
         mnt_drop_write_file(filp);
-        return -error;
+        return error;
 }
 
 STATIC int
@@ -781,41 +778,41 @@ xfs_ioc_bulkstat(
                 return -EPERM;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return -XFS_ERROR(EIO);
+                return -EIO;
 
         if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         if ((count = bulkreq.icount) <= 0)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         if (bulkreq.ubuffer == NULL)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         if (cmd == XFS_IOC_FSINUMBERS)
                 error = xfs_inumbers(mp, &inlast, &count,
                                         bulkreq.ubuffer, xfs_inumbers_fmt);
         else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
-                error = xfs_bulkstat_single(mp, &inlast,
-                                                bulkreq.ubuffer, &done);
+                error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
+                                        sizeof(xfs_bstat_t), NULL, &done);
         else    /* XFS_IOC_FSBULKSTAT */
                 error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
                                      sizeof(xfs_bstat_t), bulkreq.ubuffer,
                                      &done);
 
         if (error)
-                return -error;
+                return error;
 
         if (bulkreq.ocount != NULL) {
                 if (copy_to_user(bulkreq.lastip, &inlast,
                                                 sizeof(xfs_ino_t)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
         }
 
         return 0;
@@ -831,7 +828,7 @@ xfs_ioc_fsgeometry_v1(
 
         error = xfs_fs_geometry(mp, &fsgeo, 3);
         if (error)
-                return -error;
+                return error;
 
         /*
          * Caller should have passed an argument of type
@@ -839,7 +836,7 @@ xfs_ioc_fsgeometry_v1(
          * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
          */
         if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -853,10 +850,10 @@ xfs_ioc_fsgeometry(
 
         error = xfs_fs_geometry(mp, &fsgeo, 4);
         if (error)
-                return -error;
+                return error;
 
         if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -1041,16 +1038,16 @@ xfs_ioctl_setattr(
         trace_xfs_ioctl_setattr(ip);
 
         if (mp->m_flags & XFS_MOUNT_RDONLY)
-                return XFS_ERROR(EROFS);
+                return -EROFS;
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         /*
          * Disallow 32bit project ids when projid32bit feature is not enabled.
          */
         if ((mask & FSX_PROJID) && (fa->fsx_projid > (__uint16_t)-1) &&
                         !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         /*
          * If disk quotas is on, we make sure that the dquots do exist on disk,
@@ -1088,7 +1085,7 @@ xfs_ioctl_setattr(
          * CAP_FSETID capability is applicable.
          */
         if (!inode_owner_or_capable(VFS_I(ip))) {
-                code = XFS_ERROR(EPERM);
+                code = -EPERM;
                 goto error_return;
         }
 
@@ -1099,7 +1096,7 @@ xfs_ioctl_setattr(
          */
         if (mask & FSX_PROJID) {
                 if (current_user_ns() != &init_user_ns) {
-                        code = XFS_ERROR(EINVAL);
+                        code = -EINVAL;
                         goto error_return;
                 }
 
@@ -1122,7 +1119,7 @@ xfs_ioctl_setattr(
                 if (ip->i_d.di_nextents &&
                     ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
                      fa->fsx_extsize)) {
-                        code = XFS_ERROR(EINVAL);       /* EFBIG? */
+                        code = -EINVAL; /* EFBIG? */
                         goto error_return;
                 }
 
@@ -1141,7 +1138,7 @@ xfs_ioctl_setattr(
 
                         extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
                         if (extsize_fsb > MAXEXTLEN) {
-                                code = XFS_ERROR(EINVAL);
+                                code = -EINVAL;
                                 goto error_return;
                         }
 
@@ -1153,13 +1150,13 @@ xfs_ioctl_setattr(
                         } else {
                                 size = mp->m_sb.sb_blocksize;
                                 if (extsize_fsb > mp->m_sb.sb_agblocks / 2) {
-                                        code = XFS_ERROR(EINVAL);
+                                        code = -EINVAL;
                                         goto error_return;
                                 }
                         }
 
                         if (fa->fsx_extsize % size) {
-                                code = XFS_ERROR(EINVAL);
+                                code = -EINVAL;
                                 goto error_return;
                         }
                 }
@@ -1173,7 +1170,7 @@ xfs_ioctl_setattr(
                 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
                     (XFS_IS_REALTIME_INODE(ip)) !=
                     (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
-                        code = XFS_ERROR(EINVAL);       /* EFBIG? */
+                        code = -EINVAL; /* EFBIG? */
                         goto error_return;
                 }
 
@@ -1184,7 +1181,7 @@ xfs_ioctl_setattr(
                         if ((mp->m_sb.sb_rblocks == 0) ||
                             (mp->m_sb.sb_rextsize == 0) ||
                             (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
-                                code = XFS_ERROR(EINVAL);
+                                code = -EINVAL;
                                 goto error_return;
                         }
                 }
@@ -1198,7 +1195,7 @@ xfs_ioctl_setattr(
                      (fa->fsx_xflags &
                                 (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
                     !capable(CAP_LINUX_IMMUTABLE)) {
-                        code = XFS_ERROR(EPERM);
+                        code = -EPERM;
                         goto error_return;
                 }
         }
@@ -1301,7 +1298,7 @@ xfs_ioc_fssetxattr(
                 return error;
         error = xfs_ioctl_setattr(ip, &fa, mask);
         mnt_drop_write_file(filp);
-        return -error;
+        return error;
 }
 
 STATIC int
@@ -1346,7 +1343,7 @@ xfs_ioc_setxflags(
                 return error;
         error = xfs_ioctl_setattr(ip, &fa, mask);
         mnt_drop_write_file(filp);
-        return -error;
+        return error;
 }
 
 STATIC int
@@ -1356,7 +1353,7 @@ xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
 
         /* copy only getbmap portion (not getbmapx) */
         if (copy_to_user(base, bmv, sizeof(struct getbmap)))
-                return XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         *ap += sizeof(struct getbmap);
         return 0;
@@ -1373,23 +1370,23 @@ xfs_ioc_getbmap(
         int                     error;
 
         if (copy_from_user(&bmx, arg, sizeof(struct getbmapx)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         if (bmx.bmv_count < 2)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
-        if (ioflags & IO_INVIS)
+        if (ioflags & XFS_IO_INVIS)
                 bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
 
         error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
                             (struct getbmap *)arg+1);
         if (error)
-                return -error;
+                return error;
 
         /* copy back header - only size of getbmap */
         if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -1399,7 +1396,7 @@ xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
         struct getbmapx __user  *base = *ap;
 
         if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
-                return XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         *ap += sizeof(struct getbmapx);
         return 0;
@@ -1414,22 +1411,22 @@ xfs_ioc_getbmapx(
         int                     error;
 
         if (copy_from_user(&bmx, arg, sizeof(bmx)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         if (bmx.bmv_count < 2)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         if (bmx.bmv_iflags & (~BMV_IF_VALID))
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
                             (struct getbmapx *)arg+1);
         if (error)
-                return -error;
+                return error;
 
         /* copy back header */
         if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         return 0;
 }
@@ -1445,33 +1442,33 @@ xfs_ioc_swapext(
         /* Pull information for the target fd */
         f = fdget((int)sxp->sx_fdtarget);
         if (!f.file) {
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out;
         }
 
         if (!(f.file->f_mode & FMODE_WRITE) ||
             !(f.file->f_mode & FMODE_READ) ||
             (f.file->f_flags & O_APPEND)) {
-                error = XFS_ERROR(EBADF);
+                error = -EBADF;
                 goto out_put_file;
         }
 
         tmp = fdget((int)sxp->sx_fdtmp);
         if (!tmp.file) {
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_put_file;
         }
 
         if (!(tmp.file->f_mode & FMODE_WRITE) ||
             !(tmp.file->f_mode & FMODE_READ) ||
             (tmp.file->f_flags & O_APPEND)) {
-                error = XFS_ERROR(EBADF);
+                error = -EBADF;
                 goto out_put_tmp_file;
         }
 
         if (IS_SWAPFILE(file_inode(f.file)) ||
             IS_SWAPFILE(file_inode(tmp.file))) {
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_put_tmp_file;
         }
 
@@ -1479,17 +1476,17 @@ xfs_ioc_swapext(
         tip = XFS_I(file_inode(tmp.file));
 
         if (ip->i_mount != tip->i_mount) {
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_put_tmp_file;
         }
 
         if (ip->i_ino == tip->i_ino) {
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto out_put_tmp_file;
         }
 
         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
-                error = XFS_ERROR(EIO);
+                error = -EIO;
                 goto out_put_tmp_file;
         }
 
@@ -1523,7 +1520,7 @@ xfs_file_ioctl(
         int                     error;
 
         if (filp->f_mode & FMODE_NOCMTIME)
-                ioflags |= IO_INVIS;
+                ioflags |= XFS_IO_INVIS;
 
         trace_xfs_file_ioctl(ip);
 
@@ -1542,7 +1539,7 @@ xfs_file_ioctl(
                 xfs_flock64_t           bf;
 
                 if (copy_from_user(&bf, arg, sizeof(bf)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
         }
         case XFS_IOC_DIOINFO: {
@@ -1555,7 +1552,7 @@ xfs_file_ioctl(
                 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
 
                 if (copy_to_user(arg, &da, sizeof(da)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return 0;
         }
 
@@ -1588,7 +1585,7 @@ xfs_file_ioctl(
                 struct fsdmidata        dmi;
 
                 if (copy_from_user(&dmi, arg, sizeof(dmi)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 error = mnt_want_write_file(filp);
                 if (error)
@@ -1597,7 +1594,7 @@ xfs_file_ioctl(
                 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
                                 dmi.fsd_dmstate);
                 mnt_drop_write_file(filp);
-                return -error;
+                return error;
         }
 
         case XFS_IOC_GETBMAP:
@@ -1613,14 +1610,14 @@ xfs_file_ioctl(
                 xfs_fsop_handlereq_t    hreq;
 
                 if (copy_from_user(&hreq, arg, sizeof(hreq)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return xfs_find_handle(cmd, &hreq);
         }
         case XFS_IOC_OPEN_BY_HANDLE: {
                 xfs_fsop_handlereq_t    hreq;
 
                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return xfs_open_by_handle(filp, &hreq);
         }
         case XFS_IOC_FSSETDM_BY_HANDLE:
@@ -1630,7 +1627,7 @@ xfs_file_ioctl(
                 xfs_fsop_handlereq_t    hreq;
 
                 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return xfs_readlink_by_handle(filp, &hreq);
         }
         case XFS_IOC_ATTRLIST_BY_HANDLE:
@@ -1643,13 +1640,13 @@ xfs_file_ioctl(
                 struct xfs_swapext      sxp;
 
                 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 error = mnt_want_write_file(filp);
                 if (error)
                         return error;
                 error = xfs_ioc_swapext(&sxp);
                 mnt_drop_write_file(filp);
-                return -error;
+                return error;
         }
 
         case XFS_IOC_FSCOUNTS: {
@@ -1657,10 +1654,10 @@ xfs_file_ioctl(
 
                 error = xfs_fs_counts(mp, &out);
                 if (error)
-                        return -error;
+                        return error;
 
                 if (copy_to_user(arg, &out, sizeof(out)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return 0;
         }
 
@@ -1672,10 +1669,10 @@ xfs_file_ioctl(
                         return -EPERM;
 
                 if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return -XFS_ERROR(EROFS);
+                        return -EROFS;
 
                 if (copy_from_user(&inout, arg, sizeof(inout)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 error = mnt_want_write_file(filp);
                 if (error)
@@ -1686,10 +1683,10 @@ xfs_file_ioctl(
                 error = xfs_reserve_blocks(mp, &in, &inout);
                 mnt_drop_write_file(filp);
                 if (error)
-                        return -error;
+                        return error;
 
                 if (copy_to_user(arg, &inout, sizeof(inout)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return 0;
         }
 
@@ -1701,10 +1698,10 @@ xfs_file_ioctl(
 
                 error = xfs_reserve_blocks(mp, NULL, &out);
                 if (error)
-                        return -error;
+                        return error;
 
                 if (copy_to_user(arg, &out, sizeof(out)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 return 0;
         }
@@ -1713,42 +1710,42 @@ xfs_file_ioctl(
                 xfs_growfs_data_t in;
 
                 if (copy_from_user(&in, arg, sizeof(in)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 error = mnt_want_write_file(filp);
                 if (error)
                         return error;
                 error = xfs_growfs_data(mp, &in);
                 mnt_drop_write_file(filp);
-                return -error;
+                return error;
         }
 
         case XFS_IOC_FSGROWFSLOG: {
                 xfs_growfs_log_t in;
 
                 if (copy_from_user(&in, arg, sizeof(in)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 error = mnt_want_write_file(filp);
                 if (error)
                         return error;
                 error = xfs_growfs_log(mp, &in);
                 mnt_drop_write_file(filp);
-                return -error;
+                return error;
         }
 
         case XFS_IOC_FSGROWFSRT: {
                 xfs_growfs_rt_t in;
 
                 if (copy_from_user(&in, arg, sizeof(in)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 error = mnt_want_write_file(filp);
                 if (error)
                         return error;
                 error = xfs_growfs_rt(mp, &in);
                 mnt_drop_write_file(filp);
-                return -error;
+                return error;
         }
 
         case XFS_IOC_GOINGDOWN: {
@@ -1758,10 +1755,9 @@ xfs_file_ioctl(
                         return -EPERM;
 
                 if (get_user(in, (__uint32_t __user *)arg))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
-                error = xfs_fs_goingdown(mp, in);
-                return -error;
+                return xfs_fs_goingdown(mp, in);
         }
 
         case XFS_IOC_ERROR_INJECTION: {
@@ -1771,18 +1767,16 @@ xfs_file_ioctl(
                         return -EPERM;
 
                 if (copy_from_user(&in, arg, sizeof(in)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
-                error = xfs_errortag_add(in.errtag, mp);
-                return -error;
+                return xfs_errortag_add(in.errtag, mp);
         }
 
         case XFS_IOC_ERROR_CLEARALL:
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
 
-                error = xfs_errortag_clearall(mp, 1);
-                return -error;
+                return xfs_errortag_clearall(mp, 1);
 
         case XFS_IOC_FREE_EOFBLOCKS: {
                 struct xfs_fs_eofblocks eofb;
@@ -1792,16 +1786,16 @@ xfs_file_ioctl(
                         return -EPERM;
 
                 if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return -XFS_ERROR(EROFS);
+                        return -EROFS;
 
                 if (copy_from_user(&eofb, arg, sizeof(eofb)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
                 if (error)
-                        return -error;
+                        return error;
 
-                return -xfs_icache_free_eofblocks(mp, &keofb);
+                return xfs_icache_free_eofblocks(mp, &keofb);
         }
 
         default:
diff --git a/fs/xfs/xfs_ioctl32.c b/fs/xfs/xfs_ioctl32.c
index 944d5baa710a..a554646ff141 100644
--- a/fs/xfs/xfs_ioctl32.c
+++ b/fs/xfs/xfs_ioctl32.c
@@ -28,7 +28,6 @@
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_vnode.h"
 #include "xfs_inode.h"
 #include "xfs_itable.h"
 #include "xfs_error.h"
@@ -56,7 +55,7 @@ xfs_compat_flock64_copyin(
             get_user(bf->l_sysid,       &arg32->l_sysid) ||
             get_user(bf->l_pid,         &arg32->l_pid) ||
             copy_from_user(bf->l_pad,   &arg32->l_pad,  4*sizeof(u32)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -70,10 +69,10 @@ xfs_compat_ioc_fsgeometry_v1(
 
         error = xfs_fs_geometry(mp, &fsgeo, 3);
         if (error)
-                return -error;
+                return error;
         /* The 32-bit variant simply has some padding at the end */
         if (copy_to_user(arg32, &fsgeo, sizeof(struct compat_xfs_fsop_geom_v1)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -84,7 +83,7 @@ xfs_compat_growfs_data_copyin(
 {
         if (get_user(in->newblocks, &arg32->newblocks) ||
             get_user(in->imaxpct,   &arg32->imaxpct))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -95,14 +94,14 @@ xfs_compat_growfs_rt_copyin(
 {
         if (get_user(in->newblocks, &arg32->newblocks) ||
             get_user(in->extsize,   &arg32->extsize))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
 STATIC int
 xfs_inumbers_fmt_compat(
         void                    __user *ubuffer,
-        const xfs_inogrp_t      *buffer,
+        const struct xfs_inogrp *buffer,
         long                    count,
         long                    *written)
 {
@@ -113,7 +112,7 @@ xfs_inumbers_fmt_compat(
                 if (put_user(buffer[i].xi_startino,   &p32[i].xi_startino) ||
                     put_user(buffer[i].xi_alloccount, &p32[i].xi_alloccount) ||
                     put_user(buffer[i].xi_allocmask,  &p32[i].xi_allocmask))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
         }
         *written = count * sizeof(*p32);
         return 0;
@@ -132,7 +131,7 @@ xfs_ioctl32_bstime_copyin(
 
         if (get_user(sec32,             &bstime32->tv_sec)      ||
             get_user(bstime->tv_nsec,   &bstime32->tv_nsec))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         bstime->tv_sec = sec32;
         return 0;
 }
@@ -164,7 +163,7 @@ xfs_ioctl32_bstat_copyin(
             get_user(bstat->bs_dmevmask, &bstat32->bs_dmevmask) ||
             get_user(bstat->bs_dmstate, &bstat32->bs_dmstate)   ||
             get_user(bstat->bs_aextents, &bstat32->bs_aextents))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -180,7 +179,7 @@ xfs_bstime_store_compat(
         sec32 = p->tv_sec;
         if (put_user(sec32, &p32->tv_sec) ||
             put_user(p->tv_nsec, &p32->tv_nsec))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         return 0;
 }
 
@@ -195,7 +194,7 @@ xfs_bulkstat_one_fmt_compat(
         compat_xfs_bstat_t      __user *p32 = ubuffer;
 
         if (ubsize < sizeof(*p32))
-                return XFS_ERROR(ENOMEM);
+                return -ENOMEM;
 
         if (put_user(buffer->bs_ino,      &p32->bs_ino)         ||
             put_user(buffer->bs_mode,     &p32->bs_mode)        ||
@@ -218,7 +217,7 @@ xfs_bulkstat_one_fmt_compat(
             put_user(buffer->bs_dmevmask, &p32->bs_dmevmask)    ||
             put_user(buffer->bs_dmstate,  &p32->bs_dmstate)     ||
             put_user(buffer->bs_aextents, &p32->bs_aextents))
-                return XFS_ERROR(EFAULT);
+                return -EFAULT;
         if (ubused)
                 *ubused = sizeof(*p32);
         return 0;
@@ -256,30 +255,30 @@ xfs_compat_ioc_bulkstat(
         /* should be called again (unused here, but used in dmapi) */
 
         if (!capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return -XFS_ERROR(EIO);
+                return -EIO;
 
         if (get_user(addr, &p32->lastip))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         bulkreq.lastip = compat_ptr(addr);
         if (get_user(bulkreq.icount, &p32->icount) ||
             get_user(addr, &p32->ubuffer))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         bulkreq.ubuffer = compat_ptr(addr);
         if (get_user(addr, &p32->ocount))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         bulkreq.ocount = compat_ptr(addr);
 
         if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         if ((count = bulkreq.icount) <= 0)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         if (bulkreq.ubuffer == NULL)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         if (cmd == XFS_IOC_FSINUMBERS_32) {
                 error = xfs_inumbers(mp, &inlast, &count,
@@ -294,17 +293,17 @@ xfs_compat_ioc_bulkstat(
                         xfs_bulkstat_one_compat, sizeof(compat_xfs_bstat_t),
                         bulkreq.ubuffer, &done);
         } else
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
         if (error)
-                return -error;
+                return error;
 
         if (bulkreq.ocount != NULL) {
                 if (copy_to_user(bulkreq.lastip, &inlast,
                                                 sizeof(xfs_ino_t)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
 
                 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
         }
 
         return 0;
@@ -318,7 +317,7 @@ xfs_compat_handlereq_copyin(
         compat_xfs_fsop_handlereq_t     hreq32;
 
         if (copy_from_user(&hreq32, arg32, sizeof(compat_xfs_fsop_handlereq_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         hreq->fd = hreq32.fd;
         hreq->path = compat_ptr(hreq32.path);
@@ -352,19 +351,19 @@ xfs_compat_attrlist_by_handle(
         char                    *kbuf;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
         if (copy_from_user(&al_hreq, arg,
                            sizeof(compat_xfs_fsop_attrlist_handlereq_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
         if (al_hreq.buflen < sizeof(struct attrlist) ||
             al_hreq.buflen > XATTR_LIST_MAX)
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         /*
          * Reject flags, only allow namespaces.
          */
         if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
-                return -XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         dentry = xfs_compat_handlereq_to_dentry(parfilp, &al_hreq.hreq);
         if (IS_ERR(dentry))
@@ -376,7 +375,7 @@ xfs_compat_attrlist_by_handle(
                 goto out_dput;
 
         cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-        error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
+        error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
                                         al_hreq.flags, cursor);
         if (error)
                 goto out_kfree;
@@ -404,10 +403,10 @@ xfs_compat_attrmulti_by_handle(
         unsigned char                           *attr_name;
 
         if (!capable(CAP_SYS_ADMIN))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
         if (copy_from_user(&am_hreq, arg,
                            sizeof(compat_xfs_fsop_attrmulti_handlereq_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         /* overflow check */
         if (am_hreq.opcount >= INT_MAX / sizeof(compat_xfs_attr_multiop_t))
@@ -417,7 +416,7 @@ xfs_compat_attrmulti_by_handle(
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
-        error = E2BIG;
+        error = -E2BIG;
         size = am_hreq.opcount * sizeof(compat_xfs_attr_multiop_t);
         if (!size || size > 16 * PAGE_SIZE)
                 goto out_dput;
@@ -428,7 +427,7 @@ xfs_compat_attrmulti_by_handle(
                 goto out_dput;
         }
 
-        error = ENOMEM;
+        error = -ENOMEM;
         attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
         if (!attr_name)
                 goto out_kfree_ops;
@@ -439,7 +438,7 @@ xfs_compat_attrmulti_by_handle(
                                 compat_ptr(ops[i].am_attrname),
                                 MAXNAMELEN);
                 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
-                        error = ERANGE;
+                        error = -ERANGE;
                 if (ops[i].am_error < 0)
                         break;
 
@@ -470,19 +469,19 @@ xfs_compat_attrmulti_by_handle(
                         mnt_drop_write_file(parfilp);
                         break;
                 default:
-                        ops[i].am_error = EINVAL;
+                        ops[i].am_error = -EINVAL;
                 }
         }
 
         if (copy_to_user(compat_ptr(am_hreq.ops), ops, size))
-                error = XFS_ERROR(EFAULT);
+                error = -EFAULT;
 
         kfree(attr_name);
  out_kfree_ops:
         kfree(ops);
  out_dput:
         dput(dentry);
-        return -error;
+        return error;
 }
 
 STATIC int
@@ -496,26 +495,26 @@ xfs_compat_fssetdm_by_handle(
         struct dentry           *dentry;
 
         if (!capable(CAP_MKNOD))
-                return -XFS_ERROR(EPERM);
+                return -EPERM;
         if (copy_from_user(&dmhreq, arg,
                            sizeof(compat_xfs_fsop_setdm_handlereq_t)))
-                return -XFS_ERROR(EFAULT);
+                return -EFAULT;
 
         dentry = xfs_compat_handlereq_to_dentry(parfilp, &dmhreq.hreq);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
         if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
-                error = -XFS_ERROR(EPERM);
+                error = -EPERM;
                 goto out;
         }
 
         if (copy_from_user(&fsd, compat_ptr(dmhreq.data), sizeof(fsd))) {
-                error = -XFS_ERROR(EFAULT);
+                error = -EFAULT;
                 goto out;
         }
 
-        error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
+        error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
                                  fsd.fsd_dmstate);
 
 out:
@@ -537,7 +536,7 @@ xfs_file_compat_ioctl(
         int                     error;
 
         if (filp->f_mode & FMODE_NOCMTIME)
-                ioflags |= IO_INVIS;
+                ioflags |= XFS_IO_INVIS;
 
         trace_xfs_file_compat_ioctl(ip);
 
@@ -588,7 +587,7 @@ xfs_file_compat_ioctl(
                 struct xfs_flock64      bf;
 
                 if (xfs_compat_flock64_copyin(&bf, arg))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 cmd = _NATIVE_IOC(cmd, struct xfs_flock64);
                 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
         }
@@ -598,25 +597,25 @@ xfs_file_compat_ioctl(
                 struct xfs_growfs_data  in;
 
                 if (xfs_compat_growfs_data_copyin(&in, arg))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 error = mnt_want_write_file(filp);
                 if (error)
                         return error;
                 error = xfs_growfs_data(mp, &in);
                 mnt_drop_write_file(filp);
-                return -error;
+                return error;
         }
         case XFS_IOC_FSGROWFSRT_32: {
                 struct xfs_growfs_rt    in;
 
                 if (xfs_compat_growfs_rt_copyin(&in, arg))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 error = mnt_want_write_file(filp);
                 if (error)
                         return error;
                 error = xfs_growfs_rt(mp, &in);
                 mnt_drop_write_file(filp);
-                return -error;
+                return error;
         }
 #endif
         /* long changes size, but xfs only copiese out 32 bits */
@@ -633,13 +632,13 @@ xfs_file_compat_ioctl(
                 if (copy_from_user(&sxp, sxu,
                                    offsetof(struct xfs_swapext, sx_stat)) ||
                     xfs_ioctl32_bstat_copyin(&sxp.sx_stat, &sxu->sx_stat))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 error = mnt_want_write_file(filp);
                 if (error)
                         return error;
                 error = xfs_ioc_swapext(&sxp);
                 mnt_drop_write_file(filp);
-                return -error;
+                return error;
         }
         case XFS_IOC_FSBULKSTAT_32:
         case XFS_IOC_FSBULKSTAT_SINGLE_32:
@@ -651,7 +650,7 @@ xfs_file_compat_ioctl(
                 struct xfs_fsop_handlereq       hreq;
 
                 if (xfs_compat_handlereq_copyin(&hreq, arg))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq);
                 return xfs_find_handle(cmd, &hreq);
         }
@@ -659,14 +658,14 @@ xfs_file_compat_ioctl(
                 struct xfs_fsop_handlereq       hreq;
 
                 if (xfs_compat_handlereq_copyin(&hreq, arg))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return xfs_open_by_handle(filp, &hreq);
         }
         case XFS_IOC_READLINK_BY_HANDLE_32: {
                 struct xfs_fsop_handlereq       hreq;
 
                 if (xfs_compat_handlereq_copyin(&hreq, arg))
-                        return -XFS_ERROR(EFAULT);
+                        return -EFAULT;
                 return xfs_readlink_by_handle(filp, &hreq);
         }
         case XFS_IOC_ATTRLIST_BY_HANDLE_32:
@@ -676,6 +675,6 @@ xfs_file_compat_ioctl(
         case XFS_IOC_FSSETDM_BY_HANDLE_32:
                 return xfs_compat_fssetdm_by_handle(filp, arg);
         default:
-                return -XFS_ERROR(ENOIOCTLCMD);
+                return -ENOIOCTLCMD;
         }
 }
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 6d3ec2b6ee29..e9c47b6f5e5a 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -110,7 +110,7 @@ xfs_alert_fsblock_zero(
                 (unsigned long long)imap->br_startoff,
                 (unsigned long long)imap->br_blockcount,
                 imap->br_state);
-        return EFSCORRUPTED;
+        return -EFSCORRUPTED;
 }
 
 int
@@ -138,7 +138,7 @@ xfs_iomap_write_direct(
 
         error = xfs_qm_dqattach(ip, 0);
         if (error)
-                return XFS_ERROR(error);
+                return error;
 
         rt = XFS_IS_REALTIME_INODE(ip);
         extsz = xfs_get_extsz_hint(ip);
@@ -148,7 +148,7 @@ xfs_iomap_write_direct(
         if ((offset + count) > XFS_ISIZE(ip)) {
                 error = xfs_iomap_eof_align_last_fsb(mp, ip, extsz, &last_fsb);
                 if (error)
-                        return XFS_ERROR(error);
+                        return error;
         } else {
                 if (nmaps && (imap->br_startblock == HOLESTARTBLOCK))
                         last_fsb = MIN(last_fsb, (xfs_fileoff_t)
@@ -188,7 +188,7 @@ xfs_iomap_write_direct(
          */
         if (error) {
                 xfs_trans_cancel(tp, 0);
-                return XFS_ERROR(error);
+                return error;
         }
 
         xfs_ilock(ip, XFS_ILOCK_EXCL);
@@ -225,7 +225,7 @@ xfs_iomap_write_direct(
          * Copy any maps to caller's array and return any error.
          */
         if (nimaps == 0) {
-                error = XFS_ERROR(ENOSPC);
+                error = -ENOSPC;
                 goto out_unlock;
         }
 
@@ -397,7 +397,8 @@ xfs_quota_calc_throttle(
         struct xfs_inode *ip,
         int type,
         xfs_fsblock_t *qblocks,
-        int *qshift)
+        int *qshift,
+        int64_t *qfreesp)
 {
         int64_t freesp;
         int shift = 0;
@@ -406,6 +407,7 @@ xfs_quota_calc_throttle(
         /* over hi wmark, squash the prealloc completely */
         if (dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
                 *qblocks = 0;
+                *qfreesp = 0;
                 return;
         }
 
@@ -418,6 +420,9 @@ xfs_quota_calc_throttle(
                         shift += 2;
         }
 
+        if (freesp < *qfreesp)
+                *qfreesp = freesp;
+
         /* only overwrite the throttle values if we are more aggressive */
         if ((freesp >> shift) < (*qblocks >> *qshift)) {
                 *qblocks = freesp;
@@ -476,15 +481,18 @@ xfs_iomap_prealloc_size(
         }
 
         /*
-         * Check each quota to cap the prealloc size and provide a shift
-         * value to throttle with.
+         * Check each quota to cap the prealloc size, provide a shift value to
+         * throttle with and adjust amount of available space.
          */
         if (xfs_quota_need_throttle(ip, XFS_DQ_USER, alloc_blocks))
-                xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift);
+                xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift,
+                                        &freesp);
         if (xfs_quota_need_throttle(ip, XFS_DQ_GROUP, alloc_blocks))
-                xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift);
+                xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift,
+                                        &freesp);
         if (xfs_quota_need_throttle(ip, XFS_DQ_PROJ, alloc_blocks))
-                xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift);
+                xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift,
+                                        &freesp);
 
         /*
          * The final prealloc size is set to the minimum of free space available
@@ -552,7 +560,7 @@ xfs_iomap_write_delay(
          */
         error = xfs_qm_dqattach_locked(ip, 0);
         if (error)
-                return XFS_ERROR(error);
+                return error;
 
         extsz = xfs_get_extsz_hint(ip);
         offset_fsb = XFS_B_TO_FSBT(mp, offset);
@@ -596,11 +604,11 @@ retry:
                                 imap, &nimaps, XFS_BMAPI_ENTIRE);
         switch (error) {
         case 0:
-        case ENOSPC:
-        case EDQUOT:
+        case -ENOSPC:
+        case -EDQUOT:
                 break;
         default:
-                return XFS_ERROR(error);
+                return error;
         }
 
         /*
@@ -614,7 +622,7 @@ retry:
                         error = 0;
                         goto retry;
                 }
-                return XFS_ERROR(error ? error : ENOSPC);
+                return error ? error : -ENOSPC;
         }
 
         if (!(imap[0].br_startblock || XFS_IS_REALTIME_INODE(ip)))
@@ -663,7 +671,7 @@ xfs_iomap_write_allocate(
          */
         error = xfs_qm_dqattach(ip, 0);
         if (error)
-                return XFS_ERROR(error);
+                return error;
 
         offset_fsb = XFS_B_TO_FSBT(mp, offset);
         count_fsb = imap->br_blockcount;
@@ -690,7 +698,7 @@ xfs_iomap_write_allocate(
                                                   nres, 0);
                         if (error) {
                                 xfs_trans_cancel(tp, 0);
-                                return XFS_ERROR(error);
+                                return error;
                         }
                         xfs_ilock(ip, XFS_ILOCK_EXCL);
                         xfs_trans_ijoin(tp, ip, 0);
@@ -739,7 +747,7 @@ xfs_iomap_write_allocate(
                         if ((map_start_fsb + count_fsb) > last_block) {
                                 count_fsb = last_block - map_start_fsb;
                                 if (count_fsb == 0) {
-                                        error = EAGAIN;
+                                        error = -EAGAIN;
                                         goto trans_cancel;
                                 }
                         }
@@ -793,7 +801,7 @@ trans_cancel:
         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
 error0:
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
-        return XFS_ERROR(error);
+        return error;
 }
 
 int
@@ -853,7 +861,7 @@ xfs_iomap_write_unwritten(
                                           resblks, 0);
                 if (error) {
                         xfs_trans_cancel(tp, 0);
-                        return XFS_ERROR(error);
+                        return error;
                 }
 
                 xfs_ilock(ip, XFS_ILOCK_EXCL);
@@ -892,7 +900,7 @@ xfs_iomap_write_unwritten(
                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
                 if (error)
-                        return XFS_ERROR(error);
+                        return error;
 
                 if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
                         return xfs_alert_fsblock_zero(ip, &imap);
@@ -915,5 +923,5 @@ error_on_bmapi_transaction:
         xfs_bmap_cancel(&free_list);
         xfs_trans_cancel(tp, (XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT));
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
-        return XFS_ERROR(error);
+        return error;
 }
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 205613a06068..72129493e9d3 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -72,7 +72,7 @@ xfs_initxattrs(
         int                     error = 0;
 
         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
-                error = -xfs_attr_set(ip, xattr->name, xattr->value,
+                error = xfs_attr_set(ip, xattr->name, xattr->value,
                                       xattr->value_len, ATTR_SECURE);
                 if (error < 0)
                         break;
@@ -93,7 +93,7 @@ xfs_init_security(
         struct inode    *dir,
         const struct qstr *qstr)
 {
-        return -security_inode_init_security(inode, dir, qstr,
+        return security_inode_init_security(inode, dir, qstr,
                                              &xfs_initxattrs, NULL);
 }
 
@@ -173,12 +173,12 @@ xfs_generic_create(
 
 #ifdef CONFIG_XFS_POSIX_ACL
         if (default_acl) {
-                error = -xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
+                error = xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
                 if (error)
                         goto out_cleanup_inode;
         }
         if (acl) {
-                error = -xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
+                error = xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
                 if (error)
                         goto out_cleanup_inode;
         }
@@ -194,7 +194,7 @@ xfs_generic_create(
                 posix_acl_release(default_acl);
         if (acl)
                 posix_acl_release(acl);
-        return -error;
+        return error;
 
  out_cleanup_inode:
         if (!tmpfile)
@@ -248,8 +248,8 @@ xfs_vn_lookup(
         xfs_dentry_to_name(&name, dentry, 0);
         error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
         if (unlikely(error)) {
-                if (unlikely(error != ENOENT))
-                        return ERR_PTR(-error);
+                if (unlikely(error != -ENOENT))
+                        return ERR_PTR(error);
                 d_add(dentry, NULL);
                 return NULL;
         }
@@ -275,8 +275,8 @@ xfs_vn_ci_lookup(
         xfs_dentry_to_name(&xname, dentry, 0);
         error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
         if (unlikely(error)) {
-                if (unlikely(error != ENOENT))
-                        return ERR_PTR(-error);
+                if (unlikely(error != -ENOENT))
+                        return ERR_PTR(error);
                 /*
                  * call d_add(dentry, NULL) here when d_drop_negative_children
                  * is called in xfs_vn_mknod (ie. allow negative dentries
@@ -311,7 +311,7 @@ xfs_vn_link(
 
         error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
         if (unlikely(error))
-                return -error;
+                return error;
 
         ihold(inode);
         d_instantiate(dentry, inode);
@@ -328,7 +328,7 @@ xfs_vn_unlink(
 
         xfs_dentry_to_name(&name, dentry, 0);
 
-        error = -xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
+        error = xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
         if (error)
                 return error;
 
@@ -375,7 +375,7 @@ xfs_vn_symlink(
         xfs_cleanup_inode(dir, inode, dentry);
         iput(inode);
  out:
-        return -error;
+        return error;
 }
 
 STATIC int
@@ -392,8 +392,8 @@ xfs_vn_rename(
         xfs_dentry_to_name(&oname, odentry, 0);
         xfs_dentry_to_name(&nname, ndentry, odentry->d_inode->i_mode);
 
-        return -xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
-                           XFS_I(ndir), &nname, new_inode ?
+        return xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
+                          XFS_I(ndir), &nname, new_inode ?
                                                 XFS_I(new_inode) : NULL);
 }
 
@@ -414,7 +414,7 @@ xfs_vn_follow_link(
         if (!link)
                 goto out_err;
 
-        error = -xfs_readlink(XFS_I(dentry->d_inode), link);
+        error = xfs_readlink(XFS_I(dentry->d_inode), link);
         if (unlikely(error))
                 goto out_kfree;
 
@@ -441,7 +441,7 @@ xfs_vn_getattr(
         trace_xfs_getattr(ip);
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return -XFS_ERROR(EIO);
+                return -EIO;
 
         stat->size = XFS_ISIZE(ip);
         stat->dev = inode->i_sb->s_dev;
@@ -546,14 +546,14 @@ xfs_setattr_nonsize(
         /* If acls are being inherited, we already have this checked */
         if (!(flags & XFS_ATTR_NOACL)) {
                 if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return XFS_ERROR(EROFS);
+                        return -EROFS;
 
                 if (XFS_FORCED_SHUTDOWN(mp))
-                        return XFS_ERROR(EIO);
+                        return -EIO;
 
-                error = -inode_change_ok(inode, iattr);
+                error = inode_change_ok(inode, iattr);
                 if (error)
-                        return XFS_ERROR(error);
+                        return error;
         }
 
         ASSERT((mask & ATTR_SIZE) == 0);
@@ -703,7 +703,7 @@ xfs_setattr_nonsize(
         xfs_qm_dqrele(gdqp);
 
         if (error)
-                return XFS_ERROR(error);
+                return error;
 
         /*
          * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
@@ -713,9 +713,9 @@ xfs_setattr_nonsize(
          *           Posix ACL code seems to care about this issue either.
          */
         if ((mask & ATTR_MODE) && !(flags & XFS_ATTR_NOACL)) {
-                error = -posix_acl_chmod(inode, inode->i_mode);
+                error = posix_acl_chmod(inode, inode->i_mode);
                 if (error)
-                        return XFS_ERROR(error);
+                        return error;
         }
 
         return 0;
@@ -748,14 +748,14 @@ xfs_setattr_size(
         trace_xfs_setattr(ip);
 
         if (mp->m_flags & XFS_MOUNT_RDONLY)
-                return XFS_ERROR(EROFS);
+                return -EROFS;
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
-        error = -inode_change_ok(inode, iattr);
+        error = inode_change_ok(inode, iattr);
         if (error)
-                return XFS_ERROR(error);
+                return error;
 
         ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
         ASSERT(S_ISREG(ip->i_d.di_mode));
@@ -818,7 +818,7 @@ xfs_setattr_size(
          * care about here.
          */
         if (oldsize != ip->i_d.di_size && newsize > ip->i_d.di_size) {
-                error = -filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
+                error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
                                                       ip->i_d.di_size, newsize);
                 if (error)
                         return error;
@@ -844,7 +844,7 @@ xfs_setattr_size(
          * much we can do about this, except to hope that the caller sees ENOMEM
          * and retries the truncate operation.
          */
-        error = -block_truncate_page(inode->i_mapping, newsize, xfs_get_blocks);
+        error = block_truncate_page(inode->i_mapping, newsize, xfs_get_blocks);
         if (error)
                 return error;
         truncate_setsize(inode, newsize);
@@ -950,7 +950,7 @@ xfs_vn_setattr(
                 error = xfs_setattr_nonsize(ip, iattr, 0);
         }
 
-        return -error;
+        return error;
 }
 
 STATIC int
@@ -970,7 +970,7 @@ xfs_vn_update_time(
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_fsyncts, 0, 0);
         if (error) {
                 xfs_trans_cancel(tp, 0);
-                return -error;
+                return error;
         }
 
         xfs_ilock(ip, XFS_ILOCK_EXCL);
@@ -991,7 +991,7 @@ xfs_vn_update_time(
         }
         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
         xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP);
-        return -xfs_trans_commit(tp, 0);
+        return xfs_trans_commit(tp, 0);
 }
 
 #define XFS_FIEMAP_FLAGS        (FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
@@ -1036,7 +1036,7 @@ xfs_fiemap_format(
                 *full = 1;      /* user array now full */
         }
 
-        return -error;
+        return error;
 }
 
 STATIC int
@@ -1055,12 +1055,12 @@ xfs_vn_fiemap(
                 return error;
 
         /* Set up bmap header for xfs internal routine */
-        bm.bmv_offset = BTOBB(start);
+        bm.bmv_offset = BTOBBT(start);
         /* Special case for whole file */
         if (length == FIEMAP_MAX_OFFSET)
                 bm.bmv_length = -1LL;
         else
-                bm.bmv_length = BTOBB(length);
+                bm.bmv_length = BTOBB(start + length) - bm.bmv_offset;
 
         /* We add one because in getbmap world count includes the header */
         bm.bmv_count = !fieinfo->fi_extents_max ? MAXEXTNUM :
@@ -1075,7 +1075,7 @@ xfs_vn_fiemap(
 
         error = xfs_getbmap(ip, &bm, xfs_fiemap_format, fieinfo);
         if (error)
-                return -error;
+                return error;
 
         return 0;
 }
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index cb64f222d607..f71be9c68017 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -67,19 +67,17 @@ xfs_bulkstat_one_int(
         *stat = BULKSTAT_RV_NOTHING;
 
         if (!buffer || xfs_internal_inum(mp, ino))
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
 
         buf = kmem_alloc(sizeof(*buf), KM_SLEEP | KM_MAYFAIL);
         if (!buf)
-                return XFS_ERROR(ENOMEM);
+                return -ENOMEM;
 
         error = xfs_iget(mp, NULL, ino,
                          (XFS_IGET_DONTCACHE | XFS_IGET_UNTRUSTED),
                          XFS_ILOCK_SHARED, &ip);
-        if (error) {
-                *stat = BULKSTAT_RV_NOTHING;
+        if (error)
                 goto out_free;
-        }
 
         ASSERT(ip != NULL);
         ASSERT(ip->i_imap.im_blkno != 0);
@@ -136,7 +134,6 @@ xfs_bulkstat_one_int(
         IRELE(ip);
 
         error = formatter(buffer, ubsize, ubused, buf);
-
         if (!error)
                 *stat = BULKSTAT_RV_DIDONE;
 
@@ -154,9 +151,9 @@ xfs_bulkstat_one_fmt(
         const xfs_bstat_t       *buffer)
 {
         if (ubsize < sizeof(*buffer))
-                return XFS_ERROR(ENOMEM);
+                return -ENOMEM;
         if (copy_to_user(ubuffer, buffer, sizeof(*buffer)))
-                return XFS_ERROR(EFAULT);
+                return -EFAULT;
         if (ubused)
                 *ubused = sizeof(*buffer);
         return 0;
@@ -175,9 +172,170 @@ xfs_bulkstat_one(
                                     xfs_bulkstat_one_fmt, ubused, stat);
 }
 
+/*
+ * Loop over all clusters in a chunk for a given incore inode allocation btree
+ * record.  Do a readahead if there are any allocated inodes in that cluster.
+ */
+STATIC void
+xfs_bulkstat_ichunk_ra(
+        struct xfs_mount                *mp,
+        xfs_agnumber_t                  agno,
+        struct xfs_inobt_rec_incore     *irec)
+{
+        xfs_agblock_t                   agbno;
+        struct blk_plug                 plug;
+        int                             blks_per_cluster;
+        int                             inodes_per_cluster;
+        int                             i;      /* inode chunk index */
+
+        agbno = XFS_AGINO_TO_AGBNO(mp, irec->ir_startino);
+        blks_per_cluster = xfs_icluster_size_fsb(mp);
+        inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog;
+
+        blk_start_plug(&plug);
+        for (i = 0; i < XFS_INODES_PER_CHUNK;
+             i += inodes_per_cluster, agbno += blks_per_cluster) {
+                if (xfs_inobt_maskn(i, inodes_per_cluster) & ~irec->ir_free) {
+                        xfs_btree_reada_bufs(mp, agno, agbno, blks_per_cluster,
+                                             &xfs_inode_buf_ops);
+                }
+        }
+        blk_finish_plug(&plug);
+}
+
+/*
+ * Lookup the inode chunk that the given inode lives in and then get the record
+ * if we found the chunk.  If the inode was not the last in the chunk and there
+ * are some left allocated, update the data for the pointed-to record as well as
+ * return the count of grabbed inodes.
+ */
+STATIC int
+xfs_bulkstat_grab_ichunk(
+        struct xfs_btree_cur            *cur,   /* btree cursor */
+        xfs_agino_t                     agino,  /* starting inode of chunk */
+        int                             *icount,/* return # of inodes grabbed */
+        struct xfs_inobt_rec_incore     *irec)  /* btree record */
+{
+        int                             idx;    /* index into inode chunk */
+        int                             stat;
+        int                             error = 0;
+
+        /* Lookup the inode chunk that this inode lives in */
+        error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &stat);
+        if (error)
+                return error;
+        if (!stat) {
+                *icount = 0;
+                return error;
+        }
+
+        /* Get the record, should always work */
+        error = xfs_inobt_get_rec(cur, irec, &stat);
+        if (error)
+                return error;
+        XFS_WANT_CORRUPTED_RETURN(stat == 1);
+
+        /* Check if the record contains the inode in request */
+        if (irec->ir_startino + XFS_INODES_PER_CHUNK <= agino)
+                return -EINVAL;
+
+        idx = agino - irec->ir_startino + 1;
+        if (idx < XFS_INODES_PER_CHUNK &&
+            (xfs_inobt_maskn(idx, XFS_INODES_PER_CHUNK - idx) & ~irec->ir_free)) {
+                int     i;
+
+                /* We got a right chunk with some left inodes allocated at it.
+                 * Grab the chunk record.  Mark all the uninteresting inodes
+                 * free -- because they're before our start point.
+                 */
+                for (i = 0; i < idx; i++) {
+                        if (XFS_INOBT_MASK(i) & ~irec->ir_free)
+                                irec->ir_freecount++;
+                }
+
+                irec->ir_free |= xfs_inobt_maskn(0, idx);
+                *icount = XFS_INODES_PER_CHUNK - irec->ir_freecount;
+        }
+
+        return 0;
+}
+
 #define XFS_BULKSTAT_UBLEFT(ubleft)     ((ubleft) >= statstruct_size)
 
 /*
+ * Process inodes in chunk with a pointer to a formatter function
+ * that will iget the inode and fill in the appropriate structure.
+ */
+int
+xfs_bulkstat_ag_ichunk(
+        struct xfs_mount                *mp,
+        xfs_agnumber_t                  agno,
+        struct xfs_inobt_rec_incore     *irbp,
+        bulkstat_one_pf                 formatter,
+        size_t                          statstruct_size,
+        struct xfs_bulkstat_agichunk    *acp)
+{
+        xfs_ino_t                       lastino = acp->ac_lastino;
+        char                            __user **ubufp = acp->ac_ubuffer;
+        int                             ubleft = acp->ac_ubleft;
+        int                             ubelem = acp->ac_ubelem;
+        int                             chunkidx, clustidx;
+        int                             error = 0;
+        xfs_agino_t                     agino;
+
+        for (agino = irbp->ir_startino, chunkidx = clustidx = 0;
+             XFS_BULKSTAT_UBLEFT(ubleft) &&
+             irbp->ir_freecount < XFS_INODES_PER_CHUNK;
+             chunkidx++, clustidx++, agino++) {
+                int             fmterror;       /* bulkstat formatter result */
+                int             ubused;
+                xfs_ino_t       ino = XFS_AGINO_TO_INO(mp, agno, agino);
+
+                ASSERT(chunkidx < XFS_INODES_PER_CHUNK);
+
+                /* Skip if this inode is 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++;
+
+                /* Get the inode and fill in a single buffer */
+                ubused = statstruct_size;
+                error = formatter(mp, ino, *ubufp, ubleft, &ubused, &fmterror);
+                if (fmterror == BULKSTAT_RV_NOTHING) {
+                        if (error && error != -ENOENT && error != -EINVAL) {
+                                ubleft = 0;
+                                break;
+                        }
+                        lastino = ino;
+                        continue;
+                }
+                if (fmterror == BULKSTAT_RV_GIVEUP) {
+                        ubleft = 0;
+                        ASSERT(error);
+                        break;
+                }
+                if (*ubufp)
+                        *ubufp += ubused;
+                ubleft -= ubused;
+                ubelem++;
+                lastino = ino;
+        }
+
+        acp->ac_lastino = lastino;
+        acp->ac_ubleft = ubleft;
+        acp->ac_ubelem = ubelem;
+
+        return error;
+}
+
+/*
  * Return stat information in bulk (by-inode) for the filesystem.
  */
 int                                     /* error status */
@@ -190,13 +348,10 @@ xfs_bulkstat(
         char                    __user *ubuffer, /* buffer with inode stats */
         int                     *done)  /* 1 if there are more stats to get */
 {
-        xfs_agblock_t           agbno=0;/* allocation group block number */
         xfs_buf_t               *agbp;  /* agi header buffer */
         xfs_agi_t               *agi;   /* agi header data */
         xfs_agino_t             agino;  /* inode # in allocation group */
         xfs_agnumber_t          agno;   /* allocation group number */
-        int                     chunkidx; /* current index into inode chunk */
-        int                     clustidx; /* current index into inode cluster */
         xfs_btree_cur_t         *cur;   /* btree cursor for ialloc btree */
         int                     end_of_ag; /* set if we've seen the ag end */
         int                     error;  /* error code */
@@ -209,8 +364,6 @@ xfs_bulkstat(
         xfs_inobt_rec_incore_t  *irbuf; /* start of irec buffer */
         xfs_inobt_rec_incore_t  *irbufend; /* end of good irec buffer entries */
         xfs_ino_t               lastino; /* last inode number returned */
-        int                     blks_per_cluster; /* # of blocks per cluster */
-        int                     inodes_per_cluster;/* # of inodes per cluster */
         int                     nirbuf; /* size of irbuf */
         int                     rval;   /* return value error code */
         int                     tmp;    /* result value from btree calls */
@@ -218,7 +371,6 @@ xfs_bulkstat(
         int                     ubleft; /* bytes left in user's buffer */
         char                    __user *ubufp;  /* pointer into user's buffer */
         int                     ubelem; /* spaces used in user's buffer */
-        int                     ubused; /* bytes used by formatter */
 
         /*
          * Get the last inode value, see if there's nothing to do.
@@ -233,20 +385,16 @@ xfs_bulkstat(
                 *ubcountp = 0;
                 return 0;
         }
-        if (!ubcountp || *ubcountp <= 0) {
-                return EINVAL;
-        }
+
         ubcount = *ubcountp; /* statstruct's */
         ubleft = ubcount * statstruct_size; /* bytes */
         *ubcountp = ubelem = 0;
         *done = 0;
         fmterror = 0;
         ubufp = ubuffer;
-        blks_per_cluster = xfs_icluster_size_fsb(mp);
-        inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog;
         irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4);
         if (!irbuf)
-                return ENOMEM;
+                return -ENOMEM;
 
         nirbuf = irbsize / sizeof(*irbuf);
 
@@ -258,14 +406,8 @@ xfs_bulkstat(
         while (XFS_BULKSTAT_UBLEFT(ubleft) && agno < mp->m_sb.sb_agcount) {
                 cond_resched();
                 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
-                if (error) {
-                        /*
-                         * Skip this allocation group and go to the next one.
-                         */
-                        agno++;
-                        agino = 0;
-                        continue;
-                }
+                if (error)
+                        break;
                 agi = XFS_BUF_TO_AGI(agbp);
                 /*
                  * Allocate and initialize a btree cursor for ialloc btree.
@@ -275,96 +417,39 @@ xfs_bulkstat(
                 irbp = irbuf;
                 irbufend = irbuf + nirbuf;
                 end_of_ag = 0;
-                /*
-                 * If we're returning in the middle of an allocation group,
-                 * we need to get the remainder of the chunk we're in.
-                 */
+                icount = 0;
                 if (agino > 0) {
-                        xfs_inobt_rec_incore_t r;
-
                         /*
-                         * Lookup the inode chunk that this inode lives in.
+                         * In the middle of an allocation group, we need to get
+                         * the remainder of the chunk we're in.
                          */
-                        error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE,
-                                                 &tmp);
-                        if (!error &&   /* no I/O error */
-                            tmp &&      /* lookup succeeded */
-                                        /* got the record, should always work */
-                            !(error = xfs_inobt_get_rec(cur, &r, &i)) &&
-                            i == 1 &&
-                                        /* this is the right chunk */
-                            agino < r.ir_startino + XFS_INODES_PER_CHUNK &&
-                                        /* lastino was not last in chunk */
-                            (chunkidx = agino - r.ir_startino + 1) <
-                                    XFS_INODES_PER_CHUNK &&
-                                        /* there are some left allocated */
-                            xfs_inobt_maskn(chunkidx,
-                                    XFS_INODES_PER_CHUNK - chunkidx) &
-                                    ~r.ir_free) {
-                                /*
-                                 * Grab the chunk record.  Mark all the
-                                 * uninteresting inodes (because they're
-                                 * before our start point) free.
-                                 */
-                                for (i = 0; i < chunkidx; i++) {
-                                        if (XFS_INOBT_MASK(i) & ~r.ir_free)
-                                                r.ir_freecount++;
-                                }
-                                r.ir_free |= xfs_inobt_maskn(0, chunkidx);
+                        struct xfs_inobt_rec_incore     r;
+
+                        error = xfs_bulkstat_grab_ichunk(cur, agino, &icount, &r);
+                        if (error)
+                                break;
+                        if (icount) {
                                 irbp->ir_startino = r.ir_startino;
                                 irbp->ir_freecount = r.ir_freecount;
                                 irbp->ir_free = r.ir_free;
                                 irbp++;
                                 agino = r.ir_startino + XFS_INODES_PER_CHUNK;
-                                icount = XFS_INODES_PER_CHUNK - r.ir_freecount;
-                        } else {
-                                /*
-                                 * If any of those tests failed, bump the
-                                 * inode number (just in case).
-                                 */
-                                agino++;
-                                icount = 0;
                         }
-                        /*
-                         * In any case, increment to the next record.
-                         */
-                        if (!error)
-                                error = xfs_btree_increment(cur, 0, &tmp);
+                        /* Increment to the next record */
+                        error = xfs_btree_increment(cur, 0, &tmp);
                 } else {
-                        /*
-                         * Start of ag.  Lookup the first inode chunk.
-                         */
+                        /* Start of ag.  Lookup the first inode chunk */
                         error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &tmp);
-                        icount = 0;
                 }
+                if (error)
+                        break;
+
                 /*
                  * Loop through inode btree records in this ag,
                  * until we run out of inodes or space in the buffer.
                  */
                 while (irbp < irbufend && icount < ubcount) {
-                        xfs_inobt_rec_incore_t r;
-
-                        /*
-                         * Loop as long as we're unable to read the
-                         * inode btree.
-                         */
-                        while (error) {
-                                agino += XFS_INODES_PER_CHUNK;
-                                if (XFS_AGINO_TO_AGBNO(mp, agino) >=
-                                                be32_to_cpu(agi->agi_length))
-                                        break;
-                                error = xfs_inobt_lookup(cur, agino,
-                                                         XFS_LOOKUP_GE, &tmp);
-                                cond_resched();
-                        }
-                        /*
-                         * If ran off the end of the ag either with an error,
-                         * or the normal way, set end and stop collecting.
-                         */
-                        if (error) {
-                                end_of_ag = 1;
-                                break;
-                        }
+                        struct xfs_inobt_rec_incore     r;
 
                         error = xfs_inobt_get_rec(cur, &r, &i);
                         if (error || i == 0) {
@@ -377,25 +462,7 @@ xfs_bulkstat(
                          * Also start read-ahead now for this chunk.
                          */
                         if (r.ir_freecount < XFS_INODES_PER_CHUNK) {
-                                struct blk_plug plug;
-                                /*
-                                 * Loop over all clusters in the next chunk.
-                                 * Do a readahead if there are any allocated
-                                 * inodes in that cluster.
-                                 */
-                                blk_start_plug(&plug);
-                                agbno = XFS_AGINO_TO_AGBNO(mp, r.ir_startino);
-                                for (chunkidx = 0;
-                                     chunkidx < XFS_INODES_PER_CHUNK;
-                                     chunkidx += inodes_per_cluster,
-                                     agbno += blks_per_cluster) {
-                                        if (xfs_inobt_maskn(chunkidx,
-                                            inodes_per_cluster) & ~r.ir_free)
-                                                xfs_btree_reada_bufs(mp, agno,
-                                                        agbno, blks_per_cluster,
-                                                        &xfs_inode_buf_ops);
-                                }
-                                blk_finish_plug(&plug);
+                                xfs_bulkstat_ichunk_ra(mp, agno, &r);
                                 irbp->ir_startino = r.ir_startino;
                                 irbp->ir_freecount = r.ir_freecount;
                                 irbp->ir_free = r.ir_free;
@@ -422,57 +489,20 @@ xfs_bulkstat(
                 irbufend = irbp;
                 for (irbp = irbuf;
                      irbp < irbufend && XFS_BULKSTAT_UBLEFT(ubleft); irbp++) {
-                        /*
-                         * Now process this chunk of inodes.
-                         */
-                        for (agino = irbp->ir_startino, chunkidx = clustidx = 0;
-                             XFS_BULKSTAT_UBLEFT(ubleft) &&
-                                irbp->ir_freecount < XFS_INODES_PER_CHUNK;
-                             chunkidx++, clustidx++, agino++) {
-                                ASSERT(chunkidx < XFS_INODES_PER_CHUNK);
-
-                                ino = XFS_AGINO_TO_INO(mp, agno, agino);
-                                /*
-                                 * Skip if this inode is 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++;
-
-                                /*
-                                 * Get the inode and fill in a single buffer.
-                                 */
-                                ubused = statstruct_size;
-                                error = formatter(mp, ino, ubufp, ubleft,
-                                                  &ubused, &fmterror);
-                                if (fmterror == BULKSTAT_RV_NOTHING) {
-                                        if (error && error != ENOENT &&
-                                                error != EINVAL) {
-                                                ubleft = 0;
-                                                rval = error;
-                                                break;
-                                        }
-                                        lastino = ino;
-                                        continue;
-                                }
-                                if (fmterror == BULKSTAT_RV_GIVEUP) {
-                                        ubleft = 0;
-                                        ASSERT(error);
-                                        rval = error;
-                                        break;
-                                }
-                                if (ubufp)
-                                        ubufp += ubused;
-                                ubleft -= ubused;
-                                ubelem++;
-                                lastino = ino;
-                        }
+                        struct xfs_bulkstat_agichunk ac;
+
+                        ac.ac_lastino = lastino;
+                        ac.ac_ubuffer = &ubuffer;
+                        ac.ac_ubleft = ubleft;
+                        ac.ac_ubelem = ubelem;
+                        error = xfs_bulkstat_ag_ichunk(mp, agno, irbp,
+                                        formatter, statstruct_size, &ac);
+                        if (error)
+                                rval = error;
+
+                        lastino = ac.ac_lastino;
+                        ubleft = ac.ac_ubleft;
+                        ubelem = ac.ac_ubelem;
 
                         cond_resched();
                 }
@@ -512,58 +542,10 @@ xfs_bulkstat(
         return rval;
 }
 
-/*
- * Return stat information in bulk (by-inode) for the filesystem.
- * Special case for non-sequential one inode bulkstat.
- */
-int                                     /* error status */
-xfs_bulkstat_single(
-        xfs_mount_t             *mp,    /* mount point for filesystem */
-        xfs_ino_t               *lastinop, /* inode to return */
-        char                    __user *buffer, /* buffer with inode stats */
-        int                     *done)  /* 1 if there are more stats to get */
-{
-        int                     count;  /* count value for bulkstat call */
-        int                     error;  /* return value */
-        xfs_ino_t               ino;    /* filesystem inode number */
-        int                     res;    /* result from bs1 */
-
-        /*
-         * note that requesting valid inode numbers which are not allocated
-         * to inodes will most likely cause xfs_imap_to_bp to generate warning
-         * messages about bad magic numbers. This is ok. The fact that
-         * the inode isn't actually an inode is handled by the
-         * error check below. Done this way to make the usual case faster
-         * at the expense of the error case.
-         */
-
-        ino = *lastinop;
-        error = xfs_bulkstat_one(mp, ino, buffer, sizeof(xfs_bstat_t),
-                                 NULL, &res);
-        if (error) {
-                /*
-                 * Special case way failed, do it the "long" way
-                 * to see if that works.
-                 */
-                (*lastinop)--;
-                count = 1;
-                if (xfs_bulkstat(mp, lastinop, &count, xfs_bulkstat_one,
-                                sizeof(xfs_bstat_t), buffer, done))
-                        return error;
-                if (count == 0 || (xfs_ino_t)*lastinop != ino)
-                        return error == EFSCORRUPTED ?
-                                XFS_ERROR(EINVAL) : error;
-                else
-                        return 0;
-        }
-        *done = 0;
-        return 0;
-}
-
 int
 xfs_inumbers_fmt(
         void                    __user *ubuffer, /* buffer to write to */
-        const xfs_inogrp_t      *buffer,        /* buffer to read from */
+        const struct xfs_inogrp *buffer,        /* buffer to read from */
         long                    count,          /* # of elements to read */
         long                    *written)       /* # of bytes written */
 {
@@ -578,127 +560,104 @@ xfs_inumbers_fmt(
  */
 int                                     /* error status */
 xfs_inumbers(
-        xfs_mount_t     *mp,            /* mount point for filesystem */
-        xfs_ino_t       *lastino,       /* last inode returned */
-        int             *count,         /* size of buffer/count returned */
-        void            __user *ubuffer,/* buffer with inode descriptions */
-        inumbers_fmt_pf formatter)
+        struct xfs_mount        *mp,/* mount point for filesystem */
+        xfs_ino_t               *lastino,/* last inode returned */
+        int                     *count,/* size of buffer/count returned */
+        void                    __user *ubuffer,/* buffer with inode descriptions */
+        inumbers_fmt_pf         formatter)
 {
-        xfs_buf_t       *agbp;
-        xfs_agino_t     agino;
-        xfs_agnumber_t  agno;
-        int             bcount;
-        xfs_inogrp_t    *buffer;
-        int             bufidx;
-        xfs_btree_cur_t *cur;
-        int             error;
-        xfs_inobt_rec_incore_t r;
-        int             i;
-        xfs_ino_t       ino;
-        int             left;
-        int             tmp;
-
-        ino = (xfs_ino_t)*lastino;
-        agno = XFS_INO_TO_AGNO(mp, ino);
-        agino = XFS_INO_TO_AGINO(mp, ino);
-        left = *count;
+        xfs_agnumber_t          agno = XFS_INO_TO_AGNO(mp, *lastino);
+        xfs_agino_t             agino = XFS_INO_TO_AGINO(mp, *lastino);
+        struct xfs_btree_cur    *cur = NULL;
+        struct xfs_buf          *agbp = NULL;
+        struct xfs_inogrp       *buffer;
+        int                     bcount;
+        int                     left = *count;
+        int                     bufidx = 0;
+        int                     error = 0;
+
         *count = 0;
+        if (agno >= mp->m_sb.sb_agcount ||
+            *lastino != XFS_AGINO_TO_INO(mp, agno, agino))
+                return error;
+
         bcount = MIN(left, (int)(PAGE_SIZE / sizeof(*buffer)));
         buffer = kmem_alloc(bcount * sizeof(*buffer), KM_SLEEP);
-        error = bufidx = 0;
-        cur = NULL;
-        agbp = NULL;
-        while (left > 0 && agno < mp->m_sb.sb_agcount) {
-                if (agbp == NULL) {
+        do {
+                struct xfs_inobt_rec_incore     r;
+                int                             stat;
+
+                if (!agbp) {
                         error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
-                        if (error) {
-                                /*
-                                 * If we can't read the AGI of this ag,
-                                 * then just skip to the next one.
-                                 */
-                                ASSERT(cur == NULL);
-                                agbp = NULL;
-                                agno++;
-                                agino = 0;
-                                continue;
-                        }
+                        if (error)
+                                break;
+
                         cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno,
                                                     XFS_BTNUM_INO);
                         error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_GE,
-                                                 &tmp);
-                        if (error) {
-                                xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
-                                cur = NULL;
-                                xfs_buf_relse(agbp);
-                                agbp = NULL;
-                                /*
-                                 * Move up the last inode in the current
-                                 * chunk.  The lookup_ge will always get
-                                 * us the first inode in the next chunk.
-                                 */
-                                agino += XFS_INODES_PER_CHUNK - 1;
-                                continue;
-                        }
-                }
-                error = xfs_inobt_get_rec(cur, &r, &i);
-                if (error || i == 0) {
-                        xfs_buf_relse(agbp);
-                        agbp = NULL;
-                        xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
-                        cur = NULL;
-                        agno++;
-                        agino = 0;
-                        continue;
+                                                 &stat);
+                        if (error)
+                                break;
+                        if (!stat)
+                                goto next_ag;
                 }
+
+                error = xfs_inobt_get_rec(cur, &r, &stat);
+                if (error)
+                        break;
+                if (!stat)
+                        goto next_ag;
+
                 agino = r.ir_startino + XFS_INODES_PER_CHUNK - 1;
                 buffer[bufidx].xi_startino =
                         XFS_AGINO_TO_INO(mp, agno, r.ir_startino);
                 buffer[bufidx].xi_alloccount =
                         XFS_INODES_PER_CHUNK - r.ir_freecount;
                 buffer[bufidx].xi_allocmask = ~r.ir_free;
-                bufidx++;
-                left--;
-                if (bufidx == bcount) {
-                        long written;
-                        if (formatter(ubuffer, buffer, bufidx, &written)) {
-                                error = XFS_ERROR(EFAULT);
+                if (++bufidx == bcount) {
+                        long    written;
+
+                        error = formatter(ubuffer, buffer, bufidx, &written);
+                        if (error)
                                 break;
-                        }
                         ubuffer += written;
                         *count += bufidx;
                         bufidx = 0;
                 }
-                if (left) {
-                        error = xfs_btree_increment(cur, 0, &tmp);
-                        if (error) {
-                                xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
-                                cur = NULL;
-                                xfs_buf_relse(agbp);
-                                agbp = NULL;
-                                /*
-                                 * The agino value has already been bumped.
-                                 * Just try to skip up to it.
-                                 */
-                                agino += XFS_INODES_PER_CHUNK;
-                                continue;
-                        }
-                }
-        }
+                if (!--left)
+                        break;
+
+                error = xfs_btree_increment(cur, 0, &stat);
+                if (error)
+                        break;
+                if (stat)
+                        continue;
+
+next_ag:
+                xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
+                cur = NULL;
+                xfs_buf_relse(agbp);
+                agbp = NULL;
+                agino = 0;
+        } while (++agno < mp->m_sb.sb_agcount);
+
         if (!error) {
                 if (bufidx) {
-                        long written;
-                        if (formatter(ubuffer, buffer, bufidx, &written))
-                                error = XFS_ERROR(EFAULT);
-                        else
+                        long    written;
+
+                        error = formatter(ubuffer, buffer, bufidx, &written);
+                        if (!error)
                                 *count += bufidx;
                 }
                 *lastino = XFS_AGINO_TO_INO(mp, agno, agino);
         }
+
         kmem_free(buffer);
         if (cur)
                 xfs_btree_del_cursor(cur, (error ? XFS_BTREE_ERROR :
                                            XFS_BTREE_NOERROR));
         if (agbp)
                 xfs_buf_relse(agbp);
+
         return error;
 }
diff --git a/fs/xfs/xfs_itable.h b/fs/xfs/xfs_itable.h
index 97295d91d170..aaed08022eb9 100644
--- a/fs/xfs/xfs_itable.h
+++ b/fs/xfs/xfs_itable.h
@@ -30,6 +30,22 @@ typedef int (*bulkstat_one_pf)(struct xfs_mount	*mp,
                                int              *ubused,
                                int              *stat);
 
+struct xfs_bulkstat_agichunk {
+        xfs_ino_t       ac_lastino;     /* last inode returned */
+        char            __user **ac_ubuffer;/* pointer into user's buffer */
+        int             ac_ubleft;      /* bytes left in user's buffer */
+        int             ac_ubelem;      /* spaces used in user's buffer */
+};
+
+int
+xfs_bulkstat_ag_ichunk(
+        struct xfs_mount                *mp,
+        xfs_agnumber_t                  agno,
+        struct xfs_inobt_rec_incore     *irbp,
+        bulkstat_one_pf                 formatter,
+        size_t                          statstruct_size,
+        struct xfs_bulkstat_agichunk    *acp);
+
 /*
  * Values for stat return value.
  */
@@ -50,13 +66,6 @@ xfs_bulkstat(
         char            __user *ubuffer,/* buffer with inode stats */
         int             *done);         /* 1 if there are more stats to get */
 
-int
-xfs_bulkstat_single(
-        xfs_mount_t             *mp,
-        xfs_ino_t               *lastinop,
-        char                    __user *buffer,
-        int                     *done);
-
 typedef int (*bulkstat_one_fmt_pf)(  /* used size in bytes or negative error */
         void                    __user *ubuffer, /* buffer to write to */
         int                     ubsize,          /* remaining user buffer sz */
diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h
index 825249d2dfc1..d10dc8f397c9 100644
--- a/fs/xfs/xfs_linux.h
+++ b/fs/xfs/xfs_linux.h
@@ -21,18 +21,6 @@
 #include <linux/types.h>
 
 /*
- * XFS_BIG_BLKNOS needs block layer disk addresses to be 64 bits.
- * XFS_BIG_INUMS requires XFS_BIG_BLKNOS to be set.
- */
-#if defined(CONFIG_LBDAF) || (BITS_PER_LONG == 64)
-# define XFS_BIG_BLKNOS 1
-# define XFS_BIG_INUMS  1
-#else
-# define XFS_BIG_BLKNOS 0
-# define XFS_BIG_INUMS  0
-#endif
-
-/*
  * Kernel specific type declarations for XFS
  */
 typedef signed char             __int8_t;
@@ -113,7 +101,7 @@ typedef __uint64_t __psunsigned_t;
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 
-#include "xfs_vnode.h"
+#include "xfs_fs.h"
 #include "xfs_stats.h"
 #include "xfs_sysctl.h"
 #include "xfs_iops.h"
@@ -191,6 +179,17 @@ typedef __uint64_t __psunsigned_t;
 #define MAX(a,b)        (max(a,b))
 #define howmany(x, y)   (((x)+((y)-1))/(y))
 
+/*
+ * XFS wrapper structure for sysfs support. It depends on external data
+ * structures and is embedded in various internal data structures to implement
+ * the XFS sysfs object heirarchy. Define it here for broad access throughout
+ * the codebase.
+ */
+struct xfs_kobj {
+        struct kobject          kobject;
+        struct completion       complete;
+};
+
 /* Kernel uid/gid conversion. These are used to convert to/from the on disk
  * uid_t/gid_t types to the kuid_t/kgid_t types that the kernel uses internally.
  * The conversion here is type only, the value will remain the same since we
@@ -331,7 +330,7 @@ static inline __uint64_t roundup_64(__uint64_t x, __uint32_t y)
 {
         x += y - 1;
         do_div(x, y);
-        return(x * y);
+        return x * y;
 }
 
 static inline __uint64_t howmany_64(__uint64_t x, __uint32_t y)
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 292308dede6d..ca4fd5bd8522 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -34,6 +34,7 @@
 #include "xfs_trace.h"
 #include "xfs_fsops.h"
 #include "xfs_cksum.h"
+#include "xfs_sysfs.h"
 
 kmem_zone_t     *xfs_log_ticket_zone;
 
@@ -283,7 +284,7 @@ xlog_grant_head_wait(
         return 0;
 shutdown:
         list_del_init(&tic->t_queue);
-        return XFS_ERROR(EIO);
+        return -EIO;
 }
 
 /*
@@ -377,7 +378,7 @@ xfs_log_regrant(
         int                     error = 0;
 
         if (XLOG_FORCED_SHUTDOWN(log))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         XFS_STATS_INC(xs_try_logspace);
 
@@ -446,7 +447,7 @@ xfs_log_reserve(
         ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);
 
         if (XLOG_FORCED_SHUTDOWN(log))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         XFS_STATS_INC(xs_try_logspace);
 
@@ -454,7 +455,7 @@ xfs_log_reserve(
         tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent,
                                 KM_SLEEP | KM_MAYFAIL);
         if (!tic)
-                return XFS_ERROR(ENOMEM);
+                return -ENOMEM;
 
         tic->t_trans_type = t_type;
         *ticp = tic;
@@ -590,7 +591,7 @@ xfs_log_release_iclog(
 {
         if (xlog_state_release_iclog(mp->m_log, iclog)) {
                 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
-                return EIO;
+                return -EIO;
         }
 
         return 0;
@@ -628,7 +629,7 @@ xfs_log_mount(
 
         mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
         if (IS_ERR(mp->m_log)) {
-                error = -PTR_ERR(mp->m_log);
+                error = PTR_ERR(mp->m_log);
                 goto out;
         }
 
@@ -652,18 +653,18 @@ xfs_log_mount(
                 xfs_warn(mp,
                 "Log size %d blocks too small, minimum size is %d blocks",
                          mp->m_sb.sb_logblocks, min_logfsbs);
-                error = EINVAL;
+                error = -EINVAL;
         } else if (mp->m_sb.sb_logblocks > XFS_MAX_LOG_BLOCKS) {
                 xfs_warn(mp,
                 "Log size %d blocks too large, maximum size is %lld blocks",
                          mp->m_sb.sb_logblocks, XFS_MAX_LOG_BLOCKS);
-                error = EINVAL;
+                error = -EINVAL;
         } else if (XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks) > XFS_MAX_LOG_BYTES) {
                 xfs_warn(mp,
                 "log size %lld bytes too large, maximum size is %lld bytes",
                          XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks),
                          XFS_MAX_LOG_BYTES);
-                error = EINVAL;
+                error = -EINVAL;
         }
         if (error) {
                 if (xfs_sb_version_hascrc(&mp->m_sb)) {
@@ -707,6 +708,11 @@ xfs_log_mount(
                 }
         }
 
+        error = xfs_sysfs_init(&mp->m_log->l_kobj, &xfs_log_ktype, &mp->m_kobj,
+                               "log");
+        if (error)
+                goto out_destroy_ail;
+
         /* Normal transactions can now occur */
         mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
 
@@ -947,6 +953,9 @@ xfs_log_unmount(
         xfs_log_quiesce(mp);
 
         xfs_trans_ail_destroy(mp);
+
+        xfs_sysfs_del(&mp->m_log->l_kobj);
+
         xlog_dealloc_log(mp->m_log);
 }
 
@@ -1313,7 +1322,7 @@ xlog_alloc_log(
         xlog_in_core_t          *iclog, *prev_iclog=NULL;
         xfs_buf_t               *bp;
         int                     i;
-        int                     error = ENOMEM;
+        int                     error = -ENOMEM;
         uint                    log2_size = 0;
 
         log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL);
@@ -1340,7 +1349,7 @@ xlog_alloc_log(
         xlog_grant_head_init(&log->l_reserve_head);
         xlog_grant_head_init(&log->l_write_head);
 
-        error = EFSCORRUPTED;
+        error = -EFSCORRUPTED;
         if (xfs_sb_version_hassector(&mp->m_sb)) {
                 log2_size = mp->m_sb.sb_logsectlog;
                 if (log2_size < BBSHIFT) {
@@ -1369,8 +1378,14 @@ xlog_alloc_log(
 
         xlog_get_iclog_buffer_size(mp, log);
 
-        error = ENOMEM;
-        bp = xfs_buf_alloc(mp->m_logdev_targp, 0, BTOBB(log->l_iclog_size), 0);
+        /*
+         * Use a NULL block for the extra log buffer used during splits so that
+         * it will trigger errors if we ever try to do IO on it without first
+         * having set it up properly.
+         */
+        error = -ENOMEM;
+        bp = xfs_buf_alloc(mp->m_logdev_targp, XFS_BUF_DADDR_NULL,
+                           BTOBB(log->l_iclog_size), 0);
         if (!bp)
                 goto out_free_log;
 
@@ -1463,7 +1478,7 @@ out_free_iclog:
 out_free_log:
         kmem_free(log);
 out:
-        return ERR_PTR(-error);
+        return ERR_PTR(error);
 }       /* xlog_alloc_log */
 
 
@@ -1661,7 +1676,7 @@ xlog_bdstrat(
 
         xfs_buf_lock(bp);
         if (iclog->ic_state & XLOG_STATE_IOERROR) {
-                xfs_buf_ioerror(bp, EIO);
+                xfs_buf_ioerror(bp, -EIO);
                 xfs_buf_stale(bp);
                 xfs_buf_ioend(bp, 0);
                 /*
@@ -2360,7 +2375,7 @@ xlog_write(
 
                         ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags);
                         if (!ophdr)
-                                return XFS_ERROR(EIO);
+                                return -EIO;
 
                         xlog_write_adv_cnt(&ptr, &len, &log_offset,
                                            sizeof(struct xlog_op_header));
@@ -2859,7 +2874,7 @@ restart:
         spin_lock(&log->l_icloglock);
         if (XLOG_FORCED_SHUTDOWN(log)) {
                 spin_unlock(&log->l_icloglock);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         iclog = log->l_iclog;
@@ -3047,7 +3062,7 @@ xlog_state_release_iclog(
         int             sync = 0;       /* do we sync? */
 
         if (iclog->ic_state & XLOG_STATE_IOERROR)
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         ASSERT(atomic_read(&iclog->ic_refcnt) > 0);
         if (!atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock))
@@ -3055,7 +3070,7 @@ xlog_state_release_iclog(
 
         if (iclog->ic_state & XLOG_STATE_IOERROR) {
                 spin_unlock(&log->l_icloglock);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
         ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE ||
                iclog->ic_state == XLOG_STATE_WANT_SYNC);
@@ -3172,7 +3187,7 @@ _xfs_log_force(
         iclog = log->l_iclog;
         if (iclog->ic_state & XLOG_STATE_IOERROR) {
                 spin_unlock(&log->l_icloglock);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         /* If the head iclog is not active nor dirty, we just attach
@@ -3210,7 +3225,7 @@ _xfs_log_force(
                                 spin_unlock(&log->l_icloglock);
 
                                 if (xlog_state_release_iclog(log, iclog))
-                                        return XFS_ERROR(EIO);
+                                        return -EIO;
 
                                 if (log_flushed)
                                         *log_flushed = 1;
@@ -3246,7 +3261,7 @@ maybe_sleep:
                  */
                 if (iclog->ic_state & XLOG_STATE_IOERROR) {
                         spin_unlock(&log->l_icloglock);
-                        return XFS_ERROR(EIO);
+                        return -EIO;
                 }
                 XFS_STATS_INC(xs_log_force_sleep);
                 xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
@@ -3256,7 +3271,7 @@ maybe_sleep:
                  * and the memory read should be atomic.
                  */
                 if (iclog->ic_state & XLOG_STATE_IOERROR)
-                        return XFS_ERROR(EIO);
+                        return -EIO;
                 if (log_flushed)
                         *log_flushed = 1;
         } else {
@@ -3324,7 +3339,7 @@ try_again:
         iclog = log->l_iclog;
         if (iclog->ic_state & XLOG_STATE_IOERROR) {
                 spin_unlock(&log->l_icloglock);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         do {
@@ -3375,7 +3390,7 @@ try_again:
                         xlog_state_switch_iclogs(log, iclog, 0);
                         spin_unlock(&log->l_icloglock);
                         if (xlog_state_release_iclog(log, iclog))
-                                return XFS_ERROR(EIO);
+                                return -EIO;
                         if (log_flushed)
                                 *log_flushed = 1;
                         spin_lock(&log->l_icloglock);
@@ -3390,7 +3405,7 @@ try_again:
                          */
                         if (iclog->ic_state & XLOG_STATE_IOERROR) {
                                 spin_unlock(&log->l_icloglock);
-                                return XFS_ERROR(EIO);
+                                return -EIO;
                         }
                         XFS_STATS_INC(xs_log_force_sleep);
                         xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
@@ -3400,7 +3415,7 @@ try_again:
                          * and the memory read should be atomic.
                          */
                         if (iclog->ic_state & XLOG_STATE_IOERROR)
-                                return XFS_ERROR(EIO);
+                                return -EIO;
 
                         if (log_flushed)
                                 *log_flushed = 1;
diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index b3425b34e3d5..f6b79e5325dd 100644
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -78,8 +78,6 @@ xlog_cil_init_post_recovery(
 {
         log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);
         log->l_cilp->xc_ctx->sequence = 1;
-        log->l_cilp->xc_ctx->commit_lsn = xlog_assign_lsn(log->l_curr_cycle,
-                                                                log->l_curr_block);
 }
 
 /*
@@ -634,7 +632,7 @@ out_abort_free_ticket:
         xfs_log_ticket_put(tic);
 out_abort:
         xlog_cil_committed(ctx, XFS_LI_ABORTED);
-        return XFS_ERROR(EIO);
+        return -EIO;
 }
 
 static void
@@ -928,12 +926,12 @@ xlog_cil_init(
 
         cil = kmem_zalloc(sizeof(*cil), KM_SLEEP|KM_MAYFAIL);
         if (!cil)
-                return ENOMEM;
+                return -ENOMEM;
 
         ctx = kmem_zalloc(sizeof(*ctx), KM_SLEEP|KM_MAYFAIL);
         if (!ctx) {
                 kmem_free(cil);
-                return ENOMEM;
+                return -ENOMEM;
         }
 
         INIT_WORK(&cil->xc_push_work, xlog_cil_push_work);
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index 9bc403a9e54f..db7cbdeb2b42 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -405,6 +405,8 @@ struct xlog {
         struct xlog_grant_head  l_reserve_head;
         struct xlog_grant_head  l_write_head;
 
+        struct xfs_kobj         l_kobj;
+
         /* The following field are used for debugging; need to hold icloglock */
 #ifdef DEBUG
         char                    *l_iclog_bak[XLOG_MAX_ICLOGS];
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 981af0f6504b..1fd5787add99 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -179,7 +179,7 @@ xlog_bread_noalign(
                 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
                         nbblks);
                 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
-                return EFSCORRUPTED;
+                return -EFSCORRUPTED;
         }
 
         blk_no = round_down(blk_no, log->l_sectBBsize);
@@ -194,7 +194,7 @@ xlog_bread_noalign(
         bp->b_error = 0;
 
         if (XFS_FORCED_SHUTDOWN(log->l_mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         xfs_buf_iorequest(bp);
         error = xfs_buf_iowait(bp);
@@ -268,7 +268,7 @@ xlog_bwrite(
                 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
                         nbblks);
                 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
-                return EFSCORRUPTED;
+                return -EFSCORRUPTED;
         }
 
         blk_no = round_down(blk_no, log->l_sectBBsize);
@@ -330,14 +330,14 @@ xlog_header_check_recover(
                 xlog_header_check_dump(mp, head);
                 XFS_ERROR_REPORT("xlog_header_check_recover(1)",
                                  XFS_ERRLEVEL_HIGH, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
                 xfs_warn(mp,
         "dirty log entry has mismatched uuid - can't recover");
                 xlog_header_check_dump(mp, head);
                 XFS_ERROR_REPORT("xlog_header_check_recover(2)",
                                  XFS_ERRLEVEL_HIGH, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         return 0;
 }
@@ -364,7 +364,7 @@ xlog_header_check_mount(
                 xlog_header_check_dump(mp, head);
                 XFS_ERROR_REPORT("xlog_header_check_mount",
                                  XFS_ERRLEVEL_HIGH, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         return 0;
 }
@@ -462,7 +462,7 @@ xlog_find_verify_cycle(
         while (!(bp = xlog_get_bp(log, bufblks))) {
                 bufblks >>= 1;
                 if (bufblks < log->l_sectBBsize)
-                        return ENOMEM;
+                        return -ENOMEM;
         }
 
         for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
@@ -524,7 +524,7 @@ xlog_find_verify_log_record(
 
         if (!(bp = xlog_get_bp(log, num_blks))) {
                 if (!(bp = xlog_get_bp(log, 1)))
-                        return ENOMEM;
+                        return -ENOMEM;
                 smallmem = 1;
         } else {
                 error = xlog_bread(log, start_blk, num_blks, bp, &offset);
@@ -539,7 +539,7 @@ xlog_find_verify_log_record(
                         xfs_warn(log->l_mp,
                 "Log inconsistent (didn't find previous header)");
                         ASSERT(0);
-                        error = XFS_ERROR(EIO);
+                        error = -EIO;
                         goto out;
                 }
 
@@ -564,7 +564,7 @@ xlog_find_verify_log_record(
          * will be called again for the end of the physical log.
          */
         if (i == -1) {
-                error = -1;
+                error = 1;
                 goto out;
         }
 
@@ -628,7 +628,12 @@ xlog_find_head(
         int             error, log_bbnum = log->l_logBBsize;
 
         /* Is the end of the log device zeroed? */
-        if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
+        error = xlog_find_zeroed(log, &first_blk);
+        if (error < 0) {
+                xfs_warn(log->l_mp, "empty log check failed");
+                return error;
+        }
+        if (error == 1) {
                 *return_head_blk = first_blk;
 
                 /* Is the whole lot zeroed? */
@@ -641,15 +646,12 @@ xlog_find_head(
                 }
 
                 return 0;
-        } else if (error) {
-                xfs_warn(log->l_mp, "empty log check failed");
-                return error;
         }
 
         first_blk = 0;                  /* get cycle # of 1st block */
         bp = xlog_get_bp(log, 1);
         if (!bp)
-                return ENOMEM;
+                return -ENOMEM;
 
         error = xlog_bread(log, 0, 1, bp, &offset);
         if (error)
@@ -818,29 +820,29 @@ validate_head:
                 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
 
                 /* start ptr at last block ptr before head_blk */
-                if ((error = xlog_find_verify_log_record(log, start_blk,
-                                                        &head_blk, 0)) == -1) {
-                        error = XFS_ERROR(EIO);
-                        goto bp_err;
-                } else if (error)
+                error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
+                if (error == 1)
+                        error = -EIO;
+                if (error)
                         goto bp_err;
         } else {
                 start_blk = 0;
                 ASSERT(head_blk <= INT_MAX);
-                if ((error = xlog_find_verify_log_record(log, start_blk,
-                                                        &head_blk, 0)) == -1) {
+                error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
+                if (error < 0)
+                        goto bp_err;
+                if (error == 1) {
                         /* We hit the beginning of the log during our search */
                         start_blk = log_bbnum - (num_scan_bblks - head_blk);
                         new_blk = log_bbnum;
                         ASSERT(start_blk <= INT_MAX &&
                                 (xfs_daddr_t) log_bbnum-start_blk >= 0);
                         ASSERT(head_blk <= INT_MAX);
-                        if ((error = xlog_find_verify_log_record(log,
-                                                        start_blk, &new_blk,
-                                                        (int)head_blk)) == -1) {
-                                error = XFS_ERROR(EIO);
-                                goto bp_err;
-                        } else if (error)
+                        error = xlog_find_verify_log_record(log, start_blk,
+                                                        &new_blk, (int)head_blk);
+                        if (error == 1)
+                                error = -EIO;
+                        if (error)
                                 goto bp_err;
                         if (new_blk != log_bbnum)
                                 head_blk = new_blk;
@@ -911,7 +913,7 @@ xlog_find_tail(
 
         bp = xlog_get_bp(log, 1);
         if (!bp)
-                return ENOMEM;
+                return -ENOMEM;
         if (*head_blk == 0) {                           /* special case */
                 error = xlog_bread(log, 0, 1, bp, &offset);
                 if (error)
@@ -961,7 +963,7 @@ xlog_find_tail(
                 xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
                 xlog_put_bp(bp);
                 ASSERT(0);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         /* find blk_no of tail of log */
@@ -1092,8 +1094,8 @@ done:
  *
  * Return:
  *      0  => the log is completely written to
- *      -1 => use *blk_no as the first block of the log
- *      >0 => error has occurred
+ *      1 => use *blk_no as the first block of the log
+ *      <0 => error has occurred
  */
 STATIC int
 xlog_find_zeroed(
@@ -1112,7 +1114,7 @@ xlog_find_zeroed(
         /* check totally zeroed log */
         bp = xlog_get_bp(log, 1);
         if (!bp)
-                return ENOMEM;
+                return -ENOMEM;
         error = xlog_bread(log, 0, 1, bp, &offset);
         if (error)
                 goto bp_err;
@@ -1121,7 +1123,7 @@ xlog_find_zeroed(
         if (first_cycle == 0) {         /* completely zeroed log */
                 *blk_no = 0;
                 xlog_put_bp(bp);
-                return -1;
+                return 1;
         }
 
         /* check partially zeroed log */
@@ -1141,7 +1143,7 @@ xlog_find_zeroed(
                  */
                 xfs_warn(log->l_mp,
                         "Log inconsistent or not a log (last==0, first!=1)");
-                error = XFS_ERROR(EINVAL);
+                error = -EINVAL;
                 goto bp_err;
         }
 
@@ -1179,19 +1181,18 @@ xlog_find_zeroed(
          * Potentially backup over partial log record write.  We don't need
          * to search the end of the log because we know it is zero.
          */
-        if ((error = xlog_find_verify_log_record(log, start_blk,
-                                &last_blk, 0)) == -1) {
-            error = XFS_ERROR(EIO);
-            goto bp_err;
-        } else if (error)
-            goto bp_err;
+        error = xlog_find_verify_log_record(log, start_blk, &last_blk, 0);
+        if (error == 1)
+                error = -EIO;
+        if (error)
+                goto bp_err;
 
         *blk_no = last_blk;
 bp_err:
         xlog_put_bp(bp);
         if (error)
                 return error;
-        return -1;
+        return 1;
 }
 
 /*
@@ -1251,7 +1252,7 @@ xlog_write_log_records(
         while (!(bp = xlog_get_bp(log, bufblks))) {
                 bufblks >>= 1;
                 if (bufblks < sectbb)
-                        return ENOMEM;
+                        return -ENOMEM;
         }
 
         /* We may need to do a read at the start to fill in part of
@@ -1354,7 +1355,7 @@ xlog_clear_stale_blocks(
                 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
                                          XFS_ERRLEVEL_LOW, log->l_mp);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
                 tail_distance = tail_block + (log->l_logBBsize - head_block);
         } else {
@@ -1366,7 +1367,7 @@ xlog_clear_stale_blocks(
                 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
                                          XFS_ERRLEVEL_LOW, log->l_mp);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
                 tail_distance = tail_block - head_block;
         }
@@ -1551,7 +1552,7 @@ xlog_recover_add_to_trans(
                         xfs_warn(log->l_mp, "%s: bad header magic number",
                                 __func__);
                         ASSERT(0);
-                        return XFS_ERROR(EIO);
+                        return -EIO;
                 }
                 if (len == sizeof(xfs_trans_header_t))
                         xlog_recover_add_item(&trans->r_itemq);
@@ -1581,7 +1582,7 @@ xlog_recover_add_to_trans(
                                   in_f->ilf_size);
                         ASSERT(0);
                         kmem_free(ptr);
-                        return XFS_ERROR(EIO);
+                        return -EIO;
                 }
 
                 item->ri_total = in_f->ilf_size;
@@ -1702,7 +1703,7 @@ xlog_recover_reorder_trans(
                          */
                         if (!list_empty(&sort_list))
                                 list_splice_init(&sort_list, &trans->r_itemq);
-                        error = XFS_ERROR(EIO);
+                        error = -EIO;
                         goto out;
                 }
         }
@@ -1943,7 +1944,7 @@ xlog_recover_do_inode_buffer(
                                 item, bp);
                         XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
                                          XFS_ERRLEVEL_LOW, mp);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        return -EFSCORRUPTED;
                 }
 
                 buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
@@ -2125,6 +2126,17 @@ xlog_recover_validate_buf_type(
         __uint16_t              magic16;
         __uint16_t              magicda;
 
+        /*
+         * We can only do post recovery validation on items on CRC enabled
+         * fielsystems as we need to know when the buffer was written to be able
+         * to determine if we should have replayed the item. If we replay old
+         * metadata over a newer buffer, then it will enter a temporarily
+         * inconsistent state resulting in verification failures. Hence for now
+         * just avoid the verification stage for non-crc filesystems
+         */
+        if (!xfs_sb_version_hascrc(&mp->m_sb))
+                return;
+
         magic32 = be32_to_cpu(*(__be32 *)bp->b_addr);
         magic16 = be16_to_cpu(*(__be16*)bp->b_addr);
         magicda = be16_to_cpu(info->magic);
@@ -2162,8 +2174,6 @@ xlog_recover_validate_buf_type(
                 bp->b_ops = &xfs_agf_buf_ops;
                 break;
         case XFS_BLFT_AGFL_BUF:
-                if (!xfs_sb_version_hascrc(&mp->m_sb))
-                        break;
                 if (magic32 != XFS_AGFL_MAGIC) {
                         xfs_warn(mp, "Bad AGFL block magic!");
                         ASSERT(0);
@@ -2196,10 +2206,6 @@ xlog_recover_validate_buf_type(
 #endif
                 break;
         case XFS_BLFT_DINO_BUF:
-                /*
-                 * we get here with inode allocation buffers, not buffers that
-                 * track unlinked list changes.
-                 */
                 if (magic16 != XFS_DINODE_MAGIC) {
                         xfs_warn(mp, "Bad INODE block magic!");
                         ASSERT(0);
@@ -2279,8 +2285,6 @@ xlog_recover_validate_buf_type(
                 bp->b_ops = &xfs_attr3_leaf_buf_ops;
                 break;
         case XFS_BLFT_ATTR_RMT_BUF:
-                if (!xfs_sb_version_hascrc(&mp->m_sb))
-                        break;
                 if (magic32 != XFS_ATTR3_RMT_MAGIC) {
                         xfs_warn(mp, "Bad attr remote magic!");
                         ASSERT(0);
@@ -2387,16 +2391,7 @@ xlog_recover_do_reg_buffer(
         /* Shouldn't be any more regions */
         ASSERT(i == item->ri_total);
 
-        /*
-         * We can only do post recovery validation on items on CRC enabled
-         * fielsystems as we need to know when the buffer was written to be able
-         * to determine if we should have replayed the item. If we replay old
-         * metadata over a newer buffer, then it will enter a temporarily
-         * inconsistent state resulting in verification failures. Hence for now
-         * just avoid the verification stage for non-crc filesystems
-         */
-        if (xfs_sb_version_hascrc(&mp->m_sb))
-                xlog_recover_validate_buf_type(mp, bp, buf_f);
+        xlog_recover_validate_buf_type(mp, bp, buf_f);
 }
 
 /*
@@ -2404,8 +2399,11 @@ xlog_recover_do_reg_buffer(
  * Simple algorithm: if we have found a QUOTAOFF log item of the same type
  * (ie. USR or GRP), then just toss this buffer away; don't recover it.
  * Else, treat it as a regular buffer and do recovery.
+ *
+ * Return false if the buffer was tossed and true if we recovered the buffer to
+ * indicate to the caller if the buffer needs writing.
  */
-STATIC void
+STATIC bool
 xlog_recover_do_dquot_buffer(
         struct xfs_mount                *mp,
         struct xlog                     *log,
@@ -2420,9 +2418,8 @@ xlog_recover_do_dquot_buffer(
         /*
          * Filesystems are required to send in quota flags at mount time.
          */
-        if (mp->m_qflags == 0) {
-                return;
-        }
+        if (!mp->m_qflags)
+                return false;
 
         type = 0;
         if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
@@ -2435,9 +2432,10 @@ xlog_recover_do_dquot_buffer(
          * This type of quotas was turned off, so ignore this buffer
          */
         if (log->l_quotaoffs_flag & type)
-                return;
+                return false;
 
         xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
+        return true;
 }
 
 /*
@@ -2496,7 +2494,7 @@ xlog_recover_buffer_pass2(
         bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
                           buf_flags, NULL);
         if (!bp)
-                return XFS_ERROR(ENOMEM);
+                return -ENOMEM;
         error = bp->b_error;
         if (error) {
                 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
@@ -2504,23 +2502,44 @@ xlog_recover_buffer_pass2(
         }
 
         /*
-         * recover the buffer only if we get an LSN from it and it's less than
+         * Recover the buffer only if we get an LSN from it and it's less than
          * the lsn of the transaction we are replaying.
+         *
+         * Note that we have to be extremely careful of readahead here.
+         * Readahead does not attach verfiers to the buffers so if we don't
+         * actually do any replay after readahead because of the LSN we found
+         * in the buffer if more recent than that current transaction then we
+         * need to attach the verifier directly. Failure to do so can lead to
+         * future recovery actions (e.g. EFI and unlinked list recovery) can
+         * operate on the buffers and they won't get the verifier attached. This
+         * can lead to blocks on disk having the correct content but a stale
+         * CRC.
+         *
+         * It is safe to assume these clean buffers are currently up to date.
+         * If the buffer is dirtied by a later transaction being replayed, then
+         * the verifier will be reset to match whatever recover turns that
+         * buffer into.
          */
         lsn = xlog_recover_get_buf_lsn(mp, bp);
-        if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0)
+        if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
+                xlog_recover_validate_buf_type(mp, bp, buf_f);
                 goto out_release;
+        }
 
         if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
                 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
+                if (error)
+                        goto out_release;
         } else if (buf_f->blf_flags &
                   (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
-                xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
+                bool    dirty;
+
+                dirty = xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
+                if (!dirty)
+                        goto out_release;
         } else {
                 xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
         }
-        if (error)
-                goto out_release;
 
         /*
          * Perform delayed write on the buffer.  Asynchronous writes will be
@@ -2598,7 +2617,7 @@ xfs_recover_inode_owner_change(
 
         ip = xfs_inode_alloc(mp, in_f->ilf_ino);
         if (!ip)
-                return ENOMEM;
+                return -ENOMEM;
 
         /* instantiate the inode */
         xfs_dinode_from_disk(&ip->i_d, dip);
@@ -2676,7 +2695,7 @@ xlog_recover_inode_pass2(
         bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0,
                           &xfs_inode_buf_ops);
         if (!bp) {
-                error = ENOMEM;
+                error = -ENOMEM;
                 goto error;
         }
         error = bp->b_error;
@@ -2697,7 +2716,7 @@ xlog_recover_inode_pass2(
                         __func__, dip, bp, in_f->ilf_ino);
                 XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
                                  XFS_ERRLEVEL_LOW, mp);
-                error = EFSCORRUPTED;
+                error = -EFSCORRUPTED;
                 goto out_release;
         }
         dicp = item->ri_buf[1].i_addr;
@@ -2707,7 +2726,7 @@ xlog_recover_inode_pass2(
                         __func__, item, in_f->ilf_ino);
                 XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
                                  XFS_ERRLEVEL_LOW, mp);
-                error = EFSCORRUPTED;
+                error = -EFSCORRUPTED;
                 goto out_release;
         }
 
@@ -2764,7 +2783,7 @@ xlog_recover_inode_pass2(
                 "%s: Bad regular inode log record, rec ptr 0x%p, "
                 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
                                 __func__, item, dip, bp, in_f->ilf_ino);
-                        error = EFSCORRUPTED;
+                        error = -EFSCORRUPTED;
                         goto out_release;
                 }
         } else if (unlikely(S_ISDIR(dicp->di_mode))) {
@@ -2777,7 +2796,7 @@ xlog_recover_inode_pass2(
                 "%s: Bad dir inode log record, rec ptr 0x%p, "
                 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
                                 __func__, item, dip, bp, in_f->ilf_ino);
-                        error = EFSCORRUPTED;
+                        error = -EFSCORRUPTED;
                         goto out_release;
                 }
         }
@@ -2790,7 +2809,7 @@ xlog_recover_inode_pass2(
                         __func__, item, dip, bp, in_f->ilf_ino,
                         dicp->di_nextents + dicp->di_anextents,
                         dicp->di_nblocks);
-                error = EFSCORRUPTED;
+                error = -EFSCORRUPTED;
                 goto out_release;
         }
         if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
@@ -2800,7 +2819,7 @@ xlog_recover_inode_pass2(
         "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
         "dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__,
                         item, dip, bp, in_f->ilf_ino, dicp->di_forkoff);
-                error = EFSCORRUPTED;
+                error = -EFSCORRUPTED;
                 goto out_release;
         }
         isize = xfs_icdinode_size(dicp->di_version);
@@ -2810,7 +2829,7 @@ xlog_recover_inode_pass2(
                 xfs_alert(mp,
                         "%s: Bad inode log record length %d, rec ptr 0x%p",
                         __func__, item->ri_buf[1].i_len, item);
-                error = EFSCORRUPTED;
+                error = -EFSCORRUPTED;
                 goto out_release;
         }
 
@@ -2898,7 +2917,7 @@ xlog_recover_inode_pass2(
                 default:
                         xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
                         ASSERT(0);
-                        error = EIO;
+                        error = -EIO;
                         goto out_release;
                 }
         }
@@ -2919,7 +2938,7 @@ out_release:
 error:
         if (need_free)
                 kmem_free(in_f);
-        return XFS_ERROR(error);
+        return error;
 }
 
 /*
@@ -2946,7 +2965,7 @@ xlog_recover_quotaoff_pass1(
         if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
                 log->l_quotaoffs_flag |= XFS_DQ_GROUP;
 
-        return (0);
+        return 0;
 }
 
 /*
@@ -2971,17 +2990,17 @@ xlog_recover_dquot_pass2(
          * Filesystems are required to send in quota flags at mount time.
          */
         if (mp->m_qflags == 0)
-                return (0);
+                return 0;
 
         recddq = item->ri_buf[1].i_addr;
         if (recddq == NULL) {
                 xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
         if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
                 xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
                         item->ri_buf[1].i_len, __func__);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         /*
@@ -2990,7 +3009,7 @@ xlog_recover_dquot_pass2(
         type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
         ASSERT(type);
         if (log->l_quotaoffs_flag & type)
-                return (0);
+                return 0;
 
         /*
          * At this point we know that quota was _not_ turned off.
@@ -3007,12 +3026,19 @@ xlog_recover_dquot_pass2(
         error = xfs_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
                            "xlog_recover_dquot_pass2 (log copy)");
         if (error)
-                return XFS_ERROR(EIO);
+                return -EIO;
         ASSERT(dq_f->qlf_len == 1);
 
+        /*
+         * At this point we are assuming that the dquots have been allocated
+         * and hence the buffer has valid dquots stamped in it. It should,
+         * therefore, pass verifier validation. If the dquot is bad, then the
+         * we'll return an error here, so we don't need to specifically check
+         * the dquot in the buffer after the verifier has run.
+         */
         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno,
                                    XFS_FSB_TO_BB(mp, dq_f->qlf_len), 0, &bp,
-                                   NULL);
+                                   &xfs_dquot_buf_ops);
         if (error)
                 return error;
 
@@ -3020,18 +3046,6 @@ xlog_recover_dquot_pass2(
         ddq = (xfs_disk_dquot_t *)xfs_buf_offset(bp, dq_f->qlf_boffset);
 
         /*
-         * At least the magic num portion should be on disk because this
-         * was among a chunk of dquots created earlier, and we did some
-         * minimal initialization then.
-         */
-        error = xfs_dqcheck(mp, ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
-                           "xlog_recover_dquot_pass2");
-        if (error) {
-                xfs_buf_relse(bp);
-                return XFS_ERROR(EIO);
-        }
-
-        /*
          * If the dquot has an LSN in it, recover the dquot only if it's less
          * than the lsn of the transaction we are replaying.
          */
@@ -3178,38 +3192,38 @@ xlog_recover_do_icreate_pass2(
         icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
         if (icl->icl_type != XFS_LI_ICREATE) {
                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad type");
-                return EINVAL;
+                return -EINVAL;
         }
 
         if (icl->icl_size != 1) {
                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad icl size");
-                return EINVAL;
+                return -EINVAL;
         }
 
         agno = be32_to_cpu(icl->icl_ag);
         if (agno >= mp->m_sb.sb_agcount) {
                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agno");
-                return EINVAL;
+                return -EINVAL;
         }
         agbno = be32_to_cpu(icl->icl_agbno);
         if (!agbno || agbno == NULLAGBLOCK || agbno >= mp->m_sb.sb_agblocks) {
                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agbno");
-                return EINVAL;
+                return -EINVAL;
         }
         isize = be32_to_cpu(icl->icl_isize);
         if (isize != mp->m_sb.sb_inodesize) {
                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad isize");
-                return EINVAL;
+                return -EINVAL;
         }
         count = be32_to_cpu(icl->icl_count);
         if (!count) {
                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count");
-                return EINVAL;
+                return -EINVAL;
         }
         length = be32_to_cpu(icl->icl_length);
         if (!length || length >= mp->m_sb.sb_agblocks) {
                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad length");
-                return EINVAL;
+                return -EINVAL;
         }
 
         /* existing allocation is fixed value */
@@ -3218,7 +3232,7 @@ xlog_recover_do_icreate_pass2(
         if (count != mp->m_ialloc_inos ||
              length != mp->m_ialloc_blks) {
                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count 2");
-                return EINVAL;
+                return -EINVAL;
         }
 
         /*
@@ -3389,7 +3403,7 @@ xlog_recover_commit_pass1(
                 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
                         __func__, ITEM_TYPE(item));
                 ASSERT(0);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 }
 
@@ -3425,7 +3439,7 @@ xlog_recover_commit_pass2(
                 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
                         __func__, ITEM_TYPE(item));
                 ASSERT(0);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 }
 
@@ -3560,7 +3574,7 @@ xlog_recover_process_data(
 
         /* check the log format matches our own - else we can't recover */
         if (xlog_header_check_recover(log->l_mp, rhead))
-                return (XFS_ERROR(EIO));
+                return -EIO;
 
         while ((dp < lp) && num_logops) {
                 ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
@@ -3571,7 +3585,7 @@ xlog_recover_process_data(
                         xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
                                         __func__, ohead->oh_clientid);
                         ASSERT(0);
-                        return (XFS_ERROR(EIO));
+                        return -EIO;
                 }
                 tid = be32_to_cpu(ohead->oh_tid);
                 hash = XLOG_RHASH(tid);
@@ -3585,7 +3599,7 @@ xlog_recover_process_data(
                                 xfs_warn(log->l_mp, "%s: bad length 0x%x",
                                         __func__, be32_to_cpu(ohead->oh_len));
                                 WARN_ON(1);
-                                return (XFS_ERROR(EIO));
+                                return -EIO;
                         }
                         flags = ohead->oh_flags & ~XLOG_END_TRANS;
                         if (flags & XLOG_WAS_CONT_TRANS)
@@ -3607,7 +3621,7 @@ xlog_recover_process_data(
                                 xfs_warn(log->l_mp, "%s: bad transaction",
                                         __func__);
                                 ASSERT(0);
-                                error = XFS_ERROR(EIO);
+                                error = -EIO;
                                 break;
                         case 0:
                         case XLOG_CONTINUE_TRANS:
@@ -3618,7 +3632,7 @@ xlog_recover_process_data(
                                 xfs_warn(log->l_mp, "%s: bad flag 0x%x",
                                         __func__, flags);
                                 ASSERT(0);
-                                error = XFS_ERROR(EIO);
+                                error = -EIO;
                                 break;
                         }
                         if (error) {
@@ -3669,7 +3683,7 @@ xlog_recover_process_efi(
                          */
                         set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
                         xfs_efi_release(efip, efip->efi_format.efi_nextents);
-                        return XFS_ERROR(EIO);
+                        return -EIO;
                 }
         }
 
@@ -3969,7 +3983,7 @@ xlog_unpack_data_crc(
                  * CRC protection by punting an error back up the stack.
                  */
                 if (xfs_sb_version_hascrc(&log->l_mp->m_sb))
-                        return EFSCORRUPTED;
+                        return -EFSCORRUPTED;
         }
 
         return 0;
@@ -4018,14 +4032,14 @@ xlog_valid_rec_header(
         if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
                 XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
                                 XFS_ERRLEVEL_LOW, log->l_mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         if (unlikely(
             (!rhead->h_version ||
             (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
                 xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
                         __func__, be32_to_cpu(rhead->h_version));
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         /* LR body must have data or it wouldn't have been written */
@@ -4033,12 +4047,12 @@ xlog_valid_rec_header(
         if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
                 XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
                                 XFS_ERRLEVEL_LOW, log->l_mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
                 XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
                                 XFS_ERRLEVEL_LOW, log->l_mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
         return 0;
 }
@@ -4081,7 +4095,7 @@ xlog_do_recovery_pass(
                  */
                 hbp = xlog_get_bp(log, 1);
                 if (!hbp)
-                        return ENOMEM;
+                        return -ENOMEM;
 
                 error = xlog_bread(log, tail_blk, 1, hbp, &offset);
                 if (error)
@@ -4110,11 +4124,11 @@ xlog_do_recovery_pass(
         }
 
         if (!hbp)
-                return ENOMEM;
+                return -ENOMEM;
         dbp = xlog_get_bp(log, BTOBB(h_size));
         if (!dbp) {
                 xlog_put_bp(hbp);
-                return ENOMEM;
+                return -ENOMEM;
         }
 
         memset(rhash, 0, sizeof(rhash));
@@ -4388,7 +4402,7 @@ xlog_do_recover(
          * If IO errors happened during recovery, bail out.
          */
         if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
-                return (EIO);
+                return -EIO;
         }
 
         /*
@@ -4415,7 +4429,7 @@ xlog_do_recover(
 
         if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
                 xfs_buf_relse(bp);
-                return XFS_ERROR(EIO);
+                return -EIO;
         }
 
         xfs_buf_iorequest(bp);
@@ -4492,7 +4506,7 @@ xlog_recover(
 "Please recover the log on a kernel that supports the unknown features.",
                                 (log->l_mp->m_sb.sb_features_log_incompat &
                                         XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
-                        return EINVAL;
+                        return -EINVAL;
                 }
 
                 xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 3507cd0ec400..fbf0384a466f 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -42,6 +42,7 @@
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_dinode.h"
+#include "xfs_sysfs.h"
 
 
 #ifdef HAVE_PERCPU_SB
@@ -60,6 +61,8 @@ static DEFINE_MUTEX(xfs_uuid_table_mutex);
 static int xfs_uuid_table_size;
 static uuid_t *xfs_uuid_table;
 
+extern struct kset *xfs_kset;
+
 /*
  * See if the UUID is unique among mounted XFS filesystems.
  * Mount fails if UUID is nil or a FS with the same UUID is already mounted.
@@ -76,7 +79,7 @@ xfs_uuid_mount(
 
         if (uuid_is_nil(uuid)) {
                 xfs_warn(mp, "Filesystem has nil UUID - can't mount");
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         mutex_lock(&xfs_uuid_table_mutex);
@@ -104,7 +107,7 @@ xfs_uuid_mount(
  out_duplicate:
         mutex_unlock(&xfs_uuid_table_mutex);
         xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
-        return XFS_ERROR(EINVAL);
+        return -EINVAL;
 }
 
 STATIC void
@@ -173,13 +176,9 @@ xfs_sb_validate_fsb_count(
         ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
         ASSERT(sbp->sb_blocklog >= BBSHIFT);
 
-#if XFS_BIG_BLKNOS     /* Limited by ULONG_MAX of page cache index */
+        /* Limited by ULONG_MAX of page cache index */
         if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
-                return EFBIG;
-#else                  /* Limited by UINT_MAX of sectors */
-        if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX)
-                return EFBIG;
-#endif
+                return -EFBIG;
         return 0;
 }
 
@@ -250,9 +249,9 @@ xfs_initialize_perag(
                 mp->m_flags &= ~XFS_MOUNT_32BITINODES;
 
         if (mp->m_flags & XFS_MOUNT_32BITINODES)
-                index = xfs_set_inode32(mp);
+                index = xfs_set_inode32(mp, agcount);
         else
-                index = xfs_set_inode64(mp);
+                index = xfs_set_inode64(mp, agcount);
 
         if (maxagi)
                 *maxagi = index;
@@ -308,15 +307,15 @@ reread:
         if (!bp) {
                 if (loud)
                         xfs_warn(mp, "SB buffer read failed");
-                return EIO;
+                return -EIO;
         }
         if (bp->b_error) {
                 error = bp->b_error;
                 if (loud)
                         xfs_warn(mp, "SB validate failed with error %d.", error);
                 /* bad CRC means corrupted metadata */
-                if (error == EFSBADCRC)
-                        error = EFSCORRUPTED;
+                if (error == -EFSBADCRC)
+                        error = -EFSCORRUPTED;
                 goto release_buf;
         }
 
@@ -324,7 +323,6 @@ reread:
          * Initialize the mount structure from the superblock.
          */
         xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
-        xfs_sb_quota_from_disk(sbp);
 
         /*
          * If we haven't validated the superblock, do so now before we try
@@ -333,7 +331,7 @@ reread:
         if (sbp->sb_magicnum != XFS_SB_MAGIC) {
                 if (loud)
                         xfs_warn(mp, "Invalid superblock magic number");
-                error = EINVAL;
+                error = -EINVAL;
                 goto release_buf;
         }
 
@@ -344,7 +342,7 @@ reread:
                 if (loud)
                         xfs_warn(mp, "device supports %u byte sectors (not %u)",
                                 sector_size, sbp->sb_sectsize);
-                error = ENOSYS;
+                error = -ENOSYS;
                 goto release_buf;
         }
 
@@ -392,7 +390,7 @@ xfs_update_alignment(xfs_mount_t *mp)
                         xfs_warn(mp,
                 "alignment check failed: sunit/swidth vs. blocksize(%d)",
                                 sbp->sb_blocksize);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 } else {
                         /*
                          * Convert the stripe unit and width to FSBs.
@@ -402,14 +400,14 @@ xfs_update_alignment(xfs_mount_t *mp)
                                 xfs_warn(mp,
                         "alignment check failed: sunit/swidth vs. agsize(%d)",
                                          sbp->sb_agblocks);
-                                return XFS_ERROR(EINVAL);
+                                return -EINVAL;
                         } else if (mp->m_dalign) {
                                 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
                         } else {
                                 xfs_warn(mp,
                         "alignment check failed: sunit(%d) less than bsize(%d)",
                                          mp->m_dalign, sbp->sb_blocksize);
-                                return XFS_ERROR(EINVAL);
+                                return -EINVAL;
                         }
                 }
 
@@ -429,7 +427,7 @@ xfs_update_alignment(xfs_mount_t *mp)
                 } else {
                         xfs_warn(mp,
         "cannot change alignment: superblock does not support data alignment");
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
         } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
                     xfs_sb_version_hasdalign(&mp->m_sb)) {
@@ -556,14 +554,14 @@ xfs_check_sizes(xfs_mount_t *mp)
         d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
         if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
                 xfs_warn(mp, "filesystem size mismatch detected");
-                return XFS_ERROR(EFBIG);
+                return -EFBIG;
         }
         bp = xfs_buf_read_uncached(mp->m_ddev_targp,
                                         d - XFS_FSS_TO_BB(mp, 1),
                                         XFS_FSS_TO_BB(mp, 1), 0, NULL);
         if (!bp) {
                 xfs_warn(mp, "last sector read failed");
-                return EIO;
+                return -EIO;
         }
         xfs_buf_relse(bp);
 
@@ -571,14 +569,14 @@ xfs_check_sizes(xfs_mount_t *mp)
                 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
                 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
                         xfs_warn(mp, "log size mismatch detected");
-                        return XFS_ERROR(EFBIG);
+                        return -EFBIG;
                 }
                 bp = xfs_buf_read_uncached(mp->m_logdev_targp,
                                         d - XFS_FSB_TO_BB(mp, 1),
                                         XFS_FSB_TO_BB(mp, 1), 0, NULL);
                 if (!bp) {
                         xfs_warn(mp, "log device read failed");
-                        return EIO;
+                        return -EIO;
                 }
                 xfs_buf_relse(bp);
         }
@@ -731,10 +729,15 @@ xfs_mountfs(
 
         xfs_set_maxicount(mp);
 
-        error = xfs_uuid_mount(mp);
+        mp->m_kobj.kobject.kset = xfs_kset;
+        error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype, NULL, mp->m_fsname);
         if (error)
                 goto out;
 
+        error = xfs_uuid_mount(mp);
+        if (error)
+                goto out_remove_sysfs;
+
         /*
          * Set the minimum read and write sizes
          */
@@ -816,7 +819,7 @@ xfs_mountfs(
         if (!sbp->sb_logblocks) {
                 xfs_warn(mp, "no log defined");
                 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
-                error = XFS_ERROR(EFSCORRUPTED);
+                error = -EFSCORRUPTED;
                 goto out_free_perag;
         }
 
@@ -855,7 +858,7 @@ xfs_mountfs(
              !mp->m_sb.sb_inprogress) {
                 error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
                 if (error)
-                        goto out_fail_wait;
+                        goto out_log_dealloc;
         }
 
         /*
@@ -876,7 +879,7 @@ xfs_mountfs(
                 xfs_iunlock(rip, XFS_ILOCK_EXCL);
                 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
                                  mp);
-                error = XFS_ERROR(EFSCORRUPTED);
+                error = -EFSCORRUPTED;
                 goto out_rele_rip;
         }
         mp->m_rootip = rip;     /* save it */
@@ -927,7 +930,7 @@ xfs_mountfs(
                         xfs_notice(mp, "resetting quota flags");
                         error = xfs_mount_reset_sbqflags(mp);
                         if (error)
-                                return error;
+                                goto out_rtunmount;
                 }
         }
 
@@ -989,6 +992,8 @@ xfs_mountfs(
         xfs_da_unmount(mp);
  out_remove_uuid:
         xfs_uuid_unmount(mp);
+ out_remove_sysfs:
+        xfs_sysfs_del(&mp->m_kobj);
  out:
         return error;
 }
@@ -1071,6 +1076,8 @@ xfs_unmountfs(
         xfs_errortag_clearall(mp, 0);
 #endif
         xfs_free_perag(mp);
+
+        xfs_sysfs_del(&mp->m_kobj);
 }
 
 int
@@ -1152,7 +1159,7 @@ xfs_mod_incore_sb_unlocked(
                 lcounter += delta;
                 if (lcounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_icount = lcounter;
                 return 0;
@@ -1161,7 +1168,7 @@ xfs_mod_incore_sb_unlocked(
                 lcounter += delta;
                 if (lcounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_ifree = lcounter;
                 return 0;
@@ -1191,7 +1198,7 @@ xfs_mod_incore_sb_unlocked(
                          * blocks if were allowed to.
                          */
                         if (!rsvd)
-                                return XFS_ERROR(ENOSPC);
+                                return -ENOSPC;
 
                         lcounter = (long long)mp->m_resblks_avail + delta;
                         if (lcounter >= 0) {
@@ -1202,7 +1209,7 @@ xfs_mod_incore_sb_unlocked(
                                 "Filesystem \"%s\": reserve blocks depleted! "
                                 "Consider increasing reserve pool size.",
                                 mp->m_fsname);
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
                 }
 
                 mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp);
@@ -1211,7 +1218,7 @@ xfs_mod_incore_sb_unlocked(
                 lcounter = (long long)mp->m_sb.sb_frextents;
                 lcounter += delta;
                 if (lcounter < 0) {
-                        return XFS_ERROR(ENOSPC);
+                        return -ENOSPC;
                 }
                 mp->m_sb.sb_frextents = lcounter;
                 return 0;
@@ -1220,7 +1227,7 @@ xfs_mod_incore_sb_unlocked(
                 lcounter += delta;
                 if (lcounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_dblocks = lcounter;
                 return 0;
@@ -1229,7 +1236,7 @@ xfs_mod_incore_sb_unlocked(
                 scounter += delta;
                 if (scounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_agcount = scounter;
                 return 0;
@@ -1238,7 +1245,7 @@ xfs_mod_incore_sb_unlocked(
                 scounter += delta;
                 if (scounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_imax_pct = scounter;
                 return 0;
@@ -1247,7 +1254,7 @@ xfs_mod_incore_sb_unlocked(
                 scounter += delta;
                 if (scounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_rextsize = scounter;
                 return 0;
@@ -1256,7 +1263,7 @@ xfs_mod_incore_sb_unlocked(
                 scounter += delta;
                 if (scounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_rbmblocks = scounter;
                 return 0;
@@ -1265,7 +1272,7 @@ xfs_mod_incore_sb_unlocked(
                 lcounter += delta;
                 if (lcounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_rblocks = lcounter;
                 return 0;
@@ -1274,7 +1281,7 @@ xfs_mod_incore_sb_unlocked(
                 lcounter += delta;
                 if (lcounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_rextents = lcounter;
                 return 0;
@@ -1283,13 +1290,13 @@ xfs_mod_incore_sb_unlocked(
                 scounter += delta;
                 if (scounter < 0) {
                         ASSERT(0);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
                 mp->m_sb.sb_rextslog = scounter;
                 return 0;
         default:
                 ASSERT(0);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 }
 
@@ -1452,7 +1459,7 @@ xfs_dev_is_read_only(
             (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
                 xfs_notice(mp, "%s required on read-only device.", message);
                 xfs_notice(mp, "write access unavailable, cannot proceed.");
-                return EROFS;
+                return -EROFS;
         }
         return 0;
 }
@@ -1995,7 +2002,7 @@ slow_path:
          * (e.g. lots of space just got freed). After that
          * we are done.
          */
-        if (ret != ENOSPC)
+        if (ret != -ENOSPC)
                 xfs_icsb_balance_counter(mp, field, 0);
         xfs_icsb_unlock(mp);
         return ret;
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 7295a0b7c343..b0447c86e7e2 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -166,6 +166,7 @@ typedef struct xfs_mount {
                                                    on the next remount,rw */
         int64_t                 m_low_space[XFS_LOWSP_MAX];
                                                 /* low free space thresholds */
+        struct xfs_kobj         m_kobj;
 
         struct workqueue_struct *m_data_workqueue;
         struct workqueue_struct *m_unwritten_workqueue;
diff --git a/fs/xfs/xfs_mru_cache.c b/fs/xfs/xfs_mru_cache.c
index f99b4933dc22..1eb6f3df698c 100644
--- a/fs/xfs/xfs_mru_cache.c
+++ b/fs/xfs/xfs_mru_cache.c
@@ -337,20 +337,20 @@ xfs_mru_cache_create(
                 *mrup = NULL;
 
         if (!mrup || !grp_count || !lifetime_ms || !free_func)
-                return EINVAL;
+                return -EINVAL;
 
         if (!(grp_time = msecs_to_jiffies(lifetime_ms) / grp_count))
-                return EINVAL;
+                return -EINVAL;
 
         if (!(mru = kmem_zalloc(sizeof(*mru), KM_SLEEP)))
-                return ENOMEM;
+                return -ENOMEM;
 
         /* An extra list is needed to avoid reaping up to a grp_time early. */
         mru->grp_count = grp_count + 1;
         mru->lists = kmem_zalloc(mru->grp_count * sizeof(*mru->lists), KM_SLEEP);
 
         if (!mru->lists) {
-                err = ENOMEM;
+                err = -ENOMEM;
                 goto exit;
         }
 
@@ -434,16 +434,16 @@ xfs_mru_cache_insert(
 
         ASSERT(mru && mru->lists);
         if (!mru || !mru->lists)
-                return EINVAL;
+                return -EINVAL;
 
         if (radix_tree_preload(GFP_KERNEL))
-                return ENOMEM;
+                return -ENOMEM;
 
         INIT_LIST_HEAD(&elem->list_node);
         elem->key = key;
 
         spin_lock(&mru->lock);
-        error = -radix_tree_insert(&mru->store, key, elem);
+        error = radix_tree_insert(&mru->store, key, elem);
         radix_tree_preload_end();
         if (!error)
                 _xfs_mru_cache_list_insert(mru, elem);
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 6d26759c779a..10232102b4a6 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -98,18 +98,18 @@ restart:
                         next_index = be32_to_cpu(dqp->q_core.d_id) + 1;
 
                         error = execute(batch[i], data);
-                        if (error == EAGAIN) {
+                        if (error == -EAGAIN) {
                                 skipped++;
                                 continue;
                         }
-                        if (error && last_error != EFSCORRUPTED)
+                        if (error && last_error != -EFSCORRUPTED)
                                 last_error = error;
                 }
 
                 mutex_unlock(&qi->qi_tree_lock);
 
                 /* bail out if the filesystem is corrupted.  */
-                if (last_error == EFSCORRUPTED) {
+                if (last_error == -EFSCORRUPTED) {
                         skipped = 0;
                         break;
                 }
@@ -138,7 +138,7 @@ xfs_qm_dqpurge(
         xfs_dqlock(dqp);
         if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) {
                 xfs_dqunlock(dqp);
-                return EAGAIN;
+                return -EAGAIN;
         }
 
         dqp->dq_flags |= XFS_DQ_FREEING;
@@ -221,100 +221,6 @@ xfs_qm_unmount(
         }
 }
 
-
-/*
- * This is called from xfs_mountfs to start quotas and initialize all
- * necessary data structures like quotainfo.  This is also responsible for
- * running a quotacheck as necessary.  We are guaranteed that the superblock
- * is consistently read in at this point.
- *
- * If we fail here, the mount will continue with quota turned off. We don't
- * need to inidicate success or failure at all.
- */
-void
-xfs_qm_mount_quotas(
-        xfs_mount_t     *mp)
-{
-        int             error = 0;
-        uint            sbf;
-
-        /*
-         * If quotas on realtime volumes is not supported, we disable
-         * quotas immediately.
-         */
-        if (mp->m_sb.sb_rextents) {
-                xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
-                mp->m_qflags = 0;
-                goto write_changes;
-        }
-
-        ASSERT(XFS_IS_QUOTA_RUNNING(mp));
-
-        /*
-         * Allocate the quotainfo structure inside the mount struct, and
-         * create quotainode(s), and change/rev superblock if necessary.
-         */
-        error = xfs_qm_init_quotainfo(mp);
-        if (error) {
-                /*
-                 * We must turn off quotas.
-                 */
-                ASSERT(mp->m_quotainfo == NULL);
-                mp->m_qflags = 0;
-                goto write_changes;
-        }
-        /*
-         * If any of the quotas are not consistent, do a quotacheck.
-         */
-        if (XFS_QM_NEED_QUOTACHECK(mp)) {
-                error = xfs_qm_quotacheck(mp);
-                if (error) {
-                        /* Quotacheck failed and disabled quotas. */
-                        return;
-                }
-        }
-        /* 
-         * If one type of quotas is off, then it will lose its
-         * quotachecked status, since we won't be doing accounting for
-         * that type anymore.
-         */
-        if (!XFS_IS_UQUOTA_ON(mp))
-                mp->m_qflags &= ~XFS_UQUOTA_CHKD;
-        if (!XFS_IS_GQUOTA_ON(mp))
-                mp->m_qflags &= ~XFS_GQUOTA_CHKD;
-        if (!XFS_IS_PQUOTA_ON(mp))
-                mp->m_qflags &= ~XFS_PQUOTA_CHKD;
-
- write_changes:
-        /*
-         * We actually don't have to acquire the m_sb_lock at all.
-         * This can only be called from mount, and that's single threaded. XXX
-         */
-        spin_lock(&mp->m_sb_lock);
-        sbf = mp->m_sb.sb_qflags;
-        mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
-        spin_unlock(&mp->m_sb_lock);
-
-        if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
-                if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
-                        /*
-                         * We could only have been turning quotas off.
-                         * We aren't in very good shape actually because
-                         * the incore structures are convinced that quotas are
-                         * off, but the on disk superblock doesn't know that !
-                         */
-                        ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
-                        xfs_alert(mp, "%s: Superblock update failed!",
-                                __func__);
-                }
-        }
-
-        if (error) {
-                xfs_warn(mp, "Failed to initialize disk quotas.");
-                return;
-        }
-}
-
 /*
  * Called from the vfsops layer.
  */
@@ -671,7 +577,7 @@ xfs_qm_init_quotainfo(
 
         qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
 
-        error = -list_lru_init(&qinf->qi_lru);
+        error = list_lru_init(&qinf->qi_lru);
         if (error)
                 goto out_free_qinf;
 
@@ -995,7 +901,7 @@ xfs_qm_dqiter_bufs(
                  * will leave a trace in the log indicating corruption has
                  * been detected.
                  */
-                if (error == EFSCORRUPTED) {
+                if (error == -EFSCORRUPTED) {
                         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
                                       XFS_FSB_TO_DADDR(mp, bno),
                                       mp->m_quotainfo->qi_dqchunklen, 0, &bp,
@@ -1005,6 +911,12 @@ xfs_qm_dqiter_bufs(
                 if (error)
                         break;
 
+                /*
+                 * A corrupt buffer might not have a verifier attached, so
+                 * make sure we have the correct one attached before writeback
+                 * occurs.
+                 */
+                bp->b_ops = &xfs_dquot_buf_ops;
                 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
                 xfs_buf_delwri_queue(bp, buffer_list);
                 xfs_buf_relse(bp);
@@ -1090,7 +1002,7 @@ xfs_qm_dqiterate(
                                         xfs_buf_readahead(mp->m_ddev_targp,
                                                XFS_FSB_TO_DADDR(mp, rablkno),
                                                mp->m_quotainfo->qi_dqchunklen,
-                                               NULL);
+                                               &xfs_dquot_buf_ops);
                                         rablkno++;
                                 }
                         }
@@ -1138,8 +1050,8 @@ xfs_qm_quotacheck_dqadjust(
                 /*
                  * Shouldn't be able to turn off quotas here.
                  */
-                ASSERT(error != ESRCH);
-                ASSERT(error != ENOENT);
+                ASSERT(error != -ESRCH);
+                ASSERT(error != -ENOENT);
                 return error;
         }
 
@@ -1226,7 +1138,7 @@ xfs_qm_dqusage_adjust(
          */
         if (xfs_is_quota_inode(&mp->m_sb, ino)) {
                 *res = BULKSTAT_RV_NOTHING;
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         /*
@@ -1330,7 +1242,7 @@ out_unlock:
  * Walk thru all the filesystem inodes and construct a consistent view
  * of the disk quota world. If the quotacheck fails, disable quotas.
  */
-int
+STATIC int
 xfs_qm_quotacheck(
         xfs_mount_t     *mp)
 {
@@ -1463,7 +1375,100 @@ xfs_qm_quotacheck(
                 }
         } else
                 xfs_notice(mp, "Quotacheck: Done.");
-        return (error);
+        return error;
+}
+
+/*
+ * This is called from xfs_mountfs to start quotas and initialize all
+ * necessary data structures like quotainfo.  This is also responsible for
+ * running a quotacheck as necessary.  We are guaranteed that the superblock
+ * is consistently read in at this point.
+ *
+ * If we fail here, the mount will continue with quota turned off. We don't
+ * need to inidicate success or failure at all.
+ */
+void
+xfs_qm_mount_quotas(
+        struct xfs_mount        *mp)
+{
+        int                     error = 0;
+        uint                    sbf;
+
+        /*
+         * If quotas on realtime volumes is not supported, we disable
+         * quotas immediately.
+         */
+        if (mp->m_sb.sb_rextents) {
+                xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
+                mp->m_qflags = 0;
+                goto write_changes;
+        }
+
+        ASSERT(XFS_IS_QUOTA_RUNNING(mp));
+
+        /*
+         * Allocate the quotainfo structure inside the mount struct, and
+         * create quotainode(s), and change/rev superblock if necessary.
+         */
+        error = xfs_qm_init_quotainfo(mp);
+        if (error) {
+                /*
+                 * We must turn off quotas.
+                 */
+                ASSERT(mp->m_quotainfo == NULL);
+                mp->m_qflags = 0;
+                goto write_changes;
+        }
+        /*
+         * If any of the quotas are not consistent, do a quotacheck.
+         */
+        if (XFS_QM_NEED_QUOTACHECK(mp)) {
+                error = xfs_qm_quotacheck(mp);
+                if (error) {
+                        /* Quotacheck failed and disabled quotas. */
+                        return;
+                }
+        }
+        /*
+         * If one type of quotas is off, then it will lose its
+         * quotachecked status, since we won't be doing accounting for
+         * that type anymore.
+         */
+        if (!XFS_IS_UQUOTA_ON(mp))
+                mp->m_qflags &= ~XFS_UQUOTA_CHKD;
+        if (!XFS_IS_GQUOTA_ON(mp))
+                mp->m_qflags &= ~XFS_GQUOTA_CHKD;
+        if (!XFS_IS_PQUOTA_ON(mp))
+                mp->m_qflags &= ~XFS_PQUOTA_CHKD;
+
+ write_changes:
+        /*
+         * We actually don't have to acquire the m_sb_lock at all.
+         * This can only be called from mount, and that's single threaded. XXX
+         */
+        spin_lock(&mp->m_sb_lock);
+        sbf = mp->m_sb.sb_qflags;
+        mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
+        spin_unlock(&mp->m_sb_lock);
+
+        if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
+                if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
+                        /*
+                         * We could only have been turning quotas off.
+                         * We aren't in very good shape actually because
+                         * the incore structures are convinced that quotas are
+                         * off, but the on disk superblock doesn't know that !
+                         */
+                        ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
+                        xfs_alert(mp, "%s: Superblock update failed!",
+                                __func__);
+                }
+        }
+
+        if (error) {
+                xfs_warn(mp, "Failed to initialize disk quotas.");
+                return;
+        }
 }
 
 /*
@@ -1493,7 +1498,7 @@ xfs_qm_init_quotainos(
                         error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
                                              0, 0, &uip);
                         if (error)
-                                return XFS_ERROR(error);
+                                return error;
                 }
                 if (XFS_IS_GQUOTA_ON(mp) &&
                     mp->m_sb.sb_gquotino != NULLFSINO) {
@@ -1563,7 +1568,7 @@ error_rele:
                 IRELE(gip);
         if (pip)
                 IRELE(pip);
-        return XFS_ERROR(error);
+        return error;
 }
 
 STATIC void
@@ -1679,7 +1684,7 @@ xfs_qm_vop_dqalloc(
                                                  XFS_QMOPT_DOWARN,
                                                  &uq);
                         if (error) {
-                                ASSERT(error != ENOENT);
+                                ASSERT(error != -ENOENT);
                                 return error;
                         }
                         /*
@@ -1706,7 +1711,7 @@ xfs_qm_vop_dqalloc(
                                                  XFS_QMOPT_DOWARN,
                                                  &gq);
                         if (error) {
-                                ASSERT(error != ENOENT);
+                                ASSERT(error != -ENOENT);
                                 goto error_rele;
                         }
                         xfs_dqunlock(gq);
@@ -1726,7 +1731,7 @@ xfs_qm_vop_dqalloc(
                                                  XFS_QMOPT_DOWARN,
                                                  &pq);
                         if (error) {
-                                ASSERT(error != ENOENT);
+                                ASSERT(error != -ENOENT);
                                 goto error_rele;
                         }
                         xfs_dqunlock(pq);
@@ -1895,7 +1900,7 @@ xfs_qm_vop_chown_reserve(
                                 -((xfs_qcnt_t)delblks), 0, blkflags);
         }
 
-        return (0);
+        return 0;
 }
 
 int
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 797fd4636273..3a07a937e232 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -157,7 +157,6 @@ struct xfs_dquot_acct {
 #define XFS_QM_RTBWARNLIMIT     5
 
 extern void             xfs_qm_destroy_quotainfo(struct xfs_mount *);
-extern int              xfs_qm_quotacheck(struct xfs_mount *);
 extern int              xfs_qm_write_sb_changes(struct xfs_mount *, __int64_t);
 
 /* dquot stuff */
diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index e9be63abd8d2..2c61e61b0205 100644
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -117,7 +117,7 @@ xfs_qm_newmount(
                         (uquotaondisk ? " usrquota" : ""),
                         (gquotaondisk ? " grpquota" : ""),
                         (pquotaondisk ? " prjquota" : ""));
-                return XFS_ERROR(EPERM);
+                return -EPERM;
         }
 
         if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index bbc813caba4c..80f2d77d929a 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -64,10 +64,10 @@ xfs_qm_scall_quotaoff(
         /*
          * No file system can have quotas enabled on disk but not in core.
          * Note that quota utilities (like quotaoff) _expect_
-         * errno == EEXIST here.
+         * errno == -EEXIST here.
          */
         if ((mp->m_qflags & flags) == 0)
-                return XFS_ERROR(EEXIST);
+                return -EEXIST;
         error = 0;
 
         flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
@@ -94,7 +94,7 @@ xfs_qm_scall_quotaoff(
 
                 /* XXX what to do if error ? Revert back to old vals incore ? */
                 error = xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS);
-                return (error);
+                return error;
         }
 
         dqtype = 0;
@@ -198,7 +198,7 @@ xfs_qm_scall_quotaoff(
         if (mp->m_qflags == 0) {
                 mutex_unlock(&q->qi_quotaofflock);
                 xfs_qm_destroy_quotainfo(mp);
-                return (0);
+                return 0;
         }
 
         /*
@@ -278,13 +278,13 @@ xfs_qm_scall_trunc_qfiles(
         xfs_mount_t     *mp,
         uint            flags)
 {
-        int             error = EINVAL;
+        int             error = -EINVAL;
 
         if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 ||
             (flags & ~XFS_DQ_ALLTYPES)) {
                 xfs_debug(mp, "%s: flags=%x m_qflags=%x",
                         __func__, flags, mp->m_qflags);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         if (flags & XFS_DQ_USER) {
@@ -328,7 +328,7 @@ xfs_qm_scall_quotaon(
         if (flags == 0) {
                 xfs_debug(mp, "%s: zero flags, m_qflags=%x",
                         __func__, mp->m_qflags);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         /* No fs can turn on quotas with a delayed effect */
@@ -351,13 +351,13 @@ xfs_qm_scall_quotaon(
                 xfs_debug(mp,
                         "%s: Can't enforce without acct, flags=%x sbflags=%x",
                         __func__, flags, mp->m_sb.sb_qflags);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
         /*
          * If everything's up to-date incore, then don't waste time.
          */
         if ((mp->m_qflags & flags) == flags)
-                return XFS_ERROR(EEXIST);
+                return -EEXIST;
 
         /*
          * Change sb_qflags on disk but not incore mp->qflags
@@ -372,11 +372,11 @@ xfs_qm_scall_quotaon(
          * There's nothing to change if it's the same.
          */
         if ((qf & flags) == flags && sbflags == 0)
-                return XFS_ERROR(EEXIST);
+                return -EEXIST;
         sbflags |= XFS_SB_QFLAGS;
 
         if ((error = xfs_qm_write_sb_changes(mp, sbflags)))
-                return (error);
+                return error;
         /*
          * If we aren't trying to switch on quota enforcement, we are done.
          */
@@ -387,10 +387,10 @@ xfs_qm_scall_quotaon(
              ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) !=
              (mp->m_qflags & XFS_GQUOTA_ACCT)) ||
             (flags & XFS_ALL_QUOTA_ENFD) == 0)
-                return (0);
+                return 0;
 
         if (! XFS_IS_QUOTA_RUNNING(mp))
-                return XFS_ERROR(ESRCH);
+                return -ESRCH;
 
         /*
          * Switch on quota enforcement in core.
@@ -399,7 +399,7 @@ xfs_qm_scall_quotaon(
         mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);
         mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);
 
-        return (0);
+        return 0;
 }
 
 
@@ -426,7 +426,7 @@ xfs_qm_scall_getqstat(
         if (!xfs_sb_version_hasquota(&mp->m_sb)) {
                 out->qs_uquota.qfs_ino = NULLFSINO;
                 out->qs_gquota.qfs_ino = NULLFSINO;
-                return (0);
+                return 0;
         }
 
         out->qs_flags = (__uint16_t) xfs_qm_export_flags(mp->m_qflags &
@@ -514,7 +514,7 @@ xfs_qm_scall_getqstatv(
                 out->qs_uquota.qfs_ino = NULLFSINO;
                 out->qs_gquota.qfs_ino = NULLFSINO;
                 out->qs_pquota.qfs_ino = NULLFSINO;
-                return (0);
+                return 0;
         }
 
         out->qs_flags = (__uint16_t) xfs_qm_export_flags(mp->m_qflags &
@@ -595,7 +595,7 @@ xfs_qm_scall_setqlim(
         xfs_qcnt_t              hard, soft;
 
         if (newlim->d_fieldmask & ~XFS_DQ_MASK)
-                return EINVAL;
+                return -EINVAL;
         if ((newlim->d_fieldmask & XFS_DQ_MASK) == 0)
                 return 0;
 
@@ -615,7 +615,7 @@ xfs_qm_scall_setqlim(
          */
         error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp);
         if (error) {
-                ASSERT(error != ENOENT);
+                ASSERT(error != -ENOENT);
                 goto out_unlock;
         }
         xfs_dqunlock(dqp);
@@ -758,7 +758,7 @@ xfs_qm_log_quotaoff_end(
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_equotaoff, 0, 0);
         if (error) {
                 xfs_trans_cancel(tp, 0);
-                return (error);
+                return error;
         }
 
         qoffi = xfs_trans_get_qoff_item(tp, startqoff,
@@ -772,7 +772,7 @@ xfs_qm_log_quotaoff_end(
          */
         xfs_trans_set_sync(tp);
         error = xfs_trans_commit(tp, 0);
-        return (error);
+        return error;
 }
 
 
@@ -822,7 +822,7 @@ error0:
                 spin_unlock(&mp->m_sb_lock);
         }
         *qoffstartp = qoffi;
-        return (error);
+        return error;
 }
 
 
@@ -850,7 +850,7 @@ xfs_qm_scall_getquota(
          * our utility programs are concerned.
          */
         if (XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
-                error = XFS_ERROR(ENOENT);
+                error = -ENOENT;
                 goto out_put;
         }
 
@@ -953,7 +953,7 @@ xfs_qm_export_flags(
                 uflags |= FS_QUOTA_GDQ_ENFD;
         if (flags & XFS_PQUOTA_ENFD)
                 uflags |= FS_QUOTA_PDQ_ENFD;
-        return (uflags);
+        return uflags;
 }
 
 
diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
index 2ad1b9822e92..b238027df987 100644
--- a/fs/xfs/xfs_quotaops.c
+++ b/fs/xfs/xfs_quotaops.c
@@ -51,7 +51,7 @@ xfs_fs_get_xstate(
 
         if (!XFS_IS_QUOTA_RUNNING(mp))
                 return -ENOSYS;
-        return -xfs_qm_scall_getqstat(mp, fqs);
+        return xfs_qm_scall_getqstat(mp, fqs);
 }
 
 STATIC int
@@ -63,7 +63,7 @@ xfs_fs_get_xstatev(
 
         if (!XFS_IS_QUOTA_RUNNING(mp))
                 return -ENOSYS;
-        return -xfs_qm_scall_getqstatv(mp, fqs);
+        return xfs_qm_scall_getqstatv(mp, fqs);
 }
 
 STATIC int
@@ -95,11 +95,11 @@ xfs_fs_set_xstate(
 
         switch (op) {
         case Q_XQUOTAON:
-                return -xfs_qm_scall_quotaon(mp, flags);
+                return xfs_qm_scall_quotaon(mp, flags);
         case Q_XQUOTAOFF:
                 if (!XFS_IS_QUOTA_ON(mp))
                         return -EINVAL;
-                return -xfs_qm_scall_quotaoff(mp, flags);
+                return xfs_qm_scall_quotaoff(mp, flags);
         }
 
         return -EINVAL;
@@ -112,7 +112,7 @@ xfs_fs_rm_xquota(
 {
         struct xfs_mount        *mp = XFS_M(sb);
         unsigned int            flags = 0;
-        
+
         if (sb->s_flags & MS_RDONLY)
                 return -EROFS;
 
@@ -123,11 +123,11 @@ xfs_fs_rm_xquota(
                 flags |= XFS_DQ_USER;
         if (uflags & FS_GROUP_QUOTA)
                 flags |= XFS_DQ_GROUP;
-        if (uflags & FS_USER_QUOTA)
+        if (uflags & FS_PROJ_QUOTA)
                 flags |= XFS_DQ_PROJ;
 
-        return -xfs_qm_scall_trunc_qfiles(mp, flags);
-}       
+        return xfs_qm_scall_trunc_qfiles(mp, flags);
+}
 
 STATIC int
 xfs_fs_get_dqblk(
@@ -142,7 +142,7 @@ xfs_fs_get_dqblk(
         if (!XFS_IS_QUOTA_ON(mp))
                 return -ESRCH;
 
-        return -xfs_qm_scall_getquota(mp, from_kqid(&init_user_ns, qid),
+        return xfs_qm_scall_getquota(mp, from_kqid(&init_user_ns, qid),
                                       xfs_quota_type(qid.type), fdq);
 }
 
@@ -161,7 +161,7 @@ xfs_fs_set_dqblk(
         if (!XFS_IS_QUOTA_ON(mp))
                 return -ESRCH;
 
-        return -xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid),
+        return xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid),
                                      xfs_quota_type(qid.type), fdq);
 }
 
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index ec5ca65c6211..909e143b87ae 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -863,7 +863,7 @@ xfs_growfs_rt_alloc(
                                         XFS_BMAPI_METADATA, &firstblock,
                                         resblks, &map, &nmap, &flist);
                 if (!error && nmap < 1)
-                        error = XFS_ERROR(ENOSPC);
+                        error = -ENOSPC;
                 if (error)
                         goto error_cancel;
                 /*
@@ -903,7 +903,7 @@ xfs_growfs_rt_alloc(
                         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
                                 mp->m_bsize, 0);
                         if (bp == NULL) {
-                                error = XFS_ERROR(EIO);
+                                error = -EIO;
 error_cancel:
                                 xfs_trans_cancel(tp, cancelflags);
                                 goto error;
@@ -944,9 +944,9 @@ xfs_growfs_rt(
         xfs_buf_t       *bp;            /* temporary buffer */
         int             error;          /* error return value */
         xfs_mount_t     *nmp;           /* new (fake) mount structure */
-        xfs_drfsbno_t   nrblocks;       /* new number of realtime blocks */
+        xfs_rfsblock_t  nrblocks;       /* new number of realtime blocks */
         xfs_extlen_t    nrbmblocks;     /* new number of rt bitmap blocks */
-        xfs_drtbno_t    nrextents;      /* new number of realtime extents */
+        xfs_rtblock_t   nrextents;      /* new number of realtime extents */
         uint8_t         nrextslog;      /* new log2 of sb_rextents */
         xfs_extlen_t    nrsumblocks;    /* new number of summary blocks */
         uint            nrsumlevels;    /* new rt summary levels */
@@ -962,11 +962,11 @@ xfs_growfs_rt(
          * Initial error checking.
          */
         if (!capable(CAP_SYS_ADMIN))
-                return XFS_ERROR(EPERM);
+                return -EPERM;
         if (mp->m_rtdev_targp == NULL || mp->m_rbmip == NULL ||
             (nrblocks = in->newblocks) <= sbp->sb_rblocks ||
             (sbp->sb_rblocks && (in->extsize != sbp->sb_rextsize)))
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         if ((error = xfs_sb_validate_fsb_count(sbp, nrblocks)))
                 return error;
         /*
@@ -976,7 +976,7 @@ xfs_growfs_rt(
                                 XFS_FSB_TO_BB(mp, nrblocks - 1),
                                 XFS_FSB_TO_BB(mp, 1), 0, NULL);
         if (!bp)
-                return EIO;
+                return -EIO;
         if (bp->b_error) {
                 error = bp->b_error;
                 xfs_buf_relse(bp);
@@ -1001,7 +1001,7 @@ xfs_growfs_rt(
          * since we'll log basically the whole summary file at once.
          */
         if (nrsumblocks > (mp->m_sb.sb_logblocks >> 1))
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         /*
          * Get the old block counts for bitmap and summary inodes.
          * These can't change since other growfs callers are locked out.
@@ -1208,7 +1208,7 @@ xfs_rtallocate_extent(
                                 len, &sumbp, &sb, prod, &r);
                 break;
         default:
-                error = EIO;
+                error = -EIO;
                 ASSERT(0);
         }
         if (error)
@@ -1247,7 +1247,7 @@ xfs_rtmount_init(
         if (mp->m_rtdev_targp == NULL) {
                 xfs_warn(mp,
         "Filesystem has a realtime volume, use rtdev=device option");
-                return XFS_ERROR(ENODEV);
+                return -ENODEV;
         }
         mp->m_rsumlevels = sbp->sb_rextslog + 1;
         mp->m_rsumsize =
@@ -1263,7 +1263,7 @@ xfs_rtmount_init(
                 xfs_warn(mp, "realtime mount -- %llu != %llu",
                         (unsigned long long) XFS_BB_TO_FSB(mp, d),
                         (unsigned long long) mp->m_sb.sb_rblocks);
-                return XFS_ERROR(EFBIG);
+                return -EFBIG;
         }
         bp = xfs_buf_read_uncached(mp->m_rtdev_targp,
                                         d - XFS_FSB_TO_BB(mp, 1),
@@ -1272,7 +1272,7 @@ xfs_rtmount_init(
                 xfs_warn(mp, "realtime device size check failed");
                 if (bp)
                         xfs_buf_relse(bp);
-                return EIO;
+                return -EIO;
         }
         xfs_buf_relse(bp);
         return 0;
diff --git a/fs/xfs/xfs_rtalloc.h b/fs/xfs/xfs_rtalloc.h
index 752b63d10300..c642795324af 100644
--- a/fs/xfs/xfs_rtalloc.h
+++ b/fs/xfs/xfs_rtalloc.h
@@ -132,7 +132,7 @@ xfs_rtmount_init(
                 return 0;
 
         xfs_warn(mp, "Not built with CONFIG_XFS_RT");
-        return ENOSYS;
+        return -ENOSYS;
 }
 # define xfs_rtmount_inodes(m)  (((mp)->m_sb.sb_rblocks == 0)? 0 : (ENOSYS))
 # define xfs_rtunmount_inodes(m)
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 8f0333b3f7a0..b194652033cd 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -61,6 +61,7 @@
 static const struct super_operations xfs_super_operations;
 static kmem_zone_t *xfs_ioend_zone;
 mempool_t *xfs_ioend_pool;
+struct kset *xfs_kset;
 
 #define MNTOPT_LOGBUFS  "logbufs"       /* number of XFS log buffers */
 #define MNTOPT_LOGBSIZE "logbsize"      /* size of XFS log buffers */
@@ -185,7 +186,7 @@ xfs_parseargs(
          */
         mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
         if (!mp->m_fsname)
-                return ENOMEM;
+                return -ENOMEM;
         mp->m_fsname_len = strlen(mp->m_fsname) + 1;
 
         /*
@@ -204,9 +205,6 @@ xfs_parseargs(
          */
         mp->m_flags |= XFS_MOUNT_BARRIER;
         mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
-#if !XFS_BIG_INUMS
-        mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
-#endif
 
         /*
          * These can be overridden by the mount option parsing.
@@ -227,57 +225,57 @@ xfs_parseargs(
                         if (!value || !*value) {
                                 xfs_warn(mp, "%s option requires an argument",
                                         this_char);
-                                return EINVAL;
+                                return -EINVAL;
                         }
                         if (kstrtoint(value, 10, &mp->m_logbufs))
-                                return EINVAL;
+                                return -EINVAL;
                 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
                         if (!value || !*value) {
                                 xfs_warn(mp, "%s option requires an argument",
                                         this_char);
-                                return EINVAL;
+                                return -EINVAL;
                         }
                         if (suffix_kstrtoint(value, 10, &mp->m_logbsize))
-                                return EINVAL;
+                                return -EINVAL;
                 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
                         if (!value || !*value) {
                                 xfs_warn(mp, "%s option requires an argument",
                                         this_char);
-                                return EINVAL;
+                                return -EINVAL;
                         }
                         mp->m_logname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
                         if (!mp->m_logname)
-                                return ENOMEM;
+                                return -ENOMEM;
                 } else if (!strcmp(this_char, MNTOPT_MTPT)) {
                         xfs_warn(mp, "%s option not allowed on this system",
                                 this_char);
-                        return EINVAL;
+                        return -EINVAL;
                 } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
                         if (!value || !*value) {
                                 xfs_warn(mp, "%s option requires an argument",
                                         this_char);
-                                return EINVAL;
+                                return -EINVAL;
                         }
                         mp->m_rtname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
                         if (!mp->m_rtname)
-                                return ENOMEM;
+                                return -ENOMEM;
                 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
                         if (!value || !*value) {
                                 xfs_warn(mp, "%s option requires an argument",
                                         this_char);
-                                return EINVAL;
+                                return -EINVAL;
                         }
                         if (kstrtoint(value, 10, &iosize))
-                                return EINVAL;
+                                return -EINVAL;
                         iosizelog = ffs(iosize) - 1;
                 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
                         if (!value || !*value) {
                                 xfs_warn(mp, "%s option requires an argument",
                                         this_char);
-                                return EINVAL;
+                                return -EINVAL;
                         }
                         if (suffix_kstrtoint(value, 10, &iosize))
-                                return EINVAL;
+                                return -EINVAL;
                         iosizelog = ffs(iosize) - 1;
                 } else if (!strcmp(this_char, MNTOPT_GRPID) ||
                            !strcmp(this_char, MNTOPT_BSDGROUPS)) {
@@ -297,27 +295,22 @@ xfs_parseargs(
                         if (!value || !*value) {
                                 xfs_warn(mp, "%s option requires an argument",
                                         this_char);
-                                return EINVAL;
+                                return -EINVAL;
                         }
                         if (kstrtoint(value, 10, &dsunit))
-                                return EINVAL;
+                                return -EINVAL;
                 } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
                         if (!value || !*value) {
                                 xfs_warn(mp, "%s option requires an argument",
                                         this_char);
-                                return EINVAL;
+                                return -EINVAL;
                         }
                         if (kstrtoint(value, 10, &dswidth))
-                                return EINVAL;
+                                return -EINVAL;
                 } else if (!strcmp(this_char, MNTOPT_32BITINODE)) {
                         mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
                 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
                         mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
-#if !XFS_BIG_INUMS
-                        xfs_warn(mp, "%s option not allowed on this system",
-                                this_char);
-                        return EINVAL;
-#endif
                 } else if (!strcmp(this_char, MNTOPT_NOUUID)) {
                         mp->m_flags |= XFS_MOUNT_NOUUID;
                 } else if (!strcmp(this_char, MNTOPT_BARRIER)) {
@@ -390,7 +383,7 @@ xfs_parseargs(
         "irixsgid is now a sysctl(2) variable, option is deprecated.");
                 } else {
                         xfs_warn(mp, "unknown mount option [%s].", this_char);
-                        return EINVAL;
+                        return -EINVAL;
                 }
         }
 
@@ -400,32 +393,32 @@ xfs_parseargs(
         if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
             !(mp->m_flags & XFS_MOUNT_RDONLY)) {
                 xfs_warn(mp, "no-recovery mounts must be read-only.");
-                return EINVAL;
+                return -EINVAL;
         }
 
         if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
                 xfs_warn(mp,
         "sunit and swidth options incompatible with the noalign option");
-                return EINVAL;
+                return -EINVAL;
         }
 
 #ifndef CONFIG_XFS_QUOTA
         if (XFS_IS_QUOTA_RUNNING(mp)) {
                 xfs_warn(mp, "quota support not available in this kernel.");
-                return EINVAL;
+                return -EINVAL;
         }
 #endif
 
         if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
                 xfs_warn(mp, "sunit and swidth must be specified together");
-                return EINVAL;
+                return -EINVAL;
         }
 
         if (dsunit && (dswidth % dsunit != 0)) {
                 xfs_warn(mp,
         "stripe width (%d) must be a multiple of the stripe unit (%d)",
                         dswidth, dsunit);
-                return EINVAL;
+                return -EINVAL;
         }
 
 done:
@@ -446,7 +439,7 @@ done:
              mp->m_logbufs > XLOG_MAX_ICLOGS)) {
                 xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
                         mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
         if (mp->m_logbsize != -1 &&
             mp->m_logbsize !=  0 &&
@@ -456,7 +449,7 @@ done:
                 xfs_warn(mp,
                         "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
                         mp->m_logbsize);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         if (iosizelog) {
@@ -465,7 +458,7 @@ done:
                         xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
                                 iosizelog, XFS_MIN_IO_LOG,
                                 XFS_MAX_IO_LOG);
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
 
                 mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
@@ -597,15 +590,20 @@ xfs_max_file_offset(
         return (((__uint64_t)pagefactor) << bitshift) - 1;
 }
 
+/*
+ * xfs_set_inode32() and xfs_set_inode64() are passed an agcount
+ * because in the growfs case, mp->m_sb.sb_agcount is not updated
+ * yet to the potentially higher ag count.
+ */
 xfs_agnumber_t
-xfs_set_inode32(struct xfs_mount *mp)
+xfs_set_inode32(struct xfs_mount *mp, xfs_agnumber_t agcount)
 {
         xfs_agnumber_t  index = 0;
         xfs_agnumber_t  maxagi = 0;
         xfs_sb_t        *sbp = &mp->m_sb;
         xfs_agnumber_t  max_metadata;
-        xfs_agino_t     agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks -1, 0);
-        xfs_ino_t       ino = XFS_AGINO_TO_INO(mp, sbp->sb_agcount -1, agino);
+        xfs_agino_t     agino;
+        xfs_ino_t       ino;
         xfs_perag_t     *pag;
 
         /* Calculate how much should be reserved for inodes to meet
@@ -620,10 +618,12 @@ xfs_set_inode32(struct xfs_mount *mp)
                 do_div(icount, sbp->sb_agblocks);
                 max_metadata = icount;
         } else {
-                max_metadata = sbp->sb_agcount;
+                max_metadata = agcount;
         }
 
-        for (index = 0; index < sbp->sb_agcount; index++) {
+        agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
+
+        for (index = 0; index < agcount; index++) {
                 ino = XFS_AGINO_TO_INO(mp, index, agino);
 
                 if (ino > XFS_MAXINUMBER_32) {
@@ -648,11 +648,11 @@ xfs_set_inode32(struct xfs_mount *mp)
 }
 
 xfs_agnumber_t
-xfs_set_inode64(struct xfs_mount *mp)
+xfs_set_inode64(struct xfs_mount *mp, xfs_agnumber_t agcount)
 {
         xfs_agnumber_t index = 0;
 
-        for (index = 0; index < mp->m_sb.sb_agcount; index++) {
+        for (index = 0; index < agcount; index++) {
                 struct xfs_perag        *pag;
 
                 pag = xfs_perag_get(mp, index);
@@ -686,7 +686,7 @@ xfs_blkdev_get(
                 xfs_warn(mp, "Invalid device [%s], error=%d\n", name, error);
         }
 
-        return -error;
+        return error;
 }
 
 STATIC void
@@ -756,7 +756,7 @@ xfs_open_devices(
                 if (rtdev == ddev || rtdev == logdev) {
                         xfs_warn(mp,
         "Cannot mount filesystem with identical rtdev and ddev/logdev.");
-                        error = EINVAL;
+                        error = -EINVAL;
                         goto out_close_rtdev;
                 }
         }
@@ -764,7 +764,7 @@ xfs_open_devices(
         /*
          * Setup xfs_mount buffer target pointers
          */
-        error = ENOMEM;
+        error = -ENOMEM;
         mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev);
         if (!mp->m_ddev_targp)
                 goto out_close_rtdev;
@@ -1188,6 +1188,7 @@ xfs_fs_remount(
         char                    *options)
 {
         struct xfs_mount        *mp = XFS_M(sb);
+        xfs_sb_t                *sbp = &mp->m_sb;
         substring_t             args[MAX_OPT_ARGS];
         char                    *p;
         int                     error;
@@ -1208,10 +1209,10 @@ xfs_fs_remount(
                         mp->m_flags &= ~XFS_MOUNT_BARRIER;
                         break;
                 case Opt_inode64:
-                        mp->m_maxagi = xfs_set_inode64(mp);
+                        mp->m_maxagi = xfs_set_inode64(mp, sbp->sb_agcount);
                         break;
                 case Opt_inode32:
-                        mp->m_maxagi = xfs_set_inode32(mp);
+                        mp->m_maxagi = xfs_set_inode32(mp, sbp->sb_agcount);
                         break;
                 default:
                         /*
@@ -1295,7 +1296,7 @@ xfs_fs_freeze(
 
         xfs_save_resvblks(mp);
         xfs_quiesce_attr(mp);
-        return -xfs_fs_log_dummy(mp);
+        return xfs_fs_log_dummy(mp);
 }
 
 STATIC int
@@ -1314,7 +1315,7 @@ xfs_fs_show_options(
         struct seq_file         *m,
         struct dentry           *root)
 {
-        return -xfs_showargs(XFS_M(root->d_sb), m);
+        return xfs_showargs(XFS_M(root->d_sb), m);
 }
 
 /*
@@ -1336,14 +1337,14 @@ xfs_finish_flags(
                            mp->m_logbsize < mp->m_sb.sb_logsunit) {
                         xfs_warn(mp,
                 "logbuf size must be greater than or equal to log stripe size");
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
         } else {
                 /* Fail a mount if the logbuf is larger than 32K */
                 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
                         xfs_warn(mp,
                 "logbuf size for version 1 logs must be 16K or 32K");
-                        return XFS_ERROR(EINVAL);
+                        return -EINVAL;
                 }
         }
 
@@ -1355,7 +1356,7 @@ xfs_finish_flags(
                 xfs_warn(mp,
 "Cannot mount a V5 filesystem as %s. %s is always enabled for V5 filesystems.",
                         MNTOPT_NOATTR2, MNTOPT_ATTR2);
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         /*
@@ -1372,7 +1373,7 @@ xfs_finish_flags(
         if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
                 xfs_warn(mp,
                         "cannot mount a read-only filesystem as read-write");
-                return XFS_ERROR(EROFS);
+                return -EROFS;
         }
 
         if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
@@ -1380,7 +1381,7 @@ xfs_finish_flags(
             !xfs_sb_version_has_pquotino(&mp->m_sb)) {
                 xfs_warn(mp,
                   "Super block does not support project and group quota together");
-                return XFS_ERROR(EINVAL);
+                return -EINVAL;
         }
 
         return 0;
@@ -1394,7 +1395,7 @@ xfs_fs_fill_super(
 {
         struct inode            *root;
         struct xfs_mount        *mp = NULL;
-        int                     flags = 0, error = ENOMEM;
+        int                     flags = 0, error = -ENOMEM;
 
         mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
         if (!mp)
@@ -1428,11 +1429,11 @@ xfs_fs_fill_super(
         if (error)
                 goto out_free_fsname;
 
-        error = -xfs_init_mount_workqueues(mp);
+        error = xfs_init_mount_workqueues(mp);
         if (error)
                 goto out_close_devices;
 
-        error = -xfs_icsb_init_counters(mp);
+        error = xfs_icsb_init_counters(mp);
         if (error)
                 goto out_destroy_workqueues;
 
@@ -1474,12 +1475,12 @@ xfs_fs_fill_super(
 
         root = igrab(VFS_I(mp->m_rootip));
         if (!root) {
-                error = ENOENT;
+                error = -ENOENT;
                 goto out_unmount;
         }
         sb->s_root = d_make_root(root);
         if (!sb->s_root) {
-                error = ENOMEM;
+                error = -ENOMEM;
                 goto out_unmount;
         }
 
@@ -1499,7 +1500,7 @@ out_destroy_workqueues:
         xfs_free_fsname(mp);
         kfree(mp);
  out:
-        return -error;
+        return error;
 
  out_unmount:
         xfs_filestream_unmount(mp);
@@ -1761,9 +1762,15 @@ init_xfs_fs(void)
         if (error)
                 goto out_cleanup_procfs;
 
+        xfs_kset = kset_create_and_add("xfs", NULL, fs_kobj);
+        if (!xfs_kset) {
+                error = -ENOMEM;
+                goto out_sysctl_unregister;;
+        }
+
         error = xfs_qm_init();
         if (error)
-                goto out_sysctl_unregister;
+                goto out_kset_unregister;
 
         error = register_filesystem(&xfs_fs_type);
         if (error)
@@ -1772,6 +1779,8 @@ init_xfs_fs(void)
 
  out_qm_exit:
         xfs_qm_exit();
+ out_kset_unregister:
+        kset_unregister(xfs_kset);
  out_sysctl_unregister:
         xfs_sysctl_unregister();
  out_cleanup_procfs:
@@ -1793,6 +1802,7 @@ exit_xfs_fs(void)
 {
         xfs_qm_exit();
         unregister_filesystem(&xfs_fs_type);
+        kset_unregister(xfs_kset);
         xfs_sysctl_unregister();
         xfs_cleanup_procfs();
         xfs_buf_terminate();
diff --git a/fs/xfs/xfs_super.h b/fs/xfs/xfs_super.h
index bbe3d15a7904..2b830c2f322e 100644
--- a/fs/xfs/xfs_super.h
+++ b/fs/xfs/xfs_super.h
@@ -44,16 +44,6 @@ extern void xfs_qm_exit(void);
 # define XFS_REALTIME_STRING
 #endif
 
-#if XFS_BIG_BLKNOS
-# if XFS_BIG_INUMS
-#  define XFS_BIGFS_STRING      "large block/inode numbers, "
-# else
-#  define XFS_BIGFS_STRING      "large block numbers, "
-# endif
-#else
-# define XFS_BIGFS_STRING
-#endif
-
 #ifdef DEBUG
 # define XFS_DBG_STRING         "debug"
 #else
@@ -64,7 +54,6 @@ extern void xfs_qm_exit(void);
 #define XFS_BUILD_OPTIONS       XFS_ACL_STRING \
                                 XFS_SECURITY_STRING \
                                 XFS_REALTIME_STRING \
-                                XFS_BIGFS_STRING \
                                 XFS_DBG_STRING /* DBG must be last */
 
 struct xfs_inode;
@@ -76,8 +65,8 @@ extern __uint64_t xfs_max_file_offset(unsigned int);
 
 extern void xfs_flush_inodes(struct xfs_mount *mp);
 extern void xfs_blkdev_issue_flush(struct xfs_buftarg *);
-extern xfs_agnumber_t xfs_set_inode32(struct xfs_mount *);
-extern xfs_agnumber_t xfs_set_inode64(struct xfs_mount *);
+extern xfs_agnumber_t xfs_set_inode32(struct xfs_mount *, xfs_agnumber_t agcount);
+extern xfs_agnumber_t xfs_set_inode64(struct xfs_mount *, xfs_agnumber_t agcount);
 
 extern const struct export_operations xfs_export_operations;
 extern const struct xattr_handler *xfs_xattr_handlers[];
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index d69363c833e1..6a944a2cd36f 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -76,15 +76,15 @@ xfs_readlink_bmap(
                 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0,
                                   &xfs_symlink_buf_ops);
                 if (!bp)
-                        return XFS_ERROR(ENOMEM);
+                        return -ENOMEM;
                 error = bp->b_error;
                 if (error) {
                         xfs_buf_ioerror_alert(bp, __func__);
                         xfs_buf_relse(bp);
 
                         /* bad CRC means corrupted metadata */
-                        if (error == EFSBADCRC)
-                                error = EFSCORRUPTED;
+                        if (error == -EFSBADCRC)
+                                error = -EFSCORRUPTED;
                         goto out;
                 }
                 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
@@ -95,7 +95,7 @@ xfs_readlink_bmap(
                 if (xfs_sb_version_hascrc(&mp->m_sb)) {
                         if (!xfs_symlink_hdr_ok(ip->i_ino, offset,
                                                         byte_cnt, bp)) {
-                                error = EFSCORRUPTED;
+                                error = -EFSCORRUPTED;
                                 xfs_alert(mp,
 "symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)",
                                         offset, byte_cnt, ip->i_ino);
@@ -135,7 +135,7 @@ xfs_readlink(
         trace_xfs_readlink(ip);
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         xfs_ilock(ip, XFS_ILOCK_SHARED);
 
@@ -148,7 +148,7 @@ xfs_readlink(
                          __func__, (unsigned long long) ip->i_ino,
                          (long long) pathlen);
                 ASSERT(0);
-                error = XFS_ERROR(EFSCORRUPTED);
+                error = -EFSCORRUPTED;
                 goto out;
         }
 
@@ -203,14 +203,14 @@ xfs_symlink(
         trace_xfs_symlink(dp, link_name);
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         /*
          * Check component lengths of the target path name.
          */
         pathlen = strlen(target_path);
         if (pathlen >= MAXPATHLEN)      /* total string too long */
-                return XFS_ERROR(ENAMETOOLONG);
+                return -ENAMETOOLONG;
 
         udqp = gdqp = NULL;
         prid = xfs_get_initial_prid(dp);
@@ -238,7 +238,7 @@ xfs_symlink(
                 fs_blocks = xfs_symlink_blocks(mp, pathlen);
         resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, resblks, 0);
-        if (error == ENOSPC && fs_blocks == 0) {
+        if (error == -ENOSPC && fs_blocks == 0) {
                 resblks = 0;
                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, 0, 0);
         }
@@ -254,7 +254,7 @@ xfs_symlink(
          * Check whether the directory allows new symlinks or not.
          */
         if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
-                error = XFS_ERROR(EPERM);
+                error = -EPERM;
                 goto error_return;
         }
 
@@ -284,7 +284,7 @@ xfs_symlink(
         error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
                                prid, resblks > 0, &ip, NULL);
         if (error) {
-                if (error == ENOSPC)
+                if (error == -ENOSPC)
                         goto error_return;
                 goto error1;
         }
@@ -348,7 +348,7 @@ xfs_symlink(
                         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
                                                BTOBB(byte_cnt), 0);
                         if (!bp) {
-                                error = ENOMEM;
+                                error = -ENOMEM;
                                 goto error2;
                         }
                         bp->b_ops = &xfs_symlink_buf_ops;
@@ -489,7 +489,7 @@ xfs_inactive_symlink_rmt(
                         XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
                         XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
                 if (!bp) {
-                        error = ENOMEM;
+                        error = -ENOMEM;
                         goto error_bmap_cancel;
                 }
                 xfs_trans_binval(tp, bp);
@@ -562,7 +562,7 @@ xfs_inactive_symlink(
         trace_xfs_inactive_symlink(ip);
 
         if (XFS_FORCED_SHUTDOWN(mp))
-                return XFS_ERROR(EIO);
+                return -EIO;
 
         xfs_ilock(ip, XFS_ILOCK_EXCL);
 
@@ -580,7 +580,7 @@ xfs_inactive_symlink(
                          __func__, (unsigned long long)ip->i_ino, pathlen);
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
                 ASSERT(0);
-                return XFS_ERROR(EFSCORRUPTED);
+                return -EFSCORRUPTED;
         }
 
         if (ip->i_df.if_flags & XFS_IFINLINE) {
diff --git a/fs/xfs/xfs_sysfs.c b/fs/xfs/xfs_sysfs.c
new file mode 100644
index 000000000000..9835139ce1ec
--- /dev/null
+++ b/fs/xfs/xfs_sysfs.c
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2014 Red Hat, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "xfs.h"
+#include "xfs_sysfs.h"
+#include "xfs_log_format.h"
+#include "xfs_log.h"
+#include "xfs_log_priv.h"
+
+struct xfs_sysfs_attr {
+        struct attribute attr;
+        ssize_t (*show)(char *buf, void *data);
+        ssize_t (*store)(const char *buf, size_t count, void *data);
+};
+
+static inline struct xfs_sysfs_attr *
+to_attr(struct attribute *attr)
+{
+        return container_of(attr, struct xfs_sysfs_attr, attr);
+}
+
+#define XFS_SYSFS_ATTR_RW(name) \
+        static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RW(name)
+#define XFS_SYSFS_ATTR_RO(name) \
+        static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RO(name)
+
+#define ATTR_LIST(name) &xfs_sysfs_attr_##name.attr
+
+/*
+ * xfs_mount kobject. This currently has no attributes and thus no need for show
+ * and store helpers. The mp kobject serves as the per-mount parent object that
+ * is identified by the fsname under sysfs.
+ */
+
+struct kobj_type xfs_mp_ktype = {
+        .release = xfs_sysfs_release,
+};
+
+/* xlog */
+
+STATIC ssize_t
+log_head_lsn_show(
+        char    *buf,
+        void    *data)
+{
+        struct xlog *log = data;
+        int cycle;
+        int block;
+
+        spin_lock(&log->l_icloglock);
+        cycle = log->l_curr_cycle;
+        block = log->l_curr_block;
+        spin_unlock(&log->l_icloglock);
+
+        return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
+}
+XFS_SYSFS_ATTR_RO(log_head_lsn);
+
+STATIC ssize_t
+log_tail_lsn_show(
+        char    *buf,
+        void    *data)
+{
+        struct xlog *log = data;
+        int cycle;
+        int block;
+
+        xlog_crack_atomic_lsn(&log->l_tail_lsn, &cycle, &block);
+        return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
+}
+XFS_SYSFS_ATTR_RO(log_tail_lsn);
+
+STATIC ssize_t
+reserve_grant_head_show(
+        char    *buf,
+        void    *data)
+{
+        struct xlog *log = data;
+        int cycle;
+        int bytes;
+
+        xlog_crack_grant_head(&log->l_reserve_head.grant, &cycle, &bytes);
+        return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
+}
+XFS_SYSFS_ATTR_RO(reserve_grant_head);
+
+STATIC ssize_t
+write_grant_head_show(
+        char    *buf,
+        void    *data)
+{
+        struct xlog *log = data;
+        int cycle;
+        int bytes;
+
+        xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &bytes);
+        return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
+}
+XFS_SYSFS_ATTR_RO(write_grant_head);
+
+static struct attribute *xfs_log_attrs[] = {
+        ATTR_LIST(log_head_lsn),
+        ATTR_LIST(log_tail_lsn),
+        ATTR_LIST(reserve_grant_head),
+        ATTR_LIST(write_grant_head),
+        NULL,
+};
+
+static inline struct xlog *
+to_xlog(struct kobject *kobject)
+{
+        struct xfs_kobj *kobj = to_kobj(kobject);
+        return container_of(kobj, struct xlog, l_kobj);
+}
+
+STATIC ssize_t
+xfs_log_show(
+        struct kobject          *kobject,
+        struct attribute        *attr,
+        char                    *buf)
+{
+        struct xlog *log = to_xlog(kobject);
+        struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
+
+        return xfs_attr->show ? xfs_attr->show(buf, log) : 0;
+}
+
+STATIC ssize_t
+xfs_log_store(
+        struct kobject          *kobject,
+        struct attribute        *attr,
+        const char              *buf,
+        size_t                  count)
+{
+        struct xlog *log = to_xlog(kobject);
+        struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
+
+        return xfs_attr->store ? xfs_attr->store(buf, count, log) : 0;
+}
+
+static struct sysfs_ops xfs_log_ops = {
+        .show = xfs_log_show,
+        .store = xfs_log_store,
+};
+
+struct kobj_type xfs_log_ktype = {
+        .release = xfs_sysfs_release,
+        .sysfs_ops = &xfs_log_ops,
+        .default_attrs = xfs_log_attrs,
+};
diff --git a/fs/xfs/xfs_sysfs.h b/fs/xfs/xfs_sysfs.h
new file mode 100644
index 000000000000..54a2091183c0
--- /dev/null
+++ b/fs/xfs/xfs_sysfs.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2014 Red Hat, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __XFS_SYSFS_H__
+#define __XFS_SYSFS_H__
+
+extern struct kobj_type xfs_mp_ktype;   /* xfs_mount */
+extern struct kobj_type xfs_log_ktype;  /* xlog */
+
+static inline struct xfs_kobj *
+to_kobj(struct kobject *kobject)
+{
+        return container_of(kobject, struct xfs_kobj, kobject);
+}
+
+static inline void
+xfs_sysfs_release(struct kobject *kobject)
+{
+        struct xfs_kobj *kobj = to_kobj(kobject);
+        complete(&kobj->complete);
+}
+
+static inline int
+xfs_sysfs_init(
+        struct xfs_kobj         *kobj,
+        struct kobj_type        *ktype,
+        struct xfs_kobj         *parent_kobj,
+        const char              *name)
+{
+        init_completion(&kobj->complete);
+        return kobject_init_and_add(&kobj->kobject, ktype,
+                                    &parent_kobj->kobject, "%s", name);
+}
+
+static inline void
+xfs_sysfs_del(
+        struct xfs_kobj *kobj)
+{
+        kobject_del(&kobj->kobject);
+        kobject_put(&kobj->kobject);
+        wait_for_completion(&kobj->complete);
+}
+
+#endif  /* __XFS_SYSFS_H__ */
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index d03932564ccb..30e8e3410955 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -190,7 +190,7 @@ xfs_trans_reserve(
                                           -((int64_t)blocks), rsvd);
                 if (error != 0) {
                         current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
-                        return (XFS_ERROR(ENOSPC));
+                        return -ENOSPC;
                 }
                 tp->t_blk_res += blocks;
         }
@@ -241,7 +241,7 @@ xfs_trans_reserve(
                 error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS,
                                           -((int64_t)rtextents), rsvd);
                 if (error) {
-                        error = XFS_ERROR(ENOSPC);
+                        error = -ENOSPC;
                         goto undo_log;
                 }
                 tp->t_rtx_res += rtextents;
@@ -874,7 +874,7 @@ xfs_trans_commit(
                 goto out_unreserve;
 
         if (XFS_FORCED_SHUTDOWN(mp)) {
-                error = XFS_ERROR(EIO);
+                error = -EIO;
                 goto out_unreserve;
         }
 
@@ -917,7 +917,7 @@ out_unreserve:
         if (tp->t_ticket) {
                 commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
                 if (commit_lsn == -1 && !error)
-                        error = XFS_ERROR(EIO);
+                        error = -EIO;
         }
         current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
         xfs_trans_free_items(tp, NULLCOMMITLSN, error ? XFS_TRANS_ABORT : 0);
@@ -1024,7 +1024,7 @@ xfs_trans_roll(
          */
         error = xfs_trans_commit(trans, 0);
         if (error)
-                return (error);
+                return error;
 
         trans = *tpp;
 
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index cb0f3a84cc68..859482f53b5a 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -762,7 +762,7 @@ xfs_trans_ail_init(
 
         ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL);
         if (!ailp)
-                return ENOMEM;
+                return -ENOMEM;
 
         ailp->xa_mount = mp;
         INIT_LIST_HEAD(&ailp->xa_ail);
@@ -781,7 +781,7 @@ xfs_trans_ail_init(
 
 out_free_ailp:
         kmem_free(ailp);
-        return ENOMEM;
+        return -ENOMEM;
 }
 
 void
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index b8eef0549f3f..96c898e7ac9a 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -166,7 +166,7 @@ xfs_trans_get_buf_map(
                 ASSERT(atomic_read(&bip->bli_refcount) > 0);
                 bip->bli_recur++;
                 trace_xfs_trans_get_buf_recur(bip);
-                return (bp);
+                return bp;
         }
 
         bp = xfs_buf_get_map(target, map, nmaps, flags);
@@ -178,7 +178,7 @@ xfs_trans_get_buf_map(
 
         _xfs_trans_bjoin(tp, bp, 1);
         trace_xfs_trans_get_buf(bp->b_fspriv);
-        return (bp);
+        return bp;
 }
 
 /*
@@ -201,9 +201,8 @@ xfs_trans_getsb(xfs_trans_t	*tp,
          * Default to just trying to lock the superblock buffer
          * if tp is NULL.
          */
-        if (tp == NULL) {
-                return (xfs_getsb(mp, flags));
-        }
+        if (tp == NULL)
+                return xfs_getsb(mp, flags);
 
         /*
          * If the superblock buffer already has this transaction
@@ -218,7 +217,7 @@ xfs_trans_getsb(xfs_trans_t	*tp,
                 ASSERT(atomic_read(&bip->bli_refcount) > 0);
                 bip->bli_recur++;
                 trace_xfs_trans_getsb_recur(bip);
-                return (bp);
+                return bp;
         }
 
         bp = xfs_getsb(mp, flags);
@@ -227,7 +226,7 @@ xfs_trans_getsb(xfs_trans_t	*tp,
 
         _xfs_trans_bjoin(tp, bp, 1);
         trace_xfs_trans_getsb(bp->b_fspriv);
-        return (bp);
+        return bp;
 }
 
 #ifdef DEBUG
@@ -267,7 +266,7 @@ xfs_trans_read_buf_map(
                 bp = xfs_buf_read_map(target, map, nmaps, flags, ops);
                 if (!bp)
                         return (flags & XBF_TRYLOCK) ?
-                                        EAGAIN : XFS_ERROR(ENOMEM);
+                                        -EAGAIN : -ENOMEM;
 
                 if (bp->b_error) {
                         error = bp->b_error;
@@ -277,8 +276,8 @@ xfs_trans_read_buf_map(
                         xfs_buf_relse(bp);
 
                         /* bad CRC means corrupted metadata */
-                        if (error == EFSBADCRC)
-                                error = EFSCORRUPTED;
+                        if (error == -EFSBADCRC)
+                                error = -EFSCORRUPTED;
                         return error;
                 }
 #ifdef DEBUG
@@ -287,7 +286,7 @@ xfs_trans_read_buf_map(
                                 if (((xfs_req_num++) % xfs_error_mod) == 0) {
                                         xfs_buf_relse(bp);
                                         xfs_debug(mp, "Returning error!");
-                                        return XFS_ERROR(EIO);
+                                        return -EIO;
                                 }
                         }
                 }
@@ -343,8 +342,8 @@ xfs_trans_read_buf_map(
                                         xfs_force_shutdown(tp->t_mountp,
                                                         SHUTDOWN_META_IO_ERROR);
                                 /* bad CRC means corrupted metadata */
-                                if (error == EFSBADCRC)
-                                        error = EFSCORRUPTED;
+                                if (error == -EFSBADCRC)
+                                        error = -EFSCORRUPTED;
                                 return error;
                         }
                 }
@@ -355,7 +354,7 @@ xfs_trans_read_buf_map(
                 if (XFS_FORCED_SHUTDOWN(mp)) {
                         trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
                         *bpp = NULL;
-                        return XFS_ERROR(EIO);
+                        return -EIO;
                 }
 
 
@@ -372,7 +371,7 @@ xfs_trans_read_buf_map(
         if (bp == NULL) {
                 *bpp = NULL;
                 return (flags & XBF_TRYLOCK) ?
-                                        0 : XFS_ERROR(ENOMEM);
+                                        0 : -ENOMEM;
         }
         if (bp->b_error) {
                 error = bp->b_error;
@@ -384,8 +383,8 @@ xfs_trans_read_buf_map(
                 xfs_buf_relse(bp);
 
                 /* bad CRC means corrupted metadata */
-                if (error == EFSBADCRC)
-                        error = EFSCORRUPTED;
+                if (error == -EFSBADCRC)
+                        error = -EFSCORRUPTED;
                 return error;
         }
 #ifdef DEBUG
@@ -396,7 +395,7 @@ xfs_trans_read_buf_map(
                                                    SHUTDOWN_META_IO_ERROR);
                                 xfs_buf_relse(bp);
                                 xfs_debug(mp, "Returning trans error!");
-                                return XFS_ERROR(EIO);
+                                return -EIO;
                         }
                 }
         }
@@ -414,7 +413,7 @@ shutdown_abort:
         trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
         xfs_buf_relse(bp);
         *bpp = NULL;
-        return XFS_ERROR(EIO);
+        return -EIO;
 }
 
 /*
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 41172861e857..846e061c2e98 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -722,8 +722,8 @@ xfs_trans_dqresv(
 error_return:
         xfs_dqunlock(dqp);
         if (flags & XFS_QMOPT_ENOSPC)
-                return ENOSPC;
-        return EDQUOT;
+                return -ENOSPC;
+        return -EDQUOT;
 }
 
 
diff --git a/fs/xfs/xfs_types.h b/fs/xfs/xfs_types.h
index 65c6e6650b1a..b79dc66b2ecd 100644
--- a/fs/xfs/xfs_types.h
+++ b/fs/xfs/xfs_types.h
@@ -38,43 +38,18 @@ typedef	__int32_t	xfs_tid_t;	/* transaction identifier */
 typedef __uint32_t      xfs_dablk_t;    /* dir/attr block number (in file) */
 typedef __uint32_t      xfs_dahash_t;   /* dir/attr hash value */
 
-/*
- * These types are 64 bits on disk but are either 32 or 64 bits in memory.
- * Disk based types:
- */
-typedef __uint64_t      xfs_dfsbno_t;   /* blockno in filesystem (agno|agbno) */
-typedef __uint64_t      xfs_drfsbno_t;  /* blockno in filesystem (raw) */
-typedef __uint64_t      xfs_drtbno_t;   /* extent (block) in realtime area */
-typedef __uint64_t      xfs_dfiloff_t;  /* block number in a file */
-typedef __uint64_t      xfs_dfilblks_t; /* number of blocks in a file */
-
-/*
- * Memory based types are conditional.
- */
-#if XFS_BIG_BLKNOS
 typedef __uint64_t      xfs_fsblock_t;  /* blockno in filesystem (agno|agbno) */
 typedef __uint64_t      xfs_rfsblock_t; /* blockno in filesystem (raw) */
 typedef __uint64_t      xfs_rtblock_t;  /* extent (block) in realtime area */
-typedef __int64_t       xfs_srtblock_t; /* signed version of xfs_rtblock_t */
-#else
-typedef __uint32_t      xfs_fsblock_t;  /* blockno in filesystem (agno|agbno) */
-typedef __uint32_t      xfs_rfsblock_t; /* blockno in filesystem (raw) */
-typedef __uint32_t      xfs_rtblock_t;  /* extent (block) in realtime area */
-typedef __int32_t       xfs_srtblock_t; /* signed version of xfs_rtblock_t */
-#endif
 typedef __uint64_t      xfs_fileoff_t;  /* block number in a file */
-typedef __int64_t       xfs_sfiloff_t;  /* signed block number in a file */
 typedef __uint64_t      xfs_filblks_t;  /* number of blocks in a file */
 
+typedef __int64_t       xfs_srtblock_t; /* signed version of xfs_rtblock_t */
+typedef __int64_t       xfs_sfiloff_t;  /* signed block number in a file */
 
 /*
  * Null values for the types.
  */
-#define NULLDFSBNO      ((xfs_dfsbno_t)-1)
-#define NULLDRFSBNO     ((xfs_drfsbno_t)-1)
-#define NULLDRTBNO      ((xfs_drtbno_t)-1)
-#define NULLDFILOFF     ((xfs_dfiloff_t)-1)
-
 #define NULLFSBLOCK     ((xfs_fsblock_t)-1)
 #define NULLRFSBLOCK    ((xfs_rfsblock_t)-1)
 #define NULLRTBLOCK     ((xfs_rtblock_t)-1)
diff --git a/fs/xfs/xfs_vnode.h b/fs/xfs/xfs_vnode.h
deleted file mode 100644
index e8a77383c0d5..000000000000
--- a/fs/xfs/xfs_vnode.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
- * All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it would be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write the Free Software Foundation,
- * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-#ifndef __XFS_VNODE_H__
-#define __XFS_VNODE_H__
-
-#include "xfs_fs.h"
-
-struct file;
-struct xfs_inode;
-struct attrlist_cursor_kern;
-
-/*
- * Flags for read/write calls - same values as IRIX
- */
-#define IO_ISDIRECT     0x00004         /* bypass page cache */
-#define IO_INVIS        0x00020         /* don't update inode timestamps */
-
-#define XFS_IO_FLAGS \
-        { IO_ISDIRECT,  "DIRECT" }, \
-        { IO_INVIS,     "INVIS"}
-
-/*
- * Some useful predicates.
- */
-#define VN_MAPPED(vp)   mapping_mapped(vp->i_mapping)
-#define VN_CACHED(vp)   (vp->i_mapping->nrpages)
-#define VN_DIRTY(vp)    mapping_tagged(vp->i_mapping, \
-                                        PAGECACHE_TAG_DIRTY)
-
-
-#endif  /* __XFS_VNODE_H__ */
diff --git a/fs/xfs/xfs_xattr.c b/fs/xfs/xfs_xattr.c
index 78ed92a46fdd..93455b998041 100644
--- a/fs/xfs/xfs_xattr.c
+++ b/fs/xfs/xfs_xattr.c
@@ -49,7 +49,7 @@ xfs_xattr_get(struct dentry *dentry, const char *name,
                 value = NULL;
         }
 
-        error = -xfs_attr_get(ip, (unsigned char *)name, value, &asize, xflags);
+        error = xfs_attr_get(ip, (unsigned char *)name, value, &asize, xflags);
         if (error)
                 return error;
         return asize;
@@ -71,8 +71,8 @@ xfs_xattr_set(struct dentry *dentry, const char *name, const void *value,
                 xflags |= ATTR_REPLACE;
 
         if (!value)
-                return -xfs_attr_remove(ip, (unsigned char *)name, xflags);
-        return -xfs_attr_set(ip, (unsigned char *)name,
+                return xfs_attr_remove(ip, (unsigned char *)name, xflags);
+        return xfs_attr_set(ip, (unsigned char *)name,
                                 (void *)value, size, xflags);
 }