Merge git://git.kernel.org/pub/scm/linux/kernel/git/hskinnemoen/avr32-2.6
[linux-2.6] / fs / jbd2 / checkpoint.c
1 /*
2  * linux/fs/jbd2/checkpoint.c
3  *
4  * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
5  *
6  * Copyright 1999 Red Hat Software --- All Rights Reserved
7  *
8  * This file is part of the Linux kernel and is made available under
9  * the terms of the GNU General Public License, version 2, or at your
10  * option, any later version, incorporated herein by reference.
11  *
12  * Checkpoint routines for the generic filesystem journaling code.
13  * Part of the ext2fs journaling system.
14  *
15  * Checkpointing is the process of ensuring that a section of the log is
16  * committed fully to disk, so that that portion of the log can be
17  * reused.
18  */
19
20 #include <linux/time.h>
21 #include <linux/fs.h>
22 #include <linux/jbd2.h>
23 #include <linux/marker.h>
24 #include <linux/errno.h>
25 #include <linux/slab.h>
26
27 /*
28  * Unlink a buffer from a transaction checkpoint list.
29  *
30  * Called with j_list_lock held.
31  */
32 static inline void __buffer_unlink_first(struct journal_head *jh)
33 {
34         transaction_t *transaction = jh->b_cp_transaction;
35
36         jh->b_cpnext->b_cpprev = jh->b_cpprev;
37         jh->b_cpprev->b_cpnext = jh->b_cpnext;
38         if (transaction->t_checkpoint_list == jh) {
39                 transaction->t_checkpoint_list = jh->b_cpnext;
40                 if (transaction->t_checkpoint_list == jh)
41                         transaction->t_checkpoint_list = NULL;
42         }
43 }
44
45 /*
46  * Unlink a buffer from a transaction checkpoint(io) list.
47  *
48  * Called with j_list_lock held.
49  */
50 static inline void __buffer_unlink(struct journal_head *jh)
51 {
52         transaction_t *transaction = jh->b_cp_transaction;
53
54         __buffer_unlink_first(jh);
55         if (transaction->t_checkpoint_io_list == jh) {
56                 transaction->t_checkpoint_io_list = jh->b_cpnext;
57                 if (transaction->t_checkpoint_io_list == jh)
58                         transaction->t_checkpoint_io_list = NULL;
59         }
60 }
61
62 /*
63  * Move a buffer from the checkpoint list to the checkpoint io list
64  *
65  * Called with j_list_lock held
66  */
67 static inline void __buffer_relink_io(struct journal_head *jh)
68 {
69         transaction_t *transaction = jh->b_cp_transaction;
70
71         __buffer_unlink_first(jh);
72
73         if (!transaction->t_checkpoint_io_list) {
74                 jh->b_cpnext = jh->b_cpprev = jh;
75         } else {
76                 jh->b_cpnext = transaction->t_checkpoint_io_list;
77                 jh->b_cpprev = transaction->t_checkpoint_io_list->b_cpprev;
78                 jh->b_cpprev->b_cpnext = jh;
79                 jh->b_cpnext->b_cpprev = jh;
80         }
81         transaction->t_checkpoint_io_list = jh;
82 }
83
84 /*
85  * Try to release a checkpointed buffer from its transaction.
86  * Returns 1 if we released it and 2 if we also released the
87  * whole transaction.
88  *
89  * Requires j_list_lock
90  * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
91  */
92 static int __try_to_free_cp_buf(struct journal_head *jh)
93 {
94         int ret = 0;
95         struct buffer_head *bh = jh2bh(jh);
96
97         if (jh->b_jlist == BJ_None && !buffer_locked(bh) && !buffer_dirty(bh)) {
98                 JBUFFER_TRACE(jh, "remove from checkpoint list");
99                 ret = __jbd2_journal_remove_checkpoint(jh) + 1;
100                 jbd_unlock_bh_state(bh);
101                 jbd2_journal_remove_journal_head(bh);
102                 BUFFER_TRACE(bh, "release");
103                 __brelse(bh);
104         } else {
105                 jbd_unlock_bh_state(bh);
106         }
107         return ret;
108 }
109
110 /*
111  * __jbd2_log_wait_for_space: wait until there is space in the journal.
112  *
113  * Called under j-state_lock *only*.  It will be unlocked if we have to wait
114  * for a checkpoint to free up some space in the log.
115  */
116 void __jbd2_log_wait_for_space(journal_t *journal)
117 {
118         int nblocks;
119         assert_spin_locked(&journal->j_state_lock);
120
121         nblocks = jbd_space_needed(journal);
122         while (__jbd2_log_space_left(journal) < nblocks) {
123                 if (journal->j_flags & JBD2_ABORT)
124                         return;
125                 spin_unlock(&journal->j_state_lock);
126                 mutex_lock(&journal->j_checkpoint_mutex);
127
128                 /*
129                  * Test again, another process may have checkpointed while we
130                  * were waiting for the checkpoint lock. If there are no
131                  * outstanding transactions there is nothing to checkpoint and
132                  * we can't make progress. Abort the journal in this case.
133                  */
134                 spin_lock(&journal->j_state_lock);
135                 spin_lock(&journal->j_list_lock);
136                 nblocks = jbd_space_needed(journal);
137                 if (__jbd2_log_space_left(journal) < nblocks) {
138                         int chkpt = journal->j_checkpoint_transactions != NULL;
139
140                         spin_unlock(&journal->j_list_lock);
141                         spin_unlock(&journal->j_state_lock);
142                         if (chkpt) {
143                                 jbd2_log_do_checkpoint(journal);
144                         } else {
145                                 printk(KERN_ERR "%s: no transactions\n",
146                                        __func__);
147                                 jbd2_journal_abort(journal, 0);
148                         }
149
150                         spin_lock(&journal->j_state_lock);
151                 } else {
152                         spin_unlock(&journal->j_list_lock);
153                 }
154                 mutex_unlock(&journal->j_checkpoint_mutex);
155         }
156 }
157
158 /*
159  * We were unable to perform jbd_trylock_bh_state() inside j_list_lock.
160  * The caller must restart a list walk.  Wait for someone else to run
161  * jbd_unlock_bh_state().
162  */
163 static void jbd_sync_bh(journal_t *journal, struct buffer_head *bh)
164         __releases(journal->j_list_lock)
165 {
166         get_bh(bh);
167         spin_unlock(&journal->j_list_lock);
168         jbd_lock_bh_state(bh);
169         jbd_unlock_bh_state(bh);
170         put_bh(bh);
171 }
172
173 /*
174  * Clean up transaction's list of buffers submitted for io.
175  * We wait for any pending IO to complete and remove any clean
176  * buffers. Note that we take the buffers in the opposite ordering
177  * from the one in which they were submitted for IO.
178  *
179  * Called with j_list_lock held.
180  */
181 static void __wait_cp_io(journal_t *journal, transaction_t *transaction)
182 {
183         struct journal_head *jh;
184         struct buffer_head *bh;
185         tid_t this_tid;
186         int released = 0;
187
188         this_tid = transaction->t_tid;
189 restart:
190         /* Did somebody clean up the transaction in the meanwhile? */
191         if (journal->j_checkpoint_transactions != transaction ||
192                         transaction->t_tid != this_tid)
193                 return;
194         while (!released && transaction->t_checkpoint_io_list) {
195                 jh = transaction->t_checkpoint_io_list;
196                 bh = jh2bh(jh);
197                 if (!jbd_trylock_bh_state(bh)) {
198                         jbd_sync_bh(journal, bh);
199                         spin_lock(&journal->j_list_lock);
200                         goto restart;
201                 }
202                 if (buffer_locked(bh)) {
203                         atomic_inc(&bh->b_count);
204                         spin_unlock(&journal->j_list_lock);
205                         jbd_unlock_bh_state(bh);
206                         wait_on_buffer(bh);
207                         /* the journal_head may have gone by now */
208                         BUFFER_TRACE(bh, "brelse");
209                         __brelse(bh);
210                         spin_lock(&journal->j_list_lock);
211                         goto restart;
212                 }
213                 /*
214                  * Now in whatever state the buffer currently is, we know that
215                  * it has been written out and so we can drop it from the list
216                  */
217                 released = __jbd2_journal_remove_checkpoint(jh);
218                 jbd_unlock_bh_state(bh);
219                 jbd2_journal_remove_journal_head(bh);
220                 __brelse(bh);
221         }
222 }
223
224 #define NR_BATCH        64
225
226 static void
227 __flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
228 {
229         int i;
230
231         ll_rw_block(SWRITE, *batch_count, bhs);
232         for (i = 0; i < *batch_count; i++) {
233                 struct buffer_head *bh = bhs[i];
234                 clear_buffer_jwrite(bh);
235                 BUFFER_TRACE(bh, "brelse");
236                 __brelse(bh);
237         }
238         *batch_count = 0;
239 }
240
241 /*
242  * Try to flush one buffer from the checkpoint list to disk.
243  *
244  * Return 1 if something happened which requires us to abort the current
245  * scan of the checkpoint list.
246  *
247  * Called with j_list_lock held and drops it if 1 is returned
248  * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
249  */
250 static int __process_buffer(journal_t *journal, struct journal_head *jh,
251                         struct buffer_head **bhs, int *batch_count,
252                         transaction_t *transaction)
253 {
254         struct buffer_head *bh = jh2bh(jh);
255         int ret = 0;
256
257         if (buffer_locked(bh)) {
258                 atomic_inc(&bh->b_count);
259                 spin_unlock(&journal->j_list_lock);
260                 jbd_unlock_bh_state(bh);
261                 wait_on_buffer(bh);
262                 /* the journal_head may have gone by now */
263                 BUFFER_TRACE(bh, "brelse");
264                 __brelse(bh);
265                 ret = 1;
266         } else if (jh->b_transaction != NULL) {
267                 transaction_t *t = jh->b_transaction;
268                 tid_t tid = t->t_tid;
269
270                 transaction->t_chp_stats.cs_forced_to_close++;
271                 spin_unlock(&journal->j_list_lock);
272                 jbd_unlock_bh_state(bh);
273                 jbd2_log_start_commit(journal, tid);
274                 jbd2_log_wait_commit(journal, tid);
275                 ret = 1;
276         } else if (!buffer_dirty(bh)) {
277                 J_ASSERT_JH(jh, !buffer_jbddirty(bh));
278                 BUFFER_TRACE(bh, "remove from checkpoint");
279                 __jbd2_journal_remove_checkpoint(jh);
280                 spin_unlock(&journal->j_list_lock);
281                 jbd_unlock_bh_state(bh);
282                 jbd2_journal_remove_journal_head(bh);
283                 __brelse(bh);
284                 ret = 1;
285         } else {
286                 /*
287                  * Important: we are about to write the buffer, and
288                  * possibly block, while still holding the journal lock.
289                  * We cannot afford to let the transaction logic start
290                  * messing around with this buffer before we write it to
291                  * disk, as that would break recoverability.
292                  */
293                 BUFFER_TRACE(bh, "queue");
294                 get_bh(bh);
295                 J_ASSERT_BH(bh, !buffer_jwrite(bh));
296                 set_buffer_jwrite(bh);
297                 bhs[*batch_count] = bh;
298                 __buffer_relink_io(jh);
299                 jbd_unlock_bh_state(bh);
300                 transaction->t_chp_stats.cs_written++;
301                 (*batch_count)++;
302                 if (*batch_count == NR_BATCH) {
303                         spin_unlock(&journal->j_list_lock);
304                         __flush_batch(journal, bhs, batch_count);
305                         ret = 1;
306                 }
307         }
308         return ret;
309 }
310
311 /*
312  * Perform an actual checkpoint. We take the first transaction on the
313  * list of transactions to be checkpointed and send all its buffers
314  * to disk. We submit larger chunks of data at once.
315  *
316  * The journal should be locked before calling this function.
317  */
318 int jbd2_log_do_checkpoint(journal_t *journal)
319 {
320         transaction_t *transaction;
321         tid_t this_tid;
322         int result;
323
324         jbd_debug(1, "Start checkpoint\n");
325
326         /*
327          * First thing: if there are any transactions in the log which
328          * don't need checkpointing, just eliminate them from the
329          * journal straight away.
330          */
331         result = jbd2_cleanup_journal_tail(journal);
332         trace_mark(jbd2_checkpoint, "dev %s need_checkpoint %d",
333                    journal->j_devname, result);
334         jbd_debug(1, "cleanup_journal_tail returned %d\n", result);
335         if (result <= 0)
336                 return result;
337
338         /*
339          * OK, we need to start writing disk blocks.  Take one transaction
340          * and write it.
341          */
342         spin_lock(&journal->j_list_lock);
343         if (!journal->j_checkpoint_transactions)
344                 goto out;
345         transaction = journal->j_checkpoint_transactions;
346         if (transaction->t_chp_stats.cs_chp_time == 0)
347                 transaction->t_chp_stats.cs_chp_time = jiffies;
348         this_tid = transaction->t_tid;
349 restart:
350         /*
351          * If someone cleaned up this transaction while we slept, we're
352          * done (maybe it's a new transaction, but it fell at the same
353          * address).
354          */
355         if (journal->j_checkpoint_transactions == transaction &&
356                         transaction->t_tid == this_tid) {
357                 int batch_count = 0;
358                 struct buffer_head *bhs[NR_BATCH];
359                 struct journal_head *jh;
360                 int retry = 0;
361
362                 while (!retry && transaction->t_checkpoint_list) {
363                         struct buffer_head *bh;
364
365                         jh = transaction->t_checkpoint_list;
366                         bh = jh2bh(jh);
367                         if (!jbd_trylock_bh_state(bh)) {
368                                 jbd_sync_bh(journal, bh);
369                                 retry = 1;
370                                 break;
371                         }
372                         retry = __process_buffer(journal, jh, bhs, &batch_count,
373                                                  transaction);
374                         if (!retry && (need_resched() ||
375                                 spin_needbreak(&journal->j_list_lock))) {
376                                 spin_unlock(&journal->j_list_lock);
377                                 retry = 1;
378                                 break;
379                         }
380                 }
381
382                 if (batch_count) {
383                         if (!retry) {
384                                 spin_unlock(&journal->j_list_lock);
385                                 retry = 1;
386                         }
387                         __flush_batch(journal, bhs, &batch_count);
388                 }
389
390                 if (retry) {
391                         spin_lock(&journal->j_list_lock);
392                         goto restart;
393                 }
394                 /*
395                  * Now we have cleaned up the first transaction's checkpoint
396                  * list. Let's clean up the second one
397                  */
398                 __wait_cp_io(journal, transaction);
399         }
400 out:
401         spin_unlock(&journal->j_list_lock);
402         result = jbd2_cleanup_journal_tail(journal);
403         if (result < 0)
404                 return result;
405         return 0;
406 }
407
408 /*
409  * Check the list of checkpoint transactions for the journal to see if
410  * we have already got rid of any since the last update of the log tail
411  * in the journal superblock.  If so, we can instantly roll the
412  * superblock forward to remove those transactions from the log.
413  *
414  * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
415  *
416  * Called with the journal lock held.
417  *
418  * This is the only part of the journaling code which really needs to be
419  * aware of transaction aborts.  Checkpointing involves writing to the
420  * main filesystem area rather than to the journal, so it can proceed
421  * even in abort state, but we must not update the journal superblock if
422  * we have an abort error outstanding.
423  */
424
425 int jbd2_cleanup_journal_tail(journal_t *journal)
426 {
427         transaction_t * transaction;
428         tid_t           first_tid;
429         unsigned long   blocknr, freed;
430
431         /* OK, work out the oldest transaction remaining in the log, and
432          * the log block it starts at.
433          *
434          * If the log is now empty, we need to work out which is the
435          * next transaction ID we will write, and where it will
436          * start. */
437
438         spin_lock(&journal->j_state_lock);
439         spin_lock(&journal->j_list_lock);
440         transaction = journal->j_checkpoint_transactions;
441         if (transaction) {
442                 first_tid = transaction->t_tid;
443                 blocknr = transaction->t_log_start;
444         } else if ((transaction = journal->j_committing_transaction) != NULL) {
445                 first_tid = transaction->t_tid;
446                 blocknr = transaction->t_log_start;
447         } else if ((transaction = journal->j_running_transaction) != NULL) {
448                 first_tid = transaction->t_tid;
449                 blocknr = journal->j_head;
450         } else {
451                 first_tid = journal->j_transaction_sequence;
452                 blocknr = journal->j_head;
453         }
454         spin_unlock(&journal->j_list_lock);
455         J_ASSERT(blocknr != 0);
456
457         /* If the oldest pinned transaction is at the tail of the log
458            already then there's not much we can do right now. */
459         if (journal->j_tail_sequence == first_tid) {
460                 spin_unlock(&journal->j_state_lock);
461                 return 1;
462         }
463
464         /* OK, update the superblock to recover the freed space.
465          * Physical blocks come first: have we wrapped beyond the end of
466          * the log?  */
467         freed = blocknr - journal->j_tail;
468         if (blocknr < journal->j_tail)
469                 freed = freed + journal->j_last - journal->j_first;
470
471         jbd_debug(1,
472                   "Cleaning journal tail from %d to %d (offset %lu), "
473                   "freeing %lu\n",
474                   journal->j_tail_sequence, first_tid, blocknr, freed);
475
476         journal->j_free += freed;
477         journal->j_tail_sequence = first_tid;
478         journal->j_tail = blocknr;
479         spin_unlock(&journal->j_state_lock);
480         if (!(journal->j_flags & JBD2_ABORT))
481                 jbd2_journal_update_superblock(journal, 1);
482         return 0;
483 }
484
485
486 /* Checkpoint list management */
487
488 /*
489  * journal_clean_one_cp_list
490  *
491  * Find all the written-back checkpoint buffers in the given list and release them.
492  *
493  * Called with the journal locked.
494  * Called with j_list_lock held.
495  * Returns number of bufers reaped (for debug)
496  */
497
498 static int journal_clean_one_cp_list(struct journal_head *jh, int *released)
499 {
500         struct journal_head *last_jh;
501         struct journal_head *next_jh = jh;
502         int ret, freed = 0;
503
504         *released = 0;
505         if (!jh)
506                 return 0;
507
508         last_jh = jh->b_cpprev;
509         do {
510                 jh = next_jh;
511                 next_jh = jh->b_cpnext;
512                 /* Use trylock because of the ranking */
513                 if (jbd_trylock_bh_state(jh2bh(jh))) {
514                         ret = __try_to_free_cp_buf(jh);
515                         if (ret) {
516                                 freed++;
517                                 if (ret == 2) {
518                                         *released = 1;
519                                         return freed;
520                                 }
521                         }
522                 }
523                 /*
524                  * This function only frees up some memory
525                  * if possible so we dont have an obligation
526                  * to finish processing. Bail out if preemption
527                  * requested:
528                  */
529                 if (need_resched())
530                         return freed;
531         } while (jh != last_jh);
532
533         return freed;
534 }
535
536 /*
537  * journal_clean_checkpoint_list
538  *
539  * Find all the written-back checkpoint buffers in the journal and release them.
540  *
541  * Called with the journal locked.
542  * Called with j_list_lock held.
543  * Returns number of buffers reaped (for debug)
544  */
545
546 int __jbd2_journal_clean_checkpoint_list(journal_t *journal)
547 {
548         transaction_t *transaction, *last_transaction, *next_transaction;
549         int ret = 0;
550         int released;
551
552         transaction = journal->j_checkpoint_transactions;
553         if (!transaction)
554                 goto out;
555
556         last_transaction = transaction->t_cpprev;
557         next_transaction = transaction;
558         do {
559                 transaction = next_transaction;
560                 next_transaction = transaction->t_cpnext;
561                 ret += journal_clean_one_cp_list(transaction->
562                                 t_checkpoint_list, &released);
563                 /*
564                  * This function only frees up some memory if possible so we
565                  * dont have an obligation to finish processing. Bail out if
566                  * preemption requested:
567                  */
568                 if (need_resched())
569                         goto out;
570                 if (released)
571                         continue;
572                 /*
573                  * It is essential that we are as careful as in the case of
574                  * t_checkpoint_list with removing the buffer from the list as
575                  * we can possibly see not yet submitted buffers on io_list
576                  */
577                 ret += journal_clean_one_cp_list(transaction->
578                                 t_checkpoint_io_list, &released);
579                 if (need_resched())
580                         goto out;
581         } while (transaction != last_transaction);
582 out:
583         return ret;
584 }
585
586 /*
587  * journal_remove_checkpoint: called after a buffer has been committed
588  * to disk (either by being write-back flushed to disk, or being
589  * committed to the log).
590  *
591  * We cannot safely clean a transaction out of the log until all of the
592  * buffer updates committed in that transaction have safely been stored
593  * elsewhere on disk.  To achieve this, all of the buffers in a
594  * transaction need to be maintained on the transaction's checkpoint
595  * lists until they have been rewritten, at which point this function is
596  * called to remove the buffer from the existing transaction's
597  * checkpoint lists.
598  *
599  * The function returns 1 if it frees the transaction, 0 otherwise.
600  *
601  * This function is called with the journal locked.
602  * This function is called with j_list_lock held.
603  * This function is called with jbd_lock_bh_state(jh2bh(jh))
604  */
605
606 int __jbd2_journal_remove_checkpoint(struct journal_head *jh)
607 {
608         transaction_t *transaction;
609         journal_t *journal;
610         int ret = 0;
611
612         JBUFFER_TRACE(jh, "entry");
613
614         if ((transaction = jh->b_cp_transaction) == NULL) {
615                 JBUFFER_TRACE(jh, "not on transaction");
616                 goto out;
617         }
618         journal = transaction->t_journal;
619
620         __buffer_unlink(jh);
621         jh->b_cp_transaction = NULL;
622
623         if (transaction->t_checkpoint_list != NULL ||
624             transaction->t_checkpoint_io_list != NULL)
625                 goto out;
626         JBUFFER_TRACE(jh, "transaction has no more buffers");
627
628         /*
629          * There is one special case to worry about: if we have just pulled the
630          * buffer off a running or committing transaction's checkpoing list,
631          * then even if the checkpoint list is empty, the transaction obviously
632          * cannot be dropped!
633          *
634          * The locking here around t_state is a bit sleazy.
635          * See the comment at the end of jbd2_journal_commit_transaction().
636          */
637         if (transaction->t_state != T_FINISHED) {
638                 JBUFFER_TRACE(jh, "belongs to running/committing transaction");
639                 goto out;
640         }
641
642         /* OK, that was the last buffer for the transaction: we can now
643            safely remove this transaction from the log */
644
645         __jbd2_journal_drop_transaction(journal, transaction);
646
647         /* Just in case anybody was waiting for more transactions to be
648            checkpointed... */
649         wake_up(&journal->j_wait_logspace);
650         ret = 1;
651 out:
652         JBUFFER_TRACE(jh, "exit");
653         return ret;
654 }
655
656 /*
657  * journal_insert_checkpoint: put a committed buffer onto a checkpoint
658  * list so that we know when it is safe to clean the transaction out of
659  * the log.
660  *
661  * Called with the journal locked.
662  * Called with j_list_lock held.
663  */
664 void __jbd2_journal_insert_checkpoint(struct journal_head *jh,
665                                transaction_t *transaction)
666 {
667         JBUFFER_TRACE(jh, "entry");
668         J_ASSERT_JH(jh, buffer_dirty(jh2bh(jh)) || buffer_jbddirty(jh2bh(jh)));
669         J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
670
671         jh->b_cp_transaction = transaction;
672
673         if (!transaction->t_checkpoint_list) {
674                 jh->b_cpnext = jh->b_cpprev = jh;
675         } else {
676                 jh->b_cpnext = transaction->t_checkpoint_list;
677                 jh->b_cpprev = transaction->t_checkpoint_list->b_cpprev;
678                 jh->b_cpprev->b_cpnext = jh;
679                 jh->b_cpnext->b_cpprev = jh;
680         }
681         transaction->t_checkpoint_list = jh;
682 }
683
684 /*
685  * We've finished with this transaction structure: adios...
686  *
687  * The transaction must have no links except for the checkpoint by this
688  * point.
689  *
690  * Called with the journal locked.
691  * Called with j_list_lock held.
692  */
693
694 void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction)
695 {
696         assert_spin_locked(&journal->j_list_lock);
697         if (transaction->t_cpnext) {
698                 transaction->t_cpnext->t_cpprev = transaction->t_cpprev;
699                 transaction->t_cpprev->t_cpnext = transaction->t_cpnext;
700                 if (journal->j_checkpoint_transactions == transaction)
701                         journal->j_checkpoint_transactions =
702                                 transaction->t_cpnext;
703                 if (journal->j_checkpoint_transactions == transaction)
704                         journal->j_checkpoint_transactions = NULL;
705         }
706
707         J_ASSERT(transaction->t_state == T_FINISHED);
708         J_ASSERT(transaction->t_buffers == NULL);
709         J_ASSERT(transaction->t_forget == NULL);
710         J_ASSERT(transaction->t_iobuf_list == NULL);
711         J_ASSERT(transaction->t_shadow_list == NULL);
712         J_ASSERT(transaction->t_log_list == NULL);
713         J_ASSERT(transaction->t_checkpoint_list == NULL);
714         J_ASSERT(transaction->t_checkpoint_io_list == NULL);
715         J_ASSERT(transaction->t_updates == 0);
716         J_ASSERT(journal->j_committing_transaction != transaction);
717         J_ASSERT(journal->j_running_transaction != transaction);
718
719         jbd_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid);
720         kfree(transaction);
721 }