xref: /openbmc/linux/fs/xfs/libxfs/xfs_defer.c (revision bb47d797)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2016 Oracle.  All Rights Reserved.
4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
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_mount.h"
13 #include "xfs_defer.h"
14 #include "xfs_trans.h"
15 #include "xfs_buf_item.h"
16 #include "xfs_inode.h"
17 #include "xfs_inode_item.h"
18 #include "xfs_trace.h"
19 
20 /*
21  * Deferred Operations in XFS
22  *
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
29  * more generic.
30  *
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
39  * is not necessary.
40  *
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.
46  *
47  * Finishing a set of deferred operations is an involved process.  To
48  * start, we define "rolling a deferred-op transaction" as follows:
49  *
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
56  *     dop_pending list.
57  * > Roll the transaction.
58  *
59  * NOTE: To avoid exceeding the transaction reservation, we limit the
60  * number of items that we attach to a given xfs_defer_pending.
61  *
62  * The actual finishing process looks like this:
63  *
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
67  *     log intent item.
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
74  *       details.
75  *
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
80  * as needed.
81  *
82  * Requesting a Fresh Transaction while Finishing Deferred Work
83  *
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.
89  *
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
96  * that this happens.
97  *
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.
109  *
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
112  * there:
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  * +-------------------------------------------------+
152  *
153  * If we should crash before t2 commits, log recovery replays
154  * the following intent items:
155  *
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)
161  *
162  * In the process of recovering, it should also generate and take care
163  * of these intent items:
164  *
165  * - Intent to free extent (C, B)
166  * - Intent to free extent (F, 1) (refcountbt block)
167  * - Intent to remove rmap (F, 1, REFC)
168  *
169  * Note that the continuation requested between t2 and t3 is likely to
170  * reoccur.
171  */
172 
173 static const struct xfs_defer_op_type *defer_op_types[] = {
174 	[XFS_DEFER_OPS_TYPE_BMAP]	= &xfs_bmap_update_defer_type,
175 	[XFS_DEFER_OPS_TYPE_REFCOUNT]	= &xfs_refcount_update_defer_type,
176 	[XFS_DEFER_OPS_TYPE_RMAP]	= &xfs_rmap_update_defer_type,
177 	[XFS_DEFER_OPS_TYPE_FREE]	= &xfs_extent_free_defer_type,
178 	[XFS_DEFER_OPS_TYPE_AGFL_FREE]	= &xfs_agfl_free_defer_type,
179 };
180 
181 static void
182 xfs_defer_create_intent(
183 	struct xfs_trans		*tp,
184 	struct xfs_defer_pending	*dfp,
185 	bool				sort)
186 {
187 	const struct xfs_defer_op_type	*ops = defer_op_types[dfp->dfp_type];
188 
189 	dfp->dfp_intent = ops->create_intent(tp, &dfp->dfp_work,
190 			dfp->dfp_count, sort);
191 }
192 
193 /*
194  * For each pending item in the intake list, log its intent item and the
195  * associated extents, then add the entire intake list to the end of
196  * the pending list.
197  */
198 STATIC void
199 xfs_defer_create_intents(
200 	struct xfs_trans		*tp)
201 {
202 	struct xfs_defer_pending	*dfp;
203 
204 	list_for_each_entry(dfp, &tp->t_dfops, dfp_list) {
205 		trace_xfs_defer_create_intent(tp->t_mountp, dfp);
206 		xfs_defer_create_intent(tp, dfp, true);
207 	}
208 }
209 
210 /* Abort all the intents that were committed. */
211 STATIC void
212 xfs_defer_trans_abort(
213 	struct xfs_trans		*tp,
214 	struct list_head		*dop_pending)
215 {
216 	struct xfs_defer_pending	*dfp;
217 	const struct xfs_defer_op_type	*ops;
218 
219 	trace_xfs_defer_trans_abort(tp, _RET_IP_);
220 
221 	/* Abort intent items that don't have a done item. */
222 	list_for_each_entry(dfp, dop_pending, dfp_list) {
223 		ops = defer_op_types[dfp->dfp_type];
224 		trace_xfs_defer_pending_abort(tp->t_mountp, dfp);
225 		if (dfp->dfp_intent && !dfp->dfp_done) {
226 			ops->abort_intent(dfp->dfp_intent);
227 			dfp->dfp_intent = NULL;
228 		}
229 	}
230 }
231 
232 /* Roll a transaction so we can do some deferred op processing. */
233 STATIC int
234 xfs_defer_trans_roll(
235 	struct xfs_trans		**tpp)
236 {
237 	struct xfs_trans		*tp = *tpp;
238 	struct xfs_buf_log_item		*bli;
239 	struct xfs_inode_log_item	*ili;
240 	struct xfs_log_item		*lip;
241 	struct xfs_buf			*bplist[XFS_DEFER_OPS_NR_BUFS];
242 	struct xfs_inode		*iplist[XFS_DEFER_OPS_NR_INODES];
243 	int				bpcount = 0, ipcount = 0;
244 	int				i;
245 	int				error;
246 
247 	list_for_each_entry(lip, &tp->t_items, li_trans) {
248 		switch (lip->li_type) {
249 		case XFS_LI_BUF:
250 			bli = container_of(lip, struct xfs_buf_log_item,
251 					   bli_item);
252 			if (bli->bli_flags & XFS_BLI_HOLD) {
253 				if (bpcount >= XFS_DEFER_OPS_NR_BUFS) {
254 					ASSERT(0);
255 					return -EFSCORRUPTED;
256 				}
257 				xfs_trans_dirty_buf(tp, bli->bli_buf);
258 				bplist[bpcount++] = bli->bli_buf;
259 			}
260 			break;
261 		case XFS_LI_INODE:
262 			ili = container_of(lip, struct xfs_inode_log_item,
263 					   ili_item);
264 			if (ili->ili_lock_flags == 0) {
265 				if (ipcount >= XFS_DEFER_OPS_NR_INODES) {
266 					ASSERT(0);
267 					return -EFSCORRUPTED;
268 				}
269 				xfs_trans_log_inode(tp, ili->ili_inode,
270 						    XFS_ILOG_CORE);
271 				iplist[ipcount++] = ili->ili_inode;
272 			}
273 			break;
274 		default:
275 			break;
276 		}
277 	}
278 
279 	trace_xfs_defer_trans_roll(tp, _RET_IP_);
280 
281 	/*
282 	 * Roll the transaction.  Rolling always given a new transaction (even
283 	 * if committing the old one fails!) to hand back to the caller, so we
284 	 * join the held resources to the new transaction so that we always
285 	 * return with the held resources joined to @tpp, no matter what
286 	 * happened.
287 	 */
288 	error = xfs_trans_roll(tpp);
289 	tp = *tpp;
290 
291 	/* Rejoin the joined inodes. */
292 	for (i = 0; i < ipcount; i++)
293 		xfs_trans_ijoin(tp, iplist[i], 0);
294 
295 	/* Rejoin the buffers and dirty them so the log moves forward. */
296 	for (i = 0; i < bpcount; i++) {
297 		xfs_trans_bjoin(tp, bplist[i]);
298 		xfs_trans_bhold(tp, bplist[i]);
299 	}
300 
301 	if (error)
302 		trace_xfs_defer_trans_roll_error(tp, error);
303 	return error;
304 }
305 
306 /*
307  * Reset an already used dfops after finish.
308  */
309 static void
310 xfs_defer_reset(
311 	struct xfs_trans	*tp)
312 {
313 	ASSERT(list_empty(&tp->t_dfops));
314 
315 	/*
316 	 * Low mode state transfers across transaction rolls to mirror dfops
317 	 * lifetime. Clear it now that dfops is reset.
318 	 */
319 	tp->t_flags &= ~XFS_TRANS_LOWMODE;
320 }
321 
322 /*
323  * Free up any items left in the list.
324  */
325 static void
326 xfs_defer_cancel_list(
327 	struct xfs_mount		*mp,
328 	struct list_head		*dop_list)
329 {
330 	struct xfs_defer_pending	*dfp;
331 	struct xfs_defer_pending	*pli;
332 	struct list_head		*pwi;
333 	struct list_head		*n;
334 	const struct xfs_defer_op_type	*ops;
335 
336 	/*
337 	 * Free the pending items.  Caller should already have arranged
338 	 * for the intent items to be released.
339 	 */
340 	list_for_each_entry_safe(dfp, pli, dop_list, dfp_list) {
341 		ops = defer_op_types[dfp->dfp_type];
342 		trace_xfs_defer_cancel_list(mp, dfp);
343 		list_del(&dfp->dfp_list);
344 		list_for_each_safe(pwi, n, &dfp->dfp_work) {
345 			list_del(pwi);
346 			dfp->dfp_count--;
347 			ops->cancel_item(pwi);
348 		}
349 		ASSERT(dfp->dfp_count == 0);
350 		kmem_free(dfp);
351 	}
352 }
353 
354 /*
355  * Log an intent-done item for the first pending intent, and finish the work
356  * items.
357  */
358 static int
359 xfs_defer_finish_one(
360 	struct xfs_trans		*tp,
361 	struct xfs_defer_pending	*dfp)
362 {
363 	const struct xfs_defer_op_type	*ops = defer_op_types[dfp->dfp_type];
364 	void				*state = NULL;
365 	struct list_head		*li, *n;
366 	int				error;
367 
368 	trace_xfs_defer_pending_finish(tp->t_mountp, dfp);
369 
370 	dfp->dfp_done = ops->create_done(tp, dfp->dfp_intent, dfp->dfp_count);
371 	list_for_each_safe(li, n, &dfp->dfp_work) {
372 		list_del(li);
373 		dfp->dfp_count--;
374 		error = ops->finish_item(tp, li, dfp->dfp_done, &state);
375 		if (error == -EAGAIN) {
376 			/*
377 			 * Caller wants a fresh transaction; put the work item
378 			 * back on the list and log a new log intent item to
379 			 * replace the old one.  See "Requesting a Fresh
380 			 * Transaction while Finishing Deferred Work" above.
381 			 */
382 			list_add(li, &dfp->dfp_work);
383 			dfp->dfp_count++;
384 			dfp->dfp_done = NULL;
385 			xfs_defer_create_intent(tp, dfp, false);
386 		}
387 
388 		if (error)
389 			goto out;
390 	}
391 
392 	/* Done with the dfp, free it. */
393 	list_del(&dfp->dfp_list);
394 	kmem_free(dfp);
395 out:
396 	if (ops->finish_cleanup)
397 		ops->finish_cleanup(tp, state, error);
398 	return error;
399 }
400 
401 /*
402  * Finish all the pending work.  This involves logging intent items for
403  * any work items that wandered in since the last transaction roll (if
404  * one has even happened), rolling the transaction, and finishing the
405  * work items in the first item on the logged-and-pending list.
406  *
407  * If an inode is provided, relog it to the new transaction.
408  */
409 int
410 xfs_defer_finish_noroll(
411 	struct xfs_trans		**tp)
412 {
413 	struct xfs_defer_pending	*dfp;
414 	int				error = 0;
415 	LIST_HEAD(dop_pending);
416 
417 	ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
418 
419 	trace_xfs_defer_finish(*tp, _RET_IP_);
420 
421 	/* Until we run out of pending work to finish... */
422 	while (!list_empty(&dop_pending) || !list_empty(&(*tp)->t_dfops)) {
423 		xfs_defer_create_intents(*tp);
424 		list_splice_tail_init(&(*tp)->t_dfops, &dop_pending);
425 
426 		error = xfs_defer_trans_roll(tp);
427 		if (error)
428 			goto out_shutdown;
429 
430 		dfp = list_first_entry(&dop_pending, struct xfs_defer_pending,
431 				       dfp_list);
432 		error = xfs_defer_finish_one(*tp, dfp);
433 		if (error && error != -EAGAIN)
434 			goto out_shutdown;
435 	}
436 
437 	trace_xfs_defer_finish_done(*tp, _RET_IP_);
438 	return 0;
439 
440 out_shutdown:
441 	xfs_defer_trans_abort(*tp, &dop_pending);
442 	xfs_force_shutdown((*tp)->t_mountp, SHUTDOWN_CORRUPT_INCORE);
443 	trace_xfs_defer_finish_error(*tp, error);
444 	xfs_defer_cancel_list((*tp)->t_mountp, &dop_pending);
445 	xfs_defer_cancel(*tp);
446 	return error;
447 }
448 
449 int
450 xfs_defer_finish(
451 	struct xfs_trans	**tp)
452 {
453 	int			error;
454 
455 	/*
456 	 * Finish and roll the transaction once more to avoid returning to the
457 	 * caller with a dirty transaction.
458 	 */
459 	error = xfs_defer_finish_noroll(tp);
460 	if (error)
461 		return error;
462 	if ((*tp)->t_flags & XFS_TRANS_DIRTY) {
463 		error = xfs_defer_trans_roll(tp);
464 		if (error) {
465 			xfs_force_shutdown((*tp)->t_mountp,
466 					   SHUTDOWN_CORRUPT_INCORE);
467 			return error;
468 		}
469 	}
470 	xfs_defer_reset(*tp);
471 	return 0;
472 }
473 
474 void
475 xfs_defer_cancel(
476 	struct xfs_trans	*tp)
477 {
478 	struct xfs_mount	*mp = tp->t_mountp;
479 
480 	trace_xfs_defer_cancel(tp, _RET_IP_);
481 	xfs_defer_cancel_list(mp, &tp->t_dfops);
482 }
483 
484 /* Add an item for later deferred processing. */
485 void
486 xfs_defer_add(
487 	struct xfs_trans		*tp,
488 	enum xfs_defer_ops_type		type,
489 	struct list_head		*li)
490 {
491 	struct xfs_defer_pending	*dfp = NULL;
492 	const struct xfs_defer_op_type	*ops;
493 
494 	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
495 	BUILD_BUG_ON(ARRAY_SIZE(defer_op_types) != XFS_DEFER_OPS_TYPE_MAX);
496 
497 	/*
498 	 * Add the item to a pending item at the end of the intake list.
499 	 * If the last pending item has the same type, reuse it.  Else,
500 	 * create a new pending item at the end of the intake list.
501 	 */
502 	if (!list_empty(&tp->t_dfops)) {
503 		dfp = list_last_entry(&tp->t_dfops,
504 				struct xfs_defer_pending, dfp_list);
505 		ops = defer_op_types[dfp->dfp_type];
506 		if (dfp->dfp_type != type ||
507 		    (ops->max_items && dfp->dfp_count >= ops->max_items))
508 			dfp = NULL;
509 	}
510 	if (!dfp) {
511 		dfp = kmem_alloc(sizeof(struct xfs_defer_pending),
512 				KM_NOFS);
513 		dfp->dfp_type = type;
514 		dfp->dfp_intent = NULL;
515 		dfp->dfp_done = NULL;
516 		dfp->dfp_count = 0;
517 		INIT_LIST_HEAD(&dfp->dfp_work);
518 		list_add_tail(&dfp->dfp_list, &tp->t_dfops);
519 	}
520 
521 	list_add_tail(li, &dfp->dfp_work);
522 	dfp->dfp_count++;
523 }
524 
525 /*
526  * Move deferred ops from one transaction to another and reset the source to
527  * initial state. This is primarily used to carry state forward across
528  * transaction rolls with pending dfops.
529  */
530 void
531 xfs_defer_move(
532 	struct xfs_trans	*dtp,
533 	struct xfs_trans	*stp)
534 {
535 	list_splice_init(&stp->t_dfops, &dtp->t_dfops);
536 
537 	/*
538 	 * Low free space mode was historically controlled by a dfops field.
539 	 * This meant that low mode state potentially carried across multiple
540 	 * transaction rolls. Transfer low mode on a dfops move to preserve
541 	 * that behavior.
542 	 */
543 	dtp->t_flags |= (stp->t_flags & XFS_TRANS_LOWMODE);
544 
545 	xfs_defer_reset(stp);
546 }
547