Line data Source code
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 : */
22 : STATIC struct xfs_buf *
23 22364027624 : xfs_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 22364027624 : struct xfs_log_item *lip;
30 22364027624 : struct xfs_buf_log_item *blip;
31 22364027624 : int len = 0;
32 22364027624 : int i;
33 :
34 44729159047 : for (i = 0; i < nmaps; i++)
35 22365131423 : len += map[i].bm_len;
36 :
37 98772440759 : list_for_each_entry(lip, &tp->t_items, li_trans) {
38 77166826605 : blip = (struct xfs_buf_log_item *)lip;
39 77166826605 : if (blip->bli_item.li_type == XFS_LI_BUF &&
40 65933337483 : blip->bli_buf->b_target == target &&
41 54136290095 : xfs_buf_daddr(blip->bli_buf) == map[0].bm_bn &&
42 758410473 : blip->bli_buf->b_length == len) {
43 758413470 : ASSERT(blip->bli_buf->b_map_count == nmaps);
44 758413470 : 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 : */
60 : STATIC void
61 21630385735 : _xfs_trans_bjoin(
62 : struct xfs_trans *tp,
63 : struct xfs_buf *bp,
64 : int reset_recur)
65 : {
66 21630385735 : struct xfs_buf_log_item *bip;
67 :
68 21630385735 : 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 21630385735 : xfs_buf_item_init(bp, tp->t_mountp);
76 21626538504 : bip = bp->b_log_item;
77 21626538504 : ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
78 21626538504 : ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
79 21626538504 : ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
80 21626538504 : if (reset_recur)
81 21615690310 : bip->bli_recur = 0;
82 :
83 : /*
84 : * Take a reference for this transaction on the buf item.
85 : */
86 21626538504 : 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 21625935744 : xfs_trans_add_item(tp, &bip->bli_item);
93 21629510690 : bp->b_transp = tp;
94 :
95 21629510690 : }
96 :
97 : void
98 9615211 : xfs_trans_bjoin(
99 : struct xfs_trans *tp,
100 : struct xfs_buf *bp)
101 : {
102 9615211 : _xfs_trans_bjoin(tp, bp, 0);
103 9615166 : trace_xfs_trans_bjoin(bp->b_log_item);
104 9615180 : }
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 : */
115 : int
116 65329759 : xfs_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 65329759 : struct xfs_buf *bp;
125 65329759 : struct xfs_buf_log_item *bip;
126 65329759 : int error;
127 :
128 65329759 : *bpp = NULL;
129 65329759 : if (!tp)
130 1198801 : 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 64130958 : bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
139 64134454 : if (bp != NULL) {
140 227061 : ASSERT(xfs_buf_islocked(bp));
141 454122 : if (xfs_is_shutdown(tp->t_mountp)) {
142 0 : xfs_buf_stale(bp);
143 0 : bp->b_flags |= XBF_DONE;
144 : }
145 :
146 227061 : ASSERT(bp->b_transp == tp);
147 227061 : bip = bp->b_log_item;
148 227061 : ASSERT(bip != NULL);
149 227061 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
150 227061 : bip->bli_recur++;
151 227061 : trace_xfs_trans_get_buf_recur(bip);
152 227060 : *bpp = bp;
153 227060 : return 0;
154 : }
155 :
156 63907393 : error = xfs_buf_get_map(target, map, nmaps, flags, &bp);
157 63906324 : if (error)
158 : return error;
159 :
160 63906324 : ASSERT(!bp->b_error);
161 :
162 63906324 : _xfs_trans_bjoin(tp, bp, 1);
163 63902905 : trace_xfs_trans_get_buf(bp->b_log_item);
164 63906080 : *bpp = bp;
165 63906080 : return 0;
166 : }
167 :
168 : /*
169 : * Get and lock the superblock buffer for the given transaction.
170 : */
171 : static struct xfs_buf *
172 369829 : __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 369829 : if (bp->b_transp == tp) {
181 505 : struct xfs_buf_log_item *bip = bp->b_log_item;
182 :
183 505 : ASSERT(bip != NULL);
184 505 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
185 505 : bip->bli_recur++;
186 :
187 505 : trace_xfs_trans_getsb_recur(bip);
188 : } else {
189 369324 : xfs_buf_lock(bp);
190 369324 : xfs_buf_hold(bp);
191 369324 : _xfs_trans_bjoin(tp, bp, 1);
192 :
193 369324 : trace_xfs_trans_getsb(bp->b_log_item);
194 : }
195 :
196 369829 : return bp;
197 : }
198 :
199 : struct xfs_buf *
200 267220 : xfs_trans_getsb(
201 : struct xfs_trans *tp)
202 : {
203 267220 : return __xfs_trans_getsb(tp, tp->t_mountp->m_sb_bp);
204 : }
205 :
206 : struct xfs_buf *
207 261271 : xfs_trans_getrtsb(
208 : struct xfs_trans *tp)
209 : {
210 261271 : if (!tp->t_mountp->m_rtsb_bp)
211 : return NULL;
212 102609 : 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 : */
225 : int
226 23421753414 : xfs_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 23421753414 : struct xfs_buf *bp = NULL;
237 23421753414 : struct xfs_buf_log_item *bip;
238 23421753414 : int error;
239 :
240 23421753414 : *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 23421753414 : if (tp)
250 22297580042 : bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
251 23426549781 : if (bp) {
252 758181515 : ASSERT(xfs_buf_islocked(bp));
253 758181515 : ASSERT(bp->b_transp == tp);
254 758181515 : ASSERT(bp->b_log_item != NULL);
255 758181515 : ASSERT(!bp->b_error);
256 758181515 : 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 1516363030 : if (xfs_is_shutdown(mp)) {
263 183 : trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
264 183 : 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 758181332 : ASSERT(bp->b_ops != NULL);
280 758181332 : error = xfs_buf_reverify(bp, ops);
281 758201255 : if (error) {
282 0 : xfs_buf_ioerror_alert(bp, __return_address);
283 :
284 0 : if (tp->t_flags & XFS_TRANS_DIRTY)
285 0 : xfs_force_shutdown(tp->t_mountp,
286 : SHUTDOWN_META_IO_ERROR);
287 :
288 : /* bad CRC means corrupted metadata */
289 0 : if (error == -EFSBADCRC)
290 0 : error = -EFSCORRUPTED;
291 0 : return error;
292 : }
293 :
294 758201255 : bip = bp->b_log_item;
295 758201255 : bip->bli_recur++;
296 :
297 758201255 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
298 758201255 : trace_xfs_trans_read_buf_recur(bip);
299 758202597 : ASSERT(bp->b_ops != NULL || ops == NULL);
300 758202597 : *bpp = bp;
301 758202597 : return 0;
302 : }
303 :
304 22668368266 : error = xfs_buf_read_map(target, map, nmaps, flags, &bp, ops,
305 : __return_address);
306 22684153551 : switch (error) {
307 : case 0:
308 22680961467 : break;
309 35447 : default:
310 35447 : if (tp && (tp->t_flags & XFS_TRANS_DIRTY))
311 2297 : xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
312 : fallthrough;
313 : case -ENOMEM:
314 : case -EAGAIN:
315 : return error;
316 : }
317 :
318 45361922934 : if (xfs_is_shutdown(mp)) {
319 1450730 : xfs_buf_relse(bp);
320 1450730 : trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
321 1450730 : return -EIO;
322 : }
323 :
324 22679510737 : if (tp) {
325 21557247643 : _xfs_trans_bjoin(tp, bp, 1);
326 21551834843 : trace_xfs_trans_read_buf(bp->b_log_item);
327 : }
328 22678563519 : ASSERT(bp->b_ops != NULL || ops == NULL);
329 22678563519 : *bpp = bp;
330 22678563519 : return 0;
331 :
332 : }
333 :
334 : /* Has this buffer been dirtied by anyone? */
335 : bool
336 21 : xfs_trans_buf_is_dirty(
337 : struct xfs_buf *bp)
338 : {
339 21 : struct xfs_buf_log_item *bip = bp->b_log_item;
340 :
341 21 : if (!bip)
342 : return false;
343 21 : ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
344 21 : 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 : */
359 : void
360 21995029619 : xfs_trans_brelse(
361 : struct xfs_trans *tp,
362 : struct xfs_buf *bp)
363 : {
364 21995029619 : struct xfs_buf_log_item *bip = bp->b_log_item;
365 :
366 21995029619 : ASSERT(bp->b_transp == tp);
367 :
368 21995029619 : if (!tp) {
369 1078998130 : xfs_buf_relse(bp);
370 1079117962 : return;
371 : }
372 :
373 20916031489 : trace_xfs_trans_brelse(bip);
374 20919698592 : ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
375 20919698592 : 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 20919698592 : if (bip->bli_recur > 0) {
382 681933716 : bip->bli_recur--;
383 681933716 : 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 40475529752 : if (test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags))
391 : return;
392 18327231600 : 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 18327231600 : ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
400 18327231600 : xfs_trans_del_item(&bip->bli_item);
401 18330093762 : bip->bli_flags &= ~XFS_BLI_HOLD;
402 :
403 : /* drop the reference to the bli */
404 18330093762 : xfs_buf_item_put(bip);
405 :
406 18331997568 : bp->b_transp = NULL;
407 18331997568 : 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 : */
415 : void
416 758903826 : xfs_trans_bdetach(
417 : struct xfs_trans *tp,
418 : struct xfs_buf *bp)
419 : {
420 758903826 : struct xfs_buf_log_item *bip = bp->b_log_item;
421 :
422 758903826 : ASSERT(tp != NULL);
423 758903826 : ASSERT(bp->b_transp == tp);
424 758903826 : ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
425 758903826 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
426 :
427 758903826 : trace_xfs_trans_bdetach(bip);
428 :
429 : /*
430 : * Erase all recursion count, since we're removing this buffer from the
431 : * transaction.
432 : */
433 758903787 : 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 758903787 : ASSERT(!test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags));
440 758903787 : ASSERT(!(bip->bli_flags & XFS_BLI_DIRTY));
441 758903787 : ASSERT(!(bip->bli_flags & XFS_BLI_HOLD));
442 758903787 : ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
443 758903787 : ASSERT(!(bip->bli_flags & XFS_BLI_ORDERED));
444 758903787 : ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
445 :
446 : /* Unlink the log item from the transaction and drop the log item. */
447 758903787 : xfs_trans_del_item(&bip->bli_item);
448 758903921 : xfs_buf_item_put(bip);
449 758904046 : bp->b_transp = NULL;
450 758904046 : }
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 */
458 : void
459 10936650 : xfs_trans_bhold(
460 : xfs_trans_t *tp,
461 : struct xfs_buf *bp)
462 : {
463 10936650 : struct xfs_buf_log_item *bip = bp->b_log_item;
464 :
465 10936650 : ASSERT(bp->b_transp == tp);
466 10936650 : ASSERT(bip != NULL);
467 10936650 : ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
468 10936650 : ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
469 10936650 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
470 :
471 10936650 : bip->bli_flags |= XFS_BLI_HOLD;
472 10936650 : trace_xfs_trans_bhold(bip);
473 10936646 : }
474 :
475 : /*
476 : * Cancel the previous buffer hold request made on this buffer
477 : * for this transaction.
478 : */
479 : void
480 774796 : xfs_trans_bhold_release(
481 : xfs_trans_t *tp,
482 : struct xfs_buf *bp)
483 : {
484 774796 : struct xfs_buf_log_item *bip = bp->b_log_item;
485 :
486 774796 : ASSERT(bp->b_transp == tp);
487 774796 : ASSERT(bip != NULL);
488 774796 : ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
489 774796 : ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
490 774796 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
491 774796 : ASSERT(bip->bli_flags & XFS_BLI_HOLD);
492 :
493 774796 : bip->bli_flags &= ~XFS_BLI_HOLD;
494 774796 : trace_xfs_trans_bhold_release(bip);
495 774797 : }
496 :
497 : /*
498 : * Mark a buffer dirty in the transaction.
499 : */
500 : void
501 5864741388 : xfs_trans_dirty_buf(
502 : struct xfs_trans *tp,
503 : struct xfs_buf *bp)
504 : {
505 5864741388 : struct xfs_buf_log_item *bip = bp->b_log_item;
506 :
507 5864741388 : ASSERT(bp->b_transp == tp);
508 5864741388 : 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 5864741388 : bp->b_flags |= XBF_DONE;
517 :
518 5864741388 : 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 5864741388 : if (bip->bli_flags & XFS_BLI_STALE) {
527 0 : bip->bli_flags &= ~XFS_BLI_STALE;
528 0 : ASSERT(bp->b_flags & XBF_STALE);
529 0 : bp->b_flags &= ~XBF_STALE;
530 0 : bip->__bli_format.blf_flags &= ~XFS_BLF_CANCEL;
531 : }
532 5864741388 : bip->bli_flags |= XFS_BLI_DIRTY | XFS_BLI_LOGGED;
533 :
534 5864741388 : tp->t_flags |= XFS_TRANS_DIRTY;
535 5864741388 : set_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
536 5864982605 : }
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 : */
547 : void
548 5857882936 : xfs_trans_log_buf(
549 : struct xfs_trans *tp,
550 : struct xfs_buf *bp,
551 : uint first,
552 : uint last)
553 : {
554 5857882936 : struct xfs_buf_log_item *bip = bp->b_log_item;
555 :
556 5857882936 : ASSERT(first <= last && last < BBTOB(bp->b_length));
557 5857882936 : ASSERT(!(bip->bli_flags & XFS_BLI_ORDERED));
558 :
559 5857882936 : xfs_trans_dirty_buf(tp, bp);
560 :
561 5858289667 : trace_xfs_trans_log_buf(bip);
562 5858809249 : xfs_buf_item_log(bip, first, last);
563 5859961745 : }
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 : */
595 : void
596 32670619 : xfs_trans_binval(
597 : xfs_trans_t *tp,
598 : struct xfs_buf *bp)
599 : {
600 32670619 : struct xfs_buf_log_item *bip = bp->b_log_item;
601 32670619 : int i;
602 :
603 32670619 : ASSERT(bp->b_transp == tp);
604 32670619 : ASSERT(bip != NULL);
605 32670619 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
606 :
607 32670619 : trace_xfs_trans_binval(bip);
608 :
609 32670176 : if (bip->bli_flags & XFS_BLI_STALE) {
610 : /*
611 : * If the buffer is already invalidated, then
612 : * just return.
613 : */
614 0 : ASSERT(bp->b_flags & XBF_STALE);
615 0 : ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
616 0 : ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_INODE_BUF));
617 0 : ASSERT(!(bip->__bli_format.blf_flags & XFS_BLFT_MASK));
618 0 : ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);
619 0 : ASSERT(test_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags));
620 0 : ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
621 0 : return;
622 : }
623 :
624 32670176 : xfs_buf_stale(bp);
625 :
626 32672223 : bip->bli_flags |= XFS_BLI_STALE;
627 32672223 : bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
628 32672223 : bip->__bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
629 32672223 : bip->__bli_format.blf_flags |= XFS_BLF_CANCEL;
630 32672223 : bip->__bli_format.blf_flags &= ~XFS_BLFT_MASK;
631 65344532 : for (i = 0; i < bip->bli_format_count; i++) {
632 65344240 : memset(bip->bli_formats[i].blf_data_map, 0,
633 : (bip->bli_formats[i].blf_map_size * sizeof(uint)));
634 : }
635 32672601 : set_bit(XFS_LI_DIRTY, &bip->bli_item.li_flags);
636 32672327 : 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 : */
650 : void
651 18131830 : xfs_trans_inode_buf(
652 : xfs_trans_t *tp,
653 : struct xfs_buf *bp)
654 : {
655 18131830 : struct xfs_buf_log_item *bip = bp->b_log_item;
656 :
657 18131830 : ASSERT(bp->b_transp == tp);
658 18131830 : ASSERT(bip != NULL);
659 18131830 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
660 :
661 18131830 : bip->bli_flags |= XFS_BLI_INODE_BUF;
662 18131830 : bp->b_flags |= _XBF_INODES;
663 18131830 : xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
664 18133943 : }
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 : */
675 : void
676 128601 : xfs_trans_stale_inode_buf(
677 : xfs_trans_t *tp,
678 : struct xfs_buf *bp)
679 : {
680 128601 : struct xfs_buf_log_item *bip = bp->b_log_item;
681 :
682 128601 : ASSERT(bp->b_transp == tp);
683 128601 : ASSERT(bip != NULL);
684 128601 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
685 :
686 128601 : bip->bli_flags |= XFS_BLI_STALE_INODE;
687 128601 : bp->b_flags |= _XBF_INODES;
688 128601 : xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
689 128597 : }
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 */
700 : void
701 954224 : xfs_trans_inode_alloc_buf(
702 : xfs_trans_t *tp,
703 : struct xfs_buf *bp)
704 : {
705 954224 : struct xfs_buf_log_item *bip = bp->b_log_item;
706 :
707 954224 : ASSERT(bp->b_transp == tp);
708 954224 : ASSERT(bip != NULL);
709 954224 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
710 :
711 954224 : bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
712 954224 : bp->b_flags |= _XBF_INODES;
713 954224 : xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
714 954225 : }
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 : */
723 : bool
724 1144044 : xfs_trans_ordered_buf(
725 : struct xfs_trans *tp,
726 : struct xfs_buf *bp)
727 : {
728 1144044 : struct xfs_buf_log_item *bip = bp->b_log_item;
729 :
730 1144044 : ASSERT(bp->b_transp == tp);
731 1144044 : ASSERT(bip != NULL);
732 1144044 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
733 :
734 1144044 : if (xfs_buf_item_dirty_format(bip))
735 : return false;
736 :
737 1144051 : bip->bli_flags |= XFS_BLI_ORDERED;
738 1144051 : 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 1144052 : xfs_trans_dirty_buf(tp, bp);
745 1144052 : 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 : */
752 : void
753 9682951736 : xfs_trans_buf_set_type(
754 : struct xfs_trans *tp,
755 : struct xfs_buf *bp,
756 : enum xfs_blft type)
757 : {
758 9682951736 : struct xfs_buf_log_item *bip = bp->b_log_item;
759 :
760 9682951736 : if (!tp)
761 : return;
762 :
763 9521952415 : ASSERT(bp->b_transp == tp);
764 9521952415 : ASSERT(bip != NULL);
765 9521952415 : ASSERT(atomic_read(&bip->bli_refcount) > 0);
766 :
767 9521952415 : xfs_blft_to_flags(&bip->__bli_format, type);
768 : }
769 :
770 : void
771 2771 : xfs_trans_buf_copy_type(
772 : struct xfs_buf *dst_bp,
773 : struct xfs_buf *src_bp)
774 : {
775 2771 : struct xfs_buf_log_item *sbip = src_bp->b_log_item;
776 2771 : struct xfs_buf_log_item *dbip = dst_bp->b_log_item;
777 2771 : enum xfs_blft type;
778 :
779 2771 : type = xfs_blft_from_flags(&sbip->__bli_format);
780 2771 : xfs_blft_to_flags(&dbip->__bli_format, type);
781 2771 : }
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 */
794 : void
795 3731924 : xfs_trans_dquot_buf(
796 : xfs_trans_t *tp,
797 : struct xfs_buf *bp,
798 : uint type)
799 : {
800 3731924 : struct xfs_buf_log_item *bip = bp->b_log_item;
801 :
802 3731924 : ASSERT(type == XFS_BLF_UDQUOT_BUF ||
803 : type == XFS_BLF_PDQUOT_BUF ||
804 : type == XFS_BLF_GDQUOT_BUF);
805 :
806 3731924 : bip->__bli_format.blf_flags |= type;
807 :
808 3731924 : 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 3731924 : bp->b_flags |= _XBF_DQUOTS;
824 3731924 : xfs_trans_buf_set_type(tp, bp, type);
825 3731928 : }
|
