2 * linux/fs/jbd2/commit.c
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/jbd2.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
22 #include <linux/pagemap.h>
23 #include <linux/jiffies.h>
24 #include <linux/crc32.h>
25 #include <linux/writeback.h>
26 #include <linux/backing-dev.h>
27 #include <linux/bio.h>
28 #include <linux/blkdev.h>
29 #include <linux/bitops.h>
30 #include <trace/events/jbd2.h>
33 * IO end handler for temporary buffer_heads handling writes to the journal.
35 static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
37 struct buffer_head *orig_bh = bh->b_private;
41 set_buffer_uptodate(bh);
43 clear_buffer_uptodate(bh);
45 clear_bit_unlock(BH_Shadow, &orig_bh->b_state);
46 smp_mb__after_clear_bit();
47 wake_up_bit(&orig_bh->b_state, BH_Shadow);
53 * When an ext4 file is truncated, it is possible that some pages are not
54 * successfully freed, because they are attached to a committing transaction.
55 * After the transaction commits, these pages are left on the LRU, with no
56 * ->mapping, and with attached buffers. These pages are trivially reclaimable
57 * by the VM, but their apparent absence upsets the VM accounting, and it makes
58 * the numbers in /proc/meminfo look odd.
60 * So here, we have a buffer which has just come off the forget list. Look to
61 * see if we can strip all buffers from the backing page.
63 * Called under lock_journal(), and possibly under journal_datalist_lock. The
64 * caller provided us with a ref against the buffer, and we drop that here.
66 static void release_buffer_page(struct buffer_head *bh)
72 if (atomic_read(&bh->b_count) != 1)
80 /* OK, it's a truncated page */
81 if (!trylock_page(page))
86 try_to_free_buffers(page);
88 page_cache_release(page);
95 static void jbd2_commit_block_csum_set(journal_t *j, struct buffer_head *bh)
97 struct commit_header *h;
100 if (!jbd2_journal_has_csum_v2or3(j))
103 h = (struct commit_header *)(bh->b_data);
104 h->h_chksum_type = 0;
105 h->h_chksum_size = 0;
107 csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
108 h->h_chksum[0] = cpu_to_be32(csum);
112 * Done it all: now submit the commit record. We should have
113 * cleaned up our previous buffers by now, so if we are in abort
114 * mode we can now just skip the rest of the journal write
117 * Returns 1 if the journal needs to be aborted or 0 on success
119 static int journal_submit_commit_record(journal_t *journal,
120 transaction_t *commit_transaction,
121 struct buffer_head **cbh,
124 struct commit_header *tmp;
125 struct buffer_head *bh;
127 struct timespec now = current_kernel_time();
131 if (is_journal_aborted(journal))
134 bh = jbd2_journal_get_descriptor_buffer(journal);
138 tmp = (struct commit_header *)bh->b_data;
139 tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
140 tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK);
141 tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
142 tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
143 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
145 if (JBD2_HAS_COMPAT_FEATURE(journal,
146 JBD2_FEATURE_COMPAT_CHECKSUM)) {
147 tmp->h_chksum_type = JBD2_CRC32_CHKSUM;
148 tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE;
149 tmp->h_chksum[0] = cpu_to_be32(crc32_sum);
151 jbd2_commit_block_csum_set(journal, bh);
153 BUFFER_TRACE(bh, "submit commit block");
155 clear_buffer_dirty(bh);
156 set_buffer_uptodate(bh);
157 bh->b_end_io = journal_end_buffer_io_sync;
159 if (journal->j_flags & JBD2_BARRIER &&
160 !JBD2_HAS_INCOMPAT_FEATURE(journal,
161 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT))
162 ret = submit_bh(WRITE_SYNC | WRITE_FLUSH_FUA, bh);
164 ret = submit_bh(WRITE_SYNC, bh);
171 * This function along with journal_submit_commit_record
172 * allows to write the commit record asynchronously.
174 static int journal_wait_on_commit_record(journal_t *journal,
175 struct buffer_head *bh)
179 clear_buffer_dirty(bh);
182 if (unlikely(!buffer_uptodate(bh)))
184 put_bh(bh); /* One for getblk() */
190 * write the filemap data using writepage() address_space_operations.
191 * We don't do block allocation here even for delalloc. We don't
192 * use writepages() because with dealyed allocation we may be doing
193 * block allocation in writepages().
195 static int journal_submit_inode_data_buffers(struct address_space *mapping)
198 struct writeback_control wbc = {
199 .sync_mode = WB_SYNC_ALL,
200 .nr_to_write = mapping->nrpages * 2,
202 .range_end = i_size_read(mapping->host),
205 ret = generic_writepages(mapping, &wbc);
210 * Submit all the data buffers of inode associated with the transaction to
213 * We are in a committing transaction. Therefore no new inode can be added to
214 * our inode list. We use JI_COMMIT_RUNNING flag to protect inode we currently
215 * operate on from being released while we write out pages.
217 static int journal_submit_data_buffers(journal_t *journal,
218 transaction_t *commit_transaction)
220 struct jbd2_inode *jinode;
222 struct address_space *mapping;
224 spin_lock(&journal->j_list_lock);
225 list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
226 mapping = jinode->i_vfs_inode->i_mapping;
227 set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
228 spin_unlock(&journal->j_list_lock);
230 * submit the inode data buffers. We use writepage
231 * instead of writepages. Because writepages can do
232 * block allocation with delalloc. We need to write
233 * only allocated blocks here.
235 trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
236 err = journal_submit_inode_data_buffers(mapping);
239 spin_lock(&journal->j_list_lock);
240 J_ASSERT(jinode->i_transaction == commit_transaction);
241 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
242 smp_mb__after_clear_bit();
243 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
245 spin_unlock(&journal->j_list_lock);
250 * Wait for data submitted for writeout, refile inodes to proper
251 * transaction if needed.
254 static int journal_finish_inode_data_buffers(journal_t *journal,
255 transaction_t *commit_transaction)
257 struct jbd2_inode *jinode, *next_i;
260 /* For locking, see the comment in journal_submit_data_buffers() */
261 spin_lock(&journal->j_list_lock);
262 list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
263 set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
264 spin_unlock(&journal->j_list_lock);
265 err = filemap_fdatawait(jinode->i_vfs_inode->i_mapping);
268 * Because AS_EIO is cleared by
269 * filemap_fdatawait_range(), set it again so
270 * that user process can get -EIO from fsync().
273 &jinode->i_vfs_inode->i_mapping->flags);
278 spin_lock(&journal->j_list_lock);
279 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
280 smp_mb__after_clear_bit();
281 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
284 /* Now refile inode to proper lists */
285 list_for_each_entry_safe(jinode, next_i,
286 &commit_transaction->t_inode_list, i_list) {
287 list_del(&jinode->i_list);
288 if (jinode->i_next_transaction) {
289 jinode->i_transaction = jinode->i_next_transaction;
290 jinode->i_next_transaction = NULL;
291 list_add(&jinode->i_list,
292 &jinode->i_transaction->t_inode_list);
294 jinode->i_transaction = NULL;
297 spin_unlock(&journal->j_list_lock);
302 static __u32 jbd2_checksum_data(__u32 crc32_sum, struct buffer_head *bh)
304 struct page *page = bh->b_page;
308 addr = kmap_atomic(page);
309 checksum = crc32_be(crc32_sum,
310 (void *)(addr + offset_in_page(bh->b_data)), bh->b_size);
316 static void write_tag_block(journal_t *j, journal_block_tag_t *tag,
317 unsigned long long block)
319 tag->t_blocknr = cpu_to_be32(block & (u32)~0);
320 if (JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_64BIT))
321 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
324 static void jbd2_descr_block_csum_set(journal_t *j,
325 struct buffer_head *bh)
327 struct jbd2_journal_block_tail *tail;
330 if (!jbd2_journal_has_csum_v2or3(j))
333 tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize -
334 sizeof(struct jbd2_journal_block_tail));
335 tail->t_checksum = 0;
336 csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
337 tail->t_checksum = cpu_to_be32(csum);
340 static void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
341 struct buffer_head *bh, __u32 sequence)
343 journal_block_tag3_t *tag3 = (journal_block_tag3_t *)tag;
344 struct page *page = bh->b_page;
349 if (!jbd2_journal_has_csum_v2or3(j))
352 seq = cpu_to_be32(sequence);
353 addr = kmap_atomic(page);
354 csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq));
355 csum32 = jbd2_chksum(j, csum32, addr + offset_in_page(bh->b_data),
359 if (JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V3))
360 tag3->t_checksum = cpu_to_be32(csum32);
362 tag->t_checksum = cpu_to_be16(csum32);
365 * jbd2_journal_commit_transaction
367 * The primary function for committing a transaction to the log. This
368 * function is called by the journal thread to begin a complete commit.
370 void jbd2_journal_commit_transaction(journal_t *journal)
372 struct transaction_stats_s stats;
373 transaction_t *commit_transaction;
374 struct journal_head *jh;
375 struct buffer_head *descriptor;
376 struct buffer_head **wbuf = journal->j_wbuf;
380 unsigned long long blocknr;
384 journal_header_t *header;
385 journal_block_tag_t *tag = NULL;
390 int tag_bytes = journal_tag_bytes(journal);
391 struct buffer_head *cbh = NULL; /* For transactional checksums */
392 __u32 crc32_sum = ~0;
393 struct blk_plug plug;
394 /* Tail of the journal */
395 unsigned long first_block;
402 if (jbd2_journal_has_csum_v2or3(journal))
403 csum_size = sizeof(struct jbd2_journal_block_tail);
406 * First job: lock down the current transaction and wait for
407 * all outstanding updates to complete.
410 /* Do we need to erase the effects of a prior jbd2_journal_flush? */
411 if (journal->j_flags & JBD2_FLUSHED) {
412 jbd_debug(3, "super block updated\n");
413 mutex_lock(&journal->j_checkpoint_mutex);
415 * We hold j_checkpoint_mutex so tail cannot change under us.
416 * We don't need any special data guarantees for writing sb
417 * since journal is empty and it is ok for write to be
418 * flushed only with transaction commit.
420 jbd2_journal_update_sb_log_tail(journal,
421 journal->j_tail_sequence,
424 mutex_unlock(&journal->j_checkpoint_mutex);
426 jbd_debug(3, "superblock not updated\n");
429 J_ASSERT(journal->j_running_transaction != NULL);
430 J_ASSERT(journal->j_committing_transaction == NULL);
432 commit_transaction = journal->j_running_transaction;
434 trace_jbd2_start_commit(journal, commit_transaction);
435 jbd_debug(1, "JBD2: starting commit of transaction %d\n",
436 commit_transaction->t_tid);
438 write_lock(&journal->j_state_lock);
439 J_ASSERT(commit_transaction->t_state == T_RUNNING);
440 commit_transaction->t_state = T_LOCKED;
442 trace_jbd2_commit_locking(journal, commit_transaction);
443 stats.run.rs_wait = commit_transaction->t_max_wait;
444 stats.run.rs_request_delay = 0;
445 stats.run.rs_locked = jiffies;
446 if (commit_transaction->t_requested)
447 stats.run.rs_request_delay =
448 jbd2_time_diff(commit_transaction->t_requested,
449 stats.run.rs_locked);
450 stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
451 stats.run.rs_locked);
453 spin_lock(&commit_transaction->t_handle_lock);
454 while (atomic_read(&commit_transaction->t_updates)) {
457 prepare_to_wait(&journal->j_wait_updates, &wait,
458 TASK_UNINTERRUPTIBLE);
459 if (atomic_read(&commit_transaction->t_updates)) {
460 spin_unlock(&commit_transaction->t_handle_lock);
461 write_unlock(&journal->j_state_lock);
463 write_lock(&journal->j_state_lock);
464 spin_lock(&commit_transaction->t_handle_lock);
466 finish_wait(&journal->j_wait_updates, &wait);
468 spin_unlock(&commit_transaction->t_handle_lock);
470 J_ASSERT (atomic_read(&commit_transaction->t_outstanding_credits) <=
471 journal->j_max_transaction_buffers);
474 * First thing we are allowed to do is to discard any remaining
475 * BJ_Reserved buffers. Note, it is _not_ permissible to assume
476 * that there are no such buffers: if a large filesystem
477 * operation like a truncate needs to split itself over multiple
478 * transactions, then it may try to do a jbd2_journal_restart() while
479 * there are still BJ_Reserved buffers outstanding. These must
480 * be released cleanly from the current transaction.
482 * In this case, the filesystem must still reserve write access
483 * again before modifying the buffer in the new transaction, but
484 * we do not require it to remember exactly which old buffers it
485 * has reserved. This is consistent with the existing behaviour
486 * that multiple jbd2_journal_get_write_access() calls to the same
487 * buffer are perfectly permissible.
489 while (commit_transaction->t_reserved_list) {
490 jh = commit_transaction->t_reserved_list;
491 JBUFFER_TRACE(jh, "reserved, unused: refile");
493 * A jbd2_journal_get_undo_access()+jbd2_journal_release_buffer() may
494 * leave undo-committed data.
496 if (jh->b_committed_data) {
497 struct buffer_head *bh = jh2bh(jh);
499 jbd_lock_bh_state(bh);
500 jbd2_free(jh->b_committed_data, bh->b_size);
501 jh->b_committed_data = NULL;
502 jbd_unlock_bh_state(bh);
504 jbd2_journal_refile_buffer(journal, jh);
508 * Now try to drop any written-back buffers from the journal's
509 * checkpoint lists. We do this *before* commit because it potentially
512 spin_lock(&journal->j_list_lock);
513 __jbd2_journal_clean_checkpoint_list(journal);
514 spin_unlock(&journal->j_list_lock);
516 jbd_debug(3, "JBD2: commit phase 1\n");
519 * Clear revoked flag to reflect there is no revoked buffers
520 * in the next transaction which is going to be started.
522 jbd2_clear_buffer_revoked_flags(journal);
525 * Switch to a new revoke table.
527 jbd2_journal_switch_revoke_table(journal);
530 * Reserved credits cannot be claimed anymore, free them
532 atomic_sub(atomic_read(&journal->j_reserved_credits),
533 &commit_transaction->t_outstanding_credits);
535 trace_jbd2_commit_flushing(journal, commit_transaction);
536 stats.run.rs_flushing = jiffies;
537 stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
538 stats.run.rs_flushing);
540 commit_transaction->t_state = T_FLUSH;
541 journal->j_committing_transaction = commit_transaction;
542 journal->j_running_transaction = NULL;
543 start_time = ktime_get();
544 commit_transaction->t_log_start = journal->j_head;
545 wake_up(&journal->j_wait_transaction_locked);
546 write_unlock(&journal->j_state_lock);
548 jbd_debug(3, "JBD2: commit phase 2a\n");
551 * Now start flushing things to disk, in the order they appear
552 * on the transaction lists. Data blocks go first.
554 err = journal_submit_data_buffers(journal, commit_transaction);
556 jbd2_journal_abort(journal, err);
558 blk_start_plug(&plug);
559 jbd2_journal_write_revoke_records(journal, commit_transaction,
560 &log_bufs, WRITE_SYNC);
561 blk_finish_plug(&plug);
563 jbd_debug(3, "JBD2: commit phase 2b\n");
566 * Way to go: we have now written out all of the data for a
567 * transaction! Now comes the tricky part: we need to write out
568 * metadata. Loop over the transaction's entire buffer list:
570 write_lock(&journal->j_state_lock);
571 commit_transaction->t_state = T_COMMIT;
572 write_unlock(&journal->j_state_lock);
574 trace_jbd2_commit_logging(journal, commit_transaction);
575 stats.run.rs_logging = jiffies;
576 stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
577 stats.run.rs_logging);
578 stats.run.rs_blocks =
579 atomic_read(&commit_transaction->t_outstanding_credits);
580 stats.run.rs_blocks_logged = 0;
582 J_ASSERT(commit_transaction->t_nr_buffers <=
583 atomic_read(&commit_transaction->t_outstanding_credits));
588 blk_start_plug(&plug);
589 while (commit_transaction->t_buffers) {
591 /* Find the next buffer to be journaled... */
593 jh = commit_transaction->t_buffers;
595 /* If we're in abort mode, we just un-journal the buffer and
598 if (is_journal_aborted(journal)) {
599 clear_buffer_jbddirty(jh2bh(jh));
600 JBUFFER_TRACE(jh, "journal is aborting: refile");
601 jbd2_buffer_abort_trigger(jh,
603 jh->b_frozen_triggers :
605 jbd2_journal_refile_buffer(journal, jh);
606 /* If that was the last one, we need to clean up
607 * any descriptor buffers which may have been
608 * already allocated, even if we are now
610 if (!commit_transaction->t_buffers)
611 goto start_journal_io;
615 /* Make sure we have a descriptor block in which to
616 record the metadata buffer. */
619 J_ASSERT (bufs == 0);
621 jbd_debug(4, "JBD2: get descriptor\n");
623 descriptor = jbd2_journal_get_descriptor_buffer(journal);
625 jbd2_journal_abort(journal, -EIO);
629 jbd_debug(4, "JBD2: got buffer %llu (%p)\n",
630 (unsigned long long)descriptor->b_blocknr,
632 header = (journal_header_t *)descriptor->b_data;
633 header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
634 header->h_blocktype = cpu_to_be32(JBD2_DESCRIPTOR_BLOCK);
635 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
637 tagp = &descriptor->b_data[sizeof(journal_header_t)];
638 space_left = descriptor->b_size -
639 sizeof(journal_header_t);
641 set_buffer_jwrite(descriptor);
642 set_buffer_dirty(descriptor);
643 wbuf[bufs++] = descriptor;
645 /* Record it so that we can wait for IO
647 BUFFER_TRACE(descriptor, "ph3: file as descriptor");
648 jbd2_file_log_bh(&log_bufs, descriptor);
651 /* Where is the buffer to be written? */
653 err = jbd2_journal_next_log_block(journal, &blocknr);
654 /* If the block mapping failed, just abandon the buffer
655 and repeat this loop: we'll fall into the
656 refile-on-abort condition above. */
658 jbd2_journal_abort(journal, err);
663 * start_this_handle() uses t_outstanding_credits to determine
664 * the free space in the log, but this counter is changed
665 * by jbd2_journal_next_log_block() also.
667 atomic_dec(&commit_transaction->t_outstanding_credits);
669 /* Bump b_count to prevent truncate from stumbling over
670 the shadowed buffer! @@@ This can go if we ever get
671 rid of the shadow pairing of buffers. */
672 atomic_inc(&jh2bh(jh)->b_count);
675 * Make a temporary IO buffer with which to write it out
676 * (this will requeue the metadata buffer to BJ_Shadow).
678 set_bit(BH_JWrite, &jh2bh(jh)->b_state);
679 JBUFFER_TRACE(jh, "ph3: write metadata");
680 flags = jbd2_journal_write_metadata_buffer(commit_transaction,
681 jh, &wbuf[bufs], blocknr);
683 jbd2_journal_abort(journal, flags);
686 jbd2_file_log_bh(&io_bufs, wbuf[bufs]);
688 /* Record the new block's tag in the current descriptor
693 tag_flag |= JBD2_FLAG_ESCAPE;
695 tag_flag |= JBD2_FLAG_SAME_UUID;
697 tag = (journal_block_tag_t *) tagp;
698 write_tag_block(journal, tag, jh2bh(jh)->b_blocknr);
699 tag->t_flags = cpu_to_be16(tag_flag);
700 jbd2_block_tag_csum_set(journal, tag, wbuf[bufs],
701 commit_transaction->t_tid);
703 space_left -= tag_bytes;
707 memcpy (tagp, journal->j_uuid, 16);
713 /* If there's no more to do, or if the descriptor is full,
716 if (bufs == journal->j_wbufsize ||
717 commit_transaction->t_buffers == NULL ||
718 space_left < tag_bytes + 16 + csum_size) {
720 jbd_debug(4, "JBD2: Submit %d IOs\n", bufs);
722 /* Write an end-of-descriptor marker before
723 submitting the IOs. "tag" still points to
724 the last tag we set up. */
726 tag->t_flags |= cpu_to_be16(JBD2_FLAG_LAST_TAG);
728 jbd2_descr_block_csum_set(journal, descriptor);
730 for (i = 0; i < bufs; i++) {
731 struct buffer_head *bh = wbuf[i];
735 if (JBD2_HAS_COMPAT_FEATURE(journal,
736 JBD2_FEATURE_COMPAT_CHECKSUM)) {
738 jbd2_checksum_data(crc32_sum, bh);
742 clear_buffer_dirty(bh);
743 set_buffer_uptodate(bh);
744 bh->b_end_io = journal_end_buffer_io_sync;
745 submit_bh(WRITE_SYNC, bh);
748 stats.run.rs_blocks_logged += bufs;
750 /* Force a new descriptor to be generated next
751 time round the loop. */
757 err = journal_finish_inode_data_buffers(journal, commit_transaction);
760 "JBD2: Detected IO errors while flushing file data "
761 "on %s\n", journal->j_devname);
762 if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
763 jbd2_journal_abort(journal, err);
768 * Get current oldest transaction in the log before we issue flush
769 * to the filesystem device. After the flush we can be sure that
770 * blocks of all older transactions are checkpointed to persistent
771 * storage and we will be safe to update journal start in the
772 * superblock with the numbers we get here.
775 jbd2_journal_get_log_tail(journal, &first_tid, &first_block);
777 write_lock(&journal->j_state_lock);
779 long freed = first_block - journal->j_tail;
781 if (first_block < journal->j_tail)
782 freed += journal->j_last - journal->j_first;
783 /* Update tail only if we free significant amount of space */
784 if (freed < journal->j_maxlen / 4)
787 J_ASSERT(commit_transaction->t_state == T_COMMIT);
788 commit_transaction->t_state = T_COMMIT_DFLUSH;
789 write_unlock(&journal->j_state_lock);
792 * If the journal is not located on the file system device,
793 * then we must flush the file system device before we issue
796 if (commit_transaction->t_need_data_flush &&
797 (journal->j_fs_dev != journal->j_dev) &&
798 (journal->j_flags & JBD2_BARRIER))
799 blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL);
801 /* Done it all: now write the commit record asynchronously. */
802 if (JBD2_HAS_INCOMPAT_FEATURE(journal,
803 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
804 err = journal_submit_commit_record(journal, commit_transaction,
807 __jbd2_journal_abort_hard(journal);
810 blk_finish_plug(&plug);
812 /* Lo and behold: we have just managed to send a transaction to
813 the log. Before we can commit it, wait for the IO so far to
814 complete. Control buffers being written are on the
815 transaction's t_log_list queue, and metadata buffers are on
818 Wait for the buffers in reverse order. That way we are
819 less likely to be woken up until all IOs have completed, and
820 so we incur less scheduling load.
823 jbd_debug(3, "JBD2: commit phase 3\n");
825 while (!list_empty(&io_bufs)) {
826 struct buffer_head *bh = list_entry(io_bufs.prev,
833 if (unlikely(!buffer_uptodate(bh)))
835 jbd2_unfile_log_bh(bh);
838 * The list contains temporary buffer heads created by
839 * jbd2_journal_write_metadata_buffer().
841 BUFFER_TRACE(bh, "dumping temporary bh");
843 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
844 free_buffer_head(bh);
846 /* We also have to refile the corresponding shadowed buffer */
847 jh = commit_transaction->t_shadow_list->b_tprev;
849 clear_buffer_jwrite(bh);
850 J_ASSERT_BH(bh, buffer_jbddirty(bh));
851 J_ASSERT_BH(bh, !buffer_shadow(bh));
853 /* The metadata is now released for reuse, but we need
854 to remember it against this transaction so that when
855 we finally commit, we can do any checkpointing
857 JBUFFER_TRACE(jh, "file as BJ_Forget");
858 jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);
859 JBUFFER_TRACE(jh, "brelse shadowed buffer");
863 J_ASSERT (commit_transaction->t_shadow_list == NULL);
865 jbd_debug(3, "JBD2: commit phase 4\n");
867 /* Here we wait for the revoke record and descriptor record buffers */
868 while (!list_empty(&log_bufs)) {
869 struct buffer_head *bh;
871 bh = list_entry(log_bufs.prev, struct buffer_head, b_assoc_buffers);
875 if (unlikely(!buffer_uptodate(bh)))
878 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
879 clear_buffer_jwrite(bh);
880 jbd2_unfile_log_bh(bh);
881 __brelse(bh); /* One for getblk */
882 /* AKPM: bforget here */
886 jbd2_journal_abort(journal, err);
888 jbd_debug(3, "JBD2: commit phase 5\n");
889 write_lock(&journal->j_state_lock);
890 J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH);
891 commit_transaction->t_state = T_COMMIT_JFLUSH;
892 write_unlock(&journal->j_state_lock);
894 if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
895 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
896 err = journal_submit_commit_record(journal, commit_transaction,
899 __jbd2_journal_abort_hard(journal);
902 err = journal_wait_on_commit_record(journal, cbh);
903 if (JBD2_HAS_INCOMPAT_FEATURE(journal,
904 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT) &&
905 journal->j_flags & JBD2_BARRIER) {
906 blkdev_issue_flush(journal->j_dev, GFP_NOFS, NULL);
910 jbd2_journal_abort(journal, err);
913 * Now disk caches for filesystem device are flushed so we are safe to
914 * erase checkpointed transactions from the log by updating journal
918 jbd2_update_log_tail(journal, first_tid, first_block);
920 /* End of a transaction! Finally, we can do checkpoint
921 processing: any buffers committed as a result of this
922 transaction can be removed from any checkpoint list it was on
925 jbd_debug(3, "JBD2: commit phase 6\n");
927 J_ASSERT(list_empty(&commit_transaction->t_inode_list));
928 J_ASSERT(commit_transaction->t_buffers == NULL);
929 J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
930 J_ASSERT(commit_transaction->t_shadow_list == NULL);
934 * As there are other places (journal_unmap_buffer()) adding buffers
935 * to this list we have to be careful and hold the j_list_lock.
937 spin_lock(&journal->j_list_lock);
938 while (commit_transaction->t_forget) {
939 transaction_t *cp_transaction;
940 struct buffer_head *bh;
943 jh = commit_transaction->t_forget;
944 spin_unlock(&journal->j_list_lock);
947 * Get a reference so that bh cannot be freed before we are
951 jbd_lock_bh_state(bh);
952 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction);
955 * If there is undo-protected committed data against
956 * this buffer, then we can remove it now. If it is a
957 * buffer needing such protection, the old frozen_data
958 * field now points to a committed version of the
959 * buffer, so rotate that field to the new committed
962 * Otherwise, we can just throw away the frozen data now.
964 * We also know that the frozen data has already fired
965 * its triggers if they exist, so we can clear that too.
967 if (jh->b_committed_data) {
968 jbd2_free(jh->b_committed_data, bh->b_size);
969 jh->b_committed_data = NULL;
970 if (jh->b_frozen_data) {
971 jh->b_committed_data = jh->b_frozen_data;
972 jh->b_frozen_data = NULL;
973 jh->b_frozen_triggers = NULL;
975 } else if (jh->b_frozen_data) {
976 jbd2_free(jh->b_frozen_data, bh->b_size);
977 jh->b_frozen_data = NULL;
978 jh->b_frozen_triggers = NULL;
981 spin_lock(&journal->j_list_lock);
982 cp_transaction = jh->b_cp_transaction;
983 if (cp_transaction) {
984 JBUFFER_TRACE(jh, "remove from old cp transaction");
985 cp_transaction->t_chp_stats.cs_dropped++;
986 __jbd2_journal_remove_checkpoint(jh);
989 /* Only re-checkpoint the buffer_head if it is marked
990 * dirty. If the buffer was added to the BJ_Forget list
991 * by jbd2_journal_forget, it may no longer be dirty and
992 * there's no point in keeping a checkpoint record for
996 * A buffer which has been freed while still being journaled by
997 * a previous transaction.
999 if (buffer_freed(bh)) {
1001 * If the running transaction is the one containing
1002 * "add to orphan" operation (b_next_transaction !=
1003 * NULL), we have to wait for that transaction to
1004 * commit before we can really get rid of the buffer.
1005 * So just clear b_modified to not confuse transaction
1006 * credit accounting and refile the buffer to
1007 * BJ_Forget of the running transaction. If the just
1008 * committed transaction contains "add to orphan"
1009 * operation, we can completely invalidate the buffer
1010 * now. We are rather through in that since the
1011 * buffer may be still accessible when blocksize <
1012 * pagesize and it is attached to the last partial
1016 if (!jh->b_next_transaction) {
1017 clear_buffer_freed(bh);
1018 clear_buffer_jbddirty(bh);
1019 clear_buffer_mapped(bh);
1020 clear_buffer_new(bh);
1021 clear_buffer_req(bh);
1026 if (buffer_jbddirty(bh)) {
1027 JBUFFER_TRACE(jh, "add to new checkpointing trans");
1028 __jbd2_journal_insert_checkpoint(jh, commit_transaction);
1029 if (is_journal_aborted(journal))
1030 clear_buffer_jbddirty(bh);
1032 J_ASSERT_BH(bh, !buffer_dirty(bh));
1034 * The buffer on BJ_Forget list and not jbddirty means
1035 * it has been freed by this transaction and hence it
1036 * could not have been reallocated until this
1037 * transaction has committed. *BUT* it could be
1038 * reallocated once we have written all the data to
1039 * disk and before we process the buffer on BJ_Forget
1042 if (!jh->b_next_transaction)
1045 JBUFFER_TRACE(jh, "refile or unfile buffer");
1046 __jbd2_journal_refile_buffer(jh);
1047 jbd_unlock_bh_state(bh);
1049 release_buffer_page(bh); /* Drops bh reference */
1052 cond_resched_lock(&journal->j_list_lock);
1054 spin_unlock(&journal->j_list_lock);
1056 * This is a bit sleazy. We use j_list_lock to protect transition
1057 * of a transaction into T_FINISHED state and calling
1058 * __jbd2_journal_drop_transaction(). Otherwise we could race with
1059 * other checkpointing code processing the transaction...
1061 write_lock(&journal->j_state_lock);
1062 spin_lock(&journal->j_list_lock);
1064 * Now recheck if some buffers did not get attached to the transaction
1065 * while the lock was dropped...
1067 if (commit_transaction->t_forget) {
1068 spin_unlock(&journal->j_list_lock);
1069 write_unlock(&journal->j_state_lock);
1073 /* Done with this transaction! */
1075 jbd_debug(3, "JBD2: commit phase 7\n");
1077 J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH);
1079 commit_transaction->t_start = jiffies;
1080 stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,
1081 commit_transaction->t_start);
1084 * File the transaction statistics
1086 stats.ts_tid = commit_transaction->t_tid;
1087 stats.run.rs_handle_count =
1088 atomic_read(&commit_transaction->t_handle_count);
1089 trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
1090 commit_transaction->t_tid, &stats.run);
1093 * Calculate overall stats
1095 spin_lock(&journal->j_history_lock);
1096 journal->j_stats.ts_tid++;
1097 if (commit_transaction->t_requested)
1098 journal->j_stats.ts_requested++;
1099 journal->j_stats.run.rs_wait += stats.run.rs_wait;
1100 journal->j_stats.run.rs_request_delay += stats.run.rs_request_delay;
1101 journal->j_stats.run.rs_running += stats.run.rs_running;
1102 journal->j_stats.run.rs_locked += stats.run.rs_locked;
1103 journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
1104 journal->j_stats.run.rs_logging += stats.run.rs_logging;
1105 journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
1106 journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
1107 journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
1108 spin_unlock(&journal->j_history_lock);
1110 commit_transaction->t_state = T_COMMIT_CALLBACK;
1111 J_ASSERT(commit_transaction == journal->j_committing_transaction);
1112 journal->j_commit_sequence = commit_transaction->t_tid;
1113 journal->j_committing_transaction = NULL;
1114 commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
1117 * weight the commit time higher than the average time so we don't
1118 * react too strongly to vast changes in the commit time
1120 if (likely(journal->j_average_commit_time))
1121 journal->j_average_commit_time = (commit_time +
1122 journal->j_average_commit_time*3) / 4;
1124 journal->j_average_commit_time = commit_time;
1126 write_unlock(&journal->j_state_lock);
1128 if (journal->j_checkpoint_transactions == NULL) {
1129 journal->j_checkpoint_transactions = commit_transaction;
1130 commit_transaction->t_cpnext = commit_transaction;
1131 commit_transaction->t_cpprev = commit_transaction;
1133 commit_transaction->t_cpnext =
1134 journal->j_checkpoint_transactions;
1135 commit_transaction->t_cpprev =
1136 commit_transaction->t_cpnext->t_cpprev;
1137 commit_transaction->t_cpnext->t_cpprev =
1139 commit_transaction->t_cpprev->t_cpnext =
1142 spin_unlock(&journal->j_list_lock);
1143 /* Drop all spin_locks because commit_callback may be block.
1144 * __journal_remove_checkpoint() can not destroy transaction
1145 * under us because it is not marked as T_FINISHED yet */
1146 if (journal->j_commit_callback)
1147 journal->j_commit_callback(journal, commit_transaction);
1149 trace_jbd2_end_commit(journal, commit_transaction);
1150 jbd_debug(1, "JBD2: commit %d complete, head %d\n",
1151 journal->j_commit_sequence, journal->j_tail_sequence);
1153 write_lock(&journal->j_state_lock);
1154 spin_lock(&journal->j_list_lock);
1155 commit_transaction->t_state = T_FINISHED;
1156 /* Recheck checkpoint lists after j_list_lock was dropped */
1157 if (commit_transaction->t_checkpoint_list == NULL &&
1158 commit_transaction->t_checkpoint_io_list == NULL) {
1159 __jbd2_journal_drop_transaction(journal, commit_transaction);
1160 jbd2_journal_free_transaction(commit_transaction);
1162 spin_unlock(&journal->j_list_lock);
1163 write_unlock(&journal->j_state_lock);
1164 wake_up(&journal->j_wait_done_commit);