aboutsummaryrefslogtreecommitdiffstats
path: root/fs/jbd/commit.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /fs/jbd/commit.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'fs/jbd/commit.c')
-rw-r--r--fs/jbd/commit.c844
1 files changed, 844 insertions, 0 deletions
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
new file mode 100644
index 000000000000..dac720c837ab
--- /dev/null
+++ b/fs/jbd/commit.c
@@ -0,0 +1,844 @@
1/*
2 * linux/fs/commit.c
3 *
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>
20#include <linux/slab.h>
21#include <linux/mm.h>
22#include <linux/pagemap.h>
23#include <linux/smp_lock.h>
24
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
40 * not sucessfully freed, because they are attached to a committing transaction.
41 * After the transaction commits, these pages are left on the LRU, with no
42 * ->mapping, and with attached buffers. These pages are trivially reclaimable
43 * by the VM, but their apparent absence upsets the VM accounting, and it makes
44 * the numbers in /proc/meminfo look odd.
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 *
49 * Called under lock_journal(), and possibly under journal_datalist_lock. The
50 * caller provided us with a ref against the buffer, and we drop that here.
51 */
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 */
67 if (TestSetPageLocked(page))
68 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/*
82 * Try to acquire jbd_lock_bh_state() against the buffer, when j_list_lock is
83 * held. For ranking reasons we must trylock. If we lose, schedule away and
84 * return 0. j_list_lock is dropped in this case.
85 */
86static int inverted_lock(journal_t *journal, struct buffer_head *bh)
87{
88 if (!jbd_trylock_bh_state(bh)) {
89 spin_unlock(&journal->j_list_lock);
90 schedule();
91 return 0;
92 }
93 return 1;
94}
95
96/* Done it all: now write the commit record. We should have
97 * cleaned up our previous buffers by now, so if we are in abort
98 * mode we can now just skip the rest of the journal write
99 * entirely.
100 *
101 * Returns 1 if the journal needs to be aborted or 0 on success
102 */
103static int journal_write_commit_record(journal_t *journal,
104 transaction_t *commit_transaction)
105{
106 struct journal_head *descriptor;
107 struct buffer_head *bh;
108 int i, ret;
109 int barrier_done = 0;
110
111 if (is_journal_aborted(journal))
112 return 0;
113
114 descriptor = journal_get_descriptor_buffer(journal);
115 if (!descriptor)
116 return 1;
117
118 bh = jh2bh(descriptor);
119
120 /* AKPM: buglet - add `i' to tmp! */
121 for (i = 0; i < bh->b_size; i += 512) {
122 journal_header_t *tmp = (journal_header_t*)bh->b_data;
123 tmp->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
124 tmp->h_blocktype = cpu_to_be32(JFS_COMMIT_BLOCK);
125 tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
126 }
127
128 JBUFFER_TRACE(descriptor, "write commit block");
129 set_buffer_dirty(bh);
130 if (journal->j_flags & JFS_BARRIER) {
131 set_buffer_ordered(bh);
132 barrier_done = 1;
133 }
134 ret = sync_dirty_buffer(bh);
135 /* is it possible for another commit to fail at roughly
136 * the same time as this one? If so, we don't want to
137 * trust the barrier flag in the super, but instead want
138 * to remember if we sent a barrier request
139 */
140 if (ret == -EOPNOTSUPP && barrier_done) {
141 char b[BDEVNAME_SIZE];
142
143 printk(KERN_WARNING
144 "JBD: barrier-based sync failed on %s - "
145 "disabling barriers\n",
146 bdevname(journal->j_dev, b));
147 spin_lock(&journal->j_state_lock);
148 journal->j_flags &= ~JFS_BARRIER;
149 spin_unlock(&journal->j_state_lock);
150
151 /* And try again, without the barrier */
152 clear_buffer_ordered(bh);
153 set_buffer_uptodate(bh);
154 set_buffer_dirty(bh);
155 ret = sync_dirty_buffer(bh);
156 }
157 put_bh(bh); /* One for getblk() */
158 journal_put_journal_head(descriptor);
159
160 return (ret == -EIO);
161}
162
163/*
164 * journal_commit_transaction
165 *
166 * The primary function for committing a transaction to the log. This
167 * function is called by the journal thread to begin a complete commit.
168 */
169void journal_commit_transaction(journal_t *journal)
170{
171 transaction_t *commit_transaction;
172 struct journal_head *jh, *new_jh, *descriptor;
173 struct buffer_head **wbuf = journal->j_wbuf;
174 int bufs;
175 int flags;
176 int err;
177 unsigned long blocknr;
178 char *tagp = NULL;
179 journal_header_t *header;
180 journal_block_tag_t *tag = NULL;
181 int space_left = 0;
182 int first_tag = 0;
183 int tag_flag;
184 int i;
185
186 /*
187 * First job: lock down the current transaction and wait for
188 * all outstanding updates to complete.
189 */
190
191#ifdef COMMIT_STATS
192 spin_lock(&journal->j_list_lock);
193 summarise_journal_usage(journal);
194 spin_unlock(&journal->j_list_lock);
195#endif
196
197 /* Do we need to erase the effects of a prior journal_flush? */
198 if (journal->j_flags & JFS_FLUSHED) {
199 jbd_debug(3, "super block updated\n");
200 journal_update_superblock(journal, 1);
201 } else {
202 jbd_debug(3, "superblock not updated\n");
203 }
204
205 J_ASSERT(journal->j_running_transaction != NULL);
206 J_ASSERT(journal->j_committing_transaction == NULL);
207
208 commit_transaction = journal->j_running_transaction;
209 J_ASSERT(commit_transaction->t_state == T_RUNNING);
210
211 jbd_debug(1, "JBD: starting commit of transaction %d\n",
212 commit_transaction->t_tid);
213
214 spin_lock(&journal->j_state_lock);
215 commit_transaction->t_state = T_LOCKED;
216
217 spin_lock(&commit_transaction->t_handle_lock);
218 while (commit_transaction->t_updates) {
219 DEFINE_WAIT(wait);
220
221 prepare_to_wait(&journal->j_wait_updates, &wait,
222 TASK_UNINTERRUPTIBLE);
223 if (commit_transaction->t_updates) {
224 spin_unlock(&commit_transaction->t_handle_lock);
225 spin_unlock(&journal->j_state_lock);
226 schedule();
227 spin_lock(&journal->j_state_lock);
228 spin_lock(&commit_transaction->t_handle_lock);
229 }
230 finish_wait(&journal->j_wait_updates, &wait);
231 }
232 spin_unlock(&commit_transaction->t_handle_lock);
233
234 J_ASSERT (commit_transaction->t_outstanding_credits <=
235 journal->j_max_transaction_buffers);
236
237 /*
238 * First thing we are allowed to do is to discard any remaining
239 * BJ_Reserved buffers. Note, it is _not_ permissible to assume
240 * that there are no such buffers: if a large filesystem
241 * operation like a truncate needs to split itself over multiple
242 * transactions, then it may try to do a journal_restart() while
243 * there are still BJ_Reserved buffers outstanding. These must
244 * be released cleanly from the current transaction.
245 *
246 * In this case, the filesystem must still reserve write access
247 * again before modifying the buffer in the new transaction, but
248 * we do not require it to remember exactly which old buffers it
249 * has reserved. This is consistent with the existing behaviour
250 * that multiple journal_get_write_access() calls to the same
251 * buffer are perfectly permissable.
252 */
253 while (commit_transaction->t_reserved_list) {
254 jh = commit_transaction->t_reserved_list;
255 JBUFFER_TRACE(jh, "reserved, unused: refile");
256 /*
257 * A journal_get_undo_access()+journal_release_buffer() may
258 * leave undo-committed data.
259 */
260 if (jh->b_committed_data) {
261 struct buffer_head *bh = jh2bh(jh);
262
263 jbd_lock_bh_state(bh);
264 if (jh->b_committed_data) {
265 kfree(jh->b_committed_data);
266 jh->b_committed_data = NULL;
267 }
268 jbd_unlock_bh_state(bh);
269 }
270 journal_refile_buffer(journal, jh);
271 }
272
273 /*
274 * Now try to drop any written-back buffers from the journal's
275 * checkpoint lists. We do this *before* commit because it potentially
276 * frees some memory
277 */
278 spin_lock(&journal->j_list_lock);
279 __journal_clean_checkpoint_list(journal);
280 spin_unlock(&journal->j_list_lock);
281
282 jbd_debug (3, "JBD: commit phase 1\n");
283
284 /*
285 * Switch to a new revoke table.
286 */
287 journal_switch_revoke_table(journal);
288
289 commit_transaction->t_state = T_FLUSH;
290 journal->j_committing_transaction = commit_transaction;
291 journal->j_running_transaction = NULL;
292 commit_transaction->t_log_start = journal->j_head;
293 wake_up(&journal->j_wait_transaction_locked);
294 spin_unlock(&journal->j_state_lock);
295
296 jbd_debug (3, "JBD: commit phase 2\n");
297
298 /*
299 * First, drop modified flag: all accesses to the buffers
300 * will be tracked for a new trasaction only -bzzz
301 */
302 spin_lock(&journal->j_list_lock);
303 if (commit_transaction->t_buffers) {
304 new_jh = jh = commit_transaction->t_buffers->b_tnext;
305 do {
306 J_ASSERT_JH(new_jh, new_jh->b_modified == 1 ||
307 new_jh->b_modified == 0);
308 new_jh->b_modified = 0;
309 new_jh = new_jh->b_tnext;
310 } while (new_jh != jh);
311 }
312 spin_unlock(&journal->j_list_lock);
313
314 /*
315 * Now start flushing things to disk, in the order they appear
316 * on the transaction lists. Data blocks go first.
317 */
318
319 err = 0;
320 /*
321 * Whenever we unlock the journal and sleep, things can get added
322 * onto ->t_sync_datalist, so we have to keep looping back to
323 * write_out_data until we *know* that the list is empty.
324 */
325 bufs = 0;
326 /*
327 * Cleanup any flushed data buffers from the data list. Even in
328 * abort mode, we want to flush this out as soon as possible.
329 */
330write_out_data:
331 cond_resched();
332 spin_lock(&journal->j_list_lock);
333
334 while (commit_transaction->t_sync_datalist) {
335 struct buffer_head *bh;
336
337 jh = commit_transaction->t_sync_datalist;
338 commit_transaction->t_sync_datalist = jh->b_tnext;
339 bh = jh2bh(jh);
340 if (buffer_locked(bh)) {
341 BUFFER_TRACE(bh, "locked");
342 if (!inverted_lock(journal, bh))
343 goto write_out_data;
344 __journal_temp_unlink_buffer(jh);
345 __journal_file_buffer(jh, commit_transaction,
346 BJ_Locked);
347 jbd_unlock_bh_state(bh);
348 if (lock_need_resched(&journal->j_list_lock)) {
349 spin_unlock(&journal->j_list_lock);
350 goto write_out_data;
351 }
352 } else {
353 if (buffer_dirty(bh)) {
354 BUFFER_TRACE(bh, "start journal writeout");
355 get_bh(bh);
356 wbuf[bufs++] = bh;
357 if (bufs == journal->j_wbufsize) {
358 jbd_debug(2, "submit %d writes\n",
359 bufs);
360 spin_unlock(&journal->j_list_lock);
361 ll_rw_block(WRITE, bufs, wbuf);
362 journal_brelse_array(wbuf, bufs);
363 bufs = 0;
364 goto write_out_data;
365 }
366 } else {
367 BUFFER_TRACE(bh, "writeout complete: unfile");
368 if (!inverted_lock(journal, bh))
369 goto write_out_data;
370 __journal_unfile_buffer(jh);
371 jbd_unlock_bh_state(bh);
372 journal_remove_journal_head(bh);
373 put_bh(bh);
374 if (lock_need_resched(&journal->j_list_lock)) {
375 spin_unlock(&journal->j_list_lock);
376 goto write_out_data;
377 }
378 }
379 }
380 }
381
382 if (bufs) {
383 spin_unlock(&journal->j_list_lock);
384 ll_rw_block(WRITE, bufs, wbuf);
385 journal_brelse_array(wbuf, bufs);
386 spin_lock(&journal->j_list_lock);
387 }
388
389 /*
390 * Wait for all previously submitted IO to complete.
391 */
392 while (commit_transaction->t_locked_list) {
393 struct buffer_head *bh;
394
395 jh = commit_transaction->t_locked_list->b_tprev;
396 bh = jh2bh(jh);
397 get_bh(bh);
398 if (buffer_locked(bh)) {
399 spin_unlock(&journal->j_list_lock);
400 wait_on_buffer(bh);
401 if (unlikely(!buffer_uptodate(bh)))
402 err = -EIO;
403 spin_lock(&journal->j_list_lock);
404 }
405 if (!inverted_lock(journal, bh)) {
406 put_bh(bh);
407 spin_lock(&journal->j_list_lock);
408 continue;
409 }
410 if (buffer_jbd(bh) && jh->b_jlist == BJ_Locked) {
411 __journal_unfile_buffer(jh);
412 jbd_unlock_bh_state(bh);
413 journal_remove_journal_head(bh);
414 put_bh(bh);
415 } else {
416 jbd_unlock_bh_state(bh);
417 }
418 put_bh(bh);
419 cond_resched_lock(&journal->j_list_lock);
420 }
421 spin_unlock(&journal->j_list_lock);
422
423 if (err)
424 __journal_abort_hard(journal);
425
426 journal_write_revoke_records(journal, commit_transaction);
427
428 jbd_debug(3, "JBD: commit phase 2\n");
429
430 /*
431 * If we found any dirty or locked buffers, then we should have
432 * looped back up to the write_out_data label. If there weren't
433 * any then journal_clean_data_list should have wiped the list
434 * clean by now, so check that it is in fact empty.
435 */
436 J_ASSERT (commit_transaction->t_sync_datalist == NULL);
437
438 jbd_debug (3, "JBD: commit phase 3\n");
439
440 /*
441 * Way to go: we have now written out all of the data for a
442 * transaction! Now comes the tricky part: we need to write out
443 * metadata. Loop over the transaction's entire buffer list:
444 */
445 commit_transaction->t_state = T_COMMIT;
446
447 descriptor = NULL;
448 bufs = 0;
449 while (commit_transaction->t_buffers) {
450
451 /* Find the next buffer to be journaled... */
452
453 jh = commit_transaction->t_buffers;
454
455 /* If we're in abort mode, we just un-journal the buffer and
456 release it for background writing. */
457
458 if (is_journal_aborted(journal)) {
459 JBUFFER_TRACE(jh, "journal is aborting: refile");
460 journal_refile_buffer(journal, jh);
461 /* If that was the last one, we need to clean up
462 * any descriptor buffers which may have been
463 * already allocated, even if we are now
464 * aborting. */
465 if (!commit_transaction->t_buffers)
466 goto start_journal_io;
467 continue;
468 }
469
470 /* Make sure we have a descriptor block in which to
471 record the metadata buffer. */
472
473 if (!descriptor) {
474 struct buffer_head *bh;
475
476 J_ASSERT (bufs == 0);
477
478 jbd_debug(4, "JBD: get descriptor\n");
479
480 descriptor = journal_get_descriptor_buffer(journal);
481 if (!descriptor) {
482 __journal_abort_hard(journal);
483 continue;
484 }
485
486 bh = jh2bh(descriptor);
487 jbd_debug(4, "JBD: got buffer %llu (%p)\n",
488 (unsigned long long)bh->b_blocknr, bh->b_data);
489 header = (journal_header_t *)&bh->b_data[0];
490 header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
491 header->h_blocktype = cpu_to_be32(JFS_DESCRIPTOR_BLOCK);
492 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
493
494 tagp = &bh->b_data[sizeof(journal_header_t)];
495 space_left = bh->b_size - sizeof(journal_header_t);
496 first_tag = 1;
497 set_buffer_jwrite(bh);
498 set_buffer_dirty(bh);
499 wbuf[bufs++] = bh;
500
501 /* Record it so that we can wait for IO
502 completion later */
503 BUFFER_TRACE(bh, "ph3: file as descriptor");
504 journal_file_buffer(descriptor, commit_transaction,
505 BJ_LogCtl);
506 }
507
508 /* Where is the buffer to be written? */
509
510 err = journal_next_log_block(journal, &blocknr);
511 /* If the block mapping failed, just abandon the buffer
512 and repeat this loop: we'll fall into the
513 refile-on-abort condition above. */
514 if (err) {
515 __journal_abort_hard(journal);
516 continue;
517 }
518
519 /*
520 * start_this_handle() uses t_outstanding_credits to determine
521 * the free space in the log, but this counter is changed
522 * by journal_next_log_block() also.
523 */
524 commit_transaction->t_outstanding_credits--;
525
526 /* Bump b_count to prevent truncate from stumbling over
527 the shadowed buffer! @@@ This can go if we ever get
528 rid of the BJ_IO/BJ_Shadow pairing of buffers. */
529 atomic_inc(&jh2bh(jh)->b_count);
530
531 /* Make a temporary IO buffer with which to write it out
532 (this will requeue both the metadata buffer and the
533 temporary IO buffer). new_bh goes on BJ_IO*/
534
535 set_bit(BH_JWrite, &jh2bh(jh)->b_state);
536 /*
537 * akpm: journal_write_metadata_buffer() sets
538 * new_bh->b_transaction to commit_transaction.
539 * We need to clean this up before we release new_bh
540 * (which is of type BJ_IO)
541 */
542 JBUFFER_TRACE(jh, "ph3: write metadata");
543 flags = journal_write_metadata_buffer(commit_transaction,
544 jh, &new_jh, blocknr);
545 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
546 wbuf[bufs++] = jh2bh(new_jh);
547
548 /* Record the new block's tag in the current descriptor
549 buffer */
550
551 tag_flag = 0;
552 if (flags & 1)
553 tag_flag |= JFS_FLAG_ESCAPE;
554 if (!first_tag)
555 tag_flag |= JFS_FLAG_SAME_UUID;
556
557 tag = (journal_block_tag_t *) tagp;
558 tag->t_blocknr = cpu_to_be32(jh2bh(jh)->b_blocknr);
559 tag->t_flags = cpu_to_be32(tag_flag);
560 tagp += sizeof(journal_block_tag_t);
561 space_left -= sizeof(journal_block_tag_t);
562
563 if (first_tag) {
564 memcpy (tagp, journal->j_uuid, 16);
565 tagp += 16;
566 space_left -= 16;
567 first_tag = 0;
568 }
569
570 /* If there's no more to do, or if the descriptor is full,
571 let the IO rip! */
572
573 if (bufs == journal->j_wbufsize ||
574 commit_transaction->t_buffers == NULL ||
575 space_left < sizeof(journal_block_tag_t) + 16) {
576
577 jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
578
579 /* Write an end-of-descriptor marker before
580 submitting the IOs. "tag" still points to
581 the last tag we set up. */
582
583 tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);
584
585start_journal_io:
586 for (i = 0; i < bufs; i++) {
587 struct buffer_head *bh = wbuf[i];
588 lock_buffer(bh);
589 clear_buffer_dirty(bh);
590 set_buffer_uptodate(bh);
591 bh->b_end_io = journal_end_buffer_io_sync;
592 submit_bh(WRITE, bh);
593 }
594 cond_resched();
595
596 /* Force a new descriptor to be generated next
597 time round the loop. */
598 descriptor = NULL;
599 bufs = 0;
600 }
601 }
602
603 /* Lo and behold: we have just managed to send a transaction to
604 the log. Before we can commit it, wait for the IO so far to
605 complete. Control buffers being written are on the
606 transaction's t_log_list queue, and metadata buffers are on
607 the t_iobuf_list queue.
608
609 Wait for the buffers in reverse order. That way we are
610 less likely to be woken up until all IOs have completed, and
611 so we incur less scheduling load.
612 */
613
614 jbd_debug(3, "JBD: commit phase 4\n");
615
616 /*
617 * akpm: these are BJ_IO, and j_list_lock is not needed.
618 * See __journal_try_to_free_buffer.
619 */
620wait_for_iobuf:
621 while (commit_transaction->t_iobuf_list != NULL) {
622 struct buffer_head *bh;
623
624 jh = commit_transaction->t_iobuf_list->b_tprev;
625 bh = jh2bh(jh);
626 if (buffer_locked(bh)) {
627 wait_on_buffer(bh);
628 goto wait_for_iobuf;
629 }
630 if (cond_resched())
631 goto wait_for_iobuf;
632
633 if (unlikely(!buffer_uptodate(bh)))
634 err = -EIO;
635
636 clear_buffer_jwrite(bh);
637
638 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
639 journal_unfile_buffer(journal, jh);
640
641 /*
642 * ->t_iobuf_list should contain only dummy buffer_heads
643 * which were created by journal_write_metadata_buffer().
644 */
645 BUFFER_TRACE(bh, "dumping temporary bh");
646 journal_put_journal_head(jh);
647 __brelse(bh);
648 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
649 free_buffer_head(bh);
650
651 /* We also have to unlock and free the corresponding
652 shadowed buffer */
653 jh = commit_transaction->t_shadow_list->b_tprev;
654 bh = jh2bh(jh);
655 clear_bit(BH_JWrite, &bh->b_state);
656 J_ASSERT_BH(bh, buffer_jbddirty(bh));
657
658 /* The metadata is now released for reuse, but we need
659 to remember it against this transaction so that when
660 we finally commit, we can do any checkpointing
661 required. */
662 JBUFFER_TRACE(jh, "file as BJ_Forget");
663 journal_file_buffer(jh, commit_transaction, BJ_Forget);
664 /* Wake up any transactions which were waiting for this
665 IO to complete */
666 wake_up_bit(&bh->b_state, BH_Unshadow);
667 JBUFFER_TRACE(jh, "brelse shadowed buffer");
668 __brelse(bh);
669 }
670
671 J_ASSERT (commit_transaction->t_shadow_list == NULL);
672
673 jbd_debug(3, "JBD: commit phase 5\n");
674
675 /* Here we wait for the revoke record and descriptor record buffers */
676 wait_for_ctlbuf:
677 while (commit_transaction->t_log_list != NULL) {
678 struct buffer_head *bh;
679
680 jh = commit_transaction->t_log_list->b_tprev;
681 bh = jh2bh(jh);
682 if (buffer_locked(bh)) {
683 wait_on_buffer(bh);
684 goto wait_for_ctlbuf;
685 }
686 if (cond_resched())
687 goto wait_for_ctlbuf;
688
689 if (unlikely(!buffer_uptodate(bh)))
690 err = -EIO;
691
692 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
693 clear_buffer_jwrite(bh);
694 journal_unfile_buffer(journal, jh);
695 journal_put_journal_head(jh);
696 __brelse(bh); /* One for getblk */
697 /* AKPM: bforget here */
698 }
699
700 jbd_debug(3, "JBD: commit phase 6\n");
701
702 if (journal_write_commit_record(journal, commit_transaction))
703 err = -EIO;
704
705 if (err)
706 __journal_abort_hard(journal);
707
708 /* End of a transaction! Finally, we can do checkpoint
709 processing: any buffers committed as a result of this
710 transaction can be removed from any checkpoint list it was on
711 before. */
712
713 jbd_debug(3, "JBD: commit phase 7\n");
714
715 J_ASSERT(commit_transaction->t_sync_datalist == NULL);
716 J_ASSERT(commit_transaction->t_buffers == NULL);
717 J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
718 J_ASSERT(commit_transaction->t_iobuf_list == NULL);
719 J_ASSERT(commit_transaction->t_shadow_list == NULL);
720 J_ASSERT(commit_transaction->t_log_list == NULL);
721
722restart_loop:
723 while (commit_transaction->t_forget) {
724 transaction_t *cp_transaction;
725 struct buffer_head *bh;
726
727 jh = commit_transaction->t_forget;
728 bh = jh2bh(jh);
729 jbd_lock_bh_state(bh);
730 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction ||
731 jh->b_transaction == journal->j_running_transaction);
732
733 /*
734 * If there is undo-protected committed data against
735 * this buffer, then we can remove it now. If it is a
736 * buffer needing such protection, the old frozen_data
737 * field now points to a committed version of the
738 * buffer, so rotate that field to the new committed
739 * data.
740 *
741 * Otherwise, we can just throw away the frozen data now.
742 */
743 if (jh->b_committed_data) {
744 kfree(jh->b_committed_data);
745 jh->b_committed_data = NULL;
746 if (jh->b_frozen_data) {
747 jh->b_committed_data = jh->b_frozen_data;
748 jh->b_frozen_data = NULL;
749 }
750 } else if (jh->b_frozen_data) {
751 kfree(jh->b_frozen_data);
752 jh->b_frozen_data = NULL;
753 }
754
755 spin_lock(&journal->j_list_lock);
756 cp_transaction = jh->b_cp_transaction;
757 if (cp_transaction) {
758 JBUFFER_TRACE(jh, "remove from old cp transaction");
759 __journal_remove_checkpoint(jh);
760 }
761
762 /* Only re-checkpoint the buffer_head if it is marked
763 * dirty. If the buffer was added to the BJ_Forget list
764 * by journal_forget, it may no longer be dirty and
765 * there's no point in keeping a checkpoint record for
766 * it. */
767
768 /* A buffer which has been freed while still being
769 * journaled by a previous transaction may end up still
770 * being dirty here, but we want to avoid writing back
771 * that buffer in the future now that the last use has
772 * been committed. That's not only a performance gain,
773 * it also stops aliasing problems if the buffer is left
774 * behind for writeback and gets reallocated for another
775 * use in a different page. */
776 if (buffer_freed(bh)) {
777 clear_buffer_freed(bh);
778 clear_buffer_jbddirty(bh);
779 }
780
781 if (buffer_jbddirty(bh)) {
782 JBUFFER_TRACE(jh, "add to new checkpointing trans");
783 __journal_insert_checkpoint(jh, commit_transaction);
784 JBUFFER_TRACE(jh, "refile for checkpoint writeback");
785 __journal_refile_buffer(jh);
786 jbd_unlock_bh_state(bh);
787 } else {
788 J_ASSERT_BH(bh, !buffer_dirty(bh));
789 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
790 __journal_unfile_buffer(jh);
791 jbd_unlock_bh_state(bh);
792 journal_remove_journal_head(bh); /* needs a brelse */
793 release_buffer_page(bh);
794 }
795 spin_unlock(&journal->j_list_lock);
796 if (cond_resched())
797 goto restart_loop;
798 }
799
800 /* Done with this transaction! */
801
802 jbd_debug(3, "JBD: commit phase 8\n");
803
804 J_ASSERT(commit_transaction->t_state == T_COMMIT);
805
806 /*
807 * This is a bit sleazy. We borrow j_list_lock to protect
808 * journal->j_committing_transaction in __journal_remove_checkpoint.
809 * Really, __jornal_remove_checkpoint should be using j_state_lock but
810 * it's a bit hassle to hold that across __journal_remove_checkpoint
811 */
812 spin_lock(&journal->j_state_lock);
813 spin_lock(&journal->j_list_lock);
814 commit_transaction->t_state = T_FINISHED;
815 J_ASSERT(commit_transaction == journal->j_committing_transaction);
816 journal->j_commit_sequence = commit_transaction->t_tid;
817 journal->j_committing_transaction = NULL;
818 spin_unlock(&journal->j_state_lock);
819
820 if (commit_transaction->t_checkpoint_list == NULL) {
821 __journal_drop_transaction(journal, commit_transaction);
822 } else {
823 if (journal->j_checkpoint_transactions == NULL) {
824 journal->j_checkpoint_transactions = commit_transaction;
825 commit_transaction->t_cpnext = commit_transaction;
826 commit_transaction->t_cpprev = commit_transaction;
827 } else {
828 commit_transaction->t_cpnext =
829 journal->j_checkpoint_transactions;
830 commit_transaction->t_cpprev =
831 commit_transaction->t_cpnext->t_cpprev;
832 commit_transaction->t_cpnext->t_cpprev =
833 commit_transaction;
834 commit_transaction->t_cpprev->t_cpnext =
835 commit_transaction;
836 }
837 }
838 spin_unlock(&journal->j_list_lock);
839
840 jbd_debug(1, "JBD: commit %d complete, head %d\n",
841 journal->j_commit_sequence, journal->j_tail_sequence);
842
843 wake_up(&journal->j_wait_done_commit);
844}