blob: 3091d42992f0d934eb4355022efaa5c83ad1be0d [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>
Dave Kleikamp470decc2006-10-11 01:20:57 -070031
32/*
33 * Default IO end handler for temporary BJ_IO buffer_heads.
34 */
35static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
36{
37 BUFFER_TRACE(bh, "");
38 if (uptodate)
39 set_buffer_uptodate(bh);
40 else
41 clear_buffer_uptodate(bh);
42 unlock_buffer(bh);
43}
44
45/*
Jan Kara87c89c22008-07-11 19:27:31 -040046 * When an ext4 file is truncated, it is possible that some pages are not
47 * successfully freed, because they are attached to a committing transaction.
Dave Kleikamp470decc2006-10-11 01:20:57 -070048 * After the transaction commits, these pages are left on the LRU, with no
49 * ->mapping, and with attached buffers. These pages are trivially reclaimable
50 * by the VM, but their apparent absence upsets the VM accounting, and it makes
51 * the numbers in /proc/meminfo look odd.
52 *
53 * So here, we have a buffer which has just come off the forget list. Look to
54 * see if we can strip all buffers from the backing page.
55 *
56 * Called under lock_journal(), and possibly under journal_datalist_lock. The
57 * caller provided us with a ref against the buffer, and we drop that here.
58 */
59static void release_buffer_page(struct buffer_head *bh)
60{
61 struct page *page;
62
63 if (buffer_dirty(bh))
64 goto nope;
65 if (atomic_read(&bh->b_count) != 1)
66 goto nope;
67 page = bh->b_page;
68 if (!page)
69 goto nope;
70 if (page->mapping)
71 goto nope;
72
73 /* OK, it's a truncated page */
Nick Piggin529ae9a2008-08-02 12:01:03 +020074 if (!trylock_page(page))
Dave Kleikamp470decc2006-10-11 01:20:57 -070075 goto nope;
76
77 page_cache_get(page);
78 __brelse(bh);
79 try_to_free_buffers(page);
80 unlock_page(page);
81 page_cache_release(page);
82 return;
83
84nope:
85 __brelse(bh);
86}
87
Darrick J. Wong1f56c582012-05-27 08:10:25 -040088static void jbd2_commit_block_csum_set(journal_t *j,
89 struct journal_head *descriptor)
90{
91 struct commit_header *h;
92 __u32 csum;
93
94 if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
95 return;
96
97 h = (struct commit_header *)(jh2bh(descriptor)->b_data);
98 h->h_chksum_type = 0;
99 h->h_chksum_size = 0;
100 h->h_chksum[0] = 0;
101 csum = jbd2_chksum(j, j->j_csum_seed, jh2bh(descriptor)->b_data,
102 j->j_blocksize);
103 h->h_chksum[0] = cpu_to_be32(csum);
104}
105
Dave Kleikamp470decc2006-10-11 01:20:57 -0700106/*
Girish Shilamkar818d2762008-01-28 23:58:27 -0500107 * Done it all: now submit the commit record. We should have
Dave Kleikamp470decc2006-10-11 01:20:57 -0700108 * cleaned up our previous buffers by now, so if we are in abort
109 * mode we can now just skip the rest of the journal write
110 * entirely.
111 *
112 * Returns 1 if the journal needs to be aborted or 0 on success
113 */
Girish Shilamkar818d2762008-01-28 23:58:27 -0500114static int journal_submit_commit_record(journal_t *journal,
115 transaction_t *commit_transaction,
116 struct buffer_head **cbh,
117 __u32 crc32_sum)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700118{
119 struct journal_head *descriptor;
Girish Shilamkar818d2762008-01-28 23:58:27 -0500120 struct commit_header *tmp;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700121 struct buffer_head *bh;
Girish Shilamkar818d2762008-01-28 23:58:27 -0500122 int ret;
Theodore Ts'o736603a2008-07-11 19:27:31 -0400123 struct timespec now = current_kernel_time();
Dave Kleikamp470decc2006-10-11 01:20:57 -0700124
Zhang Huan6cba6112011-04-05 19:16:20 -0400125 *cbh = NULL;
126
Dave Kleikamp470decc2006-10-11 01:20:57 -0700127 if (is_journal_aborted(journal))
128 return 0;
129
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700130 descriptor = jbd2_journal_get_descriptor_buffer(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700131 if (!descriptor)
132 return 1;
133
134 bh = jh2bh(descriptor);
135
Girish Shilamkar818d2762008-01-28 23:58:27 -0500136 tmp = (struct commit_header *)bh->b_data;
137 tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
138 tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK);
139 tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
Theodore Ts'o736603a2008-07-11 19:27:31 -0400140 tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
141 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500142
143 if (JBD2_HAS_COMPAT_FEATURE(journal,
144 JBD2_FEATURE_COMPAT_CHECKSUM)) {
145 tmp->h_chksum_type = JBD2_CRC32_CHKSUM;
146 tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE;
147 tmp->h_chksum[0] = cpu_to_be32(crc32_sum);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700148 }
Darrick J. Wong1f56c582012-05-27 08:10:25 -0400149 jbd2_commit_block_csum_set(journal, descriptor);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700150
Girish Shilamkar818d2762008-01-28 23:58:27 -0500151 JBUFFER_TRACE(descriptor, "submit commit block");
152 lock_buffer(bh);
Theodore Ts'o45a90bf2008-10-06 12:04:02 -0400153 clear_buffer_dirty(bh);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500154 set_buffer_uptodate(bh);
155 bh->b_end_io = journal_end_buffer_io_sync;
156
157 if (journal->j_flags & JBD2_BARRIER &&
Theodore Ts'o0e3d2a62009-09-11 09:30:12 -0400158 !JBD2_HAS_INCOMPAT_FEATURE(journal,
Christoph Hellwig9c355752010-08-18 05:29:17 -0400159 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT))
Jens Axboe721a9602011-03-09 11:56:30 +0100160 ret = submit_bh(WRITE_SYNC | WRITE_FLUSH_FUA, bh);
Christoph Hellwig9c355752010-08-18 05:29:17 -0400161 else
Jens Axboe721a9602011-03-09 11:56:30 +0100162 ret = submit_bh(WRITE_SYNC, bh);
Christoph Hellwig9c355752010-08-18 05:29:17 -0400163
Girish Shilamkar818d2762008-01-28 23:58:27 -0500164 *cbh = bh;
165 return ret;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700166}
167
Girish Shilamkar818d2762008-01-28 23:58:27 -0500168/*
169 * This function along with journal_submit_commit_record
170 * allows to write the commit record asynchronously.
171 */
Theodore Ts'ofd984962009-01-05 21:34:13 -0500172static int journal_wait_on_commit_record(journal_t *journal,
173 struct buffer_head *bh)
Girish Shilamkar818d2762008-01-28 23:58:27 -0500174{
175 int ret = 0;
176
177 clear_buffer_dirty(bh);
178 wait_on_buffer(bh);
179
180 if (unlikely(!buffer_uptodate(bh)))
181 ret = -EIO;
182 put_bh(bh); /* One for getblk() */
183 jbd2_journal_put_journal_head(bh2jh(bh));
184
185 return ret;
186}
187
188/*
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400189 * write the filemap data using writepage() address_space_operations.
190 * We don't do block allocation here even for delalloc. We don't
191 * use writepages() because with dealyed allocation we may be doing
192 * block allocation in writepages().
193 */
194static int journal_submit_inode_data_buffers(struct address_space *mapping)
195{
196 int ret;
197 struct writeback_control wbc = {
198 .sync_mode = WB_SYNC_ALL,
199 .nr_to_write = mapping->nrpages * 2,
200 .range_start = 0,
201 .range_end = i_size_read(mapping->host),
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400202 };
203
204 ret = generic_writepages(mapping, &wbc);
205 return ret;
206}
207
208/*
Jan Karac851ed52008-07-11 19:27:31 -0400209 * Submit all the data buffers of inode associated with the transaction to
210 * disk.
211 *
212 * We are in a committing transaction. Therefore no new inode can be added to
213 * our inode list. We use JI_COMMIT_RUNNING flag to protect inode we currently
214 * operate on from being released while we write out pages.
215 */
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400216static int journal_submit_data_buffers(journal_t *journal,
Jan Karac851ed52008-07-11 19:27:31 -0400217 transaction_t *commit_transaction)
218{
219 struct jbd2_inode *jinode;
220 int err, ret = 0;
221 struct address_space *mapping;
222
223 spin_lock(&journal->j_list_lock);
224 list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
225 mapping = jinode->i_vfs_inode->i_mapping;
Brian King39e3ac22010-10-27 21:25:12 -0400226 set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
Jan Karac851ed52008-07-11 19:27:31 -0400227 spin_unlock(&journal->j_list_lock);
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400228 /*
229 * submit the inode data buffers. We use writepage
230 * instead of writepages. Because writepages can do
231 * block allocation with delalloc. We need to write
232 * only allocated blocks here.
233 */
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400234 trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400235 err = journal_submit_inode_data_buffers(mapping);
Jan Karac851ed52008-07-11 19:27:31 -0400236 if (!ret)
237 ret = err;
238 spin_lock(&journal->j_list_lock);
239 J_ASSERT(jinode->i_transaction == commit_transaction);
Brian King39e3ac22010-10-27 21:25:12 -0400240 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
241 smp_mb__after_clear_bit();
Jan Karac851ed52008-07-11 19:27:31 -0400242 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
243 }
244 spin_unlock(&journal->j_list_lock);
245 return ret;
246}
247
248/*
249 * Wait for data submitted for writeout, refile inodes to proper
250 * transaction if needed.
251 *
252 */
253static int journal_finish_inode_data_buffers(journal_t *journal,
254 transaction_t *commit_transaction)
255{
256 struct jbd2_inode *jinode, *next_i;
257 int err, ret = 0;
258
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400259 /* For locking, see the comment in journal_submit_data_buffers() */
Jan Karac851ed52008-07-11 19:27:31 -0400260 spin_lock(&journal->j_list_lock);
261 list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
Brian King39e3ac22010-10-27 21:25:12 -0400262 set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
Jan Karac851ed52008-07-11 19:27:31 -0400263 spin_unlock(&journal->j_list_lock);
264 err = filemap_fdatawait(jinode->i_vfs_inode->i_mapping);
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400265 if (err) {
266 /*
267 * Because AS_EIO is cleared by
Christoph Hellwig94004ed2009-09-30 22:16:33 +0200268 * filemap_fdatawait_range(), set it again so
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400269 * that user process can get -EIO from fsync().
270 */
271 set_bit(AS_EIO,
272 &jinode->i_vfs_inode->i_mapping->flags);
273
274 if (!ret)
275 ret = err;
276 }
Jan Karac851ed52008-07-11 19:27:31 -0400277 spin_lock(&journal->j_list_lock);
Brian King39e3ac22010-10-27 21:25:12 -0400278 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
279 smp_mb__after_clear_bit();
Jan Karac851ed52008-07-11 19:27:31 -0400280 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
281 }
282
283 /* Now refile inode to proper lists */
284 list_for_each_entry_safe(jinode, next_i,
285 &commit_transaction->t_inode_list, i_list) {
286 list_del(&jinode->i_list);
287 if (jinode->i_next_transaction) {
288 jinode->i_transaction = jinode->i_next_transaction;
289 jinode->i_next_transaction = NULL;
290 list_add(&jinode->i_list,
291 &jinode->i_transaction->t_inode_list);
292 } else {
293 jinode->i_transaction = NULL;
294 }
295 }
296 spin_unlock(&journal->j_list_lock);
297
298 return ret;
299}
300
Girish Shilamkar818d2762008-01-28 23:58:27 -0500301static __u32 jbd2_checksum_data(__u32 crc32_sum, struct buffer_head *bh)
302{
303 struct page *page = bh->b_page;
304 char *addr;
305 __u32 checksum;
306
Cong Wang303a8f22011-11-25 23:14:31 +0800307 addr = kmap_atomic(page);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500308 checksum = crc32_be(crc32_sum,
309 (void *)(addr + offset_in_page(bh->b_data)), bh->b_size);
Cong Wang303a8f22011-11-25 23:14:31 +0800310 kunmap_atomic(addr);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500311
312 return checksum;
313}
314
315static void write_tag_block(int tag_bytes, journal_block_tag_t *tag,
Mingming Cao18eba7a2006-10-11 01:21:13 -0700316 unsigned long long block)
Zach Brownb517bea2006-10-11 01:21:08 -0700317{
318 tag->t_blocknr = cpu_to_be32(block & (u32)~0);
Mingming Caocd02ff02007-10-16 18:38:25 -0400319 if (tag_bytes > JBD2_TAG_SIZE32)
Zach Brownb517bea2006-10-11 01:21:08 -0700320 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
321}
322
Darrick J. Wong3caa4872012-05-27 08:10:22 -0400323static void jbd2_descr_block_csum_set(journal_t *j,
324 struct journal_head *descriptor)
325{
326 struct jbd2_journal_block_tail *tail;
327 __u32 csum;
328
329 if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
330 return;
331
332 tail = (struct jbd2_journal_block_tail *)
333 (jh2bh(descriptor)->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, jh2bh(descriptor)->b_data,
337 j->j_blocksize);
338 tail->t_checksum = cpu_to_be32(csum);
339}
340
Darrick J. Wongc3900872012-05-27 08:12:12 -0400341static void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
342 struct buffer_head *bh, __u32 sequence)
343{
344 struct page *page = bh->b_page;
345 __u8 *addr;
346 __u32 csum;
347
348 if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
349 return;
350
351 sequence = cpu_to_be32(sequence);
Cong Wang906adea2012-06-23 11:24:48 +0800352 addr = kmap_atomic(page);
Darrick J. Wongc3900872012-05-27 08:12:12 -0400353 csum = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&sequence,
354 sizeof(sequence));
355 csum = jbd2_chksum(j, csum, addr + offset_in_page(bh->b_data),
356 bh->b_size);
Cong Wang906adea2012-06-23 11:24:48 +0800357 kunmap_atomic(addr);
Darrick J. Wongc3900872012-05-27 08:12:12 -0400358
359 tag->t_checksum = cpu_to_be32(csum);
360}
Dave Kleikamp470decc2006-10-11 01:20:57 -0700361/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700362 * jbd2_journal_commit_transaction
Dave Kleikamp470decc2006-10-11 01:20:57 -0700363 *
364 * The primary function for committing a transaction to the log. This
365 * function is called by the journal thread to begin a complete commit.
366 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700367void jbd2_journal_commit_transaction(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700368{
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500369 struct transaction_stats_s stats;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700370 transaction_t *commit_transaction;
371 struct journal_head *jh, *new_jh, *descriptor;
372 struct buffer_head **wbuf = journal->j_wbuf;
373 int bufs;
374 int flags;
375 int err;
Mingming Cao18eba7a2006-10-11 01:21:13 -0700376 unsigned long long blocknr;
Josef Bacike07f7182008-11-26 01:14:26 -0500377 ktime_t start_time;
378 u64 commit_time;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700379 char *tagp = NULL;
380 journal_header_t *header;
381 journal_block_tag_t *tag = NULL;
382 int space_left = 0;
383 int first_tag = 0;
384 int tag_flag;
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -0500385 int i, to_free = 0;
Zach Brownb517bea2006-10-11 01:21:08 -0700386 int tag_bytes = journal_tag_bytes(journal);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500387 struct buffer_head *cbh = NULL; /* For transactional checksums */
388 __u32 crc32_sum = ~0;
Jens Axboe82f04ab2011-03-17 11:01:52 +0100389 struct blk_plug plug;
Jan Kara33395782012-03-13 22:45:38 -0400390 /* Tail of the journal */
391 unsigned long first_block;
392 tid_t first_tid;
393 int update_tail;
Darrick J. Wong3caa4872012-05-27 08:10:22 -0400394 int csum_size = 0;
395
396 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2))
397 csum_size = sizeof(struct jbd2_journal_block_tail);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700398
399 /*
400 * First job: lock down the current transaction and wait for
401 * all outstanding updates to complete.
402 */
403
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700404 /* Do we need to erase the effects of a prior jbd2_journal_flush? */
405 if (journal->j_flags & JBD2_FLUSHED) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700406 jbd_debug(3, "super block updated\n");
Jan Karaa78bb112012-03-13 15:43:04 -0400407 mutex_lock(&journal->j_checkpoint_mutex);
Jan Kara79feb522012-03-13 22:22:54 -0400408 /*
409 * We hold j_checkpoint_mutex so tail cannot change under us.
410 * We don't need any special data guarantees for writing sb
411 * since journal is empty and it is ok for write to be
412 * flushed only with transaction commit.
413 */
414 jbd2_journal_update_sb_log_tail(journal,
415 journal->j_tail_sequence,
416 journal->j_tail,
417 WRITE_SYNC);
Jan Karaa78bb112012-03-13 15:43:04 -0400418 mutex_unlock(&journal->j_checkpoint_mutex);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700419 } else {
420 jbd_debug(3, "superblock not updated\n");
421 }
422
423 J_ASSERT(journal->j_running_transaction != NULL);
424 J_ASSERT(journal->j_committing_transaction == NULL);
425
426 commit_transaction = journal->j_running_transaction;
427 J_ASSERT(commit_transaction->t_state == T_RUNNING);
428
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400429 trace_jbd2_start_commit(journal, commit_transaction);
Eryu Guanf2a44522011-11-01 19:09:18 -0400430 jbd_debug(1, "JBD2: starting commit of transaction %d\n",
Dave Kleikamp470decc2006-10-11 01:20:57 -0700431 commit_transaction->t_tid);
432
Theodore Ts'oa931da62010-08-03 21:35:12 -0400433 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700434 commit_transaction->t_state = T_LOCKED;
435
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400436 trace_jbd2_commit_locking(journal, commit_transaction);
Theodore Ts'obf699322009-09-30 00:32:06 -0400437 stats.run.rs_wait = commit_transaction->t_max_wait;
438 stats.run.rs_locked = jiffies;
439 stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
440 stats.run.rs_locked);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500441
Dave Kleikamp470decc2006-10-11 01:20:57 -0700442 spin_lock(&commit_transaction->t_handle_lock);
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400443 while (atomic_read(&commit_transaction->t_updates)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700444 DEFINE_WAIT(wait);
445
446 prepare_to_wait(&journal->j_wait_updates, &wait,
447 TASK_UNINTERRUPTIBLE);
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400448 if (atomic_read(&commit_transaction->t_updates)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700449 spin_unlock(&commit_transaction->t_handle_lock);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400450 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700451 schedule();
Theodore Ts'oa931da62010-08-03 21:35:12 -0400452 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700453 spin_lock(&commit_transaction->t_handle_lock);
454 }
455 finish_wait(&journal->j_wait_updates, &wait);
456 }
457 spin_unlock(&commit_transaction->t_handle_lock);
458
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400459 J_ASSERT (atomic_read(&commit_transaction->t_outstanding_credits) <=
Dave Kleikamp470decc2006-10-11 01:20:57 -0700460 journal->j_max_transaction_buffers);
461
462 /*
463 * First thing we are allowed to do is to discard any remaining
464 * BJ_Reserved buffers. Note, it is _not_ permissible to assume
465 * that there are no such buffers: if a large filesystem
466 * operation like a truncate needs to split itself over multiple
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700467 * transactions, then it may try to do a jbd2_journal_restart() while
Dave Kleikamp470decc2006-10-11 01:20:57 -0700468 * there are still BJ_Reserved buffers outstanding. These must
469 * be released cleanly from the current transaction.
470 *
471 * In this case, the filesystem must still reserve write access
472 * again before modifying the buffer in the new transaction, but
473 * we do not require it to remember exactly which old buffers it
474 * has reserved. This is consistent with the existing behaviour
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700475 * that multiple jbd2_journal_get_write_access() calls to the same
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300476 * buffer are perfectly permissible.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700477 */
478 while (commit_transaction->t_reserved_list) {
479 jh = commit_transaction->t_reserved_list;
480 JBUFFER_TRACE(jh, "reserved, unused: refile");
481 /*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700482 * A jbd2_journal_get_undo_access()+jbd2_journal_release_buffer() may
Dave Kleikamp470decc2006-10-11 01:20:57 -0700483 * leave undo-committed data.
484 */
485 if (jh->b_committed_data) {
486 struct buffer_head *bh = jh2bh(jh);
487
488 jbd_lock_bh_state(bh);
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400489 jbd2_free(jh->b_committed_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700490 jh->b_committed_data = NULL;
491 jbd_unlock_bh_state(bh);
492 }
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700493 jbd2_journal_refile_buffer(journal, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700494 }
495
496 /*
497 * Now try to drop any written-back buffers from the journal's
498 * checkpoint lists. We do this *before* commit because it potentially
499 * frees some memory
500 */
501 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700502 __jbd2_journal_clean_checkpoint_list(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700503 spin_unlock(&journal->j_list_lock);
504
Eryu Guanf2a44522011-11-01 19:09:18 -0400505 jbd_debug(3, "JBD2: commit phase 1\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700506
507 /*
Yongqiang Yang1ba37262011-12-28 17:46:46 -0500508 * Clear revoked flag to reflect there is no revoked buffers
509 * in the next transaction which is going to be started.
510 */
511 jbd2_clear_buffer_revoked_flags(journal);
512
513 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700514 * Switch to a new revoke table.
515 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700516 jbd2_journal_switch_revoke_table(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700517
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400518 trace_jbd2_commit_flushing(journal, commit_transaction);
Theodore Ts'obf699322009-09-30 00:32:06 -0400519 stats.run.rs_flushing = jiffies;
520 stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,
521 stats.run.rs_flushing);
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500522
Dave Kleikamp470decc2006-10-11 01:20:57 -0700523 commit_transaction->t_state = T_FLUSH;
524 journal->j_committing_transaction = commit_transaction;
525 journal->j_running_transaction = NULL;
Josef Bacike07f7182008-11-26 01:14:26 -0500526 start_time = ktime_get();
Dave Kleikamp470decc2006-10-11 01:20:57 -0700527 commit_transaction->t_log_start = journal->j_head;
528 wake_up(&journal->j_wait_transaction_locked);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400529 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700530
Eryu Guanf2a44522011-11-01 19:09:18 -0400531 jbd_debug(3, "JBD2: commit phase 2\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700532
533 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700534 * Now start flushing things to disk, in the order they appear
535 * on the transaction lists. Data blocks go first.
536 */
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -0400537 err = journal_submit_data_buffers(journal, commit_transaction);
Jan Karac851ed52008-07-11 19:27:31 -0400538 if (err)
539 jbd2_journal_abort(journal, err);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700540
Jens Axboe82f04ab2011-03-17 11:01:52 +0100541 blk_start_plug(&plug);
Theodore Ts'o67c457a2009-04-14 07:50:56 -0400542 jbd2_journal_write_revoke_records(journal, commit_transaction,
Jens Axboe82f04ab2011-03-17 11:01:52 +0100543 WRITE_SYNC);
544 blk_finish_plug(&plug);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700545
Eryu Guanf2a44522011-11-01 19:09:18 -0400546 jbd_debug(3, "JBD2: commit phase 2\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700547
548 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700549 * Way to go: we have now written out all of the data for a
550 * transaction! Now comes the tricky part: we need to write out
551 * metadata. Loop over the transaction's entire buffer list:
552 */
Theodore Ts'oa931da62010-08-03 21:35:12 -0400553 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700554 commit_transaction->t_state = T_COMMIT;
Theodore Ts'oa931da62010-08-03 21:35:12 -0400555 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700556
Theodore Ts'o879c5e62009-06-17 11:47:48 -0400557 trace_jbd2_commit_logging(journal, commit_transaction);
Theodore Ts'obf699322009-09-30 00:32:06 -0400558 stats.run.rs_logging = jiffies;
559 stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,
560 stats.run.rs_logging);
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400561 stats.run.rs_blocks =
562 atomic_read(&commit_transaction->t_outstanding_credits);
Theodore Ts'obf699322009-09-30 00:32:06 -0400563 stats.run.rs_blocks_logged = 0;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500564
Josef Bacik1dfc3222008-04-17 10:38:59 -0400565 J_ASSERT(commit_transaction->t_nr_buffers <=
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400566 atomic_read(&commit_transaction->t_outstanding_credits));
Josef Bacik1dfc3222008-04-17 10:38:59 -0400567
Jan Kara87c89c22008-07-11 19:27:31 -0400568 err = 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700569 descriptor = NULL;
570 bufs = 0;
Jens Axboe82f04ab2011-03-17 11:01:52 +0100571 blk_start_plug(&plug);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700572 while (commit_transaction->t_buffers) {
573
574 /* Find the next buffer to be journaled... */
575
576 jh = commit_transaction->t_buffers;
577
578 /* If we're in abort mode, we just un-journal the buffer and
Hidehiro Kawai7ad74452008-10-10 20:29:31 -0400579 release it. */
Dave Kleikamp470decc2006-10-11 01:20:57 -0700580
581 if (is_journal_aborted(journal)) {
Hidehiro Kawai7ad74452008-10-10 20:29:31 -0400582 clear_buffer_jbddirty(jh2bh(jh));
Dave Kleikamp470decc2006-10-11 01:20:57 -0700583 JBUFFER_TRACE(jh, "journal is aborting: refile");
Joel Beckere06c8222008-09-11 15:35:47 -0700584 jbd2_buffer_abort_trigger(jh,
585 jh->b_frozen_data ?
586 jh->b_frozen_triggers :
587 jh->b_triggers);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700588 jbd2_journal_refile_buffer(journal, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700589 /* If that was the last one, we need to clean up
590 * any descriptor buffers which may have been
591 * already allocated, even if we are now
592 * aborting. */
593 if (!commit_transaction->t_buffers)
594 goto start_journal_io;
595 continue;
596 }
597
598 /* Make sure we have a descriptor block in which to
599 record the metadata buffer. */
600
601 if (!descriptor) {
602 struct buffer_head *bh;
603
604 J_ASSERT (bufs == 0);
605
Eryu Guanf2a44522011-11-01 19:09:18 -0400606 jbd_debug(4, "JBD2: get descriptor\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700607
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700608 descriptor = jbd2_journal_get_descriptor_buffer(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700609 if (!descriptor) {
Jan Karaa7fa2ba2007-10-16 18:38:25 -0400610 jbd2_journal_abort(journal, -EIO);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700611 continue;
612 }
613
614 bh = jh2bh(descriptor);
Eryu Guanf2a44522011-11-01 19:09:18 -0400615 jbd_debug(4, "JBD2: got buffer %llu (%p)\n",
Dave Kleikamp470decc2006-10-11 01:20:57 -0700616 (unsigned long long)bh->b_blocknr, bh->b_data);
617 header = (journal_header_t *)&bh->b_data[0];
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700618 header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
619 header->h_blocktype = cpu_to_be32(JBD2_DESCRIPTOR_BLOCK);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700620 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
621
622 tagp = &bh->b_data[sizeof(journal_header_t)];
623 space_left = bh->b_size - sizeof(journal_header_t);
624 first_tag = 1;
625 set_buffer_jwrite(bh);
626 set_buffer_dirty(bh);
627 wbuf[bufs++] = bh;
628
629 /* Record it so that we can wait for IO
630 completion later */
631 BUFFER_TRACE(bh, "ph3: file as descriptor");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700632 jbd2_journal_file_buffer(descriptor, commit_transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700633 BJ_LogCtl);
634 }
635
636 /* Where is the buffer to be written? */
637
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700638 err = jbd2_journal_next_log_block(journal, &blocknr);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700639 /* If the block mapping failed, just abandon the buffer
640 and repeat this loop: we'll fall into the
641 refile-on-abort condition above. */
642 if (err) {
Jan Karaa7fa2ba2007-10-16 18:38:25 -0400643 jbd2_journal_abort(journal, err);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700644 continue;
645 }
646
647 /*
648 * start_this_handle() uses t_outstanding_credits to determine
649 * the free space in the log, but this counter is changed
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700650 * by jbd2_journal_next_log_block() also.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700651 */
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400652 atomic_dec(&commit_transaction->t_outstanding_credits);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700653
654 /* Bump b_count to prevent truncate from stumbling over
655 the shadowed buffer! @@@ This can go if we ever get
656 rid of the BJ_IO/BJ_Shadow pairing of buffers. */
657 atomic_inc(&jh2bh(jh)->b_count);
658
659 /* Make a temporary IO buffer with which to write it out
660 (this will requeue both the metadata buffer and the
661 temporary IO buffer). new_bh goes on BJ_IO*/
662
663 set_bit(BH_JWrite, &jh2bh(jh)->b_state);
664 /*
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700665 * akpm: jbd2_journal_write_metadata_buffer() sets
Dave Kleikamp470decc2006-10-11 01:20:57 -0700666 * new_bh->b_transaction to commit_transaction.
667 * We need to clean this up before we release new_bh
668 * (which is of type BJ_IO)
669 */
670 JBUFFER_TRACE(jh, "ph3: write metadata");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700671 flags = jbd2_journal_write_metadata_buffer(commit_transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700672 jh, &new_jh, blocknr);
Theodore Ts'oe6ec1162009-12-01 09:04:42 -0500673 if (flags < 0) {
674 jbd2_journal_abort(journal, flags);
675 continue;
676 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700677 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
678 wbuf[bufs++] = jh2bh(new_jh);
679
680 /* Record the new block's tag in the current descriptor
681 buffer */
682
683 tag_flag = 0;
684 if (flags & 1)
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700685 tag_flag |= JBD2_FLAG_ESCAPE;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700686 if (!first_tag)
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700687 tag_flag |= JBD2_FLAG_SAME_UUID;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700688
689 tag = (journal_block_tag_t *) tagp;
Zach Brownb517bea2006-10-11 01:21:08 -0700690 write_tag_block(tag_bytes, tag, jh2bh(jh)->b_blocknr);
Darrick J. Wong8f888ef2012-05-22 22:43:41 -0400691 tag->t_flags = cpu_to_be16(tag_flag);
Darrick J. Wongc3900872012-05-27 08:12:12 -0400692 jbd2_block_tag_csum_set(journal, tag, jh2bh(new_jh),
693 commit_transaction->t_tid);
Zach Brownb517bea2006-10-11 01:21:08 -0700694 tagp += tag_bytes;
695 space_left -= tag_bytes;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700696
697 if (first_tag) {
698 memcpy (tagp, journal->j_uuid, 16);
699 tagp += 16;
700 space_left -= 16;
701 first_tag = 0;
702 }
703
704 /* If there's no more to do, or if the descriptor is full,
705 let the IO rip! */
706
707 if (bufs == journal->j_wbufsize ||
708 commit_transaction->t_buffers == NULL ||
Darrick J. Wong3caa4872012-05-27 08:10:22 -0400709 space_left < tag_bytes + 16 + csum_size) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700710
Eryu Guanf2a44522011-11-01 19:09:18 -0400711 jbd_debug(4, "JBD2: Submit %d IOs\n", bufs);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700712
713 /* Write an end-of-descriptor marker before
714 submitting the IOs. "tag" still points to
715 the last tag we set up. */
716
Darrick J. Wong8f888ef2012-05-22 22:43:41 -0400717 tag->t_flags |= cpu_to_be16(JBD2_FLAG_LAST_TAG);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700718
Darrick J. Wong3caa4872012-05-27 08:10:22 -0400719 jbd2_descr_block_csum_set(journal, descriptor);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700720start_journal_io:
721 for (i = 0; i < bufs; i++) {
722 struct buffer_head *bh = wbuf[i];
Girish Shilamkar818d2762008-01-28 23:58:27 -0500723 /*
724 * Compute checksum.
725 */
726 if (JBD2_HAS_COMPAT_FEATURE(journal,
727 JBD2_FEATURE_COMPAT_CHECKSUM)) {
728 crc32_sum =
729 jbd2_checksum_data(crc32_sum, bh);
730 }
731
Dave Kleikamp470decc2006-10-11 01:20:57 -0700732 lock_buffer(bh);
733 clear_buffer_dirty(bh);
734 set_buffer_uptodate(bh);
735 bh->b_end_io = journal_end_buffer_io_sync;
Jens Axboe82f04ab2011-03-17 11:01:52 +0100736 submit_bh(WRITE_SYNC, bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700737 }
738 cond_resched();
Theodore Ts'obf699322009-09-30 00:32:06 -0400739 stats.run.rs_blocks_logged += bufs;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700740
741 /* Force a new descriptor to be generated next
742 time round the loop. */
743 descriptor = NULL;
744 bufs = 0;
745 }
746 }
747
Jan Karac851ed52008-07-11 19:27:31 -0400748 err = journal_finish_inode_data_buffers(journal, commit_transaction);
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400749 if (err) {
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400750 printk(KERN_WARNING
751 "JBD2: Detected IO errors while flushing file data "
Theodore Ts'o05496762008-09-16 14:36:17 -0400752 "on %s\n", journal->j_devname);
Hidehiro Kawai5bf56832008-10-10 22:12:43 -0400753 if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
754 jbd2_journal_abort(journal, err);
Hidehiro Kawaie9e34f42008-07-31 22:26:04 -0400755 err = 0;
756 }
Jan Karac851ed52008-07-11 19:27:31 -0400757
Jan Kara33395782012-03-13 22:45:38 -0400758 /*
759 * Get current oldest transaction in the log before we issue flush
760 * to the filesystem device. After the flush we can be sure that
761 * blocks of all older transactions are checkpointed to persistent
762 * storage and we will be safe to update journal start in the
763 * superblock with the numbers we get here.
764 */
765 update_tail =
766 jbd2_journal_get_log_tail(journal, &first_tid, &first_block);
767
Jan Karabbd2be32011-05-24 11:59:18 -0400768 write_lock(&journal->j_state_lock);
Jan Kara33395782012-03-13 22:45:38 -0400769 if (update_tail) {
770 long freed = first_block - journal->j_tail;
771
772 if (first_block < journal->j_tail)
773 freed += journal->j_last - journal->j_first;
774 /* Update tail only if we free significant amount of space */
775 if (freed < journal->j_maxlen / 4)
776 update_tail = 0;
777 }
Jan Karabbd2be32011-05-24 11:59:18 -0400778 J_ASSERT(commit_transaction->t_state == T_COMMIT);
779 commit_transaction->t_state = T_COMMIT_DFLUSH;
780 write_unlock(&journal->j_state_lock);
Jan Kara33395782012-03-13 22:45:38 -0400781
Girish Shilamkar818d2762008-01-28 23:58:27 -0500782 /*
783 * If the journal is not located on the file system device,
784 * then we must flush the file system device before we issue
785 * the commit record
786 */
Jan Kara81be12c2011-05-24 11:52:40 -0400787 if (commit_transaction->t_need_data_flush &&
Girish Shilamkar818d2762008-01-28 23:58:27 -0500788 (journal->j_fs_dev != journal->j_dev) &&
789 (journal->j_flags & JBD2_BARRIER))
Shaohua Li99aa7842012-04-13 10:27:35 +0800790 blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL);
Girish Shilamkar818d2762008-01-28 23:58:27 -0500791
792 /* Done it all: now write the commit record asynchronously. */
793 if (JBD2_HAS_INCOMPAT_FEATURE(journal,
794 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
795 err = journal_submit_commit_record(journal, commit_transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700796 &cbh, crc32_sum);
797 if (err)
798 __jbd2_journal_abort_hard(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700799 }
800
Jens Axboe82f04ab2011-03-17 11:01:52 +0100801 blk_finish_plug(&plug);
802
Dave Kleikamp470decc2006-10-11 01:20:57 -0700803 /* Lo and behold: we have just managed to send a transaction to
804 the log. Before we can commit it, wait for the IO so far to
805 complete. Control buffers being written are on the
806 transaction's t_log_list queue, and metadata buffers are on
807 the t_iobuf_list queue.
808
809 Wait for the buffers in reverse order. That way we are
810 less likely to be woken up until all IOs have completed, and
811 so we incur less scheduling load.
812 */
813
Eryu Guanf2a44522011-11-01 19:09:18 -0400814 jbd_debug(3, "JBD2: commit phase 3\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700815
816 /*
817 * akpm: these are BJ_IO, and j_list_lock is not needed.
818 * See __journal_try_to_free_buffer.
819 */
820wait_for_iobuf:
821 while (commit_transaction->t_iobuf_list != NULL) {
822 struct buffer_head *bh;
823
824 jh = commit_transaction->t_iobuf_list->b_tprev;
825 bh = jh2bh(jh);
826 if (buffer_locked(bh)) {
827 wait_on_buffer(bh);
828 goto wait_for_iobuf;
829 }
830 if (cond_resched())
831 goto wait_for_iobuf;
832
833 if (unlikely(!buffer_uptodate(bh)))
834 err = -EIO;
835
836 clear_buffer_jwrite(bh);
837
838 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700839 jbd2_journal_unfile_buffer(journal, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700840
841 /*
842 * ->t_iobuf_list should contain only dummy buffer_heads
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700843 * which were created by jbd2_journal_write_metadata_buffer().
Dave Kleikamp470decc2006-10-11 01:20:57 -0700844 */
845 BUFFER_TRACE(bh, "dumping temporary bh");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700846 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700847 __brelse(bh);
848 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
849 free_buffer_head(bh);
850
851 /* We also have to unlock and free the corresponding
852 shadowed buffer */
853 jh = commit_transaction->t_shadow_list->b_tprev;
854 bh = jh2bh(jh);
855 clear_bit(BH_JWrite, &bh->b_state);
856 J_ASSERT_BH(bh, buffer_jbddirty(bh));
857
858 /* The metadata is now released for reuse, but we need
859 to remember it against this transaction so that when
860 we finally commit, we can do any checkpointing
861 required. */
862 JBUFFER_TRACE(jh, "file as BJ_Forget");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700863 jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);
Jan Kara229309c2011-05-08 19:09:53 -0400864 /*
865 * Wake up any transactions which were waiting for this IO to
866 * complete. The barrier must be here so that changes by
867 * jbd2_journal_file_buffer() take effect before wake_up_bit()
868 * does the waitqueue check.
869 */
870 smp_mb();
Dave Kleikamp470decc2006-10-11 01:20:57 -0700871 wake_up_bit(&bh->b_state, BH_Unshadow);
872 JBUFFER_TRACE(jh, "brelse shadowed buffer");
873 __brelse(bh);
874 }
875
876 J_ASSERT (commit_transaction->t_shadow_list == NULL);
877
Eryu Guanf2a44522011-11-01 19:09:18 -0400878 jbd_debug(3, "JBD2: commit phase 4\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700879
880 /* Here we wait for the revoke record and descriptor record buffers */
881 wait_for_ctlbuf:
882 while (commit_transaction->t_log_list != NULL) {
883 struct buffer_head *bh;
884
885 jh = commit_transaction->t_log_list->b_tprev;
886 bh = jh2bh(jh);
887 if (buffer_locked(bh)) {
888 wait_on_buffer(bh);
889 goto wait_for_ctlbuf;
890 }
891 if (cond_resched())
892 goto wait_for_ctlbuf;
893
894 if (unlikely(!buffer_uptodate(bh)))
895 err = -EIO;
896
897 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
898 clear_buffer_jwrite(bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700899 jbd2_journal_unfile_buffer(journal, jh);
900 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700901 __brelse(bh); /* One for getblk */
902 /* AKPM: bforget here */
903 }
904
Hidehiro Kawai77e841d2008-10-12 16:39:16 -0400905 if (err)
906 jbd2_journal_abort(journal, err);
907
Eryu Guanf2a44522011-11-01 19:09:18 -0400908 jbd_debug(3, "JBD2: commit phase 5\n");
Jan Karabbd2be32011-05-24 11:59:18 -0400909 write_lock(&journal->j_state_lock);
910 J_ASSERT(commit_transaction->t_state == T_COMMIT_DFLUSH);
911 commit_transaction->t_state = T_COMMIT_JFLUSH;
912 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700913
Girish Shilamkar818d2762008-01-28 23:58:27 -0500914 if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
Theodore Ts'o0e3d2a62009-09-11 09:30:12 -0400915 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
Girish Shilamkar818d2762008-01-28 23:58:27 -0500916 err = journal_submit_commit_record(journal, commit_transaction,
917 &cbh, crc32_sum);
918 if (err)
919 __jbd2_journal_abort_hard(journal);
920 }
Zhang Huan6cba6112011-04-05 19:16:20 -0400921 if (cbh)
Theodore Ts'ofd984962009-01-05 21:34:13 -0500922 err = journal_wait_on_commit_record(journal, cbh);
Jan Karaf73bee42010-08-18 15:56:56 +0200923 if (JBD2_HAS_INCOMPAT_FEATURE(journal,
924 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT) &&
925 journal->j_flags & JBD2_BARRIER) {
Shaohua Li99aa7842012-04-13 10:27:35 +0800926 blkdev_issue_flush(journal->j_dev, GFP_NOFS, NULL);
Jan Karaf73bee42010-08-18 15:56:56 +0200927 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700928
929 if (err)
Jan Karaa7fa2ba2007-10-16 18:38:25 -0400930 jbd2_journal_abort(journal, err);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700931
Jan Kara33395782012-03-13 22:45:38 -0400932 /*
933 * Now disk caches for filesystem device are flushed so we are safe to
934 * erase checkpointed transactions from the log by updating journal
935 * superblock.
936 */
937 if (update_tail)
938 jbd2_update_log_tail(journal, first_tid, first_block);
939
Dave Kleikamp470decc2006-10-11 01:20:57 -0700940 /* End of a transaction! Finally, we can do checkpoint
941 processing: any buffers committed as a result of this
942 transaction can be removed from any checkpoint list it was on
943 before. */
944
Eryu Guanf2a44522011-11-01 19:09:18 -0400945 jbd_debug(3, "JBD2: commit phase 6\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -0700946
Jan Karac851ed52008-07-11 19:27:31 -0400947 J_ASSERT(list_empty(&commit_transaction->t_inode_list));
Dave Kleikamp470decc2006-10-11 01:20:57 -0700948 J_ASSERT(commit_transaction->t_buffers == NULL);
949 J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
950 J_ASSERT(commit_transaction->t_iobuf_list == NULL);
951 J_ASSERT(commit_transaction->t_shadow_list == NULL);
952 J_ASSERT(commit_transaction->t_log_list == NULL);
953
954restart_loop:
955 /*
956 * As there are other places (journal_unmap_buffer()) adding buffers
957 * to this list we have to be careful and hold the j_list_lock.
958 */
959 spin_lock(&journal->j_list_lock);
960 while (commit_transaction->t_forget) {
961 transaction_t *cp_transaction;
962 struct buffer_head *bh;
Jan Karade1b7942011-06-13 15:38:22 -0400963 int try_to_free = 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700964
965 jh = commit_transaction->t_forget;
966 spin_unlock(&journal->j_list_lock);
967 bh = jh2bh(jh);
Jan Karade1b7942011-06-13 15:38:22 -0400968 /*
969 * Get a reference so that bh cannot be freed before we are
970 * done with it.
971 */
972 get_bh(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700973 jbd_lock_bh_state(bh);
dingdinghua23e2af32010-02-24 12:11:20 -0500974 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700975
976 /*
977 * If there is undo-protected committed data against
978 * this buffer, then we can remove it now. If it is a
979 * buffer needing such protection, the old frozen_data
980 * field now points to a committed version of the
981 * buffer, so rotate that field to the new committed
982 * data.
983 *
984 * Otherwise, we can just throw away the frozen data now.
Joel Beckere06c8222008-09-11 15:35:47 -0700985 *
986 * We also know that the frozen data has already fired
987 * its triggers if they exist, so we can clear that too.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700988 */
989 if (jh->b_committed_data) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400990 jbd2_free(jh->b_committed_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700991 jh->b_committed_data = NULL;
992 if (jh->b_frozen_data) {
993 jh->b_committed_data = jh->b_frozen_data;
994 jh->b_frozen_data = NULL;
Joel Beckere06c8222008-09-11 15:35:47 -0700995 jh->b_frozen_triggers = NULL;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700996 }
997 } else if (jh->b_frozen_data) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400998 jbd2_free(jh->b_frozen_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700999 jh->b_frozen_data = NULL;
Joel Beckere06c8222008-09-11 15:35:47 -07001000 jh->b_frozen_triggers = NULL;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001001 }
1002
1003 spin_lock(&journal->j_list_lock);
1004 cp_transaction = jh->b_cp_transaction;
1005 if (cp_transaction) {
1006 JBUFFER_TRACE(jh, "remove from old cp transaction");
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001007 cp_transaction->t_chp_stats.cs_dropped++;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001008 __jbd2_journal_remove_checkpoint(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001009 }
1010
1011 /* Only re-checkpoint the buffer_head if it is marked
1012 * dirty. If the buffer was added to the BJ_Forget list
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001013 * by jbd2_journal_forget, it may no longer be dirty and
Dave Kleikamp470decc2006-10-11 01:20:57 -07001014 * there's no point in keeping a checkpoint record for
1015 * it. */
1016
Jan Karab794e7a2012-09-26 23:11:13 -04001017 /*
1018 * A buffer which has been freed while still being journaled by
1019 * a previous transaction.
1020 */
1021 if (buffer_freed(bh)) {
1022 /*
1023 * If the running transaction is the one containing
1024 * "add to orphan" operation (b_next_transaction !=
1025 * NULL), we have to wait for that transaction to
1026 * commit before we can really get rid of the buffer.
1027 * So just clear b_modified to not confuse transaction
1028 * credit accounting and refile the buffer to
1029 * BJ_Forget of the running transaction. If the just
1030 * committed transaction contains "add to orphan"
1031 * operation, we can completely invalidate the buffer
1032 * now. We are rather through in that since the
1033 * buffer may be still accessible when blocksize <
1034 * pagesize and it is attached to the last partial
1035 * page.
1036 */
1037 jh->b_modified = 0;
1038 if (!jh->b_next_transaction) {
1039 clear_buffer_freed(bh);
1040 clear_buffer_jbddirty(bh);
1041 clear_buffer_mapped(bh);
1042 clear_buffer_new(bh);
1043 clear_buffer_req(bh);
1044 bh->b_bdev = NULL;
1045 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001046 }
1047
1048 if (buffer_jbddirty(bh)) {
1049 JBUFFER_TRACE(jh, "add to new checkpointing trans");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001050 __jbd2_journal_insert_checkpoint(jh, commit_transaction);
Hidehiro Kawai7ad74452008-10-10 20:29:31 -04001051 if (is_journal_aborted(journal))
1052 clear_buffer_jbddirty(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001053 } else {
1054 J_ASSERT_BH(bh, !buffer_dirty(bh));
Jan Karade1b7942011-06-13 15:38:22 -04001055 /*
1056 * The buffer on BJ_Forget list and not jbddirty means
Dave Kleikamp470decc2006-10-11 01:20:57 -07001057 * it has been freed by this transaction and hence it
1058 * could not have been reallocated until this
1059 * transaction has committed. *BUT* it could be
1060 * reallocated once we have written all the data to
1061 * disk and before we process the buffer on BJ_Forget
Jan Karade1b7942011-06-13 15:38:22 -04001062 * list.
1063 */
1064 if (!jh->b_next_transaction)
1065 try_to_free = 1;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001066 }
Jan Karade1b7942011-06-13 15:38:22 -04001067 JBUFFER_TRACE(jh, "refile or unfile buffer");
1068 __jbd2_journal_refile_buffer(jh);
1069 jbd_unlock_bh_state(bh);
1070 if (try_to_free)
1071 release_buffer_page(bh); /* Drops bh reference */
1072 else
1073 __brelse(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001074 cond_resched_lock(&journal->j_list_lock);
1075 }
1076 spin_unlock(&journal->j_list_lock);
1077 /*
Jan Karaf5a7a6b2008-01-28 23:58:27 -05001078 * This is a bit sleazy. We use j_list_lock to protect transition
1079 * of a transaction into T_FINISHED state and calling
1080 * __jbd2_journal_drop_transaction(). Otherwise we could race with
1081 * other checkpointing code processing the transaction...
Dave Kleikamp470decc2006-10-11 01:20:57 -07001082 */
Theodore Ts'oa931da62010-08-03 21:35:12 -04001083 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001084 spin_lock(&journal->j_list_lock);
1085 /*
1086 * Now recheck if some buffers did not get attached to the transaction
1087 * while the lock was dropped...
1088 */
1089 if (commit_transaction->t_forget) {
1090 spin_unlock(&journal->j_list_lock);
Theodore Ts'oa931da62010-08-03 21:35:12 -04001091 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001092 goto restart_loop;
1093 }
1094
1095 /* Done with this transaction! */
1096
Eryu Guanf2a44522011-11-01 19:09:18 -04001097 jbd_debug(3, "JBD2: commit phase 7\n");
Dave Kleikamp470decc2006-10-11 01:20:57 -07001098
Jan Karabbd2be32011-05-24 11:59:18 -04001099 J_ASSERT(commit_transaction->t_state == T_COMMIT_JFLUSH);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001100
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001101 commit_transaction->t_start = jiffies;
Theodore Ts'obf699322009-09-30 00:32:06 -04001102 stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,
1103 commit_transaction->t_start);
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001104
1105 /*
Theodore Ts'obf699322009-09-30 00:32:06 -04001106 * File the transaction statistics
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001107 */
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001108 stats.ts_tid = commit_transaction->t_tid;
Theodore Ts'o8dd42042010-08-03 21:38:29 -04001109 stats.run.rs_handle_count =
1110 atomic_read(&commit_transaction->t_handle_count);
Theodore Ts'obf699322009-09-30 00:32:06 -04001111 trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
1112 commit_transaction->t_tid, &stats.run);
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001113
1114 /*
1115 * Calculate overall stats
1116 */
Theodore Ts'obf699322009-09-30 00:32:06 -04001117 spin_lock(&journal->j_history_lock);
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001118 journal->j_stats.ts_tid++;
Theodore Ts'obf699322009-09-30 00:32:06 -04001119 journal->j_stats.run.rs_wait += stats.run.rs_wait;
1120 journal->j_stats.run.rs_running += stats.run.rs_running;
1121 journal->j_stats.run.rs_locked += stats.run.rs_locked;
1122 journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
1123 journal->j_stats.run.rs_logging += stats.run.rs_logging;
1124 journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
1125 journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
1126 journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
Johann Lombardi8e85fb32008-01-28 23:58:27 -05001127 spin_unlock(&journal->j_history_lock);
1128
Dave Kleikamp470decc2006-10-11 01:20:57 -07001129 commit_transaction->t_state = T_FINISHED;
1130 J_ASSERT(commit_transaction == journal->j_committing_transaction);
1131 journal->j_commit_sequence = commit_transaction->t_tid;
1132 journal->j_committing_transaction = NULL;
Josef Bacike07f7182008-11-26 01:14:26 -05001133 commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
Dave Kleikamp470decc2006-10-11 01:20:57 -07001134
Josef Bacike07f7182008-11-26 01:14:26 -05001135 /*
1136 * weight the commit time higher than the average time so we don't
1137 * react too strongly to vast changes in the commit time
1138 */
1139 if (likely(journal->j_average_commit_time))
1140 journal->j_average_commit_time = (commit_time +
1141 journal->j_average_commit_time*3) / 4;
1142 else
1143 journal->j_average_commit_time = commit_time;
Theodore Ts'oa931da62010-08-03 21:35:12 -04001144 write_unlock(&journal->j_state_lock);
Theodore Ts'o6c20ec82008-10-28 21:08:20 -04001145
Jan Karaf89b7792007-07-15 23:37:20 -07001146 if (commit_transaction->t_checkpoint_list == NULL &&
1147 commit_transaction->t_checkpoint_io_list == NULL) {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001148 __jbd2_journal_drop_transaction(journal, commit_transaction);
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -05001149 to_free = 1;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001150 } else {
1151 if (journal->j_checkpoint_transactions == NULL) {
1152 journal->j_checkpoint_transactions = commit_transaction;
1153 commit_transaction->t_cpnext = commit_transaction;
1154 commit_transaction->t_cpprev = commit_transaction;
1155 } else {
1156 commit_transaction->t_cpnext =
1157 journal->j_checkpoint_transactions;
1158 commit_transaction->t_cpprev =
1159 commit_transaction->t_cpnext->t_cpprev;
1160 commit_transaction->t_cpnext->t_cpprev =
1161 commit_transaction;
1162 commit_transaction->t_cpprev->t_cpnext =
1163 commit_transaction;
1164 }
1165 }
1166 spin_unlock(&journal->j_list_lock);
1167
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -05001168 if (journal->j_commit_callback)
1169 journal->j_commit_callback(journal, commit_transaction);
1170
Theodore Ts'o879c5e62009-06-17 11:47:48 -04001171 trace_jbd2_end_commit(journal, commit_transaction);
Eryu Guanf2a44522011-11-01 19:09:18 -04001172 jbd_debug(1, "JBD2: commit %d complete, head %d\n",
Dave Kleikamp470decc2006-10-11 01:20:57 -07001173 journal->j_commit_sequence, journal->j_tail_sequence);
Aneesh Kumar K.Vfb684072008-11-06 17:50:21 -05001174 if (to_free)
Yongqiang Yang0c2022e2012-02-20 17:53:02 -05001175 jbd2_journal_free_transaction(commit_transaction);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001176
1177 wake_up(&journal->j_wait_done_commit);
1178}