~hc/RK356X_SDK_RELEASE.git

..	..	@@ -10,24 +10,17 @@
10	10	#include "xfs_log_format.h"
11	11	#include "xfs_trans_resv.h"
12	12	#include "xfs_bit.h"
13		-#include "xfs_sb.h"
14	13	#include "xfs_mount.h"
15	14	#include "xfs_defer.h"
16		-#include "xfs_da_format.h"
17		-#include "xfs_da_btree.h"
18	15	#include "xfs_btree.h"
19	16	#include "xfs_trans.h"
20	17	#include "xfs_alloc.h"
21	18	#include "xfs_rmap.h"
22	19	#include "xfs_rmap_btree.h"
23		-#include "xfs_trans_space.h"
24	20	#include "xfs_trace.h"
25	21	#include "xfs_errortag.h"
26	22	#include "xfs_error.h"
27		-#include "xfs_extent_busy.h"
28		-#include "xfs_bmap.h"
29	23	#include "xfs_inode.h"
30		-#include "xfs_ialloc.h"
31	24
32	25	/*
33	26	* Lookup the first record less than or equal to [bno, len, owner, offset]
..	..	@@ -86,7 +79,7 @@
86	79	union xfs_btree_rec rec;
87	80	int error;
88	81
89		- trace_xfs_rmap_update(cur->bc_mp, cur->bc_private.a.agno,
	82	+ trace_xfs_rmap_update(cur->bc_mp, cur->bc_ag.agno,
90	83	irec->rm_startblock, irec->rm_blockcount,
91	84	irec->rm_owner, irec->rm_offset, irec->rm_flags);
92	85
..	..	@@ -98,7 +91,7 @@
98	91	error = xfs_btree_update(cur, &rec);
99	92	if (error)
100	93	trace_xfs_rmap_update_error(cur->bc_mp,
101		- cur->bc_private.a.agno, error, _RET_IP_);
	94	+ cur->bc_ag.agno, error, _RET_IP_);
102	95	return error;
103	96	}
104	97
..	..	@@ -114,13 +107,16 @@
114	107	int i;
115	108	int error;
116	109
117		- trace_xfs_rmap_insert(rcur->bc_mp, rcur->bc_private.a.agno, agbno,
	110	+ trace_xfs_rmap_insert(rcur->bc_mp, rcur->bc_ag.agno, agbno,
118	111	len, owner, offset, flags);
119	112
120	113	error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
121	114	if (error)
122	115	goto done;
123		- XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 0, done);
	116	+ if (XFS_IS_CORRUPT(rcur->bc_mp, i != 0)) {
	117	+ error = -EFSCORRUPTED;
	118	+ goto done;
	119	+ }
124	120
125	121	rcur->bc_rec.r.rm_startblock = agbno;
126	122	rcur->bc_rec.r.rm_blockcount = len;
..	..	@@ -130,11 +126,14 @@
130	126	error = xfs_btree_insert(rcur, &i);
131	127	if (error)
132	128	goto done;
133		- XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 1, done);
	129	+ if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1)) {
	130	+ error = -EFSCORRUPTED;
	131	+ goto done;
	132	+ }
134	133	done:
135	134	if (error)
136	135	trace_xfs_rmap_insert_error(rcur->bc_mp,
137		- rcur->bc_private.a.agno, error, _RET_IP_);
	136	+ rcur->bc_ag.agno, error, _RET_IP_);
138	137	return error;
139	138	}
140	139
..	..	@@ -150,22 +149,28 @@
150	149	int i;
151	150	int error;
152	151
153		- trace_xfs_rmap_delete(rcur->bc_mp, rcur->bc_private.a.agno, agbno,
	152	+ trace_xfs_rmap_delete(rcur->bc_mp, rcur->bc_ag.agno, agbno,
154	153	len, owner, offset, flags);
155	154
156	155	error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
157	156	if (error)
158	157	goto done;
159		- XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 1, done);
	158	+ if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1)) {
	159	+ error = -EFSCORRUPTED;
	160	+ goto done;
	161	+ }
160	162
161	163	error = xfs_btree_delete(rcur, &i);
162	164	if (error)
163	165	goto done;
164		- XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 1, done);
	166	+ if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1)) {
	167	+ error = -EFSCORRUPTED;
	168	+ goto done;
	169	+ }
165	170	done:
166	171	if (error)
167	172	trace_xfs_rmap_delete_error(rcur->bc_mp,
168		- rcur->bc_private.a.agno, error, _RET_IP_);
	173	+ rcur->bc_ag.agno, error, _RET_IP_);
169	174	return error;
170	175	}
171	176
..	..	@@ -175,7 +180,6 @@
175	180	union xfs_btree_rec *rec,
176	181	struct xfs_rmap_irec *irec)
177	182	{
178		- irec->rm_flags = 0;
179	183	irec->rm_startblock = be32_to_cpu(rec->rmap.rm_startblock);
180	184	irec->rm_blockcount = be32_to_cpu(rec->rmap.rm_blockcount);
181	185	irec->rm_owner = be64_to_cpu(rec->rmap.rm_owner);
..	..	@@ -193,7 +197,7 @@
193	197	int *stat)
194	198	{
195	199	struct xfs_mount *mp = cur->bc_mp;
196		- xfs_agnumber_t agno = cur->bc_private.a.agno;
	200	+ xfs_agnumber_t agno = cur->bc_ag.agno;
197	201	union xfs_btree_rec *rec;
198	202	int error;
199	203
..	..	@@ -256,20 +260,20 @@
256	260	struct xfs_find_left_neighbor_info *info = priv;
257	261
258	262	trace_xfs_rmap_find_left_neighbor_candidate(cur->bc_mp,
259		- cur->bc_private.a.agno, rec->rm_startblock,
	263	+ cur->bc_ag.agno, rec->rm_startblock,
260	264	rec->rm_blockcount, rec->rm_owner, rec->rm_offset,
261	265	rec->rm_flags);
262	266
263	267	if (rec->rm_owner != info->high.rm_owner)
264		- return XFS_BTREE_QUERY_RANGE_CONTINUE;
	268	+ return 0;
265	269	if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) &&
266	270	!(rec->rm_flags & XFS_RMAP_BMBT_BLOCK) &&
267	271	rec->rm_offset + rec->rm_blockcount - 1 != info->high.rm_offset)
268		- return XFS_BTREE_QUERY_RANGE_CONTINUE;
	272	+ return 0;
269	273
270	274	info->irec = rec;
271	275	*info->stat = 1;
272		- return XFS_BTREE_QUERY_RANGE_ABORT;
	276	+ return -ECANCELED;
273	277	}
274	278
275	279	/*
..	..	@@ -308,15 +312,15 @@
308	312	info.stat = stat;
309	313
310	314	trace_xfs_rmap_find_left_neighbor_query(cur->bc_mp,
311		- cur->bc_private.a.agno, bno, 0, owner, offset, flags);
	315	+ cur->bc_ag.agno, bno, 0, owner, offset, flags);
312	316
313	317	error = xfs_rmap_query_range(cur, &info.high, &info.high,
314	318	xfs_rmap_find_left_neighbor_helper, &info);
315		- if (error == XFS_BTREE_QUERY_RANGE_ABORT)
	319	+ if (error == -ECANCELED)
316	320	error = 0;
317	321	if (*stat)
318	322	trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
319		- cur->bc_private.a.agno, irec->rm_startblock,
	323	+ cur->bc_ag.agno, irec->rm_startblock,
320	324	irec->rm_blockcount, irec->rm_owner,
321	325	irec->rm_offset, irec->rm_flags);
322	326	return error;
..	..	@@ -332,21 +336,21 @@
332	336	struct xfs_find_left_neighbor_info *info = priv;
333	337
334	338	trace_xfs_rmap_lookup_le_range_candidate(cur->bc_mp,
335		- cur->bc_private.a.agno, rec->rm_startblock,
	339	+ cur->bc_ag.agno, rec->rm_startblock,
336	340	rec->rm_blockcount, rec->rm_owner, rec->rm_offset,
337	341	rec->rm_flags);
338	342
339	343	if (rec->rm_owner != info->high.rm_owner)
340		- return XFS_BTREE_QUERY_RANGE_CONTINUE;
	344	+ return 0;
341	345	if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) &&
342	346	!(rec->rm_flags & XFS_RMAP_BMBT_BLOCK) &&
343	347	(rec->rm_offset > info->high.rm_offset \|\|
344	348	rec->rm_offset + rec->rm_blockcount <= info->high.rm_offset))
345		- return XFS_BTREE_QUERY_RANGE_CONTINUE;
	349	+ return 0;
346	350
347	351	info->irec = rec;
348	352	*info->stat = 1;
349		- return XFS_BTREE_QUERY_RANGE_ABORT;
	353	+ return -ECANCELED;
350	354	}
351	355
352	356	/*
..	..	@@ -381,14 +385,14 @@
381	385	info.stat = stat;
382	386
383	387	trace_xfs_rmap_lookup_le_range(cur->bc_mp,
384		- cur->bc_private.a.agno, bno, 0, owner, offset, flags);
	388	+ cur->bc_ag.agno, bno, 0, owner, offset, flags);
385	389	error = xfs_rmap_query_range(cur, &info.high, &info.high,
386	390	xfs_rmap_lookup_le_range_helper, &info);
387		- if (error == XFS_BTREE_QUERY_RANGE_ABORT)
	391	+ if (error == -ECANCELED)
388	392	error = 0;
389	393	if (*stat)
390	394	trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
391		- cur->bc_private.a.agno, irec->rm_startblock,
	395	+ cur->bc_ag.agno, irec->rm_startblock,
392	396	irec->rm_blockcount, irec->rm_owner,
393	397	irec->rm_offset, irec->rm_flags);
394	398	return error;
..	..	@@ -414,24 +418,39 @@
414	418	return 0;
415	419
416	420	/* Make sure the unwritten flag matches. */
417		- XFS_WANT_CORRUPTED_GOTO(mp, (flags & XFS_RMAP_UNWRITTEN) ==
418		- (rec->rm_flags & XFS_RMAP_UNWRITTEN), out);
	421	+ if (XFS_IS_CORRUPT(mp,
	422	+ (flags & XFS_RMAP_UNWRITTEN) !=
	423	+ (rec->rm_flags & XFS_RMAP_UNWRITTEN))) {
	424	+ error = -EFSCORRUPTED;
	425	+ goto out;
	426	+ }
419	427
420	428	/* Make sure the owner matches what we expect to find in the tree. */
421		- XFS_WANT_CORRUPTED_GOTO(mp, owner == rec->rm_owner, out);
	429	+ if (XFS_IS_CORRUPT(mp, owner != rec->rm_owner)) {
	430	+ error = -EFSCORRUPTED;
	431	+ goto out;
	432	+ }
422	433
423	434	/* Check the offset, if necessary. */
424	435	if (XFS_RMAP_NON_INODE_OWNER(owner))
425	436	goto out;
426	437
427	438	if (flags & XFS_RMAP_BMBT_BLOCK) {
428		- XFS_WANT_CORRUPTED_GOTO(mp, rec->rm_flags & XFS_RMAP_BMBT_BLOCK,
429		- out);
	439	+ if (XFS_IS_CORRUPT(mp,
	440	+ !(rec->rm_flags & XFS_RMAP_BMBT_BLOCK))) {
	441	+ error = -EFSCORRUPTED;
	442	+ goto out;
	443	+ }
430	444	} else {
431		- XFS_WANT_CORRUPTED_GOTO(mp, rec->rm_offset <= offset, out);
432		- XFS_WANT_CORRUPTED_GOTO(mp,
433		- ltoff + rec->rm_blockcount >= offset + len,
434		- out);
	445	+ if (XFS_IS_CORRUPT(mp, rec->rm_offset > offset)) {
	446	+ error = -EFSCORRUPTED;
	447	+ goto out;
	448	+ }
	449	+ if (XFS_IS_CORRUPT(mp,
	450	+ offset + len > ltoff + rec->rm_blockcount)) {
	451	+ error = -EFSCORRUPTED;
	452	+ goto out;
	453	+ }
435	454	}
436	455
437	456	out:
..	..	@@ -458,28 +477,28 @@
458	477	*/
459	478	STATIC int
460	479	xfs_rmap_unmap(
461		- struct xfs_btree_cur *cur,
462		- xfs_agblock_t bno,
463		- xfs_extlen_t len,
464		- bool unwritten,
465		- struct xfs_owner_info *oinfo)
	480	+ struct xfs_btree_cur *cur,
	481	+ xfs_agblock_t bno,
	482	+ xfs_extlen_t len,
	483	+ bool unwritten,
	484	+ const struct xfs_owner_info *oinfo)
466	485	{
467		- struct xfs_mount *mp = cur->bc_mp;
468		- struct xfs_rmap_irec ltrec;
469		- uint64_t ltoff;
470		- int error = 0;
471		- int i;
472		- uint64_t owner;
473		- uint64_t offset;
474		- unsigned int flags;
475		- bool ignore_off;
	486	+ struct xfs_mount *mp = cur->bc_mp;
	487	+ struct xfs_rmap_irec ltrec;
	488	+ uint64_t ltoff;
	489	+ int error = 0;
	490	+ int i;
	491	+ uint64_t owner;
	492	+ uint64_t offset;
	493	+ unsigned int flags;
	494	+ bool ignore_off;
476	495
477	496	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
478	497	ignore_off = XFS_RMAP_NON_INODE_OWNER(owner) \|\|
479	498	(flags & XFS_RMAP_BMBT_BLOCK);
480	499	if (unwritten)
481	500	flags \|= XFS_RMAP_UNWRITTEN;
482		- trace_xfs_rmap_unmap(mp, cur->bc_private.a.agno, bno, len,
	501	+ trace_xfs_rmap_unmap(mp, cur->bc_ag.agno, bno, len,
483	502	unwritten, oinfo);
484	503
485	504	/*
..	..	@@ -490,14 +509,20 @@
490	509	error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, flags, &i);
491	510	if (error)
492	511	goto out_error;
493		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	512	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	513	+ error = -EFSCORRUPTED;
	514	+ goto out_error;
	515	+ }
494	516
495	517	error = xfs_rmap_get_rec(cur, &ltrec, &i);
496	518	if (error)
497	519	goto out_error;
498		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	520	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	521	+ error = -EFSCORRUPTED;
	522	+ goto out_error;
	523	+ }
499	524	trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
500		- cur->bc_private.a.agno, ltrec.rm_startblock,
	525	+ cur->bc_ag.agno, ltrec.rm_startblock,
501	526	ltrec.rm_blockcount, ltrec.rm_owner,
502	527	ltrec.rm_offset, ltrec.rm_flags);
503	528	ltoff = ltrec.rm_offset;
..	..	@@ -510,8 +535,12 @@
510	535	* be the case that the "left" extent goes all the way to EOFS.
511	536	*/
512	537	if (owner == XFS_RMAP_OWN_NULL) {
513		- XFS_WANT_CORRUPTED_GOTO(mp, bno >= ltrec.rm_startblock +
514		- ltrec.rm_blockcount, out_error);
	538	+ if (XFS_IS_CORRUPT(mp,
	539	+ bno <
	540	+ ltrec.rm_startblock + ltrec.rm_blockcount)) {
	541	+ error = -EFSCORRUPTED;
	542	+ goto out_error;
	543	+ }
515	544	goto out_done;
516	545	}
517	546
..	..	@@ -534,15 +563,22 @@
534	563	error = xfs_rmap_get_rec(cur, &rtrec, &i);
535	564	if (error)
536	565	goto out_error;
537		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	566	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	567	+ error = -EFSCORRUPTED;
	568	+ goto out_error;
	569	+ }
538	570	if (rtrec.rm_startblock >= bno + len)
539	571	goto out_done;
540	572	}
541	573
542	574	/* Make sure the extent we found covers the entire freeing range. */
543		- XFS_WANT_CORRUPTED_GOTO(mp, ltrec.rm_startblock <= bno &&
544		- ltrec.rm_startblock + ltrec.rm_blockcount >=
545		- bno + len, out_error);
	575	+ if (XFS_IS_CORRUPT(mp,
	576	+ ltrec.rm_startblock > bno \|\|
	577	+ ltrec.rm_startblock + ltrec.rm_blockcount <
	578	+ bno + len)) {
	579	+ error = -EFSCORRUPTED;
	580	+ goto out_error;
	581	+ }
546	582
547	583	/* Check owner information. */
548	584	error = xfs_rmap_free_check_owner(mp, ltoff, &ltrec, len, owner,
..	..	@@ -552,14 +588,17 @@
552	588
553	589	if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {
554	590	/* exact match, simply remove the record from rmap tree */
555		- trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
	591	+ trace_xfs_rmap_delete(mp, cur->bc_ag.agno,
556	592	ltrec.rm_startblock, ltrec.rm_blockcount,
557	593	ltrec.rm_owner, ltrec.rm_offset,
558	594	ltrec.rm_flags);
559	595	error = xfs_btree_delete(cur, &i);
560	596	if (error)
561	597	goto out_error;
562		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	598	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	599	+ error = -EFSCORRUPTED;
	600	+ goto out_error;
	601	+ }
563	602	} else if (ltrec.rm_startblock == bno) {
564	603	/*
565	604	* overlap left hand side of extent: move the start, trim the
..	..	@@ -627,7 +666,7 @@
627	666	else
628	667	cur->bc_rec.r.rm_offset = offset + len;
629	668	cur->bc_rec.r.rm_flags = flags;
630		- trace_xfs_rmap_insert(mp, cur->bc_private.a.agno,
	669	+ trace_xfs_rmap_insert(mp, cur->bc_ag.agno,
631	670	cur->bc_rec.r.rm_startblock,
632	671	cur->bc_rec.r.rm_blockcount,
633	672	cur->bc_rec.r.rm_owner,
..	..	@@ -639,11 +678,11 @@
639	678	}
640	679
641	680	out_done:
642		- trace_xfs_rmap_unmap_done(mp, cur->bc_private.a.agno, bno, len,
	681	+ trace_xfs_rmap_unmap_done(mp, cur->bc_ag.agno, bno, len,
643	682	unwritten, oinfo);
644	683	out_error:
645	684	if (error)
646		- trace_xfs_rmap_unmap_error(mp, cur->bc_private.a.agno,
	685	+ trace_xfs_rmap_unmap_error(mp, cur->bc_ag.agno,
647	686	error, _RET_IP_);
648	687	return error;
649	688	}
..	..	@@ -653,16 +692,16 @@
653	692	*/
654	693	int
655	694	xfs_rmap_free(
656		- struct xfs_trans *tp,
657		- struct xfs_buf *agbp,
658		- xfs_agnumber_t agno,
659		- xfs_agblock_t bno,
660		- xfs_extlen_t len,
661		- struct xfs_owner_info *oinfo)
	695	+ struct xfs_trans *tp,
	696	+ struct xfs_buf *agbp,
	697	+ xfs_agnumber_t agno,
	698	+ xfs_agblock_t bno,
	699	+ xfs_extlen_t len,
	700	+ const struct xfs_owner_info *oinfo)
662	701	{
663		- struct xfs_mount *mp = tp->t_mountp;
664		- struct xfs_btree_cur *cur;
665		- int error;
	702	+ struct xfs_mount *mp = tp->t_mountp;
	703	+ struct xfs_btree_cur *cur;
	704	+ int error;
666	705
667	706	if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
668	707	return 0;
..	..	@@ -710,23 +749,23 @@
710	749	*/
711	750	STATIC int
712	751	xfs_rmap_map(
713		- struct xfs_btree_cur *cur,
714		- xfs_agblock_t bno,
715		- xfs_extlen_t len,
716		- bool unwritten,
717		- struct xfs_owner_info *oinfo)
	752	+ struct xfs_btree_cur *cur,
	753	+ xfs_agblock_t bno,
	754	+ xfs_extlen_t len,
	755	+ bool unwritten,
	756	+ const struct xfs_owner_info *oinfo)
718	757	{
719		- struct xfs_mount *mp = cur->bc_mp;
720		- struct xfs_rmap_irec ltrec;
721		- struct xfs_rmap_irec gtrec;
722		- int have_gt;
723		- int have_lt;
724		- int error = 0;
725		- int i;
726		- uint64_t owner;
727		- uint64_t offset;
728		- unsigned int flags = 0;
729		- bool ignore_off;
	758	+ struct xfs_mount *mp = cur->bc_mp;
	759	+ struct xfs_rmap_irec ltrec;
	760	+ struct xfs_rmap_irec gtrec;
	761	+ int have_gt;
	762	+ int have_lt;
	763	+ int error = 0;
	764	+ int i;
	765	+ uint64_t owner;
	766	+ uint64_t offset;
	767	+ unsigned int flags = 0;
	768	+ bool ignore_off;
730	769
731	770	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
732	771	ASSERT(owner != 0);
..	..	@@ -734,7 +773,7 @@
734	773	(flags & XFS_RMAP_BMBT_BLOCK);
735	774	if (unwritten)
736	775	flags \|= XFS_RMAP_UNWRITTEN;
737		- trace_xfs_rmap_map(mp, cur->bc_private.a.agno, bno, len,
	776	+ trace_xfs_rmap_map(mp, cur->bc_ag.agno, bno, len,
738	777	unwritten, oinfo);
739	778	ASSERT(!xfs_rmap_should_skip_owner_update(oinfo));
740	779
..	..	@@ -751,9 +790,12 @@
751	790	error = xfs_rmap_get_rec(cur, &ltrec, &have_lt);
752	791	if (error)
753	792	goto out_error;
754		- XFS_WANT_CORRUPTED_GOTO(mp, have_lt == 1, out_error);
	793	+ if (XFS_IS_CORRUPT(mp, have_lt != 1)) {
	794	+ error = -EFSCORRUPTED;
	795	+ goto out_error;
	796	+ }
755	797	trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
756		- cur->bc_private.a.agno, ltrec.rm_startblock,
	798	+ cur->bc_ag.agno, ltrec.rm_startblock,
757	799	ltrec.rm_blockcount, ltrec.rm_owner,
758	800	ltrec.rm_offset, ltrec.rm_flags);
759	801
..	..	@@ -761,9 +803,12 @@
761	803	have_lt = 0;
762	804	}
763	805
764		- XFS_WANT_CORRUPTED_GOTO(mp,
765		- have_lt == 0 \|\|
766		- ltrec.rm_startblock + ltrec.rm_blockcount <= bno, out_error);
	806	+ if (XFS_IS_CORRUPT(mp,
	807	+ have_lt != 0 &&
	808	+ ltrec.rm_startblock + ltrec.rm_blockcount > bno)) {
	809	+ error = -EFSCORRUPTED;
	810	+ goto out_error;
	811	+ }
767	812
768	813	/*
769	814	* Increment the cursor to see if we have a right-adjacent record to our
..	..	@@ -777,11 +822,16 @@
777	822	error = xfs_rmap_get_rec(cur, &gtrec, &have_gt);
778	823	if (error)
779	824	goto out_error;
780		- XFS_WANT_CORRUPTED_GOTO(mp, have_gt == 1, out_error);
781		- XFS_WANT_CORRUPTED_GOTO(mp, bno + len <= gtrec.rm_startblock,
782		- out_error);
	825	+ if (XFS_IS_CORRUPT(mp, have_gt != 1)) {
	826	+ error = -EFSCORRUPTED;
	827	+ goto out_error;
	828	+ }
	829	+ if (XFS_IS_CORRUPT(mp, bno + len > gtrec.rm_startblock)) {
	830	+ error = -EFSCORRUPTED;
	831	+ goto out_error;
	832	+ }
783	833	trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
784		- cur->bc_private.a.agno, gtrec.rm_startblock,
	834	+ cur->bc_ag.agno, gtrec.rm_startblock,
785	835	gtrec.rm_blockcount, gtrec.rm_owner,
786	836	gtrec.rm_offset, gtrec.rm_flags);
787	837	if (!xfs_rmap_is_mergeable(&gtrec, owner, flags))
..	..	@@ -820,7 +870,7 @@
820	870	* result: \|rrrrrrrrrrrrrrrrrrrrrrrrrrrrr\|
821	871	*/
822	872	ltrec.rm_blockcount += gtrec.rm_blockcount;
823		- trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
	873	+ trace_xfs_rmap_delete(mp, cur->bc_ag.agno,
824	874	gtrec.rm_startblock,
825	875	gtrec.rm_blockcount,
826	876	gtrec.rm_owner,
..	..	@@ -829,7 +879,10 @@
829	879	error = xfs_btree_delete(cur, &i);
830	880	if (error)
831	881	goto out_error;
832		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	882	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	883	+ error = -EFSCORRUPTED;
	884	+ goto out_error;
	885	+ }
833	886	}
834	887
835	888	/* point the cursor back to the left record and update */
..	..	@@ -868,19 +921,22 @@
868	921	cur->bc_rec.r.rm_owner = owner;
869	922	cur->bc_rec.r.rm_offset = offset;
870	923	cur->bc_rec.r.rm_flags = flags;
871		- trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno, len,
	924	+ trace_xfs_rmap_insert(mp, cur->bc_ag.agno, bno, len,
872	925	owner, offset, flags);
873	926	error = xfs_btree_insert(cur, &i);
874	927	if (error)
875	928	goto out_error;
876		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	929	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	930	+ error = -EFSCORRUPTED;
	931	+ goto out_error;
	932	+ }
877	933	}
878	934
879		- trace_xfs_rmap_map_done(mp, cur->bc_private.a.agno, bno, len,
	935	+ trace_xfs_rmap_map_done(mp, cur->bc_ag.agno, bno, len,
880	936	unwritten, oinfo);
881	937	out_error:
882	938	if (error)
883		- trace_xfs_rmap_map_error(mp, cur->bc_private.a.agno,
	939	+ trace_xfs_rmap_map_error(mp, cur->bc_ag.agno,
884	940	error, _RET_IP_);
885	941	return error;
886	942	}
..	..	@@ -890,16 +946,16 @@
890	946	*/
891	947	int
892	948	xfs_rmap_alloc(
893		- struct xfs_trans *tp,
894		- struct xfs_buf *agbp,
895		- xfs_agnumber_t agno,
896		- xfs_agblock_t bno,
897		- xfs_extlen_t len,
898		- struct xfs_owner_info *oinfo)
	949	+ struct xfs_trans *tp,
	950	+ struct xfs_buf *agbp,
	951	+ xfs_agnumber_t agno,
	952	+ xfs_agblock_t bno,
	953	+ xfs_extlen_t len,
	954	+ const struct xfs_owner_info *oinfo)
899	955	{
900		- struct xfs_mount *mp = tp->t_mountp;
901		- struct xfs_btree_cur *cur;
902		- int error;
	956	+ struct xfs_mount *mp = tp->t_mountp;
	957	+ struct xfs_btree_cur *cur;
	958	+ int error;
903	959
904	960	if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
905	961	return 0;
..	..	@@ -929,16 +985,16 @@
929	985	*/
930	986	STATIC int
931	987	xfs_rmap_convert(
932		- struct xfs_btree_cur *cur,
933		- xfs_agblock_t bno,
934		- xfs_extlen_t len,
935		- bool unwritten,
936		- struct xfs_owner_info *oinfo)
	988	+ struct xfs_btree_cur *cur,
	989	+ xfs_agblock_t bno,
	990	+ xfs_extlen_t len,
	991	+ bool unwritten,
	992	+ const struct xfs_owner_info *oinfo)
937	993	{
938		- struct xfs_mount *mp = cur->bc_mp;
939		- struct xfs_rmap_irec r[4]; /* neighbor extent entries */
940		- /* left is 0, right is 1, prev is 2 */
941		- /* new is 3 */
	994	+ struct xfs_mount *mp = cur->bc_mp;
	995	+ struct xfs_rmap_irec r[4]; /* neighbor extent entries */
	996	+ /* left is 0, right is 1, */
	997	+ /* prev is 2, new is 3 */
942	998	uint64_t owner;
943	999	uint64_t offset;
944	1000	uint64_t new_endoff;
..	..	@@ -954,7 +1010,7 @@
954	1010	(flags & (XFS_RMAP_ATTR_FORK \| XFS_RMAP_BMBT_BLOCK))));
955	1011	oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
956	1012	new_endoff = offset + len;
957		- trace_xfs_rmap_convert(mp, cur->bc_private.a.agno, bno, len,
	1013	+ trace_xfs_rmap_convert(mp, cur->bc_ag.agno, bno, len,
958	1014	unwritten, oinfo);
959	1015
960	1016	/*
..	..	@@ -965,14 +1021,20 @@
965	1021	error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, oldext, &i);
966	1022	if (error)
967	1023	goto done;
968		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1024	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1025	+ error = -EFSCORRUPTED;
	1026	+ goto done;
	1027	+ }
969	1028
970	1029	error = xfs_rmap_get_rec(cur, &PREV, &i);
971	1030	if (error)
972	1031	goto done;
973		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1032	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1033	+ error = -EFSCORRUPTED;
	1034	+ goto done;
	1035	+ }
974	1036	trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
975		- cur->bc_private.a.agno, PREV.rm_startblock,
	1037	+ cur->bc_ag.agno, PREV.rm_startblock,
976	1038	PREV.rm_blockcount, PREV.rm_owner,
977	1039	PREV.rm_offset, PREV.rm_flags);
978	1040
..	..	@@ -1003,12 +1065,18 @@
1003	1065	error = xfs_rmap_get_rec(cur, &LEFT, &i);
1004	1066	if (error)
1005	1067	goto done;
1006		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1007		- XFS_WANT_CORRUPTED_GOTO(mp,
1008		- LEFT.rm_startblock + LEFT.rm_blockcount <= bno,
1009		- done);
	1068	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1069	+ error = -EFSCORRUPTED;
	1070	+ goto done;
	1071	+ }
	1072	+ if (XFS_IS_CORRUPT(mp,
	1073	+ LEFT.rm_startblock + LEFT.rm_blockcount >
	1074	+ bno)) {
	1075	+ error = -EFSCORRUPTED;
	1076	+ goto done;
	1077	+ }
1010	1078	trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
1011		- cur->bc_private.a.agno, LEFT.rm_startblock,
	1079	+ cur->bc_ag.agno, LEFT.rm_startblock,
1012	1080	LEFT.rm_blockcount, LEFT.rm_owner,
1013	1081	LEFT.rm_offset, LEFT.rm_flags);
1014	1082	if (LEFT.rm_startblock + LEFT.rm_blockcount == bno &&
..	..	@@ -1025,7 +1093,10 @@
1025	1093	error = xfs_btree_increment(cur, 0, &i);
1026	1094	if (error)
1027	1095	goto done;
1028		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1096	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1097	+ error = -EFSCORRUPTED;
	1098	+ goto done;
	1099	+ }
1029	1100	error = xfs_btree_increment(cur, 0, &i);
1030	1101	if (error)
1031	1102	goto done;
..	..	@@ -1034,11 +1105,16 @@
1034	1105	error = xfs_rmap_get_rec(cur, &RIGHT, &i);
1035	1106	if (error)
1036	1107	goto done;
1037		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1038		- XFS_WANT_CORRUPTED_GOTO(mp, bno + len <= RIGHT.rm_startblock,
1039		- done);
	1108	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1109	+ error = -EFSCORRUPTED;
	1110	+ goto done;
	1111	+ }
	1112	+ if (XFS_IS_CORRUPT(mp, bno + len > RIGHT.rm_startblock)) {
	1113	+ error = -EFSCORRUPTED;
	1114	+ goto done;
	1115	+ }
1040	1116	trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
1041		- cur->bc_private.a.agno, RIGHT.rm_startblock,
	1117	+ cur->bc_ag.agno, RIGHT.rm_startblock,
1042	1118	RIGHT.rm_blockcount, RIGHT.rm_owner,
1043	1119	RIGHT.rm_offset, RIGHT.rm_flags);
1044	1120	if (bno + len == RIGHT.rm_startblock &&
..	..	@@ -1056,14 +1132,17 @@
1056	1132	RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)
1057	1133	state &= ~RMAP_RIGHT_CONTIG;
1058	1134
1059		- trace_xfs_rmap_convert_state(mp, cur->bc_private.a.agno, state,
	1135	+ trace_xfs_rmap_convert_state(mp, cur->bc_ag.agno, state,
1060	1136	_RET_IP_);
1061	1137
1062	1138	/* reset the cursor back to PREV */
1063	1139	error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, oldext, &i);
1064	1140	if (error)
1065	1141	goto done;
1066		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1142	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1143	+ error = -EFSCORRUPTED;
	1144	+ goto done;
	1145	+ }
1067	1146
1068	1147	/*
1069	1148	* Switch out based on the FILLING and CONTIG state bits.
..	..	@@ -1079,31 +1158,46 @@
1079	1158	error = xfs_btree_increment(cur, 0, &i);
1080	1159	if (error)
1081	1160	goto done;
1082		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1083		- trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
	1161	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1162	+ error = -EFSCORRUPTED;
	1163	+ goto done;
	1164	+ }
	1165	+ trace_xfs_rmap_delete(mp, cur->bc_ag.agno,
1084	1166	RIGHT.rm_startblock, RIGHT.rm_blockcount,
1085	1167	RIGHT.rm_owner, RIGHT.rm_offset,
1086	1168	RIGHT.rm_flags);
1087	1169	error = xfs_btree_delete(cur, &i);
1088	1170	if (error)
1089	1171	goto done;
1090		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1172	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1173	+ error = -EFSCORRUPTED;
	1174	+ goto done;
	1175	+ }
1091	1176	error = xfs_btree_decrement(cur, 0, &i);
1092	1177	if (error)
1093	1178	goto done;
1094		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1095		- trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
	1179	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1180	+ error = -EFSCORRUPTED;
	1181	+ goto done;
	1182	+ }
	1183	+ trace_xfs_rmap_delete(mp, cur->bc_ag.agno,
1096	1184	PREV.rm_startblock, PREV.rm_blockcount,
1097	1185	PREV.rm_owner, PREV.rm_offset,
1098	1186	PREV.rm_flags);
1099	1187	error = xfs_btree_delete(cur, &i);
1100	1188	if (error)
1101	1189	goto done;
1102		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1190	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1191	+ error = -EFSCORRUPTED;
	1192	+ goto done;
	1193	+ }
1103	1194	error = xfs_btree_decrement(cur, 0, &i);
1104	1195	if (error)
1105	1196	goto done;
1106		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1197	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1198	+ error = -EFSCORRUPTED;
	1199	+ goto done;
	1200	+ }
1107	1201	NEW = LEFT;
1108	1202	NEW.rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;
1109	1203	error = xfs_rmap_update(cur, &NEW);
..	..	@@ -1116,18 +1210,24 @@
1116	1210	* Setting all of a previous oldext extent to newext.
1117	1211	* The left neighbor is contiguous, the right is not.
1118	1212	*/
1119		- trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
	1213	+ trace_xfs_rmap_delete(mp, cur->bc_ag.agno,
1120	1214	PREV.rm_startblock, PREV.rm_blockcount,
1121	1215	PREV.rm_owner, PREV.rm_offset,
1122	1216	PREV.rm_flags);
1123	1217	error = xfs_btree_delete(cur, &i);
1124	1218	if (error)
1125	1219	goto done;
1126		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1220	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1221	+ error = -EFSCORRUPTED;
	1222	+ goto done;
	1223	+ }
1127	1224	error = xfs_btree_decrement(cur, 0, &i);
1128	1225	if (error)
1129	1226	goto done;
1130		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1227	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1228	+ error = -EFSCORRUPTED;
	1229	+ goto done;
	1230	+ }
1131	1231	NEW = LEFT;
1132	1232	NEW.rm_blockcount += PREV.rm_blockcount;
1133	1233	error = xfs_rmap_update(cur, &NEW);
..	..	@@ -1143,19 +1243,28 @@
1143	1243	error = xfs_btree_increment(cur, 0, &i);
1144	1244	if (error)
1145	1245	goto done;
1146		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1147		- trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
	1246	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1247	+ error = -EFSCORRUPTED;
	1248	+ goto done;
	1249	+ }
	1250	+ trace_xfs_rmap_delete(mp, cur->bc_ag.agno,
1148	1251	RIGHT.rm_startblock, RIGHT.rm_blockcount,
1149	1252	RIGHT.rm_owner, RIGHT.rm_offset,
1150	1253	RIGHT.rm_flags);
1151	1254	error = xfs_btree_delete(cur, &i);
1152	1255	if (error)
1153	1256	goto done;
1154		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1257	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1258	+ error = -EFSCORRUPTED;
	1259	+ goto done;
	1260	+ }
1155	1261	error = xfs_btree_decrement(cur, 0, &i);
1156	1262	if (error)
1157	1263	goto done;
1158		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1264	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1265	+ error = -EFSCORRUPTED;
	1266	+ goto done;
	1267	+ }
1159	1268	NEW = PREV;
1160	1269	NEW.rm_blockcount = len + RIGHT.rm_blockcount;
1161	1270	NEW.rm_flags = newext;
..	..	@@ -1217,12 +1326,15 @@
1217	1326	NEW.rm_blockcount = len;
1218	1327	NEW.rm_flags = newext;
1219	1328	cur->bc_rec.r = NEW;
1220		- trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno,
	1329	+ trace_xfs_rmap_insert(mp, cur->bc_ag.agno, bno,
1221	1330	len, owner, offset, newext);
1222	1331	error = xfs_btree_insert(cur, &i);
1223	1332	if (error)
1224	1333	goto done;
1225		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1334	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1335	+ error = -EFSCORRUPTED;
	1336	+ goto done;
	1337	+ }
1226	1338	break;
1227	1339
1228	1340	case RMAP_RIGHT_FILLING \| RMAP_RIGHT_CONTIG:
..	..	@@ -1261,19 +1373,25 @@
1261	1373	oldext, &i);
1262	1374	if (error)
1263	1375	goto done;
1264		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	1376	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	1377	+ error = -EFSCORRUPTED;
	1378	+ goto done;
	1379	+ }
1265	1380	NEW.rm_startblock = bno;
1266	1381	NEW.rm_owner = owner;
1267	1382	NEW.rm_offset = offset;
1268	1383	NEW.rm_blockcount = len;
1269	1384	NEW.rm_flags = newext;
1270	1385	cur->bc_rec.r = NEW;
1271		- trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno,
	1386	+ trace_xfs_rmap_insert(mp, cur->bc_ag.agno, bno,
1272	1387	len, owner, offset, newext);
1273	1388	error = xfs_btree_insert(cur, &i);
1274	1389	if (error)
1275	1390	goto done;
1276		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1391	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1392	+ error = -EFSCORRUPTED;
	1393	+ goto done;
	1394	+ }
1277	1395	break;
1278	1396
1279	1397	case 0:
..	..	@@ -1296,14 +1414,17 @@
1296	1414	NEW = PREV;
1297	1415	NEW.rm_blockcount = offset - PREV.rm_offset;
1298	1416	cur->bc_rec.r = NEW;
1299		- trace_xfs_rmap_insert(mp, cur->bc_private.a.agno,
	1417	+ trace_xfs_rmap_insert(mp, cur->bc_ag.agno,
1300	1418	NEW.rm_startblock, NEW.rm_blockcount,
1301	1419	NEW.rm_owner, NEW.rm_offset,
1302	1420	NEW.rm_flags);
1303	1421	error = xfs_btree_insert(cur, &i);
1304	1422	if (error)
1305	1423	goto done;
1306		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1424	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1425	+ error = -EFSCORRUPTED;
	1426	+ goto done;
	1427	+ }
1307	1428	/*
1308	1429	* Reset the cursor to the position of the new extent
1309	1430	* we are about to insert as we can't trust it after
..	..	@@ -1313,16 +1434,22 @@
1313	1434	oldext, &i);
1314	1435	if (error)
1315	1436	goto done;
1316		- XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
	1437	+ if (XFS_IS_CORRUPT(mp, i != 0)) {
	1438	+ error = -EFSCORRUPTED;
	1439	+ goto done;
	1440	+ }
1317	1441	/* new middle extent - newext */
1318	1442	cur->bc_rec.r.rm_flags &= ~XFS_RMAP_UNWRITTEN;
1319	1443	cur->bc_rec.r.rm_flags \|= newext;
1320		- trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno, len,
	1444	+ trace_xfs_rmap_insert(mp, cur->bc_ag.agno, bno, len,
1321	1445	owner, offset, newext);
1322	1446	error = xfs_btree_insert(cur, &i);
1323	1447	if (error)
1324	1448	goto done;
1325		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1449	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1450	+ error = -EFSCORRUPTED;
	1451	+ goto done;
	1452	+ }
1326	1453	break;
1327	1454
1328	1455	case RMAP_LEFT_FILLING \| RMAP_LEFT_CONTIG \| RMAP_RIGHT_CONTIG:
..	..	@@ -1338,12 +1465,12 @@
1338	1465	ASSERT(0);
1339	1466	}
1340	1467
1341		- trace_xfs_rmap_convert_done(mp, cur->bc_private.a.agno, bno, len,
	1468	+ trace_xfs_rmap_convert_done(mp, cur->bc_ag.agno, bno, len,
1342	1469	unwritten, oinfo);
1343	1470	done:
1344	1471	if (error)
1345	1472	trace_xfs_rmap_convert_error(cur->bc_mp,
1346		- cur->bc_private.a.agno, error, _RET_IP_);
	1473	+ cur->bc_ag.agno, error, _RET_IP_);
1347	1474	return error;
1348	1475	}
1349	1476
..	..	@@ -1354,16 +1481,16 @@
1354	1481	*/
1355	1482	STATIC int
1356	1483	xfs_rmap_convert_shared(
1357		- struct xfs_btree_cur *cur,
1358		- xfs_agblock_t bno,
1359		- xfs_extlen_t len,
1360		- bool unwritten,
1361		- struct xfs_owner_info *oinfo)
	1484	+ struct xfs_btree_cur *cur,
	1485	+ xfs_agblock_t bno,
	1486	+ xfs_extlen_t len,
	1487	+ bool unwritten,
	1488	+ const struct xfs_owner_info *oinfo)
1362	1489	{
1363		- struct xfs_mount *mp = cur->bc_mp;
1364		- struct xfs_rmap_irec r[4]; /* neighbor extent entries */
1365		- /* left is 0, right is 1, prev is 2 */
1366		- /* new is 3 */
	1490	+ struct xfs_mount *mp = cur->bc_mp;
	1491	+ struct xfs_rmap_irec r[4]; /* neighbor extent entries */
	1492	+ /* left is 0, right is 1, */
	1493	+ /* prev is 2, new is 3 */
1367	1494	uint64_t owner;
1368	1495	uint64_t offset;
1369	1496	uint64_t new_endoff;
..	..	@@ -1379,7 +1506,7 @@
1379	1506	(flags & (XFS_RMAP_ATTR_FORK \| XFS_RMAP_BMBT_BLOCK))));
1380	1507	oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
1381	1508	new_endoff = offset + len;
1382		- trace_xfs_rmap_convert(mp, cur->bc_private.a.agno, bno, len,
	1509	+ trace_xfs_rmap_convert(mp, cur->bc_ag.agno, bno, len,
1383	1510	unwritten, oinfo);
1384	1511
1385	1512	/*
..	..	@@ -1391,7 +1518,10 @@
1391	1518	&PREV, &i);
1392	1519	if (error)
1393	1520	goto done;
1394		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1521	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1522	+ error = -EFSCORRUPTED;
	1523	+ goto done;
	1524	+ }
1395	1525
1396	1526	ASSERT(PREV.rm_offset <= offset);
1397	1527	ASSERT(PREV.rm_offset + PREV.rm_blockcount >= new_endoff);
..	..	@@ -1414,9 +1544,12 @@
1414	1544	goto done;
1415	1545	if (i) {
1416	1546	state \|= RMAP_LEFT_VALID;
1417		- XFS_WANT_CORRUPTED_GOTO(mp,
1418		- LEFT.rm_startblock + LEFT.rm_blockcount <= bno,
1419		- done);
	1547	+ if (XFS_IS_CORRUPT(mp,
	1548	+ LEFT.rm_startblock + LEFT.rm_blockcount >
	1549	+ bno)) {
	1550	+ error = -EFSCORRUPTED;
	1551	+ goto done;
	1552	+ }
1420	1553	if (xfs_rmap_is_mergeable(&LEFT, owner, newext))
1421	1554	state \|= RMAP_LEFT_CONTIG;
1422	1555	}
..	..	@@ -1431,11 +1564,16 @@
1431	1564	error = xfs_rmap_get_rec(cur, &RIGHT, &i);
1432	1565	if (error)
1433	1566	goto done;
1434		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1435		- XFS_WANT_CORRUPTED_GOTO(mp, bno + len <= RIGHT.rm_startblock,
1436		- done);
	1567	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1568	+ error = -EFSCORRUPTED;
	1569	+ goto done;
	1570	+ }
	1571	+ if (XFS_IS_CORRUPT(mp, bno + len > RIGHT.rm_startblock)) {
	1572	+ error = -EFSCORRUPTED;
	1573	+ goto done;
	1574	+ }
1437	1575	trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
1438		- cur->bc_private.a.agno, RIGHT.rm_startblock,
	1576	+ cur->bc_ag.agno, RIGHT.rm_startblock,
1439	1577	RIGHT.rm_blockcount, RIGHT.rm_owner,
1440	1578	RIGHT.rm_offset, RIGHT.rm_flags);
1441	1579	if (xfs_rmap_is_mergeable(&RIGHT, owner, newext))
..	..	@@ -1451,7 +1589,7 @@
1451	1589	RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)
1452	1590	state &= ~RMAP_RIGHT_CONTIG;
1453	1591
1454		- trace_xfs_rmap_convert_state(mp, cur->bc_private.a.agno, state,
	1592	+ trace_xfs_rmap_convert_state(mp, cur->bc_ag.agno, state,
1455	1593	_RET_IP_);
1456	1594	/*
1457	1595	* Switch out based on the FILLING and CONTIG state bits.
..	..	@@ -1480,7 +1618,10 @@
1480	1618	NEW.rm_offset, NEW.rm_flags, &i);
1481	1619	if (error)
1482	1620	goto done;
1483		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1621	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1622	+ error = -EFSCORRUPTED;
	1623	+ goto done;
	1624	+ }
1484	1625	NEW.rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;
1485	1626	error = xfs_rmap_update(cur, &NEW);
1486	1627	if (error)
..	..	@@ -1503,7 +1644,10 @@
1503	1644	NEW.rm_offset, NEW.rm_flags, &i);
1504	1645	if (error)
1505	1646	goto done;
1506		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1647	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1648	+ error = -EFSCORRUPTED;
	1649	+ goto done;
	1650	+ }
1507	1651	NEW.rm_blockcount += PREV.rm_blockcount;
1508	1652	error = xfs_rmap_update(cur, &NEW);
1509	1653	if (error)
..	..	@@ -1526,7 +1670,10 @@
1526	1670	NEW.rm_offset, NEW.rm_flags, &i);
1527	1671	if (error)
1528	1672	goto done;
1529		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1673	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1674	+ error = -EFSCORRUPTED;
	1675	+ goto done;
	1676	+ }
1530	1677	NEW.rm_blockcount += RIGHT.rm_blockcount;
1531	1678	NEW.rm_flags = RIGHT.rm_flags;
1532	1679	error = xfs_rmap_update(cur, &NEW);
..	..	@@ -1546,7 +1693,10 @@
1546	1693	NEW.rm_offset, NEW.rm_flags, &i);
1547	1694	if (error)
1548	1695	goto done;
1549		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1696	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1697	+ error = -EFSCORRUPTED;
	1698	+ goto done;
	1699	+ }
1550	1700	NEW.rm_flags = newext;
1551	1701	error = xfs_rmap_update(cur, &NEW);
1552	1702	if (error)
..	..	@@ -1578,7 +1728,10 @@
1578	1728	NEW.rm_offset, NEW.rm_flags, &i);
1579	1729	if (error)
1580	1730	goto done;
1581		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1731	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1732	+ error = -EFSCORRUPTED;
	1733	+ goto done;
	1734	+ }
1582	1735	NEW.rm_blockcount += len;
1583	1736	error = xfs_rmap_update(cur, &NEW);
1584	1737	if (error)
..	..	@@ -1620,7 +1773,10 @@
1620	1773	NEW.rm_offset, NEW.rm_flags, &i);
1621	1774	if (error)
1622	1775	goto done;
1623		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1776	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1777	+ error = -EFSCORRUPTED;
	1778	+ goto done;
	1779	+ }
1624	1780	NEW.rm_blockcount = offset - NEW.rm_offset;
1625	1781	error = xfs_rmap_update(cur, &NEW);
1626	1782	if (error)
..	..	@@ -1652,7 +1808,10 @@
1652	1808	NEW.rm_offset, NEW.rm_flags, &i);
1653	1809	if (error)
1654	1810	goto done;
1655		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1811	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1812	+ error = -EFSCORRUPTED;
	1813	+ goto done;
	1814	+ }
1656	1815	NEW.rm_blockcount -= len;
1657	1816	error = xfs_rmap_update(cur, &NEW);
1658	1817	if (error)
..	..	@@ -1687,7 +1846,10 @@
1687	1846	NEW.rm_offset, NEW.rm_flags, &i);
1688	1847	if (error)
1689	1848	goto done;
1690		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
	1849	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1850	+ error = -EFSCORRUPTED;
	1851	+ goto done;
	1852	+ }
1691	1853	NEW.rm_blockcount = offset - NEW.rm_offset;
1692	1854	error = xfs_rmap_update(cur, &NEW);
1693	1855	if (error)
..	..	@@ -1718,12 +1880,12 @@
1718	1880	ASSERT(0);
1719	1881	}
1720	1882
1721		- trace_xfs_rmap_convert_done(mp, cur->bc_private.a.agno, bno, len,
	1883	+ trace_xfs_rmap_convert_done(mp, cur->bc_ag.agno, bno, len,
1722	1884	unwritten, oinfo);
1723	1885	done:
1724	1886	if (error)
1725	1887	trace_xfs_rmap_convert_error(cur->bc_mp,
1726		- cur->bc_private.a.agno, error, _RET_IP_);
	1888	+ cur->bc_ag.agno, error, _RET_IP_);
1727	1889	return error;
1728	1890	}
1729	1891
..	..	@@ -1743,25 +1905,25 @@
1743	1905	*/
1744	1906	STATIC int
1745	1907	xfs_rmap_unmap_shared(
1746		- struct xfs_btree_cur *cur,
1747		- xfs_agblock_t bno,
1748		- xfs_extlen_t len,
1749		- bool unwritten,
1750		- struct xfs_owner_info *oinfo)
	1908	+ struct xfs_btree_cur *cur,
	1909	+ xfs_agblock_t bno,
	1910	+ xfs_extlen_t len,
	1911	+ bool unwritten,
	1912	+ const struct xfs_owner_info *oinfo)
1751	1913	{
1752		- struct xfs_mount *mp = cur->bc_mp;
1753		- struct xfs_rmap_irec ltrec;
1754		- uint64_t ltoff;
1755		- int error = 0;
1756		- int i;
1757		- uint64_t owner;
1758		- uint64_t offset;
1759		- unsigned int flags;
	1914	+ struct xfs_mount *mp = cur->bc_mp;
	1915	+ struct xfs_rmap_irec ltrec;
	1916	+ uint64_t ltoff;
	1917	+ int error = 0;
	1918	+ int i;
	1919	+ uint64_t owner;
	1920	+ uint64_t offset;
	1921	+ unsigned int flags;
1760	1922
1761	1923	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
1762	1924	if (unwritten)
1763	1925	flags \|= XFS_RMAP_UNWRITTEN;
1764		- trace_xfs_rmap_unmap(mp, cur->bc_private.a.agno, bno, len,
	1926	+ trace_xfs_rmap_unmap(mp, cur->bc_ag.agno, bno, len,
1765	1927	unwritten, oinfo);
1766	1928
1767	1929	/*
..	..	@@ -1773,25 +1935,44 @@
1773	1935	&ltrec, &i);
1774	1936	if (error)
1775	1937	goto out_error;
1776		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	1938	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	1939	+ error = -EFSCORRUPTED;
	1940	+ goto out_error;
	1941	+ }
1777	1942	ltoff = ltrec.rm_offset;
1778	1943
1779	1944	/* Make sure the extent we found covers the entire freeing range. */
1780		- XFS_WANT_CORRUPTED_GOTO(mp, ltrec.rm_startblock <= bno &&
1781		- ltrec.rm_startblock + ltrec.rm_blockcount >=
1782		- bno + len, out_error);
	1945	+ if (XFS_IS_CORRUPT(mp,
	1946	+ ltrec.rm_startblock > bno \|\|
	1947	+ ltrec.rm_startblock + ltrec.rm_blockcount <
	1948	+ bno + len)) {
	1949	+ error = -EFSCORRUPTED;
	1950	+ goto out_error;
	1951	+ }
1783	1952
1784	1953	/* Make sure the owner matches what we expect to find in the tree. */
1785		- XFS_WANT_CORRUPTED_GOTO(mp, owner == ltrec.rm_owner, out_error);
	1954	+ if (XFS_IS_CORRUPT(mp, owner != ltrec.rm_owner)) {
	1955	+ error = -EFSCORRUPTED;
	1956	+ goto out_error;
	1957	+ }
1786	1958
1787	1959	/* Make sure the unwritten flag matches. */
1788		- XFS_WANT_CORRUPTED_GOTO(mp, (flags & XFS_RMAP_UNWRITTEN) ==
1789		- (ltrec.rm_flags & XFS_RMAP_UNWRITTEN), out_error);
	1960	+ if (XFS_IS_CORRUPT(mp,
	1961	+ (flags & XFS_RMAP_UNWRITTEN) !=
	1962	+ (ltrec.rm_flags & XFS_RMAP_UNWRITTEN))) {
	1963	+ error = -EFSCORRUPTED;
	1964	+ goto out_error;
	1965	+ }
1790	1966
1791	1967	/* Check the offset. */
1792		- XFS_WANT_CORRUPTED_GOTO(mp, ltrec.rm_offset <= offset, out_error);
1793		- XFS_WANT_CORRUPTED_GOTO(mp, offset <= ltoff + ltrec.rm_blockcount,
1794		- out_error);
	1968	+ if (XFS_IS_CORRUPT(mp, ltrec.rm_offset > offset)) {
	1969	+ error = -EFSCORRUPTED;
	1970	+ goto out_error;
	1971	+ }
	1972	+ if (XFS_IS_CORRUPT(mp, offset > ltoff + ltrec.rm_blockcount)) {
	1973	+ error = -EFSCORRUPTED;
	1974	+ goto out_error;
	1975	+ }
1795	1976
1796	1977	if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {
1797	1978	/* Exact match, simply remove the record from rmap tree. */
..	..	@@ -1844,7 +2025,10 @@
1844	2025	ltrec.rm_offset, ltrec.rm_flags, &i);
1845	2026	if (error)
1846	2027	goto out_error;
1847		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	2028	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2029	+ error = -EFSCORRUPTED;
	2030	+ goto out_error;
	2031	+ }
1848	2032	ltrec.rm_blockcount -= len;
1849	2033	error = xfs_rmap_update(cur, &ltrec);
1850	2034	if (error)
..	..	@@ -1870,7 +2054,10 @@
1870	2054	ltrec.rm_offset, ltrec.rm_flags, &i);
1871	2055	if (error)
1872	2056	goto out_error;
1873		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	2057	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2058	+ error = -EFSCORRUPTED;
	2059	+ goto out_error;
	2060	+ }
1874	2061	ltrec.rm_blockcount = bno - ltrec.rm_startblock;
1875	2062	error = xfs_rmap_update(cur, &ltrec);
1876	2063	if (error)
..	..	@@ -1885,12 +2072,12 @@
1885	2072	goto out_error;
1886	2073	}
1887	2074
1888		- trace_xfs_rmap_unmap_done(mp, cur->bc_private.a.agno, bno, len,
	2075	+ trace_xfs_rmap_unmap_done(mp, cur->bc_ag.agno, bno, len,
1889	2076	unwritten, oinfo);
1890	2077	out_error:
1891	2078	if (error)
1892	2079	trace_xfs_rmap_unmap_error(cur->bc_mp,
1893		- cur->bc_private.a.agno, error, _RET_IP_);
	2080	+ cur->bc_ag.agno, error, _RET_IP_);
1894	2081	return error;
1895	2082	}
1896	2083
..	..	@@ -1905,27 +2092,27 @@
1905	2092	*/
1906	2093	STATIC int
1907	2094	xfs_rmap_map_shared(
1908		- struct xfs_btree_cur *cur,
1909		- xfs_agblock_t bno,
1910		- xfs_extlen_t len,
1911		- bool unwritten,
1912		- struct xfs_owner_info *oinfo)
	2095	+ struct xfs_btree_cur *cur,
	2096	+ xfs_agblock_t bno,
	2097	+ xfs_extlen_t len,
	2098	+ bool unwritten,
	2099	+ const struct xfs_owner_info *oinfo)
1913	2100	{
1914		- struct xfs_mount *mp = cur->bc_mp;
1915		- struct xfs_rmap_irec ltrec;
1916		- struct xfs_rmap_irec gtrec;
1917		- int have_gt;
1918		- int have_lt;
1919		- int error = 0;
1920		- int i;
1921		- uint64_t owner;
1922		- uint64_t offset;
1923		- unsigned int flags = 0;
	2101	+ struct xfs_mount *mp = cur->bc_mp;
	2102	+ struct xfs_rmap_irec ltrec;
	2103	+ struct xfs_rmap_irec gtrec;
	2104	+ int have_gt;
	2105	+ int have_lt;
	2106	+ int error = 0;
	2107	+ int i;
	2108	+ uint64_t owner;
	2109	+ uint64_t offset;
	2110	+ unsigned int flags = 0;
1924	2111
1925	2112	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
1926	2113	if (unwritten)
1927	2114	flags \|= XFS_RMAP_UNWRITTEN;
1928		- trace_xfs_rmap_map(mp, cur->bc_private.a.agno, bno, len,
	2115	+ trace_xfs_rmap_map(mp, cur->bc_ag.agno, bno, len,
1929	2116	unwritten, oinfo);
1930	2117
1931	2118	/* Is there a left record that abuts our range? */
..	..	@@ -1946,9 +2133,12 @@
1946	2133	error = xfs_rmap_get_rec(cur, &gtrec, &have_gt);
1947	2134	if (error)
1948	2135	goto out_error;
1949		- XFS_WANT_CORRUPTED_GOTO(mp, have_gt == 1, out_error);
	2136	+ if (XFS_IS_CORRUPT(mp, have_gt != 1)) {
	2137	+ error = -EFSCORRUPTED;
	2138	+ goto out_error;
	2139	+ }
1950	2140	trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
1951		- cur->bc_private.a.agno, gtrec.rm_startblock,
	2141	+ cur->bc_ag.agno, gtrec.rm_startblock,
1952	2142	gtrec.rm_blockcount, gtrec.rm_owner,
1953	2143	gtrec.rm_offset, gtrec.rm_flags);
1954	2144
..	..	@@ -1995,7 +2185,10 @@
1995	2185	ltrec.rm_offset, ltrec.rm_flags, &i);
1996	2186	if (error)
1997	2187	goto out_error;
1998		- XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
	2188	+ if (XFS_IS_CORRUPT(mp, i != 1)) {
	2189	+ error = -EFSCORRUPTED;
	2190	+ goto out_error;
	2191	+ }
1999	2192
2000	2193	error = xfs_rmap_update(cur, &ltrec);
2001	2194	if (error)
..	..	@@ -2038,12 +2231,12 @@
2038	2231	goto out_error;
2039	2232	}
2040	2233
2041		- trace_xfs_rmap_map_done(mp, cur->bc_private.a.agno, bno, len,
	2234	+ trace_xfs_rmap_map_done(mp, cur->bc_ag.agno, bno, len,
2042	2235	unwritten, oinfo);
2043	2236	out_error:
2044	2237	if (error)
2045	2238	trace_xfs_rmap_map_error(cur->bc_mp,
2046		- cur->bc_private.a.agno, error, _RET_IP_);
	2239	+ cur->bc_ag.agno, error, _RET_IP_);
2047	2240	return error;
2048	2241	}
2049	2242
..	..	@@ -2143,7 +2336,7 @@
2143	2336
2144	2337	if (rcur == NULL)
2145	2338	return;
2146		- agbp = rcur->bc_private.a.agbp;
	2339	+ agbp = rcur->bc_ag.agbp;
2147	2340	xfs_btree_del_cursor(rcur, error);
2148	2341	if (error)
2149	2342	xfs_trans_brelse(tp, agbp);
..	..	@@ -2193,7 +2386,7 @@
2193	2386	* the startblock, get one now.
2194	2387	*/
2195	2388	rcur = *pcur;
2196		- if (rcur != NULL && rcur->bc_private.a.agno != agno) {
	2389	+ if (rcur != NULL && rcur->bc_ag.agno != agno) {
2197	2390	xfs_rmap_finish_one_cleanup(tp, rcur, 0);
2198	2391	rcur = NULL;
2199	2392	*pcur = NULL;
..	..	@@ -2207,7 +2400,7 @@
2207	2400	error = xfs_free_extent_fix_freelist(tp, agno, &agbp);
2208	2401	if (error)
2209	2402	return error;
2210		- if (!agbp)
	2403	+ if (XFS_IS_CORRUPT(tp->t_mountp, !agbp))
2211	2404	return -EFSCORRUPTED;
2212	2405
2213	2406	rcur = xfs_rmapbt_init_cursor(mp, tp, agbp, agno);
..	..	@@ -2275,7 +2468,7 @@
2275	2468	* Record a rmap intent; the list is kept sorted first by AG and then by
2276	2469	* increasing age.
2277	2470	*/
2278		-static int
	2471	+static void
2279	2472	__xfs_rmap_add(
2280	2473	struct xfs_trans *tp,
2281	2474	enum xfs_rmap_intent_type type,
..	..	@@ -2294,7 +2487,7 @@
2294	2487	bmap->br_blockcount,
2295	2488	bmap->br_state);
2296	2489
2297		- ri = kmem_alloc(sizeof(struct xfs_rmap_intent), KM_SLEEP \| KM_NOFS);
	2490	+ ri = kmem_alloc(sizeof(struct xfs_rmap_intent), KM_NOFS);
2298	2491	INIT_LIST_HEAD(&ri->ri_list);
2299	2492	ri->ri_type = type;
2300	2493	ri->ri_owner = owner;
..	..	@@ -2302,39 +2495,44 @@
2302	2495	ri->ri_bmap = *bmap;
2303	2496
2304	2497	xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_RMAP, &ri->ri_list);
2305		- return 0;
2306	2498	}
2307	2499
2308	2500	/* Map an extent into a file. */
2309		-int
	2501	+void
2310	2502	xfs_rmap_map_extent(
2311	2503	struct xfs_trans *tp,
2312	2504	struct xfs_inode *ip,
2313	2505	int whichfork,
2314	2506	struct xfs_bmbt_irec *PREV)
2315	2507	{
2316		- if (!xfs_rmap_update_is_needed(tp->t_mountp, whichfork))
2317		- return 0;
	2508	+ enum xfs_rmap_intent_type type = XFS_RMAP_MAP;
2318	2509
2319		- return __xfs_rmap_add(tp, xfs_is_reflink_inode(ip) ?
2320		- XFS_RMAP_MAP_SHARED : XFS_RMAP_MAP, ip->i_ino,
2321		- whichfork, PREV);
	2510	+ if (!xfs_rmap_update_is_needed(tp->t_mountp, whichfork))
	2511	+ return;
	2512	+
	2513	+ if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))
	2514	+ type = XFS_RMAP_MAP_SHARED;
	2515	+
	2516	+ __xfs_rmap_add(tp, type, ip->i_ino, whichfork, PREV);
2322	2517	}
2323	2518
2324	2519	/* Unmap an extent out of a file. */
2325		-int
	2520	+void
2326	2521	xfs_rmap_unmap_extent(
2327	2522	struct xfs_trans *tp,
2328	2523	struct xfs_inode *ip,
2329	2524	int whichfork,
2330	2525	struct xfs_bmbt_irec *PREV)
2331	2526	{
2332		- if (!xfs_rmap_update_is_needed(tp->t_mountp, whichfork))
2333		- return 0;
	2527	+ enum xfs_rmap_intent_type type = XFS_RMAP_UNMAP;
2334	2528
2335		- return __xfs_rmap_add(tp, xfs_is_reflink_inode(ip) ?
2336		- XFS_RMAP_UNMAP_SHARED : XFS_RMAP_UNMAP, ip->i_ino,
2337		- whichfork, PREV);
	2529	+ if (!xfs_rmap_update_is_needed(tp->t_mountp, whichfork))
	2530	+ return;
	2531	+
	2532	+ if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))
	2533	+ type = XFS_RMAP_UNMAP_SHARED;
	2534	+
	2535	+ __xfs_rmap_add(tp, type, ip->i_ino, whichfork, PREV);
2338	2536	}
2339	2537
2340	2538	/*
..	..	@@ -2343,7 +2541,7 @@
2343	2541	* Note that tp can be NULL here as no transaction is used for COW fork
2344	2542	* unwritten conversion.
2345	2543	*/
2346		-int
	2544	+void
2347	2545	xfs_rmap_convert_extent(
2348	2546	struct xfs_mount *mp,
2349	2547	struct xfs_trans *tp,
..	..	@@ -2351,16 +2549,19 @@
2351	2549	int whichfork,
2352	2550	struct xfs_bmbt_irec *PREV)
2353	2551	{
2354		- if (!xfs_rmap_update_is_needed(mp, whichfork))
2355		- return 0;
	2552	+ enum xfs_rmap_intent_type type = XFS_RMAP_CONVERT;
2356	2553
2357		- return __xfs_rmap_add(tp, xfs_is_reflink_inode(ip) ?
2358		- XFS_RMAP_CONVERT_SHARED : XFS_RMAP_CONVERT, ip->i_ino,
2359		- whichfork, PREV);
	2554	+ if (!xfs_rmap_update_is_needed(mp, whichfork))
	2555	+ return;
	2556	+
	2557	+ if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))
	2558	+ type = XFS_RMAP_CONVERT_SHARED;
	2559	+
	2560	+ __xfs_rmap_add(tp, type, ip->i_ino, whichfork, PREV);
2360	2561	}
2361	2562
2362	2563	/* Schedule the creation of an rmap for non-file data. */
2363		-int
	2564	+void
2364	2565	xfs_rmap_alloc_extent(
2365	2566	struct xfs_trans *tp,
2366	2567	xfs_agnumber_t agno,
..	..	@@ -2371,18 +2572,18 @@
2371	2572	struct xfs_bmbt_irec bmap;
2372	2573
2373	2574	if (!xfs_rmap_update_is_needed(tp->t_mountp, XFS_DATA_FORK))
2374		- return 0;
	2575	+ return;
2375	2576
2376	2577	bmap.br_startblock = XFS_AGB_TO_FSB(tp->t_mountp, agno, bno);
2377	2578	bmap.br_blockcount = len;
2378	2579	bmap.br_startoff = 0;
2379	2580	bmap.br_state = XFS_EXT_NORM;
2380	2581
2381		- return __xfs_rmap_add(tp, XFS_RMAP_ALLOC, owner, XFS_DATA_FORK, &bmap);
	2582	+ __xfs_rmap_add(tp, XFS_RMAP_ALLOC, owner, XFS_DATA_FORK, &bmap);
2382	2583	}
2383	2584
2384	2585	/* Schedule the deletion of an rmap for non-file data. */
2385		-int
	2586	+void
2386	2587	xfs_rmap_free_extent(
2387	2588	struct xfs_trans *tp,
2388	2589	xfs_agnumber_t agno,
..	..	@@ -2393,14 +2594,14 @@
2393	2594	struct xfs_bmbt_irec bmap;
2394	2595
2395	2596	if (!xfs_rmap_update_is_needed(tp->t_mountp, XFS_DATA_FORK))
2396		- return 0;
	2597	+ return;
2397	2598
2398	2599	bmap.br_startblock = XFS_AGB_TO_FSB(tp->t_mountp, agno, bno);
2399	2600	bmap.br_blockcount = len;
2400	2601	bmap.br_startoff = 0;
2401	2602	bmap.br_state = XFS_EXT_NORM;
2402	2603
2403		- return __xfs_rmap_add(tp, XFS_RMAP_FREE, owner, XFS_DATA_FORK, &bmap);
	2604	+ __xfs_rmap_add(tp, XFS_RMAP_FREE, owner, XFS_DATA_FORK, &bmap);
2404	2605	}
2405	2606
2406	2607	/* Compare rmap records. Returns -1 if a < b, 1 if a > b, and 0 if equal. */
..	..	@@ -2459,18 +2660,18 @@
2459	2660	*/
2460	2661	int
2461	2662	xfs_rmap_record_exists(
2462		- struct xfs_btree_cur *cur,
2463		- xfs_agblock_t bno,
2464		- xfs_extlen_t len,
2465		- struct xfs_owner_info *oinfo,
2466		- bool *has_rmap)
	2663	+ struct xfs_btree_cur *cur,
	2664	+ xfs_agblock_t bno,
	2665	+ xfs_extlen_t len,
	2666	+ const struct xfs_owner_info *oinfo,
	2667	+ bool *has_rmap)
2467	2668	{
2468		- uint64_t owner;
2469		- uint64_t offset;
2470		- unsigned int flags;
2471		- int has_record;
2472		- struct xfs_rmap_irec irec;
2473		- int error;
	2669	+ uint64_t owner;
	2670	+ uint64_t offset;
	2671	+ unsigned int flags;
	2672	+ int has_record;
	2673	+ struct xfs_rmap_irec irec;
	2674	+ int error;
2474	2675
2475	2676	xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
2476	2677	ASSERT(XFS_RMAP_NON_INODE_OWNER(owner) \|\|
..	..	@@ -2502,7 +2703,6 @@
2502	2703	uint64_t owner;
2503	2704	uint64_t offset;
2504	2705	unsigned int flags;
2505		- bool has_rmap;
2506	2706	};
2507	2707
2508	2708	/* For each rmap given, figure out if it doesn't match the key we want. */
..	..	@@ -2517,8 +2717,7 @@
2517	2717	if (rks->owner == rec->rm_owner && rks->offset == rec->rm_offset &&
2518	2718	((rks->flags & rec->rm_flags) & XFS_RMAP_KEY_FLAGS) == rks->flags)
2519	2719	return 0;
2520		- rks->has_rmap = true;
2521		- return XFS_BTREE_QUERY_RANGE_ABORT;
	2720	+ return -ECANCELED;
2522	2721	}
2523	2722
2524	2723	/*
..	..	@@ -2530,7 +2729,7 @@
2530	2729	struct xfs_btree_cur *cur,
2531	2730	xfs_agblock_t bno,
2532	2731	xfs_extlen_t len,
2533		- struct xfs_owner_info *oinfo,
	2732	+ const struct xfs_owner_info *oinfo,
2534	2733	bool *has_rmap)
2535	2734	{
2536	2735	struct xfs_rmap_irec low = {0};
..	..	@@ -2539,7 +2738,7 @@
2539	2738	int error;
2540	2739
2541	2740	xfs_owner_info_unpack(oinfo, &rks.owner, &rks.offset, &rks.flags);
2542		- rks.has_rmap = false;
	2741	+ *has_rmap = false;
2543	2742
2544	2743	low.rm_startblock = bno;
2545	2744	memset(&high, 0xFF, sizeof(high));
..	..	@@ -2547,6 +2746,38 @@
2547	2746
2548	2747	error = xfs_rmap_query_range(cur, &low, &high,
2549	2748	xfs_rmap_has_other_keys_helper, &rks);
2550		- *has_rmap = rks.has_rmap;
	2749	+ if (error == -ECANCELED) {
	2750	+ *has_rmap = true;
	2751	+ return 0;
	2752	+ }
	2753	+
2551	2754	return error;
2552	2755	}
	2756	+
	2757	+const struct xfs_owner_info XFS_RMAP_OINFO_SKIP_UPDATE = {
	2758	+ .oi_owner = XFS_RMAP_OWN_NULL,
	2759	+};
	2760	+const struct xfs_owner_info XFS_RMAP_OINFO_ANY_OWNER = {
	2761	+ .oi_owner = XFS_RMAP_OWN_UNKNOWN,
	2762	+};
	2763	+const struct xfs_owner_info XFS_RMAP_OINFO_FS = {
	2764	+ .oi_owner = XFS_RMAP_OWN_FS,
	2765	+};
	2766	+const struct xfs_owner_info XFS_RMAP_OINFO_LOG = {
	2767	+ .oi_owner = XFS_RMAP_OWN_LOG,
	2768	+};
	2769	+const struct xfs_owner_info XFS_RMAP_OINFO_AG = {
	2770	+ .oi_owner = XFS_RMAP_OWN_AG,
	2771	+};
	2772	+const struct xfs_owner_info XFS_RMAP_OINFO_INOBT = {
	2773	+ .oi_owner = XFS_RMAP_OWN_INOBT,
	2774	+};
	2775	+const struct xfs_owner_info XFS_RMAP_OINFO_INODES = {
	2776	+ .oi_owner = XFS_RMAP_OWN_INODES,
	2777	+};
	2778	+const struct xfs_owner_info XFS_RMAP_OINFO_REFC = {
	2779	+ .oi_owner = XFS_RMAP_OWN_REFC,
	2780	+};
	2781	+const struct xfs_owner_info XFS_RMAP_OINFO_COW = {
	2782	+ .oi_owner = XFS_RMAP_OWN_COW,
	2783	+};