8 files changed, 135 insertions, 212 deletions

diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index 41ef02b7185a..5484766938f9 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -2039,10 +2039,9 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
                  */
                 xfs_bmap_init(args->flist, args->firstblock);
                 nmap = 1;
-                error = xfs_bmapi(args->trans, dp, (xfs_fileoff_t)lblkno,
+                error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)lblkno,
                                   blkcnt,
-                                  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA |
-                                                        XFS_BMAPI_WRITE,
+                                  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
                                   args->firstblock, args->total, &map, &nmap,
                                   args->flist);
                 if (!error) {
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index c2e49fd18bfd..595cc6311937 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -4211,9 +4211,8 @@ xfs_bmap_validate_ret(
                 ASSERT(i == 0 ||
                        mval[i - 1].br_startoff + mval[i - 1].br_blockcount ==
                        mval[i].br_startoff);
-                if (flags & XFS_BMAPI_WRITE)
-                        ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK &&
-                               mval[i].br_startblock != HOLESTARTBLOCK);
+                ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK &&
+                       mval[i].br_startblock != HOLESTARTBLOCK);
                 ASSERT(mval[i].br_state == XFS_EXT_NORM ||
                        mval[i].br_state == XFS_EXT_UNWRITTEN);
         }
@@ -4809,60 +4808,57 @@ xfs_bmapi_convert_unwritten(
 }
 
 /*
- * Map file blocks to filesystem blocks.
- * File range is given by the bno/len pair.
- * Adds blocks to file if a write ("flags & XFS_BMAPI_WRITE" set)
- * into a hole or past eof.
- * Only allocates blocks from a single allocation group,
- * to avoid locking problems.
+ * Map file blocks to filesystem blocks, and allocate blocks or convert the
+ * extent state if necessary.  Details behaviour is controlled by the flags
+ * parameter.  Only allocates blocks from a single allocation group, to avoid
+ * locking problems.
+ *
  * The returned value in "firstblock" from the first call in a transaction
  * must be remembered and presented to subsequent calls in "firstblock".
  * An upper bound for the number of blocks to be allocated is supplied to
  * the first call in "total"; if no allocation group has that many free
  * blocks then the call will fail (return NULLFSBLOCK in "firstblock").
  */
-int                                     /* error */
-xfs_bmapi(
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_inode_t     *ip,            /* incore inode */
-        xfs_fileoff_t   bno,            /* starting file offs. mapped */
-        xfs_filblks_t   len,            /* length to map in file */
-        int             flags,          /* XFS_BMAPI_... */
-        xfs_fsblock_t   *firstblock,    /* first allocated block
-                                           controls a.g. for allocs */
-        xfs_extlen_t    total,          /* total blocks needed */
-        xfs_bmbt_irec_t *mval,          /* output: map values */
-        int             *nmap,          /* i/o: mval size/count */
-        xfs_bmap_free_t *flist)         /* i/o: list extents to free */
+int
+xfs_bmapi_write(
+        struct xfs_trans        *tp,            /* transaction pointer */
+        struct xfs_inode        *ip,            /* incore inode */
+        xfs_fileoff_t           bno,            /* starting file offs. mapped */
+        xfs_filblks_t           len,            /* length to map in file */
+        int                     flags,          /* XFS_BMAPI_... */
+        xfs_fsblock_t           *firstblock,    /* first allocated block
+                                                   controls a.g. for allocs */
+        xfs_extlen_t            total,          /* total blocks needed */
+        struct xfs_bmbt_irec    *mval,          /* output: map values */
+        int                     *nmap,          /* i/o: mval size/count */
+        struct xfs_bmap_free    *flist)         /* i/o: list extents to free */
 {
-        xfs_bmalloca_t  bma = { 0 };    /* args for xfs_bmap_alloc */
-        xfs_btree_cur_t *cur;           /* bmap btree cursor */
-        xfs_fileoff_t   end;            /* end of mapped file region */
-        int             eof;            /* we've hit the end of extents */
-        xfs_bmbt_rec_host_t *ep;        /* extent record pointer */
-        int             error;          /* error return */
-        xfs_bmbt_irec_t got;            /* current file extent record */
-        xfs_ifork_t     *ifp;           /* inode fork pointer */
-        xfs_extnum_t    lastx;          /* last useful extent number */
-        int             logflags;       /* flags for transaction logging */
-        xfs_extlen_t    minleft;        /* min blocks left after allocation */
-        xfs_mount_t     *mp;            /* xfs mount structure */
-        int             n;              /* current extent index */
-        int             nallocs;        /* number of extents alloc'd */
-        xfs_fileoff_t   obno;           /* old block number (offset) */
-        xfs_bmbt_irec_t prev;           /* previous file extent record */
-        int             tmp_logflags;   /* temp flags holder */
-        int             whichfork;      /* data or attr fork */
-        char            inhole;         /* current location is hole in file */
-        char            wasdelay;       /* old extent was delayed */
-        char            wr;             /* this is a write request */
-        char            rt;             /* this is a realtime file */
+        struct xfs_mount        *mp = ip->i_mount;
+        struct xfs_ifork        *ifp;
+        struct xfs_bmalloca     bma = { 0 };    /* args for xfs_bmap_alloc */
+        struct xfs_btree_cur    *cur;           /* bmap btree cursor */
+        xfs_fileoff_t           end;            /* end of mapped file region */
+        int                     eof;            /* after the end of extents */
+        int                     error;          /* error return */
+        struct xfs_bmbt_irec    got;            /* current file extent record */
+        xfs_extnum_t            lastx;          /* last useful extent number */
+        int                     logflags;       /* flags for transaction logging */
+        xfs_extlen_t            minleft;        /* min blocks left after allocation */
+        int                     n;              /* current extent index */
+        int                     nallocs;        /* number of extents alloc'd */
+        xfs_fileoff_t           obno;           /* old block number (offset) */
+        struct xfs_bmbt_irec    prev;           /* previous file extent record */
+        int                     tmp_logflags;   /* temp flags holder */
+        int                     whichfork;      /* data or attr fork */
+        char                    inhole;         /* current location is hole in file */
+        char                    wasdelay;       /* old extent was delayed */
+
 #ifdef DEBUG
-        xfs_fileoff_t   orig_bno;       /* original block number value */
-        int             orig_flags;     /* original flags arg value */
-        xfs_filblks_t   orig_len;       /* original value of len arg */
-        xfs_bmbt_irec_t *orig_mval;     /* original value of mval */
-        int             orig_nmap;      /* original value of *nmap */
+        xfs_fileoff_t           orig_bno;       /* original block number value */
+        int                     orig_flags;     /* original flags arg value */
+        xfs_filblks_t           orig_len;       /* original value of len arg */
+        struct xfs_bmbt_irec    *orig_mval;     /* original value of mval */
+        int                     orig_nmap;      /* original value of *nmap */
 
         orig_bno = bno;
         orig_len = len;
@@ -4870,69 +4866,60 @@ xfs_bmapi(
         orig_mval = mval;
         orig_nmap = *nmap;
 #endif
+
         ASSERT(*nmap >= 1);
-        ASSERT(*nmap <= XFS_BMAP_MAX_NMAP || !(flags & XFS_BMAPI_WRITE));
+        ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
+        ASSERT(!(flags & XFS_BMAPI_IGSTATE));
+        ASSERT(tp != NULL);
+
         whichfork = (flags & XFS_BMAPI_ATTRFORK) ?
                 XFS_ATTR_FORK : XFS_DATA_FORK;
-        mp = ip->i_mount;
+
         if (unlikely(XFS_TEST_ERROR(
             (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
              XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
              XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL),
              mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
-                XFS_ERROR_REPORT("xfs_bmapi", XFS_ERRLEVEL_LOW, mp);
+                XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp);
                 return XFS_ERROR(EFSCORRUPTED);
         }
+
         if (XFS_FORCED_SHUTDOWN(mp))
                 return XFS_ERROR(EIO);
-        rt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
+
         ifp = XFS_IFORK_PTR(ip, whichfork);
         ASSERT(ifp->if_ext_max ==
                XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));
-        if ((wr = (flags & XFS_BMAPI_WRITE)) != 0)
-                XFS_STATS_INC(xs_blk_mapw);
-        else
-                XFS_STATS_INC(xs_blk_mapr);
-        /*
-         * IGSTATE flag is used to combine extents which
-         * differ only due to the state of the extents.
-         * This technique is used from xfs_getbmap()
-         * when the caller does not wish to see the
-         * separation (which is the default).
-         *
-         * This technique is also used when writing a
-         * buffer which has been partially written,
-         * (usually by being flushed during a chunkread),
-         * to ensure one write takes place. This also
-         * prevents a change in the xfs inode extents at
-         * this time, intentionally. This change occurs
-         * on completion of the write operation, in
-         * xfs_strat_comp(), where the xfs_bmapi() call
-         * is transactioned, and the extents combined.
-         */
-        if ((flags & XFS_BMAPI_IGSTATE) && wr)  /* if writing unwritten space */
-                wr = 0;                         /* no allocations are allowed */
+
+        XFS_STATS_INC(xs_blk_mapw);
+
         logflags = 0;
         nallocs = 0;
         cur = NULL;
+
         if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
-                ASSERT(wr && tp);
-                if ((error = xfs_bmap_local_to_extents(tp, ip,
-                                firstblock, total, &logflags, whichfork)))
+                error = xfs_bmap_local_to_extents(tp, ip, firstblock, total,
+                                                  &logflags, whichfork);
+                if (error)
                         goto error0;
         }
-        if (wr && *firstblock == NULLFSBLOCK) {
+
+        if (*firstblock == NULLFSBLOCK) {
                 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE)
                         minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1;
                 else
                         minleft = 1;
-        } else
+        } else {
                 minleft = 0;
-        if (!(ifp->if_flags & XFS_IFEXTENTS) &&
-            (error = xfs_iread_extents(tp, ip, whichfork)))
-                goto error0;
-        ep = xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got,
-                &prev);
+        }
+
+        if (!(ifp->if_flags & XFS_IFEXTENTS)) {
+                error = xfs_iread_extents(tp, ip, whichfork);
+                if (error)
+                        goto error0;
+        }
+
+        xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got, &prev);
         n = 0;
         end = bno + len;
         obno = bno;
@@ -4945,19 +4932,14 @@ xfs_bmapi(
         bma.userdata = 0;
 
         while (bno < end && n < *nmap) {
-                /*
-                 * Reading past eof, act as though there's a hole
-                 * up to end.
-                 */
-                if (eof && !wr)
-                        got.br_startoff = end;
                 inhole = eof || got.br_startoff > bno;
-                wasdelay = wr && !inhole && isnullstartblock(got.br_startblock);
+                wasdelay = !inhole && isnullstartblock(got.br_startblock);
+
                 /*
                  * First, deal with the hole before the allocated space
                  * that we found, if any.
                  */
-                if (wr && (inhole || wasdelay)) {
+                if (inhole || wasdelay) {
                         bma.eof = eof;
                         bma.conv = !!(flags & XFS_BMAPI_CONVERT);
                         bma.wasdel = wasdelay;
@@ -4975,36 +4957,20 @@ xfs_bmapi(
                                 minleft = 0;
                         if (bma.rval == NULLFSBLOCK)
                                 break;
-                } else if (inhole) {
-                        /*
-                         * Reading in a hole.
-                         */
-                        mval->br_startoff = bno;
-                        mval->br_startblock = HOLESTARTBLOCK;
-                        mval->br_blockcount =
-                                XFS_FILBLKS_MIN(len, got.br_startoff - bno);
-                        mval->br_state = XFS_EXT_NORM;
-                        bno += mval->br_blockcount;
-                        len -= mval->br_blockcount;
-                        mval++;
-                        n++;
-                        continue;
                 }
 
                 /* Deal with the allocated space we found.  */
                 xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags);
 
                 /* Execute unwritten extent conversion if necessary */
-                if (wr) {
-                        error = xfs_bmapi_convert_unwritten(&bma, mval, len,
-                                                &lastx, &cur, firstblock, flist, flags,
-                                                &tmp_logflags);
-                        logflags |= tmp_logflags;
-                        if (error == EAGAIN)
-                                continue;
-                        if (error)
-                                goto error0;
-                }
+                error = xfs_bmapi_convert_unwritten(&bma, mval, len, &lastx,
+                                                    &cur, firstblock, flist,
+                                                    flags, &tmp_logflags);
+                logflags |= tmp_logflags;
+                if (error == EAGAIN)
+                        continue;
+                if (error)
+                        goto error0;
 
                 /* update the extent map to return */
                 xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
@@ -5016,24 +4982,22 @@ xfs_bmapi(
                  */
                 if (bno >= end || n >= *nmap || nallocs >= *nmap)
                         break;
-                /*
-                 * Else go on to the next record.
-                 */
+
+                /* Else go on to the next record. */
                 prev = got;
-                if (++lastx < ifp->if_bytes / sizeof(xfs_bmbt_rec_t)) {
-                        ep = xfs_iext_get_ext(ifp, lastx);
-                        xfs_bmbt_get_all(ep, &got);
-                } else {
+                if (++lastx < ifp->if_bytes / sizeof(xfs_bmbt_rec_t))
+                        xfs_bmbt_get_all(xfs_iext_get_ext(ifp, lastx), &got);
+                else
                         eof = 1;
-                }
         }
         *nmap = n;
+
         /*
          * Transform from btree to extents, give it cur.
          */
-        if (tp && XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&
+        if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&
             XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max) {
-                ASSERT(wr && cur);
+                ASSERT(cur);
                 error = xfs_bmap_btree_to_extents(tp, ip, cur,
                         &tmp_logflags, whichfork);
                 logflags |= tmp_logflags;
@@ -5061,10 +5025,9 @@ error0:
          * detecting a case where the data is changed, there's an error,
          * and it's not logged so we don't shutdown when we should.
          */
-        if (logflags) {
-                ASSERT(tp && wr);
+        if (logflags)
                 xfs_trans_log_inode(tp, ip, logflags);
-        }
+
         if (cur) {
                 if (!error) {
                         ASSERT(*firstblock == NULLFSBLOCK ||
diff --git a/fs/xfs/xfs_bmap.h b/fs/xfs/xfs_bmap.h
index c70c19c7f1fa..be235f56d2a6 100644
--- a/fs/xfs/xfs_bmap.h
+++ b/fs/xfs/xfs_bmap.h
@@ -62,25 +62,23 @@ typedef	struct xfs_bmap_free
 #define XFS_BMAP_MAX_NMAP       4
 
 /*
- * Flags for xfs_bmapi
+ * Flags for xfs_bmapi_*
  */
-#define XFS_BMAPI_WRITE         0x001   /* write operation: allocate space */
-#define XFS_BMAPI_ENTIRE        0x004   /* return entire extent, not trimmed */
-#define XFS_BMAPI_METADATA      0x008   /* mapping metadata not user data */
-#define XFS_BMAPI_ATTRFORK      0x010   /* use attribute fork not data */
-#define XFS_BMAPI_PREALLOC      0x040   /* preallocation op: unwritten space */
-#define XFS_BMAPI_IGSTATE       0x080   /* Ignore state - */
+#define XFS_BMAPI_ENTIRE        0x001   /* return entire extent, not trimmed */
+#define XFS_BMAPI_METADATA      0x002   /* mapping metadata not user data */
+#define XFS_BMAPI_ATTRFORK      0x004   /* use attribute fork not data */
+#define XFS_BMAPI_PREALLOC      0x008   /* preallocation op: unwritten space */
+#define XFS_BMAPI_IGSTATE       0x010   /* Ignore state - */
                                         /* combine contig. space */
-#define XFS_BMAPI_CONTIG        0x100   /* must allocate only one extent */
+#define XFS_BMAPI_CONTIG        0x020   /* must allocate only one extent */
 /*
  * unwritten extent conversion - this needs write cache flushing and no additional
  * allocation alignments. When specified with XFS_BMAPI_PREALLOC it converts
  * from written to unwritten, otherwise convert from unwritten to written.
  */
-#define XFS_BMAPI_CONVERT       0x200
+#define XFS_BMAPI_CONVERT       0x040
 
 #define XFS_BMAPI_FLAGS \
-        { XFS_BMAPI_WRITE,      "WRITE" }, \
         { XFS_BMAPI_ENTIRE,     "ENTIRE" }, \
         { XFS_BMAPI_METADATA,   "METADATA" }, \
         { XFS_BMAPI_ATTRFORK,   "ATTRFORK" }, \
@@ -265,39 +263,17 @@ xfs_bmap_read_extents(
         struct xfs_inode        *ip,            /* incore inode */
         int                     whichfork);     /* data or attr fork */
 
-/*
- * Map file blocks to filesystem blocks.
- * File range is given by the bno/len pair.
- * Adds blocks to file if a write ("flags & XFS_BMAPI_WRITE" set)
- * into a hole or past eof.
- * Only allocates blocks from a single allocation group,
- * to avoid locking problems.
- * The returned value in "firstblock" from the first call in a transaction
- * must be remembered and presented to subsequent calls in "firstblock".
- * An upper bound for the number of blocks to be allocated is supplied to
- * the first call in "total"; if no allocation group has that many free
- * blocks then the call will fail (return NULLFSBLOCK in "firstblock").
- */
-int                                             /* error */
-xfs_bmapi(
-        struct xfs_trans        *tp,            /* transaction pointer */
-        struct xfs_inode        *ip,            /* incore inode */
-        xfs_fileoff_t           bno,            /* starting file offs. mapped */
-        xfs_filblks_t           len,            /* length to map in file */
-        int                     flags,          /* XFS_BMAPI_... */
-        xfs_fsblock_t           *firstblock,    /* first allocated block
-                                                   controls a.g. for allocs */
-        xfs_extlen_t            total,          /* total blocks needed */
-        struct xfs_bmbt_irec    *mval,          /* output: map values */
-        int                     *nmap,          /* i/o: mval size/count */
-        xfs_bmap_free_t         *flist);        /* i/o: list extents to free */
-
 int     xfs_bmapi_read(struct xfs_inode *ip, xfs_fileoff_t bno,
                 xfs_filblks_t len, struct xfs_bmbt_irec *mval,
                 int *nmap, int flags);
 int     xfs_bmapi_delay(struct xfs_inode *ip, xfs_fileoff_t bno,
                 xfs_filblks_t len, struct xfs_bmbt_irec *mval,
                 int *nmap, int flags);
+int     xfs_bmapi_write(struct xfs_trans *tp, struct xfs_inode *ip,
+                xfs_fileoff_t bno, xfs_filblks_t len, int flags,
+                xfs_fsblock_t *firstblock, xfs_extlen_t total,
+                struct xfs_bmbt_irec *mval, int *nmap,
+                struct xfs_bmap_free *flist);
 
 /*
  * Unmap (remove) blocks from a file.
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 70a5f580e5ed..46c8aa2740da 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -1578,9 +1578,8 @@ xfs_da_grow_inode_int(
          */
         nmap = 1;
         ASSERT(args->firstblock != NULL);
-        error = xfs_bmapi(tp, dp, *bno, count,
-                        xfs_bmapi_aflag(w)|XFS_BMAPI_WRITE|XFS_BMAPI_METADATA|
-                        XFS_BMAPI_CONTIG,
+        error = xfs_bmapi_write(tp, dp, *bno, count,
+                        xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG,
                         args->firstblock, args->total, &map, &nmap,
                         args->flist);
         if (error)
@@ -1602,9 +1601,8 @@ xfs_da_grow_inode_int(
                 for (b = *bno, mapi = 0; b < *bno + count; ) {
                         nmap = MIN(XFS_BMAP_MAX_NMAP, count);
                         c = (int)(*bno + count - b);
-                        error = xfs_bmapi(tp, dp, b, c,
-                                        xfs_bmapi_aflag(w)|XFS_BMAPI_WRITE|
-                                        XFS_BMAPI_METADATA,
+                        error = xfs_bmapi_write(tp, dp, b, c,
+                                        xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
                                         args->firstblock, args->total,
                                         &mapp[mapi], &nmap, args->flist);
                         if (error)
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index c377961657ee..179673531f20 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -379,14 +379,12 @@ xfs_qm_dqalloc(
 
         xfs_trans_ijoin_ref(tp, quotip, XFS_ILOCK_EXCL);
         nmaps = 1;
-        if ((error = xfs_bmapi(tp, quotip,
-                              offset_fsb, XFS_DQUOT_CLUSTER_SIZE_FSB,
-                              XFS_BMAPI_METADATA | XFS_BMAPI_WRITE,
-                              &firstblock,
-                              XFS_QM_DQALLOC_SPACE_RES(mp),
-                              &map, &nmaps, &flist))) {
+        error = xfs_bmapi_write(tp, quotip, offset_fsb,
+                                XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA,
+                                &firstblock, XFS_QM_DQALLOC_SPACE_RES(mp),
+                                &map, &nmaps, &flist);
+        if (error)
                 goto error0;
-        }
         ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
         ASSERT(nmaps == 1);
         ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 681ba34c9233..da5bf05c5bb7 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -210,20 +210,18 @@ xfs_iomap_write_direct(
 
         xfs_trans_ijoin(tp, ip);
 
-        bmapi_flag = XFS_BMAPI_WRITE;
+        bmapi_flag = 0;
         if (offset < ip->i_size || extsz)
                 bmapi_flag |= XFS_BMAPI_PREALLOC;
 
         /*
-         * Issue the xfs_bmapi() call to allocate the blocks.
-         *
          * From this point onwards we overwrite the imap pointer that the
          * caller gave to us.
          */
         xfs_bmap_init(&free_list, &firstfsb);
         nimaps = 1;
-        error = xfs_bmapi(tp, ip, offset_fsb, count_fsb, bmapi_flag,
-                &firstfsb, 0, imap, &nimaps, &free_list);
+        error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb, bmapi_flag,
+                                &firstfsb, 0, imap, &nimaps, &free_list);
         if (error)
                 goto error0;
 
@@ -582,14 +580,12 @@ xfs_iomap_write_allocate(
                         }
 
                         /*
-                         * Go get the actual blocks.
-                         *
                          * From this point onwards we overwrite the imap
                          * pointer that the caller gave to us.
                          */
-                        error = xfs_bmapi(tp, ip, map_start_fsb, count_fsb,
-                                        XFS_BMAPI_WRITE, &first_block, 1,
-                                        imap, &nimaps, &free_list);
+                        error = xfs_bmapi_write(tp, ip, map_start_fsb,
+                                                count_fsb, 0, &first_block, 1,
+                                                imap, &nimaps, &free_list);
                         if (error)
                                 goto trans_cancel;
 
@@ -703,8 +699,8 @@ xfs_iomap_write_unwritten(
                  */
                 xfs_bmap_init(&free_list, &firstfsb);
                 nimaps = 1;
-                error = xfs_bmapi(tp, ip, offset_fsb, count_fsb,
-                                  XFS_BMAPI_WRITE|XFS_BMAPI_CONVERT, &firstfsb,
+                error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
+                                  XFS_BMAPI_CONVERT, &firstfsb,
                                   1, &imap, &nimaps, &free_list);
                 if (error)
                         goto error_on_bmapi_transaction;
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index e5f40c6460b2..f29424964521 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -120,9 +120,9 @@ xfs_growfs_rt_alloc(
                  */
                 nmap = 1;
                 cancelflags |= XFS_TRANS_ABORT;
-                error = xfs_bmapi(tp, ip, oblocks, nblocks - oblocks,
-                        XFS_BMAPI_WRITE | XFS_BMAPI_METADATA, &firstblock,
-                        resblks, &map, &nmap, &flist);
+                error = xfs_bmapi_write(tp, ip, oblocks, nblocks - oblocks,
+                                        XFS_BMAPI_METADATA, &firstblock,
+                                        resblks, &map, &nmap, &flist);
                 if (!error && nmap < 1)
                         error = XFS_ERROR(ENOSPC);
                 if (error)
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 63874a87b378..f47ecee8d437 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -1633,10 +1633,9 @@ xfs_symlink(
                 first_fsb = 0;
                 nmaps = SYMLINK_MAPS;
 
-                error = xfs_bmapi(tp, ip, first_fsb, fs_blocks,
-                                  XFS_BMAPI_WRITE | XFS_BMAPI_METADATA,
-                                  &first_block, resblks, mval, &nmaps,
-                                  &free_list);
+                error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
+                                  XFS_BMAPI_METADATA, &first_block, resblks,
+                                  mval, &nmaps, &free_list);
                 if (error)
                         goto error2;
 
@@ -1782,7 +1781,6 @@ xfs_alloc_file_space(
         xfs_fileoff_t           startoffset_fsb;
         xfs_fsblock_t           firstfsb;
         int                     nimaps;
-        int                     bmapi_flag;
         int                     quota_flag;
         int                     rt;
         xfs_trans_t             *tp;
@@ -1810,7 +1808,6 @@ xfs_alloc_file_space(
         count = len;
         imapp = &imaps[0];
         nimaps = 1;
-        bmapi_flag = XFS_BMAPI_WRITE | alloc_type;
         startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
         allocatesize_fsb = XFS_B_TO_FSB(mp, count);
 
@@ -1883,14 +1880,10 @@ xfs_alloc_file_space(
 
                 xfs_trans_ijoin(tp, ip);
 
-                /*
-                 * Issue the xfs_bmapi() call to allocate the blocks
-                 */
                 xfs_bmap_init(&free_list, &firstfsb);
-                error = xfs_bmapi(tp, ip, startoffset_fsb,
-                                  allocatesize_fsb, bmapi_flag,
-                                  &firstfsb, 0, imapp, &nimaps,
-                                  &free_list);
+                error = xfs_bmapi_write(tp, ip, startoffset_fsb,
+                                        allocatesize_fsb, alloc_type, &firstfsb,
+                                        0, imapp, &nimaps, &free_list);
                 if (error) {
                         goto error0;
                 }