xfs_trans.c 29.4 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2
/*
3
 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4
 * Copyright (C) 2010 Red Hat, Inc.
5
 * All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
6 7
 */
#include "xfs.h"
8
#include "xfs_fs.h"
9
#include "xfs_shared.h"
10 11 12
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
Linus Torvalds's avatar
Linus Torvalds committed
13
#include "xfs_mount.h"
14
#include "xfs_extent_busy.h"
Linus Torvalds's avatar
Linus Torvalds committed
15
#include "xfs_quota.h"
16
#include "xfs_trans.h"
17
#include "xfs_trans_priv.h"
18
#include "xfs_log.h"
19
#include "xfs_trace.h"
20
#include "xfs_error.h"
21
#include "xfs_defer.h"
Linus Torvalds's avatar
Linus Torvalds committed
22

23
kmem_zone_t	*xfs_trans_zone;
Linus Torvalds's avatar
Linus Torvalds committed
24

25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
#if defined(CONFIG_TRACEPOINTS)
static void
xfs_trans_trace_reservations(
	struct xfs_mount	*mp)
{
	struct xfs_trans_res	resv;
	struct xfs_trans_res	*res;
	struct xfs_trans_res	*end_res;
	int			i;

	res = (struct xfs_trans_res *)M_RES(mp);
	end_res = (struct xfs_trans_res *)(M_RES(mp) + 1);
	for (i = 0; res < end_res; i++, res++)
		trace_xfs_trans_resv_calc(mp, i, res);
	xfs_log_get_max_trans_res(mp, &resv);
	trace_xfs_trans_resv_calc(mp, -1, &resv);
}
#else
# define xfs_trans_trace_reservations(mp)
#endif

Linus Torvalds's avatar
Linus Torvalds committed
46 47 48 49 50 51
/*
 * Initialize the precomputed transaction reservation values
 * in the mount structure.
 */
void
xfs_trans_init(
52
	struct xfs_mount	*mp)
Linus Torvalds's avatar
Linus Torvalds committed
53
{
54
	xfs_trans_resv_calc(mp, M_RES(mp));
55
	xfs_trans_trace_reservations(mp);
Linus Torvalds's avatar
Linus Torvalds committed
56 57
}

58 59 60 61 62 63
/*
 * Free the transaction structure.  If there is more clean up
 * to do when the structure is freed, add it here.
 */
STATIC void
xfs_trans_free(
64
	struct xfs_trans	*tp)
65
{
66 67
	xfs_extent_busy_sort(&tp->t_busy);
	xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
68

69
	trace_xfs_trans_free(tp, _RET_IP_);
70
	atomic_dec(&tp->t_mountp->m_active_trans);
71
	if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT))
Jan Kara's avatar
Jan Kara committed
72
		sb_end_intwrite(tp->t_mountp->m_super);
73 74 75 76
	xfs_trans_free_dqinfo(tp);
	kmem_zone_free(xfs_trans_zone, tp);
}

Linus Torvalds's avatar
Linus Torvalds committed
77 78 79 80 81 82 83 84
/*
 * This is called to create a new transaction which will share the
 * permanent log reservation of the given transaction.  The remaining
 * unused block and rt extent reservations are also inherited.  This
 * implies that the original transaction is no longer allowed to allocate
 * blocks.  Locks and log items, however, are no inherited.  They must
 * be added to the new transaction explicitly.
 */
85
STATIC struct xfs_trans *
Linus Torvalds's avatar
Linus Torvalds committed
86
xfs_trans_dup(
87
	struct xfs_trans	*tp)
Linus Torvalds's avatar
Linus Torvalds committed
88
{
89
	struct xfs_trans	*ntp;
Linus Torvalds's avatar
Linus Torvalds committed
90

91 92
	trace_xfs_trans_dup(tp, _RET_IP_);

93
	ntp = kmem_zone_zalloc(xfs_trans_zone, 0);
Linus Torvalds's avatar
Linus Torvalds committed
94 95 96 97

	/*
	 * Initialize the new transaction structure.
	 */
98
	ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
Linus Torvalds's avatar
Linus Torvalds committed
99
	ntp->t_mountp = tp->t_mountp;
100
	INIT_LIST_HEAD(&ntp->t_items);
101
	INIT_LIST_HEAD(&ntp->t_busy);
102
	INIT_LIST_HEAD(&ntp->t_dfops);
103
	ntp->t_firstblock = NULLFSBLOCK;
Linus Torvalds's avatar
Linus Torvalds committed
104 105 106

	ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
	ASSERT(tp->t_ticket != NULL);
107

Jan Kara's avatar
Jan Kara committed
108 109
	ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
		       (tp->t_flags & XFS_TRANS_RESERVE) |
110
		       (tp->t_flags & XFS_TRANS_NO_WRITECOUNT);
Jan Kara's avatar
Jan Kara committed
111
	/* We gave our writer reference to the new transaction */
112
	tp->t_flags |= XFS_TRANS_NO_WRITECOUNT;
113
	ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
114 115

	ASSERT(tp->t_blk_res >= tp->t_blk_res_used);
Linus Torvalds's avatar
Linus Torvalds committed
116 117
	ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
	tp->t_blk_res = tp->t_blk_res_used;
118

Linus Torvalds's avatar
Linus Torvalds committed
119 120
	ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
	tp->t_rtx_res = tp->t_rtx_res_used;
121
	ntp->t_pflags = tp->t_pflags;
122

123 124
	/* move deferred ops over to the new tp */
	xfs_defer_move(ntp, tp);
Linus Torvalds's avatar
Linus Torvalds committed
125

Christoph Hellwig's avatar
Christoph Hellwig committed
126
	xfs_trans_dup_dqinfo(tp, ntp);
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145

	atomic_inc(&tp->t_mountp->m_active_trans);
	return ntp;
}

/*
 * This is called to reserve free disk blocks and log space for the
 * given transaction.  This must be done before allocating any resources
 * within the transaction.
 *
 * This will return ENOSPC if there are not enough blocks available.
 * It will sleep waiting for available log space.
 * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
 * is used by long running transactions.  If any one of the reservations
 * fails then they will all be backed out.
 *
 * This does not do quota reservations. That typically is done by the
 * caller afterwards.
 */
146
static int
Linus Torvalds's avatar
Linus Torvalds committed
147
xfs_trans_reserve(
148 149 150 151
	struct xfs_trans	*tp,
	struct xfs_trans_res	*resp,
	uint			blocks,
	uint			rtextents)
Linus Torvalds's avatar
Linus Torvalds committed
152
{
153
	int		error = 0;
154
	bool		rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
Linus Torvalds's avatar
Linus Torvalds committed
155 156

	/* Mark this thread as being in a transaction */
157
	current_set_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
Linus Torvalds's avatar
Linus Torvalds committed
158 159 160 161 162 163 164

	/*
	 * Attempt to reserve the needed disk blocks by decrementing
	 * the number needed from the number available.  This will
	 * fail if the count would go below zero.
	 */
	if (blocks > 0) {
165
		error = xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd);
Linus Torvalds's avatar
Linus Torvalds committed
166
		if (error != 0) {
167
			current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
168
			return -ENOSPC;
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171 172 173 174 175
		}
		tp->t_blk_res += blocks;
	}

	/*
	 * Reserve the log space needed for this transaction.
	 */
176
	if (resp->tr_logres > 0) {
177 178
		bool	permanent = false;

179 180 181 182
		ASSERT(tp->t_log_res == 0 ||
		       tp->t_log_res == resp->tr_logres);
		ASSERT(tp->t_log_count == 0 ||
		       tp->t_log_count == resp->tr_logcount);
183

184
		if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
Linus Torvalds's avatar
Linus Torvalds committed
185
			tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
186
			permanent = true;
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191
		} else {
			ASSERT(tp->t_ticket == NULL);
			ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
		}

192
		if (tp->t_ticket != NULL) {
193
			ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
194 195
			error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
		} else {
196 197 198 199
			error = xfs_log_reserve(tp->t_mountp,
						resp->tr_logres,
						resp->tr_logcount,
						&tp->t_ticket, XFS_TRANSACTION,
200
						permanent);
Linus Torvalds's avatar
Linus Torvalds committed
201
		}
202 203 204 205

		if (error)
			goto undo_blocks;

206 207
		tp->t_log_res = resp->tr_logres;
		tp->t_log_count = resp->tr_logcount;
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210 211 212 213 214 215
	}

	/*
	 * Attempt to reserve the needed realtime extents by decrementing
	 * the number needed from the number available.  This will
	 * fail if the count would go below zero.
	 */
	if (rtextents > 0) {
216
		error = xfs_mod_frextents(tp->t_mountp, -((int64_t)rtextents));
Linus Torvalds's avatar
Linus Torvalds committed
217
		if (error) {
218
			error = -ENOSPC;
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221 222 223 224 225 226 227 228 229 230
			goto undo_log;
		}
		tp->t_rtx_res += rtextents;
	}

	return 0;

	/*
	 * Error cases jump to one of these labels to undo any
	 * reservations which have already been performed.
	 */
undo_log:
231
	if (resp->tr_logres > 0) {
232
		xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, false);
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236 237 238 239
		tp->t_ticket = NULL;
		tp->t_log_res = 0;
		tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
	}

undo_blocks:
	if (blocks > 0) {
240
		xfs_mod_fdblocks(tp->t_mountp, (int64_t)blocks, rsvd);
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243
		tp->t_blk_res = 0;
	}

244
	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
Linus Torvalds's avatar
Linus Torvalds committed
245

246
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
247 248
}

249 250 251 252 253 254 255 256 257 258 259 260
int
xfs_trans_alloc(
	struct xfs_mount	*mp,
	struct xfs_trans_res	*resp,
	uint			blocks,
	uint			rtextents,
	uint			flags,
	struct xfs_trans	**tpp)
{
	struct xfs_trans	*tp;
	int			error;

261 262 263 264 265
	/*
	 * Allocate the handle before we do our freeze accounting and setting up
	 * GFP_NOFS allocation context so that we avoid lockdep false positives
	 * by doing GFP_KERNEL allocations inside sb_start_intwrite().
	 */
266
	tp = kmem_zone_zalloc(xfs_trans_zone, 0);
267 268 269
	if (!(flags & XFS_TRANS_NO_WRITECOUNT))
		sb_start_intwrite(mp->m_super);

270 271 272 273 274 275
	/*
	 * Zero-reservation ("empty") transactions can't modify anything, so
	 * they're allowed to run while we're frozen.
	 */
	WARN_ON(resp->tr_logres > 0 &&
		mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
276 277 278 279 280 281 282
	atomic_inc(&mp->m_active_trans);

	tp->t_magic = XFS_TRANS_HEADER_MAGIC;
	tp->t_flags = flags;
	tp->t_mountp = mp;
	INIT_LIST_HEAD(&tp->t_items);
	INIT_LIST_HEAD(&tp->t_busy);
283
	INIT_LIST_HEAD(&tp->t_dfops);
284
	tp->t_firstblock = NULLFSBLOCK;
285 286 287 288 289 290 291

	error = xfs_trans_reserve(tp, resp, blocks, rtextents);
	if (error) {
		xfs_trans_cancel(tp);
		return error;
	}

292 293
	trace_xfs_trans_alloc(tp, _RET_IP_);

294 295 296 297
	*tpp = tp;
	return 0;
}

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
/*
 * Create an empty transaction with no reservation.  This is a defensive
 * mechanism for routines that query metadata without actually modifying
 * them -- if the metadata being queried is somehow cross-linked (think a
 * btree block pointer that points higher in the tree), we risk deadlock.
 * However, blocks grabbed as part of a transaction can be re-grabbed.
 * The verifiers will notice the corrupt block and the operation will fail
 * back to userspace without deadlocking.
 *
 * Note the zero-length reservation; this transaction MUST be cancelled
 * without any dirty data.
 */
int
xfs_trans_alloc_empty(
	struct xfs_mount		*mp,
	struct xfs_trans		**tpp)
{
	struct xfs_trans_res		resv = {0};

	return xfs_trans_alloc(mp, &resv, 0, 0, XFS_TRANS_NO_WRITECOUNT, tpp);
}

Linus Torvalds's avatar
Linus Torvalds committed
320 321 322 323 324 325 326
/*
 * Record the indicated change to the given field for application
 * to the file system's superblock when the transaction commits.
 * For now, just store the change in the transaction structure.
 *
 * Mark the transaction structure to indicate that the superblock
 * needs to be updated before committing.
327 328 329 330 331 332 333 334
 *
 * Because we may not be keeping track of allocated/free inodes and
 * used filesystem blocks in the superblock, we do not mark the
 * superblock dirty in this transaction if we modify these fields.
 * We still need to update the transaction deltas so that they get
 * applied to the incore superblock, but we don't want them to
 * cause the superblock to get locked and logged if these are the
 * only fields in the superblock that the transaction modifies.
Linus Torvalds's avatar
Linus Torvalds committed
335 336 337 338 339
 */
void
xfs_trans_mod_sb(
	xfs_trans_t	*tp,
	uint		field,
340
	int64_t		delta)
Linus Torvalds's avatar
Linus Torvalds committed
341
{
342 343
	uint32_t	flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
	xfs_mount_t	*mp = tp->t_mountp;
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346 347

	switch (field) {
	case XFS_TRANS_SB_ICOUNT:
		tp->t_icount_delta += delta;
348 349
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds's avatar
Linus Torvalds committed
350 351 352
		break;
	case XFS_TRANS_SB_IFREE:
		tp->t_ifree_delta += delta;
353 354
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds's avatar
Linus Torvalds committed
355 356 357
		break;
	case XFS_TRANS_SB_FDBLOCKS:
		/*
358 359 360
		 * Track the number of blocks allocated in the transaction.
		 * Make sure it does not exceed the number reserved. If so,
		 * shutdown as this can lead to accounting inconsistency.
Linus Torvalds's avatar
Linus Torvalds committed
361 362 363
		 */
		if (delta < 0) {
			tp->t_blk_res_used += (uint)-delta;
364 365
			if (tp->t_blk_res_used > tp->t_blk_res)
				xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
Linus Torvalds's avatar
Linus Torvalds committed
366 367
		}
		tp->t_fdblocks_delta += delta;
368 369
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds's avatar
Linus Torvalds committed
370 371 372 373 374 375 376 377
		break;
	case XFS_TRANS_SB_RES_FDBLOCKS:
		/*
		 * The allocation has already been applied to the
		 * in-core superblock's counter.  This should only
		 * be applied to the on-disk superblock.
		 */
		tp->t_res_fdblocks_delta += delta;
378 379
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds's avatar
Linus Torvalds committed
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
		break;
	case XFS_TRANS_SB_FREXTENTS:
		/*
		 * Track the number of blocks allocated in the
		 * transaction.  Make sure it does not exceed the
		 * number reserved.
		 */
		if (delta < 0) {
			tp->t_rtx_res_used += (uint)-delta;
			ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
		}
		tp->t_frextents_delta += delta;
		break;
	case XFS_TRANS_SB_RES_FREXTENTS:
		/*
		 * The allocation has already been applied to the
396
		 * in-core superblock's counter.  This should only
Linus Torvalds's avatar
Linus Torvalds committed
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
		 * be applied to the on-disk superblock.
		 */
		ASSERT(delta < 0);
		tp->t_res_frextents_delta += delta;
		break;
	case XFS_TRANS_SB_DBLOCKS:
		ASSERT(delta > 0);
		tp->t_dblocks_delta += delta;
		break;
	case XFS_TRANS_SB_AGCOUNT:
		ASSERT(delta > 0);
		tp->t_agcount_delta += delta;
		break;
	case XFS_TRANS_SB_IMAXPCT:
		tp->t_imaxpct_delta += delta;
		break;
	case XFS_TRANS_SB_REXTSIZE:
		tp->t_rextsize_delta += delta;
		break;
	case XFS_TRANS_SB_RBMBLOCKS:
		tp->t_rbmblocks_delta += delta;
		break;
	case XFS_TRANS_SB_RBLOCKS:
		tp->t_rblocks_delta += delta;
		break;
	case XFS_TRANS_SB_REXTENTS:
		tp->t_rextents_delta += delta;
		break;
	case XFS_TRANS_SB_REXTSLOG:
		tp->t_rextslog_delta += delta;
		break;
	default:
		ASSERT(0);
		return;
	}

433
	tp->t_flags |= flags;
Linus Torvalds's avatar
Linus Torvalds committed
434 435 436 437 438 439 440 441 442 443 444 445 446 447
}

/*
 * xfs_trans_apply_sb_deltas() is called from the commit code
 * to bring the superblock buffer into the current transaction
 * and modify it as requested by earlier calls to xfs_trans_mod_sb().
 *
 * For now we just look at each field allowed to change and change
 * it if necessary.
 */
STATIC void
xfs_trans_apply_sb_deltas(
	xfs_trans_t	*tp)
{
448
	xfs_dsb_t	*sbp;
Linus Torvalds's avatar
Linus Torvalds committed
449 450 451
	xfs_buf_t	*bp;
	int		whole = 0;

452
	bp = xfs_trans_getsb(tp, tp->t_mountp);
Linus Torvalds's avatar
Linus Torvalds committed
453 454 455 456 457 458 459 460 461
	sbp = XFS_BUF_TO_SBP(bp);

	/*
	 * Check that superblock mods match the mods made to AGF counters.
	 */
	ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) ==
	       (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
		tp->t_ag_btree_delta));

462 463 464 465
	/*
	 * Only update the superblock counters if we are logging them
	 */
	if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
466
		if (tp->t_icount_delta)
467
			be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
468
		if (tp->t_ifree_delta)
469
			be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
470
		if (tp->t_fdblocks_delta)
471
			be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
472
		if (tp->t_res_fdblocks_delta)
473
			be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
Linus Torvalds's avatar
Linus Torvalds committed
474 475
	}

476
	if (tp->t_frextents_delta)
477
		be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
478
	if (tp->t_res_frextents_delta)
479
		be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
480 481

	if (tp->t_dblocks_delta) {
482
		be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
Linus Torvalds's avatar
Linus Torvalds committed
483 484
		whole = 1;
	}
485
	if (tp->t_agcount_delta) {
486
		be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
Linus Torvalds's avatar
Linus Torvalds committed
487 488
		whole = 1;
	}
489 490
	if (tp->t_imaxpct_delta) {
		sbp->sb_imax_pct += tp->t_imaxpct_delta;
Linus Torvalds's avatar
Linus Torvalds committed
491 492
		whole = 1;
	}
493
	if (tp->t_rextsize_delta) {
494
		be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
Linus Torvalds's avatar
Linus Torvalds committed
495 496
		whole = 1;
	}
497
	if (tp->t_rbmblocks_delta) {
498
		be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
Linus Torvalds's avatar
Linus Torvalds committed
499 500
		whole = 1;
	}
501
	if (tp->t_rblocks_delta) {
502
		be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
Linus Torvalds's avatar
Linus Torvalds committed
503 504
		whole = 1;
	}
505
	if (tp->t_rextents_delta) {
506
		be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
Linus Torvalds's avatar
Linus Torvalds committed
507 508
		whole = 1;
	}
509 510
	if (tp->t_rextslog_delta) {
		sbp->sb_rextslog += tp->t_rextslog_delta;
Linus Torvalds's avatar
Linus Torvalds committed
511 512 513
		whole = 1;
	}

514
	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
Linus Torvalds's avatar
Linus Torvalds committed
515 516
	if (whole)
		/*
517
		 * Log the whole thing, the fields are noncontiguous.
Linus Torvalds's avatar
Linus Torvalds committed
518
		 */
519
		xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
Linus Torvalds's avatar
Linus Torvalds committed
520 521 522 523 524
	else
		/*
		 * Since all the modifiable fields are contiguous, we
		 * can get away with this.
		 */
525 526
		xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
				  offsetof(xfs_dsb_t, sb_frextents) +
Linus Torvalds's avatar
Linus Torvalds committed
527 528 529
				  sizeof(sbp->sb_frextents) - 1);
}

530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
STATIC int
xfs_sb_mod8(
	uint8_t			*field,
	int8_t			delta)
{
	int8_t			counter = *field;

	counter += delta;
	if (counter < 0) {
		ASSERT(0);
		return -EINVAL;
	}
	*field = counter;
	return 0;
}

STATIC int
xfs_sb_mod32(
	uint32_t		*field,
	int32_t			delta)
{
	int32_t			counter = *field;

	counter += delta;
	if (counter < 0) {
		ASSERT(0);
		return -EINVAL;
	}
	*field = counter;
	return 0;
}

STATIC int
xfs_sb_mod64(
	uint64_t		*field,
	int64_t			delta)
{
	int64_t			counter = *field;

	counter += delta;
	if (counter < 0) {
		ASSERT(0);
		return -EINVAL;
	}
	*field = counter;
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
578
/*
579 580 581 582 583
 * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations
 * and apply superblock counter changes to the in-core superblock.  The
 * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
 * applied to the in-core superblock.  The idea is that that has already been
 * done.
Linus Torvalds's avatar
Linus Torvalds committed
584
 *
585 586 587 588
 * If we are not logging superblock counters, then the inode allocated/free and
 * used block counts are not updated in the on disk superblock. In this case,
 * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
 * still need to update the incore superblock with the changes.
Linus Torvalds's avatar
Linus Torvalds committed
589
 */
590
void
Linus Torvalds's avatar
Linus Torvalds committed
591
xfs_trans_unreserve_and_mod_sb(
592
	struct xfs_trans	*tp)
Linus Torvalds's avatar
Linus Torvalds committed
593
{
594 595 596 597 598 599 600
	struct xfs_mount	*mp = tp->t_mountp;
	bool			rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
	int64_t			blkdelta = 0;
	int64_t			rtxdelta = 0;
	int64_t			idelta = 0;
	int64_t			ifreedelta = 0;
	int			error;
Linus Torvalds's avatar
Linus Torvalds committed
601

602
	/* calculate deltas */
603 604 605 606 607 608 609 610 611 612 613 614 615
	if (tp->t_blk_res > 0)
		blkdelta = tp->t_blk_res;
	if ((tp->t_fdblocks_delta != 0) &&
	    (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
	     (tp->t_flags & XFS_TRANS_SB_DIRTY)))
	        blkdelta += tp->t_fdblocks_delta;

	if (tp->t_rtx_res > 0)
		rtxdelta = tp->t_rtx_res;
	if ((tp->t_frextents_delta != 0) &&
	    (tp->t_flags & XFS_TRANS_SB_DIRTY))
		rtxdelta += tp->t_frextents_delta;

616 617 618 619 620 621 622 623
	if (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
	     (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
		idelta = tp->t_icount_delta;
		ifreedelta = tp->t_ifree_delta;
	}

	/* apply the per-cpu counters */
	if (blkdelta) {
624
		error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
625 626 627 628 629
		if (error)
			goto out;
	}

	if (idelta) {
630
		error = xfs_mod_icount(mp, idelta);
631 632 633 634 635
		if (error)
			goto out_undo_fdblocks;
	}

	if (ifreedelta) {
636
		error = xfs_mod_ifree(mp, ifreedelta);
637 638 639 640
		if (error)
			goto out_undo_icount;
	}

641 642 643
	if (rtxdelta == 0 && !(tp->t_flags & XFS_TRANS_SB_DIRTY))
		return;

644
	/* apply remaining deltas */
645
	spin_lock(&mp->m_sb_lock);
646
	if (rtxdelta) {
647
		error = xfs_sb_mod64(&mp->m_sb.sb_frextents, rtxdelta);
648 649
		if (error)
			goto out_undo_ifree;
Linus Torvalds's avatar
Linus Torvalds committed
650 651
	}

652 653
	if (tp->t_dblocks_delta != 0) {
		error = xfs_sb_mod64(&mp->m_sb.sb_dblocks, tp->t_dblocks_delta);
654
		if (error)
655
			goto out_undo_frextents;
Linus Torvalds's avatar
Linus Torvalds committed
656
	}
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
	if (tp->t_agcount_delta != 0) {
		error = xfs_sb_mod32(&mp->m_sb.sb_agcount, tp->t_agcount_delta);
		if (error)
			goto out_undo_dblocks;
	}
	if (tp->t_imaxpct_delta != 0) {
		error = xfs_sb_mod8(&mp->m_sb.sb_imax_pct, tp->t_imaxpct_delta);
		if (error)
			goto out_undo_agcount;
	}
	if (tp->t_rextsize_delta != 0) {
		error = xfs_sb_mod32(&mp->m_sb.sb_rextsize,
				     tp->t_rextsize_delta);
		if (error)
			goto out_undo_imaxpct;
	}
	if (tp->t_rbmblocks_delta != 0) {
		error = xfs_sb_mod32(&mp->m_sb.sb_rbmblocks,
				     tp->t_rbmblocks_delta);
		if (error)
			goto out_undo_rextsize;
	}
	if (tp->t_rblocks_delta != 0) {
		error = xfs_sb_mod64(&mp->m_sb.sb_rblocks, tp->t_rblocks_delta);
		if (error)
			goto out_undo_rbmblocks;
	}
	if (tp->t_rextents_delta != 0) {
		error = xfs_sb_mod64(&mp->m_sb.sb_rextents,
				     tp->t_rextents_delta);
		if (error)
			goto out_undo_rblocks;
	}
	if (tp->t_rextslog_delta != 0) {
		error = xfs_sb_mod8(&mp->m_sb.sb_rextslog,
				     tp->t_rextslog_delta);
		if (error)
			goto out_undo_rextents;
	}
	spin_unlock(&mp->m_sb_lock);
697 698
	return;

699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
out_undo_rextents:
	if (tp->t_rextents_delta)
		xfs_sb_mod64(&mp->m_sb.sb_rextents, -tp->t_rextents_delta);
out_undo_rblocks:
	if (tp->t_rblocks_delta)
		xfs_sb_mod64(&mp->m_sb.sb_rblocks, -tp->t_rblocks_delta);
out_undo_rbmblocks:
	if (tp->t_rbmblocks_delta)
		xfs_sb_mod32(&mp->m_sb.sb_rbmblocks, -tp->t_rbmblocks_delta);
out_undo_rextsize:
	if (tp->t_rextsize_delta)
		xfs_sb_mod32(&mp->m_sb.sb_rextsize, -tp->t_rextsize_delta);
out_undo_imaxpct:
	if (tp->t_rextsize_delta)
		xfs_sb_mod8(&mp->m_sb.sb_imax_pct, -tp->t_imaxpct_delta);
out_undo_agcount:
	if (tp->t_agcount_delta)
		xfs_sb_mod32(&mp->m_sb.sb_agcount, -tp->t_agcount_delta);
out_undo_dblocks:
	if (tp->t_dblocks_delta)
		xfs_sb_mod64(&mp->m_sb.sb_dblocks, -tp->t_dblocks_delta);
720 721
out_undo_frextents:
	if (rtxdelta)
722
		xfs_sb_mod64(&mp->m_sb.sb_frextents, -rtxdelta);
723
out_undo_ifree:
724
	spin_unlock(&mp->m_sb_lock);
725
	if (ifreedelta)
726
		xfs_mod_ifree(mp, -ifreedelta);
727 728
out_undo_icount:
	if (idelta)
729
		xfs_mod_icount(mp, -idelta);
730 731
out_undo_fdblocks:
	if (blkdelta)
732
		xfs_mod_fdblocks(mp, -blkdelta, rsvd);
733
out:
734
	ASSERT(error == 0);
735
	return;
Linus Torvalds's avatar
Linus Torvalds committed
736 737
}

738
/* Add the given log item to the transaction's list of log items. */
739 740 741 742 743
void
xfs_trans_add_item(
	struct xfs_trans	*tp,
	struct xfs_log_item	*lip)
{
744 745
	ASSERT(lip->li_mountp == tp->t_mountp);
	ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
746 747
	ASSERT(list_empty(&lip->li_trans));
	ASSERT(!test_bit(XFS_LI_DIRTY, &lip->li_flags));
748

749
	list_add_tail(&lip->li_trans, &tp->t_items);
750
	trace_xfs_trans_add_item(tp, _RET_IP_);
751 752 753
}

/*
754 755 756
 * Unlink the log item from the transaction. the log item is no longer
 * considered dirty in this transaction, as the linked transaction has
 * finished, either by abort or commit completion.
757 758 759 760 761
 */
void
xfs_trans_del_item(
	struct xfs_log_item	*lip)
{
762 763
	clear_bit(XFS_LI_DIRTY, &lip->li_flags);
	list_del_init(&lip->li_trans);
764 765
}

766
/* Detach and unlock all of the items in a transaction */
767
static void
768 769
xfs_trans_free_items(
	struct xfs_trans	*tp,
770
	bool			abort)
771
{
772
	struct xfs_log_item	*lip, *next;
773

774 775
	trace_xfs_trans_free_items(tp, _RET_IP_);

776 777
	list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) {
		xfs_trans_del_item(lip);
778
		if (abort)
Dave Chinner's avatar
Dave Chinner committed
779
			set_bit(XFS_LI_ABORTED, &lip->li_flags);
Christoph Hellwig's avatar
Christoph Hellwig committed
780 781
		if (lip->li_ops->iop_release)
			lip->li_ops->iop_release(lip);
782 783 784
	}
}

785 786 787
static inline void
xfs_log_item_batch_insert(
	struct xfs_ail		*ailp,
788
	struct xfs_ail_cursor	*cur,
789 790 791 792 793 794
	struct xfs_log_item	**log_items,
	int			nr_items,
	xfs_lsn_t		commit_lsn)
{
	int	i;

795 796
	spin_lock(&ailp->ail_lock);
	/* xfs_trans_ail_update_bulk drops ailp->ail_lock */
797
	xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
798

799 800 801
	for (i = 0; i < nr_items; i++) {
		struct xfs_log_item *lip = log_items[i];

802 803
		if (lip->li_ops->iop_unpin)
			lip->li_ops->iop_unpin(lip, 0);
804
	}
805 806 807 808 809 810
}

/*
 * Bulk operation version of xfs_trans_committed that takes a log vector of
 * items to insert into the AIL. This uses bulk AIL insertion techniques to
 * minimise lock traffic.
811 812 813
 *
 * If we are called with the aborted flag set, it is because a log write during
 * a CIL checkpoint commit has failed. In this case, all the items in the
Christoph Hellwig's avatar
Christoph Hellwig committed
814
 * checkpoint have already gone through iop_committed and iop_committing, which
815 816
 * means that checkpoint commit abort handling is treated exactly the same
 * as an iclog write error even though we haven't started any IO yet. Hence in
817 818
 * this case all we need to do is iop_committed processing, followed by an
 * iop_unpin(aborted) call.
819 820 821 822 823 824 825
 *
 * The AIL cursor is used to optimise the insert process. If commit_lsn is not
 * at the end of the AIL, the insert cursor avoids the need to walk
 * the AIL to find the insertion point on every xfs_log_item_batch_insert()
 * call. This saves a lot of needless list walking and is a net win, even
 * though it slightly increases that amount of AIL lock traffic to set it up
 * and tear it down.
826 827 828 829 830 831
 */
void
xfs_trans_committed_bulk(
	struct xfs_ail		*ailp,
	struct xfs_log_vec	*log_vector,
	xfs_lsn_t		commit_lsn,
832
	bool			aborted)
833 834 835 836
{
#define LOG_ITEM_BATCH_SIZE	32
	struct xfs_log_item	*log_items[LOG_ITEM_BATCH_SIZE];
	struct xfs_log_vec	*lv;
837
	struct xfs_ail_cursor	cur;
838 839
	int			i = 0;

840
	spin_lock(&ailp->ail_lock);
841
	xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
842
	spin_unlock(&ailp->ail_lock);
843

844 845 846 847 848 849
	/* unpin all the log items */
	for (lv = log_vector; lv; lv = lv->lv_next ) {
		struct xfs_log_item	*lip = lv->lv_item;
		xfs_lsn_t		item_lsn;

		if (aborted)
Dave Chinner's avatar
Dave Chinner committed
850
			set_bit(XFS_LI_ABORTED, &lip->li_flags);
851 852 853 854 855 856

		if (lip->li_ops->flags & XFS_ITEM_RELEASE_WHEN_COMMITTED) {
			lip->li_ops->iop_release(lip);
			continue;
		}

857 858 859 860
		if (lip->li_ops->iop_committed)
			item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
		else
			item_lsn = commit_lsn;
861

862
		/* item_lsn of -1 means the item needs no further processing */
863 864 865
		if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
			continue;

866 867 868 869 870
		/*
		 * if we are aborting the operation, no point in inserting the
		 * object into the AIL as we are in a shutdown situation.
		 */
		if (aborted) {
871
			ASSERT(XFS_FORCED_SHUTDOWN(ailp->ail_mount));
872 873
			if (lip->li_ops->iop_unpin)
				lip->li_ops->iop_unpin(lip, 1);
874 875 876
			continue;
		}

877 878 879 880 881
		if (item_lsn != commit_lsn) {

			/*
			 * Not a bulk update option due to unusual item_lsn.
			 * Push into AIL immediately, rechecking the lsn once
882 883 884
			 * we have the ail lock. Then unpin the item. This does
			 * not affect the AIL cursor the bulk insert path is
			 * using.
885
			 */
886
			spin_lock(&ailp->ail_lock);
887 888 889
			if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
				xfs_trans_ail_update(ailp, lip, item_lsn);
			else
890
				spin_unlock(&ailp->ail_lock);
891 892
			if (lip->li_ops->iop_unpin)
				lip->li_ops->iop_unpin(lip, 0);
893 894 895 896 897 898
			continue;
		}

		/* Item is a candidate for bulk AIL insert.  */
		log_items[i++] = lv->lv_item;
		if (i >= LOG_ITEM_BATCH_SIZE) {
899
			xfs_log_item_batch_insert(ailp, &cur, log_items,
900 901 902 903 904 905 906
					LOG_ITEM_BATCH_SIZE, commit_lsn);
			i = 0;
		}
	}

	/* make sure we insert the remainder! */
	if (i)
907 908
		xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);

909
	spin_lock(&ailp->ail_lock);
910
	xfs_trans_ail_cursor_done(&cur);
911
	spin_unlock(&ailp->ail_lock);
912 913
}

914
/*
915
 * Commit the given transaction to the log.
916 917 918 919 920 921 922 923 924 925
 *
 * XFS disk error handling mechanism is not based on a typical
 * transaction abort mechanism. Logically after the filesystem
 * gets marked 'SHUTDOWN', we can't let any new transactions
 * be durable - ie. committed to disk - because some metadata might
 * be inconsistent. In such cases, this returns an error, and the
 * caller may assume that all locked objects joined to the transaction
 * have already been unlocked as if the commit had succeeded.
 * Do not reference the transaction structure after this call.
 */
926 927
static int
__xfs_trans_commit(
928
	struct xfs_trans	*tp,
929
	bool			regrant)
930
{
931
	struct xfs_mount	*mp = tp->t_mountp;
932
	xfs_lsn_t		commit_lsn = -1;
933
	int			error = 0;
934 935
	int			sync = tp->t_flags & XFS_TRANS_SYNC;

936 937
	trace_xfs_trans_commit(tp, _RET_IP_);

938 939 940 941
	/*
	 * Finish deferred items on final commit. Only permanent transactions
	 * should ever have deferred ops.
	 */
942
	WARN_ON_ONCE(!list_empty(&tp->t_dfops) &&
943 944
		     !(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
	if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) {
945
		error = xfs_defer_finish_noroll(&tp);
946
		if (error)
947 948 949
			goto out_unreserve;
	}

950 951 952 953 954 955 956
	/*
	 * If there is nothing to be logged by the transaction,
	 * then unlock all of the items associated with the
	 * transaction and free the transaction structure.
	 * Also make sure to return any reserved blocks to
	 * the free pool.
	 */
957 958 959 960
	if (!(tp->t_flags & XFS_TRANS_DIRTY))
		goto out_unreserve;

	if (XFS_FORCED_SHUTDOWN(mp)) {
961
		error = -EIO;
962
		goto out_unreserve;
963
	}
964

965 966 967 968 969 970 971 972 973
	ASSERT(tp->t_ticket != NULL);

	/*
	 * If we need to update the superblock, then do it now.
	 */
	if (tp->t_flags & XFS_TRANS_SB_DIRTY)
		xfs_trans_apply_sb_deltas(tp);
	xfs_trans_apply_dquot_deltas(tp);

974
	xfs_log_commit_cil(mp, tp, &commit_lsn, regrant);
Linus Torvalds's avatar
Linus Torvalds committed
975

976
	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
977 978
	xfs_trans_free(tp);

Linus Torvalds's avatar
Linus Torvalds committed
979 980 981 982 983
	/*
	 * If the transaction needs to be synchronous, then force the
	 * log out now and wait for it.
	 */
	if (sync) {
984
		error = xfs_log_force_lsn(mp, commit_lsn, XFS_LOG_SYNC, NULL);
985
		XFS_STATS_INC(mp, xs_trans_sync);
Linus Torvalds's avatar
Linus Torvalds committed
986
	} else {
987
		XFS_STATS_INC(mp, xs_trans_async);
Linus Torvalds's avatar
Linus Torvalds committed
988 989
	}

990 991 992 993 994 995 996 997 998 999 1000 1001
	return error;

out_unreserve:
	xfs_trans_unreserve_and_mod_sb(tp);

	/*
	 * It is indeed possible for the transaction to be not dirty but
	 * the dqinfo portion to be.  All that means is that we have some
	 * (non-persistent) quota reservations that need to be unreserved.
	 */
	xfs_trans_unreserve_and_mod_dquots(tp);
	if (tp->t_ticket) {
1002
		commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, regrant);
1003
		if (commit_lsn == -1 && !error)
1004
			error = -EIO;
1005
		tp->t_ticket = NULL;
1006
	}
1007
	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
1008
	xfs_trans_free_items(tp, !!error);
1009 1010
	xfs_trans_free(tp);

1011
	XFS_STATS_INC(mp, xs_trans_empty);
1012
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
1013 1014
}

1015 1016 1017 1018 1019 1020 1021
int
xfs_trans_commit(
	struct xfs_trans	*tp)
{
	return __xfs_trans_commit(tp, false);
}

Linus Torvalds's avatar
Linus Torvalds committed
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
/*
 * Unlock all of the transaction's items and free the transaction.
 * The transaction must not have modified any of its items, because
 * there is no way to restore them to their previous state.
 *
 * If the transaction has made a log reservation, make sure to release
 * it as well.
 */
void
xfs_trans_cancel(
1032
	struct xfs_trans	*tp)
Linus Torvalds's avatar
Linus Torvalds committed
1033
{
1034 1035
	struct xfs_mount	*mp = tp->t_mountp;
	bool			dirty = (tp->t_flags & XFS_TRANS_DIRTY);
Linus Torvalds's avatar
Linus Torvalds committed
1036

1037 1038
	trace_xfs_trans_cancel(tp, _RET_IP_);

1039
	if (tp->t_flags & XFS_TRANS_PERM_LOG_RES)
1040
		xfs_defer_cancel(tp);
1041

Linus Torvalds's avatar
Linus Torvalds committed
1042 1043 1044 1045 1046
	/*
	 * See if the caller is relying on us to shut down the
	 * filesystem.  This happens in paths where we detect
	 * corruption and decide to give up.
	 */
1047
	if (dirty && !XFS_FORCED_SHUTDOWN(mp)) {
1048
		XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
1049
		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1050
	}
Linus Torvalds's avatar
Linus Torvalds committed
1051
#ifdef DEBUG
1052
	if (!dirty && !XFS_FORCED_SHUTDOWN(mp)) {
1053
		struct xfs_log_item *lip;
1054

1055 1056
		list_for_each_entry(lip, &tp->t_items, li_trans)
			ASSERT(!(lip->li_type == XFS_LI_EFD));
Linus Torvalds's avatar
Linus Torvalds committed
1057 1058 1059
	}
#endif
	xfs_trans_unreserve_and_mod_sb(tp);
Christoph Hellwig's avatar
Christoph Hellwig committed
1060
	xfs_trans_unreserve_and_mod_dquots(tp);
Linus Torvalds's avatar
Linus Torvalds committed
1061

1062
	if (tp->t_ticket) {
1063
		xfs_log_done(mp, tp->t_ticket, NULL, false);
1064 1065
		tp->t_ticket = NULL;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1066 1067

	/* mark this thread as no longer being in a transaction */
1068
	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
Linus Torvalds's avatar
Linus Torvalds committed
1069

1070
	xfs_trans_free_items(tp, dirty);
Linus Torvalds's avatar
Linus Torvalds committed
1071 1072 1073
	xfs_trans_free(tp);
}

1074 1075 1076
/*
 * Roll from one trans in the sequence of PERMANENT transactions to
 * the next: permanent transactions are only flushed out when
1077
 * committed with xfs_trans_commit(), but we still want as soon
1078 1079 1080 1081
 * as possible to let chunks of it go to the log. So we commit the
 * chunk we've been working on and get a new transaction to continue.
 */
int
1082
xfs_trans_roll(
1083
	struct xfs_trans	**tpp)
1084
{
1085
	struct xfs_trans	*trans = *tpp;
1086
	struct xfs_trans_res	tres;
1087 1088
	int			error;

1089 1090
	trace_xfs_trans_roll(trans, _RET_IP_);

1091 1092 1093
	/*
	 * Copy the critical parameters from one trans to the next.
	 */
1094 1095
	tres.tr_logres = trans->t_log_res;
	tres.tr_logcount = trans->t_log_count;
1096

1097 1098 1099 1100 1101 1102 1103 1104 1105
	*tpp = xfs_trans_dup(trans);

	/*
	 * Commit the current transaction.
	 * If this commit failed, then it'd just unlock those items that
	 * are not marked ihold. That also means that a filesystem shutdown
	 * is in progress. The caller takes the responsibility to cancel
	 * the duplicate transaction that gets returned.
	 */
1106
	error = __xfs_trans_commit(trans, true);
1107
	if (error)
Eric Sandeen's avatar
Eric Sandeen committed
1108
		return error;
1109 1110

	/*
1111
	 * Reserve space in the log for the next transaction.
1112 1113 1114 1115 1116 1117
	 * This also pushes items in the "AIL", the list of logged items,
	 * out to disk if they are taking up space at the tail of the log
	 * that we want to use.  This requires that either nothing be locked
	 * across this call, or that anything that is locked be logged in
	 * the prior and the next transactions.
	 */
1118
	tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
1119
	return xfs_trans_reserve(*tpp, &tres, 0, 0);
1120
}