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