1 // SPDX-License-Identifier: GPL-2.0
3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
40 	struct xfs_buf_log_format	*blfp = iovec->i_addr;  in xfs_buf_log_check_iovec()
44 	if (offsetof(struct xfs_buf_log_format, blf_data_map) > iovec->i_len)  in xfs_buf_log_check_iovec()
47 	item_end = (char *)iovec->i_addr + iovec->i_len;  in xfs_buf_log_check_iovec()
48 	bmp_end = (char *)&blfp->blf_data_map[blfp->blf_map_size];  in xfs_buf_log_check_iovec()
57 			(blfp->blf_map_size * sizeof(blfp->blf_data_map[0]));  in xfs_buf_log_format_size()
73 	if (last - first != nbits * XFS_BLF_CHUNK)  in xfs_buf_item_straddle()
80  * item segment.
83  * stretch of non-contiguous chunks to be logged.  Contiguous chunks are logged
94 	struct xfs_buf			*bp = bip->bli_buf;  in xfs_buf_item_size_segment()
100 	first_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size, 0);  in xfs_buf_item_size_segment()
101 	if (first_bit == -1)  in xfs_buf_item_size_segment()
108 		nbits = xfs_contig_bits(blfp->blf_data_map,  in xfs_buf_item_size_segment()
109 					blfp->blf_map_size, first_bit);  in xfs_buf_item_size_segment()
125 		 * returns the next set bit from there.  It returns -1  in xfs_buf_item_size_segment()
129 		first_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size,  in xfs_buf_item_size_segment()
131 	} while (first_bit != -1);  in xfs_buf_item_size_segment()
140 	while (last_bit != -1) {  in xfs_buf_item_size_segment()
143 		 * returns the next set bit from there.  It returns -1  in xfs_buf_item_size_segment()
147 		next_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size,  in xfs_buf_item_size_segment()
154 		if (next_bit == -1) {  in xfs_buf_item_size_segment()
172  * item.
178  * discontiguous buffers to be in-memory constructs, completely transparent to
182  * format structures. If the item has previously been logged and has dirty
184  * reducing the size of the relogged item by the amount of dirty data tracked
185  * by the log item. This can result in the committing transaction reducing the
195 	struct xfs_buf		*bp = bip->bli_buf;  in xfs_buf_item_size()
200 	ASSERT(atomic_read(&bip->bli_refcount) > 0);  in xfs_buf_item_size()
201 	if (bip->bli_flags & XFS_BLI_STALE) {  in xfs_buf_item_size()
205 		 * going to replay the changes tracked in the log item.  in xfs_buf_item_size()
208 		ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);  in xfs_buf_item_size()
209 		*nvecs += bip->bli_format_count;  in xfs_buf_item_size()
210 		for (i = 0; i < bip->bli_format_count; i++) {  in xfs_buf_item_size()
211 			*nbytes += xfs_buf_log_format_size(&bip->bli_formats[i]);  in xfs_buf_item_size()
216 	ASSERT(bip->bli_flags & XFS_BLI_LOGGED);  in xfs_buf_item_size()
218 	if (bip->bli_flags & XFS_BLI_ORDERED) {  in xfs_buf_item_size()
239 	for (i = 0; i < bip->bli_format_count; i++) {  in xfs_buf_item_size()
240 		xfs_buf_item_size_segment(bip, &bip->bli_formats[i], offset,  in xfs_buf_item_size()
242 		offset += BBTOB(bp->b_maps[i].bm_len);  in xfs_buf_item_size()
247 	 * allocations that need to be done as this item grows when relogged by  in xfs_buf_item_size()
277 	struct xfs_buf		*bp = bip->bli_buf;  in xfs_buf_item_format_segment()
284 	/* copy the flags across from the base format item */  in xfs_buf_item_format_segment()
285 	blfp->blf_flags = bip->__bli_format.blf_flags;  in xfs_buf_item_format_segment()
288 	 * Base size is the actual size of the ondisk structure - it reflects  in xfs_buf_item_format_segment()
294 	first_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size, 0);  in xfs_buf_item_format_segment()
295 	if (!(bip->bli_flags & XFS_BLI_STALE) && first_bit == -1) {  in xfs_buf_item_format_segment()
304 	blfp->blf_size = 1;  in xfs_buf_item_format_segment()
306 	if (bip->bli_flags & XFS_BLI_STALE) {  in xfs_buf_item_format_segment()
313 		ASSERT(blfp->blf_flags & XFS_BLF_CANCEL);  in xfs_buf_item_format_segment()
323 		nbits = xfs_contig_bits(blfp->blf_data_map,  in xfs_buf_item_format_segment()
324 					blfp->blf_map_size, first_bit);  in xfs_buf_item_format_segment()
337 		blfp->blf_size++;  in xfs_buf_item_format_segment()
341 		 * returns the next set bit from there.  It returns -1  in xfs_buf_item_format_segment()
345 		first_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size,  in xfs_buf_item_format_segment()
347 	} while (first_bit != -1);  in xfs_buf_item_format_segment()
352 	ASSERT(bp->b_addr == NULL);  in xfs_buf_item_format_segment()
358 		 * returns the next set bit from there.  It returns -1  in xfs_buf_item_format_segment()
362 		next_bit = xfs_next_bit(blfp->blf_data_map, blfp->blf_map_size,  in xfs_buf_item_format_segment()
371 		if (next_bit == -1) {  in xfs_buf_item_format_segment()
374 			blfp->blf_size++;  in xfs_buf_item_format_segment()
380 			blfp->blf_size++;  in xfs_buf_item_format_segment()
393  * given log buf item.  It fills the first entry with a buf log
403 	struct xfs_buf		*bp = bip->bli_buf;  in xfs_buf_item_format()
408 	ASSERT(atomic_read(&bip->bli_refcount) > 0);  in xfs_buf_item_format()
409 	ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||  in xfs_buf_item_format()
410 	       (bip->bli_flags & XFS_BLI_STALE));  in xfs_buf_item_format()
411 	ASSERT((bip->bli_flags & XFS_BLI_STALE) ||  in xfs_buf_item_format()
412 	       (xfs_blft_from_flags(&bip->__bli_format) > XFS_BLFT_UNKNOWN_BUF  in xfs_buf_item_format()
413 	        && xfs_blft_from_flags(&bip->__bli_format) < XFS_BLFT_MAX_BUF));  in xfs_buf_item_format()
414 	ASSERT(!(bip->bli_flags & XFS_BLI_ORDERED) ||  in xfs_buf_item_format()
415 	       (bip->bli_flags & XFS_BLI_STALE));  in xfs_buf_item_format()
419 	 * If it is an inode buffer, transfer the in-memory state to the  in xfs_buf_item_format()
420 	 * format flags and clear the in-memory state.  in xfs_buf_item_format()
427 	 * For icreate item based inode allocation, the buffers aren't written  in xfs_buf_item_format()
432 	if (bip->bli_flags & XFS_BLI_INODE_BUF) {  in xfs_buf_item_format()
433 		if (xfs_has_v3inodes(lip->li_log->l_mp) ||  in xfs_buf_item_format()
434 		    !((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&  in xfs_buf_item_format()
436 			bip->__bli_format.blf_flags |= XFS_BLF_INODE_BUF;  in xfs_buf_item_format()
437 		bip->bli_flags &= ~XFS_BLI_INODE_BUF;  in xfs_buf_item_format()
440 	for (i = 0; i < bip->bli_format_count; i++) {  in xfs_buf_item_format()
442 					    &bip->bli_formats[i]);  in xfs_buf_item_format()
443 		offset += BBTOB(bp->b_maps[i].bm_len);  in xfs_buf_item_format()
453  * This is called to pin the buffer associated with the buf log item in memory
456  * We take a reference to the buffer log item here so that the BLI life cycle
475 	ASSERT(atomic_read(&bip->bli_refcount) > 0);  in xfs_buf_item_pin()
476 	ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||  in xfs_buf_item_pin()
477 	       (bip->bli_flags & XFS_BLI_ORDERED) ||  in xfs_buf_item_pin()
478 	       (bip->bli_flags & XFS_BLI_STALE));  in xfs_buf_item_pin()
482 	xfs_buf_hold(bip->bli_buf);  in xfs_buf_item_pin()
483 	atomic_inc(&bip->bli_refcount);  in xfs_buf_item_pin()
484 	atomic_inc(&bip->bli_buf->b_pin_count);  in xfs_buf_item_pin()
488  * This is called to unpin the buffer associated with the buf log item which was
504  * true) then we re-use the current pin reference as the IO reference we hand
513 	struct xfs_buf		*bp = bip->bli_buf;  in xfs_buf_item_unpin()
514 	int			stale = bip->bli_flags & XFS_BLI_STALE;  in xfs_buf_item_unpin()
517 	ASSERT(bp->b_log_item == bip);  in xfs_buf_item_unpin()
518 	ASSERT(atomic_read(&bip->bli_refcount) > 0);  in xfs_buf_item_unpin()
522 	freed = atomic_dec_and_test(&bip->bli_refcount);  in xfs_buf_item_unpin()
523 	if (atomic_dec_and_test(&bp->b_pin_count))  in xfs_buf_item_unpin()
524 		wake_up_all(&bp->b_waiters);  in xfs_buf_item_unpin()
536 		ASSERT(bip->bli_flags & XFS_BLI_STALE);  in xfs_buf_item_unpin()
538 		ASSERT(bp->b_flags & XBF_STALE);  in xfs_buf_item_unpin()
539 		ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);  in xfs_buf_item_unpin()
540 		ASSERT(list_empty(&lip->li_trans));  in xfs_buf_item_unpin()
541 		ASSERT(!bp->b_transp);  in xfs_buf_item_unpin()
549 		 * that we only have one reference to drop once item completion  in xfs_buf_item_unpin()
556 		 * not have the item on the AIL. xfs_trans_ail_delete() will  in xfs_buf_item_unpin()
560 		if (bip->bli_flags & XFS_BLI_STALE_INODE) {  in xfs_buf_item_unpin()
563 			ASSERT(list_empty(&bp->b_li_list));  in xfs_buf_item_unpin()
567 			ASSERT(bp->b_log_item == NULL);  in xfs_buf_item_unpin()
583 		bp->b_flags |= XBF_ASYNC;  in xfs_buf_item_unpin()
589 	 * BLI has no more active references - it will be moved to the AIL to  in xfs_buf_item_unpin()
602 	struct xfs_buf		*bp = bip->bli_buf;  in xfs_buf_item_push()
620 	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));  in xfs_buf_item_push()
625 	if (bp->b_flags & XBF_WRITE_FAIL) {  in xfs_buf_item_push()
638  * Drop the buffer log item refcount and take appropriate action. This helper
648 	struct xfs_log_item	*lip = &bip->bli_item;  in xfs_buf_item_put()
653 	if (!atomic_dec_and_test(&bip->bli_refcount))  in xfs_buf_item_put()
657 	 * We dropped the last ref and must free the item if clean or aborted.  in xfs_buf_item_put()
658 	 * If the bli is dirty and non-aborted, the buffer was clean in the  in xfs_buf_item_put()
662 	aborted = test_bit(XFS_LI_ABORTED, &lip->li_flags) ||  in xfs_buf_item_put()
663 			xlog_is_shutdown(lip->li_log);  in xfs_buf_item_put()
664 	dirty = bip->bli_flags & XFS_BLI_DIRTY;  in xfs_buf_item_put()
669 	 * The bli is aborted or clean. An aborted item may be in the AIL  in xfs_buf_item_put()
676 	xfs_buf_item_relse(bip->bli_buf);  in xfs_buf_item_put()
681  * Release the buffer associated with the buf log item.  If there is no dirty
682  * logged data associated with the buffer recorded in the buf log item, then
683  * free the buf log item and remove the reference to it in the buffer.
688  * We unconditionally drop the transaction's reference to the log item. If the
689  * item was logged, then another reference was taken when it was pinned, so we
694  * If the XFS_BLI_HOLD flag is set in the buf log item, then free the log item
697  * free the item.
704 	struct xfs_buf		*bp = bip->bli_buf;  in xfs_buf_item_release()
706 	bool			hold = bip->bli_flags & XFS_BLI_HOLD;  in xfs_buf_item_release()
707 	bool			stale = bip->bli_flags & XFS_BLI_STALE;  in xfs_buf_item_release()
709 	bool			ordered = bip->bli_flags & XFS_BLI_ORDERED;  in xfs_buf_item_release()
710 	bool			dirty = bip->bli_flags & XFS_BLI_DIRTY;  in xfs_buf_item_release()
712 						   &lip->li_flags);  in xfs_buf_item_release()
723 	ASSERT(!stale || (bip->__bli_format.blf_flags & XFS_BLF_CANCEL));  in xfs_buf_item_release()
727 	 * per-transaction state from the bli, which has been copied above.  in xfs_buf_item_release()
729 	bp->b_transp = NULL;  in xfs_buf_item_release()
730 	bip->bli_flags &= ~(XFS_BLI_LOGGED | XFS_BLI_HOLD | XFS_BLI_ORDERED);  in xfs_buf_item_release()
733 	 * Unref the item and unlock the buffer unless held or stale. Stale  in xfs_buf_item_release()
754  * This is called to find out where the oldest active copy of the
755  * buf log item in the on disk log resides now that the last log
757  * We always re-log all the dirty data in a buffer, so usually the
758  * latest copy in the on disk log is the only one that matters.  For
780 	if ((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) && lip->li_lsn != 0)  in xfs_buf_item_committed()
781 		return lip->li_lsn;  in xfs_buf_item_committed()
792 	struct xfs_buf		*bp = bip->bli_buf;  in xfs_buf_item_precommit()
793 	struct xfs_mount	*mp = bp->b_mount;  in xfs_buf_item_precommit()
796 	if (!bp->b_ops || !bp->b_ops->verify_struct)  in xfs_buf_item_precommit()
798 	if (bip->bli_flags & XFS_BLI_STALE)  in xfs_buf_item_precommit()
801 	fa = bp->b_ops->verify_struct(bp);  in xfs_buf_item_precommit()
803 		xfs_buf_verifier_error(bp, -EFSCORRUPTED, bp->b_ops->name,  in xfs_buf_item_precommit()
804 				bp->b_addr, BBTOB(bp->b_length), fa);  in xfs_buf_item_precommit()
832 	ASSERT(bip->bli_formats == NULL);  in xfs_buf_item_get_format()
833 	bip->bli_format_count = count;  in xfs_buf_item_get_format()
836 		bip->bli_formats = &bip->__bli_format;  in xfs_buf_item_get_format()
840 	bip->bli_formats = kmem_zalloc(count * sizeof(struct xfs_buf_log_format),  in xfs_buf_item_get_format()
848 	if (bip->bli_formats != &bip->__bli_format) {  in xfs_buf_item_free_format()
849 		kmem_free(bip->bli_formats);  in xfs_buf_item_free_format()
850 		bip->bli_formats = NULL;  in xfs_buf_item_free_format()
855  * Allocate a new buf log item to go with the given buffer.
857  * buf log item.
864 	struct xfs_buf_log_item	*bip = bp->b_log_item;  in xfs_buf_item_init()
870 	 * Check to see if there is already a buf log item for  in xfs_buf_item_init()
874 	ASSERT(bp->b_mount == mp);  in xfs_buf_item_init()
876 		ASSERT(bip->bli_item.li_type == XFS_LI_BUF);  in xfs_buf_item_init()
877 		ASSERT(!bp->b_transp);  in xfs_buf_item_init()
878 		ASSERT(bip->bli_buf == bp);  in xfs_buf_item_init()
883 	xfs_log_item_init(mp, &bip->bli_item, XFS_LI_BUF, &xfs_buf_item_ops);  in xfs_buf_item_init()
884 	bip->bli_buf = bp;  in xfs_buf_item_init()
895 	xfs_buf_item_get_format(bip, bp->b_map_count);  in xfs_buf_item_init()
897 	for (i = 0; i < bip->bli_format_count; i++) {  in xfs_buf_item_init()
898 		chunks = DIV_ROUND_UP(BBTOB(bp->b_maps[i].bm_len),  in xfs_buf_item_init()
905 	"buffer item dirty bitmap (%u uints) too small to reflect %u bytes!",  in xfs_buf_item_init()
907 					BBTOB(bp->b_maps[i].bm_len));  in xfs_buf_item_init()
908 			return -EFSCORRUPTED;  in xfs_buf_item_init()
911 		bip->bli_formats[i].blf_type = XFS_LI_BUF;  in xfs_buf_item_init()
912 		bip->bli_formats[i].blf_blkno = bp->b_maps[i].bm_bn;  in xfs_buf_item_init()
913 		bip->bli_formats[i].blf_len = bp->b_maps[i].bm_len;  in xfs_buf_item_init()
914 		bip->bli_formats[i].blf_map_size = map_size;  in xfs_buf_item_init()
917 	bp->b_log_item = bip;  in xfs_buf_item_init()
925  * item's bitmap.
955 	bits_to_set = last_bit - first_bit + 1;  in xfs_buf_item_log_segment()
967 	bit = first_bit & (uint)(NBWORD - 1);  in xfs_buf_item_log_segment()
979 		mask = ((1U << (end_bit - bit)) - 1) << bit;  in xfs_buf_item_log_segment()
982 		bits_set = end_bit - bit;  in xfs_buf_item_log_segment()
991 	while ((bits_to_set - bits_set) >= NBWORD) {  in xfs_buf_item_log_segment()
1000 	end_bit = bits_to_set - bits_set;  in xfs_buf_item_log_segment()
1002 		mask = (1U << end_bit) - 1;  in xfs_buf_item_log_segment()
1009  * item's bitmap.
1020 	struct xfs_buf		*bp = bip->bli_buf;  in xfs_buf_item_log()
1026 	for (i = 0; i < bip->bli_format_count; i++) {  in xfs_buf_item_log()
1029 		end = start + BBTOB(bp->b_maps[i].bm_len) - 1;  in xfs_buf_item_log()
1033 			start += BBTOB(bp->b_maps[i].bm_len);  in xfs_buf_item_log()
1047 		xfs_buf_item_log_segment(first - start, end - start,  in xfs_buf_item_log()
1048 					 &bip->bli_formats[i].blf_data_map[0]);  in xfs_buf_item_log()
1050 		start += BBTOB(bp->b_maps[i].bm_len);  in xfs_buf_item_log()
1065 	for (i = 0; i < bip->bli_format_count; i++) {  in xfs_buf_item_dirty_format()
1066 		if (!xfs_bitmap_empty(bip->bli_formats[i].blf_data_map,  in xfs_buf_item_dirty_format()
1067 			     bip->bli_formats[i].blf_map_size))  in xfs_buf_item_dirty_format()
1079 	kmem_free(bip->bli_item.li_lv_shadow);  in xfs_buf_item_free()
1084  * xfs_buf_item_relse() is called when the buf log item is no longer needed.
1090 	struct xfs_buf_log_item	*bip = bp->b_log_item;  in xfs_buf_item_relse()
1093 	ASSERT(!test_bit(XFS_LI_IN_AIL, &bip->bli_item.li_flags));  in xfs_buf_item_relse()
1095 	if (atomic_read(&bip->bli_refcount))  in xfs_buf_item_relse()
1097 	bp->b_log_item = NULL;  in xfs_buf_item_relse()
1108 	 * already. That's because we simulate the log-committed callbacks to  in xfs_buf_item_done()
1109 	 * unpin these buffers. Or we may never have put this item on AIL  in xfs_buf_item_done()
1118 	xfs_trans_ail_delete(&bp->b_log_item->bli_item,  in xfs_buf_item_done()
1119 			     (bp->b_flags & _XBF_LOGRECOVERY) ? 0 :  in xfs_buf_item_done()