1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4  * Copyright (C) 2010 Red Hat, Inc.
5  * All Rights Reserved.
6  */
7 #include "xfs.h"
8 #include "xfs_fs.h"
9 #include "xfs_shared.h"
10 #include "xfs_format.h"
11 #include "xfs_log_format.h"
12 #include "xfs_trans_resv.h"
13 #include "xfs_mount.h"
14 #include "xfs_inode.h"
15 #include "xfs_extent_busy.h"
16 #include "xfs_quota.h"
17 #include "xfs_trans.h"
18 #include "xfs_trans_priv.h"
19 #include "xfs_log.h"
20 #include "xfs_trace.h"
21 #include "xfs_error.h"
22 #include "xfs_defer.h"
23 
24 kmem_zone_t	*xfs_trans_zone;
25 
26 #if defined(CONFIG_TRACEPOINTS)
27 static void
xfs_trans_trace_reservations(struct xfs_mount * mp)28 xfs_trans_trace_reservations(
29 	struct xfs_mount	*mp)
30 {
31 	struct xfs_trans_res	resv;
32 	struct xfs_trans_res	*res;
33 	struct xfs_trans_res	*end_res;
34 	int			i;
35 
36 	res = (struct xfs_trans_res *)M_RES(mp);
37 	end_res = (struct xfs_trans_res *)(M_RES(mp) + 1);
38 	for (i = 0; res < end_res; i++, res++)
39 		trace_xfs_trans_resv_calc(mp, i, res);
40 	xfs_log_get_max_trans_res(mp, &resv);
41 	trace_xfs_trans_resv_calc(mp, -1, &resv);
42 }
43 #else
44 # define xfs_trans_trace_reservations(mp)
45 #endif
46 
47 /*
48  * Initialize the precomputed transaction reservation values
49  * in the mount structure.
50  */
51 void
xfs_trans_init(struct xfs_mount * mp)52 xfs_trans_init(
53 	struct xfs_mount	*mp)
54 {
55 	xfs_trans_resv_calc(mp, M_RES(mp));
56 	xfs_trans_trace_reservations(mp);
57 }
58 
59 /*
60  * Free the transaction structure.  If there is more clean up
61  * to do when the structure is freed, add it here.
62  */
63 STATIC void
xfs_trans_free(struct xfs_trans * tp)64 xfs_trans_free(
65 	struct xfs_trans	*tp)
66 {
67 	xfs_extent_busy_sort(&tp->t_busy);
68 	xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
69 
70 	trace_xfs_trans_free(tp, _RET_IP_);
71 	atomic_dec(&tp->t_mountp->m_active_trans);
72 	if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT))
73 		sb_end_intwrite(tp->t_mountp->m_super);
74 	xfs_trans_free_dqinfo(tp);
75 	kmem_zone_free(xfs_trans_zone, tp);
76 }
77 
78 /*
79  * This is called to create a new transaction which will share the
80  * permanent log reservation of the given transaction.  The remaining
81  * unused block and rt extent reservations are also inherited.  This
82  * implies that the original transaction is no longer allowed to allocate
83  * blocks.  Locks and log items, however, are no inherited.  They must
84  * be added to the new transaction explicitly.
85  */
86 STATIC struct xfs_trans *
xfs_trans_dup(struct xfs_trans * tp)87 xfs_trans_dup(
88 	struct xfs_trans	*tp)
89 {
90 	struct xfs_trans	*ntp;
91 
92 	trace_xfs_trans_dup(tp, _RET_IP_);
93 
94 	ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
95 
96 	/*
97 	 * Initialize the new transaction structure.
98 	 */
99 	ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
100 	ntp->t_mountp = tp->t_mountp;
101 	INIT_LIST_HEAD(&ntp->t_items);
102 	INIT_LIST_HEAD(&ntp->t_busy);
103 	INIT_LIST_HEAD(&ntp->t_dfops);
104 	ntp->t_firstblock = NULLFSBLOCK;
105 
106 	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
107 	ASSERT(tp->t_ticket != NULL);
108 
109 	ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
110 		       (tp->t_flags & XFS_TRANS_RESERVE) |
111 		       (tp->t_flags & XFS_TRANS_NO_WRITECOUNT);
112 	/* We gave our writer reference to the new transaction */
113 	tp->t_flags |= XFS_TRANS_NO_WRITECOUNT;
114 	ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
115 
116 	ASSERT(tp->t_blk_res >= tp->t_blk_res_used);
117 	ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
118 	tp->t_blk_res = tp->t_blk_res_used;
119 
120 	ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
121 	tp->t_rtx_res = tp->t_rtx_res_used;
122 	ntp->t_pflags = tp->t_pflags;
123 
124 	/* move deferred ops over to the new tp */
125 	xfs_defer_move(ntp, tp);
126 
127 	xfs_trans_dup_dqinfo(tp, ntp);
128 
129 	atomic_inc(&tp->t_mountp->m_active_trans);
130 	return ntp;
131 }
132 
133 /*
134  * This is called to reserve free disk blocks and log space for the
135  * given transaction.  This must be done before allocating any resources
136  * within the transaction.
137  *
138  * This will return ENOSPC if there are not enough blocks available.
139  * It will sleep waiting for available log space.
140  * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
141  * is used by long running transactions.  If any one of the reservations
142  * fails then they will all be backed out.
143  *
144  * This does not do quota reservations. That typically is done by the
145  * caller afterwards.
146  */
147 static int
xfs_trans_reserve(struct xfs_trans * tp,struct xfs_trans_res * resp,uint blocks,uint rtextents)148 xfs_trans_reserve(
149 	struct xfs_trans	*tp,
150 	struct xfs_trans_res	*resp,
151 	uint			blocks,
152 	uint			rtextents)
153 {
154 	int		error = 0;
155 	bool		rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
156 
157 	/* Mark this thread as being in a transaction */
158 	current_set_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
159 
160 	/*
161 	 * Attempt to reserve the needed disk blocks by decrementing
162 	 * the number needed from the number available.  This will
163 	 * fail if the count would go below zero.
164 	 */
165 	if (blocks > 0) {
166 		error = xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd);
167 		if (error != 0) {
168 			current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
169 			return -ENOSPC;
170 		}
171 		tp->t_blk_res += blocks;
172 	}
173 
174 	/*
175 	 * Reserve the log space needed for this transaction.
176 	 */
177 	if (resp->tr_logres > 0) {
178 		bool	permanent = false;
179 
180 		ASSERT(tp->t_log_res == 0 ||
181 		       tp->t_log_res == resp->tr_logres);
182 		ASSERT(tp->t_log_count == 0 ||
183 		       tp->t_log_count == resp->tr_logcount);
184 
185 		if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
186 			tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
187 			permanent = true;
188 		} else {
189 			ASSERT(tp->t_ticket == NULL);
190 			ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
191 		}
192 
193 		if (tp->t_ticket != NULL) {
194 			ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
195 			error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
196 		} else {
197 			error = xfs_log_reserve(tp->t_mountp,
198 						resp->tr_logres,
199 						resp->tr_logcount,
200 						&tp->t_ticket, XFS_TRANSACTION,
201 						permanent);
202 		}
203 
204 		if (error)
205 			goto undo_blocks;
206 
207 		tp->t_log_res = resp->tr_logres;
208 		tp->t_log_count = resp->tr_logcount;
209 	}
210 
211 	/*
212 	 * Attempt to reserve the needed realtime extents by decrementing
213 	 * the number needed from the number available.  This will
214 	 * fail if the count would go below zero.
215 	 */
216 	if (rtextents > 0) {
217 		error = xfs_mod_frextents(tp->t_mountp, -((int64_t)rtextents));
218 		if (error) {
219 			error = -ENOSPC;
220 			goto undo_log;
221 		}
222 		tp->t_rtx_res += rtextents;
223 	}
224 
225 	return 0;
226 
227 	/*
228 	 * Error cases jump to one of these labels to undo any
229 	 * reservations which have already been performed.
230 	 */
231 undo_log:
232 	if (resp->tr_logres > 0) {
233 		xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, false);
234 		tp->t_ticket = NULL;
235 		tp->t_log_res = 0;
236 		tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
237 	}
238 
239 undo_blocks:
240 	if (blocks > 0) {
241 		xfs_mod_fdblocks(tp->t_mountp, (int64_t)blocks, rsvd);
242 		tp->t_blk_res = 0;
243 	}
244 
245 	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
246 
247 	return error;
248 }
249 
250 int
xfs_trans_alloc(struct xfs_mount * mp,struct xfs_trans_res * resp,uint blocks,uint rtextents,uint flags,struct xfs_trans ** tpp)251 xfs_trans_alloc(
252 	struct xfs_mount	*mp,
253 	struct xfs_trans_res	*resp,
254 	uint			blocks,
255 	uint			rtextents,
256 	uint			flags,
257 	struct xfs_trans	**tpp)
258 {
259 	struct xfs_trans	*tp;
260 	int			error;
261 
262 	/*
263 	 * Allocate the handle before we do our freeze accounting and setting up
264 	 * GFP_NOFS allocation context so that we avoid lockdep false positives
265 	 * by doing GFP_KERNEL allocations inside sb_start_intwrite().
266 	 */
267 	tp = kmem_zone_zalloc(xfs_trans_zone,
268 		(flags & XFS_TRANS_NOFS) ? KM_NOFS : KM_SLEEP);
269 
270 	if (!(flags & XFS_TRANS_NO_WRITECOUNT))
271 		sb_start_intwrite(mp->m_super);
272 
273 	/*
274 	 * Zero-reservation ("empty") transactions can't modify anything, so
275 	 * they're allowed to run while we're frozen.
276 	 */
277 	WARN_ON(resp->tr_logres > 0 &&
278 		mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
279 	atomic_inc(&mp->m_active_trans);
280 
281 	tp->t_magic = XFS_TRANS_HEADER_MAGIC;
282 	tp->t_flags = flags;
283 	tp->t_mountp = mp;
284 	INIT_LIST_HEAD(&tp->t_items);
285 	INIT_LIST_HEAD(&tp->t_busy);
286 	INIT_LIST_HEAD(&tp->t_dfops);
287 	tp->t_firstblock = NULLFSBLOCK;
288 
289 	error = xfs_trans_reserve(tp, resp, blocks, rtextents);
290 	if (error) {
291 		xfs_trans_cancel(tp);
292 		return error;
293 	}
294 
295 	trace_xfs_trans_alloc(tp, _RET_IP_);
296 
297 	*tpp = tp;
298 	return 0;
299 }
300 
301 /*
302  * Create an empty transaction with no reservation.  This is a defensive
303  * mechanism for routines that query metadata without actually modifying
304  * them -- if the metadata being queried is somehow cross-linked (think a
305  * btree block pointer that points higher in the tree), we risk deadlock.
306  * However, blocks grabbed as part of a transaction can be re-grabbed.
307  * The verifiers will notice the corrupt block and the operation will fail
308  * back to userspace without deadlocking.
309  *
310  * Note the zero-length reservation; this transaction MUST be cancelled
311  * without any dirty data.
312  */
313 int
xfs_trans_alloc_empty(struct xfs_mount * mp,struct xfs_trans ** tpp)314 xfs_trans_alloc_empty(
315 	struct xfs_mount		*mp,
316 	struct xfs_trans		**tpp)
317 {
318 	struct xfs_trans_res		resv = {0};
319 
320 	return xfs_trans_alloc(mp, &resv, 0, 0, XFS_TRANS_NO_WRITECOUNT, tpp);
321 }
322 
323 /*
324  * Record the indicated change to the given field for application
325  * to the file system's superblock when the transaction commits.
326  * For now, just store the change in the transaction structure.
327  *
328  * Mark the transaction structure to indicate that the superblock
329  * needs to be updated before committing.
330  *
331  * Because we may not be keeping track of allocated/free inodes and
332  * used filesystem blocks in the superblock, we do not mark the
333  * superblock dirty in this transaction if we modify these fields.
334  * We still need to update the transaction deltas so that they get
335  * applied to the incore superblock, but we don't want them to
336  * cause the superblock to get locked and logged if these are the
337  * only fields in the superblock that the transaction modifies.
338  */
339 void
xfs_trans_mod_sb(xfs_trans_t * tp,uint field,int64_t delta)340 xfs_trans_mod_sb(
341 	xfs_trans_t	*tp,
342 	uint		field,
343 	int64_t		delta)
344 {
345 	uint32_t	flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
346 	xfs_mount_t	*mp = tp->t_mountp;
347 
348 	switch (field) {
349 	case XFS_TRANS_SB_ICOUNT:
350 		tp->t_icount_delta += delta;
351 		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
352 			flags &= ~XFS_TRANS_SB_DIRTY;
353 		break;
354 	case XFS_TRANS_SB_IFREE:
355 		tp->t_ifree_delta += delta;
356 		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
357 			flags &= ~XFS_TRANS_SB_DIRTY;
358 		break;
359 	case XFS_TRANS_SB_FDBLOCKS:
360 		/*
361 		 * Track the number of blocks allocated in the transaction.
362 		 * Make sure it does not exceed the number reserved. If so,
363 		 * shutdown as this can lead to accounting inconsistency.
364 		 */
365 		if (delta < 0) {
366 			tp->t_blk_res_used += (uint)-delta;
367 			if (tp->t_blk_res_used > tp->t_blk_res)
368 				xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
369 		}
370 		tp->t_fdblocks_delta += delta;
371 		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
372 			flags &= ~XFS_TRANS_SB_DIRTY;
373 		break;
374 	case XFS_TRANS_SB_RES_FDBLOCKS:
375 		/*
376 		 * The allocation has already been applied to the
377 		 * in-core superblock's counter.  This should only
378 		 * be applied to the on-disk superblock.
379 		 */
380 		tp->t_res_fdblocks_delta += delta;
381 		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
382 			flags &= ~XFS_TRANS_SB_DIRTY;
383 		break;
384 	case XFS_TRANS_SB_FREXTENTS:
385 		/*
386 		 * Track the number of blocks allocated in the
387 		 * transaction.  Make sure it does not exceed the
388 		 * number reserved.
389 		 */
390 		if (delta < 0) {
391 			tp->t_rtx_res_used += (uint)-delta;
392 			ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
393 		}
394 		tp->t_frextents_delta += delta;
395 		break;
396 	case XFS_TRANS_SB_RES_FREXTENTS:
397 		/*
398 		 * The allocation has already been applied to the
399 		 * in-core superblock's counter.  This should only
400 		 * be applied to the on-disk superblock.
401 		 */
402 		ASSERT(delta < 0);
403 		tp->t_res_frextents_delta += delta;
404 		break;
405 	case XFS_TRANS_SB_DBLOCKS:
406 		ASSERT(delta > 0);
407 		tp->t_dblocks_delta += delta;
408 		break;
409 	case XFS_TRANS_SB_AGCOUNT:
410 		ASSERT(delta > 0);
411 		tp->t_agcount_delta += delta;
412 		break;
413 	case XFS_TRANS_SB_IMAXPCT:
414 		tp->t_imaxpct_delta += delta;
415 		break;
416 	case XFS_TRANS_SB_REXTSIZE:
417 		tp->t_rextsize_delta += delta;
418 		break;
419 	case XFS_TRANS_SB_RBMBLOCKS:
420 		tp->t_rbmblocks_delta += delta;
421 		break;
422 	case XFS_TRANS_SB_RBLOCKS:
423 		tp->t_rblocks_delta += delta;
424 		break;
425 	case XFS_TRANS_SB_REXTENTS:
426 		tp->t_rextents_delta += delta;
427 		break;
428 	case XFS_TRANS_SB_REXTSLOG:
429 		tp->t_rextslog_delta += delta;
430 		break;
431 	default:
432 		ASSERT(0);
433 		return;
434 	}
435 
436 	tp->t_flags |= flags;
437 }
438 
439 /*
440  * xfs_trans_apply_sb_deltas() is called from the commit code
441  * to bring the superblock buffer into the current transaction
442  * and modify it as requested by earlier calls to xfs_trans_mod_sb().
443  *
444  * For now we just look at each field allowed to change and change
445  * it if necessary.
446  */
447 STATIC void
xfs_trans_apply_sb_deltas(xfs_trans_t * tp)448 xfs_trans_apply_sb_deltas(
449 	xfs_trans_t	*tp)
450 {
451 	xfs_dsb_t	*sbp;
452 	xfs_buf_t	*bp;
453 	int		whole = 0;
454 
455 	bp = xfs_trans_getsb(tp, tp->t_mountp, 0);
456 	sbp = XFS_BUF_TO_SBP(bp);
457 
458 	/*
459 	 * Check that superblock mods match the mods made to AGF counters.
460 	 */
461 	ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) ==
462 	       (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
463 		tp->t_ag_btree_delta));
464 
465 	/*
466 	 * Only update the superblock counters if we are logging them
467 	 */
468 	if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
469 		if (tp->t_icount_delta)
470 			be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
471 		if (tp->t_ifree_delta)
472 			be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
473 		if (tp->t_fdblocks_delta)
474 			be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
475 		if (tp->t_res_fdblocks_delta)
476 			be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
477 	}
478 
479 	if (tp->t_frextents_delta)
480 		be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
481 	if (tp->t_res_frextents_delta)
482 		be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
483 
484 	if (tp->t_dblocks_delta) {
485 		be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
486 		whole = 1;
487 	}
488 	if (tp->t_agcount_delta) {
489 		be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
490 		whole = 1;
491 	}
492 	if (tp->t_imaxpct_delta) {
493 		sbp->sb_imax_pct += tp->t_imaxpct_delta;
494 		whole = 1;
495 	}
496 	if (tp->t_rextsize_delta) {
497 		be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
498 		whole = 1;
499 	}
500 	if (tp->t_rbmblocks_delta) {
501 		be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
502 		whole = 1;
503 	}
504 	if (tp->t_rblocks_delta) {
505 		be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
506 		whole = 1;
507 	}
508 	if (tp->t_rextents_delta) {
509 		be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
510 		whole = 1;
511 	}
512 	if (tp->t_rextslog_delta) {
513 		sbp->sb_rextslog += tp->t_rextslog_delta;
514 		whole = 1;
515 	}
516 
517 	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
518 	if (whole)
519 		/*
520 		 * Log the whole thing, the fields are noncontiguous.
521 		 */
522 		xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
523 	else
524 		/*
525 		 * Since all the modifiable fields are contiguous, we
526 		 * can get away with this.
527 		 */
528 		xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
529 				  offsetof(xfs_dsb_t, sb_frextents) +
530 				  sizeof(sbp->sb_frextents) - 1);
531 }
532 
533 STATIC int
xfs_sb_mod8(uint8_t * field,int8_t delta)534 xfs_sb_mod8(
535 	uint8_t			*field,
536 	int8_t			delta)
537 {
538 	int8_t			counter = *field;
539 
540 	counter += delta;
541 	if (counter < 0) {
542 		ASSERT(0);
543 		return -EINVAL;
544 	}
545 	*field = counter;
546 	return 0;
547 }
548 
549 STATIC int
xfs_sb_mod32(uint32_t * field,int32_t delta)550 xfs_sb_mod32(
551 	uint32_t		*field,
552 	int32_t			delta)
553 {
554 	int32_t			counter = *field;
555 
556 	counter += delta;
557 	if (counter < 0) {
558 		ASSERT(0);
559 		return -EINVAL;
560 	}
561 	*field = counter;
562 	return 0;
563 }
564 
565 STATIC int
xfs_sb_mod64(uint64_t * field,int64_t delta)566 xfs_sb_mod64(
567 	uint64_t		*field,
568 	int64_t			delta)
569 {
570 	int64_t			counter = *field;
571 
572 	counter += delta;
573 	if (counter < 0) {
574 		ASSERT(0);
575 		return -EINVAL;
576 	}
577 	*field = counter;
578 	return 0;
579 }
580 
581 /*
582  * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations
583  * and apply superblock counter changes to the in-core superblock.  The
584  * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
585  * applied to the in-core superblock.  The idea is that that has already been
586  * done.
587  *
588  * If we are not logging superblock counters, then the inode allocated/free and
589  * used block counts are not updated in the on disk superblock. In this case,
590  * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
591  * still need to update the incore superblock with the changes.
592  */
593 void
xfs_trans_unreserve_and_mod_sb(struct xfs_trans * tp)594 xfs_trans_unreserve_and_mod_sb(
595 	struct xfs_trans	*tp)
596 {
597 	struct xfs_mount	*mp = tp->t_mountp;
598 	bool			rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
599 	int64_t			blkdelta = 0;
600 	int64_t			rtxdelta = 0;
601 	int64_t			idelta = 0;
602 	int64_t			ifreedelta = 0;
603 	int			error;
604 
605 	/* calculate deltas */
606 	if (tp->t_blk_res > 0)
607 		blkdelta = tp->t_blk_res;
608 	if ((tp->t_fdblocks_delta != 0) &&
609 	    (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
610 	     (tp->t_flags & XFS_TRANS_SB_DIRTY)))
611 	        blkdelta += tp->t_fdblocks_delta;
612 
613 	if (tp->t_rtx_res > 0)
614 		rtxdelta = tp->t_rtx_res;
615 	if ((tp->t_frextents_delta != 0) &&
616 	    (tp->t_flags & XFS_TRANS_SB_DIRTY))
617 		rtxdelta += tp->t_frextents_delta;
618 
619 	if (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
620 	     (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
621 		idelta = tp->t_icount_delta;
622 		ifreedelta = tp->t_ifree_delta;
623 	}
624 
625 	/* apply the per-cpu counters */
626 	if (blkdelta) {
627 		error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
628 		if (error)
629 			goto out;
630 	}
631 
632 	if (idelta) {
633 		error = xfs_mod_icount(mp, idelta);
634 		if (error)
635 			goto out_undo_fdblocks;
636 	}
637 
638 	if (ifreedelta) {
639 		error = xfs_mod_ifree(mp, ifreedelta);
640 		if (error)
641 			goto out_undo_icount;
642 	}
643 
644 	if (rtxdelta == 0 && !(tp->t_flags & XFS_TRANS_SB_DIRTY))
645 		return;
646 
647 	/* apply remaining deltas */
648 	spin_lock(&mp->m_sb_lock);
649 	if (rtxdelta) {
650 		error = xfs_sb_mod64(&mp->m_sb.sb_frextents, rtxdelta);
651 		if (error)
652 			goto out_undo_ifree;
653 	}
654 
655 	if (tp->t_dblocks_delta != 0) {
656 		error = xfs_sb_mod64(&mp->m_sb.sb_dblocks, tp->t_dblocks_delta);
657 		if (error)
658 			goto out_undo_frextents;
659 	}
660 	if (tp->t_agcount_delta != 0) {
661 		error = xfs_sb_mod32(&mp->m_sb.sb_agcount, tp->t_agcount_delta);
662 		if (error)
663 			goto out_undo_dblocks;
664 	}
665 	if (tp->t_imaxpct_delta != 0) {
666 		error = xfs_sb_mod8(&mp->m_sb.sb_imax_pct, tp->t_imaxpct_delta);
667 		if (error)
668 			goto out_undo_agcount;
669 	}
670 	if (tp->t_rextsize_delta != 0) {
671 		error = xfs_sb_mod32(&mp->m_sb.sb_rextsize,
672 				     tp->t_rextsize_delta);
673 		if (error)
674 			goto out_undo_imaxpct;
675 	}
676 	if (tp->t_rbmblocks_delta != 0) {
677 		error = xfs_sb_mod32(&mp->m_sb.sb_rbmblocks,
678 				     tp->t_rbmblocks_delta);
679 		if (error)
680 			goto out_undo_rextsize;
681 	}
682 	if (tp->t_rblocks_delta != 0) {
683 		error = xfs_sb_mod64(&mp->m_sb.sb_rblocks, tp->t_rblocks_delta);
684 		if (error)
685 			goto out_undo_rbmblocks;
686 	}
687 	if (tp->t_rextents_delta != 0) {
688 		error = xfs_sb_mod64(&mp->m_sb.sb_rextents,
689 				     tp->t_rextents_delta);
690 		if (error)
691 			goto out_undo_rblocks;
692 	}
693 	if (tp->t_rextslog_delta != 0) {
694 		error = xfs_sb_mod8(&mp->m_sb.sb_rextslog,
695 				     tp->t_rextslog_delta);
696 		if (error)
697 			goto out_undo_rextents;
698 	}
699 	spin_unlock(&mp->m_sb_lock);
700 	return;
701 
702 out_undo_rextents:
703 	if (tp->t_rextents_delta)
704 		xfs_sb_mod64(&mp->m_sb.sb_rextents, -tp->t_rextents_delta);
705 out_undo_rblocks:
706 	if (tp->t_rblocks_delta)
707 		xfs_sb_mod64(&mp->m_sb.sb_rblocks, -tp->t_rblocks_delta);
708 out_undo_rbmblocks:
709 	if (tp->t_rbmblocks_delta)
710 		xfs_sb_mod32(&mp->m_sb.sb_rbmblocks, -tp->t_rbmblocks_delta);
711 out_undo_rextsize:
712 	if (tp->t_rextsize_delta)
713 		xfs_sb_mod32(&mp->m_sb.sb_rextsize, -tp->t_rextsize_delta);
714 out_undo_imaxpct:
715 	if (tp->t_rextsize_delta)
716 		xfs_sb_mod8(&mp->m_sb.sb_imax_pct, -tp->t_imaxpct_delta);
717 out_undo_agcount:
718 	if (tp->t_agcount_delta)
719 		xfs_sb_mod32(&mp->m_sb.sb_agcount, -tp->t_agcount_delta);
720 out_undo_dblocks:
721 	if (tp->t_dblocks_delta)
722 		xfs_sb_mod64(&mp->m_sb.sb_dblocks, -tp->t_dblocks_delta);
723 out_undo_frextents:
724 	if (rtxdelta)
725 		xfs_sb_mod64(&mp->m_sb.sb_frextents, -rtxdelta);
726 out_undo_ifree:
727 	spin_unlock(&mp->m_sb_lock);
728 	if (ifreedelta)
729 		xfs_mod_ifree(mp, -ifreedelta);
730 out_undo_icount:
731 	if (idelta)
732 		xfs_mod_icount(mp, -idelta);
733 out_undo_fdblocks:
734 	if (blkdelta)
735 		xfs_mod_fdblocks(mp, -blkdelta, rsvd);
736 out:
737 	ASSERT(error == 0);
738 	return;
739 }
740 
741 /* Add the given log item to the transaction's list of log items. */
742 void
xfs_trans_add_item(struct xfs_trans * tp,struct xfs_log_item * lip)743 xfs_trans_add_item(
744 	struct xfs_trans	*tp,
745 	struct xfs_log_item	*lip)
746 {
747 	ASSERT(lip->li_mountp == tp->t_mountp);
748 	ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
749 	ASSERT(list_empty(&lip->li_trans));
750 	ASSERT(!test_bit(XFS_LI_DIRTY, &lip->li_flags));
751 
752 	list_add_tail(&lip->li_trans, &tp->t_items);
753 	trace_xfs_trans_add_item(tp, _RET_IP_);
754 }
755 
756 /*
757  * Unlink the log item from the transaction. the log item is no longer
758  * considered dirty in this transaction, as the linked transaction has
759  * finished, either by abort or commit completion.
760  */
761 void
xfs_trans_del_item(struct xfs_log_item * lip)762 xfs_trans_del_item(
763 	struct xfs_log_item	*lip)
764 {
765 	clear_bit(XFS_LI_DIRTY, &lip->li_flags);
766 	list_del_init(&lip->li_trans);
767 }
768 
769 /* Detach and unlock all of the items in a transaction */
770 void
xfs_trans_free_items(struct xfs_trans * tp,xfs_lsn_t commit_lsn,bool abort)771 xfs_trans_free_items(
772 	struct xfs_trans	*tp,
773 	xfs_lsn_t		commit_lsn,
774 	bool			abort)
775 {
776 	struct xfs_log_item	*lip, *next;
777 
778 	trace_xfs_trans_free_items(tp, _RET_IP_);
779 
780 	list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) {
781 		xfs_trans_del_item(lip);
782 		if (commit_lsn != NULLCOMMITLSN)
783 			lip->li_ops->iop_committing(lip, commit_lsn);
784 		if (abort)
785 			set_bit(XFS_LI_ABORTED, &lip->li_flags);
786 		lip->li_ops->iop_unlock(lip);
787 	}
788 }
789 
790 static inline void
xfs_log_item_batch_insert(struct xfs_ail * ailp,struct xfs_ail_cursor * cur,struct xfs_log_item ** log_items,int nr_items,xfs_lsn_t commit_lsn)791 xfs_log_item_batch_insert(
792 	struct xfs_ail		*ailp,
793 	struct xfs_ail_cursor	*cur,
794 	struct xfs_log_item	**log_items,
795 	int			nr_items,
796 	xfs_lsn_t		commit_lsn)
797 {
798 	int	i;
799 
800 	spin_lock(&ailp->ail_lock);
801 	/* xfs_trans_ail_update_bulk drops ailp->ail_lock */
802 	xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
803 
804 	for (i = 0; i < nr_items; i++) {
805 		struct xfs_log_item *lip = log_items[i];
806 
807 		lip->li_ops->iop_unpin(lip, 0);
808 	}
809 }
810 
811 /*
812  * Bulk operation version of xfs_trans_committed that takes a log vector of
813  * items to insert into the AIL. This uses bulk AIL insertion techniques to
814  * minimise lock traffic.
815  *
816  * If we are called with the aborted flag set, it is because a log write during
817  * a CIL checkpoint commit has failed. In this case, all the items in the
818  * checkpoint have already gone through iop_commited and iop_unlock, which
819  * means that checkpoint commit abort handling is treated exactly the same
820  * as an iclog write error even though we haven't started any IO yet. Hence in
821  * this case all we need to do is iop_committed processing, followed by an
822  * iop_unpin(aborted) call.
823  *
824  * The AIL cursor is used to optimise the insert process. If commit_lsn is not
825  * at the end of the AIL, the insert cursor avoids the need to walk
826  * the AIL to find the insertion point on every xfs_log_item_batch_insert()
827  * call. This saves a lot of needless list walking and is a net win, even
828  * though it slightly increases that amount of AIL lock traffic to set it up
829  * and tear it down.
830  */
831 void
xfs_trans_committed_bulk(struct xfs_ail * ailp,struct xfs_log_vec * log_vector,xfs_lsn_t commit_lsn,int aborted)832 xfs_trans_committed_bulk(
833 	struct xfs_ail		*ailp,
834 	struct xfs_log_vec	*log_vector,
835 	xfs_lsn_t		commit_lsn,
836 	int			aborted)
837 {
838 #define LOG_ITEM_BATCH_SIZE	32
839 	struct xfs_log_item	*log_items[LOG_ITEM_BATCH_SIZE];
840 	struct xfs_log_vec	*lv;
841 	struct xfs_ail_cursor	cur;
842 	int			i = 0;
843 
844 	spin_lock(&ailp->ail_lock);
845 	xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
846 	spin_unlock(&ailp->ail_lock);
847 
848 	/* unpin all the log items */
849 	for (lv = log_vector; lv; lv = lv->lv_next ) {
850 		struct xfs_log_item	*lip = lv->lv_item;
851 		xfs_lsn_t		item_lsn;
852 
853 		if (aborted)
854 			set_bit(XFS_LI_ABORTED, &lip->li_flags);
855 		item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
856 
857 		/* item_lsn of -1 means the item needs no further processing */
858 		if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
859 			continue;
860 
861 		/*
862 		 * if we are aborting the operation, no point in inserting the
863 		 * object into the AIL as we are in a shutdown situation.
864 		 */
865 		if (aborted) {
866 			ASSERT(XFS_FORCED_SHUTDOWN(ailp->ail_mount));
867 			lip->li_ops->iop_unpin(lip, 1);
868 			continue;
869 		}
870 
871 		if (item_lsn != commit_lsn) {
872 
873 			/*
874 			 * Not a bulk update option due to unusual item_lsn.
875 			 * Push into AIL immediately, rechecking the lsn once
876 			 * we have the ail lock. Then unpin the item. This does
877 			 * not affect the AIL cursor the bulk insert path is
878 			 * using.
879 			 */
880 			spin_lock(&ailp->ail_lock);
881 			if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
882 				xfs_trans_ail_update(ailp, lip, item_lsn);
883 			else
884 				spin_unlock(&ailp->ail_lock);
885 			lip->li_ops->iop_unpin(lip, 0);
886 			continue;
887 		}
888 
889 		/* Item is a candidate for bulk AIL insert.  */
890 		log_items[i++] = lv->lv_item;
891 		if (i >= LOG_ITEM_BATCH_SIZE) {
892 			xfs_log_item_batch_insert(ailp, &cur, log_items,
893 					LOG_ITEM_BATCH_SIZE, commit_lsn);
894 			i = 0;
895 		}
896 	}
897 
898 	/* make sure we insert the remainder! */
899 	if (i)
900 		xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
901 
902 	spin_lock(&ailp->ail_lock);
903 	xfs_trans_ail_cursor_done(&cur);
904 	spin_unlock(&ailp->ail_lock);
905 }
906 
907 /*
908  * Commit the given transaction to the log.
909  *
910  * XFS disk error handling mechanism is not based on a typical
911  * transaction abort mechanism. Logically after the filesystem
912  * gets marked 'SHUTDOWN', we can't let any new transactions
913  * be durable - ie. committed to disk - because some metadata might
914  * be inconsistent. In such cases, this returns an error, and the
915  * caller may assume that all locked objects joined to the transaction
916  * have already been unlocked as if the commit had succeeded.
917  * Do not reference the transaction structure after this call.
918  */
919 static int
__xfs_trans_commit(struct xfs_trans * tp,bool regrant)920 __xfs_trans_commit(
921 	struct xfs_trans	*tp,
922 	bool			regrant)
923 {
924 	struct xfs_mount	*mp = tp->t_mountp;
925 	xfs_lsn_t		commit_lsn = -1;
926 	int			error = 0;
927 	int			sync = tp->t_flags & XFS_TRANS_SYNC;
928 
929 	trace_xfs_trans_commit(tp, _RET_IP_);
930 
931 	/*
932 	 * Finish deferred items on final commit. Only permanent transactions
933 	 * should ever have deferred ops.
934 	 */
935 	WARN_ON_ONCE(!list_empty(&tp->t_dfops) &&
936 		     !(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
937 	if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) {
938 		error = xfs_defer_finish_noroll(&tp);
939 		if (error)
940 			goto out_unreserve;
941 	}
942 
943 	/*
944 	 * If there is nothing to be logged by the transaction,
945 	 * then unlock all of the items associated with the
946 	 * transaction and free the transaction structure.
947 	 * Also make sure to return any reserved blocks to
948 	 * the free pool.
949 	 */
950 	if (!(tp->t_flags & XFS_TRANS_DIRTY))
951 		goto out_unreserve;
952 
953 	if (XFS_FORCED_SHUTDOWN(mp)) {
954 		error = -EIO;
955 		goto out_unreserve;
956 	}
957 
958 	ASSERT(tp->t_ticket != NULL);
959 
960 	/*
961 	 * If we need to update the superblock, then do it now.
962 	 */
963 	if (tp->t_flags & XFS_TRANS_SB_DIRTY)
964 		xfs_trans_apply_sb_deltas(tp);
965 	xfs_trans_apply_dquot_deltas(tp);
966 
967 	xfs_log_commit_cil(mp, tp, &commit_lsn, regrant);
968 
969 	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
970 	xfs_trans_free(tp);
971 
972 	/*
973 	 * If the transaction needs to be synchronous, then force the
974 	 * log out now and wait for it.
975 	 */
976 	if (sync) {
977 		error = xfs_log_force_lsn(mp, commit_lsn, XFS_LOG_SYNC, NULL);
978 		XFS_STATS_INC(mp, xs_trans_sync);
979 	} else {
980 		XFS_STATS_INC(mp, xs_trans_async);
981 	}
982 
983 	return error;
984 
985 out_unreserve:
986 	xfs_trans_unreserve_and_mod_sb(tp);
987 
988 	/*
989 	 * It is indeed possible for the transaction to be not dirty but
990 	 * the dqinfo portion to be.  All that means is that we have some
991 	 * (non-persistent) quota reservations that need to be unreserved.
992 	 */
993 	xfs_trans_unreserve_and_mod_dquots(tp);
994 	if (tp->t_ticket) {
995 		commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, regrant);
996 		if (commit_lsn == -1 && !error)
997 			error = -EIO;
998 		tp->t_ticket = NULL;
999 	}
1000 	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
1001 	xfs_trans_free_items(tp, NULLCOMMITLSN, !!error);
1002 	xfs_trans_free(tp);
1003 
1004 	XFS_STATS_INC(mp, xs_trans_empty);
1005 	return error;
1006 }
1007 
1008 int
xfs_trans_commit(struct xfs_trans * tp)1009 xfs_trans_commit(
1010 	struct xfs_trans	*tp)
1011 {
1012 	return __xfs_trans_commit(tp, false);
1013 }
1014 
1015 /*
1016  * Unlock all of the transaction's items and free the transaction.
1017  * The transaction must not have modified any of its items, because
1018  * there is no way to restore them to their previous state.
1019  *
1020  * If the transaction has made a log reservation, make sure to release
1021  * it as well.
1022  */
1023 void
xfs_trans_cancel(struct xfs_trans * tp)1024 xfs_trans_cancel(
1025 	struct xfs_trans	*tp)
1026 {
1027 	struct xfs_mount	*mp = tp->t_mountp;
1028 	bool			dirty = (tp->t_flags & XFS_TRANS_DIRTY);
1029 
1030 	trace_xfs_trans_cancel(tp, _RET_IP_);
1031 
1032 	if (tp->t_flags & XFS_TRANS_PERM_LOG_RES)
1033 		xfs_defer_cancel(tp);
1034 
1035 	/*
1036 	 * See if the caller is relying on us to shut down the
1037 	 * filesystem.  This happens in paths where we detect
1038 	 * corruption and decide to give up.
1039 	 */
1040 	if (dirty && !XFS_FORCED_SHUTDOWN(mp)) {
1041 		XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
1042 		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1043 	}
1044 #ifdef DEBUG
1045 	if (!dirty && !XFS_FORCED_SHUTDOWN(mp)) {
1046 		struct xfs_log_item *lip;
1047 
1048 		list_for_each_entry(lip, &tp->t_items, li_trans)
1049 			ASSERT(!(lip->li_type == XFS_LI_EFD));
1050 	}
1051 #endif
1052 	xfs_trans_unreserve_and_mod_sb(tp);
1053 	xfs_trans_unreserve_and_mod_dquots(tp);
1054 
1055 	if (tp->t_ticket) {
1056 		xfs_log_done(mp, tp->t_ticket, NULL, false);
1057 		tp->t_ticket = NULL;
1058 	}
1059 
1060 	/* mark this thread as no longer being in a transaction */
1061 	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
1062 
1063 	xfs_trans_free_items(tp, NULLCOMMITLSN, dirty);
1064 	xfs_trans_free(tp);
1065 }
1066 
1067 /*
1068  * Roll from one trans in the sequence of PERMANENT transactions to
1069  * the next: permanent transactions are only flushed out when
1070  * committed with xfs_trans_commit(), but we still want as soon
1071  * as possible to let chunks of it go to the log. So we commit the
1072  * chunk we've been working on and get a new transaction to continue.
1073  */
1074 int
xfs_trans_roll(struct xfs_trans ** tpp)1075 xfs_trans_roll(
1076 	struct xfs_trans	**tpp)
1077 {
1078 	struct xfs_trans	*trans = *tpp;
1079 	struct xfs_trans_res	tres;
1080 	int			error;
1081 
1082 	trace_xfs_trans_roll(trans, _RET_IP_);
1083 
1084 	/*
1085 	 * Copy the critical parameters from one trans to the next.
1086 	 */
1087 	tres.tr_logres = trans->t_log_res;
1088 	tres.tr_logcount = trans->t_log_count;
1089 
1090 	*tpp = xfs_trans_dup(trans);
1091 
1092 	/*
1093 	 * Commit the current transaction.
1094 	 * If this commit failed, then it'd just unlock those items that
1095 	 * are not marked ihold. That also means that a filesystem shutdown
1096 	 * is in progress. The caller takes the responsibility to cancel
1097 	 * the duplicate transaction that gets returned.
1098 	 */
1099 	error = __xfs_trans_commit(trans, true);
1100 	if (error)
1101 		return error;
1102 
1103 	/*
1104 	 * Reserve space in the log for the next transaction.
1105 	 * This also pushes items in the "AIL", the list of logged items,
1106 	 * out to disk if they are taking up space at the tail of the log
1107 	 * that we want to use.  This requires that either nothing be locked
1108 	 * across this call, or that anything that is locked be logged in
1109 	 * the prior and the next transactions.
1110 	 */
1111 	tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
1112 	return xfs_trans_reserve(*tpp, &tres, 0, 0);
1113 }
1114