Line data Source code
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 :
29 : struct kmem_cache *xfs_efi_cache;
30 : struct kmem_cache *xfs_efd_cache;
31 :
32 : static const struct xfs_item_ops xfs_efi_item_ops;
33 :
34 : static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip)
35 : {
36 : return container_of(lip, struct xfs_efi_log_item, efi_item);
37 : }
38 :
39 : STATIC void
40 49466370 : xfs_efi_item_free(
41 : struct xfs_efi_log_item *efip)
42 : {
43 49466370 : kmem_free(efip->efi_item.li_lv_shadow);
44 49466495 : if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS)
45 0 : kmem_free(efip);
46 : else
47 49466495 : kmem_cache_free(xfs_efi_cache, efip);
48 49466024 : }
49 :
50 : /*
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.
56 : */
57 : STATIC void
58 98921200 : xfs_efi_release(
59 : struct xfs_efi_log_item *efip)
60 : {
61 98921200 : ASSERT(atomic_read(&efip->efi_refcount) > 0);
62 197850619 : if (!atomic_dec_and_test(&efip->efi_refcount))
63 : return;
64 :
65 49465622 : xfs_trans_ail_delete(&efip->efi_item, 0);
66 49466185 : xfs_efi_item_free(efip);
67 : }
68 :
69 : STATIC void
70 49397000 : xfs_efi_item_size(
71 : struct xfs_log_item *lip,
72 : int *nvecs,
73 : int *nbytes)
74 : {
75 49397000 : struct xfs_efi_log_item *efip = EFI_ITEM(lip);
76 :
77 49397000 : *nvecs += 1;
78 49397000 : *nbytes += xfs_efi_log_format_sizeof(efip->efi_format.efi_nextents);
79 49397000 : }
80 :
81 : /*
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.
87 : */
88 : STATIC void
89 49396208 : xfs_efi_item_format(
90 : struct xfs_log_item *lip,
91 : struct xfs_log_vec *lv)
92 : {
93 49396208 : struct xfs_efi_log_item *efip = EFI_ITEM(lip);
94 49396208 : struct xfs_log_iovec *vecp = NULL;
95 :
96 49396208 : ASSERT(atomic_read(&efip->efi_next_extent) ==
97 : efip->efi_format.efi_nextents);
98 :
99 49396208 : efip->efi_format.efi_type = XFS_LI_EFI;
100 49396208 : efip->efi_format.efi_size = 1;
101 :
102 49396208 : xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFI_FORMAT,
103 49396208 : &efip->efi_format,
104 49396208 : xfs_efi_log_format_sizeof(efip->efi_format.efi_nextents));
105 49396770 : }
106 :
107 :
108 : /*
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.
115 : */
116 : STATIC void
117 49392649 : xfs_efi_item_unpin(
118 : struct xfs_log_item *lip,
119 : int remove)
120 : {
121 49392649 : struct xfs_efi_log_item *efip = EFI_ITEM(lip);
122 49392649 : xfs_efi_release(efip);
123 49396802 : }
124 :
125 : /*
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.
129 : */
130 : STATIC void
131 68620 : xfs_efi_item_release(
132 : struct xfs_log_item *lip)
133 : {
134 68620 : xfs_efi_release(EFI_ITEM(lip));
135 68620 : }
136 :
137 : /*
138 : * Allocate and initialize an efi item with the given number of extents.
139 : */
140 : STATIC struct xfs_efi_log_item *
141 49459524 : xfs_efi_init(
142 : struct xfs_mount *mp,
143 : uint nextents)
144 :
145 : {
146 49459524 : struct xfs_efi_log_item *efip;
147 :
148 49459524 : ASSERT(nextents > 0);
149 49459524 : if (nextents > XFS_EFI_MAX_FAST_EXTENTS) {
150 0 : efip = kzalloc(xfs_efi_log_item_sizeof(nextents),
151 : GFP_KERNEL | __GFP_NOFAIL);
152 : } else {
153 49459524 : efip = kmem_cache_zalloc(xfs_efi_cache,
154 : GFP_KERNEL | __GFP_NOFAIL);
155 : }
156 :
157 49453796 : xfs_log_item_init(mp, &efip->efi_item, XFS_LI_EFI, &xfs_efi_item_ops);
158 49455744 : efip->efi_format.efi_nextents = nextents;
159 49455744 : efip->efi_format.efi_id = (uintptr_t)(void *)efip;
160 49455744 : atomic_set(&efip->efi_next_extent, 0);
161 49455744 : atomic_set(&efip->efi_refcount, 2);
162 :
163 49455744 : return efip;
164 : }
165 :
166 : /*
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.
172 : */
173 : STATIC int
174 69128 : xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
175 : {
176 69128 : xfs_efi_log_format_t *src_efi_fmt = buf->i_addr;
177 69128 : uint i;
178 69128 : uint len = xfs_efi_log_format_sizeof(src_efi_fmt->efi_nextents);
179 69128 : uint len32 = xfs_efi_log_format32_sizeof(src_efi_fmt->efi_nextents);
180 69128 : uint len64 = xfs_efi_log_format64_sizeof(src_efi_fmt->efi_nextents);
181 :
182 69128 : if (buf->i_len == len) {
183 138256 : memcpy(dst_efi_fmt, src_efi_fmt,
184 : offsetof(struct xfs_efi_log_format, efi_extents));
185 139634 : for (i = 0; i < src_efi_fmt->efi_nextents; i++)
186 141012 : memcpy(&dst_efi_fmt->efi_extents[i],
187 : &src_efi_fmt->efi_extents[i],
188 : sizeof(struct xfs_extent));
189 : return 0;
190 0 : } else if (buf->i_len == len32) {
191 0 : xfs_efi_log_format_32_t *src_efi_fmt_32 = buf->i_addr;
192 :
193 0 : dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type;
194 0 : dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size;
195 0 : dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
196 0 : dst_efi_fmt->efi_id = src_efi_fmt_32->efi_id;
197 0 : for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
198 0 : dst_efi_fmt->efi_extents[i].ext_start =
199 0 : src_efi_fmt_32->efi_extents[i].ext_start;
200 0 : dst_efi_fmt->efi_extents[i].ext_len =
201 0 : src_efi_fmt_32->efi_extents[i].ext_len;
202 : }
203 : return 0;
204 0 : } else if (buf->i_len == len64) {
205 : xfs_efi_log_format_64_t *src_efi_fmt_64 = buf->i_addr;
206 :
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;
216 : }
217 : return 0;
218 : }
219 0 : XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, NULL, buf->i_addr,
220 : buf->i_len);
221 0 : return -EFSCORRUPTED;
222 : }
223 :
224 : static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip)
225 : {
226 : return container_of(lip, struct xfs_efd_log_item, efd_item);
227 : }
228 :
229 : STATIC void
230 49397625 : xfs_efd_item_free(struct xfs_efd_log_item *efdp)
231 : {
232 49397625 : kmem_free(efdp->efd_item.li_lv_shadow);
233 49396711 : if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS)
234 0 : kmem_free(efdp);
235 : else
236 49396711 : kmem_cache_free(xfs_efd_cache, efdp);
237 49397220 : }
238 :
239 : STATIC void
240 49396910 : xfs_efd_item_size(
241 : struct xfs_log_item *lip,
242 : int *nvecs,
243 : int *nbytes)
244 : {
245 49396910 : struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
246 :
247 49396910 : *nvecs += 1;
248 49396910 : *nbytes += xfs_efd_log_format_sizeof(efdp->efd_format.efd_nextents);
249 49396910 : }
250 :
251 : /*
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.
257 : */
258 : STATIC void
259 311433 : xfs_efd_item_format(
260 : struct xfs_log_item *lip,
261 : struct xfs_log_vec *lv)
262 : {
263 311433 : struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
264 311433 : struct xfs_log_iovec *vecp = NULL;
265 :
266 311433 : ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
267 :
268 311433 : efdp->efd_format.efd_type = XFS_LI_EFD;
269 311433 : efdp->efd_format.efd_size = 1;
270 :
271 311433 : xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFD_FORMAT,
272 311433 : &efdp->efd_format,
273 311433 : xfs_efd_log_format_sizeof(efdp->efd_format.efd_nextents));
274 311426 : }
275 :
276 : /*
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.
279 : */
280 : STATIC void
281 49396943 : xfs_efd_item_release(
282 : struct xfs_log_item *lip)
283 : {
284 49396943 : struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
285 :
286 49396943 : xfs_efi_release(efdp->efd_efip);
287 49397418 : xfs_efd_item_free(efdp);
288 49397003 : }
289 :
290 : static struct xfs_log_item *
291 49149308 : xfs_efd_item_intent(
292 : struct xfs_log_item *lip)
293 : {
294 49149308 : return &EFD_ITEM(lip)->efd_efip->efi_item;
295 : }
296 :
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,
304 : };
305 :
306 : /*
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.
310 : */
311 : static struct xfs_efd_log_item *
312 49396496 : xfs_trans_get_efd(
313 : struct xfs_trans *tp,
314 : struct xfs_efi_log_item *efip,
315 : unsigned int nextents)
316 : {
317 49396496 : struct xfs_efd_log_item *efdp;
318 :
319 49396496 : ASSERT(nextents > 0);
320 :
321 49396496 : if (nextents > XFS_EFD_MAX_FAST_EXTENTS) {
322 0 : efdp = kzalloc(xfs_efd_log_item_sizeof(nextents),
323 : GFP_KERNEL | __GFP_NOFAIL);
324 : } else {
325 49396496 : efdp = kmem_cache_zalloc(xfs_efd_cache,
326 : GFP_KERNEL | __GFP_NOFAIL);
327 : }
328 :
329 49396820 : xfs_log_item_init(tp->t_mountp, &efdp->efd_item, XFS_LI_EFD,
330 : &xfs_efd_item_ops);
331 49396857 : efdp->efd_efip = efip;
332 49396857 : efdp->efd_format.efd_nextents = nextents;
333 49396857 : efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
334 :
335 49396857 : xfs_trans_add_item(tp, &efdp->efd_item);
336 49397534 : return efdp;
337 : }
338 :
339 : /*
340 : * Fill the EFD with all extents from the EFI when we need to roll the
341 : * transaction and continue with a new EFI.
342 : *
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.
349 : */
350 : static void
351 0 : xfs_efd_from_efi(
352 : struct xfs_efd_log_item *efdp)
353 : {
354 0 : struct xfs_efi_log_item *efip = efdp->efd_efip;
355 0 : uint i;
356 :
357 0 : ASSERT(efip->efi_format.efi_nextents > 0);
358 0 : ASSERT(efdp->efd_next_extent < efip->efi_format.efi_nextents);
359 :
360 0 : for (i = 0; i < efip->efi_format.efi_nextents; i++) {
361 0 : efdp->efd_format.efd_extents[i] =
362 : efip->efi_format.efi_extents[i];
363 : }
364 0 : efdp->efd_next_extent = efip->efi_format.efi_nextents;
365 0 : }
366 :
367 : /*
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.
371 : */
372 : static int
373 51178031 : xfs_trans_free_extent(
374 : struct xfs_trans *tp,
375 : struct xfs_efd_log_item *efdp,
376 : struct xfs_extent_free_item *xefi)
377 : {
378 51178031 : struct xfs_owner_info oinfo = { };
379 51178031 : struct xfs_mount *mp = tp->t_mountp;
380 51178031 : struct xfs_extent *extp;
381 51178031 : uint next_extent;
382 51178031 : xfs_agblock_t agbno = XFS_FSB_TO_AGBNO(mp,
383 : xefi->xefi_startblock);
384 51178031 : int error;
385 :
386 51178031 : oinfo.oi_owner = xefi->xefi_owner;
387 51178031 : if (xefi->xefi_flags & XFS_EFI_ATTR_FORK)
388 25 : oinfo.oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
389 51178031 : if (xefi->xefi_flags & XFS_EFI_BMBT_BLOCK)
390 607596 : oinfo.oi_flags |= XFS_OWNER_INFO_BMBT_BLOCK;
391 :
392 51178031 : trace_xfs_bmap_free_deferred(tp->t_mountp, xefi->xefi_pag->pag_agno, 0,
393 : agbno, xefi->xefi_blockcount);
394 :
395 51177241 : error = __xfs_free_extent(tp, xefi->xefi_pag, agbno,
396 : xefi->xefi_blockcount, &oinfo, xefi->xefi_agresv,
397 51177241 : xefi->xefi_flags & XFS_EFI_SKIP_DISCARD);
398 :
399 : /*
400 : * Mark the transaction dirty, even on error. This ensures the
401 : * transaction is aborted, which:
402 : *
403 : * 1.) releases the EFI and frees the EFD
404 : * 2.) shuts down the filesystem
405 : */
406 51177646 : tp->t_flags |= XFS_TRANS_DIRTY | XFS_TRANS_HAS_INTENT_DONE;
407 51177646 : set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
408 :
409 : /*
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.
414 : */
415 51178361 : if (error == -EAGAIN) {
416 0 : xfs_efd_from_efi(efdp);
417 0 : return error;
418 : }
419 :
420 51178361 : next_extent = efdp->efd_next_extent;
421 51178361 : ASSERT(next_extent < efdp->efd_format.efd_nextents);
422 51178361 : extp = &(efdp->efd_format.efd_extents[next_extent]);
423 51178361 : extp->ext_start = xefi->xefi_startblock;
424 51178361 : extp->ext_len = xefi->xefi_blockcount;
425 51178361 : efdp->efd_next_extent++;
426 :
427 51178361 : return error;
428 : }
429 :
430 : /* Sort bmap items by AG. */
431 : static int
432 4337109 : xfs_extent_free_diff_items(
433 : void *priv,
434 : const struct list_head *a,
435 : const struct list_head *b)
436 : {
437 4337109 : struct xfs_extent_free_item *ra;
438 4337109 : struct xfs_extent_free_item *rb;
439 :
440 4337109 : ra = container_of(a, struct xfs_extent_free_item, xefi_list);
441 4337109 : rb = container_of(b, struct xfs_extent_free_item, xefi_list);
442 :
443 4337109 : return ra->xefi_pag->pag_agno - rb->xefi_pag->pag_agno;
444 : }
445 :
446 : /* Log a free extent to the intent item. */
447 : STATIC void
448 51465320 : xfs_extent_free_log_item(
449 : struct xfs_trans *tp,
450 : struct xfs_efi_log_item *efip,
451 : struct xfs_extent_free_item *xefi)
452 : {
453 51465320 : uint next_extent;
454 51465320 : struct xfs_extent *extp;
455 :
456 51465320 : tp->t_flags |= XFS_TRANS_DIRTY;
457 51465320 : set_bit(XFS_LI_DIRTY, &efip->efi_item.li_flags);
458 :
459 : /*
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
462 : * it.
463 : */
464 51465505 : next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
465 51465309 : ASSERT(next_extent < efip->efi_format.efi_nextents);
466 51465309 : extp = &efip->efi_format.efi_extents[next_extent];
467 51465309 : extp->ext_start = xefi->xefi_startblock;
468 51465309 : extp->ext_len = xefi->xefi_blockcount;
469 51465309 : }
470 :
471 : static struct xfs_log_item *
472 49387859 : xfs_extent_free_create_intent(
473 : struct xfs_trans *tp,
474 : struct list_head *items,
475 : unsigned int count,
476 : bool sort)
477 : {
478 49387859 : struct xfs_mount *mp = tp->t_mountp;
479 49387859 : struct xfs_efi_log_item *efip = xfs_efi_init(mp, count);
480 49383547 : struct xfs_extent_free_item *xefi;
481 :
482 49383547 : ASSERT(count > 0);
483 :
484 49383547 : xfs_trans_add_item(tp, &efip->efi_item);
485 49391960 : if (sort)
486 49301031 : list_sort(mp, items, xfs_extent_free_diff_items);
487 100855707 : list_for_each_entry(xefi, items, xefi_list)
488 51463542 : xfs_extent_free_log_item(tp, efip, xefi);
489 49392165 : return &efip->efi_item;
490 : }
491 :
492 : /* Get an EFD so we can process all the free extents. */
493 : static struct xfs_log_item *
494 49393794 : xfs_extent_free_create_done(
495 : struct xfs_trans *tp,
496 : struct xfs_log_item *intent,
497 : unsigned int count)
498 : {
499 49393794 : return &xfs_trans_get_efd(tp, EFI_ITEM(intent), count)->efd_item;
500 : }
501 :
502 : /* Take a passive ref to the AG containing the space we're freeing. */
503 : void
504 51373388 : xfs_extent_free_get_group(
505 : struct xfs_mount *mp,
506 : struct xfs_extent_free_item *xefi)
507 : {
508 51373388 : xfs_agnumber_t agno;
509 :
510 51373388 : agno = XFS_FSB_TO_AGNO(mp, xefi->xefi_startblock);
511 51373388 : xefi->xefi_pag = xfs_perag_intent_get(mp, agno);
512 51367843 : }
513 :
514 : /* Release a passive AG ref after some freeing work. */
515 : static inline void
516 : xfs_extent_free_put_group(
517 : struct xfs_extent_free_item *xefi)
518 : {
519 51375643 : xfs_perag_intent_put(xefi->xefi_pag);
520 518 : }
521 :
522 : /* Process a free extent. */
523 : STATIC int
524 51177310 : 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)
529 : {
530 51177310 : struct xfs_extent_free_item *xefi;
531 51177310 : int error;
532 :
533 51177310 : xefi = container_of(item, struct xfs_extent_free_item, xefi_list);
534 :
535 51177310 : error = xfs_trans_free_extent(tp, EFD_ITEM(done), xefi);
536 :
537 : /*
538 : * Don't free the XEFI if we need a new transaction to complete
539 : * processing of it.
540 : */
541 51176908 : if (error == -EAGAIN)
542 : return error;
543 :
544 51176908 : xfs_extent_free_put_group(xefi);
545 51177388 : kmem_cache_free(xfs_extfree_item_cache, xefi);
546 51177388 : return error;
547 : }
548 :
549 : /* Abort all pending EFIs. */
550 : STATIC void
551 117 : xfs_extent_free_abort_intent(
552 : struct xfs_log_item *intent)
553 : {
554 117 : xfs_efi_release(EFI_ITEM(intent));
555 117 : }
556 :
557 : /* Cancel a free extent. */
558 : STATIC void
559 118 : xfs_extent_free_cancel_item(
560 : struct list_head *item)
561 : {
562 118 : struct xfs_extent_free_item *xefi;
563 :
564 118 : xefi = container_of(item, struct xfs_extent_free_item, xefi_list);
565 :
566 118 : xfs_extent_free_put_group(xefi);
567 118 : kmem_cache_free(xfs_extfree_item_cache, xefi);
568 118 : }
569 :
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,
577 : };
578 :
579 : /*
580 : * AGFL blocks are accounted differently in the reserve pools and are not
581 : * inserted into the busy extent list.
582 : */
583 : STATIC int
584 198099 : 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)
589 : {
590 198099 : struct xfs_owner_info oinfo = { };
591 198099 : struct xfs_mount *mp = tp->t_mountp;
592 198099 : struct xfs_efd_log_item *efdp = EFD_ITEM(done);
593 198099 : struct xfs_extent_free_item *xefi;
594 198099 : struct xfs_extent *extp;
595 198099 : struct xfs_buf *agbp;
596 198099 : int error;
597 198099 : xfs_agblock_t agbno;
598 198099 : uint next_extent;
599 :
600 198099 : xefi = container_of(item, struct xfs_extent_free_item, xefi_list);
601 198099 : ASSERT(xefi->xefi_blockcount == 1);
602 198099 : agbno = XFS_FSB_TO_AGBNO(mp, xefi->xefi_startblock);
603 198099 : oinfo.oi_owner = xefi->xefi_owner;
604 :
605 198099 : trace_xfs_agfl_free_deferred(mp, xefi->xefi_pag->pag_agno, 0, agbno,
606 : xefi->xefi_blockcount);
607 :
608 198099 : error = xfs_alloc_read_agf(xefi->xefi_pag, tp, 0, &agbp);
609 198098 : if (!error)
610 198097 : error = xfs_free_agfl_block(tp, xefi->xefi_pag->pag_agno,
611 : agbno, agbp, &oinfo);
612 :
613 : /*
614 : * Mark the transaction dirty, even on error. This ensures the
615 : * transaction is aborted, which:
616 : *
617 : * 1.) releases the EFI and frees the EFD
618 : * 2.) shuts down the filesystem
619 : */
620 198098 : tp->t_flags |= XFS_TRANS_DIRTY;
621 198098 : set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
622 :
623 198099 : next_extent = efdp->efd_next_extent;
624 198099 : ASSERT(next_extent < efdp->efd_format.efd_nextents);
625 198099 : extp = &(efdp->efd_format.efd_extents[next_extent]);
626 198099 : extp->ext_start = xefi->xefi_startblock;
627 198099 : extp->ext_len = xefi->xefi_blockcount;
628 198099 : efdp->efd_next_extent++;
629 :
630 198099 : xfs_extent_free_put_group(xefi);
631 198099 : kmem_cache_free(xfs_extfree_item_cache, xefi);
632 198099 : return error;
633 : }
634 :
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,
643 : };
644 :
645 : /* Is this recovered EFI ok? */
646 : static inline bool
647 : xfs_efi_validate_ext(
648 : struct xfs_mount *mp,
649 : struct xfs_extent *extp)
650 : {
651 518 : return xfs_verify_fsbext(mp, extp->ext_start, extp->ext_len);
652 : }
653 :
654 : /*
655 : * Process an extent free intent item that was recovered from
656 : * the log. We need to free the extents that it describes.
657 : */
658 : STATIC int
659 514 : xfs_efi_item_recover(
660 : struct xfs_log_item *lip,
661 : struct list_head *capture_list)
662 : {
663 514 : struct xfs_efi_log_item *efip = EFI_ITEM(lip);
664 514 : struct xfs_mount *mp = lip->li_log->l_mp;
665 514 : struct xfs_efd_log_item *efdp;
666 514 : struct xfs_trans *tp;
667 514 : int i;
668 514 : int error = 0;
669 514 : bool requeue_only = false;
670 :
671 : /*
672 : * First check the validity of the extents described by the
673 : * EFI. If any are bad, then assume that all are bad and
674 : * just toss the EFI.
675 : */
676 1032 : for (i = 0; i < efip->efi_format.efi_nextents; i++) {
677 518 : if (!xfs_efi_validate_ext(mp,
678 : &efip->efi_format.efi_extents[i])) {
679 0 : XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
680 : &efip->efi_format,
681 : sizeof(efip->efi_format));
682 0 : return -EFSCORRUPTED;
683 : }
684 : }
685 :
686 514 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
687 514 : if (error)
688 : return error;
689 514 : efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
690 :
691 1546 : for (i = 0; i < efip->efi_format.efi_nextents; i++) {
692 518 : struct xfs_extent_free_item fake = {
693 : .xefi_owner = XFS_RMAP_OWN_UNKNOWN,
694 : .xefi_agresv = XFS_AG_RESV_NONE,
695 : };
696 518 : struct xfs_extent *extp;
697 :
698 518 : extp = &efip->efi_format.efi_extents[i];
699 :
700 518 : fake.xefi_startblock = extp->ext_start;
701 518 : fake.xefi_blockcount = extp->ext_len;
702 :
703 518 : if (!requeue_only) {
704 518 : xfs_extent_free_get_group(mp, &fake);
705 518 : error = xfs_trans_free_extent(tp, efdp, &fake);
706 518 : xfs_extent_free_put_group(&fake);
707 : }
708 :
709 : /*
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.
713 : */
714 518 : if (error == -EAGAIN || requeue_only) {
715 0 : error = xfs_free_extent_later(tp, fake.xefi_startblock,
716 0 : fake.xefi_blockcount,
717 : &XFS_RMAP_OINFO_ANY_OWNER,
718 : fake.xefi_agresv);
719 0 : if (!error) {
720 0 : requeue_only = true;
721 0 : continue;
722 : }
723 : }
724 :
725 518 : if (error == -EFSCORRUPTED)
726 0 : XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
727 : extp, sizeof(*extp));
728 518 : if (error)
729 0 : goto abort_error;
730 :
731 : }
732 :
733 514 : return xfs_defer_ops_capture_and_commit(tp, capture_list);
734 :
735 : abort_error:
736 0 : xfs_trans_cancel(tp);
737 0 : return error;
738 : }
739 :
740 : STATIC bool
741 68854 : xfs_efi_item_match(
742 : struct xfs_log_item *lip,
743 : uint64_t intent_id)
744 : {
745 68854 : return EFI_ITEM(lip)->efi_format.efi_id == intent_id;
746 : }
747 :
748 : /* Relog an intent item to push the log tail forward. */
749 : static struct xfs_log_item *
750 2228 : xfs_efi_item_relog(
751 : struct xfs_log_item *intent,
752 : struct xfs_trans *tp)
753 : {
754 2228 : struct xfs_efd_log_item *efdp;
755 2228 : struct xfs_efi_log_item *efip;
756 2228 : struct xfs_extent *extp;
757 2228 : unsigned int count;
758 :
759 2228 : count = EFI_ITEM(intent)->efi_format.efi_nextents;
760 2228 : extp = EFI_ITEM(intent)->efi_format.efi_extents;
761 :
762 2228 : tp->t_flags |= XFS_TRANS_DIRTY;
763 2228 : efdp = xfs_trans_get_efd(tp, EFI_ITEM(intent), count);
764 2228 : efdp->efd_next_extent = count;
765 4456 : memcpy(efdp->efd_format.efd_extents, extp, count * sizeof(*extp));
766 2228 : set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
767 :
768 2228 : efip = xfs_efi_init(tp->t_mountp, count);
769 4456 : memcpy(efip->efi_format.efi_extents, extp, count * sizeof(*extp));
770 2228 : atomic_set(&efip->efi_next_extent, count);
771 2228 : xfs_trans_add_item(tp, &efip->efi_item);
772 2228 : set_bit(XFS_LI_DIRTY, &efip->efi_item.li_flags);
773 2228 : return &efip->efi_item;
774 : }
775 :
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,
785 : };
786 :
787 : /*
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
792 : * LSN.
793 : */
794 : STATIC int
795 69128 : xlog_recover_efi_commit_pass2(
796 : struct xlog *log,
797 : struct list_head *buffer_list,
798 : struct xlog_recover_item *item,
799 : xfs_lsn_t lsn)
800 : {
801 69128 : struct xfs_mount *mp = log->l_mp;
802 69128 : struct xfs_efi_log_item *efip;
803 69128 : struct xfs_efi_log_format *efi_formatp;
804 69128 : int error;
805 :
806 69128 : efi_formatp = item->ri_buf[0].i_addr;
807 :
808 69128 : if (item->ri_buf[0].i_len < xfs_efi_log_format_sizeof(0)) {
809 0 : XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
810 : item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
811 0 : return -EFSCORRUPTED;
812 : }
813 :
814 69128 : efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
815 69128 : error = xfs_efi_copy_format(&item->ri_buf[0], &efip->efi_format);
816 69128 : if (error) {
817 0 : xfs_efi_item_free(efip);
818 0 : return error;
819 : }
820 69128 : atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
821 : /*
822 : * Insert the intent into the AIL directly and drop one reference so
823 : * that finishing or canceling the work will drop the other.
824 : */
825 69128 : xfs_trans_ail_insert(log->l_ailp, &efip->efi_item, lsn);
826 69128 : xfs_efi_release(efip);
827 69128 : return 0;
828 : }
829 :
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,
833 : };
834 :
835 : /*
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.
841 : */
842 : STATIC int
843 68644 : xlog_recover_efd_commit_pass2(
844 : struct xlog *log,
845 : struct list_head *buffer_list,
846 : struct xlog_recover_item *item,
847 : xfs_lsn_t lsn)
848 : {
849 68644 : struct xfs_efd_log_format *efd_formatp;
850 68644 : int buflen = item->ri_buf[0].i_len;
851 :
852 68644 : efd_formatp = item->ri_buf[0].i_addr;
853 :
854 68644 : if (buflen < sizeof(struct xfs_efd_log_format)) {
855 0 : XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
856 : efd_formatp, buflen);
857 0 : return -EFSCORRUPTED;
858 : }
859 :
860 68644 : if (item->ri_buf[0].i_len != xfs_efd_log_format32_sizeof(
861 68644 : efd_formatp->efd_nextents) &&
862 : item->ri_buf[0].i_len != xfs_efd_log_format64_sizeof(
863 : efd_formatp->efd_nextents)) {
864 0 : XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
865 : efd_formatp, buflen);
866 0 : return -EFSCORRUPTED;
867 : }
868 :
869 68644 : xlog_recover_release_intent(log, XFS_LI_EFI, efd_formatp->efd_efi_id);
870 68644 : return 0;
871 : }
872 :
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,
876 : };
|
