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

Commit d484467c authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-4.12-merge-7' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull xfs updates from Darrick Wong:
 "Here are the XFS changes for 4.12. The big new feature for this
  release is the new space mapping ioctl that we've been discussing
  since LSF2016, but other than that most of the patches are larger bug
  fixes, memory corruption prevention, and other cleanups.

  Summary:
   - various code cleanups
   - introduce GETFSMAP ioctl
   - various refactoring
   - avoid dio reads past eof
   - fix memory corruption and other errors with fragmented directory blocks
   - fix accidental userspace memory corruptions
   - publish fs uuid in superblock
   - make fstrim terminatable
   - fix race between quotaoff and in-core inode creation
   - avoid use-after-free when finishing up w/ buffer heads
   - reserve enough space to handle bmap tree resizing during cow remap"

* tag 'xfs-4.12-merge-7' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (53 commits)
  xfs: fix use-after-free in xfs_finish_page_writeback
  xfs: reserve enough blocks to handle btree splits when remapping
  xfs: wait on new inodes during quotaoff dquot release
  xfs: update ag iterator to support wait on new inodes
  xfs: support ability to wait on new inodes
  xfs: publish UUID in struct super_block
  xfs: Allow user to kill fstrim process
  xfs: better log intent item refcount checking
  xfs: fix up quotacheck buffer list error handling
  xfs: remove xfs_trans_ail_delete_bulk
  xfs: don't use bool values in trace buffers
  xfs: fix getfsmap userspace memory corruption while setting OF_LAST
  xfs: fix __user annotations for xfs_ioc_getfsmap
  xfs: corruption needs to respect endianess too!
  xfs: use NULL instead of 0 to initialize a pointer in xfs_ioc_getfsmap
  xfs: use NULL instead of 0 to initialize a pointer in xfs_getfsmap
  xfs: simplify validation of the unwritten extent bit
  xfs: remove unused values from xfs_exntst_t
  xfs: remove the unused XFS_MAXLINK_1 define
  xfs: more do_div cleanups
  ...
parents 044f1daa 161f55ef

fs/iomap.c

+3 −0
Original line number Diff line number Diff line
@@ -910,6 +910,9 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, 
			break;

		}

		pos += ret;



		if (iov_iter_rw(iter) == READ && pos >= dio->i_size)

			break;

	} while ((count = iov_iter_count(iter)) > 0);

	blk_finish_plug(&plug);

fs/xfs/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -79,6 +79,7 @@ xfs-y += xfs_aops.o \ 
				   xfs_extent_busy.o \

				   xfs_file.o \

				   xfs_filestream.o \

				   xfs_fsmap.o \

				   xfs_fsops.o \

				   xfs_globals.o \

				   xfs_icache.o \

fs/xfs/libxfs/xfs_alloc.c

+57 −0
Original line number Diff line number Diff line
@@ -2868,3 +2868,60 @@ xfs_free_extent( 
	xfs_trans_brelse(tp, agbp);

	return error;

}



struct xfs_alloc_query_range_info {

	xfs_alloc_query_range_fn	fn;

	void				*priv;

};



/* Format btree record and pass to our callback. */

STATIC int

xfs_alloc_query_range_helper(

	struct xfs_btree_cur		*cur,

	union xfs_btree_rec		*rec,

	void				*priv)

{

	struct xfs_alloc_query_range_info	*query = priv;

	struct xfs_alloc_rec_incore		irec;



	irec.ar_startblock = be32_to_cpu(rec->alloc.ar_startblock);

	irec.ar_blockcount = be32_to_cpu(rec->alloc.ar_blockcount);

	return query->fn(cur, &irec, query->priv);

}



/* Find all free space within a given range of blocks. */

int

xfs_alloc_query_range(

	struct xfs_btree_cur			*cur,

	struct xfs_alloc_rec_incore		*low_rec,

	struct xfs_alloc_rec_incore		*high_rec,

	xfs_alloc_query_range_fn		fn,

	void					*priv)

{

	union xfs_btree_irec			low_brec;

	union xfs_btree_irec			high_brec;

	struct xfs_alloc_query_range_info	query;



	ASSERT(cur->bc_btnum == XFS_BTNUM_BNO);

	low_brec.a = *low_rec;

	high_brec.a = *high_rec;

	query.priv = priv;

	query.fn = fn;

	return xfs_btree_query_range(cur, &low_brec, &high_brec,

			xfs_alloc_query_range_helper, &query);

}



/* Find all free space records. */

int

xfs_alloc_query_all(

	struct xfs_btree_cur			*cur,

	xfs_alloc_query_range_fn		fn,

	void					*priv)

{

	struct xfs_alloc_query_range_info	query;



	ASSERT(cur->bc_btnum == XFS_BTNUM_BNO);

	query.priv = priv;

	query.fn = fn;

	return xfs_btree_query_all(cur, xfs_alloc_query_range_helper, &query);

}

fs/xfs/libxfs/xfs_alloc.h

+12 −0
Original line number Diff line number Diff line
@@ -219,4 +219,16 @@ int xfs_free_extent_fix_freelist(struct xfs_trans *tp, xfs_agnumber_t agno, 


xfs_extlen_t xfs_prealloc_blocks(struct xfs_mount *mp);



typedef int (*xfs_alloc_query_range_fn)(

	struct xfs_btree_cur		*cur,

	struct xfs_alloc_rec_incore	*rec,

	void				*priv);



int xfs_alloc_query_range(struct xfs_btree_cur *cur,

		struct xfs_alloc_rec_incore *low_rec,

		struct xfs_alloc_rec_incore *high_rec,

		xfs_alloc_query_range_fn fn, void *priv);

int xfs_alloc_query_all(struct xfs_btree_cur *cur, xfs_alloc_query_range_fn fn,

		void *priv);



#endif	/* __XFS_ALLOC_H__ */

fs/xfs/libxfs/xfs_alloc_btree.c

+129 −43
Original line number Diff line number Diff line
@@ -205,19 +205,37 @@ xfs_allocbt_init_key_from_rec( 
	union xfs_btree_key	*key,

	union xfs_btree_rec	*rec)

{

	ASSERT(rec->alloc.ar_startblock != 0);



	key->alloc.ar_startblock = rec->alloc.ar_startblock;

	key->alloc.ar_blockcount = rec->alloc.ar_blockcount;

}



STATIC void

xfs_bnobt_init_high_key_from_rec(

	union xfs_btree_key	*key,

	union xfs_btree_rec	*rec)

{

	__u32			x;



	x = be32_to_cpu(rec->alloc.ar_startblock);

	x += be32_to_cpu(rec->alloc.ar_blockcount) - 1;

	key->alloc.ar_startblock = cpu_to_be32(x);

	key->alloc.ar_blockcount = 0;

}



STATIC void

xfs_cntbt_init_high_key_from_rec(

	union xfs_btree_key	*key,

	union xfs_btree_rec	*rec)

{

	key->alloc.ar_blockcount = rec->alloc.ar_blockcount;

	key->alloc.ar_startblock = 0;

}



STATIC void

xfs_allocbt_init_rec_from_cur(

	struct xfs_btree_cur	*cur,

	union xfs_btree_rec	*rec)

{

	ASSERT(cur->bc_rec.a.ar_startblock != 0);



	rec->alloc.ar_startblock = cpu_to_be32(cur->bc_rec.a.ar_startblock);

	rec->alloc.ar_blockcount = cpu_to_be32(cur->bc_rec.a.ar_blockcount);

}
@@ -236,19 +254,25 @@ xfs_allocbt_init_ptr_from_cur( 
}



STATIC __int64_t

xfs_allocbt_key_diff(

xfs_bnobt_key_diff(

	struct xfs_btree_cur	*cur,

	union xfs_btree_key	*key)

{

	xfs_alloc_rec_incore_t	*rec = &cur->bc_rec.a;

	xfs_alloc_key_t		*kp = &key->alloc;

	__int64_t		diff;



	if (cur->bc_btnum == XFS_BTNUM_BNO) {

		return (__int64_t)be32_to_cpu(kp->ar_startblock) -

				rec->ar_startblock;

	return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;

}



STATIC __int64_t

xfs_cntbt_key_diff(

	struct xfs_btree_cur	*cur,

	union xfs_btree_key	*key)

{

	xfs_alloc_rec_incore_t	*rec = &cur->bc_rec.a;

	xfs_alloc_key_t		*kp = &key->alloc;

	__int64_t		diff;



	diff = (__int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount;

	if (diff)

		return diff;
@@ -256,6 +280,33 @@ xfs_allocbt_key_diff( 
	return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;

}



STATIC __int64_t

xfs_bnobt_diff_two_keys(

	struct xfs_btree_cur	*cur,

	union xfs_btree_key	*k1,

	union xfs_btree_key	*k2)

{

	return (__int64_t)be32_to_cpu(k1->alloc.ar_startblock) -

			  be32_to_cpu(k2->alloc.ar_startblock);

}



STATIC __int64_t

xfs_cntbt_diff_two_keys(

	struct xfs_btree_cur	*cur,

	union xfs_btree_key	*k1,

	union xfs_btree_key	*k2)

{

	__int64_t		diff;



	diff =  be32_to_cpu(k1->alloc.ar_blockcount) -

		be32_to_cpu(k2->alloc.ar_blockcount);

	if (diff)

		return diff;



	return  be32_to_cpu(k1->alloc.ar_startblock) -

		be32_to_cpu(k2->alloc.ar_startblock);

}



static bool

xfs_allocbt_verify(

	struct xfs_buf		*bp)
@@ -346,44 +397,54 @@ const struct xfs_buf_ops xfs_allocbt_buf_ops = { 


#if defined(DEBUG) || defined(XFS_WARN)

STATIC int

xfs_allocbt_keys_inorder(

xfs_bnobt_keys_inorder(

	struct xfs_btree_cur	*cur,

	union xfs_btree_key	*k1,

	union xfs_btree_key	*k2)

{

	if (cur->bc_btnum == XFS_BTNUM_BNO) {

	return be32_to_cpu(k1->alloc.ar_startblock) <

	       be32_to_cpu(k2->alloc.ar_startblock);

	} else {

}



STATIC int

xfs_bnobt_recs_inorder(

	struct xfs_btree_cur	*cur,

	union xfs_btree_rec	*r1,

	union xfs_btree_rec	*r2)

{

	return be32_to_cpu(r1->alloc.ar_startblock) +

		be32_to_cpu(r1->alloc.ar_blockcount) <=

		be32_to_cpu(r2->alloc.ar_startblock);

}



STATIC int

xfs_cntbt_keys_inorder(

	struct xfs_btree_cur	*cur,

	union xfs_btree_key	*k1,

	union xfs_btree_key	*k2)

{

	return be32_to_cpu(k1->alloc.ar_blockcount) <

		be32_to_cpu(k2->alloc.ar_blockcount) ||

		(k1->alloc.ar_blockcount == k2->alloc.ar_blockcount &&

		 be32_to_cpu(k1->alloc.ar_startblock) <

		 be32_to_cpu(k2->alloc.ar_startblock));

}

}



STATIC int

xfs_allocbt_recs_inorder(

xfs_cntbt_recs_inorder(

	struct xfs_btree_cur	*cur,

	union xfs_btree_rec	*r1,

	union xfs_btree_rec	*r2)

{

	if (cur->bc_btnum == XFS_BTNUM_BNO) {

		return be32_to_cpu(r1->alloc.ar_startblock) +

			be32_to_cpu(r1->alloc.ar_blockcount) <=

			be32_to_cpu(r2->alloc.ar_startblock);

	} else {

	return be32_to_cpu(r1->alloc.ar_blockcount) <

		be32_to_cpu(r2->alloc.ar_blockcount) ||

		(r1->alloc.ar_blockcount == r2->alloc.ar_blockcount &&

		 be32_to_cpu(r1->alloc.ar_startblock) <

		 be32_to_cpu(r2->alloc.ar_startblock));

}

}

#endif /* DEBUG */



static const struct xfs_btree_ops xfs_allocbt_ops = {

static const struct xfs_btree_ops xfs_bnobt_ops = {

	.rec_len		= sizeof(xfs_alloc_rec_t),

	.key_len		= sizeof(xfs_alloc_key_t),
@@ -395,13 +456,39 @@ static const struct xfs_btree_ops xfs_allocbt_ops = { 
	.get_minrecs		= xfs_allocbt_get_minrecs,

	.get_maxrecs		= xfs_allocbt_get_maxrecs,

	.init_key_from_rec	= xfs_allocbt_init_key_from_rec,

	.init_high_key_from_rec	= xfs_bnobt_init_high_key_from_rec,

	.init_rec_from_cur	= xfs_allocbt_init_rec_from_cur,

	.init_ptr_from_cur	= xfs_allocbt_init_ptr_from_cur,

	.key_diff		= xfs_allocbt_key_diff,

	.key_diff		= xfs_bnobt_key_diff,

	.buf_ops		= &xfs_allocbt_buf_ops,

	.diff_two_keys		= xfs_bnobt_diff_two_keys,

#if defined(DEBUG) || defined(XFS_WARN)

	.keys_inorder		= xfs_allocbt_keys_inorder,

	.recs_inorder		= xfs_allocbt_recs_inorder,

	.keys_inorder		= xfs_bnobt_keys_inorder,

	.recs_inorder		= xfs_bnobt_recs_inorder,

#endif

};



static const struct xfs_btree_ops xfs_cntbt_ops = {

	.rec_len		= sizeof(xfs_alloc_rec_t),

	.key_len		= sizeof(xfs_alloc_key_t),



	.dup_cursor		= xfs_allocbt_dup_cursor,

	.set_root		= xfs_allocbt_set_root,

	.alloc_block		= xfs_allocbt_alloc_block,

	.free_block		= xfs_allocbt_free_block,

	.update_lastrec		= xfs_allocbt_update_lastrec,

	.get_minrecs		= xfs_allocbt_get_minrecs,

	.get_maxrecs		= xfs_allocbt_get_maxrecs,

	.init_key_from_rec	= xfs_allocbt_init_key_from_rec,

	.init_high_key_from_rec	= xfs_cntbt_init_high_key_from_rec,

	.init_rec_from_cur	= xfs_allocbt_init_rec_from_cur,

	.init_ptr_from_cur	= xfs_allocbt_init_ptr_from_cur,

	.key_diff		= xfs_cntbt_key_diff,

	.buf_ops		= &xfs_allocbt_buf_ops,

	.diff_two_keys		= xfs_cntbt_diff_two_keys,

#if defined(DEBUG) || defined(XFS_WARN)

	.keys_inorder		= xfs_cntbt_keys_inorder,

	.recs_inorder		= xfs_cntbt_recs_inorder,

#endif

};
@@ -427,16 +514,15 @@ xfs_allocbt_init_cursor( 
	cur->bc_mp = mp;

	cur->bc_btnum = btnum;

	cur->bc_blocklog = mp->m_sb.sb_blocklog;

	cur->bc_ops = &xfs_allocbt_ops;

	if (btnum == XFS_BTNUM_BNO)

		cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_abtb_2);

	else

		cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_abtc_2);



	if (btnum == XFS_BTNUM_CNT) {

		cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_abtc_2);

		cur->bc_ops = &xfs_cntbt_ops;

		cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]);

		cur->bc_flags = XFS_BTREE_LASTREC_UPDATE;

	} else {

		cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_abtb_2);

		cur->bc_ops = &xfs_bnobt_ops;

		cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]);

	}