2 * linux/fs/jbd2/checkpoint.c
4 * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
6 * Copyright 1999 Red Hat Software --- All Rights Reserved
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.
12 * Checkpoint routines for the generic filesystem journaling code.
13 * Part of the ext2fs journaling system.
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
20 #include <linux/time.h>
22 #include <linux/jbd2.h>
23 #include <linux/errno.h>
24 #include <linux/slab.h>
25 #include <linux/blkdev.h>
26 #include <trace/events/jbd2.h>
29 * Unlink a buffer from a transaction checkpoint list.
31 * Called with j_list_lock held.
33 static inline void __buffer_unlink_first(struct journal_head
*jh
)
35 transaction_t
*transaction
= jh
->b_cp_transaction
;
37 jh
->b_cpnext
->b_cpprev
= jh
->b_cpprev
;
38 jh
->b_cpprev
->b_cpnext
= jh
->b_cpnext
;
39 if (transaction
->t_checkpoint_list
== jh
) {
40 transaction
->t_checkpoint_list
= jh
->b_cpnext
;
41 if (transaction
->t_checkpoint_list
== jh
)
42 transaction
->t_checkpoint_list
= NULL
;
47 * Unlink a buffer from a transaction checkpoint(io) list.
49 * Called with j_list_lock held.
51 static inline void __buffer_unlink(struct journal_head
*jh
)
53 transaction_t
*transaction
= jh
->b_cp_transaction
;
55 __buffer_unlink_first(jh
);
56 if (transaction
->t_checkpoint_io_list
== jh
) {
57 transaction
->t_checkpoint_io_list
= jh
->b_cpnext
;
58 if (transaction
->t_checkpoint_io_list
== jh
)
59 transaction
->t_checkpoint_io_list
= NULL
;
64 * Move a buffer from the checkpoint list to the checkpoint io list
66 * Called with j_list_lock held
68 static inline void __buffer_relink_io(struct journal_head
*jh
)
70 transaction_t
*transaction
= jh
->b_cp_transaction
;
72 __buffer_unlink_first(jh
);
74 if (!transaction
->t_checkpoint_io_list
) {
75 jh
->b_cpnext
= jh
->b_cpprev
= jh
;
77 jh
->b_cpnext
= transaction
->t_checkpoint_io_list
;
78 jh
->b_cpprev
= transaction
->t_checkpoint_io_list
->b_cpprev
;
79 jh
->b_cpprev
->b_cpnext
= jh
;
80 jh
->b_cpnext
->b_cpprev
= jh
;
82 transaction
->t_checkpoint_io_list
= jh
;
86 * Try to release a checkpointed buffer from its transaction.
87 * Returns 1 if we released it and 2 if we also released the
90 * Requires j_list_lock
92 static int __try_to_free_cp_buf(struct journal_head
*jh
)
95 struct buffer_head
*bh
= jh2bh(jh
);
97 if (jh
->b_transaction
== NULL
&& !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;
106 * __jbd2_log_wait_for_space: wait until there is space in the journal.
108 * Called under j-state_lock *only*. It will be unlocked if we have to wait
109 * for a checkpoint to free up some space in the log.
111 void __jbd2_log_wait_for_space(journal_t
*journal
)
113 int nblocks
, space_left
;
114 /* assert_spin_locked(&journal->j_state_lock); */
116 nblocks
= jbd2_space_needed(journal
);
117 while (jbd2_log_space_left(journal
) < nblocks
) {
118 if (journal
->j_flags
& JBD2_ABORT
)
120 write_unlock(&journal
->j_state_lock
);
121 mutex_lock(&journal
->j_checkpoint_mutex
);
124 * Test again, another process may have checkpointed while we
125 * were waiting for the checkpoint lock. If there are no
126 * transactions ready to be checkpointed, try to recover
127 * journal space by calling cleanup_journal_tail(), and if
128 * that doesn't work, by waiting for the currently committing
129 * transaction to complete. If there is absolutely no way
130 * to make progress, this is either a BUG or corrupted
131 * filesystem, so abort the journal and leave a stack
132 * trace for forensic evidence.
134 write_lock(&journal
->j_state_lock
);
135 spin_lock(&journal
->j_list_lock
);
136 nblocks
= jbd2_space_needed(journal
);
137 space_left
= jbd2_log_space_left(journal
);
138 if (space_left
< nblocks
) {
139 int chkpt
= journal
->j_checkpoint_transactions
!= NULL
;
142 if (journal
->j_committing_transaction
)
143 tid
= journal
->j_committing_transaction
->t_tid
;
144 spin_unlock(&journal
->j_list_lock
);
145 write_unlock(&journal
->j_state_lock
);
147 jbd2_log_do_checkpoint(journal
);
148 } else if (jbd2_cleanup_journal_tail(journal
) == 0) {
149 /* We were able to recover space; yay! */
153 * jbd2_journal_commit_transaction() may want
154 * to take the checkpoint_mutex if JBD2_FLUSHED
155 * is set. So we need to temporarily drop it.
157 mutex_unlock(&journal
->j_checkpoint_mutex
);
158 jbd2_log_wait_commit(journal
, tid
);
159 write_lock(&journal
->j_state_lock
);
162 printk(KERN_ERR
"%s: needed %d blocks and "
163 "only had %d space available\n",
164 __func__
, nblocks
, space_left
);
165 printk(KERN_ERR
"%s: no way to get more "
166 "journal space in %s\n", __func__
,
169 jbd2_journal_abort(journal
, 0);
171 write_lock(&journal
->j_state_lock
);
173 spin_unlock(&journal
->j_list_lock
);
175 mutex_unlock(&journal
->j_checkpoint_mutex
);
180 __flush_batch(journal_t
*journal
, int *batch_count
)
183 struct blk_plug plug
;
185 blk_start_plug(&plug
);
186 for (i
= 0; i
< *batch_count
; i
++)
187 write_dirty_buffer(journal
->j_chkpt_bhs
[i
], WRITE_SYNC
);
188 blk_finish_plug(&plug
);
190 for (i
= 0; i
< *batch_count
; i
++) {
191 struct buffer_head
*bh
= journal
->j_chkpt_bhs
[i
];
192 BUFFER_TRACE(bh
, "brelse");
199 * Perform an actual checkpoint. We take the first transaction on the
200 * list of transactions to be checkpointed and send all its buffers
201 * to disk. We submit larger chunks of data at once.
203 * The journal should be locked before calling this function.
204 * Called with j_checkpoint_mutex held.
206 int jbd2_log_do_checkpoint(journal_t
*journal
)
208 struct journal_head
*jh
;
209 struct buffer_head
*bh
;
210 transaction_t
*transaction
;
212 int result
, batch_count
= 0;
214 jbd_debug(1, "Start checkpoint\n");
217 * First thing: if there are any transactions in the log which
218 * don't need checkpointing, just eliminate them from the
219 * journal straight away.
221 result
= jbd2_cleanup_journal_tail(journal
);
222 trace_jbd2_checkpoint(journal
, result
);
223 jbd_debug(1, "cleanup_journal_tail returned %d\n", result
);
228 * OK, we need to start writing disk blocks. Take one transaction
232 spin_lock(&journal
->j_list_lock
);
233 if (!journal
->j_checkpoint_transactions
)
235 transaction
= journal
->j_checkpoint_transactions
;
236 if (transaction
->t_chp_stats
.cs_chp_time
== 0)
237 transaction
->t_chp_stats
.cs_chp_time
= jiffies
;
238 this_tid
= transaction
->t_tid
;
241 * If someone cleaned up this transaction while we slept, we're
242 * done (maybe it's a new transaction, but it fell at the same
245 if (journal
->j_checkpoint_transactions
!= transaction
||
246 transaction
->t_tid
!= this_tid
)
249 /* checkpoint all of the transaction's buffers */
250 while (transaction
->t_checkpoint_list
) {
251 jh
= transaction
->t_checkpoint_list
;
254 if (buffer_locked(bh
)) {
255 spin_unlock(&journal
->j_list_lock
);
258 /* the journal_head may have gone by now */
259 BUFFER_TRACE(bh
, "brelse");
263 if (jh
->b_transaction
!= NULL
) {
264 transaction_t
*t
= jh
->b_transaction
;
265 tid_t tid
= t
->t_tid
;
267 transaction
->t_chp_stats
.cs_forced_to_close
++;
268 spin_unlock(&journal
->j_list_lock
);
269 if (unlikely(journal
->j_flags
& JBD2_UNMOUNT
))
271 * The journal thread is dead; so
272 * starting and waiting for a commit
273 * to finish will cause us to wait for
274 * a _very_ long time.
277 "JBD2: %s: Waiting for Godot: block %llu\n",
278 journal
->j_devname
, (unsigned long long) bh
->b_blocknr
);
280 jbd2_log_start_commit(journal
, tid
);
281 jbd2_log_wait_commit(journal
, tid
);
284 if (!buffer_dirty(bh
)) {
285 if (unlikely(buffer_write_io_error(bh
)) && !result
)
287 BUFFER_TRACE(bh
, "remove from checkpoint");
288 if (__jbd2_journal_remove_checkpoint(jh
))
289 /* The transaction was released; we're done */
294 * Important: we are about to write the buffer, and
295 * possibly block, while still holding the journal
296 * lock. We cannot afford to let the transaction
297 * logic start messing around with this buffer before
298 * we write it to disk, as that would break
301 BUFFER_TRACE(bh
, "queue");
303 J_ASSERT_BH(bh
, !buffer_jwrite(bh
));
304 journal
->j_chkpt_bhs
[batch_count
++] = bh
;
305 __buffer_relink_io(jh
);
306 transaction
->t_chp_stats
.cs_written
++;
307 if ((batch_count
== JBD2_NR_BATCH
) ||
309 spin_needbreak(&journal
->j_list_lock
))
310 goto unlock_and_flush
;
315 spin_unlock(&journal
->j_list_lock
);
318 __flush_batch(journal
, &batch_count
);
319 spin_lock(&journal
->j_list_lock
);
324 * Now we issued all of the transaction's buffers, let's deal
325 * with the buffers that are out for I/O.
328 /* Did somebody clean up the transaction in the meanwhile? */
329 if (journal
->j_checkpoint_transactions
!= transaction
||
330 transaction
->t_tid
!= this_tid
)
333 while (transaction
->t_checkpoint_io_list
) {
334 jh
= transaction
->t_checkpoint_io_list
;
336 if (buffer_locked(bh
)) {
337 spin_unlock(&journal
->j_list_lock
);
340 /* the journal_head may have gone by now */
341 BUFFER_TRACE(bh
, "brelse");
343 spin_lock(&journal
->j_list_lock
);
346 if (unlikely(buffer_write_io_error(bh
)) && !result
)
350 * Now in whatever state the buffer currently is, we
351 * know that it has been written out and so we can
352 * drop it from the list
354 if (__jbd2_journal_remove_checkpoint(jh
))
358 spin_unlock(&journal
->j_list_lock
);
360 jbd2_journal_abort(journal
, result
);
362 result
= jbd2_cleanup_journal_tail(journal
);
364 return (result
< 0) ? result
: 0;
368 * Check the list of checkpoint transactions for the journal to see if
369 * we have already got rid of any since the last update of the log tail
370 * in the journal superblock. If so, we can instantly roll the
371 * superblock forward to remove those transactions from the log.
373 * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
375 * Called with the journal lock held.
377 * This is the only part of the journaling code which really needs to be
378 * aware of transaction aborts. Checkpointing involves writing to the
379 * main filesystem area rather than to the journal, so it can proceed
380 * even in abort state, but we must not update the super block if
381 * checkpointing may have failed. Otherwise, we would lose some metadata
382 * buffers which should be written-back to the filesystem.
385 int jbd2_cleanup_journal_tail(journal_t
*journal
)
388 unsigned long blocknr
;
390 if (is_journal_aborted(journal
))
393 if (!jbd2_journal_get_log_tail(journal
, &first_tid
, &blocknr
))
395 J_ASSERT(blocknr
!= 0);
398 * We need to make sure that any blocks that were recently written out
399 * --- perhaps by jbd2_log_do_checkpoint() --- are flushed out before
400 * we drop the transactions from the journal. It's unlikely this will
401 * be necessary, especially with an appropriately sized journal, but we
402 * need this to guarantee correctness. Fortunately
403 * jbd2_cleanup_journal_tail() doesn't get called all that often.
405 if (journal
->j_flags
& JBD2_BARRIER
)
406 blkdev_issue_flush(journal
->j_fs_dev
, GFP_KERNEL
, NULL
);
408 __jbd2_update_log_tail(journal
, first_tid
, blocknr
);
413 /* Checkpoint list management */
416 * journal_clean_one_cp_list
418 * Find all the written-back checkpoint buffers in the given list and
421 * Called with the journal locked.
422 * Called with j_list_lock held.
423 * Returns number of buffers reaped (for debug)
426 static int journal_clean_one_cp_list(struct journal_head
*jh
, int *released
)
428 struct journal_head
*last_jh
;
429 struct journal_head
*next_jh
= jh
;
436 last_jh
= jh
->b_cpprev
;
439 next_jh
= jh
->b_cpnext
;
440 ret
= __try_to_free_cp_buf(jh
);
449 * This function only frees up some memory
450 * if possible so we dont have an obligation
451 * to finish processing. Bail out if preemption
456 } while (jh
!= last_jh
);
462 * journal_clean_checkpoint_list
464 * Find all the written-back checkpoint buffers in the journal and release them.
466 * Called with the journal locked.
467 * Called with j_list_lock held.
468 * Returns number of buffers reaped (for debug)
471 int __jbd2_journal_clean_checkpoint_list(journal_t
*journal
)
473 transaction_t
*transaction
, *last_transaction
, *next_transaction
;
477 transaction
= journal
->j_checkpoint_transactions
;
481 last_transaction
= transaction
->t_cpprev
;
482 next_transaction
= transaction
;
484 transaction
= next_transaction
;
485 next_transaction
= transaction
->t_cpnext
;
486 ret
+= journal_clean_one_cp_list(transaction
->
487 t_checkpoint_list
, &released
);
489 * This function only frees up some memory if possible so we
490 * dont have an obligation to finish processing. Bail out if
491 * preemption requested:
498 * It is essential that we are as careful as in the case of
499 * t_checkpoint_list with removing the buffer from the list as
500 * we can possibly see not yet submitted buffers on io_list
502 ret
+= journal_clean_one_cp_list(transaction
->
503 t_checkpoint_io_list
, &released
);
506 } while (transaction
!= last_transaction
);
512 * journal_remove_checkpoint: called after a buffer has been committed
513 * to disk (either by being write-back flushed to disk, or being
514 * committed to the log).
516 * We cannot safely clean a transaction out of the log until all of the
517 * buffer updates committed in that transaction have safely been stored
518 * elsewhere on disk. To achieve this, all of the buffers in a
519 * transaction need to be maintained on the transaction's checkpoint
520 * lists until they have been rewritten, at which point this function is
521 * called to remove the buffer from the existing transaction's
524 * The function returns 1 if it frees the transaction, 0 otherwise.
525 * The function can free jh and bh.
527 * This function is called with j_list_lock held.
529 int __jbd2_journal_remove_checkpoint(struct journal_head
*jh
)
531 struct transaction_chp_stats_s
*stats
;
532 transaction_t
*transaction
;
536 JBUFFER_TRACE(jh
, "entry");
538 if ((transaction
= jh
->b_cp_transaction
) == NULL
) {
539 JBUFFER_TRACE(jh
, "not on transaction");
542 journal
= transaction
->t_journal
;
544 JBUFFER_TRACE(jh
, "removing from transaction");
546 jh
->b_cp_transaction
= NULL
;
547 jbd2_journal_put_journal_head(jh
);
549 if (transaction
->t_checkpoint_list
!= NULL
||
550 transaction
->t_checkpoint_io_list
!= NULL
)
554 * There is one special case to worry about: if we have just pulled the
555 * buffer off a running or committing transaction's checkpoing list,
556 * then even if the checkpoint list is empty, the transaction obviously
559 * The locking here around t_state is a bit sleazy.
560 * See the comment at the end of jbd2_journal_commit_transaction().
562 if (transaction
->t_state
!= T_FINISHED
)
565 /* OK, that was the last buffer for the transaction: we can now
566 safely remove this transaction from the log */
567 stats
= &transaction
->t_chp_stats
;
568 if (stats
->cs_chp_time
)
569 stats
->cs_chp_time
= jbd2_time_diff(stats
->cs_chp_time
,
571 trace_jbd2_checkpoint_stats(journal
->j_fs_dev
->bd_dev
,
572 transaction
->t_tid
, stats
);
574 __jbd2_journal_drop_transaction(journal
, transaction
);
575 jbd2_journal_free_transaction(transaction
);
582 * journal_insert_checkpoint: put a committed buffer onto a checkpoint
583 * list so that we know when it is safe to clean the transaction out of
586 * Called with the journal locked.
587 * Called with j_list_lock held.
589 void __jbd2_journal_insert_checkpoint(struct journal_head
*jh
,
590 transaction_t
*transaction
)
592 JBUFFER_TRACE(jh
, "entry");
593 J_ASSERT_JH(jh
, buffer_dirty(jh2bh(jh
)) || buffer_jbddirty(jh2bh(jh
)));
594 J_ASSERT_JH(jh
, jh
->b_cp_transaction
== NULL
);
596 /* Get reference for checkpointing transaction */
597 jbd2_journal_grab_journal_head(jh2bh(jh
));
598 jh
->b_cp_transaction
= transaction
;
600 if (!transaction
->t_checkpoint_list
) {
601 jh
->b_cpnext
= jh
->b_cpprev
= jh
;
603 jh
->b_cpnext
= transaction
->t_checkpoint_list
;
604 jh
->b_cpprev
= transaction
->t_checkpoint_list
->b_cpprev
;
605 jh
->b_cpprev
->b_cpnext
= jh
;
606 jh
->b_cpnext
->b_cpprev
= jh
;
608 transaction
->t_checkpoint_list
= jh
;
612 * We've finished with this transaction structure: adios...
614 * The transaction must have no links except for the checkpoint by this
617 * Called with the journal locked.
618 * Called with j_list_lock held.
621 void __jbd2_journal_drop_transaction(journal_t
*journal
, transaction_t
*transaction
)
623 assert_spin_locked(&journal
->j_list_lock
);
624 if (transaction
->t_cpnext
) {
625 transaction
->t_cpnext
->t_cpprev
= transaction
->t_cpprev
;
626 transaction
->t_cpprev
->t_cpnext
= transaction
->t_cpnext
;
627 if (journal
->j_checkpoint_transactions
== transaction
)
628 journal
->j_checkpoint_transactions
=
629 transaction
->t_cpnext
;
630 if (journal
->j_checkpoint_transactions
== transaction
)
631 journal
->j_checkpoint_transactions
= NULL
;
634 J_ASSERT(transaction
->t_state
== T_FINISHED
);
635 J_ASSERT(transaction
->t_buffers
== NULL
);
636 J_ASSERT(transaction
->t_forget
== NULL
);
637 J_ASSERT(transaction
->t_shadow_list
== NULL
);
638 J_ASSERT(transaction
->t_checkpoint_list
== NULL
);
639 J_ASSERT(transaction
->t_checkpoint_io_list
== NULL
);
640 J_ASSERT(atomic_read(&transaction
->t_updates
) == 0);
641 J_ASSERT(journal
->j_committing_transaction
!= transaction
);
642 J_ASSERT(journal
->j_running_transaction
!= transaction
);
644 trace_jbd2_drop_transaction(journal
, transaction
);
646 jbd_debug(1, "Dropping transaction %d, all done\n", transaction
->t_tid
);