1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * linux/fs/jbd2/journal.c 4 * 5 * Written by Stephen C. Tweedie <sct@redhat.com>, 1998 6 * 7 * Copyright 1998 Red Hat corp --- All Rights Reserved 8 * 9 * Generic filesystem journal-writing code; part of the ext2fs 10 * journaling system. 11 * 12 * This file manages journals: areas of disk reserved for logging 13 * transactional updates. This includes the kernel journaling thread 14 * which is responsible for scheduling updates to the log. 15 * 16 * We do not actually manage the physical storage of the journal in this 17 * file: that is left to a per-journal policy function, which allows us 18 * to store the journal within a filesystem-specified area for ext2 19 * journaling (ext2 can use a reserved inode for storing the log). 20 */ 21 22 #include <linux/module.h> 23 #include <linux/time.h> 24 #include <linux/fs.h> 25 #include <linux/jbd2.h> 26 #include <linux/errno.h> 27 #include <linux/slab.h> 28 #include <linux/init.h> 29 #include <linux/mm.h> 30 #include <linux/freezer.h> 31 #include <linux/pagemap.h> 32 #include <linux/kthread.h> 33 #include <linux/poison.h> 34 #include <linux/proc_fs.h> 35 #include <linux/seq_file.h> 36 #include <linux/math64.h> 37 #include <linux/hash.h> 38 #include <linux/log2.h> 39 #include <linux/vmalloc.h> 40 #include <linux/backing-dev.h> 41 #include <linux/bitops.h> 42 #include <linux/ratelimit.h> 43 #include <linux/sched/mm.h> 44 45 #define CREATE_TRACE_POINTS 46 #include <trace/events/jbd2.h> 47 48 #include <linux/uaccess.h> 49 #include <asm/page.h> 50 51 #ifdef CONFIG_JBD2_DEBUG 52 ushort jbd2_journal_enable_debug __read_mostly; 53 EXPORT_SYMBOL(jbd2_journal_enable_debug); 54 55 module_param_named(jbd2_debug, jbd2_journal_enable_debug, ushort, 0644); 56 MODULE_PARM_DESC(jbd2_debug, "Debugging level for jbd2"); 57 #endif 58 59 EXPORT_SYMBOL(jbd2_journal_extend); 60 EXPORT_SYMBOL(jbd2_journal_stop); 61 EXPORT_SYMBOL(jbd2_journal_lock_updates); 62 EXPORT_SYMBOL(jbd2_journal_unlock_updates); 63 EXPORT_SYMBOL(jbd2_journal_get_write_access); 64 EXPORT_SYMBOL(jbd2_journal_get_create_access); 65 EXPORT_SYMBOL(jbd2_journal_get_undo_access); 66 EXPORT_SYMBOL(jbd2_journal_set_triggers); 67 EXPORT_SYMBOL(jbd2_journal_dirty_metadata); 68 EXPORT_SYMBOL(jbd2_journal_forget); 69 EXPORT_SYMBOL(jbd2_journal_flush); 70 EXPORT_SYMBOL(jbd2_journal_revoke); 71 72 EXPORT_SYMBOL(jbd2_journal_init_dev); 73 EXPORT_SYMBOL(jbd2_journal_init_inode); 74 EXPORT_SYMBOL(jbd2_journal_check_used_features); 75 EXPORT_SYMBOL(jbd2_journal_check_available_features); 76 EXPORT_SYMBOL(jbd2_journal_set_features); 77 EXPORT_SYMBOL(jbd2_journal_load); 78 EXPORT_SYMBOL(jbd2_journal_destroy); 79 EXPORT_SYMBOL(jbd2_journal_abort); 80 EXPORT_SYMBOL(jbd2_journal_errno); 81 EXPORT_SYMBOL(jbd2_journal_ack_err); 82 EXPORT_SYMBOL(jbd2_journal_clear_err); 83 EXPORT_SYMBOL(jbd2_log_wait_commit); 84 EXPORT_SYMBOL(jbd2_log_start_commit); 85 EXPORT_SYMBOL(jbd2_journal_start_commit); 86 EXPORT_SYMBOL(jbd2_journal_force_commit_nested); 87 EXPORT_SYMBOL(jbd2_journal_wipe); 88 EXPORT_SYMBOL(jbd2_journal_blocks_per_page); 89 EXPORT_SYMBOL(jbd2_journal_invalidatepage); 90 EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers); 91 EXPORT_SYMBOL(jbd2_journal_force_commit); 92 EXPORT_SYMBOL(jbd2_journal_inode_ranged_write); 93 EXPORT_SYMBOL(jbd2_journal_inode_ranged_wait); 94 EXPORT_SYMBOL(jbd2_journal_submit_inode_data_buffers); 95 EXPORT_SYMBOL(jbd2_journal_finish_inode_data_buffers); 96 EXPORT_SYMBOL(jbd2_journal_init_jbd_inode); 97 EXPORT_SYMBOL(jbd2_journal_release_jbd_inode); 98 EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate); 99 EXPORT_SYMBOL(jbd2_inode_cache); 100 101 static int jbd2_journal_create_slab(size_t slab_size); 102 103 #ifdef CONFIG_JBD2_DEBUG 104 void __jbd2_debug(int level, const char *file, const char *func, 105 unsigned int line, const char *fmt, ...) 106 { 107 struct va_format vaf; 108 va_list args; 109 110 if (level > jbd2_journal_enable_debug) 111 return; 112 va_start(args, fmt); 113 vaf.fmt = fmt; 114 vaf.va = &args; 115 printk(KERN_DEBUG "%s: (%s, %u): %pV", file, func, line, &vaf); 116 va_end(args); 117 } 118 EXPORT_SYMBOL(__jbd2_debug); 119 #endif 120 121 /* Checksumming functions */ 122 static int jbd2_verify_csum_type(journal_t *j, journal_superblock_t *sb) 123 { 124 if (!jbd2_journal_has_csum_v2or3_feature(j)) 125 return 1; 126 127 return sb->s_checksum_type == JBD2_CRC32C_CHKSUM; 128 } 129 130 static __be32 jbd2_superblock_csum(journal_t *j, journal_superblock_t *sb) 131 { 132 __u32 csum; 133 __be32 old_csum; 134 135 old_csum = sb->s_checksum; 136 sb->s_checksum = 0; 137 csum = jbd2_chksum(j, ~0, (char *)sb, sizeof(journal_superblock_t)); 138 sb->s_checksum = old_csum; 139 140 return cpu_to_be32(csum); 141 } 142 143 /* 144 * Helper function used to manage commit timeouts 145 */ 146 147 static void commit_timeout(struct timer_list *t) 148 { 149 journal_t *journal = from_timer(journal, t, j_commit_timer); 150 151 wake_up_process(journal->j_task); 152 } 153 154 /* 155 * kjournald2: The main thread function used to manage a logging device 156 * journal. 157 * 158 * This kernel thread is responsible for two things: 159 * 160 * 1) COMMIT: Every so often we need to commit the current state of the 161 * filesystem to disk. The journal thread is responsible for writing 162 * all of the metadata buffers to disk. If a fast commit is ongoing 163 * journal thread waits until it's done and then continues from 164 * there on. 165 * 166 * 2) CHECKPOINT: We cannot reuse a used section of the log file until all 167 * of the data in that part of the log has been rewritten elsewhere on 168 * the disk. Flushing these old buffers to reclaim space in the log is 169 * known as checkpointing, and this thread is responsible for that job. 170 */ 171 172 static int kjournald2(void *arg) 173 { 174 journal_t *journal = arg; 175 transaction_t *transaction; 176 177 /* 178 * Set up an interval timer which can be used to trigger a commit wakeup 179 * after the commit interval expires 180 */ 181 timer_setup(&journal->j_commit_timer, commit_timeout, 0); 182 183 set_freezable(); 184 185 /* Record that the journal thread is running */ 186 journal->j_task = current; 187 wake_up(&journal->j_wait_done_commit); 188 189 /* 190 * Make sure that no allocations from this kernel thread will ever 191 * recurse to the fs layer because we are responsible for the 192 * transaction commit and any fs involvement might get stuck waiting for 193 * the trasn. commit. 194 */ 195 memalloc_nofs_save(); 196 197 /* 198 * And now, wait forever for commit wakeup events. 199 */ 200 write_lock(&journal->j_state_lock); 201 202 loop: 203 if (journal->j_flags & JBD2_UNMOUNT) 204 goto end_loop; 205 206 jbd_debug(1, "commit_sequence=%u, commit_request=%u\n", 207 journal->j_commit_sequence, journal->j_commit_request); 208 209 if (journal->j_commit_sequence != journal->j_commit_request) { 210 jbd_debug(1, "OK, requests differ\n"); 211 write_unlock(&journal->j_state_lock); 212 del_timer_sync(&journal->j_commit_timer); 213 jbd2_journal_commit_transaction(journal); 214 write_lock(&journal->j_state_lock); 215 goto loop; 216 } 217 218 wake_up(&journal->j_wait_done_commit); 219 if (freezing(current)) { 220 /* 221 * The simpler the better. Flushing journal isn't a 222 * good idea, because that depends on threads that may 223 * be already stopped. 224 */ 225 jbd_debug(1, "Now suspending kjournald2\n"); 226 write_unlock(&journal->j_state_lock); 227 try_to_freeze(); 228 write_lock(&journal->j_state_lock); 229 } else { 230 /* 231 * We assume on resume that commits are already there, 232 * so we don't sleep 233 */ 234 DEFINE_WAIT(wait); 235 int should_sleep = 1; 236 237 prepare_to_wait(&journal->j_wait_commit, &wait, 238 TASK_INTERRUPTIBLE); 239 if (journal->j_commit_sequence != journal->j_commit_request) 240 should_sleep = 0; 241 transaction = journal->j_running_transaction; 242 if (transaction && time_after_eq(jiffies, 243 transaction->t_expires)) 244 should_sleep = 0; 245 if (journal->j_flags & JBD2_UNMOUNT) 246 should_sleep = 0; 247 if (should_sleep) { 248 write_unlock(&journal->j_state_lock); 249 schedule(); 250 write_lock(&journal->j_state_lock); 251 } 252 finish_wait(&journal->j_wait_commit, &wait); 253 } 254 255 jbd_debug(1, "kjournald2 wakes\n"); 256 257 /* 258 * Were we woken up by a commit wakeup event? 259 */ 260 transaction = journal->j_running_transaction; 261 if (transaction && time_after_eq(jiffies, transaction->t_expires)) { 262 journal->j_commit_request = transaction->t_tid; 263 jbd_debug(1, "woke because of timeout\n"); 264 } 265 goto loop; 266 267 end_loop: 268 del_timer_sync(&journal->j_commit_timer); 269 journal->j_task = NULL; 270 wake_up(&journal->j_wait_done_commit); 271 jbd_debug(1, "Journal thread exiting.\n"); 272 write_unlock(&journal->j_state_lock); 273 return 0; 274 } 275 276 static int jbd2_journal_start_thread(journal_t *journal) 277 { 278 struct task_struct *t; 279 280 t = kthread_run(kjournald2, journal, "jbd2/%s", 281 journal->j_devname); 282 if (IS_ERR(t)) 283 return PTR_ERR(t); 284 285 wait_event(journal->j_wait_done_commit, journal->j_task != NULL); 286 return 0; 287 } 288 289 static void journal_kill_thread(journal_t *journal) 290 { 291 write_lock(&journal->j_state_lock); 292 journal->j_flags |= JBD2_UNMOUNT; 293 294 while (journal->j_task) { 295 write_unlock(&journal->j_state_lock); 296 wake_up(&journal->j_wait_commit); 297 wait_event(journal->j_wait_done_commit, journal->j_task == NULL); 298 write_lock(&journal->j_state_lock); 299 } 300 write_unlock(&journal->j_state_lock); 301 } 302 303 /* 304 * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal. 305 * 306 * Writes a metadata buffer to a given disk block. The actual IO is not 307 * performed but a new buffer_head is constructed which labels the data 308 * to be written with the correct destination disk block. 309 * 310 * Any magic-number escaping which needs to be done will cause a 311 * copy-out here. If the buffer happens to start with the 312 * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the 313 * magic number is only written to the log for descripter blocks. In 314 * this case, we copy the data and replace the first word with 0, and we 315 * return a result code which indicates that this buffer needs to be 316 * marked as an escaped buffer in the corresponding log descriptor 317 * block. The missing word can then be restored when the block is read 318 * during recovery. 319 * 320 * If the source buffer has already been modified by a new transaction 321 * since we took the last commit snapshot, we use the frozen copy of 322 * that data for IO. If we end up using the existing buffer_head's data 323 * for the write, then we have to make sure nobody modifies it while the 324 * IO is in progress. do_get_write_access() handles this. 325 * 326 * The function returns a pointer to the buffer_head to be used for IO. 327 * 328 * 329 * Return value: 330 * <0: Error 331 * >=0: Finished OK 332 * 333 * On success: 334 * Bit 0 set == escape performed on the data 335 * Bit 1 set == buffer copy-out performed (kfree the data after IO) 336 */ 337 338 int jbd2_journal_write_metadata_buffer(transaction_t *transaction, 339 struct journal_head *jh_in, 340 struct buffer_head **bh_out, 341 sector_t blocknr) 342 { 343 int need_copy_out = 0; 344 int done_copy_out = 0; 345 int do_escape = 0; 346 char *mapped_data; 347 struct buffer_head *new_bh; 348 struct page *new_page; 349 unsigned int new_offset; 350 struct buffer_head *bh_in = jh2bh(jh_in); 351 journal_t *journal = transaction->t_journal; 352 353 /* 354 * The buffer really shouldn't be locked: only the current committing 355 * transaction is allowed to write it, so nobody else is allowed 356 * to do any IO. 357 * 358 * akpm: except if we're journalling data, and write() output is 359 * also part of a shared mapping, and another thread has 360 * decided to launch a writepage() against this buffer. 361 */ 362 J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in)); 363 364 new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL); 365 366 /* keep subsequent assertions sane */ 367 atomic_set(&new_bh->b_count, 1); 368 369 spin_lock(&jh_in->b_state_lock); 370 repeat: 371 /* 372 * If a new transaction has already done a buffer copy-out, then 373 * we use that version of the data for the commit. 374 */ 375 if (jh_in->b_frozen_data) { 376 done_copy_out = 1; 377 new_page = virt_to_page(jh_in->b_frozen_data); 378 new_offset = offset_in_page(jh_in->b_frozen_data); 379 } else { 380 new_page = jh2bh(jh_in)->b_page; 381 new_offset = offset_in_page(jh2bh(jh_in)->b_data); 382 } 383 384 mapped_data = kmap_atomic(new_page); 385 /* 386 * Fire data frozen trigger if data already wasn't frozen. Do this 387 * before checking for escaping, as the trigger may modify the magic 388 * offset. If a copy-out happens afterwards, it will have the correct 389 * data in the buffer. 390 */ 391 if (!done_copy_out) 392 jbd2_buffer_frozen_trigger(jh_in, mapped_data + new_offset, 393 jh_in->b_triggers); 394 395 /* 396 * Check for escaping 397 */ 398 if (*((__be32 *)(mapped_data + new_offset)) == 399 cpu_to_be32(JBD2_MAGIC_NUMBER)) { 400 need_copy_out = 1; 401 do_escape = 1; 402 } 403 kunmap_atomic(mapped_data); 404 405 /* 406 * Do we need to do a data copy? 407 */ 408 if (need_copy_out && !done_copy_out) { 409 char *tmp; 410 411 spin_unlock(&jh_in->b_state_lock); 412 tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS); 413 if (!tmp) { 414 brelse(new_bh); 415 return -ENOMEM; 416 } 417 spin_lock(&jh_in->b_state_lock); 418 if (jh_in->b_frozen_data) { 419 jbd2_free(tmp, bh_in->b_size); 420 goto repeat; 421 } 422 423 jh_in->b_frozen_data = tmp; 424 mapped_data = kmap_atomic(new_page); 425 memcpy(tmp, mapped_data + new_offset, bh_in->b_size); 426 kunmap_atomic(mapped_data); 427 428 new_page = virt_to_page(tmp); 429 new_offset = offset_in_page(tmp); 430 done_copy_out = 1; 431 432 /* 433 * This isn't strictly necessary, as we're using frozen 434 * data for the escaping, but it keeps consistency with 435 * b_frozen_data usage. 436 */ 437 jh_in->b_frozen_triggers = jh_in->b_triggers; 438 } 439 440 /* 441 * Did we need to do an escaping? Now we've done all the 442 * copying, we can finally do so. 443 */ 444 if (do_escape) { 445 mapped_data = kmap_atomic(new_page); 446 *((unsigned int *)(mapped_data + new_offset)) = 0; 447 kunmap_atomic(mapped_data); 448 } 449 450 set_bh_page(new_bh, new_page, new_offset); 451 new_bh->b_size = bh_in->b_size; 452 new_bh->b_bdev = journal->j_dev; 453 new_bh->b_blocknr = blocknr; 454 new_bh->b_private = bh_in; 455 set_buffer_mapped(new_bh); 456 set_buffer_dirty(new_bh); 457 458 *bh_out = new_bh; 459 460 /* 461 * The to-be-written buffer needs to get moved to the io queue, 462 * and the original buffer whose contents we are shadowing or 463 * copying is moved to the transaction's shadow queue. 464 */ 465 JBUFFER_TRACE(jh_in, "file as BJ_Shadow"); 466 spin_lock(&journal->j_list_lock); 467 __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow); 468 spin_unlock(&journal->j_list_lock); 469 set_buffer_shadow(bh_in); 470 spin_unlock(&jh_in->b_state_lock); 471 472 return do_escape | (done_copy_out << 1); 473 } 474 475 /* 476 * Allocation code for the journal file. Manage the space left in the 477 * journal, so that we can begin checkpointing when appropriate. 478 */ 479 480 /* 481 * Called with j_state_lock locked for writing. 482 * Returns true if a transaction commit was started. 483 */ 484 int __jbd2_log_start_commit(journal_t *journal, tid_t target) 485 { 486 /* Return if the txn has already requested to be committed */ 487 if (journal->j_commit_request == target) 488 return 0; 489 490 /* 491 * The only transaction we can possibly wait upon is the 492 * currently running transaction (if it exists). Otherwise, 493 * the target tid must be an old one. 494 */ 495 if (journal->j_running_transaction && 496 journal->j_running_transaction->t_tid == target) { 497 /* 498 * We want a new commit: OK, mark the request and wakeup the 499 * commit thread. We do _not_ do the commit ourselves. 500 */ 501 502 journal->j_commit_request = target; 503 jbd_debug(1, "JBD2: requesting commit %u/%u\n", 504 journal->j_commit_request, 505 journal->j_commit_sequence); 506 journal->j_running_transaction->t_requested = jiffies; 507 wake_up(&journal->j_wait_commit); 508 return 1; 509 } else if (!tid_geq(journal->j_commit_request, target)) 510 /* This should never happen, but if it does, preserve 511 the evidence before kjournald goes into a loop and 512 increments j_commit_sequence beyond all recognition. */ 513 WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n", 514 journal->j_commit_request, 515 journal->j_commit_sequence, 516 target, journal->j_running_transaction ? 517 journal->j_running_transaction->t_tid : 0); 518 return 0; 519 } 520 521 int jbd2_log_start_commit(journal_t *journal, tid_t tid) 522 { 523 int ret; 524 525 write_lock(&journal->j_state_lock); 526 ret = __jbd2_log_start_commit(journal, tid); 527 write_unlock(&journal->j_state_lock); 528 return ret; 529 } 530 531 /* 532 * Force and wait any uncommitted transactions. We can only force the running 533 * transaction if we don't have an active handle, otherwise, we will deadlock. 534 * Returns: <0 in case of error, 535 * 0 if nothing to commit, 536 * 1 if transaction was successfully committed. 537 */ 538 static int __jbd2_journal_force_commit(journal_t *journal) 539 { 540 transaction_t *transaction = NULL; 541 tid_t tid; 542 int need_to_start = 0, ret = 0; 543 544 read_lock(&journal->j_state_lock); 545 if (journal->j_running_transaction && !current->journal_info) { 546 transaction = journal->j_running_transaction; 547 if (!tid_geq(journal->j_commit_request, transaction->t_tid)) 548 need_to_start = 1; 549 } else if (journal->j_committing_transaction) 550 transaction = journal->j_committing_transaction; 551 552 if (!transaction) { 553 /* Nothing to commit */ 554 read_unlock(&journal->j_state_lock); 555 return 0; 556 } 557 tid = transaction->t_tid; 558 read_unlock(&journal->j_state_lock); 559 if (need_to_start) 560 jbd2_log_start_commit(journal, tid); 561 ret = jbd2_log_wait_commit(journal, tid); 562 if (!ret) 563 ret = 1; 564 565 return ret; 566 } 567 568 /** 569 * jbd2_journal_force_commit_nested - Force and wait upon a commit if the 570 * calling process is not within transaction. 571 * 572 * @journal: journal to force 573 * Returns true if progress was made. 574 * 575 * This is used for forcing out undo-protected data which contains 576 * bitmaps, when the fs is running out of space. 577 */ 578 int jbd2_journal_force_commit_nested(journal_t *journal) 579 { 580 int ret; 581 582 ret = __jbd2_journal_force_commit(journal); 583 return ret > 0; 584 } 585 586 /** 587 * jbd2_journal_force_commit() - force any uncommitted transactions 588 * @journal: journal to force 589 * 590 * Caller want unconditional commit. We can only force the running transaction 591 * if we don't have an active handle, otherwise, we will deadlock. 592 */ 593 int jbd2_journal_force_commit(journal_t *journal) 594 { 595 int ret; 596 597 J_ASSERT(!current->journal_info); 598 ret = __jbd2_journal_force_commit(journal); 599 if (ret > 0) 600 ret = 0; 601 return ret; 602 } 603 604 /* 605 * Start a commit of the current running transaction (if any). Returns true 606 * if a transaction is going to be committed (or is currently already 607 * committing), and fills its tid in at *ptid 608 */ 609 int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid) 610 { 611 int ret = 0; 612 613 write_lock(&journal->j_state_lock); 614 if (journal->j_running_transaction) { 615 tid_t tid = journal->j_running_transaction->t_tid; 616 617 __jbd2_log_start_commit(journal, tid); 618 /* There's a running transaction and we've just made sure 619 * it's commit has been scheduled. */ 620 if (ptid) 621 *ptid = tid; 622 ret = 1; 623 } else if (journal->j_committing_transaction) { 624 /* 625 * If commit has been started, then we have to wait for 626 * completion of that transaction. 627 */ 628 if (ptid) 629 *ptid = journal->j_committing_transaction->t_tid; 630 ret = 1; 631 } 632 write_unlock(&journal->j_state_lock); 633 return ret; 634 } 635 636 /* 637 * Return 1 if a given transaction has not yet sent barrier request 638 * connected with a transaction commit. If 0 is returned, transaction 639 * may or may not have sent the barrier. Used to avoid sending barrier 640 * twice in common cases. 641 */ 642 int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid) 643 { 644 int ret = 0; 645 transaction_t *commit_trans; 646 647 if (!(journal->j_flags & JBD2_BARRIER)) 648 return 0; 649 read_lock(&journal->j_state_lock); 650 /* Transaction already committed? */ 651 if (tid_geq(journal->j_commit_sequence, tid)) 652 goto out; 653 commit_trans = journal->j_committing_transaction; 654 if (!commit_trans || commit_trans->t_tid != tid) { 655 ret = 1; 656 goto out; 657 } 658 /* 659 * Transaction is being committed and we already proceeded to 660 * submitting a flush to fs partition? 661 */ 662 if (journal->j_fs_dev != journal->j_dev) { 663 if (!commit_trans->t_need_data_flush || 664 commit_trans->t_state >= T_COMMIT_DFLUSH) 665 goto out; 666 } else { 667 if (commit_trans->t_state >= T_COMMIT_JFLUSH) 668 goto out; 669 } 670 ret = 1; 671 out: 672 read_unlock(&journal->j_state_lock); 673 return ret; 674 } 675 EXPORT_SYMBOL(jbd2_trans_will_send_data_barrier); 676 677 /* 678 * Wait for a specified commit to complete. 679 * The caller may not hold the journal lock. 680 */ 681 int jbd2_log_wait_commit(journal_t *journal, tid_t tid) 682 { 683 int err = 0; 684 685 read_lock(&journal->j_state_lock); 686 #ifdef CONFIG_PROVE_LOCKING 687 /* 688 * Some callers make sure transaction is already committing and in that 689 * case we cannot block on open handles anymore. So don't warn in that 690 * case. 691 */ 692 if (tid_gt(tid, journal->j_commit_sequence) && 693 (!journal->j_committing_transaction || 694 journal->j_committing_transaction->t_tid != tid)) { 695 read_unlock(&journal->j_state_lock); 696 jbd2_might_wait_for_commit(journal); 697 read_lock(&journal->j_state_lock); 698 } 699 #endif 700 #ifdef CONFIG_JBD2_DEBUG 701 if (!tid_geq(journal->j_commit_request, tid)) { 702 printk(KERN_ERR 703 "%s: error: j_commit_request=%u, tid=%u\n", 704 __func__, journal->j_commit_request, tid); 705 } 706 #endif 707 while (tid_gt(tid, journal->j_commit_sequence)) { 708 jbd_debug(1, "JBD2: want %u, j_commit_sequence=%u\n", 709 tid, journal->j_commit_sequence); 710 read_unlock(&journal->j_state_lock); 711 wake_up(&journal->j_wait_commit); 712 wait_event(journal->j_wait_done_commit, 713 !tid_gt(tid, journal->j_commit_sequence)); 714 read_lock(&journal->j_state_lock); 715 } 716 read_unlock(&journal->j_state_lock); 717 718 if (unlikely(is_journal_aborted(journal))) 719 err = -EIO; 720 return err; 721 } 722 723 /* 724 * Start a fast commit. If there's an ongoing fast or full commit wait for 725 * it to complete. Returns 0 if a new fast commit was started. Returns -EALREADY 726 * if a fast commit is not needed, either because there's an already a commit 727 * going on or this tid has already been committed. Returns -EINVAL if no jbd2 728 * commit has yet been performed. 729 */ 730 int jbd2_fc_begin_commit(journal_t *journal, tid_t tid) 731 { 732 if (unlikely(is_journal_aborted(journal))) 733 return -EIO; 734 /* 735 * Fast commits only allowed if at least one full commit has 736 * been processed. 737 */ 738 if (!journal->j_stats.ts_tid) 739 return -EINVAL; 740 741 write_lock(&journal->j_state_lock); 742 if (tid <= journal->j_commit_sequence) { 743 write_unlock(&journal->j_state_lock); 744 return -EALREADY; 745 } 746 747 if (journal->j_flags & JBD2_FULL_COMMIT_ONGOING || 748 (journal->j_flags & JBD2_FAST_COMMIT_ONGOING)) { 749 DEFINE_WAIT(wait); 750 751 prepare_to_wait(&journal->j_fc_wait, &wait, 752 TASK_UNINTERRUPTIBLE); 753 write_unlock(&journal->j_state_lock); 754 schedule(); 755 finish_wait(&journal->j_fc_wait, &wait); 756 return -EALREADY; 757 } 758 journal->j_flags |= JBD2_FAST_COMMIT_ONGOING; 759 write_unlock(&journal->j_state_lock); 760 761 return 0; 762 } 763 EXPORT_SYMBOL(jbd2_fc_begin_commit); 764 765 /* 766 * Stop a fast commit. If fallback is set, this function starts commit of 767 * TID tid before any other fast commit can start. 768 */ 769 static int __jbd2_fc_end_commit(journal_t *journal, tid_t tid, bool fallback) 770 { 771 if (journal->j_fc_cleanup_callback) 772 journal->j_fc_cleanup_callback(journal, 0); 773 write_lock(&journal->j_state_lock); 774 journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING; 775 if (fallback) 776 journal->j_flags |= JBD2_FULL_COMMIT_ONGOING; 777 write_unlock(&journal->j_state_lock); 778 wake_up(&journal->j_fc_wait); 779 if (fallback) 780 return jbd2_complete_transaction(journal, tid); 781 return 0; 782 } 783 784 int jbd2_fc_end_commit(journal_t *journal) 785 { 786 return __jbd2_fc_end_commit(journal, 0, false); 787 } 788 EXPORT_SYMBOL(jbd2_fc_end_commit); 789 790 int jbd2_fc_end_commit_fallback(journal_t *journal) 791 { 792 tid_t tid; 793 794 read_lock(&journal->j_state_lock); 795 tid = journal->j_running_transaction ? 796 journal->j_running_transaction->t_tid : 0; 797 read_unlock(&journal->j_state_lock); 798 return __jbd2_fc_end_commit(journal, tid, true); 799 } 800 EXPORT_SYMBOL(jbd2_fc_end_commit_fallback); 801 802 /* Return 1 when transaction with given tid has already committed. */ 803 int jbd2_transaction_committed(journal_t *journal, tid_t tid) 804 { 805 int ret = 1; 806 807 read_lock(&journal->j_state_lock); 808 if (journal->j_running_transaction && 809 journal->j_running_transaction->t_tid == tid) 810 ret = 0; 811 if (journal->j_committing_transaction && 812 journal->j_committing_transaction->t_tid == tid) 813 ret = 0; 814 read_unlock(&journal->j_state_lock); 815 return ret; 816 } 817 EXPORT_SYMBOL(jbd2_transaction_committed); 818 819 /* 820 * When this function returns the transaction corresponding to tid 821 * will be completed. If the transaction has currently running, start 822 * committing that transaction before waiting for it to complete. If 823 * the transaction id is stale, it is by definition already completed, 824 * so just return SUCCESS. 825 */ 826 int jbd2_complete_transaction(journal_t *journal, tid_t tid) 827 { 828 int need_to_wait = 1; 829 830 read_lock(&journal->j_state_lock); 831 if (journal->j_running_transaction && 832 journal->j_running_transaction->t_tid == tid) { 833 if (journal->j_commit_request != tid) { 834 /* transaction not yet started, so request it */ 835 read_unlock(&journal->j_state_lock); 836 jbd2_log_start_commit(journal, tid); 837 goto wait_commit; 838 } 839 } else if (!(journal->j_committing_transaction && 840 journal->j_committing_transaction->t_tid == tid)) 841 need_to_wait = 0; 842 read_unlock(&journal->j_state_lock); 843 if (!need_to_wait) 844 return 0; 845 wait_commit: 846 return jbd2_log_wait_commit(journal, tid); 847 } 848 EXPORT_SYMBOL(jbd2_complete_transaction); 849 850 /* 851 * Log buffer allocation routines: 852 */ 853 854 int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp) 855 { 856 unsigned long blocknr; 857 858 write_lock(&journal->j_state_lock); 859 J_ASSERT(journal->j_free > 1); 860 861 blocknr = journal->j_head; 862 journal->j_head++; 863 journal->j_free--; 864 if (journal->j_head == journal->j_last) 865 journal->j_head = journal->j_first; 866 write_unlock(&journal->j_state_lock); 867 return jbd2_journal_bmap(journal, blocknr, retp); 868 } 869 870 /* Map one fast commit buffer for use by the file system */ 871 int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out) 872 { 873 unsigned long long pblock; 874 unsigned long blocknr; 875 int ret = 0; 876 struct buffer_head *bh; 877 int fc_off; 878 879 *bh_out = NULL; 880 881 if (journal->j_fc_off + journal->j_fc_first < journal->j_fc_last) { 882 fc_off = journal->j_fc_off; 883 blocknr = journal->j_fc_first + fc_off; 884 journal->j_fc_off++; 885 } else { 886 ret = -EINVAL; 887 } 888 889 if (ret) 890 return ret; 891 892 ret = jbd2_journal_bmap(journal, blocknr, &pblock); 893 if (ret) 894 return ret; 895 896 bh = __getblk(journal->j_dev, pblock, journal->j_blocksize); 897 if (!bh) 898 return -ENOMEM; 899 900 901 journal->j_fc_wbuf[fc_off] = bh; 902 903 *bh_out = bh; 904 905 return 0; 906 } 907 EXPORT_SYMBOL(jbd2_fc_get_buf); 908 909 /* 910 * Wait on fast commit buffers that were allocated by jbd2_fc_get_buf 911 * for completion. 912 */ 913 int jbd2_fc_wait_bufs(journal_t *journal, int num_blks) 914 { 915 struct buffer_head *bh; 916 int i, j_fc_off; 917 918 j_fc_off = journal->j_fc_off; 919 920 /* 921 * Wait in reverse order to minimize chances of us being woken up before 922 * all IOs have completed 923 */ 924 for (i = j_fc_off - 1; i >= j_fc_off - num_blks; i--) { 925 bh = journal->j_fc_wbuf[i]; 926 wait_on_buffer(bh); 927 put_bh(bh); 928 journal->j_fc_wbuf[i] = NULL; 929 if (unlikely(!buffer_uptodate(bh))) 930 return -EIO; 931 } 932 933 return 0; 934 } 935 EXPORT_SYMBOL(jbd2_fc_wait_bufs); 936 937 int jbd2_fc_release_bufs(journal_t *journal) 938 { 939 struct buffer_head *bh; 940 int i, j_fc_off; 941 942 j_fc_off = journal->j_fc_off; 943 944 for (i = j_fc_off - 1; i >= 0; i--) { 945 bh = journal->j_fc_wbuf[i]; 946 if (!bh) 947 break; 948 put_bh(bh); 949 journal->j_fc_wbuf[i] = NULL; 950 } 951 952 return 0; 953 } 954 EXPORT_SYMBOL(jbd2_fc_release_bufs); 955 956 /* 957 * Conversion of logical to physical block numbers for the journal 958 * 959 * On external journals the journal blocks are identity-mapped, so 960 * this is a no-op. If needed, we can use j_blk_offset - everything is 961 * ready. 962 */ 963 int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr, 964 unsigned long long *retp) 965 { 966 int err = 0; 967 unsigned long long ret; 968 sector_t block = 0; 969 970 if (journal->j_inode) { 971 block = blocknr; 972 ret = bmap(journal->j_inode, &block); 973 974 if (ret || !block) { 975 printk(KERN_ALERT "%s: journal block not found " 976 "at offset %lu on %s\n", 977 __func__, blocknr, journal->j_devname); 978 err = -EIO; 979 jbd2_journal_abort(journal, err); 980 } else { 981 *retp = block; 982 } 983 984 } else { 985 *retp = blocknr; /* +journal->j_blk_offset */ 986 } 987 return err; 988 } 989 990 /* 991 * We play buffer_head aliasing tricks to write data/metadata blocks to 992 * the journal without copying their contents, but for journal 993 * descriptor blocks we do need to generate bona fide buffers. 994 * 995 * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying 996 * the buffer's contents they really should run flush_dcache_page(bh->b_page). 997 * But we don't bother doing that, so there will be coherency problems with 998 * mmaps of blockdevs which hold live JBD-controlled filesystems. 999 */ 1000 struct buffer_head * 1001 jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type) 1002 { 1003 journal_t *journal = transaction->t_journal; 1004 struct buffer_head *bh; 1005 unsigned long long blocknr; 1006 journal_header_t *header; 1007 int err; 1008 1009 err = jbd2_journal_next_log_block(journal, &blocknr); 1010 1011 if (err) 1012 return NULL; 1013 1014 bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize); 1015 if (!bh) 1016 return NULL; 1017 atomic_dec(&transaction->t_outstanding_credits); 1018 lock_buffer(bh); 1019 memset(bh->b_data, 0, journal->j_blocksize); 1020 header = (journal_header_t *)bh->b_data; 1021 header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER); 1022 header->h_blocktype = cpu_to_be32(type); 1023 header->h_sequence = cpu_to_be32(transaction->t_tid); 1024 set_buffer_uptodate(bh); 1025 unlock_buffer(bh); 1026 BUFFER_TRACE(bh, "return this buffer"); 1027 return bh; 1028 } 1029 1030 void jbd2_descriptor_block_csum_set(journal_t *j, struct buffer_head *bh) 1031 { 1032 struct jbd2_journal_block_tail *tail; 1033 __u32 csum; 1034 1035 if (!jbd2_journal_has_csum_v2or3(j)) 1036 return; 1037 1038 tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize - 1039 sizeof(struct jbd2_journal_block_tail)); 1040 tail->t_checksum = 0; 1041 csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize); 1042 tail->t_checksum = cpu_to_be32(csum); 1043 } 1044 1045 /* 1046 * Return tid of the oldest transaction in the journal and block in the journal 1047 * where the transaction starts. 1048 * 1049 * If the journal is now empty, return which will be the next transaction ID 1050 * we will write and where will that transaction start. 1051 * 1052 * The return value is 0 if journal tail cannot be pushed any further, 1 if 1053 * it can. 1054 */ 1055 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid, 1056 unsigned long *block) 1057 { 1058 transaction_t *transaction; 1059 int ret; 1060 1061 read_lock(&journal->j_state_lock); 1062 spin_lock(&journal->j_list_lock); 1063 transaction = journal->j_checkpoint_transactions; 1064 if (transaction) { 1065 *tid = transaction->t_tid; 1066 *block = transaction->t_log_start; 1067 } else if ((transaction = journal->j_committing_transaction) != NULL) { 1068 *tid = transaction->t_tid; 1069 *block = transaction->t_log_start; 1070 } else if ((transaction = journal->j_running_transaction) != NULL) { 1071 *tid = transaction->t_tid; 1072 *block = journal->j_head; 1073 } else { 1074 *tid = journal->j_transaction_sequence; 1075 *block = journal->j_head; 1076 } 1077 ret = tid_gt(*tid, journal->j_tail_sequence); 1078 spin_unlock(&journal->j_list_lock); 1079 read_unlock(&journal->j_state_lock); 1080 1081 return ret; 1082 } 1083 1084 /* 1085 * Update information in journal structure and in on disk journal superblock 1086 * about log tail. This function does not check whether information passed in 1087 * really pushes log tail further. It's responsibility of the caller to make 1088 * sure provided log tail information is valid (e.g. by holding 1089 * j_checkpoint_mutex all the time between computing log tail and calling this 1090 * function as is the case with jbd2_cleanup_journal_tail()). 1091 * 1092 * Requires j_checkpoint_mutex 1093 */ 1094 int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) 1095 { 1096 unsigned long freed; 1097 int ret; 1098 1099 BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); 1100 1101 /* 1102 * We cannot afford for write to remain in drive's caches since as 1103 * soon as we update j_tail, next transaction can start reusing journal 1104 * space and if we lose sb update during power failure we'd replay 1105 * old transaction with possibly newly overwritten data. 1106 */ 1107 ret = jbd2_journal_update_sb_log_tail(journal, tid, block, 1108 REQ_SYNC | REQ_FUA); 1109 if (ret) 1110 goto out; 1111 1112 write_lock(&journal->j_state_lock); 1113 freed = block - journal->j_tail; 1114 if (block < journal->j_tail) 1115 freed += journal->j_last - journal->j_first; 1116 1117 trace_jbd2_update_log_tail(journal, tid, block, freed); 1118 jbd_debug(1, 1119 "Cleaning journal tail from %u to %u (offset %lu), " 1120 "freeing %lu\n", 1121 journal->j_tail_sequence, tid, block, freed); 1122 1123 journal->j_free += freed; 1124 journal->j_tail_sequence = tid; 1125 journal->j_tail = block; 1126 write_unlock(&journal->j_state_lock); 1127 1128 out: 1129 return ret; 1130 } 1131 1132 /* 1133 * This is a variation of __jbd2_update_log_tail which checks for validity of 1134 * provided log tail and locks j_checkpoint_mutex. So it is safe against races 1135 * with other threads updating log tail. 1136 */ 1137 void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) 1138 { 1139 mutex_lock_io(&journal->j_checkpoint_mutex); 1140 if (tid_gt(tid, journal->j_tail_sequence)) 1141 __jbd2_update_log_tail(journal, tid, block); 1142 mutex_unlock(&journal->j_checkpoint_mutex); 1143 } 1144 1145 struct jbd2_stats_proc_session { 1146 journal_t *journal; 1147 struct transaction_stats_s *stats; 1148 int start; 1149 int max; 1150 }; 1151 1152 static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos) 1153 { 1154 return *pos ? NULL : SEQ_START_TOKEN; 1155 } 1156 1157 static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos) 1158 { 1159 (*pos)++; 1160 return NULL; 1161 } 1162 1163 static int jbd2_seq_info_show(struct seq_file *seq, void *v) 1164 { 1165 struct jbd2_stats_proc_session *s = seq->private; 1166 1167 if (v != SEQ_START_TOKEN) 1168 return 0; 1169 seq_printf(seq, "%lu transactions (%lu requested), " 1170 "each up to %u blocks\n", 1171 s->stats->ts_tid, s->stats->ts_requested, 1172 s->journal->j_max_transaction_buffers); 1173 if (s->stats->ts_tid == 0) 1174 return 0; 1175 seq_printf(seq, "average: \n %ums waiting for transaction\n", 1176 jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid)); 1177 seq_printf(seq, " %ums request delay\n", 1178 (s->stats->ts_requested == 0) ? 0 : 1179 jiffies_to_msecs(s->stats->run.rs_request_delay / 1180 s->stats->ts_requested)); 1181 seq_printf(seq, " %ums running transaction\n", 1182 jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid)); 1183 seq_printf(seq, " %ums transaction was being locked\n", 1184 jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid)); 1185 seq_printf(seq, " %ums flushing data (in ordered mode)\n", 1186 jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid)); 1187 seq_printf(seq, " %ums logging transaction\n", 1188 jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid)); 1189 seq_printf(seq, " %lluus average transaction commit time\n", 1190 div_u64(s->journal->j_average_commit_time, 1000)); 1191 seq_printf(seq, " %lu handles per transaction\n", 1192 s->stats->run.rs_handle_count / s->stats->ts_tid); 1193 seq_printf(seq, " %lu blocks per transaction\n", 1194 s->stats->run.rs_blocks / s->stats->ts_tid); 1195 seq_printf(seq, " %lu logged blocks per transaction\n", 1196 s->stats->run.rs_blocks_logged / s->stats->ts_tid); 1197 return 0; 1198 } 1199 1200 static void jbd2_seq_info_stop(struct seq_file *seq, void *v) 1201 { 1202 } 1203 1204 static const struct seq_operations jbd2_seq_info_ops = { 1205 .start = jbd2_seq_info_start, 1206 .next = jbd2_seq_info_next, 1207 .stop = jbd2_seq_info_stop, 1208 .show = jbd2_seq_info_show, 1209 }; 1210 1211 static int jbd2_seq_info_open(struct inode *inode, struct file *file) 1212 { 1213 journal_t *journal = PDE_DATA(inode); 1214 struct jbd2_stats_proc_session *s; 1215 int rc, size; 1216 1217 s = kmalloc(sizeof(*s), GFP_KERNEL); 1218 if (s == NULL) 1219 return -ENOMEM; 1220 size = sizeof(struct transaction_stats_s); 1221 s->stats = kmalloc(size, GFP_KERNEL); 1222 if (s->stats == NULL) { 1223 kfree(s); 1224 return -ENOMEM; 1225 } 1226 spin_lock(&journal->j_history_lock); 1227 memcpy(s->stats, &journal->j_stats, size); 1228 s->journal = journal; 1229 spin_unlock(&journal->j_history_lock); 1230 1231 rc = seq_open(file, &jbd2_seq_info_ops); 1232 if (rc == 0) { 1233 struct seq_file *m = file->private_data; 1234 m->private = s; 1235 } else { 1236 kfree(s->stats); 1237 kfree(s); 1238 } 1239 return rc; 1240 1241 } 1242 1243 static int jbd2_seq_info_release(struct inode *inode, struct file *file) 1244 { 1245 struct seq_file *seq = file->private_data; 1246 struct jbd2_stats_proc_session *s = seq->private; 1247 kfree(s->stats); 1248 kfree(s); 1249 return seq_release(inode, file); 1250 } 1251 1252 static const struct proc_ops jbd2_info_proc_ops = { 1253 .proc_open = jbd2_seq_info_open, 1254 .proc_read = seq_read, 1255 .proc_lseek = seq_lseek, 1256 .proc_release = jbd2_seq_info_release, 1257 }; 1258 1259 static struct proc_dir_entry *proc_jbd2_stats; 1260 1261 static void jbd2_stats_proc_init(journal_t *journal) 1262 { 1263 journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats); 1264 if (journal->j_proc_entry) { 1265 proc_create_data("info", S_IRUGO, journal->j_proc_entry, 1266 &jbd2_info_proc_ops, journal); 1267 } 1268 } 1269 1270 static void jbd2_stats_proc_exit(journal_t *journal) 1271 { 1272 remove_proc_entry("info", journal->j_proc_entry); 1273 remove_proc_entry(journal->j_devname, proc_jbd2_stats); 1274 } 1275 1276 /* Minimum size of descriptor tag */ 1277 static int jbd2_min_tag_size(void) 1278 { 1279 /* 1280 * Tag with 32-bit block numbers does not use last four bytes of the 1281 * structure 1282 */ 1283 return sizeof(journal_block_tag_t) - 4; 1284 } 1285 1286 /* 1287 * Management for journal control blocks: functions to create and 1288 * destroy journal_t structures, and to initialise and read existing 1289 * journal blocks from disk. */ 1290 1291 /* First: create and setup a journal_t object in memory. We initialise 1292 * very few fields yet: that has to wait until we have created the 1293 * journal structures from from scratch, or loaded them from disk. */ 1294 1295 static journal_t *journal_init_common(struct block_device *bdev, 1296 struct block_device *fs_dev, 1297 unsigned long long start, int len, int blocksize) 1298 { 1299 static struct lock_class_key jbd2_trans_commit_key; 1300 journal_t *journal; 1301 int err; 1302 struct buffer_head *bh; 1303 int n; 1304 1305 journal = kzalloc(sizeof(*journal), GFP_KERNEL); 1306 if (!journal) 1307 return NULL; 1308 1309 init_waitqueue_head(&journal->j_wait_transaction_locked); 1310 init_waitqueue_head(&journal->j_wait_done_commit); 1311 init_waitqueue_head(&journal->j_wait_commit); 1312 init_waitqueue_head(&journal->j_wait_updates); 1313 init_waitqueue_head(&journal->j_wait_reserved); 1314 init_waitqueue_head(&journal->j_fc_wait); 1315 mutex_init(&journal->j_abort_mutex); 1316 mutex_init(&journal->j_barrier); 1317 mutex_init(&journal->j_checkpoint_mutex); 1318 spin_lock_init(&journal->j_revoke_lock); 1319 spin_lock_init(&journal->j_list_lock); 1320 rwlock_init(&journal->j_state_lock); 1321 1322 journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE); 1323 journal->j_min_batch_time = 0; 1324 journal->j_max_batch_time = 15000; /* 15ms */ 1325 atomic_set(&journal->j_reserved_credits, 0); 1326 1327 /* The journal is marked for error until we succeed with recovery! */ 1328 journal->j_flags = JBD2_ABORT; 1329 1330 /* Set up a default-sized revoke table for the new mount. */ 1331 err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH); 1332 if (err) 1333 goto err_cleanup; 1334 1335 spin_lock_init(&journal->j_history_lock); 1336 1337 lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle", 1338 &jbd2_trans_commit_key, 0); 1339 1340 /* journal descriptor can store up to n blocks -bzzz */ 1341 journal->j_blocksize = blocksize; 1342 journal->j_dev = bdev; 1343 journal->j_fs_dev = fs_dev; 1344 journal->j_blk_offset = start; 1345 journal->j_total_len = len; 1346 /* We need enough buffers to write out full descriptor block. */ 1347 n = journal->j_blocksize / jbd2_min_tag_size(); 1348 journal->j_wbufsize = n; 1349 journal->j_fc_wbuf = NULL; 1350 journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *), 1351 GFP_KERNEL); 1352 if (!journal->j_wbuf) 1353 goto err_cleanup; 1354 1355 bh = getblk_unmovable(journal->j_dev, start, journal->j_blocksize); 1356 if (!bh) { 1357 pr_err("%s: Cannot get buffer for journal superblock\n", 1358 __func__); 1359 goto err_cleanup; 1360 } 1361 journal->j_sb_buffer = bh; 1362 journal->j_superblock = (journal_superblock_t *)bh->b_data; 1363 1364 return journal; 1365 1366 err_cleanup: 1367 kfree(journal->j_wbuf); 1368 jbd2_journal_destroy_revoke(journal); 1369 kfree(journal); 1370 return NULL; 1371 } 1372 1373 /* jbd2_journal_init_dev and jbd2_journal_init_inode: 1374 * 1375 * Create a journal structure assigned some fixed set of disk blocks to 1376 * the journal. We don't actually touch those disk blocks yet, but we 1377 * need to set up all of the mapping information to tell the journaling 1378 * system where the journal blocks are. 1379 * 1380 */ 1381 1382 /** 1383 * journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure 1384 * @bdev: Block device on which to create the journal 1385 * @fs_dev: Device which hold journalled filesystem for this journal. 1386 * @start: Block nr Start of journal. 1387 * @len: Length of the journal in blocks. 1388 * @blocksize: blocksize of journalling device 1389 * 1390 * Returns: a newly created journal_t * 1391 * 1392 * jbd2_journal_init_dev creates a journal which maps a fixed contiguous 1393 * range of blocks on an arbitrary block device. 1394 * 1395 */ 1396 journal_t *jbd2_journal_init_dev(struct block_device *bdev, 1397 struct block_device *fs_dev, 1398 unsigned long long start, int len, int blocksize) 1399 { 1400 journal_t *journal; 1401 1402 journal = journal_init_common(bdev, fs_dev, start, len, blocksize); 1403 if (!journal) 1404 return NULL; 1405 1406 bdevname(journal->j_dev, journal->j_devname); 1407 strreplace(journal->j_devname, '/', '!'); 1408 jbd2_stats_proc_init(journal); 1409 1410 return journal; 1411 } 1412 1413 /** 1414 * journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode. 1415 * @inode: An inode to create the journal in 1416 * 1417 * jbd2_journal_init_inode creates a journal which maps an on-disk inode as 1418 * the journal. The inode must exist already, must support bmap() and 1419 * must have all data blocks preallocated. 1420 */ 1421 journal_t *jbd2_journal_init_inode(struct inode *inode) 1422 { 1423 journal_t *journal; 1424 sector_t blocknr; 1425 char *p; 1426 int err = 0; 1427 1428 blocknr = 0; 1429 err = bmap(inode, &blocknr); 1430 1431 if (err || !blocknr) { 1432 pr_err("%s: Cannot locate journal superblock\n", 1433 __func__); 1434 return NULL; 1435 } 1436 1437 jbd_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n", 1438 inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size, 1439 inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize); 1440 1441 journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev, 1442 blocknr, inode->i_size >> inode->i_sb->s_blocksize_bits, 1443 inode->i_sb->s_blocksize); 1444 if (!journal) 1445 return NULL; 1446 1447 journal->j_inode = inode; 1448 bdevname(journal->j_dev, journal->j_devname); 1449 p = strreplace(journal->j_devname, '/', '!'); 1450 sprintf(p, "-%lu", journal->j_inode->i_ino); 1451 jbd2_stats_proc_init(journal); 1452 1453 return journal; 1454 } 1455 1456 /* 1457 * If the journal init or create aborts, we need to mark the journal 1458 * superblock as being NULL to prevent the journal destroy from writing 1459 * back a bogus superblock. 1460 */ 1461 static void journal_fail_superblock(journal_t *journal) 1462 { 1463 struct buffer_head *bh = journal->j_sb_buffer; 1464 brelse(bh); 1465 journal->j_sb_buffer = NULL; 1466 } 1467 1468 /* 1469 * Given a journal_t structure, initialise the various fields for 1470 * startup of a new journaling session. We use this both when creating 1471 * a journal, and after recovering an old journal to reset it for 1472 * subsequent use. 1473 */ 1474 1475 static int journal_reset(journal_t *journal) 1476 { 1477 journal_superblock_t *sb = journal->j_superblock; 1478 unsigned long long first, last; 1479 1480 first = be32_to_cpu(sb->s_first); 1481 last = be32_to_cpu(sb->s_maxlen); 1482 if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) { 1483 printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n", 1484 first, last); 1485 journal_fail_superblock(journal); 1486 return -EINVAL; 1487 } 1488 1489 journal->j_first = first; 1490 journal->j_last = last; 1491 1492 journal->j_head = journal->j_first; 1493 journal->j_tail = journal->j_first; 1494 journal->j_free = journal->j_last - journal->j_first; 1495 1496 journal->j_tail_sequence = journal->j_transaction_sequence; 1497 journal->j_commit_sequence = journal->j_transaction_sequence - 1; 1498 journal->j_commit_request = journal->j_commit_sequence; 1499 1500 journal->j_max_transaction_buffers = jbd2_journal_get_max_txn_bufs(journal); 1501 1502 /* 1503 * Now that journal recovery is done, turn fast commits off here. This 1504 * way, if fast commit was enabled before the crash but if now FS has 1505 * disabled it, we don't enable fast commits. 1506 */ 1507 jbd2_clear_feature_fast_commit(journal); 1508 1509 /* 1510 * As a special case, if the on-disk copy is already marked as needing 1511 * no recovery (s_start == 0), then we can safely defer the superblock 1512 * update until the next commit by setting JBD2_FLUSHED. This avoids 1513 * attempting a write to a potential-readonly device. 1514 */ 1515 if (sb->s_start == 0) { 1516 jbd_debug(1, "JBD2: Skipping superblock update on recovered sb " 1517 "(start %ld, seq %u, errno %d)\n", 1518 journal->j_tail, journal->j_tail_sequence, 1519 journal->j_errno); 1520 journal->j_flags |= JBD2_FLUSHED; 1521 } else { 1522 /* Lock here to make assertions happy... */ 1523 mutex_lock_io(&journal->j_checkpoint_mutex); 1524 /* 1525 * Update log tail information. We use REQ_FUA since new 1526 * transaction will start reusing journal space and so we 1527 * must make sure information about current log tail is on 1528 * disk before that. 1529 */ 1530 jbd2_journal_update_sb_log_tail(journal, 1531 journal->j_tail_sequence, 1532 journal->j_tail, 1533 REQ_SYNC | REQ_FUA); 1534 mutex_unlock(&journal->j_checkpoint_mutex); 1535 } 1536 return jbd2_journal_start_thread(journal); 1537 } 1538 1539 /* 1540 * This function expects that the caller will have locked the journal 1541 * buffer head, and will return with it unlocked 1542 */ 1543 static int jbd2_write_superblock(journal_t *journal, int write_flags) 1544 { 1545 struct buffer_head *bh = journal->j_sb_buffer; 1546 journal_superblock_t *sb = journal->j_superblock; 1547 int ret; 1548 1549 /* Buffer got discarded which means block device got invalidated */ 1550 if (!buffer_mapped(bh)) { 1551 unlock_buffer(bh); 1552 return -EIO; 1553 } 1554 1555 trace_jbd2_write_superblock(journal, write_flags); 1556 if (!(journal->j_flags & JBD2_BARRIER)) 1557 write_flags &= ~(REQ_FUA | REQ_PREFLUSH); 1558 if (buffer_write_io_error(bh)) { 1559 /* 1560 * Oh, dear. A previous attempt to write the journal 1561 * superblock failed. This could happen because the 1562 * USB device was yanked out. Or it could happen to 1563 * be a transient write error and maybe the block will 1564 * be remapped. Nothing we can do but to retry the 1565 * write and hope for the best. 1566 */ 1567 printk(KERN_ERR "JBD2: previous I/O error detected " 1568 "for journal superblock update for %s.\n", 1569 journal->j_devname); 1570 clear_buffer_write_io_error(bh); 1571 set_buffer_uptodate(bh); 1572 } 1573 if (jbd2_journal_has_csum_v2or3(journal)) 1574 sb->s_checksum = jbd2_superblock_csum(journal, sb); 1575 get_bh(bh); 1576 bh->b_end_io = end_buffer_write_sync; 1577 ret = submit_bh(REQ_OP_WRITE, write_flags, bh); 1578 wait_on_buffer(bh); 1579 if (buffer_write_io_error(bh)) { 1580 clear_buffer_write_io_error(bh); 1581 set_buffer_uptodate(bh); 1582 ret = -EIO; 1583 } 1584 if (ret) { 1585 printk(KERN_ERR "JBD2: Error %d detected when updating " 1586 "journal superblock for %s.\n", ret, 1587 journal->j_devname); 1588 if (!is_journal_aborted(journal)) 1589 jbd2_journal_abort(journal, ret); 1590 } 1591 1592 return ret; 1593 } 1594 1595 /** 1596 * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk. 1597 * @journal: The journal to update. 1598 * @tail_tid: TID of the new transaction at the tail of the log 1599 * @tail_block: The first block of the transaction at the tail of the log 1600 * @write_op: With which operation should we write the journal sb 1601 * 1602 * Update a journal's superblock information about log tail and write it to 1603 * disk, waiting for the IO to complete. 1604 */ 1605 int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid, 1606 unsigned long tail_block, int write_op) 1607 { 1608 journal_superblock_t *sb = journal->j_superblock; 1609 int ret; 1610 1611 if (is_journal_aborted(journal)) 1612 return -EIO; 1613 if (test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) { 1614 jbd2_journal_abort(journal, -EIO); 1615 return -EIO; 1616 } 1617 1618 BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); 1619 jbd_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n", 1620 tail_block, tail_tid); 1621 1622 lock_buffer(journal->j_sb_buffer); 1623 sb->s_sequence = cpu_to_be32(tail_tid); 1624 sb->s_start = cpu_to_be32(tail_block); 1625 1626 ret = jbd2_write_superblock(journal, write_op); 1627 if (ret) 1628 goto out; 1629 1630 /* Log is no longer empty */ 1631 write_lock(&journal->j_state_lock); 1632 WARN_ON(!sb->s_sequence); 1633 journal->j_flags &= ~JBD2_FLUSHED; 1634 write_unlock(&journal->j_state_lock); 1635 1636 out: 1637 return ret; 1638 } 1639 1640 /** 1641 * jbd2_mark_journal_empty() - Mark on disk journal as empty. 1642 * @journal: The journal to update. 1643 * @write_op: With which operation should we write the journal sb 1644 * 1645 * Update a journal's dynamic superblock fields to show that journal is empty. 1646 * Write updated superblock to disk waiting for IO to complete. 1647 */ 1648 static void jbd2_mark_journal_empty(journal_t *journal, int write_op) 1649 { 1650 journal_superblock_t *sb = journal->j_superblock; 1651 bool had_fast_commit = false; 1652 1653 BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); 1654 lock_buffer(journal->j_sb_buffer); 1655 if (sb->s_start == 0) { /* Is it already empty? */ 1656 unlock_buffer(journal->j_sb_buffer); 1657 return; 1658 } 1659 1660 jbd_debug(1, "JBD2: Marking journal as empty (seq %u)\n", 1661 journal->j_tail_sequence); 1662 1663 sb->s_sequence = cpu_to_be32(journal->j_tail_sequence); 1664 sb->s_start = cpu_to_be32(0); 1665 if (jbd2_has_feature_fast_commit(journal)) { 1666 /* 1667 * When journal is clean, no need to commit fast commit flag and 1668 * make file system incompatible with older kernels. 1669 */ 1670 jbd2_clear_feature_fast_commit(journal); 1671 had_fast_commit = true; 1672 } 1673 1674 jbd2_write_superblock(journal, write_op); 1675 1676 if (had_fast_commit) 1677 jbd2_set_feature_fast_commit(journal); 1678 1679 /* Log is no longer empty */ 1680 write_lock(&journal->j_state_lock); 1681 journal->j_flags |= JBD2_FLUSHED; 1682 write_unlock(&journal->j_state_lock); 1683 } 1684 1685 /** 1686 * __jbd2_journal_erase() - Discard or zeroout journal blocks (excluding superblock) 1687 * @journal: The journal to erase. 1688 * @flags: A discard/zeroout request is sent for each physically contigous 1689 * region of the journal. Either JBD2_JOURNAL_FLUSH_DISCARD or 1690 * JBD2_JOURNAL_FLUSH_ZEROOUT must be set to determine which operation 1691 * to perform. 1692 * 1693 * Note: JBD2_JOURNAL_FLUSH_ZEROOUT attempts to use hardware offload. Zeroes 1694 * will be explicitly written if no hardware offload is available, see 1695 * blkdev_issue_zeroout for more details. 1696 */ 1697 static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) 1698 { 1699 int err = 0; 1700 unsigned long block, log_offset; /* logical */ 1701 unsigned long long phys_block, block_start, block_stop; /* physical */ 1702 loff_t byte_start, byte_stop, byte_count; 1703 struct request_queue *q = bdev_get_queue(journal->j_dev); 1704 1705 /* flags must be set to either discard or zeroout */ 1706 if ((flags & ~JBD2_JOURNAL_FLUSH_VALID) || !flags || 1707 ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && 1708 (flags & JBD2_JOURNAL_FLUSH_ZEROOUT))) 1709 return -EINVAL; 1710 1711 if (!q) 1712 return -ENXIO; 1713 1714 if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && !blk_queue_discard(q)) 1715 return -EOPNOTSUPP; 1716 1717 /* 1718 * lookup block mapping and issue discard/zeroout for each 1719 * contiguous region 1720 */ 1721 log_offset = be32_to_cpu(journal->j_superblock->s_first); 1722 block_start = ~0ULL; 1723 for (block = log_offset; block < journal->j_total_len; block++) { 1724 err = jbd2_journal_bmap(journal, block, &phys_block); 1725 if (err) { 1726 pr_err("JBD2: bad block at offset %lu", block); 1727 return err; 1728 } 1729 1730 if (block_start == ~0ULL) { 1731 block_start = phys_block; 1732 block_stop = block_start - 1; 1733 } 1734 1735 /* 1736 * last block not contiguous with current block, 1737 * process last contiguous region and return to this block on 1738 * next loop 1739 */ 1740 if (phys_block != block_stop + 1) { 1741 block--; 1742 } else { 1743 block_stop++; 1744 /* 1745 * if this isn't the last block of journal, 1746 * no need to process now because next block may also 1747 * be part of this contiguous region 1748 */ 1749 if (block != journal->j_total_len - 1) 1750 continue; 1751 } 1752 1753 /* 1754 * end of contiguous region or this is last block of journal, 1755 * take care of the region 1756 */ 1757 byte_start = block_start * journal->j_blocksize; 1758 byte_stop = block_stop * journal->j_blocksize; 1759 byte_count = (block_stop - block_start + 1) * 1760 journal->j_blocksize; 1761 1762 truncate_inode_pages_range(journal->j_dev->bd_inode->i_mapping, 1763 byte_start, byte_stop); 1764 1765 if (flags & JBD2_JOURNAL_FLUSH_DISCARD) { 1766 err = blkdev_issue_discard(journal->j_dev, 1767 byte_start >> SECTOR_SHIFT, 1768 byte_count >> SECTOR_SHIFT, 1769 GFP_NOFS, 0); 1770 } else if (flags & JBD2_JOURNAL_FLUSH_ZEROOUT) { 1771 err = blkdev_issue_zeroout(journal->j_dev, 1772 byte_start >> SECTOR_SHIFT, 1773 byte_count >> SECTOR_SHIFT, 1774 GFP_NOFS, 0); 1775 } 1776 1777 if (unlikely(err != 0)) { 1778 pr_err("JBD2: (error %d) unable to wipe journal at physical blocks %llu - %llu", 1779 err, block_start, block_stop); 1780 return err; 1781 } 1782 1783 /* reset start and stop after processing a region */ 1784 block_start = ~0ULL; 1785 } 1786 1787 return blkdev_issue_flush(journal->j_dev); 1788 } 1789 1790 /** 1791 * jbd2_journal_update_sb_errno() - Update error in the journal. 1792 * @journal: The journal to update. 1793 * 1794 * Update a journal's errno. Write updated superblock to disk waiting for IO 1795 * to complete. 1796 */ 1797 void jbd2_journal_update_sb_errno(journal_t *journal) 1798 { 1799 journal_superblock_t *sb = journal->j_superblock; 1800 int errcode; 1801 1802 lock_buffer(journal->j_sb_buffer); 1803 errcode = journal->j_errno; 1804 if (errcode == -ESHUTDOWN) 1805 errcode = 0; 1806 jbd_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode); 1807 sb->s_errno = cpu_to_be32(errcode); 1808 1809 jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA); 1810 } 1811 EXPORT_SYMBOL(jbd2_journal_update_sb_errno); 1812 1813 static int journal_revoke_records_per_block(journal_t *journal) 1814 { 1815 int record_size; 1816 int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t); 1817 1818 if (jbd2_has_feature_64bit(journal)) 1819 record_size = 8; 1820 else 1821 record_size = 4; 1822 1823 if (jbd2_journal_has_csum_v2or3(journal)) 1824 space -= sizeof(struct jbd2_journal_block_tail); 1825 return space / record_size; 1826 } 1827 1828 /* 1829 * Read the superblock for a given journal, performing initial 1830 * validation of the format. 1831 */ 1832 static int journal_get_superblock(journal_t *journal) 1833 { 1834 struct buffer_head *bh; 1835 journal_superblock_t *sb; 1836 int err = -EIO; 1837 1838 bh = journal->j_sb_buffer; 1839 1840 J_ASSERT(bh != NULL); 1841 if (!buffer_uptodate(bh)) { 1842 ll_rw_block(REQ_OP_READ, 0, 1, &bh); 1843 wait_on_buffer(bh); 1844 if (!buffer_uptodate(bh)) { 1845 printk(KERN_ERR 1846 "JBD2: IO error reading journal superblock\n"); 1847 goto out; 1848 } 1849 } 1850 1851 if (buffer_verified(bh)) 1852 return 0; 1853 1854 sb = journal->j_superblock; 1855 1856 err = -EINVAL; 1857 1858 if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) || 1859 sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) { 1860 printk(KERN_WARNING "JBD2: no valid journal superblock found\n"); 1861 goto out; 1862 } 1863 1864 switch(be32_to_cpu(sb->s_header.h_blocktype)) { 1865 case JBD2_SUPERBLOCK_V1: 1866 journal->j_format_version = 1; 1867 break; 1868 case JBD2_SUPERBLOCK_V2: 1869 journal->j_format_version = 2; 1870 break; 1871 default: 1872 printk(KERN_WARNING "JBD2: unrecognised superblock format ID\n"); 1873 goto out; 1874 } 1875 1876 if (be32_to_cpu(sb->s_maxlen) < journal->j_total_len) 1877 journal->j_total_len = be32_to_cpu(sb->s_maxlen); 1878 else if (be32_to_cpu(sb->s_maxlen) > journal->j_total_len) { 1879 printk(KERN_WARNING "JBD2: journal file too short\n"); 1880 goto out; 1881 } 1882 1883 if (be32_to_cpu(sb->s_first) == 0 || 1884 be32_to_cpu(sb->s_first) >= journal->j_total_len) { 1885 printk(KERN_WARNING 1886 "JBD2: Invalid start block of journal: %u\n", 1887 be32_to_cpu(sb->s_first)); 1888 goto out; 1889 } 1890 1891 if (jbd2_has_feature_csum2(journal) && 1892 jbd2_has_feature_csum3(journal)) { 1893 /* Can't have checksum v2 and v3 at the same time! */ 1894 printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 " 1895 "at the same time!\n"); 1896 goto out; 1897 } 1898 1899 if (jbd2_journal_has_csum_v2or3_feature(journal) && 1900 jbd2_has_feature_checksum(journal)) { 1901 /* Can't have checksum v1 and v2 on at the same time! */ 1902 printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 " 1903 "at the same time!\n"); 1904 goto out; 1905 } 1906 1907 if (!jbd2_verify_csum_type(journal, sb)) { 1908 printk(KERN_ERR "JBD2: Unknown checksum type\n"); 1909 goto out; 1910 } 1911 1912 /* Load the checksum driver */ 1913 if (jbd2_journal_has_csum_v2or3_feature(journal)) { 1914 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); 1915 if (IS_ERR(journal->j_chksum_driver)) { 1916 printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n"); 1917 err = PTR_ERR(journal->j_chksum_driver); 1918 journal->j_chksum_driver = NULL; 1919 goto out; 1920 } 1921 } 1922 1923 if (jbd2_journal_has_csum_v2or3(journal)) { 1924 /* Check superblock checksum */ 1925 if (sb->s_checksum != jbd2_superblock_csum(journal, sb)) { 1926 printk(KERN_ERR "JBD2: journal checksum error\n"); 1927 err = -EFSBADCRC; 1928 goto out; 1929 } 1930 1931 /* Precompute checksum seed for all metadata */ 1932 journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid, 1933 sizeof(sb->s_uuid)); 1934 } 1935 1936 journal->j_revoke_records_per_block = 1937 journal_revoke_records_per_block(journal); 1938 set_buffer_verified(bh); 1939 1940 return 0; 1941 1942 out: 1943 journal_fail_superblock(journal); 1944 return err; 1945 } 1946 1947 /* 1948 * Load the on-disk journal superblock and read the key fields into the 1949 * journal_t. 1950 */ 1951 1952 static int load_superblock(journal_t *journal) 1953 { 1954 int err; 1955 journal_superblock_t *sb; 1956 int num_fc_blocks; 1957 1958 err = journal_get_superblock(journal); 1959 if (err) 1960 return err; 1961 1962 sb = journal->j_superblock; 1963 1964 journal->j_tail_sequence = be32_to_cpu(sb->s_sequence); 1965 journal->j_tail = be32_to_cpu(sb->s_start); 1966 journal->j_first = be32_to_cpu(sb->s_first); 1967 journal->j_errno = be32_to_cpu(sb->s_errno); 1968 journal->j_last = be32_to_cpu(sb->s_maxlen); 1969 1970 if (jbd2_has_feature_fast_commit(journal)) { 1971 journal->j_fc_last = be32_to_cpu(sb->s_maxlen); 1972 num_fc_blocks = jbd2_journal_get_num_fc_blks(sb); 1973 if (journal->j_last - num_fc_blocks >= JBD2_MIN_JOURNAL_BLOCKS) 1974 journal->j_last = journal->j_fc_last - num_fc_blocks; 1975 journal->j_fc_first = journal->j_last + 1; 1976 journal->j_fc_off = 0; 1977 } 1978 1979 return 0; 1980 } 1981 1982 1983 /** 1984 * jbd2_journal_load() - Read journal from disk. 1985 * @journal: Journal to act on. 1986 * 1987 * Given a journal_t structure which tells us which disk blocks contain 1988 * a journal, read the journal from disk to initialise the in-memory 1989 * structures. 1990 */ 1991 int jbd2_journal_load(journal_t *journal) 1992 { 1993 int err; 1994 journal_superblock_t *sb; 1995 1996 err = load_superblock(journal); 1997 if (err) 1998 return err; 1999 2000 sb = journal->j_superblock; 2001 /* If this is a V2 superblock, then we have to check the 2002 * features flags on it. */ 2003 2004 if (journal->j_format_version >= 2) { 2005 if ((sb->s_feature_ro_compat & 2006 ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) || 2007 (sb->s_feature_incompat & 2008 ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) { 2009 printk(KERN_WARNING 2010 "JBD2: Unrecognised features on journal\n"); 2011 return -EINVAL; 2012 } 2013 } 2014 2015 /* 2016 * Create a slab for this blocksize 2017 */ 2018 err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize)); 2019 if (err) 2020 return err; 2021 2022 /* Let the recovery code check whether it needs to recover any 2023 * data from the journal. */ 2024 if (jbd2_journal_recover(journal)) 2025 goto recovery_error; 2026 2027 if (journal->j_failed_commit) { 2028 printk(KERN_ERR "JBD2: journal transaction %u on %s " 2029 "is corrupt.\n", journal->j_failed_commit, 2030 journal->j_devname); 2031 return -EFSCORRUPTED; 2032 } 2033 /* 2034 * clear JBD2_ABORT flag initialized in journal_init_common 2035 * here to update log tail information with the newest seq. 2036 */ 2037 journal->j_flags &= ~JBD2_ABORT; 2038 2039 /* OK, we've finished with the dynamic journal bits: 2040 * reinitialise the dynamic contents of the superblock in memory 2041 * and reset them on disk. */ 2042 if (journal_reset(journal)) 2043 goto recovery_error; 2044 2045 journal->j_flags |= JBD2_LOADED; 2046 return 0; 2047 2048 recovery_error: 2049 printk(KERN_WARNING "JBD2: recovery failed\n"); 2050 return -EIO; 2051 } 2052 2053 /** 2054 * jbd2_journal_shrink_scan() 2055 * 2056 * Scan the checkpointed buffer on the checkpoint list and release the 2057 * journal_head. 2058 */ 2059 static unsigned long jbd2_journal_shrink_scan(struct shrinker *shrink, 2060 struct shrink_control *sc) 2061 { 2062 journal_t *journal = container_of(shrink, journal_t, j_shrinker); 2063 unsigned long nr_to_scan = sc->nr_to_scan; 2064 unsigned long nr_shrunk; 2065 unsigned long count; 2066 2067 count = percpu_counter_read_positive(&journal->j_jh_shrink_count); 2068 trace_jbd2_shrink_scan_enter(journal, sc->nr_to_scan, count); 2069 2070 nr_shrunk = jbd2_journal_shrink_checkpoint_list(journal, &nr_to_scan); 2071 2072 count = percpu_counter_read_positive(&journal->j_jh_shrink_count); 2073 trace_jbd2_shrink_scan_exit(journal, nr_to_scan, nr_shrunk, count); 2074 2075 return nr_shrunk; 2076 } 2077 2078 /** 2079 * jbd2_journal_shrink_count() 2080 * 2081 * Count the number of checkpoint buffers on the checkpoint list. 2082 */ 2083 static unsigned long jbd2_journal_shrink_count(struct shrinker *shrink, 2084 struct shrink_control *sc) 2085 { 2086 journal_t *journal = container_of(shrink, journal_t, j_shrinker); 2087 unsigned long count; 2088 2089 count = percpu_counter_read_positive(&journal->j_jh_shrink_count); 2090 trace_jbd2_shrink_count(journal, sc->nr_to_scan, count); 2091 2092 return count; 2093 } 2094 2095 /** 2096 * jbd2_journal_register_shrinker() 2097 * @journal: Journal to act on. 2098 * 2099 * Init a percpu counter to record the checkpointed buffers on the checkpoint 2100 * list and register a shrinker to release their journal_head. 2101 */ 2102 int jbd2_journal_register_shrinker(journal_t *journal) 2103 { 2104 int err; 2105 2106 journal->j_shrink_transaction = NULL; 2107 2108 err = percpu_counter_init(&journal->j_jh_shrink_count, 0, GFP_KERNEL); 2109 if (err) 2110 return err; 2111 2112 journal->j_shrinker.scan_objects = jbd2_journal_shrink_scan; 2113 journal->j_shrinker.count_objects = jbd2_journal_shrink_count; 2114 journal->j_shrinker.seeks = DEFAULT_SEEKS; 2115 journal->j_shrinker.batch = journal->j_max_transaction_buffers; 2116 2117 err = register_shrinker(&journal->j_shrinker); 2118 if (err) { 2119 percpu_counter_destroy(&journal->j_jh_shrink_count); 2120 return err; 2121 } 2122 2123 return 0; 2124 } 2125 2126 /** 2127 * jbd2_journal_unregister_shrinker() 2128 * @journal: Journal to act on. 2129 * 2130 * Unregister the checkpointed buffer shrinker and destroy the percpu counter. 2131 */ 2132 void jbd2_journal_unregister_shrinker(journal_t *journal) 2133 { 2134 percpu_counter_destroy(&journal->j_jh_shrink_count); 2135 unregister_shrinker(&journal->j_shrinker); 2136 } 2137 2138 /** 2139 * jbd2_journal_destroy() - Release a journal_t structure. 2140 * @journal: Journal to act on. 2141 * 2142 * Release a journal_t structure once it is no longer in use by the 2143 * journaled object. 2144 * Return <0 if we couldn't clean up the journal. 2145 */ 2146 int jbd2_journal_destroy(journal_t *journal) 2147 { 2148 int err = 0; 2149 2150 /* Wait for the commit thread to wake up and die. */ 2151 journal_kill_thread(journal); 2152 2153 /* Force a final log commit */ 2154 if (journal->j_running_transaction) 2155 jbd2_journal_commit_transaction(journal); 2156 2157 /* Force any old transactions to disk */ 2158 2159 /* Totally anal locking here... */ 2160 spin_lock(&journal->j_list_lock); 2161 while (journal->j_checkpoint_transactions != NULL) { 2162 spin_unlock(&journal->j_list_lock); 2163 mutex_lock_io(&journal->j_checkpoint_mutex); 2164 err = jbd2_log_do_checkpoint(journal); 2165 mutex_unlock(&journal->j_checkpoint_mutex); 2166 /* 2167 * If checkpointing failed, just free the buffers to avoid 2168 * looping forever 2169 */ 2170 if (err) { 2171 jbd2_journal_destroy_checkpoint(journal); 2172 spin_lock(&journal->j_list_lock); 2173 break; 2174 } 2175 spin_lock(&journal->j_list_lock); 2176 } 2177 2178 J_ASSERT(journal->j_running_transaction == NULL); 2179 J_ASSERT(journal->j_committing_transaction == NULL); 2180 J_ASSERT(journal->j_checkpoint_transactions == NULL); 2181 spin_unlock(&journal->j_list_lock); 2182 2183 /* 2184 * OK, all checkpoint transactions have been checked, now check the 2185 * write out io error flag and abort the journal if some buffer failed 2186 * to write back to the original location, otherwise the filesystem 2187 * may become inconsistent. 2188 */ 2189 if (!is_journal_aborted(journal) && 2190 test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) 2191 jbd2_journal_abort(journal, -EIO); 2192 2193 if (journal->j_sb_buffer) { 2194 if (!is_journal_aborted(journal)) { 2195 mutex_lock_io(&journal->j_checkpoint_mutex); 2196 2197 write_lock(&journal->j_state_lock); 2198 journal->j_tail_sequence = 2199 ++journal->j_transaction_sequence; 2200 write_unlock(&journal->j_state_lock); 2201 2202 jbd2_mark_journal_empty(journal, 2203 REQ_SYNC | REQ_PREFLUSH | REQ_FUA); 2204 mutex_unlock(&journal->j_checkpoint_mutex); 2205 } else 2206 err = -EIO; 2207 brelse(journal->j_sb_buffer); 2208 } 2209 2210 jbd2_journal_unregister_shrinker(journal); 2211 2212 if (journal->j_proc_entry) 2213 jbd2_stats_proc_exit(journal); 2214 iput(journal->j_inode); 2215 if (journal->j_revoke) 2216 jbd2_journal_destroy_revoke(journal); 2217 if (journal->j_chksum_driver) 2218 crypto_free_shash(journal->j_chksum_driver); 2219 kfree(journal->j_fc_wbuf); 2220 kfree(journal->j_wbuf); 2221 kfree(journal); 2222 2223 return err; 2224 } 2225 2226 2227 /** 2228 * jbd2_journal_check_used_features() - Check if features specified are used. 2229 * @journal: Journal to check. 2230 * @compat: bitmask of compatible features 2231 * @ro: bitmask of features that force read-only mount 2232 * @incompat: bitmask of incompatible features 2233 * 2234 * Check whether the journal uses all of a given set of 2235 * features. Return true (non-zero) if it does. 2236 **/ 2237 2238 int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat, 2239 unsigned long ro, unsigned long incompat) 2240 { 2241 journal_superblock_t *sb; 2242 2243 if (!compat && !ro && !incompat) 2244 return 1; 2245 /* Load journal superblock if it is not loaded yet. */ 2246 if (journal->j_format_version == 0 && 2247 journal_get_superblock(journal) != 0) 2248 return 0; 2249 if (journal->j_format_version == 1) 2250 return 0; 2251 2252 sb = journal->j_superblock; 2253 2254 if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) && 2255 ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) && 2256 ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat)) 2257 return 1; 2258 2259 return 0; 2260 } 2261 2262 /** 2263 * jbd2_journal_check_available_features() - Check feature set in journalling layer 2264 * @journal: Journal to check. 2265 * @compat: bitmask of compatible features 2266 * @ro: bitmask of features that force read-only mount 2267 * @incompat: bitmask of incompatible features 2268 * 2269 * Check whether the journaling code supports the use of 2270 * all of a given set of features on this journal. Return true 2271 * (non-zero) if it can. */ 2272 2273 int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat, 2274 unsigned long ro, unsigned long incompat) 2275 { 2276 if (!compat && !ro && !incompat) 2277 return 1; 2278 2279 /* We can support any known requested features iff the 2280 * superblock is in version 2. Otherwise we fail to support any 2281 * extended sb features. */ 2282 2283 if (journal->j_format_version != 2) 2284 return 0; 2285 2286 if ((compat & JBD2_KNOWN_COMPAT_FEATURES) == compat && 2287 (ro & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro && 2288 (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat) 2289 return 1; 2290 2291 return 0; 2292 } 2293 2294 static int 2295 jbd2_journal_initialize_fast_commit(journal_t *journal) 2296 { 2297 journal_superblock_t *sb = journal->j_superblock; 2298 unsigned long long num_fc_blks; 2299 2300 num_fc_blks = jbd2_journal_get_num_fc_blks(sb); 2301 if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS) 2302 return -ENOSPC; 2303 2304 /* Are we called twice? */ 2305 WARN_ON(journal->j_fc_wbuf != NULL); 2306 journal->j_fc_wbuf = kmalloc_array(num_fc_blks, 2307 sizeof(struct buffer_head *), GFP_KERNEL); 2308 if (!journal->j_fc_wbuf) 2309 return -ENOMEM; 2310 2311 journal->j_fc_wbufsize = num_fc_blks; 2312 journal->j_fc_last = journal->j_last; 2313 journal->j_last = journal->j_fc_last - num_fc_blks; 2314 journal->j_fc_first = journal->j_last + 1; 2315 journal->j_fc_off = 0; 2316 journal->j_free = journal->j_last - journal->j_first; 2317 journal->j_max_transaction_buffers = 2318 jbd2_journal_get_max_txn_bufs(journal); 2319 2320 return 0; 2321 } 2322 2323 /** 2324 * jbd2_journal_set_features() - Mark a given journal feature in the superblock 2325 * @journal: Journal to act on. 2326 * @compat: bitmask of compatible features 2327 * @ro: bitmask of features that force read-only mount 2328 * @incompat: bitmask of incompatible features 2329 * 2330 * Mark a given journal feature as present on the 2331 * superblock. Returns true if the requested features could be set. 2332 * 2333 */ 2334 2335 int jbd2_journal_set_features(journal_t *journal, unsigned long compat, 2336 unsigned long ro, unsigned long incompat) 2337 { 2338 #define INCOMPAT_FEATURE_ON(f) \ 2339 ((incompat & (f)) && !(sb->s_feature_incompat & cpu_to_be32(f))) 2340 #define COMPAT_FEATURE_ON(f) \ 2341 ((compat & (f)) && !(sb->s_feature_compat & cpu_to_be32(f))) 2342 journal_superblock_t *sb; 2343 2344 if (jbd2_journal_check_used_features(journal, compat, ro, incompat)) 2345 return 1; 2346 2347 if (!jbd2_journal_check_available_features(journal, compat, ro, incompat)) 2348 return 0; 2349 2350 /* If enabling v2 checksums, turn on v3 instead */ 2351 if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V2) { 2352 incompat &= ~JBD2_FEATURE_INCOMPAT_CSUM_V2; 2353 incompat |= JBD2_FEATURE_INCOMPAT_CSUM_V3; 2354 } 2355 2356 /* Asking for checksumming v3 and v1? Only give them v3. */ 2357 if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V3 && 2358 compat & JBD2_FEATURE_COMPAT_CHECKSUM) 2359 compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM; 2360 2361 jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n", 2362 compat, ro, incompat); 2363 2364 sb = journal->j_superblock; 2365 2366 if (incompat & JBD2_FEATURE_INCOMPAT_FAST_COMMIT) { 2367 if (jbd2_journal_initialize_fast_commit(journal)) { 2368 pr_err("JBD2: Cannot enable fast commits.\n"); 2369 return 0; 2370 } 2371 } 2372 2373 /* Load the checksum driver if necessary */ 2374 if ((journal->j_chksum_driver == NULL) && 2375 INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) { 2376 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); 2377 if (IS_ERR(journal->j_chksum_driver)) { 2378 printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n"); 2379 journal->j_chksum_driver = NULL; 2380 return 0; 2381 } 2382 /* Precompute checksum seed for all metadata */ 2383 journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid, 2384 sizeof(sb->s_uuid)); 2385 } 2386 2387 lock_buffer(journal->j_sb_buffer); 2388 2389 /* If enabling v3 checksums, update superblock */ 2390 if (INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) { 2391 sb->s_checksum_type = JBD2_CRC32C_CHKSUM; 2392 sb->s_feature_compat &= 2393 ~cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM); 2394 } 2395 2396 /* If enabling v1 checksums, downgrade superblock */ 2397 if (COMPAT_FEATURE_ON(JBD2_FEATURE_COMPAT_CHECKSUM)) 2398 sb->s_feature_incompat &= 2399 ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_CSUM_V2 | 2400 JBD2_FEATURE_INCOMPAT_CSUM_V3); 2401 2402 sb->s_feature_compat |= cpu_to_be32(compat); 2403 sb->s_feature_ro_compat |= cpu_to_be32(ro); 2404 sb->s_feature_incompat |= cpu_to_be32(incompat); 2405 unlock_buffer(journal->j_sb_buffer); 2406 journal->j_revoke_records_per_block = 2407 journal_revoke_records_per_block(journal); 2408 2409 return 1; 2410 #undef COMPAT_FEATURE_ON 2411 #undef INCOMPAT_FEATURE_ON 2412 } 2413 2414 /* 2415 * jbd2_journal_clear_features() - Clear a given journal feature in the 2416 * superblock 2417 * @journal: Journal to act on. 2418 * @compat: bitmask of compatible features 2419 * @ro: bitmask of features that force read-only mount 2420 * @incompat: bitmask of incompatible features 2421 * 2422 * Clear a given journal feature as present on the 2423 * superblock. 2424 */ 2425 void jbd2_journal_clear_features(journal_t *journal, unsigned long compat, 2426 unsigned long ro, unsigned long incompat) 2427 { 2428 journal_superblock_t *sb; 2429 2430 jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n", 2431 compat, ro, incompat); 2432 2433 sb = journal->j_superblock; 2434 2435 sb->s_feature_compat &= ~cpu_to_be32(compat); 2436 sb->s_feature_ro_compat &= ~cpu_to_be32(ro); 2437 sb->s_feature_incompat &= ~cpu_to_be32(incompat); 2438 journal->j_revoke_records_per_block = 2439 journal_revoke_records_per_block(journal); 2440 } 2441 EXPORT_SYMBOL(jbd2_journal_clear_features); 2442 2443 /** 2444 * jbd2_journal_flush() - Flush journal 2445 * @journal: Journal to act on. 2446 * @flags: optional operation on the journal blocks after the flush (see below) 2447 * 2448 * Flush all data for a given journal to disk and empty the journal. 2449 * Filesystems can use this when remounting readonly to ensure that 2450 * recovery does not need to happen on remount. Optionally, a discard or zeroout 2451 * can be issued on the journal blocks after flushing. 2452 * 2453 * flags: 2454 * JBD2_JOURNAL_FLUSH_DISCARD: issues discards for the journal blocks 2455 * JBD2_JOURNAL_FLUSH_ZEROOUT: issues zeroouts for the journal blocks 2456 */ 2457 int jbd2_journal_flush(journal_t *journal, unsigned int flags) 2458 { 2459 int err = 0; 2460 transaction_t *transaction = NULL; 2461 2462 write_lock(&journal->j_state_lock); 2463 2464 /* Force everything buffered to the log... */ 2465 if (journal->j_running_transaction) { 2466 transaction = journal->j_running_transaction; 2467 __jbd2_log_start_commit(journal, transaction->t_tid); 2468 } else if (journal->j_committing_transaction) 2469 transaction = journal->j_committing_transaction; 2470 2471 /* Wait for the log commit to complete... */ 2472 if (transaction) { 2473 tid_t tid = transaction->t_tid; 2474 2475 write_unlock(&journal->j_state_lock); 2476 jbd2_log_wait_commit(journal, tid); 2477 } else { 2478 write_unlock(&journal->j_state_lock); 2479 } 2480 2481 /* ...and flush everything in the log out to disk. */ 2482 spin_lock(&journal->j_list_lock); 2483 while (!err && journal->j_checkpoint_transactions != NULL) { 2484 spin_unlock(&journal->j_list_lock); 2485 mutex_lock_io(&journal->j_checkpoint_mutex); 2486 err = jbd2_log_do_checkpoint(journal); 2487 mutex_unlock(&journal->j_checkpoint_mutex); 2488 spin_lock(&journal->j_list_lock); 2489 } 2490 spin_unlock(&journal->j_list_lock); 2491 2492 if (is_journal_aborted(journal)) 2493 return -EIO; 2494 2495 mutex_lock_io(&journal->j_checkpoint_mutex); 2496 if (!err) { 2497 err = jbd2_cleanup_journal_tail(journal); 2498 if (err < 0) { 2499 mutex_unlock(&journal->j_checkpoint_mutex); 2500 goto out; 2501 } 2502 err = 0; 2503 } 2504 2505 /* Finally, mark the journal as really needing no recovery. 2506 * This sets s_start==0 in the underlying superblock, which is 2507 * the magic code for a fully-recovered superblock. Any future 2508 * commits of data to the journal will restore the current 2509 * s_start value. */ 2510 jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA); 2511 2512 if (flags) 2513 err = __jbd2_journal_erase(journal, flags); 2514 2515 mutex_unlock(&journal->j_checkpoint_mutex); 2516 write_lock(&journal->j_state_lock); 2517 J_ASSERT(!journal->j_running_transaction); 2518 J_ASSERT(!journal->j_committing_transaction); 2519 J_ASSERT(!journal->j_checkpoint_transactions); 2520 J_ASSERT(journal->j_head == journal->j_tail); 2521 J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence); 2522 write_unlock(&journal->j_state_lock); 2523 out: 2524 return err; 2525 } 2526 2527 /** 2528 * jbd2_journal_wipe() - Wipe journal contents 2529 * @journal: Journal to act on. 2530 * @write: flag (see below) 2531 * 2532 * Wipe out all of the contents of a journal, safely. This will produce 2533 * a warning if the journal contains any valid recovery information. 2534 * Must be called between journal_init_*() and jbd2_journal_load(). 2535 * 2536 * If 'write' is non-zero, then we wipe out the journal on disk; otherwise 2537 * we merely suppress recovery. 2538 */ 2539 2540 int jbd2_journal_wipe(journal_t *journal, int write) 2541 { 2542 int err = 0; 2543 2544 J_ASSERT (!(journal->j_flags & JBD2_LOADED)); 2545 2546 err = load_superblock(journal); 2547 if (err) 2548 return err; 2549 2550 if (!journal->j_tail) 2551 goto no_recovery; 2552 2553 printk(KERN_WARNING "JBD2: %s recovery information on journal\n", 2554 write ? "Clearing" : "Ignoring"); 2555 2556 err = jbd2_journal_skip_recovery(journal); 2557 if (write) { 2558 /* Lock to make assertions happy... */ 2559 mutex_lock_io(&journal->j_checkpoint_mutex); 2560 jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA); 2561 mutex_unlock(&journal->j_checkpoint_mutex); 2562 } 2563 2564 no_recovery: 2565 return err; 2566 } 2567 2568 /** 2569 * jbd2_journal_abort () - Shutdown the journal immediately. 2570 * @journal: the journal to shutdown. 2571 * @errno: an error number to record in the journal indicating 2572 * the reason for the shutdown. 2573 * 2574 * Perform a complete, immediate shutdown of the ENTIRE 2575 * journal (not of a single transaction). This operation cannot be 2576 * undone without closing and reopening the journal. 2577 * 2578 * The jbd2_journal_abort function is intended to support higher level error 2579 * recovery mechanisms such as the ext2/ext3 remount-readonly error 2580 * mode. 2581 * 2582 * Journal abort has very specific semantics. Any existing dirty, 2583 * unjournaled buffers in the main filesystem will still be written to 2584 * disk by bdflush, but the journaling mechanism will be suspended 2585 * immediately and no further transaction commits will be honoured. 2586 * 2587 * Any dirty, journaled buffers will be written back to disk without 2588 * hitting the journal. Atomicity cannot be guaranteed on an aborted 2589 * filesystem, but we _do_ attempt to leave as much data as possible 2590 * behind for fsck to use for cleanup. 2591 * 2592 * Any attempt to get a new transaction handle on a journal which is in 2593 * ABORT state will just result in an -EROFS error return. A 2594 * jbd2_journal_stop on an existing handle will return -EIO if we have 2595 * entered abort state during the update. 2596 * 2597 * Recursive transactions are not disturbed by journal abort until the 2598 * final jbd2_journal_stop, which will receive the -EIO error. 2599 * 2600 * Finally, the jbd2_journal_abort call allows the caller to supply an errno 2601 * which will be recorded (if possible) in the journal superblock. This 2602 * allows a client to record failure conditions in the middle of a 2603 * transaction without having to complete the transaction to record the 2604 * failure to disk. ext3_error, for example, now uses this 2605 * functionality. 2606 * 2607 */ 2608 2609 void jbd2_journal_abort(journal_t *journal, int errno) 2610 { 2611 transaction_t *transaction; 2612 2613 /* 2614 * Lock the aborting procedure until everything is done, this avoid 2615 * races between filesystem's error handling flow (e.g. ext4_abort()), 2616 * ensure panic after the error info is written into journal's 2617 * superblock. 2618 */ 2619 mutex_lock(&journal->j_abort_mutex); 2620 /* 2621 * ESHUTDOWN always takes precedence because a file system check 2622 * caused by any other journal abort error is not required after 2623 * a shutdown triggered. 2624 */ 2625 write_lock(&journal->j_state_lock); 2626 if (journal->j_flags & JBD2_ABORT) { 2627 int old_errno = journal->j_errno; 2628 2629 write_unlock(&journal->j_state_lock); 2630 if (old_errno != -ESHUTDOWN && errno == -ESHUTDOWN) { 2631 journal->j_errno = errno; 2632 jbd2_journal_update_sb_errno(journal); 2633 } 2634 mutex_unlock(&journal->j_abort_mutex); 2635 return; 2636 } 2637 2638 /* 2639 * Mark the abort as occurred and start current running transaction 2640 * to release all journaled buffer. 2641 */ 2642 pr_err("Aborting journal on device %s.\n", journal->j_devname); 2643 2644 journal->j_flags |= JBD2_ABORT; 2645 journal->j_errno = errno; 2646 transaction = journal->j_running_transaction; 2647 if (transaction) 2648 __jbd2_log_start_commit(journal, transaction->t_tid); 2649 write_unlock(&journal->j_state_lock); 2650 2651 /* 2652 * Record errno to the journal super block, so that fsck and jbd2 2653 * layer could realise that a filesystem check is needed. 2654 */ 2655 jbd2_journal_update_sb_errno(journal); 2656 mutex_unlock(&journal->j_abort_mutex); 2657 } 2658 2659 /** 2660 * jbd2_journal_errno() - returns the journal's error state. 2661 * @journal: journal to examine. 2662 * 2663 * This is the errno number set with jbd2_journal_abort(), the last 2664 * time the journal was mounted - if the journal was stopped 2665 * without calling abort this will be 0. 2666 * 2667 * If the journal has been aborted on this mount time -EROFS will 2668 * be returned. 2669 */ 2670 int jbd2_journal_errno(journal_t *journal) 2671 { 2672 int err; 2673 2674 read_lock(&journal->j_state_lock); 2675 if (journal->j_flags & JBD2_ABORT) 2676 err = -EROFS; 2677 else 2678 err = journal->j_errno; 2679 read_unlock(&journal->j_state_lock); 2680 return err; 2681 } 2682 2683 /** 2684 * jbd2_journal_clear_err() - clears the journal's error state 2685 * @journal: journal to act on. 2686 * 2687 * An error must be cleared or acked to take a FS out of readonly 2688 * mode. 2689 */ 2690 int jbd2_journal_clear_err(journal_t *journal) 2691 { 2692 int err = 0; 2693 2694 write_lock(&journal->j_state_lock); 2695 if (journal->j_flags & JBD2_ABORT) 2696 err = -EROFS; 2697 else 2698 journal->j_errno = 0; 2699 write_unlock(&journal->j_state_lock); 2700 return err; 2701 } 2702 2703 /** 2704 * jbd2_journal_ack_err() - Ack journal err. 2705 * @journal: journal to act on. 2706 * 2707 * An error must be cleared or acked to take a FS out of readonly 2708 * mode. 2709 */ 2710 void jbd2_journal_ack_err(journal_t *journal) 2711 { 2712 write_lock(&journal->j_state_lock); 2713 if (journal->j_errno) 2714 journal->j_flags |= JBD2_ACK_ERR; 2715 write_unlock(&journal->j_state_lock); 2716 } 2717 2718 int jbd2_journal_blocks_per_page(struct inode *inode) 2719 { 2720 return 1 << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits); 2721 } 2722 2723 /* 2724 * helper functions to deal with 32 or 64bit block numbers. 2725 */ 2726 size_t journal_tag_bytes(journal_t *journal) 2727 { 2728 size_t sz; 2729 2730 if (jbd2_has_feature_csum3(journal)) 2731 return sizeof(journal_block_tag3_t); 2732 2733 sz = sizeof(journal_block_tag_t); 2734 2735 if (jbd2_has_feature_csum2(journal)) 2736 sz += sizeof(__u16); 2737 2738 if (jbd2_has_feature_64bit(journal)) 2739 return sz; 2740 else 2741 return sz - sizeof(__u32); 2742 } 2743 2744 /* 2745 * JBD memory management 2746 * 2747 * These functions are used to allocate block-sized chunks of memory 2748 * used for making copies of buffer_head data. Very often it will be 2749 * page-sized chunks of data, but sometimes it will be in 2750 * sub-page-size chunks. (For example, 16k pages on Power systems 2751 * with a 4k block file system.) For blocks smaller than a page, we 2752 * use a SLAB allocator. There are slab caches for each block size, 2753 * which are allocated at mount time, if necessary, and we only free 2754 * (all of) the slab caches when/if the jbd2 module is unloaded. For 2755 * this reason we don't need to a mutex to protect access to 2756 * jbd2_slab[] allocating or releasing memory; only in 2757 * jbd2_journal_create_slab(). 2758 */ 2759 #define JBD2_MAX_SLABS 8 2760 static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS]; 2761 2762 static const char *jbd2_slab_names[JBD2_MAX_SLABS] = { 2763 "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k", 2764 "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k" 2765 }; 2766 2767 2768 static void jbd2_journal_destroy_slabs(void) 2769 { 2770 int i; 2771 2772 for (i = 0; i < JBD2_MAX_SLABS; i++) { 2773 kmem_cache_destroy(jbd2_slab[i]); 2774 jbd2_slab[i] = NULL; 2775 } 2776 } 2777 2778 static int jbd2_journal_create_slab(size_t size) 2779 { 2780 static DEFINE_MUTEX(jbd2_slab_create_mutex); 2781 int i = order_base_2(size) - 10; 2782 size_t slab_size; 2783 2784 if (size == PAGE_SIZE) 2785 return 0; 2786 2787 if (i >= JBD2_MAX_SLABS) 2788 return -EINVAL; 2789 2790 if (unlikely(i < 0)) 2791 i = 0; 2792 mutex_lock(&jbd2_slab_create_mutex); 2793 if (jbd2_slab[i]) { 2794 mutex_unlock(&jbd2_slab_create_mutex); 2795 return 0; /* Already created */ 2796 } 2797 2798 slab_size = 1 << (i+10); 2799 jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size, 2800 slab_size, 0, NULL); 2801 mutex_unlock(&jbd2_slab_create_mutex); 2802 if (!jbd2_slab[i]) { 2803 printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n"); 2804 return -ENOMEM; 2805 } 2806 return 0; 2807 } 2808 2809 static struct kmem_cache *get_slab(size_t size) 2810 { 2811 int i = order_base_2(size) - 10; 2812 2813 BUG_ON(i >= JBD2_MAX_SLABS); 2814 if (unlikely(i < 0)) 2815 i = 0; 2816 BUG_ON(jbd2_slab[i] == NULL); 2817 return jbd2_slab[i]; 2818 } 2819 2820 void *jbd2_alloc(size_t size, gfp_t flags) 2821 { 2822 void *ptr; 2823 2824 BUG_ON(size & (size-1)); /* Must be a power of 2 */ 2825 2826 if (size < PAGE_SIZE) 2827 ptr = kmem_cache_alloc(get_slab(size), flags); 2828 else 2829 ptr = (void *)__get_free_pages(flags, get_order(size)); 2830 2831 /* Check alignment; SLUB has gotten this wrong in the past, 2832 * and this can lead to user data corruption! */ 2833 BUG_ON(((unsigned long) ptr) & (size-1)); 2834 2835 return ptr; 2836 } 2837 2838 void jbd2_free(void *ptr, size_t size) 2839 { 2840 if (size < PAGE_SIZE) 2841 kmem_cache_free(get_slab(size), ptr); 2842 else 2843 free_pages((unsigned long)ptr, get_order(size)); 2844 }; 2845 2846 /* 2847 * Journal_head storage management 2848 */ 2849 static struct kmem_cache *jbd2_journal_head_cache; 2850 #ifdef CONFIG_JBD2_DEBUG 2851 static atomic_t nr_journal_heads = ATOMIC_INIT(0); 2852 #endif 2853 2854 static int __init jbd2_journal_init_journal_head_cache(void) 2855 { 2856 J_ASSERT(!jbd2_journal_head_cache); 2857 jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head", 2858 sizeof(struct journal_head), 2859 0, /* offset */ 2860 SLAB_TEMPORARY | SLAB_TYPESAFE_BY_RCU, 2861 NULL); /* ctor */ 2862 if (!jbd2_journal_head_cache) { 2863 printk(KERN_EMERG "JBD2: no memory for journal_head cache\n"); 2864 return -ENOMEM; 2865 } 2866 return 0; 2867 } 2868 2869 static void jbd2_journal_destroy_journal_head_cache(void) 2870 { 2871 kmem_cache_destroy(jbd2_journal_head_cache); 2872 jbd2_journal_head_cache = NULL; 2873 } 2874 2875 /* 2876 * journal_head splicing and dicing 2877 */ 2878 static struct journal_head *journal_alloc_journal_head(void) 2879 { 2880 struct journal_head *ret; 2881 2882 #ifdef CONFIG_JBD2_DEBUG 2883 atomic_inc(&nr_journal_heads); 2884 #endif 2885 ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS); 2886 if (!ret) { 2887 jbd_debug(1, "out of memory for journal_head\n"); 2888 pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__); 2889 ret = kmem_cache_zalloc(jbd2_journal_head_cache, 2890 GFP_NOFS | __GFP_NOFAIL); 2891 } 2892 if (ret) 2893 spin_lock_init(&ret->b_state_lock); 2894 return ret; 2895 } 2896 2897 static void journal_free_journal_head(struct journal_head *jh) 2898 { 2899 #ifdef CONFIG_JBD2_DEBUG 2900 atomic_dec(&nr_journal_heads); 2901 memset(jh, JBD2_POISON_FREE, sizeof(*jh)); 2902 #endif 2903 kmem_cache_free(jbd2_journal_head_cache, jh); 2904 } 2905 2906 /* 2907 * A journal_head is attached to a buffer_head whenever JBD has an 2908 * interest in the buffer. 2909 * 2910 * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit 2911 * is set. This bit is tested in core kernel code where we need to take 2912 * JBD-specific actions. Testing the zeroness of ->b_private is not reliable 2913 * there. 2914 * 2915 * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one. 2916 * 2917 * When a buffer has its BH_JBD bit set it is immune from being released by 2918 * core kernel code, mainly via ->b_count. 2919 * 2920 * A journal_head is detached from its buffer_head when the journal_head's 2921 * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint 2922 * transaction (b_cp_transaction) hold their references to b_jcount. 2923 * 2924 * Various places in the kernel want to attach a journal_head to a buffer_head 2925 * _before_ attaching the journal_head to a transaction. To protect the 2926 * journal_head in this situation, jbd2_journal_add_journal_head elevates the 2927 * journal_head's b_jcount refcount by one. The caller must call 2928 * jbd2_journal_put_journal_head() to undo this. 2929 * 2930 * So the typical usage would be: 2931 * 2932 * (Attach a journal_head if needed. Increments b_jcount) 2933 * struct journal_head *jh = jbd2_journal_add_journal_head(bh); 2934 * ... 2935 * (Get another reference for transaction) 2936 * jbd2_journal_grab_journal_head(bh); 2937 * jh->b_transaction = xxx; 2938 * (Put original reference) 2939 * jbd2_journal_put_journal_head(jh); 2940 */ 2941 2942 /* 2943 * Give a buffer_head a journal_head. 2944 * 2945 * May sleep. 2946 */ 2947 struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh) 2948 { 2949 struct journal_head *jh; 2950 struct journal_head *new_jh = NULL; 2951 2952 repeat: 2953 if (!buffer_jbd(bh)) 2954 new_jh = journal_alloc_journal_head(); 2955 2956 jbd_lock_bh_journal_head(bh); 2957 if (buffer_jbd(bh)) { 2958 jh = bh2jh(bh); 2959 } else { 2960 J_ASSERT_BH(bh, 2961 (atomic_read(&bh->b_count) > 0) || 2962 (bh->b_page && bh->b_page->mapping)); 2963 2964 if (!new_jh) { 2965 jbd_unlock_bh_journal_head(bh); 2966 goto repeat; 2967 } 2968 2969 jh = new_jh; 2970 new_jh = NULL; /* We consumed it */ 2971 set_buffer_jbd(bh); 2972 bh->b_private = jh; 2973 jh->b_bh = bh; 2974 get_bh(bh); 2975 BUFFER_TRACE(bh, "added journal_head"); 2976 } 2977 jh->b_jcount++; 2978 jbd_unlock_bh_journal_head(bh); 2979 if (new_jh) 2980 journal_free_journal_head(new_jh); 2981 return bh->b_private; 2982 } 2983 2984 /* 2985 * Grab a ref against this buffer_head's journal_head. If it ended up not 2986 * having a journal_head, return NULL 2987 */ 2988 struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh) 2989 { 2990 struct journal_head *jh = NULL; 2991 2992 jbd_lock_bh_journal_head(bh); 2993 if (buffer_jbd(bh)) { 2994 jh = bh2jh(bh); 2995 jh->b_jcount++; 2996 } 2997 jbd_unlock_bh_journal_head(bh); 2998 return jh; 2999 } 3000 3001 static void __journal_remove_journal_head(struct buffer_head *bh) 3002 { 3003 struct journal_head *jh = bh2jh(bh); 3004 3005 J_ASSERT_JH(jh, jh->b_transaction == NULL); 3006 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 3007 J_ASSERT_JH(jh, jh->b_cp_transaction == NULL); 3008 J_ASSERT_JH(jh, jh->b_jlist == BJ_None); 3009 J_ASSERT_BH(bh, buffer_jbd(bh)); 3010 J_ASSERT_BH(bh, jh2bh(jh) == bh); 3011 BUFFER_TRACE(bh, "remove journal_head"); 3012 3013 /* Unlink before dropping the lock */ 3014 bh->b_private = NULL; 3015 jh->b_bh = NULL; /* debug, really */ 3016 clear_buffer_jbd(bh); 3017 } 3018 3019 static void journal_release_journal_head(struct journal_head *jh, size_t b_size) 3020 { 3021 if (jh->b_frozen_data) { 3022 printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__); 3023 jbd2_free(jh->b_frozen_data, b_size); 3024 } 3025 if (jh->b_committed_data) { 3026 printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__); 3027 jbd2_free(jh->b_committed_data, b_size); 3028 } 3029 journal_free_journal_head(jh); 3030 } 3031 3032 /* 3033 * Drop a reference on the passed journal_head. If it fell to zero then 3034 * release the journal_head from the buffer_head. 3035 */ 3036 void jbd2_journal_put_journal_head(struct journal_head *jh) 3037 { 3038 struct buffer_head *bh = jh2bh(jh); 3039 3040 jbd_lock_bh_journal_head(bh); 3041 J_ASSERT_JH(jh, jh->b_jcount > 0); 3042 --jh->b_jcount; 3043 if (!jh->b_jcount) { 3044 __journal_remove_journal_head(bh); 3045 jbd_unlock_bh_journal_head(bh); 3046 journal_release_journal_head(jh, bh->b_size); 3047 __brelse(bh); 3048 } else { 3049 jbd_unlock_bh_journal_head(bh); 3050 } 3051 } 3052 3053 /* 3054 * Initialize jbd inode head 3055 */ 3056 void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode) 3057 { 3058 jinode->i_transaction = NULL; 3059 jinode->i_next_transaction = NULL; 3060 jinode->i_vfs_inode = inode; 3061 jinode->i_flags = 0; 3062 jinode->i_dirty_start = 0; 3063 jinode->i_dirty_end = 0; 3064 INIT_LIST_HEAD(&jinode->i_list); 3065 } 3066 3067 /* 3068 * Function to be called before we start removing inode from memory (i.e., 3069 * clear_inode() is a fine place to be called from). It removes inode from 3070 * transaction's lists. 3071 */ 3072 void jbd2_journal_release_jbd_inode(journal_t *journal, 3073 struct jbd2_inode *jinode) 3074 { 3075 if (!journal) 3076 return; 3077 restart: 3078 spin_lock(&journal->j_list_lock); 3079 /* Is commit writing out inode - we have to wait */ 3080 if (jinode->i_flags & JI_COMMIT_RUNNING) { 3081 wait_queue_head_t *wq; 3082 DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING); 3083 wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING); 3084 prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE); 3085 spin_unlock(&journal->j_list_lock); 3086 schedule(); 3087 finish_wait(wq, &wait.wq_entry); 3088 goto restart; 3089 } 3090 3091 if (jinode->i_transaction) { 3092 list_del(&jinode->i_list); 3093 jinode->i_transaction = NULL; 3094 } 3095 spin_unlock(&journal->j_list_lock); 3096 } 3097 3098 3099 #ifdef CONFIG_PROC_FS 3100 3101 #define JBD2_STATS_PROC_NAME "fs/jbd2" 3102 3103 static void __init jbd2_create_jbd_stats_proc_entry(void) 3104 { 3105 proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL); 3106 } 3107 3108 static void __exit jbd2_remove_jbd_stats_proc_entry(void) 3109 { 3110 if (proc_jbd2_stats) 3111 remove_proc_entry(JBD2_STATS_PROC_NAME, NULL); 3112 } 3113 3114 #else 3115 3116 #define jbd2_create_jbd_stats_proc_entry() do {} while (0) 3117 #define jbd2_remove_jbd_stats_proc_entry() do {} while (0) 3118 3119 #endif 3120 3121 struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache; 3122 3123 static int __init jbd2_journal_init_inode_cache(void) 3124 { 3125 J_ASSERT(!jbd2_inode_cache); 3126 jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0); 3127 if (!jbd2_inode_cache) { 3128 pr_emerg("JBD2: failed to create inode cache\n"); 3129 return -ENOMEM; 3130 } 3131 return 0; 3132 } 3133 3134 static int __init jbd2_journal_init_handle_cache(void) 3135 { 3136 J_ASSERT(!jbd2_handle_cache); 3137 jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY); 3138 if (!jbd2_handle_cache) { 3139 printk(KERN_EMERG "JBD2: failed to create handle cache\n"); 3140 return -ENOMEM; 3141 } 3142 return 0; 3143 } 3144 3145 static void jbd2_journal_destroy_inode_cache(void) 3146 { 3147 kmem_cache_destroy(jbd2_inode_cache); 3148 jbd2_inode_cache = NULL; 3149 } 3150 3151 static void jbd2_journal_destroy_handle_cache(void) 3152 { 3153 kmem_cache_destroy(jbd2_handle_cache); 3154 jbd2_handle_cache = NULL; 3155 } 3156 3157 /* 3158 * Module startup and shutdown 3159 */ 3160 3161 static int __init journal_init_caches(void) 3162 { 3163 int ret; 3164 3165 ret = jbd2_journal_init_revoke_record_cache(); 3166 if (ret == 0) 3167 ret = jbd2_journal_init_revoke_table_cache(); 3168 if (ret == 0) 3169 ret = jbd2_journal_init_journal_head_cache(); 3170 if (ret == 0) 3171 ret = jbd2_journal_init_handle_cache(); 3172 if (ret == 0) 3173 ret = jbd2_journal_init_inode_cache(); 3174 if (ret == 0) 3175 ret = jbd2_journal_init_transaction_cache(); 3176 return ret; 3177 } 3178 3179 static void jbd2_journal_destroy_caches(void) 3180 { 3181 jbd2_journal_destroy_revoke_record_cache(); 3182 jbd2_journal_destroy_revoke_table_cache(); 3183 jbd2_journal_destroy_journal_head_cache(); 3184 jbd2_journal_destroy_handle_cache(); 3185 jbd2_journal_destroy_inode_cache(); 3186 jbd2_journal_destroy_transaction_cache(); 3187 jbd2_journal_destroy_slabs(); 3188 } 3189 3190 static int __init journal_init(void) 3191 { 3192 int ret; 3193 3194 BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024); 3195 3196 ret = journal_init_caches(); 3197 if (ret == 0) { 3198 jbd2_create_jbd_stats_proc_entry(); 3199 } else { 3200 jbd2_journal_destroy_caches(); 3201 } 3202 return ret; 3203 } 3204 3205 static void __exit journal_exit(void) 3206 { 3207 #ifdef CONFIG_JBD2_DEBUG 3208 int n = atomic_read(&nr_journal_heads); 3209 if (n) 3210 printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n); 3211 #endif 3212 jbd2_remove_jbd_stats_proc_entry(); 3213 jbd2_journal_destroy_caches(); 3214 } 3215 3216 MODULE_LICENSE("GPL"); 3217 module_init(journal_init); 3218 module_exit(journal_exit); 3219 3220