1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2016 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 */
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_format.h"
9#include "xfs_log_format.h"
10#include "xfs_trans_resv.h"
11#include "xfs_bit.h"
12#include "xfs_shared.h"
13#include "xfs_mount.h"
14#include "xfs_defer.h"
15#include "xfs_trans.h"
16#include "xfs_trans_priv.h"
17#include "xfs_refcount_item.h"
18#include "xfs_log.h"
19#include "xfs_refcount.h"
20#include "xfs_error.h"
21#include "xfs_log_priv.h"
22#include "xfs_log_recover.h"
23#include "xfs_ag.h"
24
25struct kmem_cache *xfs_cui_cache;
26struct kmem_cache *xfs_cud_cache;
27
28static const struct xfs_item_ops xfs_cui_item_ops;
29
30static inline struct xfs_cui_log_item *CUI_ITEM(struct xfs_log_item *lip)
31{
32 return container_of(lip, struct xfs_cui_log_item, cui_item);
33}
34
35STATIC void
36xfs_cui_item_free(
37 struct xfs_cui_log_item *cuip)
38{
39 kmem_free(ptr: cuip->cui_item.li_lv_shadow);
40 if (cuip->cui_format.cui_nextents > XFS_CUI_MAX_FAST_EXTENTS)
41 kmem_free(ptr: cuip);
42 else
43 kmem_cache_free(s: xfs_cui_cache, objp: cuip);
44}
45
46/*
47 * Freeing the CUI requires that we remove it from the AIL if it has already
48 * been placed there. However, the CUI may not yet have been placed in the AIL
49 * when called by xfs_cui_release() from CUD processing due to the ordering of
50 * committed vs unpin operations in bulk insert operations. Hence the reference
51 * count to ensure only the last caller frees the CUI.
52 */
53STATIC void
54xfs_cui_release(
55 struct xfs_cui_log_item *cuip)
56{
57 ASSERT(atomic_read(&cuip->cui_refcount) > 0);
58 if (!atomic_dec_and_test(v: &cuip->cui_refcount))
59 return;
60
61 xfs_trans_ail_delete(lip: &cuip->cui_item, shutdown_type: 0);
62 xfs_cui_item_free(cuip);
63}
64
65
66STATIC void
67xfs_cui_item_size(
68 struct xfs_log_item *lip,
69 int *nvecs,
70 int *nbytes)
71{
72 struct xfs_cui_log_item *cuip = CUI_ITEM(lip);
73
74 *nvecs += 1;
75 *nbytes += xfs_cui_log_format_sizeof(cuip->cui_format.cui_nextents);
76}
77
78/*
79 * This is called to fill in the vector of log iovecs for the
80 * given cui log item. We use only 1 iovec, and we point that
81 * at the cui_log_format structure embedded in the cui item.
82 * It is at this point that we assert that all of the extent
83 * slots in the cui item have been filled.
84 */
85STATIC void
86xfs_cui_item_format(
87 struct xfs_log_item *lip,
88 struct xfs_log_vec *lv)
89{
90 struct xfs_cui_log_item *cuip = CUI_ITEM(lip);
91 struct xfs_log_iovec *vecp = NULL;
92
93 ASSERT(atomic_read(&cuip->cui_next_extent) ==
94 cuip->cui_format.cui_nextents);
95
96 cuip->cui_format.cui_type = XFS_LI_CUI;
97 cuip->cui_format.cui_size = 1;
98
99 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_CUI_FORMAT, &cuip->cui_format,
100 xfs_cui_log_format_sizeof(cuip->cui_format.cui_nextents));
101}
102
103/*
104 * The unpin operation is the last place an CUI is manipulated in the log. It is
105 * either inserted in the AIL or aborted in the event of a log I/O error. In
106 * either case, the CUI transaction has been successfully committed to make it
107 * this far. Therefore, we expect whoever committed the CUI to either construct
108 * and commit the CUD or drop the CUD's reference in the event of error. Simply
109 * drop the log's CUI reference now that the log is done with it.
110 */
111STATIC void
112xfs_cui_item_unpin(
113 struct xfs_log_item *lip,
114 int remove)
115{
116 struct xfs_cui_log_item *cuip = CUI_ITEM(lip);
117
118 xfs_cui_release(cuip);
119}
120
121/*
122 * The CUI has been either committed or aborted if the transaction has been
123 * cancelled. If the transaction was cancelled, an CUD isn't going to be
124 * constructed and thus we free the CUI here directly.
125 */
126STATIC void
127xfs_cui_item_release(
128 struct xfs_log_item *lip)
129{
130 xfs_cui_release(cuip: CUI_ITEM(lip));
131}
132
133/*
134 * Allocate and initialize an cui item with the given number of extents.
135 */
136STATIC struct xfs_cui_log_item *
137xfs_cui_init(
138 struct xfs_mount *mp,
139 uint nextents)
140
141{
142 struct xfs_cui_log_item *cuip;
143
144 ASSERT(nextents > 0);
145 if (nextents > XFS_CUI_MAX_FAST_EXTENTS)
146 cuip = kmem_zalloc(size: xfs_cui_log_item_sizeof(nr: nextents),
147 flags: 0);
148 else
149 cuip = kmem_cache_zalloc(k: xfs_cui_cache,
150 GFP_KERNEL | __GFP_NOFAIL);
151
152 xfs_log_item_init(mp, &cuip->cui_item, XFS_LI_CUI, &xfs_cui_item_ops);
153 cuip->cui_format.cui_nextents = nextents;
154 cuip->cui_format.cui_id = (uintptr_t)(void *)cuip;
155 atomic_set(v: &cuip->cui_next_extent, i: 0);
156 atomic_set(v: &cuip->cui_refcount, i: 2);
157
158 return cuip;
159}
160
161static inline struct xfs_cud_log_item *CUD_ITEM(struct xfs_log_item *lip)
162{
163 return container_of(lip, struct xfs_cud_log_item, cud_item);
164}
165
166STATIC void
167xfs_cud_item_size(
168 struct xfs_log_item *lip,
169 int *nvecs,
170 int *nbytes)
171{
172 *nvecs += 1;
173 *nbytes += sizeof(struct xfs_cud_log_format);
174}
175
176/*
177 * This is called to fill in the vector of log iovecs for the
178 * given cud log item. We use only 1 iovec, and we point that
179 * at the cud_log_format structure embedded in the cud item.
180 * It is at this point that we assert that all of the extent
181 * slots in the cud item have been filled.
182 */
183STATIC void
184xfs_cud_item_format(
185 struct xfs_log_item *lip,
186 struct xfs_log_vec *lv)
187{
188 struct xfs_cud_log_item *cudp = CUD_ITEM(lip);
189 struct xfs_log_iovec *vecp = NULL;
190
191 cudp->cud_format.cud_type = XFS_LI_CUD;
192 cudp->cud_format.cud_size = 1;
193
194 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_CUD_FORMAT, &cudp->cud_format,
195 sizeof(struct xfs_cud_log_format));
196}
197
198/*
199 * The CUD is either committed or aborted if the transaction is cancelled. If
200 * the transaction is cancelled, drop our reference to the CUI and free the
201 * CUD.
202 */
203STATIC void
204xfs_cud_item_release(
205 struct xfs_log_item *lip)
206{
207 struct xfs_cud_log_item *cudp = CUD_ITEM(lip);
208
209 xfs_cui_release(cuip: cudp->cud_cuip);
210 kmem_free(ptr: cudp->cud_item.li_lv_shadow);
211 kmem_cache_free(s: xfs_cud_cache, objp: cudp);
212}
213
214static struct xfs_log_item *
215xfs_cud_item_intent(
216 struct xfs_log_item *lip)
217{
218 return &CUD_ITEM(lip)->cud_cuip->cui_item;
219}
220
221static const struct xfs_item_ops xfs_cud_item_ops = {
222 .flags = XFS_ITEM_RELEASE_WHEN_COMMITTED |
223 XFS_ITEM_INTENT_DONE,
224 .iop_size = xfs_cud_item_size,
225 .iop_format = xfs_cud_item_format,
226 .iop_release = xfs_cud_item_release,
227 .iop_intent = xfs_cud_item_intent,
228};
229
230static struct xfs_cud_log_item *
231xfs_trans_get_cud(
232 struct xfs_trans *tp,
233 struct xfs_cui_log_item *cuip)
234{
235 struct xfs_cud_log_item *cudp;
236
237 cudp = kmem_cache_zalloc(k: xfs_cud_cache, GFP_KERNEL | __GFP_NOFAIL);
238 xfs_log_item_init(tp->t_mountp, &cudp->cud_item, XFS_LI_CUD,
239 &xfs_cud_item_ops);
240 cudp->cud_cuip = cuip;
241 cudp->cud_format.cud_cui_id = cuip->cui_format.cui_id;
242
243 xfs_trans_add_item(tp, &cudp->cud_item);
244 return cudp;
245}
246
247/*
248 * Finish an refcount update and log it to the CUD. Note that the
249 * transaction is marked dirty regardless of whether the refcount
250 * update succeeds or fails to support the CUI/CUD lifecycle rules.
251 */
252static int
253xfs_trans_log_finish_refcount_update(
254 struct xfs_trans *tp,
255 struct xfs_cud_log_item *cudp,
256 struct xfs_refcount_intent *ri,
257 struct xfs_btree_cur **pcur)
258{
259 int error;
260
261 error = xfs_refcount_finish_one(tp, ri, pcur);
262
263 /*
264 * Mark the transaction dirty, even on error. This ensures the
265 * transaction is aborted, which:
266 *
267 * 1.) releases the CUI and frees the CUD
268 * 2.) shuts down the filesystem
269 */
270 tp->t_flags |= XFS_TRANS_DIRTY | XFS_TRANS_HAS_INTENT_DONE;
271 set_bit(XFS_LI_DIRTY, addr: &cudp->cud_item.li_flags);
272
273 return error;
274}
275
276/* Sort refcount intents by AG. */
277static int
278xfs_refcount_update_diff_items(
279 void *priv,
280 const struct list_head *a,
281 const struct list_head *b)
282{
283 struct xfs_refcount_intent *ra;
284 struct xfs_refcount_intent *rb;
285
286 ra = container_of(a, struct xfs_refcount_intent, ri_list);
287 rb = container_of(b, struct xfs_refcount_intent, ri_list);
288
289 return ra->ri_pag->pag_agno - rb->ri_pag->pag_agno;
290}
291
292/* Set the phys extent flags for this reverse mapping. */
293static void
294xfs_trans_set_refcount_flags(
295 struct xfs_phys_extent *pmap,
296 enum xfs_refcount_intent_type type)
297{
298 pmap->pe_flags = 0;
299 switch (type) {
300 case XFS_REFCOUNT_INCREASE:
301 case XFS_REFCOUNT_DECREASE:
302 case XFS_REFCOUNT_ALLOC_COW:
303 case XFS_REFCOUNT_FREE_COW:
304 pmap->pe_flags |= type;
305 break;
306 default:
307 ASSERT(0);
308 }
309}
310
311/* Log refcount updates in the intent item. */
312STATIC void
313xfs_refcount_update_log_item(
314 struct xfs_trans *tp,
315 struct xfs_cui_log_item *cuip,
316 struct xfs_refcount_intent *ri)
317{
318 uint next_extent;
319 struct xfs_phys_extent *pmap;
320
321 tp->t_flags |= XFS_TRANS_DIRTY;
322 set_bit(XFS_LI_DIRTY, addr: &cuip->cui_item.li_flags);
323
324 /*
325 * atomic_inc_return gives us the value after the increment;
326 * we want to use it as an array index so we need to subtract 1 from
327 * it.
328 */
329 next_extent = atomic_inc_return(v: &cuip->cui_next_extent) - 1;
330 ASSERT(next_extent < cuip->cui_format.cui_nextents);
331 pmap = &cuip->cui_format.cui_extents[next_extent];
332 pmap->pe_startblock = ri->ri_startblock;
333 pmap->pe_len = ri->ri_blockcount;
334 xfs_trans_set_refcount_flags(pmap, type: ri->ri_type);
335}
336
337static struct xfs_log_item *
338xfs_refcount_update_create_intent(
339 struct xfs_trans *tp,
340 struct list_head *items,
341 unsigned int count,
342 bool sort)
343{
344 struct xfs_mount *mp = tp->t_mountp;
345 struct xfs_cui_log_item *cuip = xfs_cui_init(mp, nextents: count);
346 struct xfs_refcount_intent *ri;
347
348 ASSERT(count > 0);
349
350 xfs_trans_add_item(tp, &cuip->cui_item);
351 if (sort)
352 list_sort(priv: mp, head: items, cmp: xfs_refcount_update_diff_items);
353 list_for_each_entry(ri, items, ri_list)
354 xfs_refcount_update_log_item(tp, cuip, ri);
355 return &cuip->cui_item;
356}
357
358/* Get an CUD so we can process all the deferred refcount updates. */
359static struct xfs_log_item *
360xfs_refcount_update_create_done(
361 struct xfs_trans *tp,
362 struct xfs_log_item *intent,
363 unsigned int count)
364{
365 return &xfs_trans_get_cud(tp, cuip: CUI_ITEM(lip: intent))->cud_item;
366}
367
368/* Take a passive ref to the AG containing the space we're refcounting. */
369void
370xfs_refcount_update_get_group(
371 struct xfs_mount *mp,
372 struct xfs_refcount_intent *ri)
373{
374 xfs_agnumber_t agno;
375
376 agno = XFS_FSB_TO_AGNO(mp, ri->ri_startblock);
377 ri->ri_pag = xfs_perag_intent_get(mp, agno);
378}
379
380/* Release a passive AG ref after finishing refcounting work. */
381static inline void
382xfs_refcount_update_put_group(
383 struct xfs_refcount_intent *ri)
384{
385 xfs_perag_intent_put(pag: ri->ri_pag);
386}
387
388/* Process a deferred refcount update. */
389STATIC int
390xfs_refcount_update_finish_item(
391 struct xfs_trans *tp,
392 struct xfs_log_item *done,
393 struct list_head *item,
394 struct xfs_btree_cur **state)
395{
396 struct xfs_refcount_intent *ri;
397 int error;
398
399 ri = container_of(item, struct xfs_refcount_intent, ri_list);
400 error = xfs_trans_log_finish_refcount_update(tp, cudp: CUD_ITEM(lip: done), ri,
401 pcur: state);
402
403 /* Did we run out of reservation? Requeue what we didn't finish. */
404 if (!error && ri->ri_blockcount > 0) {
405 ASSERT(ri->ri_type == XFS_REFCOUNT_INCREASE ||
406 ri->ri_type == XFS_REFCOUNT_DECREASE);
407 return -EAGAIN;
408 }
409
410 xfs_refcount_update_put_group(ri);
411 kmem_cache_free(xfs_refcount_intent_cache, ri);
412 return error;
413}
414
415/* Abort all pending CUIs. */
416STATIC void
417xfs_refcount_update_abort_intent(
418 struct xfs_log_item *intent)
419{
420 xfs_cui_release(cuip: CUI_ITEM(lip: intent));
421}
422
423/* Cancel a deferred refcount update. */
424STATIC void
425xfs_refcount_update_cancel_item(
426 struct list_head *item)
427{
428 struct xfs_refcount_intent *ri;
429
430 ri = container_of(item, struct xfs_refcount_intent, ri_list);
431
432 xfs_refcount_update_put_group(ri);
433 kmem_cache_free(xfs_refcount_intent_cache, ri);
434}
435
436const struct xfs_defer_op_type xfs_refcount_update_defer_type = {
437 .max_items = XFS_CUI_MAX_FAST_EXTENTS,
438 .create_intent = xfs_refcount_update_create_intent,
439 .abort_intent = xfs_refcount_update_abort_intent,
440 .create_done = xfs_refcount_update_create_done,
441 .finish_item = xfs_refcount_update_finish_item,
442 .finish_cleanup = xfs_refcount_finish_one_cleanup,
443 .cancel_item = xfs_refcount_update_cancel_item,
444};
445
446/* Is this recovered CUI ok? */
447static inline bool
448xfs_cui_validate_phys(
449 struct xfs_mount *mp,
450 struct xfs_phys_extent *pmap)
451{
452 if (!xfs_has_reflink(mp))
453 return false;
454
455 if (pmap->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS)
456 return false;
457
458 switch (pmap->pe_flags & XFS_REFCOUNT_EXTENT_TYPE_MASK) {
459 case XFS_REFCOUNT_INCREASE:
460 case XFS_REFCOUNT_DECREASE:
461 case XFS_REFCOUNT_ALLOC_COW:
462 case XFS_REFCOUNT_FREE_COW:
463 break;
464 default:
465 return false;
466 }
467
468 return xfs_verify_fsbext(mp, pmap->pe_startblock, pmap->pe_len);
469}
470
471/*
472 * Process a refcount update intent item that was recovered from the log.
473 * We need to update the refcountbt.
474 */
475STATIC int
476xfs_cui_item_recover(
477 struct xfs_log_item *lip,
478 struct list_head *capture_list)
479{
480 struct xfs_trans_res resv;
481 struct xfs_cui_log_item *cuip = CUI_ITEM(lip);
482 struct xfs_cud_log_item *cudp;
483 struct xfs_trans *tp;
484 struct xfs_btree_cur *rcur = NULL;
485 struct xfs_mount *mp = lip->li_log->l_mp;
486 unsigned int refc_type;
487 bool requeue_only = false;
488 int i;
489 int error = 0;
490
491 /*
492 * First check the validity of the extents described by the
493 * CUI. If any are bad, then assume that all are bad and
494 * just toss the CUI.
495 */
496 for (i = 0; i < cuip->cui_format.cui_nextents; i++) {
497 if (!xfs_cui_validate_phys(mp,
498 pmap: &cuip->cui_format.cui_extents[i])) {
499 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
500 &cuip->cui_format,
501 sizeof(cuip->cui_format));
502 return -EFSCORRUPTED;
503 }
504 }
505
506 /*
507 * Under normal operation, refcount updates are deferred, so we
508 * wouldn't be adding them directly to a transaction. All
509 * refcount updates manage reservation usage internally and
510 * dynamically by deferring work that won't fit in the
511 * transaction. Normally, any work that needs to be deferred
512 * gets attached to the same defer_ops that scheduled the
513 * refcount update. However, we're in log recovery here, so we
514 * use the passed in defer_ops and to finish up any work that
515 * doesn't fit. We need to reserve enough blocks to handle a
516 * full btree split on either end of the refcount range.
517 */
518 resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
519 error = xfs_trans_alloc(mp, &resv, mp->m_refc_maxlevels * 2, 0,
520 XFS_TRANS_RESERVE, &tp);
521 if (error)
522 return error;
523
524 cudp = xfs_trans_get_cud(tp, cuip);
525
526 for (i = 0; i < cuip->cui_format.cui_nextents; i++) {
527 struct xfs_refcount_intent fake = { };
528 struct xfs_phys_extent *pmap;
529
530 pmap = &cuip->cui_format.cui_extents[i];
531 refc_type = pmap->pe_flags & XFS_REFCOUNT_EXTENT_TYPE_MASK;
532 switch (refc_type) {
533 case XFS_REFCOUNT_INCREASE:
534 case XFS_REFCOUNT_DECREASE:
535 case XFS_REFCOUNT_ALLOC_COW:
536 case XFS_REFCOUNT_FREE_COW:
537 fake.ri_type = refc_type;
538 break;
539 default:
540 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
541 &cuip->cui_format,
542 sizeof(cuip->cui_format));
543 error = -EFSCORRUPTED;
544 goto abort_error;
545 }
546
547 fake.ri_startblock = pmap->pe_startblock;
548 fake.ri_blockcount = pmap->pe_len;
549
550 if (!requeue_only) {
551 xfs_refcount_update_get_group(mp, ri: &fake);
552 error = xfs_trans_log_finish_refcount_update(tp, cudp,
553 ri: &fake, pcur: &rcur);
554 xfs_refcount_update_put_group(ri: &fake);
555 }
556 if (error == -EFSCORRUPTED)
557 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
558 &cuip->cui_format,
559 sizeof(cuip->cui_format));
560 if (error)
561 goto abort_error;
562
563 /* Requeue what we didn't finish. */
564 if (fake.ri_blockcount > 0) {
565 struct xfs_bmbt_irec irec = {
566 .br_startblock = fake.ri_startblock,
567 .br_blockcount = fake.ri_blockcount,
568 };
569
570 switch (fake.ri_type) {
571 case XFS_REFCOUNT_INCREASE:
572 xfs_refcount_increase_extent(tp, &irec);
573 break;
574 case XFS_REFCOUNT_DECREASE:
575 xfs_refcount_decrease_extent(tp, &irec);
576 break;
577 case XFS_REFCOUNT_ALLOC_COW:
578 xfs_refcount_alloc_cow_extent(tp,
579 irec.br_startblock,
580 irec.br_blockcount);
581 break;
582 case XFS_REFCOUNT_FREE_COW:
583 xfs_refcount_free_cow_extent(tp,
584 irec.br_startblock,
585 irec.br_blockcount);
586 break;
587 default:
588 ASSERT(0);
589 }
590 requeue_only = true;
591 }
592 }
593
594 xfs_refcount_finish_one_cleanup(tp, rcur, error);
595 return xfs_defer_ops_capture_and_commit(tp, capture_list);
596
597abort_error:
598 xfs_refcount_finish_one_cleanup(tp, rcur, error);
599 xfs_trans_cancel(tp);
600 return error;
601}
602
603STATIC bool
604xfs_cui_item_match(
605 struct xfs_log_item *lip,
606 uint64_t intent_id)
607{
608 return CUI_ITEM(lip)->cui_format.cui_id == intent_id;
609}
610
611/* Relog an intent item to push the log tail forward. */
612static struct xfs_log_item *
613xfs_cui_item_relog(
614 struct xfs_log_item *intent,
615 struct xfs_trans *tp)
616{
617 struct xfs_cud_log_item *cudp;
618 struct xfs_cui_log_item *cuip;
619 struct xfs_phys_extent *pmap;
620 unsigned int count;
621
622 count = CUI_ITEM(lip: intent)->cui_format.cui_nextents;
623 pmap = CUI_ITEM(lip: intent)->cui_format.cui_extents;
624
625 tp->t_flags |= XFS_TRANS_DIRTY;
626 cudp = xfs_trans_get_cud(tp, cuip: CUI_ITEM(lip: intent));
627 set_bit(XFS_LI_DIRTY, addr: &cudp->cud_item.li_flags);
628
629 cuip = xfs_cui_init(mp: tp->t_mountp, nextents: count);
630 memcpy(cuip->cui_format.cui_extents, pmap, count * sizeof(*pmap));
631 atomic_set(v: &cuip->cui_next_extent, i: count);
632 xfs_trans_add_item(tp, &cuip->cui_item);
633 set_bit(XFS_LI_DIRTY, addr: &cuip->cui_item.li_flags);
634 return &cuip->cui_item;
635}
636
637static const struct xfs_item_ops xfs_cui_item_ops = {
638 .flags = XFS_ITEM_INTENT,
639 .iop_size = xfs_cui_item_size,
640 .iop_format = xfs_cui_item_format,
641 .iop_unpin = xfs_cui_item_unpin,
642 .iop_release = xfs_cui_item_release,
643 .iop_recover = xfs_cui_item_recover,
644 .iop_match = xfs_cui_item_match,
645 .iop_relog = xfs_cui_item_relog,
646};
647
648static inline void
649xfs_cui_copy_format(
650 struct xfs_cui_log_format *dst,
651 const struct xfs_cui_log_format *src)
652{
653 unsigned int i;
654
655 memcpy(dst, src, offsetof(struct xfs_cui_log_format, cui_extents));
656
657 for (i = 0; i < src->cui_nextents; i++)
658 memcpy(&dst->cui_extents[i], &src->cui_extents[i],
659 sizeof(struct xfs_phys_extent));
660}
661
662/*
663 * This routine is called to create an in-core extent refcount update
664 * item from the cui format structure which was logged on disk.
665 * It allocates an in-core cui, copies the extents from the format
666 * structure into it, and adds the cui to the AIL with the given
667 * LSN.
668 */
669STATIC int
670xlog_recover_cui_commit_pass2(
671 struct xlog *log,
672 struct list_head *buffer_list,
673 struct xlog_recover_item *item,
674 xfs_lsn_t lsn)
675{
676 struct xfs_mount *mp = log->l_mp;
677 struct xfs_cui_log_item *cuip;
678 struct xfs_cui_log_format *cui_formatp;
679 size_t len;
680
681 cui_formatp = item->ri_buf[0].i_addr;
682
683 if (item->ri_buf[0].i_len < xfs_cui_log_format_sizeof(0)) {
684 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
685 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
686 return -EFSCORRUPTED;
687 }
688
689 len = xfs_cui_log_format_sizeof(cui_formatp->cui_nextents);
690 if (item->ri_buf[0].i_len != len) {
691 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
692 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
693 return -EFSCORRUPTED;
694 }
695
696 cuip = xfs_cui_init(mp, nextents: cui_formatp->cui_nextents);
697 xfs_cui_copy_format(dst: &cuip->cui_format, src: cui_formatp);
698 atomic_set(v: &cuip->cui_next_extent, i: cui_formatp->cui_nextents);
699 /*
700 * Insert the intent into the AIL directly and drop one reference so
701 * that finishing or canceling the work will drop the other.
702 */
703 xfs_trans_ail_insert(log->l_ailp, &cuip->cui_item, lsn);
704 xfs_cui_release(cuip);
705 return 0;
706}
707
708const struct xlog_recover_item_ops xlog_cui_item_ops = {
709 .item_type = XFS_LI_CUI,
710 .commit_pass2 = xlog_recover_cui_commit_pass2,
711};
712
713/*
714 * This routine is called when an CUD format structure is found in a committed
715 * transaction in the log. Its purpose is to cancel the corresponding CUI if it
716 * was still in the log. To do this it searches the AIL for the CUI with an id
717 * equal to that in the CUD format structure. If we find it we drop the CUD
718 * reference, which removes the CUI from the AIL and frees it.
719 */
720STATIC int
721xlog_recover_cud_commit_pass2(
722 struct xlog *log,
723 struct list_head *buffer_list,
724 struct xlog_recover_item *item,
725 xfs_lsn_t lsn)
726{
727 struct xfs_cud_log_format *cud_formatp;
728
729 cud_formatp = item->ri_buf[0].i_addr;
730 if (item->ri_buf[0].i_len != sizeof(struct xfs_cud_log_format)) {
731 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
732 item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
733 return -EFSCORRUPTED;
734 }
735
736 xlog_recover_release_intent(log, XFS_LI_CUI, cud_formatp->cud_cui_id);
737 return 0;
738}
739
740const struct xlog_recover_item_ops xlog_cud_item_ops = {
741 .item_type = XFS_LI_CUD,
742 .commit_pass2 = xlog_recover_cud_commit_pass2,
743};
744

source code of linux/fs/xfs/xfs_refcount_item.c