4 * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
6 * Copyright 1998 Red Hat corp --- 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 * Journal commit routines for the generic filesystem journaling code;
13 * part of the ext2fs journaling system.
16 #include <linux/time.h>
18 #include <linux/jbd.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
22 #include <linux/pagemap.h>
23 #include <linux/smp_lock.h>
26 * Default IO end handler for temporary BJ_IO buffer_heads.
28 static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
32 set_buffer_uptodate(bh);
34 clear_buffer_uptodate(bh);
39 * When an ext3-ordered file is truncated, it is possible that many pages are
40 * not sucessfully freed, because they are attached to a committing transaction.
41 * After the transaction commits, these pages are left on the LRU, with no
42 * ->mapping, and with attached buffers. These pages are trivially reclaimable
43 * by the VM, but their apparent absence upsets the VM accounting, and it makes
44 * the numbers in /proc/meminfo look odd.
46 * So here, we have a buffer which has just come off the forget list. Look to
47 * see if we can strip all buffers from the backing page.
49 * Called under lock_journal(), and possibly under journal_datalist_lock. The
50 * caller provided us with a ref against the buffer, and we drop that here.
52 static void release_buffer_page(struct buffer_head *bh)
58 if (atomic_read(&bh->b_count) != 1)
66 /* OK, it's a truncated page */
67 if (TestSetPageLocked(page))
72 try_to_free_buffers(page);
74 page_cache_release(page);
82 * Try to acquire jbd_lock_bh_state() against the buffer, when j_list_lock is
83 * held. For ranking reasons we must trylock. If we lose, schedule away and
84 * return 0. j_list_lock is dropped in this case.
86 static int inverted_lock(journal_t *journal, struct buffer_head *bh)
88 if (!jbd_trylock_bh_state(bh)) {
89 spin_unlock(&journal->j_list_lock);
97 * journal_commit_transaction
99 * The primary function for committing a transaction to the log. This
100 * function is called by the journal thread to begin a complete commit.
102 void journal_commit_transaction(journal_t *journal)
104 transaction_t *commit_transaction;
105 struct journal_head *jh, *new_jh, *descriptor;
106 struct buffer_head *wbuf[64];
110 unsigned long blocknr;
112 journal_header_t *header;
113 journal_block_tag_t *tag = NULL;
120 * First job: lock down the current transaction and wait for
121 * all outstanding updates to complete.
125 spin_lock(&journal->j_list_lock);
126 summarise_journal_usage(journal);
127 spin_unlock(&journal->j_list_lock);
130 /* Do we need to erase the effects of a prior journal_flush? */
131 if (journal->j_flags & JFS_FLUSHED) {
132 jbd_debug(3, "super block updated\n");
133 journal_update_superblock(journal, 1);
135 jbd_debug(3, "superblock not updated\n");
138 J_ASSERT(journal->j_running_transaction != NULL);
139 J_ASSERT(journal->j_committing_transaction == NULL);
141 commit_transaction = journal->j_running_transaction;
142 J_ASSERT(commit_transaction->t_state == T_RUNNING);
144 jbd_debug(1, "JBD: starting commit of transaction %d\n",
145 commit_transaction->t_tid);
147 spin_lock(&journal->j_state_lock);
148 commit_transaction->t_state = T_LOCKED;
150 spin_lock(&commit_transaction->t_handle_lock);
151 while (commit_transaction->t_updates) {
154 prepare_to_wait(&journal->j_wait_updates, &wait,
155 TASK_UNINTERRUPTIBLE);
156 if (commit_transaction->t_updates) {
157 spin_unlock(&commit_transaction->t_handle_lock);
158 spin_unlock(&journal->j_state_lock);
160 spin_lock(&journal->j_state_lock);
161 spin_lock(&commit_transaction->t_handle_lock);
163 finish_wait(&journal->j_wait_updates, &wait);
165 spin_unlock(&commit_transaction->t_handle_lock);
167 J_ASSERT (commit_transaction->t_outstanding_credits <=
168 journal->j_max_transaction_buffers);
171 * First thing we are allowed to do is to discard any remaining
172 * BJ_Reserved buffers. Note, it is _not_ permissible to assume
173 * that there are no such buffers: if a large filesystem
174 * operation like a truncate needs to split itself over multiple
175 * transactions, then it may try to do a journal_restart() while
176 * there are still BJ_Reserved buffers outstanding. These must
177 * be released cleanly from the current transaction.
179 * In this case, the filesystem must still reserve write access
180 * again before modifying the buffer in the new transaction, but
181 * we do not require it to remember exactly which old buffers it
182 * has reserved. This is consistent with the existing behaviour
183 * that multiple journal_get_write_access() calls to the same
184 * buffer are perfectly permissable.
186 while (commit_transaction->t_reserved_list) {
187 jh = commit_transaction->t_reserved_list;
188 JBUFFER_TRACE(jh, "reserved, unused: refile");
190 * A journal_get_undo_access()+journal_release_buffer() may
191 * leave undo-committed data.
193 if (jh->b_committed_data) {
194 struct buffer_head *bh = jh2bh(jh);
196 jbd_lock_bh_state(bh);
197 if (jh->b_committed_data) {
198 kfree(jh->b_committed_data);
199 jh->b_committed_data = NULL;
201 jbd_unlock_bh_state(bh);
203 journal_refile_buffer(journal, jh);
207 * Now try to drop any written-back buffers from the journal's
208 * checkpoint lists. We do this *before* commit because it potentially
211 spin_lock(&journal->j_list_lock);
212 __journal_clean_checkpoint_list(journal);
213 spin_unlock(&journal->j_list_lock);
215 jbd_debug (3, "JBD: commit phase 1\n");
218 * Switch to a new revoke table.
220 journal_switch_revoke_table(journal);
222 commit_transaction->t_state = T_FLUSH;
223 journal->j_committing_transaction = commit_transaction;
224 journal->j_running_transaction = NULL;
225 commit_transaction->t_log_start = journal->j_head;
226 wake_up(&journal->j_wait_transaction_locked);
227 spin_unlock(&journal->j_state_lock);
229 jbd_debug (3, "JBD: commit phase 2\n");
232 * Now start flushing things to disk, in the order they appear
233 * on the transaction lists. Data blocks go first.
238 * Whenever we unlock the journal and sleep, things can get added
239 * onto ->t_sync_datalist, so we have to keep looping back to
240 * write_out_data until we *know* that the list is empty.
244 * Cleanup any flushed data buffers from the data list. Even in
245 * abort mode, we want to flush this out as soon as possible.
249 spin_lock(&journal->j_list_lock);
251 while (commit_transaction->t_sync_datalist) {
252 struct buffer_head *bh;
254 jh = commit_transaction->t_sync_datalist;
255 commit_transaction->t_sync_datalist = jh->b_tnext;
257 if (buffer_locked(bh)) {
258 BUFFER_TRACE(bh, "locked");
259 if (!inverted_lock(journal, bh))
261 __journal_unfile_buffer(jh);
262 __journal_file_buffer(jh, commit_transaction,
264 jbd_unlock_bh_state(bh);
265 if (lock_need_resched(&journal->j_list_lock)) {
266 spin_unlock(&journal->j_list_lock);
270 if (buffer_dirty(bh)) {
271 BUFFER_TRACE(bh, "start journal writeout");
274 if (bufs == ARRAY_SIZE(wbuf)) {
275 jbd_debug(2, "submit %d writes\n",
277 spin_unlock(&journal->j_list_lock);
278 ll_rw_block(WRITE, bufs, wbuf);
279 journal_brelse_array(wbuf, bufs);
284 BUFFER_TRACE(bh, "writeout complete: unfile");
285 if (!inverted_lock(journal, bh))
287 __journal_unfile_buffer(jh);
288 jbd_unlock_bh_state(bh);
289 journal_remove_journal_head(bh);
291 if (lock_need_resched(&journal->j_list_lock)) {
292 spin_unlock(&journal->j_list_lock);
300 spin_unlock(&journal->j_list_lock);
301 ll_rw_block(WRITE, bufs, wbuf);
302 journal_brelse_array(wbuf, bufs);
303 spin_lock(&journal->j_list_lock);
307 * Wait for all previously submitted IO to complete.
309 while (commit_transaction->t_locked_list) {
310 struct buffer_head *bh;
312 jh = commit_transaction->t_locked_list->b_tprev;
315 if (buffer_locked(bh)) {
316 spin_unlock(&journal->j_list_lock);
318 if (unlikely(!buffer_uptodate(bh)))
320 spin_lock(&journal->j_list_lock);
322 if (!inverted_lock(journal, bh)) {
324 spin_lock(&journal->j_list_lock);
327 if (buffer_jbd(bh) && jh->b_jlist == BJ_Locked) {
328 __journal_unfile_buffer(jh);
329 jbd_unlock_bh_state(bh);
330 journal_remove_journal_head(bh);
333 jbd_unlock_bh_state(bh);
336 cond_resched_lock(&journal->j_list_lock);
338 spin_unlock(&journal->j_list_lock);
341 __journal_abort_hard(journal);
343 journal_write_revoke_records(journal, commit_transaction);
345 jbd_debug(3, "JBD: commit phase 2\n");
348 * If we found any dirty or locked buffers, then we should have
349 * looped back up to the write_out_data label. If there weren't
350 * any then journal_clean_data_list should have wiped the list
351 * clean by now, so check that it is in fact empty.
353 J_ASSERT (commit_transaction->t_sync_datalist == NULL);
355 jbd_debug (3, "JBD: commit phase 3\n");
358 * Way to go: we have now written out all of the data for a
359 * transaction! Now comes the tricky part: we need to write out
360 * metadata. Loop over the transaction's entire buffer list:
362 commit_transaction->t_state = T_COMMIT;
366 while (commit_transaction->t_buffers) {
368 /* Find the next buffer to be journaled... */
370 jh = commit_transaction->t_buffers;
372 /* If we're in abort mode, we just un-journal the buffer and
373 release it for background writing. */
375 if (is_journal_aborted(journal)) {
376 JBUFFER_TRACE(jh, "journal is aborting: refile");
377 journal_refile_buffer(journal, jh);
378 /* If that was the last one, we need to clean up
379 * any descriptor buffers which may have been
380 * already allocated, even if we are now
382 if (!commit_transaction->t_buffers)
383 goto start_journal_io;
387 /* Make sure we have a descriptor block in which to
388 record the metadata buffer. */
391 struct buffer_head *bh;
393 J_ASSERT (bufs == 0);
395 jbd_debug(4, "JBD: get descriptor\n");
397 descriptor = journal_get_descriptor_buffer(journal);
399 __journal_abort_hard(journal);
403 bh = jh2bh(descriptor);
404 jbd_debug(4, "JBD: got buffer %llu (%p)\n",
405 (unsigned long long)bh->b_blocknr, bh->b_data);
406 header = (journal_header_t *)&bh->b_data[0];
407 header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
408 header->h_blocktype = cpu_to_be32(JFS_DESCRIPTOR_BLOCK);
409 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
411 tagp = &bh->b_data[sizeof(journal_header_t)];
412 space_left = bh->b_size - sizeof(journal_header_t);
414 set_buffer_jwrite(bh);
415 set_buffer_dirty(bh);
418 /* Record it so that we can wait for IO
420 BUFFER_TRACE(bh, "ph3: file as descriptor");
421 journal_file_buffer(descriptor, commit_transaction,
425 /* Where is the buffer to be written? */
427 err = journal_next_log_block(journal, &blocknr);
428 /* If the block mapping failed, just abandon the buffer
429 and repeat this loop: we'll fall into the
430 refile-on-abort condition above. */
432 __journal_abort_hard(journal);
437 * start_this_handle() uses t_outstanding_credits to determine
438 * the free space in the log, but this counter is changed
439 * by journal_next_log_block() also.
441 commit_transaction->t_outstanding_credits--;
443 /* Bump b_count to prevent truncate from stumbling over
444 the shadowed buffer! @@@ This can go if we ever get
445 rid of the BJ_IO/BJ_Shadow pairing of buffers. */
446 atomic_inc(&jh2bh(jh)->b_count);
448 /* Make a temporary IO buffer with which to write it out
449 (this will requeue both the metadata buffer and the
450 temporary IO buffer). new_bh goes on BJ_IO*/
452 set_bit(BH_JWrite, &jh2bh(jh)->b_state);
454 * akpm: journal_write_metadata_buffer() sets
455 * new_bh->b_transaction to commit_transaction.
456 * We need to clean this up before we release new_bh
457 * (which is of type BJ_IO)
459 JBUFFER_TRACE(jh, "ph3: write metadata");
460 flags = journal_write_metadata_buffer(commit_transaction,
461 jh, &new_jh, blocknr);
462 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
463 wbuf[bufs++] = jh2bh(new_jh);
465 /* Record the new block's tag in the current descriptor
470 tag_flag |= JFS_FLAG_ESCAPE;
472 tag_flag |= JFS_FLAG_SAME_UUID;
474 tag = (journal_block_tag_t *) tagp;
475 tag->t_blocknr = cpu_to_be32(jh2bh(jh)->b_blocknr);
476 tag->t_flags = cpu_to_be32(tag_flag);
477 tagp += sizeof(journal_block_tag_t);
478 space_left -= sizeof(journal_block_tag_t);
481 memcpy (tagp, journal->j_uuid, 16);
487 /* If there's no more to do, or if the descriptor is full,
490 if (bufs == ARRAY_SIZE(wbuf) ||
491 commit_transaction->t_buffers == NULL ||
492 space_left < sizeof(journal_block_tag_t) + 16) {
494 jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
496 /* Write an end-of-descriptor marker before
497 submitting the IOs. "tag" still points to
498 the last tag we set up. */
500 tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);
503 for (i = 0; i < bufs; i++) {
504 struct buffer_head *bh = wbuf[i];
506 clear_buffer_dirty(bh);
507 set_buffer_uptodate(bh);
508 bh->b_end_io = journal_end_buffer_io_sync;
509 submit_bh(WRITE, bh);
513 /* Force a new descriptor to be generated next
514 time round the loop. */
520 /* Lo and behold: we have just managed to send a transaction to
521 the log. Before we can commit it, wait for the IO so far to
522 complete. Control buffers being written are on the
523 transaction's t_log_list queue, and metadata buffers are on
524 the t_iobuf_list queue.
526 Wait for the buffers in reverse order. That way we are
527 less likely to be woken up until all IOs have completed, and
528 so we incur less scheduling load.
531 jbd_debug(3, "JBD: commit phase 4\n");
534 * akpm: these are BJ_IO, and j_list_lock is not needed.
535 * See __journal_try_to_free_buffer.
538 while (commit_transaction->t_iobuf_list != NULL) {
539 struct buffer_head *bh;
541 jh = commit_transaction->t_iobuf_list->b_tprev;
543 if (buffer_locked(bh)) {
550 if (unlikely(!buffer_uptodate(bh)))
553 clear_buffer_jwrite(bh);
555 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
556 journal_unfile_buffer(journal, jh);
559 * ->t_iobuf_list should contain only dummy buffer_heads
560 * which were created by journal_write_metadata_buffer().
562 BUFFER_TRACE(bh, "dumping temporary bh");
563 journal_put_journal_head(jh);
565 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
566 free_buffer_head(bh);
568 /* We also have to unlock and free the corresponding
570 jh = commit_transaction->t_shadow_list->b_tprev;
572 clear_bit(BH_JWrite, &bh->b_state);
573 J_ASSERT_BH(bh, buffer_jbddirty(bh));
575 /* The metadata is now released for reuse, but we need
576 to remember it against this transaction so that when
577 we finally commit, we can do any checkpointing
579 JBUFFER_TRACE(jh, "file as BJ_Forget");
580 journal_file_buffer(jh, commit_transaction, BJ_Forget);
581 /* Wake up any transactions which were waiting for this
583 wake_up_bit(&bh->b_state, BH_Unshadow);
584 JBUFFER_TRACE(jh, "brelse shadowed buffer");
588 J_ASSERT (commit_transaction->t_shadow_list == NULL);
590 jbd_debug(3, "JBD: commit phase 5\n");
592 /* Here we wait for the revoke record and descriptor record buffers */
594 while (commit_transaction->t_log_list != NULL) {
595 struct buffer_head *bh;
597 jh = commit_transaction->t_log_list->b_tprev;
599 if (buffer_locked(bh)) {
601 goto wait_for_ctlbuf;
604 goto wait_for_ctlbuf;
606 if (unlikely(!buffer_uptodate(bh)))
609 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
610 clear_buffer_jwrite(bh);
611 journal_unfile_buffer(journal, jh);
612 journal_put_journal_head(jh);
613 __brelse(bh); /* One for getblk */
614 /* AKPM: bforget here */
617 jbd_debug(3, "JBD: commit phase 6\n");
619 if (is_journal_aborted(journal))
622 /* Done it all: now write the commit record. We should have
623 * cleaned up our previous buffers by now, so if we are in abort
624 * mode we can now just skip the rest of the journal write
627 descriptor = journal_get_descriptor_buffer(journal);
629 __journal_abort_hard(journal);
633 /* AKPM: buglet - add `i' to tmp! */
634 for (i = 0; i < jh2bh(descriptor)->b_size; i += 512) {
635 journal_header_t *tmp =
636 (journal_header_t*)jh2bh(descriptor)->b_data;
637 tmp->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
638 tmp->h_blocktype = cpu_to_be32(JFS_COMMIT_BLOCK);
639 tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
642 JBUFFER_TRACE(descriptor, "write commit block");
644 struct buffer_head *bh = jh2bh(descriptor);
646 int barrier_done = 0;
648 set_buffer_dirty(bh);
649 if (journal->j_flags & JFS_BARRIER) {
650 set_buffer_ordered(bh);
653 ret = sync_dirty_buffer(bh);
654 /* is it possible for another commit to fail at roughly
655 * the same time as this one? If so, we don't want to
656 * trust the barrier flag in the super, but instead want
657 * to remember if we sent a barrier request
659 if (ret == -EOPNOTSUPP && barrier_done) {
660 char b[BDEVNAME_SIZE];
663 "JBD: barrier-based sync failed on %s - "
664 "disabling barriers\n",
665 bdevname(journal->j_dev, b));
666 spin_lock(&journal->j_state_lock);
667 journal->j_flags &= ~JFS_BARRIER;
668 spin_unlock(&journal->j_state_lock);
670 /* And try again, without the barrier */
671 clear_buffer_ordered(bh);
672 set_buffer_uptodate(bh);
673 set_buffer_dirty(bh);
674 ret = sync_dirty_buffer(bh);
676 if (unlikely(ret == -EIO))
678 put_bh(bh); /* One for getblk() */
679 journal_put_journal_head(descriptor);
682 /* End of a transaction! Finally, we can do checkpoint
683 processing: any buffers committed as a result of this
684 transaction can be removed from any checkpoint list it was on
687 skip_commit: /* The journal should be unlocked by now. */
690 __journal_abort_hard(journal);
692 jbd_debug(3, "JBD: commit phase 7\n");
694 J_ASSERT(commit_transaction->t_sync_datalist == NULL);
695 J_ASSERT(commit_transaction->t_buffers == NULL);
696 J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
697 J_ASSERT(commit_transaction->t_iobuf_list == NULL);
698 J_ASSERT(commit_transaction->t_shadow_list == NULL);
699 J_ASSERT(commit_transaction->t_log_list == NULL);
702 while (commit_transaction->t_forget) {
703 transaction_t *cp_transaction;
704 struct buffer_head *bh;
706 jh = commit_transaction->t_forget;
708 jbd_lock_bh_state(bh);
709 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction ||
710 jh->b_transaction == journal->j_running_transaction);
713 * If there is undo-protected committed data against
714 * this buffer, then we can remove it now. If it is a
715 * buffer needing such protection, the old frozen_data
716 * field now points to a committed version of the
717 * buffer, so rotate that field to the new committed
720 * Otherwise, we can just throw away the frozen data now.
722 if (jh->b_committed_data) {
723 kfree(jh->b_committed_data);
724 jh->b_committed_data = NULL;
725 if (jh->b_frozen_data) {
726 jh->b_committed_data = jh->b_frozen_data;
727 jh->b_frozen_data = NULL;
729 } else if (jh->b_frozen_data) {
730 kfree(jh->b_frozen_data);
731 jh->b_frozen_data = NULL;
734 spin_lock(&journal->j_list_lock);
735 cp_transaction = jh->b_cp_transaction;
736 if (cp_transaction) {
737 JBUFFER_TRACE(jh, "remove from old cp transaction");
738 __journal_remove_checkpoint(jh);
741 /* Only re-checkpoint the buffer_head if it is marked
742 * dirty. If the buffer was added to the BJ_Forget list
743 * by journal_forget, it may no longer be dirty and
744 * there's no point in keeping a checkpoint record for
747 /* A buffer which has been freed while still being
748 * journaled by a previous transaction may end up still
749 * being dirty here, but we want to avoid writing back
750 * that buffer in the future now that the last use has
751 * been committed. That's not only a performance gain,
752 * it also stops aliasing problems if the buffer is left
753 * behind for writeback and gets reallocated for another
754 * use in a different page. */
755 if (buffer_freed(bh)) {
756 clear_buffer_freed(bh);
757 clear_buffer_jbddirty(bh);
760 if (buffer_jbddirty(bh)) {
761 JBUFFER_TRACE(jh, "add to new checkpointing trans");
762 __journal_insert_checkpoint(jh, commit_transaction);
763 JBUFFER_TRACE(jh, "refile for checkpoint writeback");
764 __journal_refile_buffer(jh);
765 jbd_unlock_bh_state(bh);
767 J_ASSERT_BH(bh, !buffer_dirty(bh));
768 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
769 __journal_unfile_buffer(jh);
770 jbd_unlock_bh_state(bh);
771 journal_remove_journal_head(bh); /* needs a brelse */
772 release_buffer_page(bh);
774 spin_unlock(&journal->j_list_lock);
779 /* Done with this transaction! */
781 jbd_debug(3, "JBD: commit phase 8\n");
783 J_ASSERT(commit_transaction->t_state == T_COMMIT);
786 * This is a bit sleazy. We borrow j_list_lock to protect
787 * journal->j_committing_transaction in __journal_remove_checkpoint.
788 * Really, __jornal_remove_checkpoint should be using j_state_lock but
789 * it's a bit hassle to hold that across __journal_remove_checkpoint
791 spin_lock(&journal->j_state_lock);
792 spin_lock(&journal->j_list_lock);
793 commit_transaction->t_state = T_FINISHED;
794 J_ASSERT(commit_transaction == journal->j_committing_transaction);
795 journal->j_commit_sequence = commit_transaction->t_tid;
796 journal->j_committing_transaction = NULL;
797 spin_unlock(&journal->j_state_lock);
799 if (commit_transaction->t_checkpoint_list == NULL) {
800 __journal_drop_transaction(journal, commit_transaction);
802 if (journal->j_checkpoint_transactions == NULL) {
803 journal->j_checkpoint_transactions = commit_transaction;
804 commit_transaction->t_cpnext = commit_transaction;
805 commit_transaction->t_cpprev = commit_transaction;
807 commit_transaction->t_cpnext =
808 journal->j_checkpoint_transactions;
809 commit_transaction->t_cpprev =
810 commit_transaction->t_cpnext->t_cpprev;
811 commit_transaction->t_cpnext->t_cpprev =
813 commit_transaction->t_cpprev->t_cpnext =
817 spin_unlock(&journal->j_list_lock);
819 jbd_debug(1, "JBD: commit %d complete, head %d\n",
820 journal->j_commit_sequence, journal->j_tail_sequence);
822 wake_up(&journal->j_wait_done_commit);