1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000,2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_bit.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"
19 #include "xfs_bmap.h"
20 #include "xfs_trace.h"
21
22 /*
23 * This routine is called to allocate an "extent free done"
24 * log item that will hold nextents worth of extents. The
25 * caller must use all nextents extents, because we are not
26 * flexible about this at all.
27 */
28 struct xfs_efd_log_item *
xfs_trans_get_efd(struct xfs_trans * tp,struct xfs_efi_log_item * efip,uint nextents)29 xfs_trans_get_efd(struct xfs_trans *tp,
30 struct xfs_efi_log_item *efip,
31 uint nextents)
32 {
33 struct xfs_efd_log_item *efdp;
34
35 ASSERT(tp != NULL);
36 ASSERT(nextents > 0);
37
38 efdp = xfs_efd_init(tp->t_mountp, efip, nextents);
39 ASSERT(efdp != NULL);
40
41 /*
42 * Get a log_item_desc to point at the new item.
43 */
44 xfs_trans_add_item(tp, &efdp->efd_item);
45 return efdp;
46 }
47
48 /*
49 * Free an extent and log it to the EFD. Note that the transaction is marked
50 * dirty regardless of whether the extent free succeeds or fails to support the
51 * EFI/EFD lifecycle rules.
52 */
53 int
xfs_trans_free_extent(struct xfs_trans * tp,struct xfs_efd_log_item * efdp,xfs_fsblock_t start_block,xfs_extlen_t ext_len,struct xfs_owner_info * oinfo,bool skip_discard)54 xfs_trans_free_extent(
55 struct xfs_trans *tp,
56 struct xfs_efd_log_item *efdp,
57 xfs_fsblock_t start_block,
58 xfs_extlen_t ext_len,
59 struct xfs_owner_info *oinfo,
60 bool skip_discard)
61 {
62 struct xfs_mount *mp = tp->t_mountp;
63 uint next_extent;
64 xfs_agnumber_t agno = XFS_FSB_TO_AGNO(mp, start_block);
65 xfs_agblock_t agbno = XFS_FSB_TO_AGBNO(mp, start_block);
66 struct xfs_extent *extp;
67 int error;
68
69 trace_xfs_bmap_free_deferred(tp->t_mountp, agno, 0, agbno, ext_len);
70
71 error = __xfs_free_extent(tp, start_block, ext_len,
72 oinfo, XFS_AG_RESV_NONE, skip_discard);
73 /*
74 * Mark the transaction dirty, even on error. This ensures the
75 * transaction is aborted, which:
76 *
77 * 1.) releases the EFI and frees the EFD
78 * 2.) shuts down the filesystem
79 */
80 tp->t_flags |= XFS_TRANS_DIRTY;
81 set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
82
83 next_extent = efdp->efd_next_extent;
84 ASSERT(next_extent < efdp->efd_format.efd_nextents);
85 extp = &(efdp->efd_format.efd_extents[next_extent]);
86 extp->ext_start = start_block;
87 extp->ext_len = ext_len;
88 efdp->efd_next_extent++;
89
90 return error;
91 }
92
93 /* Sort bmap items by AG. */
94 static int
xfs_extent_free_diff_items(void * priv,struct list_head * a,struct list_head * b)95 xfs_extent_free_diff_items(
96 void *priv,
97 struct list_head *a,
98 struct list_head *b)
99 {
100 struct xfs_mount *mp = priv;
101 struct xfs_extent_free_item *ra;
102 struct xfs_extent_free_item *rb;
103
104 ra = container_of(a, struct xfs_extent_free_item, xefi_list);
105 rb = container_of(b, struct xfs_extent_free_item, xefi_list);
106 return XFS_FSB_TO_AGNO(mp, ra->xefi_startblock) -
107 XFS_FSB_TO_AGNO(mp, rb->xefi_startblock);
108 }
109
110 /* Get an EFI. */
111 STATIC void *
xfs_extent_free_create_intent(struct xfs_trans * tp,unsigned int count)112 xfs_extent_free_create_intent(
113 struct xfs_trans *tp,
114 unsigned int count)
115 {
116 struct xfs_efi_log_item *efip;
117
118 ASSERT(tp != NULL);
119 ASSERT(count > 0);
120
121 efip = xfs_efi_init(tp->t_mountp, count);
122 ASSERT(efip != NULL);
123
124 /*
125 * Get a log_item_desc to point at the new item.
126 */
127 xfs_trans_add_item(tp, &efip->efi_item);
128 return efip;
129 }
130
131 /* Log a free extent to the intent item. */
132 STATIC void
xfs_extent_free_log_item(struct xfs_trans * tp,void * intent,struct list_head * item)133 xfs_extent_free_log_item(
134 struct xfs_trans *tp,
135 void *intent,
136 struct list_head *item)
137 {
138 struct xfs_efi_log_item *efip = intent;
139 struct xfs_extent_free_item *free;
140 uint next_extent;
141 struct xfs_extent *extp;
142
143 free = container_of(item, struct xfs_extent_free_item, xefi_list);
144
145 tp->t_flags |= XFS_TRANS_DIRTY;
146 set_bit(XFS_LI_DIRTY, &efip->efi_item.li_flags);
147
148 /*
149 * atomic_inc_return gives us the value after the increment;
150 * we want to use it as an array index so we need to subtract 1 from
151 * it.
152 */
153 next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
154 ASSERT(next_extent < efip->efi_format.efi_nextents);
155 extp = &efip->efi_format.efi_extents[next_extent];
156 extp->ext_start = free->xefi_startblock;
157 extp->ext_len = free->xefi_blockcount;
158 }
159
160 /* Get an EFD so we can process all the free extents. */
161 STATIC void *
xfs_extent_free_create_done(struct xfs_trans * tp,void * intent,unsigned int count)162 xfs_extent_free_create_done(
163 struct xfs_trans *tp,
164 void *intent,
165 unsigned int count)
166 {
167 return xfs_trans_get_efd(tp, intent, count);
168 }
169
170 /* Process a free extent. */
171 STATIC int
xfs_extent_free_finish_item(struct xfs_trans * tp,struct list_head * item,void * done_item,void ** state)172 xfs_extent_free_finish_item(
173 struct xfs_trans *tp,
174 struct list_head *item,
175 void *done_item,
176 void **state)
177 {
178 struct xfs_extent_free_item *free;
179 int error;
180
181 free = container_of(item, struct xfs_extent_free_item, xefi_list);
182 error = xfs_trans_free_extent(tp, done_item,
183 free->xefi_startblock,
184 free->xefi_blockcount,
185 &free->xefi_oinfo, free->xefi_skip_discard);
186 kmem_free(free);
187 return error;
188 }
189
190 /* Abort all pending EFIs. */
191 STATIC void
xfs_extent_free_abort_intent(void * intent)192 xfs_extent_free_abort_intent(
193 void *intent)
194 {
195 xfs_efi_release(intent);
196 }
197
198 /* Cancel a free extent. */
199 STATIC void
xfs_extent_free_cancel_item(struct list_head * item)200 xfs_extent_free_cancel_item(
201 struct list_head *item)
202 {
203 struct xfs_extent_free_item *free;
204
205 free = container_of(item, struct xfs_extent_free_item, xefi_list);
206 kmem_free(free);
207 }
208
209 static const struct xfs_defer_op_type xfs_extent_free_defer_type = {
210 .type = XFS_DEFER_OPS_TYPE_FREE,
211 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
212 .diff_items = xfs_extent_free_diff_items,
213 .create_intent = xfs_extent_free_create_intent,
214 .abort_intent = xfs_extent_free_abort_intent,
215 .log_item = xfs_extent_free_log_item,
216 .create_done = xfs_extent_free_create_done,
217 .finish_item = xfs_extent_free_finish_item,
218 .cancel_item = xfs_extent_free_cancel_item,
219 };
220
221 /*
222 * AGFL blocks are accounted differently in the reserve pools and are not
223 * inserted into the busy extent list.
224 */
225 STATIC int
xfs_agfl_free_finish_item(struct xfs_trans * tp,struct list_head * item,void * done_item,void ** state)226 xfs_agfl_free_finish_item(
227 struct xfs_trans *tp,
228 struct list_head *item,
229 void *done_item,
230 void **state)
231 {
232 struct xfs_mount *mp = tp->t_mountp;
233 struct xfs_efd_log_item *efdp = done_item;
234 struct xfs_extent_free_item *free;
235 struct xfs_extent *extp;
236 struct xfs_buf *agbp;
237 int error;
238 xfs_agnumber_t agno;
239 xfs_agblock_t agbno;
240 uint next_extent;
241
242 free = container_of(item, struct xfs_extent_free_item, xefi_list);
243 ASSERT(free->xefi_blockcount == 1);
244 agno = XFS_FSB_TO_AGNO(mp, free->xefi_startblock);
245 agbno = XFS_FSB_TO_AGBNO(mp, free->xefi_startblock);
246
247 trace_xfs_agfl_free_deferred(mp, agno, 0, agbno, free->xefi_blockcount);
248
249 error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
250 if (!error)
251 error = xfs_free_agfl_block(tp, agno, agbno, agbp,
252 &free->xefi_oinfo);
253
254 /*
255 * Mark the transaction dirty, even on error. This ensures the
256 * transaction is aborted, which:
257 *
258 * 1.) releases the EFI and frees the EFD
259 * 2.) shuts down the filesystem
260 */
261 tp->t_flags |= XFS_TRANS_DIRTY;
262 set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
263
264 next_extent = efdp->efd_next_extent;
265 ASSERT(next_extent < efdp->efd_format.efd_nextents);
266 extp = &(efdp->efd_format.efd_extents[next_extent]);
267 extp->ext_start = free->xefi_startblock;
268 extp->ext_len = free->xefi_blockcount;
269 efdp->efd_next_extent++;
270
271 kmem_free(free);
272 return error;
273 }
274
275
276 /* sub-type with special handling for AGFL deferred frees */
277 static const struct xfs_defer_op_type xfs_agfl_free_defer_type = {
278 .type = XFS_DEFER_OPS_TYPE_AGFL_FREE,
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,
287 };
288
289 /* Register the deferred op type. */
290 void
xfs_extent_free_init_defer_op(void)291 xfs_extent_free_init_defer_op(void)
292 {
293 xfs_defer_init_op_type(&xfs_extent_free_defer_type);
294 xfs_defer_init_op_type(&xfs_agfl_free_defer_type);
295 }
296