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