Linux Audio

Check our new training course

Loading...
v6.9.4
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  4 * All Rights Reserved.
  5 */
  6#include "xfs.h"
  7#include "xfs_fs.h"
  8#include "xfs_shared.h"
  9#include "xfs_format.h"
 10#include "xfs_log_format.h"
 11#include "xfs_trans_resv.h"
 12#include "xfs_mount.h"
 13#include "xfs_trans.h"
 14#include "xfs_buf_item.h"
 15#include "xfs_trans_priv.h"
 16#include "xfs_trace.h"
 17
 18/*
 19 * Check to see if a buffer matching the given parameters is already
 20 * a part of the given transaction.
 21 */
 22STATIC struct xfs_buf *
 23xfs_trans_buf_item_match(
 24	struct xfs_trans	*tp,
 25	struct xfs_buftarg	*target,
 26	struct xfs_buf_map	*map,
 27	int			nmaps)
 28{
 29	struct xfs_log_item	*lip;
 30	struct xfs_buf_log_item	*blip;
 31	int			len = 0;
 32	int			i;
 33
 34	for (i = 0; i < nmaps; i++)
 35		len += map[i].bm_len;
 36
 37	list_for_each_entry(lip, &tp->t_items, li_trans) {
 38		blip = (struct xfs_buf_log_item *)lip;
 39		if (blip->bli_item.li_type == XFS_LI_BUF &&
 40		    blip->bli_buf->b_target == target &&
 41		    xfs_buf_daddr(blip->bli_buf) == map[0].bm_bn &&
 42		    blip->bli_buf->b_length == len) {
 43			ASSERT(blip->bli_buf->b_map_count == nmaps);
 44			return blip->bli_buf;
 45		}
 46	}
 47
 48	return NULL;
 49}
 50
 51/*
 52 * Add the locked buffer to the transaction.
 53 *
 54 * The buffer must be locked, and it cannot be associated with any
 55 * transaction.
 56 *
 57 * If the buffer does not yet have a buf log item associated with it,
 58 * then allocate one for it.  Then add the buf item to the transaction.
 59 */
 60STATIC void
 61_xfs_trans_bjoin(
 62	struct xfs_trans	*tp,
 63	struct xfs_buf		*bp,
 64	int			reset_recur)
 65{
 66	struct xfs_buf_log_item	*bip;
 67
 68	ASSERT(bp->b_transp == NULL);
 69
 70	/*
 71	 * The xfs_buf_log_item pointer is stored in b_log_item.  If
 72	 * it doesn't have one yet, then allocate one and initialize it.
 73	 * The checks to see if one is there are in xfs_buf_item_init().
 74	 */
 75	xfs_buf_item_init(bp, tp->t_mountp);
 76	bip = bp->b_log_item;
 77	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
 78	ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
 79	ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
 80	if (reset_recur)
 81		bip->bli_recur = 0;
 82
 83	/*
 84	 * Take a reference for this transaction on the buf item.
 85	 */
 86	atomic_inc(&bip->bli_refcount);
 87
 88	/*
 89	 * Attach the item to the transaction so we can find it in
 90	 * xfs_trans_get_buf() and friends.
 91	 */
 92	xfs_trans_add_item(tp, &bip->bli_item);
 93	bp->b_transp = tp;
 94
 95}
 96
 97void
 98xfs_trans_bjoin(
 99	struct xfs_trans	*tp,
100	struct xfs_buf		*bp)
101{
102	_xfs_trans_bjoin(tp, bp, 0);
103	trace_xfs_trans_bjoin(bp->b_log_item);
104}
105
106/*
107 * Get and lock the buffer for the caller if it is not already
108 * locked within the given transaction.  If it is already locked
109 * within the transaction, just increment its lock recursion count
110 * and return a pointer to it.
111 *
112 * If the transaction pointer is NULL, make this just a normal
113 * get_buf() call.
114 */
115int
116xfs_trans_get_buf_map(
117	struct xfs_trans	*tp,
118	struct xfs_buftarg	*target,
119	struct xfs_buf_map	*map,
120	int			nmaps,
121	xfs_buf_flags_t		flags,
122	struct xfs_buf		**bpp)
123{
124	struct xfs_buf		*bp;
125	struct xfs_buf_log_item	*bip;
126	int			error;
127
128	*bpp = NULL;
129	if (!tp)
130		return xfs_buf_get_map(target, map, nmaps, flags, bpp);
131
132	/*
133	 * If we find the buffer in the cache with this transaction
134	 * pointer in its b_fsprivate2 field, then we know we already
135	 * have it locked.  In this case we just increment the lock
136	 * recursion count and return the buffer to the caller.
137	 */
138	bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
139	if (bp != NULL) {
140		ASSERT(xfs_buf_islocked(bp));
141		if (xfs_is_shutdown(tp->t_mountp)) {
142			xfs_buf_stale(bp);
143			bp->b_flags |= XBF_DONE;
144		}
145
146		ASSERT(bp->b_transp == tp);
147		bip = bp->b_log_item;
148		ASSERT(bip != NULL);
149		ASSERT(atomic_read(&bip->bli_refcount) > 0);
150		bip->bli_recur++;
151		trace_xfs_trans_get_buf_recur(bip);
152		*bpp = bp;
153		return 0;
154	}
155
156	error = xfs_buf_get_map(target, map, nmaps, flags, &bp);
157	if (error)
158		return error;
159
160	ASSERT(!bp->b_error);
161
162	_xfs_trans_bjoin(tp, bp, 1);
163	trace_xfs_trans_get_buf(bp->b_log_item);
164	*bpp = bp;
165	return 0;
166}
167
168/*
169 * Get and lock the superblock buffer for the given transaction.
170 */
171struct xfs_buf *
172xfs_trans_getsb(
173	struct xfs_trans	*tp)
 
174{
175	struct xfs_buf		*bp = tp->t_mountp->m_sb_bp;
176
177	/*
178	 * Just increment the lock recursion count if the buffer is already
179	 * attached to this transaction.
180	 */
181	if (bp->b_transp == tp) {
182		struct xfs_buf_log_item	*bip = bp->b_log_item;
183
184		ASSERT(bip != NULL);
185		ASSERT(atomic_read(&bip->bli_refcount) > 0);
186		bip->bli_recur++;
187
188		trace_xfs_trans_getsb_recur(bip);
189	} else {
190		xfs_buf_lock(bp);
191		xfs_buf_hold(bp);
192		_xfs_trans_bjoin(tp, bp, 1);
193
194		trace_xfs_trans_getsb(bp->b_log_item);
195	}
196
197	return bp;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
198}
199
200/*
201 * Get and lock the buffer for the caller if it is not already
202 * locked within the given transaction.  If it has not yet been
203 * read in, read it from disk. If it is already locked
204 * within the transaction and already read in, just increment its
205 * lock recursion count and return a pointer to it.
206 *
207 * If the transaction pointer is NULL, make this just a normal
208 * read_buf() call.
209 */
210int
211xfs_trans_read_buf_map(
212	struct xfs_mount	*mp,
213	struct xfs_trans	*tp,
214	struct xfs_buftarg	*target,
215	struct xfs_buf_map	*map,
216	int			nmaps,
217	xfs_buf_flags_t		flags,
218	struct xfs_buf		**bpp,
219	const struct xfs_buf_ops *ops)
220{
221	struct xfs_buf		*bp = NULL;
222	struct xfs_buf_log_item	*bip;
223	int			error;
224
225	*bpp = NULL;
226	/*
227	 * If we find the buffer in the cache with this transaction
228	 * pointer in its b_fsprivate2 field, then we know we already
229	 * have it locked.  If it is already read in we just increment
230	 * the lock recursion count and return the buffer to the caller.
231	 * If the buffer is not yet read in, then we read it in, increment
232	 * the lock recursion count, and return it to the caller.
233	 */
234	if (tp)
235		bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
236	if (bp) {
237		ASSERT(xfs_buf_islocked(bp));
238		ASSERT(bp->b_transp == tp);
239		ASSERT(bp->b_log_item != NULL);
240		ASSERT(!bp->b_error);
241		ASSERT(bp->b_flags & XBF_DONE);
242
243		/*
244		 * We never locked this buf ourselves, so we shouldn't
245		 * brelse it either. Just get out.
246		 */
247		if (xfs_is_shutdown(mp)) {
248			trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
249			return -EIO;
250		}
251
252		/*
253		 * Check if the caller is trying to read a buffer that is
254		 * already attached to the transaction yet has no buffer ops
255		 * assigned.  Ops are usually attached when the buffer is
256		 * attached to the transaction, or by the read caller if
257		 * special circumstances.  That didn't happen, which is not
258		 * how this is supposed to go.
259		 *
260		 * If the buffer passes verification we'll let this go, but if
261		 * not we have to shut down.  Let the transaction cleanup code
262		 * release this buffer when it kills the tranaction.
263		 */
264		ASSERT(bp->b_ops != NULL);
265		error = xfs_buf_reverify(bp, ops);
266		if (error) {
267			xfs_buf_ioerror_alert(bp, __return_address);
268
269			if (tp->t_flags & XFS_TRANS_DIRTY)
270				xfs_force_shutdown(tp->t_mountp,
271						SHUTDOWN_META_IO_ERROR);
272
273			/* bad CRC means corrupted metadata */
274			if (error == -EFSBADCRC)
275				error = -EFSCORRUPTED;
276			return error;
277		}
278
279		bip = bp->b_log_item;
280		bip->bli_recur++;
281
282		ASSERT(atomic_read(&bip->bli_refcount) > 0);
283		trace_xfs_trans_read_buf_recur(bip);
284		ASSERT(bp->b_ops != NULL || ops == NULL);
285		*bpp = bp;
286		return 0;
287	}
288
289	error = xfs_buf_read_map(target, map, nmaps, flags, &bp, ops,
290			__return_address);
291	switch (error) {
292	case 0:
293		break;
294	default:
295		if (tp && (tp->t_flags & XFS_TRANS_DIRTY))
296			xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
297		fallthrough;
298	case -ENOMEM:
299	case -EAGAIN:
300		return error;
301	}
302
303	if (xfs_is_shutdown(mp)) {
304		xfs_buf_relse(bp);
305		trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
306		return -EIO;
307	}
308
309	if (tp) {
310		_xfs_trans_bjoin(tp, bp, 1);
311		trace_xfs_trans_read_buf(bp->b_log_item);
312	}
313	ASSERT(bp->b_ops != NULL || ops == NULL);
314	*bpp = bp;
315	return 0;
316
317}
318
319/* Has this buffer been dirtied by anyone? */
320bool
321xfs_trans_buf_is_dirty(
322	struct xfs_buf		*bp)
323{
324	struct xfs_buf_log_item	*bip = bp->b_log_item;
325
326	if (!bip)
327		return false;
328	ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
329	return test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
330}
331
332/*
333 * Release a buffer previously joined to the transaction. If the buffer is
334 * modified within this transaction, decrement the recursion count but do not
335 * release the buffer even if the count goes to 0. If the buffer is not modified
336 * within the transaction, decrement the recursion count and release the buffer
337 * if the recursion count goes to 0.
338 *
339 * If the buffer is to be released and it was not already dirty before this
340 * transaction began, then also free the buf_log_item associated with it.
341 *
342 * If the transaction pointer is NULL, this is a normal xfs_buf_relse() call.
343 */
344void
345xfs_trans_brelse(
346	struct xfs_trans	*tp,
347	struct xfs_buf		*bp)
348{
349	struct xfs_buf_log_item	*bip = bp->b_log_item;
350
351	ASSERT(bp->b_transp == tp);
352
353	if (!tp) {
354		xfs_buf_relse(bp);
355		return;
356	}
357
358	trace_xfs_trans_brelse(bip);
359	ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
360	ASSERT(atomic_read(&bip->bli_refcount) > 0);
361
362	/*
363	 * If the release is for a recursive lookup, then decrement the count
364	 * and return.
365	 */
366	if (bip->bli_recur > 0) {
367		bip->bli_recur--;
368		return;
369	}
370
371	/*
372	 * If the buffer is invalidated or dirty in this transaction, we can't
373	 * release it until we commit.
374	 */
375	if (test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags))
376		return;
377	if (bip->bli_flags & XFS_BLI_STALE)
378		return;
379
380	/*
381	 * Unlink the log item from the transaction and clear the hold flag, if
382	 * set. We wouldn't want the next user of the buffer to get confused.
383	 */
384	ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
385	xfs_trans_del_item(&bip->bli_item);
386	bip->bli_flags &= ~XFS_BLI_HOLD;
387
388	/* drop the reference to the bli */
389	xfs_buf_item_put(bip);
390
391	bp->b_transp = NULL;
392	xfs_buf_relse(bp);
393}
394
395/*
396 * Forcibly detach a buffer previously joined to the transaction.  The caller
397 * will retain its locked reference to the buffer after this function returns.
398 * The buffer must be completely clean and must not be held to the transaction.
399 */
400void
401xfs_trans_bdetach(
402	struct xfs_trans	*tp,
403	struct xfs_buf		*bp)
404{
405	struct xfs_buf_log_item	*bip = bp->b_log_item;
406
407	ASSERT(tp != NULL);
408	ASSERT(bp->b_transp == tp);
409	ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
410	ASSERT(atomic_read(&bip->bli_refcount) > 0);
411
412	trace_xfs_trans_bdetach(bip);
413
414	/*
415	 * Erase all recursion count, since we're removing this buffer from the
416	 * transaction.
417	 */
418	bip->bli_recur = 0;
419
420	/*
421	 * The buffer must be completely clean.  Specifically, it had better
422	 * not be dirty, stale, logged, ordered, or held to the transaction.
423	 */
424	ASSERT(!test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags));
425	ASSERT(!(bip->bli_flags & XFS_BLI_DIRTY));
426	ASSERT(!(bip->bli_flags & XFS_BLI_HOLD));
427	ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
428	ASSERT(!(bip->bli_flags & XFS_BLI_ORDERED));
429	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
430
431	/* Unlink the log item from the transaction and drop the log item. */
432	xfs_trans_del_item(&bip->bli_item);
433	xfs_buf_item_put(bip);
434	bp->b_transp = NULL;
435}
436
437/*
438 * Mark the buffer as not needing to be unlocked when the buf item's
439 * iop_committing() routine is called.  The buffer must already be locked
440 * and associated with the given transaction.
441 */
442/* ARGSUSED */
443void
444xfs_trans_bhold(
445	xfs_trans_t		*tp,
446	struct xfs_buf		*bp)
447{
448	struct xfs_buf_log_item	*bip = bp->b_log_item;
449
450	ASSERT(bp->b_transp == tp);
451	ASSERT(bip != NULL);
452	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
453	ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
454	ASSERT(atomic_read(&bip->bli_refcount) > 0);
455
456	bip->bli_flags |= XFS_BLI_HOLD;
457	trace_xfs_trans_bhold(bip);
458}
459
460/*
461 * Cancel the previous buffer hold request made on this buffer
462 * for this transaction.
463 */
464void
465xfs_trans_bhold_release(
466	xfs_trans_t		*tp,
467	struct xfs_buf		*bp)
468{
469	struct xfs_buf_log_item	*bip = bp->b_log_item;
470
471	ASSERT(bp->b_transp == tp);
472	ASSERT(bip != NULL);
473	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
474	ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
475	ASSERT(atomic_read(&bip->bli_refcount) > 0);
476	ASSERT(bip->bli_flags & XFS_BLI_HOLD);
477
478	bip->bli_flags &= ~XFS_BLI_HOLD;
479	trace_xfs_trans_bhold_release(bip);
480}
481
482/*
483 * Mark a buffer dirty in the transaction.
484 */
485void
486xfs_trans_dirty_buf(
487	struct xfs_trans	*tp,
488	struct xfs_buf		*bp)
489{
490	struct xfs_buf_log_item	*bip = bp->b_log_item;
491
492	ASSERT(bp->b_transp == tp);
493	ASSERT(bip != NULL);
494
495	/*
496	 * Mark the buffer as needing to be written out eventually,
497	 * and set its iodone function to remove the buffer's buf log
498	 * item from the AIL and free it when the buffer is flushed
499	 * to disk.
500	 */
501	bp->b_flags |= XBF_DONE;
502
503	ASSERT(atomic_read(&bip->bli_refcount) > 0);
504
505	/*
506	 * If we invalidated the buffer within this transaction, then
507	 * cancel the invalidation now that we're dirtying the buffer
508	 * again.  There are no races with the code in xfs_buf_item_unpin(),
509	 * because we have a reference to the buffer this entire time.
510	 */
511	if (bip->bli_flags & XFS_BLI_STALE) {
512		bip->bli_flags &= ~XFS_BLI_STALE;
513		ASSERT(bp->b_flags & XBF_STALE);
514		bp->b_flags &= ~XBF_STALE;
515		bip->__bli_format.blf_flags &= ~XFS_BLF_CANCEL;
516	}
517	bip->bli_flags |= XFS_BLI_DIRTY | XFS_BLI_LOGGED;
518
519	tp->t_flags |= XFS_TRANS_DIRTY;
520	set_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
521}
522
523/*
524 * This is called to mark bytes first through last inclusive of the given
525 * buffer as needing to be logged when the transaction is committed.
526 * The buffer must already be associated with the given transaction.
527 *
528 * First and last are numbers relative to the beginning of this buffer,
529 * so the first byte in the buffer is numbered 0 regardless of the
530 * value of b_blkno.
531 */
532void
533xfs_trans_log_buf(
534	struct xfs_trans	*tp,
535	struct xfs_buf		*bp,
536	uint			first,
537	uint			last)
538{
539	struct xfs_buf_log_item	*bip = bp->b_log_item;
540
541	ASSERT(first <= last && last < BBTOB(bp->b_length));
542	ASSERT(!(bip->bli_flags & XFS_BLI_ORDERED));
543
544	xfs_trans_dirty_buf(tp, bp);
545
546	trace_xfs_trans_log_buf(bip);
547	xfs_buf_item_log(bip, first, last);
548}
549
550
551/*
552 * Invalidate a buffer that is being used within a transaction.
553 *
554 * Typically this is because the blocks in the buffer are being freed, so we
555 * need to prevent it from being written out when we're done.  Allowing it
556 * to be written again might overwrite data in the free blocks if they are
557 * reallocated to a file.
558 *
559 * We prevent the buffer from being written out by marking it stale.  We can't
560 * get rid of the buf log item at this point because the buffer may still be
561 * pinned by another transaction.  If that is the case, then we'll wait until
562 * the buffer is committed to disk for the last time (we can tell by the ref
563 * count) and free it in xfs_buf_item_unpin().  Until that happens we will
564 * keep the buffer locked so that the buffer and buf log item are not reused.
565 *
566 * We also set the XFS_BLF_CANCEL flag in the buf log format structure and log
567 * the buf item.  This will be used at recovery time to determine that copies
568 * of the buffer in the log before this should not be replayed.
569 *
570 * We mark the item descriptor and the transaction dirty so that we'll hold
571 * the buffer until after the commit.
572 *
573 * Since we're invalidating the buffer, we also clear the state about which
574 * parts of the buffer have been logged.  We also clear the flag indicating
575 * that this is an inode buffer since the data in the buffer will no longer
576 * be valid.
577 *
578 * We set the stale bit in the buffer as well since we're getting rid of it.
579 */
580void
581xfs_trans_binval(
582	xfs_trans_t		*tp,
583	struct xfs_buf		*bp)
584{
585	struct xfs_buf_log_item	*bip = bp->b_log_item;
586	int			i;
587
588	ASSERT(bp->b_transp == tp);
589	ASSERT(bip != NULL);
590	ASSERT(atomic_read(&bip->bli_refcount) > 0);
591
592	trace_xfs_trans_binval(bip);
593
594	if (bip->bli_flags & XFS_BLI_STALE) {
595		/*
596		 * If the buffer is already invalidated, then
597		 * just return.
598		 */
599		ASSERT(bp->b_flags & XBF_STALE);
600		ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
601		ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_INODE_BUF));
602		ASSERT(!(bip->__bli_format.blf_flags & XFS_BLFT_MASK));
603		ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);
604		ASSERT(test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags));
605		ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
606		return;
607	}
608
609	xfs_buf_stale(bp);
610
611	bip->bli_flags |= XFS_BLI_STALE;
612	bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
613	bip->__bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
614	bip->__bli_format.blf_flags |= XFS_BLF_CANCEL;
615	bip->__bli_format.blf_flags &= ~XFS_BLFT_MASK;
616	for (i = 0; i < bip->bli_format_count; i++) {
617		memset(bip->bli_formats[i].blf_data_map, 0,
618		       (bip->bli_formats[i].blf_map_size * sizeof(uint)));
619	}
620	set_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
621	tp->t_flags |= XFS_TRANS_DIRTY;
622}
623
624/*
625 * This call is used to indicate that the buffer contains on-disk inodes which
626 * must be handled specially during recovery.  They require special handling
627 * because only the di_next_unlinked from the inodes in the buffer should be
628 * recovered.  The rest of the data in the buffer is logged via the inodes
629 * themselves.
630 *
631 * All we do is set the XFS_BLI_INODE_BUF flag in the items flags so it can be
632 * transferred to the buffer's log format structure so that we'll know what to
633 * do at recovery time.
634 */
635void
636xfs_trans_inode_buf(
637	xfs_trans_t		*tp,
638	struct xfs_buf		*bp)
639{
640	struct xfs_buf_log_item	*bip = bp->b_log_item;
641
642	ASSERT(bp->b_transp == tp);
643	ASSERT(bip != NULL);
644	ASSERT(atomic_read(&bip->bli_refcount) > 0);
645
646	bip->bli_flags |= XFS_BLI_INODE_BUF;
647	bp->b_flags |= _XBF_INODES;
648	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
649}
650
651/*
652 * This call is used to indicate that the buffer is going to
653 * be staled and was an inode buffer. This means it gets
654 * special processing during unpin - where any inodes
655 * associated with the buffer should be removed from ail.
656 * There is also special processing during recovery,
657 * any replay of the inodes in the buffer needs to be
658 * prevented as the buffer may have been reused.
659 */
660void
661xfs_trans_stale_inode_buf(
662	xfs_trans_t		*tp,
663	struct xfs_buf		*bp)
664{
665	struct xfs_buf_log_item	*bip = bp->b_log_item;
666
667	ASSERT(bp->b_transp == tp);
668	ASSERT(bip != NULL);
669	ASSERT(atomic_read(&bip->bli_refcount) > 0);
670
671	bip->bli_flags |= XFS_BLI_STALE_INODE;
672	bp->b_flags |= _XBF_INODES;
673	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
674}
675
676/*
677 * Mark the buffer as being one which contains newly allocated
678 * inodes.  We need to make sure that even if this buffer is
679 * relogged as an 'inode buf' we still recover all of the inode
680 * images in the face of a crash.  This works in coordination with
681 * xfs_buf_item_committed() to ensure that the buffer remains in the
682 * AIL at its original location even after it has been relogged.
683 */
684/* ARGSUSED */
685void
686xfs_trans_inode_alloc_buf(
687	xfs_trans_t		*tp,
688	struct xfs_buf		*bp)
689{
690	struct xfs_buf_log_item	*bip = bp->b_log_item;
691
692	ASSERT(bp->b_transp == tp);
693	ASSERT(bip != NULL);
694	ASSERT(atomic_read(&bip->bli_refcount) > 0);
695
696	bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
697	bp->b_flags |= _XBF_INODES;
698	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
699}
700
701/*
702 * Mark the buffer as ordered for this transaction. This means that the contents
703 * of the buffer are not recorded in the transaction but it is tracked in the
704 * AIL as though it was. This allows us to record logical changes in
705 * transactions rather than the physical changes we make to the buffer without
706 * changing writeback ordering constraints of metadata buffers.
707 */
708bool
709xfs_trans_ordered_buf(
710	struct xfs_trans	*tp,
711	struct xfs_buf		*bp)
712{
713	struct xfs_buf_log_item	*bip = bp->b_log_item;
714
715	ASSERT(bp->b_transp == tp);
716	ASSERT(bip != NULL);
717	ASSERT(atomic_read(&bip->bli_refcount) > 0);
718
719	if (xfs_buf_item_dirty_format(bip))
720		return false;
721
722	bip->bli_flags |= XFS_BLI_ORDERED;
723	trace_xfs_buf_item_ordered(bip);
724
725	/*
726	 * We don't log a dirty range of an ordered buffer but it still needs
727	 * to be marked dirty and that it has been logged.
728	 */
729	xfs_trans_dirty_buf(tp, bp);
730	return true;
731}
732
733/*
734 * Set the type of the buffer for log recovery so that it can correctly identify
735 * and hence attach the correct buffer ops to the buffer after replay.
736 */
737void
738xfs_trans_buf_set_type(
739	struct xfs_trans	*tp,
740	struct xfs_buf		*bp,
741	enum xfs_blft		type)
742{
743	struct xfs_buf_log_item	*bip = bp->b_log_item;
744
745	if (!tp)
746		return;
747
748	ASSERT(bp->b_transp == tp);
749	ASSERT(bip != NULL);
750	ASSERT(atomic_read(&bip->bli_refcount) > 0);
751
752	xfs_blft_to_flags(&bip->__bli_format, type);
753}
754
755void
756xfs_trans_buf_copy_type(
757	struct xfs_buf		*dst_bp,
758	struct xfs_buf		*src_bp)
759{
760	struct xfs_buf_log_item	*sbip = src_bp->b_log_item;
761	struct xfs_buf_log_item	*dbip = dst_bp->b_log_item;
762	enum xfs_blft		type;
763
764	type = xfs_blft_from_flags(&sbip->__bli_format);
765	xfs_blft_to_flags(&dbip->__bli_format, type);
766}
767
768/*
769 * Similar to xfs_trans_inode_buf(), this marks the buffer as a cluster of
770 * dquots. However, unlike in inode buffer recovery, dquot buffers get
771 * recovered in their entirety. (Hence, no XFS_BLI_DQUOT_ALLOC_BUF flag).
772 * The only thing that makes dquot buffers different from regular
773 * buffers is that we must not replay dquot bufs when recovering
774 * if a _corresponding_ quotaoff has happened. We also have to distinguish
775 * between usr dquot bufs and grp dquot bufs, because usr and grp quotas
776 * can be turned off independently.
777 */
778/* ARGSUSED */
779void
780xfs_trans_dquot_buf(
781	xfs_trans_t		*tp,
782	struct xfs_buf		*bp,
783	uint			type)
784{
785	struct xfs_buf_log_item	*bip = bp->b_log_item;
786
787	ASSERT(type == XFS_BLF_UDQUOT_BUF ||
788	       type == XFS_BLF_PDQUOT_BUF ||
789	       type == XFS_BLF_GDQUOT_BUF);
790
791	bip->__bli_format.blf_flags |= type;
792
793	switch (type) {
794	case XFS_BLF_UDQUOT_BUF:
795		type = XFS_BLFT_UDQUOT_BUF;
796		break;
797	case XFS_BLF_PDQUOT_BUF:
798		type = XFS_BLFT_PDQUOT_BUF;
799		break;
800	case XFS_BLF_GDQUOT_BUF:
801		type = XFS_BLFT_GDQUOT_BUF;
802		break;
803	default:
804		type = XFS_BLFT_UNKNOWN_BUF;
805		break;
806	}
807
808	bp->b_flags |= _XBF_DQUOTS;
809	xfs_trans_buf_set_type(tp, bp, type);
810}
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  4 * All Rights Reserved.
  5 */
  6#include "xfs.h"
  7#include "xfs_fs.h"
  8#include "xfs_shared.h"
  9#include "xfs_format.h"
 10#include "xfs_log_format.h"
 11#include "xfs_trans_resv.h"
 12#include "xfs_mount.h"
 13#include "xfs_trans.h"
 14#include "xfs_buf_item.h"
 15#include "xfs_trans_priv.h"
 16#include "xfs_trace.h"
 17
 18/*
 19 * Check to see if a buffer matching the given parameters is already
 20 * a part of the given transaction.
 21 */
 22STATIC struct xfs_buf *
 23xfs_trans_buf_item_match(
 24	struct xfs_trans	*tp,
 25	struct xfs_buftarg	*target,
 26	struct xfs_buf_map	*map,
 27	int			nmaps)
 28{
 29	struct xfs_log_item	*lip;
 30	struct xfs_buf_log_item	*blip;
 31	int			len = 0;
 32	int			i;
 33
 34	for (i = 0; i < nmaps; i++)
 35		len += map[i].bm_len;
 36
 37	list_for_each_entry(lip, &tp->t_items, li_trans) {
 38		blip = (struct xfs_buf_log_item *)lip;
 39		if (blip->bli_item.li_type == XFS_LI_BUF &&
 40		    blip->bli_buf->b_target == target &&
 41		    xfs_buf_daddr(blip->bli_buf) == map[0].bm_bn &&
 42		    blip->bli_buf->b_length == len) {
 43			ASSERT(blip->bli_buf->b_map_count == nmaps);
 44			return blip->bli_buf;
 45		}
 46	}
 47
 48	return NULL;
 49}
 50
 51/*
 52 * Add the locked buffer to the transaction.
 53 *
 54 * The buffer must be locked, and it cannot be associated with any
 55 * transaction.
 56 *
 57 * If the buffer does not yet have a buf log item associated with it,
 58 * then allocate one for it.  Then add the buf item to the transaction.
 59 */
 60STATIC void
 61_xfs_trans_bjoin(
 62	struct xfs_trans	*tp,
 63	struct xfs_buf		*bp,
 64	int			reset_recur)
 65{
 66	struct xfs_buf_log_item	*bip;
 67
 68	ASSERT(bp->b_transp == NULL);
 69
 70	/*
 71	 * The xfs_buf_log_item pointer is stored in b_log_item.  If
 72	 * it doesn't have one yet, then allocate one and initialize it.
 73	 * The checks to see if one is there are in xfs_buf_item_init().
 74	 */
 75	xfs_buf_item_init(bp, tp->t_mountp);
 76	bip = bp->b_log_item;
 77	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
 78	ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
 79	ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
 80	if (reset_recur)
 81		bip->bli_recur = 0;
 82
 83	/*
 84	 * Take a reference for this transaction on the buf item.
 85	 */
 86	atomic_inc(&bip->bli_refcount);
 87
 88	/*
 89	 * Attach the item to the transaction so we can find it in
 90	 * xfs_trans_get_buf() and friends.
 91	 */
 92	xfs_trans_add_item(tp, &bip->bli_item);
 93	bp->b_transp = tp;
 94
 95}
 96
 97void
 98xfs_trans_bjoin(
 99	struct xfs_trans	*tp,
100	struct xfs_buf		*bp)
101{
102	_xfs_trans_bjoin(tp, bp, 0);
103	trace_xfs_trans_bjoin(bp->b_log_item);
104}
105
106/*
107 * Get and lock the buffer for the caller if it is not already
108 * locked within the given transaction.  If it is already locked
109 * within the transaction, just increment its lock recursion count
110 * and return a pointer to it.
111 *
112 * If the transaction pointer is NULL, make this just a normal
113 * get_buf() call.
114 */
115int
116xfs_trans_get_buf_map(
117	struct xfs_trans	*tp,
118	struct xfs_buftarg	*target,
119	struct xfs_buf_map	*map,
120	int			nmaps,
121	xfs_buf_flags_t		flags,
122	struct xfs_buf		**bpp)
123{
124	struct xfs_buf		*bp;
125	struct xfs_buf_log_item	*bip;
126	int			error;
127
128	*bpp = NULL;
129	if (!tp)
130		return xfs_buf_get_map(target, map, nmaps, flags, bpp);
131
132	/*
133	 * If we find the buffer in the cache with this transaction
134	 * pointer in its b_fsprivate2 field, then we know we already
135	 * have it locked.  In this case we just increment the lock
136	 * recursion count and return the buffer to the caller.
137	 */
138	bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
139	if (bp != NULL) {
140		ASSERT(xfs_buf_islocked(bp));
141		if (xfs_is_shutdown(tp->t_mountp)) {
142			xfs_buf_stale(bp);
143			bp->b_flags |= XBF_DONE;
144		}
145
146		ASSERT(bp->b_transp == tp);
147		bip = bp->b_log_item;
148		ASSERT(bip != NULL);
149		ASSERT(atomic_read(&bip->bli_refcount) > 0);
150		bip->bli_recur++;
151		trace_xfs_trans_get_buf_recur(bip);
152		*bpp = bp;
153		return 0;
154	}
155
156	error = xfs_buf_get_map(target, map, nmaps, flags, &bp);
157	if (error)
158		return error;
159
160	ASSERT(!bp->b_error);
161
162	_xfs_trans_bjoin(tp, bp, 1);
163	trace_xfs_trans_get_buf(bp->b_log_item);
164	*bpp = bp;
165	return 0;
166}
167
168/*
169 * Get and lock the superblock buffer for the given transaction.
170 */
171static struct xfs_buf *
172__xfs_trans_getsb(
173	struct xfs_trans	*tp,
174	struct xfs_buf		*bp)
175{
 
 
176	/*
177	 * Just increment the lock recursion count if the buffer is already
178	 * attached to this transaction.
179	 */
180	if (bp->b_transp == tp) {
181		struct xfs_buf_log_item	*bip = bp->b_log_item;
182
183		ASSERT(bip != NULL);
184		ASSERT(atomic_read(&bip->bli_refcount) > 0);
185		bip->bli_recur++;
186
187		trace_xfs_trans_getsb_recur(bip);
188	} else {
189		xfs_buf_lock(bp);
190		xfs_buf_hold(bp);
191		_xfs_trans_bjoin(tp, bp, 1);
192
193		trace_xfs_trans_getsb(bp->b_log_item);
194	}
195
196	return bp;
197}
198
199struct xfs_buf *
200xfs_trans_getsb(
201	struct xfs_trans	*tp)
202{
203	return __xfs_trans_getsb(tp, tp->t_mountp->m_sb_bp);
204}
205
206struct xfs_buf *
207xfs_trans_getrtsb(
208	struct xfs_trans	*tp)
209{
210	if (!tp->t_mountp->m_rtsb_bp)
211		return NULL;
212	return __xfs_trans_getsb(tp, tp->t_mountp->m_rtsb_bp);
213}
214
215/*
216 * Get and lock the buffer for the caller if it is not already
217 * locked within the given transaction.  If it has not yet been
218 * read in, read it from disk. If it is already locked
219 * within the transaction and already read in, just increment its
220 * lock recursion count and return a pointer to it.
221 *
222 * If the transaction pointer is NULL, make this just a normal
223 * read_buf() call.
224 */
225int
226xfs_trans_read_buf_map(
227	struct xfs_mount	*mp,
228	struct xfs_trans	*tp,
229	struct xfs_buftarg	*target,
230	struct xfs_buf_map	*map,
231	int			nmaps,
232	xfs_buf_flags_t		flags,
233	struct xfs_buf		**bpp,
234	const struct xfs_buf_ops *ops)
235{
236	struct xfs_buf		*bp = NULL;
237	struct xfs_buf_log_item	*bip;
238	int			error;
239
240	*bpp = NULL;
241	/*
242	 * If we find the buffer in the cache with this transaction
243	 * pointer in its b_fsprivate2 field, then we know we already
244	 * have it locked.  If it is already read in we just increment
245	 * the lock recursion count and return the buffer to the caller.
246	 * If the buffer is not yet read in, then we read it in, increment
247	 * the lock recursion count, and return it to the caller.
248	 */
249	if (tp)
250		bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
251	if (bp) {
252		ASSERT(xfs_buf_islocked(bp));
253		ASSERT(bp->b_transp == tp);
254		ASSERT(bp->b_log_item != NULL);
255		ASSERT(!bp->b_error);
256		ASSERT(bp->b_flags & XBF_DONE);
257
258		/*
259		 * We never locked this buf ourselves, so we shouldn't
260		 * brelse it either. Just get out.
261		 */
262		if (xfs_is_shutdown(mp)) {
263			trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
264			return -EIO;
265		}
266
267		/*
268		 * Check if the caller is trying to read a buffer that is
269		 * already attached to the transaction yet has no buffer ops
270		 * assigned.  Ops are usually attached when the buffer is
271		 * attached to the transaction, or by the read caller if
272		 * special circumstances.  That didn't happen, which is not
273		 * how this is supposed to go.
274		 *
275		 * If the buffer passes verification we'll let this go, but if
276		 * not we have to shut down.  Let the transaction cleanup code
277		 * release this buffer when it kills the tranaction.
278		 */
279		ASSERT(bp->b_ops != NULL);
280		error = xfs_buf_reverify(bp, ops);
281		if (error) {
282			xfs_buf_ioerror_alert(bp, __return_address);
283
284			if (tp->t_flags & XFS_TRANS_DIRTY)
285				xfs_force_shutdown(tp->t_mountp,
286						SHUTDOWN_META_IO_ERROR);
287
288			/* bad CRC means corrupted metadata */
289			if (error == -EFSBADCRC)
290				error = -EFSCORRUPTED;
291			return error;
292		}
293
294		bip = bp->b_log_item;
295		bip->bli_recur++;
296
297		ASSERT(atomic_read(&bip->bli_refcount) > 0);
298		trace_xfs_trans_read_buf_recur(bip);
299		ASSERT(bp->b_ops != NULL || ops == NULL);
300		*bpp = bp;
301		return 0;
302	}
303
304	error = xfs_buf_read_map(target, map, nmaps, flags, &bp, ops,
305			__return_address);
306	switch (error) {
307	case 0:
308		break;
309	default:
310		if (tp && (tp->t_flags & XFS_TRANS_DIRTY))
311			xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
312		fallthrough;
313	case -ENOMEM:
314	case -EAGAIN:
315		return error;
316	}
317
318	if (xfs_is_shutdown(mp)) {
319		xfs_buf_relse(bp);
320		trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
321		return -EIO;
322	}
323
324	if (tp) {
325		_xfs_trans_bjoin(tp, bp, 1);
326		trace_xfs_trans_read_buf(bp->b_log_item);
327	}
328	ASSERT(bp->b_ops != NULL || ops == NULL);
329	*bpp = bp;
330	return 0;
331
332}
333
334/* Has this buffer been dirtied by anyone? */
335bool
336xfs_trans_buf_is_dirty(
337	struct xfs_buf		*bp)
338{
339	struct xfs_buf_log_item	*bip = bp->b_log_item;
340
341	if (!bip)
342		return false;
343	ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
344	return test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
345}
346
347/*
348 * Release a buffer previously joined to the transaction. If the buffer is
349 * modified within this transaction, decrement the recursion count but do not
350 * release the buffer even if the count goes to 0. If the buffer is not modified
351 * within the transaction, decrement the recursion count and release the buffer
352 * if the recursion count goes to 0.
353 *
354 * If the buffer is to be released and it was not already dirty before this
355 * transaction began, then also free the buf_log_item associated with it.
356 *
357 * If the transaction pointer is NULL, this is a normal xfs_buf_relse() call.
358 */
359void
360xfs_trans_brelse(
361	struct xfs_trans	*tp,
362	struct xfs_buf		*bp)
363{
364	struct xfs_buf_log_item	*bip = bp->b_log_item;
365
366	ASSERT(bp->b_transp == tp);
367
368	if (!tp) {
369		xfs_buf_relse(bp);
370		return;
371	}
372
373	trace_xfs_trans_brelse(bip);
374	ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
375	ASSERT(atomic_read(&bip->bli_refcount) > 0);
376
377	/*
378	 * If the release is for a recursive lookup, then decrement the count
379	 * and return.
380	 */
381	if (bip->bli_recur > 0) {
382		bip->bli_recur--;
383		return;
384	}
385
386	/*
387	 * If the buffer is invalidated or dirty in this transaction, we can't
388	 * release it until we commit.
389	 */
390	if (test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags))
391		return;
392	if (bip->bli_flags & XFS_BLI_STALE)
393		return;
394
395	/*
396	 * Unlink the log item from the transaction and clear the hold flag, if
397	 * set. We wouldn't want the next user of the buffer to get confused.
398	 */
399	ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
400	xfs_trans_del_item(&bip->bli_item);
401	bip->bli_flags &= ~XFS_BLI_HOLD;
402
403	/* drop the reference to the bli */
404	xfs_buf_item_put(bip);
405
406	bp->b_transp = NULL;
407	xfs_buf_relse(bp);
408}
409
410/*
411 * Forcibly detach a buffer previously joined to the transaction.  The caller
412 * will retain its locked reference to the buffer after this function returns.
413 * The buffer must be completely clean and must not be held to the transaction.
414 */
415void
416xfs_trans_bdetach(
417	struct xfs_trans	*tp,
418	struct xfs_buf		*bp)
419{
420	struct xfs_buf_log_item	*bip = bp->b_log_item;
421
422	ASSERT(tp != NULL);
423	ASSERT(bp->b_transp == tp);
424	ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
425	ASSERT(atomic_read(&bip->bli_refcount) > 0);
426
427	trace_xfs_trans_bdetach(bip);
428
429	/*
430	 * Erase all recursion count, since we're removing this buffer from the
431	 * transaction.
432	 */
433	bip->bli_recur = 0;
434
435	/*
436	 * The buffer must be completely clean.  Specifically, it had better
437	 * not be dirty, stale, logged, ordered, or held to the transaction.
438	 */
439	ASSERT(!test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags));
440	ASSERT(!(bip->bli_flags & XFS_BLI_DIRTY));
441	ASSERT(!(bip->bli_flags & XFS_BLI_HOLD));
442	ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
443	ASSERT(!(bip->bli_flags & XFS_BLI_ORDERED));
444	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
445
446	/* Unlink the log item from the transaction and drop the log item. */
447	xfs_trans_del_item(&bip->bli_item);
448	xfs_buf_item_put(bip);
449	bp->b_transp = NULL;
450}
451
452/*
453 * Mark the buffer as not needing to be unlocked when the buf item's
454 * iop_committing() routine is called.  The buffer must already be locked
455 * and associated with the given transaction.
456 */
457/* ARGSUSED */
458void
459xfs_trans_bhold(
460	xfs_trans_t		*tp,
461	struct xfs_buf		*bp)
462{
463	struct xfs_buf_log_item	*bip = bp->b_log_item;
464
465	ASSERT(bp->b_transp == tp);
466	ASSERT(bip != NULL);
467	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
468	ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
469	ASSERT(atomic_read(&bip->bli_refcount) > 0);
470
471	bip->bli_flags |= XFS_BLI_HOLD;
472	trace_xfs_trans_bhold(bip);
473}
474
475/*
476 * Cancel the previous buffer hold request made on this buffer
477 * for this transaction.
478 */
479void
480xfs_trans_bhold_release(
481	xfs_trans_t		*tp,
482	struct xfs_buf		*bp)
483{
484	struct xfs_buf_log_item	*bip = bp->b_log_item;
485
486	ASSERT(bp->b_transp == tp);
487	ASSERT(bip != NULL);
488	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
489	ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
490	ASSERT(atomic_read(&bip->bli_refcount) > 0);
491	ASSERT(bip->bli_flags & XFS_BLI_HOLD);
492
493	bip->bli_flags &= ~XFS_BLI_HOLD;
494	trace_xfs_trans_bhold_release(bip);
495}
496
497/*
498 * Mark a buffer dirty in the transaction.
499 */
500void
501xfs_trans_dirty_buf(
502	struct xfs_trans	*tp,
503	struct xfs_buf		*bp)
504{
505	struct xfs_buf_log_item	*bip = bp->b_log_item;
506
507	ASSERT(bp->b_transp == tp);
508	ASSERT(bip != NULL);
509
510	/*
511	 * Mark the buffer as needing to be written out eventually,
512	 * and set its iodone function to remove the buffer's buf log
513	 * item from the AIL and free it when the buffer is flushed
514	 * to disk.
515	 */
516	bp->b_flags |= XBF_DONE;
517
518	ASSERT(atomic_read(&bip->bli_refcount) > 0);
519
520	/*
521	 * If we invalidated the buffer within this transaction, then
522	 * cancel the invalidation now that we're dirtying the buffer
523	 * again.  There are no races with the code in xfs_buf_item_unpin(),
524	 * because we have a reference to the buffer this entire time.
525	 */
526	if (bip->bli_flags & XFS_BLI_STALE) {
527		bip->bli_flags &= ~XFS_BLI_STALE;
528		ASSERT(bp->b_flags & XBF_STALE);
529		bp->b_flags &= ~XBF_STALE;
530		bip->__bli_format.blf_flags &= ~XFS_BLF_CANCEL;
531	}
532	bip->bli_flags |= XFS_BLI_DIRTY | XFS_BLI_LOGGED;
533
534	tp->t_flags |= XFS_TRANS_DIRTY;
535	set_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
536}
537
538/*
539 * This is called to mark bytes first through last inclusive of the given
540 * buffer as needing to be logged when the transaction is committed.
541 * The buffer must already be associated with the given transaction.
542 *
543 * First and last are numbers relative to the beginning of this buffer,
544 * so the first byte in the buffer is numbered 0 regardless of the
545 * value of b_blkno.
546 */
547void
548xfs_trans_log_buf(
549	struct xfs_trans	*tp,
550	struct xfs_buf		*bp,
551	uint			first,
552	uint			last)
553{
554	struct xfs_buf_log_item	*bip = bp->b_log_item;
555
556	ASSERT(first <= last && last < BBTOB(bp->b_length));
557	ASSERT(!(bip->bli_flags & XFS_BLI_ORDERED));
558
559	xfs_trans_dirty_buf(tp, bp);
560
561	trace_xfs_trans_log_buf(bip);
562	xfs_buf_item_log(bip, first, last);
563}
564
565
566/*
567 * Invalidate a buffer that is being used within a transaction.
568 *
569 * Typically this is because the blocks in the buffer are being freed, so we
570 * need to prevent it from being written out when we're done.  Allowing it
571 * to be written again might overwrite data in the free blocks if they are
572 * reallocated to a file.
573 *
574 * We prevent the buffer from being written out by marking it stale.  We can't
575 * get rid of the buf log item at this point because the buffer may still be
576 * pinned by another transaction.  If that is the case, then we'll wait until
577 * the buffer is committed to disk for the last time (we can tell by the ref
578 * count) and free it in xfs_buf_item_unpin().  Until that happens we will
579 * keep the buffer locked so that the buffer and buf log item are not reused.
580 *
581 * We also set the XFS_BLF_CANCEL flag in the buf log format structure and log
582 * the buf item.  This will be used at recovery time to determine that copies
583 * of the buffer in the log before this should not be replayed.
584 *
585 * We mark the item descriptor and the transaction dirty so that we'll hold
586 * the buffer until after the commit.
587 *
588 * Since we're invalidating the buffer, we also clear the state about which
589 * parts of the buffer have been logged.  We also clear the flag indicating
590 * that this is an inode buffer since the data in the buffer will no longer
591 * be valid.
592 *
593 * We set the stale bit in the buffer as well since we're getting rid of it.
594 */
595void
596xfs_trans_binval(
597	xfs_trans_t		*tp,
598	struct xfs_buf		*bp)
599{
600	struct xfs_buf_log_item	*bip = bp->b_log_item;
601	int			i;
602
603	ASSERT(bp->b_transp == tp);
604	ASSERT(bip != NULL);
605	ASSERT(atomic_read(&bip->bli_refcount) > 0);
606
607	trace_xfs_trans_binval(bip);
608
609	if (bip->bli_flags & XFS_BLI_STALE) {
610		/*
611		 * If the buffer is already invalidated, then
612		 * just return.
613		 */
614		ASSERT(bp->b_flags & XBF_STALE);
615		ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
616		ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_INODE_BUF));
617		ASSERT(!(bip->__bli_format.blf_flags & XFS_BLFT_MASK));
618		ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);
619		ASSERT(test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags));
620		ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
621		return;
622	}
623
624	xfs_buf_stale(bp);
625
626	bip->bli_flags |= XFS_BLI_STALE;
627	bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
628	bip->__bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
629	bip->__bli_format.blf_flags |= XFS_BLF_CANCEL;
630	bip->__bli_format.blf_flags &= ~XFS_BLFT_MASK;
631	for (i = 0; i < bip->bli_format_count; i++) {
632		memset(bip->bli_formats[i].blf_data_map, 0,
633		       (bip->bli_formats[i].blf_map_size * sizeof(uint)));
634	}
635	set_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
636	tp->t_flags |= XFS_TRANS_DIRTY;
637}
638
639/*
640 * This call is used to indicate that the buffer contains on-disk inodes which
641 * must be handled specially during recovery.  They require special handling
642 * because only the di_next_unlinked from the inodes in the buffer should be
643 * recovered.  The rest of the data in the buffer is logged via the inodes
644 * themselves.
645 *
646 * All we do is set the XFS_BLI_INODE_BUF flag in the items flags so it can be
647 * transferred to the buffer's log format structure so that we'll know what to
648 * do at recovery time.
649 */
650void
651xfs_trans_inode_buf(
652	xfs_trans_t		*tp,
653	struct xfs_buf		*bp)
654{
655	struct xfs_buf_log_item	*bip = bp->b_log_item;
656
657	ASSERT(bp->b_transp == tp);
658	ASSERT(bip != NULL);
659	ASSERT(atomic_read(&bip->bli_refcount) > 0);
660
661	bip->bli_flags |= XFS_BLI_INODE_BUF;
662	bp->b_flags |= _XBF_INODES;
663	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
664}
665
666/*
667 * This call is used to indicate that the buffer is going to
668 * be staled and was an inode buffer. This means it gets
669 * special processing during unpin - where any inodes
670 * associated with the buffer should be removed from ail.
671 * There is also special processing during recovery,
672 * any replay of the inodes in the buffer needs to be
673 * prevented as the buffer may have been reused.
674 */
675void
676xfs_trans_stale_inode_buf(
677	xfs_trans_t		*tp,
678	struct xfs_buf		*bp)
679{
680	struct xfs_buf_log_item	*bip = bp->b_log_item;
681
682	ASSERT(bp->b_transp == tp);
683	ASSERT(bip != NULL);
684	ASSERT(atomic_read(&bip->bli_refcount) > 0);
685
686	bip->bli_flags |= XFS_BLI_STALE_INODE;
687	bp->b_flags |= _XBF_INODES;
688	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
689}
690
691/*
692 * Mark the buffer as being one which contains newly allocated
693 * inodes.  We need to make sure that even if this buffer is
694 * relogged as an 'inode buf' we still recover all of the inode
695 * images in the face of a crash.  This works in coordination with
696 * xfs_buf_item_committed() to ensure that the buffer remains in the
697 * AIL at its original location even after it has been relogged.
698 */
699/* ARGSUSED */
700void
701xfs_trans_inode_alloc_buf(
702	xfs_trans_t		*tp,
703	struct xfs_buf		*bp)
704{
705	struct xfs_buf_log_item	*bip = bp->b_log_item;
706
707	ASSERT(bp->b_transp == tp);
708	ASSERT(bip != NULL);
709	ASSERT(atomic_read(&bip->bli_refcount) > 0);
710
711	bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
712	bp->b_flags |= _XBF_INODES;
713	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
714}
715
716/*
717 * Mark the buffer as ordered for this transaction. This means that the contents
718 * of the buffer are not recorded in the transaction but it is tracked in the
719 * AIL as though it was. This allows us to record logical changes in
720 * transactions rather than the physical changes we make to the buffer without
721 * changing writeback ordering constraints of metadata buffers.
722 */
723bool
724xfs_trans_ordered_buf(
725	struct xfs_trans	*tp,
726	struct xfs_buf		*bp)
727{
728	struct xfs_buf_log_item	*bip = bp->b_log_item;
729
730	ASSERT(bp->b_transp == tp);
731	ASSERT(bip != NULL);
732	ASSERT(atomic_read(&bip->bli_refcount) > 0);
733
734	if (xfs_buf_item_dirty_format(bip))
735		return false;
736
737	bip->bli_flags |= XFS_BLI_ORDERED;
738	trace_xfs_buf_item_ordered(bip);
739
740	/*
741	 * We don't log a dirty range of an ordered buffer but it still needs
742	 * to be marked dirty and that it has been logged.
743	 */
744	xfs_trans_dirty_buf(tp, bp);
745	return true;
746}
747
748/*
749 * Set the type of the buffer for log recovery so that it can correctly identify
750 * and hence attach the correct buffer ops to the buffer after replay.
751 */
752void
753xfs_trans_buf_set_type(
754	struct xfs_trans	*tp,
755	struct xfs_buf		*bp,
756	enum xfs_blft		type)
757{
758	struct xfs_buf_log_item	*bip = bp->b_log_item;
759
760	if (!tp)
761		return;
762
763	ASSERT(bp->b_transp == tp);
764	ASSERT(bip != NULL);
765	ASSERT(atomic_read(&bip->bli_refcount) > 0);
766
767	xfs_blft_to_flags(&bip->__bli_format, type);
768}
769
770void
771xfs_trans_buf_copy_type(
772	struct xfs_buf		*dst_bp,
773	struct xfs_buf		*src_bp)
774{
775	struct xfs_buf_log_item	*sbip = src_bp->b_log_item;
776	struct xfs_buf_log_item	*dbip = dst_bp->b_log_item;
777	enum xfs_blft		type;
778
779	type = xfs_blft_from_flags(&sbip->__bli_format);
780	xfs_blft_to_flags(&dbip->__bli_format, type);
781}
782
783/*
784 * Similar to xfs_trans_inode_buf(), this marks the buffer as a cluster of
785 * dquots. However, unlike in inode buffer recovery, dquot buffers get
786 * recovered in their entirety. (Hence, no XFS_BLI_DQUOT_ALLOC_BUF flag).
787 * The only thing that makes dquot buffers different from regular
788 * buffers is that we must not replay dquot bufs when recovering
789 * if a _corresponding_ quotaoff has happened. We also have to distinguish
790 * between usr dquot bufs and grp dquot bufs, because usr and grp quotas
791 * can be turned off independently.
792 */
793/* ARGSUSED */
794void
795xfs_trans_dquot_buf(
796	xfs_trans_t		*tp,
797	struct xfs_buf		*bp,
798	uint			type)
799{
800	struct xfs_buf_log_item	*bip = bp->b_log_item;
801
802	ASSERT(type == XFS_BLF_UDQUOT_BUF ||
803	       type == XFS_BLF_PDQUOT_BUF ||
804	       type == XFS_BLF_GDQUOT_BUF);
805
806	bip->__bli_format.blf_flags |= type;
807
808	switch (type) {
809	case XFS_BLF_UDQUOT_BUF:
810		type = XFS_BLFT_UDQUOT_BUF;
811		break;
812	case XFS_BLF_PDQUOT_BUF:
813		type = XFS_BLFT_PDQUOT_BUF;
814		break;
815	case XFS_BLF_GDQUOT_BUF:
816		type = XFS_BLFT_GDQUOT_BUF;
817		break;
818	default:
819		type = XFS_BLFT_UNKNOWN_BUF;
820		break;
821	}
822
823	bp->b_flags |= _XBF_DQUOTS;
824	xfs_trans_buf_set_type(tp, bp, type);
825}