jbd: Fix oops in journal_remove_journal_head()
[linux-2.6.git] / fs / jbd / checkpoint.c
1 /*
2  * linux/fs/jbd/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/jbd.h>
23 #include <linux/errno.h>
24 #include <linux/slab.h>
25 #include <trace/events/jbd.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) &&
98             !buffer_dirty(bh) && !buffer_write_io_error(bh)) {
99                 /*
100                  * Get our reference so that bh cannot be freed before
101                  * we unlock it
102                  */
103                 get_bh(bh);
104                 JBUFFER_TRACE(jh, "remove from checkpoint list");
105                 ret = __journal_remove_checkpoint(jh) + 1;
106                 jbd_unlock_bh_state(bh);
107                 BUFFER_TRACE(bh, "release");
108                 __brelse(bh);
109         } else {
110                 jbd_unlock_bh_state(bh);
111         }
112         return ret;
113 }
114
115 /*
116  * __log_wait_for_space: wait until there is space in the journal.
117  *
118  * Called under j-state_lock *only*.  It will be unlocked if we have to wait
119  * for a checkpoint to free up some space in the log.
120  */
121 void __log_wait_for_space(journal_t *journal)
122 {
123         int nblocks, space_left;
124         assert_spin_locked(&journal->j_state_lock);
125
126         nblocks = jbd_space_needed(journal);
127         while (__log_space_left(journal) < nblocks) {
128                 if (journal->j_flags & JFS_ABORT)
129                         return;
130                 spin_unlock(&journal->j_state_lock);
131                 mutex_lock(&journal->j_checkpoint_mutex);
132
133                 /*
134                  * Test again, another process may have checkpointed while we
135                  * were waiting for the checkpoint lock. If there are no
136                  * transactions ready to be checkpointed, try to recover
137                  * journal space by calling cleanup_journal_tail(), and if
138                  * that doesn't work, by waiting for the currently committing
139                  * transaction to complete.  If there is absolutely no way
140                  * to make progress, this is either a BUG or corrupted
141                  * filesystem, so abort the journal and leave a stack
142                  * trace for forensic evidence.
143                  */
144                 spin_lock(&journal->j_state_lock);
145                 spin_lock(&journal->j_list_lock);
146                 nblocks = jbd_space_needed(journal);
147                 space_left = __log_space_left(journal);
148                 if (space_left < nblocks) {
149                         int chkpt = journal->j_checkpoint_transactions != NULL;
150                         tid_t tid = 0;
151
152                         if (journal->j_committing_transaction)
153                                 tid = journal->j_committing_transaction->t_tid;
154                         spin_unlock(&journal->j_list_lock);
155                         spin_unlock(&journal->j_state_lock);
156                         if (chkpt) {
157                                 log_do_checkpoint(journal);
158                         } else if (cleanup_journal_tail(journal) == 0) {
159                                 /* We were able to recover space; yay! */
160                                 ;
161                         } else if (tid) {
162                                 log_wait_commit(journal, tid);
163                         } else {
164                                 printk(KERN_ERR "%s: needed %d blocks and "
165                                        "only had %d space available\n",
166                                        __func__, nblocks, space_left);
167                                 printk(KERN_ERR "%s: no way to get more "
168                                        "journal space\n", __func__);
169                                 WARN_ON(1);
170                                 journal_abort(journal, 0);
171                         }
172                         spin_lock(&journal->j_state_lock);
173                 } else {
174                         spin_unlock(&journal->j_list_lock);
175                 }
176                 mutex_unlock(&journal->j_checkpoint_mutex);
177         }
178 }
179
180 /*
181  * We were unable to perform jbd_trylock_bh_state() inside j_list_lock.
182  * The caller must restart a list walk.  Wait for someone else to run
183  * jbd_unlock_bh_state().
184  */
185 static void jbd_sync_bh(journal_t *journal, struct buffer_head *bh)
186         __releases(journal->j_list_lock)
187 {
188         get_bh(bh);
189         spin_unlock(&journal->j_list_lock);
190         jbd_lock_bh_state(bh);
191         jbd_unlock_bh_state(bh);
192         put_bh(bh);
193 }
194
195 /*
196  * Clean up transaction's list of buffers submitted for io.
197  * We wait for any pending IO to complete and remove any clean
198  * buffers. Note that we take the buffers in the opposite ordering
199  * from the one in which they were submitted for IO.
200  *
201  * Return 0 on success, and return <0 if some buffers have failed
202  * to be written out.
203  *
204  * Called with j_list_lock held.
205  */
206 static int __wait_cp_io(journal_t *journal, transaction_t *transaction)
207 {
208         struct journal_head *jh;
209         struct buffer_head *bh;
210         tid_t this_tid;
211         int released = 0;
212         int ret = 0;
213
214         this_tid = transaction->t_tid;
215 restart:
216         /* Did somebody clean up the transaction in the meanwhile? */
217         if (journal->j_checkpoint_transactions != transaction ||
218                         transaction->t_tid != this_tid)
219                 return ret;
220         while (!released && transaction->t_checkpoint_io_list) {
221                 jh = transaction->t_checkpoint_io_list;
222                 bh = jh2bh(jh);
223                 if (!jbd_trylock_bh_state(bh)) {
224                         jbd_sync_bh(journal, bh);
225                         spin_lock(&journal->j_list_lock);
226                         goto restart;
227                 }
228                 get_bh(bh);
229                 if (buffer_locked(bh)) {
230                         spin_unlock(&journal->j_list_lock);
231                         jbd_unlock_bh_state(bh);
232                         wait_on_buffer(bh);
233                         /* the journal_head may have gone by now */
234                         BUFFER_TRACE(bh, "brelse");
235                         __brelse(bh);
236                         spin_lock(&journal->j_list_lock);
237                         goto restart;
238                 }
239                 if (unlikely(buffer_write_io_error(bh)))
240                         ret = -EIO;
241
242                 /*
243                  * Now in whatever state the buffer currently is, we know that
244                  * it has been written out and so we can drop it from the list
245                  */
246                 released = __journal_remove_checkpoint(jh);
247                 jbd_unlock_bh_state(bh);
248                 __brelse(bh);
249         }
250
251         return ret;
252 }
253
254 #define NR_BATCH        64
255
256 static void
257 __flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
258 {
259         int i;
260
261         for (i = 0; i < *batch_count; i++)
262                 write_dirty_buffer(bhs[i], WRITE);
263
264         for (i = 0; i < *batch_count; i++) {
265                 struct buffer_head *bh = bhs[i];
266                 clear_buffer_jwrite(bh);
267                 BUFFER_TRACE(bh, "brelse");
268                 __brelse(bh);
269         }
270         *batch_count = 0;
271 }
272
273 /*
274  * Try to flush one buffer from the checkpoint list to disk.
275  *
276  * Return 1 if something happened which requires us to abort the current
277  * scan of the checkpoint list.  Return <0 if the buffer has failed to
278  * be written out.
279  *
280  * Called with j_list_lock held and drops it if 1 is returned
281  * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
282  */
283 static int __process_buffer(journal_t *journal, struct journal_head *jh,
284                         struct buffer_head **bhs, int *batch_count)
285 {
286         struct buffer_head *bh = jh2bh(jh);
287         int ret = 0;
288
289         if (buffer_locked(bh)) {
290                 get_bh(bh);
291                 spin_unlock(&journal->j_list_lock);
292                 jbd_unlock_bh_state(bh);
293                 wait_on_buffer(bh);
294                 /* the journal_head may have gone by now */
295                 BUFFER_TRACE(bh, "brelse");
296                 __brelse(bh);
297                 ret = 1;
298         } else if (jh->b_transaction != NULL) {
299                 transaction_t *t = jh->b_transaction;
300                 tid_t tid = t->t_tid;
301
302                 spin_unlock(&journal->j_list_lock);
303                 jbd_unlock_bh_state(bh);
304                 log_start_commit(journal, tid);
305                 log_wait_commit(journal, tid);
306                 ret = 1;
307         } else if (!buffer_dirty(bh)) {
308                 ret = 1;
309                 if (unlikely(buffer_write_io_error(bh)))
310                         ret = -EIO;
311                 get_bh(bh);
312                 J_ASSERT_JH(jh, !buffer_jbddirty(bh));
313                 BUFFER_TRACE(bh, "remove from checkpoint");
314                 __journal_remove_checkpoint(jh);
315                 spin_unlock(&journal->j_list_lock);
316                 jbd_unlock_bh_state(bh);
317                 __brelse(bh);
318         } else {
319                 /*
320                  * Important: we are about to write the buffer, and
321                  * possibly block, while still holding the journal lock.
322                  * We cannot afford to let the transaction logic start
323                  * messing around with this buffer before we write it to
324                  * disk, as that would break recoverability.
325                  */
326                 BUFFER_TRACE(bh, "queue");
327                 get_bh(bh);
328                 J_ASSERT_BH(bh, !buffer_jwrite(bh));
329                 set_buffer_jwrite(bh);
330                 bhs[*batch_count] = bh;
331                 __buffer_relink_io(jh);
332                 jbd_unlock_bh_state(bh);
333                 (*batch_count)++;
334                 if (*batch_count == NR_BATCH) {
335                         spin_unlock(&journal->j_list_lock);
336                         __flush_batch(journal, bhs, batch_count);
337                         ret = 1;
338                 }
339         }
340         return ret;
341 }
342
343 /*
344  * Perform an actual checkpoint. We take the first transaction on the
345  * list of transactions to be checkpointed and send all its buffers
346  * to disk. We submit larger chunks of data at once.
347  *
348  * The journal should be locked before calling this function.
349  * Called with j_checkpoint_mutex held.
350  */
351 int log_do_checkpoint(journal_t *journal)
352 {
353         transaction_t *transaction;
354         tid_t this_tid;
355         int result;
356
357         jbd_debug(1, "Start checkpoint\n");
358
359         /*
360          * First thing: if there are any transactions in the log which
361          * don't need checkpointing, just eliminate them from the
362          * journal straight away.
363          */
364         result = cleanup_journal_tail(journal);
365         trace_jbd_checkpoint(journal, result);
366         jbd_debug(1, "cleanup_journal_tail returned %d\n", result);
367         if (result <= 0)
368                 return result;
369
370         /*
371          * OK, we need to start writing disk blocks.  Take one transaction
372          * and write it.
373          */
374         result = 0;
375         spin_lock(&journal->j_list_lock);
376         if (!journal->j_checkpoint_transactions)
377                 goto out;
378         transaction = journal->j_checkpoint_transactions;
379         this_tid = transaction->t_tid;
380 restart:
381         /*
382          * If someone cleaned up this transaction while we slept, we're
383          * done (maybe it's a new transaction, but it fell at the same
384          * address).
385          */
386         if (journal->j_checkpoint_transactions == transaction &&
387                         transaction->t_tid == this_tid) {
388                 int batch_count = 0;
389                 struct buffer_head *bhs[NR_BATCH];
390                 struct journal_head *jh;
391                 int retry = 0, err;
392
393                 while (!retry && transaction->t_checkpoint_list) {
394                         struct buffer_head *bh;
395
396                         jh = transaction->t_checkpoint_list;
397                         bh = jh2bh(jh);
398                         if (!jbd_trylock_bh_state(bh)) {
399                                 jbd_sync_bh(journal, bh);
400                                 retry = 1;
401                                 break;
402                         }
403                         retry = __process_buffer(journal, jh, bhs,&batch_count);
404                         if (retry < 0 && !result)
405                                 result = retry;
406                         if (!retry && (need_resched() ||
407                                 spin_needbreak(&journal->j_list_lock))) {
408                                 spin_unlock(&journal->j_list_lock);
409                                 retry = 1;
410                                 break;
411                         }
412                 }
413
414                 if (batch_count) {
415                         if (!retry) {
416                                 spin_unlock(&journal->j_list_lock);
417                                 retry = 1;
418                         }
419                         __flush_batch(journal, bhs, &batch_count);
420                 }
421
422                 if (retry) {
423                         spin_lock(&journal->j_list_lock);
424                         goto restart;
425                 }
426                 /*
427                  * Now we have cleaned up the first transaction's checkpoint
428                  * list. Let's clean up the second one
429                  */
430                 err = __wait_cp_io(journal, transaction);
431                 if (!result)
432                         result = err;
433         }
434 out:
435         spin_unlock(&journal->j_list_lock);
436         if (result < 0)
437                 journal_abort(journal, result);
438         else
439                 result = cleanup_journal_tail(journal);
440
441         return (result < 0) ? result : 0;
442 }
443
444 /*
445  * Check the list of checkpoint transactions for the journal to see if
446  * we have already got rid of any since the last update of the log tail
447  * in the journal superblock.  If so, we can instantly roll the
448  * superblock forward to remove those transactions from the log.
449  *
450  * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
451  *
452  * Called with the journal lock held.
453  *
454  * This is the only part of the journaling code which really needs to be
455  * aware of transaction aborts.  Checkpointing involves writing to the
456  * main filesystem area rather than to the journal, so it can proceed
457  * even in abort state, but we must not update the super block if
458  * checkpointing may have failed.  Otherwise, we would lose some metadata
459  * buffers which should be written-back to the filesystem.
460  */
461
462 int cleanup_journal_tail(journal_t *journal)
463 {
464         transaction_t * transaction;
465         tid_t           first_tid;
466         unsigned int    blocknr, freed;
467
468         if (is_journal_aborted(journal))
469                 return 1;
470
471         /* OK, work out the oldest transaction remaining in the log, and
472          * the log block it starts at.
473          *
474          * If the log is now empty, we need to work out which is the
475          * next transaction ID we will write, and where it will
476          * start. */
477
478         spin_lock(&journal->j_state_lock);
479         spin_lock(&journal->j_list_lock);
480         transaction = journal->j_checkpoint_transactions;
481         if (transaction) {
482                 first_tid = transaction->t_tid;
483                 blocknr = transaction->t_log_start;
484         } else if ((transaction = journal->j_committing_transaction) != NULL) {
485                 first_tid = transaction->t_tid;
486                 blocknr = transaction->t_log_start;
487         } else if ((transaction = journal->j_running_transaction) != NULL) {
488                 first_tid = transaction->t_tid;
489                 blocknr = journal->j_head;
490         } else {
491                 first_tid = journal->j_transaction_sequence;
492                 blocknr = journal->j_head;
493         }
494         spin_unlock(&journal->j_list_lock);
495         J_ASSERT(blocknr != 0);
496
497         /* If the oldest pinned transaction is at the tail of the log
498            already then there's not much we can do right now. */
499         if (journal->j_tail_sequence == first_tid) {
500                 spin_unlock(&journal->j_state_lock);
501                 return 1;
502         }
503
504         /* OK, update the superblock to recover the freed space.
505          * Physical blocks come first: have we wrapped beyond the end of
506          * the log?  */
507         freed = blocknr - journal->j_tail;
508         if (blocknr < journal->j_tail)
509                 freed = freed + journal->j_last - journal->j_first;
510
511         trace_jbd_cleanup_journal_tail(journal, first_tid, blocknr, freed);
512         jbd_debug(1,
513                   "Cleaning journal tail from %d to %d (offset %u), "
514                   "freeing %u\n",
515                   journal->j_tail_sequence, first_tid, blocknr, freed);
516
517         journal->j_free += freed;
518         journal->j_tail_sequence = first_tid;
519         journal->j_tail = blocknr;
520         spin_unlock(&journal->j_state_lock);
521         if (!(journal->j_flags & JFS_ABORT))
522                 journal_update_superblock(journal, 1);
523         return 0;
524 }
525
526
527 /* Checkpoint list management */
528
529 /*
530  * journal_clean_one_cp_list
531  *
532  * Find all the written-back checkpoint buffers in the given list and release
533  * them.
534  *
535  * Called with j_list_lock held.
536  * Returns number of bufers reaped (for debug)
537  */
538
539 static int journal_clean_one_cp_list(struct journal_head *jh, int *released)
540 {
541         struct journal_head *last_jh;
542         struct journal_head *next_jh = jh;
543         int ret, freed = 0;
544
545         *released = 0;
546         if (!jh)
547                 return 0;
548
549         last_jh = jh->b_cpprev;
550         do {
551                 jh = next_jh;
552                 next_jh = jh->b_cpnext;
553                 /* Use trylock because of the ranking */
554                 if (jbd_trylock_bh_state(jh2bh(jh))) {
555                         ret = __try_to_free_cp_buf(jh);
556                         if (ret) {
557                                 freed++;
558                                 if (ret == 2) {
559                                         *released = 1;
560                                         return freed;
561                                 }
562                         }
563                 }
564                 /*
565                  * This function only frees up some memory
566                  * if possible so we dont have an obligation
567                  * to finish processing. Bail out if preemption
568                  * requested:
569                  */
570                 if (need_resched())
571                         return freed;
572         } while (jh != last_jh);
573
574         return freed;
575 }
576
577 /*
578  * journal_clean_checkpoint_list
579  *
580  * Find all the written-back checkpoint buffers in the journal and release them.
581  *
582  * Called with the journal locked.
583  * Called with j_list_lock held.
584  * Returns number of buffers reaped (for debug)
585  */
586
587 int __journal_clean_checkpoint_list(journal_t *journal)
588 {
589         transaction_t *transaction, *last_transaction, *next_transaction;
590         int ret = 0;
591         int released;
592
593         transaction = journal->j_checkpoint_transactions;
594         if (!transaction)
595                 goto out;
596
597         last_transaction = transaction->t_cpprev;
598         next_transaction = transaction;
599         do {
600                 transaction = next_transaction;
601                 next_transaction = transaction->t_cpnext;
602                 ret += journal_clean_one_cp_list(transaction->
603                                 t_checkpoint_list, &released);
604                 /*
605                  * This function only frees up some memory if possible so we
606                  * dont have an obligation to finish processing. Bail out if
607                  * preemption requested:
608                  */
609                 if (need_resched())
610                         goto out;
611                 if (released)
612                         continue;
613                 /*
614                  * It is essential that we are as careful as in the case of
615                  * t_checkpoint_list with removing the buffer from the list as
616                  * we can possibly see not yet submitted buffers on io_list
617                  */
618                 ret += journal_clean_one_cp_list(transaction->
619                                 t_checkpoint_io_list, &released);
620                 if (need_resched())
621                         goto out;
622         } while (transaction != last_transaction);
623 out:
624         return ret;
625 }
626
627 /*
628  * journal_remove_checkpoint: called after a buffer has been committed
629  * to disk (either by being write-back flushed to disk, or being
630  * committed to the log).
631  *
632  * We cannot safely clean a transaction out of the log until all of the
633  * buffer updates committed in that transaction have safely been stored
634  * elsewhere on disk.  To achieve this, all of the buffers in a
635  * transaction need to be maintained on the transaction's checkpoint
636  * lists until they have been rewritten, at which point this function is
637  * called to remove the buffer from the existing transaction's
638  * checkpoint lists.
639  *
640  * The function returns 1 if it frees the transaction, 0 otherwise.
641  * The function can free jh and bh.
642  *
643  * This function is called with j_list_lock held.
644  * This function is called with jbd_lock_bh_state(jh2bh(jh))
645  */
646
647 int __journal_remove_checkpoint(struct journal_head *jh)
648 {
649         transaction_t *transaction;
650         journal_t *journal;
651         int ret = 0;
652
653         JBUFFER_TRACE(jh, "entry");
654
655         if ((transaction = jh->b_cp_transaction) == NULL) {
656                 JBUFFER_TRACE(jh, "not on transaction");
657                 goto out;
658         }
659         journal = transaction->t_journal;
660
661         JBUFFER_TRACE(jh, "removing from transaction");
662         __buffer_unlink(jh);
663         jh->b_cp_transaction = NULL;
664         journal_put_journal_head(jh);
665
666         if (transaction->t_checkpoint_list != NULL ||
667             transaction->t_checkpoint_io_list != NULL)
668                 goto out;
669
670         /*
671          * There is one special case to worry about: if we have just pulled the
672          * buffer off a running or committing transaction's checkpoing list,
673          * then even if the checkpoint list is empty, the transaction obviously
674          * cannot be dropped!
675          *
676          * The locking here around t_state is a bit sleazy.
677          * See the comment at the end of journal_commit_transaction().
678          */
679         if (transaction->t_state != T_FINISHED)
680                 goto out;
681
682         /* OK, that was the last buffer for the transaction: we can now
683            safely remove this transaction from the log */
684
685         __journal_drop_transaction(journal, transaction);
686
687         /* Just in case anybody was waiting for more transactions to be
688            checkpointed... */
689         wake_up(&journal->j_wait_logspace);
690         ret = 1;
691 out:
692         return ret;
693 }
694
695 /*
696  * journal_insert_checkpoint: put a committed buffer onto a checkpoint
697  * list so that we know when it is safe to clean the transaction out of
698  * the log.
699  *
700  * Called with the journal locked.
701  * Called with j_list_lock held.
702  */
703 void __journal_insert_checkpoint(struct journal_head *jh,
704                                transaction_t *transaction)
705 {
706         JBUFFER_TRACE(jh, "entry");
707         J_ASSERT_JH(jh, buffer_dirty(jh2bh(jh)) || buffer_jbddirty(jh2bh(jh)));
708         J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
709
710         /* Get reference for checkpointing transaction */
711         journal_grab_journal_head(jh2bh(jh));
712         jh->b_cp_transaction = transaction;
713
714         if (!transaction->t_checkpoint_list) {
715                 jh->b_cpnext = jh->b_cpprev = jh;
716         } else {
717                 jh->b_cpnext = transaction->t_checkpoint_list;
718                 jh->b_cpprev = transaction->t_checkpoint_list->b_cpprev;
719                 jh->b_cpprev->b_cpnext = jh;
720                 jh->b_cpnext->b_cpprev = jh;
721         }
722         transaction->t_checkpoint_list = jh;
723 }
724
725 /*
726  * We've finished with this transaction structure: adios...
727  *
728  * The transaction must have no links except for the checkpoint by this
729  * point.
730  *
731  * Called with the journal locked.
732  * Called with j_list_lock held.
733  */
734
735 void __journal_drop_transaction(journal_t *journal, transaction_t *transaction)
736 {
737         assert_spin_locked(&journal->j_list_lock);
738         if (transaction->t_cpnext) {
739                 transaction->t_cpnext->t_cpprev = transaction->t_cpprev;
740                 transaction->t_cpprev->t_cpnext = transaction->t_cpnext;
741                 if (journal->j_checkpoint_transactions == transaction)
742                         journal->j_checkpoint_transactions =
743                                 transaction->t_cpnext;
744                 if (journal->j_checkpoint_transactions == transaction)
745                         journal->j_checkpoint_transactions = NULL;
746         }
747
748         J_ASSERT(transaction->t_state == T_FINISHED);
749         J_ASSERT(transaction->t_buffers == NULL);
750         J_ASSERT(transaction->t_sync_datalist == NULL);
751         J_ASSERT(transaction->t_forget == NULL);
752         J_ASSERT(transaction->t_iobuf_list == NULL);
753         J_ASSERT(transaction->t_shadow_list == NULL);
754         J_ASSERT(transaction->t_log_list == NULL);
755         J_ASSERT(transaction->t_checkpoint_list == NULL);
756         J_ASSERT(transaction->t_checkpoint_io_list == NULL);
757         J_ASSERT(transaction->t_updates == 0);
758         J_ASSERT(journal->j_committing_transaction != transaction);
759         J_ASSERT(journal->j_running_transaction != transaction);
760
761         trace_jbd_drop_transaction(journal, transaction);
762         jbd_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid);
763         kfree(transaction);
764 }