xfs: rename xfs_bmapi to xfs_bmapi_write (c0dc7828) · Commits · e / devices / android_kernel_teracube_2e

fs/xfs/xfs_attr.c

+2 −3

Original line number	Diff line number	Diff line
		@@ -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) {

fs/xfs/xfs_bmap.c

+94 −131

Original line number	Diff line number	Diff line
		@@ -4211,7 +4211,6 @@ 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_state == XFS_EXT_NORM \|\|
		@@ -4809,59 +4808,56 @@ 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 */
		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 */
		xfs_bmbt_irec_t mval, / output: map values */
		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 */
		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 */
		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; /* we've hit the end of extents */
		xfs_bmbt_rec_host_t ep; / extent record pointer */
		int eof; /* after the end of extents */
		int error; /* error return */
		xfs_bmbt_irec_t got; /* current file extent record */
		xfs_ifork_t ifp; / inode fork pointer */
		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 */
		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 */
		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 */
		char wr; /* this is a write request */
		char rt; /* this is a realtime file */

		#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 */
		struct xfs_bmbt_irec orig_mval; / original value of mval */
		int orig_nmap; /* original value of nmap /

		orig_bno = bno;
		@@ -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 */

		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)))
		}

		if (!(ifp->if_flags & XFS_IFEXTENTS)) {
		error = xfs_iread_extents(tp, ip, whichfork);
		if (error)
		goto error0;
		ep = xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got,
		&prev);
		}

		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);
		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 @@ xfs_bmapi(
		* 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 \|\|

fs/xfs/xfs_bmap.h

+13 −37

Original line number	Diff line number	Diff line
		@@ -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.

fs/xfs/xfs_da_btree.c

+4 −6

Original line number	Diff line number	Diff line
		@@ -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)

fs/xfs/xfs_dquot.c

+5 −7

Original line number	Diff line number	Diff line
		@@ -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) &&