1 /*
2 * linux/fs/jbd2/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/jbd2.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
21 #include <linux/mm.h>
22 #include <linux/pagemap.h>
23 #include <linux/jiffies.h>
24 #include <linux/crc32.h>
25 #include <linux/writeback.h>
26 #include <linux/backing-dev.h>
27 #include <linux/bio.h>
28 #include <trace/events/jbd2.h>
29
30 /*
31 * Default IO end handler for temporary BJ_IO buffer_heads.
32 */
33 static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
34 {
35 BUFFER_TRACE(bh, "");
36 if (uptodate)
37 set_buffer_uptodate(bh);
38 else
39 clear_buffer_uptodate(bh);
40 unlock_buffer(bh);
41 }
42
43 /*
44 * When an ext4 file is truncated, it is possible that some pages are not
45 * successfully freed, because they are attached to a committing transaction.
46 * After the transaction commits, these pages are left on the LRU, with no
47 * ->mapping, and with attached buffers. These pages are trivially reclaimable
48 * by the VM, but their apparent absence upsets the VM accounting, and it makes
49 * the numbers in /proc/meminfo look odd.
50 *
51 * So here, we have a buffer which has just come off the forget list. Look to
52 * see if we can strip all buffers from the backing page.
53 *
54 * Called under lock_journal(), and possibly under journal_datalist_lock. The
55 * caller provided us with a ref against the buffer, and we drop that here.
56 */
57 static void release_buffer_page(struct buffer_head *bh)
58 {
59 struct page *page;
60
61 if (buffer_dirty(bh))
62 goto nope;
63 if (atomic_read(&bh->b_count) != 1)
64 goto nope;
65 page = bh->b_page;
66 if (!page)
67 goto nope;
68 if (page->mapping)
69 goto nope;
70
71 /* OK, it's a truncated page */
72 if (!trylock_page(page))
73 goto nope;
74
75 page_cache_get(page);
76 __brelse(bh);
77 try_to_free_buffers(page);
78 unlock_page(page);
79 page_cache_release(page);
80 return;
81
82 nope:
83 __brelse(bh);
84 }
85
86 /*
87 * Done it all: now submit the commit record. We should have
88 * cleaned up our previous buffers by now, so if we are in abort
89 * mode we can now just skip the rest of the journal write
90 * entirely.
91 *
92 * Returns 1 if the journal needs to be aborted or 0 on success
93 */
94 static int journal_submit_commit_record(journal_t *journal,
95 transaction_t *commit_transaction,
96 struct buffer_head **cbh,
97 __u32 crc32_sum)
98 {
99 struct journal_head *descriptor;
100 struct commit_header *tmp;
101 struct buffer_head *bh;
102 int ret;
103 int barrier_done = 0;
104 struct timespec now = current_kernel_time();
105
106 if (is_journal_aborted(journal))
107 return 0;
108
109 descriptor = jbd2_journal_get_descriptor_buffer(journal);
110 if (!descriptor)
111 return 1;
112
113 bh = jh2bh(descriptor);
114
115 tmp = (struct commit_header *)bh->b_data;
116 tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
117 tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK);
118 tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
119 tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
120 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
121
122 if (JBD2_HAS_COMPAT_FEATURE(journal,
123 JBD2_FEATURE_COMPAT_CHECKSUM)) {
124 tmp->h_chksum_type = JBD2_CRC32_CHKSUM;
125 tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE;
126 tmp->h_chksum[0] = cpu_to_be32(crc32_sum);
127 }
128
129 JBUFFER_TRACE(descriptor, "submit commit block");
130 lock_buffer(bh);
131 clear_buffer_dirty(bh);
132 set_buffer_uptodate(bh);
133 bh->b_end_io = journal_end_buffer_io_sync;
134
135 if (journal->j_flags & JBD2_BARRIER &&
136 !JBD2_HAS_INCOMPAT_FEATURE(journal,
137 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
138 set_buffer_ordered(bh);
139 barrier_done = 1;
140 }
141 ret = submit_bh(WRITE_SYNC_PLUG, bh);
142 if (barrier_done)
143 clear_buffer_ordered(bh);
144
145 /* is it possible for another commit to fail at roughly
146 * the same time as this one? If so, we don't want to
147 * trust the barrier flag in the super, but instead want
148 * to remember if we sent a barrier request
149 */
150 if (ret == -EOPNOTSUPP && barrier_done) {
151 printk(KERN_WARNING
152 "JBD: barrier-based sync failed on %s - "
153 "disabling barriers\n", journal->j_devname);
154 spin_lock(&journal->j_state_lock);
155 journal->j_flags &= ~JBD2_BARRIER;
156 spin_unlock(&journal->j_state_lock);
157
158 /* And try again, without the barrier */
159 lock_buffer(bh);
160 set_buffer_uptodate(bh);
161 clear_buffer_dirty(bh);
162 ret = submit_bh(WRITE_SYNC_PLUG, bh);
163 }
164 *cbh = bh;
165 return ret;
166 }
167
168 /*
169 * This function along with journal_submit_commit_record
170 * allows to write the commit record asynchronously.
171 */
172 static int journal_wait_on_commit_record(journal_t *journal,
173 struct buffer_head *bh)
174 {
175 int ret = 0;
176
177 retry:
178 clear_buffer_dirty(bh);
179 wait_on_buffer(bh);
180 if (buffer_eopnotsupp(bh) && (journal->j_flags & JBD2_BARRIER)) {
181 printk(KERN_WARNING
182 "JBD2: wait_on_commit_record: sync failed on %s - "
183 "disabling barriers\n", journal->j_devname);
184 spin_lock(&journal->j_state_lock);
185 journal->j_flags &= ~JBD2_BARRIER;
186 spin_unlock(&journal->j_state_lock);
187
188 lock_buffer(bh);
189 clear_buffer_dirty(bh);
190 set_buffer_uptodate(bh);
191 bh->b_end_io = journal_end_buffer_io_sync;
192
193 ret = submit_bh(WRITE_SYNC_PLUG, bh);
194 if (ret) {
195 unlock_buffer(bh);
196 return ret;
197 }
198 goto retry;
199 }
200
201 if (unlikely(!buffer_uptodate(bh)))
202 ret = -EIO;
203 put_bh(bh); /* One for getblk() */
204 jbd2_journal_put_journal_head(bh2jh(bh));
205
206 return ret;
207 }
208
209 /*
210 * write the filemap data using writepage() address_space_operations.
211 * We don't do block allocation here even for delalloc. We don't
212 * use writepages() because with dealyed allocation we may be doing
213 * block allocation in writepages().
214 */
215 static int journal_submit_inode_data_buffers(struct address_space *mapping)
216 {
217 int ret;
218 struct writeback_control wbc = {
219 .sync_mode = WB_SYNC_ALL,
220 .nr_to_write = mapping->nrpages * 2,
221 .range_start = 0,
222 .range_end = i_size_read(mapping->host),
223 .for_writepages = 1,
224 };
225
226 ret = generic_writepages(mapping, &wbc);
227 return ret;
228 }
229
230 /*
231 * Submit all the data buffers of inode associated with the transaction to
232 * disk.
233 *
234 * We are in a committing transaction. Therefore no new inode can be added to
235 * our inode list. We use JI_COMMIT_RUNNING flag to protect inode we currently
236 * operate on from being released while we write out pages.
237 */
238 static int journal_submit_data_buffers(journal_t *journal,
239 transaction_t *commit_transaction)
240 {
241 struct jbd2_inode *jinode;
242 int err, ret = 0;
243 struct address_space *mapping;
244
245 spin_lock(&journal->j_list_lock);
246 list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
247 mapping = jinode->i_vfs_inode->i_mapping;
248 jinode->i_flags |= JI_COMMIT_RUNNING;
249 spin_unlock(&journal->j_list_lock);
250 /*
251 * submit the inode data buffers. We use writepage
252 * instead of writepages. Because writepages can do
253 * block allocation with delalloc. We need to write
254 * only allocated blocks here.
255 */
256 trace_jbd2_submit_inode_data(jinode->i_vfs_inode);
257 err = journal_submit_inode_data_buffers(mapping);
258 if (!ret)
259 ret = err;
260 spin_lock(&journal->j_list_lock);
261 J_ASSERT(jinode->i_transaction == commit_transaction);
262 jinode->i_flags &= ~JI_COMMIT_RUNNING;
263 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
264 }
265 spin_unlock(&journal->j_list_lock);
266 return ret;
267 }
268
269 /*
270 * Wait for data submitted for writeout, refile inodes to proper
271 * transaction if needed.
272 *
273 */
274 static int journal_finish_inode_data_buffers(journal_t *journal,
275 transaction_t *commit_transaction)
276 {
277 struct jbd2_inode *jinode, *next_i;
278 int err, ret = 0;
279
280 /* For locking, see the comment in journal_submit_data_buffers() */
281 spin_lock(&journal->j_list_lock);
282 list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
283 jinode->i_flags |= JI_COMMIT_RUNNING;
284 spin_unlock(&journal->j_list_lock);
285 err = filemap_fdatawait(jinode->i_vfs_inode->i_mapping);
286 if (err) {
287 /*
288 * Because AS_EIO is cleared by
289 * wait_on_page_writeback_range(), set it again so
290 * that user process can get -EIO from fsync().
291 */
292 set_bit(AS_EIO,
293 &jinode->i_vfs_inode->i_mapping->flags);
294
295 if (!ret)
296 ret = err;
297 }
298 spin_lock(&journal->j_list_lock);
299 jinode->i_flags &= ~JI_COMMIT_RUNNING;
300 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
301 }
302
303 /* Now refile inode to proper lists */
304 list_for_each_entry_safe(jinode, next_i,
305 &commit_transaction->t_inode_list, i_list) {
306 list_del(&jinode->i_list);
307 if (jinode->i_next_transaction) {
308 jinode->i_transaction = jinode->i_next_transaction;
309 jinode->i_next_transaction = NULL;
310 list_add(&jinode->i_list,
311 &jinode->i_transaction->t_inode_list);
312 } else {
313 jinode->i_transaction = NULL;
314 }
315 }
316 spin_unlock(&journal->j_list_lock);
317
318 return ret;
319 }
320
321 static __u32 jbd2_checksum_data(__u32 crc32_sum, struct buffer_head *bh)
322 {
323 struct page *page = bh->b_page;
324 char *addr;
325 __u32 checksum;
326
327 addr = kmap_atomic(page, KM_USER0);
328 checksum = crc32_be(crc32_sum,
329 (void *)(addr + offset_in_page(bh->b_data)), bh->b_size);
330 kunmap_atomic(addr, KM_USER0);
331
332 return checksum;
333 }
334
335 static void write_tag_block(int tag_bytes, journal_block_tag_t *tag,
336 unsigned long long block)
337 {
338 tag->t_blocknr = cpu_to_be32(block & (u32)~0);
339 if (tag_bytes > JBD2_TAG_SIZE32)
340 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
341 }
342
343 /*
344 * jbd2_journal_commit_transaction
345 *
346 * The primary function for committing a transaction to the log. This
347 * function is called by the journal thread to begin a complete commit.
348 */
349 void jbd2_journal_commit_transaction(journal_t *journal)
350 {
351 struct transaction_stats_s stats;
352 transaction_t *commit_transaction;
353 struct journal_head *jh, *new_jh, *descriptor;
354 struct buffer_head **wbuf = journal->j_wbuf;
355 int bufs;
356 int flags;
357 int err;
358 unsigned long long blocknr;
359 ktime_t start_time;
360 u64 commit_time;
361 char *tagp = NULL;
362 journal_header_t *header;
363 journal_block_tag_t *tag = NULL;
364 int space_left = 0;
365 int first_tag = 0;
366 int tag_flag;
367 int i, to_free = 0;
368 int tag_bytes = journal_tag_bytes(journal);
369 struct buffer_head *cbh = NULL; /* For transactional checksums */
370 __u32 crc32_sum = ~0;
371 int write_op = WRITE;
372
373 /*
374 * First job: lock down the current transaction and wait for
375 * all outstanding updates to complete.
376 */
377
378 #ifdef COMMIT_STATS
379 spin_lock(&journal->j_list_lock);
380 summarise_journal_usage(journal);
381 spin_unlock(&journal->j_list_lock);
382 #endif
383
384 /* Do we need to erase the effects of a prior jbd2_journal_flush? */
385 if (journal->j_flags & JBD2_FLUSHED) {
386 jbd_debug(3, "super block updated\n");
387 jbd2_journal_update_superblock(journal, 1);
388 } else {
389 jbd_debug(3, "superblock not updated\n");
390 }
391
392 J_ASSERT(journal->j_running_transaction != NULL);
393 J_ASSERT(journal->j_committing_transaction == NULL);
394
395 commit_transaction = journal->j_running_transaction;
396 J_ASSERT(commit_transaction->t_state == T_RUNNING);
397
398 trace_jbd2_start_commit(journal, commit_transaction);
399 jbd_debug(1, "JBD: starting commit of transaction %d\n",
400 commit_transaction->t_tid);
401
402 spin_lock(&journal->j_state_lock);
403 commit_transaction->t_state = T_LOCKED;
404
405 /*
406 * Use plugged writes here, since we want to submit several before
407 * we unplug the device. We don't do explicit unplugging in here,
408 * instead we rely on sync_buffer() doing the unplug for us.
409 */
410 if (commit_transaction->t_synchronous_commit)
411 write_op = WRITE_SYNC_PLUG;
412 trace_jbd2_commit_locking(journal, commit_transaction);
413 stats.u.run.rs_wait = commit_transaction->t_max_wait;
414 stats.u.run.rs_locked = jiffies;
415 stats.u.run.rs_running = jbd2_time_diff(commit_transaction->t_start,
416 stats.u.run.rs_locked);
417
418 spin_lock(&commit_transaction->t_handle_lock);
419 while (commit_transaction->t_updates) {
420 DEFINE_WAIT(wait);
421
422 prepare_to_wait(&journal->j_wait_updates, &wait,
423 TASK_UNINTERRUPTIBLE);
424 if (commit_transaction->t_updates) {
425 spin_unlock(&commit_transaction->t_handle_lock);
426 spin_unlock(&journal->j_state_lock);
427 schedule();
428 spin_lock(&journal->j_state_lock);
429 spin_lock(&commit_transaction->t_handle_lock);
430 }
431 finish_wait(&journal->j_wait_updates, &wait);
432 }
433 spin_unlock(&commit_transaction->t_handle_lock);
434
435 J_ASSERT (commit_transaction->t_outstanding_credits <=
436 journal->j_max_transaction_buffers);
437
438 /*
439 * First thing we are allowed to do is to discard any remaining
440 * BJ_Reserved buffers. Note, it is _not_ permissible to assume
441 * that there are no such buffers: if a large filesystem
442 * operation like a truncate needs to split itself over multiple
443 * transactions, then it may try to do a jbd2_journal_restart() while
444 * there are still BJ_Reserved buffers outstanding. These must
445 * be released cleanly from the current transaction.
446 *
447 * In this case, the filesystem must still reserve write access
448 * again before modifying the buffer in the new transaction, but
449 * we do not require it to remember exactly which old buffers it
450 * has reserved. This is consistent with the existing behaviour
451 * that multiple jbd2_journal_get_write_access() calls to the same
452 * buffer are perfectly permissable.
453 */
454 while (commit_transaction->t_reserved_list) {
455 jh = commit_transaction->t_reserved_list;
456 JBUFFER_TRACE(jh, "reserved, unused: refile");
457 /*
458 * A jbd2_journal_get_undo_access()+jbd2_journal_release_buffer() may
459 * leave undo-committed data.
460 */
461 if (jh->b_committed_data) {
462 struct buffer_head *bh = jh2bh(jh);
463
464 jbd_lock_bh_state(bh);
465 jbd2_free(jh->b_committed_data, bh->b_size);
466 jh->b_committed_data = NULL;
467 jbd_unlock_bh_state(bh);
468 }
469 jbd2_journal_refile_buffer(journal, jh);
470 }
471
472 /*
473 * Now try to drop any written-back buffers from the journal's
474 * checkpoint lists. We do this *before* commit because it potentially
475 * frees some memory
476 */
477 spin_lock(&journal->j_list_lock);
478 __jbd2_journal_clean_checkpoint_list(journal);
479 spin_unlock(&journal->j_list_lock);
480
481 jbd_debug (3, "JBD: commit phase 1\n");
482
483 /*
484 * Switch to a new revoke table.
485 */
486 jbd2_journal_switch_revoke_table(journal);
487
488 trace_jbd2_commit_flushing(journal, commit_transaction);
489 stats.u.run.rs_flushing = jiffies;
490 stats.u.run.rs_locked = jbd2_time_diff(stats.u.run.rs_locked,
491 stats.u.run.rs_flushing);
492
493 commit_transaction->t_state = T_FLUSH;
494 journal->j_committing_transaction = commit_transaction;
495 journal->j_running_transaction = NULL;
496 start_time = ktime_get();
497 commit_transaction->t_log_start = journal->j_head;
498 wake_up(&journal->j_wait_transaction_locked);
499 spin_unlock(&journal->j_state_lock);
500
501 jbd_debug (3, "JBD: commit phase 2\n");
502
503 /*
504 * Now start flushing things to disk, in the order they appear
505 * on the transaction lists. Data blocks go first.
506 */
507 err = journal_submit_data_buffers(journal, commit_transaction);
508 if (err)
509 jbd2_journal_abort(journal, err);
510
511 jbd2_journal_write_revoke_records(journal, commit_transaction,
512 write_op);
513
514 jbd_debug(3, "JBD: commit phase 2\n");
515
516 /*
517 * Way to go: we have now written out all of the data for a
518 * transaction! Now comes the tricky part: we need to write out
519 * metadata. Loop over the transaction's entire buffer list:
520 */
521 spin_lock(&journal->j_state_lock);
522 commit_transaction->t_state = T_COMMIT;
523 spin_unlock(&journal->j_state_lock);
524
525 trace_jbd2_commit_logging(journal, commit_transaction);
526 stats.u.run.rs_logging = jiffies;
527 stats.u.run.rs_flushing = jbd2_time_diff(stats.u.run.rs_flushing,
528 stats.u.run.rs_logging);
529 stats.u.run.rs_blocks = commit_transaction->t_outstanding_credits;
530 stats.u.run.rs_blocks_logged = 0;
531
532 J_ASSERT(commit_transaction->t_nr_buffers <=
533 commit_transaction->t_outstanding_credits);
534
535 err = 0;
536 descriptor = NULL;
537 bufs = 0;
538 while (commit_transaction->t_buffers) {
539
540 /* Find the next buffer to be journaled... */
541
542 jh = commit_transaction->t_buffers;
543
544 /* If we're in abort mode, we just un-journal the buffer and
545 release it. */
546
547 if (is_journal_aborted(journal)) {
548 clear_buffer_jbddirty(jh2bh(jh));
549 JBUFFER_TRACE(jh, "journal is aborting: refile");
550 jbd2_buffer_abort_trigger(jh,
551 jh->b_frozen_data ?
552 jh->b_frozen_triggers :
553 jh->b_triggers);
554 jbd2_journal_refile_buffer(journal, jh);
555 /* If that was the last one, we need to clean up
556 * any descriptor buffers which may have been
557 * already allocated, even if we are now
558 * aborting. */
559 if (!commit_transaction->t_buffers)
560 goto start_journal_io;
561 continue;
562 }
563
564 /* Make sure we have a descriptor block in which to
565 record the metadata buffer. */
566
567 if (!descriptor) {
568 struct buffer_head *bh;
569
570 J_ASSERT (bufs == 0);
571
572 jbd_debug(4, "JBD: get descriptor\n");
573
574 descriptor = jbd2_journal_get_descriptor_buffer(journal);
575 if (!descriptor) {
576 jbd2_journal_abort(journal, -EIO);
577 continue;
578 }
579
580 bh = jh2bh(descriptor);
581 jbd_debug(4, "JBD: got buffer %llu (%p)\n",
582 (unsigned long long)bh->b_blocknr, bh->b_data);
583 header = (journal_header_t *)&bh->b_data[0];
584 header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
585 header->h_blocktype = cpu_to_be32(JBD2_DESCRIPTOR_BLOCK);
586 header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
587
588 tagp = &bh->b_data[sizeof(journal_header_t)];
589 space_left = bh->b_size - sizeof(journal_header_t);
590 first_tag = 1;
591 set_buffer_jwrite(bh);
592 set_buffer_dirty(bh);
593 wbuf[bufs++] = bh;
594
595 /* Record it so that we can wait for IO
596 completion later */
597 BUFFER_TRACE(bh, "ph3: file as descriptor");
598 jbd2_journal_file_buffer(descriptor, commit_transaction,
599 BJ_LogCtl);
600 }
601
602 /* Where is the buffer to be written? */
603
604 err = jbd2_journal_next_log_block(journal, &blocknr);
605 /* If the block mapping failed, just abandon the buffer
606 and repeat this loop: we'll fall into the
607 refile-on-abort condition above. */
608 if (err) {
609 jbd2_journal_abort(journal, err);
610 continue;
611 }
612
613 /*
614 * start_this_handle() uses t_outstanding_credits to determine
615 * the free space in the log, but this counter is changed
616 * by jbd2_journal_next_log_block() also.
617 */
618 commit_transaction->t_outstanding_credits--;
619
620 /* Bump b_count to prevent truncate from stumbling over
621 the shadowed buffer! @@@ This can go if we ever get
622 rid of the BJ_IO/BJ_Shadow pairing of buffers. */
623 atomic_inc(&jh2bh(jh)->b_count);
624
625 /* Make a temporary IO buffer with which to write it out
626 (this will requeue both the metadata buffer and the
627 temporary IO buffer). new_bh goes on BJ_IO*/
628
629 set_bit(BH_JWrite, &jh2bh(jh)->b_state);
630 /*
631 * akpm: jbd2_journal_write_metadata_buffer() sets
632 * new_bh->b_transaction to commit_transaction.
633 * We need to clean this up before we release new_bh
634 * (which is of type BJ_IO)
635 */
636 JBUFFER_TRACE(jh, "ph3: write metadata");
637 flags = jbd2_journal_write_metadata_buffer(commit_transaction,
638 jh, &new_jh, blocknr);
639 if (flags < 0) {
640 jbd2_journal_abort(journal, flags);
641 continue;
642 }
643 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state);
644 wbuf[bufs++] = jh2bh(new_jh);
645
646 /* Record the new block's tag in the current descriptor
647 buffer */
648
649 tag_flag = 0;
650 if (flags & 1)
651 tag_flag |= JBD2_FLAG_ESCAPE;
652 if (!first_tag)
653 tag_flag |= JBD2_FLAG_SAME_UUID;
654
655 tag = (journal_block_tag_t *) tagp;
656 write_tag_block(tag_bytes, tag, jh2bh(jh)->b_blocknr);
657 tag->t_flags = cpu_to_be32(tag_flag);
658 tagp += tag_bytes;
659 space_left -= tag_bytes;
660
661 if (first_tag) {
662 memcpy (tagp, journal->j_uuid, 16);
663 tagp += 16;
664 space_left -= 16;
665 first_tag = 0;
666 }
667
668 /* If there's no more to do, or if the descriptor is full,
669 let the IO rip! */
670
671 if (bufs == journal->j_wbufsize ||
672 commit_transaction->t_buffers == NULL ||
673 space_left < tag_bytes + 16) {
674
675 jbd_debug(4, "JBD: Submit %d IOs\n", bufs);
676
677 /* Write an end-of-descriptor marker before
678 submitting the IOs. "tag" still points to
679 the last tag we set up. */
680
681 tag->t_flags |= cpu_to_be32(JBD2_FLAG_LAST_TAG);
682
683 start_journal_io:
684 for (i = 0; i < bufs; i++) {
685 struct buffer_head *bh = wbuf[i];
686 /*
687 * Compute checksum.
688 */
689 if (JBD2_HAS_COMPAT_FEATURE(journal,
690 JBD2_FEATURE_COMPAT_CHECKSUM)) {
691 crc32_sum =
692 jbd2_checksum_data(crc32_sum, bh);
693 }
694
695 lock_buffer(bh);
696 clear_buffer_dirty(bh);
697 set_buffer_uptodate(bh);
698 bh->b_end_io = journal_end_buffer_io_sync;
699 submit_bh(write_op, bh);
700 }
701 cond_resched();
702 stats.u.run.rs_blocks_logged += bufs;
703
704 /* Force a new descriptor to be generated next
705 time round the loop. */
706 descriptor = NULL;
707 bufs = 0;
708 }
709 }
710
711 /* Done it all: now write the commit record asynchronously. */
712
713 if (JBD2_HAS_INCOMPAT_FEATURE(journal,
714 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
715 err = journal_submit_commit_record(journal, commit_transaction,
716 &cbh, crc32_sum);
717 if (err)
718 __jbd2_journal_abort_hard(journal);
719 }
720
721 /*
722 * This is the right place to wait for data buffers both for ASYNC
723 * and !ASYNC commit. If commit is ASYNC, we need to wait only after
724 * the commit block went to disk (which happens above). If commit is
725 * SYNC, we need to wait for data buffers before we start writing
726 * commit block, which happens below in such setting.
727 */
728 err = journal_finish_inode_data_buffers(journal, commit_transaction);
729 if (err) {
730 printk(KERN_WARNING
731 "JBD2: Detected IO errors while flushing file data "
732 "on %s\n", journal->j_devname);
733 if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
734 jbd2_journal_abort(journal, err);
735 err = 0;
736 }
737
738 /* Lo and behold: we have just managed to send a transaction to
739 the log. Before we can commit it, wait for the IO so far to
740 complete. Control buffers being written are on the
741 transaction's t_log_list queue, and metadata buffers are on
742 the t_iobuf_list queue.
743
744 Wait for the buffers in reverse order. That way we are
745 less likely to be woken up until all IOs have completed, and
746 so we incur less scheduling load.
747 */
748
749 jbd_debug(3, "JBD: commit phase 3\n");
750
751 /*
752 * akpm: these are BJ_IO, and j_list_lock is not needed.
753 * See __journal_try_to_free_buffer.
754 */
755 wait_for_iobuf:
756 while (commit_transaction->t_iobuf_list != NULL) {
757 struct buffer_head *bh;
758
759 jh = commit_transaction->t_iobuf_list->b_tprev;
760 bh = jh2bh(jh);
761 if (buffer_locked(bh)) {
762 wait_on_buffer(bh);
763 goto wait_for_iobuf;
764 }
765 if (cond_resched())
766 goto wait_for_iobuf;
767
768 if (unlikely(!buffer_uptodate(bh)))
769 err = -EIO;
770
771 clear_buffer_jwrite(bh);
772
773 JBUFFER_TRACE(jh, "ph4: unfile after journal write");
774 jbd2_journal_unfile_buffer(journal, jh);
775
776 /*
777 * ->t_iobuf_list should contain only dummy buffer_heads
778 * which were created by jbd2_journal_write_metadata_buffer().
779 */
780 BUFFER_TRACE(bh, "dumping temporary bh");
781 jbd2_journal_put_journal_head(jh);
782 __brelse(bh);
783 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0);
784 free_buffer_head(bh);
785
786 /* We also have to unlock and free the corresponding
787 shadowed buffer */
788 jh = commit_transaction->t_shadow_list->b_tprev;
789 bh = jh2bh(jh);
790 clear_bit(BH_JWrite, &bh->b_state);
791 J_ASSERT_BH(bh, buffer_jbddirty(bh));
792
793 /* The metadata is now released for reuse, but we need
794 to remember it against this transaction so that when
795 we finally commit, we can do any checkpointing
796 required. */
797 JBUFFER_TRACE(jh, "file as BJ_Forget");
798 jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget);
799 /* Wake up any transactions which were waiting for this
800 IO to complete */
801 wake_up_bit(&bh->b_state, BH_Unshadow);
802 JBUFFER_TRACE(jh, "brelse shadowed buffer");
803 __brelse(bh);
804 }
805
806 J_ASSERT (commit_transaction->t_shadow_list == NULL);
807
808 jbd_debug(3, "JBD: commit phase 4\n");
809
810 /* Here we wait for the revoke record and descriptor record buffers */
811 wait_for_ctlbuf:
812 while (commit_transaction->t_log_list != NULL) {
813 struct buffer_head *bh;
814
815 jh = commit_transaction->t_log_list->b_tprev;
816 bh = jh2bh(jh);
817 if (buffer_locked(bh)) {
818 wait_on_buffer(bh);
819 goto wait_for_ctlbuf;
820 }
821 if (cond_resched())
822 goto wait_for_ctlbuf;
823
824 if (unlikely(!buffer_uptodate(bh)))
825 err = -EIO;
826
827 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile");
828 clear_buffer_jwrite(bh);
829 jbd2_journal_unfile_buffer(journal, jh);
830 jbd2_journal_put_journal_head(jh);
831 __brelse(bh); /* One for getblk */
832 /* AKPM: bforget here */
833 }
834
835 if (err)
836 jbd2_journal_abort(journal, err);
837
838 jbd_debug(3, "JBD: commit phase 5\n");
839
840 if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
841 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
842 err = journal_submit_commit_record(journal, commit_transaction,
843 &cbh, crc32_sum);
844 if (err)
845 __jbd2_journal_abort_hard(journal);
846 }
847 if (!err && !is_journal_aborted(journal))
848 err = journal_wait_on_commit_record(journal, cbh);
849
850 if (err)
851 jbd2_journal_abort(journal, err);
852
853 /* End of a transaction! Finally, we can do checkpoint
854 processing: any buffers committed as a result of this
855 transaction can be removed from any checkpoint list it was on
856 before. */
857
858 jbd_debug(3, "JBD: commit phase 6\n");
859
860 J_ASSERT(list_empty(&commit_transaction->t_inode_list));
861 J_ASSERT(commit_transaction->t_buffers == NULL);
862 J_ASSERT(commit_transaction->t_checkpoint_list == NULL);
863 J_ASSERT(commit_transaction->t_iobuf_list == NULL);
864 J_ASSERT(commit_transaction->t_shadow_list == NULL);
865 J_ASSERT(commit_transaction->t_log_list == NULL);
866
867 restart_loop:
868 /*
869 * As there are other places (journal_unmap_buffer()) adding buffers
870 * to this list we have to be careful and hold the j_list_lock.
871 */
872 spin_lock(&journal->j_list_lock);
873 while (commit_transaction->t_forget) {
874 transaction_t *cp_transaction;
875 struct buffer_head *bh;
876
877 jh = commit_transaction->t_forget;
878 spin_unlock(&journal->j_list_lock);
879 bh = jh2bh(jh);
880 jbd_lock_bh_state(bh);
881 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction ||
882 jh->b_transaction == journal->j_running_transaction);
883
884 /*
885 * If there is undo-protected committed data against
886 * this buffer, then we can remove it now. If it is a
887 * buffer needing such protection, the old frozen_data
888 * field now points to a committed version of the
889 * buffer, so rotate that field to the new committed
890 * data.
891 *
892 * Otherwise, we can just throw away the frozen data now.
893 *
894 * We also know that the frozen data has already fired
895 * its triggers if they exist, so we can clear that too.
896 */
897 if (jh->b_committed_data) {
898 jbd2_free(jh->b_committed_data, bh->b_size);
899 jh->b_committed_data = NULL;
900 if (jh->b_frozen_data) {
901 jh->b_committed_data = jh->b_frozen_data;
902 jh->b_frozen_data = NULL;
903 jh->b_frozen_triggers = NULL;
904 }
905 } else if (jh->b_frozen_data) {
906 jbd2_free(jh->b_frozen_data, bh->b_size);
907 jh->b_frozen_data = NULL;
908 jh->b_frozen_triggers = NULL;
909 }
910
911 spin_lock(&journal->j_list_lock);
912 cp_transaction = jh->b_cp_transaction;
913 if (cp_transaction) {
914 JBUFFER_TRACE(jh, "remove from old cp transaction");
915 cp_transaction->t_chp_stats.cs_dropped++;
916 __jbd2_journal_remove_checkpoint(jh);
917 }
918
919 /* Only re-checkpoint the buffer_head if it is marked
920 * dirty. If the buffer was added to the BJ_Forget list
921 * by jbd2_journal_forget, it may no longer be dirty and
922 * there's no point in keeping a checkpoint record for
923 * it. */
924
925 /* A buffer which has been freed while still being
926 * journaled by a previous transaction may end up still
927 * being dirty here, but we want to avoid writing back
928 * that buffer in the future now that the last use has
929 * been committed. That's not only a performance gain,
930 * it also stops aliasing problems if the buffer is left
931 * behind for writeback and gets reallocated for another
932 * use in a different page. */
933 if (buffer_freed(bh)) {
934 clear_buffer_freed(bh);
935 clear_buffer_jbddirty(bh);
936 }
937
938 if (buffer_jbddirty(bh)) {
939 JBUFFER_TRACE(jh, "add to new checkpointing trans");
940 __jbd2_journal_insert_checkpoint(jh, commit_transaction);
941 if (is_journal_aborted(journal))
942 clear_buffer_jbddirty(bh);
943 JBUFFER_TRACE(jh, "refile for checkpoint writeback");
944 __jbd2_journal_refile_buffer(jh);
945 jbd_unlock_bh_state(bh);
946 } else {
947 J_ASSERT_BH(bh, !buffer_dirty(bh));
948 /* The buffer on BJ_Forget list and not jbddirty means
949 * it has been freed by this transaction and hence it
950 * could not have been reallocated until this
951 * transaction has committed. *BUT* it could be
952 * reallocated once we have written all the data to
953 * disk and before we process the buffer on BJ_Forget
954 * list. */
955 JBUFFER_TRACE(jh, "refile or unfile freed buffer");
956 __jbd2_journal_refile_buffer(jh);
957 if (!jh->b_transaction) {
958 jbd_unlock_bh_state(bh);
959 /* needs a brelse */
960 jbd2_journal_remove_journal_head(bh);
961 release_buffer_page(bh);
962 } else
963 jbd_unlock_bh_state(bh);
964 }
965 cond_resched_lock(&journal->j_list_lock);
966 }
967 spin_unlock(&journal->j_list_lock);
968 /*
969 * This is a bit sleazy. We use j_list_lock to protect transition
970 * of a transaction into T_FINISHED state and calling
971 * __jbd2_journal_drop_transaction(). Otherwise we could race with
972 * other checkpointing code processing the transaction...
973 */
974 spin_lock(&journal->j_state_lock);
975 spin_lock(&journal->j_list_lock);
976 /*
977 * Now recheck if some buffers did not get attached to the transaction
978 * while the lock was dropped...
979 */
980 if (commit_transaction->t_forget) {
981 spin_unlock(&journal->j_list_lock);
982 spin_unlock(&journal->j_state_lock);
983 goto restart_loop;
984 }
985
986 /* Done with this transaction! */
987
988 jbd_debug(3, "JBD: commit phase 7\n");
989
990 J_ASSERT(commit_transaction->t_state == T_COMMIT);
991
992 commit_transaction->t_start = jiffies;
993 stats.u.run.rs_logging = jbd2_time_diff(stats.u.run.rs_logging,
994 commit_transaction->t_start);
995
996 /*
997 * File the transaction for history
998 */
999 stats.ts_type = JBD2_STATS_RUN;
1000 stats.ts_tid = commit_transaction->t_tid;
1001 stats.u.run.rs_handle_count = commit_transaction->t_handle_count;
1002 spin_lock(&journal->j_history_lock);
1003 memcpy(journal->j_history + journal->j_history_cur, &stats,
1004 sizeof(stats));
1005 if (++journal->j_history_cur == journal->j_history_max)
1006 journal->j_history_cur = 0;
1007
1008 /*
1009 * Calculate overall stats
1010 */
1011 journal->j_stats.ts_tid++;
1012 journal->j_stats.u.run.rs_wait += stats.u.run.rs_wait;
1013 journal->j_stats.u.run.rs_running += stats.u.run.rs_running;
1014 journal->j_stats.u.run.rs_locked += stats.u.run.rs_locked;
1015 journal->j_stats.u.run.rs_flushing += stats.u.run.rs_flushing;
1016 journal->j_stats.u.run.rs_logging += stats.u.run.rs_logging;
1017 journal->j_stats.u.run.rs_handle_count += stats.u.run.rs_handle_count;
1018 journal->j_stats.u.run.rs_blocks += stats.u.run.rs_blocks;
1019 journal->j_stats.u.run.rs_blocks_logged += stats.u.run.rs_blocks_logged;
1020 spin_unlock(&journal->j_history_lock);
1021
1022 commit_transaction->t_state = T_FINISHED;
1023 J_ASSERT(commit_transaction == journal->j_committing_transaction);
1024 journal->j_commit_sequence = commit_transaction->t_tid;
1025 journal->j_committing_transaction = NULL;
1026 commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time));
1027
1028 /*
1029 * weight the commit time higher than the average time so we don't
1030 * react too strongly to vast changes in the commit time
1031 */
1032 if (likely(journal->j_average_commit_time))
1033 journal->j_average_commit_time = (commit_time +
1034 journal->j_average_commit_time*3) / 4;
1035 else
1036 journal->j_average_commit_time = commit_time;
1037 spin_unlock(&journal->j_state_lock);
1038
1039 if (commit_transaction->t_checkpoint_list == NULL &&
1040 commit_transaction->t_checkpoint_io_list == NULL) {
1041 __jbd2_journal_drop_transaction(journal, commit_transaction);
1042 to_free = 1;
1043 } else {
1044 if (journal->j_checkpoint_transactions == NULL) {
1045 journal->j_checkpoint_transactions = commit_transaction;
1046 commit_transaction->t_cpnext = commit_transaction;
1047 commit_transaction->t_cpprev = commit_transaction;
1048 } else {
1049 commit_transaction->t_cpnext =
1050 journal->j_checkpoint_transactions;
1051 commit_transaction->t_cpprev =
1052 commit_transaction->t_cpnext->t_cpprev;
1053 commit_transaction->t_cpnext->t_cpprev =
1054 commit_transaction;
1055 commit_transaction->t_cpprev->t_cpnext =
1056 commit_transaction;
1057 }
1058 }
1059 spin_unlock(&journal->j_list_lock);
1060
1061 if (journal->j_commit_callback)
1062 journal->j_commit_callback(journal, commit_transaction);
1063
1064 trace_jbd2_end_commit(journal, commit_transaction);
1065 jbd_debug(1, "JBD: commit %d complete, head %d\n",
1066 journal->j_commit_sequence, journal->j_tail_sequence);
1067 if (to_free)
1068 kfree(commit_transaction);
1069
1070 wake_up(&journal->j_wait_done_commit);
1071 }
1072
|
This page was automatically generated by the
LXR engine.
|