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 | |
25 | struct kmem_cache *xfs_cui_cache; |
26 | struct kmem_cache *xfs_cud_cache; |
27 | |
28 | static const struct xfs_item_ops xfs_cui_item_ops; |
29 | |
30 | static 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 | |
35 | STATIC void |
36 | xfs_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 | */ |
53 | STATIC void |
54 | xfs_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 | |
66 | STATIC void |
67 | xfs_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 | */ |
85 | STATIC void |
86 | xfs_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 | */ |
111 | STATIC void |
112 | xfs_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 | */ |
126 | STATIC void |
127 | xfs_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 | */ |
136 | STATIC struct xfs_cui_log_item * |
137 | xfs_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 | |
161 | static 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 | |
166 | STATIC void |
167 | xfs_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 | */ |
183 | STATIC void |
184 | xfs_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 | */ |
203 | STATIC void |
204 | xfs_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 | |
214 | static struct xfs_log_item * |
215 | xfs_cud_item_intent( |
216 | struct xfs_log_item *lip) |
217 | { |
218 | return &CUD_ITEM(lip)->cud_cuip->cui_item; |
219 | } |
220 | |
221 | static 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 | |
230 | static struct xfs_cud_log_item * |
231 | xfs_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 | */ |
252 | static int |
253 | xfs_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. */ |
277 | static int |
278 | xfs_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. */ |
293 | static void |
294 | xfs_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. */ |
312 | STATIC void |
313 | xfs_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 | |
337 | static struct xfs_log_item * |
338 | xfs_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. */ |
359 | static struct xfs_log_item * |
360 | xfs_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. */ |
369 | void |
370 | xfs_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. */ |
381 | static inline void |
382 | xfs_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. */ |
389 | STATIC int |
390 | xfs_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. */ |
416 | STATIC void |
417 | xfs_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. */ |
424 | STATIC void |
425 | xfs_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 | |
436 | const 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? */ |
447 | static inline bool |
448 | xfs_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 | */ |
475 | STATIC int |
476 | xfs_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 | |
597 | abort_error: |
598 | xfs_refcount_finish_one_cleanup(tp, rcur, error); |
599 | xfs_trans_cancel(tp); |
600 | return error; |
601 | } |
602 | |
603 | STATIC bool |
604 | xfs_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. */ |
612 | static struct xfs_log_item * |
613 | xfs_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 | |
637 | static 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 | |
648 | static inline void |
649 | xfs_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 | */ |
669 | STATIC int |
670 | xlog_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 | |
708 | const 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 | */ |
720 | STATIC int |
721 | xlog_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 | |
740 | const 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 | |