1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
8 #include "xfs_format.h"
9 #include "xfs_log_format.h"
10 #include "xfs_trans_resv.h"
12 #include "xfs_shared.h"
13 #include "xfs_mount.h"
15 #include "xfs_defer.h"
16 #include "xfs_trans.h"
17 #include "xfs_trans_priv.h"
18 #include "xfs_extfree_item.h"
20 #include "xfs_btree.h"
22 #include "xfs_alloc.h"
24 #include "xfs_trace.h"
25 #include "xfs_error.h"
26 #include "xfs_log_priv.h"
27 #include "xfs_log_recover.h"
29 struct kmem_cache
*xfs_efi_cache
;
30 struct kmem_cache
*xfs_efd_cache
;
32 static const struct xfs_item_ops xfs_efi_item_ops
;
34 static inline struct xfs_efi_log_item
*EFI_ITEM(struct xfs_log_item
*lip
)
36 return container_of(lip
, struct xfs_efi_log_item
, efi_item
);
41 struct xfs_efi_log_item
*efip
)
43 kmem_free(efip
->efi_item
.li_lv_shadow
);
44 if (efip
->efi_format
.efi_nextents
> XFS_EFI_MAX_FAST_EXTENTS
)
47 kmem_cache_free(xfs_efi_cache
, efip
);
51 * Freeing the efi requires that we remove it from the AIL if it has already
52 * been placed there. However, the EFI may not yet have been placed in the AIL
53 * when called by xfs_efi_release() from EFD processing due to the ordering of
54 * committed vs unpin operations in bulk insert operations. Hence the reference
55 * count to ensure only the last caller frees the EFI.
59 struct xfs_efi_log_item
*efip
)
61 ASSERT(atomic_read(&efip
->efi_refcount
) > 0);
62 if (!atomic_dec_and_test(&efip
->efi_refcount
))
65 xfs_trans_ail_delete(&efip
->efi_item
, 0);
66 xfs_efi_item_free(efip
);
71 struct xfs_log_item
*lip
,
75 struct xfs_efi_log_item
*efip
= EFI_ITEM(lip
);
78 *nbytes
+= xfs_efi_log_format_sizeof(efip
->efi_format
.efi_nextents
);
82 * This is called to fill in the vector of log iovecs for the
83 * given efi log item. We use only 1 iovec, and we point that
84 * at the efi_log_format structure embedded in the efi item.
85 * It is at this point that we assert that all of the extent
86 * slots in the efi item have been filled.
90 struct xfs_log_item
*lip
,
91 struct xfs_log_vec
*lv
)
93 struct xfs_efi_log_item
*efip
= EFI_ITEM(lip
);
94 struct xfs_log_iovec
*vecp
= NULL
;
96 ASSERT(atomic_read(&efip
->efi_next_extent
) ==
97 efip
->efi_format
.efi_nextents
);
99 efip
->efi_format
.efi_type
= XFS_LI_EFI
;
100 efip
->efi_format
.efi_size
= 1;
102 xlog_copy_iovec(lv
, &vecp
, XLOG_REG_TYPE_EFI_FORMAT
,
104 xfs_efi_log_format_sizeof(efip
->efi_format
.efi_nextents
));
109 * The unpin operation is the last place an EFI is manipulated in the log. It is
110 * either inserted in the AIL or aborted in the event of a log I/O error. In
111 * either case, the EFI transaction has been successfully committed to make it
112 * this far. Therefore, we expect whoever committed the EFI to either construct
113 * and commit the EFD or drop the EFD's reference in the event of error. Simply
114 * drop the log's EFI reference now that the log is done with it.
118 struct xfs_log_item
*lip
,
121 struct xfs_efi_log_item
*efip
= EFI_ITEM(lip
);
122 xfs_efi_release(efip
);
126 * The EFI has been either committed or aborted if the transaction has been
127 * cancelled. If the transaction was cancelled, an EFD isn't going to be
128 * constructed and thus we free the EFI here directly.
131 xfs_efi_item_release(
132 struct xfs_log_item
*lip
)
134 xfs_efi_release(EFI_ITEM(lip
));
138 * Allocate and initialize an efi item with the given number of extents.
140 STATIC
struct xfs_efi_log_item
*
142 struct xfs_mount
*mp
,
146 struct xfs_efi_log_item
*efip
;
148 ASSERT(nextents
> 0);
149 if (nextents
> XFS_EFI_MAX_FAST_EXTENTS
) {
150 efip
= kzalloc(xfs_efi_log_item_sizeof(nextents
),
151 GFP_KERNEL
| __GFP_NOFAIL
);
153 efip
= kmem_cache_zalloc(xfs_efi_cache
,
154 GFP_KERNEL
| __GFP_NOFAIL
);
157 xfs_log_item_init(mp
, &efip
->efi_item
, XFS_LI_EFI
, &xfs_efi_item_ops
);
158 efip
->efi_format
.efi_nextents
= nextents
;
159 efip
->efi_format
.efi_id
= (uintptr_t)(void *)efip
;
160 atomic_set(&efip
->efi_next_extent
, 0);
161 atomic_set(&efip
->efi_refcount
, 2);
167 * Copy an EFI format buffer from the given buf, and into the destination
168 * EFI format structure.
169 * The given buffer can be in 32 bit or 64 bit form (which has different padding),
170 * one of which will be the native format for this kernel.
171 * It will handle the conversion of formats if necessary.
174 xfs_efi_copy_format(xfs_log_iovec_t
*buf
, xfs_efi_log_format_t
*dst_efi_fmt
)
176 xfs_efi_log_format_t
*src_efi_fmt
= buf
->i_addr
;
178 uint len
= xfs_efi_log_format_sizeof(src_efi_fmt
->efi_nextents
);
179 uint len32
= xfs_efi_log_format32_sizeof(src_efi_fmt
->efi_nextents
);
180 uint len64
= xfs_efi_log_format64_sizeof(src_efi_fmt
->efi_nextents
);
182 if (buf
->i_len
== len
) {
183 memcpy(dst_efi_fmt
, src_efi_fmt
,
184 offsetof(struct xfs_efi_log_format
, efi_extents
));
185 for (i
= 0; i
< src_efi_fmt
->efi_nextents
; i
++)
186 memcpy(&dst_efi_fmt
->efi_extents
[i
],
187 &src_efi_fmt
->efi_extents
[i
],
188 sizeof(struct xfs_extent
));
190 } else if (buf
->i_len
== len32
) {
191 xfs_efi_log_format_32_t
*src_efi_fmt_32
= buf
->i_addr
;
193 dst_efi_fmt
->efi_type
= src_efi_fmt_32
->efi_type
;
194 dst_efi_fmt
->efi_size
= src_efi_fmt_32
->efi_size
;
195 dst_efi_fmt
->efi_nextents
= src_efi_fmt_32
->efi_nextents
;
196 dst_efi_fmt
->efi_id
= src_efi_fmt_32
->efi_id
;
197 for (i
= 0; i
< dst_efi_fmt
->efi_nextents
; i
++) {
198 dst_efi_fmt
->efi_extents
[i
].ext_start
=
199 src_efi_fmt_32
->efi_extents
[i
].ext_start
;
200 dst_efi_fmt
->efi_extents
[i
].ext_len
=
201 src_efi_fmt_32
->efi_extents
[i
].ext_len
;
204 } else if (buf
->i_len
== len64
) {
205 xfs_efi_log_format_64_t
*src_efi_fmt_64
= buf
->i_addr
;
207 dst_efi_fmt
->efi_type
= src_efi_fmt_64
->efi_type
;
208 dst_efi_fmt
->efi_size
= src_efi_fmt_64
->efi_size
;
209 dst_efi_fmt
->efi_nextents
= src_efi_fmt_64
->efi_nextents
;
210 dst_efi_fmt
->efi_id
= src_efi_fmt_64
->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_64
->efi_extents
[i
].ext_start
;
214 dst_efi_fmt
->efi_extents
[i
].ext_len
=
215 src_efi_fmt_64
->efi_extents
[i
].ext_len
;
219 XFS_CORRUPTION_ERROR(__func__
, XFS_ERRLEVEL_LOW
, NULL
, buf
->i_addr
,
221 return -EFSCORRUPTED
;
224 static inline struct xfs_efd_log_item
*EFD_ITEM(struct xfs_log_item
*lip
)
226 return container_of(lip
, struct xfs_efd_log_item
, efd_item
);
230 xfs_efd_item_free(struct xfs_efd_log_item
*efdp
)
232 kmem_free(efdp
->efd_item
.li_lv_shadow
);
233 if (efdp
->efd_format
.efd_nextents
> XFS_EFD_MAX_FAST_EXTENTS
)
236 kmem_cache_free(xfs_efd_cache
, efdp
);
241 struct xfs_log_item
*lip
,
245 struct xfs_efd_log_item
*efdp
= EFD_ITEM(lip
);
248 *nbytes
+= xfs_efd_log_format_sizeof(efdp
->efd_format
.efd_nextents
);
252 * This is called to fill in the vector of log iovecs for the
253 * given efd log item. We use only 1 iovec, and we point that
254 * at the efd_log_format structure embedded in the efd item.
255 * It is at this point that we assert that all of the extent
256 * slots in the efd item have been filled.
260 struct xfs_log_item
*lip
,
261 struct xfs_log_vec
*lv
)
263 struct xfs_efd_log_item
*efdp
= EFD_ITEM(lip
);
264 struct xfs_log_iovec
*vecp
= NULL
;
266 ASSERT(efdp
->efd_next_extent
== efdp
->efd_format
.efd_nextents
);
268 efdp
->efd_format
.efd_type
= XFS_LI_EFD
;
269 efdp
->efd_format
.efd_size
= 1;
271 xlog_copy_iovec(lv
, &vecp
, XLOG_REG_TYPE_EFD_FORMAT
,
273 xfs_efd_log_format_sizeof(efdp
->efd_format
.efd_nextents
));
277 * The EFD is either committed or aborted if the transaction is cancelled. If
278 * the transaction is cancelled, drop our reference to the EFI and free the EFD.
281 xfs_efd_item_release(
282 struct xfs_log_item
*lip
)
284 struct xfs_efd_log_item
*efdp
= EFD_ITEM(lip
);
286 xfs_efi_release(efdp
->efd_efip
);
287 xfs_efd_item_free(efdp
);
290 static struct xfs_log_item
*
292 struct xfs_log_item
*lip
)
294 return &EFD_ITEM(lip
)->efd_efip
->efi_item
;
297 static const struct xfs_item_ops xfs_efd_item_ops
= {
298 .flags
= XFS_ITEM_RELEASE_WHEN_COMMITTED
|
299 XFS_ITEM_INTENT_DONE
,
300 .iop_size
= xfs_efd_item_size
,
301 .iop_format
= xfs_efd_item_format
,
302 .iop_release
= xfs_efd_item_release
,
303 .iop_intent
= xfs_efd_item_intent
,
307 * Allocate an "extent free done" log item that will hold nextents worth of
308 * extents. The caller must use all nextents extents, because we are not
309 * flexible about this at all.
311 static struct xfs_efd_log_item
*
313 struct xfs_trans
*tp
,
314 struct xfs_efi_log_item
*efip
,
315 unsigned int nextents
)
317 struct xfs_efd_log_item
*efdp
;
319 ASSERT(nextents
> 0);
321 if (nextents
> XFS_EFD_MAX_FAST_EXTENTS
) {
322 efdp
= kzalloc(xfs_efd_log_item_sizeof(nextents
),
323 GFP_KERNEL
| __GFP_NOFAIL
);
325 efdp
= kmem_cache_zalloc(xfs_efd_cache
,
326 GFP_KERNEL
| __GFP_NOFAIL
);
329 xfs_log_item_init(tp
->t_mountp
, &efdp
->efd_item
, XFS_LI_EFD
,
331 efdp
->efd_efip
= efip
;
332 efdp
->efd_format
.efd_nextents
= nextents
;
333 efdp
->efd_format
.efd_efi_id
= efip
->efi_format
.efi_id
;
335 xfs_trans_add_item(tp
, &efdp
->efd_item
);
340 * Fill the EFD with all extents from the EFI when we need to roll the
341 * transaction and continue with a new EFI.
343 * This simply copies all the extents in the EFI to the EFD rather than make
344 * assumptions about which extents in the EFI have already been processed. We
345 * currently keep the xefi list in the same order as the EFI extent list, but
346 * that may not always be the case. Copying everything avoids leaving a landmine
347 * were we fail to cancel all the extents in an EFI if the xefi list is
348 * processed in a different order to the extents in the EFI.
352 struct xfs_efd_log_item
*efdp
)
354 struct xfs_efi_log_item
*efip
= efdp
->efd_efip
;
357 ASSERT(efip
->efi_format
.efi_nextents
> 0);
358 ASSERT(efdp
->efd_next_extent
< efip
->efi_format
.efi_nextents
);
360 for (i
= 0; i
< efip
->efi_format
.efi_nextents
; i
++) {
361 efdp
->efd_format
.efd_extents
[i
] =
362 efip
->efi_format
.efi_extents
[i
];
364 efdp
->efd_next_extent
= efip
->efi_format
.efi_nextents
;
368 * Free an extent and log it to the EFD. Note that the transaction is marked
369 * dirty regardless of whether the extent free succeeds or fails to support the
370 * EFI/EFD lifecycle rules.
373 xfs_trans_free_extent(
374 struct xfs_trans
*tp
,
375 struct xfs_efd_log_item
*efdp
,
376 struct xfs_extent_free_item
*xefi
)
378 struct xfs_owner_info oinfo
= { };
379 struct xfs_mount
*mp
= tp
->t_mountp
;
380 struct xfs_extent
*extp
;
382 xfs_agblock_t agbno
= XFS_FSB_TO_AGBNO(mp
,
383 xefi
->xefi_startblock
);
386 oinfo
.oi_owner
= xefi
->xefi_owner
;
387 if (xefi
->xefi_flags
& XFS_EFI_ATTR_FORK
)
388 oinfo
.oi_flags
|= XFS_OWNER_INFO_ATTR_FORK
;
389 if (xefi
->xefi_flags
& XFS_EFI_BMBT_BLOCK
)
390 oinfo
.oi_flags
|= XFS_OWNER_INFO_BMBT_BLOCK
;
392 trace_xfs_bmap_free_deferred(tp
->t_mountp
, xefi
->xefi_pag
->pag_agno
, 0,
393 agbno
, xefi
->xefi_blockcount
);
395 error
= __xfs_free_extent(tp
, xefi
->xefi_pag
, agbno
,
396 xefi
->xefi_blockcount
, &oinfo
, xefi
->xefi_agresv
,
397 xefi
->xefi_flags
& XFS_EFI_SKIP_DISCARD
);
400 * Mark the transaction dirty, even on error. This ensures the
401 * transaction is aborted, which:
403 * 1.) releases the EFI and frees the EFD
404 * 2.) shuts down the filesystem
406 tp
->t_flags
|= XFS_TRANS_DIRTY
| XFS_TRANS_HAS_INTENT_DONE
;
407 set_bit(XFS_LI_DIRTY
, &efdp
->efd_item
.li_flags
);
410 * If we need a new transaction to make progress, the caller will log a
411 * new EFI with the current contents. It will also log an EFD to cancel
412 * the existing EFI, and so we need to copy all the unprocessed extents
413 * in this EFI to the EFD so this works correctly.
415 if (error
== -EAGAIN
) {
416 xfs_efd_from_efi(efdp
);
420 next_extent
= efdp
->efd_next_extent
;
421 ASSERT(next_extent
< efdp
->efd_format
.efd_nextents
);
422 extp
= &(efdp
->efd_format
.efd_extents
[next_extent
]);
423 extp
->ext_start
= xefi
->xefi_startblock
;
424 extp
->ext_len
= xefi
->xefi_blockcount
;
425 efdp
->efd_next_extent
++;
430 /* Sort bmap items by AG. */
432 xfs_extent_free_diff_items(
434 const struct list_head
*a
,
435 const struct list_head
*b
)
437 struct xfs_extent_free_item
*ra
;
438 struct xfs_extent_free_item
*rb
;
440 ra
= container_of(a
, struct xfs_extent_free_item
, xefi_list
);
441 rb
= container_of(b
, struct xfs_extent_free_item
, xefi_list
);
443 return ra
->xefi_pag
->pag_agno
- rb
->xefi_pag
->pag_agno
;
446 /* Log a free extent to the intent item. */
448 xfs_extent_free_log_item(
449 struct xfs_trans
*tp
,
450 struct xfs_efi_log_item
*efip
,
451 struct xfs_extent_free_item
*xefi
)
454 struct xfs_extent
*extp
;
456 tp
->t_flags
|= XFS_TRANS_DIRTY
;
457 set_bit(XFS_LI_DIRTY
, &efip
->efi_item
.li_flags
);
460 * atomic_inc_return gives us the value after the increment;
461 * we want to use it as an array index so we need to subtract 1 from
464 next_extent
= atomic_inc_return(&efip
->efi_next_extent
) - 1;
465 ASSERT(next_extent
< efip
->efi_format
.efi_nextents
);
466 extp
= &efip
->efi_format
.efi_extents
[next_extent
];
467 extp
->ext_start
= xefi
->xefi_startblock
;
468 extp
->ext_len
= xefi
->xefi_blockcount
;
471 static struct xfs_log_item
*
472 xfs_extent_free_create_intent(
473 struct xfs_trans
*tp
,
474 struct list_head
*items
,
478 struct xfs_mount
*mp
= tp
->t_mountp
;
479 struct xfs_efi_log_item
*efip
= xfs_efi_init(mp
, count
);
480 struct xfs_extent_free_item
*xefi
;
484 xfs_trans_add_item(tp
, &efip
->efi_item
);
486 list_sort(mp
, items
, xfs_extent_free_diff_items
);
487 list_for_each_entry(xefi
, items
, xefi_list
)
488 xfs_extent_free_log_item(tp
, efip
, xefi
);
489 return &efip
->efi_item
;
492 /* Get an EFD so we can process all the free extents. */
493 static struct xfs_log_item
*
494 xfs_extent_free_create_done(
495 struct xfs_trans
*tp
,
496 struct xfs_log_item
*intent
,
499 return &xfs_trans_get_efd(tp
, EFI_ITEM(intent
), count
)->efd_item
;
502 /* Take a passive ref to the AG containing the space we're freeing. */
504 xfs_extent_free_get_group(
505 struct xfs_mount
*mp
,
506 struct xfs_extent_free_item
*xefi
)
510 agno
= XFS_FSB_TO_AGNO(mp
, xefi
->xefi_startblock
);
511 xefi
->xefi_pag
= xfs_perag_intent_get(mp
, agno
);
514 /* Release a passive AG ref after some freeing work. */
516 xfs_extent_free_put_group(
517 struct xfs_extent_free_item
*xefi
)
519 xfs_perag_intent_put(xefi
->xefi_pag
);
522 /* Process a free extent. */
524 xfs_extent_free_finish_item(
525 struct xfs_trans
*tp
,
526 struct xfs_log_item
*done
,
527 struct list_head
*item
,
528 struct xfs_btree_cur
**state
)
530 struct xfs_extent_free_item
*xefi
;
533 xefi
= container_of(item
, struct xfs_extent_free_item
, xefi_list
);
535 error
= xfs_trans_free_extent(tp
, EFD_ITEM(done
), xefi
);
538 * Don't free the XEFI if we need a new transaction to complete
541 if (error
== -EAGAIN
)
544 xfs_extent_free_put_group(xefi
);
545 kmem_cache_free(xfs_extfree_item_cache
, xefi
);
549 /* Abort all pending EFIs. */
551 xfs_extent_free_abort_intent(
552 struct xfs_log_item
*intent
)
554 xfs_efi_release(EFI_ITEM(intent
));
557 /* Cancel a free extent. */
559 xfs_extent_free_cancel_item(
560 struct list_head
*item
)
562 struct xfs_extent_free_item
*xefi
;
564 xefi
= container_of(item
, struct xfs_extent_free_item
, xefi_list
);
566 xfs_extent_free_put_group(xefi
);
567 kmem_cache_free(xfs_extfree_item_cache
, xefi
);
570 const struct xfs_defer_op_type xfs_extent_free_defer_type
= {
571 .max_items
= XFS_EFI_MAX_FAST_EXTENTS
,
572 .create_intent
= xfs_extent_free_create_intent
,
573 .abort_intent
= xfs_extent_free_abort_intent
,
574 .create_done
= xfs_extent_free_create_done
,
575 .finish_item
= xfs_extent_free_finish_item
,
576 .cancel_item
= xfs_extent_free_cancel_item
,
580 * AGFL blocks are accounted differently in the reserve pools and are not
581 * inserted into the busy extent list.
584 xfs_agfl_free_finish_item(
585 struct xfs_trans
*tp
,
586 struct xfs_log_item
*done
,
587 struct list_head
*item
,
588 struct xfs_btree_cur
**state
)
590 struct xfs_owner_info oinfo
= { };
591 struct xfs_mount
*mp
= tp
->t_mountp
;
592 struct xfs_efd_log_item
*efdp
= EFD_ITEM(done
);
593 struct xfs_extent_free_item
*xefi
;
594 struct xfs_extent
*extp
;
595 struct xfs_buf
*agbp
;
600 xefi
= container_of(item
, struct xfs_extent_free_item
, xefi_list
);
601 ASSERT(xefi
->xefi_blockcount
== 1);
602 agbno
= XFS_FSB_TO_AGBNO(mp
, xefi
->xefi_startblock
);
603 oinfo
.oi_owner
= xefi
->xefi_owner
;
605 trace_xfs_agfl_free_deferred(mp
, xefi
->xefi_pag
->pag_agno
, 0, agbno
,
606 xefi
->xefi_blockcount
);
608 error
= xfs_alloc_read_agf(xefi
->xefi_pag
, tp
, 0, &agbp
);
610 error
= xfs_free_agfl_block(tp
, xefi
->xefi_pag
->pag_agno
,
611 agbno
, agbp
, &oinfo
);
614 * Mark the transaction dirty, even on error. This ensures the
615 * transaction is aborted, which:
617 * 1.) releases the EFI and frees the EFD
618 * 2.) shuts down the filesystem
620 tp
->t_flags
|= XFS_TRANS_DIRTY
;
621 set_bit(XFS_LI_DIRTY
, &efdp
->efd_item
.li_flags
);
623 next_extent
= efdp
->efd_next_extent
;
624 ASSERT(next_extent
< efdp
->efd_format
.efd_nextents
);
625 extp
= &(efdp
->efd_format
.efd_extents
[next_extent
]);
626 extp
->ext_start
= xefi
->xefi_startblock
;
627 extp
->ext_len
= xefi
->xefi_blockcount
;
628 efdp
->efd_next_extent
++;
630 xfs_extent_free_put_group(xefi
);
631 kmem_cache_free(xfs_extfree_item_cache
, xefi
);
635 /* sub-type with special handling for AGFL deferred frees */
636 const struct xfs_defer_op_type xfs_agfl_free_defer_type
= {
637 .max_items
= XFS_EFI_MAX_FAST_EXTENTS
,
638 .create_intent
= xfs_extent_free_create_intent
,
639 .abort_intent
= xfs_extent_free_abort_intent
,
640 .create_done
= xfs_extent_free_create_done
,
641 .finish_item
= xfs_agfl_free_finish_item
,
642 .cancel_item
= xfs_extent_free_cancel_item
,
645 /* Is this recovered EFI ok? */
647 xfs_efi_validate_ext(
648 struct xfs_mount
*mp
,
649 struct xfs_extent
*extp
)
651 return xfs_verify_fsbext(mp
, extp
->ext_start
, extp
->ext_len
);
655 * Process an extent free intent item that was recovered from
656 * the log. We need to free the extents that it describes.
659 xfs_efi_item_recover(
660 struct xfs_log_item
*lip
,
661 struct list_head
*capture_list
)
663 struct xfs_efi_log_item
*efip
= EFI_ITEM(lip
);
664 struct xfs_mount
*mp
= lip
->li_log
->l_mp
;
665 struct xfs_efd_log_item
*efdp
;
666 struct xfs_trans
*tp
;
669 bool requeue_only
= false;
672 * First check the validity of the extents described by the
673 * EFI. If any are bad, then assume that all are bad and
676 for (i
= 0; i
< efip
->efi_format
.efi_nextents
; i
++) {
677 if (!xfs_efi_validate_ext(mp
,
678 &efip
->efi_format
.efi_extents
[i
])) {
679 XFS_CORRUPTION_ERROR(__func__
, XFS_ERRLEVEL_LOW
, mp
,
681 sizeof(efip
->efi_format
));
682 return -EFSCORRUPTED
;
686 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_itruncate
, 0, 0, 0, &tp
);
689 efdp
= xfs_trans_get_efd(tp
, efip
, efip
->efi_format
.efi_nextents
);
691 for (i
= 0; i
< efip
->efi_format
.efi_nextents
; i
++) {
692 struct xfs_extent_free_item fake
= {
693 .xefi_owner
= XFS_RMAP_OWN_UNKNOWN
,
694 .xefi_agresv
= XFS_AG_RESV_NONE
,
696 struct xfs_extent
*extp
;
698 extp
= &efip
->efi_format
.efi_extents
[i
];
700 fake
.xefi_startblock
= extp
->ext_start
;
701 fake
.xefi_blockcount
= extp
->ext_len
;
704 xfs_extent_free_get_group(mp
, &fake
);
705 error
= xfs_trans_free_extent(tp
, efdp
, &fake
);
706 xfs_extent_free_put_group(&fake
);
710 * If we can't free the extent without potentially deadlocking,
711 * requeue the rest of the extents to a new so that they get
712 * run again later with a new transaction context.
714 if (error
== -EAGAIN
|| requeue_only
) {
715 error
= xfs_free_extent_later(tp
, fake
.xefi_startblock
,
716 fake
.xefi_blockcount
,
717 &XFS_RMAP_OINFO_ANY_OWNER
,
725 if (error
== -EFSCORRUPTED
)
726 XFS_CORRUPTION_ERROR(__func__
, XFS_ERRLEVEL_LOW
, mp
,
727 extp
, sizeof(*extp
));
733 return xfs_defer_ops_capture_and_commit(tp
, capture_list
);
736 xfs_trans_cancel(tp
);
742 struct xfs_log_item
*lip
,
745 return EFI_ITEM(lip
)->efi_format
.efi_id
== intent_id
;
748 /* Relog an intent item to push the log tail forward. */
749 static struct xfs_log_item
*
751 struct xfs_log_item
*intent
,
752 struct xfs_trans
*tp
)
754 struct xfs_efd_log_item
*efdp
;
755 struct xfs_efi_log_item
*efip
;
756 struct xfs_extent
*extp
;
759 count
= EFI_ITEM(intent
)->efi_format
.efi_nextents
;
760 extp
= EFI_ITEM(intent
)->efi_format
.efi_extents
;
762 tp
->t_flags
|= XFS_TRANS_DIRTY
;
763 efdp
= xfs_trans_get_efd(tp
, EFI_ITEM(intent
), count
);
764 efdp
->efd_next_extent
= count
;
765 memcpy(efdp
->efd_format
.efd_extents
, extp
, count
* sizeof(*extp
));
766 set_bit(XFS_LI_DIRTY
, &efdp
->efd_item
.li_flags
);
768 efip
= xfs_efi_init(tp
->t_mountp
, count
);
769 memcpy(efip
->efi_format
.efi_extents
, extp
, count
* sizeof(*extp
));
770 atomic_set(&efip
->efi_next_extent
, count
);
771 xfs_trans_add_item(tp
, &efip
->efi_item
);
772 set_bit(XFS_LI_DIRTY
, &efip
->efi_item
.li_flags
);
773 return &efip
->efi_item
;
776 static const struct xfs_item_ops xfs_efi_item_ops
= {
777 .flags
= XFS_ITEM_INTENT
,
778 .iop_size
= xfs_efi_item_size
,
779 .iop_format
= xfs_efi_item_format
,
780 .iop_unpin
= xfs_efi_item_unpin
,
781 .iop_release
= xfs_efi_item_release
,
782 .iop_recover
= xfs_efi_item_recover
,
783 .iop_match
= xfs_efi_item_match
,
784 .iop_relog
= xfs_efi_item_relog
,
788 * This routine is called to create an in-core extent free intent
789 * item from the efi format structure which was logged on disk.
790 * It allocates an in-core efi, copies the extents from the format
791 * structure into it, and adds the efi to the AIL with the given
795 xlog_recover_efi_commit_pass2(
797 struct list_head
*buffer_list
,
798 struct xlog_recover_item
*item
,
801 struct xfs_mount
*mp
= log
->l_mp
;
802 struct xfs_efi_log_item
*efip
;
803 struct xfs_efi_log_format
*efi_formatp
;
806 efi_formatp
= item
->ri_buf
[0].i_addr
;
808 if (item
->ri_buf
[0].i_len
< xfs_efi_log_format_sizeof(0)) {
809 XFS_CORRUPTION_ERROR(__func__
, XFS_ERRLEVEL_LOW
, mp
,
810 item
->ri_buf
[0].i_addr
, item
->ri_buf
[0].i_len
);
811 return -EFSCORRUPTED
;
814 efip
= xfs_efi_init(mp
, efi_formatp
->efi_nextents
);
815 error
= xfs_efi_copy_format(&item
->ri_buf
[0], &efip
->efi_format
);
817 xfs_efi_item_free(efip
);
820 atomic_set(&efip
->efi_next_extent
, efi_formatp
->efi_nextents
);
822 * Insert the intent into the AIL directly and drop one reference so
823 * that finishing or canceling the work will drop the other.
825 xfs_trans_ail_insert(log
->l_ailp
, &efip
->efi_item
, lsn
);
826 xfs_efi_release(efip
);
830 const struct xlog_recover_item_ops xlog_efi_item_ops
= {
831 .item_type
= XFS_LI_EFI
,
832 .commit_pass2
= xlog_recover_efi_commit_pass2
,
836 * This routine is called when an EFD format structure is found in a committed
837 * transaction in the log. Its purpose is to cancel the corresponding EFI if it
838 * was still in the log. To do this it searches the AIL for the EFI with an id
839 * equal to that in the EFD format structure. If we find it we drop the EFD
840 * reference, which removes the EFI from the AIL and frees it.
843 xlog_recover_efd_commit_pass2(
845 struct list_head
*buffer_list
,
846 struct xlog_recover_item
*item
,
849 struct xfs_efd_log_format
*efd_formatp
;
850 int buflen
= item
->ri_buf
[0].i_len
;
852 efd_formatp
= item
->ri_buf
[0].i_addr
;
854 if (buflen
< sizeof(struct xfs_efd_log_format
)) {
855 XFS_CORRUPTION_ERROR(__func__
, XFS_ERRLEVEL_LOW
, log
->l_mp
,
856 efd_formatp
, buflen
);
857 return -EFSCORRUPTED
;
860 if (item
->ri_buf
[0].i_len
!= xfs_efd_log_format32_sizeof(
861 efd_formatp
->efd_nextents
) &&
862 item
->ri_buf
[0].i_len
!= xfs_efd_log_format64_sizeof(
863 efd_formatp
->efd_nextents
)) {
864 XFS_CORRUPTION_ERROR(__func__
, XFS_ERRLEVEL_LOW
, log
->l_mp
,
865 efd_formatp
, buflen
);
866 return -EFSCORRUPTED
;
869 xlog_recover_release_intent(log
, XFS_LI_EFI
, efd_formatp
->efd_efi_id
);
873 const struct xlog_recover_item_ops xlog_efd_item_ops
= {
874 .item_type
= XFS_LI_EFD
,
875 .commit_pass2
= xlog_recover_efd_commit_pass2
,