xfs_trans.c 27.8 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
3
 * Copyright (C) 2010 Red Hat, Inc.
4
 * All Rights Reserved.
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
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.
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
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"
L
Linus Torvalds 已提交
25 26
#include "xfs_mount.h"
#include "xfs_inode.h"
27
#include "xfs_extent_busy.h"
L
Linus Torvalds 已提交
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"
L
Linus Torvalds 已提交
34

35
kmem_zone_t	*xfs_trans_zone;
36
kmem_zone_t	*xfs_log_item_desc_zone;
L
Linus Torvalds 已提交
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)
L
Linus Torvalds 已提交
45
{
46
	xfs_trans_resv_calc(mp, M_RES(mp));
L
Linus Torvalds 已提交
47 48 49 50 51 52
}

/*
 * This routine is called to allocate a transaction structure.
 * The type parameter indicates the type of the transaction.  These
 * are enumerated in xfs_trans.h.
53 54 55
 *
 * Dynamically allocate the transaction structure from the transaction
 * zone, initialize it, and return it to the caller.
L
Linus Torvalds 已提交
56
 */
57 58 59 60 61
xfs_trans_t *
xfs_trans_alloc(
	xfs_mount_t	*mp,
	uint		type)
{
J
Jan Kara 已提交
62 63 64 65 66 67
	xfs_trans_t     *tp;

	sb_start_intwrite(mp->m_super);
	tp = _xfs_trans_alloc(mp, type, KM_SLEEP);
	tp->t_flags |= XFS_TRANS_FREEZE_PROT;
	return tp;
68 69 70
}

xfs_trans_t *
L
Linus Torvalds 已提交
71
_xfs_trans_alloc(
72 73
	xfs_mount_t	*mp,
	uint		type,
74
	xfs_km_flags_t	memflags)
L
Linus Torvalds 已提交
75
{
76
	xfs_trans_t	*tp;
L
Linus Torvalds 已提交
77

J
Jan Kara 已提交
78
	WARN_ON(mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
79
	atomic_inc(&mp->m_active_trans);
L
Linus Torvalds 已提交
80

81
	tp = kmem_zone_zalloc(xfs_trans_zone, memflags);
82
	tp->t_magic = XFS_TRANS_HEADER_MAGIC;
L
Linus Torvalds 已提交
83 84
	tp->t_type = type;
	tp->t_mountp = mp;
85
	INIT_LIST_HEAD(&tp->t_items);
86
	INIT_LIST_HEAD(&tp->t_busy);
87
	return tp;
L
Linus Torvalds 已提交
88 89
}

90 91 92 93 94 95
/*
 * 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(
96
	struct xfs_trans	*tp)
97
{
D
Dave Chinner 已提交
98 99
	xfs_extent_busy_sort(&tp->t_busy);
	xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
100

101
	atomic_dec(&tp->t_mountp->m_active_trans);
J
Jan Kara 已提交
102 103
	if (tp->t_flags & XFS_TRANS_FREEZE_PROT)
		sb_end_intwrite(tp->t_mountp->m_super);
104 105 106 107
	xfs_trans_free_dqinfo(tp);
	kmem_zone_free(xfs_trans_zone, tp);
}

L
Linus Torvalds 已提交
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
/*
 * 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.
 */
xfs_trans_t *
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.
	 */
127
	ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
L
Linus Torvalds 已提交
128 129
	ntp->t_type = tp->t_type;
	ntp->t_mountp = tp->t_mountp;
130
	INIT_LIST_HEAD(&ntp->t_items);
131
	INIT_LIST_HEAD(&ntp->t_busy);
L
Linus Torvalds 已提交
132 133 134

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

J
Jan Kara 已提交
136 137 138 139 140
	ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
		       (tp->t_flags & XFS_TRANS_RESERVE) |
		       (tp->t_flags & XFS_TRANS_FREEZE_PROT);
	/* We gave our writer reference to the new transaction */
	tp->t_flags &= ~XFS_TRANS_FREEZE_PROT;
141
	ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
L
Linus Torvalds 已提交
142 143 144 145
	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;
146
	ntp->t_pflags = tp->t_pflags;
L
Linus Torvalds 已提交
147

C
Christoph Hellwig 已提交
148
	xfs_trans_dup_dqinfo(tp, ntp);
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169

	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.
 */
int
xfs_trans_reserve(
170 171 172 173
	struct xfs_trans	*tp,
	struct xfs_trans_res	*resp,
	uint			blocks,
	uint			rtextents)
L
Linus Torvalds 已提交
174
{
175
	int		error = 0;
176
	bool		rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
L
Linus Torvalds 已提交
177 178

	/* Mark this thread as being in a transaction */
179
	current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
L
Linus Torvalds 已提交
180 181 182 183 184 185 186

	/*
	 * 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) {
187
		error = xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd);
L
Linus Torvalds 已提交
188
		if (error != 0) {
189
			current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
D
Dave Chinner 已提交
190
			return -ENOSPC;
L
Linus Torvalds 已提交
191 192 193 194 195 196 197
		}
		tp->t_blk_res += blocks;
	}

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

201 202 203 204
		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);
205

206
		if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
L
Linus Torvalds 已提交
207
			tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
208
			permanent = true;
L
Linus Torvalds 已提交
209 210 211 212 213
		} else {
			ASSERT(tp->t_ticket == NULL);
			ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
		}

214
		if (tp->t_ticket != NULL) {
215
			ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
216 217
			error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
		} else {
218 219 220 221 222
			error = xfs_log_reserve(tp->t_mountp,
						resp->tr_logres,
						resp->tr_logcount,
						&tp->t_ticket, XFS_TRANSACTION,
						permanent, tp->t_type);
L
Linus Torvalds 已提交
223
		}
224 225 226 227

		if (error)
			goto undo_blocks;

228 229
		tp->t_log_res = resp->tr_logres;
		tp->t_log_count = resp->tr_logcount;
L
Linus Torvalds 已提交
230 231 232 233 234 235 236 237
	}

	/*
	 * 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) {
D
Dave Chinner 已提交
238
		error = xfs_mod_frextents(tp->t_mountp, -((int64_t)rtextents));
L
Linus Torvalds 已提交
239
		if (error) {
D
Dave Chinner 已提交
240
			error = -ENOSPC;
L
Linus Torvalds 已提交
241 242 243 244 245 246 247 248 249 250 251 252
			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:
253
	if (resp->tr_logres > 0) {
254 255
		int		log_flags;

256
		if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
L
Linus Torvalds 已提交
257 258 259 260 261 262 263 264 265 266 267 268
			log_flags = XFS_LOG_REL_PERM_RESERV;
		} else {
			log_flags = 0;
		}
		xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, log_flags);
		tp->t_ticket = NULL;
		tp->t_log_res = 0;
		tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
	}

undo_blocks:
	if (blocks > 0) {
269
		xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd);
L
Linus Torvalds 已提交
270 271 272
		tp->t_blk_res = 0;
	}

273
	current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
L
Linus Torvalds 已提交
274

275
	return error;
L
Linus Torvalds 已提交
276 277 278 279 280 281 282 283 284
}

/*
 * 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.
D
David Chinner 已提交
285 286 287 288 289 290 291 292
 *
 * 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.
L
Linus Torvalds 已提交
293 294 295 296 297
 */
void
xfs_trans_mod_sb(
	xfs_trans_t	*tp,
	uint		field,
298
	int64_t		delta)
L
Linus Torvalds 已提交
299
{
D
David Chinner 已提交
300 301
	uint32_t	flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
	xfs_mount_t	*mp = tp->t_mountp;
L
Linus Torvalds 已提交
302 303 304 305

	switch (field) {
	case XFS_TRANS_SB_ICOUNT:
		tp->t_icount_delta += delta;
D
David Chinner 已提交
306 307
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
L
Linus Torvalds 已提交
308 309 310
		break;
	case XFS_TRANS_SB_IFREE:
		tp->t_ifree_delta += delta;
D
David Chinner 已提交
311 312
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
L
Linus Torvalds 已提交
313 314 315 316 317 318 319 320 321 322 323 324
		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;
D
David Chinner 已提交
325 326
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
L
Linus Torvalds 已提交
327 328 329 330 331 332 333 334 335
		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.
		 */
		ASSERT(delta < 0);
		tp->t_res_fdblocks_delta += delta;
D
David Chinner 已提交
336 337
		if (xfs_sb_version_haslazysbcount(&mp->m_sb))
			flags &= ~XFS_TRANS_SB_DIRTY;
L
Linus Torvalds 已提交
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
		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
354
		 * in-core superblock's counter.  This should only
L
Linus Torvalds 已提交
355 356 357 358 359 360 361 362 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
		 * 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;
	}

391
	tp->t_flags |= flags;
L
Linus Torvalds 已提交
392 393 394 395 396 397 398 399 400 401 402 403 404 405
}

/*
 * 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)
{
406
	xfs_dsb_t	*sbp;
L
Linus Torvalds 已提交
407 408 409 410 411 412 413 414 415 416 417 418 419
	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));

D
David Chinner 已提交
420 421 422 423
	/*
	 * Only update the superblock counters if we are logging them
	 */
	if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
424
		if (tp->t_icount_delta)
425
			be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
426
		if (tp->t_ifree_delta)
427
			be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
428
		if (tp->t_fdblocks_delta)
429
			be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
430
		if (tp->t_res_fdblocks_delta)
431
			be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
L
Linus Torvalds 已提交
432 433
	}

434
	if (tp->t_frextents_delta)
435
		be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
436
	if (tp->t_res_frextents_delta)
437
		be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
438 439

	if (tp->t_dblocks_delta) {
440
		be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
L
Linus Torvalds 已提交
441 442
		whole = 1;
	}
443
	if (tp->t_agcount_delta) {
444
		be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
L
Linus Torvalds 已提交
445 446
		whole = 1;
	}
447 448
	if (tp->t_imaxpct_delta) {
		sbp->sb_imax_pct += tp->t_imaxpct_delta;
L
Linus Torvalds 已提交
449 450
		whole = 1;
	}
451
	if (tp->t_rextsize_delta) {
452
		be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
L
Linus Torvalds 已提交
453 454
		whole = 1;
	}
455
	if (tp->t_rbmblocks_delta) {
456
		be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
L
Linus Torvalds 已提交
457 458
		whole = 1;
	}
459
	if (tp->t_rblocks_delta) {
460
		be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
L
Linus Torvalds 已提交
461 462
		whole = 1;
	}
463
	if (tp->t_rextents_delta) {
464
		be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
L
Linus Torvalds 已提交
465 466
		whole = 1;
	}
467 468
	if (tp->t_rextslog_delta) {
		sbp->sb_rextslog += tp->t_rextslog_delta;
L
Linus Torvalds 已提交
469 470 471
		whole = 1;
	}

472
	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
L
Linus Torvalds 已提交
473 474
	if (whole)
		/*
475
		 * Log the whole thing, the fields are noncontiguous.
L
Linus Torvalds 已提交
476
		 */
477
		xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
L
Linus Torvalds 已提交
478 479 480 481 482
	else
		/*
		 * Since all the modifiable fields are contiguous, we
		 * can get away with this.
		 */
483 484
		xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
				  offsetof(xfs_dsb_t, sb_frextents) +
L
Linus Torvalds 已提交
485 486 487 488
				  sizeof(sbp->sb_frextents) - 1);
}

/*
489 490 491 492 493
 * 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.
L
Linus Torvalds 已提交
494 495
 *
 * This is done efficiently with a single call to xfs_mod_incore_sb_batch().
496 497 498 499 500 501 502 503 504 505
 * However, we have to ensure that we only modify each superblock field only
 * once because the application of the delta values may not be atomic. That can
 * lead to ENOSPC races occurring if we have two separate modifcations of the
 * free space counter to put back the entire reservation and then take away
 * what we used.
 *
 * 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.
L
Linus Torvalds 已提交
506
 */
507
void
L
Linus Torvalds 已提交
508 509 510
xfs_trans_unreserve_and_mod_sb(
	xfs_trans_t	*tp)
{
511
	xfs_mod_sb_t	msb[9];	/* If you add cases, add entries */
L
Linus Torvalds 已提交
512
	xfs_mod_sb_t	*msbp;
D
David Chinner 已提交
513
	xfs_mount_t	*mp = tp->t_mountp;
L
Linus Torvalds 已提交
514 515
	/* REFERENCED */
	int		error;
516
	bool		rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
517 518
	int64_t		blkdelta = 0;
	int64_t		rtxdelta = 0;
519 520
	int64_t		idelta = 0;
	int64_t		ifreedelta = 0;
L
Linus Torvalds 已提交
521 522 523

	msbp = msb;

524
	/* calculate deltas */
525 526 527 528 529 530 531 532 533 534 535 536 537
	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;

538 539 540 541 542 543 544 545
	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) {
546
		error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
547 548 549 550 551
		if (error)
			goto out;
	}

	if (idelta) {
552
		error = xfs_mod_icount(mp, idelta);
553 554 555 556 557
		if (error)
			goto out_undo_fdblocks;
	}

	if (ifreedelta) {
558
		error = xfs_mod_ifree(mp, ifreedelta);
559 560 561 562 563
		if (error)
			goto out_undo_icount;
	}

	/* apply remaining deltas */
D
Dave Chinner 已提交
564 565 566 567
	if (rtxdelta) {
		error = xfs_mod_frextents(mp, rtxdelta);
		if (error)
			goto out_undo_ifree;
L
Linus Torvalds 已提交
568 569
	}

D
David Chinner 已提交
570
	if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
L
Linus Torvalds 已提交
571 572
		if (tp->t_dblocks_delta != 0) {
			msbp->msb_field = XFS_SBS_DBLOCKS;
573
			msbp->msb_delta = tp->t_dblocks_delta;
L
Linus Torvalds 已提交
574 575 576 577
			msbp++;
		}
		if (tp->t_agcount_delta != 0) {
			msbp->msb_field = XFS_SBS_AGCOUNT;
578
			msbp->msb_delta = tp->t_agcount_delta;
L
Linus Torvalds 已提交
579 580 581 582
			msbp++;
		}
		if (tp->t_imaxpct_delta != 0) {
			msbp->msb_field = XFS_SBS_IMAX_PCT;
583
			msbp->msb_delta = tp->t_imaxpct_delta;
L
Linus Torvalds 已提交
584 585 586 587
			msbp++;
		}
		if (tp->t_rextsize_delta != 0) {
			msbp->msb_field = XFS_SBS_REXTSIZE;
588
			msbp->msb_delta = tp->t_rextsize_delta;
L
Linus Torvalds 已提交
589 590 591 592
			msbp++;
		}
		if (tp->t_rbmblocks_delta != 0) {
			msbp->msb_field = XFS_SBS_RBMBLOCKS;
593
			msbp->msb_delta = tp->t_rbmblocks_delta;
L
Linus Torvalds 已提交
594 595 596 597
			msbp++;
		}
		if (tp->t_rblocks_delta != 0) {
			msbp->msb_field = XFS_SBS_RBLOCKS;
598
			msbp->msb_delta = tp->t_rblocks_delta;
L
Linus Torvalds 已提交
599 600 601 602
			msbp++;
		}
		if (tp->t_rextents_delta != 0) {
			msbp->msb_field = XFS_SBS_REXTENTS;
603
			msbp->msb_delta = tp->t_rextents_delta;
L
Linus Torvalds 已提交
604 605 606 607
			msbp++;
		}
		if (tp->t_rextslog_delta != 0) {
			msbp->msb_field = XFS_SBS_REXTSLOG;
608
			msbp->msb_delta = tp->t_rextslog_delta;
L
Linus Torvalds 已提交
609 610 611 612 613 614 615 616 617 618
			msbp++;
		}
	}

	/*
	 * If we need to change anything, do it.
	 */
	if (msbp > msb) {
		error = xfs_mod_incore_sb_batch(tp->t_mountp, msb,
			(uint)(msbp - msb), rsvd);
619
		if (error)
D
Dave Chinner 已提交
620
			goto out_undo_frextents;
L
Linus Torvalds 已提交
621
	}
622 623 624

	return;

D
Dave Chinner 已提交
625 626 627 628
out_undo_frextents:
	if (rtxdelta)
		xfs_mod_frextents(mp, -rtxdelta);
out_undo_ifree:
629
	if (ifreedelta)
630
		xfs_mod_ifree(mp, -ifreedelta);
631 632
out_undo_icount:
	if (idelta)
633
		xfs_mod_icount(mp, -idelta);
634 635
out_undo_fdblocks:
	if (blkdelta)
636
		xfs_mod_fdblocks(mp, -blkdelta, rsvd);
637
out:
638
	ASSERT(error == 0);
639
	return;
L
Linus Torvalds 已提交
640 641
}

642 643 644 645 646 647 648 649 650 651 652 653
/*
 * 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;

654 655
	ASSERT(lip->li_mountp == tp->t_mountp);
	ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
656

657
	lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS);
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

	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.
 */
689
void
690 691 692 693 694 695 696 697 698 699 700 701 702
xfs_trans_free_items(
	struct xfs_trans	*tp,
	xfs_lsn_t		commit_lsn,
	int			flags)
{
	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)
703
			lip->li_ops->iop_committing(lip, commit_lsn);
704 705
		if (flags & XFS_TRANS_ABORT)
			lip->li_flags |= XFS_LI_ABORTED;
706
		lip->li_ops->iop_unlock(lip);
707 708 709 710 711

		xfs_trans_free_item_desc(lidp);
	}
}

712 713 714
static inline void
xfs_log_item_batch_insert(
	struct xfs_ail		*ailp,
715
	struct xfs_ail_cursor	*cur,
716 717 718 719 720 721 722 723
	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 */
724
	xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
725

726 727 728 729 730
	for (i = 0; i < nr_items; i++) {
		struct xfs_log_item *lip = log_items[i];

		lip->li_ops->iop_unpin(lip, 0);
	}
731 732 733 734 735 736
}

/*
 * 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.
737 738 739
 *
 * 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
740
 * checkpoint have already gone through iop_commited and iop_unlock, which
741 742
 * 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
743 744
 * this case all we need to do is iop_committed processing, followed by an
 * iop_unpin(aborted) call.
745 746 747 748 749 750 751
 *
 * 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.
752 753 754 755 756 757 758 759 760 761 762
 */
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;
763
	struct xfs_ail_cursor	cur;
764 765
	int			i = 0;

766 767 768 769
	spin_lock(&ailp->xa_lock);
	xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
	spin_unlock(&ailp->xa_lock);

770 771 772 773 774 775 776
	/* 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;
777
		item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
778

779
		/* item_lsn of -1 means the item needs no further processing */
780 781 782
		if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
			continue;

783 784 785 786 787 788
		/*
		 * 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));
789
			lip->li_ops->iop_unpin(lip, 1);
790 791 792
			continue;
		}

793 794 795 796 797
		if (item_lsn != commit_lsn) {

			/*
			 * Not a bulk update option due to unusual item_lsn.
			 * Push into AIL immediately, rechecking the lsn once
798 799 800
			 * we have the ail lock. Then unpin the item. This does
			 * not affect the AIL cursor the bulk insert path is
			 * using.
801 802 803 804 805 806
			 */
			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);
807
			lip->li_ops->iop_unpin(lip, 0);
808 809 810 811 812 813
			continue;
		}

		/* Item is a candidate for bulk AIL insert.  */
		log_items[i++] = lv->lv_item;
		if (i >= LOG_ITEM_BATCH_SIZE) {
814
			xfs_log_item_batch_insert(ailp, &cur, log_items,
815 816 817 818 819 820 821
					LOG_ITEM_BATCH_SIZE, commit_lsn);
			i = 0;
		}
	}

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

	spin_lock(&ailp->xa_lock);
825
	xfs_trans_ail_cursor_done(&cur);
826
	spin_unlock(&ailp->xa_lock);
827 828
}

829
/*
830
 * Commit the given transaction to the log.
831 832 833 834 835 836 837 838 839 840 841
 *
 * 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.
 */
int
842
xfs_trans_commit(
843
	struct xfs_trans	*tp,
844
	uint			flags)
845
{
846
	struct xfs_mount	*mp = tp->t_mountp;
847
	xfs_lsn_t		commit_lsn = -1;
848
	int			error = 0;
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
	int			log_flags = 0;
	int			sync = tp->t_flags & XFS_TRANS_SYNC;

	/*
	 * Determine whether this commit is releasing a permanent
	 * log reservation or not.
	 */
	if (flags & XFS_TRANS_RELEASE_LOG_RES) {
		ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
		log_flags = XFS_LOG_REL_PERM_RESERV;
	}

	/*
	 * 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.
	 */
868 869 870 871
	if (!(tp->t_flags & XFS_TRANS_DIRTY))
		goto out_unreserve;

	if (XFS_FORCED_SHUTDOWN(mp)) {
D
Dave Chinner 已提交
872
		error = -EIO;
873
		goto out_unreserve;
874
	}
875

876 877 878 879 880 881 882 883 884
	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);

885
	xfs_log_commit_cil(mp, tp, &commit_lsn, flags);
L
Linus Torvalds 已提交
886

887 888 889
	current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
	xfs_trans_free(tp);

L
Linus Torvalds 已提交
890 891 892 893 894
	/*
	 * If the transaction needs to be synchronous, then force the
	 * log out now and wait for it.
	 */
	if (sync) {
895
		error = _xfs_log_force_lsn(mp, commit_lsn, XFS_LOG_SYNC, NULL);
L
Linus Torvalds 已提交
896 897 898 899 900
		XFS_STATS_INC(xs_trans_sync);
	} else {
		XFS_STATS_INC(xs_trans_async);
	}

901 902 903 904 905 906 907 908 909 910 911 912 913 914
	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) {
		commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
		if (commit_lsn == -1 && !error)
D
Dave Chinner 已提交
915
			error = -EIO;
916 917
	}
	current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
918
	xfs_trans_free_items(tp, NULLCOMMITLSN, error ? XFS_TRANS_ABORT : 0);
919 920 921 922
	xfs_trans_free(tp);

	XFS_STATS_INC(xs_trans_empty);
	return error;
L
Linus Torvalds 已提交
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
}

/*
 * 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(
	xfs_trans_t		*tp,
	int			flags)
{
	int			log_flags;
939
	xfs_mount_t		*mp = tp->t_mountp;
L
Linus Torvalds 已提交
940 941 942 943 944 945 946 947 948 949 950 951

	/*
	 * See if the caller is being too lazy to figure out if
	 * the transaction really needs an abort.
	 */
	if ((flags & XFS_TRANS_ABORT) && !(tp->t_flags & XFS_TRANS_DIRTY))
		flags &= ~XFS_TRANS_ABORT;
	/*
	 * 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.
	 */
952
	if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) {
953
		XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
954
		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
955
	}
L
Linus Torvalds 已提交
956
#ifdef DEBUG
957 958 959 960 961
	if (!(flags & XFS_TRANS_ABORT) && !XFS_FORCED_SHUTDOWN(mp)) {
		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));
L
Linus Torvalds 已提交
962 963 964
	}
#endif
	xfs_trans_unreserve_and_mod_sb(tp);
C
Christoph Hellwig 已提交
965
	xfs_trans_unreserve_and_mod_dquots(tp);
L
Linus Torvalds 已提交
966 967 968 969 970 971 972 973

	if (tp->t_ticket) {
		if (flags & XFS_TRANS_RELEASE_LOG_RES) {
			ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
			log_flags = XFS_LOG_REL_PERM_RESERV;
		} else {
			log_flags = 0;
		}
974
		xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
L
Linus Torvalds 已提交
975 976 977
	}

	/* mark this thread as no longer being in a transaction */
978
	current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
L
Linus Torvalds 已提交
979

980
	xfs_trans_free_items(tp, NULLCOMMITLSN, flags);
L
Linus Torvalds 已提交
981 982 983
	xfs_trans_free(tp);
}

984 985 986 987 988 989 990 991 992 993 994 995 996
/*
 * Roll from one trans in the sequence of PERMANENT transactions to
 * the next: permanent transactions are only flushed out when
 * committed with XFS_TRANS_RELEASE_LOG_RES, but we still want as soon
 * 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
xfs_trans_roll(
	struct xfs_trans	**tpp,
	struct xfs_inode	*dp)
{
	struct xfs_trans	*trans;
997
	struct xfs_trans_res	tres;
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
	int			error;

	/*
	 * Ensure that the inode is always logged.
	 */
	trans = *tpp;
	xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE);

	/*
	 * Copy the critical parameters from one trans to the next.
	 */
1009 1010
	tres.tr_logres = trans->t_log_res;
	tres.tr_logcount = trans->t_log_count;
1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
	*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.
	 */
	error = xfs_trans_commit(trans, 0);
	if (error)
E
Eric Sandeen 已提交
1022
		return error;
1023 1024 1025

	trans = *tpp;

1026 1027 1028 1029 1030 1031 1032
	/*
	 * transaction commit worked ok so we can drop the extra ticket
	 * reference that we gained in xfs_trans_dup()
	 */
	xfs_log_ticket_put(trans->t_ticket);


1033 1034 1035 1036 1037 1038 1039 1040
	/*
	 * Reserve space in the log for th next transaction.
	 * 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.
	 */
1041 1042
	tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
	error = xfs_trans_reserve(trans, &tres, 0, 0);
1043 1044 1045 1046 1047 1048
	/*
	 *  Ensure that the inode is in the new transaction and locked.
	 */
	if (error)
		return error;

1049
	xfs_trans_ijoin(trans, dp, 0);
1050 1051
	return 0;
}