xfs_trans.c 28 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
}

/*
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
56
 */
57 58 59 60 61
xfs_trans_t *
xfs_trans_alloc(
	xfs_mount_t	*mp,
	uint		type)
{
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 *
Linus Torvalds's avatar
Linus Torvalds committed
71
_xfs_trans_alloc(
72 73
	xfs_mount_t	*mp,
	uint		type,
74
	xfs_km_flags_t	memflags)
Linus Torvalds's avatar
Linus Torvalds committed
75
{
76
	xfs_trans_t	*tp;
Linus Torvalds's avatar
Linus Torvalds committed
77

78
	WARN_ON(mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
79
	atomic_inc(&mp->m_active_trans);
Linus Torvalds's avatar
Linus Torvalds committed
80

81
	tp = kmem_zone_zalloc(xfs_trans_zone, memflags);
82
	tp->t_magic = XFS_TRANS_HEADER_MAGIC;
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
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
{
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);
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);
}

Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
132 133 134

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

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);
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
147

Christoph Hellwig's avatar
Christoph Hellwig committed
148
	xfs_trans_dup_dqinfo(tp, ntp);
Linus Torvalds's avatar
Linus Torvalds committed
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)
Linus Torvalds's avatar
Linus Torvalds committed
174
{
175 176
	int		error = 0;
	int		rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
Linus Torvalds's avatar
Linus Torvalds committed
177 178

	/* Mark this thread as being in a transaction */
179
	current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
Linus Torvalds's avatar
Linus Torvalds committed
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_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS,
188
					  -((int64_t)blocks), rsvd);
Linus Torvalds's avatar
Linus Torvalds committed
189
		if (error != 0) {
190
			current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
191
			return -ENOSPC;
Linus Torvalds's avatar
Linus Torvalds committed
192 193 194 195 196 197 198
		}
		tp->t_blk_res += blocks;
	}

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

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

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

215
		if (tp->t_ticket != NULL) {
216
			ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
217 218
			error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
		} else {
219 220 221 222 223
			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
224
		}
225 226 227 228

		if (error)
			goto undo_blocks;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
	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 */
571
	if (rtxdelta != 0) {
Linus Torvalds's avatar
Linus Torvalds committed
572
		msbp->msb_field = XFS_SBS_FREXTENTS;
573
		msbp->msb_delta = rtxdelta;
Linus Torvalds's avatar
Linus Torvalds committed
574 575 576
		msbp++;
	}

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

	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:
642
	ASSERT(error == 0);
643
	return;
Linus Torvalds's avatar
Linus Torvalds committed
644 645
}

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

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

661
	lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS);
662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692

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

		xfs_trans_free_item_desc(lidp);
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

	spin_lock(&ailp->xa_lock);
829
	xfs_trans_ail_cursor_done(&cur);
830
	spin_unlock(&ailp->xa_lock);
831 832
}

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

	if (XFS_FORCED_SHUTDOWN(mp)) {
876
		error = -EIO;
877
		goto out_unreserve;
878
	}
879

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

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

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

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

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

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

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

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

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

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

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

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

	trans = *tpp;

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


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

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