checkpoint.c 20 KB
Newer Older
1
/*
2
 * linux/fs/jbd2/checkpoint.c
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
 *
 * Copyright 1999 Red Hat Software --- All Rights Reserved
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
 * option, any later version, incorporated herein by reference.
 *
 * Checkpoint routines for the generic filesystem journaling code.
 * Part of the ext2fs journaling system.
 *
 * Checkpointing is the process of ensuring that a section of the log is
 * committed fully to disk, so that that portion of the log can be
 * reused.
 */

#include <linux/time.h>
#include <linux/fs.h>
22
#include <linux/jbd2.h>
23 24
#include <linux/errno.h>
#include <linux/slab.h>
25
#include <linux/blkdev.h>
26
#include <trace/events/jbd2.h>
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96

/*
 * Unlink a buffer from a transaction checkpoint list.
 *
 * Called with j_list_lock held.
 */
static inline void __buffer_unlink_first(struct journal_head *jh)
{
	transaction_t *transaction = jh->b_cp_transaction;

	jh->b_cpnext->b_cpprev = jh->b_cpprev;
	jh->b_cpprev->b_cpnext = jh->b_cpnext;
	if (transaction->t_checkpoint_list == jh) {
		transaction->t_checkpoint_list = jh->b_cpnext;
		if (transaction->t_checkpoint_list == jh)
			transaction->t_checkpoint_list = NULL;
	}
}

/*
 * Unlink a buffer from a transaction checkpoint(io) list.
 *
 * Called with j_list_lock held.
 */
static inline void __buffer_unlink(struct journal_head *jh)
{
	transaction_t *transaction = jh->b_cp_transaction;

	__buffer_unlink_first(jh);
	if (transaction->t_checkpoint_io_list == jh) {
		transaction->t_checkpoint_io_list = jh->b_cpnext;
		if (transaction->t_checkpoint_io_list == jh)
			transaction->t_checkpoint_io_list = NULL;
	}
}

/*
 * Move a buffer from the checkpoint list to the checkpoint io list
 *
 * Called with j_list_lock held
 */
static inline void __buffer_relink_io(struct journal_head *jh)
{
	transaction_t *transaction = jh->b_cp_transaction;

	__buffer_unlink_first(jh);

	if (!transaction->t_checkpoint_io_list) {
		jh->b_cpnext = jh->b_cpprev = jh;
	} else {
		jh->b_cpnext = transaction->t_checkpoint_io_list;
		jh->b_cpprev = transaction->t_checkpoint_io_list->b_cpprev;
		jh->b_cpprev->b_cpnext = jh;
		jh->b_cpnext->b_cpprev = jh;
	}
	transaction->t_checkpoint_io_list = jh;
}

/*
 * Try to release a checkpointed buffer from its transaction.
 * Returns 1 if we released it and 2 if we also released the
 * whole transaction.
 *
 * Requires j_list_lock
 */
static int __try_to_free_cp_buf(struct journal_head *jh)
{
	int ret = 0;
	struct buffer_head *bh = jh2bh(jh);

97
	if (jh->b_transaction == NULL && !buffer_locked(bh) &&
98
	    !buffer_dirty(bh) && !buffer_write_io_error(bh)) {
99 100 101 102 103
		/*
		 * Get our reference so that bh cannot be freed before
		 * we unlock it
		 */
		get_bh(bh);
104
		JBUFFER_TRACE(jh, "remove from checkpoint list");
105
		ret = __jbd2_journal_remove_checkpoint(jh) + 1;
106 107 108 109 110 111 112
		BUFFER_TRACE(bh, "release");
		__brelse(bh);
	}
	return ret;
}

/*
113
 * __jbd2_log_wait_for_space: wait until there is space in the journal.
114 115 116 117
 *
 * Called under j-state_lock *only*.  It will be unlocked if we have to wait
 * for a checkpoint to free up some space in the log.
 */
118
void __jbd2_log_wait_for_space(journal_t *journal)
119
{
120
	int nblocks, space_left;
121
	/* assert_spin_locked(&journal->j_state_lock); */
122

123 124
	nblocks = jbd2_space_needed(journal);
	while (jbd2_log_space_left(journal) < nblocks) {
125
		if (journal->j_flags & JBD2_ABORT)
126
			return;
127
		write_unlock(&journal->j_state_lock);
128 129 130 131
		mutex_lock(&journal->j_checkpoint_mutex);

		/*
		 * Test again, another process may have checkpointed while we
132
		 * were waiting for the checkpoint lock. If there are no
133 134 135 136 137 138 139
		 * transactions ready to be checkpointed, try to recover
		 * journal space by calling cleanup_journal_tail(), and if
		 * that doesn't work, by waiting for the currently committing
		 * transaction to complete.  If there is absolutely no way
		 * to make progress, this is either a BUG or corrupted
		 * filesystem, so abort the journal and leave a stack
		 * trace for forensic evidence.
140
		 */
141
		write_lock(&journal->j_state_lock);
142
		spin_lock(&journal->j_list_lock);
143 144
		nblocks = jbd2_space_needed(journal);
		space_left = jbd2_log_space_left(journal);
145
		if (space_left < nblocks) {
146
			int chkpt = journal->j_checkpoint_transactions != NULL;
147
			tid_t tid = 0;
148

149 150
			if (journal->j_committing_transaction)
				tid = journal->j_committing_transaction->t_tid;
151
			spin_unlock(&journal->j_list_lock);
152
			write_unlock(&journal->j_state_lock);
153 154
			if (chkpt) {
				jbd2_log_do_checkpoint(journal);
155 156 157 158
			} else if (jbd2_cleanup_journal_tail(journal) == 0) {
				/* We were able to recover space; yay! */
				;
			} else if (tid) {
159 160 161 162 163 164
				/*
				 * jbd2_journal_commit_transaction() may want
				 * to take the checkpoint_mutex if JBD2_FLUSHED
				 * is set.  So we need to temporarily drop it.
				 */
				mutex_unlock(&journal->j_checkpoint_mutex);
165
				jbd2_log_wait_commit(journal, tid);
166 167
				write_lock(&journal->j_state_lock);
				continue;
168
			} else {
169 170 171 172 173 174 175
				printk(KERN_ERR "%s: needed %d blocks and "
				       "only had %d space available\n",
				       __func__, nblocks, space_left);
				printk(KERN_ERR "%s: no way to get more "
				       "journal space in %s\n", __func__,
				       journal->j_devname);
				WARN_ON(1);
176 177
				jbd2_journal_abort(journal, 0);
			}
178
			write_lock(&journal->j_state_lock);
179 180
		} else {
			spin_unlock(&journal->j_list_lock);
181 182 183 184 185 186 187 188 189 190 191
		}
		mutex_unlock(&journal->j_checkpoint_mutex);
	}
}

/*
 * Clean up transaction's list of buffers submitted for io.
 * We wait for any pending IO to complete and remove any clean
 * buffers. Note that we take the buffers in the opposite ordering
 * from the one in which they were submitted for IO.
 *
192 193 194
 * Return 0 on success, and return <0 if some buffers have failed
 * to be written out.
 *
195 196
 * Called with j_list_lock held.
 */
197
static int __wait_cp_io(journal_t *journal, transaction_t *transaction)
198 199 200 201 202
{
	struct journal_head *jh;
	struct buffer_head *bh;
	tid_t this_tid;
	int released = 0;
203
	int ret = 0;
204 205 206 207 208 209

	this_tid = transaction->t_tid;
restart:
	/* Did somebody clean up the transaction in the meanwhile? */
	if (journal->j_checkpoint_transactions != transaction ||
			transaction->t_tid != this_tid)
210
		return ret;
211 212 213
	while (!released && transaction->t_checkpoint_io_list) {
		jh = transaction->t_checkpoint_io_list;
		bh = jh2bh(jh);
214
		get_bh(bh);
215 216 217 218 219 220 221 222 223
		if (buffer_locked(bh)) {
			spin_unlock(&journal->j_list_lock);
			wait_on_buffer(bh);
			/* the journal_head may have gone by now */
			BUFFER_TRACE(bh, "brelse");
			__brelse(bh);
			spin_lock(&journal->j_list_lock);
			goto restart;
		}
224 225 226
		if (unlikely(buffer_write_io_error(bh)))
			ret = -EIO;

227 228 229 230
		/*
		 * Now in whatever state the buffer currently is, we know that
		 * it has been written out and so we can drop it from the list
		 */
231
		released = __jbd2_journal_remove_checkpoint(jh);
232 233
		__brelse(bh);
	}
234 235

	return ret;
236 237 238
}

static void
239
__flush_batch(journal_t *journal, int *batch_count)
240 241
{
	int i;
242
	struct blk_plug plug;
243

244
	blk_start_plug(&plug);
245
	for (i = 0; i < *batch_count; i++)
246 247
		write_dirty_buffer(journal->j_chkpt_bhs[i], WRITE_SYNC);
	blk_finish_plug(&plug);
248

249
	for (i = 0; i < *batch_count; i++) {
250
		struct buffer_head *bh = journal->j_chkpt_bhs[i];
251 252 253 254 255 256 257 258 259 260
		BUFFER_TRACE(bh, "brelse");
		__brelse(bh);
	}
	*batch_count = 0;
}

/*
 * Try to flush one buffer from the checkpoint list to disk.
 *
 * Return 1 if something happened which requires us to abort the current
261 262
 * scan of the checkpoint list.  Return <0 if the buffer has failed to
 * be written out.
263 264 265 266
 *
 * Called with j_list_lock held and drops it if 1 is returned
 */
static int __process_buffer(journal_t *journal, struct journal_head *jh,
267
			    int *batch_count, transaction_t *transaction)
268 269 270 271 272
{
	struct buffer_head *bh = jh2bh(jh);
	int ret = 0;

	if (buffer_locked(bh)) {
273
		get_bh(bh);
274 275 276 277 278 279 280 281 282 283
		spin_unlock(&journal->j_list_lock);
		wait_on_buffer(bh);
		/* the journal_head may have gone by now */
		BUFFER_TRACE(bh, "brelse");
		__brelse(bh);
		ret = 1;
	} else if (jh->b_transaction != NULL) {
		transaction_t *t = jh->b_transaction;
		tid_t tid = t->t_tid;

284
		transaction->t_chp_stats.cs_forced_to_close++;
285
		spin_unlock(&journal->j_list_lock);
286 287 288 289 290 291 292 293 294 295
		if (unlikely(journal->j_flags & JBD2_UNMOUNT))
			/*
			 * The journal thread is dead; so starting and
			 * waiting for a commit to finish will cause
			 * us to wait for a _very_ long time.
			 */
			printk(KERN_ERR "JBD2: %s: "
			       "Waiting for Godot: block %llu\n",
			       journal->j_devname,
			       (unsigned long long) bh->b_blocknr);
296 297
		jbd2_log_start_commit(journal, tid);
		jbd2_log_wait_commit(journal, tid);
298 299
		ret = 1;
	} else if (!buffer_dirty(bh)) {
300 301 302
		ret = 1;
		if (unlikely(buffer_write_io_error(bh)))
			ret = -EIO;
303
		get_bh(bh);
304
		BUFFER_TRACE(bh, "remove from checkpoint");
305
		__jbd2_journal_remove_checkpoint(jh);
306 307 308 309 310 311 312 313 314 315 316 317 318
		spin_unlock(&journal->j_list_lock);
		__brelse(bh);
	} else {
		/*
		 * Important: we are about to write the buffer, and
		 * possibly block, while still holding the journal lock.
		 * We cannot afford to let the transaction logic start
		 * messing around with this buffer before we write it to
		 * disk, as that would break recoverability.
		 */
		BUFFER_TRACE(bh, "queue");
		get_bh(bh);
		J_ASSERT_BH(bh, !buffer_jwrite(bh));
319
		journal->j_chkpt_bhs[*batch_count] = bh;
320
		__buffer_relink_io(jh);
321
		transaction->t_chp_stats.cs_written++;
322
		(*batch_count)++;
323
		if (*batch_count == JBD2_NR_BATCH) {
324
			spin_unlock(&journal->j_list_lock);
325
			__flush_batch(journal, batch_count);
326 327 328 329 330 331 332 333 334 335 336 337
			ret = 1;
		}
	}
	return ret;
}

/*
 * Perform an actual checkpoint. We take the first transaction on the
 * list of transactions to be checkpointed and send all its buffers
 * to disk. We submit larger chunks of data at once.
 *
 * The journal should be locked before calling this function.
338
 * Called with j_checkpoint_mutex held.
339
 */
340
int jbd2_log_do_checkpoint(journal_t *journal)
341 342 343 344 345 346 347 348 349 350 351 352
{
	transaction_t *transaction;
	tid_t this_tid;
	int result;

	jbd_debug(1, "Start checkpoint\n");

	/*
	 * First thing: if there are any transactions in the log which
	 * don't need checkpointing, just eliminate them from the
	 * journal straight away.
	 */
353
	result = jbd2_cleanup_journal_tail(journal);
354
	trace_jbd2_checkpoint(journal, result);
355 356 357 358 359 360 361 362
	jbd_debug(1, "cleanup_journal_tail returned %d\n", result);
	if (result <= 0)
		return result;

	/*
	 * OK, we need to start writing disk blocks.  Take one transaction
	 * and write it.
	 */
363
	result = 0;
364 365 366 367
	spin_lock(&journal->j_list_lock);
	if (!journal->j_checkpoint_transactions)
		goto out;
	transaction = journal->j_checkpoint_transactions;
368 369
	if (transaction->t_chp_stats.cs_chp_time == 0)
		transaction->t_chp_stats.cs_chp_time = jiffies;
370 371 372 373 374 375 376 377 378 379 380
	this_tid = transaction->t_tid;
restart:
	/*
	 * If someone cleaned up this transaction while we slept, we're
	 * done (maybe it's a new transaction, but it fell at the same
	 * address).
	 */
	if (journal->j_checkpoint_transactions == transaction &&
			transaction->t_tid == this_tid) {
		int batch_count = 0;
		struct journal_head *jh;
381
		int retry = 0, err;
382 383 384

		while (!retry && transaction->t_checkpoint_list) {
			jh = transaction->t_checkpoint_list;
385
			retry = __process_buffer(journal, jh, &batch_count,
386
						 transaction);
387 388
			if (retry < 0 && !result)
				result = retry;
389 390
			if (!retry && (need_resched() ||
				spin_needbreak(&journal->j_list_lock))) {
391 392 393 394 395 396 397 398 399 400 401
				spin_unlock(&journal->j_list_lock);
				retry = 1;
				break;
			}
		}

		if (batch_count) {
			if (!retry) {
				spin_unlock(&journal->j_list_lock);
				retry = 1;
			}
402
			__flush_batch(journal, &batch_count);
403 404 405 406 407 408 409 410 411 412
		}

		if (retry) {
			spin_lock(&journal->j_list_lock);
			goto restart;
		}
		/*
		 * Now we have cleaned up the first transaction's checkpoint
		 * list. Let's clean up the second one
		 */
413 414 415
		err = __wait_cp_io(journal, transaction);
		if (!result)
			result = err;
416 417 418 419
	}
out:
	spin_unlock(&journal->j_list_lock);
	if (result < 0)
420 421 422 423 424
		jbd2_journal_abort(journal, result);
	else
		result = jbd2_cleanup_journal_tail(journal);

	return (result < 0) ? result : 0;
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
}

/*
 * Check the list of checkpoint transactions for the journal to see if
 * we have already got rid of any since the last update of the log tail
 * in the journal superblock.  If so, we can instantly roll the
 * superblock forward to remove those transactions from the log.
 *
 * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
 *
 * Called with the journal lock held.
 *
 * This is the only part of the journaling code which really needs to be
 * aware of transaction aborts.  Checkpointing involves writing to the
 * main filesystem area rather than to the journal, so it can proceed
440 441 442
 * even in abort state, but we must not update the super block if
 * checkpointing may have failed.  Otherwise, we would lose some metadata
 * buffers which should be written-back to the filesystem.
443 444
 */

445
int jbd2_cleanup_journal_tail(journal_t *journal)
446 447
{
	tid_t		first_tid;
448
	unsigned long	blocknr;
449

450 451 452
	if (is_journal_aborted(journal))
		return 1;

453
	if (!jbd2_journal_get_log_tail(journal, &first_tid, &blocknr))
454
		return 1;
455
	J_ASSERT(blocknr != 0);
456 457

	/*
458 459 460 461 462 463
	 * We need to make sure that any blocks that were recently written out
	 * --- perhaps by jbd2_log_do_checkpoint() --- are flushed out before
	 * we drop the transactions from the journal. It's unlikely this will
	 * be necessary, especially with an appropriately sized journal, but we
	 * need this to guarantee correctness.  Fortunately
	 * jbd2_cleanup_journal_tail() doesn't get called all that often.
464
	 */
465
	if (journal->j_flags & JBD2_BARRIER)
466
		blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL);
467 468

	__jbd2_update_log_tail(journal, first_tid, blocknr);
469 470 471 472 473 474 475 476 477
	return 0;
}


/* Checkpoint list management */

/*
 * journal_clean_one_cp_list
 *
478 479
 * Find all the written-back checkpoint buffers in the given list and
 * release them.
480 481 482
 *
 * Called with the journal locked.
 * Called with j_list_lock held.
483
 * Returns number of buffers reaped (for debug)
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
 */

static int journal_clean_one_cp_list(struct journal_head *jh, int *released)
{
	struct journal_head *last_jh;
	struct journal_head *next_jh = jh;
	int ret, freed = 0;

	*released = 0;
	if (!jh)
		return 0;

	last_jh = jh->b_cpprev;
	do {
		jh = next_jh;
		next_jh = jh->b_cpnext;
500 501 502 503 504 505
		ret = __try_to_free_cp_buf(jh);
		if (ret) {
			freed++;
			if (ret == 2) {
				*released = 1;
				return freed;
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
			}
		}
		/*
		 * This function only frees up some memory
		 * if possible so we dont have an obligation
		 * to finish processing. Bail out if preemption
		 * requested:
		 */
		if (need_resched())
			return freed;
	} while (jh != last_jh);

	return freed;
}

/*
 * journal_clean_checkpoint_list
 *
 * Find all the written-back checkpoint buffers in the journal and release them.
 *
 * Called with the journal locked.
 * Called with j_list_lock held.
 * Returns number of buffers reaped (for debug)
 */

531
int __jbd2_journal_clean_checkpoint_list(journal_t *journal)
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
{
	transaction_t *transaction, *last_transaction, *next_transaction;
	int ret = 0;
	int released;

	transaction = journal->j_checkpoint_transactions;
	if (!transaction)
		goto out;

	last_transaction = transaction->t_cpprev;
	next_transaction = transaction;
	do {
		transaction = next_transaction;
		next_transaction = transaction->t_cpnext;
		ret += journal_clean_one_cp_list(transaction->
				t_checkpoint_list, &released);
		/*
		 * This function only frees up some memory if possible so we
		 * dont have an obligation to finish processing. Bail out if
		 * preemption requested:
		 */
		if (need_resched())
			goto out;
		if (released)
			continue;
		/*
		 * It is essential that we are as careful as in the case of
		 * t_checkpoint_list with removing the buffer from the list as
		 * we can possibly see not yet submitted buffers on io_list
		 */
		ret += journal_clean_one_cp_list(transaction->
				t_checkpoint_io_list, &released);
		if (need_resched())
			goto out;
	} while (transaction != last_transaction);
out:
	return ret;
}

/*
 * journal_remove_checkpoint: called after a buffer has been committed
 * to disk (either by being write-back flushed to disk, or being
 * committed to the log).
 *
 * We cannot safely clean a transaction out of the log until all of the
 * buffer updates committed in that transaction have safely been stored
 * elsewhere on disk.  To achieve this, all of the buffers in a
 * transaction need to be maintained on the transaction's checkpoint
 * lists until they have been rewritten, at which point this function is
 * called to remove the buffer from the existing transaction's
 * checkpoint lists.
 *
 * The function returns 1 if it frees the transaction, 0 otherwise.
585
 * The function can free jh and bh.
586 587 588
 *
 * This function is called with j_list_lock held.
 */
589
int __jbd2_journal_remove_checkpoint(struct journal_head *jh)
590
{
591
	struct transaction_chp_stats_s *stats;
592 593 594 595 596 597 598 599 600 601 602 603
	transaction_t *transaction;
	journal_t *journal;
	int ret = 0;

	JBUFFER_TRACE(jh, "entry");

	if ((transaction = jh->b_cp_transaction) == NULL) {
		JBUFFER_TRACE(jh, "not on transaction");
		goto out;
	}
	journal = transaction->t_journal;

604
	JBUFFER_TRACE(jh, "removing from transaction");
605 606
	__buffer_unlink(jh);
	jh->b_cp_transaction = NULL;
607
	jbd2_journal_put_journal_head(jh);
608 609 610 611 612 613 614

	if (transaction->t_checkpoint_list != NULL ||
	    transaction->t_checkpoint_io_list != NULL)
		goto out;

	/*
	 * There is one special case to worry about: if we have just pulled the
615 616 617
	 * buffer off a running or committing transaction's checkpoing list,
	 * then even if the checkpoint list is empty, the transaction obviously
	 * cannot be dropped!
618
	 *
619
	 * The locking here around t_state is a bit sleazy.
620
	 * See the comment at the end of jbd2_journal_commit_transaction().
621
	 */
622
	if (transaction->t_state != T_FINISHED)
623 624 625 626
		goto out;

	/* OK, that was the last buffer for the transaction: we can now
	   safely remove this transaction from the log */
627 628 629 630 631 632
	stats = &transaction->t_chp_stats;
	if (stats->cs_chp_time)
		stats->cs_chp_time = jbd2_time_diff(stats->cs_chp_time,
						    jiffies);
	trace_jbd2_checkpoint_stats(journal->j_fs_dev->bd_dev,
				    transaction->t_tid, stats);
633

634
	__jbd2_journal_drop_transaction(journal, transaction);
635
	jbd2_journal_free_transaction(transaction);
636 637 638 639 640 641 642 643 644 645 646 647 648
	ret = 1;
out:
	return ret;
}

/*
 * journal_insert_checkpoint: put a committed buffer onto a checkpoint
 * list so that we know when it is safe to clean the transaction out of
 * the log.
 *
 * Called with the journal locked.
 * Called with j_list_lock held.
 */
649
void __jbd2_journal_insert_checkpoint(struct journal_head *jh,
650 651 652 653 654 655
			       transaction_t *transaction)
{
	JBUFFER_TRACE(jh, "entry");
	J_ASSERT_JH(jh, buffer_dirty(jh2bh(jh)) || buffer_jbddirty(jh2bh(jh)));
	J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);

656 657
	/* Get reference for checkpointing transaction */
	jbd2_journal_grab_journal_head(jh2bh(jh));
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
	jh->b_cp_transaction = transaction;

	if (!transaction->t_checkpoint_list) {
		jh->b_cpnext = jh->b_cpprev = jh;
	} else {
		jh->b_cpnext = transaction->t_checkpoint_list;
		jh->b_cpprev = transaction->t_checkpoint_list->b_cpprev;
		jh->b_cpprev->b_cpnext = jh;
		jh->b_cpnext->b_cpprev = jh;
	}
	transaction->t_checkpoint_list = jh;
}

/*
 * We've finished with this transaction structure: adios...
 *
 * The transaction must have no links except for the checkpoint by this
 * point.
 *
 * Called with the journal locked.
 * Called with j_list_lock held.
 */

681
void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction)
682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699
{
	assert_spin_locked(&journal->j_list_lock);
	if (transaction->t_cpnext) {
		transaction->t_cpnext->t_cpprev = transaction->t_cpprev;
		transaction->t_cpprev->t_cpnext = transaction->t_cpnext;
		if (journal->j_checkpoint_transactions == transaction)
			journal->j_checkpoint_transactions =
				transaction->t_cpnext;
		if (journal->j_checkpoint_transactions == transaction)
			journal->j_checkpoint_transactions = NULL;
	}

	J_ASSERT(transaction->t_state == T_FINISHED);
	J_ASSERT(transaction->t_buffers == NULL);
	J_ASSERT(transaction->t_forget == NULL);
	J_ASSERT(transaction->t_shadow_list == NULL);
	J_ASSERT(transaction->t_checkpoint_list == NULL);
	J_ASSERT(transaction->t_checkpoint_io_list == NULL);
700
	J_ASSERT(atomic_read(&transaction->t_updates) == 0);
701 702 703
	J_ASSERT(journal->j_committing_transaction != transaction);
	J_ASSERT(journal->j_running_transaction != transaction);

704 705
	trace_jbd2_drop_transaction(journal, transaction);

706 707
	jbd_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid);
}