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
)) {
100 * Get our reference so that bh cannot be freed before
104 JBUFFER_TRACE(jh
, "remove from checkpoint list");
105 ret
= __jbd2_journal_remove_checkpoint(jh
) + 1;
106 BUFFER_TRACE(bh
, "release");
113 * __jbd2_log_wait_for_space: wait until there is space in the journal.
115 * Called under j-state_lock *only*. It will be unlocked if we have to wait
116 * for a checkpoint to free up some space in the log.
118 void __jbd2_log_wait_for_space(journal_t
*journal
)
120 int nblocks
, space_left
;
121 /* assert_spin_locked(&journal->j_state_lock); */
123 nblocks
= jbd2_space_needed(journal
);
124 while (jbd2_log_space_left(journal
) < nblocks
) {
125 if (journal
->j_flags
& JBD2_ABORT
)
127 write_unlock(&journal
->j_state_lock
);
128 mutex_lock(&journal
->j_checkpoint_mutex
);
131 * Test again, another process may have checkpointed while we
132 * were waiting for the checkpoint lock. If there are no
133 * transactions ready to be checkpointed, try to recover
134 * journal space by calling cleanup_journal_tail(), and if
135 * that doesn't work, by waiting for the currently committing
136 * transaction to complete. If there is absolutely no way
137 * to make progress, this is either a BUG or corrupted
138 * filesystem, so abort the journal and leave a stack
139 * trace for forensic evidence.
141 write_lock(&journal
->j_state_lock
);
142 spin_lock(&journal
->j_list_lock
);
143 nblocks
= jbd2_space_needed(journal
);
144 space_left
= jbd2_log_space_left(journal
);
145 if (space_left
< nblocks
) {
146 int chkpt
= journal
->j_checkpoint_transactions
!= NULL
;
149 if (journal
->j_committing_transaction
)
150 tid
= journal
->j_committing_transaction
->t_tid
;
151 spin_unlock(&journal
->j_list_lock
);
152 write_unlock(&journal
->j_state_lock
);
154 jbd2_log_do_checkpoint(journal
);
155 } else if (jbd2_cleanup_journal_tail(journal
) == 0) {
156 /* We were able to recover space; yay! */
160 * jbd2_journal_commit_transaction() may want
161 * to take the checkpoint_mutex if JBD2_FLUSHED
162 * is set. So we need to temporarily drop it.
164 mutex_unlock(&journal
->j_checkpoint_mutex
);
165 jbd2_log_wait_commit(journal
, tid
);
166 write_lock(&journal
->j_state_lock
);
169 printk(KERN_ERR
"%s: needed %d blocks and "
170 "only had %d space available\n",
171 __func__
, nblocks
, space_left
);
172 printk(KERN_ERR
"%s: no way to get more "
173 "journal space in %s\n", __func__
,
176 jbd2_journal_abort(journal
, 0);
178 write_lock(&journal
->j_state_lock
);
180 spin_unlock(&journal
->j_list_lock
);
182 mutex_unlock(&journal
->j_checkpoint_mutex
);
187 __flush_batch(journal_t
*journal
, int *batch_count
)
190 struct blk_plug plug
;
192 blk_start_plug(&plug
);
193 for (i
= 0; i
< *batch_count
; i
++)
194 write_dirty_buffer(journal
->j_chkpt_bhs
[i
], WRITE_SYNC
);
195 blk_finish_plug(&plug
);
197 for (i
= 0; i
< *batch_count
; i
++) {
198 struct buffer_head
*bh
= journal
->j_chkpt_bhs
[i
];
199 BUFFER_TRACE(bh
, "brelse");
206 * Perform an actual checkpoint. We take the first transaction on the
207 * list of transactions to be checkpointed and send all its buffers
208 * to disk. We submit larger chunks of data at once.
210 * The journal should be locked before calling this function.
211 * Called with j_checkpoint_mutex held.
213 int jbd2_log_do_checkpoint(journal_t
*journal
)
215 struct journal_head
*jh
;
216 struct buffer_head
*bh
;
217 transaction_t
*transaction
;
219 int result
, batch_count
= 0, done
= 0;
221 jbd_debug(1, "Start checkpoint\n");
224 * First thing: if there are any transactions in the log which
225 * don't need checkpointing, just eliminate them from the
226 * journal straight away.
228 result
= jbd2_cleanup_journal_tail(journal
);
229 trace_jbd2_checkpoint(journal
, result
);
230 jbd_debug(1, "cleanup_journal_tail returned %d\n", result
);
235 * OK, we need to start writing disk blocks. Take one transaction
239 spin_lock(&journal
->j_list_lock
);
240 if (!journal
->j_checkpoint_transactions
)
242 transaction
= journal
->j_checkpoint_transactions
;
243 if (transaction
->t_chp_stats
.cs_chp_time
== 0)
244 transaction
->t_chp_stats
.cs_chp_time
= jiffies
;
245 this_tid
= transaction
->t_tid
;
248 * If someone cleaned up this transaction while we slept, we're
249 * done (maybe it's a new transaction, but it fell at the same
252 if (journal
->j_checkpoint_transactions
!= transaction
||
253 transaction
->t_tid
!= this_tid
)
256 /* checkpoint all of the transaction's buffers */
257 while (transaction
->t_checkpoint_list
) {
258 jh
= transaction
->t_checkpoint_list
;
261 if (buffer_locked(bh
)) {
262 spin_unlock(&journal
->j_list_lock
);
265 /* the journal_head may have gone by now */
266 BUFFER_TRACE(bh
, "brelse");
270 if (jh
->b_transaction
!= NULL
) {
271 transaction_t
*t
= jh
->b_transaction
;
272 tid_t tid
= t
->t_tid
;
274 transaction
->t_chp_stats
.cs_forced_to_close
++;
275 spin_unlock(&journal
->j_list_lock
);
276 if (unlikely(journal
->j_flags
& JBD2_UNMOUNT
))
278 * The journal thread is dead; so
279 * starting and waiting for a commit
280 * to finish will cause us to wait for
281 * a _very_ long time.
284 "JBD2: %s: Waiting for Godot: block %llu\n",
285 journal
->j_devname
, (unsigned long long) bh
->b_blocknr
);
287 jbd2_log_start_commit(journal
, tid
);
288 jbd2_log_wait_commit(journal
, tid
);
291 if (!buffer_dirty(bh
)) {
292 if (unlikely(buffer_write_io_error(bh
)) && !result
)
295 BUFFER_TRACE(bh
, "remove from checkpoint");
296 __jbd2_journal_remove_checkpoint(jh
);
297 spin_unlock(&journal
->j_list_lock
);
302 * Important: we are about to write the buffer, and
303 * possibly block, while still holding the journal
304 * lock. We cannot afford to let the transaction
305 * logic start messing around with this buffer before
306 * we write it to disk, as that would break
309 BUFFER_TRACE(bh
, "queue");
311 J_ASSERT_BH(bh
, !buffer_jwrite(bh
));
312 journal
->j_chkpt_bhs
[batch_count
++] = bh
;
313 __buffer_relink_io(jh
);
314 transaction
->t_chp_stats
.cs_written
++;
315 if ((batch_count
== JBD2_NR_BATCH
) ||
317 spin_needbreak(&journal
->j_list_lock
))
318 goto unlock_and_flush
;
323 spin_unlock(&journal
->j_list_lock
);
326 __flush_batch(journal
, &batch_count
);
327 spin_lock(&journal
->j_list_lock
);
332 * Now we issued all of the transaction's buffers, let's deal
333 * with the buffers that are out for I/O.
336 /* Did somebody clean up the transaction in the meanwhile? */
337 if (journal
->j_checkpoint_transactions
!= transaction
||
338 transaction
->t_tid
!= this_tid
)
341 while (!done
&& transaction
->t_checkpoint_io_list
) {
342 jh
= transaction
->t_checkpoint_io_list
;
345 if (buffer_locked(bh
)) {
346 spin_unlock(&journal
->j_list_lock
);
348 /* the journal_head may have gone by now */
349 BUFFER_TRACE(bh
, "brelse");
351 spin_lock(&journal
->j_list_lock
);
354 if (unlikely(buffer_write_io_error(bh
)) && !result
)
358 * Now in whatever state the buffer currently is, we
359 * know that it has been written out and so we can
360 * drop it from the list
362 done
= __jbd2_journal_remove_checkpoint(jh
);
366 spin_unlock(&journal
->j_list_lock
);
368 jbd2_journal_abort(journal
, result
);
370 result
= jbd2_cleanup_journal_tail(journal
);
372 return (result
< 0) ? result
: 0;
376 * Check the list of checkpoint transactions for the journal to see if
377 * we have already got rid of any since the last update of the log tail
378 * in the journal superblock. If so, we can instantly roll the
379 * superblock forward to remove those transactions from the log.
381 * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
383 * Called with the journal lock held.
385 * This is the only part of the journaling code which really needs to be
386 * aware of transaction aborts. Checkpointing involves writing to the
387 * main filesystem area rather than to the journal, so it can proceed
388 * even in abort state, but we must not update the super block if
389 * checkpointing may have failed. Otherwise, we would lose some metadata
390 * buffers which should be written-back to the filesystem.
393 int jbd2_cleanup_journal_tail(journal_t
*journal
)
396 unsigned long blocknr
;
398 if (is_journal_aborted(journal
))
401 if (!jbd2_journal_get_log_tail(journal
, &first_tid
, &blocknr
))
403 J_ASSERT(blocknr
!= 0);
406 * We need to make sure that any blocks that were recently written out
407 * --- perhaps by jbd2_log_do_checkpoint() --- are flushed out before
408 * we drop the transactions from the journal. It's unlikely this will
409 * be necessary, especially with an appropriately sized journal, but we
410 * need this to guarantee correctness. Fortunately
411 * jbd2_cleanup_journal_tail() doesn't get called all that often.
413 if (journal
->j_flags
& JBD2_BARRIER
)
414 blkdev_issue_flush(journal
->j_fs_dev
, GFP_KERNEL
, NULL
);
416 __jbd2_update_log_tail(journal
, first_tid
, blocknr
);
421 /* Checkpoint list management */
424 * journal_clean_one_cp_list
426 * Find all the written-back checkpoint buffers in the given list and
429 * Called with the journal locked.
430 * Called with j_list_lock held.
431 * Returns number of buffers reaped (for debug)
434 static int journal_clean_one_cp_list(struct journal_head
*jh
, int *released
)
436 struct journal_head
*last_jh
;
437 struct journal_head
*next_jh
= jh
;
444 last_jh
= jh
->b_cpprev
;
447 next_jh
= jh
->b_cpnext
;
448 ret
= __try_to_free_cp_buf(jh
);
457 * This function only frees up some memory
458 * if possible so we dont have an obligation
459 * to finish processing. Bail out if preemption
464 } while (jh
!= last_jh
);
470 * journal_clean_checkpoint_list
472 * Find all the written-back checkpoint buffers in the journal and release them.
474 * Called with the journal locked.
475 * Called with j_list_lock held.
476 * Returns number of buffers reaped (for debug)
479 int __jbd2_journal_clean_checkpoint_list(journal_t
*journal
)
481 transaction_t
*transaction
, *last_transaction
, *next_transaction
;
485 transaction
= journal
->j_checkpoint_transactions
;
489 last_transaction
= transaction
->t_cpprev
;
490 next_transaction
= transaction
;
492 transaction
= next_transaction
;
493 next_transaction
= transaction
->t_cpnext
;
494 ret
+= journal_clean_one_cp_list(transaction
->
495 t_checkpoint_list
, &released
);
497 * This function only frees up some memory if possible so we
498 * dont have an obligation to finish processing. Bail out if
499 * preemption requested:
506 * It is essential that we are as careful as in the case of
507 * t_checkpoint_list with removing the buffer from the list as
508 * we can possibly see not yet submitted buffers on io_list
510 ret
+= journal_clean_one_cp_list(transaction
->
511 t_checkpoint_io_list
, &released
);
514 } while (transaction
!= last_transaction
);
520 * journal_remove_checkpoint: called after a buffer has been committed
521 * to disk (either by being write-back flushed to disk, or being
522 * committed to the log).
524 * We cannot safely clean a transaction out of the log until all of the
525 * buffer updates committed in that transaction have safely been stored
526 * elsewhere on disk. To achieve this, all of the buffers in a
527 * transaction need to be maintained on the transaction's checkpoint
528 * lists until they have been rewritten, at which point this function is
529 * called to remove the buffer from the existing transaction's
532 * The function returns 1 if it frees the transaction, 0 otherwise.
533 * The function can free jh and bh.
535 * This function is called with j_list_lock held.
537 int __jbd2_journal_remove_checkpoint(struct journal_head
*jh
)
539 struct transaction_chp_stats_s
*stats
;
540 transaction_t
*transaction
;
544 JBUFFER_TRACE(jh
, "entry");
546 if ((transaction
= jh
->b_cp_transaction
) == NULL
) {
547 JBUFFER_TRACE(jh
, "not on transaction");
550 journal
= transaction
->t_journal
;
552 JBUFFER_TRACE(jh
, "removing from transaction");
554 jh
->b_cp_transaction
= NULL
;
555 jbd2_journal_put_journal_head(jh
);
557 if (transaction
->t_checkpoint_list
!= NULL
||
558 transaction
->t_checkpoint_io_list
!= NULL
)
562 * There is one special case to worry about: if we have just pulled the
563 * buffer off a running or committing transaction's checkpoing list,
564 * then even if the checkpoint list is empty, the transaction obviously
567 * The locking here around t_state is a bit sleazy.
568 * See the comment at the end of jbd2_journal_commit_transaction().
570 if (transaction
->t_state
!= T_FINISHED
)
573 /* OK, that was the last buffer for the transaction: we can now
574 safely remove this transaction from the log */
575 stats
= &transaction
->t_chp_stats
;
576 if (stats
->cs_chp_time
)
577 stats
->cs_chp_time
= jbd2_time_diff(stats
->cs_chp_time
,
579 trace_jbd2_checkpoint_stats(journal
->j_fs_dev
->bd_dev
,
580 transaction
->t_tid
, stats
);
582 __jbd2_journal_drop_transaction(journal
, transaction
);
583 jbd2_journal_free_transaction(transaction
);
590 * journal_insert_checkpoint: put a committed buffer onto a checkpoint
591 * list so that we know when it is safe to clean the transaction out of
594 * Called with the journal locked.
595 * Called with j_list_lock held.
597 void __jbd2_journal_insert_checkpoint(struct journal_head
*jh
,
598 transaction_t
*transaction
)
600 JBUFFER_TRACE(jh
, "entry");
601 J_ASSERT_JH(jh
, buffer_dirty(jh2bh(jh
)) || buffer_jbddirty(jh2bh(jh
)));
602 J_ASSERT_JH(jh
, jh
->b_cp_transaction
== NULL
);
604 /* Get reference for checkpointing transaction */
605 jbd2_journal_grab_journal_head(jh2bh(jh
));
606 jh
->b_cp_transaction
= transaction
;
608 if (!transaction
->t_checkpoint_list
) {
609 jh
->b_cpnext
= jh
->b_cpprev
= jh
;
611 jh
->b_cpnext
= transaction
->t_checkpoint_list
;
612 jh
->b_cpprev
= transaction
->t_checkpoint_list
->b_cpprev
;
613 jh
->b_cpprev
->b_cpnext
= jh
;
614 jh
->b_cpnext
->b_cpprev
= jh
;
616 transaction
->t_checkpoint_list
= jh
;
620 * We've finished with this transaction structure: adios...
622 * The transaction must have no links except for the checkpoint by this
625 * Called with the journal locked.
626 * Called with j_list_lock held.
629 void __jbd2_journal_drop_transaction(journal_t
*journal
, transaction_t
*transaction
)
631 assert_spin_locked(&journal
->j_list_lock
);
632 if (transaction
->t_cpnext
) {
633 transaction
->t_cpnext
->t_cpprev
= transaction
->t_cpprev
;
634 transaction
->t_cpprev
->t_cpnext
= transaction
->t_cpnext
;
635 if (journal
->j_checkpoint_transactions
== transaction
)
636 journal
->j_checkpoint_transactions
=
637 transaction
->t_cpnext
;
638 if (journal
->j_checkpoint_transactions
== transaction
)
639 journal
->j_checkpoint_transactions
= NULL
;
642 J_ASSERT(transaction
->t_state
== T_FINISHED
);
643 J_ASSERT(transaction
->t_buffers
== NULL
);
644 J_ASSERT(transaction
->t_forget
== NULL
);
645 J_ASSERT(transaction
->t_shadow_list
== NULL
);
646 J_ASSERT(transaction
->t_checkpoint_list
== NULL
);
647 J_ASSERT(transaction
->t_checkpoint_io_list
== NULL
);
648 J_ASSERT(atomic_read(&transaction
->t_updates
) == 0);
649 J_ASSERT(journal
->j_committing_transaction
!= transaction
);
650 J_ASSERT(journal
->j_running_transaction
!= transaction
);
652 trace_jbd2_drop_transaction(journal
, transaction
);
654 jbd_debug(1, "Dropping transaction %d, all done\n", transaction
->t_tid
);