Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1aef882f authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-for-linus-4.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/dgc/linux-xfs 

Pull xfs update from Dave Chinner:
 "This update contains:

   - RENAME_WHITEOUT support

   - conversion of per-cpu superblock accounting to use generic counters

   - new inode mmap lock so that we can lock page faults out of
     truncate, hole punch and other direct extent manipulation functions
     to avoid racing mmap writes from causing data corruption

   - rework of direct IO submission and completion to solve data
     corruption issue when running concurrent extending DIO writes.
     Also solves problem of running IO completion transactions in
     interrupt context during size extending AIO writes.

   - FALLOC_FL_INSERT_RANGE support for inserting holes into a file via
     direct extent manipulation to avoid needing to copy data within the
     file

   - attribute block header field overflow fix for 64k block size
     filesystems

   - Lots of changes to log messaging to be more informative and concise
     when errors occur.  Also prevent a lot of unnecessary log spamming
     due to cascading failures in error conditions.

   - lots of cleanups and bug fixes

  One thing of note is the direct IO fixes that we merged last week
  after the window opened.  Even though a little late, they fix a user
  reported data corruption and have been pretty well tested.  I figured
  there was not much point waiting another 2 weeks for -rc1 to be
  released just so I could send them to you..."

* tag 'xfs-for-linus-4.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/dgc/linux-xfs: (49 commits)
  xfs: using generic_file_direct_write() is unnecessary
  xfs: direct IO EOF zeroing needs to drain AIO
  xfs: DIO write completion size updates race
  xfs: DIO writes within EOF don't need an ioend
  xfs: handle DIO overwrite EOF update completion correctly
  xfs: DIO needs an ioend for writes
  xfs: move DIO mapping size calculation
  xfs: factor DIO write mapping from get_blocks
  xfs: unlock i_mutex in xfs_break_layouts
  xfs: kill unnecessary firstused overflow check on attr3 leaf removal
  xfs: use larger in-core attr firstused field and detect overflow
  xfs: pass attr geometry to attr leaf header conversion functions
  xfs: disallow ro->rw remount on norecovery mount
  xfs: xfs_shift_file_space can be static
  xfs: Add support FALLOC_FL_INSERT_RANGE for fallocate
  fs: Add support FALLOC_FL_INSERT_RANGE for fallocate
  xfs: Fix incorrect positive ENOMEM return
  xfs: xfs_mru_cache_insert() should use GFP_NOFS
  xfs: %pF is only for function pointers
  xfs: fix shadow warning in xfs_da3_root_split()
  ...
parents d869844b 542c3118

Documentation/filesystems/xfs.txt

+9 −20
Original line number Diff line number Diff line
@@ -228,30 +228,19 @@ default behaviour. 
Deprecated Mount Options

========================



  delaylog/nodelaylog

	Delayed logging is the only logging method that XFS supports

	now, so these mount options are now ignored.



	Due for removal in 3.12.



  ihashsize=value

	In memory inode hashes have been removed, so this option has

	no function as of August 2007. Option is deprecated.



	Due for removal in 3.12.

None at present.



  irixsgid

	This behaviour is now controlled by a sysctl, so the mount

	option is ignored.



	Due for removal in 3.12.

Removed Mount Options

=====================



  osyncisdsync

  osyncisosync

	O_SYNC and O_DSYNC are fully supported, so there is no need

	for these options any more.

  Name				Removed

  ----				-------

  delaylog/nodelaylog		v3.20

  ihashsize			v3.20

  irixsgid			v3.20

  osyncisdsync/osyncisosync	v3.20



	Due for removal in 3.12.



sysctls

=======

fs/open.c

+6 −2
Original line number Diff line number Diff line
@@ -231,8 +231,7 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len) 
		return -EINVAL;



	/* Return error if mode is not supported */

	if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |

		     FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE))

	if (mode & ~FALLOC_FL_SUPPORTED_MASK)

		return -EOPNOTSUPP;



	/* Punch hole and zero range are mutually exclusive */
@@ -250,6 +249,11 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len) 
	    (mode & ~FALLOC_FL_COLLAPSE_RANGE))

		return -EINVAL;



	/* Insert range should only be used exclusively. */

	if ((mode & FALLOC_FL_INSERT_RANGE) &&

	    (mode & ~FALLOC_FL_INSERT_RANGE))

		return -EINVAL;



	if (!(file->f_mode & FMODE_WRITE))

		return -EBADF;

fs/xfs/libxfs/xfs_alloc.c

+55 −49
Original line number Diff line number Diff line
@@ -260,6 +260,7 @@ xfs_alloc_fix_len( 
		rlen = rlen - (k - args->mod);

	else

		rlen = rlen - args->prod + (args->mod - k);

	/* casts to (int) catch length underflows */

	if ((int)rlen < (int)args->minlen)

		return;

	ASSERT(rlen >= args->minlen && rlen <= args->maxlen);
@@ -286,7 +287,8 @@ xfs_alloc_fix_minleft( 
	if (diff >= 0)

		return 1;

	args->len += diff;		/* shrink the allocated space */

	if (args->len >= args->minlen)

	/* casts to (int) catch length underflows */

	if ((int)args->len >= (int)args->minlen)

		return 1;

	args->agbno = NULLAGBLOCK;

	return 0;
@@ -315,6 +317,9 @@ xfs_alloc_fixup_trees( 
	xfs_agblock_t	nfbno2;		/* second new free startblock */

	xfs_extlen_t	nflen1=0;	/* first new free length */

	xfs_extlen_t	nflen2=0;	/* second new free length */

	struct xfs_mount *mp;



	mp = cnt_cur->bc_mp;



	/*

	 * Look up the record in the by-size tree if necessary.
@@ -323,13 +328,13 @@ xfs_alloc_fixup_trees( 
#ifdef DEBUG

		if ((error = xfs_alloc_get_rec(cnt_cur, &nfbno1, &nflen1, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(

		XFS_WANT_CORRUPTED_RETURN(mp,

			i == 1 && nfbno1 == fbno && nflen1 == flen);

#endif

	} else {

		if ((error = xfs_alloc_lookup_eq(cnt_cur, fbno, flen, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 1);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 1);

	}

	/*

	 * Look up the record in the by-block tree if necessary.
@@ -338,13 +343,13 @@ xfs_alloc_fixup_trees( 
#ifdef DEBUG

		if ((error = xfs_alloc_get_rec(bno_cur, &nfbno1, &nflen1, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(

		XFS_WANT_CORRUPTED_RETURN(mp,

			i == 1 && nfbno1 == fbno && nflen1 == flen);

#endif

	} else {

		if ((error = xfs_alloc_lookup_eq(bno_cur, fbno, flen, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 1);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 1);

	}



#ifdef DEBUG
@@ -355,7 +360,7 @@ xfs_alloc_fixup_trees( 
		bnoblock = XFS_BUF_TO_BLOCK(bno_cur->bc_bufs[0]);

		cntblock = XFS_BUF_TO_BLOCK(cnt_cur->bc_bufs[0]);



		XFS_WANT_CORRUPTED_RETURN(

		XFS_WANT_CORRUPTED_RETURN(mp,

			bnoblock->bb_numrecs == cntblock->bb_numrecs);

	}

#endif
@@ -386,25 +391,25 @@ xfs_alloc_fixup_trees( 
	 */

	if ((error = xfs_btree_delete(cnt_cur, &i)))

		return error;

	XFS_WANT_CORRUPTED_RETURN(i == 1);

	XFS_WANT_CORRUPTED_RETURN(mp, i == 1);

	/*

	 * Add new by-size btree entry(s).

	 */

	if (nfbno1 != NULLAGBLOCK) {

		if ((error = xfs_alloc_lookup_eq(cnt_cur, nfbno1, nflen1, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 0);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 0);

		if ((error = xfs_btree_insert(cnt_cur, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 1);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 1);

	}

	if (nfbno2 != NULLAGBLOCK) {

		if ((error = xfs_alloc_lookup_eq(cnt_cur, nfbno2, nflen2, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 0);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 0);

		if ((error = xfs_btree_insert(cnt_cur, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 1);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 1);

	}

	/*

	 * Fix up the by-block btree entry(s).
@@ -415,7 +420,7 @@ xfs_alloc_fixup_trees( 
		 */

		if ((error = xfs_btree_delete(bno_cur, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 1);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 1);

	} else {

		/*

		 * Update the by-block entry to start later|be shorter.
@@ -429,10 +434,10 @@ xfs_alloc_fixup_trees( 
		 */

		if ((error = xfs_alloc_lookup_eq(bno_cur, nfbno2, nflen2, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 0);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 0);

		if ((error = xfs_btree_insert(bno_cur, &i)))

			return error;

		XFS_WANT_CORRUPTED_RETURN(i == 1);

		XFS_WANT_CORRUPTED_RETURN(mp, i == 1);

	}

	return 0;

}
@@ -682,7 +687,7 @@ xfs_alloc_ag_vextent_exact( 
	error = xfs_alloc_get_rec(bno_cur, &fbno, &flen, &i);

	if (error)

		goto error0;

	XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

	XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

	ASSERT(fbno <= args->agbno);



	/*
@@ -783,7 +788,7 @@ xfs_alloc_find_best_extent( 
		error = xfs_alloc_get_rec(*scur, sbno, slen, &i);

		if (error)

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

		xfs_alloc_compute_aligned(args, *sbno, *slen, sbnoa, slena);



		/*
@@ -946,7 +951,7 @@ xfs_alloc_ag_vextent_near( 
				if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno,

						&ltlen, &i)))

					goto error0;

				XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

				XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

				if (ltlen >= args->minlen)

					break;

				if ((error = xfs_btree_increment(cnt_cur, 0, &i)))
@@ -966,7 +971,7 @@ xfs_alloc_ag_vextent_near( 
			 */

			if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno, &ltlen, &i)))

				goto error0;

			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

			XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

			xfs_alloc_compute_aligned(args, ltbno, ltlen,

						  &ltbnoa, &ltlena);

			if (ltlena < args->minlen)
@@ -999,7 +1004,7 @@ xfs_alloc_ag_vextent_near( 
		cnt_cur->bc_ptrs[0] = besti;

		if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno, &ltlen, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

		ASSERT(ltbno + ltlen <= be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length));

		args->len = blen;

		if (!xfs_alloc_fix_minleft(args)) {
@@ -1088,7 +1093,7 @@ xfs_alloc_ag_vextent_near( 
		if (bno_cur_lt) {

			if ((error = xfs_alloc_get_rec(bno_cur_lt, &ltbno, &ltlen, &i)))

				goto error0;

			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

			XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

			xfs_alloc_compute_aligned(args, ltbno, ltlen,

						  &ltbnoa, &ltlena);

			if (ltlena >= args->minlen)
@@ -1104,7 +1109,7 @@ xfs_alloc_ag_vextent_near( 
		if (bno_cur_gt) {

			if ((error = xfs_alloc_get_rec(bno_cur_gt, &gtbno, &gtlen, &i)))

				goto error0;

			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

			XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

			xfs_alloc_compute_aligned(args, gtbno, gtlen,

						  &gtbnoa, &gtlena);

			if (gtlena >= args->minlen)
@@ -1303,7 +1308,7 @@ xfs_alloc_ag_vextent_size( 
			error = xfs_alloc_get_rec(cnt_cur, &fbno, &flen, &i);

			if (error)

				goto error0;

			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

			XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);



			xfs_alloc_compute_aligned(args, fbno, flen,

						  &rbno, &rlen);
@@ -1342,7 +1347,7 @@ xfs_alloc_ag_vextent_size( 
	 * This can't happen in the second case above.

	 */

	rlen = XFS_EXTLEN_MIN(args->maxlen, rlen);

	XFS_WANT_CORRUPTED_GOTO(rlen == 0 ||

	XFS_WANT_CORRUPTED_GOTO(args->mp, rlen == 0 ||

			(rlen <= flen && rbno + rlen <= fbno + flen), error0);

	if (rlen < args->maxlen) {

		xfs_agblock_t	bestfbno;
@@ -1362,13 +1367,13 @@ xfs_alloc_ag_vextent_size( 
			if ((error = xfs_alloc_get_rec(cnt_cur, &fbno, &flen,

					&i)))

				goto error0;

			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

			XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

			if (flen < bestrlen)

				break;

			xfs_alloc_compute_aligned(args, fbno, flen,

						  &rbno, &rlen);

			rlen = XFS_EXTLEN_MIN(args->maxlen, rlen);

			XFS_WANT_CORRUPTED_GOTO(rlen == 0 ||

			XFS_WANT_CORRUPTED_GOTO(args->mp, rlen == 0 ||

				(rlen <= flen && rbno + rlen <= fbno + flen),

				error0);

			if (rlen > bestrlen) {
@@ -1383,7 +1388,7 @@ xfs_alloc_ag_vextent_size( 
		if ((error = xfs_alloc_lookup_eq(cnt_cur, bestfbno, bestflen,

				&i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

		rlen = bestrlen;

		rbno = bestrbno;

		flen = bestflen;
@@ -1408,7 +1413,7 @@ xfs_alloc_ag_vextent_size( 
	if (!xfs_alloc_fix_minleft(args))

		goto out_nominleft;

	rlen = args->len;

	XFS_WANT_CORRUPTED_GOTO(rlen <= flen, error0);

	XFS_WANT_CORRUPTED_GOTO(args->mp, rlen <= flen, error0);

	/*

	 * Allocate and initialize a cursor for the by-block tree.

	 */
@@ -1422,7 +1427,7 @@ xfs_alloc_ag_vextent_size( 
	cnt_cur = bno_cur = NULL;

	args->len = rlen;

	args->agbno = rbno;

	XFS_WANT_CORRUPTED_GOTO(

	XFS_WANT_CORRUPTED_GOTO(args->mp,

		args->agbno + args->len <=

			be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length),

		error0);
@@ -1467,7 +1472,7 @@ xfs_alloc_ag_vextent_small( 
	if (i) {

		if ((error = xfs_alloc_get_rec(ccur, &fbno, &flen, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);

	}

	/*

	 * Nothing in the btree, try the freelist.  Make sure
@@ -1493,7 +1498,7 @@ xfs_alloc_ag_vextent_small( 
			}

			args->len = 1;

			args->agbno = fbno;

			XFS_WANT_CORRUPTED_GOTO(

			XFS_WANT_CORRUPTED_GOTO(args->mp,

				args->agbno + args->len <=

				be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length),

				error0);
@@ -1579,7 +1584,7 @@ xfs_free_ag_extent( 
		 */

		if ((error = xfs_alloc_get_rec(bno_cur, &ltbno, &ltlen, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		/*

		 * It's not contiguous, though.

		 */
@@ -1591,7 +1596,8 @@ xfs_free_ag_extent( 
			 * space was invalid, it's (partly) already free.

			 * Very bad.

			 */

			XFS_WANT_CORRUPTED_GOTO(ltbno + ltlen <= bno, error0);

			XFS_WANT_CORRUPTED_GOTO(mp,

						ltbno + ltlen <= bno, error0);

		}

	}

	/*
@@ -1606,7 +1612,7 @@ xfs_free_ag_extent( 
		 */

		if ((error = xfs_alloc_get_rec(bno_cur, &gtbno, &gtlen, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		/*

		 * It's not contiguous, though.

		 */
@@ -1618,7 +1624,7 @@ xfs_free_ag_extent( 
			 * space was invalid, it's (partly) already free.

			 * Very bad.

			 */

			XFS_WANT_CORRUPTED_GOTO(gtbno >= bno + len, error0);

			XFS_WANT_CORRUPTED_GOTO(mp, gtbno >= bno + len, error0);

		}

	}

	/*
@@ -1635,31 +1641,31 @@ xfs_free_ag_extent( 
		 */

		if ((error = xfs_alloc_lookup_eq(cnt_cur, ltbno, ltlen, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		if ((error = xfs_btree_delete(cnt_cur, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		/*

		 * Delete the old by-size entry on the right.

		 */

		if ((error = xfs_alloc_lookup_eq(cnt_cur, gtbno, gtlen, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		if ((error = xfs_btree_delete(cnt_cur, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		/*

		 * Delete the old by-block entry for the right block.

		 */

		if ((error = xfs_btree_delete(bno_cur, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		/*

		 * Move the by-block cursor back to the left neighbor.

		 */

		if ((error = xfs_btree_decrement(bno_cur, 0, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

#ifdef DEBUG

		/*

		 * Check that this is the right record: delete didn't
@@ -1672,7 +1678,7 @@ xfs_free_ag_extent( 
			if ((error = xfs_alloc_get_rec(bno_cur, &xxbno, &xxlen,

					&i)))

				goto error0;

			XFS_WANT_CORRUPTED_GOTO(

			XFS_WANT_CORRUPTED_GOTO(mp,

				i == 1 && xxbno == ltbno && xxlen == ltlen,

				error0);

		}
@@ -1695,17 +1701,17 @@ xfs_free_ag_extent( 
		 */

		if ((error = xfs_alloc_lookup_eq(cnt_cur, ltbno, ltlen, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		if ((error = xfs_btree_delete(cnt_cur, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		/*

		 * Back up the by-block cursor to the left neighbor, and

		 * update its length.

		 */

		if ((error = xfs_btree_decrement(bno_cur, 0, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		nbno = ltbno;

		nlen = len + ltlen;

		if ((error = xfs_alloc_update(bno_cur, nbno, nlen)))
@@ -1721,10 +1727,10 @@ xfs_free_ag_extent( 
		 */

		if ((error = xfs_alloc_lookup_eq(cnt_cur, gtbno, gtlen, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		if ((error = xfs_btree_delete(cnt_cur, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

		/*

		 * Update the starting block and length of the right

		 * neighbor in the by-block tree.
@@ -1743,7 +1749,7 @@ xfs_free_ag_extent( 
		nlen = len;

		if ((error = xfs_btree_insert(bno_cur, &i)))

			goto error0;

		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

		XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

	}

	xfs_btree_del_cursor(bno_cur, XFS_BTREE_NOERROR);

	bno_cur = NULL;
@@ -1752,10 +1758,10 @@ xfs_free_ag_extent( 
	 */

	if ((error = xfs_alloc_lookup_eq(cnt_cur, nbno, nlen, &i)))

		goto error0;

	XFS_WANT_CORRUPTED_GOTO(i == 0, error0);

	XFS_WANT_CORRUPTED_GOTO(mp, i == 0, error0);

	if ((error = xfs_btree_insert(cnt_cur, &i)))

		goto error0;

	XFS_WANT_CORRUPTED_GOTO(i == 1, error0);

	XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);

	xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);

	cnt_cur = NULL;

fs/xfs/libxfs/xfs_attr_leaf.c

+114 −36
Original line number Diff line number Diff line
@@ -86,8 +86,83 @@ STATIC void xfs_attr3_leaf_moveents(struct xfs_da_args *args, 
			int move_count);

STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);



/*

 * attr3 block 'firstused' conversion helpers.

 *

 * firstused refers to the offset of the first used byte of the nameval region

 * of an attr leaf block. The region starts at the tail of the block and expands

 * backwards towards the middle. As such, firstused is initialized to the block

 * size for an empty leaf block and is reduced from there.

 *

 * The attr3 block size is pegged to the fsb size and the maximum fsb is 64k.

 * The in-core firstused field is 32-bit and thus supports the maximum fsb size.

 * The on-disk field is only 16-bit, however, and overflows at 64k. Since this

 * only occurs at exactly 64k, we use zero as a magic on-disk value to represent

 * the attr block size. The following helpers manage the conversion between the

 * in-core and on-disk formats.

 */



static void

xfs_attr3_leaf_firstused_from_disk(

	struct xfs_da_geometry		*geo,

	struct xfs_attr3_icleaf_hdr	*to,

	struct xfs_attr_leafblock	*from)

{

	struct xfs_attr3_leaf_hdr	*hdr3;



	if (from->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC)) {

		hdr3 = (struct xfs_attr3_leaf_hdr *) from;

		to->firstused = be16_to_cpu(hdr3->firstused);

	} else {

		to->firstused = be16_to_cpu(from->hdr.firstused);

	}



	/*

	 * Convert from the magic fsb size value to actual blocksize. This

	 * should only occur for empty blocks when the block size overflows

	 * 16-bits.

	 */

	if (to->firstused == XFS_ATTR3_LEAF_NULLOFF) {

		ASSERT(!to->count && !to->usedbytes);

		ASSERT(geo->blksize > USHRT_MAX);

		to->firstused = geo->blksize;

	}

}



static void

xfs_attr3_leaf_firstused_to_disk(

	struct xfs_da_geometry		*geo,

	struct xfs_attr_leafblock	*to,

	struct xfs_attr3_icleaf_hdr	*from)

{

	struct xfs_attr3_leaf_hdr	*hdr3;

	uint32_t			firstused;



	/* magic value should only be seen on disk */

	ASSERT(from->firstused != XFS_ATTR3_LEAF_NULLOFF);



	/*

	 * Scale down the 32-bit in-core firstused value to the 16-bit on-disk

	 * value. This only overflows at the max supported value of 64k. Use the

	 * magic on-disk value to represent block size in this case.

	 */

	firstused = from->firstused;

	if (firstused > USHRT_MAX) {

		ASSERT(from->firstused == geo->blksize);

		firstused = XFS_ATTR3_LEAF_NULLOFF;

	}



	if (from->magic == XFS_ATTR3_LEAF_MAGIC) {

		hdr3 = (struct xfs_attr3_leaf_hdr *) to;

		hdr3->firstused = cpu_to_be16(firstused);

	} else {

		to->hdr.firstused = cpu_to_be16(firstused);

	}

}



void

xfs_attr3_leaf_hdr_from_disk(

	struct xfs_da_geometry		*geo,

	struct xfs_attr3_icleaf_hdr	*to,

	struct xfs_attr_leafblock	*from)

{
@@ -104,7 +179,7 @@ xfs_attr3_leaf_hdr_from_disk( 
		to->magic = be16_to_cpu(hdr3->info.hdr.magic);

		to->count = be16_to_cpu(hdr3->count);

		to->usedbytes = be16_to_cpu(hdr3->usedbytes);

		to->firstused = be16_to_cpu(hdr3->firstused);

		xfs_attr3_leaf_firstused_from_disk(geo, to, from);

		to->holes = hdr3->holes;



		for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
@@ -118,7 +193,7 @@ xfs_attr3_leaf_hdr_from_disk( 
	to->magic = be16_to_cpu(from->hdr.info.magic);

	to->count = be16_to_cpu(from->hdr.count);

	to->usedbytes = be16_to_cpu(from->hdr.usedbytes);

	to->firstused = be16_to_cpu(from->hdr.firstused);

	xfs_attr3_leaf_firstused_from_disk(geo, to, from);

	to->holes = from->hdr.holes;



	for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
@@ -129,6 +204,7 @@ xfs_attr3_leaf_hdr_from_disk( 


void

xfs_attr3_leaf_hdr_to_disk(

	struct xfs_da_geometry		*geo,

	struct xfs_attr_leafblock	*to,

	struct xfs_attr3_icleaf_hdr	*from)

{
@@ -145,7 +221,7 @@ xfs_attr3_leaf_hdr_to_disk( 
		hdr3->info.hdr.magic = cpu_to_be16(from->magic);

		hdr3->count = cpu_to_be16(from->count);

		hdr3->usedbytes = cpu_to_be16(from->usedbytes);

		hdr3->firstused = cpu_to_be16(from->firstused);

		xfs_attr3_leaf_firstused_to_disk(geo, to, from);

		hdr3->holes = from->holes;

		hdr3->pad1 = 0;
@@ -160,7 +236,7 @@ xfs_attr3_leaf_hdr_to_disk( 
	to->hdr.info.magic = cpu_to_be16(from->magic);

	to->hdr.count = cpu_to_be16(from->count);

	to->hdr.usedbytes = cpu_to_be16(from->usedbytes);

	to->hdr.firstused = cpu_to_be16(from->firstused);

	xfs_attr3_leaf_firstused_to_disk(geo, to, from);

	to->hdr.holes = from->holes;

	to->hdr.pad1 = 0;
@@ -178,7 +254,7 @@ xfs_attr3_leaf_verify( 
	struct xfs_attr_leafblock *leaf = bp->b_addr;

	struct xfs_attr3_icleaf_hdr ichdr;



	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);



	if (xfs_sb_version_hascrc(&mp->m_sb)) {

		struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
@@ -757,9 +833,10 @@ xfs_attr_shortform_allfit( 
	struct xfs_attr3_icleaf_hdr leafhdr;

	int			bytes;

	int			i;

	struct xfs_mount	*mp = bp->b_target->bt_mount;



	leaf = bp->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&leafhdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);

	entry = xfs_attr3_leaf_entryp(leaf);



	bytes = sizeof(struct xfs_attr_sf_hdr);
@@ -812,7 +889,7 @@ xfs_attr3_leaf_to_shortform( 
	memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);



	leaf = (xfs_attr_leafblock_t *)tmpbuffer;

	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

	entry = xfs_attr3_leaf_entryp(leaf);



	/* XXX (dgc): buffer is about to be marked stale - why zero it? */
@@ -923,7 +1000,7 @@ xfs_attr3_leaf_to_node( 
	btree = dp->d_ops->node_tree_p(node);



	leaf = bp2->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&icleafhdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &icleafhdr, leaf);

	entries = xfs_attr3_leaf_entryp(leaf);



	/* both on-disk, don't endian-flip twice */
@@ -988,7 +1065,7 @@ xfs_attr3_leaf_create( 
	}

	ichdr.freemap[0].size = ichdr.firstused - ichdr.freemap[0].base;



	xfs_attr3_leaf_hdr_to_disk(leaf, &ichdr);

	xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);

	xfs_trans_log_buf(args->trans, bp, 0, args->geo->blksize - 1);



	*bpp = bp;
@@ -1073,7 +1150,7 @@ xfs_attr3_leaf_add( 
	trace_xfs_attr_leaf_add(args);



	leaf = bp->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

	ASSERT(args->index >= 0 && args->index <= ichdr.count);

	entsize = xfs_attr_leaf_newentsize(args, NULL);
@@ -1126,7 +1203,7 @@ xfs_attr3_leaf_add( 
	tmp = xfs_attr3_leaf_add_work(bp, &ichdr, args, 0);



out_log_hdr:

	xfs_attr3_leaf_hdr_to_disk(leaf, &ichdr);

	xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);

	xfs_trans_log_buf(args->trans, bp,

		XFS_DA_LOGRANGE(leaf, &leaf->hdr,

				xfs_attr3_leaf_hdr_size(leaf)));
@@ -1294,7 +1371,7 @@ xfs_attr3_leaf_compact( 
						ichdr_dst->freemap[0].base;



	/* write the header back to initialise the underlying buffer */

	xfs_attr3_leaf_hdr_to_disk(leaf_dst, ichdr_dst);

	xfs_attr3_leaf_hdr_to_disk(args->geo, leaf_dst, ichdr_dst);



	/*

	 * Copy all entry's in the same (sorted) order,
@@ -1344,9 +1421,10 @@ xfs_attr_leaf_order( 
{

	struct xfs_attr3_icleaf_hdr ichdr1;

	struct xfs_attr3_icleaf_hdr ichdr2;

	struct xfs_mount *mp = leaf1_bp->b_target->bt_mount;



	xfs_attr3_leaf_hdr_from_disk(&ichdr1, leaf1_bp->b_addr);

	xfs_attr3_leaf_hdr_from_disk(&ichdr2, leaf2_bp->b_addr);

	xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr1, leaf1_bp->b_addr);

	xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr2, leaf2_bp->b_addr);

	return xfs_attr3_leaf_order(leaf1_bp, &ichdr1, leaf2_bp, &ichdr2);

}
@@ -1388,8 +1466,8 @@ xfs_attr3_leaf_rebalance( 
	ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);

	leaf1 = blk1->bp->b_addr;

	leaf2 = blk2->bp->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&ichdr1, leaf1);

	xfs_attr3_leaf_hdr_from_disk(&ichdr2, leaf2);

	xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr1, leaf1);

	xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr2, leaf2);

	ASSERT(ichdr2.count == 0);

	args = state->args;
@@ -1490,8 +1568,8 @@ xfs_attr3_leaf_rebalance( 
					ichdr1.count, count);

	}



	xfs_attr3_leaf_hdr_to_disk(leaf1, &ichdr1);

	xfs_attr3_leaf_hdr_to_disk(leaf2, &ichdr2);

	xfs_attr3_leaf_hdr_to_disk(state->args->geo, leaf1, &ichdr1);

	xfs_attr3_leaf_hdr_to_disk(state->args->geo, leaf2, &ichdr2);

	xfs_trans_log_buf(args->trans, blk1->bp, 0, args->geo->blksize - 1);

	xfs_trans_log_buf(args->trans, blk2->bp, 0, args->geo->blksize - 1);
@@ -1684,7 +1762,7 @@ xfs_attr3_leaf_toosmall( 
	 */

	blk = &state->path.blk[ state->path.active-1 ];

	leaf = blk->bp->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr, leaf);

	bytes = xfs_attr3_leaf_hdr_size(leaf) +

		ichdr.count * sizeof(xfs_attr_leaf_entry_t) +

		ichdr.usedbytes;
@@ -1740,7 +1818,7 @@ xfs_attr3_leaf_toosmall( 
		if (error)

			return error;



		xfs_attr3_leaf_hdr_from_disk(&ichdr2, bp->b_addr);

		xfs_attr3_leaf_hdr_from_disk(state->args->geo, &ichdr2, bp->b_addr);



		bytes = state->args->geo->blksize -

			(state->args->geo->blksize >> 2) -
@@ -1805,7 +1883,7 @@ xfs_attr3_leaf_remove( 
	trace_xfs_attr_leaf_remove(args);



	leaf = bp->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);



	ASSERT(ichdr.count > 0 && ichdr.count < args->geo->blksize / 8);

	ASSERT(args->index >= 0 && args->index < ichdr.count);
@@ -1918,12 +1996,11 @@ xfs_attr3_leaf_remove( 
				tmp = be16_to_cpu(entry->nameidx);

		}

		ichdr.firstused = tmp;

		if (!ichdr.firstused)

			ichdr.firstused = tmp - XFS_ATTR_LEAF_NAME_ALIGN;

		ASSERT(ichdr.firstused != 0);

	} else {

		ichdr.holes = 1;	/* mark as needing compaction */

	}

	xfs_attr3_leaf_hdr_to_disk(leaf, &ichdr);

	xfs_attr3_leaf_hdr_to_disk(args->geo, leaf, &ichdr);

	xfs_trans_log_buf(args->trans, bp,

			  XFS_DA_LOGRANGE(leaf, &leaf->hdr,

					  xfs_attr3_leaf_hdr_size(leaf)));
@@ -1957,8 +2034,8 @@ xfs_attr3_leaf_unbalance( 


	drop_leaf = drop_blk->bp->b_addr;

	save_leaf = save_blk->bp->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&drophdr, drop_leaf);

	xfs_attr3_leaf_hdr_from_disk(&savehdr, save_leaf);

	xfs_attr3_leaf_hdr_from_disk(state->args->geo, &drophdr, drop_leaf);

	xfs_attr3_leaf_hdr_from_disk(state->args->geo, &savehdr, save_leaf);

	entry = xfs_attr3_leaf_entryp(drop_leaf);



	/*
@@ -2012,7 +2089,7 @@ xfs_attr3_leaf_unbalance( 
		tmphdr.firstused = state->args->geo->blksize;



		/* write the header to the temp buffer to initialise it */

		xfs_attr3_leaf_hdr_to_disk(tmp_leaf, &tmphdr);

		xfs_attr3_leaf_hdr_to_disk(state->args->geo, tmp_leaf, &tmphdr);



		if (xfs_attr3_leaf_order(save_blk->bp, &savehdr,

					 drop_blk->bp, &drophdr)) {
@@ -2039,7 +2116,7 @@ xfs_attr3_leaf_unbalance( 
		kmem_free(tmp_leaf);

	}



	xfs_attr3_leaf_hdr_to_disk(save_leaf, &savehdr);

	xfs_attr3_leaf_hdr_to_disk(state->args->geo, save_leaf, &savehdr);

	xfs_trans_log_buf(state->args->trans, save_blk->bp, 0,

					   state->args->geo->blksize - 1);
@@ -2085,7 +2162,7 @@ xfs_attr3_leaf_lookup_int( 
	trace_xfs_attr_leaf_lookup(args);



	leaf = bp->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

	entries = xfs_attr3_leaf_entryp(leaf);

	ASSERT(ichdr.count < args->geo->blksize / 8);
@@ -2190,7 +2267,7 @@ xfs_attr3_leaf_getvalue( 
	int			valuelen;



	leaf = bp->b_addr;

	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

	ASSERT(ichdr.count < args->geo->blksize / 8);

	ASSERT(args->index < ichdr.count);
@@ -2391,8 +2468,9 @@ xfs_attr_leaf_lasthash( 
{

	struct xfs_attr3_icleaf_hdr ichdr;

	struct xfs_attr_leaf_entry *entries;

	struct xfs_mount *mp = bp->b_target->bt_mount;



	xfs_attr3_leaf_hdr_from_disk(&ichdr, bp->b_addr);

	xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, bp->b_addr);

	entries = xfs_attr3_leaf_entryp(bp->b_addr);

	if (count)

		*count = ichdr.count;
@@ -2486,7 +2564,7 @@ xfs_attr3_leaf_clearflag( 
	ASSERT(entry->flags & XFS_ATTR_INCOMPLETE);



#ifdef DEBUG

	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

	ASSERT(args->index < ichdr.count);

	ASSERT(args->index >= 0);
@@ -2550,7 +2628,7 @@ xfs_attr3_leaf_setflag( 


	leaf = bp->b_addr;

#ifdef DEBUG

	xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr, leaf);

	ASSERT(args->index < ichdr.count);

	ASSERT(args->index >= 0);

#endif
@@ -2629,11 +2707,11 @@ xfs_attr3_leaf_flipflags( 
	entry2 = &xfs_attr3_leaf_entryp(leaf2)[args->index2];



#ifdef DEBUG

	xfs_attr3_leaf_hdr_from_disk(&ichdr1, leaf1);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr1, leaf1);

	ASSERT(args->index < ichdr1.count);

	ASSERT(args->index >= 0);



	xfs_attr3_leaf_hdr_from_disk(&ichdr2, leaf2);

	xfs_attr3_leaf_hdr_from_disk(args->geo, &ichdr2, leaf2);

	ASSERT(args->index2 < ichdr2.count);

	ASSERT(args->index2 >= 0);

fs/xfs/libxfs/xfs_attr_leaf.h

+4 −2
Original line number Diff line number Diff line
@@ -100,9 +100,11 @@ int xfs_attr_leaf_newentsize(struct xfs_da_args *args, int *local); 
int	xfs_attr3_leaf_read(struct xfs_trans *tp, struct xfs_inode *dp,

			xfs_dablk_t bno, xfs_daddr_t mappedbno,

			struct xfs_buf **bpp);

void	xfs_attr3_leaf_hdr_from_disk(struct xfs_attr3_icleaf_hdr *to,

void	xfs_attr3_leaf_hdr_from_disk(struct xfs_da_geometry *geo,

				     struct xfs_attr3_icleaf_hdr *to,

				     struct xfs_attr_leafblock *from);

void	xfs_attr3_leaf_hdr_to_disk(struct xfs_attr_leafblock *to,

void	xfs_attr3_leaf_hdr_to_disk(struct xfs_da_geometry *geo,

				   struct xfs_attr_leafblock *to,

				   struct xfs_attr3_icleaf_hdr *from);



#endif	/* __XFS_ATTR_LEAF_H__ */