blob: f486ff6977813bdc3f9ec009c57b75941f7a26d7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Uwe Zeisbergerf30c2262006-10-03 23:01:26 +02002 * linux/fs/jbd/commit.c
Linus Torvalds1da177e2005-04-16 15:20:36 -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>
18#include <linux/jbd.h>
19#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/mm.h>
21#include <linux/pagemap.h>
Theodore Ts'o512a0042009-03-27 22:14:27 -040022#include <linux/bio.h>
Jens Axboe65ab8022011-03-17 10:56:45 +010023#include <linux/blkdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25/*
26 * Default IO end handler for temporary BJ_IO buffer_heads.
27 */
28static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
29{
30 BUFFER_TRACE(bh, "");
31 if (uptodate)
32 set_buffer_uptodate(bh);
33 else
34 clear_buffer_uptodate(bh);
35 unlock_buffer(bh);
36}
37
38/*
39 * When an ext3-ordered file is truncated, it is possible that many pages are
Toshiyuki Okajimafc80c442008-07-25 01:46:29 -070040 * not successfully freed, because they are attached to a committing transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * After the transaction commits, these pages are left on the LRU, with no
42 * ->mapping, and with attached buffers. These pages are trivially reclaimable
43 * by the VM, but their apparent absence upsets the VM accounting, and it makes
44 * the numbers in /proc/meminfo look odd.
45 *
46 * So here, we have a buffer which has just come off the forget list. Look to
47 * see if we can strip all buffers from the backing page.
48 *
Toshiyuki Okajimafc80c442008-07-25 01:46:29 -070049 * Called under journal->j_list_lock. The caller provided us with a ref
50 * against the buffer, and we drop that here.
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 */
52static void release_buffer_page(struct buffer_head *bh)
53{
54 struct page *page;
55
56 if (buffer_dirty(bh))
57 goto nope;
58 if (atomic_read(&bh->b_count) != 1)
59 goto nope;
60 page = bh->b_page;
61 if (!page)
62 goto nope;
63 if (page->mapping)
64 goto nope;
65
66 /* OK, it's a truncated page */
Nick Piggin529ae9a2008-08-02 12:01:03 +020067 if (!trylock_page(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 goto nope;
69
70 page_cache_get(page);
71 __brelse(bh);
72 try_to_free_buffers(page);
73 unlock_page(page);
74 page_cache_release(page);
75 return;
76
77nope:
78 __brelse(bh);
79}
80
81/*
Toshiyuki Okajimafc80c442008-07-25 01:46:29 -070082 * Decrement reference counter for data buffer. If it has been marked
83 * 'BH_Freed', release it and the page to which it belongs if possible.
84 */
85static void release_data_buffer(struct buffer_head *bh)
86{
87 if (buffer_freed(bh)) {
88 clear_buffer_freed(bh);
89 release_buffer_page(bh);
90 } else
91 put_bh(bh);
92}
93
94/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 * Try to acquire jbd_lock_bh_state() against the buffer, when j_list_lock is
96 * held. For ranking reasons we must trylock. If we lose, schedule away and
97 * return 0. j_list_lock is dropped in this case.
98 */
99static int inverted_lock(journal_t *journal, struct buffer_head *bh)
100{
101 if (!jbd_trylock_bh_state(bh)) {
102 spin_unlock(&journal->j_list_lock);
103 schedule();
104 return 0;
105 }
106 return 1;
107}
108
109/* Done it all: now write the commit record. We should have
110 * cleaned up our previous buffers by now, so if we are in abort
111 * mode we can now just skip the rest of the journal write
112 * entirely.
113 *
114 * Returns 1 if the journal needs to be aborted or 0 on success
115 */
116static int journal_write_commit_record(journal_t *journal,
117 transaction_t *commit_transaction)
118{
119 struct journal_head *descriptor;
120 struct buffer_head *bh;
Jan Kara53152172008-02-01 08:26:46 -0500121 journal_header_t *header;
122 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124 if (is_journal_aborted(journal))
125 return 0;
126
127 descriptor = journal_get_descriptor_buffer(journal);
128 if (!descriptor)
129 return 1;
130
131 bh = jh2bh(descriptor);
132
Jan Kara53152172008-02-01 08:26:46 -0500133 header = (journal_header_t *)(bh->b_data);
134 header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
135 header->h_blocktype = cpu_to_be32(JFS_COMMIT_BLOCK);
136 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
138 JBUFFER_TRACE(descriptor, "write commit block");
139 set_buffer_dirty(bh);
Christoph Hellwig87e99512010-08-11 17:05:45 +0200140
Christoph Hellwig45244512010-08-18 05:29:16 -0400141 if (journal->j_flags & JFS_BARRIER)
142 ret = __sync_dirty_buffer(bh, WRITE_SYNC | WRITE_FLUSH_FUA);
143 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 ret = sync_dirty_buffer(bh);
Christoph Hellwig87e99512010-08-11 17:05:45 +0200145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 put_bh(bh); /* One for getblk() */
147 journal_put_journal_head(descriptor);
148
149 return (ret == -EIO);
150}
151
Theodore Ts'o512a0042009-03-27 22:14:27 -0400152static void journal_do_submit_data(struct buffer_head **wbuf, int bufs,
153 int write_op)
Jan Kara3998b932006-09-25 23:30:53 -0700154{
155 int i;
156
157 for (i = 0; i < bufs; i++) {
158 wbuf[i]->b_end_io = end_buffer_write_sync;
159 /* We use-up our safety reference in submit_bh() */
Theodore Ts'o512a0042009-03-27 22:14:27 -0400160 submit_bh(write_op, wbuf[i]);
Jan Kara3998b932006-09-25 23:30:53 -0700161 }
162}
163
164/*
165 * Submit all the data buffers to disk
166 */
Hidehiro Kawaicbe5f462008-07-25 01:46:30 -0700167static int journal_submit_data_buffers(journal_t *journal,
Theodore Ts'o512a0042009-03-27 22:14:27 -0400168 transaction_t *commit_transaction,
169 int write_op)
Jan Kara3998b932006-09-25 23:30:53 -0700170{
171 struct journal_head *jh;
172 struct buffer_head *bh;
173 int locked;
174 int bufs = 0;
175 struct buffer_head **wbuf = journal->j_wbuf;
Hidehiro Kawaicbe5f462008-07-25 01:46:30 -0700176 int err = 0;
Jan Kara3998b932006-09-25 23:30:53 -0700177
178 /*
179 * Whenever we unlock the journal and sleep, things can get added
180 * onto ->t_sync_datalist, so we have to keep looping back to
181 * write_out_data until we *know* that the list is empty.
182 *
183 * Cleanup any flushed data buffers from the data list. Even in
184 * abort mode, we want to flush this out as soon as possible.
185 */
186write_out_data:
187 cond_resched();
188 spin_lock(&journal->j_list_lock);
189
190 while (commit_transaction->t_sync_datalist) {
191 jh = commit_transaction->t_sync_datalist;
192 bh = jh2bh(jh);
193 locked = 0;
194
195 /* Get reference just to make sure buffer does not disappear
196 * when we are forced to drop various locks */
197 get_bh(bh);
198 /* If the buffer is dirty, we need to submit IO and hence
199 * we need the buffer lock. We try to lock the buffer without
200 * blocking. If we fail, we need to drop j_list_lock and do
201 * blocking lock_buffer().
202 */
203 if (buffer_dirty(bh)) {
Nick Pigginca5de402008-08-02 12:02:13 +0200204 if (!trylock_buffer(bh)) {
Jan Kara3998b932006-09-25 23:30:53 -0700205 BUFFER_TRACE(bh, "needs blocking lock");
206 spin_unlock(&journal->j_list_lock);
207 /* Write out all data to prevent deadlocks */
Theodore Ts'o512a0042009-03-27 22:14:27 -0400208 journal_do_submit_data(wbuf, bufs, write_op);
Jan Kara3998b932006-09-25 23:30:53 -0700209 bufs = 0;
210 lock_buffer(bh);
211 spin_lock(&journal->j_list_lock);
212 }
213 locked = 1;
214 }
215 /* We have to get bh_state lock. Again out of order, sigh. */
216 if (!inverted_lock(journal, bh)) {
217 jbd_lock_bh_state(bh);
218 spin_lock(&journal->j_list_lock);
219 }
220 /* Someone already cleaned up the buffer? */
Jan Karaa61d90d2009-06-09 16:26:26 -0700221 if (!buffer_jbd(bh) || bh2jh(bh) != jh
Jan Kara3998b932006-09-25 23:30:53 -0700222 || jh->b_transaction != commit_transaction
223 || jh->b_jlist != BJ_SyncData) {
224 jbd_unlock_bh_state(bh);
225 if (locked)
226 unlock_buffer(bh);
227 BUFFER_TRACE(bh, "already cleaned up");
Toshiyuki Okajimafc80c442008-07-25 01:46:29 -0700228 release_data_buffer(bh);
Jan Kara3998b932006-09-25 23:30:53 -0700229 continue;
230 }
231 if (locked && test_clear_buffer_dirty(bh)) {
232 BUFFER_TRACE(bh, "needs writeout, adding to array");
233 wbuf[bufs++] = bh;
234 __journal_file_buffer(jh, commit_transaction,
235 BJ_Locked);
236 jbd_unlock_bh_state(bh);
237 if (bufs == journal->j_wbufsize) {
238 spin_unlock(&journal->j_list_lock);
Theodore Ts'o512a0042009-03-27 22:14:27 -0400239 journal_do_submit_data(wbuf, bufs, write_op);
Jan Kara3998b932006-09-25 23:30:53 -0700240 bufs = 0;
241 goto write_out_data;
242 }
Hisashi Hifumi6f5a9da2006-12-22 01:11:50 -0800243 } else if (!locked && buffer_locked(bh)) {
244 __journal_file_buffer(jh, commit_transaction,
245 BJ_Locked);
246 jbd_unlock_bh_state(bh);
247 put_bh(bh);
248 } else {
Jan Kara3998b932006-09-25 23:30:53 -0700249 BUFFER_TRACE(bh, "writeout complete: unfile");
Hidehiro Kawaicbe5f462008-07-25 01:46:30 -0700250 if (unlikely(!buffer_uptodate(bh)))
251 err = -EIO;
Jan Kara3998b932006-09-25 23:30:53 -0700252 __journal_unfile_buffer(jh);
253 jbd_unlock_bh_state(bh);
254 if (locked)
255 unlock_buffer(bh);
256 journal_remove_journal_head(bh);
Toshiyuki Okajimafc80c442008-07-25 01:46:29 -0700257 /* One for our safety reference, other for
Jan Kara3998b932006-09-25 23:30:53 -0700258 * journal_remove_journal_head() */
259 put_bh(bh);
Toshiyuki Okajimafc80c442008-07-25 01:46:29 -0700260 release_data_buffer(bh);
Jan Kara3998b932006-09-25 23:30:53 -0700261 }
262
Nick Piggin95c354f2008-01-30 13:31:20 +0100263 if (need_resched() || spin_needbreak(&journal->j_list_lock)) {
Jan Kara3998b932006-09-25 23:30:53 -0700264 spin_unlock(&journal->j_list_lock);
265 goto write_out_data;
266 }
267 }
268 spin_unlock(&journal->j_list_lock);
Theodore Ts'o512a0042009-03-27 22:14:27 -0400269 journal_do_submit_data(wbuf, bufs, write_op);
Hidehiro Kawaicbe5f462008-07-25 01:46:30 -0700270
271 return err;
Jan Kara3998b932006-09-25 23:30:53 -0700272}
273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274/*
275 * journal_commit_transaction
276 *
277 * The primary function for committing a transaction to the log. This
278 * function is called by the journal thread to begin a complete commit.
279 */
280void journal_commit_transaction(journal_t *journal)
281{
282 transaction_t *commit_transaction;
283 struct journal_head *jh, *new_jh, *descriptor;
284 struct buffer_head **wbuf = journal->j_wbuf;
285 int bufs;
286 int flags;
287 int err;
Jan Kara9c28cbc2009-08-03 19:21:00 +0200288 unsigned int blocknr;
Josef Bacikf420d4d2009-01-07 18:07:24 -0800289 ktime_t start_time;
290 u64 commit_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 char *tagp = NULL;
292 journal_header_t *header;
293 journal_block_tag_t *tag = NULL;
294 int space_left = 0;
295 int first_tag = 0;
296 int tag_flag;
297 int i;
Jens Axboe65ab8022011-03-17 10:56:45 +0100298 struct blk_plug plug;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 /*
301 * First job: lock down the current transaction and wait for
302 * all outstanding updates to complete.
303 */
304
305#ifdef COMMIT_STATS
306 spin_lock(&journal->j_list_lock);
307 summarise_journal_usage(journal);
308 spin_unlock(&journal->j_list_lock);
309#endif
310
311 /* Do we need to erase the effects of a prior journal_flush? */
312 if (journal->j_flags & JFS_FLUSHED) {
313 jbd_debug(3, "super block updated\n");
314 journal_update_superblock(journal, 1);
315 } else {
316 jbd_debug(3, "superblock not updated\n");
317 }
318
319 J_ASSERT(journal->j_running_transaction != NULL);
320 J_ASSERT(journal->j_committing_transaction == NULL);
321
322 commit_transaction = journal->j_running_transaction;
323 J_ASSERT(commit_transaction->t_state == T_RUNNING);
324
325 jbd_debug(1, "JBD: starting commit of transaction %d\n",
326 commit_transaction->t_tid);
327
328 spin_lock(&journal->j_state_lock);
329 commit_transaction->t_state = T_LOCKED;
330
331 spin_lock(&commit_transaction->t_handle_lock);
332 while (commit_transaction->t_updates) {
333 DEFINE_WAIT(wait);
334
335 prepare_to_wait(&journal->j_wait_updates, &wait,
336 TASK_UNINTERRUPTIBLE);
337 if (commit_transaction->t_updates) {
338 spin_unlock(&commit_transaction->t_handle_lock);
339 spin_unlock(&journal->j_state_lock);
340 schedule();
341 spin_lock(&journal->j_state_lock);
342 spin_lock(&commit_transaction->t_handle_lock);
343 }
344 finish_wait(&journal->j_wait_updates, &wait);
345 }
346 spin_unlock(&commit_transaction->t_handle_lock);
347
348 J_ASSERT (commit_transaction->t_outstanding_credits <=
349 journal->j_max_transaction_buffers);
350
351 /*
352 * First thing we are allowed to do is to discard any remaining
353 * BJ_Reserved buffers. Note, it is _not_ permissible to assume
354 * that there are no such buffers: if a large filesystem
355 * operation like a truncate needs to split itself over multiple
356 * transactions, then it may try to do a journal_restart() while
357 * there are still BJ_Reserved buffers outstanding. These must
358 * be released cleanly from the current transaction.
359 *
360 * In this case, the filesystem must still reserve write access
361 * again before modifying the buffer in the new transaction, but
362 * we do not require it to remember exactly which old buffers it
363 * has reserved. This is consistent with the existing behaviour
364 * that multiple journal_get_write_access() calls to the same
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300365 * buffer are perfectly permissible.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 */
367 while (commit_transaction->t_reserved_list) {
368 jh = commit_transaction->t_reserved_list;
369 JBUFFER_TRACE(jh, "reserved, unused: refile");
370 /*
371 * A journal_get_undo_access()+journal_release_buffer() may
372 * leave undo-committed data.
373 */
374 if (jh->b_committed_data) {
375 struct buffer_head *bh = jh2bh(jh);
376
377 jbd_lock_bh_state(bh);
Mingming Caoc089d492007-10-16 18:38:25 -0400378 jbd_free(jh->b_committed_data, bh->b_size);
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800379 jh->b_committed_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 jbd_unlock_bh_state(bh);
381 }
382 journal_refile_buffer(journal, jh);
383 }
384
385 /*
386 * Now try to drop any written-back buffers from the journal's
387 * checkpoint lists. We do this *before* commit because it potentially
388 * frees some memory
389 */
390 spin_lock(&journal->j_list_lock);
391 __journal_clean_checkpoint_list(journal);
392 spin_unlock(&journal->j_list_lock);
393
394 jbd_debug (3, "JBD: commit phase 1\n");
395
396 /*
397 * Switch to a new revoke table.
398 */
399 journal_switch_revoke_table(journal);
400
401 commit_transaction->t_state = T_FLUSH;
402 journal->j_committing_transaction = commit_transaction;
403 journal->j_running_transaction = NULL;
Josef Bacikf420d4d2009-01-07 18:07:24 -0800404 start_time = ktime_get();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 commit_transaction->t_log_start = journal->j_head;
406 wake_up(&journal->j_wait_transaction_locked);
407 spin_unlock(&journal->j_state_lock);
408
409 jbd_debug (3, "JBD: commit phase 2\n");
410
411 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 * Now start flushing things to disk, in the order they appear
413 * on the transaction lists. Data blocks go first.
414 */
Jens Axboe65ab8022011-03-17 10:56:45 +0100415 blk_start_plug(&plug);
Theodore Ts'o512a0042009-03-27 22:14:27 -0400416 err = journal_submit_data_buffers(journal, commit_transaction,
Jens Axboe65ab8022011-03-17 10:56:45 +0100417 WRITE_SYNC);
418 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
420 /*
421 * Wait for all previously submitted IO to complete.
422 */
Jan Kara3998b932006-09-25 23:30:53 -0700423 spin_lock(&journal->j_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 while (commit_transaction->t_locked_list) {
425 struct buffer_head *bh;
426
427 jh = commit_transaction->t_locked_list->b_tprev;
428 bh = jh2bh(jh);
429 get_bh(bh);
430 if (buffer_locked(bh)) {
431 spin_unlock(&journal->j_list_lock);
432 wait_on_buffer(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 spin_lock(&journal->j_list_lock);
434 }
Hidehiro Kawaicbe5f462008-07-25 01:46:30 -0700435 if (unlikely(!buffer_uptodate(bh))) {
Nick Piggin529ae9a2008-08-02 12:01:03 +0200436 if (!trylock_page(bh->b_page)) {
Hidehiro Kawaicbe5f462008-07-25 01:46:30 -0700437 spin_unlock(&journal->j_list_lock);
438 lock_page(bh->b_page);
439 spin_lock(&journal->j_list_lock);
440 }
441 if (bh->b_page->mapping)
442 set_bit(AS_EIO, &bh->b_page->mapping->flags);
443
444 unlock_page(bh->b_page);
445 SetPageError(bh->b_page);
446 err = -EIO;
447 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 if (!inverted_lock(journal, bh)) {
449 put_bh(bh);
450 spin_lock(&journal->j_list_lock);
451 continue;
452 }
Jan Karaa61d90d2009-06-09 16:26:26 -0700453 if (buffer_jbd(bh) && bh2jh(bh) == jh &&
454 jh->b_transaction == commit_transaction &&
455 jh->b_jlist == BJ_Locked) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 __journal_unfile_buffer(jh);
457 jbd_unlock_bh_state(bh);
458 journal_remove_journal_head(bh);
459 put_bh(bh);
460 } else {
461 jbd_unlock_bh_state(bh);
462 }
Toshiyuki Okajimafc80c442008-07-25 01:46:29 -0700463 release_data_buffer(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 cond_resched_lock(&journal->j_list_lock);
465 }
466 spin_unlock(&journal->j_list_lock);
467
Hidehiro Kawaicbe5f462008-07-25 01:46:30 -0700468 if (err) {
469 char b[BDEVNAME_SIZE];
470
471 printk(KERN_WARNING
472 "JBD: Detected IO errors while flushing file data "
473 "on %s\n", bdevname(journal->j_fs_dev, b));
Hidehiro Kawai0e4fb5e2008-10-18 20:27:57 -0700474 if (journal->j_flags & JFS_ABORT_ON_SYNCDATA_ERR)
475 journal_abort(journal, err);
Hidehiro Kawaicbe5f462008-07-25 01:46:30 -0700476 err = 0;
477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Jens Axboe65ab8022011-03-17 10:56:45 +0100479 blk_start_plug(&plug);
480
481 journal_write_revoke_records(journal, commit_transaction, WRITE_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 /*
484 * If we found any dirty or locked buffers, then we should have
485 * looped back up to the write_out_data label. If there weren't
486 * any then journal_clean_data_list should have wiped the list
487 * clean by now, so check that it is in fact empty.
488 */
489 J_ASSERT (commit_transaction->t_sync_datalist == NULL);
490
491 jbd_debug (3, "JBD: commit phase 3\n");
492
493 /*
494 * Way to go: we have now written out all of the data for a
495 * transaction! Now comes the tricky part: we need to write out
496 * metadata. Loop over the transaction's entire buffer list:
497 */
Mingming Cao772279c2008-05-14 16:05:41 -0700498 spin_lock(&journal->j_state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 commit_transaction->t_state = T_COMMIT;
Mingming Cao772279c2008-05-14 16:05:41 -0700500 spin_unlock(&journal->j_state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Josef Bacik5b9a4992008-04-28 02:16:12 -0700502 J_ASSERT(commit_transaction->t_nr_buffers <=
503 commit_transaction->t_outstanding_credits);
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 descriptor = NULL;
506 bufs = 0;
507 while (commit_transaction->t_buffers) {
508
509 /* Find the next buffer to be journaled... */
510
511 jh = commit_transaction->t_buffers;
512
513 /* If we're in abort mode, we just un-journal the buffer and
Hidehiro Kawai885e3532008-10-18 20:27:54 -0700514 release it. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
516 if (is_journal_aborted(journal)) {
Hidehiro Kawai885e3532008-10-18 20:27:54 -0700517 clear_buffer_jbddirty(jh2bh(jh));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 JBUFFER_TRACE(jh, "journal is aborting: refile");
519 journal_refile_buffer(journal, jh);
520 /* If that was the last one, we need to clean up
521 * any descriptor buffers which may have been
522 * already allocated, even if we are now
523 * aborting. */
524 if (!commit_transaction->t_buffers)
525 goto start_journal_io;
526 continue;
527 }
528
529 /* Make sure we have a descriptor block in which to
530 record the metadata buffer. */
531
532 if (!descriptor) {
533 struct buffer_head *bh;
534
535 J_ASSERT (bufs == 0);
536
537 jbd_debug(4, "JBD: get descriptor\n");
538
539 descriptor = journal_get_descriptor_buffer(journal);
540 if (!descriptor) {
Jan Kara7a266e72007-10-18 23:39:22 -0700541 journal_abort(journal, -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 continue;
543 }
544
545 bh = jh2bh(descriptor);
546 jbd_debug(4, "JBD: got buffer %llu (%p)\n",
547 (unsigned long long)bh->b_blocknr, bh->b_data);
548 header = (journal_header_t *)&bh->b_data[0];
549 header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
550 header->h_blocktype = cpu_to_be32(JFS_DESCRIPTOR_BLOCK);
551 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
552
553 tagp = &bh->b_data[sizeof(journal_header_t)];
554 space_left = bh->b_size - sizeof(journal_header_t);
555 first_tag = 1;
556 set_buffer_jwrite(bh);
557 set_buffer_dirty(bh);
558 wbuf[bufs++] = bh;
559
560 /* Record it so that we can wait for IO
561 completion later */
562 BUFFER_TRACE(bh, "ph3: file as descriptor");
563 journal_file_buffer(descriptor, commit_transaction,
564 BJ_LogCtl);
565 }
566
567 /* Where is the buffer to be written? */
568
569 err = journal_next_log_block(journal, &blocknr);
570 /* If the block mapping failed, just abandon the buffer
571 and repeat this loop: we'll fall into the
572 refile-on-abort condition above. */
573 if (err) {
Jan Kara7a266e72007-10-18 23:39:22 -0700574 journal_abort(journal, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 continue;
576 }
577
578 /*
579 * start_this_handle() uses t_outstanding_credits to determine
580 * the free space in the log, but this counter is changed
581 * by journal_next_log_block() also.
582 */
583 commit_transaction->t_outstanding_credits--;
584
585 /* Bump b_count to prevent truncate from stumbling over
586 the shadowed buffer! @@@ This can go if we ever get
587 rid of the BJ_IO/BJ_Shadow pairing of buffers. */
Namhyung Kime4d5e3a2010-10-16 17:11:02 +0900588 get_bh(jh2bh(jh));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
590 /* Make a temporary IO buffer with which to write it out
591 (this will requeue both the metadata buffer and the
592 temporary IO buffer). new_bh goes on BJ_IO*/
593
Namhyung Kima910eef2010-10-08 20:05:06 +0900594 set_buffer_jwrite(jh2bh(jh));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 /*
596 * akpm: journal_write_metadata_buffer() sets
597 * new_bh->b_transaction to commit_transaction.
598 * We need to clean this up before we release new_bh
599 * (which is of type BJ_IO)
600 */
601 JBUFFER_TRACE(jh, "ph3: write metadata");
602 flags = journal_write_metadata_buffer(commit_transaction,
603 jh, &new_jh, blocknr);
Namhyung Kima910eef2010-10-08 20:05:06 +0900604 set_buffer_jwrite(jh2bh(new_jh));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 wbuf[bufs++] = jh2bh(new_jh);
606
607 /* Record the new block's tag in the current descriptor
608 buffer */
609
610 tag_flag = 0;
611 if (flags & 1)
612 tag_flag |= JFS_FLAG_ESCAPE;
613 if (!first_tag)
614 tag_flag |= JFS_FLAG_SAME_UUID;
615
616 tag = (journal_block_tag_t *) tagp;
617 tag->t_blocknr = cpu_to_be32(jh2bh(jh)->b_blocknr);
618 tag->t_flags = cpu_to_be32(tag_flag);
619 tagp += sizeof(journal_block_tag_t);
620 space_left -= sizeof(journal_block_tag_t);
621
622 if (first_tag) {
623 memcpy (tagp, journal->j_uuid, 16);
624 tagp += 16;
625 space_left -= 16;
626 first_tag = 0;
627 }
628
629 /* If there's no more to do, or if the descriptor is full,
630 let the IO rip! */
631
632 if (bufs == journal->j_wbufsize ||
633 commit_transaction->t_buffers == NULL ||
634 space_left < sizeof(journal_block_tag_t) + 16) {
635
636 jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
637
638 /* Write an end-of-descriptor marker before
639 submitting the IOs. "tag" still points to
640 the last tag we set up. */
641
642 tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);
643
644start_journal_io:
645 for (i = 0; i < bufs; i++) {
646 struct buffer_head *bh = wbuf[i];
647 lock_buffer(bh);
648 clear_buffer_dirty(bh);
649 set_buffer_uptodate(bh);
650 bh->b_end_io = journal_end_buffer_io_sync;
Jens Axboe65ab8022011-03-17 10:56:45 +0100651 submit_bh(WRITE_SYNC, bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 }
653 cond_resched();
654
655 /* Force a new descriptor to be generated next
656 time round the loop. */
657 descriptor = NULL;
658 bufs = 0;
659 }
660 }
661
Jens Axboe65ab8022011-03-17 10:56:45 +0100662 blk_finish_plug(&plug);
663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 /* Lo and behold: we have just managed to send a transaction to
665 the log. Before we can commit it, wait for the IO so far to
666 complete. Control buffers being written are on the
667 transaction's t_log_list queue, and metadata buffers are on
668 the t_iobuf_list queue.
669
670 Wait for the buffers in reverse order. That way we are
671 less likely to be woken up until all IOs have completed, and
672 so we incur less scheduling load.
673 */
674
675 jbd_debug(3, "JBD: commit phase 4\n");
676
677 /*
678 * akpm: these are BJ_IO, and j_list_lock is not needed.
679 * See __journal_try_to_free_buffer.
680 */
681wait_for_iobuf:
682 while (commit_transaction->t_iobuf_list != NULL) {
683 struct buffer_head *bh;
684
685 jh = commit_transaction->t_iobuf_list->b_tprev;
686 bh = jh2bh(jh);
687 if (buffer_locked(bh)) {
688 wait_on_buffer(bh);
689 goto wait_for_iobuf;
690 }
691 if (cond_resched())
692 goto wait_for_iobuf;
693
694 if (unlikely(!buffer_uptodate(bh)))
695 err = -EIO;
696
697 clear_buffer_jwrite(bh);
698
699 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
700 journal_unfile_buffer(journal, jh);
701
702 /*
703 * ->t_iobuf_list should contain only dummy buffer_heads
704 * which were created by journal_write_metadata_buffer().
705 */
706 BUFFER_TRACE(bh, "dumping temporary bh");
707 journal_put_journal_head(jh);
708 __brelse(bh);
709 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
710 free_buffer_head(bh);
711
712 /* We also have to unlock and free the corresponding
713 shadowed buffer */
714 jh = commit_transaction->t_shadow_list->b_tprev;
715 bh = jh2bh(jh);
Namhyung Kima910eef2010-10-08 20:05:06 +0900716 clear_buffer_jwrite(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 J_ASSERT_BH(bh, buffer_jbddirty(bh));
718
719 /* The metadata is now released for reuse, but we need
720 to remember it against this transaction so that when
721 we finally commit, we can do any checkpointing
722 required. */
723 JBUFFER_TRACE(jh, "file as BJ_Forget");
724 journal_file_buffer(jh, commit_transaction, BJ_Forget);
Jan Kara2842bb22011-05-05 13:59:35 +0200725 /*
726 * Wake up any transactions which were waiting for this
727 * IO to complete. The barrier must be here so that changes
728 * by journal_file_buffer() take effect before wake_up_bit()
729 * does the waitqueue check.
730 */
731 smp_mb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 wake_up_bit(&bh->b_state, BH_Unshadow);
733 JBUFFER_TRACE(jh, "brelse shadowed buffer");
734 __brelse(bh);
735 }
736
737 J_ASSERT (commit_transaction->t_shadow_list == NULL);
738
739 jbd_debug(3, "JBD: commit phase 5\n");
740
741 /* Here we wait for the revoke record and descriptor record buffers */
742 wait_for_ctlbuf:
743 while (commit_transaction->t_log_list != NULL) {
744 struct buffer_head *bh;
745
746 jh = commit_transaction->t_log_list->b_tprev;
747 bh = jh2bh(jh);
748 if (buffer_locked(bh)) {
749 wait_on_buffer(bh);
750 goto wait_for_ctlbuf;
751 }
752 if (cond_resched())
753 goto wait_for_ctlbuf;
754
755 if (unlikely(!buffer_uptodate(bh)))
756 err = -EIO;
757
758 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
759 clear_buffer_jwrite(bh);
760 journal_unfile_buffer(journal, jh);
761 journal_put_journal_head(jh);
762 __brelse(bh); /* One for getblk */
763 /* AKPM: bforget here */
764 }
765
Hidehiro Kawaid1645e52008-10-18 20:27:53 -0700766 if (err)
767 journal_abort(journal, err);
768
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 jbd_debug(3, "JBD: commit phase 6\n");
770
Jan Kara03f4d802010-04-15 22:16:24 +0200771 /* All metadata is written, now write commit record and do cleanup */
772 spin_lock(&journal->j_state_lock);
773 J_ASSERT(commit_transaction->t_state == T_COMMIT);
774 commit_transaction->t_state = T_COMMIT_RECORD;
775 spin_unlock(&journal->j_state_lock);
776
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 if (journal_write_commit_record(journal, commit_transaction))
778 err = -EIO;
779
780 if (err)
Jan Kara7a266e72007-10-18 23:39:22 -0700781 journal_abort(journal, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
783 /* End of a transaction! Finally, we can do checkpoint
784 processing: any buffers committed as a result of this
785 transaction can be removed from any checkpoint list it was on
786 before. */
787
788 jbd_debug(3, "JBD: commit phase 7\n");
789
790 J_ASSERT(commit_transaction->t_sync_datalist == NULL);
791 J_ASSERT(commit_transaction->t_buffers == NULL);
792 J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
793 J_ASSERT(commit_transaction->t_iobuf_list == NULL);
794 J_ASSERT(commit_transaction->t_shadow_list == NULL);
795 J_ASSERT(commit_transaction->t_log_list == NULL);
796
797restart_loop:
Jan Karae6c9f5c2005-09-06 15:19:09 -0700798 /*
799 * As there are other places (journal_unmap_buffer()) adding buffers
800 * to this list we have to be careful and hold the j_list_lock.
801 */
802 spin_lock(&journal->j_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 while (commit_transaction->t_forget) {
804 transaction_t *cp_transaction;
805 struct buffer_head *bh;
806
807 jh = commit_transaction->t_forget;
Jan Karae6c9f5c2005-09-06 15:19:09 -0700808 spin_unlock(&journal->j_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 bh = jh2bh(jh);
810 jbd_lock_bh_state(bh);
811 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction ||
812 jh->b_transaction == journal->j_running_transaction);
813
814 /*
815 * If there is undo-protected committed data against
816 * this buffer, then we can remove it now. If it is a
817 * buffer needing such protection, the old frozen_data
818 * field now points to a committed version of the
819 * buffer, so rotate that field to the new committed
820 * data.
821 *
822 * Otherwise, we can just throw away the frozen data now.
823 */
824 if (jh->b_committed_data) {
Mingming Caoc089d492007-10-16 18:38:25 -0400825 jbd_free(jh->b_committed_data, bh->b_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 jh->b_committed_data = NULL;
827 if (jh->b_frozen_data) {
828 jh->b_committed_data = jh->b_frozen_data;
829 jh->b_frozen_data = NULL;
830 }
831 } else if (jh->b_frozen_data) {
Mingming Caoc089d492007-10-16 18:38:25 -0400832 jbd_free(jh->b_frozen_data, bh->b_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 jh->b_frozen_data = NULL;
834 }
835
836 spin_lock(&journal->j_list_lock);
837 cp_transaction = jh->b_cp_transaction;
838 if (cp_transaction) {
839 JBUFFER_TRACE(jh, "remove from old cp transaction");
840 __journal_remove_checkpoint(jh);
841 }
842
843 /* Only re-checkpoint the buffer_head if it is marked
844 * dirty. If the buffer was added to the BJ_Forget list
845 * by journal_forget, it may no longer be dirty and
846 * there's no point in keeping a checkpoint record for
847 * it. */
848
849 /* A buffer which has been freed while still being
850 * journaled by a previous transaction may end up still
851 * being dirty here, but we want to avoid writing back
Jan Kara86963912010-02-16 20:37:12 +0100852 * that buffer in the future after the "add to orphan"
853 * operation been committed, That's not only a performance
854 * gain, it also stops aliasing problems if the buffer is
855 * left behind for writeback and gets reallocated for another
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 * use in a different page. */
Jan Kara86963912010-02-16 20:37:12 +0100857 if (buffer_freed(bh) && !jh->b_next_transaction) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 clear_buffer_freed(bh);
859 clear_buffer_jbddirty(bh);
860 }
861
862 if (buffer_jbddirty(bh)) {
863 JBUFFER_TRACE(jh, "add to new checkpointing trans");
864 __journal_insert_checkpoint(jh, commit_transaction);
Hidehiro Kawai885e3532008-10-18 20:27:54 -0700865 if (is_journal_aborted(journal))
866 clear_buffer_jbddirty(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 JBUFFER_TRACE(jh, "refile for checkpoint writeback");
868 __journal_refile_buffer(jh);
869 jbd_unlock_bh_state(bh);
870 } else {
871 J_ASSERT_BH(bh, !buffer_dirty(bh));
Jan Kara9ada7342006-06-23 02:05:25 -0700872 /* The buffer on BJ_Forget list and not jbddirty means
873 * it has been freed by this transaction and hence it
874 * could not have been reallocated until this
875 * transaction has committed. *BUT* it could be
876 * reallocated once we have written all the data to
877 * disk and before we process the buffer on BJ_Forget
878 * list. */
879 JBUFFER_TRACE(jh, "refile or unfile freed buffer");
880 __journal_refile_buffer(jh);
881 if (!jh->b_transaction) {
882 jbd_unlock_bh_state(bh);
883 /* needs a brelse */
884 journal_remove_journal_head(bh);
885 release_buffer_page(bh);
886 } else
887 jbd_unlock_bh_state(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 }
Jan Karae6c9f5c2005-09-06 15:19:09 -0700889 cond_resched_lock(&journal->j_list_lock);
890 }
891 spin_unlock(&journal->j_list_lock);
892 /*
Jan Karad4beaf42007-12-04 23:45:27 -0800893 * This is a bit sleazy. We use j_list_lock to protect transition
894 * of a transaction into T_FINISHED state and calling
895 * __journal_drop_transaction(). Otherwise we could race with
896 * other checkpointing code processing the transaction...
Jan Karae6c9f5c2005-09-06 15:19:09 -0700897 */
898 spin_lock(&journal->j_state_lock);
899 spin_lock(&journal->j_list_lock);
900 /*
901 * Now recheck if some buffers did not get attached to the transaction
902 * while the lock was dropped...
903 */
904 if (commit_transaction->t_forget) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 spin_unlock(&journal->j_list_lock);
Jan Karae6c9f5c2005-09-06 15:19:09 -0700906 spin_unlock(&journal->j_state_lock);
907 goto restart_loop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 }
909
910 /* Done with this transaction! */
911
912 jbd_debug(3, "JBD: commit phase 8\n");
913
Jan Kara03f4d802010-04-15 22:16:24 +0200914 J_ASSERT(commit_transaction->t_state == T_COMMIT_RECORD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 commit_transaction->t_state = T_FINISHED;
917 J_ASSERT(commit_transaction == journal->j_committing_transaction);
918 journal->j_commit_sequence = commit_transaction->t_tid;
919 journal->j_committing_transaction = NULL;
Josef Bacikf420d4d2009-01-07 18:07:24 -0800920 commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
921
922 /*
923 * weight the commit time higher than the average time so we don't
924 * react too strongly to vast changes in commit time
925 */
926 if (likely(journal->j_average_commit_time))
927 journal->j_average_commit_time = (commit_time*3 +
928 journal->j_average_commit_time) / 4;
929 else
930 journal->j_average_commit_time = commit_time;
931
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 spin_unlock(&journal->j_state_lock);
933
Jan Karafe28e422007-07-15 23:37:18 -0700934 if (commit_transaction->t_checkpoint_list == NULL &&
935 commit_transaction->t_checkpoint_io_list == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 __journal_drop_transaction(journal, commit_transaction);
937 } else {
938 if (journal->j_checkpoint_transactions == NULL) {
939 journal->j_checkpoint_transactions = commit_transaction;
940 commit_transaction->t_cpnext = commit_transaction;
941 commit_transaction->t_cpprev = commit_transaction;
942 } else {
943 commit_transaction->t_cpnext =
944 journal->j_checkpoint_transactions;
945 commit_transaction->t_cpprev =
946 commit_transaction->t_cpnext->t_cpprev;
947 commit_transaction->t_cpnext->t_cpprev =
948 commit_transaction;
949 commit_transaction->t_cpprev->t_cpnext =
950 commit_transaction;
951 }
952 }
953 spin_unlock(&journal->j_list_lock);
954
955 jbd_debug(1, "JBD: commit %d complete, head %d\n",
956 journal->j_commit_sequence, journal->j_tail_sequence);
957
958 wake_up(&journal->j_wait_done_commit);
959}