]>
git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blob - libxfs/xfs_defer.c
1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2016 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
6 #include "libxfs_priv.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
14 #include "xfs_mount.h"
15 #include "xfs_defer.h"
16 #include "xfs_trans.h"
17 #include "xfs_inode.h"
18 #include "xfs_trace.h"
21 * Deferred Operations in XFS
23 * Due to the way locking rules work in XFS, certain transactions (block
24 * mapping and unmapping, typically) have permanent reservations so that
25 * we can roll the transaction to adhere to AG locking order rules and
26 * to unlock buffers between metadata updates. Prior to rmap/reflink,
27 * the mapping code had a mechanism to perform these deferrals for
28 * extents that were going to be freed; this code makes that facility
31 * When adding the reverse mapping and reflink features, it became
32 * necessary to perform complex remapping multi-transactions to comply
33 * with AG locking order rules, and to be able to spread a single
34 * refcount update operation (an operation on an n-block extent can
35 * update as many as n records!) among multiple transactions. XFS can
36 * roll a transaction to facilitate this, but using this facility
37 * requires us to log "intent" items in case log recovery needs to
38 * redo the operation, and to log "done" items to indicate that redo
41 * Deferred work is tracked in xfs_defer_pending items. Each pending
42 * item tracks one type of deferred work. Incoming work items (which
43 * have not yet had an intent logged) are attached to a pending item
44 * on the dop_intake list, where they wait for the caller to finish
45 * the deferred operations.
47 * Finishing a set of deferred operations is an involved process. To
48 * start, we define "rolling a deferred-op transaction" as follows:
50 * > For each xfs_defer_pending item on the dop_intake list,
51 * - Sort the work items in AG order. XFS locking
52 * order rules require us to lock buffers in AG order.
53 * - Create a log intent item for that type.
54 * - Attach it to the pending item.
55 * - Move the pending item from the dop_intake list to the
57 * > Roll the transaction.
59 * NOTE: To avoid exceeding the transaction reservation, we limit the
60 * number of items that we attach to a given xfs_defer_pending.
62 * The actual finishing process looks like this:
64 * > For each xfs_defer_pending in the dop_pending list,
65 * - Roll the deferred-op transaction as above.
66 * - Create a log done item for that type, and attach it to the
68 * - For each work item attached to the log intent item,
69 * * Perform the described action.
70 * * Attach the work item to the log done item.
71 * * If the result of doing the work was -EAGAIN, ->finish work
72 * wants a new transaction. See the "Requesting a Fresh
73 * Transaction while Finishing Deferred Work" section below for
76 * The key here is that we must log an intent item for all pending
77 * work items every time we roll the transaction, and that we must log
78 * a done item as soon as the work is completed. With this mechanism
79 * we can perform complex remapping operations, chaining intent items
82 * Requesting a Fresh Transaction while Finishing Deferred Work
84 * If ->finish_item decides that it needs a fresh transaction to
85 * finish the work, it must ask its caller (xfs_defer_finish) for a
86 * continuation. The most likely cause of this circumstance are the
87 * refcount adjust functions deciding that they've logged enough items
88 * to be at risk of exceeding the transaction reservation.
90 * To get a fresh transaction, we want to log the existing log done
91 * item to prevent the log intent item from replaying, immediately log
92 * a new log intent item with the unfinished work items, roll the
93 * transaction, and re-call ->finish_item wherever it left off. The
94 * log done item and the new log intent item must be in the same
95 * transaction or atomicity cannot be guaranteed; defer_finish ensures
98 * This requires some coordination between ->finish_item and
99 * defer_finish. Upon deciding to request a new transaction,
100 * ->finish_item should update the current work item to reflect the
101 * unfinished work. Next, it should reset the log done item's list
102 * count to the number of items finished, and return -EAGAIN.
103 * defer_finish sees the -EAGAIN, logs the new log intent item
104 * with the remaining work items, and leaves the xfs_defer_pending
105 * item at the head of the dop_work queue. Then it rolls the
106 * transaction and picks up processing where it left off. It is
107 * required that ->finish_item must be careful to leave enough
108 * transaction reservation to fit the new log intent item.
110 * This is an example of remapping the extent (E, E+B) into file X at
111 * offset A and dealing with the extent (C, C+B) already being mapped
113 * +-------------------------------------------------+
114 * | Unmap file X startblock C offset A length B | t0
115 * | Intent to reduce refcount for extent (C, B) |
116 * | Intent to remove rmap (X, C, A, B) |
117 * | Intent to free extent (D, 1) (bmbt block) |
118 * | Intent to map (X, A, B) at startblock E |
119 * +-------------------------------------------------+
120 * | Map file X startblock E offset A length B | t1
121 * | Done mapping (X, E, A, B) |
122 * | Intent to increase refcount for extent (E, B) |
123 * | Intent to add rmap (X, E, A, B) |
124 * +-------------------------------------------------+
125 * | Reduce refcount for extent (C, B) | t2
126 * | Done reducing refcount for extent (C, 9) |
127 * | Intent to reduce refcount for extent (C+9, B-9) |
128 * | (ran out of space after 9 refcount updates) |
129 * +-------------------------------------------------+
130 * | Reduce refcount for extent (C+9, B+9) | t3
131 * | Done reducing refcount for extent (C+9, B-9) |
132 * | Increase refcount for extent (E, B) |
133 * | Done increasing refcount for extent (E, B) |
134 * | Intent to free extent (C, B) |
135 * | Intent to free extent (F, 1) (refcountbt block) |
136 * | Intent to remove rmap (F, 1, REFC) |
137 * +-------------------------------------------------+
138 * | Remove rmap (X, C, A, B) | t4
139 * | Done removing rmap (X, C, A, B) |
140 * | Add rmap (X, E, A, B) |
141 * | Done adding rmap (X, E, A, B) |
142 * | Remove rmap (F, 1, REFC) |
143 * | Done removing rmap (F, 1, REFC) |
144 * +-------------------------------------------------+
145 * | Free extent (C, B) | t5
146 * | Done freeing extent (C, B) |
147 * | Free extent (D, 1) |
148 * | Done freeing extent (D, 1) |
149 * | Free extent (F, 1) |
150 * | Done freeing extent (F, 1) |
151 * +-------------------------------------------------+
153 * If we should crash before t2 commits, log recovery replays
154 * the following intent items:
156 * - Intent to reduce refcount for extent (C, B)
157 * - Intent to remove rmap (X, C, A, B)
158 * - Intent to free extent (D, 1) (bmbt block)
159 * - Intent to increase refcount for extent (E, B)
160 * - Intent to add rmap (X, E, A, B)
162 * In the process of recovering, it should also generate and take care
163 * of these intent items:
165 * - Intent to free extent (C, B)
166 * - Intent to free extent (F, 1) (refcountbt block)
167 * - Intent to remove rmap (F, 1, REFC)
169 * Note that the continuation requested between t2 and t3 is likely to
173 static const struct xfs_defer_op_type
*defer_op_types
[XFS_DEFER_OPS_TYPE_MAX
];
176 * For each pending item in the intake list, log its intent item and the
177 * associated extents, then add the entire intake list to the end of
181 xfs_defer_create_intents(
182 struct xfs_trans
*tp
)
184 struct list_head
*li
;
185 struct xfs_defer_pending
*dfp
;
187 list_for_each_entry(dfp
, &tp
->t_dfops
, dfp_list
) {
188 dfp
->dfp_intent
= dfp
->dfp_type
->create_intent(tp
,
190 trace_xfs_defer_create_intent(tp
->t_mountp
, dfp
);
191 list_sort(tp
->t_mountp
, &dfp
->dfp_work
,
192 dfp
->dfp_type
->diff_items
);
193 list_for_each(li
, &dfp
->dfp_work
)
194 dfp
->dfp_type
->log_item(tp
, dfp
->dfp_intent
, li
);
198 /* Abort all the intents that were committed. */
200 xfs_defer_trans_abort(
201 struct xfs_trans
*tp
,
202 struct list_head
*dop_pending
)
204 struct xfs_defer_pending
*dfp
;
206 trace_xfs_defer_trans_abort(tp
, _RET_IP_
);
208 /* Abort intent items that don't have a done item. */
209 list_for_each_entry(dfp
, dop_pending
, dfp_list
) {
210 trace_xfs_defer_pending_abort(tp
->t_mountp
, dfp
);
211 if (dfp
->dfp_intent
&& !dfp
->dfp_done
) {
212 dfp
->dfp_type
->abort_intent(dfp
->dfp_intent
);
213 dfp
->dfp_intent
= NULL
;
218 /* Roll a transaction so we can do some deferred op processing. */
220 xfs_defer_trans_roll(
221 struct xfs_trans
**tpp
)
223 struct xfs_trans
*tp
= *tpp
;
224 struct xfs_buf_log_item
*bli
;
225 struct xfs_inode_log_item
*ili
;
226 struct xfs_log_item
*lip
;
227 struct xfs_buf
*bplist
[XFS_DEFER_OPS_NR_BUFS
];
228 struct xfs_inode
*iplist
[XFS_DEFER_OPS_NR_INODES
];
229 int bpcount
= 0, ipcount
= 0;
233 list_for_each_entry(lip
, &tp
->t_items
, li_trans
) {
234 switch (lip
->li_type
) {
236 bli
= container_of(lip
, struct xfs_buf_log_item
,
238 if (bli
->bli_flags
& XFS_BLI_HOLD
) {
239 if (bpcount
>= XFS_DEFER_OPS_NR_BUFS
) {
241 return -EFSCORRUPTED
;
243 xfs_trans_dirty_buf(tp
, bli
->bli_buf
);
244 bplist
[bpcount
++] = bli
->bli_buf
;
248 ili
= container_of(lip
, struct xfs_inode_log_item
,
250 if (ili
->ili_lock_flags
== 0) {
251 if (ipcount
>= XFS_DEFER_OPS_NR_INODES
) {
253 return -EFSCORRUPTED
;
255 xfs_trans_log_inode(tp
, ili
->ili_inode
,
257 iplist
[ipcount
++] = ili
->ili_inode
;
265 trace_xfs_defer_trans_roll(tp
, _RET_IP_
);
267 /* Roll the transaction. */
268 error
= xfs_trans_roll(tpp
);
271 trace_xfs_defer_trans_roll_error(tp
, error
);
275 /* Rejoin the joined inodes. */
276 for (i
= 0; i
< ipcount
; i
++)
277 xfs_trans_ijoin(tp
, iplist
[i
], 0);
279 /* Rejoin the buffers and dirty them so the log moves forward. */
280 for (i
= 0; i
< bpcount
; i
++) {
281 xfs_trans_bjoin(tp
, bplist
[i
]);
282 xfs_trans_bhold(tp
, bplist
[i
]);
289 * Reset an already used dfops after finish.
293 struct xfs_trans
*tp
)
295 ASSERT(list_empty(&tp
->t_dfops
));
298 * Low mode state transfers across transaction rolls to mirror dfops
299 * lifetime. Clear it now that dfops is reset.
301 tp
->t_flags
&= ~XFS_TRANS_LOWMODE
;
305 * Free up any items left in the list.
308 xfs_defer_cancel_list(
309 struct xfs_mount
*mp
,
310 struct list_head
*dop_list
)
312 struct xfs_defer_pending
*dfp
;
313 struct xfs_defer_pending
*pli
;
314 struct list_head
*pwi
;
318 * Free the pending items. Caller should already have arranged
319 * for the intent items to be released.
321 list_for_each_entry_safe(dfp
, pli
, dop_list
, dfp_list
) {
322 trace_xfs_defer_cancel_list(mp
, dfp
);
323 list_del(&dfp
->dfp_list
);
324 list_for_each_safe(pwi
, n
, &dfp
->dfp_work
) {
327 dfp
->dfp_type
->cancel_item(pwi
);
329 ASSERT(dfp
->dfp_count
== 0);
335 * Finish all the pending work. This involves logging intent items for
336 * any work items that wandered in since the last transaction roll (if
337 * one has even happened), rolling the transaction, and finishing the
338 * work items in the first item on the logged-and-pending list.
340 * If an inode is provided, relog it to the new transaction.
343 xfs_defer_finish_noroll(
344 struct xfs_trans
**tp
)
346 struct xfs_defer_pending
*dfp
;
347 struct list_head
*li
;
351 void (*cleanup_fn
)(struct xfs_trans
*, void *, int);
352 LIST_HEAD(dop_pending
);
354 ASSERT((*tp
)->t_flags
& XFS_TRANS_PERM_LOG_RES
);
356 trace_xfs_defer_finish(*tp
, _RET_IP_
);
358 /* Until we run out of pending work to finish... */
359 while (!list_empty(&dop_pending
) || !list_empty(&(*tp
)->t_dfops
)) {
360 /* log intents and pull in intake items */
361 xfs_defer_create_intents(*tp
);
362 list_splice_tail_init(&(*tp
)->t_dfops
, &dop_pending
);
365 * Roll the transaction.
367 error
= xfs_defer_trans_roll(tp
);
371 /* Log an intent-done item for the first pending item. */
372 dfp
= list_first_entry(&dop_pending
, struct xfs_defer_pending
,
374 trace_xfs_defer_pending_finish((*tp
)->t_mountp
, dfp
);
375 dfp
->dfp_done
= dfp
->dfp_type
->create_done(*tp
, dfp
->dfp_intent
,
377 cleanup_fn
= dfp
->dfp_type
->finish_cleanup
;
379 /* Finish the work items. */
381 list_for_each_safe(li
, n
, &dfp
->dfp_work
) {
384 error
= dfp
->dfp_type
->finish_item(*tp
, li
,
385 dfp
->dfp_done
, &state
);
386 if (error
== -EAGAIN
) {
388 * Caller wants a fresh transaction;
389 * put the work item back on the list
392 list_add(li
, &dfp
->dfp_work
);
397 * Clean up after ourselves and jump out.
398 * xfs_defer_cancel will take care of freeing
399 * all these lists and stuff.
402 cleanup_fn(*tp
, state
, error
);
406 if (error
== -EAGAIN
) {
408 * Caller wants a fresh transaction, so log a
409 * new log intent item to replace the old one
410 * and roll the transaction. See "Requesting
411 * a Fresh Transaction while Finishing
412 * Deferred Work" above.
414 dfp
->dfp_intent
= dfp
->dfp_type
->create_intent(*tp
,
416 dfp
->dfp_done
= NULL
;
417 list_for_each(li
, &dfp
->dfp_work
)
418 dfp
->dfp_type
->log_item(*tp
, dfp
->dfp_intent
,
421 /* Done with the dfp, free it. */
422 list_del(&dfp
->dfp_list
);
427 cleanup_fn(*tp
, state
, error
);
432 xfs_defer_trans_abort(*tp
, &dop_pending
);
433 xfs_force_shutdown((*tp
)->t_mountp
, SHUTDOWN_CORRUPT_INCORE
);
434 trace_xfs_defer_finish_error(*tp
, error
);
435 xfs_defer_cancel_list((*tp
)->t_mountp
, &dop_pending
);
436 xfs_defer_cancel(*tp
);
440 trace_xfs_defer_finish_done(*tp
, _RET_IP_
);
446 struct xfs_trans
**tp
)
451 * Finish and roll the transaction once more to avoid returning to the
452 * caller with a dirty transaction.
454 error
= xfs_defer_finish_noroll(tp
);
457 if ((*tp
)->t_flags
& XFS_TRANS_DIRTY
) {
458 error
= xfs_defer_trans_roll(tp
);
460 xfs_force_shutdown((*tp
)->t_mountp
,
461 SHUTDOWN_CORRUPT_INCORE
);
465 xfs_defer_reset(*tp
);
471 struct xfs_trans
*tp
)
473 struct xfs_mount
*mp
= tp
->t_mountp
;
475 trace_xfs_defer_cancel(tp
, _RET_IP_
);
476 xfs_defer_cancel_list(mp
, &tp
->t_dfops
);
479 /* Add an item for later deferred processing. */
482 struct xfs_trans
*tp
,
483 enum xfs_defer_ops_type type
,
484 struct list_head
*li
)
486 struct xfs_defer_pending
*dfp
= NULL
;
488 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
491 * Add the item to a pending item at the end of the intake list.
492 * If the last pending item has the same type, reuse it. Else,
493 * create a new pending item at the end of the intake list.
495 if (!list_empty(&tp
->t_dfops
)) {
496 dfp
= list_last_entry(&tp
->t_dfops
,
497 struct xfs_defer_pending
, dfp_list
);
498 if (dfp
->dfp_type
->type
!= type
||
499 (dfp
->dfp_type
->max_items
&&
500 dfp
->dfp_count
>= dfp
->dfp_type
->max_items
))
504 dfp
= kmem_alloc(sizeof(struct xfs_defer_pending
),
506 dfp
->dfp_type
= defer_op_types
[type
];
507 dfp
->dfp_intent
= NULL
;
508 dfp
->dfp_done
= NULL
;
510 INIT_LIST_HEAD(&dfp
->dfp_work
);
511 list_add_tail(&dfp
->dfp_list
, &tp
->t_dfops
);
514 list_add_tail(li
, &dfp
->dfp_work
);
518 /* Initialize a deferred operation list. */
520 xfs_defer_init_op_type(
521 const struct xfs_defer_op_type
*type
)
523 defer_op_types
[type
->type
] = type
;
527 * Move deferred ops from one transaction to another and reset the source to
528 * initial state. This is primarily used to carry state forward across
529 * transaction rolls with pending dfops.
533 struct xfs_trans
*dtp
,
534 struct xfs_trans
*stp
)
536 list_splice_init(&stp
->t_dfops
, &dtp
->t_dfops
);
539 * Low free space mode was historically controlled by a dfops field.
540 * This meant that low mode state potentially carried across multiple
541 * transaction rolls. Transfer low mode on a dfops move to preserve
544 dtp
->t_flags
|= (stp
->t_flags
& XFS_TRANS_LOWMODE
);
546 xfs_defer_reset(stp
);