]> Git Repo - J-linux.git/blob - fs/xfs/xfs_trans_buf.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / fs / xfs / xfs_trans_buf.c
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 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         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  */
60 STATIC 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
97 void
98 xfs_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  */
115 int
116 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         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  */
171 static 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
199 struct xfs_buf *
200 xfs_trans_getsb(
201         struct xfs_trans        *tp)
202 {
203         return __xfs_trans_getsb(tp, tp->t_mountp->m_sb_bp);
204 }
205
206 struct xfs_buf *
207 xfs_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  */
225 int
226 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         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? */
335 bool
336 xfs_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  */
359 void
360 xfs_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  */
415 void
416 xfs_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 */
458 void
459 xfs_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  */
479 void
480 xfs_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  */
500 void
501 xfs_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  */
547 void
548 xfs_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  */
595 void
596 xfs_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  */
650 void
651 xfs_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  */
675 void
676 xfs_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 */
700 void
701 xfs_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  */
723 bool
724 xfs_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  */
752 void
753 xfs_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
770 void
771 xfs_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 */
794 void
795 xfs_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 }
This page took 0.069815 seconds and 4 git commands to generate.