1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
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_ag.h"
15#include "xfs_defer.h"
16#include "xfs_trans.h"
17#include "xfs_trans_priv.h"
18#include "xfs_extfree_item.h"
19#include "xfs_log.h"
20#include "xfs_btree.h"
21#include "xfs_rmap.h"
22#include "xfs_alloc.h"
23#include "xfs_bmap.h"
24#include "xfs_trace.h"
25#include "xfs_error.h"
26#include "xfs_log_priv.h"
27#include "xfs_log_recover.h"
28#include "xfs_rtalloc.h"
29#include "xfs_inode.h"
30#include "xfs_rtbitmap.h"
31#include "xfs_rtgroup.h"
32#include "xfs_zone_alloc.h"
33
34struct kmem_cache *xfs_efi_cache;
35struct kmem_cache *xfs_efd_cache;
36
37static const struct xfs_item_ops xfs_efi_item_ops;
38
39static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip)
40{
41 return container_of(lip, struct xfs_efi_log_item, efi_item);
42}
43
44STATIC void
45xfs_efi_item_free(
46 struct xfs_efi_log_item *efip)
47{
48 kvfree(addr: efip->efi_item.li_lv_shadow);
49 if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS)
50 kfree(objp: efip);
51 else
52 kmem_cache_free(s: xfs_efi_cache, objp: efip);
53}
54
55/*
56 * Freeing the efi requires that we remove it from the AIL if it has already
57 * been placed there. However, the EFI may not yet have been placed in the AIL
58 * when called by xfs_efi_release() from EFD processing due to the ordering of
59 * committed vs unpin operations in bulk insert operations. Hence the reference
60 * count to ensure only the last caller frees the EFI.
61 */
62STATIC void
63xfs_efi_release(
64 struct xfs_efi_log_item *efip)
65{
66 ASSERT(atomic_read(&efip->efi_refcount) > 0);
67 if (!atomic_dec_and_test(v: &efip->efi_refcount))
68 return;
69
70 xfs_trans_ail_delete(lip: &efip->efi_item, shutdown_type: 0);
71 xfs_efi_item_free(efip);
72}
73
74STATIC void
75xfs_efi_item_size(
76 struct xfs_log_item *lip,
77 int *nvecs,
78 int *nbytes)
79{
80 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
81
82 *nvecs += 1;
83 *nbytes += xfs_efi_log_format_sizeof(efip->efi_format.efi_nextents);
84}
85
86unsigned int xfs_efi_log_space(unsigned int nr)
87{
88 return xlog_item_space(niovecs: 1, nbytes: xfs_efi_log_format_sizeof(nr));
89}
90
91/*
92 * This is called to fill in the vector of log iovecs for the
93 * given efi log item. We use only 1 iovec, and we point that
94 * at the efi_log_format structure embedded in the efi item.
95 * It is at this point that we assert that all of the extent
96 * slots in the efi item have been filled.
97 */
98STATIC void
99xfs_efi_item_format(
100 struct xfs_log_item *lip,
101 struct xfs_log_vec *lv)
102{
103 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
104 struct xfs_log_iovec *vecp = NULL;
105
106 ASSERT(atomic_read(&efip->efi_next_extent) ==
107 efip->efi_format.efi_nextents);
108 ASSERT(lip->li_type == XFS_LI_EFI || lip->li_type == XFS_LI_EFI_RT);
109
110 efip->efi_format.efi_type = lip->li_type;
111 efip->efi_format.efi_size = 1;
112
113 xlog_copy_iovec(lv, vecp: &vecp, XLOG_REG_TYPE_EFI_FORMAT, data: &efip->efi_format,
114 len: xfs_efi_log_format_sizeof(efip->efi_format.efi_nextents));
115}
116
117/*
118 * The unpin operation is the last place an EFI is manipulated in the log. It is
119 * either inserted in the AIL or aborted in the event of a log I/O error. In
120 * either case, the EFI transaction has been successfully committed to make it
121 * this far. Therefore, we expect whoever committed the EFI to either construct
122 * and commit the EFD or drop the EFD's reference in the event of error. Simply
123 * drop the log's EFI reference now that the log is done with it.
124 */
125STATIC void
126xfs_efi_item_unpin(
127 struct xfs_log_item *lip,
128 int remove)
129{
130 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
131 xfs_efi_release(efip);
132}
133
134/*
135 * The EFI has been either committed or aborted if the transaction has been
136 * cancelled. If the transaction was cancelled, an EFD isn't going to be
137 * constructed and thus we free the EFI here directly.
138 */
139STATIC void
140xfs_efi_item_release(
141 struct xfs_log_item *lip)
142{
143 xfs_efi_release(efip: EFI_ITEM(lip));
144}
145
146/*
147 * Allocate and initialize an efi item with the given number of extents.
148 */
149STATIC struct xfs_efi_log_item *
150xfs_efi_init(
151 struct xfs_mount *mp,
152 unsigned short item_type,
153 uint nextents)
154{
155 struct xfs_efi_log_item *efip;
156
157 ASSERT(item_type == XFS_LI_EFI || item_type == XFS_LI_EFI_RT);
158 ASSERT(nextents > 0);
159
160 if (nextents > XFS_EFI_MAX_FAST_EXTENTS) {
161 efip = kzalloc(xfs_efi_log_item_sizeof(nextents),
162 GFP_KERNEL | __GFP_NOFAIL);
163 } else {
164 efip = kmem_cache_zalloc(xfs_efi_cache,
165 GFP_KERNEL | __GFP_NOFAIL);
166 }
167
168 xfs_log_item_init(mp, item: &efip->efi_item, type: item_type, ops: &xfs_efi_item_ops);
169 efip->efi_format.efi_nextents = nextents;
170 efip->efi_format.efi_id = (uintptr_t)(void *)efip;
171 atomic_set(v: &efip->efi_next_extent, i: 0);
172 atomic_set(v: &efip->efi_refcount, i: 2);
173
174 return efip;
175}
176
177/*
178 * Copy an EFI format buffer from the given buf, and into the destination
179 * EFI format structure.
180 * The given buffer can be in 32 bit or 64 bit form (which has different padding),
181 * one of which will be the native format for this kernel.
182 * It will handle the conversion of formats if necessary.
183 */
184STATIC int
185xfs_efi_copy_format(
186 struct kvec *buf,
187 struct xfs_efi_log_format *dst_efi_fmt)
188{
189 struct xfs_efi_log_format *src_efi_fmt = buf->iov_base;
190 uint len, len32, len64, i;
191
192 len = xfs_efi_log_format_sizeof(src_efi_fmt->efi_nextents);
193 len32 = xfs_efi_log_format32_sizeof(src_efi_fmt->efi_nextents);
194 len64 = xfs_efi_log_format64_sizeof(src_efi_fmt->efi_nextents);
195
196 if (buf->iov_len == len) {
197 memcpy(dst_efi_fmt, src_efi_fmt,
198 offsetof(struct xfs_efi_log_format, efi_extents));
199 for (i = 0; i < src_efi_fmt->efi_nextents; i++)
200 memcpy(&dst_efi_fmt->efi_extents[i],
201 &src_efi_fmt->efi_extents[i],
202 sizeof(struct xfs_extent));
203 return 0;
204 } else if (buf->iov_len == len32) {
205 struct xfs_efi_log_format_32 *src_efi_fmt_32 = buf->iov_base;
206
207 dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type;
208 dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size;
209 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
210 dst_efi_fmt->efi_id = src_efi_fmt_32->efi_id;
211 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
212 dst_efi_fmt->efi_extents[i].ext_start =
213 src_efi_fmt_32->efi_extents[i].ext_start;
214 dst_efi_fmt->efi_extents[i].ext_len =
215 src_efi_fmt_32->efi_extents[i].ext_len;
216 }
217 return 0;
218 } else if (buf->iov_len == len64) {
219 struct xfs_efi_log_format_64 *src_efi_fmt_64 = buf->iov_base;
220
221 dst_efi_fmt->efi_type = src_efi_fmt_64->efi_type;
222 dst_efi_fmt->efi_size = src_efi_fmt_64->efi_size;
223 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents;
224 dst_efi_fmt->efi_id = src_efi_fmt_64->efi_id;
225 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
226 dst_efi_fmt->efi_extents[i].ext_start =
227 src_efi_fmt_64->efi_extents[i].ext_start;
228 dst_efi_fmt->efi_extents[i].ext_len =
229 src_efi_fmt_64->efi_extents[i].ext_len;
230 }
231 return 0;
232 }
233 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, NULL, buf->iov_base,
234 buf->iov_len);
235 return -EFSCORRUPTED;
236}
237
238static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip)
239{
240 return container_of(lip, struct xfs_efd_log_item, efd_item);
241}
242
243STATIC void
244xfs_efd_item_free(struct xfs_efd_log_item *efdp)
245{
246 kvfree(addr: efdp->efd_item.li_lv_shadow);
247 if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS)
248 kfree(objp: efdp);
249 else
250 kmem_cache_free(s: xfs_efd_cache, objp: efdp);
251}
252
253STATIC void
254xfs_efd_item_size(
255 struct xfs_log_item *lip,
256 int *nvecs,
257 int *nbytes)
258{
259 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
260
261 *nvecs += 1;
262 *nbytes += xfs_efd_log_format_sizeof(efdp->efd_format.efd_nextents);
263}
264
265unsigned int xfs_efd_log_space(unsigned int nr)
266{
267 return xlog_item_space(niovecs: 1, nbytes: xfs_efd_log_format_sizeof(nr));
268}
269
270/*
271 * This is called to fill in the vector of log iovecs for the
272 * given efd log item. We use only 1 iovec, and we point that
273 * at the efd_log_format structure embedded in the efd item.
274 * It is at this point that we assert that all of the extent
275 * slots in the efd item have been filled.
276 */
277STATIC void
278xfs_efd_item_format(
279 struct xfs_log_item *lip,
280 struct xfs_log_vec *lv)
281{
282 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
283 struct xfs_log_iovec *vecp = NULL;
284
285 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
286 ASSERT(lip->li_type == XFS_LI_EFD || lip->li_type == XFS_LI_EFD_RT);
287
288 efdp->efd_format.efd_type = lip->li_type;
289 efdp->efd_format.efd_size = 1;
290
291 xlog_copy_iovec(lv, vecp: &vecp, XLOG_REG_TYPE_EFD_FORMAT, data: &efdp->efd_format,
292 len: xfs_efd_log_format_sizeof(efdp->efd_format.efd_nextents));
293}
294
295/*
296 * The EFD is either committed or aborted if the transaction is cancelled. If
297 * the transaction is cancelled, drop our reference to the EFI and free the EFD.
298 */
299STATIC void
300xfs_efd_item_release(
301 struct xfs_log_item *lip)
302{
303 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
304
305 xfs_efi_release(efip: efdp->efd_efip);
306 xfs_efd_item_free(efdp);
307}
308
309static struct xfs_log_item *
310xfs_efd_item_intent(
311 struct xfs_log_item *lip)
312{
313 return &EFD_ITEM(lip)->efd_efip->efi_item;
314}
315
316static const struct xfs_item_ops xfs_efd_item_ops = {
317 .flags = XFS_ITEM_RELEASE_WHEN_COMMITTED |
318 XFS_ITEM_INTENT_DONE,
319 .iop_size = xfs_efd_item_size,
320 .iop_format = xfs_efd_item_format,
321 .iop_release = xfs_efd_item_release,
322 .iop_intent = xfs_efd_item_intent,
323};
324
325static inline struct xfs_extent_free_item *xefi_entry(const struct list_head *e)
326{
327 return list_entry(e, struct xfs_extent_free_item, xefi_list);
328}
329
330static inline bool
331xfs_efi_item_isrt(const struct xfs_log_item *lip)
332{
333 ASSERT(lip->li_type == XFS_LI_EFI || lip->li_type == XFS_LI_EFI_RT);
334
335 return lip->li_type == XFS_LI_EFI_RT;
336}
337
338/*
339 * Fill the EFD with all extents from the EFI when we need to roll the
340 * transaction and continue with a new EFI.
341 *
342 * This simply copies all the extents in the EFI to the EFD rather than make
343 * assumptions about which extents in the EFI have already been processed. We
344 * currently keep the xefi list in the same order as the EFI extent list, but
345 * that may not always be the case. Copying everything avoids leaving a landmine
346 * were we fail to cancel all the extents in an EFI if the xefi list is
347 * processed in a different order to the extents in the EFI.
348 */
349static void
350xfs_efd_from_efi(
351 struct xfs_efd_log_item *efdp)
352{
353 struct xfs_efi_log_item *efip = efdp->efd_efip;
354 uint i;
355
356 ASSERT(efip->efi_format.efi_nextents > 0);
357 ASSERT(efdp->efd_next_extent < efip->efi_format.efi_nextents);
358
359 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
360 efdp->efd_format.efd_extents[i] =
361 efip->efi_format.efi_extents[i];
362 }
363 efdp->efd_next_extent = efip->efi_format.efi_nextents;
364}
365
366static void
367xfs_efd_add_extent(
368 struct xfs_efd_log_item *efdp,
369 struct xfs_extent_free_item *xefi)
370{
371 struct xfs_extent *extp;
372
373 ASSERT(efdp->efd_next_extent < efdp->efd_format.efd_nextents);
374
375 extp = &efdp->efd_format.efd_extents[efdp->efd_next_extent];
376 extp->ext_start = xefi->xefi_startblock;
377 extp->ext_len = xefi->xefi_blockcount;
378
379 efdp->efd_next_extent++;
380}
381
382/* Sort bmap items by AG. */
383static int
384xfs_extent_free_diff_items(
385 void *priv,
386 const struct list_head *a,
387 const struct list_head *b)
388{
389 struct xfs_extent_free_item *ra = xefi_entry(e: a);
390 struct xfs_extent_free_item *rb = xefi_entry(e: b);
391
392 return ra->xefi_group->xg_gno - rb->xefi_group->xg_gno;
393}
394
395/* Log a free extent to the intent item. */
396STATIC void
397xfs_extent_free_log_item(
398 struct xfs_trans *tp,
399 struct xfs_efi_log_item *efip,
400 struct xfs_extent_free_item *xefi)
401{
402 uint next_extent;
403 struct xfs_extent *extp;
404
405 /*
406 * atomic_inc_return gives us the value after the increment;
407 * we want to use it as an array index so we need to subtract 1 from
408 * it.
409 */
410 next_extent = atomic_inc_return(v: &efip->efi_next_extent) - 1;
411 ASSERT(next_extent < efip->efi_format.efi_nextents);
412 extp = &efip->efi_format.efi_extents[next_extent];
413 extp->ext_start = xefi->xefi_startblock;
414 extp->ext_len = xefi->xefi_blockcount;
415}
416
417static struct xfs_log_item *
418__xfs_extent_free_create_intent(
419 struct xfs_trans *tp,
420 struct list_head *items,
421 unsigned int count,
422 bool sort,
423 unsigned short item_type)
424{
425 struct xfs_mount *mp = tp->t_mountp;
426 struct xfs_efi_log_item *efip;
427 struct xfs_extent_free_item *xefi;
428
429 ASSERT(count > 0);
430
431 efip = xfs_efi_init(mp, item_type, nextents: count);
432 if (sort)
433 list_sort(priv: mp, head: items, cmp: xfs_extent_free_diff_items);
434 list_for_each_entry(xefi, items, xefi_list)
435 xfs_extent_free_log_item(tp, efip, xefi);
436 return &efip->efi_item;
437}
438
439static struct xfs_log_item *
440xfs_extent_free_create_intent(
441 struct xfs_trans *tp,
442 struct list_head *items,
443 unsigned int count,
444 bool sort)
445{
446 return __xfs_extent_free_create_intent(tp, items, count, sort,
447 XFS_LI_EFI);
448}
449
450static inline unsigned short
451xfs_efd_type_from_efi(const struct xfs_efi_log_item *efip)
452{
453 return xfs_efi_item_isrt(&efip->efi_item) ? XFS_LI_EFD_RT : XFS_LI_EFD;
454}
455
456/* Get an EFD so we can process all the free extents. */
457static struct xfs_log_item *
458xfs_extent_free_create_done(
459 struct xfs_trans *tp,
460 struct xfs_log_item *intent,
461 unsigned int count)
462{
463 struct xfs_efi_log_item *efip = EFI_ITEM(lip: intent);
464 struct xfs_efd_log_item *efdp;
465
466 ASSERT(count > 0);
467
468 if (count > XFS_EFD_MAX_FAST_EXTENTS) {
469 efdp = kzalloc(xfs_efd_log_item_sizeof(count),
470 GFP_KERNEL | __GFP_NOFAIL);
471 } else {
472 efdp = kmem_cache_zalloc(xfs_efd_cache,
473 GFP_KERNEL | __GFP_NOFAIL);
474 }
475
476 xfs_log_item_init(mp: tp->t_mountp, item: &efdp->efd_item,
477 type: xfs_efd_type_from_efi(efip), ops: &xfs_efd_item_ops);
478 efdp->efd_efip = efip;
479 efdp->efd_format.efd_nextents = count;
480 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
481
482 return &efdp->efd_item;
483}
484
485static inline const struct xfs_defer_op_type *
486xefi_ops(
487 struct xfs_extent_free_item *xefi)
488{
489 if (xfs_efi_is_realtime(xefi))
490 return &xfs_rtextent_free_defer_type;
491 if (xefi->xefi_agresv == XFS_AG_RESV_AGFL)
492 return &xfs_agfl_free_defer_type;
493 return &xfs_extent_free_defer_type;
494}
495
496/* Add this deferred EFI to the transaction. */
497void
498xfs_extent_free_defer_add(
499 struct xfs_trans *tp,
500 struct xfs_extent_free_item *xefi,
501 struct xfs_defer_pending **dfpp)
502{
503 struct xfs_mount *mp = tp->t_mountp;
504
505 xefi->xefi_group = xfs_group_intent_get(mp, xefi->xefi_startblock,
506 xfs_efi_is_realtime(xefi) ? XG_TYPE_RTG : XG_TYPE_AG);
507
508 trace_xfs_extent_free_defer(mp, free: xefi);
509 *dfpp = xfs_defer_add(tp, &xefi->xefi_list, xefi_ops(xefi));
510}
511
512/* Cancel a free extent. */
513STATIC void
514xfs_extent_free_cancel_item(
515 struct list_head *item)
516{
517 struct xfs_extent_free_item *xefi = xefi_entry(e: item);
518
519 xfs_group_intent_put(rtg: xefi->xefi_group);
520 kmem_cache_free(xfs_extfree_item_cache, xefi);
521}
522
523/* Process a free extent. */
524STATIC int
525xfs_extent_free_finish_item(
526 struct xfs_trans *tp,
527 struct xfs_log_item *done,
528 struct list_head *item,
529 struct xfs_btree_cur **state)
530{
531 struct xfs_owner_info oinfo = { };
532 struct xfs_extent_free_item *xefi = xefi_entry(e: item);
533 struct xfs_efd_log_item *efdp = EFD_ITEM(lip: done);
534 struct xfs_mount *mp = tp->t_mountp;
535 xfs_agblock_t agbno;
536 int error = 0;
537
538 agbno = XFS_FSB_TO_AGBNO(mp, xefi->xefi_startblock);
539
540 oinfo.oi_owner = xefi->xefi_owner;
541 if (xefi->xefi_flags & XFS_EFI_ATTR_FORK)
542 oinfo.oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
543 if (xefi->xefi_flags & XFS_EFI_BMBT_BLOCK)
544 oinfo.oi_flags |= XFS_OWNER_INFO_BMBT_BLOCK;
545
546 trace_xfs_extent_free_deferred(mp, free: xefi);
547
548 /*
549 * If we need a new transaction to make progress, the caller will log a
550 * new EFI with the current contents. It will also log an EFD to cancel
551 * the existing EFI, and so we need to copy all the unprocessed extents
552 * in this EFI to the EFD so this works correctly.
553 */
554 if (!(xefi->xefi_flags & XFS_EFI_CANCELLED))
555 error = __xfs_free_extent(tp, to_perag(xefi->xefi_group), agbno,
556 xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv,
557 xefi->xefi_flags & XFS_EFI_SKIP_DISCARD);
558 if (error == -EAGAIN) {
559 xfs_efd_from_efi(efdp);
560 return error;
561 }
562
563 xfs_efd_add_extent(efdp, xefi);
564 xfs_extent_free_cancel_item(item);
565 return error;
566}
567
568/* Abort all pending EFIs. */
569STATIC void
570xfs_extent_free_abort_intent(
571 struct xfs_log_item *intent)
572{
573 xfs_efi_release(efip: EFI_ITEM(lip: intent));
574}
575
576/*
577 * AGFL blocks are accounted differently in the reserve pools and are not
578 * inserted into the busy extent list.
579 */
580STATIC int
581xfs_agfl_free_finish_item(
582 struct xfs_trans *tp,
583 struct xfs_log_item *done,
584 struct list_head *item,
585 struct xfs_btree_cur **state)
586{
587 struct xfs_owner_info oinfo = { };
588 struct xfs_mount *mp = tp->t_mountp;
589 struct xfs_efd_log_item *efdp = EFD_ITEM(lip: done);
590 struct xfs_extent_free_item *xefi = xefi_entry(e: item);
591 struct xfs_buf *agbp;
592 int error;
593 xfs_agblock_t agbno;
594
595 ASSERT(xefi->xefi_blockcount == 1);
596 agbno = XFS_FSB_TO_AGBNO(mp, xefi->xefi_startblock);
597 oinfo.oi_owner = xefi->xefi_owner;
598
599 trace_xfs_agfl_free_deferred(mp, free: xefi);
600
601 error = xfs_alloc_read_agf(to_perag(xefi->xefi_group), tp, 0, &agbp);
602 if (!error)
603 error = xfs_free_ag_extent(tp, agbp, agbno, 1, &oinfo,
604 XFS_AG_RESV_AGFL);
605
606 xfs_efd_add_extent(efdp, xefi);
607 xfs_extent_free_cancel_item(item: &xefi->xefi_list);
608 return error;
609}
610
611/* Is this recovered EFI ok? */
612static inline bool
613xfs_efi_validate_ext(
614 struct xfs_mount *mp,
615 bool isrt,
616 struct xfs_extent *extp)
617{
618 if (isrt)
619 return xfs_verify_rtbext(mp, extp->ext_start, extp->ext_len);
620
621 return xfs_verify_fsbext(mp, extp->ext_start, extp->ext_len);
622}
623
624static inline void
625xfs_efi_recover_work(
626 struct xfs_mount *mp,
627 struct xfs_defer_pending *dfp,
628 bool isrt,
629 struct xfs_extent *extp)
630{
631 struct xfs_extent_free_item *xefi;
632
633 xefi = kmem_cache_zalloc(xfs_extfree_item_cache,
634 GFP_KERNEL | __GFP_NOFAIL);
635 xefi->xefi_startblock = extp->ext_start;
636 xefi->xefi_blockcount = extp->ext_len;
637 xefi->xefi_agresv = XFS_AG_RESV_NONE;
638 xefi->xefi_owner = XFS_RMAP_OWN_UNKNOWN;
639 xefi->xefi_group = xfs_group_intent_get(mp, extp->ext_start,
640 isrt ? XG_TYPE_RTG : XG_TYPE_AG);
641 if (isrt)
642 xefi->xefi_flags |= XFS_EFI_REALTIME;
643
644 xfs_defer_add_item(dfp, &xefi->xefi_list);
645}
646
647/*
648 * Process an extent free intent item that was recovered from
649 * the log. We need to free the extents that it describes.
650 */
651STATIC int
652xfs_extent_free_recover_work(
653 struct xfs_defer_pending *dfp,
654 struct list_head *capture_list)
655{
656 struct xfs_trans_res resv;
657 struct xfs_log_item *lip = dfp->dfp_intent;
658 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
659 struct xfs_mount *mp = lip->li_log->l_mp;
660 struct xfs_trans *tp;
661 int i;
662 int error = 0;
663 bool isrt = xfs_efi_item_isrt(lip);
664
665 /*
666 * First check the validity of the extents described by the EFI. If
667 * any are bad, then assume that all are bad and just toss the EFI.
668 * Mixing RT and non-RT extents in the same EFI item is not allowed.
669 */
670 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
671 if (!xfs_efi_validate_ext(mp, isrt,
672 extp: &efip->efi_format.efi_extents[i])) {
673 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
674 &efip->efi_format,
675 sizeof(efip->efi_format));
676 return -EFSCORRUPTED;
677 }
678
679 xfs_efi_recover_work(mp, dfp, isrt,
680 extp: &efip->efi_format.efi_extents[i]);
681 }
682
683 resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
684 error = xfs_trans_alloc(mp, resp: &resv, blocks: 0, rtextents: 0, flags: 0, tpp: &tp);
685 if (error)
686 return error;
687
688 error = xlog_recover_finish_intent(tp, dfp);
689 if (error == -EFSCORRUPTED)
690 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
691 &efip->efi_format,
692 sizeof(efip->efi_format));
693 if (error)
694 goto abort_error;
695
696 return xfs_defer_ops_capture_and_commit(tp, capture_list);
697
698abort_error:
699 xfs_trans_cancel(tp);
700 return error;
701}
702
703/* Relog an intent item to push the log tail forward. */
704static struct xfs_log_item *
705xfs_extent_free_relog_intent(
706 struct xfs_trans *tp,
707 struct xfs_log_item *intent,
708 struct xfs_log_item *done_item)
709{
710 struct xfs_efd_log_item *efdp = EFD_ITEM(lip: done_item);
711 struct xfs_efi_log_item *efip;
712 struct xfs_extent *extp;
713 unsigned int count;
714
715 count = EFI_ITEM(lip: intent)->efi_format.efi_nextents;
716 extp = EFI_ITEM(lip: intent)->efi_format.efi_extents;
717
718 ASSERT(intent->li_type == XFS_LI_EFI || intent->li_type == XFS_LI_EFI_RT);
719
720 efdp->efd_next_extent = count;
721 memcpy(efdp->efd_format.efd_extents, extp, count * sizeof(*extp));
722
723 efip = xfs_efi_init(mp: tp->t_mountp, item_type: intent->li_type, nextents: count);
724 memcpy(efip->efi_format.efi_extents, extp, count * sizeof(*extp));
725 atomic_set(v: &efip->efi_next_extent, i: count);
726
727 return &efip->efi_item;
728}
729
730const struct xfs_defer_op_type xfs_extent_free_defer_type = {
731 .name = "extent_free",
732 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
733 .create_intent = xfs_extent_free_create_intent,
734 .abort_intent = xfs_extent_free_abort_intent,
735 .create_done = xfs_extent_free_create_done,
736 .finish_item = xfs_extent_free_finish_item,
737 .cancel_item = xfs_extent_free_cancel_item,
738 .recover_work = xfs_extent_free_recover_work,
739 .relog_intent = xfs_extent_free_relog_intent,
740};
741
742/* sub-type with special handling for AGFL deferred frees */
743const struct xfs_defer_op_type xfs_agfl_free_defer_type = {
744 .name = "agfl_free",
745 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
746 .create_intent = xfs_extent_free_create_intent,
747 .abort_intent = xfs_extent_free_abort_intent,
748 .create_done = xfs_extent_free_create_done,
749 .finish_item = xfs_agfl_free_finish_item,
750 .cancel_item = xfs_extent_free_cancel_item,
751 .recover_work = xfs_extent_free_recover_work,
752 .relog_intent = xfs_extent_free_relog_intent,
753};
754
755#ifdef CONFIG_XFS_RT
756/* Create a realtime extent freeing */
757static struct xfs_log_item *
758xfs_rtextent_free_create_intent(
759 struct xfs_trans *tp,
760 struct list_head *items,
761 unsigned int count,
762 bool sort)
763{
764 return __xfs_extent_free_create_intent(tp, items, count, sort,
765 XFS_LI_EFI_RT);
766}
767
768/* Process a free realtime extent. */
769STATIC int
770xfs_rtextent_free_finish_item(
771 struct xfs_trans *tp,
772 struct xfs_log_item *done,
773 struct list_head *item,
774 struct xfs_btree_cur **state)
775{
776 struct xfs_mount *mp = tp->t_mountp;
777 struct xfs_extent_free_item *xefi = xefi_entry(e: item);
778 struct xfs_efd_log_item *efdp = EFD_ITEM(lip: done);
779 struct xfs_rtgroup **rtgp = (struct xfs_rtgroup **)state;
780 int error = 0;
781
782 trace_xfs_extent_free_deferred(mp, free: xefi);
783
784 if (xefi->xefi_flags & XFS_EFI_CANCELLED)
785 goto done;
786
787 if (*rtgp != to_rtg(xefi->xefi_group)) {
788 unsigned int lock_flags;
789
790 if (xfs_has_zoned(mp))
791 lock_flags = XFS_RTGLOCK_RMAP;
792 else
793 lock_flags = XFS_RTGLOCK_BITMAP;
794
795 *rtgp = to_rtg(xefi->xefi_group);
796 xfs_rtgroup_lock(*rtgp, lock_flags);
797 xfs_rtgroup_trans_join(tp, *rtgp, lock_flags);
798 }
799
800 if (xfs_has_zoned(mp)) {
801 error = xfs_zone_free_blocks(tp, *rtgp, xefi->xefi_startblock,
802 xefi->xefi_blockcount);
803 } else {
804 error = xfs_rtfree_blocks(tp, *rtgp, xefi->xefi_startblock,
805 xefi->xefi_blockcount);
806 }
807
808 if (error == -EAGAIN) {
809 xfs_efd_from_efi(efdp);
810 return error;
811 }
812done:
813 xfs_efd_add_extent(efdp, xefi);
814 xfs_extent_free_cancel_item(item);
815 return error;
816}
817
818const struct xfs_defer_op_type xfs_rtextent_free_defer_type = {
819 .name = "rtextent_free",
820 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
821 .create_intent = xfs_rtextent_free_create_intent,
822 .abort_intent = xfs_extent_free_abort_intent,
823 .create_done = xfs_extent_free_create_done,
824 .finish_item = xfs_rtextent_free_finish_item,
825 .cancel_item = xfs_extent_free_cancel_item,
826 .recover_work = xfs_extent_free_recover_work,
827 .relog_intent = xfs_extent_free_relog_intent,
828};
829#else
830const struct xfs_defer_op_type xfs_rtextent_free_defer_type = {
831 .name = "rtextent_free",
832};
833#endif /* CONFIG_XFS_RT */
834
835STATIC bool
836xfs_efi_item_match(
837 struct xfs_log_item *lip,
838 uint64_t intent_id)
839{
840 return EFI_ITEM(lip)->efi_format.efi_id == intent_id;
841}
842
843static const struct xfs_item_ops xfs_efi_item_ops = {
844 .flags = XFS_ITEM_INTENT,
845 .iop_size = xfs_efi_item_size,
846 .iop_format = xfs_efi_item_format,
847 .iop_unpin = xfs_efi_item_unpin,
848 .iop_release = xfs_efi_item_release,
849 .iop_match = xfs_efi_item_match,
850};
851
852/*
853 * This routine is called to create an in-core extent free intent
854 * item from the efi format structure which was logged on disk.
855 * It allocates an in-core efi, copies the extents from the format
856 * structure into it, and adds the efi to the AIL with the given
857 * LSN.
858 */
859STATIC int
860xlog_recover_efi_commit_pass2(
861 struct xlog *log,
862 struct list_head *buffer_list,
863 struct xlog_recover_item *item,
864 xfs_lsn_t lsn)
865{
866 struct xfs_mount *mp = log->l_mp;
867 struct xfs_efi_log_item *efip;
868 struct xfs_efi_log_format *efi_formatp;
869 int error;
870
871 efi_formatp = item->ri_buf[0].iov_base;
872
873 if (item->ri_buf[0].iov_len < xfs_efi_log_format_sizeof(0)) {
874 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
875 item->ri_buf[0].iov_base, item->ri_buf[0].iov_len);
876 return -EFSCORRUPTED;
877 }
878
879 efip = xfs_efi_init(mp, item_type: ITEM_TYPE(item), nextents: efi_formatp->efi_nextents);
880 error = xfs_efi_copy_format(buf: &item->ri_buf[0], dst_efi_fmt: &efip->efi_format);
881 if (error) {
882 xfs_efi_item_free(efip);
883 return error;
884 }
885 atomic_set(v: &efip->efi_next_extent, i: efi_formatp->efi_nextents);
886
887 xlog_recover_intent_item(log, &efip->efi_item, lsn,
888 &xfs_extent_free_defer_type);
889 return 0;
890}
891
892const struct xlog_recover_item_ops xlog_efi_item_ops = {
893 .item_type = XFS_LI_EFI,
894 .commit_pass2 = xlog_recover_efi_commit_pass2,
895};
896
897#ifdef CONFIG_XFS_RT
898STATIC int
899xlog_recover_rtefi_commit_pass2(
900 struct xlog *log,
901 struct list_head *buffer_list,
902 struct xlog_recover_item *item,
903 xfs_lsn_t lsn)
904{
905 struct xfs_mount *mp = log->l_mp;
906 struct xfs_efi_log_item *efip;
907 struct xfs_efi_log_format *efi_formatp;
908 int error;
909
910 efi_formatp = item->ri_buf[0].iov_base;
911
912 if (item->ri_buf[0].iov_len < xfs_efi_log_format_sizeof(0)) {
913 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
914 item->ri_buf[0].iov_base, item->ri_buf[0].iov_len);
915 return -EFSCORRUPTED;
916 }
917
918 efip = xfs_efi_init(mp, item_type: ITEM_TYPE(item), nextents: efi_formatp->efi_nextents);
919 error = xfs_efi_copy_format(buf: &item->ri_buf[0], dst_efi_fmt: &efip->efi_format);
920 if (error) {
921 xfs_efi_item_free(efip);
922 return error;
923 }
924 atomic_set(v: &efip->efi_next_extent, i: efi_formatp->efi_nextents);
925
926 xlog_recover_intent_item(log, &efip->efi_item, lsn,
927 &xfs_rtextent_free_defer_type);
928 return 0;
929}
930#else
931STATIC int
932xlog_recover_rtefi_commit_pass2(
933 struct xlog *log,
934 struct list_head *buffer_list,
935 struct xlog_recover_item *item,
936 xfs_lsn_t lsn)
937{
938 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
939 item->ri_buf[0].iov_base, item->ri_buf[0].iov_len);
940 return -EFSCORRUPTED;
941}
942#endif
943
944const struct xlog_recover_item_ops xlog_rtefi_item_ops = {
945 .item_type = XFS_LI_EFI_RT,
946 .commit_pass2 = xlog_recover_rtefi_commit_pass2,
947};
948
949/*
950 * This routine is called when an EFD format structure is found in a committed
951 * transaction in the log. Its purpose is to cancel the corresponding EFI if it
952 * was still in the log. To do this it searches the AIL for the EFI with an id
953 * equal to that in the EFD format structure. If we find it we drop the EFD
954 * reference, which removes the EFI from the AIL and frees it.
955 */
956STATIC int
957xlog_recover_efd_commit_pass2(
958 struct xlog *log,
959 struct list_head *buffer_list,
960 struct xlog_recover_item *item,
961 xfs_lsn_t lsn)
962{
963 struct xfs_efd_log_format *efd_formatp;
964 int buflen = item->ri_buf[0].iov_len;
965
966 efd_formatp = item->ri_buf[0].iov_base;
967
968 if (buflen < sizeof(struct xfs_efd_log_format)) {
969 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
970 efd_formatp, buflen);
971 return -EFSCORRUPTED;
972 }
973
974 if (item->ri_buf[0].iov_len != xfs_efd_log_format32_sizeof(
975 efd_formatp->efd_nextents) &&
976 item->ri_buf[0].iov_len != xfs_efd_log_format64_sizeof(
977 efd_formatp->efd_nextents)) {
978 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
979 efd_formatp, buflen);
980 return -EFSCORRUPTED;
981 }
982
983 xlog_recover_release_intent(log, XFS_LI_EFI, efd_formatp->efd_efi_id);
984 return 0;
985}
986
987const struct xlog_recover_item_ops xlog_efd_item_ops = {
988 .item_type = XFS_LI_EFD,
989 .commit_pass2 = xlog_recover_efd_commit_pass2,
990};
991
992#ifdef CONFIG_XFS_RT
993STATIC int
994xlog_recover_rtefd_commit_pass2(
995 struct xlog *log,
996 struct list_head *buffer_list,
997 struct xlog_recover_item *item,
998 xfs_lsn_t lsn)
999{
1000 struct xfs_efd_log_format *efd_formatp;
1001 int buflen = item->ri_buf[0].iov_len;
1002
1003 efd_formatp = item->ri_buf[0].iov_base;
1004
1005 if (buflen < sizeof(struct xfs_efd_log_format)) {
1006 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
1007 efd_formatp, buflen);
1008 return -EFSCORRUPTED;
1009 }
1010
1011 if (item->ri_buf[0].iov_len != xfs_efd_log_format32_sizeof(
1012 efd_formatp->efd_nextents) &&
1013 item->ri_buf[0].iov_len != xfs_efd_log_format64_sizeof(
1014 efd_formatp->efd_nextents)) {
1015 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
1016 efd_formatp, buflen);
1017 return -EFSCORRUPTED;
1018 }
1019
1020 xlog_recover_release_intent(log, XFS_LI_EFI_RT,
1021 efd_formatp->efd_efi_id);
1022 return 0;
1023}
1024#else
1025# define xlog_recover_rtefd_commit_pass2 xlog_recover_rtefi_commit_pass2
1026#endif
1027
1028const struct xlog_recover_item_ops xlog_rtefd_item_ops = {
1029 .item_type = XFS_LI_EFD_RT,
1030 .commit_pass2 = xlog_recover_rtefd_commit_pass2,
1031};
1032

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