2 * Copyright (c) 2000,2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "xfs_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
25 #include "xfs_defer.h"
26 #include "xfs_trans.h"
27 #include "xfs_trans_priv.h"
28 #include "xfs_extfree_item.h"
29 #include "xfs_alloc.h"
33 * This routine is called to allocate an "extent free intention"
34 * log item that will hold nextents worth of extents. The
35 * caller must use all nextents extents, because we are not
36 * flexible about this at all.
38 STATIC struct xfs_efi_log_item *
39 xfs_trans_get_efi(struct xfs_trans *tp,
42 struct xfs_efi_log_item *efip;
47 efip = xfs_efi_init(tp->t_mountp, nextents);
51 * Get a log_item_desc to point at the new item.
53 xfs_trans_add_item(tp, &efip->efi_item);
58 * This routine is called to indicate that the described
59 * extent is to be logged as needing to be freed. It should
60 * be called once for each extent to be freed.
63 xfs_trans_log_efi_extent(struct xfs_trans *tp,
64 struct xfs_efi_log_item *efip,
65 xfs_fsblock_t start_block,
69 struct xfs_extent *extp;
71 tp->t_flags |= XFS_TRANS_DIRTY;
72 efip->efi_item.li_desc->lid_flags |= XFS_LID_DIRTY;
75 * atomic_inc_return gives us the value after the increment;
76 * we want to use it as an array index so we need to subtract 1 from
79 next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
80 ASSERT(next_extent < efip->efi_format.efi_nextents);
81 extp = &(efip->efi_format.efi_extents[next_extent]);
82 extp->ext_start = start_block;
83 extp->ext_len = ext_len;
88 * This routine is called to allocate an "extent free done"
89 * log item that will hold nextents worth of extents. The
90 * caller must use all nextents extents, because we are not
91 * flexible about this at all.
93 struct xfs_efd_log_item *
94 xfs_trans_get_efd(struct xfs_trans *tp,
95 struct xfs_efi_log_item *efip,
98 struct xfs_efd_log_item *efdp;
101 ASSERT(nextents > 0);
103 efdp = xfs_efd_init(tp->t_mountp, efip, nextents);
104 ASSERT(efdp != NULL);
107 * Get a log_item_desc to point at the new item.
109 xfs_trans_add_item(tp, &efdp->efd_item);
114 * Free an extent and log it to the EFD. Note that the transaction is marked
115 * dirty regardless of whether the extent free succeeds or fails to support the
116 * EFI/EFD lifecycle rules.
119 xfs_trans_free_extent(
120 struct xfs_trans *tp,
121 struct xfs_efd_log_item *efdp,
122 xfs_fsblock_t start_block,
123 xfs_extlen_t ext_len)
126 struct xfs_extent *extp;
129 error = xfs_free_extent(tp, start_block, ext_len);
132 * Mark the transaction dirty, even on error. This ensures the
133 * transaction is aborted, which:
135 * 1.) releases the EFI and frees the EFD
136 * 2.) shuts down the filesystem
138 tp->t_flags |= XFS_TRANS_DIRTY;
139 efdp->efd_item.li_desc->lid_flags |= XFS_LID_DIRTY;
141 next_extent = efdp->efd_next_extent;
142 ASSERT(next_extent < efdp->efd_format.efd_nextents);
143 extp = &(efdp->efd_format.efd_extents[next_extent]);
144 extp->ext_start = start_block;
145 extp->ext_len = ext_len;
146 efdp->efd_next_extent++;
151 /* Sort bmap items by AG. */
153 xfs_extent_free_diff_items(
158 struct xfs_mount *mp = priv;
159 struct xfs_extent_free_item *ra;
160 struct xfs_extent_free_item *rb;
162 ra = container_of(a, struct xfs_extent_free_item, xefi_list);
163 rb = container_of(b, struct xfs_extent_free_item, xefi_list);
164 return XFS_FSB_TO_AGNO(mp, ra->xefi_startblock) -
165 XFS_FSB_TO_AGNO(mp, rb->xefi_startblock);
170 xfs_extent_free_create_intent(
171 struct xfs_trans *tp,
174 return xfs_trans_get_efi(tp, count);
177 /* Log a free extent to the intent item. */
179 xfs_extent_free_log_item(
180 struct xfs_trans *tp,
182 struct list_head *item)
184 struct xfs_extent_free_item *free;
186 free = container_of(item, struct xfs_extent_free_item, xefi_list);
187 xfs_trans_log_efi_extent(tp, intent, free->xefi_startblock,
188 free->xefi_blockcount);
191 /* Get an EFD so we can process all the free extents. */
193 xfs_extent_free_create_done(
194 struct xfs_trans *tp,
198 return xfs_trans_get_efd(tp, intent, count);
201 /* Process a free extent. */
203 xfs_extent_free_finish_item(
204 struct xfs_trans *tp,
205 struct xfs_defer_ops *dop,
206 struct list_head *item,
210 struct xfs_extent_free_item *free;
213 free = container_of(item, struct xfs_extent_free_item, xefi_list);
214 error = xfs_trans_free_extent(tp, done_item,
215 free->xefi_startblock,
216 free->xefi_blockcount);
221 /* Abort all pending EFIs. */
223 xfs_extent_free_abort_intent(
226 xfs_efi_release(intent);
229 /* Cancel a free extent. */
231 xfs_extent_free_cancel_item(
232 struct list_head *item)
234 struct xfs_extent_free_item *free;
236 free = container_of(item, struct xfs_extent_free_item, xefi_list);
240 static const struct xfs_defer_op_type xfs_extent_free_defer_type = {
241 .type = XFS_DEFER_OPS_TYPE_FREE,
242 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
243 .diff_items = xfs_extent_free_diff_items,
244 .create_intent = xfs_extent_free_create_intent,
245 .abort_intent = xfs_extent_free_abort_intent,
246 .log_item = xfs_extent_free_log_item,
247 .create_done = xfs_extent_free_create_done,
248 .finish_item = xfs_extent_free_finish_item,
249 .cancel_item = xfs_extent_free_cancel_item,
252 /* Register the deferred op type. */
254 xfs_extent_free_init_defer_op(void)
256 xfs_defer_init_op_type(&xfs_extent_free_defer_type);