~hc/RK356X_SDK_RELEASE.git

..	..	@@ -13,14 +13,10 @@
13	13	#include "xfs_sb.h"
14	14	#include "xfs_mount.h"
15	15	#include "xfs_defer.h"
16		-#include "xfs_da_format.h"
17		-#include "xfs_da_btree.h"
18	16	#include "xfs_dir2.h"
19	17	#include "xfs_inode.h"
20	18	#include "xfs_btree.h"
21	19	#include "xfs_trans.h"
22		-#include "xfs_inode_item.h"
23		-#include "xfs_extfree_item.h"
24	20	#include "xfs_alloc.h"
25	21	#include "xfs_bmap.h"
26	22	#include "xfs_bmap_util.h"
..	..	@@ -32,13 +28,13 @@
32	28	#include "xfs_trans_space.h"
33	29	#include "xfs_buf_item.h"
34	30	#include "xfs_trace.h"
35		-#include "xfs_symlink.h"
36	31	#include "xfs_attr_leaf.h"
37	32	#include "xfs_filestream.h"
38	33	#include "xfs_rmap.h"
39	34	#include "xfs_ag_resv.h"
40	35	#include "xfs_refcount.h"
41	36	#include "xfs_icache.h"
	37	+#include "xfs_iomap.h"
42	38
43	39
44	40	kmem_zone_t *xfs_bmap_free_item_zone;
..	..	@@ -65,10 +61,10 @@
65	61	int sz; /* root block size */
66	62
67	63	/*
68		- * The maximum number of extents in a file, hence the maximum
69		- * number of leaf entries, is controlled by the type of di_nextents
70		- * (a signed 32-bit number, xfs_extnum_t), or by di_anextents
71		- * (a signed 16-bit number, xfs_aextnum_t).
	64	+ * The maximum number of extents in a file, hence the maximum number of
	65	+ * leaf entries, is controlled by the size of the on-disk extent count,
	66	+ * either a signed 32-bit number for the data fork, or a signed 16-bit
	67	+ * number for the attr fork.
72	68	*
73	69	* Note that we can no longer assume that if we are in ATTR1 that
74	70	* the fork offset of all the inodes will be
..	..	@@ -124,10 +120,11 @@
124	120	*/
125	121	static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork)
126	122	{
	123	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
	124	+
127	125	return whichfork != XFS_COW_FORK &&
128		- XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
129		- XFS_IFORK_NEXTENTS(ip, whichfork) >
130		- XFS_IFORK_MAXEXT(ip, whichfork);
	126	+ ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
	127	+ ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork);
131	128	}
132	129
133	130	/*
..	..	@@ -135,10 +132,11 @@
135	132	*/
136	133	static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork)
137	134	{
	135	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
	136	+
138	137	return whichfork != XFS_COW_FORK &&
139		- XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&
140		- XFS_IFORK_NEXTENTS(ip, whichfork) <=
141		- XFS_IFORK_MAXEXT(ip, whichfork);
	138	+ ifp->if_format == XFS_DINODE_FMT_BTREE &&
	139	+ ifp->if_nextents <= XFS_IFORK_MAXEXT(ip, whichfork);
142	140	}
143	141
144	142	/*
..	..	@@ -197,14 +195,12 @@
197	195	struct xfs_mount *mp = ip->i_mount;
198	196	uint offset;
199	197
200		- if (mp->m_sb.sb_inodesize == 256) {
201		- offset = XFS_LITINO(mp, ip->i_d.di_version) -
202		- XFS_BMDR_SPACE_CALC(MINABTPTRS);
203		- } else {
	198	+ if (mp->m_sb.sb_inodesize == 256)
	199	+ offset = XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
	200	+ else
204	201	offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS);
205		- }
206	202
207		- ASSERT(offset < XFS_LITINO(mp, ip->i_d.di_version));
	203	+ ASSERT(offset < XFS_LITINO(mp));
208	204	return offset;
209	205	}
210	206
..	..	@@ -219,8 +215,8 @@
219	215	int whichfork)
220	216	{
221	217	if (whichfork == XFS_ATTR_FORK &&
222		- ip->i_d.di_format != XFS_DINODE_FMT_DEV &&
223		- ip->i_d.di_format != XFS_DINODE_FMT_BTREE) {
	218	+ ip->i_df.if_format != XFS_DINODE_FMT_DEV &&
	219	+ ip->i_df.if_format != XFS_DINODE_FMT_BTREE) {
224	220	uint dfl_forkoff = xfs_default_attroffset(ip) >> 3;
225	221
226	222	if (dfl_forkoff > ip->i_d.di_forkoff)
..	..	@@ -321,31 +317,28 @@
321	317	xfs_inode_t ip, / incore inode pointer */
322	318	int whichfork) /* data or attr fork */
323	319	{
	320	+ struct xfs_mount *mp = ip->i_mount;
	321	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
324	322	struct xfs_btree_block block; / current btree block */
325	323	xfs_fsblock_t bno; /* block # of "block" */
326	324	xfs_buf_t bp; / buffer for "block" */
327	325	int error; /* error return value */
328	326	xfs_extnum_t i=0, j; /* index into the extents list */
329		- struct xfs_ifork ifp; / fork structure */
330	327	int level; /* btree level, for checking */
331		- xfs_mount_t mp; / file system mount structure */
332	328	__be64 pp; / pointer to block address */
333	329	xfs_bmbt_rec_t ep; / pointer to current extent */
334	330	xfs_bmbt_rec_t last = {0, 0}; /* last extent in prev block */
335	331	xfs_bmbt_rec_t nextp; / pointer to next extent */
336	332	int bp_release = 0;
337	333
338		- if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) {
	334	+ if (ifp->if_format != XFS_DINODE_FMT_BTREE)
339	335	return;
340		- }
341	336
342	337	/* skip large extent count inodes */
343		- if (ip->i_d.di_nextents > 10000)
	338	+ if (ip->i_df.if_nextents > 10000)
344	339	return;
345	340
346	341	bno = NULLFSBLOCK;
347		- mp = ip->i_mount;
348		- ifp = XFS_IFORK_PTR(ip, whichfork);
349	342	block = ifp->if_broot;
350	343	/*
351	344	* Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
..	..	@@ -370,7 +363,7 @@
370	363	bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
371	364	if (!bp) {
372	365	bp_release = 1;
373		- error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp,
	366	+ error = xfs_btree_read_bufl(mp, NULL, bno, &bp,
374	367	XFS_BMAP_BTREE_REF,
375	368	&xfs_bmbt_buf_ops);
376	369	if (error)
..	..	@@ -388,8 +381,10 @@
388	381	xfs_check_block(block, mp, 0, 0);
389	382	pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
390	383	bno = be64_to_cpu(*pp);
391		- XFS_WANT_CORRUPTED_GOTO(mp,
392		- xfs_verify_fsbno(mp, bno), error0);
	384	+ if (XFS_IS_CORRUPT(mp, !xfs_verify_fsbno(mp, bno))) {
	385	+ error = -EFSCORRUPTED;
	386	+ goto error0;
	387	+ }
393	388	if (bp_release) {
394	389	bp_release = 0;
395	390	xfs_trans_brelse(NULL, bp);
..	..	@@ -454,7 +449,7 @@
454	449	bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
455	450	if (!bp) {
456	451	bp_release = 1;
457		- error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp,
	452	+ error = xfs_btree_read_bufl(mp, NULL, bno, &bp,
458	453	XFS_BMAP_BTREE_REF,
459	454	&xfs_bmbt_buf_ops);
460	455	if (error)
..	..	@@ -536,7 +531,7 @@
536	531	struct xfs_trans *tp,
537	532	xfs_fsblock_t bno,
538	533	xfs_filblks_t len,
539		- struct xfs_owner_info *oinfo,
	534	+ const struct xfs_owner_info *oinfo,
540	535	bool skip_discard)
541	536	{
542	537	struct xfs_extent_free_item new; / new element */
..	..	@@ -558,13 +553,14 @@
558	553	#endif
559	554	ASSERT(xfs_bmap_free_item_zone != NULL);
560	555
561		- new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP);
	556	+ new = kmem_cache_alloc(xfs_bmap_free_item_zone,
	557	+ GFP_KERNEL \| __GFP_NOFAIL);
562	558	new->xefi_startblock = bno;
563	559	new->xefi_blockcount = (xfs_extlen_t)len;
564	560	if (oinfo)
565	561	new->xefi_oinfo = *oinfo;
566	562	else
567		- xfs_rmap_skip_owner_update(&new->xefi_oinfo);
	563	+ new->xefi_oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
568	564	new->xefi_skip_discard = skip_discard;
569	565	trace_xfs_bmap_free_defer(tp->t_mountp,
570	566	XFS_FSB_TO_AGNO(tp->t_mountp, bno), 0,
..	..	@@ -577,47 +573,49 @@
577	573	*/
578	574
579	575	/*
580		- * Transform a btree format file with only one leaf node, where the
581		- * extents list will fit in the inode, into an extents format file.
582		- * Since the file extents are already in-core, all we have to do is
583		- * give up the space for the btree root and pitch the leaf block.
	576	+ * Convert the inode format to extent format if it currently is in btree format,
	577	+ * but the extent list is small enough that it fits into the extent format.
	578	+ *
	579	+ * Since the extents are already in-core, all we have to do is give up the space
	580	+ * for the btree root and pitch the leaf block.
584	581	*/
585	582	STATIC int /* error */
586	583	xfs_bmap_btree_to_extents(
587		- xfs_trans_t tp, / transaction pointer */
588		- xfs_inode_t ip, / incore inode pointer */
589		- xfs_btree_cur_t cur, / btree cursor */
	584	+ struct xfs_trans tp, / transaction pointer */
	585	+ struct xfs_inode ip, / incore inode pointer */
	586	+ struct xfs_btree_cur cur, / btree cursor */
590	587	int logflagsp, / inode logging flags */
591	588	int whichfork) /* data or attr fork */
592	589	{
593		- /* REFERENCED */
	590	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
	591	+ struct xfs_mount *mp = ip->i_mount;
	592	+ struct xfs_btree_block *rblock = ifp->if_broot;
594	593	struct xfs_btree_block cblock;/ child btree block */
595	594	xfs_fsblock_t cbno; /* child block number */
596	595	xfs_buf_t cbp; / child block's buffer */
597	596	int error; /* error return value */
598		- struct xfs_ifork ifp; / inode fork data */
599		- xfs_mount_t mp; / mount point structure */
600	597	__be64 pp; / ptr to block address */
601		- struct xfs_btree_block rblock;/ root btree block */
602	598	struct xfs_owner_info oinfo;
603	599
604		- mp = ip->i_mount;
605		- ifp = XFS_IFORK_PTR(ip, whichfork);
	600	+ /* check if we actually need the extent format first: */
	601	+ if (!xfs_bmap_wants_extents(ip, whichfork))
	602	+ return 0;
	603	+
	604	+ ASSERT(cur);
606	605	ASSERT(whichfork != XFS_COW_FORK);
607	606	ASSERT(ifp->if_flags & XFS_IFEXTENTS);
608		- ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
609		- rblock = ifp->if_broot;
	607	+ ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
610	608	ASSERT(be16_to_cpu(rblock->bb_level) == 1);
611	609	ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1);
612	610	ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1);
	611	+
613	612	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes);
614	613	cbno = be64_to_cpu(*pp);
615		- *logflagsp = 0;
616	614	#ifdef DEBUG
617		- XFS_WANT_CORRUPTED_RETURN(cur->bc_mp,
618		- xfs_btree_check_lptr(cur, cbno, 1));
	615	+ if (XFS_IS_CORRUPT(cur->bc_mp, !xfs_btree_check_lptr(cur, cbno, 1)))
	616	+ return -EFSCORRUPTED;
619	617	#endif
620		- error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF,
	618	+ error = xfs_btree_read_bufl(mp, tp, cbno, &cbp, XFS_BMAP_BTREE_REF,
621	619	&xfs_bmbt_buf_ops);
622	620	if (error)
623	621	return error;
..	..	@@ -634,8 +632,8 @@
634	632	xfs_iroot_realloc(ip, -1, whichfork);
635	633	ASSERT(ifp->if_broot == NULL);
636	634	ASSERT((ifp->if_flags & XFS_IFBROOT) == 0);
637		- XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
638		- *logflagsp = XFS_ILOG_CORE \| xfs_ilog_fext(whichfork);
	635	+ ifp->if_format = XFS_DINODE_FMT_EXTENTS;
	636	+ *logflagsp \|= XFS_ILOG_CORE \| xfs_ilog_fext(whichfork);
639	637	return 0;
640	638	}
641	639
..	..	@@ -670,7 +668,7 @@
670	668	mp = ip->i_mount;
671	669	ASSERT(whichfork != XFS_COW_FORK);
672	670	ifp = XFS_IFORK_PTR(ip, whichfork);
673		- ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS);
	671	+ ASSERT(ifp->if_format == XFS_DINODE_FMT_EXTENTS);
674	672
675	673	/*
676	674	* Make space in the inode incore. This needs to be undone if we fail
..	..	@@ -690,11 +688,11 @@
690	688	* Need a cursor. Can't allocate until bb_level is filled in.
691	689	*/
692	690	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
693		- cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0;
	691	+ cur->bc_ino.flags = wasdel ? XFS_BTCUR_BMBT_WASDEL : 0;
694	692	/*
695	693	* Convert to a btree with two levels, one record in root.
696	694	*/
697		- XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE);
	695	+ ifp->if_format = XFS_DINODE_FMT_BTREE;
698	696	memset(&args, 0, sizeof(args));
699	697	args.tp = tp;
700	698	args.mp = mp;
..	..	@@ -727,14 +725,14 @@
727	725	ASSERT(tp->t_firstblock == NULLFSBLOCK \|\|
728	726	args.agno >= XFS_FSB_TO_AGNO(mp, tp->t_firstblock));
729	727	tp->t_firstblock = args.fsbno;
730		- cur->bc_private.b.allocated++;
	728	+ cur->bc_ino.allocated++;
731	729	ip->i_d.di_nblocks++;
732	730	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L);
733		- abp = xfs_btree_get_bufl(mp, tp, args.fsbno, 0);
734		- if (!abp) {
735		- error = -EFSCORRUPTED;
	731	+ error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
	732	+ XFS_FSB_TO_DADDR(mp, args.fsbno),
	733	+ mp->m_bsize, 0, &abp);
	734	+ if (error)
736	735	goto out_unreserve_dquot;
737		- }
738	736
739	737	/*
740	738	* Fill in the child block.
..	..	@@ -752,7 +750,7 @@
752	750	xfs_bmbt_disk_set_all(arp, &rec);
753	751	cnt++;
754	752	}
755		- ASSERT(cnt == XFS_IFORK_NEXTENTS(ip, whichfork));
	753	+ ASSERT(cnt == ifp->if_nextents);
756	754	xfs_btree_set_numrecs(ablock, cnt);
757	755
758	756	/*
..	..	@@ -780,7 +778,7 @@
780	778	xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
781	779	out_root_realloc:
782	780	xfs_iroot_realloc(ip, -1, whichfork);
783		- XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
	781	+ ifp->if_format = XFS_DINODE_FMT_EXTENTS;
784	782	ASSERT(ifp->if_broot == NULL);
785	783	xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
786	784
..	..	@@ -795,22 +793,24 @@
795	793	*/
796	794	void
797	795	xfs_bmap_local_to_extents_empty(
	796	+ struct xfs_trans *tp,
798	797	struct xfs_inode *ip,
799	798	int whichfork)
800	799	{
801	800	struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
802	801
803	802	ASSERT(whichfork != XFS_COW_FORK);
804		- ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
	803	+ ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
805	804	ASSERT(ifp->if_bytes == 0);
806		- ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0);
	805	+ ASSERT(ifp->if_nextents == 0);
807	806
808	807	xfs_bmap_forkoff_reset(ip, whichfork);
809	808	ifp->if_flags &= ~XFS_IFINLINE;
810	809	ifp->if_flags \|= XFS_IFEXTENTS;
811	810	ifp->if_u1.if_root = NULL;
812	811	ifp->if_height = 0;
813		- XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
	812	+ ifp->if_format = XFS_DINODE_FMT_EXTENTS;
	813	+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
814	814	}
815	815
816	816
..	..	@@ -840,10 +840,10 @@
840	840	*/
841	841	ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK));
842	842	ifp = XFS_IFORK_PTR(ip, whichfork);
843		- ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
	843	+ ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
844	844
845	845	if (!ifp->if_bytes) {
846		- xfs_bmap_local_to_extents_empty(ip, whichfork);
	846	+ xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
847	847	flags = XFS_ILOG_CORE;
848	848	goto done;
849	849	}
..	..	@@ -876,7 +876,11 @@
876	876	ASSERT(args.fsbno != NULLFSBLOCK);
877	877	ASSERT(args.len == 1);
878	878	tp->t_firstblock = args.fsbno;
879		- bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0);
	879	+ error = xfs_trans_get_buf(tp, args.mp->m_ddev_targp,
	880	+ XFS_FSB_TO_DADDR(args.mp, args.fsbno),
	881	+ args.mp->m_bsize, 0, &bp);
	882	+ if (error)
	883	+ goto done;
880	884
881	885	/*
882	886	* Initialize the block, copy the data and log the remote buffer.
..	..	@@ -890,7 +894,7 @@
890	894
891	895	/* account for the change in fork size */
892	896	xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
893		- xfs_bmap_local_to_extents_empty(ip, whichfork);
	897	+ xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
894	898	flags \|= XFS_ILOG_CORE;
895	899
896	900	ifp->if_u1.if_root = NULL;
..	..	@@ -903,7 +907,7 @@
903	907	xfs_iext_first(ifp, &icur);
904	908	xfs_iext_insert(ip, &icur, &rec, 0);
905	909
906		- XFS_IFORK_NEXT_SET(ip, whichfork, 1);
	910	+ ifp->if_nextents = 1;
907	911	ip->i_d.di_nblocks = 1;
908	912	xfs_trans_mod_dquot_byino(tp, ip,
909	913	XFS_TRANS_DQ_BCOUNT, 1L);
..	..	@@ -937,14 +941,17 @@
937	941	if (error)
938	942	goto error0;
939	943	/* must be at least one entry */
940		- XFS_WANT_CORRUPTED_GOTO(mp, stat == 1, error0);
	944	+ if (XFS_IS_CORRUPT(mp, stat != 1)) {
	945	+ error = -EFSCORRUPTED;
	946	+ goto error0;
	947	+ }
941	948	if ((error = xfs_btree_new_iroot(cur, flags, &stat)))
942	949	goto error0;
943	950	if (stat == 0) {
944	951	xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
945	952	return -ENOSPC;
946	953	}
947		- cur->bc_private.b.allocated = 0;
	954	+ cur->bc_ino.allocated = 0;
948	955	xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
949	956	}
950	957	return 0;
..	..	@@ -965,13 +972,14 @@
965	972	xfs_btree_cur_t cur; / bmap btree cursor */
966	973	int error; /* error return value */
967	974
968		- if (ip->i_d.di_nextents * sizeof(xfs_bmbt_rec_t) <= XFS_IFORK_DSIZE(ip))
	975	+ if (ip->i_df.if_nextents * sizeof(struct xfs_bmbt_rec) <=
	976	+ XFS_IFORK_DSIZE(ip))
969	977	return 0;
970	978	cur = NULL;
971	979	error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, flags,
972	980	XFS_DATA_FORK);
973	981	if (cur) {
974		- cur->bc_private.b.allocated = 0;
	982	+ cur->bc_ino.allocated = 0;
975	983	xfs_btree_del_cursor(cur, error);
976	984	}
977	985	return error;
..	..	@@ -1026,7 +1034,7 @@
1026	1034	int size,
1027	1035	int *version)
1028	1036	{
1029		- switch (ip->i_d.di_format) {
	1037	+ switch (ip->i_df.if_format) {
1030	1038	case XFS_DINODE_FMT_DEV:
1031	1039	ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
1032	1040	break;
..	..	@@ -1084,17 +1092,6 @@
1084	1092	goto trans_cancel;
1085	1093	if (XFS_IFORK_Q(ip))
1086	1094	goto trans_cancel;
1087		- if (ip->i_d.di_anextents != 0) {
1088		- error = -EFSCORRUPTED;
1089		- goto trans_cancel;
1090		- }
1091		- if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS) {
1092		- /*
1093		- * For inodes coming from pre-6.2 filesystems.
1094		- */
1095		- ASSERT(ip->i_d.di_aformat == 0);
1096		- ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
1097		- }
1098	1095
1099	1096	xfs_trans_ijoin(tp, ip, 0);
1100	1097	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
..	..	@@ -1102,10 +1099,14 @@
1102	1099	if (error)
1103	1100	goto trans_cancel;
1104	1101	ASSERT(ip->i_afp == NULL);
1105		- ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
	1102	+
	1103	+ ip->i_afp = kmem_cache_zalloc(xfs_ifork_zone,
	1104	+ GFP_KERNEL \| __GFP_NOFAIL);
	1105	+
	1106	+ ip->i_afp->if_format = XFS_DINODE_FMT_EXTENTS;
1106	1107	ip->i_afp->if_flags = XFS_IFEXTENTS;
1107	1108	logflags = 0;
1108		- switch (ip->i_d.di_format) {
	1109	+ switch (ip->i_df.if_format) {
1109	1110	case XFS_DINODE_FMT_LOCAL:
1110	1111	error = xfs_bmap_add_attrfork_local(tp, ip, &logflags);
1111	1112	break;
..	..	@@ -1155,6 +1156,65 @@
1155	1156	* Internal and external extent tree search functions.
1156	1157	*/
1157	1158
	1159	+struct xfs_iread_state {
	1160	+ struct xfs_iext_cursor icur;
	1161	+ xfs_extnum_t loaded;
	1162	+};
	1163	+
	1164	+/* Stuff every bmbt record from this block into the incore extent map. */
	1165	+static int
	1166	+xfs_iread_bmbt_block(
	1167	+ struct xfs_btree_cur *cur,
	1168	+ int level,
	1169	+ void *priv)
	1170	+{
	1171	+ struct xfs_iread_state *ir = priv;
	1172	+ struct xfs_mount *mp = cur->bc_mp;
	1173	+ struct xfs_inode *ip = cur->bc_ino.ip;
	1174	+ struct xfs_btree_block *block;
	1175	+ struct xfs_buf *bp;
	1176	+ struct xfs_bmbt_rec *frp;
	1177	+ xfs_extnum_t num_recs;
	1178	+ xfs_extnum_t j;
	1179	+ int whichfork = cur->bc_ino.whichfork;
	1180	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
	1181	+
	1182	+ block = xfs_btree_get_block(cur, level, &bp);
	1183	+
	1184	+ /* Abort if we find more records than nextents. */
	1185	+ num_recs = xfs_btree_get_numrecs(block);
	1186	+ if (unlikely(ir->loaded + num_recs > ifp->if_nextents)) {
	1187	+ xfs_warn(ip->i_mount, "corrupt dinode %llu, (btree extents).",
	1188	+ (unsigned long long)ip->i_ino);
	1189	+ xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__, block,
	1190	+ sizeof(*block), __this_address);
	1191	+ return -EFSCORRUPTED;
	1192	+ }
	1193	+
	1194	+ /* Copy records into the incore cache. */
	1195	+ frp = XFS_BMBT_REC_ADDR(mp, block, 1);
	1196	+ for (j = 0; j < num_recs; j++, frp++, ir->loaded++) {
	1197	+ struct xfs_bmbt_irec new;
	1198	+ xfs_failaddr_t fa;
	1199	+
	1200	+ xfs_bmbt_disk_get_all(frp, &new);
	1201	+ fa = xfs_bmap_validate_extent(ip, whichfork, &new);
	1202	+ if (fa) {
	1203	+ xfs_inode_verifier_error(ip, -EFSCORRUPTED,
	1204	+ "xfs_iread_extents(2)", frp,
	1205	+ sizeof(*frp), fa);
	1206	+ return -EFSCORRUPTED;
	1207	+ }
	1208	+ xfs_iext_insert(ip, &ir->icur, &new,
	1209	+ xfs_bmap_fork_to_state(whichfork));
	1210	+ trace_xfs_read_extent(ip, &ir->icur,
	1211	+ xfs_bmap_fork_to_state(whichfork), _THIS_IP_);
	1212	+ xfs_iext_next(ifp, &ir->icur);
	1213	+ }
	1214	+
	1215	+ return 0;
	1216	+}
	1217	+
1158	1218	/*
1159	1219	* Read in extents from a btree-format inode.
1160	1220	*/
..	..	@@ -1164,134 +1224,36 @@
1164	1224	struct xfs_inode *ip,
1165	1225	int whichfork)
1166	1226	{
1167		- struct xfs_mount *mp = ip->i_mount;
1168		- int state = xfs_bmap_fork_to_state(whichfork);
	1227	+ struct xfs_iread_state ir;
1169	1228	struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1170		- xfs_extnum_t nextents = XFS_IFORK_NEXTENTS(ip, whichfork);
1171		- struct xfs_btree_block *block = ifp->if_broot;
1172		- struct xfs_iext_cursor icur;
1173		- struct xfs_bmbt_irec new;
1174		- xfs_fsblock_t bno;
1175		- struct xfs_buf *bp;
1176		- xfs_extnum_t i, j;
1177		- int level;
1178		- __be64 *pp;
	1229	+ struct xfs_mount *mp = ip->i_mount;
	1230	+ struct xfs_btree_cur *cur;
1179	1231	int error;
1180	1232
1181	1233	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1182	1234
1183		- if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
1184		- XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
1185		- return -EFSCORRUPTED;
1186		- }
1187		-
1188		- /*
1189		- * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
1190		- */
1191		- level = be16_to_cpu(block->bb_level);
1192		- if (unlikely(level == 0)) {
1193		- XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
1194		- return -EFSCORRUPTED;
1195		- }
1196		- pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
1197		- bno = be64_to_cpu(*pp);
1198		-
1199		- /*
1200		- * Go down the tree until leaf level is reached, following the first
1201		- * pointer (leftmost) at each level.
1202		- */
1203		- while (level-- > 0) {
1204		- error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp,
1205		- XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops);
1206		- if (error)
1207		- goto out;
1208		- block = XFS_BUF_TO_BLOCK(bp);
1209		- if (level == 0)
1210		- break;
1211		- pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
1212		- bno = be64_to_cpu(*pp);
1213		- XFS_WANT_CORRUPTED_GOTO(mp,
1214		- xfs_verify_fsbno(mp, bno), out_brelse);
1215		- xfs_trans_brelse(tp, bp);
1216		- }
1217		-
1218		- /*
1219		- * Here with bp and block set to the leftmost leaf node in the tree.
1220		- */
1221		- i = 0;
1222		- xfs_iext_first(ifp, &icur);
1223		-
1224		- /*
1225		- * Loop over all leaf nodes. Copy information to the extent records.
1226		- */
1227		- for (;;) {
1228		- xfs_bmbt_rec_t *frp;
1229		- xfs_fsblock_t nextbno;
1230		- xfs_extnum_t num_recs;
1231		-
1232		- num_recs = xfs_btree_get_numrecs(block);
1233		- if (unlikely(i + num_recs > nextents)) {
1234		- xfs_warn(ip->i_mount,
1235		- "corrupt dinode %Lu, (btree extents).",
1236		- (unsigned long long) ip->i_ino);
1237		- xfs_inode_verifier_error(ip, -EFSCORRUPTED,
1238		- __func__, block, sizeof(*block),
1239		- __this_address);
1240		- error = -EFSCORRUPTED;
1241		- goto out_brelse;
1242		- }
1243		- /*
1244		- * Read-ahead the next leaf block, if any.
1245		- */
1246		- nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
1247		- if (nextbno != NULLFSBLOCK)
1248		- xfs_btree_reada_bufl(mp, nextbno, 1,
1249		- &xfs_bmbt_buf_ops);
1250		- /*
1251		- * Copy records into the extent records.
1252		- */
1253		- frp = XFS_BMBT_REC_ADDR(mp, block, 1);
1254		- for (j = 0; j < num_recs; j++, frp++, i++) {
1255		- xfs_failaddr_t fa;
1256		-
1257		- xfs_bmbt_disk_get_all(frp, &new);
1258		- fa = xfs_bmap_validate_extent(ip, whichfork, &new);
1259		- if (fa) {
1260		- error = -EFSCORRUPTED;
1261		- xfs_inode_verifier_error(ip, error,
1262		- "xfs_iread_extents(2)",
1263		- frp, sizeof(*frp), fa);
1264		- goto out_brelse;
1265		- }
1266		- xfs_iext_insert(ip, &icur, &new, state);
1267		- trace_xfs_read_extent(ip, &icur, state, _THIS_IP_);
1268		- xfs_iext_next(ifp, &icur);
1269		- }
1270		- xfs_trans_brelse(tp, bp);
1271		- bno = nextbno;
1272		- /*
1273		- * If we've reached the end, stop.
1274		- */
1275		- if (bno == NULLFSBLOCK)
1276		- break;
1277		- error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp,
1278		- XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops);
1279		- if (error)
1280		- goto out;
1281		- block = XFS_BUF_TO_BLOCK(bp);
1282		- }
1283		-
1284		- if (i != XFS_IFORK_NEXTENTS(ip, whichfork)) {
	1235	+ if (XFS_IS_CORRUPT(mp, ifp->if_format != XFS_DINODE_FMT_BTREE)) {
1285	1236	error = -EFSCORRUPTED;
1286	1237	goto out;
1287	1238	}
1288		- ASSERT(i == xfs_iext_count(ifp));
	1239	+
	1240	+ ir.loaded = 0;
	1241	+ xfs_iext_first(ifp, &ir.icur);
	1242	+ cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
	1243	+ error = xfs_btree_visit_blocks(cur, xfs_iread_bmbt_block,
	1244	+ XFS_BTREE_VISIT_RECORDS, &ir);
	1245	+ xfs_btree_del_cursor(cur, error);
	1246	+ if (error)
	1247	+ goto out;
	1248	+
	1249	+ if (XFS_IS_CORRUPT(mp, ir.loaded != ifp->if_nextents)) {
	1250	+ error = -EFSCORRUPTED;
	1251	+ goto out;
	1252	+ }
	1253	+ ASSERT(ir.loaded == xfs_iext_count(ifp));
1289	1254
1290	1255	ifp->if_flags \|= XFS_IFEXTENTS;
1291	1256	return 0;
1292		-
1293		-out_brelse:
1294		- xfs_trans_brelse(tp, bp);
1295	1257	out:
1296	1258	xfs_iext_destroy(ifp);
1297	1259	return error;
..	..	@@ -1318,14 +1280,12 @@
1318	1280	xfs_fileoff_t lowest, max;
1319	1281	int error;
1320	1282
1321		- ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE \|\|
1322		- XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS \|\|
1323		- XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
1324		-
1325		- if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
	1283	+ if (ifp->if_format == XFS_DINODE_FMT_LOCAL) {
1326	1284	*first_unused = 0;
1327	1285	return 0;
1328	1286	}
	1287	+
	1288	+ ASSERT(xfs_ifork_has_extents(ifp));
1329	1289
1330	1290	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1331	1291	error = xfs_iread_extents(tp, ip, whichfork);
..	..	@@ -1367,7 +1327,7 @@
1367	1327	struct xfs_iext_cursor icur;
1368	1328	int error;
1369	1329
1370		- switch (XFS_IFORK_FORMAT(ip, whichfork)) {
	1330	+ switch (ifp->if_format) {
1371	1331	case XFS_DINODE_FMT_LOCAL:
1372	1332	*last_block = 0;
1373	1333	return 0;
..	..	@@ -1375,7 +1335,8 @@
1375	1335	case XFS_DINODE_FMT_EXTENTS:
1376	1336	break;
1377	1337	default:
1378		- return -EIO;
	1338	+ ASSERT(0);
	1339	+ return -EFSCORRUPTED;
1379	1340	}
1380	1341
1381	1342	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
..	..	@@ -1465,18 +1426,18 @@
1465	1426	xfs_fileoff_t *last_block,
1466	1427	int whichfork)
1467	1428	{
	1429	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1468	1430	struct xfs_bmbt_irec rec;
1469	1431	int is_empty;
1470	1432	int error;
1471	1433
1472	1434	*last_block = 0;
1473	1435
1474		- if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL)
	1436	+ if (ifp->if_format == XFS_DINODE_FMT_LOCAL)
1475	1437	return 0;
1476	1438
1477		- if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
1478		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
1479		- return -EIO;
	1439	+ if (XFS_IS_CORRUPT(ip->i_mount, !xfs_ifork_has_extents(ifp)))
	1440	+ return -EFSCORRUPTED;
1480	1441
1481	1442	error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
1482	1443	if (error \|\| is_empty)
..	..	@@ -1493,23 +1454,22 @@
1493	1454	*/
1494	1455	int /* 1=>1 block, 0=>otherwise */
1495	1456	xfs_bmap_one_block(
1496		- xfs_inode_t ip, / incore inode */
1497		- int whichfork) /* data or attr fork */
	1457	+ struct xfs_inode ip, / incore inode */
	1458	+ int whichfork) /* data or attr fork */
1498	1459	{
1499		- struct xfs_ifork ifp; / inode fork pointer */
1500		- int rval; /* return value */
1501		- xfs_bmbt_irec_t s; /* internal version of extent */
	1460	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
	1461	+ int rval; /* return value */
	1462	+ struct xfs_bmbt_irec s; /* internal version of extent */
1502	1463	struct xfs_iext_cursor icur;
1503	1464
1504	1465	#ifndef DEBUG
1505	1466	if (whichfork == XFS_DATA_FORK)
1506	1467	return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize;
1507	1468	#endif /* !DEBUG */
1508		- if (XFS_IFORK_NEXTENTS(ip, whichfork) != 1)
	1469	+ if (ifp->if_nextents != 1)
1509	1470	return 0;
1510		- if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
	1471	+ if (ifp->if_format != XFS_DINODE_FMT_EXTENTS)
1511	1472	return 0;
1512		- ifp = XFS_IFORK_PTR(ip, whichfork);
1513	1473	ASSERT(ifp->if_flags & XFS_IFEXTENTS);
1514	1474	xfs_iext_first(ifp, &icur);
1515	1475	xfs_iext_get_extent(ifp, &icur, &s);
..	..	@@ -1531,10 +1491,11 @@
1531	1491	struct xfs_bmalloca *bma,
1532	1492	int whichfork)
1533	1493	{
	1494	+ struct xfs_mount *mp = bma->ip->i_mount;
	1495	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
1534	1496	struct xfs_bmbt_irec *new = &bma->got;
1535	1497	int error; /* error return value */
1536	1498	int i; /* temp state */
1537		- struct xfs_ifork ifp; / inode fork pointer */
1538	1499	xfs_fileoff_t new_endoff; /* end offset of new entry */
1539	1500	xfs_bmbt_irec_t r[3]; /* neighbor extent entries */
1540	1501	/* left is 0, right is 1, prev is 2 */
..	..	@@ -1544,19 +1505,12 @@
1544	1505	xfs_filblks_t da_old; /* old count del alloc blocks used */
1545	1506	xfs_filblks_t temp=0; /* value for da_new calculations */
1546	1507	int tmp_rval; /* partial logging flags */
1547		- struct xfs_mount *mp;
1548		- xfs_extnum_t *nextents;
1549	1508	struct xfs_bmbt_irec old;
1550	1509
1551		- mp = bma->ip->i_mount;
1552		- ifp = XFS_IFORK_PTR(bma->ip, whichfork);
1553	1510	ASSERT(whichfork != XFS_ATTR_FORK);
1554		- nextents = (whichfork == XFS_COW_FORK ? &bma->ip->i_cnextents :
1555		- &bma->ip->i_d.di_nextents);
1556		-
1557	1511	ASSERT(!isnullstartblock(new->br_startblock));
1558	1512	ASSERT(!bma->cur \|\|
1559		- (bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL));
	1513	+ (bma->cur->bc_ino.flags & XFS_BTCUR_BMBT_WASDEL));
1560	1514
1561	1515	XFS_STATS_INC(mp, xs_add_exlist);
1562	1516
..	..	@@ -1644,7 +1598,7 @@
1644	1598	xfs_iext_remove(bma->ip, &bma->icur, state);
1645	1599	xfs_iext_prev(ifp, &bma->icur);
1646	1600	xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1647		- (*nextents)--;
	1601	+ ifp->if_nextents--;
1648	1602
1649	1603	if (bma->cur == NULL)
1650	1604	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
..	..	@@ -1653,15 +1607,24 @@
1653	1607	error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1654	1608	if (error)
1655	1609	goto done;
1656		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1610	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1611	+ error = -EFSCORRUPTED;
	1612	+ goto done;
	1613	+ }
1657	1614	error = xfs_btree_delete(bma->cur, &i);
1658	1615	if (error)
1659	1616	goto done;
1660		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1617	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1618	+ error = -EFSCORRUPTED;
	1619	+ goto done;
	1620	+ }
1661	1621	error = xfs_btree_decrement(bma->cur, 0, &i);
1662	1622	if (error)
1663	1623	goto done;
1664		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1624	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1625	+ error = -EFSCORRUPTED;
	1626	+ goto done;
	1627	+ }
1665	1628	error = xfs_bmbt_update(bma->cur, &LEFT);
1666	1629	if (error)
1667	1630	goto done;
..	..	@@ -1687,7 +1650,10 @@
1687	1650	error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1688	1651	if (error)
1689	1652	goto done;
1690		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1653	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1654	+ error = -EFSCORRUPTED;
	1655	+ goto done;
	1656	+ }
1691	1657	error = xfs_bmbt_update(bma->cur, &LEFT);
1692	1658	if (error)
1693	1659	goto done;
..	..	@@ -1717,7 +1683,10 @@
1717	1683	error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1718	1684	if (error)
1719	1685	goto done;
1720		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1686	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1687	+ error = -EFSCORRUPTED;
	1688	+ goto done;
	1689	+ }
1721	1690	error = xfs_bmbt_update(bma->cur, &PREV);
1722	1691	if (error)
1723	1692	goto done;
..	..	@@ -1733,8 +1702,8 @@
1733	1702	PREV.br_startblock = new->br_startblock;
1734	1703	PREV.br_state = new->br_state;
1735	1704	xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
	1705	+ ifp->if_nextents++;
1736	1706
1737		- (*nextents)++;
1738	1707	if (bma->cur == NULL)
1739	1708	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
1740	1709	else {
..	..	@@ -1742,11 +1711,17 @@
1742	1711	error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1743	1712	if (error)
1744	1713	goto done;
1745		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	1714	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	1715	+ error = -EFSCORRUPTED;
	1716	+ goto done;
	1717	+ }
1746	1718	error = xfs_btree_insert(bma->cur, &i);
1747	1719	if (error)
1748	1720	goto done;
1749		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1721	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1722	+ error = -EFSCORRUPTED;
	1723	+ goto done;
	1724	+ }
1750	1725	}
1751	1726	break;
1752	1727
..	..	@@ -1777,7 +1752,10 @@
1777	1752	error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1778	1753	if (error)
1779	1754	goto done;
1780		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1755	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1756	+ error = -EFSCORRUPTED;
	1757	+ goto done;
	1758	+ }
1781	1759	error = xfs_bmbt_update(bma->cur, &LEFT);
1782	1760	if (error)
1783	1761	goto done;
..	..	@@ -1790,7 +1768,8 @@
1790	1768	* The left neighbor is not contiguous.
1791	1769	*/
1792	1770	xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1793		- (*nextents)++;
	1771	+ ifp->if_nextents++;
	1772	+
1794	1773	if (bma->cur == NULL)
1795	1774	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
1796	1775	else {
..	..	@@ -1798,11 +1777,17 @@
1798	1777	error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1799	1778	if (error)
1800	1779	goto done;
1801		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	1780	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	1781	+ error = -EFSCORRUPTED;
	1782	+ goto done;
	1783	+ }
1802	1784	error = xfs_btree_insert(bma->cur, &i);
1803	1785	if (error)
1804	1786	goto done;
1805		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1787	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1788	+ error = -EFSCORRUPTED;
	1789	+ goto done;
	1790	+ }
1806	1791	}
1807	1792
1808	1793	if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
..	..	@@ -1816,7 +1801,7 @@
1816	1801	temp = PREV.br_blockcount - new->br_blockcount;
1817	1802	da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1818	1803	startblockval(PREV.br_startblock) -
1819		- (bma->cur ? bma->cur->bc_private.b.allocated : 0));
	1804	+ (bma->cur ? bma->cur->bc_ino.allocated : 0));
1820	1805
1821	1806	PREV.br_startoff = new_endoff;
1822	1807	PREV.br_blockcount = temp;
..	..	@@ -1843,7 +1828,10 @@
1843	1828	error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1844	1829	if (error)
1845	1830	goto done;
1846		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1831	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1832	+ error = -EFSCORRUPTED;
	1833	+ goto done;
	1834	+ }
1847	1835	error = xfs_bmbt_update(bma->cur, &RIGHT);
1848	1836	if (error)
1849	1837	goto done;
..	..	@@ -1867,7 +1855,8 @@
1867	1855	* The right neighbor is not contiguous.
1868	1856	*/
1869	1857	xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1870		- (*nextents)++;
	1858	+ ifp->if_nextents++;
	1859	+
1871	1860	if (bma->cur == NULL)
1872	1861	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
1873	1862	else {
..	..	@@ -1875,11 +1864,17 @@
1875	1864	error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1876	1865	if (error)
1877	1866	goto done;
1878		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	1867	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	1868	+ error = -EFSCORRUPTED;
	1869	+ goto done;
	1870	+ }
1879	1871	error = xfs_btree_insert(bma->cur, &i);
1880	1872	if (error)
1881	1873	goto done;
1882		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1874	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1875	+ error = -EFSCORRUPTED;
	1876	+ goto done;
	1877	+ }
1883	1878	}
1884	1879
1885	1880	if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
..	..	@@ -1893,7 +1888,7 @@
1893	1888	temp = PREV.br_blockcount - new->br_blockcount;
1894	1889	da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1895	1890	startblockval(PREV.br_startblock) -
1896		- (bma->cur ? bma->cur->bc_private.b.allocated : 0));
	1891	+ (bma->cur ? bma->cur->bc_ino.allocated : 0));
1897	1892
1898	1893	PREV.br_startblock = nullstartblock(da_new);
1899	1894	PREV.br_blockcount = temp;
..	..	@@ -1946,7 +1941,7 @@
1946	1941	xfs_iext_next(ifp, &bma->icur);
1947	1942	xfs_iext_insert(bma->ip, &bma->icur, &RIGHT, state);
1948	1943	xfs_iext_insert(bma->ip, &bma->icur, &LEFT, state);
1949		- (*nextents)++;
	1944	+ ifp->if_nextents++;
1950	1945
1951	1946	if (bma->cur == NULL)
1952	1947	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
..	..	@@ -1955,11 +1950,17 @@
1955	1950	error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1956	1951	if (error)
1957	1952	goto done;
1958		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	1953	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	1954	+ error = -EFSCORRUPTED;
	1955	+ goto done;
	1956	+ }
1959	1957	error = xfs_btree_insert(bma->cur, &i);
1960	1958	if (error)
1961	1959	goto done;
1962		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1960	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1961	+ error = -EFSCORRUPTED;
	1962	+ goto done;
	1963	+ }
1963	1964	}
1964	1965
1965	1966	if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
..	..	@@ -1988,11 +1989,8 @@
1988	1989	}
1989	1990
1990	1991	/* add reverse mapping unless caller opted out */
1991		- if (!(bma->flags & XFS_BMAPI_NORMAP)) {
1992		- error = xfs_rmap_map_extent(bma->tp, bma->ip, whichfork, new);
1993		- if (error)
1994		- goto done;
1995		- }
	1992	+ if (!(bma->flags & XFS_BMAPI_NORMAP))
	1993	+ xfs_rmap_map_extent(bma->tp, bma->ip, whichfork, new);
1996	1994
1997	1995	/* convert to a btree if necessary */
1998	1996	if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
..	..	@@ -2007,9 +2005,12 @@
2007	2005	goto done;
2008	2006	}
2009	2007
	2008	+ if (da_new != da_old)
	2009	+ xfs_mod_delalloc(mp, (int64_t)da_new - da_old);
	2010	+
2010	2011	if (bma->cur) {
2011		- da_new += bma->cur->bc_private.b.allocated;
2012		- bma->cur->bc_private.b.allocated = 0;
	2012	+ da_new += bma->cur->bc_ino.allocated;
	2013	+ bma->cur->bc_ino.allocated = 0;
2013	2014	}
2014	2015
2015	2016	/* adjust for changes in reserved delayed indirect blocks */
..	..	@@ -2032,7 +2033,7 @@
2032	2033	/*
2033	2034	* Convert an unwritten allocation to a real allocation or vice versa.
2034	2035	*/
2035		-STATIC int /* error */
	2036	+int /* error */
2036	2037	xfs_bmap_add_extent_unwritten_real(
2037	2038	struct xfs_trans *tp,
2038	2039	xfs_inode_t ip, / incore inode pointer */
..	..	@@ -2144,8 +2145,7 @@
2144	2145	xfs_iext_remove(ip, icur, state);
2145	2146	xfs_iext_prev(ifp, icur);
2146	2147	xfs_iext_update_extent(ip, state, icur, &LEFT);
2147		- XFS_IFORK_NEXT_SET(ip, whichfork,
2148		- XFS_IFORK_NEXTENTS(ip, whichfork) - 2);
	2148	+ ifp->if_nextents -= 2;
2149	2149	if (cur == NULL)
2150	2150	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
2151	2151	else {
..	..	@@ -2153,19 +2153,34 @@
2153	2153	error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
2154	2154	if (error)
2155	2155	goto done;
2156		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2156	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2157	+ error = -EFSCORRUPTED;
	2158	+ goto done;
	2159	+ }
2157	2160	if ((error = xfs_btree_delete(cur, &i)))
2158	2161	goto done;
2159		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2162	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2163	+ error = -EFSCORRUPTED;
	2164	+ goto done;
	2165	+ }
2160	2166	if ((error = xfs_btree_decrement(cur, 0, &i)))
2161	2167	goto done;
2162		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2168	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2169	+ error = -EFSCORRUPTED;
	2170	+ goto done;
	2171	+ }
2163	2172	if ((error = xfs_btree_delete(cur, &i)))
2164	2173	goto done;
2165		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2174	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2175	+ error = -EFSCORRUPTED;
	2176	+ goto done;
	2177	+ }
2166	2178	if ((error = xfs_btree_decrement(cur, 0, &i)))
2167	2179	goto done;
2168		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2180	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2181	+ error = -EFSCORRUPTED;
	2182	+ goto done;
	2183	+ }
2169	2184	error = xfs_bmbt_update(cur, &LEFT);
2170	2185	if (error)
2171	2186	goto done;
..	..	@@ -2182,8 +2197,7 @@
2182	2197	xfs_iext_remove(ip, icur, state);
2183	2198	xfs_iext_prev(ifp, icur);
2184	2199	xfs_iext_update_extent(ip, state, icur, &LEFT);
2185		- XFS_IFORK_NEXT_SET(ip, whichfork,
2186		- XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
	2200	+ ifp->if_nextents--;
2187	2201	if (cur == NULL)
2188	2202	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
2189	2203	else {
..	..	@@ -2191,13 +2205,22 @@
2191	2205	error = xfs_bmbt_lookup_eq(cur, &PREV, &i);
2192	2206	if (error)
2193	2207	goto done;
2194		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2208	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2209	+ error = -EFSCORRUPTED;
	2210	+ goto done;
	2211	+ }
2195	2212	if ((error = xfs_btree_delete(cur, &i)))
2196	2213	goto done;
2197		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2214	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2215	+ error = -EFSCORRUPTED;
	2216	+ goto done;
	2217	+ }
2198	2218	if ((error = xfs_btree_decrement(cur, 0, &i)))
2199	2219	goto done;
2200		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2220	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2221	+ error = -EFSCORRUPTED;
	2222	+ goto done;
	2223	+ }
2201	2224	error = xfs_bmbt_update(cur, &LEFT);
2202	2225	if (error)
2203	2226	goto done;
..	..	@@ -2216,9 +2239,8 @@
2216	2239	xfs_iext_remove(ip, icur, state);
2217	2240	xfs_iext_prev(ifp, icur);
2218	2241	xfs_iext_update_extent(ip, state, icur, &PREV);
	2242	+ ifp->if_nextents--;
2219	2243
2220		- XFS_IFORK_NEXT_SET(ip, whichfork,
2221		- XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
2222	2244	if (cur == NULL)
2223	2245	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
2224	2246	else {
..	..	@@ -2226,13 +2248,22 @@
2226	2248	error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
2227	2249	if (error)
2228	2250	goto done;
2229		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2251	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2252	+ error = -EFSCORRUPTED;
	2253	+ goto done;
	2254	+ }
2230	2255	if ((error = xfs_btree_delete(cur, &i)))
2231	2256	goto done;
2232		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2257	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2258	+ error = -EFSCORRUPTED;
	2259	+ goto done;
	2260	+ }
2233	2261	if ((error = xfs_btree_decrement(cur, 0, &i)))
2234	2262	goto done;
2235		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2263	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2264	+ error = -EFSCORRUPTED;
	2265	+ goto done;
	2266	+ }
2236	2267	error = xfs_bmbt_update(cur, &PREV);
2237	2268	if (error)
2238	2269	goto done;
..	..	@@ -2255,7 +2286,10 @@
2255	2286	error = xfs_bmbt_lookup_eq(cur, new, &i);
2256	2287	if (error)
2257	2288	goto done;
2258		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2289	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2290	+ error = -EFSCORRUPTED;
	2291	+ goto done;
	2292	+ }
2259	2293	error = xfs_bmbt_update(cur, &PREV);
2260	2294	if (error)
2261	2295	goto done;
..	..	@@ -2285,7 +2319,10 @@
2285	2319	error = xfs_bmbt_lookup_eq(cur, &old, &i);
2286	2320	if (error)
2287	2321	goto done;
2288		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2322	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2323	+ error = -EFSCORRUPTED;
	2324	+ goto done;
	2325	+ }
2289	2326	error = xfs_bmbt_update(cur, &PREV);
2290	2327	if (error)
2291	2328	goto done;
..	..	@@ -2310,8 +2347,8 @@
2310	2347
2311	2348	xfs_iext_update_extent(ip, state, icur, &PREV);
2312	2349	xfs_iext_insert(ip, icur, new, state);
2313		- XFS_IFORK_NEXT_SET(ip, whichfork,
2314		- XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
	2350	+ ifp->if_nextents++;
	2351	+
2315	2352	if (cur == NULL)
2316	2353	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
2317	2354	else {
..	..	@@ -2319,14 +2356,20 @@
2319	2356	error = xfs_bmbt_lookup_eq(cur, &old, &i);
2320	2357	if (error)
2321	2358	goto done;
2322		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2359	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2360	+ error = -EFSCORRUPTED;
	2361	+ goto done;
	2362	+ }
2323	2363	error = xfs_bmbt_update(cur, &PREV);
2324	2364	if (error)
2325	2365	goto done;
2326	2366	cur->bc_rec.b = *new;
2327	2367	if ((error = xfs_btree_insert(cur, &i)))
2328	2368	goto done;
2329		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2369	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2370	+ error = -EFSCORRUPTED;
	2371	+ goto done;
	2372	+ }
2330	2373	}
2331	2374	break;
2332	2375
..	..	@@ -2353,7 +2396,10 @@
2353	2396	error = xfs_bmbt_lookup_eq(cur, &old, &i);
2354	2397	if (error)
2355	2398	goto done;
2356		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2399	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2400	+ error = -EFSCORRUPTED;
	2401	+ goto done;
	2402	+ }
2357	2403	error = xfs_bmbt_update(cur, &PREV);
2358	2404	if (error)
2359	2405	goto done;
..	..	@@ -2377,9 +2423,8 @@
2377	2423	xfs_iext_update_extent(ip, state, icur, &PREV);
2378	2424	xfs_iext_next(ifp, icur);
2379	2425	xfs_iext_insert(ip, icur, new, state);
	2426	+ ifp->if_nextents++;
2380	2427
2381		- XFS_IFORK_NEXT_SET(ip, whichfork,
2382		- XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
2383	2428	if (cur == NULL)
2384	2429	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
2385	2430	else {
..	..	@@ -2387,17 +2432,26 @@
2387	2432	error = xfs_bmbt_lookup_eq(cur, &old, &i);
2388	2433	if (error)
2389	2434	goto done;
2390		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2435	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2436	+ error = -EFSCORRUPTED;
	2437	+ goto done;
	2438	+ }
2391	2439	error = xfs_bmbt_update(cur, &PREV);
2392	2440	if (error)
2393	2441	goto done;
2394	2442	error = xfs_bmbt_lookup_eq(cur, new, &i);
2395	2443	if (error)
2396	2444	goto done;
2397		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	2445	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	2446	+ error = -EFSCORRUPTED;
	2447	+ goto done;
	2448	+ }
2398	2449	if ((error = xfs_btree_insert(cur, &i)))
2399	2450	goto done;
2400		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2451	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2452	+ error = -EFSCORRUPTED;
	2453	+ goto done;
	2454	+ }
2401	2455	}
2402	2456	break;
2403	2457
..	..	@@ -2421,9 +2475,8 @@
2421	2475	xfs_iext_next(ifp, icur);
2422	2476	xfs_iext_insert(ip, icur, &r[1], state);
2423	2477	xfs_iext_insert(ip, icur, &r[0], state);
	2478	+ ifp->if_nextents += 2;
2424	2479
2425		- XFS_IFORK_NEXT_SET(ip, whichfork,
2426		- XFS_IFORK_NEXTENTS(ip, whichfork) + 2);
2427	2480	if (cur == NULL)
2428	2481	rval = XFS_ILOG_CORE \| XFS_ILOG_DEXT;
2429	2482	else {
..	..	@@ -2431,7 +2484,10 @@
2431	2484	error = xfs_bmbt_lookup_eq(cur, &old, &i);
2432	2485	if (error)
2433	2486	goto done;
2434		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2487	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2488	+ error = -EFSCORRUPTED;
	2489	+ goto done;
	2490	+ }
2435	2491	/* new right extent - oldext */
2436	2492	error = xfs_bmbt_update(cur, &r[1]);
2437	2493	if (error)
..	..	@@ -2440,7 +2496,10 @@
2440	2496	cur->bc_rec.b = PREV;
2441	2497	if ((error = xfs_btree_insert(cur, &i)))
2442	2498	goto done;
2443		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2499	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2500	+ error = -EFSCORRUPTED;
	2501	+ goto done;
	2502	+ }
2444	2503	/*
2445	2504	* Reset the cursor to the position of the new extent
2446	2505	* we are about to insert as we can't trust it after
..	..	@@ -2449,11 +2508,17 @@
2449	2508	error = xfs_bmbt_lookup_eq(cur, new, &i);
2450	2509	if (error)
2451	2510	goto done;
2452		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	2511	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	2512	+ error = -EFSCORRUPTED;
	2513	+ goto done;
	2514	+ }
2453	2515	/* new middle extent - newext */
2454	2516	if ((error = xfs_btree_insert(cur, &i)))
2455	2517	goto done;
2456		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2518	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2519	+ error = -EFSCORRUPTED;
	2520	+ goto done;
	2521	+ }
2457	2522	}
2458	2523	break;
2459	2524
..	..	@@ -2471,9 +2536,7 @@
2471	2536	}
2472	2537
2473	2538	/* update reverse mappings */
2474		- error = xfs_rmap_convert_extent(mp, tp, ip, whichfork, new);
2475		- if (error)
2476		- goto done;
	2539	+ xfs_rmap_convert_extent(mp, tp, ip, whichfork, new);
2477	2540
2478	2541	/* convert to a btree if necessary */
2479	2542	if (xfs_bmap_needs_btree(ip, whichfork)) {
..	..	@@ -2489,7 +2552,7 @@
2489	2552
2490	2553	/* clear out the allocated field, done with it now in any case. */
2491	2554	if (cur) {
2492		- cur->bc_private.b.allocated = 0;
	2555	+ cur->bc_ino.allocated = 0;
2493	2556	*curp = cur;
2494	2557	}
2495	2558
..	..	@@ -2638,6 +2701,7 @@
2638	2701	/*
2639	2702	* Nothing to do for disk quota accounting here.
2640	2703	*/
	2704	+ xfs_mod_delalloc(ip->i_mount, (int64_t)newlen - oldlen);
2641	2705	}
2642	2706	}
2643	2707
..	..	@@ -2667,7 +2731,7 @@
2667	2731	struct xfs_bmbt_irec old;
2668	2732
2669	2733	ASSERT(!isnullstartblock(new->br_startblock));
2670		- ASSERT(!cur \|\| !(cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL));
	2734	+ ASSERT(!cur \|\| !(cur->bc_ino.flags & XFS_BTCUR_BMBT_WASDEL));
2671	2735
2672	2736	XFS_STATS_INC(mp, xs_add_exlist);
2673	2737
..	..	@@ -2727,9 +2791,8 @@
2727	2791	xfs_iext_remove(ip, icur, state);
2728	2792	xfs_iext_prev(ifp, icur);
2729	2793	xfs_iext_update_extent(ip, state, icur, &left);
	2794	+ ifp->if_nextents--;
2730	2795
2731		- XFS_IFORK_NEXT_SET(ip, whichfork,
2732		- XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
2733	2796	if (cur == NULL) {
2734	2797	rval = XFS_ILOG_CORE \| xfs_ilog_fext(whichfork);
2735	2798	} else {
..	..	@@ -2737,15 +2800,24 @@
2737	2800	error = xfs_bmbt_lookup_eq(cur, &right, &i);
2738	2801	if (error)
2739	2802	goto done;
2740		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2803	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2804	+ error = -EFSCORRUPTED;
	2805	+ goto done;
	2806	+ }
2741	2807	error = xfs_btree_delete(cur, &i);
2742	2808	if (error)
2743	2809	goto done;
2744		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2810	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2811	+ error = -EFSCORRUPTED;
	2812	+ goto done;
	2813	+ }
2745	2814	error = xfs_btree_decrement(cur, 0, &i);
2746	2815	if (error)
2747	2816	goto done;
2748		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2817	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2818	+ error = -EFSCORRUPTED;
	2819	+ goto done;
	2820	+ }
2749	2821	error = xfs_bmbt_update(cur, &left);
2750	2822	if (error)
2751	2823	goto done;
..	..	@@ -2771,7 +2843,10 @@
2771	2843	error = xfs_bmbt_lookup_eq(cur, &old, &i);
2772	2844	if (error)
2773	2845	goto done;
2774		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2846	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2847	+ error = -EFSCORRUPTED;
	2848	+ goto done;
	2849	+ }
2775	2850	error = xfs_bmbt_update(cur, &left);
2776	2851	if (error)
2777	2852	goto done;
..	..	@@ -2798,7 +2873,10 @@
2798	2873	error = xfs_bmbt_lookup_eq(cur, &old, &i);
2799	2874	if (error)
2800	2875	goto done;
2801		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2876	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2877	+ error = -EFSCORRUPTED;
	2878	+ goto done;
	2879	+ }
2802	2880	error = xfs_bmbt_update(cur, &right);
2803	2881	if (error)
2804	2882	goto done;
..	..	@@ -2812,8 +2890,8 @@
2812	2890	* Insert a new entry.
2813	2891	*/
2814	2892	xfs_iext_insert(ip, icur, new, state);
2815		- XFS_IFORK_NEXT_SET(ip, whichfork,
2816		- XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
	2893	+ ifp->if_nextents++;
	2894	+
2817	2895	if (cur == NULL) {
2818	2896	rval = XFS_ILOG_CORE \| xfs_ilog_fext(whichfork);
2819	2897	} else {
..	..	@@ -2821,21 +2899,24 @@
2821	2899	error = xfs_bmbt_lookup_eq(cur, new, &i);
2822	2900	if (error)
2823	2901	goto done;
2824		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	2902	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	2903	+ error = -EFSCORRUPTED;
	2904	+ goto done;
	2905	+ }
2825	2906	error = xfs_btree_insert(cur, &i);
2826	2907	if (error)
2827	2908	goto done;
2828		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	2909	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2910	+ error = -EFSCORRUPTED;
	2911	+ goto done;
	2912	+ }
2829	2913	}
2830	2914	break;
2831	2915	}
2832	2916
2833	2917	/* add reverse mapping unless caller opted out */
2834		- if (!(flags & XFS_BMAPI_NORMAP)) {
2835		- error = xfs_rmap_map_extent(tp, ip, whichfork, new);
2836		- if (error)
2837		- goto done;
2838		- }
	2918	+ if (!(flags & XFS_BMAPI_NORMAP))
	2919	+ xfs_rmap_map_extent(tp, ip, whichfork, new);
2839	2920
2840	2921	/* convert to a btree if necessary */
2841	2922	if (xfs_bmap_needs_btree(ip, whichfork)) {
..	..	@@ -2852,7 +2933,7 @@
2852	2933
2853	2934	/* clear out the allocated field, done with it now in any case. */
2854	2935	if (cur)
2855		- cur->bc_private.b.allocated = 0;
	2936	+ cur->bc_ino.allocated = 0;
2856	2937
2857	2938	xfs_bmap_check_leaf_extents(cur, ip, whichfork);
2858	2939	done:
..	..	@@ -3063,7 +3144,7 @@
3063	3144	mp = ap->ip->i_mount;
3064	3145	nullfb = ap->tp->t_firstblock == NULLFSBLOCK;
3065	3146	rt = XFS_IS_REALTIME_INODE(ap->ip) &&
3066		- xfs_alloc_is_userdata(ap->datatype);
	3147	+ (ap->datatype & XFS_ALLOC_USERDATA);
3067	3148	fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,
3068	3149	ap->tp->t_firstblock);
3069	3150	/*
..	..	@@ -3208,11 +3289,12 @@
3208	3289	pag = xfs_perag_get(mp, ag);
3209	3290	if (!pag->pagf_init) {
3210	3291	error = xfs_alloc_pagf_init(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK);
3211		- if (error)
3212		- goto out;
3213		-
3214		- if (!pag->pagf_init) {
3215		- *notinit = 1;
	3292	+ if (error) {
	3293	+ /* Couldn't lock the AGF, so skip this AG. */
	3294	+ if (error == -EAGAIN) {
	3295	+ *notinit = 1;
	3296	+ error = 0;
	3297	+ }
3216	3298	goto out;
3217	3299	}
3218	3300	}
..	..	@@ -3350,8 +3432,10 @@
3350	3432	* already have quota reservation and there's nothing to do
3351	3433	* yet.
3352	3434	*/
3353		- if (ap->wasdel)
	3435	+ if (ap->wasdel) {
	3436	+ xfs_mod_delalloc(ap->ip->i_mount, -(int64_t)args->len);
3354	3437	return;
	3438	+ }
3355	3439
3356	3440	/*
3357	3441	* Otherwise, we've allocated blocks in a hole. The transaction
..	..	@@ -3370,8 +3454,10 @@
3370	3454	/* data/attr fork only */
3371	3455	ap->ip->i_d.di_nblocks += args->len;
3372	3456	xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
3373		- if (ap->wasdel)
	3457	+ if (ap->wasdel) {
3374	3458	ap->ip->i_delayed_blks -= args->len;
	3459	+ xfs_mod_delalloc(ap->ip->i_mount, -(int64_t)args->len);
	3460	+ }
3375	3461	xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
3376	3462	ap->wasdel ? XFS_TRANS_DQ_DELBCOUNT : XFS_TRANS_DQ_BCOUNT,
3377	3463	args->len);
..	..	@@ -3412,7 +3498,7 @@
3412	3498
3413	3499	if (ap->flags & XFS_BMAPI_COWFORK)
3414	3500	align = xfs_get_cowextsz_hint(ap->ip);
3415		- else if (xfs_alloc_is_userdata(ap->datatype))
	3501	+ else if (ap->datatype & XFS_ALLOC_USERDATA)
3416	3502	align = xfs_get_extsz_hint(ap->ip);
3417	3503	if (align) {
3418	3504	error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
..	..	@@ -3427,7 +3513,7 @@
3427	3513	fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,
3428	3514	ap->tp->t_firstblock);
3429	3515	if (nullfb) {
3430		- if (xfs_alloc_is_userdata(ap->datatype) &&
	3516	+ if ((ap->datatype & XFS_ALLOC_USERDATA) &&
3431	3517	xfs_inode_is_filestream(ap->ip)) {
3432	3518	ag = xfs_filestream_lookup_ag(ap->ip);
3433	3519	ag = (ag != NULLAGNUMBER) ? ag : 0;
..	..	@@ -3456,7 +3542,7 @@
3456	3542	args.tp = ap->tp;
3457	3543	args.mp = mp;
3458	3544	args.fsbno = ap->blkno;
3459		- xfs_rmap_skip_owner_update(&args.oinfo);
	3545	+ args.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
3460	3546
3461	3547	/* Trim the allocation back to the maximum an AG can fit. */
3462	3548	args.maxlen = min(ap->length, mp->m_ag_max_usable);
..	..	@@ -3467,7 +3553,7 @@
3467	3553	* enough for the request. If one isn't found, then adjust
3468	3554	* the minimum allocation size to the largest space found.
3469	3555	*/
3470		- if (xfs_alloc_is_userdata(ap->datatype) &&
	3556	+ if ((ap->datatype & XFS_ALLOC_USERDATA) &&
3471	3557	xfs_inode_is_filestream(ap->ip))
3472	3558	error = xfs_bmap_btalloc_filestreams(ap, &args, &blen);
3473	3559	else
..	..	@@ -3501,13 +3587,11 @@
3501	3587	args.mod = args.prod - args.mod;
3502	3588	}
3503	3589	/*
3504		- * If we are not low on available data blocks, and the
3505		- * underlying logical volume manager is a stripe, and
3506		- * the file offset is zero then try to allocate data
3507		- * blocks on stripe unit boundary.
3508		- * NOTE: ap->aeof is only set if the allocation length
3509		- * is >= the stripe unit and the allocation offset is
3510		- * at the end of file.
	3590	+ * If we are not low on available data blocks, and the underlying
	3591	+ * logical volume manager is a stripe, and the file offset is zero then
	3592	+ * try to allocate data blocks on stripe unit boundary. NOTE: ap->aeof
	3593	+ * is only set if the allocation length is >= the stripe unit and the
	3594	+ * allocation offset is at the end of file.
3511	3595	*/
3512	3596	if (!(ap->tp->t_flags & XFS_TRANS_LOWMODE) && ap->aeof) {
3513	3597	if (!ap->offset) {
..	..	@@ -3515,9 +3599,11 @@
3515	3599	atype = args.type;
3516	3600	isaligned = 1;
3517	3601	/*
3518		- * Adjust for alignment
	3602	+ * Adjust minlen to try and preserve alignment if we
	3603	+ * can't guarantee an aligned maxlen extent.
3519	3604	*/
3520		- if (blen > args.alignment && blen <= args.maxlen)
	3605	+ if (blen > args.alignment &&
	3606	+ blen <= args.maxlen + args.alignment)
3521	3607	args.minlen = blen - args.alignment;
3522	3608	args.minalignslop = 0;
3523	3609	} else {
..	..	@@ -3555,8 +3641,6 @@
3555	3641	args.wasdel = ap->wasdel;
3556	3642	args.resv = XFS_AG_RESV_NONE;
3557	3643	args.datatype = ap->datatype;
3558		- if (ap->datatype & XFS_ALLOC_USERDATA_ZERO)
3559		- args.ip = ap->ip;
3560	3644
3561	3645	error = xfs_alloc_vextent(&args);
3562	3646	if (error)
..	..	@@ -3641,20 +3725,6 @@
3641	3725	return 0;
3642	3726	}
3643	3727
3644		-/*
3645		- * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file.
3646		- * It figures out where to ask the underlying allocator to put the new extent.
3647		- */
3648		-STATIC int
3649		-xfs_bmap_alloc(
3650		- struct xfs_bmalloca ap) / bmap alloc argument struct */
3651		-{
3652		- if (XFS_IS_REALTIME_INODE(ap->ip) &&
3653		- xfs_alloc_is_userdata(ap->datatype))
3654		- return xfs_bmap_rtalloc(ap);
3655		- return xfs_bmap_btalloc(ap);
3656		-}
3657		-
3658	3728	/* Trim extent to fit a logical block range. */
3659	3729	void
3660	3730	xfs_trim_extent(
..	..	@@ -3686,17 +3756,6 @@
3686	3756	distance = irec->br_startoff + irec->br_blockcount - end;
3687	3757	irec->br_blockcount -= distance;
3688	3758	}
3689		-}
3690		-
3691		-/* trim extent to within eof */
3692		-void
3693		-xfs_trim_extent_eof(
3694		- struct xfs_bmbt_irec *irec,
3695		- struct xfs_inode *ip)
3696		-
3697		-{
3698		- xfs_trim_extent(irec, 0, XFS_B_TO_FSB(ip->i_mount,
3699		- i_size_read(VFS_I(ip))));
3700	3759	}
3701	3760
3702	3761	/*
..	..	@@ -3812,7 +3871,8 @@
3812	3871	int flags)
3813	3872	{
3814	3873	struct xfs_mount *mp = ip->i_mount;
3815		- struct xfs_ifork *ifp;
	3874	+ int whichfork = xfs_bmapi_whichfork(flags);
	3875	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
3816	3876	struct xfs_bmbt_irec got;
3817	3877	xfs_fileoff_t obno;
3818	3878	xfs_fileoff_t end;
..	..	@@ -3820,50 +3880,22 @@
3820	3880	int error;
3821	3881	bool eof = false;
3822	3882	int n = 0;
3823		- int whichfork = xfs_bmapi_whichfork(flags);
3824	3883
3825	3884	ASSERT(*nmap >= 1);
3826		- ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK\|XFS_BMAPI_ENTIRE\|
3827		- XFS_BMAPI_COWFORK)));
	3885	+ ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK \| XFS_BMAPI_ENTIRE)));
3828	3886	ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED\|XFS_ILOCK_EXCL));
3829	3887
3830		- if (unlikely(XFS_TEST_ERROR(
3831		- (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
3832		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
3833		- mp, XFS_ERRTAG_BMAPIFORMAT))) {
3834		- XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp);
	3888	+ if (WARN_ON_ONCE(!ifp))
3835	3889	return -EFSCORRUPTED;
3836		- }
	3890	+
	3891	+ if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) \|\|
	3892	+ XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT))
	3893	+ return -EFSCORRUPTED;
3837	3894
3838	3895	if (XFS_FORCED_SHUTDOWN(mp))
3839	3896	return -EIO;
3840	3897
3841	3898	XFS_STATS_INC(mp, xs_blk_mapr);
3842		-
3843		- ifp = XFS_IFORK_PTR(ip, whichfork);
3844		- if (!ifp) {
3845		- /* No CoW fork? Return a hole. */
3846		- if (whichfork == XFS_COW_FORK) {
3847		- mval->br_startoff = bno;
3848		- mval->br_startblock = HOLESTARTBLOCK;
3849		- mval->br_blockcount = len;
3850		- mval->br_state = XFS_EXT_NORM;
3851		- *nmap = 1;
3852		- return 0;
3853		- }
3854		-
3855		- /*
3856		- * A missing attr ifork implies that the inode says we're in
3857		- * extents or btree format but failed to pass the inode fork
3858		- * verifier while trying to load it. Treat that as a file
3859		- * corruption too.
3860		- */
3861		-#ifdef DEBUG
3862		- xfs_alert(mp, "%s: inode %llu missing fork %d",
3863		- __func__, ip->i_ino, whichfork);
3864		-#endif /* DEBUG */
3865		- return -EFSCORRUPTED;
3866		- }
3867	3899
3868	3900	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
3869	3901	error = xfs_iread_extents(NULL, ip, whichfork);
..	..	@@ -3991,6 +4023,7 @@
3991	4023
3992	4024
3993	4025	ip->i_delayed_blks += alen;
	4026	+ xfs_mod_delalloc(ip->i_mount, alen + indlen);
3994	4027
3995	4028	got->br_startoff = aoff;
3996	4029	got->br_startblock = nullstartblock(indlen);
..	..	@@ -4021,6 +4054,39 @@
4021	4054	}
4022	4055
4023	4056	static int
	4057	+xfs_bmap_alloc_userdata(
	4058	+ struct xfs_bmalloca *bma)
	4059	+{
	4060	+ struct xfs_mount *mp = bma->ip->i_mount;
	4061	+ int whichfork = xfs_bmapi_whichfork(bma->flags);
	4062	+ int error;
	4063	+
	4064	+ /*
	4065	+ * Set the data type being allocated. For the data fork, the first data
	4066	+ * in the file is treated differently to all other allocations. For the
	4067	+ * attribute fork, we only need to ensure the allocated range is not on
	4068	+ * the busy list.
	4069	+ */
	4070	+ bma->datatype = XFS_ALLOC_NOBUSY;
	4071	+ if (whichfork == XFS_DATA_FORK) {
	4072	+ bma->datatype \|= XFS_ALLOC_USERDATA;
	4073	+ if (bma->offset == 0)
	4074	+ bma->datatype \|= XFS_ALLOC_INITIAL_USER_DATA;
	4075	+
	4076	+ if (mp->m_dalign && bma->length >= mp->m_dalign) {
	4077	+ error = xfs_bmap_isaeof(bma, whichfork);
	4078	+ if (error)
	4079	+ return error;
	4080	+ }
	4081	+
	4082	+ if (XFS_IS_REALTIME_INODE(bma->ip))
	4083	+ return xfs_bmap_rtalloc(bma);
	4084	+ }
	4085	+
	4086	+ return xfs_bmap_btalloc(bma);
	4087	+}
	4088	+
	4089	+static int
4024	4090	xfs_bmapi_allocate(
4025	4091	struct xfs_bmalloca *bma)
4026	4092	{
..	..	@@ -4039,7 +4105,8 @@
4039	4105	if (bma->wasdel) {
4040	4106	bma->length = (xfs_extlen_t)bma->got.br_blockcount;
4041	4107	bma->offset = bma->got.br_startoff;
4042		- xfs_iext_peek_prev_extent(ifp, &bma->icur, &bma->prev);
	4108	+ if (!xfs_iext_peek_prev_extent(ifp, &bma->icur, &bma->prev))
	4109	+ bma->prev.br_startoff = NULLFILEOFF;
4043	4110	} else {
4044	4111	bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN);
4045	4112	if (!bma->eof)
..	..	@@ -4047,43 +4114,24 @@
4047	4114	bma->got.br_startoff - bma->offset);
4048	4115	}
4049	4116
4050		- /*
4051		- * Set the data type being allocated. For the data fork, the first data
4052		- * in the file is treated differently to all other allocations. For the
4053		- * attribute fork, we only need to ensure the allocated range is not on
4054		- * the busy list.
4055		- */
4056		- if (!(bma->flags & XFS_BMAPI_METADATA)) {
4057		- bma->datatype = XFS_ALLOC_NOBUSY;
4058		- if (whichfork == XFS_DATA_FORK) {
4059		- if (bma->offset == 0)
4060		- bma->datatype \|= XFS_ALLOC_INITIAL_USER_DATA;
4061		- else
4062		- bma->datatype \|= XFS_ALLOC_USERDATA;
4063		- }
4064		- if (bma->flags & XFS_BMAPI_ZERO)
4065		- bma->datatype \|= XFS_ALLOC_USERDATA_ZERO;
4066		- }
	4117	+ if (bma->flags & XFS_BMAPI_CONTIG)
	4118	+ bma->minlen = bma->length;
	4119	+ else
	4120	+ bma->minlen = 1;
4067	4121
4068		- bma->minlen = (bma->flags & XFS_BMAPI_CONTIG) ? bma->length : 1;
	4122	+ if (bma->flags & XFS_BMAPI_METADATA)
	4123	+ error = xfs_bmap_btalloc(bma);
	4124	+ else
	4125	+ error = xfs_bmap_alloc_userdata(bma);
	4126	+ if (error \|\| bma->blkno == NULLFSBLOCK)
	4127	+ return error;
4069	4128
4070		- /*
4071		- * Only want to do the alignment at the eof if it is userdata and
4072		- * allocation length is larger than a stripe unit.
4073		- */
4074		- if (mp->m_dalign && bma->length >= mp->m_dalign &&
4075		- !(bma->flags & XFS_BMAPI_METADATA) && whichfork == XFS_DATA_FORK) {
4076		- error = xfs_bmap_isaeof(bma, whichfork);
	4129	+ if (bma->flags & XFS_BMAPI_ZERO) {
	4130	+ error = xfs_zero_extent(bma->ip, bma->blkno, bma->length);
4077	4131	if (error)
4078	4132	return error;
4079	4133	}
4080	4134
4081		- error = xfs_bmap_alloc(bma);
4082		- if (error)
4083		- return error;
4084		-
4085		- if (bma->blkno == NULLFSBLOCK)
4086		- return 0;
4087	4135	if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur)
4088	4136	bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork);
4089	4137	/*
..	..	@@ -4093,26 +4141,15 @@
4093	4141	bma->nallocs++;
4094	4142
4095	4143	if (bma->cur)
4096		- bma->cur->bc_private.b.flags =
4097		- bma->wasdel ? XFS_BTCUR_BPRV_WASDEL : 0;
	4144	+ bma->cur->bc_ino.flags =
	4145	+ bma->wasdel ? XFS_BTCUR_BMBT_WASDEL : 0;
4098	4146
4099	4147	bma->got.br_startoff = bma->offset;
4100	4148	bma->got.br_startblock = bma->blkno;
4101	4149	bma->got.br_blockcount = bma->length;
4102	4150	bma->got.br_state = XFS_EXT_NORM;
4103	4151
4104		- /*
4105		- * In the data fork, a wasdelay extent has been initialized, so
4106		- * shouldn't be flagged as unwritten.
4107		- *
4108		- * For the cow fork, however, we convert delalloc reservations
4109		- * (extents allocated for speculative preallocation) to
4110		- * allocated unwritten extents, and only convert the unwritten
4111		- * extents to real extents when we're about to write the data.
4112		- */
4113		- if ((!bma->wasdel \|\| (bma->flags & XFS_BMAPI_COWFORK)) &&
4114		- (bma->flags & XFS_BMAPI_PREALLOC) &&
4115		- xfs_sb_version_hasextflgbit(&mp->m_sb))
	4152	+ if (bma->flags & XFS_BMAPI_PREALLOC)
4116	4153	bma->got.br_state = XFS_EXT_UNWRITTEN;
4117	4154
4118	4155	if (bma->wasdel)
..	..	@@ -4220,6 +4257,48 @@
4220	4257	return 0;
4221	4258	}
4222	4259
	4260	+static inline xfs_extlen_t
	4261	+xfs_bmapi_minleft(
	4262	+ struct xfs_trans *tp,
	4263	+ struct xfs_inode *ip,
	4264	+ int fork)
	4265	+{
	4266	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, fork);
	4267	+
	4268	+ if (tp && tp->t_firstblock != NULLFSBLOCK)
	4269	+ return 0;
	4270	+ if (ifp->if_format != XFS_DINODE_FMT_BTREE)
	4271	+ return 1;
	4272	+ return be16_to_cpu(ifp->if_broot->bb_level) + 1;
	4273	+}
	4274	+
	4275	+/*
	4276	+ * Log whatever the flags say, even if error. Otherwise we might miss detecting
	4277	+ * a case where the data is changed, there's an error, and it's not logged so we
	4278	+ * don't shutdown when we should. Don't bother logging extents/btree changes if
	4279	+ * we converted to the other format.
	4280	+ */
	4281	+static void
	4282	+xfs_bmapi_finish(
	4283	+ struct xfs_bmalloca *bma,
	4284	+ int whichfork,
	4285	+ int error)
	4286	+{
	4287	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
	4288	+
	4289	+ if ((bma->logflags & xfs_ilog_fext(whichfork)) &&
	4290	+ ifp->if_format != XFS_DINODE_FMT_EXTENTS)
	4291	+ bma->logflags &= ~xfs_ilog_fext(whichfork);
	4292	+ else if ((bma->logflags & xfs_ilog_fbroot(whichfork)) &&
	4293	+ ifp->if_format != XFS_DINODE_FMT_BTREE)
	4294	+ bma->logflags &= ~xfs_ilog_fbroot(whichfork);
	4295	+
	4296	+ if (bma->logflags)
	4297	+ xfs_trans_log_inode(bma->tp, bma->ip, bma->logflags);
	4298	+ if (bma->cur)
	4299	+ xfs_btree_del_cursor(bma->cur, error);
	4300	+}
	4301	+
4223	4302	/*
4224	4303	* Map file blocks to filesystem blocks, and allocate blocks or convert the
4225	4304	* extent state if necessary. Details behaviour is controlled by the flags
..	..	@@ -4237,15 +4316,19 @@
4237	4316	struct xfs_bmbt_irec mval, / output: map values */
4238	4317	int nmap) / i/o: mval size/count */
4239	4318	{
	4319	+ struct xfs_bmalloca bma = {
	4320	+ .tp = tp,
	4321	+ .ip = ip,
	4322	+ .total = total,
	4323	+ };
4240	4324	struct xfs_mount *mp = ip->i_mount;
4241		- struct xfs_ifork *ifp;
4242		- struct xfs_bmalloca bma = { NULL }; /* args for xfs_bmap_alloc */
	4325	+ int whichfork = xfs_bmapi_whichfork(flags);
	4326	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
4243	4327	xfs_fileoff_t end; /* end of mapped file region */
4244	4328	bool eof = false; /* after the end of extents */
4245	4329	int error; /* error return */
4246	4330	int n; /* current extent index */
4247	4331	xfs_fileoff_t obno; /* old block number (offset) */
4248		- int whichfork; /* data or attr fork */
4249	4332
4250	4333	#ifdef DEBUG
4251	4334	xfs_fileoff_t orig_bno; /* original block number value */
..	..	@@ -4260,15 +4343,12 @@
4260	4343	orig_mval = mval;
4261	4344	orig_nmap = *nmap;
4262	4345	#endif
4263		- whichfork = xfs_bmapi_whichfork(flags);
4264	4346
4265	4347	ASSERT(*nmap >= 1);
4266	4348	ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
4267		- ASSERT(tp != NULL \|\|
4268		- (flags & (XFS_BMAPI_CONVERT \| XFS_BMAPI_COWFORK)) ==
4269		- (XFS_BMAPI_CONVERT \| XFS_BMAPI_COWFORK));
	4349	+ ASSERT(tp != NULL);
4270	4350	ASSERT(len > 0);
4271		- ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL);
	4351	+ ASSERT(ifp->if_format != XFS_DINODE_FMT_LOCAL);
4272	4352	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
4273	4353	ASSERT(!(flags & XFS_BMAPI_REMAP));
4274	4354
..	..	@@ -4284,29 +4364,15 @@
4284	4364	ASSERT((flags & (XFS_BMAPI_PREALLOC \| XFS_BMAPI_ZERO)) !=
4285	4365	(XFS_BMAPI_PREALLOC \| XFS_BMAPI_ZERO));
4286	4366
4287		- if (unlikely(XFS_TEST_ERROR(
4288		- (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
4289		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
4290		- mp, XFS_ERRTAG_BMAPIFORMAT))) {
4291		- XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp);
	4367	+ if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) \|\|
	4368	+ XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
4292	4369	return -EFSCORRUPTED;
4293	4370	}
4294	4371
4295	4372	if (XFS_FORCED_SHUTDOWN(mp))
4296	4373	return -EIO;
4297	4374
4298		- ifp = XFS_IFORK_PTR(ip, whichfork);
4299		-
4300	4375	XFS_STATS_INC(mp, xs_blk_mapw);
4301		-
4302		- if (!tp \|\| tp->t_firstblock == NULLFSBLOCK) {
4303		- if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE)
4304		- bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1;
4305		- else
4306		- bma.minleft = 1;
4307		- } else {
4308		- bma.minleft = 0;
4309		- }
4310	4376
4311	4377	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
4312	4378	error = xfs_iread_extents(tp, ip, whichfork);
..	..	@@ -4314,19 +4380,15 @@
4314	4380	goto error0;
4315	4381	}
4316	4382
4317		- n = 0;
4318		- end = bno + len;
4319		- obno = bno;
4320		-
4321	4383	if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.icur, &bma.got))
4322	4384	eof = true;
4323	4385	if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
4324	4386	bma.prev.br_startoff = NULLFILEOFF;
4325		- bma.tp = tp;
4326		- bma.ip = ip;
4327		- bma.total = total;
4328		- bma.datatype = 0;
	4387	+ bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
4329	4388
	4389	+ n = 0;
	4390	+ end = bno + len;
	4391	+ obno = bno;
4330	4392	while (bno < end && n < *nmap) {
4331	4393	bool need_alloc = false, wasdelay = false;
4332	4394
..	..	@@ -4340,26 +4402,7 @@
4340	4402	ASSERT(!((flags & XFS_BMAPI_CONVERT) &&
4341	4403	(flags & XFS_BMAPI_COWFORK)));
4342	4404
4343		- if (flags & XFS_BMAPI_DELALLOC) {
4344		- /*
4345		- * For the COW fork we can reasonably get a
4346		- * request for converting an extent that races
4347		- * with other threads already having converted
4348		- * part of it, as there converting COW to
4349		- * regular blocks is not protected using the
4350		- * IOLOCK.
4351		- */
4352		- ASSERT(flags & XFS_BMAPI_COWFORK);
4353		- if (!(flags & XFS_BMAPI_COWFORK)) {
4354		- error = -EIO;
4355		- goto error0;
4356		- }
4357		-
4358		- if (eof \|\| bno >= end)
4359		- break;
4360		- } else {
4361		- need_alloc = true;
4362		- }
	4405	+ need_alloc = true;
4363	4406	} else if (isnullstartblock(bma.got.br_startblock)) {
4364	4407	wasdelay = true;
4365	4408	}
..	..	@@ -4368,8 +4411,7 @@
4368	4411	* First, deal with the hole before the allocated space
4369	4412	* that we found, if any.
4370	4413	*/
4371		- if ((need_alloc \|\| wasdelay) &&
4372		- !(flags & XFS_BMAPI_CONVERT_ONLY)) {
	4414	+ if (need_alloc \|\| wasdelay) {
4373	4415	bma.eof = eof;
4374	4416	bma.conv = !!(flags & XFS_BMAPI_CONVERT);
4375	4417	bma.wasdel = wasdelay;
..	..	@@ -4400,12 +4442,9 @@
4400	4442	* If this is a CoW allocation, record the data in
4401	4443	* the refcount btree for orphan recovery.
4402	4444	*/
4403		- if (whichfork == XFS_COW_FORK) {
4404		- error = xfs_refcount_alloc_cow_extent(tp,
4405		- bma.blkno, bma.length);
4406		- if (error)
4407		- goto error0;
4408		- }
	4445	+ if (whichfork == XFS_COW_FORK)
	4446	+ xfs_refcount_alloc_cow_extent(tp, bma.blkno,
	4447	+ bma.length);
4409	4448	}
4410	4449
4411	4450	/* Deal with the allocated space we found. */
..	..	@@ -4437,49 +4476,144 @@
4437	4476	}
4438	4477	*nmap = n;
4439	4478
4440		- /*
4441		- * Transform from btree to extents, give it cur.
4442		- */
4443		- if (xfs_bmap_wants_extents(ip, whichfork)) {
4444		- int tmp_logflags = 0;
	4479	+ error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
	4480	+ whichfork);
	4481	+ if (error)
	4482	+ goto error0;
4445	4483
4446		- ASSERT(bma.cur);
4447		- error = xfs_bmap_btree_to_extents(tp, ip, bma.cur,
4448		- &tmp_logflags, whichfork);
4449		- bma.logflags \|= tmp_logflags;
4450		- if (error)
4451		- goto error0;
4452		- }
4453		-
4454		- ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE \|\|
4455		- XFS_IFORK_NEXTENTS(ip, whichfork) >
4456		- XFS_IFORK_MAXEXT(ip, whichfork));
4457		- error = 0;
	4484	+ ASSERT(ifp->if_format != XFS_DINODE_FMT_BTREE \|\|
	4485	+ ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork));
	4486	+ xfs_bmapi_finish(&bma, whichfork, 0);
	4487	+ xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval,
	4488	+ orig_nmap, *nmap);
	4489	+ return 0;
4458	4490	error0:
4459		- /*
4460		- * Log everything. Do this after conversion, there's no point in
4461		- * logging the extent records if we've converted to btree format.
4462		- */
4463		- if ((bma.logflags & xfs_ilog_fext(whichfork)) &&
4464		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
4465		- bma.logflags &= ~xfs_ilog_fext(whichfork);
4466		- else if ((bma.logflags & xfs_ilog_fbroot(whichfork)) &&
4467		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)
4468		- bma.logflags &= ~xfs_ilog_fbroot(whichfork);
4469		- /*
4470		- * Log whatever the flags say, even if error. Otherwise we might miss
4471		- * detecting a case where the data is changed, there's an error,
4472		- * and it's not logged so we don't shutdown when we should.
4473		- */
4474		- if (bma.logflags)
4475		- xfs_trans_log_inode(tp, ip, bma.logflags);
	4491	+ xfs_bmapi_finish(&bma, whichfork, error);
	4492	+ return error;
	4493	+}
4476	4494
4477		- if (bma.cur) {
4478		- xfs_btree_del_cursor(bma.cur, error);
	4495	+/*
	4496	+ * Convert an existing delalloc extent to real blocks based on file offset. This
	4497	+ * attempts to allocate the entire delalloc extent and may require multiple
	4498	+ * invocations to allocate the target offset if a large enough physical extent
	4499	+ * is not available.
	4500	+ */
	4501	+int
	4502	+xfs_bmapi_convert_delalloc(
	4503	+ struct xfs_inode *ip,
	4504	+ int whichfork,
	4505	+ xfs_off_t offset,
	4506	+ struct iomap *iomap,
	4507	+ unsigned int *seq)
	4508	+{
	4509	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
	4510	+ struct xfs_mount *mp = ip->i_mount;
	4511	+ xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
	4512	+ struct xfs_bmalloca bma = { NULL };
	4513	+ uint16_t flags = 0;
	4514	+ struct xfs_trans *tp;
	4515	+ int error;
	4516	+
	4517	+ if (whichfork == XFS_COW_FORK)
	4518	+ flags \|= IOMAP_F_SHARED;
	4519	+
	4520	+ /*
	4521	+ * Space for the extent and indirect blocks was reserved when the
	4522	+ * delalloc extent was created so there's no need to do so here.
	4523	+ */
	4524	+ error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0,
	4525	+ XFS_TRANS_RESERVE, &tp);
	4526	+ if (error)
	4527	+ return error;
	4528	+
	4529	+ xfs_ilock(ip, XFS_ILOCK_EXCL);
	4530	+ xfs_trans_ijoin(tp, ip, 0);
	4531	+
	4532	+ if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &bma.icur, &bma.got) \|\|
	4533	+ bma.got.br_startoff > offset_fsb) {
	4534	+ /*
	4535	+ * No extent found in the range we are trying to convert. This
	4536	+ * should only happen for the COW fork, where another thread
	4537	+ * might have moved the extent to the data fork in the meantime.
	4538	+ */
	4539	+ WARN_ON_ONCE(whichfork != XFS_COW_FORK);
	4540	+ error = -EAGAIN;
	4541	+ goto out_trans_cancel;
4479	4542	}
4480		- if (!error)
4481		- xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval,
4482		- orig_nmap, *nmap);
	4543	+
	4544	+ /*
	4545	+ * If we find a real extent here we raced with another thread converting
	4546	+ * the extent. Just return the real extent at this offset.
	4547	+ */
	4548	+ if (!isnullstartblock(bma.got.br_startblock)) {
	4549	+ xfs_bmbt_to_iomap(ip, iomap, &bma.got, flags);
	4550	+ *seq = READ_ONCE(ifp->if_seq);
	4551	+ goto out_trans_cancel;
	4552	+ }
	4553	+
	4554	+ bma.tp = tp;
	4555	+ bma.ip = ip;
	4556	+ bma.wasdel = true;
	4557	+ bma.offset = bma.got.br_startoff;
	4558	+ bma.length = max_t(xfs_filblks_t, bma.got.br_blockcount, MAXEXTLEN);
	4559	+ bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
	4560	+
	4561	+ /*
	4562	+ * When we're converting the delalloc reservations backing dirty pages
	4563	+ * in the page cache, we must be careful about how we create the new
	4564	+ * extents:
	4565	+ *
	4566	+ * New CoW fork extents are created unwritten, turned into real extents
	4567	+ * when we're about to write the data to disk, and mapped into the data
	4568	+ * fork after the write finishes. End of story.
	4569	+ *
	4570	+ * New data fork extents must be mapped in as unwritten and converted
	4571	+ * to real extents after the write succeeds to avoid exposing stale
	4572	+ * disk contents if we crash.
	4573	+ */
	4574	+ bma.flags = XFS_BMAPI_PREALLOC;
	4575	+ if (whichfork == XFS_COW_FORK)
	4576	+ bma.flags \|= XFS_BMAPI_COWFORK;
	4577	+
	4578	+ if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
	4579	+ bma.prev.br_startoff = NULLFILEOFF;
	4580	+
	4581	+ error = xfs_bmapi_allocate(&bma);
	4582	+ if (error)
	4583	+ goto out_finish;
	4584	+
	4585	+ error = -ENOSPC;
	4586	+ if (WARN_ON_ONCE(bma.blkno == NULLFSBLOCK))
	4587	+ goto out_finish;
	4588	+ error = -EFSCORRUPTED;
	4589	+ if (WARN_ON_ONCE(!xfs_valid_startblock(ip, bma.got.br_startblock)))
	4590	+ goto out_finish;
	4591	+
	4592	+ XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, bma.length));
	4593	+ XFS_STATS_INC(mp, xs_xstrat_quick);
	4594	+
	4595	+ ASSERT(!isnullstartblock(bma.got.br_startblock));
	4596	+ xfs_bmbt_to_iomap(ip, iomap, &bma.got, flags);
	4597	+ *seq = READ_ONCE(ifp->if_seq);
	4598	+
	4599	+ if (whichfork == XFS_COW_FORK)
	4600	+ xfs_refcount_alloc_cow_extent(tp, bma.blkno, bma.length);
	4601	+
	4602	+ error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
	4603	+ whichfork);
	4604	+ if (error)
	4605	+ goto out_finish;
	4606	+
	4607	+ xfs_bmapi_finish(&bma, whichfork, 0);
	4608	+ error = xfs_trans_commit(tp);
	4609	+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
	4610	+ return error;
	4611	+
	4612	+out_finish:
	4613	+ xfs_bmapi_finish(&bma, whichfork, error);
	4614	+out_trans_cancel:
	4615	+ xfs_trans_cancel(tp);
	4616	+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
4483	4617	return error;
4484	4618	}
4485	4619
..	..	@@ -4509,11 +4643,8 @@
4509	4643	ASSERT((flags & (XFS_BMAPI_ATTRFORK \| XFS_BMAPI_PREALLOC)) !=
4510	4644	(XFS_BMAPI_ATTRFORK \| XFS_BMAPI_PREALLOC));
4511	4645
4512		- if (unlikely(XFS_TEST_ERROR(
4513		- (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
4514		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
4515		- mp, XFS_ERRTAG_BMAPIFORMAT))) {
4516		- XFS_ERROR_REPORT("xfs_bmapi_remap", XFS_ERRLEVEL_LOW, mp);
	4646	+ if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) \|\|
	4647	+ XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
4517	4648	return -EFSCORRUPTED;
4518	4649	}
4519	4650
..	..	@@ -4537,7 +4668,7 @@
4537	4668
4538	4669	if (ifp->if_flags & XFS_IFBROOT) {
4539	4670	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
4540		- cur->bc_private.b.flags = 0;
	4671	+ cur->bc_ino.flags = 0;
4541	4672	}
4542	4673
4543	4674	got.br_startoff = bno;
..	..	@@ -4553,18 +4684,12 @@
4553	4684	if (error)
4554	4685	goto error0;
4555	4686
4556		- if (xfs_bmap_wants_extents(ip, whichfork)) {
4557		- int tmp_logflags = 0;
4558		-
4559		- error = xfs_bmap_btree_to_extents(tp, ip, cur,
4560		- &tmp_logflags, whichfork);
4561		- logflags \|= tmp_logflags;
4562		- }
	4687	+ error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags, whichfork);
4563	4688
4564	4689	error0:
4565		- if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS)
	4690	+ if (ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS)
4566	4691	logflags &= ~XFS_ILOG_DEXT;
4567		- else if (ip->i_d.di_format != XFS_DINODE_FMT_BTREE)
	4692	+ else if (ip->i_df.if_format != XFS_DINODE_FMT_BTREE)
4568	4693	logflags &= ~XFS_ILOG_DBROOT;
4569	4694
4570	4695	if (logflags)
..	..	@@ -4781,8 +4906,10 @@
4781	4906	da_diff = da_old - da_new;
4782	4907	if (!isrt)
4783	4908	da_diff += del->br_blockcount;
4784		- if (da_diff)
	4909	+ if (da_diff) {
4785	4910	xfs_mod_fdblocks(mp, da_diff, false);
	4911	+ xfs_mod_delalloc(mp, -da_diff);
	4912	+ }
4786	4913	return error;
4787	4914	}
4788	4915
..	..	@@ -4912,9 +5039,8 @@
4912	5039	* conversion to btree format, since the transaction will be dirty then.
4913	5040	*/
4914	5041	if (tp->t_blk_res == 0 &&
4915		- XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
4916		- XFS_IFORK_NEXTENTS(ip, whichfork) >=
4917		- XFS_IFORK_MAXEXT(ip, whichfork) &&
	5042	+ ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
	5043	+ ifp->if_nextents >= XFS_IFORK_MAXEXT(ip, whichfork) &&
4918	5044	del->br_startoff > got.br_startoff && del_endoff < got_endoff)
4919	5045	return -ENOSPC;
4920	5046
..	..	@@ -4953,7 +5079,10 @@
4953	5079	error = xfs_bmbt_lookup_eq(cur, &got, &i);
4954	5080	if (error)
4955	5081	goto done;
4956		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	5082	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	5083	+ error = -EFSCORRUPTED;
	5084	+ goto done;
	5085	+ }
4957	5086	}
4958	5087
4959	5088	if (got.br_startoff == del->br_startoff)
..	..	@@ -4968,8 +5097,8 @@
4968	5097	*/
4969	5098	xfs_iext_remove(ip, icur, state);
4970	5099	xfs_iext_prev(ifp, icur);
4971		- XFS_IFORK_NEXT_SET(ip, whichfork,
4972		- XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
	5100	+ ifp->if_nextents--;
	5101	+
4973	5102	flags \|= XFS_ILOG_CORE;
4974	5103	if (!cur) {
4975	5104	flags \|= xfs_ilog_fext(whichfork);
..	..	@@ -4977,7 +5106,10 @@
4977	5106	}
4978	5107	if ((error = xfs_btree_delete(cur, &i)))
4979	5108	goto done;
4980		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	5109	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	5110	+ error = -EFSCORRUPTED;
	5111	+ goto done;
	5112	+ }
4981	5113	break;
4982	5114	case BMAP_LEFT_FILLING:
4983	5115	/*
..	..	@@ -5048,7 +5180,10 @@
5048	5180	error = xfs_bmbt_lookup_eq(cur, &got, &i);
5049	5181	if (error)
5050	5182	goto done;
5051		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	5183	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	5184	+ error = -EFSCORRUPTED;
	5185	+ goto done;
	5186	+ }
5052	5187	/*
5053	5188	* Update the btree record back
5054	5189	* to the original value.
..	..	@@ -5065,29 +5200,28 @@
5065	5200	error = -ENOSPC;
5066	5201	goto done;
5067	5202	}
5068		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	5203	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	5204	+ error = -EFSCORRUPTED;
	5205	+ goto done;
	5206	+ }
5069	5207	} else
5070	5208	flags \|= xfs_ilog_fext(whichfork);
5071		- XFS_IFORK_NEXT_SET(ip, whichfork,
5072		- XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
	5209	+
	5210	+ ifp->if_nextents++;
5073	5211	xfs_iext_next(ifp, icur);
5074	5212	xfs_iext_insert(ip, icur, &new, state);
5075	5213	break;
5076	5214	}
5077	5215
5078	5216	/* remove reverse mapping */
5079		- error = xfs_rmap_unmap_extent(tp, ip, whichfork, del);
5080		- if (error)
5081		- goto done;
	5217	+ xfs_rmap_unmap_extent(tp, ip, whichfork, del);
5082	5218
5083	5219	/*
5084	5220	* If we need to, add to list of extents to delete.
5085	5221	*/
5086	5222	if (do_fx && !(bflags & XFS_BMAPI_REMAP)) {
5087	5223	if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) {
5088		- error = xfs_refcount_decrease_extent(tp, del);
5089		- if (error)
5090		- goto done;
	5224	+ xfs_refcount_decrease_extent(tp, del);
5091	5225	} else {
5092	5226	__xfs_bmap_add_free(tp, del->br_startblock,
5093	5227	del->br_blockcount, NULL,
..	..	@@ -5136,7 +5270,7 @@
5136	5270	int isrt; /* freeing in rt area */
5137	5271	int logflags; /* transaction logging flags */
5138	5272	xfs_extlen_t mod; /* rt extent offset */
5139		- struct xfs_mount mp; / mount structure */
	5273	+ struct xfs_mount *mp = ip->i_mount;
5140	5274	int tmp_logflags; /* partial logging flags */
5141	5275	int wasdel; /* was a delayed alloc extent */
5142	5276	int whichfork; /* data or attribute fork */
..	..	@@ -5153,14 +5287,8 @@
5153	5287	whichfork = xfs_bmapi_whichfork(flags);
5154	5288	ASSERT(whichfork != XFS_COW_FORK);
5155	5289	ifp = XFS_IFORK_PTR(ip, whichfork);
5156		- if (unlikely(
5157		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
5158		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
5159		- XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW,
5160		- ip->i_mount);
	5290	+ if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)))
5161	5291	return -EFSCORRUPTED;
5162		- }
5163		- mp = ip->i_mount;
5164	5292	if (XFS_FORCED_SHUTDOWN(mp))
5165	5293	return -EIO;
5166	5294
..	..	@@ -5197,9 +5325,9 @@
5197	5325
5198	5326	logflags = 0;
5199	5327	if (ifp->if_flags & XFS_IFBROOT) {
5200		- ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
	5328	+ ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
5201	5329	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5202		- cur->bc_private.b.flags = 0;
	5330	+ cur->bc_ino.flags = 0;
5203	5331	} else
5204	5332	cur = NULL;
5205	5333
..	..	@@ -5280,8 +5408,7 @@
5280	5408	* unmapping part of it. But we can't really
5281	5409	* get rid of part of a realtime extent.
5282	5410	*/
5283		- if (del.br_state == XFS_EXT_UNWRITTEN \|\|
5284		- !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
	5411	+ if (del.br_state == XFS_EXT_UNWRITTEN) {
5285	5412	/*
5286	5413	* This piece is unwritten, or we're not
5287	5414	* using unwritten extents. Skip over it.
..	..	@@ -5321,20 +5448,20 @@
5321	5448	}
5322	5449	div_u64_rem(del.br_startblock, mp->m_sb.sb_rextsize, &mod);
5323	5450	if (mod) {
	5451	+ xfs_extlen_t off = mp->m_sb.sb_rextsize - mod;
	5452	+
5324	5453	/*
5325	5454	* Realtime extent is lined up at the end but not
5326	5455	* at the front. We'll get rid of full extents if
5327	5456	* we can.
5328	5457	*/
5329		- mod = mp->m_sb.sb_rextsize - mod;
5330		- if (del.br_blockcount > mod) {
5331		- del.br_blockcount -= mod;
5332		- del.br_startoff += mod;
5333		- del.br_startblock += mod;
5334		- } else if ((del.br_startoff == start &&
5335		- (del.br_state == XFS_EXT_UNWRITTEN \|\|
5336		- tp->t_blk_res == 0)) \|\|
5337		- !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
	5458	+ if (del.br_blockcount > off) {
	5459	+ del.br_blockcount -= off;
	5460	+ del.br_startoff += off;
	5461	+ del.br_startblock += off;
	5462	+ } else if (del.br_startoff == start &&
	5463	+ (del.br_state == XFS_EXT_UNWRITTEN \|\|
	5464	+ tp->t_blk_res == 0)) {
5338	5465	/*
5339	5466	* Can't make it unwritten. There isn't
5340	5467	* a full extent here so just skip it.
..	..	@@ -5349,6 +5476,7 @@
5349	5476	continue;
5350	5477	} else if (del.br_state == XFS_EXT_UNWRITTEN) {
5351	5478	struct xfs_bmbt_irec prev;
	5479	+ xfs_fileoff_t unwrite_start;
5352	5480
5353	5481	/*
5354	5482	* This one is already unwritten.
..	..	@@ -5362,12 +5490,13 @@
5362	5490	ASSERT(!isnullstartblock(prev.br_startblock));
5363	5491	ASSERT(del.br_startblock ==
5364	5492	prev.br_startblock + prev.br_blockcount);
5365		- if (prev.br_startoff < start) {
5366		- mod = start - prev.br_startoff;
5367		- prev.br_blockcount -= mod;
5368		- prev.br_startblock += mod;
5369		- prev.br_startoff = start;
5370		- }
	5493	+ unwrite_start = max3(start,
	5494	+ del.br_startoff - mod,
	5495	+ prev.br_startoff);
	5496	+ mod = unwrite_start - prev.br_startoff;
	5497	+ prev.br_startoff = unwrite_start;
	5498	+ prev.br_startblock += mod;
	5499	+ prev.br_blockcount -= mod;
5371	5500	prev.br_state = XFS_EXT_UNWRITTEN;
5372	5501	error = xfs_bmap_add_extent_unwritten_real(tp,
5373	5502	ip, whichfork, &icur, &cur,
..	..	@@ -5430,34 +5559,21 @@
5430	5559	error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
5431	5560	&tmp_logflags, whichfork);
5432	5561	logflags \|= tmp_logflags;
5433		- if (error)
5434		- goto error0;
5435		- }
5436		- /*
5437		- * transform from btree to extents, give it cur
5438		- */
5439		- else if (xfs_bmap_wants_extents(ip, whichfork)) {
5440		- ASSERT(cur != NULL);
5441		- error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags,
	5562	+ } else {
	5563	+ error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags,
5442	5564	whichfork);
5443		- logflags \|= tmp_logflags;
5444		- if (error)
5445		- goto error0;
5446	5565	}
5447		- /*
5448		- * transform from extents to local?
5449		- */
5450		- error = 0;
	5566	+
5451	5567	error0:
5452	5568	/*
5453	5569	* Log everything. Do this after conversion, there's no point in
5454	5570	* logging the extent records if we've converted to btree format.
5455	5571	*/
5456	5572	if ((logflags & xfs_ilog_fext(whichfork)) &&
5457		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
	5573	+ ifp->if_format != XFS_DINODE_FMT_EXTENTS)
5458	5574	logflags &= ~xfs_ilog_fext(whichfork);
5459	5575	else if ((logflags & xfs_ilog_fbroot(whichfork)) &&
5460		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)
	5576	+ ifp->if_format != XFS_DINODE_FMT_BTREE)
5461	5577	logflags &= ~xfs_ilog_fbroot(whichfork);
5462	5578	/*
5463	5579	* Log inode even in the error case, if the transaction
..	..	@@ -5467,7 +5583,7 @@
5467	5583	xfs_trans_log_inode(tp, ip, logflags);
5468	5584	if (cur) {
5469	5585	if (!error)
5470		- cur->bc_private.b.allocated = 0;
	5586	+ cur->bc_ino.allocated = 0;
5471	5587	xfs_btree_del_cursor(cur, error);
5472	5588	}
5473	5589	return error;
..	..	@@ -5539,6 +5655,7 @@
5539	5655	struct xfs_btree_cur *cur,
5540	5656	int logflags) / output */
5541	5657	{
	5658	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
5542	5659	struct xfs_bmbt_irec new;
5543	5660	xfs_filblks_t blockcount;
5544	5661	int error, i;
..	..	@@ -5557,8 +5674,7 @@
5557	5674	* Update the on-disk extent count, the btree if necessary and log the
5558	5675	* inode.
5559	5676	*/
5560		- XFS_IFORK_NEXT_SET(ip, whichfork,
5561		- XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
	5677	+ ifp->if_nextents--;
5562	5678	*logflags \|= XFS_ILOG_CORE;
5563	5679	if (!cur) {
5564	5680	*logflags \|= XFS_ILOG_DEXT;
..	..	@@ -5569,36 +5685,43 @@
5569	5685	error = xfs_bmbt_lookup_eq(cur, got, &i);
5570	5686	if (error)
5571	5687	return error;
5572		- XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
	5688	+ if (XFS_IS_CORRUPT(mp, i != 1))
	5689	+ return -EFSCORRUPTED;
5573	5690
5574	5691	error = xfs_btree_delete(cur, &i);
5575	5692	if (error)
5576	5693	return error;
5577		- XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
	5694	+ if (XFS_IS_CORRUPT(mp, i != 1))
	5695	+ return -EFSCORRUPTED;
5578	5696
5579	5697	/* lookup and update size of the previous extent */
5580	5698	error = xfs_bmbt_lookup_eq(cur, left, &i);
5581	5699	if (error)
5582	5700	return error;
5583		- XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
	5701	+ if (XFS_IS_CORRUPT(mp, i != 1))
	5702	+ return -EFSCORRUPTED;
5584	5703
5585	5704	error = xfs_bmbt_update(cur, &new);
5586	5705	if (error)
5587	5706	return error;
5588	5707
	5708	+ /* change to extent format if required after extent removal */
	5709	+ error = xfs_bmap_btree_to_extents(tp, ip, cur, logflags, whichfork);
	5710	+ if (error)
	5711	+ return error;
	5712	+
5589	5713	done:
5590	5714	xfs_iext_remove(ip, icur, 0);
5591		- xfs_iext_prev(XFS_IFORK_PTR(ip, whichfork), icur);
	5715	+ xfs_iext_prev(ifp, icur);
5592	5716	xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
5593	5717	&new);
5594	5718
5595	5719	/* update reverse mapping. rmap functions merge the rmaps for us */
5596		- error = xfs_rmap_unmap_extent(tp, ip, whichfork, got);
5597		- if (error)
5598		- return error;
	5720	+ xfs_rmap_unmap_extent(tp, ip, whichfork, got);
5599	5721	memcpy(&new, got, sizeof(new));
5600	5722	new.br_startoff = left->br_startoff + left->br_blockcount;
5601		- return xfs_rmap_map_extent(tp, ip, whichfork, &new);
	5723	+ xfs_rmap_map_extent(tp, ip, whichfork, &new);
	5724	+ return 0;
5602	5725	}
5603	5726
5604	5727	static int
..	..	@@ -5624,7 +5747,8 @@
5624	5747	error = xfs_bmbt_lookup_eq(cur, &prev, &i);
5625	5748	if (error)
5626	5749	return error;
5627		- XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
	5750	+ if (XFS_IS_CORRUPT(mp, i != 1))
	5751	+ return -EFSCORRUPTED;
5628	5752
5629	5753	error = xfs_bmbt_update(cur, got);
5630	5754	if (error)
..	..	@@ -5637,10 +5761,9 @@
5637	5761	got);
5638	5762
5639	5763	/* update reverse mapping */
5640		- error = xfs_rmap_unmap_extent(tp, ip, whichfork, &prev);
5641		- if (error)
5642		- return error;
5643		- return xfs_rmap_map_extent(tp, ip, whichfork, got);
	5764	+ xfs_rmap_unmap_extent(tp, ip, whichfork, &prev);
	5765	+ xfs_rmap_map_extent(tp, ip, whichfork, got);
	5766	+ return 0;
5644	5767	}
5645	5768
5646	5769	int
..	..	@@ -5661,11 +5784,8 @@
5661	5784	int error = 0;
5662	5785	int logflags = 0;
5663	5786
5664		- if (unlikely(XFS_TEST_ERROR(
5665		- (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
5666		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
5667		- mp, XFS_ERRTAG_BMAPIFORMAT))) {
5668		- XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
	5787	+ if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) \|\|
	5788	+ XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
5669	5789	return -EFSCORRUPTED;
5670	5790	}
5671	5791
..	..	@@ -5682,15 +5802,17 @@
5682	5802
5683	5803	if (ifp->if_flags & XFS_IFBROOT) {
5684	5804	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5685		- cur->bc_private.b.flags = 0;
	5805	+ cur->bc_ino.flags = 0;
5686	5806	}
5687	5807
5688	5808	if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
5689	5809	*done = true;
5690	5810	goto del_cursor;
5691	5811	}
5692		- XFS_WANT_CORRUPTED_GOTO(mp, !isnullstartblock(got.br_startblock),
5693		- del_cursor);
	5812	+ if (XFS_IS_CORRUPT(mp, isnullstartblock(got.br_startblock))) {
	5813	+ error = -EFSCORRUPTED;
	5814	+ goto del_cursor;
	5815	+ }
5694	5816
5695	5817	new_startoff = got.br_startoff - offset_shift_fsb;
5696	5818	if (xfs_iext_peek_prev_extent(ifp, &icur, &prev)) {
..	..	@@ -5779,11 +5901,8 @@
5779	5901	int error = 0;
5780	5902	int logflags = 0;
5781	5903
5782		- if (unlikely(XFS_TEST_ERROR(
5783		- (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
5784		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
5785		- mp, XFS_ERRTAG_BMAPIFORMAT))) {
5786		- XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp);
	5904	+ if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) \|\|
	5905	+ XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
5787	5906	return -EFSCORRUPTED;
5788	5907	}
5789	5908
..	..	@@ -5800,7 +5919,7 @@
5800	5919
5801	5920	if (ifp->if_flags & XFS_IFBROOT) {
5802	5921	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5803		- cur->bc_private.b.flags = 0;
	5922	+ cur->bc_ino.flags = 0;
5804	5923	}
5805	5924
5806	5925	if (*next_fsb == NULLFSBLOCK) {
..	..	@@ -5816,11 +5935,13 @@
5816	5935	goto del_cursor;
5817	5936	}
5818	5937	}
5819		- XFS_WANT_CORRUPTED_GOTO(mp, !isnullstartblock(got.br_startblock),
5820		- del_cursor);
	5938	+ if (XFS_IS_CORRUPT(mp, isnullstartblock(got.br_startblock))) {
	5939	+ error = -EFSCORRUPTED;
	5940	+ goto del_cursor;
	5941	+ }
5821	5942
5822		- if (stop_fsb >= got.br_startoff + got.br_blockcount) {
5823		- error = -EIO;
	5943	+ if (XFS_IS_CORRUPT(mp, stop_fsb > got.br_startoff)) {
	5944	+ error = -EFSCORRUPTED;
5824	5945	goto del_cursor;
5825	5946	}
5826	5947
..	..	@@ -5867,37 +5988,32 @@
5867	5988	* @split_fsb is a block where the extents is split. If split_fsb lies in a
5868	5989	* hole or the first block of extents, just return 0.
5869	5990	*/
5870		-STATIC int
5871		-xfs_bmap_split_extent_at(
	5991	+int
	5992	+xfs_bmap_split_extent(
5872	5993	struct xfs_trans *tp,
5873	5994	struct xfs_inode *ip,
5874	5995	xfs_fileoff_t split_fsb)
5875	5996	{
5876	5997	int whichfork = XFS_DATA_FORK;
	5998	+ struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
5877	5999	struct xfs_btree_cur *cur = NULL;
5878	6000	struct xfs_bmbt_irec got;
5879	6001	struct xfs_bmbt_irec new; /* split extent */
5880	6002	struct xfs_mount *mp = ip->i_mount;
5881		- struct xfs_ifork *ifp;
5882	6003	xfs_fsblock_t gotblkcnt; /* new block count for got */
5883	6004	struct xfs_iext_cursor icur;
5884	6005	int error = 0;
5885	6006	int logflags = 0;
5886	6007	int i = 0;
5887	6008
5888		- if (unlikely(XFS_TEST_ERROR(
5889		- (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
5890		- XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
5891		- mp, XFS_ERRTAG_BMAPIFORMAT))) {
5892		- XFS_ERROR_REPORT("xfs_bmap_split_extent_at",
5893		- XFS_ERRLEVEL_LOW, mp);
	6009	+ if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) \|\|
	6010	+ XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
5894	6011	return -EFSCORRUPTED;
5895	6012	}
5896	6013
5897	6014	if (XFS_FORCED_SHUTDOWN(mp))
5898	6015	return -EIO;
5899	6016
5900		- ifp = XFS_IFORK_PTR(ip, whichfork);
5901	6017	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
5902	6018	/* Read in all the extents */
5903	6019	error = xfs_iread_extents(tp, ip, whichfork);
..	..	@@ -5920,11 +6036,14 @@
5920	6036
5921	6037	if (ifp->if_flags & XFS_IFBROOT) {
5922	6038	cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5923		- cur->bc_private.b.flags = 0;
	6039	+ cur->bc_ino.flags = 0;
5924	6040	error = xfs_bmbt_lookup_eq(cur, &got, &i);
5925	6041	if (error)
5926	6042	goto del_cursor;
5927		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor);
	6043	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	6044	+ error = -EFSCORRUPTED;
	6045	+ goto del_cursor;
	6046	+ }
5928	6047	}
5929	6048
5930	6049	got.br_blockcount = gotblkcnt;
..	..	@@ -5942,18 +6061,23 @@
5942	6061	/* Add new extent */
5943	6062	xfs_iext_next(ifp, &icur);
5944	6063	xfs_iext_insert(ip, &icur, &new, 0);
5945		- XFS_IFORK_NEXT_SET(ip, whichfork,
5946		- XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
	6064	+ ifp->if_nextents++;
5947	6065
5948	6066	if (cur) {
5949	6067	error = xfs_bmbt_lookup_eq(cur, &new, &i);
5950	6068	if (error)
5951	6069	goto del_cursor;
5952		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, del_cursor);
	6070	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	6071	+ error = -EFSCORRUPTED;
	6072	+ goto del_cursor;
	6073	+ }
5953	6074	error = xfs_btree_insert(cur, &i);
5954	6075	if (error)
5955	6076	goto del_cursor;
5956		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor);
	6077	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	6078	+ error = -EFSCORRUPTED;
	6079	+ goto del_cursor;
	6080	+ }
5957	6081	}
5958	6082
5959	6083	/*
..	..	@@ -5970,40 +6094,12 @@
5970	6094
5971	6095	del_cursor:
5972	6096	if (cur) {
5973		- cur->bc_private.b.allocated = 0;
	6097	+ cur->bc_ino.allocated = 0;
5974	6098	xfs_btree_del_cursor(cur, error);
5975	6099	}
5976	6100
5977	6101	if (logflags)
5978	6102	xfs_trans_log_inode(tp, ip, logflags);
5979		- return error;
5980		-}
5981		-
5982		-int
5983		-xfs_bmap_split_extent(
5984		- struct xfs_inode *ip,
5985		- xfs_fileoff_t split_fsb)
5986		-{
5987		- struct xfs_mount *mp = ip->i_mount;
5988		- struct xfs_trans *tp;
5989		- int error;
5990		-
5991		- error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write,
5992		- XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp);
5993		- if (error)
5994		- return error;
5995		-
5996		- xfs_ilock(ip, XFS_ILOCK_EXCL);
5997		- xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
5998		-
5999		- error = xfs_bmap_split_extent_at(tp, ip, split_fsb);
6000		- if (error)
6001		- goto out;
6002		-
6003		- return xfs_trans_commit(tp);
6004		-
6005		-out:
6006		- xfs_trans_cancel(tp);
6007	6103	return error;
6008	6104	}
6009	6105
..	..	@@ -6036,7 +6132,7 @@
6036	6132	bmap->br_blockcount,
6037	6133	bmap->br_state);
6038	6134
6039		- bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_SLEEP \| KM_NOFS);
	6135	+ bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_NOFS);
6040	6136	INIT_LIST_HEAD(&bi->bi_list);
6041	6137	bi->bi_type = type;
6042	6138	bi->bi_owner = ip;
..	..	@@ -6048,29 +6144,29 @@
6048	6144	}
6049	6145
6050	6146	/* Map an extent into a file. */
6051		-int
	6147	+void
6052	6148	xfs_bmap_map_extent(
6053	6149	struct xfs_trans *tp,
6054	6150	struct xfs_inode *ip,
6055	6151	struct xfs_bmbt_irec *PREV)
6056	6152	{
6057	6153	if (!xfs_bmap_is_update_needed(PREV))
6058		- return 0;
	6154	+ return;
6059	6155
6060		- return __xfs_bmap_add(tp, XFS_BMAP_MAP, ip, XFS_DATA_FORK, PREV);
	6156	+ __xfs_bmap_add(tp, XFS_BMAP_MAP, ip, XFS_DATA_FORK, PREV);
6061	6157	}
6062	6158
6063	6159	/* Unmap an extent out of a file. */
6064		-int
	6160	+void
6065	6161	xfs_bmap_unmap_extent(
6066	6162	struct xfs_trans *tp,
6067	6163	struct xfs_inode *ip,
6068	6164	struct xfs_bmbt_irec *PREV)
6069	6165	{
6070	6166	if (!xfs_bmap_is_update_needed(PREV))
6071		- return 0;
	6167	+ return;
6072	6168
6073		- return __xfs_bmap_add(tp, XFS_BMAP_UNMAP, ip, XFS_DATA_FORK, PREV);
	6169	+ __xfs_bmap_add(tp, XFS_BMAP_UNMAP, ip, XFS_DATA_FORK, PREV);
6074	6170	}
6075	6171
6076	6172	/*
..	..	@@ -6133,6 +6229,11 @@
6133	6229	xfs_fsblock_t endfsb;
6134	6230	bool isrt;
6135	6231
	6232	+ if (irec->br_startblock + irec->br_blockcount <= irec->br_startblock)
	6233	+ return __this_address;
	6234	+ if (irec->br_startoff + irec->br_blockcount <= irec->br_startoff)
	6235	+ return __this_address;
	6236	+
6136	6237	isrt = XFS_IS_REALTIME_INODE(ip);
6137	6238	endfsb = irec->br_startblock + irec->br_blockcount - 1;
6138	6239	if (isrt && whichfork == XFS_DATA_FORK) {
..	..	@@ -6149,11 +6250,7 @@
6149	6250	XFS_FSB_TO_AGNO(mp, endfsb))
6150	6251	return __this_address;
6151	6252	}
6152		- if (irec->br_state != XFS_EXT_NORM) {
6153		- if (whichfork != XFS_DATA_FORK)
6154		- return __this_address;
6155		- if (!xfs_sb_version_hasextflgbit(&mp->m_sb))
6156		- return __this_address;
6157		- }
	6253	+ if (irec->br_state != XFS_EXT_NORM && whichfork != XFS_DATA_FORK)
	6254	+ return __this_address;
6158	6255	return NULL;
6159	6256	}