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