checkpoint.c 19.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 * linux/fs/checkpoint.c
3
 *
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11
 * 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.
 *
12 13
 * Checkpoint routines for the generic filesystem journaling code.
 * Part of the ext2fs journaling system.
Linus Torvalds's avatar
Linus Torvalds committed
14 15 16 17 18 19 20 21 22 23 24 25 26
 *
 * 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>
#include <linux/jbd.h>
#include <linux/errno.h>
#include <linux/slab.h>

/*
27
 * Unlink a buffer from a transaction checkpoint list.
Linus Torvalds's avatar
Linus Torvalds committed
28 29 30
 *
 * Called with j_list_lock held.
 */
31
static inline void __buffer_unlink_first(struct journal_head *jh)
Linus Torvalds's avatar
Linus Torvalds committed
32
{
33
	transaction_t *transaction = jh->b_cp_transaction;
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36

	jh->b_cpnext->b_cpprev = jh->b_cpprev;
	jh->b_cpprev->b_cpnext = jh->b_cpnext;
37
	if (transaction->t_checkpoint_list == jh) {
Linus Torvalds's avatar
Linus Torvalds committed
38
		transaction->t_checkpoint_list = jh->b_cpnext;
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
		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;
Linus Torvalds's avatar
Linus Torvalds committed
81 82 83 84
}

/*
 * Try to release a checkpointed buffer from its transaction.
85 86 87
 * Returns 1 if we released it and 2 if we also released the
 * whole transaction.
 *
Linus Torvalds's avatar
Linus Torvalds committed
88 89 90 91 92 93 94 95 96 97
 * Requires j_list_lock
 * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
 */
static int __try_to_free_cp_buf(struct journal_head *jh)
{
	int ret = 0;
	struct buffer_head *bh = jh2bh(jh);

	if (jh->b_jlist == BJ_None && !buffer_locked(bh) && !buffer_dirty(bh)) {
		JBUFFER_TRACE(jh, "remove from checkpoint list");
98
		ret = __journal_remove_checkpoint(jh) + 1;
Linus Torvalds's avatar
Linus Torvalds committed
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
		jbd_unlock_bh_state(bh);
		journal_remove_journal_head(bh);
		BUFFER_TRACE(bh, "release");
		__brelse(bh);
	} else {
		jbd_unlock_bh_state(bh);
	}
	return ret;
}

/*
 * __log_wait_for_space: wait until there is space in the journal.
 *
 * 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.
 */
void __log_wait_for_space(journal_t *journal)
{
	int nblocks;
	assert_spin_locked(&journal->j_state_lock);

	nblocks = jbd_space_needed(journal);
	while (__log_space_left(journal) < nblocks) {
		if (journal->j_flags & JFS_ABORT)
			return;
		spin_unlock(&journal->j_state_lock);
125
		mutex_lock(&journal->j_checkpoint_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
126 127 128 129 130 131 132 133 134 135 136 137

		/*
		 * Test again, another process may have checkpointed while we
		 * were waiting for the checkpoint lock
		 */
		spin_lock(&journal->j_state_lock);
		nblocks = jbd_space_needed(journal);
		if (__log_space_left(journal) < nblocks) {
			spin_unlock(&journal->j_state_lock);
			log_do_checkpoint(journal);
			spin_lock(&journal->j_state_lock);
		}
138
		mutex_unlock(&journal->j_checkpoint_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
139 140 141 142 143 144 145 146 147
	}
}

/*
 * We were unable to perform jbd_trylock_bh_state() inside j_list_lock.
 * The caller must restart a list walk.  Wait for someone else to run
 * jbd_unlock_bh_state().
 */
static void jbd_sync_bh(journal_t *journal, struct buffer_head *bh)
148
	__releases(journal->j_list_lock)
Linus Torvalds's avatar
Linus Torvalds committed
149 150 151 152 153 154 155 156 157
{
	get_bh(bh);
	spin_unlock(&journal->j_list_lock);
	jbd_lock_bh_state(bh);
	jbd_unlock_bh_state(bh);
	put_bh(bh);
}

/*
158 159 160 161
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
162 163 164
 *
 * Called with j_list_lock held.
 */
165
static void __wait_cp_io(journal_t *journal, transaction_t *transaction)
Linus Torvalds's avatar
Linus Torvalds committed
166
{
167
	struct journal_head *jh;
Linus Torvalds's avatar
Linus Torvalds committed
168
	struct buffer_head *bh;
169 170 171 172 173 174 175 176 177 178 179
	tid_t this_tid;
	int released = 0;

	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)
		return;
	while (!released && transaction->t_checkpoint_io_list) {
		jh = transaction->t_checkpoint_io_list;
Linus Torvalds's avatar
Linus Torvalds committed
180
		bh = jh2bh(jh);
181 182 183 184 185
		if (!jbd_trylock_bh_state(bh)) {
			jbd_sync_bh(journal, bh);
			spin_lock(&journal->j_list_lock);
			goto restart;
		}
Linus Torvalds's avatar
Linus Torvalds committed
186 187 188
		if (buffer_locked(bh)) {
			atomic_inc(&bh->b_count);
			spin_unlock(&journal->j_list_lock);
189
			jbd_unlock_bh_state(bh);
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192 193
			wait_on_buffer(bh);
			/* the journal_head may have gone by now */
			BUFFER_TRACE(bh, "brelse");
			__brelse(bh);
194 195
			spin_lock(&journal->j_list_lock);
			goto restart;
Linus Torvalds's avatar
Linus Torvalds committed
196 197
		}
		/*
198 199
		 * 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
Linus Torvalds's avatar
Linus Torvalds committed
200
		 */
201 202 203 204 205
		released = __journal_remove_checkpoint(jh);
		jbd_unlock_bh_state(bh);
		journal_remove_journal_head(bh);
		__brelse(bh);
	}
Linus Torvalds's avatar
Linus Torvalds committed
206 207 208 209 210 211 212 213 214
}

#define NR_BATCH	64

static void
__flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
{
	int i;

215
	ll_rw_block(SWRITE, *batch_count, bhs);
Linus Torvalds's avatar
Linus Torvalds committed
216 217 218 219 220 221 222 223 224 225 226 227 228
	for (i = 0; i < *batch_count; i++) {
		struct buffer_head *bh = bhs[i];
		clear_buffer_jwrite(bh);
		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
229
 * scan of the checkpoint list.
Linus Torvalds's avatar
Linus Torvalds committed
230
 *
231
 * Called with j_list_lock held and drops it if 1 is returned
Linus Torvalds's avatar
Linus Torvalds committed
232 233
 * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
 */
234 235
static int __process_buffer(journal_t *journal, struct journal_head *jh,
			struct buffer_head **bhs, int *batch_count)
Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239
{
	struct buffer_head *bh = jh2bh(jh);
	int ret = 0;

240 241 242 243 244 245 246 247 248 249 250 251
	if (buffer_locked(bh)) {
		atomic_inc(&bh->b_count);
		spin_unlock(&journal->j_list_lock);
		jbd_unlock_bh_state(bh);
		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;
Linus Torvalds's avatar
Linus Torvalds committed
252

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
		spin_unlock(&journal->j_list_lock);
		jbd_unlock_bh_state(bh);
		log_start_commit(journal, tid);
		log_wait_commit(journal, tid);
		ret = 1;
	} else if (!buffer_dirty(bh)) {
		J_ASSERT_JH(jh, !buffer_jbddirty(bh));
		BUFFER_TRACE(bh, "remove from checkpoint");
		__journal_remove_checkpoint(jh);
		spin_unlock(&journal->j_list_lock);
		jbd_unlock_bh_state(bh);
		journal_remove_journal_head(bh);
		__brelse(bh);
		ret = 1;
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
268 269 270 271 272
		/*
		 * 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
273
		 * disk, as that would break recoverability.
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276 277 278 279
		 */
		BUFFER_TRACE(bh, "queue");
		get_bh(bh);
		J_ASSERT_BH(bh, !buffer_jwrite(bh));
		set_buffer_jwrite(bh);
		bhs[*batch_count] = bh;
280
		__buffer_relink_io(jh);
Linus Torvalds's avatar
Linus Torvalds committed
281 282 283
		jbd_unlock_bh_state(bh);
		(*batch_count)++;
		if (*batch_count == NR_BATCH) {
284
			spin_unlock(&journal->j_list_lock);
Linus Torvalds's avatar
Linus Torvalds committed
285 286 287 288 289 290 291 292
			__flush_batch(journal, bhs, batch_count);
			ret = 1;
		}
	}
	return ret;
}

/*
293 294 295
 * 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.
296
 *
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299 300
 * The journal should be locked before calling this function.
 */
int log_do_checkpoint(journal_t *journal)
{
301 302
	transaction_t *transaction;
	tid_t this_tid;
Linus Torvalds's avatar
Linus Torvalds committed
303 304 305 306
	int result;

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

307
	/*
Linus Torvalds's avatar
Linus Torvalds committed
308 309
	 * First thing: if there are any transactions in the log which
	 * don't need checkpointing, just eliminate them from the
310
	 * journal straight away.
Linus Torvalds's avatar
Linus Torvalds committed
311 312 313 314 315 316 317
	 */
	result = cleanup_journal_tail(journal);
	jbd_debug(1, "cleanup_journal_tail returned %d\n", result);
	if (result <= 0)
		return result;

	/*
318 319
	 * OK, we need to start writing disk blocks.  Take one transaction
	 * and write it.
Linus Torvalds's avatar
Linus Torvalds committed
320
	 */
321 322 323 324 325 326
	spin_lock(&journal->j_list_lock);
	if (!journal->j_checkpoint_transactions)
		goto out;
	transaction = journal->j_checkpoint_transactions;
	this_tid = transaction->t_tid;
restart:
Linus Torvalds's avatar
Linus Torvalds committed
327
	/*
328 329 330
	 * 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).
Linus Torvalds's avatar
Linus Torvalds committed
331
	 */
332 333 334 335 336 337 338 339
	if (journal->j_checkpoint_transactions == transaction &&
			transaction->t_tid == this_tid) {
		int batch_count = 0;
		struct buffer_head *bhs[NR_BATCH];
		struct journal_head *jh;
		int retry = 0;

		while (!retry && transaction->t_checkpoint_list) {
Linus Torvalds's avatar
Linus Torvalds committed
340 341
			struct buffer_head *bh;

342
			jh = transaction->t_checkpoint_list;
Linus Torvalds's avatar
Linus Torvalds committed
343 344 345 346 347 348
			bh = jh2bh(jh);
			if (!jbd_trylock_bh_state(bh)) {
				jbd_sync_bh(journal, bh);
				retry = 1;
				break;
			}
349 350 351
			retry = __process_buffer(journal, jh, bhs,&batch_count);
			if (!retry && lock_need_resched(&journal->j_list_lock)){
				spin_unlock(&journal->j_list_lock);
Linus Torvalds's avatar
Linus Torvalds committed
352 353 354
				retry = 1;
				break;
			}
355
		}
Linus Torvalds's avatar
Linus Torvalds committed
356

357
		if (batch_count) {
358 359 360 361
			if (!retry) {
				spin_unlock(&journal->j_list_lock);
				retry = 1;
			}
Linus Torvalds's avatar
Linus Torvalds committed
362
			__flush_batch(journal, bhs, &batch_count);
363
		}
Linus Torvalds's avatar
Linus Torvalds committed
364

365 366 367 368
		if (retry) {
			spin_lock(&journal->j_list_lock);
			goto restart;
		}
Linus Torvalds's avatar
Linus Torvalds committed
369
		/*
370 371
		 * Now we have cleaned up the first transaction's checkpoint
		 * list. Let's clean up the second one
372
		 */
373
		__wait_cp_io(journal, transaction);
Linus Torvalds's avatar
Linus Torvalds committed
374
	}
375
out:
Linus Torvalds's avatar
Linus Torvalds committed
376 377 378 379 380 381 382 383 384 385 386 387
	spin_unlock(&journal->j_list_lock);
	result = cleanup_journal_tail(journal);
	if (result < 0)
		return result;
	return 0;
}

/*
 * 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.
388
 *
Linus Torvalds's avatar
Linus Torvalds committed
389
 * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
390
 *
Linus Torvalds's avatar
Linus Torvalds committed
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
 * 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
 * even in abort state, but we must not update the journal superblock if
 * we have an abort error outstanding.
 */

int cleanup_journal_tail(journal_t *journal)
{
	transaction_t * transaction;
	tid_t		first_tid;
	unsigned long	blocknr, freed;

	/* OK, work out the oldest transaction remaining in the log, and
407 408
	 * the log block it starts at.
	 *
Linus Torvalds's avatar
Linus Torvalds committed
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
	 * If the log is now empty, we need to work out which is the
	 * next transaction ID we will write, and where it will
	 * start. */

	spin_lock(&journal->j_state_lock);
	spin_lock(&journal->j_list_lock);
	transaction = journal->j_checkpoint_transactions;
	if (transaction) {
		first_tid = transaction->t_tid;
		blocknr = transaction->t_log_start;
	} else if ((transaction = journal->j_committing_transaction) != NULL) {
		first_tid = transaction->t_tid;
		blocknr = transaction->t_log_start;
	} else if ((transaction = journal->j_running_transaction) != NULL) {
		first_tid = transaction->t_tid;
		blocknr = journal->j_head;
	} else {
		first_tid = journal->j_transaction_sequence;
		blocknr = journal->j_head;
	}
	spin_unlock(&journal->j_list_lock);
	J_ASSERT(blocknr != 0);

	/* If the oldest pinned transaction is at the tail of the log
           already then there's not much we can do right now. */
	if (journal->j_tail_sequence == first_tid) {
		spin_unlock(&journal->j_state_lock);
		return 1;
	}

	/* OK, update the superblock to recover the freed space.
	 * Physical blocks come first: have we wrapped beyond the end of
	 * the log?  */
	freed = blocknr - journal->j_tail;
	if (blocknr < journal->j_tail)
		freed = freed + journal->j_last - journal->j_first;

	jbd_debug(1,
		  "Cleaning journal tail from %d to %d (offset %lu), "
		  "freeing %lu\n",
		  journal->j_tail_sequence, first_tid, blocknr, freed);

	journal->j_free += freed;
	journal->j_tail_sequence = first_tid;
	journal->j_tail = blocknr;
	spin_unlock(&journal->j_state_lock);
	if (!(journal->j_flags & JFS_ABORT))
		journal_update_superblock(journal, 1);
	return 0;
}


/* Checkpoint list management */

463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
/*
 * journal_clean_one_cp_list
 *
 * Find all the written-back checkpoint buffers in the given list and release them.
 *
 * Called with the journal locked.
 * Called with j_list_lock held.
 * Returns number of bufers reaped (for debug)
 */

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;
		/* Use trylock because of the ranking */
		if (jbd_trylock_bh_state(jh2bh(jh))) {
			ret = __try_to_free_cp_buf(jh);
			if (ret) {
				freed++;
				if (ret == 2) {
					*released = 1;
					return freed;
				}
			}
		}
		/*
		 * 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;
}

Linus Torvalds's avatar
Linus Torvalds committed
511 512 513 514 515 516 517
/*
 * 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.
518
 * Returns number of buffers reaped (for debug)
Linus Torvalds's avatar
Linus Torvalds committed
519 520 521 522 523
 */

int __journal_clean_checkpoint_list(journal_t *journal)
{
	transaction_t *transaction, *last_transaction, *next_transaction;
524
	int ret = 0;
525
	int released;
Linus Torvalds's avatar
Linus Torvalds committed
526 527

	transaction = journal->j_checkpoint_transactions;
528
	if (!transaction)
Linus Torvalds's avatar
Linus Torvalds committed
529 530 531 532 533 534 535
		goto out;

	last_transaction = transaction->t_cpprev;
	next_transaction = transaction;
	do {
		transaction = next_transaction;
		next_transaction = transaction->t_cpnext;
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
		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;
Linus Torvalds's avatar
Linus Torvalds committed
556 557 558 559 560
	} while (transaction != last_transaction);
out:
	return ret;
}

561
/*
Linus Torvalds's avatar
Linus Torvalds committed
562 563 564 565 566 567 568 569
 * 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
570
 * lists until they have been rewritten, at which point this function is
Linus Torvalds's avatar
Linus Torvalds committed
571
 * called to remove the buffer from the existing transaction's
572 573 574
 * checkpoint lists.
 *
 * The function returns 1 if it frees the transaction, 0 otherwise.
Linus Torvalds's avatar
Linus Torvalds committed
575 576 577
 *
 * This function is called with the journal locked.
 * This function is called with j_list_lock held.
578
 * This function is called with jbd_lock_bh_state(jh2bh(jh))
Linus Torvalds's avatar
Linus Torvalds committed
579 580
 */

581
int __journal_remove_checkpoint(struct journal_head *jh)
Linus Torvalds's avatar
Linus Torvalds committed
582 583 584
{
	transaction_t *transaction;
	journal_t *journal;
585
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
586 587 588 589 590 591 592 593 594 595

	JBUFFER_TRACE(jh, "entry");

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

	__buffer_unlink(jh);
596
	jh->b_cp_transaction = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
597

598 599
	if (transaction->t_checkpoint_list != NULL ||
	    transaction->t_checkpoint_io_list != NULL)
Linus Torvalds's avatar
Linus Torvalds committed
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
		goto out;
	JBUFFER_TRACE(jh, "transaction has no more buffers");

	/*
	 * There is one special case to worry about: if we have just pulled the
	 * buffer off a committing transaction's forget list, then even if the
	 * checkpoint list is empty, the transaction obviously cannot be
	 * dropped!
	 *
	 * The locking here around j_committing_transaction is a bit sleazy.
	 * See the comment at the end of journal_commit_transaction().
	 */
	if (transaction == journal->j_committing_transaction) {
		JBUFFER_TRACE(jh, "belongs to committing transaction");
		goto out;
	}

	/* OK, that was the last buffer for the transaction: we can now
	   safely remove this transaction from the log */

	__journal_drop_transaction(journal, transaction);

	/* Just in case anybody was waiting for more transactions to be
           checkpointed... */
	wake_up(&journal->j_wait_logspace);
625
	ret = 1;
Linus Torvalds's avatar
Linus Torvalds committed
626 627
out:
	JBUFFER_TRACE(jh, "exit");
628
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
629 630 631 632 633 634 635 636 637 638
}

/*
 * 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.
 */
639
void __journal_insert_checkpoint(struct journal_head *jh,
Linus Torvalds's avatar
Linus Torvalds committed
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
			       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);

	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...
661
 *
Linus Torvalds's avatar
Linus Torvalds committed
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
 * The transaction must have no links except for the checkpoint by this
 * point.
 *
 * Called with the journal locked.
 * Called with j_list_lock held.
 */

void __journal_drop_transaction(journal_t *journal, transaction_t *transaction)
{
	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_sync_datalist == NULL);
	J_ASSERT(transaction->t_forget == NULL);
	J_ASSERT(transaction->t_iobuf_list == NULL);
	J_ASSERT(transaction->t_shadow_list == NULL);
	J_ASSERT(transaction->t_log_list == NULL);
	J_ASSERT(transaction->t_checkpoint_list == NULL);
690
	J_ASSERT(transaction->t_checkpoint_io_list == NULL);
Linus Torvalds's avatar
Linus Torvalds committed
691 692 693 694 695 696 697
	J_ASSERT(transaction->t_updates == 0);
	J_ASSERT(journal->j_committing_transaction != transaction);
	J_ASSERT(journal->j_running_transaction != transaction);

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