checkpoint.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * linux/fs/jbd2/checkpoint.c
  4 *
  5 * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
  6 *
  7 * Copyright 1999 Red Hat Software --- All Rights Reserved
  8 *
  9 * Checkpoint routines for the generic filesystem journaling code.
 10 * Part of the ext2fs journaling system.
 11 *
 12 * Checkpointing is the process of ensuring that a section of the log is
 13 * committed fully to disk, so that that portion of the log can be
 14 * reused.
 15 */
 16
 17#include <linux/time.h>
 18#include <linux/fs.h>
 19#include <linux/jbd2.h>
 20#include <linux/errno.h>
 21#include <linux/slab.h>
 22#include <linux/blkdev.h>
 23#include <trace/events/jbd2.h>
 24
 25/*
 26 * Unlink a buffer from a transaction checkpoint list.
 27 *
 28 * Called with j_list_lock held.
 29 */
 30static inline void __buffer_unlink(struct journal_head *jh)
 31{
 32	transaction_t *transaction = jh->b_cp_transaction;
 33
 34	jh->b_cpnext->b_cpprev = jh->b_cpprev;
 35	jh->b_cpprev->b_cpnext = jh->b_cpnext;
 36	if (transaction->t_checkpoint_list == jh) {
 37		transaction->t_checkpoint_list = jh->b_cpnext;
 38		if (transaction->t_checkpoint_list == jh)
 39			transaction->t_checkpoint_list = NULL;
 40	}
 41}
 42
 43/*
 44 * __jbd2_log_wait_for_space: wait until there is space in the journal.
 45 *
 46 * Called under j-state_lock *only*.  It will be unlocked if we have to wait
 47 * for a checkpoint to free up some space in the log.
 48 */
 49void __jbd2_log_wait_for_space(journal_t *journal)
 50__acquires(&journal->j_state_lock)
 51__releases(&journal->j_state_lock)
 52{
 53	int nblocks, space_left;
 54	/* assert_spin_locked(&journal->j_state_lock); */
 55
 56	nblocks = journal->j_max_transaction_buffers;
 57	while (jbd2_log_space_left(journal) < nblocks) {
 58		write_unlock(&journal->j_state_lock);
 59		mutex_lock_io(&journal->j_checkpoint_mutex);
 60
 61		/*
 62		 * Test again, another process may have checkpointed while we
 63		 * were waiting for the checkpoint lock. If there are no
 64		 * transactions ready to be checkpointed, try to recover
 65		 * journal space by calling cleanup_journal_tail(), and if
 66		 * that doesn't work, by waiting for the currently committing
 67		 * transaction to complete.  If there is absolutely no way
 68		 * to make progress, this is either a BUG or corrupted
 69		 * filesystem, so abort the journal and leave a stack
 70		 * trace for forensic evidence.
 71		 */
 72		write_lock(&journal->j_state_lock);
 73		if (journal->j_flags & JBD2_ABORT) {
 74			mutex_unlock(&journal->j_checkpoint_mutex);
 75			return;
 76		}
 77		spin_lock(&journal->j_list_lock);
 78		space_left = jbd2_log_space_left(journal);
 79		if (space_left < nblocks) {
 80			int chkpt = journal->j_checkpoint_transactions != NULL;
 81			tid_t tid = 0;
 82			bool has_transaction = false;
 83
 84			if (journal->j_committing_transaction) {
 85				tid = journal->j_committing_transaction->t_tid;
 86				has_transaction = true;
 87			}
 88			spin_unlock(&journal->j_list_lock);
 89			write_unlock(&journal->j_state_lock);
 90			if (chkpt) {
 91				jbd2_log_do_checkpoint(journal);
 92			} else if (jbd2_cleanup_journal_tail(journal) <= 0) {
 93				/*
 94				 * We were able to recover space or the
 95				 * journal was aborted due to an error.
 96				 */
 97				;
 98			} else if (has_transaction) {
 99				/*
100				 * jbd2_journal_commit_transaction() may want
101				 * to take the checkpoint_mutex if JBD2_FLUSHED
102				 * is set.  So we need to temporarily drop it.
103				 */
104				mutex_unlock(&journal->j_checkpoint_mutex);
105				jbd2_log_wait_commit(journal, tid);
106				write_lock(&journal->j_state_lock);
107				continue;
108			} else {
109				printk(KERN_ERR "%s: needed %d blocks and "
110				       "only had %d space available\n",
111				       __func__, nblocks, space_left);
112				printk(KERN_ERR "%s: no way to get more "
113				       "journal space in %s\n", __func__,
114				       journal->j_devname);
115				WARN_ON(1);
116				jbd2_journal_abort(journal, -ENOSPC);
117			}
118			write_lock(&journal->j_state_lock);
119		} else {
120			spin_unlock(&journal->j_list_lock);
121		}
122		mutex_unlock(&journal->j_checkpoint_mutex);
123	}
124}
125
126static void
127__flush_batch(journal_t *journal, int *batch_count)
128{
129	int i;
130	struct blk_plug plug;
131
132	blk_start_plug(&plug);
133	for (i = 0; i < *batch_count; i++)
134		write_dirty_buffer(journal->j_chkpt_bhs[i], JBD2_JOURNAL_REQ_FLAGS);
135	blk_finish_plug(&plug);
136
137	for (i = 0; i < *batch_count; i++) {
138		struct buffer_head *bh = journal->j_chkpt_bhs[i];
139		BUFFER_TRACE(bh, "brelse");
140		__brelse(bh);
141		journal->j_chkpt_bhs[i] = NULL;
142	}
143	*batch_count = 0;
144}
145
146/*
147 * Perform an actual checkpoint. We take the first transaction on the
148 * list of transactions to be checkpointed and send all its buffers
149 * to disk. We submit larger chunks of data at once.
150 *
151 * The journal should be locked before calling this function.
152 * Called with j_checkpoint_mutex held.
153 */
154int jbd2_log_do_checkpoint(journal_t *journal)
155{
156	struct journal_head	*jh;
157	struct buffer_head	*bh;
158	transaction_t		*transaction;
159	tid_t			this_tid;
160	int			result, batch_count = 0;
161
162	jbd2_debug(1, "Start checkpoint\n");
163
164	/*
165	 * First thing: if there are any transactions in the log which
166	 * don't need checkpointing, just eliminate them from the
167	 * journal straight away.
168	 */
169	result = jbd2_cleanup_journal_tail(journal);
170	trace_jbd2_checkpoint(journal, result);
171	jbd2_debug(1, "cleanup_journal_tail returned %d\n", result);
172	if (result <= 0)
173		return result;
174
175	/*
176	 * OK, we need to start writing disk blocks.  Take one transaction
177	 * and write it.
178	 */
179	spin_lock(&journal->j_list_lock);
180	if (!journal->j_checkpoint_transactions)
181		goto out;
182	transaction = journal->j_checkpoint_transactions;
183	if (transaction->t_chp_stats.cs_chp_time == 0)
184		transaction->t_chp_stats.cs_chp_time = jiffies;
185	this_tid = transaction->t_tid;
186restart:
187	/*
188	 * If someone cleaned up this transaction while we slept, we're
189	 * done (maybe it's a new transaction, but it fell at the same
190	 * address).
191	 */
192	if (journal->j_checkpoint_transactions != transaction ||
193	    transaction->t_tid != this_tid)
194		goto out;
195
196	/* checkpoint all of the transaction's buffers */
197	while (transaction->t_checkpoint_list) {
198		jh = transaction->t_checkpoint_list;
199		bh = jh2bh(jh);
200
201		if (jh->b_transaction != NULL) {
202			transaction_t *t = jh->b_transaction;
203			tid_t tid = t->t_tid;
204
205			transaction->t_chp_stats.cs_forced_to_close++;
206			spin_unlock(&journal->j_list_lock);
207			if (unlikely(journal->j_flags & JBD2_UNMOUNT))
208				/*
209				 * The journal thread is dead; so
210				 * starting and waiting for a commit
211				 * to finish will cause us to wait for
212				 * a _very_ long time.
213				 */
214				printk(KERN_ERR
215		"JBD2: %s: Waiting for Godot: block %llu\n",
216		journal->j_devname, (unsigned long long) bh->b_blocknr);
217
218			if (batch_count)
219				__flush_batch(journal, &batch_count);
220			jbd2_log_start_commit(journal, tid);
221			/*
222			 * jbd2_journal_commit_transaction() may want
223			 * to take the checkpoint_mutex if JBD2_FLUSHED
224			 * is set, jbd2_update_log_tail() called by
225			 * jbd2_journal_commit_transaction() may also take
226			 * checkpoint_mutex.  So we need to temporarily
227			 * drop it.
228			 */
229			mutex_unlock(&journal->j_checkpoint_mutex);
230			jbd2_log_wait_commit(journal, tid);
231			mutex_lock_io(&journal->j_checkpoint_mutex);
232			spin_lock(&journal->j_list_lock);
233			goto restart;
234		}
235		if (!trylock_buffer(bh)) {
236			/*
237			 * The buffer is locked, it may be writing back, or
238			 * flushing out in the last couple of cycles, or
239			 * re-adding into a new transaction, need to check
240			 * it again until it's unlocked.
241			 */
242			get_bh(bh);
243			spin_unlock(&journal->j_list_lock);
244			wait_on_buffer(bh);
245			/* the journal_head may have gone by now */
246			BUFFER_TRACE(bh, "brelse");
247			__brelse(bh);
248			goto retry;
249		} else if (!buffer_dirty(bh)) {
250			unlock_buffer(bh);
251			BUFFER_TRACE(bh, "remove from checkpoint");
252			/*
253			 * If the transaction was released or the checkpoint
254			 * list was empty, we're done.
255			 */
256			if (__jbd2_journal_remove_checkpoint(jh) ||
257			    !transaction->t_checkpoint_list)
258				goto out;
259		} else {
260			unlock_buffer(bh);
261			/*
262			 * We are about to write the buffer, it could be
263			 * raced by some other transaction shrink or buffer
264			 * re-log logic once we release the j_list_lock,
265			 * leave it on the checkpoint list and check status
266			 * again to make sure it's clean.
267			 */
268			BUFFER_TRACE(bh, "queue");
269			get_bh(bh);
270			if (WARN_ON_ONCE(buffer_jwrite(bh))) {
271				put_bh(bh); /* drop the ref we just took */
272				spin_unlock(&journal->j_list_lock);
273				/* Clean up any previously batched buffers */
274				if (batch_count)
275					__flush_batch(journal, &batch_count);
276				jbd2_journal_abort(journal, -EFSCORRUPTED);
277				return -EFSCORRUPTED;
278			}
279			journal->j_chkpt_bhs[batch_count++] = bh;
280			transaction->t_chp_stats.cs_written++;
281			transaction->t_checkpoint_list = jh->b_cpnext;
282		}
283
284		if ((batch_count == JBD2_NR_BATCH) ||
285		    need_resched() || spin_needbreak(&journal->j_list_lock) ||
286		    jh2bh(transaction->t_checkpoint_list) == journal->j_chkpt_bhs[0])
287			goto unlock_and_flush;
288	}
289
290	if (batch_count) {
291		unlock_and_flush:
292			spin_unlock(&journal->j_list_lock);
293		retry:
294			if (batch_count)
295				__flush_batch(journal, &batch_count);
296			cond_resched();
297			spin_lock(&journal->j_list_lock);
298			goto restart;
299	}
300
301out:
302	spin_unlock(&journal->j_list_lock);
303	result = jbd2_cleanup_journal_tail(journal);
304
305	return (result < 0) ? result : 0;
306}
307
308/*
309 * Check the list of checkpoint transactions for the journal to see if
310 * we have already got rid of any since the last update of the log tail
311 * in the journal superblock.  If so, we can instantly roll the
312 * superblock forward to remove those transactions from the log.
313 *
314 * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
315 *
316 * Called with the journal lock held.
317 *
318 * This is the only part of the journaling code which really needs to be
319 * aware of transaction aborts.  Checkpointing involves writing to the
320 * main filesystem area rather than to the journal, so it can proceed
321 * even in abort state, but we must not update the super block if
322 * checkpointing may have failed.  Otherwise, we would lose some metadata
323 * buffers which should be written-back to the filesystem.
324 */
325
326int jbd2_cleanup_journal_tail(journal_t *journal)
327{
328	tid_t		first_tid;
329	unsigned long	blocknr;
330
331	if (is_journal_aborted(journal))
332		return -EIO;
333
334	if (!jbd2_journal_get_log_tail(journal, &first_tid, &blocknr))
335		return 1;
336	if (WARN_ON_ONCE(blocknr == 0)) {
337		jbd2_journal_abort(journal, -EFSCORRUPTED);
338		return -EFSCORRUPTED;
339	}
340
341	/*
342	 * We need to make sure that any blocks that were recently written out
343	 * --- perhaps by jbd2_log_do_checkpoint() --- are flushed out before
344	 * we drop the transactions from the journal. It's unlikely this will
345	 * be necessary, especially with an appropriately sized journal, but we
346	 * need this to guarantee correctness.  Fortunately
347	 * jbd2_cleanup_journal_tail() doesn't get called all that often.
348	 */
349	if (journal->j_flags & JBD2_BARRIER)
350		blkdev_issue_flush(journal->j_fs_dev);
351
352	return __jbd2_update_log_tail(journal, first_tid, blocknr);
353}
354
355
356/* Checkpoint list management */
357
358/*
359 * journal_shrink_one_cp_list
360 *
361 * Find all the written-back checkpoint buffers in the given list
362 * and try to release them. If the whole transaction is released, set
363 * the 'released' parameter. Return the number of released checkpointed
364 * buffers.
365 *
366 * Called with j_list_lock held.
367 */
368static unsigned long journal_shrink_one_cp_list(struct journal_head *jh,
369						enum jbd2_shrink_type type,
370						bool *released)
371{
372	struct journal_head *last_jh;
373	struct journal_head *next_jh = jh;
374	unsigned long nr_freed = 0;
375	int ret;
376
377	*released = false;
378	if (!jh)
379		return 0;
380
381	last_jh = jh->b_cpprev;
382	do {
383		jh = next_jh;
384		next_jh = jh->b_cpnext;
385
386		if (type == JBD2_SHRINK_DESTROY) {
387			ret = __jbd2_journal_remove_checkpoint(jh);
388		} else {
389			ret = jbd2_journal_try_remove_checkpoint(jh);
390			if (ret < 0) {
391				if (type == JBD2_SHRINK_BUSY_SKIP)
392					continue;
393				break;
394			}
395		}
396
397		nr_freed++;
398		if (ret) {
399			*released = true;
400			break;
401		}
402
403		if (need_resched())
404			break;
405	} while (jh != last_jh);
406
407	return nr_freed;
408}
409
410/*
411 * jbd2_journal_shrink_checkpoint_list
412 *
413 * Find 'nr_to_scan' written-back checkpoint buffers in the journal
414 * and try to release them. Return the number of released checkpointed
415 * buffers.
416 *
417 * Called with j_list_lock held.
418 */
419unsigned long jbd2_journal_shrink_checkpoint_list(journal_t *journal,
420						  unsigned long *nr_to_scan)
421{
422	transaction_t *transaction, *last_transaction, *next_transaction;
423	bool __maybe_unused released;
424	tid_t first_tid = 0, last_tid = 0, next_tid = 0;
425	tid_t tid = 0;
426	unsigned long nr_freed = 0;
427	unsigned long freed;
428	bool first_set = false;
429
430again:
431	spin_lock(&journal->j_list_lock);
432	if (!journal->j_checkpoint_transactions) {
433		spin_unlock(&journal->j_list_lock);
434		goto out;
435	}
436
437	/*
438	 * Get next shrink transaction, resume previous scan or start
439	 * over again. If some others do checkpoint and drop transaction
440	 * from the checkpoint list, we ignore saved j_shrink_transaction
441	 * and start over unconditionally.
442	 */
443	if (journal->j_shrink_transaction)
444		transaction = journal->j_shrink_transaction;
445	else
446		transaction = journal->j_checkpoint_transactions;
447
448	if (!first_set) {
449		first_tid = transaction->t_tid;
450		first_set = true;
451	}
452	last_transaction = journal->j_checkpoint_transactions->t_cpprev;
453	next_transaction = transaction;
454	last_tid = last_transaction->t_tid;
455	do {
456		transaction = next_transaction;
457		next_transaction = transaction->t_cpnext;
458		tid = transaction->t_tid;
459
460		freed = journal_shrink_one_cp_list(transaction->t_checkpoint_list,
461						   JBD2_SHRINK_BUSY_SKIP, &released);
462		nr_freed += freed;
463		(*nr_to_scan) -= min(*nr_to_scan, freed);
464		if (*nr_to_scan == 0)
465			break;
466		if (need_resched() || spin_needbreak(&journal->j_list_lock))
467			break;
468	} while (transaction != last_transaction);
469
470	if (transaction != last_transaction) {
471		journal->j_shrink_transaction = next_transaction;
472		next_tid = next_transaction->t_tid;
473	} else {
474		journal->j_shrink_transaction = NULL;
475		next_tid = 0;
476	}
477
478	spin_unlock(&journal->j_list_lock);
479	cond_resched();
480
481	if (*nr_to_scan && journal->j_shrink_transaction)
482		goto again;
483out:
484	trace_jbd2_shrink_checkpoint_list(journal, first_tid, tid, last_tid,
485					  nr_freed, next_tid);
486
487	return nr_freed;
488}
489
490/*
491 * journal_clean_checkpoint_list
492 *
493 * Find all the written-back checkpoint buffers in the journal and release them.
494 * If 'type' is JBD2_SHRINK_DESTROY, release all buffers unconditionally. If
495 * 'type' is JBD2_SHRINK_BUSY_STOP, will stop release buffers if encounters a
496 * busy buffer. To avoid wasting CPU cycles scanning the buffer list in some
497 * cases, don't pass JBD2_SHRINK_BUSY_SKIP 'type' for this function.
498 *
499 * Called with j_list_lock held.
500 */
501void __jbd2_journal_clean_checkpoint_list(journal_t *journal,
502					  enum jbd2_shrink_type type)
503{
504	transaction_t *transaction, *last_transaction, *next_transaction;
505	bool released;
506
507	WARN_ON_ONCE(type == JBD2_SHRINK_BUSY_SKIP);
508
509	transaction = journal->j_checkpoint_transactions;
510	if (!transaction)
511		return;
512
513	last_transaction = transaction->t_cpprev;
514	next_transaction = transaction;
515	do {
516		transaction = next_transaction;
517		next_transaction = transaction->t_cpnext;
518		journal_shrink_one_cp_list(transaction->t_checkpoint_list,
519					   type, &released);
520		/*
521		 * This function only frees up some memory if possible so we
522		 * dont have an obligation to finish processing. Bail out if
523		 * preemption requested:
524		 */
525		if (need_resched())
526			return;
527		/*
528		 * Stop scanning if we couldn't free the transaction. This
529		 * avoids pointless scanning of transactions which still
530		 * weren't checkpointed.
531		 */
532		if (!released)
533			return;
534	} while (transaction != last_transaction);
535}
536
537/*
538 * Remove buffers from all checkpoint lists as journal is aborted and we just
539 * need to free memory
540 */
541void jbd2_journal_destroy_checkpoint(journal_t *journal)
542{
543	/*
544	 * We loop because __jbd2_journal_clean_checkpoint_list() may abort
545	 * early due to a need of rescheduling.
546	 */
547	while (1) {
548		spin_lock(&journal->j_list_lock);
549		if (!journal->j_checkpoint_transactions) {
550			spin_unlock(&journal->j_list_lock);
551			break;
552		}
553		__jbd2_journal_clean_checkpoint_list(journal, JBD2_SHRINK_DESTROY);
554		spin_unlock(&journal->j_list_lock);
555		cond_resched();
556	}
557}
558
559/*
560 * journal_remove_checkpoint: called after a buffer has been committed
561 * to disk (either by being write-back flushed to disk, or being
562 * committed to the log).
563 *
564 * We cannot safely clean a transaction out of the log until all of the
565 * buffer updates committed in that transaction have safely been stored
566 * elsewhere on disk.  To achieve this, all of the buffers in a
567 * transaction need to be maintained on the transaction's checkpoint
568 * lists until they have been rewritten, at which point this function is
569 * called to remove the buffer from the existing transaction's
570 * checkpoint lists.
571 *
572 * The function returns 1 if it frees the transaction, 0 otherwise.
573 * The function can free jh and bh.
574 *
575 * This function is called with j_list_lock held.
576 */
577int __jbd2_journal_remove_checkpoint(struct journal_head *jh)
578{
579	struct transaction_chp_stats_s *stats;
580	transaction_t *transaction;
581	journal_t *journal;
582
583	JBUFFER_TRACE(jh, "entry");
584
585	transaction = jh->b_cp_transaction;
586	if (!transaction) {
587		JBUFFER_TRACE(jh, "not on transaction");
588		return 0;
589	}
590	journal = transaction->t_journal;
591
592	JBUFFER_TRACE(jh, "removing from transaction");
593
594	__buffer_unlink(jh);
595	jh->b_cp_transaction = NULL;
596	percpu_counter_dec(&journal->j_checkpoint_jh_count);
597	jbd2_journal_put_journal_head(jh);
598
599	/* Is this transaction empty? */
600	if (transaction->t_checkpoint_list)
601		return 0;
602
603	/*
604	 * There is one special case to worry about: if we have just pulled the
605	 * buffer off a running or committing transaction's checkpoing list,
606	 * then even if the checkpoint list is empty, the transaction obviously
607	 * cannot be dropped!
608	 *
609	 * The locking here around t_state is a bit sleazy.
610	 * See the comment at the end of jbd2_journal_commit_transaction().
611	 */
612	if (transaction->t_state != T_FINISHED)
613		return 0;
614
615	/*
616	 * OK, that was the last buffer for the transaction, we can now
617	 * safely remove this transaction from the log.
618	 */
619	stats = &transaction->t_chp_stats;
620	if (stats->cs_chp_time)
621		stats->cs_chp_time = jbd2_time_diff(stats->cs_chp_time,
622						    jiffies);
623	trace_jbd2_checkpoint_stats(journal->j_fs_dev->bd_dev,
624				    transaction->t_tid, stats);
625
626	__jbd2_journal_drop_transaction(journal, transaction);
627	jbd2_journal_free_transaction(transaction);
628	return 1;
629}
630
631/*
632 * Check the checkpoint buffer and try to remove it from the checkpoint
633 * list if it's clean. Returns -EBUSY if it is not clean, returns 1 if
634 * it frees the transaction, 0 otherwise.
635 *
636 * This function is called with j_list_lock held.
637 */
638int jbd2_journal_try_remove_checkpoint(struct journal_head *jh)
639{
640	struct buffer_head *bh = jh2bh(jh);
641
642	if (jh->b_transaction)
643		return -EBUSY;
644	if (!trylock_buffer(bh))
645		return -EBUSY;
646	if (buffer_dirty(bh)) {
647		unlock_buffer(bh);
648		return -EBUSY;
649	}
650	unlock_buffer(bh);
651
652	/*
653	 * Buffer is clean and the IO has finished (we held the buffer
654	 * lock) so the checkpoint is done. We can safely remove the
655	 * buffer from this transaction.
656	 */
657	JBUFFER_TRACE(jh, "remove from checkpoint list");
658	return __jbd2_journal_remove_checkpoint(jh);
659}
660
661/*
662 * journal_insert_checkpoint: put a committed buffer onto a checkpoint
663 * list so that we know when it is safe to clean the transaction out of
664 * the log.
665 *
666 * Called with the journal locked.
667 * Called with j_list_lock held.
668 */
669void __jbd2_journal_insert_checkpoint(struct journal_head *jh,
670			       transaction_t *transaction)
671{
672	JBUFFER_TRACE(jh, "entry");
673	J_ASSERT_JH(jh, buffer_dirty(jh2bh(jh)) || buffer_jbddirty(jh2bh(jh)));
674	J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
675
676	/* Get reference for checkpointing transaction */
677	jbd2_journal_grab_journal_head(jh2bh(jh));
678	jh->b_cp_transaction = transaction;
679
680	if (!transaction->t_checkpoint_list) {
681		jh->b_cpnext = jh->b_cpprev = jh;
682	} else {
683		jh->b_cpnext = transaction->t_checkpoint_list;
684		jh->b_cpprev = transaction->t_checkpoint_list->b_cpprev;
685		jh->b_cpprev->b_cpnext = jh;
686		jh->b_cpnext->b_cpprev = jh;
687	}
688	transaction->t_checkpoint_list = jh;
689	percpu_counter_inc(&transaction->t_journal->j_checkpoint_jh_count);
690}
691
692/*
693 * We've finished with this transaction structure: adios...
694 *
695 * The transaction must have no links except for the checkpoint by this
696 * point.
697 *
698 * Called with the journal locked.
699 * Called with j_list_lock held.
700 */
701
702void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction)
703{
704	assert_spin_locked(&journal->j_list_lock);
705
706	journal->j_shrink_transaction = NULL;
707	if (transaction->t_cpnext) {
708		transaction->t_cpnext->t_cpprev = transaction->t_cpprev;
709		transaction->t_cpprev->t_cpnext = transaction->t_cpnext;
710		if (journal->j_checkpoint_transactions == transaction)
711			journal->j_checkpoint_transactions =
712				transaction->t_cpnext;
713		if (journal->j_checkpoint_transactions == transaction)
714			journal->j_checkpoint_transactions = NULL;
715	}
716
717	J_ASSERT(transaction->t_state == T_FINISHED);
718	J_ASSERT(transaction->t_buffers == NULL);
719	J_ASSERT(transaction->t_forget == NULL);
720	J_ASSERT(transaction->t_shadow_list == NULL);
721	J_ASSERT(transaction->t_checkpoint_list == NULL);
722	J_ASSERT(atomic_read(&transaction->t_updates) == 0);
723	J_ASSERT(journal->j_committing_transaction != transaction);
724	J_ASSERT(journal->j_running_transaction != transaction);
725
726	trace_jbd2_drop_transaction(journal, transaction);
727
728	jbd2_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid);
729}