xref: /openbmc/linux/fs/xfs/xfs_trans_buf.c (revision 81d67439)
1 /*
2  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_mount.h"
28 #include "xfs_bmap_btree.h"
29 #include "xfs_alloc_btree.h"
30 #include "xfs_ialloc_btree.h"
31 #include "xfs_dinode.h"
32 #include "xfs_inode.h"
33 #include "xfs_buf_item.h"
34 #include "xfs_trans_priv.h"
35 #include "xfs_error.h"
36 #include "xfs_rw.h"
37 #include "xfs_trace.h"
38 
39 /*
40  * Check to see if a buffer matching the given parameters is already
41  * a part of the given transaction.
42  */
43 STATIC struct xfs_buf *
44 xfs_trans_buf_item_match(
45 	struct xfs_trans	*tp,
46 	struct xfs_buftarg	*target,
47 	xfs_daddr_t		blkno,
48 	int			len)
49 {
50 	struct xfs_log_item_desc *lidp;
51 	struct xfs_buf_log_item	*blip;
52 
53 	len = BBTOB(len);
54 	list_for_each_entry(lidp, &tp->t_items, lid_trans) {
55 		blip = (struct xfs_buf_log_item *)lidp->lid_item;
56 		if (blip->bli_item.li_type == XFS_LI_BUF &&
57 		    XFS_BUF_TARGET(blip->bli_buf) == target &&
58 		    XFS_BUF_ADDR(blip->bli_buf) == blkno &&
59 		    XFS_BUF_COUNT(blip->bli_buf) == len)
60 			return blip->bli_buf;
61 	}
62 
63 	return NULL;
64 }
65 
66 /*
67  * Add the locked buffer to the transaction.
68  *
69  * The buffer must be locked, and it cannot be associated with any
70  * transaction.
71  *
72  * If the buffer does not yet have a buf log item associated with it,
73  * then allocate one for it.  Then add the buf item to the transaction.
74  */
75 STATIC void
76 _xfs_trans_bjoin(
77 	struct xfs_trans	*tp,
78 	struct xfs_buf		*bp,
79 	int			reset_recur)
80 {
81 	struct xfs_buf_log_item	*bip;
82 
83 	ASSERT(XFS_BUF_ISBUSY(bp));
84 	ASSERT(bp->b_transp == NULL);
85 
86 	/*
87 	 * The xfs_buf_log_item pointer is stored in b_fsprivate.  If
88 	 * it doesn't have one yet, then allocate one and initialize it.
89 	 * The checks to see if one is there are in xfs_buf_item_init().
90 	 */
91 	xfs_buf_item_init(bp, tp->t_mountp);
92 	bip = bp->b_fspriv;
93 	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
94 	ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
95 	ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
96 	if (reset_recur)
97 		bip->bli_recur = 0;
98 
99 	/*
100 	 * Take a reference for this transaction on the buf item.
101 	 */
102 	atomic_inc(&bip->bli_refcount);
103 
104 	/*
105 	 * Get a log_item_desc to point at the new item.
106 	 */
107 	xfs_trans_add_item(tp, &bip->bli_item);
108 
109 	/*
110 	 * Initialize b_fsprivate2 so we can find it with incore_match()
111 	 * in xfs_trans_get_buf() and friends above.
112 	 */
113 	bp->b_transp = tp;
114 
115 }
116 
117 void
118 xfs_trans_bjoin(
119 	struct xfs_trans	*tp,
120 	struct xfs_buf		*bp)
121 {
122 	_xfs_trans_bjoin(tp, bp, 0);
123 	trace_xfs_trans_bjoin(bp->b_fspriv);
124 }
125 
126 /*
127  * Get and lock the buffer for the caller if it is not already
128  * locked within the given transaction.  If it is already locked
129  * within the transaction, just increment its lock recursion count
130  * and return a pointer to it.
131  *
132  * If the transaction pointer is NULL, make this just a normal
133  * get_buf() call.
134  */
135 xfs_buf_t *
136 xfs_trans_get_buf(xfs_trans_t	*tp,
137 		  xfs_buftarg_t	*target_dev,
138 		  xfs_daddr_t	blkno,
139 		  int		len,
140 		  uint		flags)
141 {
142 	xfs_buf_t		*bp;
143 	xfs_buf_log_item_t	*bip;
144 
145 	if (flags == 0)
146 		flags = XBF_LOCK | XBF_MAPPED;
147 
148 	/*
149 	 * Default to a normal get_buf() call if the tp is NULL.
150 	 */
151 	if (tp == NULL)
152 		return xfs_buf_get(target_dev, blkno, len,
153 				   flags | XBF_DONT_BLOCK);
154 
155 	/*
156 	 * If we find the buffer in the cache with this transaction
157 	 * pointer in its b_fsprivate2 field, then we know we already
158 	 * have it locked.  In this case we just increment the lock
159 	 * recursion count and return the buffer to the caller.
160 	 */
161 	bp = xfs_trans_buf_item_match(tp, target_dev, blkno, len);
162 	if (bp != NULL) {
163 		ASSERT(xfs_buf_islocked(bp));
164 		if (XFS_FORCED_SHUTDOWN(tp->t_mountp))
165 			XFS_BUF_SUPER_STALE(bp);
166 
167 		/*
168 		 * If the buffer is stale then it was binval'ed
169 		 * since last read.  This doesn't matter since the
170 		 * caller isn't allowed to use the data anyway.
171 		 */
172 		else if (XFS_BUF_ISSTALE(bp))
173 			ASSERT(!XFS_BUF_ISDELAYWRITE(bp));
174 
175 		ASSERT(bp->b_transp == tp);
176 		bip = bp->b_fspriv;
177 		ASSERT(bip != NULL);
178 		ASSERT(atomic_read(&bip->bli_refcount) > 0);
179 		bip->bli_recur++;
180 		trace_xfs_trans_get_buf_recur(bip);
181 		return (bp);
182 	}
183 
184 	/*
185 	 * We always specify the XBF_DONT_BLOCK flag within a transaction
186 	 * so that get_buf does not try to push out a delayed write buffer
187 	 * which might cause another transaction to take place (if the
188 	 * buffer was delayed alloc).  Such recursive transactions can
189 	 * easily deadlock with our current transaction as well as cause
190 	 * us to run out of stack space.
191 	 */
192 	bp = xfs_buf_get(target_dev, blkno, len, flags | XBF_DONT_BLOCK);
193 	if (bp == NULL) {
194 		return NULL;
195 	}
196 
197 	ASSERT(!XFS_BUF_GETERROR(bp));
198 
199 	_xfs_trans_bjoin(tp, bp, 1);
200 	trace_xfs_trans_get_buf(bp->b_fspriv);
201 	return (bp);
202 }
203 
204 /*
205  * Get and lock the superblock buffer of this file system for the
206  * given transaction.
207  *
208  * We don't need to use incore_match() here, because the superblock
209  * buffer is a private buffer which we keep a pointer to in the
210  * mount structure.
211  */
212 xfs_buf_t *
213 xfs_trans_getsb(xfs_trans_t	*tp,
214 		struct xfs_mount *mp,
215 		int		flags)
216 {
217 	xfs_buf_t		*bp;
218 	xfs_buf_log_item_t	*bip;
219 
220 	/*
221 	 * Default to just trying to lock the superblock buffer
222 	 * if tp is NULL.
223 	 */
224 	if (tp == NULL) {
225 		return (xfs_getsb(mp, flags));
226 	}
227 
228 	/*
229 	 * If the superblock buffer already has this transaction
230 	 * pointer in its b_fsprivate2 field, then we know we already
231 	 * have it locked.  In this case we just increment the lock
232 	 * recursion count and return the buffer to the caller.
233 	 */
234 	bp = mp->m_sb_bp;
235 	if (bp->b_transp == tp) {
236 		bip = bp->b_fspriv;
237 		ASSERT(bip != NULL);
238 		ASSERT(atomic_read(&bip->bli_refcount) > 0);
239 		bip->bli_recur++;
240 		trace_xfs_trans_getsb_recur(bip);
241 		return (bp);
242 	}
243 
244 	bp = xfs_getsb(mp, flags);
245 	if (bp == NULL)
246 		return NULL;
247 
248 	_xfs_trans_bjoin(tp, bp, 1);
249 	trace_xfs_trans_getsb(bp->b_fspriv);
250 	return (bp);
251 }
252 
253 #ifdef DEBUG
254 xfs_buftarg_t *xfs_error_target;
255 int	xfs_do_error;
256 int	xfs_req_num;
257 int	xfs_error_mod = 33;
258 #endif
259 
260 /*
261  * Get and lock the buffer for the caller if it is not already
262  * locked within the given transaction.  If it has not yet been
263  * read in, read it from disk. If it is already locked
264  * within the transaction and already read in, just increment its
265  * lock recursion count and return a pointer to it.
266  *
267  * If the transaction pointer is NULL, make this just a normal
268  * read_buf() call.
269  */
270 int
271 xfs_trans_read_buf(
272 	xfs_mount_t	*mp,
273 	xfs_trans_t	*tp,
274 	xfs_buftarg_t	*target,
275 	xfs_daddr_t	blkno,
276 	int		len,
277 	uint		flags,
278 	xfs_buf_t	**bpp)
279 {
280 	xfs_buf_t		*bp;
281 	xfs_buf_log_item_t	*bip;
282 	int			error;
283 
284 	if (flags == 0)
285 		flags = XBF_LOCK | XBF_MAPPED;
286 
287 	/*
288 	 * Default to a normal get_buf() call if the tp is NULL.
289 	 */
290 	if (tp == NULL) {
291 		bp = xfs_buf_read(target, blkno, len, flags | XBF_DONT_BLOCK);
292 		if (!bp)
293 			return (flags & XBF_TRYLOCK) ?
294 					EAGAIN : XFS_ERROR(ENOMEM);
295 
296 		if (XFS_BUF_GETERROR(bp) != 0) {
297 			xfs_ioerror_alert("xfs_trans_read_buf", mp,
298 					  bp, blkno);
299 			error = XFS_BUF_GETERROR(bp);
300 			xfs_buf_relse(bp);
301 			return error;
302 		}
303 #ifdef DEBUG
304 		if (xfs_do_error) {
305 			if (xfs_error_target == target) {
306 				if (((xfs_req_num++) % xfs_error_mod) == 0) {
307 					xfs_buf_relse(bp);
308 					xfs_debug(mp, "Returning error!");
309 					return XFS_ERROR(EIO);
310 				}
311 			}
312 		}
313 #endif
314 		if (XFS_FORCED_SHUTDOWN(mp))
315 			goto shutdown_abort;
316 		*bpp = bp;
317 		return 0;
318 	}
319 
320 	/*
321 	 * If we find the buffer in the cache with this transaction
322 	 * pointer in its b_fsprivate2 field, then we know we already
323 	 * have it locked.  If it is already read in we just increment
324 	 * the lock recursion count and return the buffer to the caller.
325 	 * If the buffer is not yet read in, then we read it in, increment
326 	 * the lock recursion count, and return it to the caller.
327 	 */
328 	bp = xfs_trans_buf_item_match(tp, target, blkno, len);
329 	if (bp != NULL) {
330 		ASSERT(xfs_buf_islocked(bp));
331 		ASSERT(bp->b_transp == tp);
332 		ASSERT(bp->b_fspriv != NULL);
333 		ASSERT((XFS_BUF_ISERROR(bp)) == 0);
334 		if (!(XFS_BUF_ISDONE(bp))) {
335 			trace_xfs_trans_read_buf_io(bp, _RET_IP_);
336 			ASSERT(!XFS_BUF_ISASYNC(bp));
337 			XFS_BUF_READ(bp);
338 			xfsbdstrat(tp->t_mountp, bp);
339 			error = xfs_buf_iowait(bp);
340 			if (error) {
341 				xfs_ioerror_alert("xfs_trans_read_buf", mp,
342 						  bp, blkno);
343 				xfs_buf_relse(bp);
344 				/*
345 				 * We can gracefully recover from most read
346 				 * errors. Ones we can't are those that happen
347 				 * after the transaction's already dirty.
348 				 */
349 				if (tp->t_flags & XFS_TRANS_DIRTY)
350 					xfs_force_shutdown(tp->t_mountp,
351 							SHUTDOWN_META_IO_ERROR);
352 				return error;
353 			}
354 		}
355 		/*
356 		 * We never locked this buf ourselves, so we shouldn't
357 		 * brelse it either. Just get out.
358 		 */
359 		if (XFS_FORCED_SHUTDOWN(mp)) {
360 			trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
361 			*bpp = NULL;
362 			return XFS_ERROR(EIO);
363 		}
364 
365 
366 		bip = bp->b_fspriv;
367 		bip->bli_recur++;
368 
369 		ASSERT(atomic_read(&bip->bli_refcount) > 0);
370 		trace_xfs_trans_read_buf_recur(bip);
371 		*bpp = bp;
372 		return 0;
373 	}
374 
375 	/*
376 	 * We always specify the XBF_DONT_BLOCK flag within a transaction
377 	 * so that get_buf does not try to push out a delayed write buffer
378 	 * which might cause another transaction to take place (if the
379 	 * buffer was delayed alloc).  Such recursive transactions can
380 	 * easily deadlock with our current transaction as well as cause
381 	 * us to run out of stack space.
382 	 */
383 	bp = xfs_buf_read(target, blkno, len, flags | XBF_DONT_BLOCK);
384 	if (bp == NULL) {
385 		*bpp = NULL;
386 		return (flags & XBF_TRYLOCK) ?
387 					0 : XFS_ERROR(ENOMEM);
388 	}
389 	if (XFS_BUF_GETERROR(bp) != 0) {
390 	    XFS_BUF_SUPER_STALE(bp);
391 		error = XFS_BUF_GETERROR(bp);
392 
393 		xfs_ioerror_alert("xfs_trans_read_buf", mp,
394 				  bp, blkno);
395 		if (tp->t_flags & XFS_TRANS_DIRTY)
396 			xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
397 		xfs_buf_relse(bp);
398 		return error;
399 	}
400 #ifdef DEBUG
401 	if (xfs_do_error && !(tp->t_flags & XFS_TRANS_DIRTY)) {
402 		if (xfs_error_target == target) {
403 			if (((xfs_req_num++) % xfs_error_mod) == 0) {
404 				xfs_force_shutdown(tp->t_mountp,
405 						   SHUTDOWN_META_IO_ERROR);
406 				xfs_buf_relse(bp);
407 				xfs_debug(mp, "Returning trans error!");
408 				return XFS_ERROR(EIO);
409 			}
410 		}
411 	}
412 #endif
413 	if (XFS_FORCED_SHUTDOWN(mp))
414 		goto shutdown_abort;
415 
416 	_xfs_trans_bjoin(tp, bp, 1);
417 	trace_xfs_trans_read_buf(bp->b_fspriv);
418 
419 	*bpp = bp;
420 	return 0;
421 
422 shutdown_abort:
423 	/*
424 	 * the theory here is that buffer is good but we're
425 	 * bailing out because the filesystem is being forcibly
426 	 * shut down.  So we should leave the b_flags alone since
427 	 * the buffer's not staled and just get out.
428 	 */
429 #if defined(DEBUG)
430 	if (XFS_BUF_ISSTALE(bp) && XFS_BUF_ISDELAYWRITE(bp))
431 		xfs_notice(mp, "about to pop assert, bp == 0x%p", bp);
432 #endif
433 	ASSERT((XFS_BUF_BFLAGS(bp) & (XBF_STALE|XBF_DELWRI)) !=
434 				     (XBF_STALE|XBF_DELWRI));
435 
436 	trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
437 	xfs_buf_relse(bp);
438 	*bpp = NULL;
439 	return XFS_ERROR(EIO);
440 }
441 
442 
443 /*
444  * Release the buffer bp which was previously acquired with one of the
445  * xfs_trans_... buffer allocation routines if the buffer has not
446  * been modified within this transaction.  If the buffer is modified
447  * within this transaction, do decrement the recursion count but do
448  * not release the buffer even if the count goes to 0.  If the buffer is not
449  * modified within the transaction, decrement the recursion count and
450  * release the buffer if the recursion count goes to 0.
451  *
452  * If the buffer is to be released and it was not modified before
453  * this transaction began, then free the buf_log_item associated with it.
454  *
455  * If the transaction pointer is NULL, make this just a normal
456  * brelse() call.
457  */
458 void
459 xfs_trans_brelse(xfs_trans_t	*tp,
460 		 xfs_buf_t	*bp)
461 {
462 	xfs_buf_log_item_t	*bip;
463 
464 	/*
465 	 * Default to a normal brelse() call if the tp is NULL.
466 	 */
467 	if (tp == NULL) {
468 		struct xfs_log_item	*lip = bp->b_fspriv;
469 
470 		ASSERT(bp->b_transp == NULL);
471 
472 		/*
473 		 * If there's a buf log item attached to the buffer,
474 		 * then let the AIL know that the buffer is being
475 		 * unlocked.
476 		 */
477 		if (lip != NULL && lip->li_type == XFS_LI_BUF) {
478 			bip = bp->b_fspriv;
479 			xfs_trans_unlocked_item(bip->bli_item.li_ailp, lip);
480 		}
481 		xfs_buf_relse(bp);
482 		return;
483 	}
484 
485 	ASSERT(bp->b_transp == tp);
486 	bip = bp->b_fspriv;
487 	ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
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 
492 	trace_xfs_trans_brelse(bip);
493 
494 	/*
495 	 * If the release is just for a recursive lock,
496 	 * then decrement the count and return.
497 	 */
498 	if (bip->bli_recur > 0) {
499 		bip->bli_recur--;
500 		return;
501 	}
502 
503 	/*
504 	 * If the buffer is dirty within this transaction, we can't
505 	 * release it until we commit.
506 	 */
507 	if (bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY)
508 		return;
509 
510 	/*
511 	 * If the buffer has been invalidated, then we can't release
512 	 * it until the transaction commits to disk unless it is re-dirtied
513 	 * as part of this transaction.  This prevents us from pulling
514 	 * the item from the AIL before we should.
515 	 */
516 	if (bip->bli_flags & XFS_BLI_STALE)
517 		return;
518 
519 	ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
520 
521 	/*
522 	 * Free up the log item descriptor tracking the released item.
523 	 */
524 	xfs_trans_del_item(&bip->bli_item);
525 
526 	/*
527 	 * Clear the hold flag in the buf log item if it is set.
528 	 * We wouldn't want the next user of the buffer to
529 	 * get confused.
530 	 */
531 	if (bip->bli_flags & XFS_BLI_HOLD) {
532 		bip->bli_flags &= ~XFS_BLI_HOLD;
533 	}
534 
535 	/*
536 	 * Drop our reference to the buf log item.
537 	 */
538 	atomic_dec(&bip->bli_refcount);
539 
540 	/*
541 	 * If the buf item is not tracking data in the log, then
542 	 * we must free it before releasing the buffer back to the
543 	 * free pool.  Before releasing the buffer to the free pool,
544 	 * clear the transaction pointer in b_fsprivate2 to dissolve
545 	 * its relation to this transaction.
546 	 */
547 	if (!xfs_buf_item_dirty(bip)) {
548 /***
549 		ASSERT(bp->b_pincount == 0);
550 ***/
551 		ASSERT(atomic_read(&bip->bli_refcount) == 0);
552 		ASSERT(!(bip->bli_item.li_flags & XFS_LI_IN_AIL));
553 		ASSERT(!(bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF));
554 		xfs_buf_item_relse(bp);
555 		bip = NULL;
556 	}
557 	bp->b_transp = NULL;
558 
559 	/*
560 	 * If we've still got a buf log item on the buffer, then
561 	 * tell the AIL that the buffer is being unlocked.
562 	 */
563 	if (bip != NULL) {
564 		xfs_trans_unlocked_item(bip->bli_item.li_ailp,
565 					(xfs_log_item_t*)bip);
566 	}
567 
568 	xfs_buf_relse(bp);
569 	return;
570 }
571 
572 /*
573  * Mark the buffer as not needing to be unlocked when the buf item's
574  * IOP_UNLOCK() routine is called.  The buffer must already be locked
575  * and associated with the given transaction.
576  */
577 /* ARGSUSED */
578 void
579 xfs_trans_bhold(xfs_trans_t	*tp,
580 		xfs_buf_t	*bp)
581 {
582 	xfs_buf_log_item_t	*bip = bp->b_fspriv;
583 
584 	ASSERT(XFS_BUF_ISBUSY(bp));
585 	ASSERT(bp->b_transp == tp);
586 	ASSERT(bip != NULL);
587 	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
588 	ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
589 	ASSERT(atomic_read(&bip->bli_refcount) > 0);
590 
591 	bip->bli_flags |= XFS_BLI_HOLD;
592 	trace_xfs_trans_bhold(bip);
593 }
594 
595 /*
596  * Cancel the previous buffer hold request made on this buffer
597  * for this transaction.
598  */
599 void
600 xfs_trans_bhold_release(xfs_trans_t	*tp,
601 			xfs_buf_t	*bp)
602 {
603 	xfs_buf_log_item_t	*bip = bp->b_fspriv;
604 
605 	ASSERT(XFS_BUF_ISBUSY(bp));
606 	ASSERT(bp->b_transp == tp);
607 	ASSERT(bip != NULL);
608 	ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
609 	ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
610 	ASSERT(atomic_read(&bip->bli_refcount) > 0);
611 	ASSERT(bip->bli_flags & XFS_BLI_HOLD);
612 
613 	bip->bli_flags &= ~XFS_BLI_HOLD;
614 	trace_xfs_trans_bhold_release(bip);
615 }
616 
617 /*
618  * This is called to mark bytes first through last inclusive of the given
619  * buffer as needing to be logged when the transaction is committed.
620  * The buffer must already be associated with the given transaction.
621  *
622  * First and last are numbers relative to the beginning of this buffer,
623  * so the first byte in the buffer is numbered 0 regardless of the
624  * value of b_blkno.
625  */
626 void
627 xfs_trans_log_buf(xfs_trans_t	*tp,
628 		  xfs_buf_t	*bp,
629 		  uint		first,
630 		  uint		last)
631 {
632 	xfs_buf_log_item_t	*bip = bp->b_fspriv;
633 
634 	ASSERT(XFS_BUF_ISBUSY(bp));
635 	ASSERT(bp->b_transp == tp);
636 	ASSERT(bip != NULL);
637 	ASSERT((first <= last) && (last < XFS_BUF_COUNT(bp)));
638 	ASSERT(bp->b_iodone == NULL ||
639 	       bp->b_iodone == xfs_buf_iodone_callbacks);
640 
641 	/*
642 	 * Mark the buffer as needing to be written out eventually,
643 	 * and set its iodone function to remove the buffer's buf log
644 	 * item from the AIL and free it when the buffer is flushed
645 	 * to disk.  See xfs_buf_attach_iodone() for more details
646 	 * on li_cb and xfs_buf_iodone_callbacks().
647 	 * If we end up aborting this transaction, we trap this buffer
648 	 * inside the b_bdstrat callback so that this won't get written to
649 	 * disk.
650 	 */
651 	XFS_BUF_DELAYWRITE(bp);
652 	XFS_BUF_DONE(bp);
653 
654 	ASSERT(atomic_read(&bip->bli_refcount) > 0);
655 	bp->b_iodone = xfs_buf_iodone_callbacks;
656 	bip->bli_item.li_cb = xfs_buf_iodone;
657 
658 	trace_xfs_trans_log_buf(bip);
659 
660 	/*
661 	 * If we invalidated the buffer within this transaction, then
662 	 * cancel the invalidation now that we're dirtying the buffer
663 	 * again.  There are no races with the code in xfs_buf_item_unpin(),
664 	 * because we have a reference to the buffer this entire time.
665 	 */
666 	if (bip->bli_flags & XFS_BLI_STALE) {
667 		bip->bli_flags &= ~XFS_BLI_STALE;
668 		ASSERT(XFS_BUF_ISSTALE(bp));
669 		XFS_BUF_UNSTALE(bp);
670 		bip->bli_format.blf_flags &= ~XFS_BLF_CANCEL;
671 	}
672 
673 	tp->t_flags |= XFS_TRANS_DIRTY;
674 	bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
675 	bip->bli_flags |= XFS_BLI_LOGGED;
676 	xfs_buf_item_log(bip, first, last);
677 }
678 
679 
680 /*
681  * This called to invalidate a buffer that is being used within
682  * a transaction.  Typically this is because the blocks in the
683  * buffer are being freed, so we need to prevent it from being
684  * written out when we're done.  Allowing it to be written again
685  * might overwrite data in the free blocks if they are reallocated
686  * to a file.
687  *
688  * We prevent the buffer from being written out by clearing the
689  * B_DELWRI flag.  We can't always
690  * get rid of the buf log item at this point, though, because
691  * the buffer may still be pinned by another transaction.  If that
692  * is the case, then we'll wait until the buffer is committed to
693  * disk for the last time (we can tell by the ref count) and
694  * free it in xfs_buf_item_unpin().  Until it is cleaned up we
695  * will keep the buffer locked so that the buffer and buf log item
696  * are not reused.
697  */
698 void
699 xfs_trans_binval(
700 	xfs_trans_t	*tp,
701 	xfs_buf_t	*bp)
702 {
703 	xfs_buf_log_item_t	*bip = bp->b_fspriv;
704 
705 	ASSERT(XFS_BUF_ISBUSY(bp));
706 	ASSERT(bp->b_transp == tp);
707 	ASSERT(bip != NULL);
708 	ASSERT(atomic_read(&bip->bli_refcount) > 0);
709 
710 	trace_xfs_trans_binval(bip);
711 
712 	if (bip->bli_flags & XFS_BLI_STALE) {
713 		/*
714 		 * If the buffer is already invalidated, then
715 		 * just return.
716 		 */
717 		ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
718 		ASSERT(XFS_BUF_ISSTALE(bp));
719 		ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
720 		ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_INODE_BUF));
721 		ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
722 		ASSERT(bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY);
723 		ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
724 		return;
725 	}
726 
727 	/*
728 	 * Clear the dirty bit in the buffer and set the STALE flag
729 	 * in the buf log item.  The STALE flag will be used in
730 	 * xfs_buf_item_unpin() to determine if it should clean up
731 	 * when the last reference to the buf item is given up.
732 	 * We set the XFS_BLF_CANCEL flag in the buf log format structure
733 	 * and log the buf item.  This will be used at recovery time
734 	 * to determine that copies of the buffer in the log before
735 	 * this should not be replayed.
736 	 * We mark the item descriptor and the transaction dirty so
737 	 * that we'll hold the buffer until after the commit.
738 	 *
739 	 * Since we're invalidating the buffer, we also clear the state
740 	 * about which parts of the buffer have been logged.  We also
741 	 * clear the flag indicating that this is an inode buffer since
742 	 * the data in the buffer will no longer be valid.
743 	 *
744 	 * We set the stale bit in the buffer as well since we're getting
745 	 * rid of it.
746 	 */
747 	XFS_BUF_UNDELAYWRITE(bp);
748 	XFS_BUF_STALE(bp);
749 	bip->bli_flags |= XFS_BLI_STALE;
750 	bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
751 	bip->bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
752 	bip->bli_format.blf_flags |= XFS_BLF_CANCEL;
753 	memset((char *)(bip->bli_format.blf_data_map), 0,
754 	      (bip->bli_format.blf_map_size * sizeof(uint)));
755 	bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
756 	tp->t_flags |= XFS_TRANS_DIRTY;
757 }
758 
759 /*
760  * This call is used to indicate that the buffer contains on-disk inodes which
761  * must be handled specially during recovery.  They require special handling
762  * because only the di_next_unlinked from the inodes in the buffer should be
763  * recovered.  The rest of the data in the buffer is logged via the inodes
764  * themselves.
765  *
766  * All we do is set the XFS_BLI_INODE_BUF flag in the items flags so it can be
767  * transferred to the buffer's log format structure so that we'll know what to
768  * do at recovery time.
769  */
770 void
771 xfs_trans_inode_buf(
772 	xfs_trans_t	*tp,
773 	xfs_buf_t	*bp)
774 {
775 	xfs_buf_log_item_t	*bip = bp->b_fspriv;
776 
777 	ASSERT(XFS_BUF_ISBUSY(bp));
778 	ASSERT(bp->b_transp == tp);
779 	ASSERT(bip != NULL);
780 	ASSERT(atomic_read(&bip->bli_refcount) > 0);
781 
782 	bip->bli_flags |= XFS_BLI_INODE_BUF;
783 }
784 
785 /*
786  * This call is used to indicate that the buffer is going to
787  * be staled and was an inode buffer. This means it gets
788  * special processing during unpin - where any inodes
789  * associated with the buffer should be removed from ail.
790  * There is also special processing during recovery,
791  * any replay of the inodes in the buffer needs to be
792  * prevented as the buffer may have been reused.
793  */
794 void
795 xfs_trans_stale_inode_buf(
796 	xfs_trans_t	*tp,
797 	xfs_buf_t	*bp)
798 {
799 	xfs_buf_log_item_t	*bip = bp->b_fspriv;
800 
801 	ASSERT(XFS_BUF_ISBUSY(bp));
802 	ASSERT(bp->b_transp == tp);
803 	ASSERT(bip != NULL);
804 	ASSERT(atomic_read(&bip->bli_refcount) > 0);
805 
806 	bip->bli_flags |= XFS_BLI_STALE_INODE;
807 	bip->bli_item.li_cb = xfs_buf_iodone;
808 }
809 
810 /*
811  * Mark the buffer as being one which contains newly allocated
812  * inodes.  We need to make sure that even if this buffer is
813  * relogged as an 'inode buf' we still recover all of the inode
814  * images in the face of a crash.  This works in coordination with
815  * xfs_buf_item_committed() to ensure that the buffer remains in the
816  * AIL at its original location even after it has been relogged.
817  */
818 /* ARGSUSED */
819 void
820 xfs_trans_inode_alloc_buf(
821 	xfs_trans_t	*tp,
822 	xfs_buf_t	*bp)
823 {
824 	xfs_buf_log_item_t	*bip = bp->b_fspriv;
825 
826 	ASSERT(XFS_BUF_ISBUSY(bp));
827 	ASSERT(bp->b_transp == tp);
828 	ASSERT(bip != NULL);
829 	ASSERT(atomic_read(&bip->bli_refcount) > 0);
830 
831 	bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
832 }
833 
834 
835 /*
836  * Similar to xfs_trans_inode_buf(), this marks the buffer as a cluster of
837  * dquots. However, unlike in inode buffer recovery, dquot buffers get
838  * recovered in their entirety. (Hence, no XFS_BLI_DQUOT_ALLOC_BUF flag).
839  * The only thing that makes dquot buffers different from regular
840  * buffers is that we must not replay dquot bufs when recovering
841  * if a _corresponding_ quotaoff has happened. We also have to distinguish
842  * between usr dquot bufs and grp dquot bufs, because usr and grp quotas
843  * can be turned off independently.
844  */
845 /* ARGSUSED */
846 void
847 xfs_trans_dquot_buf(
848 	xfs_trans_t	*tp,
849 	xfs_buf_t	*bp,
850 	uint		type)
851 {
852 	xfs_buf_log_item_t	*bip = bp->b_fspriv;
853 
854 	ASSERT(XFS_BUF_ISBUSY(bp));
855 	ASSERT(bp->b_transp == tp);
856 	ASSERT(bip != NULL);
857 	ASSERT(type == XFS_BLF_UDQUOT_BUF ||
858 	       type == XFS_BLF_PDQUOT_BUF ||
859 	       type == XFS_BLF_GDQUOT_BUF);
860 	ASSERT(atomic_read(&bip->bli_refcount) > 0);
861 
862 	bip->bli_format.blf_flags |= type;
863 }
864