1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000,2005 Silicon Graphics, Inc.
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.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_extfree_item.h"
18 #include "xfs_alloc.h"
20 #include "xfs_trace.h"
21 #include "xfs_defer.h"
24 * This routine is called to allocate an "extent free done"
25 * log item that will hold nextents worth of extents. The
26 * caller must use all nextents extents, because we are not
27 * flexible about this at all.
29 struct xfs_efd_log_item *
30 xfs_trans_get_efd(struct xfs_trans *tp,
31 struct xfs_efi_log_item *efip,
34 struct xfs_efd_log_item *efdp;
39 efdp = xfs_efd_init(tp->t_mountp, efip, nextents);
43 * Get a log_item_desc to point at the new item.
45 xfs_trans_add_item(tp, &efdp->efd_item);
50 * Free an extent and log it to the EFD. Note that the transaction is marked
51 * dirty regardless of whether the extent free succeeds or fails to support the
52 * EFI/EFD lifecycle rules.
55 xfs_trans_free_extent(
57 struct xfs_efd_log_item *efdp,
58 xfs_fsblock_t start_block,
60 const struct xfs_owner_info *oinfo,
63 struct xfs_mount *mp = tp->t_mountp;
64 struct xfs_extent *extp;
66 xfs_agnumber_t agno = XFS_FSB_TO_AGNO(mp, start_block);
67 xfs_agblock_t agbno = XFS_FSB_TO_AGBNO(mp,
71 trace_xfs_bmap_free_deferred(tp->t_mountp, agno, 0, agbno, ext_len);
73 error = __xfs_free_extent(tp, start_block, ext_len,
74 oinfo, XFS_AG_RESV_NONE, skip_discard);
76 * Mark the transaction dirty, even on error. This ensures the
77 * transaction is aborted, which:
79 * 1.) releases the EFI and frees the EFD
80 * 2.) shuts down the filesystem
82 tp->t_flags |= XFS_TRANS_DIRTY;
83 set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
85 next_extent = efdp->efd_next_extent;
86 ASSERT(next_extent < efdp->efd_format.efd_nextents);
87 extp = &(efdp->efd_format.efd_extents[next_extent]);
88 extp->ext_start = start_block;
89 extp->ext_len = ext_len;
90 efdp->efd_next_extent++;
95 /* Sort bmap items by AG. */
97 xfs_extent_free_diff_items(
102 struct xfs_mount *mp = priv;
103 struct xfs_extent_free_item *ra;
104 struct xfs_extent_free_item *rb;
106 ra = container_of(a, struct xfs_extent_free_item, xefi_list);
107 rb = container_of(b, struct xfs_extent_free_item, xefi_list);
108 return XFS_FSB_TO_AGNO(mp, ra->xefi_startblock) -
109 XFS_FSB_TO_AGNO(mp, rb->xefi_startblock);
114 xfs_extent_free_create_intent(
115 struct xfs_trans *tp,
118 struct xfs_efi_log_item *efip;
123 efip = xfs_efi_init(tp->t_mountp, count);
124 ASSERT(efip != NULL);
127 * Get a log_item_desc to point at the new item.
129 xfs_trans_add_item(tp, &efip->efi_item);
133 /* Log a free extent to the intent item. */
135 xfs_extent_free_log_item(
136 struct xfs_trans *tp,
138 struct list_head *item)
140 struct xfs_efi_log_item *efip = intent;
141 struct xfs_extent_free_item *free;
143 struct xfs_extent *extp;
145 free = container_of(item, struct xfs_extent_free_item, xefi_list);
147 tp->t_flags |= XFS_TRANS_DIRTY;
148 set_bit(XFS_LI_DIRTY, &efip->efi_item.li_flags);
151 * atomic_inc_return gives us the value after the increment;
152 * we want to use it as an array index so we need to subtract 1 from
155 next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
156 ASSERT(next_extent < efip->efi_format.efi_nextents);
157 extp = &efip->efi_format.efi_extents[next_extent];
158 extp->ext_start = free->xefi_startblock;
159 extp->ext_len = free->xefi_blockcount;
162 /* Get an EFD so we can process all the free extents. */
164 xfs_extent_free_create_done(
165 struct xfs_trans *tp,
169 return xfs_trans_get_efd(tp, intent, count);
172 /* Process a free extent. */
174 xfs_extent_free_finish_item(
175 struct xfs_trans *tp,
176 struct list_head *item,
180 struct xfs_extent_free_item *free;
183 free = container_of(item, struct xfs_extent_free_item, xefi_list);
184 error = xfs_trans_free_extent(tp, done_item,
185 free->xefi_startblock,
186 free->xefi_blockcount,
187 &free->xefi_oinfo, free->xefi_skip_discard);
192 /* Abort all pending EFIs. */
194 xfs_extent_free_abort_intent(
197 xfs_efi_release(intent);
200 /* Cancel a free extent. */
202 xfs_extent_free_cancel_item(
203 struct list_head *item)
205 struct xfs_extent_free_item *free;
207 free = container_of(item, struct xfs_extent_free_item, xefi_list);
211 const struct xfs_defer_op_type xfs_extent_free_defer_type = {
212 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
213 .diff_items = xfs_extent_free_diff_items,
214 .create_intent = xfs_extent_free_create_intent,
215 .abort_intent = xfs_extent_free_abort_intent,
216 .log_item = xfs_extent_free_log_item,
217 .create_done = xfs_extent_free_create_done,
218 .finish_item = xfs_extent_free_finish_item,
219 .cancel_item = xfs_extent_free_cancel_item,
223 * AGFL blocks are accounted differently in the reserve pools and are not
224 * inserted into the busy extent list.
227 xfs_agfl_free_finish_item(
228 struct xfs_trans *tp,
229 struct list_head *item,
233 struct xfs_mount *mp = tp->t_mountp;
234 struct xfs_efd_log_item *efdp = done_item;
235 struct xfs_extent_free_item *free;
236 struct xfs_extent *extp;
237 struct xfs_buf *agbp;
243 free = container_of(item, struct xfs_extent_free_item, xefi_list);
244 ASSERT(free->xefi_blockcount == 1);
245 agno = XFS_FSB_TO_AGNO(mp, free->xefi_startblock);
246 agbno = XFS_FSB_TO_AGBNO(mp, free->xefi_startblock);
248 trace_xfs_agfl_free_deferred(mp, agno, 0, agbno, free->xefi_blockcount);
250 error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
252 error = xfs_free_agfl_block(tp, agno, agbno, agbp,
256 * Mark the transaction dirty, even on error. This ensures the
257 * transaction is aborted, which:
259 * 1.) releases the EFI and frees the EFD
260 * 2.) shuts down the filesystem
262 tp->t_flags |= XFS_TRANS_DIRTY;
263 set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
265 next_extent = efdp->efd_next_extent;
266 ASSERT(next_extent < efdp->efd_format.efd_nextents);
267 extp = &(efdp->efd_format.efd_extents[next_extent]);
268 extp->ext_start = free->xefi_startblock;
269 extp->ext_len = free->xefi_blockcount;
270 efdp->efd_next_extent++;
277 /* sub-type with special handling for AGFL deferred frees */
278 const struct xfs_defer_op_type xfs_agfl_free_defer_type = {
279 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
280 .diff_items = xfs_extent_free_diff_items,
281 .create_intent = xfs_extent_free_create_intent,
282 .abort_intent = xfs_extent_free_abort_intent,
283 .log_item = xfs_extent_free_log_item,
284 .create_done = xfs_extent_free_create_done,
285 .finish_item = xfs_agfl_free_finish_item,
286 .cancel_item = xfs_extent_free_cancel_item,