lael-labs/linux

fs/xfs/Makefile+1−0

@@ -71,6 +71,7 @@ xfs-y += xfs_alloc.o \ · 70 unmodified lines
71	xfs_dir2_sf.o \	71	xfs_dir2_sf.o \
72	xfs_ialloc.o \	72	xfs_ialloc.o \
73	xfs_ialloc_btree.o \	73	xfs_ialloc_btree.o \
		74	xfs_icreate_item.o \
74	xfs_inode.o \	75	xfs_inode.o \
75	xfs_log_recover.o \	76	xfs_log_recover.o \
76	xfs_mount.o \	77	xfs_mount.o \

fs/xfs/xfs_alloc.c+18−6

 	xfs_agblock_t	wantbno,	/* target starting block */
 	xfs_extlen_t	wantlen,	/* target length */
 	xfs_extlen_t	alignment,	/* target alignment */
+	char		userdata,	/* are we allocating data? */
 	xfs_agblock_t	freebno,	/* freespace's starting block */
 	xfs_extlen_t	freelen,	/* freespace's length */
 	xfs_agblock_t	*newbnop)	/* result: best start block from free */
 	ASSERT(freelen >= wantlen);
 	freeend = freebno + freelen;
 	wantend = wantbno + wantlen;
-	if (freebno >= wantbno) {
+	/*
+	 * We want to allocate from the start of a free extent if it is past
+	 * the desired block or if we are allocating user data and the free
+	 * extent is before desired block. The second case is there to allow
+	 * for contiguous allocation from the remaining free space if the file
+	 * grows in the short term.
+	 */
+	if (freebno >= wantbno || (userdata && freeend < wantend)) {
 		if ((newbno1 = roundup(freebno, alignment)) >= freeend)
 			newbno1 = NULLAGBLOCK;
 	} else if (freeend >= wantend && alignment > 1) {
 			xfs_alloc_fix_len(args);
 			sdiff = xfs_alloc_compute_diff(args->agbno, args->len,
-						       args->alignment, *sbnoa,
+						       args->alignment,
+						       args->userdata, *sbnoa,
 						       *slena, &new);
 			/*
 			if (args->len < blen)
 				continue;
 			ltdiff = xfs_alloc_compute_diff(args->agbno, args->len,
-				args->alignment, ltbnoa, ltlena, &ltnew);
+				args->alignment, args->userdata, ltbnoa,
+				ltlena, &ltnew);
 			if (ltnew != NULLAGBLOCK &&
 			    (args->len > blen || ltdiff < bdiff)) {
 				bdiff = ltdiff;
 			args->len = XFS_EXTLEN_MIN(ltlena, args->maxlen);
 			xfs_alloc_fix_len(args);
 			ltdiff = xfs_alloc_compute_diff(args->agbno, args->len,
-				args->alignment, ltbnoa, ltlena, &ltnew);
+				args->alignment, args->userdata, ltbnoa,
+				ltlena, &ltnew);
 			error = xfs_alloc_find_best_extent(args,
 						&bno_cur_lt, &bno_cur_gt,
 			args->len = XFS_EXTLEN_MIN(gtlena, args->maxlen);
 			xfs_alloc_fix_len(args);
 			gtdiff = xfs_alloc_compute_diff(args->agbno, args->len,
-				args->alignment, gtbnoa, gtlena, &gtnew);
+				args->alignment, args->userdata, gtbnoa,
+				gtlena, &gtnew);
 			error = xfs_alloc_find_best_extent(args,
 						&bno_cur_gt, &bno_cur_lt,
 	}
 	rlen = args->len;
 	(void)xfs_alloc_compute_diff(args->agbno, rlen, args->alignment,
-				     ltbnoa, ltlena, &ltnew);
+				     args->userdata, ltbnoa, ltlena, &ltnew);
 	ASSERT(ltnew >= ltbno);
 	ASSERT(ltnew + rlen <= ltbnoa + ltlena);
 	ASSERT(ltnew + rlen <= be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length));

fs/xfs/xfs_bmap_btree.h+2−0

@@ -196,6 +196,8 @@ typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t; · 195 unmodified lines
196	#define XFS_BMDR_SPACE_CALC(nrecs) \	196	#define XFS_BMDR_SPACE_CALC(nrecs) \
197	(int)(sizeof(xfs_bmdr_block_t) + \	197	(int)(sizeof(xfs_bmdr_block_t) + \
198	((nrecs) * (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t))))	198	((nrecs) * (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t))))
		199	#define XFS_BMAP_BMDR_SPACE(bb) \
		200	(XFS_BMDR_SPACE_CALC(be16_to_cpu((bb)->bb_numrecs)))
199		201
200	/*	202	/*
201	* Maximum number of bmap btree levels.	203	* Maximum number of bmap btree levels.

fs/xfs/xfs_buf_item.c+58−29

@@ -140,6 +140,16 @@ xfs_buf_item_size( · 139 unmodified lines
140		140
141	ASSERT(bip->bli_flags & XFS_BLI_LOGGED);	141	ASSERT(bip->bli_flags & XFS_BLI_LOGGED);
142		142
		143	if (bip->bli_flags & XFS_BLI_ORDERED) {
		144	/*
		145	* The buffer has been logged just to order it.
		146	* It is not being included in the transaction
		147	* commit, so no vectors are used at all.
		148	*/
		149	trace_xfs_buf_item_size_ordered(bip);
		150	return XFS_LOG_VEC_ORDERED;
		151	}
		152
143	/*	153	/*
144	* the vector count is based on the number of buffer vectors we have	154	* the vector count is based on the number of buffer vectors we have
145	* dirty bits in. This will only be greater than one when we have a	155	* dirty bits in. This will only be greater than one when we have a
@@ -212,6 +222,7 @@ xfs_buf_item_format_segment( · 66 unmodified lines
212	goto out;	222	goto out;
213	}	223	}
214		224
		225
215	/*	226	/*
216	* Fill in an iovec for each set of contiguous chunks.	227	* Fill in an iovec for each set of contiguous chunks.
217	*/	228	*/
@@ -299,18 +310,36 @@ xfs_buf_item_format( · 81 unmodified lines
299		310
300	/*	311	/*
301	* If it is an inode buffer, transfer the in-memory state to the	312	* If it is an inode buffer, transfer the in-memory state to the
302	* format flags and clear the in-memory state. We do not transfer	313	* format flags and clear the in-memory state.
		314	*
		315	* For buffer based inode allocation, we do not transfer
303	* this state if the inode buffer allocation has not yet been committed	316	* this state if the inode buffer allocation has not yet been committed
304	* to the log as setting the XFS_BLI_INODE_BUF flag will prevent	317	* to the log as setting the XFS_BLI_INODE_BUF flag will prevent
305	* correct replay of the inode allocation.	318	* correct replay of the inode allocation.
		319	*
		320	* For icreate item based inode allocation, the buffers aren't written
		321	* to the journal during allocation, and hence we should always tag the
		322	* buffer as an inode buffer so that the correct unlinked list replay
		323	* occurs during recovery.
306	*/	324	*/
307	if (bip->bli_flags & XFS_BLI_INODE_BUF) {	325	if (bip->bli_flags & XFS_BLI_INODE_BUF) {
308	if (!((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&	326	if (xfs_sb_version_hascrc(&lip->li_mountp->m_sb) \|\|
		327	!((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&
309	xfs_log_item_in_current_chkpt(lip)))	328	xfs_log_item_in_current_chkpt(lip)))
310	bip->__bli_format.blf_flags \|= XFS_BLF_INODE_BUF;	329	bip->__bli_format.blf_flags \|= XFS_BLF_INODE_BUF;
311	bip->bli_flags &= ~XFS_BLI_INODE_BUF;	330	bip->bli_flags &= ~XFS_BLI_INODE_BUF;
312	}	331	}
313		332
		333	if ((bip->bli_flags & (XFS_BLI_ORDERED\|XFS_BLI_STALE)) ==
		334	XFS_BLI_ORDERED) {
		335	/*
		336	* The buffer has been logged just to order it. It is not being
		337	* included in the transaction commit, so don't format it.
		338	*/
		339	trace_xfs_buf_item_format_ordered(bip);
		340	return;
		341	}
		342
314	for (i = 0; i < bip->bli_format_count; i++) {	343	for (i = 0; i < bip->bli_format_count; i++) {
315	vecp = xfs_buf_item_format_segment(bip, vecp, offset,	344	vecp = xfs_buf_item_format_segment(bip, vecp, offset,
316	&bip->bli_formats[i]);	345	&bip->bli_formats[i]);
@@ -340,6 +369,7 @@ xfs_buf_item_pin( · 23 unmodified lines
340		369
341	ASSERT(atomic_read(&bip->bli_refcount) > 0);	370	ASSERT(atomic_read(&bip->bli_refcount) > 0);
342	ASSERT((bip->bli_flags & XFS_BLI_LOGGED) \|\|	371	ASSERT((bip->bli_flags & XFS_BLI_LOGGED) \|\|
		372	(bip->bli_flags & XFS_BLI_ORDERED) \|\|
343	(bip->bli_flags & XFS_BLI_STALE));	373	(bip->bli_flags & XFS_BLI_STALE));
344		374
345	trace_xfs_buf_item_pin(bip);	375	trace_xfs_buf_item_pin(bip);
@@ -512,8 +542,9 @@ xfs_buf_item_unlock( · 166 unmodified lines
512	{	542	{
513	struct xfs_buf_log_item *bip = BUF_ITEM(lip);	543	struct xfs_buf_log_item *bip = BUF_ITEM(lip);
514	struct xfs_buf *bp = bip->bli_buf;	544	struct xfs_buf *bp = bip->bli_buf;
515	int aborted, clean, i;	545	bool clean;
516	uint hold;	546	bool aborted;
		547	int flags;
517		548
518	/* Clear the buffer's association with this transaction. */	549	/* Clear the buffer's association with this transaction. */
519	bp->b_transp = NULL;	550	bp->b_transp = NULL;
@@ -524,23 +555,21 @@ xfs_buf_item_unlock( · 4 unmodified lines
524	* (cancelled) buffers at unpin time, but we'll never go through the	555	* (cancelled) buffers at unpin time, but we'll never go through the
525	* pin/unpin cycle if we abort inside commit.	556	* pin/unpin cycle if we abort inside commit.
526	*/	557	*/
527	aborted = (lip->li_flags & XFS_LI_ABORTED) != 0;	558	aborted = (lip->li_flags & XFS_LI_ABORTED) ? true : false;
528
529	/*	559	/*
530	* Before possibly freeing the buf item, determine if we should	560	* Before possibly freeing the buf item, copy the per-transaction state
531	* release the buffer at the end of this routine.	561	* so we can reference it safely later after clearing it from the
		562	* buffer log item.
532	*/	563	*/
533	hold = bip->bli_flags & XFS_BLI_HOLD;	564	flags = bip->bli_flags;
534		565	bip->bli_flags &= ~(XFS_BLI_LOGGED \| XFS_BLI_HOLD \| XFS_BLI_ORDERED);
535	/* Clear the per transaction state. */
536	bip->bli_flags &= ~(XFS_BLI_LOGGED \| XFS_BLI_HOLD);
537		566
538	/*	567	/*
539	* If the buf item is marked stale, then don't do anything. We'll	568	* If the buf item is marked stale, then don't do anything. We'll
540	* unlock the buffer and free the buf item when the buffer is unpinned	569	* unlock the buffer and free the buf item when the buffer is unpinned
541	* for the last time.	570	* for the last time.
542	*/	571	*/
543	if (bip->bli_flags & XFS_BLI_STALE) {	572	if (flags & XFS_BLI_STALE) {
544	trace_xfs_buf_item_unlock_stale(bip);	573	trace_xfs_buf_item_unlock_stale(bip);
545	ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);	574	ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);
546	if (!aborted) {	575	if (!aborted) {
@@ -557,13 +586,19 @@ xfs_buf_item_unlock( · 10 unmodified lines
557	* be the only reference to the buf item, so we free it anyway	586	* be the only reference to the buf item, so we free it anyway
558	* regardless of whether it is dirty or not. A dirty abort implies a	587	* regardless of whether it is dirty or not. A dirty abort implies a
559	* shutdown, anyway.	588	* shutdown, anyway.
		589	*
		590	* Ordered buffers are dirty but may have no recorded changes, so ensure
		591	* we only release clean items here.
560	*/	592	*/
561	clean = 1;	593	clean = (flags & XFS_BLI_DIRTY) ? false : true;
562	for (i = 0; i < bip->bli_format_count; i++) {	594	if (clean) {
563	if (!xfs_bitmap_empty(bip->bli_formats[i].blf_data_map,	595	int i;
564	bip->bli_formats[i].blf_map_size)) {	596	for (i = 0; i < bip->bli_format_count; i++) {
565	clean = 0;	597	if (!xfs_bitmap_empty(bip->bli_formats[i].blf_data_map,
566	break;	598	bip->bli_formats[i].blf_map_size)) {
		599	clean = false;
		600	break;
		601	}
567	}	602	}
568	}	603	}
569	if (clean)	604	if (clean)
@@ -576,7 +611,7 @@ xfs_buf_item_unlock( · 6 unmodified lines
576	} else	611	} else
577	atomic_dec(&bip->bli_refcount);	612	atomic_dec(&bip->bli_refcount);
578		613
579	if (!hold)	614	if (!(flags & XFS_BLI_HOLD))
580	xfs_buf_relse(bp);	615	xfs_buf_relse(bp);
581	}	616	}
582		617
@@ -841,12 +876,6 @@ xfs_buf_item_log( · 258 unmodified lines
841	uint end;	876	uint end;
842	struct xfs_buf *bp = bip->bli_buf;	877	struct xfs_buf *bp = bip->bli_buf;
843		878
844	/*
845	* Mark the item as having some dirty data for
846	* quick reference in xfs_buf_item_dirty.
847	*/
848	bip->bli_flags \|= XFS_BLI_DIRTY;
849
850	/*	879	/*
851	* walk each buffer segment and mark them dirty appropriately.	880	* walk each buffer segment and mark them dirty appropriately.
852	*/	881	*/
@@ -873,7 +902,7 @@ xfs_buf_item_log( · 20 unmodified lines
873		902
874		903
875	/*	904	/*
876	* Return 1 if the buffer has some data that has been logged (at any	905	* Return 1 if the buffer has been logged or ordered in a transaction (at any
877	* point, not just the current transaction) and 0 if not.	906	* point, not just the current transaction) and 0 if not.
878	*/	907	*/
879	uint	908	uint
@@ -907,11 +936,11 @@ void · 27 unmodified lines
907	xfs_buf_item_relse(	936	xfs_buf_item_relse(
908	xfs_buf_t *bp)	937	xfs_buf_t *bp)
909	{	938	{
910	xfs_buf_log_item_t *bip;	939	xfs_buf_log_item_t *bip = bp->b_fspriv;
911		940
912	trace_xfs_buf_item_relse(bp, _RET_IP_);	941	trace_xfs_buf_item_relse(bp, _RET_IP_);
		942	ASSERT(!(bip->bli_item.li_flags & XFS_LI_IN_AIL));
913		943
914	bip = bp->b_fspriv;
915	bp->b_fspriv = bip->bli_item.li_bio_list;	944	bp->b_fspriv = bip->bli_item.li_bio_list;
916	if (bp->b_fspriv == NULL)	945	if (bp->b_fspriv == NULL)
917	bp->b_iodone = NULL;	946	bp->b_iodone = NULL;

fs/xfs/xfs_buf_item.h+3−1

 #define	XFS_BLI_INODE_ALLOC_BUF	0x10
 #define XFS_BLI_STALE_INODE	0x20
 #define	XFS_BLI_INODE_BUF	0x40
+#define	XFS_BLI_ORDERED		0x80
 #define XFS_BLI_FLAGS \
 	{ XFS_BLI_HOLD,		"HOLD" }, \
 	{ XFS_BLI_LOGGED,	"LOGGED" }, \
 	{ XFS_BLI_INODE_ALLOC_BUF, "INODE_ALLOC" }, \
 	{ XFS_BLI_STALE_INODE,	"STALE_INODE" }, \
-	{ XFS_BLI_INODE_BUF,	"INODE_BUF" }
+	{ XFS_BLI_INODE_BUF,	"INODE_BUF" }, \
+	{ XFS_BLI_ORDERED,	"ORDERED" }
 #ifdef __KERNEL__

fs/xfs/xfs_dfrag.c+5−3

 #include "xfs_ag.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
+#include "xfs_ialloc_btree.h"
+#include "xfs_btree.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
 	 */
 	if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
 		if (XFS_IFORK_BOFF(ip) &&
-		    tip->i_df.if_broot_bytes > XFS_IFORK_BOFF(ip))
+		    XFS_BMAP_BMDR_SPACE(tip->i_df.if_broot) > XFS_IFORK_BOFF(ip))
 			return EINVAL;
 		if (XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <=
 		    XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
 	/* Reciprocal target->temp btree format checks */
 	if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
 		if (XFS_IFORK_BOFF(tip) &&
-		    ip->i_df.if_broot_bytes > XFS_IFORK_BOFF(tip))
+		    XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > XFS_IFORK_BOFF(tip))
 			return EINVAL;
 		if (XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <=
 		    XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
 			return EINVAL;

fs/xfs/xfs_dir2_leaf.c+3−0

 	struct xfs_mount	*mp = dp->i_mount;
 	struct xfs_buf		*bp = *bpp;
 	struct xfs_bmbt_irec	*map = mip->map;
+	struct blk_plug		plug;
 	int			error = 0;
 	int			length;
 	int			i;
 	/*
 	 * Do we need more readahead?
 	 */
+	blk_start_plug(&plug);
 	for (mip->ra_index = mip->ra_offset = i = 0;
 	     mip->ra_want > mip->ra_current && i < mip->map_blocks;
 	     i += mp->m_dirblkfsbs) {
 			}
 		}
 	}
+	blk_finish_plug(&plug);
 out:
 	*bpp = bp;

fs/xfs/xfs_dquot.c+8−8

@@ -570,13 +570,13 @@ xfs_qm_dqtobp( · 569 unmodified lines
570	xfs_buf_t **O_bpp,	570	xfs_buf_t **O_bpp,
571	uint flags)	571	uint flags)
572	{	572	{
573	xfs_bmbt_irec_t map;	573	struct xfs_bmbt_irec map;
574	int nmaps = 1, error;	574	int nmaps = 1, error;
575	xfs_buf_t *bp;	575	struct xfs_buf *bp;
576	xfs_inode_t *quotip = XFS_DQ_TO_QIP(dqp);	576	struct xfs_inode *quotip = xfs_dq_to_quota_inode(dqp);
577	xfs_mount_t *mp = dqp->q_mount;	577	struct xfs_mount *mp = dqp->q_mount;
578	xfs_dqid_t id = be32_to_cpu(dqp->q_core.d_id);	578	xfs_dqid_t id = be32_to_cpu(dqp->q_core.d_id);
579	xfs_trans_t tp = (tpp ? tpp : NULL);	579	struct xfs_trans tp = (tpp ? tpp : NULL);
580		580
581	dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;	581	dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
582		582
@@ -804,7 +804,7 @@ xfs_qm_dqget( · 221 unmodified lines
804	xfs_dquot_t *O_dqpp) / OUT : locked incore dquot */	804	xfs_dquot_t *O_dqpp) / OUT : locked incore dquot */
805	{	805	{
806	struct xfs_quotainfo *qi = mp->m_quotainfo;	806	struct xfs_quotainfo *qi = mp->m_quotainfo;
807	struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type);	807	struct radix_tree_root *tree = xfs_dquot_tree(qi, type);
808	struct xfs_dquot *dqp;	808	struct xfs_dquot *dqp;
809	int error;	809	int error;
810		810

fs/xfs/xfs_dquot.h+0−4

 #define XFS_QM_ISUDQ(dqp)	((dqp)->dq_flags & XFS_DQ_USER)
 #define XFS_QM_ISPDQ(dqp)	((dqp)->dq_flags & XFS_DQ_PROJ)
 #define XFS_QM_ISGDQ(dqp)	((dqp)->dq_flags & XFS_DQ_GROUP)
-#define XFS_DQ_TO_QINF(dqp)	((dqp)->q_mount->m_quotainfo)
-#define XFS_DQ_TO_QIP(dqp)	(XFS_QM_ISUDQ(dqp) ? \
-				 XFS_DQ_TO_QINF(dqp)->qi_uquotaip : \
-				 XFS_DQ_TO_QINF(dqp)->qi_gquotaip)
 extern int		xfs_qm_dqread(struct xfs_mount *, xfs_dqid_t, uint,
 					uint, struct xfs_dquot	**);

fs/xfs/xfs_fsops.c+1−1

@@ -176,7 +176,7 @@ xfs_growfs_data_private( · 175 unmodified lines
176	if (!bp)	176	if (!bp)
177	return EIO;	177	return EIO;
178	if (bp->b_error) {	178	if (bp->b_error) {
179	int error = bp->b_error;	179	error = bp->b_error;
180	xfs_buf_relse(bp);	180	xfs_buf_relse(bp);
181	return error;	181	return error;
182	}	182	}

fs/xfs/xfs_ialloc.c+53−21

@@ -38,6 +38,7 @@ · 37 unmodified lines
38	#include "xfs_bmap.h"	38	#include "xfs_bmap.h"
39	#include "xfs_cksum.h"	39	#include "xfs_cksum.h"
40	#include "xfs_buf_item.h"	40	#include "xfs_buf_item.h"
		41	#include "xfs_icreate_item.h"
41		42
42		43
43	/*	44	/*
@@ -150,12 +151,16 @@ xfs_check_agi_freecount( · 106 unmodified lines
150	#endif	151	#endif
151		152
152	/*	153	/*
153	* Initialise a new set of inodes.	154	* Initialise a new set of inodes. When called without a transaction context
		155	* (e.g. from recovery) we initiate a delayed write of the inode buffers rather
		156	* than logging them (which in a transaction context puts them into the AIL
		157	* for writeback rather than the xfsbufd queue).
154	*/	158	*/
155	STATIC int	159	int
156	xfs_ialloc_inode_init(	160	xfs_ialloc_inode_init(
157	struct xfs_mount *mp,	161	struct xfs_mount *mp,
158	struct xfs_trans *tp,	162	struct xfs_trans *tp,
		163	struct list_head *buffer_list,
159	xfs_agnumber_t agno,	164	xfs_agnumber_t agno,
160	xfs_agblock_t agbno,	165	xfs_agblock_t agbno,
161	xfs_agblock_t length,	166	xfs_agblock_t length,
@@ -208,6 +213,18 @@ xfs_ialloc_inode_init( · 46 unmodified lines
208	version = 3;	213	version = 3;
209	ino = XFS_AGINO_TO_INO(mp, agno,	214	ino = XFS_AGINO_TO_INO(mp, agno,
210	XFS_OFFBNO_TO_AGINO(mp, agbno, 0));	215	XFS_OFFBNO_TO_AGINO(mp, agbno, 0));
		216
		217	/*
		218	* log the initialisation that is about to take place as an
		219	* logical operation. This means the transaction does not
		220	* need to log the physical changes to the inode buffers as log
		221	* recovery will know what initialisation is actually needed.
		222	* Hence we only need to log the buffers as "ordered" buffers so
		223	* they track in the AIL as if they were physically logged.
		224	*/
		225	if (tp)
		226	xfs_icreate_log(tp, agno, agbno, XFS_IALLOC_INODES(mp),
		227	mp->m_sb.sb_inodesize, length, gen);
211	} else if (xfs_sb_version_hasnlink(&mp->m_sb))	228	} else if (xfs_sb_version_hasnlink(&mp->m_sb))
212	version = 2;	229	version = 2;
213	else	230	else
@@ -223,13 +240,8 @@ xfs_ialloc_inode_init( · 9 unmodified lines
223	XBF_UNMAPPED);	240	XBF_UNMAPPED);
224	if (!fbuf)	241	if (!fbuf)
225	return ENOMEM;	242	return ENOMEM;
226	/*	243
227	* Initialize all inodes in this buffer and then log them.	244	/* Initialize the inode buffers and log them appropriately. */
228	*
229	* XXX: It would be much better if we had just one transaction
230	* to log a whole cluster of inodes instead of all the
231	* individual transactions causing a lot of log traffic.
232	*/
233	fbuf->b_ops = &xfs_inode_buf_ops;	245	fbuf->b_ops = &xfs_inode_buf_ops;
234	xfs_buf_zero(fbuf, 0, BBTOB(fbuf->b_length));	246	xfs_buf_zero(fbuf, 0, BBTOB(fbuf->b_length));
235	for (i = 0; i < ninodes; i++) {	247	for (i = 0; i < ninodes; i++) {
@@ -247,18 +259,39 @@ xfs_ialloc_inode_init( · 11 unmodified lines
247	ino++;	259	ino++;
248	uuid_copy(&free->di_uuid, &mp->m_sb.sb_uuid);	260	uuid_copy(&free->di_uuid, &mp->m_sb.sb_uuid);
249	xfs_dinode_calc_crc(mp, free);	261	xfs_dinode_calc_crc(mp, free);
250	} else {	262	} else if (tp) {
251	/* just log the inode core */	263	/* just log the inode core */
252	xfs_trans_log_buf(tp, fbuf, ioffset,	264	xfs_trans_log_buf(tp, fbuf, ioffset,
253	ioffset + isize - 1);	265	ioffset + isize - 1);
254	}	266	}
255	}	267	}
256	if (version == 3) {	268
257	/* need to log the entire buffer */	269	if (tp) {
258	xfs_trans_log_buf(tp, fbuf, 0,	270	/*
259	BBTOB(fbuf->b_length) - 1);	271	* Mark the buffer as an inode allocation buffer so it
		272	* sticks in AIL at the point of this allocation
		273	* transaction. This ensures the they are on disk before
		274	* the tail of the log can be moved past this
		275	* transaction (i.e. by preventing relogging from moving
		276	* it forward in the log).
		277	*/
		278	xfs_trans_inode_alloc_buf(tp, fbuf);
		279	if (version == 3) {
		280	/*
		281	* Mark the buffer as ordered so that they are
		282	* not physically logged in the transaction but
		283	* still tracked in the AIL as part of the
		284	* transaction and pin the log appropriately.
		285	*/
		286	xfs_trans_ordered_buf(tp, fbuf);
		287	xfs_trans_log_buf(tp, fbuf, 0,
		288	BBTOB(fbuf->b_length) - 1);
		289	}
		290	} else {
		291	fbuf->b_flags \|= XBF_DONE;
		292	xfs_buf_delwri_queue(fbuf, buffer_list);
		293	xfs_buf_relse(fbuf);
260	}	294	}
261	xfs_trans_inode_alloc_buf(tp, fbuf);
262	}	295	}
263	return 0;	296	return 0;
264	}	297	}
@@ -303,7 +336,7 @@ xfs_ialloc_ag_alloc( · 38 unmodified lines
303	* First try to allocate inodes contiguous with the last-allocated	336	* First try to allocate inodes contiguous with the last-allocated
304	* chunk of inodes. If the filesystem is striped, this will fill	337	* chunk of inodes. If the filesystem is striped, this will fill
305	* an entire stripe unit with inodes.	338	* an entire stripe unit with inodes.
306	*/	339	*/
307	agi = XFS_BUF_TO_AGI(agbp);	340	agi = XFS_BUF_TO_AGI(agbp);
308	newino = be32_to_cpu(agi->agi_newino);	341	newino = be32_to_cpu(agi->agi_newino);
309	agno = be32_to_cpu(agi->agi_seqno);	342	agno = be32_to_cpu(agi->agi_seqno);
@@ -402,7 +435,7 @@ xfs_ialloc_ag_alloc( · 92 unmodified lines
402	* rather than a linear progression to prevent the next generation	435	* rather than a linear progression to prevent the next generation
403	* number from being easily guessable.	436	* number from being easily guessable.
404	*/	437	*/
405	error = xfs_ialloc_inode_init(args.mp, tp, agno, args.agbno,	438	error = xfs_ialloc_inode_init(args.mp, tp, NULL, agno, args.agbno,
406	args.len, prandom_u32());	439	args.len, prandom_u32());
407		440
408	if (error)	441	if (error)
@@ -615,8 +648,7 @@ xfs_ialloc_get_rec( · 206 unmodified lines
615	struct xfs_btree_cur *cur,	648	struct xfs_btree_cur *cur,
616	xfs_agino_t agino,	649	xfs_agino_t agino,
617	xfs_inobt_rec_incore_t *rec,	650	xfs_inobt_rec_incore_t *rec,
618	int *done,	651	int *done)
619	int left)
620	{	652	{
621	int error;	653	int error;
622	int i;	654	int i;
@@ -724,12 +756,12 @@ xfs_dialloc_ag( · 101 unmodified lines
724	pag->pagl_leftrec != NULLAGINO &&	756	pag->pagl_leftrec != NULLAGINO &&
725	pag->pagl_rightrec != NULLAGINO) {	757	pag->pagl_rightrec != NULLAGINO) {
726	error = xfs_ialloc_get_rec(tcur, pag->pagl_leftrec,	758	error = xfs_ialloc_get_rec(tcur, pag->pagl_leftrec,
727	&trec, &doneleft, 1);	759	&trec, &doneleft);
728	if (error)	760	if (error)
729	goto error1;	761	goto error1;
730		762
731	error = xfs_ialloc_get_rec(cur, pag->pagl_rightrec,	763	error = xfs_ialloc_get_rec(cur, pag->pagl_rightrec,
732	&rec, &doneright, 0);	764	&rec, &doneright);
733	if (error)	765	if (error)
734	goto error1;	766	goto error1;
735	} else {	767	} else {

fs/xfs/xfs_ialloc.h+8−0

@@ -150,6 +150,14 @@ int xfs_inobt_lookup(struct xfs_btree_cur *cur, xfs_agino_t ino, · 149 unmodified lines
150	int xfs_inobt_get_rec(struct xfs_btree_cur *cur,	150	int xfs_inobt_get_rec(struct xfs_btree_cur *cur,
151	xfs_inobt_rec_incore_t rec, int stat);	151	xfs_inobt_rec_incore_t rec, int stat);
152		152
		153	/*
		154	* Inode chunk initialisation routine
		155	*/
		156	int xfs_ialloc_inode_init(struct xfs_mount mp, struct xfs_trans tp,
		157	struct list_head *buffer_list,
		158	xfs_agnumber_t agno, xfs_agblock_t agbno,
		159	xfs_agblock_t length, unsigned int gen);
		160
153	extern const struct xfs_buf_ops xfs_agi_buf_ops;	161	extern const struct xfs_buf_ops xfs_agi_buf_ops;
154		162
155	#endif /* __XFS_IALLOC_H__ */	163	#endif /* __XFS_IALLOC_H__ */

fs/xfs/xfs_icache.c+2−1

@@ -335,7 +335,8 @@ xfs_iget_cache_miss( · 334 unmodified lines
335	iflags = XFS_INEW;	335	iflags = XFS_INEW;
336	if (flags & XFS_IGET_DONTCACHE)	336	if (flags & XFS_IGET_DONTCACHE)
337	iflags \|= XFS_IDONTCACHE;	337	iflags \|= XFS_IDONTCACHE;
338	ip->i_udquot = ip->i_gdquot = NULL;	338	ip->i_udquot = NULL;
		339	ip->i_gdquot = NULL;
339	xfs_iflags_set(ip, iflags);	340	xfs_iflags_set(ip, iflags);
340		341
341	/* insert the new inode */	342	/* insert the new inode */

fs/xfs/xfs_icache.h+0−1

@@ -40,7 +40,6 @@ void xfs_inode_clear_eofblocks_tag(struct xfs_inode *ip); · 39 unmodified lines
40	int xfs_icache_free_eofblocks(struct xfs_mount , struct xfs_eofblocks );	40	int xfs_icache_free_eofblocks(struct xfs_mount , struct xfs_eofblocks );
41	void xfs_eofblocks_worker(struct work_struct *);	41	void xfs_eofblocks_worker(struct work_struct *);
42		42
43	int xfs_sync_inode_grab(struct xfs_inode *ip);
44	int xfs_inode_ag_iterator(struct xfs_mount *mp,	43	int xfs_inode_ag_iterator(struct xfs_mount *mp,
45	int (execute)(struct xfs_inode ip, struct xfs_perag *pag,	44	int (execute)(struct xfs_inode ip, struct xfs_perag *pag,
46	int flags, void *args),	45	int flags, void *args),

fs/xfs/xfs_icreate_item.c+195−0

@@ -0,0 +1,195 @@
	1	/*
	2	* Copyright (c) 2008-2010, 2013 Dave Chinner
	3	* All Rights Reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18	#include "xfs.h"
	19	#include "xfs_fs.h"
	20	#include "xfs_types.h"
	21	#include "xfs_bit.h"
	22	#include "xfs_log.h"
	23	#include "xfs_inum.h"
	24	#include "xfs_trans.h"
	25	#include "xfs_buf_item.h"
	26	#include "xfs_sb.h"
	27	#include "xfs_ag.h"
	28	#include "xfs_dir2.h"
	29	#include "xfs_mount.h"
	30	#include "xfs_trans_priv.h"
	31	#include "xfs_bmap_btree.h"
	32	#include "xfs_alloc_btree.h"
	33	#include "xfs_ialloc_btree.h"
	34	#include "xfs_attr_sf.h"
	35	#include "xfs_dinode.h"
	36	#include "xfs_inode.h"
	37	#include "xfs_inode_item.h"
	38	#include "xfs_btree.h"
	39	#include "xfs_ialloc.h"
	40	#include "xfs_error.h"
	41	#include "xfs_icreate_item.h"
	42
	43	kmem_zone_t xfs_icreate_zone; / inode create item zone */
	44
	45	static inline struct xfs_icreate_item ICR_ITEM(struct xfs_log_item lip)
	46	{
	47	return container_of(lip, struct xfs_icreate_item, ic_item);
	48	}
	49
	50	/*
	51	* This returns the number of iovecs needed to log the given inode item.
	52	*
	53	* We only need one iovec for the icreate log structure.
	54	*/
	55	STATIC uint
	56	xfs_icreate_item_size(
	57	struct xfs_log_item *lip)
	58	{
	59	return 1;
	60	}
	61
	62	/*
	63	* This is called to fill in the vector of log iovecs for the
	64	* given inode create log item.
	65	*/
	66	STATIC void
	67	xfs_icreate_item_format(
	68	struct xfs_log_item *lip,
	69	struct xfs_log_iovec *log_vector)
	70	{
	71	struct xfs_icreate_item *icp = ICR_ITEM(lip);
	72
	73	log_vector->i_addr = (xfs_caddr_t)&icp->ic_format;
	74	log_vector->i_len = sizeof(struct xfs_icreate_log);
	75	log_vector->i_type = XLOG_REG_TYPE_ICREATE;
	76	}
	77
	78
	79	/* Pinning has no meaning for the create item, so just return. */
	80	STATIC void
	81	xfs_icreate_item_pin(
	82	struct xfs_log_item *lip)
	83	{
	84	}
	85
	86
	87	/* pinning has no meaning for the create item, so just return. */
	88	STATIC void
	89	xfs_icreate_item_unpin(
	90	struct xfs_log_item *lip,
	91	int remove)
	92	{
	93	}
	94
	95	STATIC void
	96	xfs_icreate_item_unlock(
	97	struct xfs_log_item *lip)
	98	{
	99	struct xfs_icreate_item *icp = ICR_ITEM(lip);
	100
	101	if (icp->ic_item.li_flags & XFS_LI_ABORTED)
	102	kmem_zone_free(xfs_icreate_zone, icp);
	103	return;
	104	}
	105
	106	/*
	107	* Because we have ordered buffers being tracked in the AIL for the inode
	108	* creation, we don't need the create item after this. Hence we can free
	109	* the log item and return -1 to tell the caller we're done with the item.
	110	*/
	111	STATIC xfs_lsn_t
	112	xfs_icreate_item_committed(
	113	struct xfs_log_item *lip,
	114	xfs_lsn_t lsn)
	115	{
	116	struct xfs_icreate_item *icp = ICR_ITEM(lip);
	117
	118	kmem_zone_free(xfs_icreate_zone, icp);
	119	return (xfs_lsn_t)-1;
	120	}
	121
	122	/* item can never get into the AIL */
	123	STATIC uint
	124	xfs_icreate_item_push(
	125	struct xfs_log_item *lip,
	126	struct list_head *buffer_list)
	127	{
	128	ASSERT(0);
	129	return XFS_ITEM_SUCCESS;
	130	}
	131
	132	/* Ordered buffers do the dependency tracking here, so this does nothing. */
	133	STATIC void
	134	xfs_icreate_item_committing(
	135	struct xfs_log_item *lip,
	136	xfs_lsn_t lsn)
	137	{
	138	}
	139
	140	/*
	141	* This is the ops vector shared by all buf log items.
	142	*/
	143	static struct xfs_item_ops xfs_icreate_item_ops = {
	144	.iop_size = xfs_icreate_item_size,
	145	.iop_format = xfs_icreate_item_format,
	146	.iop_pin = xfs_icreate_item_pin,
	147	.iop_unpin = xfs_icreate_item_unpin,
	148	.iop_push = xfs_icreate_item_push,
	149	.iop_unlock = xfs_icreate_item_unlock,
	150	.iop_committed = xfs_icreate_item_committed,
	151	.iop_committing = xfs_icreate_item_committing,
	152	};
	153
	154
	155	/*
	156	* Initialize the inode log item for a newly allocated (in-core) inode.
	157	*
	158	* Inode extents can only reside within an AG. Hence specify the starting
	159	* block for the inode chunk by offset within an AG as well as the
	160	* length of the allocated extent.
	161	*
	162	* This joins the item to the transaction and marks it dirty so
	163	* that we don't need a separate call to do this, nor does the
	164	* caller need to know anything about the icreate item.
	165	*/
	166	void
	167	xfs_icreate_log(
	168	struct xfs_trans *tp,
	169	xfs_agnumber_t agno,
	170	xfs_agblock_t agbno,
	171	unsigned int count,
	172	unsigned int inode_size,
	173	xfs_agblock_t length,
	174	unsigned int generation)
	175	{
	176	struct xfs_icreate_item *icp;
	177
	178	icp = kmem_zone_zalloc(xfs_icreate_zone, KM_SLEEP);
	179
	180	xfs_log_item_init(tp->t_mountp, &icp->ic_item, XFS_LI_ICREATE,
	181	&xfs_icreate_item_ops);
	182
	183	icp->ic_format.icl_type = XFS_LI_ICREATE;
	184	icp->ic_format.icl_size = 1; /* single vector */
	185	icp->ic_format.icl_ag = cpu_to_be32(agno);
	186	icp->ic_format.icl_agbno = cpu_to_be32(agbno);
	187	icp->ic_format.icl_count = cpu_to_be32(count);
	188	icp->ic_format.icl_isize = cpu_to_be32(inode_size);
	189	icp->ic_format.icl_length = cpu_to_be32(length);
	190	icp->ic_format.icl_gen = cpu_to_be32(generation);
	191
	192	xfs_trans_add_item(tp, &icp->ic_item);
	193	tp->t_flags \|= XFS_TRANS_DIRTY;
	194	icp->ic_item.li_desc->lid_flags \|= XFS_LID_DIRTY;
	195	}

fs/xfs/xfs_icreate_item.h+52−0

@@ -0,0 +1,52 @@
	1	/*
	2	* Copyright (c) 2008-2010, Dave Chinner
	3	* All Rights Reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18	#ifndef XFS_ICREATE_ITEM_H
	19	#define XFS_ICREATE_ITEM_H 1
	20
	21	/*
	22	* on disk log item structure
	23	*
	24	* Log recovery assumes the first two entries are the type and size and they fit
	25	* in 32 bits. Also in host order (ugh) so they have to be 32 bit aligned so
	26	* decoding can be done correctly.
	27	*/
	28	struct xfs_icreate_log {
	29	__uint16_t icl_type; /* type of log format structure */
	30	__uint16_t icl_size; /* size of log format structure */
	31	__be32 icl_ag; /* ag being allocated in */
	32	__be32 icl_agbno; /* start block of inode range */
	33	__be32 icl_count; /* number of inodes to initialise */
	34	__be32 icl_isize; /* size of inodes */
	35	__be32 icl_length; /* length of extent to initialise */
	36	__be32 icl_gen; /* inode generation number to use */
	37	};
	38
	39	/* in memory log item structure */
	40	struct xfs_icreate_item {
	41	struct xfs_log_item ic_item;
	42	struct xfs_icreate_log ic_format;
	43	};
	44
	45	extern kmem_zone_t xfs_icreate_zone; / inode create item zone */
	46
	47	void xfs_icreate_log(struct xfs_trans *tp, xfs_agnumber_t agno,
	48	xfs_agblock_t agbno, unsigned int count,
	49	unsigned int inode_size, xfs_agblock_t length,
	50	unsigned int generation);
	51
	52	#endif /* XFS_ICREATE_ITEM_H */

fs/xfs/xfs_inode.c+32−36

@@ -1028,6 +1028,11 @@ xfs_dinode_calc_crc( · 1027 unmodified lines
1028		1028
1029	/*	1029	/*
1030	* Read the disk inode attributes into the in-core inode structure.	1030	* Read the disk inode attributes into the in-core inode structure.
		1031	*
		1032	* If we are initialising a new inode and we are not utilising the
		1033	* XFS_MOUNT_IKEEP inode cluster mode, we can simple build the new inode core
		1034	* with a random generation number. If we are keeping inodes around, we need to
		1035	* read the inode cluster to get the existing generation number off disk.
1031	*/	1036	*/
1032	int	1037	int
1033	xfs_iread(	1038	xfs_iread(
@@ -1047,6 +1052,22 @@ xfs_iread( · 13 unmodified lines
1047	if (error)	1052	if (error)
1048	return error;	1053	return error;
1049		1054
		1055	/* shortcut IO on inode allocation if possible */
		1056	if ((iget_flags & XFS_IGET_CREATE) &&
		1057	!(mp->m_flags & XFS_MOUNT_IKEEP)) {
		1058	/* initialise the on-disk inode core */
		1059	memset(&ip->i_d, 0, sizeof(ip->i_d));
		1060	ip->i_d.di_magic = XFS_DINODE_MAGIC;
		1061	ip->i_d.di_gen = prandom_u32();
		1062	if (xfs_sb_version_hascrc(&mp->m_sb)) {
		1063	ip->i_d.di_version = 3;
		1064	ip->i_d.di_ino = ip->i_ino;
		1065	uuid_copy(&ip->i_d.di_uuid, &mp->m_sb.sb_uuid);
		1066	} else
		1067	ip->i_d.di_version = 2;
		1068	return 0;
		1069	}
		1070
1050	/*	1071	/*
1051	* Get pointers to the on-disk inode and the buffer containing it.	1072	* Get pointers to the on-disk inode and the buffer containing it.
1052	*/	1073	*/
@@ -1133,17 +1154,16 @@ xfs_iread( · 80 unmodified lines
1133	xfs_buf_set_ref(bp, XFS_INO_REF);	1154	xfs_buf_set_ref(bp, XFS_INO_REF);
1134		1155
1135	/*	1156	/*
1136	* Use xfs_trans_brelse() to release the buffer containing the	1157	* Use xfs_trans_brelse() to release the buffer containing the on-disk
1137	* on-disk inode, because it was acquired with xfs_trans_read_buf()	1158	* inode, because it was acquired with xfs_trans_read_buf() in
1138	* in xfs_imap_to_bp() above. If tp is NULL, this is just a normal	1159	* xfs_imap_to_bp() above. If tp is NULL, this is just a normal
1139	* brelse(). If we're within a transaction, then xfs_trans_brelse()	1160	* brelse(). If we're within a transaction, then xfs_trans_brelse()
1140	* will only release the buffer if it is not dirty within the	1161	* will only release the buffer if it is not dirty within the
1141	* transaction. It will be OK to release the buffer in this case,	1162	* transaction. It will be OK to release the buffer in this case,
1142	* because inodes on disk are never destroyed and we will be	1163	* because inodes on disk are never destroyed and we will be locking the
1143	* locking the new in-core inode before putting it in the hash	1164	* new in-core inode before putting it in the cache where other
1144	* table where other processes can find it. Thus we don't have	1165	* processes can find it. Thus we don't have to worry about the inode
1145	* to worry about the inode being changed just because we released	1166	* being changed just because we released the buffer.
1146	* the buffer.
1147	*/	1167	*/
1148	out_brelse:	1168	out_brelse:
1149	xfs_trans_brelse(tp, bp);	1169	xfs_trans_brelse(tp, bp);
@@ -2028,8 +2048,6 @@ xfs_ifree( · 878 unmodified lines
2028	int error;	2048	int error;
2029	int delete;	2049	int delete;
2030	xfs_ino_t first_ino;	2050	xfs_ino_t first_ino;
2031	xfs_dinode_t *dip;
2032	xfs_buf_t *ibp;
2033		2051
2034	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));	2052	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2035	ASSERT(ip->i_d.di_nlink == 0);	2053	ASSERT(ip->i_d.di_nlink == 0);
@@ -2042,14 +2060,13 @@ xfs_ifree( · 6 unmodified lines
2042	* Pull the on-disk inode from the AGI unlinked list.	2060	* Pull the on-disk inode from the AGI unlinked list.
2043	*/	2061	*/
2044	error = xfs_iunlink_remove(tp, ip);	2062	error = xfs_iunlink_remove(tp, ip);
2045	if (error != 0) {	2063	if (error)
2046	return error;	2064	return error;
2047	}
2048		2065
2049	error = xfs_difree(tp, ip->i_ino, flist, &delete, &first_ino);	2066	error = xfs_difree(tp, ip->i_ino, flist, &delete, &first_ino);
2050	if (error != 0) {	2067	if (error)
2051	return error;	2068	return error;
2052	}	2069
2053	ip->i_d.di_mode = 0; /* mark incore inode as free */	2070	ip->i_d.di_mode = 0; /* mark incore inode as free */
2054	ip->i_d.di_flags = 0;	2071	ip->i_d.di_flags = 0;
2055	ip->i_d.di_dmevmask = 0;	2072	ip->i_d.di_dmevmask = 0;
@@ -2061,31 +2078,10 @@ xfs_ifree( · 5 unmodified lines
2061	* by reincarnations of this inode.	2078	* by reincarnations of this inode.
2062	*/	2079	*/
2063	ip->i_d.di_gen++;	2080	ip->i_d.di_gen++;
2064
2065	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);	2081	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2066		2082
2067	error = xfs_imap_to_bp(ip->i_mount, tp, &ip->i_imap, &dip, &ibp,	2083	if (delete)
2068	0, 0);
2069	if (error)
2070	return error;
2071
2072	/*
2073	* Clear the on-disk di_mode. This is to prevent xfs_bulkstat
2074	* from picking up this inode when it is reclaimed (its incore state
2075	* initialzed but not flushed to disk yet). The in-core di_mode is
2076	* already cleared and a corresponding transaction logged.
2077	* The hack here just synchronizes the in-core to on-disk
2078	* di_mode value in advance before the actual inode sync to disk.
2079	* This is OK because the inode is already unlinked and would never
2080	* change its di_mode again for this inode generation.
2081	* This is a temporary hack that would require a proper fix
2082	* in the future.
2083	*/
2084	dip->di_mode = 0;
2085
2086	if (delete) {
2087	error = xfs_ifree_cluster(ip, tp, first_ino);	2084	error = xfs_ifree_cluster(ip, tp, first_ino);
2088	}
2089		2085
2090	return error;	2086	return error;
2091	}	2087	}

fs/xfs/xfs_iomap.c+13−0

@@ -283,6 +283,15 @@ xfs_iomap_eof_want_preallocate( · 282 unmodified lines
283	if (offset + count <= XFS_ISIZE(ip))	283	if (offset + count <= XFS_ISIZE(ip))
284	return 0;	284	return 0;
285		285
		286	/*
		287	* If the file is smaller than the minimum prealloc and we are using
		288	* dynamic preallocation, don't do any preallocation at all as it is
		289	* likely this is the only write to the file that is going to be done.
		290	*/
		291	if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE) &&
		292	XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_writeio_blocks))
		293	return 0;
		294
286	/*	295	/*
287	* If there are any real blocks past eof, then don't	296	* If there are any real blocks past eof, then don't
288	* do any speculative allocation.	297	* do any speculative allocation.
@@ -345,6 +354,10 @@ xfs_iomap_eof_prealloc_initial_size( · 56 unmodified lines
345	if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)	354	if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)
346	return 0;	355	return 0;
347		356
		357	/* If the file is small, then use the minimum prealloc */
		358	if (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_dalign))
		359	return 0;
		360
348	/*	361	/*
349	* As we write multiple pages, the offset will always align to the	362	* As we write multiple pages, the offset will always align to the
350	* start of a page and hence point to a hole at EOF. i.e. if the size is	363	* start of a page and hence point to a hole at EOF. i.e. if the size is

fs/xfs/xfs_iops.c+2−1

 	if (bmv->bmv_oflags & BMV_OF_PREALLOC)
 		fiemap_flags |= FIEMAP_EXTENT_UNWRITTEN;
 	else if (bmv->bmv_oflags & BMV_OF_DELALLOC) {
-		fiemap_flags |= FIEMAP_EXTENT_DELALLOC;
+		fiemap_flags |= (FIEMAP_EXTENT_DELALLOC |
+				 FIEMAP_EXTENT_UNKNOWN);
 		physical = 0;   /* no block yet */
 	}
 	if (bmv->bmv_oflags & BMV_OF_LAST)

fs/xfs/xfs_itable.c+4−1

 {
 	return (ino == mp->m_sb.sb_rbmino || ino == mp->m_sb.sb_rsumino ||
 		(xfs_sb_version_hasquota(&mp->m_sb) &&
-		 (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino)));
+		 xfs_is_quota_inode(&mp->m_sb, ino)));
 }
 /*
 			 * Also start read-ahead now for this chunk.
 			 */
 			if (r.ir_freecount < XFS_INODES_PER_CHUNK) {
+				struct blk_plug	plug;
 				/*
 				 * Loop over all clusters in the next chunk.
 				 * Do a readahead if there are any allocated
 				 * inodes in that cluster.
 				 */
+				blk_start_plug(&plug);
 				agbno = XFS_AGINO_TO_AGBNO(mp, r.ir_startino);
 				for (chunkidx = 0;
 				     chunkidx < XFS_INODES_PER_CHUNK;
 							agbno, nbcluster,
 							&xfs_inode_buf_ops);
 				}
+				blk_finish_plug(&plug);
 				irbp->ir_startino = r.ir_startino;
 				irbp->ir_freecount = r.ir_freecount;
 				irbp->ir_free = r.ir_free;

fs/xfs/xfs_log.c+18−4

 		headers++;
 	for (lv = log_vector; lv; lv = lv->lv_next) {
+		/* we don't write ordered log vectors */
+		if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED)
+			continue;
 		headers += lv->lv_niovecs;
 		for (i = 0; i < lv->lv_niovecs; i++) {
 	index = 0;
 	lv = log_vector;
 	vecp = lv->lv_iovecp;
-	while (lv && index < lv->lv_niovecs) {
+	while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
 		void		*ptr;
 		int		log_offset;
 		 * This loop writes out as many regions as can fit in the amount
 		 * of space which was allocated by xlog_state_get_iclog_space().
 		 */
-		while (lv && index < lv->lv_niovecs) {
+		while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
-			struct xfs_log_iovec	*reg = &vecp[index];
+			struct xfs_log_iovec	*reg;
 			struct xlog_op_header	*ophdr;
 			int			start_rec_copy;
 			int			copy_len;
 			int			copy_off;
+			bool			ordered = false;
+			/* ordered log vectors have no regions to write */
+			if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) {
+				ASSERT(lv->lv_niovecs == 0);
+				ordered = true;
+				goto next_lv;
+			}
+			reg = &vecp[index];
 			ASSERT(reg->i_len % sizeof(__int32_t) == 0);
 			ASSERT((unsigned long)ptr % sizeof(__int32_t) == 0);
 				break;
 			if (++index == lv->lv_niovecs) {
+next_lv:
 				lv = lv->lv_next;
 				index = 0;
 				if (lv)
 					vecp = lv->lv_iovecp;
 			}
-			if (record_cnt == 0) {
+			if (record_cnt == 0 && ordered == false) {
 				if (!lv)
 					return 0;
 				break;

fs/xfs/xfs_log.h+4−1

 #define XLOG_REG_TYPE_UNMOUNT		17
 #define XLOG_REG_TYPE_COMMIT		18
 #define XLOG_REG_TYPE_TRANSHDR		19
-#define XLOG_REG_TYPE_MAX		19
+#define XLOG_REG_TYPE_ICREATE		20
+#define XLOG_REG_TYPE_MAX		20
 typedef struct xfs_log_iovec {
 	void		*i_addr;	/* beginning address of region */
 	int			lv_buf_len;	/* size of formatted buffer */
 };
+#define XFS_LOG_VEC_ORDERED	(-1)
 /*
  * Structure used to pass callback function and the function's argument
  * to the log manager.

fs/xfs/xfs_log_cil.c+51−24

 		int	index;
 		int	len = 0;
 		uint	niovecs;
+		bool	ordered = false;
 		/* Skip items which aren't dirty in this transaction. */
 		if (!(lidp->lid_flags & XFS_LID_DIRTY))
 		if (!niovecs)
 			continue;
+		/*
+		 * Ordered items need to be tracked but we do not wish to write
+		 * them. We need a logvec to track the object, but we do not
+		 * need an iovec or buffer to be allocated for copying data.
+		 */
+		if (niovecs == XFS_LOG_VEC_ORDERED) {
+			ordered = true;
+			niovecs = 0;
+		}
 		new_lv = kmem_zalloc(sizeof(*new_lv) +
 				niovecs * sizeof(struct xfs_log_iovec),
 				KM_SLEEP|KM_NOFS);
+		new_lv->lv_item = lidp->lid_item;
+		new_lv->lv_niovecs = niovecs;
+		if (ordered) {
+			/* track as an ordered logvec */
+			new_lv->lv_buf_len = XFS_LOG_VEC_ORDERED;
+			goto next;
+		}
 		/* The allocated iovec region lies beyond the log vector. */
 		new_lv->lv_iovecp = (struct xfs_log_iovec *)&new_lv[1];
-		new_lv->lv_niovecs = niovecs;
-		new_lv->lv_item = lidp->lid_item;
 		/* build the vector array and calculate it's length */
 		IOP_FORMAT(new_lv->lv_item, new_lv->lv_iovecp);
 		}
 		ASSERT(ptr == new_lv->lv_buf + new_lv->lv_buf_len);
+next:
 		if (!ret_lv)
 			ret_lv = new_lv;
 		else
 	if (old) {
 		/* existing lv on log item, space used is a delta */
-		ASSERT(!list_empty(&lv->lv_item->li_cil));
+		ASSERT((old->lv_buf && old->lv_buf_len && old->lv_niovecs) ||
-		ASSERT(old->lv_buf && old->lv_buf_len && old->lv_niovecs);
+			old->lv_buf_len == XFS_LOG_VEC_ORDERED);
+		/*
+		 * If the new item is ordered, keep the old one that is already
+		 * tracking dirty or ordered regions
+		 */
+		if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) {
+			ASSERT(!lv->lv_buf);
+			kmem_free(lv);
+			return;
+		}
 		*len += lv->lv_buf_len - old->lv_buf_len;
 		*diff_iovecs += lv->lv_niovecs - old->lv_niovecs;
 	} else {
 		/* new lv, must pin the log item */
 		ASSERT(!lv->lv_item->li_lv);
-		ASSERT(list_empty(&lv->lv_item->li_cil));
-		*len += lv->lv_buf_len;
+		if (lv->lv_buf_len != XFS_LOG_VEC_ORDERED) {
-		*diff_iovecs += lv->lv_niovecs;
+			*len += lv->lv_buf_len;
+			*diff_iovecs += lv->lv_niovecs;
+		}
 		IOP_PIN(lv->lv_item);
 	}
 	 * We can do this safely because the context can't checkpoint until we
 	 * are done so it doesn't matter exactly how we update the CIL.
 	 */
-	for (lv = log_vector; lv; lv = lv->lv_next)
-		xfs_cil_prepare_item(log, lv, &len, &diff_iovecs);
-	/* account for space used by new iovec headers  */
-	len += diff_iovecs * sizeof(xlog_op_header_t);
 	spin_lock(&cil->xc_cil_lock);
+	for (lv = log_vector; lv; ) {
+		struct xfs_log_vec *next = lv->lv_next;
-	/* move the items to the tail of the CIL */
+		ASSERT(lv->lv_item->li_lv || list_empty(&lv->lv_item->li_cil));
-	for (lv = log_vector; lv; lv = lv->lv_next)
+		lv->lv_next = NULL;
+		/*
+		 * xfs_cil_prepare_item() may free the lv, so move the item on
+		 * the CIL first.
+		 */
 		list_move_tail(&lv->lv_item->li_cil, &cil->xc_cil);
+		xfs_cil_prepare_item(log, lv, &len, &diff_iovecs);
+		lv = next;
+	}
+	/* account for space used by new iovec headers  */
+	len += diff_iovecs * sizeof(xlog_op_header_t);
 	ctx->nvecs += diff_iovecs;
 	/*
 	struct xfs_cil_ctx	*new_ctx;
 	struct xlog_in_core	*commit_iclog;
 	struct xlog_ticket	*tic;
-	int			num_lv;
 	int			num_iovecs;
-	int			len;
 	int			error = 0;
 	struct xfs_trans_header thdr;
 	struct xfs_log_iovec	lhdr;
 	 * side which is currently locked out by the flush lock.
 	 */
 	lv = NULL;
-	num_lv = 0;
 	num_iovecs = 0;
-	len = 0;
 	while (!list_empty(&cil->xc_cil)) {
 		struct xfs_log_item	*item;
-		int			i;
 		item = list_first_entry(&cil->xc_cil,
 					struct xfs_log_item, li_cil);
 			lv->lv_next = item->li_lv;
 		lv = item->li_lv;
 		item->li_lv = NULL;
-		num_lv++;
 		num_iovecs += lv->lv_niovecs;
-		for (i = 0; i < lv->lv_niovecs; i++)
-			len += lv->lv_iovecp[i].i_len;
 	}
 	/*
 	if (commit_lsn)
 		*commit_lsn = log->l_cilp->xc_ctx->sequence;
+	/* xlog_cil_insert_items() destroys log_vector list */
 	xlog_cil_insert_items(log, log_vector, tp->t_ticket);
 	/* check we didn't blow the reservation */

fs/xfs/xfs_log_recover.c+109−5

@@ -45,6 +45,7 @@ · 44 unmodified lines
45	#include "xfs_cksum.h"	45	#include "xfs_cksum.h"
46	#include "xfs_trace.h"	46	#include "xfs_trace.h"
47	#include "xfs_icache.h"	47	#include "xfs_icache.h"
		48	#include "xfs_icreate_item.h"
48		49
49	/* Need all the magic numbers and buffer ops structures from these headers */	50	/* Need all the magic numbers and buffer ops structures from these headers */
50	#include "xfs_symlink.h"	51	#include "xfs_symlink.h"
@@ -1617,7 +1618,10 @@ xlog_recover_add_to_trans( · 1566 unmodified lines
1617	* form the cancelled buffer table. Hence they have tobe done last.	1618	* form the cancelled buffer table. Hence they have tobe done last.
1618	*	1619	*
1619	* 3. Inode allocation buffers must be replayed before inode items that	1620	* 3. Inode allocation buffers must be replayed before inode items that
1620	* read the buffer and replay changes into it.	1621	* read the buffer and replay changes into it. For filesystems using the
		1622	* ICREATE transactions, this means XFS_LI_ICREATE objects need to get
		1623	* treated the same as inode allocation buffers as they create and
		1624	* initialise the buffers directly.
1621	*	1625	*
1622	* 4. Inode unlink buffers must be replayed after inode items are replayed.	1626	* 4. Inode unlink buffers must be replayed after inode items are replayed.
1623	* This ensures that inodes are completely flushed to the inode buffer	1627	* This ensures that inodes are completely flushed to the inode buffer
@@ -1632,10 +1636,17 @@ xlog_recover_add_to_trans( · 8 unmodified lines
1632	* from all the other buffers and move them to last.	1636	* from all the other buffers and move them to last.
1633	*	1637	*
1634	* Hence, 4 lists, in order from head to tail:	1638	* Hence, 4 lists, in order from head to tail:
1635	* - buffer_list for all buffers except cancelled/inode unlink buffers	1639	* - buffer_list for all buffers except cancelled/inode unlink buffers
1636	* - item_list for all non-buffer items	1640	* - item_list for all non-buffer items
1637	* - inode_buffer_list for inode unlink buffers	1641	* - inode_buffer_list for inode unlink buffers
1638	* - cancel_list for the cancelled buffers	1642	* - cancel_list for the cancelled buffers
		1643	*
		1644	* Note that we add objects to the tail of the lists so that first-to-last
		1645	* ordering is preserved within the lists. Adding objects to the head of the
		1646	* list means when we traverse from the head we walk them in last-to-first
		1647	* order. For cancelled buffers and inode unlink buffers this doesn't matter,
		1648	* but for all other items there may be specific ordering that we need to
		1649	* preserve.
1639	*/	1650	*/
1640	STATIC int	1651	STATIC int
1641	xlog_recover_reorder_trans(	1652	xlog_recover_reorder_trans(
@@ -1655,6 +1666,9 @@ xlog_recover_reorder_trans( · 13 unmodified lines
1655	xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;	1666	xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
1656		1667
1657	switch (ITEM_TYPE(item)) {	1668	switch (ITEM_TYPE(item)) {
		1669	case XFS_LI_ICREATE:
		1670	list_move_tail(&item->ri_list, &buffer_list);
		1671	break;
1658	case XFS_LI_BUF:	1672	case XFS_LI_BUF:
1659	if (buf_f->blf_flags & XFS_BLF_CANCEL) {	1673	if (buf_f->blf_flags & XFS_BLF_CANCEL) {
1660	trace_xfs_log_recover_item_reorder_head(log,	1674	trace_xfs_log_recover_item_reorder_head(log,
@@ -2981,6 +2995,93 @@ xlog_recover_efd_pass2( · 1320 unmodified lines
2981	return 0;	2995	return 0;
2982	}	2996	}
2983		2997
		2998	/*
		2999	* This routine is called when an inode create format structure is found in a
		3000	* committed transaction in the log. It's purpose is to initialise the inodes
		3001	* being allocated on disk. This requires us to get inode cluster buffers that
		3002	* match the range to be intialised, stamped with inode templates and written
		3003	* by delayed write so that subsequent modifications will hit the cached buffer
		3004	* and only need writing out at the end of recovery.
		3005	*/
		3006	STATIC int
		3007	xlog_recover_do_icreate_pass2(
		3008	struct xlog *log,
		3009	struct list_head *buffer_list,
		3010	xlog_recover_item_t *item)
		3011	{
		3012	struct xfs_mount *mp = log->l_mp;
		3013	struct xfs_icreate_log *icl;
		3014	xfs_agnumber_t agno;
		3015	xfs_agblock_t agbno;
		3016	unsigned int count;
		3017	unsigned int isize;
		3018	xfs_agblock_t length;
		3019
		3020	icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
		3021	if (icl->icl_type != XFS_LI_ICREATE) {
		3022	xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad type");
		3023	return EINVAL;
		3024	}
		3025
		3026	if (icl->icl_size != 1) {
		3027	xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad icl size");
		3028	return EINVAL;
		3029	}
		3030
		3031	agno = be32_to_cpu(icl->icl_ag);
		3032	if (agno >= mp->m_sb.sb_agcount) {
		3033	xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agno");
		3034	return EINVAL;
		3035	}
		3036	agbno = be32_to_cpu(icl->icl_agbno);
		3037	if (!agbno \|\| agbno == NULLAGBLOCK \|\| agbno >= mp->m_sb.sb_agblocks) {
		3038	xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agbno");
		3039	return EINVAL;
		3040	}
		3041	isize = be32_to_cpu(icl->icl_isize);
		3042	if (isize != mp->m_sb.sb_inodesize) {
		3043	xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad isize");
		3044	return EINVAL;
		3045	}
		3046	count = be32_to_cpu(icl->icl_count);
		3047	if (!count) {
		3048	xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count");
		3049	return EINVAL;
		3050	}
		3051	length = be32_to_cpu(icl->icl_length);
		3052	if (!length \|\| length >= mp->m_sb.sb_agblocks) {
		3053	xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad length");
		3054	return EINVAL;
		3055	}
		3056
		3057	/* existing allocation is fixed value */
		3058	ASSERT(count == XFS_IALLOC_INODES(mp));
		3059	ASSERT(length == XFS_IALLOC_BLOCKS(mp));
		3060	if (count != XFS_IALLOC_INODES(mp) \|\|
		3061	length != XFS_IALLOC_BLOCKS(mp)) {
		3062	xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count 2");
		3063	return EINVAL;
		3064	}
		3065
		3066	/*
		3067	* Inode buffers can be freed. Do not replay the inode initialisation as
		3068	* we could be overwriting something written after this inode buffer was
		3069	* cancelled.
		3070	*
		3071	* XXX: we need to iterate all buffers and only init those that are not
		3072	* cancelled. I think that a more fine grained factoring of
		3073	* xfs_ialloc_inode_init may be appropriate here to enable this to be
		3074	* done easily.
		3075	*/
		3076	if (xlog_check_buffer_cancelled(log,
		3077	XFS_AGB_TO_DADDR(mp, agno, agbno), length, 0))
		3078	return 0;
		3079
		3080	xfs_ialloc_inode_init(mp, NULL, buffer_list, agno, agbno, length,
		3081	be32_to_cpu(icl->icl_gen));
		3082	return 0;
		3083	}
		3084
2984	/*	3085	/*
2985	* Free up any resources allocated by the transaction	3086	* Free up any resources allocated by the transaction
2986	*	3087	*
@@ -3023,6 +3124,7 @@ xlog_recover_commit_pass1( · 36 unmodified lines
3023	case XFS_LI_EFI:	3124	case XFS_LI_EFI:
3024	case XFS_LI_EFD:	3125	case XFS_LI_EFD:
3025	case XFS_LI_DQUOT:	3126	case XFS_LI_DQUOT:
		3127	case XFS_LI_ICREATE:
3026	/* nothing to do in pass 1 */	3128	/* nothing to do in pass 1 */
3027	return 0;	3129	return 0;
3028	default:	3130	default:
@@ -3053,6 +3155,8 @@ xlog_recover_commit_pass2( · 24 unmodified lines
3053	return xlog_recover_efd_pass2(log, item);	3155	return xlog_recover_efd_pass2(log, item);
3054	case XFS_LI_DQUOT:	3156	case XFS_LI_DQUOT:
3055	return xlog_recover_dquot_pass2(log, buffer_list, item);	3157	return xlog_recover_dquot_pass2(log, buffer_list, item);
		3158	case XFS_LI_ICREATE:
		3159	return xlog_recover_do_icreate_pass2(log, buffer_list, item);
3056	case XFS_LI_QUOTAOFF:	3160	case XFS_LI_QUOTAOFF:
3057	/* nothing to do in pass2 */	3161	/* nothing to do in pass2 */
3058	return 0;	3162	return 0;

fs/xfs/xfs_mount.c+66−26

 		return XFS_ERROR(EWRONGFS);
 	}
+	if ((sbp->sb_qflags & (XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD)) &&
+			(sbp->sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD |
+				XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD))) {
+		xfs_notice(mp,
+"Super block has XFS_OQUOTA bits along with XFS_PQUOTA and/or XFS_GQUOTA bits.\n");
+		return XFS_ERROR(EFSCORRUPTED);
+	}
 	/*
 	 * Version 5 superblock feature mask validation. Reject combinations the
 	 * kernel cannot support up front before checking anything else. For
 	return error;
 }
+static void
+xfs_sb_quota_from_disk(struct xfs_sb *sbp)
+{
+	if (sbp->sb_qflags & XFS_OQUOTA_ENFD)
+		sbp->sb_qflags |= (sbp->sb_qflags & XFS_PQUOTA_ACCT) ?
+					XFS_PQUOTA_ENFD : XFS_GQUOTA_ENFD;
+	if (sbp->sb_qflags & XFS_OQUOTA_CHKD)
+		sbp->sb_qflags |= (sbp->sb_qflags & XFS_PQUOTA_ACCT) ?
+					XFS_PQUOTA_CHKD : XFS_GQUOTA_CHKD;
+	sbp->sb_qflags &= ~(XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD);
+}
 void
 xfs_sb_from_disk(
 	struct xfs_sb	*to,
 	to->sb_lsn = be64_to_cpu(from->sb_lsn);
 }
+static inline void
+xfs_sb_quota_to_disk(
+	xfs_dsb_t	*to,
+	xfs_sb_t	*from,
+	__int64_t	*fields)
+{
+	__uint16_t	qflags = from->sb_qflags;
+	if (*fields & XFS_SB_QFLAGS) {
+		/*
+		 * The in-core version of sb_qflags do not have
+		 * XFS_OQUOTA_* flags, whereas the on-disk version
+		 * does.  So, convert incore XFS_{PG}QUOTA_* flags
+		 * to on-disk XFS_OQUOTA_* flags.
+		 */
+		qflags &= ~(XFS_PQUOTA_ENFD | XFS_PQUOTA_CHKD |
+				XFS_GQUOTA_ENFD | XFS_GQUOTA_CHKD);
+		if (from->sb_qflags &
+				(XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD))
+			qflags |= XFS_OQUOTA_ENFD;
+		if (from->sb_qflags &
+				(XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD))
+			qflags |= XFS_OQUOTA_CHKD;
+		to->sb_qflags = cpu_to_be16(qflags);
+		*fields &= ~XFS_SB_QFLAGS;
+	}
+}
 /*
  * Copy in core superblock to ondisk one.
  *
 	if (!fields)
 		return;
+	xfs_sb_quota_to_disk(to, from, &fields);
 	while (fields) {
 		f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);
 		first = xfs_sb_info[f].offset;
 	 */
 	xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp));
+	xfs_sb_quota_from_disk(&mp->m_sb);
 	/*
 	 * We must be able to do sector-sized and sector-aligned IO.
 	 */
 		 */
 		if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
 		    (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
-			if (mp->m_flags & XFS_MOUNT_RETERR) {
+			xfs_warn(mp,
-				xfs_warn(mp, "alignment check failed: "
+		"alignment check failed: sunit/swidth vs. blocksize(%d)",
-					 "(sunit/swidth vs. blocksize)");
+				sbp->sb_blocksize);
-				return XFS_ERROR(EINVAL);
+			return XFS_ERROR(EINVAL);
-			}
-			mp->m_dalign = mp->m_swidth = 0;
 		} else {
 			/*
 			 * Convert the stripe unit and width to FSBs.
 			 */
 			mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
 			if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) {
-				if (mp->m_flags & XFS_MOUNT_RETERR) {
-					xfs_warn(mp, "alignment check failed: "
-						 "(sunit/swidth vs. ag size)");
-					return XFS_ERROR(EINVAL);
-				}
 				xfs_warn(mp,
-		"stripe alignment turned off: sunit(%d)/swidth(%d) "
+			"alignment check failed: sunit/swidth vs. agsize(%d)",
-		"incompatible with agsize(%d)",
+					 sbp->sb_agblocks);
-					mp->m_dalign, mp->m_swidth,
+				return XFS_ERROR(EINVAL);
-					sbp->sb_agblocks);
-				mp->m_dalign = 0;
-				mp->m_swidth = 0;
 			} else if (mp->m_dalign) {
 				mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
 			} else {
-				if (mp->m_flags & XFS_MOUNT_RETERR) {
+				xfs_warn(mp,
-					xfs_warn(mp, "alignment check failed: "
+			"alignment check failed: sunit(%d) less than bsize(%d)",
-						"sunit(%d) less than bsize(%d)",
+					 mp->m_dalign, sbp->sb_blocksize);
-						mp->m_dalign,
+				return XFS_ERROR(EINVAL);
-						mp->m_blockmask +1);
-					return XFS_ERROR(EINVAL);
-				}
-				mp->m_swidth = 0;
 			}
 		}
 				sbp->sb_width = mp->m_swidth;
 				mp->m_update_flags |= XFS_SB_WIDTH;
 			}
+		} else {
+			xfs_warn(mp,
+	"cannot change alignment: superblock does not support data alignment");
+			return XFS_ERROR(EINVAL);
 		}
 	} else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
 		    xfs_sb_version_hasdalign(&mp->m_sb)) {

fs/xfs/xfs_mount.h+0−4

 	xfs_dablk_t		m_dirleafblk;	/* blockno of dir non-data v2 */
 	xfs_dablk_t		m_dirfreeblk;	/* blockno of dirfreeindex v2 */
 	uint			m_chsize;	/* size of next field */
-	struct xfs_chash	*m_chash;	/* fs private inode per-cluster
-						 * hash table */
 	atomic_t		m_active_trans;	/* number trans frozen */
 #ifdef HAVE_PERCPU_SB
 	xfs_icsb_cnts_t __percpu *m_sb_cnts;	/* per-cpu superblock counters */
 						   operations, typically for
 						   disk errors in metadata */
 #define XFS_MOUNT_DISCARD	(1ULL << 5)	/* discard unused blocks */
-#define XFS_MOUNT_RETERR	(1ULL << 6)     /* return alignment errors to
-						   user */
 #define XFS_MOUNT_NOALIGN	(1ULL << 7)	/* turn off stripe alignment
 						   allocations */
 #define XFS_MOUNT_ATTR2		(1ULL << 8)	/* allow use of attr2 format */

fs/xfs/xfs_qm.c+92−83

 	void			*data)
 {
 	struct xfs_quotainfo	*qi = mp->m_quotainfo;
-	struct radix_tree_root	*tree = XFS_DQUOT_TREE(qi, type);
+	struct radix_tree_root	*tree = xfs_dquot_tree(qi, type);
 	uint32_t		next_index;
 	int			last_error = 0;
 	int			skipped;
 	xfs_dqfunlock(dqp);
 	xfs_dqunlock(dqp);
-	radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags),
+	radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
 			  be32_to_cpu(dqp->q_core.d_id));
 	qi->qi_dquots--;
 	 */
 	if (!XFS_IS_UQUOTA_ON(mp))
 		mp->m_qflags &= ~XFS_UQUOTA_CHKD;
-	if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
+	if (!XFS_IS_GQUOTA_ON(mp))
-		mp->m_qflags &= ~XFS_OQUOTA_CHKD;
+		mp->m_qflags &= ~XFS_GQUOTA_CHKD;
+	if (!XFS_IS_PQUOTA_ON(mp))
+		mp->m_qflags &= ~XFS_PQUOTA_CHKD;
  write_changes:
 	/*
 		return false;
 	if (!XFS_NOT_DQATTACHED(mp, ip))
 		return false;
-	if (ip->i_ino == mp->m_sb.sb_uquotino ||
+	if (xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
-	    ip->i_ino == mp->m_sb.sb_gquotino)
 		return false;
 	return true;
 }
 	trace_xfs_dquot_dqdetach(ip);
-	ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
+	ASSERT(!xfs_is_quota_inode(&ip->i_mount->m_sb, ip->i_ino));
-	ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
 	if (ip->i_udquot) {
 		xfs_qm_dqrele(ip->i_udquot);
 		ip->i_udquot = NULL;
 	 * rootino must have its resources accounted for, not so with the quota
 	 * inodes.
 	 */
-	if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
+	if (xfs_is_quota_inode(&mp->m_sb, ino)) {
 		*res = BULKSTAT_RV_NOTHING;
 		return XFS_ERROR(EINVAL);
 	}
 xfs_qm_quotacheck(
 	xfs_mount_t	*mp)
 {
-	int		done, count, error, error2;
+	int			done, count, error, error2;
-	xfs_ino_t	lastino;
+	xfs_ino_t		lastino;
-	size_t		structsz;
+	size_t			structsz;
-	xfs_inode_t	*uip, *gip;
+	uint			flags;
-	uint		flags;
+	LIST_HEAD		(buffer_list);
-	LIST_HEAD	(buffer_list);
+	struct xfs_inode	*uip = mp->m_quotainfo->qi_uquotaip;
+	struct xfs_inode	*gip = mp->m_quotainfo->qi_gquotaip;
 	count = INT_MAX;
 	structsz = 1;
 	lastino = 0;
 	flags = 0;
-	ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);
+	ASSERT(uip || gip);
 	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 	xfs_notice(mp, "Quotacheck needed: Please wait.");
 	 * their counters to zero. We need a clean slate.
 	 * We don't log our changes till later.
 	 */
-	uip = mp->m_quotainfo->qi_uquotaip;
 	if (uip) {
 		error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA,
 					 &buffer_list);
 		flags |= XFS_UQUOTA_CHKD;
 	}
-	gip = mp->m_quotainfo->qi_gquotaip;
 	if (gip) {
 		error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
 					 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA,
 					 &buffer_list);
 		if (error)
 			goto error_return;
-		flags |= XFS_OQUOTA_CHKD;
+		flags |= XFS_IS_GQUOTA_ON(mp) ?
+					XFS_GQUOTA_CHKD : XFS_PQUOTA_CHKD;
 	}
 	do {
 xfs_qm_init_quotainos(
 	xfs_mount_t	*mp)
 {
-	xfs_inode_t	*uip, *gip;
+	struct xfs_inode	*uip = NULL;
-	int		error;
+	struct xfs_inode	*gip = NULL;
-	__int64_t	sbflags;
+	int			error;
-	uint		flags;
+	__int64_t		sbflags = 0;
+	uint			flags = 0;
 	ASSERT(mp->m_quotainfo);
-	uip = gip = NULL;
-	sbflags = 0;
-	flags = 0;
 	/*
 	 * Get the uquota and gquota inodes
 		if (XFS_IS_UQUOTA_ON(mp) &&
 		    mp->m_sb.sb_uquotino != NULLFSINO) {
 			ASSERT(mp->m_sb.sb_uquotino > 0);
-			if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
+			error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
-					     0, 0, &uip)))
+					     0, 0, &uip);
+			if (error)
 				return XFS_ERROR(error);
 		}
 		if (XFS_IS_OQUOTA_ON(mp) &&
 		    mp->m_sb.sb_gquotino != NULLFSINO) {
 			ASSERT(mp->m_sb.sb_gquotino > 0);
-			if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
+			error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
-					     0, 0, &gip))) {
+					     0, 0, &gip);
-				if (uip)
+			if (error)
-					IRELE(uip);
+				goto error_rele;
-				return XFS_ERROR(error);
-			}
 		}
 	} else {
 		flags |= XFS_QMOPT_SBVERSION;
 	 * temporarily switch to read-write to do this.
 	 */
 	if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
-		if ((error = xfs_qm_qino_alloc(mp, &uip,
+		error = xfs_qm_qino_alloc(mp, &uip,
 					      sbflags | XFS_SB_UQUOTINO,
-					      flags | XFS_QMOPT_UQUOTA)))
+					      flags | XFS_QMOPT_UQUOTA);
-			return XFS_ERROR(error);
+		if (error)
+			goto error_rele;
 		flags &= ~XFS_QMOPT_SBVERSION;
 	}
 				XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
 		error = xfs_qm_qino_alloc(mp, &gip,
 					  sbflags | XFS_SB_GQUOTINO, flags);
-		if (error) {
+		if (error)
-			if (uip)
+			goto error_rele;
-				IRELE(uip);
-			return XFS_ERROR(error);
-		}
 	}
 	mp->m_quotainfo->qi_uquotaip = uip;
 	mp->m_quotainfo->qi_gquotaip = gip;
 	return 0;
+error_rele:
+	if (uip)
+		IRELE(uip);
+	if (gip)
+		IRELE(gip);
+	return XFS_ERROR(error);
 }
 STATIC void
 	struct xfs_quotainfo	*qi = mp->m_quotainfo;
 	mutex_lock(&qi->qi_tree_lock);
-	radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags),
+	radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
 			  be32_to_cpu(dqp->q_core.d_id));
 	qi->qi_dquots--;
 	struct xfs_dquot	**O_gdqpp)
 {
 	struct xfs_mount	*mp = ip->i_mount;
-	struct xfs_dquot	*uq, *gq;
+	struct xfs_dquot	*uq = NULL;
+	struct xfs_dquot	*gq = NULL;
 	int			error;
 	uint			lockflags;
 		}
 	}
-	uq = gq = NULL;
 	if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
 		if (ip->i_d.di_uid != uid) {
 			/*
 			 * holding ilock.
 			 */
 			xfs_iunlock(ip, lockflags);
-			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
+			error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
 						 XFS_DQ_USER,
 						 XFS_QMOPT_DQALLOC |
 						 XFS_QMOPT_DOWARN,
-						 &uq))) {
+						 &uq);
+			if (error) {
 				ASSERT(error != ENOENT);
 				return error;
 			}
 	if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
 		if (ip->i_d.di_gid != gid) {
 			xfs_iunlock(ip, lockflags);
-			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
+			error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
 						 XFS_DQ_GROUP,
 						 XFS_QMOPT_DQALLOC |
 						 XFS_QMOPT_DOWARN,
-						 &gq))) {
+						 &gq);
-				if (uq)
+			if (error) {
-					xfs_qm_dqrele(uq);
 				ASSERT(error != ENOENT);
-				return error;
+				goto error_rele;
 			}
 			xfs_dqunlock(gq);
 			lockflags = XFS_ILOCK_SHARED;
 	} else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
 		if (xfs_get_projid(ip) != prid) {
 			xfs_iunlock(ip, lockflags);
-			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
+			error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
 						 XFS_DQ_PROJ,
 						 XFS_QMOPT_DQALLOC |
 						 XFS_QMOPT_DOWARN,
-						 &gq))) {
+						 &gq);
-				if (uq)
+			if (error) {
-					xfs_qm_dqrele(uq);
 				ASSERT(error != ENOENT);
-				return (error);
+				goto error_rele;
 			}
 			xfs_dqunlock(gq);
 			lockflags = XFS_ILOCK_SHARED;
 	else if (gq)
 		xfs_qm_dqrele(gq);
 	return 0;
+error_rele:
+	if (uq)
+		xfs_qm_dqrele(uq);
+	return error;
 }
 /*
  */
 int
 xfs_qm_vop_chown_reserve(
-	xfs_trans_t	*tp,
+	struct xfs_trans	*tp,
-	xfs_inode_t	*ip,
+	struct xfs_inode	*ip,
-	xfs_dquot_t	*udqp,
+	struct xfs_dquot	*udqp,
-	xfs_dquot_t	*gdqp,
+	struct xfs_dquot	*gdqp,
-	uint		flags)
+	uint			flags)
 {
-	xfs_mount_t	*mp = ip->i_mount;
+	struct xfs_mount	*mp = ip->i_mount;
-	uint		delblks, blkflags, prjflags = 0;
+	uint			delblks, blkflags, prjflags = 0;
-	xfs_dquot_t	*unresudq, *unresgdq, *delblksudq, *delblksgdq;
+	struct xfs_dquot	*udq_unres = NULL;
-	int		error;
+	struct xfs_dquot	*gdq_unres = NULL;
+	struct xfs_dquot	*udq_delblks = NULL;
+	struct xfs_dquot	*gdq_delblks = NULL;
+	int			error;
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
 	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 	delblks = ip->i_delayed_blks;
-	delblksudq = delblksgdq = unresudq = unresgdq = NULL;
 	blkflags = XFS_IS_REALTIME_INODE(ip) ?
 			XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
 	if (XFS_IS_UQUOTA_ON(mp) && udqp &&
 	    ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
-		delblksudq = udqp;
+		udq_delblks = udqp;
 		/*
 		 * If there are delayed allocation blocks, then we have to
 		 * unreserve those from the old dquot, and add them to the
 		 */
 		if (delblks) {
 			ASSERT(ip->i_udquot);
-			unresudq = ip->i_udquot;
+			udq_unres = ip->i_udquot;
 		}
 	}
 	if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
 		if (prjflags ||
 		    (XFS_IS_GQUOTA_ON(ip->i_mount) &&
 		     ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
-			delblksgdq = gdqp;
+			gdq_delblks = gdqp;
 			if (delblks) {
 				ASSERT(ip->i_gdquot);
-				unresgdq = ip->i_gdquot;
+				gdq_unres = ip->i_gdquot;
 			}
 		}
 	}
-	if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
+	error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
-				delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
+				udq_delblks, gdq_delblks, ip->i_d.di_nblocks, 1,
-				flags | blkflags | prjflags)))
+				flags | blkflags | prjflags);
-		return (error);
+	if (error)
+		return error;
 	/*
 	 * Do the delayed blks reservations/unreservations now. Since, these
 		/*
 		 * Do the reservations first. Unreservation can't fail.
 		 */
-		ASSERT(delblksudq || delblksgdq);
+		ASSERT(udq_delblks || gdq_delblks);
-		ASSERT(unresudq || unresgdq);
+		ASSERT(udq_unres || gdq_unres);
-		if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
+		error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
-				delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
+			    udq_delblks, gdq_delblks, (xfs_qcnt_t)delblks, 0,
-				flags | blkflags | prjflags)))
+			    flags | blkflags | prjflags);
-			return (error);
+		if (error)
+			return error;
 		xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
-				unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
+				udq_unres, gdq_unres, -((xfs_qcnt_t)delblks), 0,
 				blkflags);
 	}

fs/xfs/xfs_qm.h+58−25

 	struct shrinker  qi_shrinker;
 } xfs_quotainfo_t;
-#define XFS_DQUOT_TREE(qi, type) \
+static inline struct radix_tree_root *
-	((type & XFS_DQ_USER) ? \
+xfs_dquot_tree(
-	 &((qi)->qi_uquota_tree) : \
+	struct xfs_quotainfo	*qi,
-	 &((qi)->qi_gquota_tree))
+	int			type)
+{
+	switch (type) {
+	case XFS_DQ_USER:
+		return &qi->qi_uquota_tree;
+	case XFS_DQ_GROUP:
+	case XFS_DQ_PROJ:
+		return &qi->qi_gquota_tree;
+	default:
+		ASSERT(0);
+	}
+	return NULL;
+}
+static inline struct xfs_inode *
+xfs_dq_to_quota_inode(struct xfs_dquot *dqp)
+{
+	switch (dqp->dq_flags & XFS_DQ_ALLTYPES) {
+	case XFS_DQ_USER:
+		return dqp->q_mount->m_quotainfo->qi_uquotaip;
+	case XFS_DQ_GROUP:
+	case XFS_DQ_PROJ:
+		return dqp->q_mount->m_quotainfo->qi_gquotaip;
+	default:
+		ASSERT(0);
+	}
+	return NULL;
+}
 extern int	xfs_qm_calc_dquots_per_chunk(struct xfs_mount *mp,
 					     unsigned int nbblks);
-extern void	xfs_trans_mod_dquot(xfs_trans_t *, xfs_dquot_t *, uint, long);
+extern void	xfs_trans_mod_dquot(struct xfs_trans *,
-extern int	xfs_trans_reserve_quota_bydquots(xfs_trans_t *, xfs_mount_t *,
+					struct xfs_dquot *, uint, long);
-			xfs_dquot_t *, xfs_dquot_t *, long, long, uint);
+extern int	xfs_trans_reserve_quota_bydquots(struct xfs_trans *,
-extern void	xfs_trans_dqjoin(xfs_trans_t *, xfs_dquot_t *);
+			struct xfs_mount *, struct xfs_dquot *,
-extern void	xfs_trans_log_dquot(xfs_trans_t *, xfs_dquot_t *);
+			struct xfs_dquot *, long, long, uint);
+extern void	xfs_trans_dqjoin(struct xfs_trans *, struct xfs_dquot *);
+extern void	xfs_trans_log_dquot(struct xfs_trans *, struct xfs_dquot *);
 /*
  * We keep the usr and grp dquots separately so that locking will be easier
  * to do at commit time. All transactions that we know of at this point
  * affect no more than two dquots of one type. Hence, the TRANS_MAXDQS value.
  */
+enum {
+	XFS_QM_TRANS_USR = 0,
+	XFS_QM_TRANS_GRP,
+	XFS_QM_TRANS_DQTYPES
+};
 #define XFS_QM_TRANS_MAXDQS		2
-typedef struct xfs_dquot_acct {
+struct xfs_dquot_acct {
-	xfs_dqtrx_t	dqa_usrdquots[XFS_QM_TRANS_MAXDQS];
+	struct xfs_dqtrx	dqs[XFS_QM_TRANS_DQTYPES][XFS_QM_TRANS_MAXDQS];
-	xfs_dqtrx_t	dqa_grpdquots[XFS_QM_TRANS_MAXDQS];
+};
-} xfs_dquot_acct_t;
 /*
  * Users are allowed to have a usage exceeding their softlimit for
 #define XFS_QM_IWARNLIMIT	5
 #define XFS_QM_RTBWARNLIMIT	5
-extern void		xfs_qm_destroy_quotainfo(xfs_mount_t *);
+extern void		xfs_qm_destroy_quotainfo(struct xfs_mount *);
-extern int		xfs_qm_quotacheck(xfs_mount_t *);
+extern int		xfs_qm_quotacheck(struct xfs_mount *);
-extern int		xfs_qm_write_sb_changes(xfs_mount_t *, __int64_t);
+extern int		xfs_qm_write_sb_changes(struct xfs_mount *, __int64_t);
 /* dquot stuff */
-extern void		xfs_qm_dqpurge_all(xfs_mount_t *, uint);
+extern void		xfs_qm_dqpurge_all(struct xfs_mount *, uint);
-extern void		xfs_qm_dqrele_all_inodes(xfs_mount_t *, uint);
+extern void		xfs_qm_dqrele_all_inodes(struct xfs_mount *, uint);
 /* quota ops */
-extern int		xfs_qm_scall_trunc_qfiles(xfs_mount_t *, uint);
+extern int		xfs_qm_scall_trunc_qfiles(struct xfs_mount *, uint);
-extern int		xfs_qm_scall_getquota(xfs_mount_t *, xfs_dqid_t, uint,
+extern int		xfs_qm_scall_getquota(struct xfs_mount *, xfs_dqid_t,
-					fs_disk_quota_t *);
+					uint, struct fs_disk_quota *);
 extern int		xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint,
-					fs_disk_quota_t *);
+					struct fs_disk_quota *);
-extern int		xfs_qm_scall_getqstat(xfs_mount_t *, fs_quota_stat_t *);
+extern int		xfs_qm_scall_getqstat(struct xfs_mount *,
-extern int		xfs_qm_scall_quotaon(xfs_mount_t *, uint);
+					struct fs_quota_stat *);
-extern int		xfs_qm_scall_quotaoff(xfs_mount_t *, uint);
+extern int		xfs_qm_scall_quotaon(struct xfs_mount *, uint);
+extern int		xfs_qm_scall_quotaoff(struct xfs_mount *, uint);
 #endif /* __XFS_QM_H__ */

fs/xfs/xfs_qm_syscalls.c+27−24

 	}
 	if (flags & XFS_GQUOTA_ACCT) {
 		dqtype |= XFS_QMOPT_GQUOTA;
-		flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
+		flags |= (XFS_GQUOTA_CHKD | XFS_GQUOTA_ENFD);
 		inactivate_flags |= XFS_GQUOTA_ACTIVE;
 	} else if (flags & XFS_PQUOTA_ACCT) {
 		dqtype |= XFS_QMOPT_PQUOTA;
-		flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
+		flags |= (XFS_PQUOTA_CHKD | XFS_PQUOTA_ENFD);
 		inactivate_flags |= XFS_PQUOTA_ACTIVE;
 	}
 	 * quota acct on ondisk without m_qflags' knowing.
 	 */
 	if (((flags & XFS_UQUOTA_ACCT) == 0 &&
-	    (mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
+	     (mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
-	    (flags & XFS_UQUOTA_ENFD))
+	     (flags & XFS_UQUOTA_ENFD)) ||
-	    ||
+	    ((flags & XFS_GQUOTA_ACCT) == 0 &&
+	     (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
+	     (flags & XFS_GQUOTA_ENFD)) ||
 	    ((flags & XFS_PQUOTA_ACCT) == 0 &&
-	    (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
+	     (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
-	    (flags & XFS_GQUOTA_ACCT) == 0 &&
+	     (flags & XFS_PQUOTA_ENFD))) {
-	    (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
-	    (flags & XFS_OQUOTA_ENFD))) {
 		xfs_debug(mp,
 			"%s: Can't enforce without acct, flags=%x sbflags=%x\n",
 			__func__, flags, mp->m_sb.sb_qflags);
 	struct fs_quota_stat	*out)
 {
 	struct xfs_quotainfo	*q = mp->m_quotainfo;
-	struct xfs_inode	*uip, *gip;
+	struct xfs_inode	*uip = NULL;
-	bool                    tempuqip, tempgqip;
+	struct xfs_inode	*gip = NULL;
+	bool                    tempuqip = false;
+	bool                    tempgqip = false;
-	uip = gip = NULL;
-	tempuqip = tempgqip = false;
 	memset(out, 0, sizeof(fs_quota_stat_t));
 	out->qs_version = FS_QSTAT_VERSION;
 	 * gets turned off. No need to confuse the user level code,
 	 * so return zeroes in that case.
 	 */
-	if ((!XFS_IS_UQUOTA_ENFORCED(mp) && dqp->q_core.d_flags == XFS_DQ_USER) ||
+	if ((!XFS_IS_UQUOTA_ENFORCED(mp) &&
-	    (!XFS_IS_OQUOTA_ENFORCED(mp) &&
+	     dqp->q_core.d_flags == XFS_DQ_USER) ||
-			(dqp->q_core.d_flags & (XFS_DQ_PROJ | XFS_DQ_GROUP)))) {
+	    (!XFS_IS_GQUOTA_ENFORCED(mp) &&
+	     dqp->q_core.d_flags == XFS_DQ_GROUP) ||
+	    (!XFS_IS_PQUOTA_ENFORCED(mp) &&
+	     dqp->q_core.d_flags == XFS_DQ_PROJ)) {
 		dst->d_btimer = 0;
 		dst->d_itimer = 0;
 		dst->d_rtbtimer = 0;
 #ifdef DEBUG
 	if (((XFS_IS_UQUOTA_ENFORCED(mp) && dst->d_flags == FS_USER_QUOTA) ||
-	     (XFS_IS_OQUOTA_ENFORCED(mp) &&
+	     (XFS_IS_GQUOTA_ENFORCED(mp) && dst->d_flags == FS_GROUP_QUOTA) ||
-			(dst->d_flags & (FS_PROJ_QUOTA | FS_GROUP_QUOTA)))) &&
+	     (XFS_IS_PQUOTA_ENFORCED(mp) && dst->d_flags == FS_PROJ_QUOTA)) &&
 	    dst->d_id != 0) {
 		if ((dst->d_bcount > dst->d_blk_softlimit) &&
 		    (dst->d_blk_softlimit > 0)) {
 	uflags = 0;
 	if (flags & XFS_UQUOTA_ACCT)
 		uflags |= FS_QUOTA_UDQ_ACCT;
-	if (flags & XFS_PQUOTA_ACCT)
-		uflags |= FS_QUOTA_PDQ_ACCT;
 	if (flags & XFS_GQUOTA_ACCT)
 		uflags |= FS_QUOTA_GDQ_ACCT;
+	if (flags & XFS_PQUOTA_ACCT)
+		uflags |= FS_QUOTA_PDQ_ACCT;
 	if (flags & XFS_UQUOTA_ENFD)
 		uflags |= FS_QUOTA_UDQ_ENFD;
-	if (flags & (XFS_OQUOTA_ENFD)) {
+	if (flags & XFS_GQUOTA_ENFD)
-		uflags |= (flags & XFS_GQUOTA_ACCT) ?
+		uflags |= FS_QUOTA_GDQ_ENFD;
-			FS_QUOTA_GDQ_ENFD : FS_QUOTA_PDQ_ENFD;
+	if (flags & XFS_PQUOTA_ENFD)
-	}
+		uflags |= FS_QUOTA_PDQ_ENFD;
 	return (uflags);
 }

fs/xfs/xfs_quota.h+29−18

 #define XFS_OQUOTA_CHKD	0x0020  /* quotacheck run on other (grp/prj) quotas */
 #define XFS_GQUOTA_ACCT	0x0040  /* group quota accounting ON */
+/*
+ * Conversion to and from the combined OQUOTA flag (if necessary)
+ * is done only in xfs_sb_qflags_to_disk() and xfs_sb_qflags_from_disk()
+ */
+#define XFS_GQUOTA_ENFD	0x0080  /* group quota limits enforced */
+#define XFS_GQUOTA_CHKD	0x0100  /* quotacheck run on group quotas */
+#define XFS_PQUOTA_ENFD	0x0200  /* project quota limits enforced */
+#define XFS_PQUOTA_CHKD	0x0400  /* quotacheck run on project quotas */
 /*
  * Quota Accounting/Enforcement flags
  */
 #define XFS_ALL_QUOTA_ACCT	\
 		(XFS_UQUOTA_ACCT | XFS_GQUOTA_ACCT | XFS_PQUOTA_ACCT)
-#define XFS_ALL_QUOTA_ENFD	(XFS_UQUOTA_ENFD | XFS_OQUOTA_ENFD)
+#define XFS_ALL_QUOTA_ENFD	\
-#define XFS_ALL_QUOTA_CHKD	(XFS_UQUOTA_CHKD | XFS_OQUOTA_CHKD)
+		(XFS_UQUOTA_ENFD | XFS_GQUOTA_ENFD | XFS_PQUOTA_ENFD)
+#define XFS_ALL_QUOTA_CHKD	\
+		(XFS_UQUOTA_CHKD | XFS_GQUOTA_CHKD | XFS_PQUOTA_CHKD)
 #define XFS_IS_QUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_ALL_QUOTA_ACCT)
 #define XFS_IS_UQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_UQUOTA_ACCT)
 #define XFS_IS_PQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_PQUOTA_ACCT)
 #define XFS_IS_GQUOTA_RUNNING(mp)	((mp)->m_qflags & XFS_GQUOTA_ACCT)
 #define XFS_IS_UQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_UQUOTA_ENFD)
-#define XFS_IS_OQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_OQUOTA_ENFD)
+#define XFS_IS_GQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_GQUOTA_ENFD)
+#define XFS_IS_PQUOTA_ENFORCED(mp)	((mp)->m_qflags & XFS_PQUOTA_ENFD)
 /*
  * Incore only flags for quotaoff - these bits get cleared when quota(s)
  * are in the process of getting turned off. These flags are in m_qflags but
  * never in sb_qflags.
  */
-#define XFS_UQUOTA_ACTIVE	0x0100  /* uquotas are being turned off */
+#define XFS_UQUOTA_ACTIVE	0x1000  /* uquotas are being turned off */
-#define XFS_PQUOTA_ACTIVE	0x0200  /* pquotas are being turned off */
+#define XFS_GQUOTA_ACTIVE	0x2000  /* gquotas are being turned off */
-#define XFS_GQUOTA_ACTIVE	0x0400  /* gquotas are being turned off */
+#define XFS_PQUOTA_ACTIVE	0x4000  /* pquotas are being turned off */
 #define XFS_ALL_QUOTA_ACTIVE	\
-	(XFS_UQUOTA_ACTIVE | XFS_PQUOTA_ACTIVE | XFS_GQUOTA_ACTIVE)
+	(XFS_UQUOTA_ACTIVE | XFS_GQUOTA_ACTIVE | XFS_PQUOTA_ACTIVE)
 /*
  * Checking XFS_IS_*QUOTA_ON() while holding any inode lock guarantees
 	((XFS_IS_UQUOTA_ON(mp) && \
 		(mp->m_sb.sb_qflags & XFS_UQUOTA_CHKD) == 0) || \
 	 (XFS_IS_GQUOTA_ON(mp) && \
-		((mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD) == 0 || \
+		(mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD) == 0) || \
-		 (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT))) || \
 	 (XFS_IS_PQUOTA_ON(mp) && \
-		((mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD) == 0 || \
+		(mp->m_sb.sb_qflags & XFS_PQUOTA_CHKD) == 0))
-		 (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT))))
 #define XFS_MOUNT_QUOTA_SET1	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
-				 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\
+				 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\
-				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD)
+				 XFS_GQUOTA_ENFD|XFS_GQUOTA_CHKD)
 #define XFS_MOUNT_QUOTA_SET2	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
-				 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\
+				 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\
-				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD)
+				 XFS_PQUOTA_ENFD|XFS_PQUOTA_CHKD)
 #define XFS_MOUNT_QUOTA_ALL	(XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
-				 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\
+				 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\
-				 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD|\
+				 XFS_GQUOTA_ENFD|XFS_GQUOTA_CHKD|\
-				 XFS_GQUOTA_ACCT)
+				 XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD|\
+				 XFS_PQUOTA_CHKD)
 /*

fs/xfs/xfs_quotaops.c+4−2

 		flags |= XFS_GQUOTA_ACCT;
 	if (uflags & FS_QUOTA_UDQ_ENFD)
 		flags |= XFS_UQUOTA_ENFD;
-	if (uflags & (FS_QUOTA_PDQ_ENFD|FS_QUOTA_GDQ_ENFD))
+	if (uflags & FS_QUOTA_GDQ_ENFD)
-		flags |= XFS_OQUOTA_ENFD;
+		flags |= XFS_GQUOTA_ENFD;
+	if (uflags & FS_QUOTA_PDQ_ENFD)
+		flags |= XFS_PQUOTA_ENFD;
 	switch (op) {
 	case Q_XQUOTAON:

fs/xfs/xfs_sb.h+6−0

 	return (sbp->sb_features_log_incompat & feature) != 0;
 }
+static inline bool
+xfs_is_quota_inode(struct xfs_sb *sbp, xfs_ino_t ino)
+{
+	return (ino == sbp->sb_uquotino || ino == sbp->sb_gquotino);
+}
 /*
  * end of superblock version macros
  */

fs/xfs/xfs_super.c+23−16

 #include "xfs_inode_item.h"
 #include "xfs_icache.h"
 #include "xfs_trace.h"
+#include "xfs_icreate_item.h"
 #include <linux/namei.h>
 #include <linux/init.h>
 		} else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
 			   !strcmp(this_char, MNTOPT_PRJQUOTA)) {
 			mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
-					 XFS_OQUOTA_ENFD);
+					 XFS_PQUOTA_ENFD);
 		} else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
 			mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
-			mp->m_qflags &= ~XFS_OQUOTA_ENFD;
+			mp->m_qflags &= ~XFS_PQUOTA_ENFD;
 		} else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
 			   !strcmp(this_char, MNTOPT_GRPQUOTA)) {
 			mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
-					 XFS_OQUOTA_ENFD);
+					 XFS_GQUOTA_ENFD);
 		} else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
 			mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
-			mp->m_qflags &= ~XFS_OQUOTA_ENFD;
+			mp->m_qflags &= ~XFS_GQUOTA_ENFD;
 		} else if (!strcmp(this_char, MNTOPT_DELAYLOG)) {
 			xfs_warn(mp,
 	"delaylog is the default now, option is deprecated.");
 	}
 done:
-	if (!(mp->m_flags & XFS_MOUNT_NOALIGN)) {
+	if (dsunit && !(mp->m_flags & XFS_MOUNT_NOALIGN)) {
 		/*
 		 * At this point the superblock has not been read
 		 * in, therefore we do not know the block size.
 		 * Before the mount call ends we will convert
 		 * these to FSBs.
 		 */
-		if (dsunit) {
+		mp->m_dalign = dsunit;
-			mp->m_dalign = dsunit;
+		mp->m_swidth = dswidth;
-			mp->m_flags |= XFS_MOUNT_RETERR;
-		}
-		if (dswidth)
-			mp->m_swidth = dswidth;
 	}
 	if (mp->m_logbufs != -1 &&
 	/* Either project or group quotas can be active, not both */
 	if (mp->m_qflags & XFS_PQUOTA_ACCT) {
-		if (mp->m_qflags & XFS_OQUOTA_ENFD)
+		if (mp->m_qflags & XFS_PQUOTA_ENFD)
 			seq_puts(m, "," MNTOPT_PRJQUOTA);
 		else
 			seq_puts(m, "," MNTOPT_PQUOTANOENF);
 	} else if (mp->m_qflags & XFS_GQUOTA_ACCT) {
-		if (mp->m_qflags & XFS_OQUOTA_ENFD)
+		if (mp->m_qflags & XFS_GQUOTA_ENFD)
 			seq_puts(m, "," MNTOPT_GRPQUOTA);
 		else
 			seq_puts(m, "," MNTOPT_GQUOTANOENF);
 	spin_unlock(&mp->m_sb_lock);
 	if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
-	    ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))) ==
+	    ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
-			      (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
+			      (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))
 		xfs_qm_statvfs(ip, statp);
 	return 0;
 }
 	sb->s_time_gran = 1;
 	set_posix_acl_flag(sb);
+	/* version 5 superblocks support inode version counters. */
+	if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5)
+		sb->s_flags |= MS_I_VERSION;
 	error = xfs_mountfs(mp);
 	if (error)
 		goto out_filestream_unmount;
 					KM_ZONE_SPREAD, NULL);
 	if (!xfs_ili_zone)
 		goto out_destroy_inode_zone;
+	xfs_icreate_zone = kmem_zone_init(sizeof(struct xfs_icreate_item),
+					"xfs_icr");
+	if (!xfs_icreate_zone)
+		goto out_destroy_ili_zone;
 	return 0;
+ out_destroy_ili_zone:
+	kmem_zone_destroy(xfs_ili_zone);
  out_destroy_inode_zone:
 	kmem_zone_destroy(xfs_inode_zone);
  out_destroy_efi_zone:
 	 * destroy caches.
 	 */
 	rcu_barrier();
+	kmem_zone_destroy(xfs_icreate_zone);
 	kmem_zone_destroy(xfs_ili_zone);
 	kmem_zone_destroy(xfs_inode_zone);
 	kmem_zone_destroy(xfs_efi_zone);

fs/xfs/xfs_symlink.c+48−3

@@ -358,7 +358,8 @@ xfs_symlink( · 357 unmodified lines
358	int n;	358	int n;
359	xfs_buf_t *bp;	359	xfs_buf_t *bp;
360	prid_t prid;	360	prid_t prid;
361	struct xfs_dquot udqp, gdqp;	361	struct xfs_dquot *udqp = NULL;
		362	struct xfs_dquot *gdqp = NULL;
362	uint resblks;	363	uint resblks;
363		364
364	*ipp = NULL;	365	*ipp = NULL;
@@ -585,7 +586,7 @@ xfs_symlink( · 220 unmodified lines
585	/*	586	/*
586	* Free a symlink that has blocks associated with it.	587	* Free a symlink that has blocks associated with it.
587	*/	588	*/
588	int	589	STATIC int
589	xfs_inactive_symlink_rmt(	590	xfs_inactive_symlink_rmt(
590	xfs_inode_t *ip,	591	xfs_inode_t *ip,
591	xfs_trans_t **tpp)	592	xfs_trans_t **tpp)
@@ -606,7 +607,7 @@ xfs_inactive_symlink_rmt( · 14 unmodified lines
606		607
607	tp = *tpp;	608	tp = *tpp;
608	mp = ip->i_mount;	609	mp = ip->i_mount;
609	ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));	610	ASSERT(ip->i_df.if_flags & XFS_IFEXTENTS);
610	/*	611	/*
611	* We're freeing a symlink that has some	612	* We're freeing a symlink that has some
612	* blocks allocated to it. Free the	613	* blocks allocated to it. Free the
@@ -720,3 +721,47 @@ xfs_inactive_symlink_rmt( · 107 unmodified lines
720	error0:	721	error0:
721	return error;	722	return error;
722	}	723	}
		724
		725	/*
		726	* xfs_inactive_symlink - free a symlink
		727	*/
		728	int
		729	xfs_inactive_symlink(
		730	struct xfs_inode *ip,
		731	struct xfs_trans **tp)
		732	{
		733	struct xfs_mount *mp = ip->i_mount;
		734	int pathlen;
		735
		736	trace_xfs_inactive_symlink(ip);
		737
		738	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
		739
		740	if (XFS_FORCED_SHUTDOWN(mp))
		741	return XFS_ERROR(EIO);
		742
		743	/*
		744	* Zero length symlinks _can_ exist.
		745	*/
		746	pathlen = (int)ip->i_d.di_size;
		747	if (!pathlen)
		748	return 0;
		749
		750	if (pathlen < 0 \|\| pathlen > MAXPATHLEN) {
		751	xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)",
		752	__func__, (unsigned long long)ip->i_ino, pathlen);
		753	ASSERT(0);
		754	return XFS_ERROR(EFSCORRUPTED);
		755	}
		756
		757	if (ip->i_df.if_flags & XFS_IFINLINE) {
		758	if (ip->i_df.if_bytes > 0)
		759	xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
		760	XFS_DATA_FORK);
		761	ASSERT(ip->i_df.if_bytes == 0);
		762	return 0;
		763	}
		764
		765	/* remove the remote symlink */
		766	return xfs_inactive_symlink_rmt(ip, tp);
		767	}

fs/xfs/xfs_symlink.h+1−1

@@ -60,7 +60,7 @@ extern const struct xfs_buf_ops xfs_symlink_buf_ops; · 59 unmodified lines
60	int xfs_symlink(struct xfs_inode dp, struct xfs_name link_name,	60	int xfs_symlink(struct xfs_inode dp, struct xfs_name link_name,
61	const char target_path, umode_t mode, struct xfs_inode *ipp);	61	const char target_path, umode_t mode, struct xfs_inode *ipp);
62	int xfs_readlink(struct xfs_inode ip, char link);	62	int xfs_readlink(struct xfs_inode ip, char link);
63	int xfs_inactive_symlink_rmt(struct xfs_inode ip, struct xfs_trans *tpp);	63	int xfs_inactive_symlink(struct xfs_inode ip, struct xfs_trans *tpp);
64		64
65	#endif /* __KERNEL__ */	65	#endif /* __KERNEL__ */
66	#endif /* __XFS_SYMLINK_H */	66	#endif /* __XFS_SYMLINK_H */

fs/xfs/xfs_sysctl.c+13−13

@@ -25,11 +25,11 @@ static struct ctl_table_header *xfs_table_header; · 24 unmodified lines
25	#ifdef CONFIG_PROC_FS	25	#ifdef CONFIG_PROC_FS
26	STATIC int	26	STATIC int
27	xfs_stats_clear_proc_handler(	27	xfs_stats_clear_proc_handler(
28	ctl_table *ctl,	28	struct ctl_table *ctl,
29	int write,	29	int write,
30	void __user *buffer,	30	void __user *buffer,
31	size_t *lenp,	31	size_t *lenp,
32	loff_t *ppos)	32	loff_t *ppos)
33	{	33	{
34	int c, ret, *valp = ctl->data;	34	int c, ret, *valp = ctl->data;
35	__uint32_t vn_active;	35	__uint32_t vn_active;
@@ -55,11 +55,11 @@ xfs_stats_clear_proc_handler( · 19 unmodified lines
55		55
56	STATIC int	56	STATIC int
57	xfs_panic_mask_proc_handler(	57	xfs_panic_mask_proc_handler(
58	ctl_table *ctl,	58	struct ctl_table *ctl,
59	int write,	59	int write,
60	void __user *buffer,	60	void __user *buffer,
61	size_t *lenp,	61	size_t *lenp,
62	loff_t *ppos)	62	loff_t *ppos)
63	{	63	{
64	int ret, *valp = ctl->data;	64	int ret, *valp = ctl->data;
65		65
@@ -74,7 +74,7 @@ xfs_panic_mask_proc_handler( · 8 unmodified lines
74	}	74	}
75	#endif /* CONFIG_PROC_FS */	75	#endif /* CONFIG_PROC_FS */
76		76
77	static ctl_table xfs_table[] = {	77	static struct ctl_table xfs_table[] = {
78	{	78	{
79	.procname = "irix_sgid_inherit",	79	.procname = "irix_sgid_inherit",
80	.data = &xfs_params.sgid_inherit.val,	80	.data = &xfs_params.sgid_inherit.val,
@@ -227,7 +227,7 @@ static ctl_table xfs_table[] = { · 146 unmodified lines
227	{}	227	{}
228	};	228	};
229		229
230	static ctl_table xfs_dir_table[] = {	230	static struct ctl_table xfs_dir_table[] = {
231	{	231	{
232	.procname = "xfs",	232	.procname = "xfs",
233	.mode = 0555,	233	.mode = 0555,
@@ -236,7 +236,7 @@ static ctl_table xfs_dir_table[] = { · 2 unmodified lines
236	{}	236	{}
237	};	237	};
238		238
239	static ctl_table xfs_root_table[] = {	239	static struct ctl_table xfs_root_table[] = {
240	{	240	{
241	.procname = "fs",	241	.procname = "fs",
242	.mode = 0555,	242	.mode = 0555,

fs/xfs/xfs_trace.h+5−0

 	TP_PROTO(struct xfs_buf_log_item *bip), \
 	TP_ARGS(bip))
 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size);
+DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_ordered);
 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale);
 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format);
+DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_ordered);
 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_stale);
+DEFINE_BUF_ITEM_EVENT(xfs_buf_item_ordered);
 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_pin);
 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin);
 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin_stale);
 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold);
 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release);
 DEFINE_BUF_ITEM_EVENT(xfs_trans_binval);
+DEFINE_BUF_ITEM_EVENT(xfs_trans_buf_ordered);
 DECLARE_EVENT_CLASS(xfs_lock_class,
 	TP_PROTO(struct xfs_inode *ip, unsigned lock_flags,
 DEFINE_INODE_EVENT(xfs_getattr);
 DEFINE_INODE_EVENT(xfs_setattr);
 DEFINE_INODE_EVENT(xfs_readlink);
+DEFINE_INODE_EVENT(xfs_inactive_symlink);
 DEFINE_INODE_EVENT(xfs_alloc_file_space);
 DEFINE_INODE_EVENT(xfs_free_file_space);
 DEFINE_INODE_EVENT(xfs_readdir);

fs/xfs/xfs_trans.c+77−41

@@ -234,71 +234,93 @@ xfs_calc_remove_reservation( · 233 unmodified lines
234	}	234	}
235		235
236	/*	236	/*
237	* For symlink we can modify:	237	* For create, break it in to the two cases that the transaction
		238	* covers. We start with the modify case - allocation done by modification
		239	* of the state of existing inodes - and the allocation case.
		240	*/
		241
		242	/*
		243	* For create we can modify:
238	* the parent directory inode: inode size	244	* the parent directory inode: inode size
239	* the new inode: inode size	245	* the new inode: inode size
240	* the inode btree entry: 1 block	246	* the inode btree entry: block size
		247	* the superblock for the nlink flag: sector size
241	* the directory btree: (max depth + v2) * dir block size	248	* the directory btree: (max depth + v2) * dir block size
242	* the directory inode's bmap btree: (max depth + v2) * block size	249	* the directory inode's bmap btree: (max depth + v2) * block size
243	* the blocks for the symlink: 1 kB	250	*/
244	* Or in the first xact we allocate some inodes giving:	251	STATIC uint
		252	xfs_calc_create_resv_modify(
		253	struct xfs_mount *mp)
		254	{
		255	return xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
		256	xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
		257	(uint)XFS_FSB_TO_B(mp, 1) +
		258	xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp), XFS_FSB_TO_B(mp, 1));
		259	}
		260
		261	/*
		262	* For create we can allocate some inodes giving:
245	* the agi and agf of the ag getting the new inodes: 2 * sectorsize	263	* the agi and agf of the ag getting the new inodes: 2 * sectorsize
		264	* the superblock for the nlink flag: sector size
246	* the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize	265	* the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize
247	* the inode btree: max depth * blocksize	266	* the inode btree: max depth * blocksize
248	* the allocation btrees: 2 trees * (2 * max depth - 1) * block size	267	* the allocation btrees: 2 trees * (max depth - 1) * block size
249	*/	268	*/
250	STATIC uint	269	STATIC uint
251	xfs_calc_symlink_reservation(	270	xfs_calc_create_resv_alloc(
		271	struct xfs_mount *mp)
		272	{
		273	return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
		274	mp->m_sb.sb_sectsize +
		275	xfs_calc_buf_res(XFS_IALLOC_BLOCKS(mp), XFS_FSB_TO_B(mp, 1)) +
		276	xfs_calc_buf_res(mp->m_in_maxlevels, XFS_FSB_TO_B(mp, 1)) +
		277	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
		278	XFS_FSB_TO_B(mp, 1));
		279	}
		280
		281	STATIC uint
		282	__xfs_calc_create_reservation(
252	struct xfs_mount *mp)	283	struct xfs_mount *mp)
253	{	284	{
254	return XFS_DQUOT_LOGRES(mp) +	285	return XFS_DQUOT_LOGRES(mp) +
255	MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +	286	MAX(xfs_calc_create_resv_alloc(mp),
256	xfs_calc_buf_res(1, XFS_FSB_TO_B(mp, 1)) +	287	xfs_calc_create_resv_modify(mp));
257	xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
258	XFS_FSB_TO_B(mp, 1)) +
259	xfs_calc_buf_res(1, 1024)),
260	(xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
261	xfs_calc_buf_res(XFS_IALLOC_BLOCKS(mp),
262	XFS_FSB_TO_B(mp, 1)) +
263	xfs_calc_buf_res(mp->m_in_maxlevels,
264	XFS_FSB_TO_B(mp, 1)) +
265	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
266	XFS_FSB_TO_B(mp, 1))));
267	}	288	}
268		289
269	/*	290	/*
270	* For create we can modify:	291	* For icreate we can allocate some inodes giving:
271	* the parent directory inode: inode size
272	* the new inode: inode size
273	* the inode btree entry: block size
274	* the superblock for the nlink flag: sector size
275	* the directory btree: (max depth + v2) * dir block size
276	* the directory inode's bmap btree: (max depth + v2) * block size
277	* Or in the first xact we allocate some inodes giving:
278	* the agi and agf of the ag getting the new inodes: 2 * sectorsize	292	* the agi and agf of the ag getting the new inodes: 2 * sectorsize
279	* the superblock for the nlink flag: sector size	293	* the superblock for the nlink flag: sector size
280	* the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize
281	* the inode btree: max depth * blocksize	294	* the inode btree: max depth * blocksize
282	* the allocation btrees: 2 trees * (max depth - 1) * block size	295	* the allocation btrees: 2 trees * (max depth - 1) * block size
283	*/	296	*/
284	STATIC uint	297	STATIC uint
285	xfs_calc_create_reservation(	298	xfs_calc_icreate_resv_alloc(
286	struct xfs_mount *mp)	299	struct xfs_mount *mp)
		300	{
		301	return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
		302	mp->m_sb.sb_sectsize +
		303	xfs_calc_buf_res(mp->m_in_maxlevels, XFS_FSB_TO_B(mp, 1)) +
		304	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
		305	XFS_FSB_TO_B(mp, 1));
		306	}
		307
		308	STATIC uint
		309	xfs_calc_icreate_reservation(xfs_mount_t *mp)
287	{	310	{
288	return XFS_DQUOT_LOGRES(mp) +	311	return XFS_DQUOT_LOGRES(mp) +
289	MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +	312	MAX(xfs_calc_icreate_resv_alloc(mp),
290	xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +	313	xfs_calc_create_resv_modify(mp));
291	(uint)XFS_FSB_TO_B(mp, 1) +	314	}
292	xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),	315
293	XFS_FSB_TO_B(mp, 1))),	316	STATIC uint
294	(xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +	317	xfs_calc_create_reservation(
295	mp->m_sb.sb_sectsize +	318	struct xfs_mount *mp)
296	xfs_calc_buf_res(XFS_IALLOC_BLOCKS(mp),	319	{
297	XFS_FSB_TO_B(mp, 1)) +	320	if (xfs_sb_version_hascrc(&mp->m_sb))
298	xfs_calc_buf_res(mp->m_in_maxlevels,	321	return xfs_calc_icreate_reservation(mp);
299	XFS_FSB_TO_B(mp, 1)) +	322	return __xfs_calc_create_reservation(mp);
300	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),	323
301	XFS_FSB_TO_B(mp, 1))));
302	}	324	}
303		325
304	/*	326	/*
@@ -311,6 +333,20 @@ xfs_calc_mkdir_reservation( · 6 unmodified lines
311	return xfs_calc_create_reservation(mp);	333	return xfs_calc_create_reservation(mp);
312	}	334	}
313		335
		336
		337	/*
		338	* Making a new symplink is the same as creating a new file, but
		339	* with the added blocks for remote symlink data which can be up to 1kB in
		340	* length (MAXPATHLEN).
		341	*/
		342	STATIC uint
		343	xfs_calc_symlink_reservation(
		344	struct xfs_mount *mp)
		345	{
		346	return xfs_calc_create_reservation(mp) +
		347	xfs_calc_buf_res(1, MAXPATHLEN);
		348	}
		349
314	/*	350	/*
315	* In freeing an inode we can modify:	351	* In freeing an inode we can modify:
316	* the inode being freed: inode size	352	* the inode being freed: inode size

fs/xfs/xfs_trans.h+7−9

 #define	XFS_LI_BUF		0x123c	/* v2 bufs, variable sized inode bufs */
 #define	XFS_LI_DQUOT		0x123d
 #define	XFS_LI_QUOTAOFF		0x123e
+#define	XFS_LI_ICREATE		0x123f
 #define XFS_LI_TYPE_DESC \
 	{ XFS_LI_EFI,		"XFS_LI_EFI" }, \
 #define	XFS_TRANS_SWAPEXT		40
 #define	XFS_TRANS_SB_COUNT		41
 #define	XFS_TRANS_CHECKPOINT		42
-#define	XFS_TRANS_TYPE_MAX		42
+#define	XFS_TRANS_ICREATE		43
+#define	XFS_TRANS_TYPE_MAX		43
 /* new transaction types need to be reflected in xfs_logprint(8) */
 #define XFS_TRANS_TYPES \
 /*
  * Per-extent log reservation for the allocation btree changes
  * involved in freeing or allocating an extent.
- * 2 trees * (2 blocks/level * max depth - 1) * block size
+ * 2 trees * (2 blocks/level * max depth - 1)
  */
-#define	XFS_ALLOCFREE_LOG_RES(mp,nx) \
-	((nx) * (2 * XFS_FSB_TO_B((mp), 2 * XFS_AG_MAXLEVELS(mp) - 1)))
 #define	XFS_ALLOCFREE_LOG_COUNT(mp,nx) \
 	((nx) * (2 * (2 * XFS_AG_MAXLEVELS(mp) - 1)))
 /*
  * Per-directory log reservation for any directory change.
- * dir blocks: (1 btree block per level + data block + free block) * dblock size
+ * dir blocks: (1 btree block per level + data block + free block)
- * bmap btree: (levels + 2) * max depth * block size
+ * bmap btree: (levels + 2) * max depth
  * v2 directory blocks can be fragmented below the dirblksize down to the fsb
  * size, so account for that in the DAENTER macros.
  */
-#define	XFS_DIROP_LOG_RES(mp)	\
-	(XFS_FSB_TO_B(mp, XFS_DAENTER_BLOCKS(mp, XFS_DATA_FORK)) + \
-	 (XFS_FSB_TO_B(mp, XFS_DAENTER_BMAPS(mp, XFS_DATA_FORK) + 1)))
 #define	XFS_DIROP_LOG_COUNT(mp)	\
 	(XFS_DAENTER_BLOCKS(mp, XFS_DATA_FORK) + \
 	 XFS_DAENTER_BMAPS(mp, XFS_DATA_FORK) + 1)
 void		xfs_trans_binval(xfs_trans_t *, struct xfs_buf *);
 void		xfs_trans_inode_buf(xfs_trans_t *, struct xfs_buf *);
 void		xfs_trans_stale_inode_buf(xfs_trans_t *, struct xfs_buf *);
+void		xfs_trans_ordered_buf(xfs_trans_t *, struct xfs_buf *);
 void		xfs_trans_dquot_buf(xfs_trans_t *, struct xfs_buf *, uint);
 void		xfs_trans_inode_alloc_buf(xfs_trans_t *, struct xfs_buf *);
 void		xfs_trans_ichgtime(struct xfs_trans *, struct xfs_inode *, int);

fs/xfs/xfs_trans_buf.c+31−3

@@ -397,7 +397,6 @@ shutdown_abort: · 396 unmodified lines
397	return XFS_ERROR(EIO);	397	return XFS_ERROR(EIO);
398	}	398	}
399		399
400
401	/*	400	/*
402	* Release the buffer bp which was previously acquired with one of the	401	* Release the buffer bp which was previously acquired with one of the
403	* xfs_trans_... buffer allocation routines if the buffer has not	402	* xfs_trans_... buffer allocation routines if the buffer has not
@@ -603,8 +602,14 @@ xfs_trans_log_buf(xfs_trans_t *tp, · 199 unmodified lines
603		602
604	tp->t_flags \|= XFS_TRANS_DIRTY;	603	tp->t_flags \|= XFS_TRANS_DIRTY;
605	bip->bli_item.li_desc->lid_flags \|= XFS_LID_DIRTY;	604	bip->bli_item.li_desc->lid_flags \|= XFS_LID_DIRTY;
606	bip->bli_flags \|= XFS_BLI_LOGGED;	605
607	xfs_buf_item_log(bip, first, last);	606	/*
		607	* If we have an ordered buffer we are not logging any dirty range but
		608	* it still needs to be marked dirty and that it has been logged.
		609	*/
		610	bip->bli_flags \|= XFS_BLI_DIRTY \| XFS_BLI_LOGGED;
		611	if (!(bip->bli_flags & XFS_BLI_ORDERED))
		612	xfs_buf_item_log(bip, first, last);
608	}	613	}
609		614
610		615
@@ -756,6 +761,29 @@ xfs_trans_inode_alloc_buf( · 145 unmodified lines
756	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);	761	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
757	}	762	}
758		763
		764	/*
		765	* Mark the buffer as ordered for this transaction. This means
		766	* that the contents of the buffer are not recorded in the transaction
		767	* but it is tracked in the AIL as though it was. This allows us
		768	* to record logical changes in transactions rather than the physical
		769	* changes we make to the buffer without changing writeback ordering
		770	* constraints of metadata buffers.
		771	*/
		772	void
		773	xfs_trans_ordered_buf(
		774	struct xfs_trans *tp,
		775	struct xfs_buf *bp)
		776	{
		777	struct xfs_buf_log_item *bip = bp->b_fspriv;
		778
		779	ASSERT(bp->b_transp == tp);
		780	ASSERT(bip != NULL);
		781	ASSERT(atomic_read(&bip->bli_refcount) > 0);
		782
		783	bip->bli_flags \|= XFS_BLI_ORDERED;
		784	trace_xfs_buf_item_ordered(bip);
		785	}
		786
759	/*	787	/*
760	* Set the type of the buffer for log recovery so that it can correctly identify	788	* Set the type of the buffer for log recovery so that it can correctly identify
761	* and hence attach the correct buffer ops to the buffer after replay.	789	* and hence attach the correct buffer ops to the buffer after replay.

fs/xfs/xfs_trans_dquot.c+37−50

 		return;
 	xfs_trans_alloc_dqinfo(ntp);
-	oqa = otp->t_dqinfo->dqa_usrdquots;
-	nqa = ntp->t_dqinfo->dqa_usrdquots;
 	/*
 	 * Because the quota blk reservation is carried forward,
 	if(otp->t_flags & XFS_TRANS_DQ_DIRTY)
 		ntp->t_flags |= XFS_TRANS_DQ_DIRTY;
-	for (j = 0; j < 2; j++) {
+	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
+		oqa = otp->t_dqinfo->dqs[j];
+		nqa = ntp->t_dqinfo->dqs[j];
 		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 			if (oqa[i].qt_dquot == NULL)
 				break;
 			oq->qt_ino_res = oq->qt_ino_res_used;
 		}
-		oqa = otp->t_dqinfo->dqa_grpdquots;
-		nqa = ntp->t_dqinfo->dqa_grpdquots;
 	}
 }
 	if (!XFS_IS_QUOTA_RUNNING(mp) ||
 	    !XFS_IS_QUOTA_ON(mp) ||
-	    ip->i_ino == mp->m_sb.sb_uquotino ||
+	    xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
-	    ip->i_ino == mp->m_sb.sb_gquotino)
 		return;
 	if (tp->t_dqinfo == NULL)
 		(void) xfs_trans_mod_dquot(tp, ip->i_gdquot, field, delta);
 }
-STATIC xfs_dqtrx_t *
+STATIC struct xfs_dqtrx *
 xfs_trans_get_dqtrx(
-	xfs_trans_t	*tp,
+	struct xfs_trans	*tp,
-	xfs_dquot_t	*dqp)
+	struct xfs_dquot	*dqp)
 {
-	int		i;
+	int			i;
-	xfs_dqtrx_t	*qa;
+	struct xfs_dqtrx	*qa;
-	qa = XFS_QM_ISUDQ(dqp) ?
+	if (XFS_QM_ISUDQ(dqp))
-		tp->t_dqinfo->dqa_usrdquots : tp->t_dqinfo->dqa_grpdquots;
+		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_USR];
+	else
+		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_GRP];
 	for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 		if (qa[i].qt_dquot == NULL ||
 		return;
 	ASSERT(tp->t_dqinfo);
-	qa = tp->t_dqinfo->dqa_usrdquots;
+	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
-	for (j = 0; j < 2; j++) {
+		qa = tp->t_dqinfo->dqs[j];
-		if (qa[0].qt_dquot == NULL) {
+		if (qa[0].qt_dquot == NULL)
-			qa = tp->t_dqinfo->dqa_grpdquots;
 			continue;
-		}
 		/*
 		 * Lock all of the dquots and join them to the transaction.
 			ASSERT(dqp->q_res_rtbcount >=
 				be64_to_cpu(dqp->q_core.d_rtbcount));
 		}
-		/*
-		 * Do the group quotas next
-		 */
-		qa = tp->t_dqinfo->dqa_grpdquots;
 	}
 }
 	if (!tp->t_dqinfo || !(tp->t_flags & XFS_TRANS_DQ_DIRTY))
 		return;
-	qa = tp->t_dqinfo->dqa_usrdquots;
+	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
+		qa = tp->t_dqinfo->dqs[j];
-	for (j = 0; j < 2; j++) {
 		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 			qtrx = &qa[i];
 			/*
 				xfs_dqunlock(dqp);
 		}
-		qa = tp->t_dqinfo->dqa_grpdquots;
 	}
 }
 	if ((flags & XFS_QMOPT_FORCE_RES) == 0 &&
 	    dqp->q_core.d_id &&
 	    ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) ||
-	     (XFS_IS_OQUOTA_ENFORCED(dqp->q_mount) &&
+	     (XFS_IS_GQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISGDQ(dqp)) ||
-	      (XFS_QM_ISPDQ(dqp) || XFS_QM_ISGDQ(dqp))))) {
+	     (XFS_IS_PQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISPDQ(dqp)))) {
 		if (nblks > 0) {
 			/*
 			 * dquot is locked already. See if we'd go over the
  */
 int
 xfs_trans_reserve_quota_bydquots(
-	xfs_trans_t	*tp,
+	struct xfs_trans	*tp,
-	xfs_mount_t	*mp,
+	struct xfs_mount	*mp,
-	xfs_dquot_t	*udqp,
+	struct xfs_dquot	*udqp,
-	xfs_dquot_t	*gdqp,
+	struct xfs_dquot	*gdqp,
-	long		nblks,
+	long			nblks,
-	long		ninos,
+	long			ninos,
-	uint		flags)
+	uint			flags)
 {
-	int		resvd = 0, error;
+	int		error;
 	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 		return 0;
 					(flags & ~XFS_QMOPT_ENOSPC));
 		if (error)
 			return error;
-		resvd = 1;
 	}
 	if (gdqp) {
 		error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags);
-		if (error) {
+		if (error)
-			/*
+			goto unwind_usr;
-			 * can't do it, so backout previous reservation
-			 */
-			if (resvd) {
-				flags |= XFS_QMOPT_FORCE_RES;
-				xfs_trans_dqresv(tp, mp, udqp,
-						 -nblks, -ninos, flags);
-			}
-			return error;
-		}
 	}
 	/*
 	 * Didn't change anything critical, so, no need to log
 	 */
 	return 0;
+unwind_usr:
+	flags |= XFS_QMOPT_FORCE_RES;
+	if (udqp)
+		xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags);
+	return error;
 }
 	if (XFS_IS_PQUOTA_ON(mp))
 		flags |= XFS_QMOPT_ENOSPC;
-	ASSERT(ip->i_ino != mp->m_sb.sb_uquotino);
+	ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino));
-	ASSERT(ip->i_ino != mp->m_sb.sb_gquotino);
 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 	ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==

fs/xfs/xfs_trans_inode.c+11−0

@@ -112,6 +112,17 @@ xfs_trans_log_inode( · 111 unmodified lines
112	ASSERT(ip->i_itemp != NULL);	112	ASSERT(ip->i_itemp != NULL);
113	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));	113	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
114		114
		115	/*
		116	* First time we log the inode in a transaction, bump the inode change
		117	* counter if it is configured for this to occur.
		118	*/
		119	if (!(ip->i_itemp->ili_item.li_desc->lid_flags & XFS_LID_DIRTY) &&
		120	IS_I_VERSION(VFS_I(ip))) {
		121	inode_inc_iversion(VFS_I(ip));
		122	ip->i_d.di_changecount = VFS_I(ip)->i_version;
		123	flags \|= XFS_ILOG_CORE;
		124	}
		125
115	tp->t_flags \|= XFS_TRANS_DIRTY;	126	tp->t_flags \|= XFS_TRANS_DIRTY;
116	ip->i_itemp->ili_item.li_desc->lid_flags \|= XFS_LID_DIRTY;	127	ip->i_itemp->ili_item.li_desc->lid_flags \|= XFS_LID_DIRTY;
117		128

fs/xfs/xfs_vnodeops.c+3−12

 	xfs_trans_ijoin(tp, ip, 0);
 	if (S_ISLNK(ip->i_d.di_mode)) {
-		/*
+		error = xfs_inactive_symlink(ip, &tp);
-		 * Zero length symlinks _can_ exist.
+		if (error)
-		 */
+			goto out_cancel;
-		if (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) {
-			error = xfs_inactive_symlink_rmt(ip, &tp);
-			if (error)
-				goto out_cancel;
-		} else if (ip->i_df.if_bytes > 0) {
-			xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
-					  XFS_DATA_FORK);
-			ASSERT(ip->i_df.if_bytes == 0);
-		}
 	} else if (truncate) {
 		ip->i_d.di_size = 0;
 		xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);