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 27 28
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
29
#include "xfs_extent_busy.h"
Linus Torvalds's avatar
Linus Torvalds committed
30
#include "xfs_quota.h"
31
#include "xfs_trans.h"
32
#include "xfs_trans_priv.h"
33
#include "xfs_log.h"
34
#include "xfs_trace.h"
35
#include "xfs_error.h"
Linus Torvalds's avatar
Linus Torvalds committed
36

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

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

/*
 * 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.
55 56 57
 *
 * Dynamically allocate the transaction structure from the transaction
 * zone, initialize it, and return it to the caller.
Linus Torvalds's avatar
Linus Torvalds committed
58
 */
59 60 61 62 63
xfs_trans_t *
xfs_trans_alloc(
	xfs_mount_t	*mp,
	uint		type)
{
Jan Kara's avatar
Jan Kara committed
64 65 66 67 68 69
	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;
70 71 72
}

xfs_trans_t *
Linus Torvalds's avatar
Linus Torvalds committed
73
_xfs_trans_alloc(
74 75
	xfs_mount_t	*mp,
	uint		type,
76
	xfs_km_flags_t	memflags)
Linus Torvalds's avatar
Linus Torvalds committed
77
{
78
	xfs_trans_t	*tp;
Linus Torvalds's avatar
Linus Torvalds committed
79

Jan Kara's avatar
Jan Kara committed
80
	WARN_ON(mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
81
	atomic_inc(&mp->m_active_trans);
Linus Torvalds's avatar
Linus Torvalds committed
82

83
	tp = kmem_zone_zalloc(xfs_trans_zone, memflags);
84
	tp->t_magic = XFS_TRANS_HEADER_MAGIC;
Linus Torvalds's avatar
Linus Torvalds committed
85 86
	tp->t_type = type;
	tp->t_mountp = mp;
87
	INIT_LIST_HEAD(&tp->t_items);
88
	INIT_LIST_HEAD(&tp->t_busy);
89
	return tp;
Linus Torvalds's avatar
Linus Torvalds committed
90 91
}

92 93 94 95 96 97
/*
 * 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(
98
	struct xfs_trans	*tp)
99
{
100 101
	xfs_extent_busy_sort(&tp->t_busy);
	xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
102

103
	atomic_dec(&tp->t_mountp->m_active_trans);
Jan Kara's avatar
Jan Kara committed
104 105
	if (tp->t_flags & XFS_TRANS_FREEZE_PROT)
		sb_end_intwrite(tp->t_mountp->m_super);
106 107 108 109
	xfs_trans_free_dqinfo(tp);
	kmem_zone_free(xfs_trans_zone, tp);
}

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

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

Jan Kara's avatar
Jan Kara committed
138 139 140 141 142
	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;
143
	ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
Linus Torvalds's avatar
Linus Torvalds committed
144 145 146 147
	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;
148
	ntp->t_pflags = tp->t_pflags;
Linus Torvalds's avatar
Linus Torvalds committed
149

Christoph Hellwig's avatar
Christoph Hellwig committed
150
	xfs_trans_dup_dqinfo(tp, ntp);
Linus Torvalds's avatar
Linus Torvalds committed
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171

	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(
172 173 174 175
	struct xfs_trans	*tp,
	struct xfs_trans_res	*resp,
	uint			blocks,
	uint			rtextents)
Linus Torvalds's avatar
Linus Torvalds committed
176
{
177 178
	int		error = 0;
	int		rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
Linus Torvalds's avatar
Linus Torvalds committed
179 180

	/* Mark this thread as being in a transaction */
181
	current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
Linus Torvalds's avatar
Linus Torvalds committed
182 183 184 185 186 187 188

	/*
	 * 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) {
189
		error = xfs_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS,
190
					  -((int64_t)blocks), rsvd);
Linus Torvalds's avatar
Linus Torvalds committed
191
		if (error != 0) {
192
			current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
Linus Torvalds's avatar
Linus Torvalds committed
193 194 195 196 197 198 199 200
			return (XFS_ERROR(ENOSPC));
		}
		tp->t_blk_res += blocks;
	}

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

204 205 206 207
		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);
208

209
		if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
Linus Torvalds's avatar
Linus Torvalds committed
210
			tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
211
			permanent = true;
Linus Torvalds's avatar
Linus Torvalds committed
212 213 214 215 216
		} else {
			ASSERT(tp->t_ticket == NULL);
			ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
		}

217
		if (tp->t_ticket != NULL) {
218
			ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
219 220
			error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
		} else {
221 222 223 224 225
			error = xfs_log_reserve(tp->t_mountp,
						resp->tr_logres,
						resp->tr_logcount,
						&tp->t_ticket, XFS_TRANSACTION,
						permanent, tp->t_type);
Linus Torvalds's avatar
Linus Torvalds committed
226
		}
227 228 229 230

		if (error)
			goto undo_blocks;

231 232
		tp->t_log_res = resp->tr_logres;
		tp->t_log_count = resp->tr_logcount;
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236 237 238 239 240 241
	}

	/*
	 * 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) {
		error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS,
242
					  -((int64_t)rtextents), rsvd);
Linus Torvalds's avatar
Linus Torvalds committed
243 244 245 246 247 248 249 250 251 252 253 254 255 256
		if (error) {
			error = XFS_ERROR(ENOSPC);
			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:
257
	if (resp->tr_logres > 0) {
258 259
		int		log_flags;

260
		if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
Linus Torvalds's avatar
Linus Torvalds committed
261 262 263 264 265 266 267 268 269 270 271 272
			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) {
273
		xfs_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS,
274
					 (int64_t)blocks, rsvd);
Linus Torvalds's avatar
Linus Torvalds committed
275 276 277
		tp->t_blk_res = 0;
	}

278
	current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
Linus Torvalds's avatar
Linus Torvalds committed
279

280
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
281 282 283 284 285 286 287 288 289
}

/*
 * 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.
David Chinner's avatar
David Chinner committed
290 291 292 293 294 295 296 297
 *
 * 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
298 299 300 301 302
 */
void
xfs_trans_mod_sb(
	xfs_trans_t	*tp,
	uint		field,
303
	int64_t		delta)
Linus Torvalds's avatar
Linus Torvalds committed
304
{
David Chinner's avatar
David Chinner committed
305 306
	uint32_t	flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
	xfs_mount_t	*mp = tp->t_mountp;
Linus Torvalds's avatar
Linus Torvalds committed
307 308 309 310

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

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

/*
 * 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)
{
411
	xfs_dsb_t	*sbp;
Linus Torvalds's avatar
Linus Torvalds committed
412 413 414 415 416 417 418 419 420 421 422 423 424
	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));

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

439
	if (tp->t_frextents_delta)
440
		be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
441
	if (tp->t_res_frextents_delta)
442
		be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
443 444

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

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

/*
493 494 495 496 497
 * 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
498 499
 *
 * This is done efficiently with a single call to xfs_mod_incore_sb_batch().
500 501 502 503 504 505 506 507 508 509
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
510
 */
511
void
Linus Torvalds's avatar
Linus Torvalds committed
512 513 514
xfs_trans_unreserve_and_mod_sb(
	xfs_trans_t	*tp)
{
515
	xfs_mod_sb_t	msb[9];	/* If you add cases, add entries */
Linus Torvalds's avatar
Linus Torvalds committed
516
	xfs_mod_sb_t	*msbp;
David Chinner's avatar
David Chinner committed
517
	xfs_mount_t	*mp = tp->t_mountp;
Linus Torvalds's avatar
Linus Torvalds committed
518 519 520
	/* REFERENCED */
	int		error;
	int		rsvd;
521 522
	int64_t		blkdelta = 0;
	int64_t		rtxdelta = 0;
523 524
	int64_t		idelta = 0;
	int64_t		ifreedelta = 0;
Linus Torvalds's avatar
Linus Torvalds committed
525 526 527 528

	msbp = msb;
	rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;

529
	/* calculate deltas */
530 531 532 533 534 535 536 537 538 539 540 541 542
	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;

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
	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) {
		error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
						 blkdelta, rsvd);
		if (error)
			goto out;
	}

	if (idelta) {
		error = xfs_icsb_modify_counters(mp, XFS_SBS_ICOUNT,
						 idelta, rsvd);
		if (error)
			goto out_undo_fdblocks;
	}

	if (ifreedelta) {
		error = xfs_icsb_modify_counters(mp, XFS_SBS_IFREE,
						 ifreedelta, rsvd);
		if (error)
			goto out_undo_icount;
	}

	/* apply remaining deltas */
572
	if (rtxdelta != 0) {
Linus Torvalds's avatar
Linus Torvalds committed
573
		msbp->msb_field = XFS_SBS_FREXTENTS;
574
		msbp->msb_delta = rtxdelta;
Linus Torvalds's avatar
Linus Torvalds committed
575 576 577
		msbp++;
	}

David Chinner's avatar
David Chinner committed
578
	if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
Linus Torvalds's avatar
Linus Torvalds committed
579 580
		if (tp->t_dblocks_delta != 0) {
			msbp->msb_field = XFS_SBS_DBLOCKS;
581
			msbp->msb_delta = tp->t_dblocks_delta;
Linus Torvalds's avatar
Linus Torvalds committed
582 583 584 585
			msbp++;
		}
		if (tp->t_agcount_delta != 0) {
			msbp->msb_field = XFS_SBS_AGCOUNT;
586
			msbp->msb_delta = tp->t_agcount_delta;
Linus Torvalds's avatar
Linus Torvalds committed
587 588 589 590
			msbp++;
		}
		if (tp->t_imaxpct_delta != 0) {
			msbp->msb_field = XFS_SBS_IMAX_PCT;
591
			msbp->msb_delta = tp->t_imaxpct_delta;
Linus Torvalds's avatar
Linus Torvalds committed
592 593 594 595
			msbp++;
		}
		if (tp->t_rextsize_delta != 0) {
			msbp->msb_field = XFS_SBS_REXTSIZE;
596
			msbp->msb_delta = tp->t_rextsize_delta;
Linus Torvalds's avatar
Linus Torvalds committed
597 598 599 600
			msbp++;
		}
		if (tp->t_rbmblocks_delta != 0) {
			msbp->msb_field = XFS_SBS_RBMBLOCKS;
601
			msbp->msb_delta = tp->t_rbmblocks_delta;
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604 605
			msbp++;
		}
		if (tp->t_rblocks_delta != 0) {
			msbp->msb_field = XFS_SBS_RBLOCKS;
606
			msbp->msb_delta = tp->t_rblocks_delta;
Linus Torvalds's avatar
Linus Torvalds committed
607 608 609 610
			msbp++;
		}
		if (tp->t_rextents_delta != 0) {
			msbp->msb_field = XFS_SBS_REXTENTS;
611
			msbp->msb_delta = tp->t_rextents_delta;
Linus Torvalds's avatar
Linus Torvalds committed
612 613 614 615
			msbp++;
		}
		if (tp->t_rextslog_delta != 0) {
			msbp->msb_field = XFS_SBS_REXTSLOG;
616
			msbp->msb_delta = tp->t_rextslog_delta;
Linus Torvalds's avatar
Linus Torvalds committed
617 618 619 620 621 622 623 624 625 626
			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);
627 628
		if (error)
			goto out_undo_ifreecount;
Linus Torvalds's avatar
Linus Torvalds committed
629
	}
630 631 632 633 634 635 636 637 638 639 640 641 642

	return;

out_undo_ifreecount:
	if (ifreedelta)
		xfs_icsb_modify_counters(mp, XFS_SBS_IFREE, -ifreedelta, rsvd);
out_undo_icount:
	if (idelta)
		xfs_icsb_modify_counters(mp, XFS_SBS_ICOUNT, -idelta, rsvd);
out_undo_fdblocks:
	if (blkdelta)
		xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS, -blkdelta, rsvd);
out:
643
	ASSERT(error == 0);
644
	return;
Linus Torvalds's avatar
Linus Torvalds committed
645 646
}

647 648 649 650 651 652 653 654 655 656 657 658
/*
 * 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;

659 660
	ASSERT(lip->li_mountp == tp->t_mountp);
	ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
661

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

	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.
 */
694
void
695 696 697 698 699 700 701 702 703 704 705 706 707
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)
708
			lip->li_ops->iop_committing(lip, commit_lsn);
709 710
		if (flags & XFS_TRANS_ABORT)
			lip->li_flags |= XFS_LI_ABORTED;
711
		lip->li_ops->iop_unlock(lip);
712 713 714 715 716

		xfs_trans_free_item_desc(lidp);
	}
}

717 718 719
static inline void
xfs_log_item_batch_insert(
	struct xfs_ail		*ailp,
720
	struct xfs_ail_cursor	*cur,
721 722 723 724 725 726 727 728
	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 */
729
	xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
730

731 732 733 734 735
	for (i = 0; i < nr_items; i++) {
		struct xfs_log_item *lip = log_items[i];

		lip->li_ops->iop_unpin(lip, 0);
	}
736 737 738 739 740 741
}

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

771 772 773 774
	spin_lock(&ailp->xa_lock);
	xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
	spin_unlock(&ailp->xa_lock);

775 776 777 778 779 780 781
	/* 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;
782
		item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
783

784
		/* item_lsn of -1 means the item needs no further processing */
785 786 787
		if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
			continue;

788 789 790 791 792 793
		/*
		 * 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));
794
			lip->li_ops->iop_unpin(lip, 1);
795 796 797
			continue;
		}

798 799 800 801 802
		if (item_lsn != commit_lsn) {

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

		/* Item is a candidate for bulk AIL insert.  */
		log_items[i++] = lv->lv_item;
		if (i >= LOG_ITEM_BATCH_SIZE) {
819
			xfs_log_item_batch_insert(ailp, &cur, log_items,
820 821 822 823 824 825 826
					LOG_ITEM_BATCH_SIZE, commit_lsn);
			i = 0;
		}
	}

	/* make sure we insert the remainder! */
	if (i)
827 828 829 830 831
		xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);

	spin_lock(&ailp->xa_lock);
	xfs_trans_ail_cursor_done(ailp, &cur);
	spin_unlock(&ailp->xa_lock);
832 833
}

834
/*
835
 * Commit the given transaction to the log.
836 837 838 839 840 841 842 843 844 845 846
 *
 * 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
847
xfs_trans_commit(
848
	struct xfs_trans	*tp,
849
	uint			flags)
850
{
851
	struct xfs_mount	*mp = tp->t_mountp;
852
	xfs_lsn_t		commit_lsn = -1;
853
	int			error = 0;
854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872
	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.
	 */
873 874 875 876 877 878
	if (!(tp->t_flags & XFS_TRANS_DIRTY))
		goto out_unreserve;

	if (XFS_FORCED_SHUTDOWN(mp)) {
		error = XFS_ERROR(EIO);
		goto out_unreserve;
879
	}
880

881 882 883 884 885 886 887 888 889
	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);

890
	xfs_log_commit_cil(mp, tp, &commit_lsn, flags);
Linus Torvalds's avatar
Linus Torvalds committed
891

892 893 894
	current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
	xfs_trans_free(tp);

Linus Torvalds's avatar
Linus Torvalds committed
895 896 897 898 899
	/*
	 * If the transaction needs to be synchronous, then force the
	 * log out now and wait for it.
	 */
	if (sync) {
900
		error = _xfs_log_force_lsn(mp, commit_lsn, XFS_LOG_SYNC, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
901 902 903 904 905
		XFS_STATS_INC(xs_trans_sync);
	} else {
		XFS_STATS_INC(xs_trans_async);
	}

906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
	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)
			error = XFS_ERROR(EIO);
	}
	current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
923
	xfs_trans_free_items(tp, NULLCOMMITLSN, error ? XFS_TRANS_ABORT : 0);
924 925 926 927
	xfs_trans_free(tp);

	XFS_STATS_INC(xs_trans_empty);
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
}

/*
 * 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;
944
	xfs_mount_t		*mp = tp->t_mountp;
Linus Torvalds's avatar
Linus Torvalds committed
945 946 947 948 949 950 951 952 953 954 955 956

	/*
	 * 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.
	 */
957
	if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) {
958
		XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
959
		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
960
	}
Linus Torvalds's avatar
Linus Torvalds committed
961
#ifdef DEBUG
962 963 964 965 966
	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));
Linus Torvalds's avatar
Linus Torvalds committed
967 968 969
	}
#endif
	xfs_trans_unreserve_and_mod_sb(tp);
Christoph Hellwig's avatar
Christoph Hellwig committed
970
	xfs_trans_unreserve_and_mod_dquots(tp);
Linus Torvalds's avatar
Linus Torvalds committed
971 972 973 974 975 976 977 978

	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;
		}
979
		xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
Linus Torvalds's avatar
Linus Torvalds committed
980 981 982
	}

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

985
	xfs_trans_free_items(tp, NULLCOMMITLSN, flags);
Linus Torvalds's avatar
Linus Torvalds committed
986 987 988
	xfs_trans_free(tp);
}

989 990 991 992 993 994 995 996 997 998 999 1000 1001
/*
 * 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;
1002
	struct xfs_trans_res	tres;
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
	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.
	 */
1014 1015
	tres.tr_logres = trans->t_log_res;
	tres.tr_logcount = trans->t_log_count;
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
	*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)
		return (error);

	trans = *tpp;

1031 1032 1033 1034 1035 1036 1037
	/*
	 * 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);


1038 1039 1040 1041 1042 1043 1044 1045
	/*
	 * 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.
	 */
1046 1047
	tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
	error = xfs_trans_reserve(trans, &tres, 0, 0);
1048 1049 1050 1051 1052 1053
	/*
	 *  Ensure that the inode is in the new transaction and locked.
	 */
	if (error)
		return error;

1054
	xfs_trans_ijoin(trans, dp, 0);
1055 1056
	return 0;
}