Commit bc85178a authored by Dave Chinner's avatar Dave Chinner Committed by Dave Chinner
Browse files

xfs: remove mp->m_dir_geo from directory logging 



We don't pass the xfs_da_args or the geometry all the way down to
the directory buffer logging code, hence we have to use
mp->m_dir_geo here. Fix this to use the geometry passed via the
xfs_da_args, and convert all the directory logging functions for
consistency.

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarBrian Foster <bfoster@redhat.com>
Signed-off-by: default avatarDave Chinner <david@fromorbit.com>
parent 53f82db0

fs/xfs/xfs_dir2.h

+6 −6
Original line number Diff line number Diff line
@@ -153,16 +153,16 @@ extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db, 


extern void xfs_dir2_data_freescan(struct xfs_inode *dp,

		struct xfs_dir2_data_hdr *hdr, int *loghead);

extern void xfs_dir2_data_log_entry(struct xfs_trans *tp, struct xfs_inode *dp,

extern void xfs_dir2_data_log_entry(struct xfs_da_args *args,

		struct xfs_buf *bp, struct xfs_dir2_data_entry *dep);

extern void xfs_dir2_data_log_header(struct xfs_trans *tp, struct xfs_inode *dp,

extern void xfs_dir2_data_log_header(struct xfs_da_args *args,

		struct xfs_buf *bp);

extern void xfs_dir2_data_log_unused(struct xfs_trans *tp, struct xfs_buf *bp,

		struct xfs_dir2_data_unused *dup);

extern void xfs_dir2_data_make_free(struct xfs_trans *tp, struct xfs_inode *dp,

extern void xfs_dir2_data_log_unused(struct xfs_da_args *args,

		struct xfs_buf *bp, struct xfs_dir2_data_unused *dup);

extern void xfs_dir2_data_make_free(struct xfs_da_args *args,

		struct xfs_buf *bp, xfs_dir2_data_aoff_t offset,

		xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp);

extern void xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_inode *dp,

extern void xfs_dir2_data_use_free(struct xfs_da_args *args,

		struct xfs_buf *bp, struct xfs_dir2_data_unused *dup,

		xfs_dir2_data_aoff_t offset, xfs_dir2_data_aoff_t len,

		int *needlogp, int *needscanp);

fs/xfs/xfs_dir2_block.c

+19 −20
Original line number Diff line number Diff line
@@ -281,8 +281,7 @@ out: 
 */

static void

xfs_dir2_block_compact(

	struct xfs_trans		*tp,

	struct xfs_inode		*dp,

	struct xfs_da_args		*args,

	struct xfs_buf			*bp,

	struct xfs_dir2_data_hdr	*hdr,

	struct xfs_dir2_block_tail	*btp,
@@ -315,7 +314,7 @@ xfs_dir2_block_compact( 
	*lfloglow = toidx + 1 - (be32_to_cpu(btp->stale) - 1);

	*lfloghigh -= be32_to_cpu(btp->stale) - 1;

	be32_add_cpu(&btp->count, -(be32_to_cpu(btp->stale) - 1));

	xfs_dir2_data_make_free(tp, dp, bp,

	xfs_dir2_data_make_free(args, bp,

		(xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),

		(xfs_dir2_data_aoff_t)((be32_to_cpu(btp->stale) - 1) * sizeof(*blp)),

		needlog, &needscan);
@@ -325,7 +324,7 @@ xfs_dir2_block_compact( 
	 * This needs to happen before the next call to use_free.

	 */

	if (needscan)

		xfs_dir2_data_freescan(dp, hdr, needlog);

		xfs_dir2_data_freescan(args->dp, hdr, needlog);

}



/*
@@ -420,7 +419,7 @@ xfs_dir2_block_addname( 
	 * If need to compact the leaf entries, do it now.

	 */

	if (compact) {

		xfs_dir2_block_compact(tp, dp, bp, hdr, btp, blp, &needlog,

		xfs_dir2_block_compact(args, bp, hdr, btp, blp, &needlog,

				      &lfloghigh, &lfloglow);

		/* recalculate blp post-compaction */

		blp = xfs_dir2_block_leaf_p(btp);
@@ -455,7 +454,7 @@ xfs_dir2_block_addname( 
		/*

		 * Mark the space needed for the new leaf entry, now in use.

		 */

		xfs_dir2_data_use_free(tp, dp, bp, enddup,

		xfs_dir2_data_use_free(args, bp, enddup,

			(xfs_dir2_data_aoff_t)

			((char *)enddup - (char *)hdr + be16_to_cpu(enddup->length) -

			 sizeof(*blp)),
@@ -542,7 +541,7 @@ xfs_dir2_block_addname( 
	/*

	 * Mark space for the data entry used.

	 */

	xfs_dir2_data_use_free(tp, dp, bp, dup,

	xfs_dir2_data_use_free(args, bp, dup,

		(xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),

		(xfs_dir2_data_aoff_t)len, &needlog, &needscan);

	/*
@@ -560,9 +559,9 @@ xfs_dir2_block_addname( 
	if (needscan)

		xfs_dir2_data_freescan(dp, hdr, &needlog);

	if (needlog)

		xfs_dir2_data_log_header(tp, dp, bp);

		xfs_dir2_data_log_header(args, bp);

	xfs_dir2_block_log_tail(tp, bp);

	xfs_dir2_data_log_entry(tp, dp, bp, dep);

	xfs_dir2_data_log_entry(args, bp, dep);

	xfs_dir3_data_check(dp, bp);

	return 0;

}
@@ -803,7 +802,7 @@ xfs_dir2_block_removename( 
	 * Mark the data entry's space free.

	 */

	needlog = needscan = 0;

	xfs_dir2_data_make_free(tp, dp, bp,

	xfs_dir2_data_make_free(args, bp,

		(xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),

		dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);

	/*
@@ -822,7 +821,7 @@ xfs_dir2_block_removename( 
	if (needscan)

		xfs_dir2_data_freescan(dp, hdr, &needlog);

	if (needlog)

		xfs_dir2_data_log_header(tp, dp, bp);

		xfs_dir2_data_log_header(args, bp);

	xfs_dir3_data_check(dp, bp);

	/*

	 * See if the size as a shortform is good enough.
@@ -881,7 +880,7 @@ xfs_dir2_block_replace( 
	 */

	dep->inumber = cpu_to_be64(args->inumber);

	dp->d_ops->data_put_ftype(dep, args->filetype);

	xfs_dir2_data_log_entry(args->trans, dp, bp, dep);

	xfs_dir2_data_log_entry(args, bp, dep);

	xfs_dir3_data_check(dp, bp);

	return 0;

}
@@ -1004,7 +1003,7 @@ xfs_dir2_leaf_to_block( 
	/*

	 * Use up the space at the end of the block (blp/btp).

	 */

	xfs_dir2_data_use_free(tp, dp, dbp, dup, args->geo->blksize - size, size,

	xfs_dir2_data_use_free(args, dbp, dup, args->geo->blksize - size, size,

		&needlog, &needscan);

	/*

	 * Initialize the block tail.
@@ -1030,7 +1029,7 @@ xfs_dir2_leaf_to_block( 
	if (needscan)

		xfs_dir2_data_freescan(dp, hdr, &needlog);

	if (needlog)

		xfs_dir2_data_log_header(tp, dp, dbp);

		xfs_dir2_data_log_header(args, dbp);

	/*

	 * Pitch the old leaf block.

	 */
@@ -1143,7 +1142,7 @@ xfs_dir2_sf_to_block( 
	 */

	dup = dp->d_ops->data_unused_p(hdr);

	needlog = needscan = 0;

	xfs_dir2_data_use_free(tp, dp, bp, dup, args->geo->blksize - i,

	xfs_dir2_data_use_free(args, bp, dup, args->geo->blksize - i,

			       i, &needlog, &needscan);

	ASSERT(needscan == 0);

	/*
@@ -1157,7 +1156,7 @@ xfs_dir2_sf_to_block( 
	/*

	 * Remove the freespace, we'll manage it.

	 */

	xfs_dir2_data_use_free(tp, dp, bp, dup,

	xfs_dir2_data_use_free(args, bp, dup,

		(xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),

		be16_to_cpu(dup->length), &needlog, &needscan);

	/*
@@ -1170,7 +1169,7 @@ xfs_dir2_sf_to_block( 
	dp->d_ops->data_put_ftype(dep, XFS_DIR3_FT_DIR);

	tagp = dp->d_ops->data_entry_tag_p(dep);

	*tagp = cpu_to_be16((char *)dep - (char *)hdr);

	xfs_dir2_data_log_entry(tp, dp, bp, dep);

	xfs_dir2_data_log_entry(args, bp, dep);

	blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot);

	blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(

				(char *)dep - (char *)hdr));
@@ -1184,7 +1183,7 @@ xfs_dir2_sf_to_block( 
	dp->d_ops->data_put_ftype(dep, XFS_DIR3_FT_DIR);

	tagp = dp->d_ops->data_entry_tag_p(dep);

	*tagp = cpu_to_be16((char *)dep - (char *)hdr);

	xfs_dir2_data_log_entry(tp, dp, bp, dep);

	xfs_dir2_data_log_entry(args, bp, dep);

	blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);

	blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(

				(char *)dep - (char *)hdr));
@@ -1218,7 +1217,7 @@ xfs_dir2_sf_to_block( 
			dup->length = cpu_to_be16(newoffset - offset);

			*xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16(

				((char *)dup - (char *)hdr));

			xfs_dir2_data_log_unused(tp, bp, dup);

			xfs_dir2_data_log_unused(args, bp, dup);

			xfs_dir2_data_freeinsert(hdr,

						 dp->d_ops->data_bestfree_p(hdr),

						 dup, &dummy);
@@ -1235,7 +1234,7 @@ xfs_dir2_sf_to_block( 
		memcpy(dep->name, sfep->name, dep->namelen);

		tagp = dp->d_ops->data_entry_tag_p(dep);

		*tagp = cpu_to_be16((char *)dep - (char *)hdr);

		xfs_dir2_data_log_entry(tp, dp, bp, dep);

		xfs_dir2_data_log_entry(args, bp, dep);

		name.name = sfep->name;

		name.len = sfep->namelen;

		blp[2 + i].hashval = cpu_to_be32(mp->m_dirnameops->

fs/xfs/xfs_dir2_data.c

+26 −33
Original line number Diff line number Diff line
@@ -630,8 +630,8 @@ xfs_dir3_data_init( 
	/*

	 * Log it and return it.

	 */

	xfs_dir2_data_log_header(tp, dp, bp);

	xfs_dir2_data_log_unused(tp, bp, dup);

	xfs_dir2_data_log_header(args, bp);

	xfs_dir2_data_log_unused(args, bp, dup);

	*bpp = bp;

	return 0;

}
@@ -641,8 +641,7 @@ xfs_dir3_data_init( 
 */

void

xfs_dir2_data_log_entry(

	struct xfs_trans	*tp,

	struct xfs_inode	*dp,

	struct xfs_da_args	*args,

	struct xfs_buf		*bp,

	xfs_dir2_data_entry_t	*dep)		/* data entry pointer */

{
@@ -653,8 +652,8 @@ xfs_dir2_data_log_entry( 
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||

	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));



	xfs_trans_log_buf(tp, bp, (uint)((char *)dep - (char *)hdr),

		(uint)((char *)(dp->d_ops->data_entry_tag_p(dep) + 1) -

	xfs_trans_log_buf(args->trans, bp, (uint)((char *)dep - (char *)hdr),

		(uint)((char *)(args->dp->d_ops->data_entry_tag_p(dep) + 1) -

		       (char *)hdr - 1));

}
@@ -663,8 +662,7 @@ xfs_dir2_data_log_entry( 
 */

void

xfs_dir2_data_log_header(

	struct xfs_trans	*tp,

	struct xfs_inode	*dp,

	struct xfs_da_args	*args,

	struct xfs_buf		*bp)

{

#ifdef DEBUG
@@ -676,7 +674,8 @@ xfs_dir2_data_log_header( 
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));

#endif



	xfs_trans_log_buf(tp, bp, 0, dp->d_ops->data_entry_offset - 1);

	xfs_trans_log_buf(args->trans, bp, 0,

			  args->dp->d_ops->data_entry_offset - 1);

}



/*
@@ -684,7 +683,7 @@ xfs_dir2_data_log_header( 
 */

void

xfs_dir2_data_log_unused(

	struct xfs_trans	*tp,

	struct xfs_da_args	*args,

	struct xfs_buf		*bp,

	xfs_dir2_data_unused_t	*dup)		/* data unused pointer */

{
@@ -698,13 +697,13 @@ xfs_dir2_data_log_unused( 
	/*

	 * Log the first part of the unused entry.

	 */

	xfs_trans_log_buf(tp, bp, (uint)((char *)dup - (char *)hdr),

	xfs_trans_log_buf(args->trans, bp, (uint)((char *)dup - (char *)hdr),

		(uint)((char *)&dup->length + sizeof(dup->length) -

		       1 - (char *)hdr));

	/*

	 * Log the end (tag) of the unused entry.

	 */

	xfs_trans_log_buf(tp, bp,

	xfs_trans_log_buf(args->trans, bp,

		(uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr),

		(uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr +

		       sizeof(xfs_dir2_data_off_t) - 1));
@@ -716,8 +715,7 @@ xfs_dir2_data_log_unused( 
 */

void

xfs_dir2_data_make_free(

	struct xfs_trans	*tp,

	struct xfs_inode	*dp,

	struct xfs_da_args	*args,

	struct xfs_buf		*bp,

	xfs_dir2_data_aoff_t	offset,		/* starting byte offset */

	xfs_dir2_data_aoff_t	len,		/* length in bytes */
@@ -727,37 +725,33 @@ xfs_dir2_data_make_free( 
	xfs_dir2_data_hdr_t	*hdr;		/* data block pointer */

	xfs_dir2_data_free_t	*dfp;		/* bestfree pointer */

	char			*endptr;	/* end of data area */

	xfs_mount_t		*mp;		/* filesystem mount point */

	int			needscan;	/* need to regen bestfree */

	xfs_dir2_data_unused_t	*newdup;	/* new unused entry */

	xfs_dir2_data_unused_t	*postdup;	/* unused entry after us */

	xfs_dir2_data_unused_t	*prevdup;	/* unused entry before us */

	struct xfs_dir2_data_free *bf;

	struct xfs_da_geometry	*geo;



	mp = tp->t_mountp;

	hdr = bp->b_addr;

	geo = mp->m_dir_geo;



	/*

	 * Figure out where the end of the data area is.

	 */

	if (hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||

	    hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC))

		endptr = (char *)hdr + geo->blksize;

		endptr = (char *)hdr + args->geo->blksize;

	else {

		xfs_dir2_block_tail_t	*btp;	/* block tail */



		ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||

			hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));

		btp = xfs_dir2_block_tail_p(geo, hdr);

		btp = xfs_dir2_block_tail_p(args->geo, hdr);

		endptr = (char *)xfs_dir2_block_leaf_p(btp);

	}

	/*

	 * If this isn't the start of the block, then back up to

	 * the previous entry and see if it's free.

	 */

	if (offset > dp->d_ops->data_entry_offset) {

	if (offset > args->dp->d_ops->data_entry_offset) {

		__be16			*tagp;	/* tag just before us */



		tagp = (__be16 *)((char *)hdr + offset) - 1;
@@ -783,7 +777,7 @@ xfs_dir2_data_make_free( 
	 * Previous and following entries are both free,

	 * merge everything into a single free entry.

	 */

	bf = dp->d_ops->data_bestfree_p(hdr);

	bf = args->dp->d_ops->data_bestfree_p(hdr);

	if (prevdup && postdup) {

		xfs_dir2_data_free_t	*dfp2;	/* another bestfree pointer */
@@ -805,7 +799,7 @@ xfs_dir2_data_make_free( 
		be16_add_cpu(&prevdup->length, len + be16_to_cpu(postdup->length));

		*xfs_dir2_data_unused_tag_p(prevdup) =

			cpu_to_be16((char *)prevdup - (char *)hdr);

		xfs_dir2_data_log_unused(tp, bp, prevdup);

		xfs_dir2_data_log_unused(args, bp, prevdup);

		if (!needscan) {

			/*

			 * Has to be the case that entries 0 and 1 are
@@ -840,7 +834,7 @@ xfs_dir2_data_make_free( 
		be16_add_cpu(&prevdup->length, len);

		*xfs_dir2_data_unused_tag_p(prevdup) =

			cpu_to_be16((char *)prevdup - (char *)hdr);

		xfs_dir2_data_log_unused(tp, bp, prevdup);

		xfs_dir2_data_log_unused(args, bp, prevdup);

		/*

		 * If the previous entry was in the table, the new entry

		 * is longer, so it will be in the table too.  Remove
@@ -868,7 +862,7 @@ xfs_dir2_data_make_free( 
		newdup->length = cpu_to_be16(len + be16_to_cpu(postdup->length));

		*xfs_dir2_data_unused_tag_p(newdup) =

			cpu_to_be16((char *)newdup - (char *)hdr);

		xfs_dir2_data_log_unused(tp, bp, newdup);

		xfs_dir2_data_log_unused(args, bp, newdup);

		/*

		 * If the following entry was in the table, the new entry

		 * is longer, so it will be in the table too.  Remove
@@ -895,7 +889,7 @@ xfs_dir2_data_make_free( 
		newdup->length = cpu_to_be16(len);

		*xfs_dir2_data_unused_tag_p(newdup) =

			cpu_to_be16((char *)newdup - (char *)hdr);

		xfs_dir2_data_log_unused(tp, bp, newdup);

		xfs_dir2_data_log_unused(args, bp, newdup);

		xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);

	}

	*needscanp = needscan;
@@ -906,8 +900,7 @@ xfs_dir2_data_make_free( 
 */

void

xfs_dir2_data_use_free(

	struct xfs_trans	*tp,

	struct xfs_inode	*dp,

	struct xfs_da_args	*args,

	struct xfs_buf		*bp,

	xfs_dir2_data_unused_t	*dup,		/* unused entry */

	xfs_dir2_data_aoff_t	offset,		/* starting offset to use */
@@ -938,7 +931,7 @@ xfs_dir2_data_use_free( 
	 * Look up the entry in the bestfree table.

	 */

	oldlen = be16_to_cpu(dup->length);

	bf = dp->d_ops->data_bestfree_p(hdr);

	bf = args->dp->d_ops->data_bestfree_p(hdr);

	dfp = xfs_dir2_data_freefind(hdr, bf, dup);

	ASSERT(dfp || oldlen <= be16_to_cpu(bf[2].length));

	/*
@@ -970,7 +963,7 @@ xfs_dir2_data_use_free( 
		newdup->length = cpu_to_be16(oldlen - len);

		*xfs_dir2_data_unused_tag_p(newdup) =

			cpu_to_be16((char *)newdup - (char *)hdr);

		xfs_dir2_data_log_unused(tp, bp, newdup);

		xfs_dir2_data_log_unused(args, bp, newdup);

		/*

		 * If it was in the table, remove it and add the new one.

		 */
@@ -998,7 +991,7 @@ xfs_dir2_data_use_free( 
		newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);

		*xfs_dir2_data_unused_tag_p(newdup) =

			cpu_to_be16((char *)newdup - (char *)hdr);

		xfs_dir2_data_log_unused(tp, bp, newdup);

		xfs_dir2_data_log_unused(args, bp, newdup);

		/*

		 * If it was in the table, remove it and add the new one.

		 */
@@ -1026,13 +1019,13 @@ xfs_dir2_data_use_free( 
		newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);

		*xfs_dir2_data_unused_tag_p(newdup) =

			cpu_to_be16((char *)newdup - (char *)hdr);

		xfs_dir2_data_log_unused(tp, bp, newdup);

		xfs_dir2_data_log_unused(args, bp, newdup);

		newdup2 = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);

		newdup2->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);

		newdup2->length = cpu_to_be16(oldlen - len - be16_to_cpu(newdup->length));

		*xfs_dir2_data_unused_tag_p(newdup2) =

			cpu_to_be16((char *)newdup2 - (char *)hdr);

		xfs_dir2_data_log_unused(tp, bp, newdup2);

		xfs_dir2_data_log_unused(args, bp, newdup2);

		/*

		 * If the old entry was in the table, we need to scan

		 * if the 3rd entry was valid, since these entries

fs/xfs/xfs_dir2_leaf.c

+53 −50
Original line number Diff line number Diff line
@@ -41,9 +41,10 @@ 
 */

static int xfs_dir2_leaf_lookup_int(xfs_da_args_t *args, struct xfs_buf **lbpp,

				    int *indexp, struct xfs_buf **dbpp);

static void xfs_dir3_leaf_log_bests(struct xfs_trans *tp, struct xfs_buf *bp,

				    int first, int last);

static void xfs_dir3_leaf_log_tail(struct xfs_trans *tp, struct xfs_buf *bp);

static void xfs_dir3_leaf_log_bests(struct xfs_da_args *args,

				    struct xfs_buf *bp, int first, int last);

static void xfs_dir3_leaf_log_tail(struct xfs_da_args *args,

				   struct xfs_buf *bp);



/*

 * Check the internal consistency of a leaf1 block.
@@ -357,9 +358,9 @@ xfs_dir3_leaf_get_buf( 
		return error;



	xfs_dir3_leaf_init(mp, tp, bp, dp->i_ino, magic);

	xfs_dir3_leaf_log_header(tp, dp, bp);

	xfs_dir3_leaf_log_header(args, bp);

	if (magic == XFS_DIR2_LEAF1_MAGIC)

		xfs_dir3_leaf_log_tail(tp, bp);

		xfs_dir3_leaf_log_tail(args, bp);

	*bpp = bp;

	return 0;

}
@@ -428,21 +429,21 @@ xfs_dir2_block_to_leaf( 
	leafhdr.count = be32_to_cpu(btp->count);

	leafhdr.stale = be32_to_cpu(btp->stale);

	dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);

	xfs_dir3_leaf_log_header(tp, dp, lbp);

	xfs_dir3_leaf_log_header(args, lbp);



	/*

	 * Could compact these but I think we always do the conversion

	 * after squeezing out stale entries.

	 */

	memcpy(ents, blp, be32_to_cpu(btp->count) * sizeof(xfs_dir2_leaf_entry_t));

	xfs_dir3_leaf_log_ents(tp, dp, lbp, 0, leafhdr.count - 1);

	xfs_dir3_leaf_log_ents(args, lbp, 0, leafhdr.count - 1);

	needscan = 0;

	needlog = 1;

	/*

	 * Make the space formerly occupied by the leaf entries and block

	 * tail be free.

	 */

	xfs_dir2_data_make_free(tp, dp, dbp,

	xfs_dir2_data_make_free(args, dbp,

		(xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),

		(xfs_dir2_data_aoff_t)((char *)hdr + args->geo->blksize -

				       (char *)blp),
@@ -470,10 +471,10 @@ xfs_dir2_block_to_leaf( 
	 * Log the data header and leaf bests table.

	 */

	if (needlog)

		xfs_dir2_data_log_header(tp, dp, dbp);

		xfs_dir2_data_log_header(args, dbp);

	xfs_dir3_leaf_check(dp, lbp);

	xfs_dir3_data_check(dp, dbp);

	xfs_dir3_leaf_log_bests(tp, lbp, 0, 0);

	xfs_dir3_leaf_log_bests(args, lbp, 0, 0);

	return 0;

}
@@ -811,14 +812,15 @@ xfs_dir2_leaf_addname( 
			memmove(&bestsp[0], &bestsp[1],

				be32_to_cpu(ltp->bestcount) * sizeof(bestsp[0]));

			be32_add_cpu(&ltp->bestcount, 1);

			xfs_dir3_leaf_log_tail(tp, lbp);

			xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);

			xfs_dir3_leaf_log_tail(args, lbp);

			xfs_dir3_leaf_log_bests(args, lbp, 0,

						be32_to_cpu(ltp->bestcount) - 1);

		}

		/*

		 * If we're filling in a previously empty block just log it.

		 */

		else

			xfs_dir3_leaf_log_bests(tp, lbp, use_block, use_block);

			xfs_dir3_leaf_log_bests(args, lbp, use_block, use_block);

		hdr = dbp->b_addr;

		bf = dp->d_ops->data_bestfree_p(hdr);

		bestsp[use_block] = bf[0].length;
@@ -849,7 +851,7 @@ xfs_dir2_leaf_addname( 
	/*

	 * Mark the initial part of our freespace in use for the new entry.

	 */

	xfs_dir2_data_use_free(tp, dp, dbp, dup,

	xfs_dir2_data_use_free(args, dbp, dup,

		(xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length,

		&needlog, &needscan);

	/*
@@ -871,8 +873,8 @@ xfs_dir2_leaf_addname( 
	 * Need to log the data block's header.

	 */

	if (needlog)

		xfs_dir2_data_log_header(tp, dp, dbp);

	xfs_dir2_data_log_entry(tp, dp, dbp, dep);

		xfs_dir2_data_log_header(args, dbp);

	xfs_dir2_data_log_entry(args, dbp, dep);

	/*

	 * If the bests table needs to be changed, do it.

	 * Log the change unless we've already done that.
@@ -880,7 +882,7 @@ xfs_dir2_leaf_addname( 
	if (be16_to_cpu(bestsp[use_block]) != be16_to_cpu(bf[0].length)) {

		bestsp[use_block] = bf[0].length;

		if (!grown)

			xfs_dir3_leaf_log_bests(tp, lbp, use_block, use_block);

			xfs_dir3_leaf_log_bests(args, lbp, use_block, use_block);

	}



	lep = xfs_dir3_leaf_find_entry(&leafhdr, ents, index, compact, lowstale,
@@ -897,8 +899,8 @@ xfs_dir2_leaf_addname( 
	 * Log the leaf fields and give up the buffers.

	 */

	dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);

	xfs_dir3_leaf_log_header(tp, dp, lbp);

	xfs_dir3_leaf_log_ents(tp, dp, lbp, lfloglow, lfloghigh);

	xfs_dir3_leaf_log_header(args, lbp);

	xfs_dir3_leaf_log_ents(args, lbp, lfloglow, lfloghigh);

	xfs_dir3_leaf_check(dp, lbp);

	xfs_dir3_data_check(dp, dbp);

	return 0;
@@ -950,9 +952,9 @@ xfs_dir3_leaf_compact( 
	leafhdr->stale = 0;



	dp->d_ops->leaf_hdr_to_disk(leaf, leafhdr);

	xfs_dir3_leaf_log_header(args->trans, dp, bp);

	xfs_dir3_leaf_log_header(args, bp);

	if (loglow != -1)

		xfs_dir3_leaf_log_ents(args->trans, dp, bp, loglow, to - 1);

		xfs_dir3_leaf_log_ents(args, bp, loglow, to - 1);

}



/*
@@ -1054,7 +1056,7 @@ xfs_dir3_leaf_compact_x1( 
 */

static void

xfs_dir3_leaf_log_bests(

	xfs_trans_t		*tp,		/* transaction pointer */

	struct xfs_da_args	*args,

	struct xfs_buf		*bp,		/* leaf buffer */

	int			first,		/* first entry to log */

	int			last)		/* last entry to log */
@@ -1067,10 +1069,11 @@ xfs_dir3_leaf_log_bests( 
	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||

	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC));



	ltp = xfs_dir2_leaf_tail_p(tp->t_mountp->m_dir_geo, leaf);

	ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

	firstb = xfs_dir2_leaf_bests_p(ltp) + first;

	lastb = xfs_dir2_leaf_bests_p(ltp) + last;

	xfs_trans_log_buf(tp, bp, (uint)((char *)firstb - (char *)leaf),

	xfs_trans_log_buf(args->trans, bp,

		(uint)((char *)firstb - (char *)leaf),

		(uint)((char *)lastb - (char *)leaf + sizeof(*lastb) - 1));

}
@@ -1079,8 +1082,7 @@ xfs_dir3_leaf_log_bests( 
 */

void

xfs_dir3_leaf_log_ents(

	struct xfs_trans	*tp,

	struct xfs_inode	*dp,

	struct xfs_da_args	*args,

	struct xfs_buf		*bp,

	int			first,

	int			last)
@@ -1095,10 +1097,11 @@ xfs_dir3_leaf_log_ents( 
	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||

	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));



	ents = dp->d_ops->leaf_ents_p(leaf);

	ents = args->dp->d_ops->leaf_ents_p(leaf);

	firstlep = &ents[first];

	lastlep = &ents[last];

	xfs_trans_log_buf(tp, bp, (uint)((char *)firstlep - (char *)leaf),

	xfs_trans_log_buf(args->trans, bp,

		(uint)((char *)firstlep - (char *)leaf),

		(uint)((char *)lastlep - (char *)leaf + sizeof(*lastlep) - 1));

}
@@ -1107,8 +1110,7 @@ xfs_dir3_leaf_log_ents( 
 */

void

xfs_dir3_leaf_log_header(

	struct xfs_trans	*tp,

	struct xfs_inode	*dp,

	struct xfs_da_args	*args,

	struct xfs_buf		*bp)

{

	struct xfs_dir2_leaf	*leaf = bp->b_addr;
@@ -1118,8 +1120,9 @@ xfs_dir3_leaf_log_header( 
	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||

	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));



	xfs_trans_log_buf(tp, bp, (uint)((char *)&leaf->hdr - (char *)leaf),

			  dp->d_ops->leaf_hdr_size - 1);

	xfs_trans_log_buf(args->trans, bp,

			  (uint)((char *)&leaf->hdr - (char *)leaf),

			  args->dp->d_ops->leaf_hdr_size - 1);

}



/*
@@ -1127,21 +1130,20 @@ xfs_dir3_leaf_log_header( 
 */

STATIC void

xfs_dir3_leaf_log_tail(

	struct xfs_trans	*tp,

	struct xfs_da_args	*args,

	struct xfs_buf		*bp)

{

	struct xfs_dir2_leaf	*leaf = bp->b_addr;

	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */

	struct xfs_mount	*mp = tp->t_mountp;



	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||

	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||

	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||

	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));



	ltp = xfs_dir2_leaf_tail_p(mp->m_dir_geo, leaf);

	xfs_trans_log_buf(tp, bp, (uint)((char *)ltp - (char *)leaf),

		(uint)(mp->m_dir_geo->blksize - 1));

	ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);

	xfs_trans_log_buf(args->trans, bp, (uint)((char *)ltp - (char *)leaf),

		(uint)(args->geo->blksize - 1));

}



/*
@@ -1395,7 +1397,7 @@ xfs_dir2_leaf_removename( 
	/*

	 * Mark the former data entry unused.

	 */

	xfs_dir2_data_make_free(tp, dp, dbp,

	xfs_dir2_data_make_free(args, dbp,

		(xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),

		dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);

	/*
@@ -1403,10 +1405,10 @@ xfs_dir2_leaf_removename( 
	 */

	leafhdr.stale++;

	dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);

	xfs_dir3_leaf_log_header(tp, dp, lbp);

	xfs_dir3_leaf_log_header(args, lbp);



	lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);

	xfs_dir3_leaf_log_ents(tp, dp, lbp, index, index);

	xfs_dir3_leaf_log_ents(args, lbp, index, index);



	/*

	 * Scan the freespace in the data block again if necessary,
@@ -1415,14 +1417,14 @@ xfs_dir2_leaf_removename( 
	if (needscan)

		xfs_dir2_data_freescan(dp, hdr, &needlog);

	if (needlog)

		xfs_dir2_data_log_header(tp, dp, dbp);

		xfs_dir2_data_log_header(args, dbp);

	/*

	 * If the longest freespace in the data block has changed,

	 * put the new value in the bests table and log that.

	 */

	if (be16_to_cpu(bf[0].length) != oldbest) {

		bestsp[db] = bf[0].length;

		xfs_dir3_leaf_log_bests(tp, lbp, db, db);

		xfs_dir3_leaf_log_bests(args, lbp, db, db);

	}

	xfs_dir3_data_check(dp, dbp);

	/*
@@ -1463,8 +1465,9 @@ xfs_dir2_leaf_removename( 
			memmove(&bestsp[db - i], bestsp,

				(be32_to_cpu(ltp->bestcount) - (db - i)) * sizeof(*bestsp));

			be32_add_cpu(&ltp->bestcount, -(db - i));

			xfs_dir3_leaf_log_tail(tp, lbp);

			xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);

			xfs_dir3_leaf_log_tail(args, lbp);

			xfs_dir3_leaf_log_bests(args, lbp, 0,

						be32_to_cpu(ltp->bestcount) - 1);

		} else

			bestsp[db] = cpu_to_be16(NULLDATAOFF);

	}
@@ -1527,7 +1530,7 @@ xfs_dir2_leaf_replace( 
	dep->inumber = cpu_to_be64(args->inumber);

	dp->d_ops->data_put_ftype(dep, args->filetype);

	tp = args->trans;

	xfs_dir2_data_log_entry(tp, dp, dbp, dep);

	xfs_dir2_data_log_entry(args, dbp, dep);

	xfs_dir3_leaf_check(dp, lbp);

	xfs_trans_brelse(tp, lbp);

	return 0;
@@ -1648,8 +1651,8 @@ xfs_dir2_leaf_trim_data( 
	bestsp = xfs_dir2_leaf_bests_p(ltp);

	be32_add_cpu(&ltp->bestcount, -1);

	memmove(&bestsp[1], &bestsp[0], be32_to_cpu(ltp->bestcount) * sizeof(*bestsp));

	xfs_dir3_leaf_log_tail(tp, lbp);

	xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);

	xfs_dir3_leaf_log_tail(args, lbp);

	xfs_dir3_leaf_log_bests(args, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);

	return 0;

}
@@ -1795,9 +1798,9 @@ xfs_dir2_node_to_leaf( 
		freehdr.nvalid * sizeof(xfs_dir2_data_off_t));



	dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);

	xfs_dir3_leaf_log_header(tp, dp, lbp);

	xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);

	xfs_dir3_leaf_log_tail(tp, lbp);

	xfs_dir3_leaf_log_header(args, lbp);

	xfs_dir3_leaf_log_bests(args, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);

	xfs_dir3_leaf_log_tail(args, lbp);

	xfs_dir3_leaf_check(dp, lbp);



	/*

fs/xfs/xfs_dir2_node.c

+31 −37

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE