xfs_trans.c 28.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
3
 * Copyright (C) 2010 Red Hat, Inc.
4
 * All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
5
 *
6 7
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
Linus Torvalds's avatar
Linus Torvalds committed
8 9
 * published by the Free Software Foundation.
 *
10 11 12 13
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
Linus Torvalds's avatar
Linus Torvalds committed
14
 *
15 16 17
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
Linus Torvalds's avatar
Linus Torvalds committed
18 19
 */
#include "xfs.h"
20
#include "xfs_fs.h"
21
#include "xfs_shared.h"
22 23 24
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
Linus Torvalds's avatar
Linus Torvalds committed
25 26
#include "xfs_mount.h"
#include "xfs_inode.h"
27
#include "xfs_extent_busy.h"
Linus Torvalds's avatar
Linus Torvalds committed
28
#include "xfs_quota.h"
29
#include "xfs_trans.h"
30
#include "xfs_trans_priv.h"
31
#include "xfs_log.h"
32
#include "xfs_trace.h"
33
#include "xfs_error.h"
Linus Torvalds's avatar
Linus Torvalds committed
34

35
kmem_zone_t	*xfs_trans_zone;
36
kmem_zone_t	*xfs_log_item_desc_zone;
Linus Torvalds's avatar
Linus Torvalds committed
37 38 39 40 41 42 43

/*
 * Initialize the precomputed transaction reservation values
 * in the mount structure.
 */
void
xfs_trans_init(
44
	struct xfs_mount	*mp)
Linus Torvalds's avatar
Linus Torvalds committed
45
{
46
	xfs_trans_resv_calc(mp, M_RES(mp));
Linus Torvalds's avatar
Linus Torvalds committed
47 48
}

49 50 51 52 53 54
/*
 * 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(
55
	struct xfs_trans	*tp)
56
{
57 58
	xfs_extent_busy_sort(&tp->t_busy);
	xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
59

60
	atomic_dec(&tp->t_mountp->m_active_trans);
61
	if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT))
62
		sb_end_intwrite(tp->t_mountp->m_super);
63 64 65 66
	xfs_trans_free_dqinfo(tp);
	kmem_zone_free(xfs_trans_zone, tp);
}

Linus Torvalds's avatar
Linus Torvalds committed
67 68 69 70 71 72 73 74
/*
 * 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.
 */
75
STATIC xfs_trans_t *
Linus Torvalds's avatar
Linus Torvalds committed
76 77 78 79 80 81 82 83 84 85
xfs_trans_dup(
	xfs_trans_t	*tp)
{
	xfs_trans_t	*ntp;

	ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);

	/*
	 * Initialize the new transaction structure.
	 */
86
	ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
Linus Torvalds's avatar
Linus Torvalds committed
87
	ntp->t_mountp = tp->t_mountp;
88
	INIT_LIST_HEAD(&ntp->t_items);
89
	INIT_LIST_HEAD(&ntp->t_busy);
Linus Torvalds's avatar
Linus Torvalds committed
90 91 92

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

94 95
	ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
		       (tp->t_flags & XFS_TRANS_RESERVE) |
96
		       (tp->t_flags & XFS_TRANS_NO_WRITECOUNT);
97
	/* We gave our writer reference to the new transaction */
98
	tp->t_flags |= XFS_TRANS_NO_WRITECOUNT;
99
	ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103
	ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
	tp->t_blk_res = tp->t_blk_res_used;
	ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
	tp->t_rtx_res = tp->t_rtx_res_used;
104
	ntp->t_pflags = tp->t_pflags;
Linus Torvalds's avatar
Linus Torvalds committed
105

Christoph Hellwig's avatar
Christoph Hellwig committed
106
	xfs_trans_dup_dqinfo(tp, ntp);
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125

	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.
 */
126
static int
Linus Torvalds's avatar
Linus Torvalds committed
127
xfs_trans_reserve(
128 129 130 131
	struct xfs_trans	*tp,
	struct xfs_trans_res	*resp,
	uint			blocks,
	uint			rtextents)
Linus Torvalds's avatar
Linus Torvalds committed
132
{
133
	int		error = 0;
134
	bool		rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
Linus Torvalds's avatar
Linus Torvalds committed
135 136

	/* Mark this thread as being in a transaction */
137
	current_set_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
Linus Torvalds's avatar
Linus Torvalds committed
138 139 140 141 142 143 144

	/*
	 * 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) {
145
		error = xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd);
Linus Torvalds's avatar
Linus Torvalds committed
146
		if (error != 0) {
147
			current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
148
			return -ENOSPC;
Linus Torvalds's avatar
Linus Torvalds committed
149 150 151 152 153 154 155
		}
		tp->t_blk_res += blocks;
	}

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

159 160 161 162
		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);
163

164
		if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
Linus Torvalds's avatar
Linus Torvalds committed
165
			tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
166
			permanent = true;
Linus Torvalds's avatar
Linus Torvalds committed
167 168 169 170 171
		} else {
			ASSERT(tp->t_ticket == NULL);
			ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
		}

172
		if (tp->t_ticket != NULL) {
173
			ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
174 175
			error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
		} else {
176 177 178 179
			error = xfs_log_reserve(tp->t_mountp,
						resp->tr_logres,
						resp->tr_logcount,
						&tp->t_ticket, XFS_TRANSACTION,
180
						permanent);
Linus Torvalds's avatar
Linus Torvalds committed
181
		}
182 183 184 185

		if (error)
			goto undo_blocks;

186 187
		tp->t_log_res = resp->tr_logres;
		tp->t_log_count = resp->tr_logcount;
Linus Torvalds's avatar
Linus Torvalds committed
188 189 190 191 192 193 194 195
	}

	/*
	 * 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) {
196
		error = xfs_mod_frextents(tp->t_mountp, -((int64_t)rtextents));
Linus Torvalds's avatar
Linus Torvalds committed
197
		if (error) {
198
			error = -ENOSPC;
Linus Torvalds's avatar
Linus Torvalds committed
199 200 201 202 203 204 205 206 207 208 209 210
			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:
211
	if (resp->tr_logres > 0) {
212
		xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, false);
Linus Torvalds's avatar
Linus Torvalds committed
213 214 215 216 217 218 219
		tp->t_ticket = NULL;
		tp->t_log_res = 0;
		tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
	}

undo_blocks:
	if (blocks > 0) {
220
		xfs_mod_fdblocks(tp->t_mountp, (int64_t)blocks, rsvd);
Linus Torvalds's avatar
Linus Torvalds committed
221 222 223
		tp->t_blk_res = 0;
	}

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

226
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
227 228
}

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
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;

	if (!(flags & XFS_TRANS_NO_WRITECOUNT))
		sb_start_intwrite(mp->m_super);

	WARN_ON(mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
	atomic_inc(&mp->m_active_trans);

	tp = kmem_zone_zalloc(xfs_trans_zone,
		(flags & XFS_TRANS_NOFS) ? KM_NOFS : KM_SLEEP);
	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);

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

	*tpp = tp;
	return 0;
}

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
/*
 * 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
287 288 289 290 291 292 293
/*
 * 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.
294 295 296 297 298 299 300 301
 *
 * 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
302 303 304 305 306
 */
void
xfs_trans_mod_sb(
	xfs_trans_t	*tp,
	uint		field,
307
	int64_t		delta)
Linus Torvalds's avatar
Linus Torvalds committed
308
{
309 310
	uint32_t	flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
	xfs_mount_t	*mp = tp->t_mountp;
Linus Torvalds's avatar
Linus Torvalds committed
311 312 313 314

	switch (field) {
	case XFS_TRANS_SB_ICOUNT:
		tp->t_icount_delta += delta;
315 316
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds's avatar
Linus Torvalds committed
317 318 319
		break;
	case XFS_TRANS_SB_IFREE:
		tp->t_ifree_delta += delta;
320 321
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds's avatar
Linus Torvalds committed
322 323 324 325 326 327 328 329 330 331 332 333
		break;
	case XFS_TRANS_SB_FDBLOCKS:
		/*
		 * Track the number of blocks allocated in the
		 * transaction.  Make sure it does not exceed the
		 * number reserved.
		 */
		if (delta < 0) {
			tp->t_blk_res_used += (uint)-delta;
			ASSERT(tp->t_blk_res_used <= tp->t_blk_res);
		}
		tp->t_fdblocks_delta += delta;
334 335
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds's avatar
Linus Torvalds committed
336 337 338 339 340 341 342 343
		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;
344 345
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds's avatar
Linus Torvalds committed
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
		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
362
		 * in-core superblock's counter.  This should only
Linus Torvalds's avatar
Linus Torvalds committed
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
		 * 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;
	}

399
	tp->t_flags |= flags;
Linus Torvalds's avatar
Linus Torvalds committed
400 401 402 403 404 405 406 407 408 409 410 411 412 413
}

/*
 * 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)
{
414
	xfs_dsb_t	*sbp;
Linus Torvalds's avatar
Linus Torvalds committed
415 416 417 418 419 420 421 422 423 424 425 426 427
	xfs_buf_t	*bp;
	int		whole = 0;

	bp = xfs_trans_getsb(tp, tp->t_mountp, 0);
	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));

428 429 430 431
	/*
	 * Only update the superblock counters if we are logging them
	 */
	if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
432
		if (tp->t_icount_delta)
433
			be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
434
		if (tp->t_ifree_delta)
435
			be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
436
		if (tp->t_fdblocks_delta)
437
			be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
438
		if (tp->t_res_fdblocks_delta)
439
			be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
Linus Torvalds's avatar
Linus Torvalds committed
440 441
	}

442
	if (tp->t_frextents_delta)
443
		be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
444
	if (tp->t_res_frextents_delta)
445
		be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
446 447

	if (tp->t_dblocks_delta) {
448
		be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
Linus Torvalds's avatar
Linus Torvalds committed
449 450
		whole = 1;
	}
451
	if (tp->t_agcount_delta) {
452
		be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
Linus Torvalds's avatar
Linus Torvalds committed
453 454
		whole = 1;
	}
455 456
	if (tp->t_imaxpct_delta) {
		sbp->sb_imax_pct += tp->t_imaxpct_delta;
Linus Torvalds's avatar
Linus Torvalds committed
457 458
		whole = 1;
	}
459
	if (tp->t_rextsize_delta) {
460
		be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
Linus Torvalds's avatar
Linus Torvalds committed
461 462
		whole = 1;
	}
463
	if (tp->t_rbmblocks_delta) {
464
		be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
Linus Torvalds's avatar
Linus Torvalds committed
465 466
		whole = 1;
	}
467
	if (tp->t_rblocks_delta) {
468
		be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
Linus Torvalds's avatar
Linus Torvalds committed
469 470
		whole = 1;
	}
471
	if (tp->t_rextents_delta) {
472
		be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
Linus Torvalds's avatar
Linus Torvalds committed
473 474
		whole = 1;
	}
475 476
	if (tp->t_rextslog_delta) {
		sbp->sb_rextslog += tp->t_rextslog_delta;
Linus Torvalds's avatar
Linus Torvalds committed
477 478 479
		whole = 1;
	}

480
	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
Linus Torvalds's avatar
Linus Torvalds committed
481 482
	if (whole)
		/*
483
		 * Log the whole thing, the fields are noncontiguous.
Linus Torvalds's avatar
Linus Torvalds committed
484
		 */
485
		xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
Linus Torvalds's avatar
Linus Torvalds committed
486 487 488 489 490
	else
		/*
		 * Since all the modifiable fields are contiguous, we
		 * can get away with this.
		 */
491 492
		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
493 494 495
				  sizeof(sbp->sb_frextents) - 1);
}

496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
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
544
/*
545 546 547 548 549
 * 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
550
 *
551 552 553 554
 * 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
555
 */
556
void
Linus Torvalds's avatar
Linus Torvalds committed
557
xfs_trans_unreserve_and_mod_sb(
558
	struct xfs_trans	*tp)
Linus Torvalds's avatar
Linus Torvalds committed
559
{
560 561 562 563 564 565 566
	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
567

568
	/* calculate deltas */
569 570 571 572 573 574 575 576 577 578 579 580 581
	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;

582 583 584 585 586 587 588 589
	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) {
590
		error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
591 592 593 594 595
		if (error)
			goto out;
	}

	if (idelta) {
596
		error = xfs_mod_icount(mp, idelta);
597 598 599 600 601
		if (error)
			goto out_undo_fdblocks;
	}

	if (ifreedelta) {
602
		error = xfs_mod_ifree(mp, ifreedelta);
603 604 605 606
		if (error)
			goto out_undo_icount;
	}

607 608 609
	if (rtxdelta == 0 && !(tp->t_flags & XFS_TRANS_SB_DIRTY))
		return;

610
	/* apply remaining deltas */
611
	spin_lock(&mp->m_sb_lock);
612
	if (rtxdelta) {
613
		error = xfs_sb_mod64(&mp->m_sb.sb_frextents, rtxdelta);
614 615
		if (error)
			goto out_undo_ifree;
Linus Torvalds's avatar
Linus Torvalds committed
616 617
	}

618 619
	if (tp->t_dblocks_delta != 0) {
		error = xfs_sb_mod64(&mp->m_sb.sb_dblocks, tp->t_dblocks_delta);
620
		if (error)
621
			goto out_undo_frextents;
Linus Torvalds's avatar
Linus Torvalds committed
622
	}
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
	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);
663 664
	return;

665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
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);
686 687
out_undo_frextents:
	if (rtxdelta)
688
		xfs_sb_mod64(&mp->m_sb.sb_frextents, -rtxdelta);
689
out_undo_ifree:
690
	spin_unlock(&mp->m_sb_lock);
691
	if (ifreedelta)
692
		xfs_mod_ifree(mp, -ifreedelta);
693 694
out_undo_icount:
	if (idelta)
695
		xfs_mod_icount(mp, -idelta);
696 697
out_undo_fdblocks:
	if (blkdelta)
698
		xfs_mod_fdblocks(mp, -blkdelta, rsvd);
699
out:
700
	ASSERT(error == 0);
701
	return;
Linus Torvalds's avatar
Linus Torvalds committed
702 703
}

704 705 706 707 708 709 710 711 712 713 714 715
/*
 * Add the given log item to the transaction's list of log items.
 *
 * The log item will now point to its new descriptor with its li_desc field.
 */
void
xfs_trans_add_item(
	struct xfs_trans	*tp,
	struct xfs_log_item	*lip)
{
	struct xfs_log_item_desc *lidp;

716 717
	ASSERT(lip->li_mountp == tp->t_mountp);
	ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
718

719
	lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS);
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750

	lidp->lid_item = lip;
	lidp->lid_flags = 0;
	list_add_tail(&lidp->lid_trans, &tp->t_items);

	lip->li_desc = lidp;
}

STATIC void
xfs_trans_free_item_desc(
	struct xfs_log_item_desc *lidp)
{
	list_del_init(&lidp->lid_trans);
	kmem_zone_free(xfs_log_item_desc_zone, lidp);
}

/*
 * Unlink and free the given descriptor.
 */
void
xfs_trans_del_item(
	struct xfs_log_item	*lip)
{
	xfs_trans_free_item_desc(lip->li_desc);
	lip->li_desc = NULL;
}

/*
 * Unlock all of the items of a transaction and free all the descriptors
 * of that transaction.
 */
751
void
752 753 754
xfs_trans_free_items(
	struct xfs_trans	*tp,
	xfs_lsn_t		commit_lsn,
755
	bool			abort)
756 757 758 759 760 761 762 763 764
{
	struct xfs_log_item_desc *lidp, *next;

	list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) {
		struct xfs_log_item	*lip = lidp->lid_item;

		lip->li_desc = NULL;

		if (commit_lsn != NULLCOMMITLSN)
765
			lip->li_ops->iop_committing(lip, commit_lsn);
766
		if (abort)
767
			lip->li_flags |= XFS_LI_ABORTED;
768
		lip->li_ops->iop_unlock(lip);
769 770 771 772 773

		xfs_trans_free_item_desc(lidp);
	}
}

774 775 776
static inline void
xfs_log_item_batch_insert(
	struct xfs_ail		*ailp,
777
	struct xfs_ail_cursor	*cur,
778 779 780 781 782 783 784 785
	struct xfs_log_item	**log_items,
	int			nr_items,
	xfs_lsn_t		commit_lsn)
{
	int	i;

	spin_lock(&ailp->xa_lock);
	/* xfs_trans_ail_update_bulk drops ailp->xa_lock */
786
	xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
787

788 789 790 791 792
	for (i = 0; i < nr_items; i++) {
		struct xfs_log_item *lip = log_items[i];

		lip->li_ops->iop_unpin(lip, 0);
	}
793 794 795 796 797 798
}

/*
 * 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.
799 800 801
 *
 * 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
802
 * checkpoint have already gone through iop_commited and iop_unlock, which
803 804
 * 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
805 806
 * this case all we need to do is iop_committed processing, followed by an
 * iop_unpin(aborted) call.
807 808 809 810 811 812 813
 *
 * 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.
814 815 816 817 818 819 820 821 822 823 824
 */
void
xfs_trans_committed_bulk(
	struct xfs_ail		*ailp,
	struct xfs_log_vec	*log_vector,
	xfs_lsn_t		commit_lsn,
	int			aborted)
{
#define LOG_ITEM_BATCH_SIZE	32
	struct xfs_log_item	*log_items[LOG_ITEM_BATCH_SIZE];
	struct xfs_log_vec	*lv;
825
	struct xfs_ail_cursor	cur;
826 827
	int			i = 0;

828 829 830 831
	spin_lock(&ailp->xa_lock);
	xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
	spin_unlock(&ailp->xa_lock);

832 833 834 835 836 837 838
	/* 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)
			lip->li_flags |= XFS_LI_ABORTED;
839
		item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
840

841
		/* item_lsn of -1 means the item needs no further processing */
842 843 844
		if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
			continue;

845 846 847 848 849 850
		/*
		 * if we are aborting the operation, no point in inserting the
		 * object into the AIL as we are in a shutdown situation.
		 */
		if (aborted) {
			ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount));
851
			lip->li_ops->iop_unpin(lip, 1);
852 853 854
			continue;
		}

855 856 857 858 859
		if (item_lsn != commit_lsn) {

			/*
			 * Not a bulk update option due to unusual item_lsn.
			 * Push into AIL immediately, rechecking the lsn once
860 861 862
			 * we have the ail lock. Then unpin the item. This does
			 * not affect the AIL cursor the bulk insert path is
			 * using.
863 864 865 866 867 868
			 */
			spin_lock(&ailp->xa_lock);
			if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
				xfs_trans_ail_update(ailp, lip, item_lsn);
			else
				spin_unlock(&ailp->xa_lock);
869
			lip->li_ops->iop_unpin(lip, 0);
870 871 872 873 874 875
			continue;
		}

		/* Item is a candidate for bulk AIL insert.  */
		log_items[i++] = lv->lv_item;
		if (i >= LOG_ITEM_BATCH_SIZE) {
876
			xfs_log_item_batch_insert(ailp, &cur, log_items,
877 878 879 880 881 882 883
					LOG_ITEM_BATCH_SIZE, commit_lsn);
			i = 0;
		}
	}

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

	spin_lock(&ailp->xa_lock);
887
	xfs_trans_ail_cursor_done(&cur);
888
	spin_unlock(&ailp->xa_lock);
889 890
}

891
/*
892
 * Commit the given transaction to the log.
893 894 895 896 897 898 899 900 901 902
 *
 * 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.
 */
903 904
static int
__xfs_trans_commit(
905
	struct xfs_trans	*tp,
906
	bool			regrant)
907
{
908
	struct xfs_mount	*mp = tp->t_mountp;
909
	xfs_lsn_t		commit_lsn = -1;
910
	int			error = 0;
911 912 913 914 915 916 917 918 919
	int			sync = tp->t_flags & XFS_TRANS_SYNC;

	/*
	 * 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.
	 */
920 921 922 923
	if (!(tp->t_flags & XFS_TRANS_DIRTY))
		goto out_unreserve;

	if (XFS_FORCED_SHUTDOWN(mp)) {
924
		error = -EIO;
925
		goto out_unreserve;
926
	}
927

928 929 930 931 932 933 934 935 936
	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);

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

939
	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
940 941
	xfs_trans_free(tp);

Linus Torvalds's avatar
Linus Torvalds committed
942 943 944 945 946
	/*
	 * If the transaction needs to be synchronous, then force the
	 * log out now and wait for it.
	 */
	if (sync) {
947
		error = _xfs_log_force_lsn(mp, commit_lsn, XFS_LOG_SYNC, NULL);
948
		XFS_STATS_INC(mp, xs_trans_sync);
Linus Torvalds's avatar
Linus Torvalds committed
949
	} else {
950
		XFS_STATS_INC(mp, xs_trans_async);
Linus Torvalds's avatar
Linus Torvalds committed
951 952
	}

953 954 955 956 957 958 959 960 961 962 963 964
	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) {
965
		commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, regrant);
966
		if (commit_lsn == -1 && !error)
967
			error = -EIO;
968
	}
969
	current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
970
	xfs_trans_free_items(tp, NULLCOMMITLSN, !!error);
971 972
	xfs_trans_free(tp);

973
	XFS_STATS_INC(mp, xs_trans_empty);
974
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
975 976
}

977 978 979 980 981 982 983
int
xfs_trans_commit(
	struct xfs_trans	*tp)
{
	return __xfs_trans_commit(tp, false);
}

Linus Torvalds's avatar
Linus Torvalds committed
984 985 986 987 988 989 990 991 992 993
/*
 * 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(
994
	struct xfs_trans	*tp)
Linus Torvalds's avatar
Linus Torvalds committed
995
{
996 997
	struct xfs_mount	*mp = tp->t_mountp;
	bool			dirty = (tp->t_flags & XFS_TRANS_DIRTY);
Linus Torvalds's avatar
Linus Torvalds committed
998 999 1000 1001 1002 1003

	/*
	 * 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.
	 */
1004
	if (dirty && !XFS_FORCED_SHUTDOWN(mp)) {
1005
		XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
1006
		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1007
	}
Linus Torvalds's avatar
Linus Torvalds committed
1008
#ifdef DEBUG
1009
	if (!dirty && !XFS_FORCED_SHUTDOWN(mp)) {
1010 1011 1012 1013
		struct xfs_log_item_desc *lidp;

		list_for_each_entry(lidp, &tp->t_items, lid_trans)
			ASSERT(!(lidp->lid_item->li_type == XFS_LI_EFD));
Linus Torvalds's avatar
Linus Torvalds committed
1014 1015 1016
	}
#endif
	xfs_trans_unreserve_and_mod_sb(tp);
Christoph Hellwig's avatar
Christoph Hellwig committed
1017
	xfs_trans_unreserve_and_mod_dquots(tp);
Linus Torvalds's avatar
Linus Torvalds committed
1018

1019 1020
	if (tp->t_ticket)
		xfs_log_done(mp, tp->t_ticket, NULL, false);
Linus Torvalds's avatar
Linus Torvalds committed
1021 1022

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

1025
	xfs_trans_free_items(tp, NULLCOMMITLSN, dirty);
Linus Torvalds's avatar
Linus Torvalds committed
1026 1027 1028
	xfs_trans_free(tp);
}

1029 1030 1031
/*
 * Roll from one trans in the sequence of PERMANENT transactions to
 * the next: permanent transactions are only flushed out when
1032
 * committed with xfs_trans_commit(), but we still want as soon
1033 1034 1035 1036
 * 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
1037
xfs_trans_roll(
1038
	struct xfs_trans	**tpp)
1039
{
1040
	struct xfs_trans	*trans = *tpp;
1041
	struct xfs_trans_res	tres;
1042 1043 1044 1045 1046
	int			error;

	/*
	 * Copy the critical parameters from one trans to the next.
	 */
1047 1048
	tres.tr_logres = trans->t_log_res;
	tres.tr_logcount = trans->t_log_count;
1049

1050 1051 1052 1053 1054 1055 1056 1057 1058
	*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.
	 */
1059
	error = __xfs_trans_commit(trans, true);
1060
	if (error)
1061
		return error;
1062 1063

	/*
1064
	 * Reserve space in the log for the next transaction.
1065 1066 1067 1068 1069 1070
	 * 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.
	 */
1071
	tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
1072
	return xfs_trans_reserve(*tpp, &tres, 0, 0);
1073
}