1 files changed, 40 insertions, 37 deletions

diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 1c0a5a585a82..eb198c01c35d 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -323,13 +323,13 @@ xfs_bmap_trace_pre_update(
         int             whichfork);     /* data or attr fork */
 
 #define XFS_BMAP_TRACE_DELETE(d,ip,i,c,w)       \
-        xfs_bmap_trace_delete(__FUNCTION__,d,ip,i,c,w)
+        xfs_bmap_trace_delete(__func__,d,ip,i,c,w)
 #define XFS_BMAP_TRACE_INSERT(d,ip,i,c,r1,r2,w) \
-        xfs_bmap_trace_insert(__FUNCTION__,d,ip,i,c,r1,r2,w)
+        xfs_bmap_trace_insert(__func__,d,ip,i,c,r1,r2,w)
 #define XFS_BMAP_TRACE_POST_UPDATE(d,ip,i,w)    \
-        xfs_bmap_trace_post_update(__FUNCTION__,d,ip,i,w)
+        xfs_bmap_trace_post_update(__func__,d,ip,i,w)
 #define XFS_BMAP_TRACE_PRE_UPDATE(d,ip,i,w)     \
-        xfs_bmap_trace_pre_update(__FUNCTION__,d,ip,i,w)
+        xfs_bmap_trace_pre_update(__func__,d,ip,i,w)
 #else
 #define XFS_BMAP_TRACE_DELETE(d,ip,i,c,w)
 #define XFS_BMAP_TRACE_INSERT(d,ip,i,c,r1,r2,w)
@@ -2402,7 +2402,7 @@ xfs_bmap_extsize_align(
 
 #define XFS_ALLOC_GAP_UNITS     4
 
-STATIC int
+STATIC void
 xfs_bmap_adjacent(
         xfs_bmalloca_t  *ap)            /* bmap alloc argument struct */
 {
@@ -2548,7 +2548,6 @@ xfs_bmap_adjacent(
                         ap->rval = gotbno;
         }
 #undef ISVALID
-        return 0;
 }
 
 STATIC int
@@ -4047,17 +4046,17 @@ xfs_bmap_add_attrfork(
                 xfs_trans_log_inode(tp, ip, logflags);
         if (error)
                 goto error2;
-        if (!XFS_SB_VERSION_HASATTR(&mp->m_sb) ||
-           (!XFS_SB_VERSION_HASATTR2(&mp->m_sb) && version == 2)) {
+        if (!xfs_sb_version_hasattr(&mp->m_sb) ||
+           (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) {
                 __int64_t sbfields = 0;
 
                 spin_lock(&mp->m_sb_lock);
-                if (!XFS_SB_VERSION_HASATTR(&mp->m_sb)) {
-                        XFS_SB_VERSION_ADDATTR(&mp->m_sb);
+                if (!xfs_sb_version_hasattr(&mp->m_sb)) {
+                        xfs_sb_version_addattr(&mp->m_sb);
                         sbfields |= XFS_SB_VERSIONNUM;
                 }
-                if (!XFS_SB_VERSION_HASATTR2(&mp->m_sb) && version == 2) {
-                        XFS_SB_VERSION_ADDATTR2(&mp->m_sb);
+                if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) {
+                        xfs_sb_version_addattr2(&mp->m_sb);
                         sbfields |= (XFS_SB_VERSIONNUM | XFS_SB_FEATURES2);
                 }
                 if (sbfields) {
@@ -4154,16 +4153,21 @@ xfs_bmap_compute_maxlevels(
          * number of leaf entries, is controlled by the type of di_nextents
          * (a signed 32-bit number, xfs_extnum_t), or by di_anextents
          * (a signed 16-bit number, xfs_aextnum_t).
+         *
+         * Note that we can no longer assume that if we are in ATTR1 that
+         * the fork offset of all the inodes will be (m_attroffset >> 3)
+         * because we could have mounted with ATTR2 and then mounted back
+         * with ATTR1, keeping the di_forkoff's fixed but probably at
+         * various positions. Therefore, for both ATTR1 and ATTR2
+         * we have to assume the worst case scenario of a minimum size
+         * available.
          */
         if (whichfork == XFS_DATA_FORK) {
                 maxleafents = MAXEXTNUM;
-                sz = (mp->m_flags & XFS_MOUNT_ATTR2) ?
-                        XFS_BMDR_SPACE_CALC(MINDBTPTRS) : mp->m_attroffset;
+                sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
         } else {
                 maxleafents = MAXAEXTNUM;
-                sz = (mp->m_flags & XFS_MOUNT_ATTR2) ?
-                        XFS_BMDR_SPACE_CALC(MINABTPTRS) :
-                        mp->m_sb.sb_inodesize - mp->m_attroffset;
+                sz = XFS_BMDR_SPACE_CALC(MINABTPTRS);
         }
         maxrootrecs = (int)XFS_BTREE_BLOCK_MAXRECS(sz, xfs_bmdr, 0);
         minleafrecs = mp->m_bmap_dmnr[0];
@@ -5043,7 +5047,7 @@ xfs_bmapi(
                          * A wasdelay extent has been initialized, so
                          * shouldn't be flagged as unwritten.
                          */
-                        if (wr && XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
+                        if (wr && xfs_sb_version_hasextflgbit(&mp->m_sb)) {
                                 if (!wasdelay && (flags & XFS_BMAPI_PREALLOC))
                                         got.br_state = XFS_EXT_UNWRITTEN;
                         }
@@ -5483,7 +5487,7 @@ xfs_bunmapi(
                          * get rid of part of a realtime extent.
                          */
                         if (del.br_state == XFS_EXT_UNWRITTEN ||
-                            !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
+                            !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
                                 /*
                                  * This piece is unwritten, or we're not
                                  * using unwritten extents.  Skip over it.
@@ -5535,7 +5539,7 @@ xfs_bunmapi(
                         } else if ((del.br_startoff == start &&
                                     (del.br_state == XFS_EXT_UNWRITTEN ||
                                      xfs_trans_get_block_res(tp) == 0)) ||
-                                   !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
+                                   !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
                                 /*
                                  * Can't make it unwritten.  There isn't
                                  * a full extent here so just skip it.
@@ -5772,7 +5776,6 @@ xfs_getbmap(
         int                     error;          /* return value */
         __int64_t               fixlen;         /* length for -1 case */
         int                     i;              /* extent number */
-        bhv_vnode_t             *vp;            /* corresponding vnode */
         int                     lock;           /* lock state */
         xfs_bmbt_irec_t         *map;           /* buffer for user's data */
         xfs_mount_t             *mp;            /* file system mount point */
@@ -5789,7 +5792,6 @@ xfs_getbmap(
         int                     bmapi_flags;    /* flags for xfs_bmapi */
         __int32_t               oflags;         /* getbmapx bmv_oflags field */
 
-        vp = XFS_ITOV(ip);
         mp = ip->i_mount;
 
         whichfork = interface & BMV_IF_ATTRFORK ? XFS_ATTR_FORK : XFS_DATA_FORK;
@@ -5811,7 +5813,7 @@ xfs_getbmap(
         if ((interface & BMV_IF_NO_DMAPI_READ) == 0 &&
             DM_EVENT_ENABLED(ip, DM_EVENT_READ) &&
             whichfork == XFS_DATA_FORK) {
-                error = XFS_SEND_DATA(mp, DM_EVENT_READ, vp, 0, 0, 0, NULL);
+                error = XFS_SEND_DATA(mp, DM_EVENT_READ, ip, 0, 0, 0, NULL);
                 if (error)
                         return XFS_ERROR(error);
         }
@@ -5869,6 +5871,10 @@ xfs_getbmap(
                 /* xfs_fsize_t last_byte = xfs_file_last_byte(ip); */
                 error = xfs_flush_pages(ip, (xfs_off_t)0,
                                                -1, 0, FI_REMAPF);
+                if (error) {
+                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
+                return error;
+                }
         }
 
         ASSERT(whichfork == XFS_ATTR_FORK || ip->i_delayed_blks == 0);
@@ -6162,10 +6168,10 @@ xfs_check_block(
                         }
                         if (*thispa == *pp) {
                                 cmn_err(CE_WARN, "%s: thispa(%d) == pp(%d) %Ld",
-                                        __FUNCTION__, j, i,
+                                        __func__, j, i,
                                         (unsigned long long)be64_to_cpu(*thispa));
                                 panic("%s: ptrs are equal in node\n",
-                                        __FUNCTION__);
+                                        __func__);
                         }
                 }
         }
@@ -6192,7 +6198,7 @@ xfs_bmap_check_leaf_extents(
         xfs_mount_t             *mp;    /* file system mount structure */
         __be64                  *pp;    /* pointer to block address */
         xfs_bmbt_rec_t          *ep;    /* pointer to current extent */
-        xfs_bmbt_rec_t          *lastp; /* pointer to previous extent */
+        xfs_bmbt_rec_t          last = {0, 0}; /* last extent in prev block */
         xfs_bmbt_rec_t          *nextp; /* pointer to next extent */
         int                     bp_release = 0;
 
@@ -6262,7 +6268,6 @@ xfs_bmap_check_leaf_extents(
         /*
          * Loop over all leaf nodes checking that all extents are in the right order.
          */
-        lastp = NULL;
         for (;;) {
                 xfs_fsblock_t   nextbno;
                 xfs_extnum_t    num_recs;
@@ -6283,18 +6288,16 @@ xfs_bmap_check_leaf_extents(
                  */
 
                 ep = XFS_BTREE_REC_ADDR(xfs_bmbt, block, 1);
+                if (i) {
+                        xfs_btree_check_rec(XFS_BTNUM_BMAP, &last, ep);
+                }
                 for (j = 1; j < num_recs; j++) {
                         nextp = XFS_BTREE_REC_ADDR(xfs_bmbt, block, j + 1);
-                        if (lastp) {
-                                xfs_btree_check_rec(XFS_BTNUM_BMAP,
-                                        (void *)lastp, (void *)ep);
-                        }
-                        xfs_btree_check_rec(XFS_BTNUM_BMAP, (void *)ep,
-                                (void *)(nextp));
-                        lastp = ep;
+                        xfs_btree_check_rec(XFS_BTNUM_BMAP, ep, nextp);
                         ep = nextp;
                 }
 
+                last = *ep;
                 i += num_recs;
                 if (bp_release) {
                         bp_release = 0;
@@ -6325,13 +6328,13 @@ xfs_bmap_check_leaf_extents(
         return;
 
 error0:
-        cmn_err(CE_WARN, "%s: at error0", __FUNCTION__);
+        cmn_err(CE_WARN, "%s: at error0", __func__);
         if (bp_release)
                 xfs_trans_brelse(NULL, bp);
 error_norelse:
         cmn_err(CE_WARN, "%s: BAD after btree leaves for %d extents",
-                __FUNCTION__, i);
-        panic("%s: CORRUPTED BTREE OR SOMETHING", __FUNCTION__);
+                __func__, i);
+        panic("%s: CORRUPTED BTREE OR SOMETHING", __func__);
         return;
 }
 #endif