blob: 7f21cf3aaf92e66d892259289cae31553423312b [file] [log] [blame]
Dave Kleikamp470decc2006-10-11 01:20:57 -07001/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002 * linux/fs/jbd2/commit.c
Dave Kleikamp470decc2006-10-11 01:20:57 -07003 *
4 * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
5 *
6 * Copyright 1998 Red Hat corp --- 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 * Journal commit routines for the generic filesystem journaling code;
13 * part of the ext2fs journaling system.
14 */
15
16#include <linux/time.h>
17#include <linux/fs.h>
Mingming Caof7f4bcc2006-10-11 01:20:59 -070018#include <linux/jbd2.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070019#include <linux/errno.h>
20#include <linux/slab.h>
21#include <linux/mm.h>
22#include <linux/pagemap.h>
Johann Lombardi8e85fb32008-01-28 23:58:27 -050023#include <linux/jiffies.h>
Girish Shilamkar818d2762008-01-28 23:58:27 -050024#include <linux/crc32.h>
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -040025#include <linux/writeback.h>
26#include <linux/backing-dev.h>
Theodore Ts'ofd984962009-01-05 21:34:13 -050027#include <linux/bio.h>
Theodore Ts'o0e3d2a62009-09-11 09:30:12 -040028#include <linux/blkdev.h>
Brian King39e3ac22010-10-27 21:25:12 -040029#include <linux/bitops.h>
Theodore Ts'o879c5e62009-06-17 11:47:48 -040030#include <trace/events/jbd2.h>
Brian King39e3ac22010-10-27 21:25:12 -040031#include <asm/system.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070032
33/*
34 * Default IO end handler for temporary BJ_IO buffer_heads.
35 */
36static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
37{
38 BUFFER_TRACE(bh, "");
39 if (uptodate)
40 set_buffer_uptodate(bh);
41 else
42 clear_buffer_uptodate(bh);
43 unlock_buffer(bh);
44}
45
46/*
Jan Kara87c89c22008-07-11 19:27:31 -040047 * When an ext4 file is truncated, it is possible that some pages are not
48 * successfully freed, because they are attached to a committing transaction.
Dave Kleikamp470decc2006-10-11 01:20:57 -070049 * After the transaction commits, these pages are left on the LRU, with no
50 * ->mapping, and with attached buffers. These pages are trivially reclaimable
51 * by the VM, but their apparent absence upsets the VM accounting, and it makes
52 * the numbers in /proc/meminfo look odd.
53 *
54 * So here, we have a buffer which has just come off the forget list. Look to
55 * see if we can strip all buffers from the backing page.
56 *
57 * Called under lock_journal(), and possibly under journal_datalist_lock. The
58 * caller provided us with a ref against the buffer, and we drop that here.
59 */
60static void release_buffer_page(struct buffer_head *bh)
61{
62 struct page *page;
63
64 if (buffer_dirty(bh))
65 goto nope;
66 if (atomic_read(&bh->b_count) != 1)
67 goto nope;
68 page = bh->b_page;
69 if (!page)
70 goto nope;
71 if (page->mapping)
72 goto nope;
73
74 /* OK, it's a truncated page */
Nick Piggin529ae9a2008-08-02 12:01:03 +020075 if (!trylock_page(page))
Dave Kleikamp470decc2006-10-11 01:20:57 -070076 goto nope;
77
78 page_cache_get(page);
79 __brelse(bh);
80 try_to_free_buffers(page);
81 unlock_page(page);
82 page_cache_release(page);
83 return;
84
85nope:
86 __brelse(bh);
87}
88
89/*
Girish Shilamkar818d2762008-01-28 23:58:27 -050090 * Done it all: now submit the commit record. We should have
Dave Kleikamp470decc2006-10-11 01:20:57 -070091 * cleaned up our previous buffers by now, so if we are in abort
92 * mode we can now just skip the rest of the journal write
93 * entirely.
94 *
95 * Returns 1 if the journal needs to be aborted or 0 on success
96 */
Girish Shilamkar818d2762008-01-28 23:58:27 -050097static int journal_submit_commit_record(journal_t *journal,
98 transaction_t *commit_transaction,
99 struct buffer_head **cbh,
100 __u32 crc32_sum)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700101{
102 struct journal_head *descriptor;
Girish Shilamkar818d2762008-01-28 23:58:27 -0500103 struct commit_header *tmp;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700104 struct buffer_head *bh;
Girish Shilamkar818d2762008-01-28 23:58:27 -0500105 int ret;
Theodore Ts'o736603a2008-07-11 19:27:31 -0400106 struct timespec now = current_kernel_time();
Dave Kleikamp470decc2006-10-11 01:20:57 -0700107
Zhang Huan6cba6112011-04-05 19:16:20 -0400108 *cbh = NULL;
109
Dave Kleikamp470decc2006-10-11 01:20:57 -0700110 if (is_journal_aborted(journal))
111 return 0;
112
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700113 descriptor = jbd2_journal_get_descriptor_buffer(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700114 if (!descriptor)
115 return 1;
116
117 bh = jh2bh(descriptor);
118
Girish Shilamkar818d2762008-01-28 23:58:27 -0500119 tmp = (struct commit_header *)bh->b_data;
120 tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
121 tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK);
122 tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
Theodore Ts'o736603a2008-07-11 19:27:31 -0400123 tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
124 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500125
126 if (JBD2_HAS_COMPAT_FEATURE(journal,
127 JBD2_FEATURE_COMPAT_CHECKSUM)) {
128 tmp->h_chksum_type = JBD2_CRC32_CHKSUM;
129 tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE;
130 tmp->h_chksum[0] = cpu_to_be32(crc32_sum);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700131 }
132
Girish Shilamkar818d2762008-01-28 23:58:27 -0500133 JBUFFER_TRACE(descriptor, "submit commit block");
134 lock_buffer(bh);
Theodore Ts'o45a90bf2008-10-06 12:04:02 -0400135 clear_buffer_dirty(bh);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500136 set_buffer_uptodate(bh);
137 bh->b_end_io = journal_end_buffer_io_sync;
138
139 if (journal->j_flags & JBD2_BARRIER &&
Theodore Ts'o0e3d2a62009-09-11 09:30:12 -0400140 !JBD2_HAS_INCOMPAT_FEATURE(journal,
Christoph Hellwig9c355752010-08-18 05:29:17 -0400141 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT))
Jens Axboe721a9602011-03-09 11:56:30 +0100142 ret = submit_bh(WRITE_SYNC | WRITE_FLUSH_FUA, bh);
Christoph Hellwig9c355752010-08-18 05:29:17 -0400143 else
Jens Axboe721a9602011-03-09 11:56:30 +0100144 ret = submit_bh(WRITE_SYNC, bh);
Christoph Hellwig9c355752010-08-18 05:29:17 -0400145
Girish Shilamkar818d2762008-01-28 23:58:27 -0500146 *cbh = bh;
147 return ret;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700148}
149
Girish Shilamkar818d2762008-01-28 23:58:27 -0500150/*
151 * This function along with journal_submit_commit_record
152 * allows to write the commit record asynchronously.
153 */
Theodore Ts'ofd984962009-01-05 21:34:13 -0500154static int journal_wait_on_commit_record(journal_t *journal,
155 struct buffer_head *bh)
Girish Shilamkar818d2762008-01-28 23:58:27 -0500156{
157 int ret = 0;
158
159 clear_buffer_dirty(bh);
160 wait_on_buffer(bh);
161
162 if (unlikely(!buffer_uptodate(bh)))
163 ret = -EIO;
164 put_bh(bh); /* One for getblk() */
165 jbd2_journal_put_journal_head(bh2jh(bh));
166
167 return ret;
168}
169
170/*
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400171 * write the filemap data using writepage() address_space_operations.
172 * We don't do block allocation here even for delalloc. We don't
173 * use writepages() because with dealyed allocation we may be doing
174 * block allocation in writepages().
175 */
176static int journal_submit_inode_data_buffers(struct address_space *mapping)
177{
178 int ret;
179 struct writeback_control wbc = {
180 .sync_mode = WB_SYNC_ALL,
181 .nr_to_write = mapping->nrpages * 2,
182 .range_start = 0,
183 .range_end = i_size_read(mapping->host),
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400184 };
185
186 ret = generic_writepages(mapping, &wbc);
187 return ret;
188}
189
190/*
Jan Karac851ed52008-07-11 19:27:31 -0400191 * Submit all the data buffers of inode associated with the transaction to
192 * disk.
193 *
194 * We are in a committing transaction. Therefore no new inode can be added to
195 * our inode list. We use JI_COMMIT_RUNNING flag to protect inode we currently
196 * operate on from being released while we write out pages.
197 */
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400198static int journal_submit_data_buffers(journal_t *journal,
Jan Karac851ed52008-07-11 19:27:31 -0400199 transaction_t *commit_transaction)
200{
201 struct jbd2_inode *jinode;
202 int err, ret = 0;
203 struct address_space *mapping;
204
205 spin_lock(&journal->j_list_lock);
206 list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
207 mapping = jinode->i_vfs_inode->i_mapping;
Brian King39e3ac22010-10-27 21:25:12 -0400208 set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
Jan Karac851ed52008-07-11 19:27:31 -0400209 spin_unlock(&journal->j_list_lock);
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400210 /*
211 * submit the inode data buffers. We use writepage
212 * instead of writepages. Because writepages can do
213 * block allocation with delalloc. We need to write
214 * only allocated blocks here.
215 */
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400216 trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400217 err = journal_submit_inode_data_buffers(mapping);
Jan Karac851ed52008-07-11 19:27:31 -0400218 if (!ret)
219 ret = err;
220 spin_lock(&journal->j_list_lock);
221 J_ASSERT(jinode->i_transaction == commit_transaction);
Brian King39e3ac22010-10-27 21:25:12 -0400222 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
223 smp_mb__after_clear_bit();
Jan Karac851ed52008-07-11 19:27:31 -0400224 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
225 }
226 spin_unlock(&journal->j_list_lock);
227 return ret;
228}
229
230/*
231 * Wait for data submitted for writeout, refile inodes to proper
232 * transaction if needed.
233 *
234 */
235static int journal_finish_inode_data_buffers(journal_t *journal,
236 transaction_t *commit_transaction)
237{
238 struct jbd2_inode *jinode, *next_i;
239 int err, ret = 0;
240
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400241 /* For locking, see the comment in journal_submit_data_buffers() */
Jan Karac851ed52008-07-11 19:27:31 -0400242 spin_lock(&journal->j_list_lock);
243 list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
Brian King39e3ac22010-10-27 21:25:12 -0400244 set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
Jan Karac851ed52008-07-11 19:27:31 -0400245 spin_unlock(&journal->j_list_lock);
246 err = filemap_fdatawait(jinode->i_vfs_inode->i_mapping);
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400247 if (err) {
248 /*
249 * Because AS_EIO is cleared by
Christoph Hellwig94004ed2009-09-30 22:16:33 +0200250 * filemap_fdatawait_range(), set it again so
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400251 * that user process can get -EIO from fsync().
252 */
253 set_bit(AS_EIO,
254 &jinode->i_vfs_inode->i_mapping->flags);
255
256 if (!ret)
257 ret = err;
258 }
Jan Karac851ed52008-07-11 19:27:31 -0400259 spin_lock(&journal->j_list_lock);
Brian King39e3ac22010-10-27 21:25:12 -0400260 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
261 smp_mb__after_clear_bit();
Jan Karac851ed52008-07-11 19:27:31 -0400262 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
263 }
264
265 /* Now refile inode to proper lists */
266 list_for_each_entry_safe(jinode, next_i,
267 &commit_transaction->t_inode_list, i_list) {
268 list_del(&jinode->i_list);
269 if (jinode->i_next_transaction) {
270 jinode->i_transaction = jinode->i_next_transaction;
271 jinode->i_next_transaction = NULL;
272 list_add(&jinode->i_list,
273 &jinode->i_transaction->t_inode_list);
274 } else {
275 jinode->i_transaction = NULL;
276 }
277 }
278 spin_unlock(&journal->j_list_lock);
279
280 return ret;
281}
282
Girish Shilamkar818d2762008-01-28 23:58:27 -0500283static __u32 jbd2_checksum_data(__u32 crc32_sum, struct buffer_head *bh)
284{
285 struct page *page = bh->b_page;
286 char *addr;
287 __u32 checksum;
288
289 addr = kmap_atomic(page, KM_USER0);
290 checksum = crc32_be(crc32_sum,
291 (void *)(addr + offset_in_page(bh->b_data)), bh->b_size);
292 kunmap_atomic(addr, KM_USER0);
293
294 return checksum;
295}
296
297static void write_tag_block(int tag_bytes, journal_block_tag_t *tag,
Mingming Cao18eba7a2006-10-11 01:21:13 -0700298 unsigned long long block)
Zach Brownb517bea2006-10-11 01:21:08 -0700299{
300 tag->t_blocknr = cpu_to_be32(block & (u32)~0);
Mingming Caocd02ff02007-10-16 18:38:25 -0400301 if (tag_bytes > JBD2_TAG_SIZE32)
Zach Brownb517bea2006-10-11 01:21:08 -0700302 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
303}
304
Dave Kleikamp470decc2006-10-11 01:20:57 -0700305/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700306 * jbd2_journal_commit_transaction
Dave Kleikamp470decc2006-10-11 01:20:57 -0700307 *
308 * The primary function for committing a transaction to the log. This
309 * function is called by the journal thread to begin a complete commit.
310 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700311void jbd2_journal_commit_transaction(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700312{
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500313 struct transaction_stats_s stats;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700314 transaction_t *commit_transaction;
315 struct journal_head *jh, *new_jh, *descriptor;
316 struct buffer_head **wbuf = journal->j_wbuf;
317 int bufs;
318 int flags;
319 int err;
Mingming Cao18eba7a2006-10-11 01:21:13 -0700320 unsigned long long blocknr;
Josef Bacike07f7182008-11-26 01:14:26 -0500321 ktime_t start_time;
322 u64 commit_time;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700323 char *tagp = NULL;
324 journal_header_t *header;
325 journal_block_tag_t *tag = NULL;
326 int space_left = 0;
327 int first_tag = 0;
328 int tag_flag;
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -0500329 int i, to_free = 0;
Zach Brownb517bea2006-10-11 01:21:08 -0700330 int tag_bytes = journal_tag_bytes(journal);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500331 struct buffer_head *cbh = NULL; /* For transactional checksums */
332 __u32 crc32_sum = ~0;
Jens Axboe82f04ab2011-03-17 11:01:52 +0100333 struct blk_plug plug;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700334
335 /*
336 * First job: lock down the current transaction and wait for
337 * all outstanding updates to complete.
338 */
339
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700340 /* Do we need to erase the effects of a prior jbd2_journal_flush? */
341 if (journal->j_flags & JBD2_FLUSHED) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700342 jbd_debug(3, "super block updated\n");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700343 jbd2_journal_update_superblock(journal, 1);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700344 } else {
345 jbd_debug(3, "superblock not updated\n");
346 }
347
348 J_ASSERT(journal->j_running_transaction != NULL);
349 J_ASSERT(journal->j_committing_transaction == NULL);
350
351 commit_transaction = journal->j_running_transaction;
352 J_ASSERT(commit_transaction->t_state == T_RUNNING);
353
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400354 trace_jbd2_start_commit(journal, commit_transaction);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700355 jbd_debug(1, "JBD: starting commit of transaction %d\n",
356 commit_transaction->t_tid);
357
Theodore Ts'oa931da62010-08-03 21:35:12 -0400358 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700359 commit_transaction->t_state = T_LOCKED;
360
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400361 trace_jbd2_commit_locking(journal, commit_transaction);
Theodore Ts'obf699322009-09-30 00:32:06 -0400362 stats.run.rs_wait = commit_transaction->t_max_wait;
363 stats.run.rs_locked = jiffies;
364 stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
365 stats.run.rs_locked);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500366
Dave Kleikamp470decc2006-10-11 01:20:57 -0700367 spin_lock(&commit_transaction->t_handle_lock);
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400368 while (atomic_read(&commit_transaction->t_updates)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700369 DEFINE_WAIT(wait);
370
371 prepare_to_wait(&journal->j_wait_updates, &wait,
372 TASK_UNINTERRUPTIBLE);
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400373 if (atomic_read(&commit_transaction->t_updates)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700374 spin_unlock(&commit_transaction->t_handle_lock);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400375 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700376 schedule();
Theodore Ts'oa931da62010-08-03 21:35:12 -0400377 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700378 spin_lock(&commit_transaction->t_handle_lock);
379 }
380 finish_wait(&journal->j_wait_updates, &wait);
381 }
382 spin_unlock(&commit_transaction->t_handle_lock);
383
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400384 J_ASSERT (atomic_read(&commit_transaction->t_outstanding_credits) <=
Dave Kleikamp470decc2006-10-11 01:20:57 -0700385 journal->j_max_transaction_buffers);
386
387 /*
388 * First thing we are allowed to do is to discard any remaining
389 * BJ_Reserved buffers. Note, it is _not_ permissible to assume
390 * that there are no such buffers: if a large filesystem
391 * operation like a truncate needs to split itself over multiple
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700392 * transactions, then it may try to do a jbd2_journal_restart() while
Dave Kleikamp470decc2006-10-11 01:20:57 -0700393 * there are still BJ_Reserved buffers outstanding. These must
394 * be released cleanly from the current transaction.
395 *
396 * In this case, the filesystem must still reserve write access
397 * again before modifying the buffer in the new transaction, but
398 * we do not require it to remember exactly which old buffers it
399 * has reserved. This is consistent with the existing behaviour
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700400 * that multiple jbd2_journal_get_write_access() calls to the same
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300401 * buffer are perfectly permissible.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700402 */
403 while (commit_transaction->t_reserved_list) {
404 jh = commit_transaction->t_reserved_list;
405 JBUFFER_TRACE(jh, "reserved, unused: refile");
406 /*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700407 * A jbd2_journal_get_undo_access()+jbd2_journal_release_buffer() may
Dave Kleikamp470decc2006-10-11 01:20:57 -0700408 * leave undo-committed data.
409 */
410 if (jh->b_committed_data) {
411 struct buffer_head *bh = jh2bh(jh);
412
413 jbd_lock_bh_state(bh);
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400414 jbd2_free(jh->b_committed_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700415 jh->b_committed_data = NULL;
416 jbd_unlock_bh_state(bh);
417 }
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700418 jbd2_journal_refile_buffer(journal, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700419 }
420
421 /*
422 * Now try to drop any written-back buffers from the journal's
423 * checkpoint lists. We do this *before* commit because it potentially
424 * frees some memory
425 */
426 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700427 __jbd2_journal_clean_checkpoint_list(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700428 spin_unlock(&journal->j_list_lock);
429
430 jbd_debug (3, "JBD: commit phase 1\n");
431
432 /*
433 * Switch to a new revoke table.
434 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700435 jbd2_journal_switch_revoke_table(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700436
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400437 trace_jbd2_commit_flushing(journal, commit_transaction);
Theodore Ts'obf699322009-09-30 00:32:06 -0400438 stats.run.rs_flushing = jiffies;
439 stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
440 stats.run.rs_flushing);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500441
Dave Kleikamp470decc2006-10-11 01:20:57 -0700442 commit_transaction->t_state = T_FLUSH;
443 journal->j_committing_transaction = commit_transaction;
444 journal->j_running_transaction = NULL;
Josef Bacike07f7182008-11-26 01:14:26 -0500445 start_time = ktime_get();
Dave Kleikamp470decc2006-10-11 01:20:57 -0700446 commit_transaction->t_log_start = journal->j_head;
447 wake_up(&journal->j_wait_transaction_locked);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400448 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700449
450 jbd_debug (3, "JBD: commit phase 2\n");
451
452 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700453 * Now start flushing things to disk, in the order they appear
454 * on the transaction lists. Data blocks go first.
455 */
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400456 err = journal_submit_data_buffers(journal, commit_transaction);
Jan Karac851ed52008-07-11 19:27:31 -0400457 if (err)
458 jbd2_journal_abort(journal, err);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700459
Jens Axboe82f04ab2011-03-17 11:01:52 +0100460 blk_start_plug(&plug);
Theodore Ts'o67c457a2009-04-14 07:50:56 -0400461 jbd2_journal_write_revoke_records(journal, commit_transaction,
Jens Axboe82f04ab2011-03-17 11:01:52 +0100462 WRITE_SYNC);
463 blk_finish_plug(&plug);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700464
465 jbd_debug(3, "JBD: commit phase 2\n");
466
467 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700468 * Way to go: we have now written out all of the data for a
469 * transaction! Now comes the tricky part: we need to write out
470 * metadata. Loop over the transaction's entire buffer list:
471 */
Theodore Ts'oa931da62010-08-03 21:35:12 -0400472 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700473 commit_transaction->t_state = T_COMMIT;
Theodore Ts'oa931da62010-08-03 21:35:12 -0400474 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700475
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400476 trace_jbd2_commit_logging(journal, commit_transaction);
Theodore Ts'obf699322009-09-30 00:32:06 -0400477 stats.run.rs_logging = jiffies;
478 stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
479 stats.run.rs_logging);
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400480 stats.run.rs_blocks =
481 atomic_read(&commit_transaction->t_outstanding_credits);
Theodore Ts'obf699322009-09-30 00:32:06 -0400482 stats.run.rs_blocks_logged = 0;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500483
Josef Bacik1dfc3222008-04-17 10:38:59 -0400484 J_ASSERT(commit_transaction->t_nr_buffers <=
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400485 atomic_read(&commit_transaction->t_outstanding_credits));
Josef Bacik1dfc3222008-04-17 10:38:59 -0400486
Jan Kara87c89c22008-07-11 19:27:31 -0400487 err = 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700488 descriptor = NULL;
489 bufs = 0;
Jens Axboe82f04ab2011-03-17 11:01:52 +0100490 blk_start_plug(&plug);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700491 while (commit_transaction->t_buffers) {
492
493 /* Find the next buffer to be journaled... */
494
495 jh = commit_transaction->t_buffers;
496
497 /* If we're in abort mode, we just un-journal the buffer and
Hidehiro Kawai7ad74452008-10-10 20:29:31 -0400498 release it. */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700499
500 if (is_journal_aborted(journal)) {
Hidehiro Kawai7ad74452008-10-10 20:29:31 -0400501 clear_buffer_jbddirty(jh2bh(jh));
Dave Kleikamp470decc2006-10-11 01:20:57 -0700502 JBUFFER_TRACE(jh, "journal is aborting: refile");
Joel Beckere06c8222008-09-11 15:35:47 -0700503 jbd2_buffer_abort_trigger(jh,
504 jh->b_frozen_data ?
505 jh->b_frozen_triggers :
506 jh->b_triggers);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700507 jbd2_journal_refile_buffer(journal, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700508 /* If that was the last one, we need to clean up
509 * any descriptor buffers which may have been
510 * already allocated, even if we are now
511 * aborting. */
512 if (!commit_transaction->t_buffers)
513 goto start_journal_io;
514 continue;
515 }
516
517 /* Make sure we have a descriptor block in which to
518 record the metadata buffer. */
519
520 if (!descriptor) {
521 struct buffer_head *bh;
522
523 J_ASSERT (bufs == 0);
524
525 jbd_debug(4, "JBD: get descriptor\n");
526
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700527 descriptor = jbd2_journal_get_descriptor_buffer(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700528 if (!descriptor) {
Jan Karaa7fa2ba2007-10-16 18:38:25 -0400529 jbd2_journal_abort(journal, -EIO);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700530 continue;
531 }
532
533 bh = jh2bh(descriptor);
534 jbd_debug(4, "JBD: got buffer %llu (%p)\n",
535 (unsigned long long)bh->b_blocknr, bh->b_data);
536 header = (journal_header_t *)&bh->b_data[0];
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700537 header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
538 header->h_blocktype = cpu_to_be32(JBD2_DESCRIPTOR_BLOCK);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700539 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
540
541 tagp = &bh->b_data[sizeof(journal_header_t)];
542 space_left = bh->b_size - sizeof(journal_header_t);
543 first_tag = 1;
544 set_buffer_jwrite(bh);
545 set_buffer_dirty(bh);
546 wbuf[bufs++] = bh;
547
548 /* Record it so that we can wait for IO
549 completion later */
550 BUFFER_TRACE(bh, "ph3: file as descriptor");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700551 jbd2_journal_file_buffer(descriptor, commit_transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700552 BJ_LogCtl);
553 }
554
555 /* Where is the buffer to be written? */
556
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700557 err = jbd2_journal_next_log_block(journal, &blocknr);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700558 /* If the block mapping failed, just abandon the buffer
559 and repeat this loop: we'll fall into the
560 refile-on-abort condition above. */
561 if (err) {
Jan Karaa7fa2ba2007-10-16 18:38:25 -0400562 jbd2_journal_abort(journal, err);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700563 continue;
564 }
565
566 /*
567 * start_this_handle() uses t_outstanding_credits to determine
568 * the free space in the log, but this counter is changed
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700569 * by jbd2_journal_next_log_block() also.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700570 */
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400571 atomic_dec(&commit_transaction->t_outstanding_credits);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700572
573 /* Bump b_count to prevent truncate from stumbling over
574 the shadowed buffer! @@@ This can go if we ever get
575 rid of the BJ_IO/BJ_Shadow pairing of buffers. */
576 atomic_inc(&jh2bh(jh)->b_count);
577
578 /* Make a temporary IO buffer with which to write it out
579 (this will requeue both the metadata buffer and the
580 temporary IO buffer). new_bh goes on BJ_IO*/
581
582 set_bit(BH_JWrite, &jh2bh(jh)->b_state);
583 /*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700584 * akpm: jbd2_journal_write_metadata_buffer() sets
Dave Kleikamp470decc2006-10-11 01:20:57 -0700585 * new_bh->b_transaction to commit_transaction.
586 * We need to clean this up before we release new_bh
587 * (which is of type BJ_IO)
588 */
589 JBUFFER_TRACE(jh, "ph3: write metadata");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700590 flags = jbd2_journal_write_metadata_buffer(commit_transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700591 jh, &new_jh, blocknr);
Theodore Ts'oe6ec1162009-12-01 09:04:42 -0500592 if (flags < 0) {
593 jbd2_journal_abort(journal, flags);
594 continue;
595 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700596 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
597 wbuf[bufs++] = jh2bh(new_jh);
598
599 /* Record the new block's tag in the current descriptor
600 buffer */
601
602 tag_flag = 0;
603 if (flags & 1)
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700604 tag_flag |= JBD2_FLAG_ESCAPE;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700605 if (!first_tag)
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700606 tag_flag |= JBD2_FLAG_SAME_UUID;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700607
608 tag = (journal_block_tag_t *) tagp;
Zach Brownb517bea2006-10-11 01:21:08 -0700609 write_tag_block(tag_bytes, tag, jh2bh(jh)->b_blocknr);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700610 tag->t_flags = cpu_to_be32(tag_flag);
Zach Brownb517bea2006-10-11 01:21:08 -0700611 tagp += tag_bytes;
612 space_left -= tag_bytes;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700613
614 if (first_tag) {
615 memcpy (tagp, journal->j_uuid, 16);
616 tagp += 16;
617 space_left -= 16;
618 first_tag = 0;
619 }
620
621 /* If there's no more to do, or if the descriptor is full,
622 let the IO rip! */
623
624 if (bufs == journal->j_wbufsize ||
625 commit_transaction->t_buffers == NULL ||
Zach Brownb517bea2006-10-11 01:21:08 -0700626 space_left < tag_bytes + 16) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700627
628 jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
629
630 /* Write an end-of-descriptor marker before
631 submitting the IOs. "tag" still points to
632 the last tag we set up. */
633
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700634 tag->t_flags |= cpu_to_be32(JBD2_FLAG_LAST_TAG);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700635
636start_journal_io:
637 for (i = 0; i < bufs; i++) {
638 struct buffer_head *bh = wbuf[i];
Girish Shilamkar818d2762008-01-28 23:58:27 -0500639 /*
640 * Compute checksum.
641 */
642 if (JBD2_HAS_COMPAT_FEATURE(journal,
643 JBD2_FEATURE_COMPAT_CHECKSUM)) {
644 crc32_sum =
645 jbd2_checksum_data(crc32_sum, bh);
646 }
647
Dave Kleikamp470decc2006-10-11 01:20:57 -0700648 lock_buffer(bh);
649 clear_buffer_dirty(bh);
650 set_buffer_uptodate(bh);
651 bh->b_end_io = journal_end_buffer_io_sync;
Jens Axboe82f04ab2011-03-17 11:01:52 +0100652 submit_bh(WRITE_SYNC, bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700653 }
654 cond_resched();
Theodore Ts'obf699322009-09-30 00:32:06 -0400655 stats.run.rs_blocks_logged += bufs;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700656
657 /* Force a new descriptor to be generated next
658 time round the loop. */
659 descriptor = NULL;
660 bufs = 0;
661 }
662 }
663
Jan Karac851ed52008-07-11 19:27:31 -0400664 err = journal_finish_inode_data_buffers(journal, commit_transaction);
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400665 if (err) {
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400666 printk(KERN_WARNING
667 "JBD2: Detected IO errors while flushing file data "
Theodore Ts'o05496762008-09-16 14:36:17 -0400668 "on %s\n", journal->j_devname);
Hidehiro Kawai5bf56832008-10-10 22:12:43 -0400669 if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
670 jbd2_journal_abort(journal, err);
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400671 err = 0;
672 }
Jan Karac851ed52008-07-11 19:27:31 -0400673
Jan Karabbd2be32011-05-24 11:59:18 -0400674 write_lock(&journal->j_state_lock);
675 J_ASSERT(commit_transaction->t_state == T_COMMIT);
676 commit_transaction->t_state = T_COMMIT_DFLUSH;
677 write_unlock(&journal->j_state_lock);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500678 /*
679 * If the journal is not located on the file system device,
680 * then we must flush the file system device before we issue
681 * the commit record
682 */
Jan Kara81be12c2011-05-24 11:52:40 -0400683 if (commit_transaction->t_need_data_flush &&
Girish Shilamkar818d2762008-01-28 23:58:27 -0500684 (journal->j_fs_dev != journal->j_dev) &&
685 (journal->j_flags & JBD2_BARRIER))
Christoph Hellwigdd3932e2010-09-16 20:51:46 +0200686 blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500687
688 /* Done it all: now write the commit record asynchronously. */
689 if (JBD2_HAS_INCOMPAT_FEATURE(journal,
690 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
691 err = journal_submit_commit_record(journal, commit_transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700692 &cbh, crc32_sum);
693 if (err)
694 __jbd2_journal_abort_hard(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700695 }
696
Jens Axboe82f04ab2011-03-17 11:01:52 +0100697 blk_finish_plug(&plug);
698
Dave Kleikamp470decc2006-10-11 01:20:57 -0700699 /* Lo and behold: we have just managed to send a transaction to
700 the log. Before we can commit it, wait for the IO so far to
701 complete. Control buffers being written are on the
702 transaction's t_log_list queue, and metadata buffers are on
703 the t_iobuf_list queue.
704
705 Wait for the buffers in reverse order. That way we are
706 less likely to be woken up until all IOs have completed, and
707 so we incur less scheduling load.
708 */
709
710 jbd_debug(3, "JBD: commit phase 3\n");
711
712 /*
713 * akpm: these are BJ_IO, and j_list_lock is not needed.
714 * See __journal_try_to_free_buffer.
715 */
716wait_for_iobuf:
717 while (commit_transaction->t_iobuf_list != NULL) {
718 struct buffer_head *bh;
719
720 jh = commit_transaction->t_iobuf_list->b_tprev;
721 bh = jh2bh(jh);
722 if (buffer_locked(bh)) {
723 wait_on_buffer(bh);
724 goto wait_for_iobuf;
725 }
726 if (cond_resched())
727 goto wait_for_iobuf;
728
729 if (unlikely(!buffer_uptodate(bh)))
730 err = -EIO;
731
732 clear_buffer_jwrite(bh);
733
734 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700735 jbd2_journal_unfile_buffer(journal, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700736
737 /*
738 * ->t_iobuf_list should contain only dummy buffer_heads
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700739 * which were created by jbd2_journal_write_metadata_buffer().
Dave Kleikamp470decc2006-10-11 01:20:57 -0700740 */
741 BUFFER_TRACE(bh, "dumping temporary bh");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700742 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700743 __brelse(bh);
744 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
745 free_buffer_head(bh);
746
747 /* We also have to unlock and free the corresponding
748 shadowed buffer */
749 jh = commit_transaction->t_shadow_list->b_tprev;
750 bh = jh2bh(jh);
751 clear_bit(BH_JWrite, &bh->b_state);
752 J_ASSERT_BH(bh, buffer_jbddirty(bh));
753
754 /* The metadata is now released for reuse, but we need
755 to remember it against this transaction so that when
756 we finally commit, we can do any checkpointing
757 required. */
758 JBUFFER_TRACE(jh, "file as BJ_Forget");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700759 jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);
Jan Kara229309c2011-05-08 19:09:53 -0400760 /*
761 * Wake up any transactions which were waiting for this IO to
762 * complete. The barrier must be here so that changes by
763 * jbd2_journal_file_buffer() take effect before wake_up_bit()
764 * does the waitqueue check.
765 */
766 smp_mb();
Dave Kleikamp470decc2006-10-11 01:20:57 -0700767 wake_up_bit(&bh->b_state, BH_Unshadow);
768 JBUFFER_TRACE(jh, "brelse shadowed buffer");
769 __brelse(bh);
770 }
771
772 J_ASSERT (commit_transaction->t_shadow_list == NULL);
773
Jan Kara87c89c22008-07-11 19:27:31 -0400774 jbd_debug(3, "JBD: commit phase 4\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700775
776 /* Here we wait for the revoke record and descriptor record buffers */
777 wait_for_ctlbuf:
778 while (commit_transaction->t_log_list != NULL) {
779 struct buffer_head *bh;
780
781 jh = commit_transaction->t_log_list->b_tprev;
782 bh = jh2bh(jh);
783 if (buffer_locked(bh)) {
784 wait_on_buffer(bh);
785 goto wait_for_ctlbuf;
786 }
787 if (cond_resched())
788 goto wait_for_ctlbuf;
789
790 if (unlikely(!buffer_uptodate(bh)))
791 err = -EIO;
792
793 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
794 clear_buffer_jwrite(bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700795 jbd2_journal_unfile_buffer(journal, jh);
796 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700797 __brelse(bh); /* One for getblk */
798 /* AKPM: bforget here */
799 }
800
Hidehiro Kawai77e841d2008-10-12 16:39:16 -0400801 if (err)
802 jbd2_journal_abort(journal, err);
803
Jan Kara87c89c22008-07-11 19:27:31 -0400804 jbd_debug(3, "JBD: commit phase 5\n");
Jan Karabbd2be32011-05-24 11:59:18 -0400805 write_lock(&journal->j_state_lock);
806 J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH);
807 commit_transaction->t_state = T_COMMIT_JFLUSH;
808 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700809
Girish Shilamkar818d2762008-01-28 23:58:27 -0500810 if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
Theodore Ts'o0e3d2a62009-09-11 09:30:12 -0400811 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
Girish Shilamkar818d2762008-01-28 23:58:27 -0500812 err = journal_submit_commit_record(journal, commit_transaction,
813 &cbh, crc32_sum);
814 if (err)
815 __jbd2_journal_abort_hard(journal);
816 }
Zhang Huan6cba6112011-04-05 19:16:20 -0400817 if (cbh)
Theodore Ts'ofd984962009-01-05 21:34:13 -0500818 err = journal_wait_on_commit_record(journal, cbh);
Jan Karaf73bee42010-08-18 15:56:56 +0200819 if (JBD2_HAS_INCOMPAT_FEATURE(journal,
820 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT) &&
821 journal->j_flags & JBD2_BARRIER) {
Christoph Hellwigdd3932e2010-09-16 20:51:46 +0200822 blkdev_issue_flush(journal->j_dev, GFP_KERNEL, NULL);
Jan Karaf73bee42010-08-18 15:56:56 +0200823 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700824
825 if (err)
Jan Karaa7fa2ba2007-10-16 18:38:25 -0400826 jbd2_journal_abort(journal, err);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700827
828 /* End of a transaction! Finally, we can do checkpoint
829 processing: any buffers committed as a result of this
830 transaction can be removed from any checkpoint list it was on
831 before. */
832
Jan Kara87c89c22008-07-11 19:27:31 -0400833 jbd_debug(3, "JBD: commit phase 6\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700834
Jan Karac851ed52008-07-11 19:27:31 -0400835 J_ASSERT(list_empty(&commit_transaction->t_inode_list));
Dave Kleikamp470decc2006-10-11 01:20:57 -0700836 J_ASSERT(commit_transaction->t_buffers == NULL);
837 J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
838 J_ASSERT(commit_transaction->t_iobuf_list == NULL);
839 J_ASSERT(commit_transaction->t_shadow_list == NULL);
840 J_ASSERT(commit_transaction->t_log_list == NULL);
841
842restart_loop:
843 /*
844 * As there are other places (journal_unmap_buffer()) adding buffers
845 * to this list we have to be careful and hold the j_list_lock.
846 */
847 spin_lock(&journal->j_list_lock);
848 while (commit_transaction->t_forget) {
849 transaction_t *cp_transaction;
850 struct buffer_head *bh;
851
852 jh = commit_transaction->t_forget;
853 spin_unlock(&journal->j_list_lock);
854 bh = jh2bh(jh);
855 jbd_lock_bh_state(bh);
dingdinghua23e2af32010-02-24 12:11:20 -0500856 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700857
858 /*
859 * If there is undo-protected committed data against
860 * this buffer, then we can remove it now. If it is a
861 * buffer needing such protection, the old frozen_data
862 * field now points to a committed version of the
863 * buffer, so rotate that field to the new committed
864 * data.
865 *
866 * Otherwise, we can just throw away the frozen data now.
Joel Beckere06c8222008-09-11 15:35:47 -0700867 *
868 * We also know that the frozen data has already fired
869 * its triggers if they exist, so we can clear that too.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700870 */
871 if (jh->b_committed_data) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400872 jbd2_free(jh->b_committed_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700873 jh->b_committed_data = NULL;
874 if (jh->b_frozen_data) {
875 jh->b_committed_data = jh->b_frozen_data;
876 jh->b_frozen_data = NULL;
Joel Beckere06c8222008-09-11 15:35:47 -0700877 jh->b_frozen_triggers = NULL;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700878 }
879 } else if (jh->b_frozen_data) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400880 jbd2_free(jh->b_frozen_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700881 jh->b_frozen_data = NULL;
Joel Beckere06c8222008-09-11 15:35:47 -0700882 jh->b_frozen_triggers = NULL;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700883 }
884
885 spin_lock(&journal->j_list_lock);
886 cp_transaction = jh->b_cp_transaction;
887 if (cp_transaction) {
888 JBUFFER_TRACE(jh, "remove from old cp transaction");
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500889 cp_transaction->t_chp_stats.cs_dropped++;
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700890 __jbd2_journal_remove_checkpoint(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700891 }
892
893 /* Only re-checkpoint the buffer_head if it is marked
894 * dirty. If the buffer was added to the BJ_Forget list
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700895 * by jbd2_journal_forget, it may no longer be dirty and
Dave Kleikamp470decc2006-10-11 01:20:57 -0700896 * there's no point in keeping a checkpoint record for
897 * it. */
898
899 /* A buffer which has been freed while still being
900 * journaled by a previous transaction may end up still
901 * being dirty here, but we want to avoid writing back
dingdinghuaba869022010-02-15 16:35:42 -0500902 * that buffer in the future after the "add to orphan"
903 * operation been committed, That's not only a performance
904 * gain, it also stops aliasing problems if the buffer is
905 * left behind for writeback and gets reallocated for another
Dave Kleikamp470decc2006-10-11 01:20:57 -0700906 * use in a different page. */
dingdinghuaba869022010-02-15 16:35:42 -0500907 if (buffer_freed(bh) && !jh->b_next_transaction) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700908 clear_buffer_freed(bh);
909 clear_buffer_jbddirty(bh);
910 }
911
912 if (buffer_jbddirty(bh)) {
913 JBUFFER_TRACE(jh, "add to new checkpointing trans");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700914 __jbd2_journal_insert_checkpoint(jh, commit_transaction);
Hidehiro Kawai7ad74452008-10-10 20:29:31 -0400915 if (is_journal_aborted(journal))
916 clear_buffer_jbddirty(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700917 JBUFFER_TRACE(jh, "refile for checkpoint writeback");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700918 __jbd2_journal_refile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700919 jbd_unlock_bh_state(bh);
920 } else {
921 J_ASSERT_BH(bh, !buffer_dirty(bh));
922 /* The buffer on BJ_Forget list and not jbddirty means
923 * it has been freed by this transaction and hence it
924 * could not have been reallocated until this
925 * transaction has committed. *BUT* it could be
926 * reallocated once we have written all the data to
927 * disk and before we process the buffer on BJ_Forget
928 * list. */
929 JBUFFER_TRACE(jh, "refile or unfile freed buffer");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700930 __jbd2_journal_refile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700931 if (!jh->b_transaction) {
932 jbd_unlock_bh_state(bh);
933 /* needs a brelse */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700934 jbd2_journal_remove_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700935 release_buffer_page(bh);
936 } else
937 jbd_unlock_bh_state(bh);
938 }
939 cond_resched_lock(&journal->j_list_lock);
940 }
941 spin_unlock(&journal->j_list_lock);
942 /*
Jan Karaf5a7a6b2008-01-28 23:58:27 -0500943 * This is a bit sleazy. We use j_list_lock to protect transition
944 * of a transaction into T_FINISHED state and calling
945 * __jbd2_journal_drop_transaction(). Otherwise we could race with
946 * other checkpointing code processing the transaction...
Dave Kleikamp470decc2006-10-11 01:20:57 -0700947 */
Theodore Ts'oa931da62010-08-03 21:35:12 -0400948 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700949 spin_lock(&journal->j_list_lock);
950 /*
951 * Now recheck if some buffers did not get attached to the transaction
952 * while the lock was dropped...
953 */
954 if (commit_transaction->t_forget) {
955 spin_unlock(&journal->j_list_lock);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400956 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700957 goto restart_loop;
958 }
959
960 /* Done with this transaction! */
961
Jan Kara87c89c22008-07-11 19:27:31 -0400962 jbd_debug(3, "JBD: commit phase 7\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700963
Jan Karabbd2be32011-05-24 11:59:18 -0400964 J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700965
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500966 commit_transaction->t_start = jiffies;
Theodore Ts'obf699322009-09-30 00:32:06 -0400967 stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,
968 commit_transaction->t_start);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500969
970 /*
Theodore Ts'obf699322009-09-30 00:32:06 -0400971 * File the transaction statistics
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500972 */
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500973 stats.ts_tid = commit_transaction->t_tid;
Theodore Ts'o8dd42042010-08-03 21:38:29 -0400974 stats.run.rs_handle_count =
975 atomic_read(&commit_transaction->t_handle_count);
Theodore Ts'obf699322009-09-30 00:32:06 -0400976 trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
977 commit_transaction->t_tid, &stats.run);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500978
979 /*
980 * Calculate overall stats
981 */
Theodore Ts'obf699322009-09-30 00:32:06 -0400982 spin_lock(&journal->j_history_lock);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500983 journal->j_stats.ts_tid++;
Theodore Ts'obf699322009-09-30 00:32:06 -0400984 journal->j_stats.run.rs_wait += stats.run.rs_wait;
985 journal->j_stats.run.rs_running += stats.run.rs_running;
986 journal->j_stats.run.rs_locked += stats.run.rs_locked;
987 journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
988 journal->j_stats.run.rs_logging += stats.run.rs_logging;
989 journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
990 journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
991 journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500992 spin_unlock(&journal->j_history_lock);
993
Dave Kleikamp470decc2006-10-11 01:20:57 -0700994 commit_transaction->t_state = T_FINISHED;
995 J_ASSERT(commit_transaction == journal->j_committing_transaction);
996 journal->j_commit_sequence = commit_transaction->t_tid;
997 journal->j_committing_transaction = NULL;
Josef Bacike07f7182008-11-26 01:14:26 -0500998 commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
Dave Kleikamp470decc2006-10-11 01:20:57 -0700999
Josef Bacike07f7182008-11-26 01:14:26 -05001000 /*
1001 * weight the commit time higher than the average time so we don't
1002 * react too strongly to vast changes in the commit time
1003 */
1004 if (likely(journal->j_average_commit_time))
1005 journal->j_average_commit_time = (commit_time +
1006 journal->j_average_commit_time*3) / 4;
1007 else
1008 journal->j_average_commit_time = commit_time;
Theodore Ts'oa931da62010-08-03 21:35:12 -04001009 write_unlock(&journal->j_state_lock);
Theodore Ts'o6c20ec82008-10-28 21:08:20 -04001010
Jan Karaf89b7792007-07-15 23:37:20 -07001011 if (commit_transaction->t_checkpoint_list == NULL &&
1012 commit_transaction->t_checkpoint_io_list == NULL) {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001013 __jbd2_journal_drop_transaction(journal, commit_transaction);
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -05001014 to_free = 1;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001015 } else {
1016 if (journal->j_checkpoint_transactions == NULL) {
1017 journal->j_checkpoint_transactions = commit_transaction;
1018 commit_transaction->t_cpnext = commit_transaction;
1019 commit_transaction->t_cpprev = commit_transaction;
1020 } else {
1021 commit_transaction->t_cpnext =
1022 journal->j_checkpoint_transactions;
1023 commit_transaction->t_cpprev =
1024 commit_transaction->t_cpnext->t_cpprev;
1025 commit_transaction->t_cpnext->t_cpprev =
1026 commit_transaction;
1027 commit_transaction->t_cpprev->t_cpnext =
1028 commit_transaction;
1029 }
1030 }
1031 spin_unlock(&journal->j_list_lock);
1032
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -05001033 if (journal->j_commit_callback)
1034 journal->j_commit_callback(journal, commit_transaction);
1035
Theodore Ts'o879c5e62009-06-17 11:47:48 -04001036 trace_jbd2_end_commit(journal, commit_transaction);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001037 jbd_debug(1, "JBD: commit %d complete, head %d\n",
1038 journal->j_commit_sequence, journal->j_tail_sequence);
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -05001039 if (to_free)
1040 kfree(commit_transaction);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001041
1042 wake_up(&journal->j_wait_done_commit);
1043}