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 set_bit(BH_JWrite, &jh2bh(new_jh)->b_state); 640 wbuf[bufs++] = jh2bh(new_jh); 641 642 /* Record the new block's tag in the current descriptor 643 buffer */ 644 645 tag_flag = 0; 646 if (flags & 1) 647 tag_flag |= JBD2_FLAG_ESCAPE; 648 if (!first_tag) 649 tag_flag |= JBD2_FLAG_SAME_UUID; 650 651 tag = (journal_block_tag_t *) tagp; 652 write_tag_block(tag_bytes, tag, jh2bh(jh)->b_blocknr); 653 tag->t_flags = cpu_to_be32(tag_flag); 654 tagp += tag_bytes; 655 space_left -= tag_bytes; 656 657 if (first_tag) { 658 memcpy (tagp, journal->j_uuid, 16); 659 tagp += 16; 660 space_left -= 16; 661 first_tag = 0; 662 } 663 664 /* If there's no more to do, or if the descriptor is full, 665 let the IO rip! */ 666 667 if (bufs == journal->j_wbufsize || 668 commit_transaction->t_buffers == NULL || 669 space_left < tag_bytes + 16) { 670 671 jbd_debug(4, "JBD: Submit %d IOs\n", bufs); 672 673 /* Write an end-of-descriptor marker before 674 submitting the IOs. "tag" still points to 675 the last tag we set up. */ 676 677 tag->t_flags |= cpu_to_be32(JBD2_FLAG_LAST_TAG); 678 679 start_journal_io: 680 for (i = 0; i < bufs; i++) { 681 struct buffer_head *bh = wbuf[i]; 682 /* 683 * Compute checksum. 684 */ 685 if (JBD2_HAS_COMPAT_FEATURE(journal, 686 JBD2_FEATURE_COMPAT_CHECKSUM)) { 687 crc32_sum = 688 jbd2_checksum_data(crc32_sum, bh); 689 } 690 691 lock_buffer(bh); 692 clear_buffer_dirty(bh); 693 set_buffer_uptodate(bh); 694 bh->b_end_io = journal_end_buffer_io_sync; 695 submit_bh(write_op, bh); 696 } 697 cond_resched(); 698 stats.u.run.rs_blocks_logged += bufs; 699 700 /* Force a new descriptor to be generated next 701 time round the loop. */ 702 descriptor = NULL; 703 bufs = 0; 704 } 705 } 706 707 /* Done it all: now write the commit record asynchronously. */ 708 709 if (JBD2_HAS_INCOMPAT_FEATURE(journal, 710 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) { 711 err = journal_submit_commit_record(journal, commit_transaction, 712 &cbh, crc32_sum); 713 if (err) 714 __jbd2_journal_abort_hard(journal); 715 } 716 717 /* 718 * This is the right place to wait for data buffers both for ASYNC 719 * and !ASYNC commit. If commit is ASYNC, we need to wait only after 720 * the commit block went to disk (which happens above). If commit is 721 * SYNC, we need to wait for data buffers before we start writing 722 * commit block, which happens below in such setting. 723 */ 724 err = journal_finish_inode_data_buffers(journal, commit_transaction); 725 if (err) { 726 printk(KERN_WARNING 727 "JBD2: Detected IO errors while flushing file data " 728 "on %s\n", journal->j_devname); 729 if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR) 730 jbd2_journal_abort(journal, err); 731 err = 0; 732 } 733 734 /* Lo and behold: we have just managed to send a transaction to 735 the log. Before we can commit it, wait for the IO so far to 736 complete. Control buffers being written are on the 737 transaction's t_log_list queue, and metadata buffers are on 738 the t_iobuf_list queue. 739 740 Wait for the buffers in reverse order. That way we are 741 less likely to be woken up until all IOs have completed, and 742 so we incur less scheduling load. 743 */ 744 745 jbd_debug(3, "JBD: commit phase 3\n"); 746 747 /* 748 * akpm: these are BJ_IO, and j_list_lock is not needed. 749 * See __journal_try_to_free_buffer. 750 */ 751 wait_for_iobuf: 752 while (commit_transaction->t_iobuf_list != NULL) { 753 struct buffer_head *bh; 754 755 jh = commit_transaction->t_iobuf_list->b_tprev; 756 bh = jh2bh(jh); 757 if (buffer_locked(bh)) { 758 wait_on_buffer(bh); 759 goto wait_for_iobuf; 760 } 761 if (cond_resched()) 762 goto wait_for_iobuf; 763 764 if (unlikely(!buffer_uptodate(bh))) 765 err = -EIO; 766 767 clear_buffer_jwrite(bh); 768 769 JBUFFER_TRACE(jh, "ph4: unfile after journal write"); 770 jbd2_journal_unfile_buffer(journal, jh); 771 772 /* 773 * ->t_iobuf_list should contain only dummy buffer_heads 774 * which were created by jbd2_journal_write_metadata_buffer(). 775 */ 776 BUFFER_TRACE(bh, "dumping temporary bh"); 777 jbd2_journal_put_journal_head(jh); 778 __brelse(bh); 779 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0); 780 free_buffer_head(bh); 781 782 /* We also have to unlock and free the corresponding 783 shadowed buffer */ 784 jh = commit_transaction->t_shadow_list->b_tprev; 785 bh = jh2bh(jh); 786 clear_bit(BH_JWrite, &bh->b_state); 787 J_ASSERT_BH(bh, buffer_jbddirty(bh)); 788 789 /* The metadata is now released for reuse, but we need 790 to remember it against this transaction so that when 791 we finally commit, we can do any checkpointing 792 required. */ 793 JBUFFER_TRACE(jh, "file as BJ_Forget"); 794 jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget); 795 /* Wake up any transactions which were waiting for this 796 IO to complete */ 797 wake_up_bit(&bh->b_state, BH_Unshadow); 798 JBUFFER_TRACE(jh, "brelse shadowed buffer"); 799 __brelse(bh); 800 } 801 802 J_ASSERT (commit_transaction->t_shadow_list == NULL); 803 804 jbd_debug(3, "JBD: commit phase 4\n"); 805 806 /* Here we wait for the revoke record and descriptor record buffers */ 807 wait_for_ctlbuf: 808 while (commit_transaction->t_log_list != NULL) { 809 struct buffer_head *bh; 810 811 jh = commit_transaction->t_log_list->b_tprev; 812 bh = jh2bh(jh); 813 if (buffer_locked(bh)) { 814 wait_on_buffer(bh); 815 goto wait_for_ctlbuf; 816 } 817 if (cond_resched()) 818 goto wait_for_ctlbuf; 819 820 if (unlikely(!buffer_uptodate(bh))) 821 err = -EIO; 822 823 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile"); 824 clear_buffer_jwrite(bh); 825 jbd2_journal_unfile_buffer(journal, jh); 826 jbd2_journal_put_journal_head(jh); 827 __brelse(bh); /* One for getblk */ 828 /* AKPM: bforget here */ 829 } 830 831 if (err) 832 jbd2_journal_abort(journal, err); 833 834 jbd_debug(3, "JBD: commit phase 5\n"); 835 836 if (!JBD2_HAS_INCOMPAT_FEATURE(journal, 837 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) { 838 err = journal_submit_commit_record(journal, commit_transaction, 839 &cbh, crc32_sum); 840 if (err) 841 __jbd2_journal_abort_hard(journal); 842 } 843 if (!err && !is_journal_aborted(journal)) 844 err = journal_wait_on_commit_record(journal, cbh); 845 846 if (err) 847 jbd2_journal_abort(journal, err); 848 849 /* End of a transaction! Finally, we can do checkpoint 850 processing: any buffers committed as a result of this 851 transaction can be removed from any checkpoint list it was on 852 before. */ 853 854 jbd_debug(3, "JBD: commit phase 6\n"); 855 856 J_ASSERT(list_empty(&commit_transaction->t_inode_list)); 857 J_ASSERT(commit_transaction->t_buffers == NULL); 858 J_ASSERT(commit_transaction->t_checkpoint_list == NULL); 859 J_ASSERT(commit_transaction->t_iobuf_list == NULL); 860 J_ASSERT(commit_transaction->t_shadow_list == NULL); 861 J_ASSERT(commit_transaction->t_log_list == NULL); 862 863 restart_loop: 864 /* 865 * As there are other places (journal_unmap_buffer()) adding buffers 866 * to this list we have to be careful and hold the j_list_lock. 867 */ 868 spin_lock(&journal->j_list_lock); 869 while (commit_transaction->t_forget) { 870 transaction_t *cp_transaction; 871 struct buffer_head *bh; 872 873 jh = commit_transaction->t_forget; 874 spin_unlock(&journal->j_list_lock); 875 bh = jh2bh(jh); 876 jbd_lock_bh_state(bh); 877 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction || 878 jh->b_transaction == journal->j_running_transaction); 879 880 /* 881 * If there is undo-protected committed data against 882 * this buffer, then we can remove it now. If it is a 883 * buffer needing such protection, the old frozen_data 884 * field now points to a committed version of the 885 * buffer, so rotate that field to the new committed 886 * data. 887 * 888 * Otherwise, we can just throw away the frozen data now. 889 * 890 * We also know that the frozen data has already fired 891 * its triggers if they exist, so we can clear that too. 892 */ 893 if (jh->b_committed_data) { 894 jbd2_free(jh->b_committed_data, bh->b_size); 895 jh->b_committed_data = NULL; 896 if (jh->b_frozen_data) { 897 jh->b_committed_data = jh->b_frozen_data; 898 jh->b_frozen_data = NULL; 899 jh->b_frozen_triggers = NULL; 900 } 901 } else if (jh->b_frozen_data) { 902 jbd2_free(jh->b_frozen_data, bh->b_size); 903 jh->b_frozen_data = NULL; 904 jh->b_frozen_triggers = NULL; 905 } 906 907 spin_lock(&journal->j_list_lock); 908 cp_transaction = jh->b_cp_transaction; 909 if (cp_transaction) { 910 JBUFFER_TRACE(jh, "remove from old cp transaction"); 911 cp_transaction->t_chp_stats.cs_dropped++; 912 __jbd2_journal_remove_checkpoint(jh); 913 } 914 915 /* Only re-checkpoint the buffer_head if it is marked 916 * dirty. If the buffer was added to the BJ_Forget list 917 * by jbd2_journal_forget, it may no longer be dirty and 918 * there's no point in keeping a checkpoint record for 919 * it. */ 920 921 /* A buffer which has been freed while still being 922 * journaled by a previous transaction may end up still 923 * being dirty here, but we want to avoid writing back 924 * that buffer in the future now that the last use has 925 * been committed. That's not only a performance gain, 926 * it also stops aliasing problems if the buffer is left 927 * behind for writeback and gets reallocated for another 928 * use in a different page. */ 929 if (buffer_freed(bh)) { 930 clear_buffer_freed(bh); 931 clear_buffer_jbddirty(bh); 932 } 933 934 if (buffer_jbddirty(bh)) { 935 JBUFFER_TRACE(jh, "add to new checkpointing trans"); 936 __jbd2_journal_insert_checkpoint(jh, commit_transaction); 937 if (is_journal_aborted(journal)) 938 clear_buffer_jbddirty(bh); 939 JBUFFER_TRACE(jh, "refile for checkpoint writeback"); 940 __jbd2_journal_refile_buffer(jh); 941 jbd_unlock_bh_state(bh); 942 } else { 943 J_ASSERT_BH(bh, !buffer_dirty(bh)); 944 /* The buffer on BJ_Forget list and not jbddirty means 945 * it has been freed by this transaction and hence it 946 * could not have been reallocated until this 947 * transaction has committed. *BUT* it could be 948 * reallocated once we have written all the data to 949 * disk and before we process the buffer on BJ_Forget 950 * list. */ 951 JBUFFER_TRACE(jh, "refile or unfile freed buffer"); 952 __jbd2_journal_refile_buffer(jh); 953 if (!jh->b_transaction) { 954 jbd_unlock_bh_state(bh); 955 /* needs a brelse */ 956 jbd2_journal_remove_journal_head(bh); 957 release_buffer_page(bh); 958 } else 959 jbd_unlock_bh_state(bh); 960 } 961 cond_resched_lock(&journal->j_list_lock); 962 } 963 spin_unlock(&journal->j_list_lock); 964 /* 965 * This is a bit sleazy. We use j_list_lock to protect transition 966 * of a transaction into T_FINISHED state and calling 967 * __jbd2_journal_drop_transaction(). Otherwise we could race with 968 * other checkpointing code processing the transaction... 969 */ 970 spin_lock(&journal->j_state_lock); 971 spin_lock(&journal->j_list_lock); 972 /* 973 * Now recheck if some buffers did not get attached to the transaction 974 * while the lock was dropped... 975 */ 976 if (commit_transaction->t_forget) { 977 spin_unlock(&journal->j_list_lock); 978 spin_unlock(&journal->j_state_lock); 979 goto restart_loop; 980 } 981 982 /* Done with this transaction! */ 983 984 jbd_debug(3, "JBD: commit phase 7\n"); 985 986 J_ASSERT(commit_transaction->t_state == T_COMMIT); 987 988 commit_transaction->t_start = jiffies; 989 stats.u.run.rs_logging = jbd2_time_diff(stats.u.run.rs_logging, 990 commit_transaction->t_start); 991 992 /* 993 * File the transaction for history 994 */ 995 stats.ts_type = JBD2_STATS_RUN; 996 stats.ts_tid = commit_transaction->t_tid; 997 stats.u.run.rs_handle_count = commit_transaction->t_handle_count; 998 spin_lock(&journal->j_history_lock); 999 memcpy(journal->j_history + journal->j_history_cur, &stats, 1000 sizeof(stats)); 1001 if (++journal->j_history_cur == journal->j_history_max) 1002 journal->j_history_cur = 0; 1003 1004 /* 1005 * Calculate overall stats 1006 */ 1007 journal->j_stats.ts_tid++; 1008 journal->j_stats.u.run.rs_wait += stats.u.run.rs_wait; 1009 journal->j_stats.u.run.rs_running += stats.u.run.rs_running; 1010 journal->j_stats.u.run.rs_locked += stats.u.run.rs_locked; 1011 journal->j_stats.u.run.rs_flushing += stats.u.run.rs_flushing; 1012 journal->j_stats.u.run.rs_logging += stats.u.run.rs_logging; 1013 journal->j_stats.u.run.rs_handle_count += stats.u.run.rs_handle_count; 1014 journal->j_stats.u.run.rs_blocks += stats.u.run.rs_blocks; 1015 journal->j_stats.u.run.rs_blocks_logged += stats.u.run.rs_blocks_logged; 1016 spin_unlock(&journal->j_history_lock); 1017 1018 commit_transaction->t_state = T_FINISHED; 1019 J_ASSERT(commit_transaction == journal->j_committing_transaction); 1020 journal->j_commit_sequence = commit_transaction->t_tid; 1021 journal->j_committing_transaction = NULL; 1022 commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time)); 1023 1024 /* 1025 * weight the commit time higher than the average time so we don't 1026 * react too strongly to vast changes in the commit time 1027 */ 1028 if (likely(journal->j_average_commit_time)) 1029 journal->j_average_commit_time = (commit_time + 1030 journal->j_average_commit_time*3) / 4; 1031 else 1032 journal->j_average_commit_time = commit_time; 1033 spin_unlock(&journal->j_state_lock); 1034 1035 if (commit_transaction->t_checkpoint_list == NULL && 1036 commit_transaction->t_checkpoint_io_list == NULL) { 1037 __jbd2_journal_drop_transaction(journal, commit_transaction); 1038 to_free = 1; 1039 } else { 1040 if (journal->j_checkpoint_transactions == NULL) { 1041 journal->j_checkpoint_transactions = commit_transaction; 1042 commit_transaction->t_cpnext = commit_transaction; 1043 commit_transaction->t_cpprev = commit_transaction; 1044 } else { 1045 commit_transaction->t_cpnext = 1046 journal->j_checkpoint_transactions; 1047 commit_transaction->t_cpprev = 1048 commit_transaction->t_cpnext->t_cpprev; 1049 commit_transaction->t_cpnext->t_cpprev = 1050 commit_transaction; 1051 commit_transaction->t_cpprev->t_cpnext = 1052 commit_transaction; 1053 } 1054 } 1055 spin_unlock(&journal->j_list_lock); 1056 1057 if (journal->j_commit_callback) 1058 journal->j_commit_callback(journal, commit_transaction); 1059 1060 trace_jbd2_end_commit(journal, commit_transaction); 1061 jbd_debug(1, "JBD: commit %d complete, head %d\n", 1062 journal->j_commit_sequence, journal->j_tail_sequence); 1063 if (to_free) 1064 kfree(commit_transaction); 1065 1066 wake_up(&journal->j_wait_done_commit); 1067 } 1068