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 int barrier_done = 0; 105 struct timespec now = current_kernel_time(); 106 107 if (is_journal_aborted(journal)) 108 return 0; 109 110 descriptor = jbd2_journal_get_descriptor_buffer(journal); 111 if (!descriptor) 112 return 1; 113 114 bh = jh2bh(descriptor); 115 116 tmp = (struct commit_header *)bh->b_data; 117 tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER); 118 tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK); 119 tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid); 120 tmp->h_commit_sec = cpu_to_be64(now.tv_sec); 121 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec); 122 123 if (JBD2_HAS_COMPAT_FEATURE(journal, 124 JBD2_FEATURE_COMPAT_CHECKSUM)) { 125 tmp->h_chksum_type = JBD2_CRC32_CHKSUM; 126 tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE; 127 tmp->h_chksum[0] = cpu_to_be32(crc32_sum); 128 } 129 130 JBUFFER_TRACE(descriptor, "submit commit block"); 131 lock_buffer(bh); 132 clear_buffer_dirty(bh); 133 set_buffer_uptodate(bh); 134 bh->b_end_io = journal_end_buffer_io_sync; 135 136 if (journal->j_flags & JBD2_BARRIER && 137 !JBD2_HAS_INCOMPAT_FEATURE(journal, 138 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) { 139 set_buffer_ordered(bh); 140 barrier_done = 1; 141 } 142 ret = submit_bh(WRITE_SYNC_PLUG, bh); 143 if (barrier_done) 144 clear_buffer_ordered(bh); 145 146 /* is it possible for another commit to fail at roughly 147 * the same time as this one? If so, we don't want to 148 * trust the barrier flag in the super, but instead want 149 * to remember if we sent a barrier request 150 */ 151 if (ret == -EOPNOTSUPP && barrier_done) { 152 printk(KERN_WARNING 153 "JBD: barrier-based sync failed on %s - " 154 "disabling barriers\n", journal->j_devname); 155 spin_lock(&journal->j_state_lock); 156 journal->j_flags &= ~JBD2_BARRIER; 157 spin_unlock(&journal->j_state_lock); 158 159 /* And try again, without the barrier */ 160 lock_buffer(bh); 161 set_buffer_uptodate(bh); 162 clear_buffer_dirty(bh); 163 ret = submit_bh(WRITE_SYNC_PLUG, bh); 164 } 165 *cbh = bh; 166 return ret; 167 } 168 169 /* 170 * This function along with journal_submit_commit_record 171 * allows to write the commit record asynchronously. 172 */ 173 static int journal_wait_on_commit_record(journal_t *journal, 174 struct buffer_head *bh) 175 { 176 int ret = 0; 177 178 retry: 179 clear_buffer_dirty(bh); 180 wait_on_buffer(bh); 181 if (buffer_eopnotsupp(bh) && (journal->j_flags & JBD2_BARRIER)) { 182 printk(KERN_WARNING 183 "JBD2: wait_on_commit_record: sync failed on %s - " 184 "disabling barriers\n", journal->j_devname); 185 spin_lock(&journal->j_state_lock); 186 journal->j_flags &= ~JBD2_BARRIER; 187 spin_unlock(&journal->j_state_lock); 188 189 lock_buffer(bh); 190 clear_buffer_dirty(bh); 191 set_buffer_uptodate(bh); 192 bh->b_end_io = journal_end_buffer_io_sync; 193 194 ret = submit_bh(WRITE_SYNC_PLUG, bh); 195 if (ret) { 196 unlock_buffer(bh); 197 return ret; 198 } 199 goto retry; 200 } 201 202 if (unlikely(!buffer_uptodate(bh))) 203 ret = -EIO; 204 put_bh(bh); /* One for getblk() */ 205 jbd2_journal_put_journal_head(bh2jh(bh)); 206 207 return ret; 208 } 209 210 /* 211 * write the filemap data using writepage() address_space_operations. 212 * We don't do block allocation here even for delalloc. We don't 213 * use writepages() because with dealyed allocation we may be doing 214 * block allocation in writepages(). 215 */ 216 static int journal_submit_inode_data_buffers(struct address_space *mapping) 217 { 218 int ret; 219 struct writeback_control wbc = { 220 .sync_mode = WB_SYNC_ALL, 221 .nr_to_write = mapping->nrpages * 2, 222 .range_start = 0, 223 .range_end = i_size_read(mapping->host), 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 * filemap_fdatawait_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.run.rs_wait = commit_transaction->t_max_wait; 414 stats.run.rs_locked = jiffies; 415 stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start, 416 stats.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.run.rs_flushing = jiffies; 490 stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked, 491 stats.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.run.rs_logging = jiffies; 527 stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing, 528 stats.run.rs_logging); 529 stats.run.rs_blocks = commit_transaction->t_outstanding_credits; 530 stats.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.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 if (journal->j_flags & JBD2_BARRIER) 720 blkdev_issue_flush(journal->j_dev, NULL); 721 } 722 723 /* 724 * This is the right place to wait for data buffers both for ASYNC 725 * and !ASYNC commit. If commit is ASYNC, we need to wait only after 726 * the commit block went to disk (which happens above). If commit is 727 * SYNC, we need to wait for data buffers before we start writing 728 * commit block, which happens below in such setting. 729 */ 730 err = journal_finish_inode_data_buffers(journal, commit_transaction); 731 if (err) { 732 printk(KERN_WARNING 733 "JBD2: Detected IO errors while flushing file data " 734 "on %s\n", journal->j_devname); 735 if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR) 736 jbd2_journal_abort(journal, err); 737 err = 0; 738 } 739 740 /* Lo and behold: we have just managed to send a transaction to 741 the log. Before we can commit it, wait for the IO so far to 742 complete. Control buffers being written are on the 743 transaction's t_log_list queue, and metadata buffers are on 744 the t_iobuf_list queue. 745 746 Wait for the buffers in reverse order. That way we are 747 less likely to be woken up until all IOs have completed, and 748 so we incur less scheduling load. 749 */ 750 751 jbd_debug(3, "JBD: commit phase 3\n"); 752 753 /* 754 * akpm: these are BJ_IO, and j_list_lock is not needed. 755 * See __journal_try_to_free_buffer. 756 */ 757 wait_for_iobuf: 758 while (commit_transaction->t_iobuf_list != NULL) { 759 struct buffer_head *bh; 760 761 jh = commit_transaction->t_iobuf_list->b_tprev; 762 bh = jh2bh(jh); 763 if (buffer_locked(bh)) { 764 wait_on_buffer(bh); 765 goto wait_for_iobuf; 766 } 767 if (cond_resched()) 768 goto wait_for_iobuf; 769 770 if (unlikely(!buffer_uptodate(bh))) 771 err = -EIO; 772 773 clear_buffer_jwrite(bh); 774 775 JBUFFER_TRACE(jh, "ph4: unfile after journal write"); 776 jbd2_journal_unfile_buffer(journal, jh); 777 778 /* 779 * ->t_iobuf_list should contain only dummy buffer_heads 780 * which were created by jbd2_journal_write_metadata_buffer(). 781 */ 782 BUFFER_TRACE(bh, "dumping temporary bh"); 783 jbd2_journal_put_journal_head(jh); 784 __brelse(bh); 785 J_ASSERT_BH(bh, atomic_read(&bh->b_count) == 0); 786 free_buffer_head(bh); 787 788 /* We also have to unlock and free the corresponding 789 shadowed buffer */ 790 jh = commit_transaction->t_shadow_list->b_tprev; 791 bh = jh2bh(jh); 792 clear_bit(BH_JWrite, &bh->b_state); 793 J_ASSERT_BH(bh, buffer_jbddirty(bh)); 794 795 /* The metadata is now released for reuse, but we need 796 to remember it against this transaction so that when 797 we finally commit, we can do any checkpointing 798 required. */ 799 JBUFFER_TRACE(jh, "file as BJ_Forget"); 800 jbd2_journal_file_buffer(jh, commit_transaction, BJ_Forget); 801 /* Wake up any transactions which were waiting for this 802 IO to complete */ 803 wake_up_bit(&bh->b_state, BH_Unshadow); 804 JBUFFER_TRACE(jh, "brelse shadowed buffer"); 805 __brelse(bh); 806 } 807 808 J_ASSERT (commit_transaction->t_shadow_list == NULL); 809 810 jbd_debug(3, "JBD: commit phase 4\n"); 811 812 /* Here we wait for the revoke record and descriptor record buffers */ 813 wait_for_ctlbuf: 814 while (commit_transaction->t_log_list != NULL) { 815 struct buffer_head *bh; 816 817 jh = commit_transaction->t_log_list->b_tprev; 818 bh = jh2bh(jh); 819 if (buffer_locked(bh)) { 820 wait_on_buffer(bh); 821 goto wait_for_ctlbuf; 822 } 823 if (cond_resched()) 824 goto wait_for_ctlbuf; 825 826 if (unlikely(!buffer_uptodate(bh))) 827 err = -EIO; 828 829 BUFFER_TRACE(bh, "ph5: control buffer writeout done: unfile"); 830 clear_buffer_jwrite(bh); 831 jbd2_journal_unfile_buffer(journal, jh); 832 jbd2_journal_put_journal_head(jh); 833 __brelse(bh); /* One for getblk */ 834 /* AKPM: bforget here */ 835 } 836 837 if (err) 838 jbd2_journal_abort(journal, err); 839 840 jbd_debug(3, "JBD: commit phase 5\n"); 841 842 if (!JBD2_HAS_INCOMPAT_FEATURE(journal, 843 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) { 844 err = journal_submit_commit_record(journal, commit_transaction, 845 &cbh, crc32_sum); 846 if (err) 847 __jbd2_journal_abort_hard(journal); 848 } 849 if (!err && !is_journal_aborted(journal)) 850 err = journal_wait_on_commit_record(journal, cbh); 851 852 if (err) 853 jbd2_journal_abort(journal, err); 854 855 /* End of a transaction! Finally, we can do checkpoint 856 processing: any buffers committed as a result of this 857 transaction can be removed from any checkpoint list it was on 858 before. */ 859 860 jbd_debug(3, "JBD: commit phase 6\n"); 861 862 J_ASSERT(list_empty(&commit_transaction->t_inode_list)); 863 J_ASSERT(commit_transaction->t_buffers == NULL); 864 J_ASSERT(commit_transaction->t_checkpoint_list == NULL); 865 J_ASSERT(commit_transaction->t_iobuf_list == NULL); 866 J_ASSERT(commit_transaction->t_shadow_list == NULL); 867 J_ASSERT(commit_transaction->t_log_list == NULL); 868 869 restart_loop: 870 /* 871 * As there are other places (journal_unmap_buffer()) adding buffers 872 * to this list we have to be careful and hold the j_list_lock. 873 */ 874 spin_lock(&journal->j_list_lock); 875 while (commit_transaction->t_forget) { 876 transaction_t *cp_transaction; 877 struct buffer_head *bh; 878 879 jh = commit_transaction->t_forget; 880 spin_unlock(&journal->j_list_lock); 881 bh = jh2bh(jh); 882 jbd_lock_bh_state(bh); 883 J_ASSERT_JH(jh, jh->b_transaction == commit_transaction || 884 jh->b_transaction == journal->j_running_transaction); 885 886 /* 887 * If there is undo-protected committed data against 888 * this buffer, then we can remove it now. If it is a 889 * buffer needing such protection, the old frozen_data 890 * field now points to a committed version of the 891 * buffer, so rotate that field to the new committed 892 * data. 893 * 894 * Otherwise, we can just throw away the frozen data now. 895 * 896 * We also know that the frozen data has already fired 897 * its triggers if they exist, so we can clear that too. 898 */ 899 if (jh->b_committed_data) { 900 jbd2_free(jh->b_committed_data, bh->b_size); 901 jh->b_committed_data = NULL; 902 if (jh->b_frozen_data) { 903 jh->b_committed_data = jh->b_frozen_data; 904 jh->b_frozen_data = NULL; 905 jh->b_frozen_triggers = NULL; 906 } 907 } else if (jh->b_frozen_data) { 908 jbd2_free(jh->b_frozen_data, bh->b_size); 909 jh->b_frozen_data = NULL; 910 jh->b_frozen_triggers = NULL; 911 } 912 913 spin_lock(&journal->j_list_lock); 914 cp_transaction = jh->b_cp_transaction; 915 if (cp_transaction) { 916 JBUFFER_TRACE(jh, "remove from old cp transaction"); 917 cp_transaction->t_chp_stats.cs_dropped++; 918 __jbd2_journal_remove_checkpoint(jh); 919 } 920 921 /* Only re-checkpoint the buffer_head if it is marked 922 * dirty. If the buffer was added to the BJ_Forget list 923 * by jbd2_journal_forget, it may no longer be dirty and 924 * there's no point in keeping a checkpoint record for 925 * it. */ 926 927 /* A buffer which has been freed while still being 928 * journaled by a previous transaction may end up still 929 * being dirty here, but we want to avoid writing back 930 * that buffer in the future now that the last use has 931 * been committed. That's not only a performance gain, 932 * it also stops aliasing problems if the buffer is left 933 * behind for writeback and gets reallocated for another 934 * use in a different page. */ 935 if (buffer_freed(bh)) { 936 clear_buffer_freed(bh); 937 clear_buffer_jbddirty(bh); 938 } 939 940 if (buffer_jbddirty(bh)) { 941 JBUFFER_TRACE(jh, "add to new checkpointing trans"); 942 __jbd2_journal_insert_checkpoint(jh, commit_transaction); 943 if (is_journal_aborted(journal)) 944 clear_buffer_jbddirty(bh); 945 JBUFFER_TRACE(jh, "refile for checkpoint writeback"); 946 __jbd2_journal_refile_buffer(jh); 947 jbd_unlock_bh_state(bh); 948 } else { 949 J_ASSERT_BH(bh, !buffer_dirty(bh)); 950 /* The buffer on BJ_Forget list and not jbddirty means 951 * it has been freed by this transaction and hence it 952 * could not have been reallocated until this 953 * transaction has committed. *BUT* it could be 954 * reallocated once we have written all the data to 955 * disk and before we process the buffer on BJ_Forget 956 * list. */ 957 JBUFFER_TRACE(jh, "refile or unfile freed buffer"); 958 __jbd2_journal_refile_buffer(jh); 959 if (!jh->b_transaction) { 960 jbd_unlock_bh_state(bh); 961 /* needs a brelse */ 962 jbd2_journal_remove_journal_head(bh); 963 release_buffer_page(bh); 964 } else 965 jbd_unlock_bh_state(bh); 966 } 967 cond_resched_lock(&journal->j_list_lock); 968 } 969 spin_unlock(&journal->j_list_lock); 970 /* 971 * This is a bit sleazy. We use j_list_lock to protect transition 972 * of a transaction into T_FINISHED state and calling 973 * __jbd2_journal_drop_transaction(). Otherwise we could race with 974 * other checkpointing code processing the transaction... 975 */ 976 spin_lock(&journal->j_state_lock); 977 spin_lock(&journal->j_list_lock); 978 /* 979 * Now recheck if some buffers did not get attached to the transaction 980 * while the lock was dropped... 981 */ 982 if (commit_transaction->t_forget) { 983 spin_unlock(&journal->j_list_lock); 984 spin_unlock(&journal->j_state_lock); 985 goto restart_loop; 986 } 987 988 /* Done with this transaction! */ 989 990 jbd_debug(3, "JBD: commit phase 7\n"); 991 992 J_ASSERT(commit_transaction->t_state == T_COMMIT); 993 994 commit_transaction->t_start = jiffies; 995 stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging, 996 commit_transaction->t_start); 997 998 /* 999 * File the transaction statistics 1000 */ 1001 stats.ts_tid = commit_transaction->t_tid; 1002 stats.run.rs_handle_count = commit_transaction->t_handle_count; 1003 trace_jbd2_run_stats(journal->j_fs_dev->bd_dev, 1004 commit_transaction->t_tid, &stats.run); 1005 1006 /* 1007 * Calculate overall stats 1008 */ 1009 spin_lock(&journal->j_history_lock); 1010 journal->j_stats.ts_tid++; 1011 journal->j_stats.run.rs_wait += stats.run.rs_wait; 1012 journal->j_stats.run.rs_running += stats.run.rs_running; 1013 journal->j_stats.run.rs_locked += stats.run.rs_locked; 1014 journal->j_stats.run.rs_flushing += stats.run.rs_flushing; 1015 journal->j_stats.run.rs_logging += stats.run.rs_logging; 1016 journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count; 1017 journal->j_stats.run.rs_blocks += stats.run.rs_blocks; 1018 journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged; 1019 spin_unlock(&journal->j_history_lock); 1020 1021 commit_transaction->t_state = T_FINISHED; 1022 J_ASSERT(commit_transaction == journal->j_committing_transaction); 1023 journal->j_commit_sequence = commit_transaction->t_tid; 1024 journal->j_committing_transaction = NULL; 1025 commit_time = ktime_to_ns(ktime_sub(ktime_get(), start_time)); 1026 1027 /* 1028 * weight the commit time higher than the average time so we don't 1029 * react too strongly to vast changes in the commit time 1030 */ 1031 if (likely(journal->j_average_commit_time)) 1032 journal->j_average_commit_time = (commit_time + 1033 journal->j_average_commit_time*3) / 4; 1034 else 1035 journal->j_average_commit_time = commit_time; 1036 spin_unlock(&journal->j_state_lock); 1037 1038 if (commit_transaction->t_checkpoint_list == NULL && 1039 commit_transaction->t_checkpoint_io_list == NULL) { 1040 __jbd2_journal_drop_transaction(journal, commit_transaction); 1041 to_free = 1; 1042 } else { 1043 if (journal->j_checkpoint_transactions == NULL) { 1044 journal->j_checkpoint_transactions = commit_transaction; 1045 commit_transaction->t_cpnext = commit_transaction; 1046 commit_transaction->t_cpprev = commit_transaction; 1047 } else { 1048 commit_transaction->t_cpnext = 1049 journal->j_checkpoint_transactions; 1050 commit_transaction->t_cpprev = 1051 commit_transaction->t_cpnext->t_cpprev; 1052 commit_transaction->t_cpnext->t_cpprev = 1053 commit_transaction; 1054 commit_transaction->t_cpprev->t_cpnext = 1055 commit_transaction; 1056 } 1057 } 1058 spin_unlock(&journal->j_list_lock); 1059 1060 if (journal->j_commit_callback) 1061 journal->j_commit_callback(journal, commit_transaction); 1062 1063 trace_jbd2_end_commit(journal, commit_transaction); 1064 jbd_debug(1, "JBD: commit %d complete, head %d\n", 1065 journal->j_commit_sequence, journal->j_tail_sequence); 1066 if (to_free) 1067 kfree(commit_transaction); 1068 1069 wake_up(&journal->j_wait_done_commit); 1070 } 1071