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

Commit 56431cd1 authored by Ben Myers's avatar Ben Myers
Browse files

Merge branch 'xfs-for-3.9'

parents a49f0d1e ec47eb6b

fs/xfs/xfs_buf.c

+6 −6
Original line number Diff line number Diff line
@@ -175,7 +175,7 @@ xfs_buf_get_maps( 
	bp->b_map_count = map_count;



	if (map_count == 1) {

		bp->b_maps = &bp->b_map;

		bp->b_maps = &bp->__b_map;

		return 0;

	}
@@ -193,7 +193,7 @@ static void 
xfs_buf_free_maps(

	struct xfs_buf	*bp)

{

	if (bp->b_maps != &bp->b_map) {

	if (bp->b_maps != &bp->__b_map) {

		kmem_free(bp->b_maps);

		bp->b_maps = NULL;

	}
@@ -377,8 +377,8 @@ xfs_buf_allocate_memory( 
	}



use_alloc_page:

	start = BBTOB(bp->b_map.bm_bn) >> PAGE_SHIFT;

	end = (BBTOB(bp->b_map.bm_bn + bp->b_length) + PAGE_SIZE - 1)

	start = BBTOB(bp->b_maps[0].bm_bn) >> PAGE_SHIFT;

	end = (BBTOB(bp->b_maps[0].bm_bn + bp->b_length) + PAGE_SIZE - 1)

								>> PAGE_SHIFT;

	page_count = end - start;

	error = _xfs_buf_get_pages(bp, page_count, flags);
@@ -640,7 +640,7 @@ _xfs_buf_read( 
	xfs_buf_flags_t		flags)

{

	ASSERT(!(flags & XBF_WRITE));

	ASSERT(bp->b_map.bm_bn != XFS_BUF_DADDR_NULL);

	ASSERT(bp->b_maps[0].bm_bn != XFS_BUF_DADDR_NULL);



	bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_READ_AHEAD);

	bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | XBF_READ_AHEAD);
@@ -1709,7 +1709,7 @@ xfs_buf_cmp( 
	struct xfs_buf	*bp = container_of(b, struct xfs_buf, b_list);

	xfs_daddr_t		diff;



	diff = ap->b_map.bm_bn - bp->b_map.bm_bn;

	diff = ap->b_maps[0].bm_bn - bp->b_maps[0].bm_bn;

	if (diff < 0)

		return -1;

	if (diff > 0)

fs/xfs/xfs_buf.h

+3 −3
Original line number Diff line number Diff line
@@ -151,7 +151,7 @@ typedef struct xfs_buf { 
	struct page		**b_pages;	/* array of page pointers */

	struct page		*b_page_array[XB_PAGES]; /* inline pages */

	struct xfs_buf_map	*b_maps;	/* compound buffer map */

	struct xfs_buf_map	b_map;		/* inline compound buffer map */

	struct xfs_buf_map	__b_map;	/* inline compound buffer map */

	int			b_map_count;

	int			b_io_length;	/* IO size in BBs */

	atomic_t		b_pin_count;	/* pin count */
@@ -330,8 +330,8 @@ void xfs_buf_stale(struct xfs_buf *bp); 
 * In future, uncached buffers will pass the block number directly to the io

 * request function and hence these macros will go away at that point.

 */

#define XFS_BUF_ADDR(bp)		((bp)->b_map.bm_bn)

#define XFS_BUF_SET_ADDR(bp, bno)	((bp)->b_map.bm_bn = (xfs_daddr_t)(bno))

#define XFS_BUF_ADDR(bp)		((bp)->b_maps[0].bm_bn)

#define XFS_BUF_SET_ADDR(bp, bno)	((bp)->b_maps[0].bm_bn = (xfs_daddr_t)(bno))



static inline void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref)

{

fs/xfs/xfs_buf_item.c

+32 −121
Original line number Diff line number Diff line
@@ -37,109 +37,6 @@ static inline struct xfs_buf_log_item *BUF_ITEM(struct xfs_log_item *lip) 
	return container_of(lip, struct xfs_buf_log_item, bli_item);

}





#ifdef XFS_TRANS_DEBUG

/*

 * This function uses an alternate strategy for tracking the bytes

 * that the user requests to be logged.  This can then be used

 * in conjunction with the bli_orig array in the buf log item to

 * catch bugs in our callers' code.

 *

 * We also double check the bits set in xfs_buf_item_log using a

 * simple algorithm to check that every byte is accounted for.

 */

STATIC void

xfs_buf_item_log_debug(

	xfs_buf_log_item_t	*bip,

	uint			first,

	uint			last)

{

	uint	x;

	uint	byte;

	uint	nbytes;

	uint	chunk_num;

	uint	word_num;

	uint	bit_num;

	uint	bit_set;

	uint	*wordp;



	ASSERT(bip->bli_logged != NULL);

	byte = first;

	nbytes = last - first + 1;

	bfset(bip->bli_logged, first, nbytes);

	for (x = 0; x < nbytes; x++) {

		chunk_num = byte >> XFS_BLF_SHIFT;

		word_num = chunk_num >> BIT_TO_WORD_SHIFT;

		bit_num = chunk_num & (NBWORD - 1);

		wordp = &(bip->bli_format.blf_data_map[word_num]);

		bit_set = *wordp & (1 << bit_num);

		ASSERT(bit_set);

		byte++;

	}

}



/*

 * This function is called when we flush something into a buffer without

 * logging it.  This happens for things like inodes which are logged

 * separately from the buffer.

 */

void

xfs_buf_item_flush_log_debug(

	xfs_buf_t	*bp,

	uint		first,

	uint		last)

{

	xfs_buf_log_item_t	*bip = bp->b_fspriv;

	uint			nbytes;



	if (bip == NULL || (bip->bli_item.li_type != XFS_LI_BUF))

		return;



	ASSERT(bip->bli_logged != NULL);

	nbytes = last - first + 1;

	bfset(bip->bli_logged, first, nbytes);

}



/*

 * This function is called to verify that our callers have logged

 * all the bytes that they changed.

 *

 * It does this by comparing the original copy of the buffer stored in

 * the buf log item's bli_orig array to the current copy of the buffer

 * and ensuring that all bytes which mismatch are set in the bli_logged

 * array of the buf log item.

 */

STATIC void

xfs_buf_item_log_check(

	xfs_buf_log_item_t	*bip)

{

	char		*orig;

	char		*buffer;

	int		x;

	xfs_buf_t	*bp;



	ASSERT(bip->bli_orig != NULL);

	ASSERT(bip->bli_logged != NULL);



	bp = bip->bli_buf;

	ASSERT(bp->b_length > 0);

	ASSERT(bp->b_addr != NULL);

	orig = bip->bli_orig;

	buffer = bp->b_addr;

	for (x = 0; x < BBTOB(bp->b_length); x++) {

		if (orig[x] != buffer[x] && !btst(bip->bli_logged, x)) {

			xfs_emerg(bp->b_mount,

				"%s: bip %x buffer %x orig %x index %d",

				__func__, bip, bp, orig, x);

			ASSERT(0);

		}

	}

}

#else

#define		xfs_buf_item_log_debug(x,y,z)

#define		xfs_buf_item_log_check(x)

#endif



STATIC void	xfs_buf_do_callbacks(struct xfs_buf *bp);



/*
@@ -237,7 +134,7 @@ xfs_buf_item_size( 
		 * cancel flag in it.

		 */

		trace_xfs_buf_item_size_stale(bip);

		ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);

		ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);

		return bip->bli_format_count;

	}
@@ -278,7 +175,7 @@ xfs_buf_item_format_segment( 
	uint		buffer_offset;



	/* copy the flags across from the base format item */

	blfp->blf_flags = bip->bli_format.blf_flags;

	blfp->blf_flags = bip->__bli_format.blf_flags;



	/*

	 * Base size is the actual size of the ondisk structure - it reflects
@@ -287,6 +184,17 @@ xfs_buf_item_format_segment( 
	 */

	base_size = offsetof(struct xfs_buf_log_format, blf_data_map) +

			(blfp->blf_map_size * sizeof(blfp->blf_data_map[0]));



	nvecs = 0;

	first_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size, 0);

	if (!(bip->bli_flags & XFS_BLI_STALE) && first_bit == -1) {

		/*

		 * If the map is not be dirty in the transaction, mark

		 * the size as zero and do not advance the vector pointer.

		 */

		goto out;

	}



	vecp->i_addr = blfp;

	vecp->i_len = base_size;

	vecp->i_type = XLOG_REG_TYPE_BFORMAT;
@@ -301,15 +209,13 @@ xfs_buf_item_format_segment( 
		 */

		trace_xfs_buf_item_format_stale(bip);

		ASSERT(blfp->blf_flags & XFS_BLF_CANCEL);

		blfp->blf_size = nvecs;

		return vecp;

		goto out;

	}



	/*

	 * Fill in an iovec for each set of contiguous chunks.

	 */

	first_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size, 0);

	ASSERT(first_bit != -1);



	last_bit = first_bit;

	nbits = 1;

	for (;;) {
@@ -371,7 +277,8 @@ xfs_buf_item_format_segment( 
			nbits++;

		}

	}

	bip->bli_format.blf_size = nvecs;

out:

	blfp->blf_size = nvecs;

	return vecp;

}
@@ -405,7 +312,7 @@ xfs_buf_item_format( 
	if (bip->bli_flags & XFS_BLI_INODE_BUF) {

		if (!((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&

		      xfs_log_item_in_current_chkpt(lip)))

			bip->bli_format.blf_flags |= XFS_BLF_INODE_BUF;

			bip->__bli_format.blf_flags |= XFS_BLF_INODE_BUF;

		bip->bli_flags &= ~XFS_BLI_INODE_BUF;

	}
@@ -419,7 +326,6 @@ xfs_buf_item_format( 
	 * Check to make sure everything is consistent.

	 */

	trace_xfs_buf_item_format(bip);

	xfs_buf_item_log_check(bip);

}



/*
@@ -485,7 +391,7 @@ xfs_buf_item_unpin( 
		ASSERT(bip->bli_flags & XFS_BLI_STALE);

		ASSERT(xfs_buf_islocked(bp));

		ASSERT(XFS_BUF_ISSTALE(bp));

		ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);

		ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);



		trace_xfs_buf_item_unpin_stale(bip);
@@ -601,7 +507,7 @@ xfs_buf_item_unlock( 
{

	struct xfs_buf_log_item	*bip = BUF_ITEM(lip);

	struct xfs_buf		*bp = bip->bli_buf;

	int			aborted;

	int			aborted, clean, i;

	uint			hold;



	/* Clear the buffer's association with this transaction. */
@@ -631,7 +537,7 @@ xfs_buf_item_unlock( 
	 */

	if (bip->bli_flags & XFS_BLI_STALE) {

		trace_xfs_buf_item_unlock_stale(bip);

		ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);

		ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);

		if (!aborted) {

			atomic_dec(&bip->bli_refcount);

			return;
@@ -644,8 +550,15 @@ xfs_buf_item_unlock( 
	 * If the buf item isn't tracking any data, free it, otherwise drop the

	 * reference we hold to it.

	 */

	if (xfs_bitmap_empty(bip->bli_format.blf_data_map,

			     bip->bli_format.blf_map_size))

	clean = 1;

	for (i = 0; i < bip->bli_format_count; i++) {

		if (!xfs_bitmap_empty(bip->bli_formats[i].blf_data_map,

			     bip->bli_formats[i].blf_map_size)) {

			clean = 0;

			break;

		}

	}

	if (clean)

		xfs_buf_item_relse(bp);

	else

		atomic_dec(&bip->bli_refcount);
@@ -716,7 +629,7 @@ xfs_buf_item_get_format( 
	bip->bli_format_count = count;



	if (count == 1) {

		bip->bli_formats = &bip->bli_format;

		bip->bli_formats = &bip->__bli_format;

		return 0;

	}
@@ -731,7 +644,7 @@ STATIC void 
xfs_buf_item_free_format(

	struct xfs_buf_log_item	*bip)

{

	if (bip->bli_formats != &bip->bli_format) {

	if (bip->bli_formats != &bip->__bli_format) {

		kmem_free(bip->bli_formats);

		bip->bli_formats = NULL;

	}
@@ -898,8 +811,6 @@ xfs_buf_item_log_segment( 
		mask = (1 << end_bit) - 1;

		*wordp |= mask;

	}



	xfs_buf_item_log_debug(bip, first, last);

}



/*

fs/xfs/xfs_buf_item.h

+1 −15
Original line number Diff line number Diff line
@@ -98,13 +98,9 @@ typedef struct xfs_buf_log_item { 
	unsigned int		bli_flags;	/* misc flags */

	unsigned int		bli_recur;	/* lock recursion count */

	atomic_t		bli_refcount;	/* cnt of tp refs */

#ifdef XFS_TRANS_DEBUG

	char			*bli_orig;	/* original buffer copy */

	char			*bli_logged;	/* bytes logged (bitmap) */

#endif

	int			bli_format_count;	/* count of headers */

	struct xfs_buf_log_format *bli_formats;	/* array of in-log header ptrs */

	struct xfs_buf_log_format bli_format;	/* embedded in-log header */

	struct xfs_buf_log_format __bli_format;	/* embedded in-log header */

} xfs_buf_log_item_t;



void	xfs_buf_item_init(struct xfs_buf *, struct xfs_mount *);
@@ -117,16 +113,6 @@ void xfs_buf_attach_iodone(struct xfs_buf *, 
void	xfs_buf_iodone_callbacks(struct xfs_buf *);

void	xfs_buf_iodone(struct xfs_buf *, struct xfs_log_item *);



#ifdef XFS_TRANS_DEBUG

void

xfs_buf_item_flush_log_debug(

	struct xfs_buf *bp,

	uint	first,

	uint	last);

#else

#define	xfs_buf_item_flush_log_debug(bp, first, last)

#endif



#endif	/* __KERNEL__ */



#endif	/* __XFS_BUF_ITEM_H__ */

fs/xfs/xfs_inode.c

+0 −6
Original line number Diff line number Diff line
@@ -2379,9 +2379,6 @@ xfs_iflush_fork( 
	char			*cp;

	xfs_ifork_t		*ifp;

	xfs_mount_t		*mp;

#ifdef XFS_TRANS_DEBUG

	int			first;

#endif

	static const short	brootflag[2] =

		{ XFS_ILOG_DBROOT, XFS_ILOG_ABROOT };

	static const short	dataflag[2] =
@@ -2724,9 +2721,6 @@ xfs_iflush_int( 
	xfs_inode_log_item_t	*iip;

	xfs_dinode_t		*dip;

	xfs_mount_t		*mp;

#ifdef XFS_TRANS_DEBUG

	int			first;

#endif



	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));

	ASSERT(xfs_isiflocked(ip));