aboutsummaryrefslogtreecommitdiffstats
path: root/fs/jbd/commit.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/jbd/commit.c')
-rw-r--r--fs/jbd/commit.c1021
1 files changed, 0 insertions, 1021 deletions
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
deleted file mode 100644
index bb217dcb41af..000000000000
--- a/fs/jbd/commit.c
+++ /dev/null
@@ -1,1021 +0,0 @@
1/*
2 * linux/fs/jbd/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/mm.h>
21#include <linux/pagemap.h>
22#include <linux/bio.h>
23#include <linux/blkdev.h>
24#include <trace/events/jbd.h>
25
26/*
27 * Default IO end handler for temporary BJ_IO buffer_heads.
28 */
29static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
30{
31 BUFFER_TRACE(bh, "");
32 if (uptodate)
33 set_buffer_uptodate(bh);
34 else
35 clear_buffer_uptodate(bh);
36 unlock_buffer(bh);
37}
38
39/*
40 * When an ext3-ordered file is truncated, it is possible that many pages are
41 * not successfully freed, because they are attached to a committing transaction.
42 * After the transaction commits, these pages are left on the LRU, with no
43 * ->mapping, and with attached buffers. These pages are trivially reclaimable
44 * by the VM, but their apparent absence upsets the VM accounting, and it makes
45 * the numbers in /proc/meminfo look odd.
46 *
47 * So here, we have a buffer which has just come off the forget list. Look to
48 * see if we can strip all buffers from the backing page.
49 *
50 * Called under journal->j_list_lock. The caller provided us with a ref
51 * against the buffer, and we drop that here.
52 */
53static void release_buffer_page(struct buffer_head *bh)
54{
55 struct page *page;
56
57 if (buffer_dirty(bh))
58 goto nope;
59 if (atomic_read(&bh->b_count) != 1)
60 goto nope;
61 page = bh->b_page;
62 if (!page)
63 goto nope;
64 if (page->mapping)
65 goto nope;
66
67 /* OK, it's a truncated page */
68 if (!trylock_page(page))
69 goto nope;
70
71 page_cache_get(page);
72 __brelse(bh);
73 try_to_free_buffers(page);
74 unlock_page(page);
75 page_cache_release(page);
76 return;
77
78nope:
79 __brelse(bh);
80}
81
82/*
83 * Decrement reference counter for data buffer. If it has been marked
84 * 'BH_Freed', release it and the page to which it belongs if possible.
85 */
86static void release_data_buffer(struct buffer_head *bh)
87{
88 if (buffer_freed(bh)) {
89 WARN_ON_ONCE(buffer_dirty(bh));
90 clear_buffer_freed(bh);
91 clear_buffer_mapped(bh);
92 clear_buffer_new(bh);
93 clear_buffer_req(bh);
94 bh->b_bdev = NULL;
95 release_buffer_page(bh);
96 } else
97 put_bh(bh);
98}
99
100/*
101 * Try to acquire jbd_lock_bh_state() against the buffer, when j_list_lock is
102 * held. For ranking reasons we must trylock. If we lose, schedule away and
103 * return 0. j_list_lock is dropped in this case.
104 */
105static int inverted_lock(journal_t *journal, struct buffer_head *bh)
106{
107 if (!jbd_trylock_bh_state(bh)) {
108 spin_unlock(&journal->j_list_lock);
109 schedule();
110 return 0;
111 }
112 return 1;
113}
114
115/* Done it all: now write the commit record. We should have
116 * cleaned up our previous buffers by now, so if we are in abort
117 * mode we can now just skip the rest of the journal write
118 * entirely.
119 *
120 * Returns 1 if the journal needs to be aborted or 0 on success
121 */
122static int journal_write_commit_record(journal_t *journal,
123 transaction_t *commit_transaction)
124{
125 struct journal_head *descriptor;
126 struct buffer_head *bh;
127 journal_header_t *header;
128 int ret;
129
130 if (is_journal_aborted(journal))
131 return 0;
132
133 descriptor = journal_get_descriptor_buffer(journal);
134 if (!descriptor)
135 return 1;
136
137 bh = jh2bh(descriptor);
138
139 header = (journal_header_t *)(bh->b_data);
140 header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
141 header->h_blocktype = cpu_to_be32(JFS_COMMIT_BLOCK);
142 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
143
144 JBUFFER_TRACE(descriptor, "write commit block");
145 set_buffer_dirty(bh);
146
147 if (journal->j_flags & JFS_BARRIER)
148 ret = __sync_dirty_buffer(bh, WRITE_SYNC | WRITE_FLUSH_FUA);
149 else
150 ret = sync_dirty_buffer(bh);
151
152 put_bh(bh); /* One for getblk() */
153 journal_put_journal_head(descriptor);
154
155 return (ret == -EIO);
156}
157
158static void journal_do_submit_data(struct buffer_head **wbuf, int bufs,
159 int write_op)
160{
161 int i;
162
163 for (i = 0; i < bufs; i++) {
164 wbuf[i]->b_end_io = end_buffer_write_sync;
165 /*
166 * Here we write back pagecache data that may be mmaped. Since
167 * we cannot afford to clean the page and set PageWriteback
168 * here due to lock ordering (page lock ranks above transaction
169 * start), the data can change while IO is in flight. Tell the
170 * block layer it should bounce the bio pages if stable data
171 * during write is required.
172 *
173 * We use up our safety reference in submit_bh().
174 */
175 _submit_bh(write_op, wbuf[i], 1 << BIO_SNAP_STABLE);
176 }
177}
178
179/*
180 * Submit all the data buffers to disk
181 */
182static int journal_submit_data_buffers(journal_t *journal,
183 transaction_t *commit_transaction,
184 int write_op)
185{
186 struct journal_head *jh;
187 struct buffer_head *bh;
188 int locked;
189 int bufs = 0;
190 struct buffer_head **wbuf = journal->j_wbuf;
191 int err = 0;
192
193 /*
194 * Whenever we unlock the journal and sleep, things can get added
195 * onto ->t_sync_datalist, so we have to keep looping back to
196 * write_out_data until we *know* that the list is empty.
197 *
198 * Cleanup any flushed data buffers from the data list. Even in
199 * abort mode, we want to flush this out as soon as possible.
200 */
201write_out_data:
202 cond_resched();
203 spin_lock(&journal->j_list_lock);
204
205 while (commit_transaction->t_sync_datalist) {
206 jh = commit_transaction->t_sync_datalist;
207 bh = jh2bh(jh);
208 locked = 0;
209
210 /* Get reference just to make sure buffer does not disappear
211 * when we are forced to drop various locks */
212 get_bh(bh);
213 /* If the buffer is dirty, we need to submit IO and hence
214 * we need the buffer lock. We try to lock the buffer without
215 * blocking. If we fail, we need to drop j_list_lock and do
216 * blocking lock_buffer().
217 */
218 if (buffer_dirty(bh)) {
219 if (!trylock_buffer(bh)) {
220 BUFFER_TRACE(bh, "needs blocking lock");
221 spin_unlock(&journal->j_list_lock);
222 trace_jbd_do_submit_data(journal,
223 commit_transaction);
224 /* Write out all data to prevent deadlocks */
225 journal_do_submit_data(wbuf, bufs, write_op);
226 bufs = 0;
227 lock_buffer(bh);
228 spin_lock(&journal->j_list_lock);
229 }
230 locked = 1;
231 }
232 /* We have to get bh_state lock. Again out of order, sigh. */
233 if (!inverted_lock(journal, bh)) {
234 jbd_lock_bh_state(bh);
235 spin_lock(&journal->j_list_lock);
236 }
237 /* Someone already cleaned up the buffer? */
238 if (!buffer_jbd(bh) || bh2jh(bh) != jh
239 || jh->b_transaction != commit_transaction
240 || jh->b_jlist != BJ_SyncData) {
241 jbd_unlock_bh_state(bh);
242 if (locked)
243 unlock_buffer(bh);
244 BUFFER_TRACE(bh, "already cleaned up");
245 release_data_buffer(bh);
246 continue;
247 }
248 if (locked && test_clear_buffer_dirty(bh)) {
249 BUFFER_TRACE(bh, "needs writeout, adding to array");
250 wbuf[bufs++] = bh;
251 __journal_file_buffer(jh, commit_transaction,
252 BJ_Locked);
253 jbd_unlock_bh_state(bh);
254 if (bufs == journal->j_wbufsize) {
255 spin_unlock(&journal->j_list_lock);
256 trace_jbd_do_submit_data(journal,
257 commit_transaction);
258 journal_do_submit_data(wbuf, bufs, write_op);
259 bufs = 0;
260 goto write_out_data;
261 }
262 } else if (!locked && buffer_locked(bh)) {
263 __journal_file_buffer(jh, commit_transaction,
264 BJ_Locked);
265 jbd_unlock_bh_state(bh);
266 put_bh(bh);
267 } else {
268 BUFFER_TRACE(bh, "writeout complete: unfile");
269 if (unlikely(!buffer_uptodate(bh)))
270 err = -EIO;
271 __journal_unfile_buffer(jh);
272 jbd_unlock_bh_state(bh);
273 if (locked)
274 unlock_buffer(bh);
275 release_data_buffer(bh);
276 }
277
278 if (need_resched() || spin_needbreak(&journal->j_list_lock)) {
279 spin_unlock(&journal->j_list_lock);
280 goto write_out_data;
281 }
282 }
283 spin_unlock(&journal->j_list_lock);
284 trace_jbd_do_submit_data(journal, commit_transaction);
285 journal_do_submit_data(wbuf, bufs, write_op);
286
287 return err;
288}
289
290/*
291 * journal_commit_transaction
292 *
293 * The primary function for committing a transaction to the log. This
294 * function is called by the journal thread to begin a complete commit.
295 */
296void journal_commit_transaction(journal_t *journal)
297{
298 transaction_t *commit_transaction;
299 struct journal_head *jh, *new_jh, *descriptor;
300 struct buffer_head **wbuf = journal->j_wbuf;
301 int bufs;
302 int flags;
303 int err;
304 unsigned int blocknr;
305 ktime_t start_time;
306 u64 commit_time;
307 char *tagp = NULL;
308 journal_header_t *header;
309 journal_block_tag_t *tag = NULL;
310 int space_left = 0;
311 int first_tag = 0;
312 int tag_flag;
313 int i;
314 struct blk_plug plug;
315 int write_op = WRITE;
316
317 /*
318 * First job: lock down the current transaction and wait for
319 * all outstanding updates to complete.
320 */
321
322 /* Do we need to erase the effects of a prior journal_flush? */
323 if (journal->j_flags & JFS_FLUSHED) {
324 jbd_debug(3, "super block updated\n");
325 mutex_lock(&journal->j_checkpoint_mutex);
326 /*
327 * We hold j_checkpoint_mutex so tail cannot change under us.
328 * We don't need any special data guarantees for writing sb
329 * since journal is empty and it is ok for write to be
330 * flushed only with transaction commit.
331 */
332 journal_update_sb_log_tail(journal, journal->j_tail_sequence,
333 journal->j_tail, WRITE_SYNC);
334 mutex_unlock(&journal->j_checkpoint_mutex);
335 } else {
336 jbd_debug(3, "superblock not updated\n");
337 }
338
339 J_ASSERT(journal->j_running_transaction != NULL);
340 J_ASSERT(journal->j_committing_transaction == NULL);
341
342 commit_transaction = journal->j_running_transaction;
343
344 trace_jbd_start_commit(journal, commit_transaction);
345 jbd_debug(1, "JBD: starting commit of transaction %d\n",
346 commit_transaction->t_tid);
347
348 spin_lock(&journal->j_state_lock);
349 J_ASSERT(commit_transaction->t_state == T_RUNNING);
350 commit_transaction->t_state = T_LOCKED;
351
352 trace_jbd_commit_locking(journal, commit_transaction);
353 spin_lock(&commit_transaction->t_handle_lock);
354 while (commit_transaction->t_updates) {
355 DEFINE_WAIT(wait);
356
357 prepare_to_wait(&journal->j_wait_updates, &wait,
358 TASK_UNINTERRUPTIBLE);
359 if (commit_transaction->t_updates) {
360 spin_unlock(&commit_transaction->t_handle_lock);
361 spin_unlock(&journal->j_state_lock);
362 schedule();
363 spin_lock(&journal->j_state_lock);
364 spin_lock(&commit_transaction->t_handle_lock);
365 }
366 finish_wait(&journal->j_wait_updates, &wait);
367 }
368 spin_unlock(&commit_transaction->t_handle_lock);
369
370 J_ASSERT (commit_transaction->t_outstanding_credits <=
371 journal->j_max_transaction_buffers);
372
373 /*
374 * First thing we are allowed to do is to discard any remaining
375 * BJ_Reserved buffers. Note, it is _not_ permissible to assume
376 * that there are no such buffers: if a large filesystem
377 * operation like a truncate needs to split itself over multiple
378 * transactions, then it may try to do a journal_restart() while
379 * there are still BJ_Reserved buffers outstanding. These must
380 * be released cleanly from the current transaction.
381 *
382 * In this case, the filesystem must still reserve write access
383 * again before modifying the buffer in the new transaction, but
384 * we do not require it to remember exactly which old buffers it
385 * has reserved. This is consistent with the existing behaviour
386 * that multiple journal_get_write_access() calls to the same
387 * buffer are perfectly permissible.
388 */
389 while (commit_transaction->t_reserved_list) {
390 jh = commit_transaction->t_reserved_list;
391 JBUFFER_TRACE(jh, "reserved, unused: refile");
392 /*
393 * A journal_get_undo_access()+journal_release_buffer() may
394 * leave undo-committed data.
395 */
396 if (jh->b_committed_data) {
397 struct buffer_head *bh = jh2bh(jh);
398
399 jbd_lock_bh_state(bh);
400 jbd_free(jh->b_committed_data, bh->b_size);
401 jh->b_committed_data = NULL;
402 jbd_unlock_bh_state(bh);
403 }
404 journal_refile_buffer(journal, jh);
405 }
406
407 /*
408 * Now try to drop any written-back buffers from the journal's
409 * checkpoint lists. We do this *before* commit because it potentially
410 * frees some memory
411 */
412 spin_lock(&journal->j_list_lock);
413 __journal_clean_checkpoint_list(journal);
414 spin_unlock(&journal->j_list_lock);
415
416 jbd_debug (3, "JBD: commit phase 1\n");
417
418 /*
419 * Clear revoked flag to reflect there is no revoked buffers
420 * in the next transaction which is going to be started.
421 */
422 journal_clear_buffer_revoked_flags(journal);
423
424 /*
425 * Switch to a new revoke table.
426 */
427 journal_switch_revoke_table(journal);
428
429 trace_jbd_commit_flushing(journal, commit_transaction);
430 commit_transaction->t_state = T_FLUSH;
431 journal->j_committing_transaction = commit_transaction;
432 journal->j_running_transaction = NULL;
433 start_time = ktime_get();
434 commit_transaction->t_log_start = journal->j_head;
435 wake_up(&journal->j_wait_transaction_locked);
436 spin_unlock(&journal->j_state_lock);
437
438 jbd_debug (3, "JBD: commit phase 2\n");
439
440 if (tid_geq(journal->j_commit_waited, commit_transaction->t_tid))
441 write_op = WRITE_SYNC;
442
443 /*
444 * Now start flushing things to disk, in the order they appear
445 * on the transaction lists. Data blocks go first.
446 */
447 blk_start_plug(&plug);
448 err = journal_submit_data_buffers(journal, commit_transaction,
449 write_op);
450 blk_finish_plug(&plug);
451
452 /*
453 * Wait for all previously submitted IO to complete.
454 */
455 spin_lock(&journal->j_list_lock);
456 while (commit_transaction->t_locked_list) {
457 struct buffer_head *bh;
458
459 jh = commit_transaction->t_locked_list->b_tprev;
460 bh = jh2bh(jh);
461 get_bh(bh);
462 if (buffer_locked(bh)) {
463 spin_unlock(&journal->j_list_lock);
464 wait_on_buffer(bh);
465 spin_lock(&journal->j_list_lock);
466 }
467 if (unlikely(!buffer_uptodate(bh))) {
468 if (!trylock_page(bh->b_page)) {
469 spin_unlock(&journal->j_list_lock);
470 lock_page(bh->b_page);
471 spin_lock(&journal->j_list_lock);
472 }
473 if (bh->b_page->mapping)
474 set_bit(AS_EIO, &bh->b_page->mapping->flags);
475
476 unlock_page(bh->b_page);
477 SetPageError(bh->b_page);
478 err = -EIO;
479 }
480 if (!inverted_lock(journal, bh)) {
481 put_bh(bh);
482 spin_lock(&journal->j_list_lock);
483 continue;
484 }
485 if (buffer_jbd(bh) && bh2jh(bh) == jh &&
486 jh->b_transaction == commit_transaction &&
487 jh->b_jlist == BJ_Locked)
488 __journal_unfile_buffer(jh);
489 jbd_unlock_bh_state(bh);
490 release_data_buffer(bh);
491 cond_resched_lock(&journal->j_list_lock);
492 }
493 spin_unlock(&journal->j_list_lock);
494
495 if (err) {
496 char b[BDEVNAME_SIZE];
497
498 printk(KERN_WARNING
499 "JBD: Detected IO errors while flushing file data "
500 "on %s\n", bdevname(journal->j_fs_dev, b));
501 if (journal->j_flags & JFS_ABORT_ON_SYNCDATA_ERR)
502 journal_abort(journal, err);
503 err = 0;
504 }
505
506 blk_start_plug(&plug);
507
508 journal_write_revoke_records(journal, commit_transaction, write_op);
509
510 /*
511 * If we found any dirty or locked buffers, then we should have
512 * looped back up to the write_out_data label. If there weren't
513 * any then journal_clean_data_list should have wiped the list
514 * clean by now, so check that it is in fact empty.
515 */
516 J_ASSERT (commit_transaction->t_sync_datalist == NULL);
517
518 jbd_debug (3, "JBD: commit phase 3\n");
519
520 /*
521 * Way to go: we have now written out all of the data for a
522 * transaction! Now comes the tricky part: we need to write out
523 * metadata. Loop over the transaction's entire buffer list:
524 */
525 spin_lock(&journal->j_state_lock);
526 commit_transaction->t_state = T_COMMIT;
527 spin_unlock(&journal->j_state_lock);
528
529 trace_jbd_commit_logging(journal, commit_transaction);
530 J_ASSERT(commit_transaction->t_nr_buffers <=
531 commit_transaction->t_outstanding_credits);
532
533 descriptor = NULL;
534 bufs = 0;
535 while (commit_transaction->t_buffers) {
536
537 /* Find the next buffer to be journaled... */
538
539 jh = commit_transaction->t_buffers;
540
541 /* If we're in abort mode, we just un-journal the buffer and
542 release it. */
543
544 if (is_journal_aborted(journal)) {
545 clear_buffer_jbddirty(jh2bh(jh));
546 JBUFFER_TRACE(jh, "journal is aborting: refile");
547 journal_refile_buffer(journal, jh);
548 /* If that was the last one, we need to clean up
549 * any descriptor buffers which may have been
550 * already allocated, even if we are now
551 * aborting. */
552 if (!commit_transaction->t_buffers)
553 goto start_journal_io;
554 continue;
555 }
556
557 /* Make sure we have a descriptor block in which to
558 record the metadata buffer. */
559
560 if (!descriptor) {
561 struct buffer_head *bh;
562
563 J_ASSERT (bufs == 0);
564
565 jbd_debug(4, "JBD: get descriptor\n");
566
567 descriptor = journal_get_descriptor_buffer(journal);
568 if (!descriptor) {
569 journal_abort(journal, -EIO);
570 continue;
571 }
572
573 bh = jh2bh(descriptor);
574 jbd_debug(4, "JBD: got buffer %llu (%p)\n",
575 (unsigned long long)bh->b_blocknr, bh->b_data);
576 header = (journal_header_t *)&bh->b_data[0];
577 header->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
578 header->h_blocktype = cpu_to_be32(JFS_DESCRIPTOR_BLOCK);
579 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
580
581 tagp = &bh->b_data[sizeof(journal_header_t)];
582 space_left = bh->b_size - sizeof(journal_header_t);
583 first_tag = 1;
584 set_buffer_jwrite(bh);
585 set_buffer_dirty(bh);
586 wbuf[bufs++] = bh;
587
588 /* Record it so that we can wait for IO
589 completion later */
590 BUFFER_TRACE(bh, "ph3: file as descriptor");
591 journal_file_buffer(descriptor, commit_transaction,
592 BJ_LogCtl);
593 }
594
595 /* Where is the buffer to be written? */
596
597 err = journal_next_log_block(journal, &blocknr);
598 /* If the block mapping failed, just abandon the buffer
599 and repeat this loop: we'll fall into the
600 refile-on-abort condition above. */
601 if (err) {
602 journal_abort(journal, err);
603 continue;
604 }
605
606 /*
607 * start_this_handle() uses t_outstanding_credits to determine
608 * the free space in the log, but this counter is changed
609 * by journal_next_log_block() also.
610 */
611 commit_transaction->t_outstanding_credits--;
612
613 /* Bump b_count to prevent truncate from stumbling over
614 the shadowed buffer! @@@ This can go if we ever get
615 rid of the BJ_IO/BJ_Shadow pairing of buffers. */
616 get_bh(jh2bh(jh));
617
618 /* Make a temporary IO buffer with which to write it out
619 (this will requeue both the metadata buffer and the
620 temporary IO buffer). new_bh goes on BJ_IO*/
621
622 set_buffer_jwrite(jh2bh(jh));
623 /*
624 * akpm: journal_write_metadata_buffer() sets
625 * new_bh->b_transaction to commit_transaction.
626 * We need to clean this up before we release new_bh
627 * (which is of type BJ_IO)
628 */
629 JBUFFER_TRACE(jh, "ph3: write metadata");
630 flags = journal_write_metadata_buffer(commit_transaction,
631 jh, &new_jh, blocknr);
632 set_buffer_jwrite(jh2bh(new_jh));
633 wbuf[bufs++] = jh2bh(new_jh);
634
635 /* Record the new block's tag in the current descriptor
636 buffer */
637
638 tag_flag = 0;
639 if (flags & 1)
640 tag_flag |= JFS_FLAG_ESCAPE;
641 if (!first_tag)
642 tag_flag |= JFS_FLAG_SAME_UUID;
643
644 tag = (journal_block_tag_t *) tagp;
645 tag->t_blocknr = cpu_to_be32(jh2bh(jh)->b_blocknr);
646 tag->t_flags = cpu_to_be32(tag_flag);
647 tagp += sizeof(journal_block_tag_t);
648 space_left -= sizeof(journal_block_tag_t);
649
650 if (first_tag) {
651 memcpy (tagp, journal->j_uuid, 16);
652 tagp += 16;
653 space_left -= 16;
654 first_tag = 0;
655 }
656
657 /* If there's no more to do, or if the descriptor is full,
658 let the IO rip! */
659
660 if (bufs == journal->j_wbufsize ||
661 commit_transaction->t_buffers == NULL ||
662 space_left < sizeof(journal_block_tag_t) + 16) {
663
664 jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
665
666 /* Write an end-of-descriptor marker before
667 submitting the IOs. "tag" still points to
668 the last tag we set up. */
669
670 tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);
671
672start_journal_io:
673 for (i = 0; i < bufs; i++) {
674 struct buffer_head *bh = wbuf[i];
675 lock_buffer(bh);
676 clear_buffer_dirty(bh);
677 set_buffer_uptodate(bh);
678 bh->b_end_io = journal_end_buffer_io_sync;
679 /*
680 * In data=journal mode, here we can end up
681 * writing pagecache data that might be
682 * mmapped. Since we can't afford to clean the
683 * page and set PageWriteback (see the comment
684 * near the other use of _submit_bh()), the
685 * data can change while the write is in
686 * flight. Tell the block layer to bounce the
687 * bio pages if stable pages are required.
688 */
689 _submit_bh(write_op, bh, 1 << BIO_SNAP_STABLE);
690 }
691 cond_resched();
692
693 /* Force a new descriptor to be generated next
694 time round the loop. */
695 descriptor = NULL;
696 bufs = 0;
697 }
698 }
699
700 blk_finish_plug(&plug);
701
702 /* Lo and behold: we have just managed to send a transaction to
703 the log. Before we can commit it, wait for the IO so far to
704 complete. Control buffers being written are on the
705 transaction's t_log_list queue, and metadata buffers are on
706 the t_iobuf_list queue.
707
708 Wait for the buffers in reverse order. That way we are
709 less likely to be woken up until all IOs have completed, and
710 so we incur less scheduling load.
711 */
712
713 jbd_debug(3, "JBD: commit phase 4\n");
714
715 /*
716 * akpm: these are BJ_IO, and j_list_lock is not needed.
717 * See __journal_try_to_free_buffer.
718 */
719wait_for_iobuf:
720 while (commit_transaction->t_iobuf_list != NULL) {
721 struct buffer_head *bh;
722
723 jh = commit_transaction->t_iobuf_list->b_tprev;
724 bh = jh2bh(jh);
725 if (buffer_locked(bh)) {
726 wait_on_buffer(bh);
727 goto wait_for_iobuf;
728 }
729 if (cond_resched())
730 goto wait_for_iobuf;
731
732 if (unlikely(!buffer_uptodate(bh)))
733 err = -EIO;
734
735 clear_buffer_jwrite(bh);
736
737 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
738 journal_unfile_buffer(journal, jh);
739
740 /*
741 * ->t_iobuf_list should contain only dummy buffer_heads
742 * which were created by journal_write_metadata_buffer().
743 */
744 BUFFER_TRACE(bh, "dumping temporary bh");
745 journal_put_journal_head(jh);
746 __brelse(bh);
747 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
748 free_buffer_head(bh);
749
750 /* We also have to unlock and free the corresponding
751 shadowed buffer */
752 jh = commit_transaction->t_shadow_list->b_tprev;
753 bh = jh2bh(jh);
754 clear_buffer_jwrite(bh);
755 J_ASSERT_BH(bh, buffer_jbddirty(bh));
756
757 /* The metadata is now released for reuse, but we need
758 to remember it against this transaction so that when
759 we finally commit, we can do any checkpointing
760 required. */
761 JBUFFER_TRACE(jh, "file as BJ_Forget");
762 journal_file_buffer(jh, commit_transaction, BJ_Forget);
763 /*
764 * Wake up any transactions which were waiting for this
765 * IO to complete. The barrier must be here so that changes
766 * by journal_file_buffer() take effect before wake_up_bit()
767 * does the waitqueue check.
768 */
769 smp_mb();
770 wake_up_bit(&bh->b_state, BH_Unshadow);
771 JBUFFER_TRACE(jh, "brelse shadowed buffer");
772 __brelse(bh);
773 }
774
775 J_ASSERT (commit_transaction->t_shadow_list == NULL);
776
777 jbd_debug(3, "JBD: commit phase 5\n");
778
779 /* Here we wait for the revoke record and descriptor record buffers */
780 wait_for_ctlbuf:
781 while (commit_transaction->t_log_list != NULL) {
782 struct buffer_head *bh;
783
784 jh = commit_transaction->t_log_list->b_tprev;
785 bh = jh2bh(jh);
786 if (buffer_locked(bh)) {
787 wait_on_buffer(bh);
788 goto wait_for_ctlbuf;
789 }
790 if (cond_resched())
791 goto wait_for_ctlbuf;
792
793 if (unlikely(!buffer_uptodate(bh)))
794 err = -EIO;
795
796 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
797 clear_buffer_jwrite(bh);
798 journal_unfile_buffer(journal, jh);
799 journal_put_journal_head(jh);
800 __brelse(bh); /* One for getblk */
801 /* AKPM: bforget here */
802 }
803
804 if (err)
805 journal_abort(journal, err);
806
807 jbd_debug(3, "JBD: commit phase 6\n");
808
809 /* All metadata is written, now write commit record and do cleanup */
810 spin_lock(&journal->j_state_lock);
811 J_ASSERT(commit_transaction->t_state == T_COMMIT);
812 commit_transaction->t_state = T_COMMIT_RECORD;
813 spin_unlock(&journal->j_state_lock);
814
815 if (journal_write_commit_record(journal, commit_transaction))
816 err = -EIO;
817
818 if (err)
819 journal_abort(journal, err);
820
821 /* End of a transaction! Finally, we can do checkpoint
822 processing: any buffers committed as a result of this
823 transaction can be removed from any checkpoint list it was on
824 before. */
825
826 jbd_debug(3, "JBD: commit phase 7\n");
827
828 J_ASSERT(commit_transaction->t_sync_datalist == NULL);
829 J_ASSERT(commit_transaction->t_buffers == NULL);
830 J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
831 J_ASSERT(commit_transaction->t_iobuf_list == NULL);
832 J_ASSERT(commit_transaction->t_shadow_list == NULL);
833 J_ASSERT(commit_transaction->t_log_list == NULL);
834
835restart_loop:
836 /*
837 * As there are other places (journal_unmap_buffer()) adding buffers
838 * to this list we have to be careful and hold the j_list_lock.
839 */
840 spin_lock(&journal->j_list_lock);
841 while (commit_transaction->t_forget) {
842 transaction_t *cp_transaction;
843 struct buffer_head *bh;
844 int try_to_free = 0;
845
846 jh = commit_transaction->t_forget;
847 spin_unlock(&journal->j_list_lock);
848 bh = jh2bh(jh);
849 /*
850 * Get a reference so that bh cannot be freed before we are
851 * done with it.
852 */
853 get_bh(bh);
854 jbd_lock_bh_state(bh);
855 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction ||
856 jh->b_transaction == journal->j_running_transaction);
857
858 /*
859 * If there is undo-protected committed data against
860 * this buffer, then we can remove it now. If it is a
861 * buffer needing such protection, the old frozen_data
862 * field now points to a committed version of the
863 * buffer, so rotate that field to the new committed
864 * data.
865 *
866 * Otherwise, we can just throw away the frozen data now.
867 */
868 if (jh->b_committed_data) {
869 jbd_free(jh->b_committed_data, bh->b_size);
870 jh->b_committed_data = NULL;
871 if (jh->b_frozen_data) {
872 jh->b_committed_data = jh->b_frozen_data;
873 jh->b_frozen_data = NULL;
874 }
875 } else if (jh->b_frozen_data) {
876 jbd_free(jh->b_frozen_data, bh->b_size);
877 jh->b_frozen_data = NULL;
878 }
879
880 spin_lock(&journal->j_list_lock);
881 cp_transaction = jh->b_cp_transaction;
882 if (cp_transaction) {
883 JBUFFER_TRACE(jh, "remove from old cp transaction");
884 __journal_remove_checkpoint(jh);
885 }
886
887 /* Only re-checkpoint the buffer_head if it is marked
888 * dirty. If the buffer was added to the BJ_Forget list
889 * by journal_forget, it may no longer be dirty and
890 * there's no point in keeping a checkpoint record for
891 * it. */
892
893 /*
894 * A buffer which has been freed while still being journaled by
895 * a previous transaction.
896 */
897 if (buffer_freed(bh)) {
898 /*
899 * If the running transaction is the one containing
900 * "add to orphan" operation (b_next_transaction !=
901 * NULL), we have to wait for that transaction to
902 * commit before we can really get rid of the buffer.
903 * So just clear b_modified to not confuse transaction
904 * credit accounting and refile the buffer to
905 * BJ_Forget of the running transaction. If the just
906 * committed transaction contains "add to orphan"
907 * operation, we can completely invalidate the buffer
908 * now. We are rather throughout in that since the
909 * buffer may be still accessible when blocksize <
910 * pagesize and it is attached to the last partial
911 * page.
912 */
913 jh->b_modified = 0;
914 if (!jh->b_next_transaction) {
915 clear_buffer_freed(bh);
916 clear_buffer_jbddirty(bh);
917 clear_buffer_mapped(bh);
918 clear_buffer_new(bh);
919 clear_buffer_req(bh);
920 bh->b_bdev = NULL;
921 }
922 }
923
924 if (buffer_jbddirty(bh)) {
925 JBUFFER_TRACE(jh, "add to new checkpointing trans");
926 __journal_insert_checkpoint(jh, commit_transaction);
927 if (is_journal_aborted(journal))
928 clear_buffer_jbddirty(bh);
929 } else {
930 J_ASSERT_BH(bh, !buffer_dirty(bh));
931 /*
932 * The buffer on BJ_Forget list and not jbddirty means
933 * it has been freed by this transaction and hence it
934 * could not have been reallocated until this
935 * transaction has committed. *BUT* it could be
936 * reallocated once we have written all the data to
937 * disk and before we process the buffer on BJ_Forget
938 * list.
939 */
940 if (!jh->b_next_transaction)
941 try_to_free = 1;
942 }
943 JBUFFER_TRACE(jh, "refile or unfile freed buffer");
944 __journal_refile_buffer(jh);
945 jbd_unlock_bh_state(bh);
946 if (try_to_free)
947 release_buffer_page(bh);
948 else
949 __brelse(bh);
950 cond_resched_lock(&journal->j_list_lock);
951 }
952 spin_unlock(&journal->j_list_lock);
953 /*
954 * This is a bit sleazy. We use j_list_lock to protect transition
955 * of a transaction into T_FINISHED state and calling
956 * __journal_drop_transaction(). Otherwise we could race with
957 * other checkpointing code processing the transaction...
958 */
959 spin_lock(&journal->j_state_lock);
960 spin_lock(&journal->j_list_lock);
961 /*
962 * Now recheck if some buffers did not get attached to the transaction
963 * while the lock was dropped...
964 */
965 if (commit_transaction->t_forget) {
966 spin_unlock(&journal->j_list_lock);
967 spin_unlock(&journal->j_state_lock);
968 goto restart_loop;
969 }
970
971 /* Done with this transaction! */
972
973 jbd_debug(3, "JBD: commit phase 8\n");
974
975 J_ASSERT(commit_transaction->t_state == T_COMMIT_RECORD);
976
977 commit_transaction->t_state = T_FINISHED;
978 J_ASSERT(commit_transaction == journal->j_committing_transaction);
979 journal->j_commit_sequence = commit_transaction->t_tid;
980 journal->j_committing_transaction = NULL;
981 commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
982
983 /*
984 * weight the commit time higher than the average time so we don't
985 * react too strongly to vast changes in commit time
986 */
987 if (likely(journal->j_average_commit_time))
988 journal->j_average_commit_time = (commit_time*3 +
989 journal->j_average_commit_time) / 4;
990 else
991 journal->j_average_commit_time = commit_time;
992
993 spin_unlock(&journal->j_state_lock);
994
995 if (commit_transaction->t_checkpoint_list == NULL &&
996 commit_transaction->t_checkpoint_io_list == NULL) {
997 __journal_drop_transaction(journal, commit_transaction);
998 } else {
999 if (journal->j_checkpoint_transactions == NULL) {
1000 journal->j_checkpoint_transactions = commit_transaction;
1001 commit_transaction->t_cpnext = commit_transaction;
1002 commit_transaction->t_cpprev = commit_transaction;
1003 } else {
1004 commit_transaction->t_cpnext =
1005 journal->j_checkpoint_transactions;
1006 commit_transaction->t_cpprev =
1007 commit_transaction->t_cpnext->t_cpprev;
1008 commit_transaction->t_cpnext->t_cpprev =
1009 commit_transaction;
1010 commit_transaction->t_cpprev->t_cpnext =
1011 commit_transaction;
1012 }
1013 }
1014 spin_unlock(&journal->j_list_lock);
1015
1016 trace_jbd_end_commit(journal, commit_transaction);
1017 jbd_debug(1, "JBD: commit %d complete, head %d\n",
1018 journal->j_commit_sequence, journal->j_tail_sequence);
1019
1020 wake_up(&journal->j_wait_done_commit);
1021}
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-26 08:06:20 -0400