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 EXPORT_SYMBOL(jbd2_journal_register_shrinker); 2126 2127 /** 2128 * jbd2_journal_unregister_shrinker() 2129 * @journal: Journal to act on. 2130 * 2131 * Unregister the checkpointed buffer shrinker and destroy the percpu counter. 2132 */ 2133 void jbd2_journal_unregister_shrinker(journal_t *journal) 2134 { 2135 percpu_counter_destroy(&journal->j_jh_shrink_count); 2136 unregister_shrinker(&journal->j_shrinker); 2137 } 2138 EXPORT_SYMBOL(jbd2_journal_unregister_shrinker); 2139 2140 /** 2141 * jbd2_journal_destroy() - Release a journal_t structure. 2142 * @journal: Journal to act on. 2143 * 2144 * Release a journal_t structure once it is no longer in use by the 2145 * journaled object. 2146 * Return <0 if we couldn't clean up the journal. 2147 */ 2148 int jbd2_journal_destroy(journal_t *journal) 2149 { 2150 int err = 0; 2151 2152 /* Wait for the commit thread to wake up and die. */ 2153 journal_kill_thread(journal); 2154 2155 /* Force a final log commit */ 2156 if (journal->j_running_transaction) 2157 jbd2_journal_commit_transaction(journal); 2158 2159 /* Force any old transactions to disk */ 2160 2161 /* Totally anal locking here... */ 2162 spin_lock(&journal->j_list_lock); 2163 while (journal->j_checkpoint_transactions != NULL) { 2164 spin_unlock(&journal->j_list_lock); 2165 mutex_lock_io(&journal->j_checkpoint_mutex); 2166 err = jbd2_log_do_checkpoint(journal); 2167 mutex_unlock(&journal->j_checkpoint_mutex); 2168 /* 2169 * If checkpointing failed, just free the buffers to avoid 2170 * looping forever 2171 */ 2172 if (err) { 2173 jbd2_journal_destroy_checkpoint(journal); 2174 spin_lock(&journal->j_list_lock); 2175 break; 2176 } 2177 spin_lock(&journal->j_list_lock); 2178 } 2179 2180 J_ASSERT(journal->j_running_transaction == NULL); 2181 J_ASSERT(journal->j_committing_transaction == NULL); 2182 J_ASSERT(journal->j_checkpoint_transactions == NULL); 2183 spin_unlock(&journal->j_list_lock); 2184 2185 /* 2186 * OK, all checkpoint transactions have been checked, now check the 2187 * write out io error flag and abort the journal if some buffer failed 2188 * to write back to the original location, otherwise the filesystem 2189 * may become inconsistent. 2190 */ 2191 if (!is_journal_aborted(journal) && 2192 test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) 2193 jbd2_journal_abort(journal, -EIO); 2194 2195 if (journal->j_sb_buffer) { 2196 if (!is_journal_aborted(journal)) { 2197 mutex_lock_io(&journal->j_checkpoint_mutex); 2198 2199 write_lock(&journal->j_state_lock); 2200 journal->j_tail_sequence = 2201 ++journal->j_transaction_sequence; 2202 write_unlock(&journal->j_state_lock); 2203 2204 jbd2_mark_journal_empty(journal, 2205 REQ_SYNC | REQ_PREFLUSH | REQ_FUA); 2206 mutex_unlock(&journal->j_checkpoint_mutex); 2207 } else 2208 err = -EIO; 2209 brelse(journal->j_sb_buffer); 2210 } 2211 2212 jbd2_journal_unregister_shrinker(journal); 2213 2214 if (journal->j_proc_entry) 2215 jbd2_stats_proc_exit(journal); 2216 iput(journal->j_inode); 2217 if (journal->j_revoke) 2218 jbd2_journal_destroy_revoke(journal); 2219 if (journal->j_chksum_driver) 2220 crypto_free_shash(journal->j_chksum_driver); 2221 kfree(journal->j_fc_wbuf); 2222 kfree(journal->j_wbuf); 2223 kfree(journal); 2224 2225 return err; 2226 } 2227 2228 2229 /** 2230 * jbd2_journal_check_used_features() - Check if features specified are used. 2231 * @journal: Journal to check. 2232 * @compat: bitmask of compatible features 2233 * @ro: bitmask of features that force read-only mount 2234 * @incompat: bitmask of incompatible features 2235 * 2236 * Check whether the journal uses all of a given set of 2237 * features. Return true (non-zero) if it does. 2238 **/ 2239 2240 int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat, 2241 unsigned long ro, unsigned long incompat) 2242 { 2243 journal_superblock_t *sb; 2244 2245 if (!compat && !ro && !incompat) 2246 return 1; 2247 /* Load journal superblock if it is not loaded yet. */ 2248 if (journal->j_format_version == 0 && 2249 journal_get_superblock(journal) != 0) 2250 return 0; 2251 if (journal->j_format_version == 1) 2252 return 0; 2253 2254 sb = journal->j_superblock; 2255 2256 if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) && 2257 ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) && 2258 ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat)) 2259 return 1; 2260 2261 return 0; 2262 } 2263 2264 /** 2265 * jbd2_journal_check_available_features() - Check feature set in journalling layer 2266 * @journal: Journal to check. 2267 * @compat: bitmask of compatible features 2268 * @ro: bitmask of features that force read-only mount 2269 * @incompat: bitmask of incompatible features 2270 * 2271 * Check whether the journaling code supports the use of 2272 * all of a given set of features on this journal. Return true 2273 * (non-zero) if it can. */ 2274 2275 int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat, 2276 unsigned long ro, unsigned long incompat) 2277 { 2278 if (!compat && !ro && !incompat) 2279 return 1; 2280 2281 /* We can support any known requested features iff the 2282 * superblock is in version 2. Otherwise we fail to support any 2283 * extended sb features. */ 2284 2285 if (journal->j_format_version != 2) 2286 return 0; 2287 2288 if ((compat & JBD2_KNOWN_COMPAT_FEATURES) == compat && 2289 (ro & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro && 2290 (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat) 2291 return 1; 2292 2293 return 0; 2294 } 2295 2296 static int 2297 jbd2_journal_initialize_fast_commit(journal_t *journal) 2298 { 2299 journal_superblock_t *sb = journal->j_superblock; 2300 unsigned long long num_fc_blks; 2301 2302 num_fc_blks = jbd2_journal_get_num_fc_blks(sb); 2303 if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS) 2304 return -ENOSPC; 2305 2306 /* Are we called twice? */ 2307 WARN_ON(journal->j_fc_wbuf != NULL); 2308 journal->j_fc_wbuf = kmalloc_array(num_fc_blks, 2309 sizeof(struct buffer_head *), GFP_KERNEL); 2310 if (!journal->j_fc_wbuf) 2311 return -ENOMEM; 2312 2313 journal->j_fc_wbufsize = num_fc_blks; 2314 journal->j_fc_last = journal->j_last; 2315 journal->j_last = journal->j_fc_last - num_fc_blks; 2316 journal->j_fc_first = journal->j_last + 1; 2317 journal->j_fc_off = 0; 2318 journal->j_free = journal->j_last - journal->j_first; 2319 journal->j_max_transaction_buffers = 2320 jbd2_journal_get_max_txn_bufs(journal); 2321 2322 return 0; 2323 } 2324 2325 /** 2326 * jbd2_journal_set_features() - Mark a given journal feature in the superblock 2327 * @journal: Journal to act on. 2328 * @compat: bitmask of compatible features 2329 * @ro: bitmask of features that force read-only mount 2330 * @incompat: bitmask of incompatible features 2331 * 2332 * Mark a given journal feature as present on the 2333 * superblock. Returns true if the requested features could be set. 2334 * 2335 */ 2336 2337 int jbd2_journal_set_features(journal_t *journal, unsigned long compat, 2338 unsigned long ro, unsigned long incompat) 2339 { 2340 #define INCOMPAT_FEATURE_ON(f) \ 2341 ((incompat & (f)) && !(sb->s_feature_incompat & cpu_to_be32(f))) 2342 #define COMPAT_FEATURE_ON(f) \ 2343 ((compat & (f)) && !(sb->s_feature_compat & cpu_to_be32(f))) 2344 journal_superblock_t *sb; 2345 2346 if (jbd2_journal_check_used_features(journal, compat, ro, incompat)) 2347 return 1; 2348 2349 if (!jbd2_journal_check_available_features(journal, compat, ro, incompat)) 2350 return 0; 2351 2352 /* If enabling v2 checksums, turn on v3 instead */ 2353 if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V2) { 2354 incompat &= ~JBD2_FEATURE_INCOMPAT_CSUM_V2; 2355 incompat |= JBD2_FEATURE_INCOMPAT_CSUM_V3; 2356 } 2357 2358 /* Asking for checksumming v3 and v1? Only give them v3. */ 2359 if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V3 && 2360 compat & JBD2_FEATURE_COMPAT_CHECKSUM) 2361 compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM; 2362 2363 jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n", 2364 compat, ro, incompat); 2365 2366 sb = journal->j_superblock; 2367 2368 if (incompat & JBD2_FEATURE_INCOMPAT_FAST_COMMIT) { 2369 if (jbd2_journal_initialize_fast_commit(journal)) { 2370 pr_err("JBD2: Cannot enable fast commits.\n"); 2371 return 0; 2372 } 2373 } 2374 2375 /* Load the checksum driver if necessary */ 2376 if ((journal->j_chksum_driver == NULL) && 2377 INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) { 2378 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); 2379 if (IS_ERR(journal->j_chksum_driver)) { 2380 printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n"); 2381 journal->j_chksum_driver = NULL; 2382 return 0; 2383 } 2384 /* Precompute checksum seed for all metadata */ 2385 journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid, 2386 sizeof(sb->s_uuid)); 2387 } 2388 2389 lock_buffer(journal->j_sb_buffer); 2390 2391 /* If enabling v3 checksums, update superblock */ 2392 if (INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) { 2393 sb->s_checksum_type = JBD2_CRC32C_CHKSUM; 2394 sb->s_feature_compat &= 2395 ~cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM); 2396 } 2397 2398 /* If enabling v1 checksums, downgrade superblock */ 2399 if (COMPAT_FEATURE_ON(JBD2_FEATURE_COMPAT_CHECKSUM)) 2400 sb->s_feature_incompat &= 2401 ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_CSUM_V2 | 2402 JBD2_FEATURE_INCOMPAT_CSUM_V3); 2403 2404 sb->s_feature_compat |= cpu_to_be32(compat); 2405 sb->s_feature_ro_compat |= cpu_to_be32(ro); 2406 sb->s_feature_incompat |= cpu_to_be32(incompat); 2407 unlock_buffer(journal->j_sb_buffer); 2408 journal->j_revoke_records_per_block = 2409 journal_revoke_records_per_block(journal); 2410 2411 return 1; 2412 #undef COMPAT_FEATURE_ON 2413 #undef INCOMPAT_FEATURE_ON 2414 } 2415 2416 /* 2417 * jbd2_journal_clear_features() - Clear a given journal feature in the 2418 * superblock 2419 * @journal: Journal to act on. 2420 * @compat: bitmask of compatible features 2421 * @ro: bitmask of features that force read-only mount 2422 * @incompat: bitmask of incompatible features 2423 * 2424 * Clear a given journal feature as present on the 2425 * superblock. 2426 */ 2427 void jbd2_journal_clear_features(journal_t *journal, unsigned long compat, 2428 unsigned long ro, unsigned long incompat) 2429 { 2430 journal_superblock_t *sb; 2431 2432 jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n", 2433 compat, ro, incompat); 2434 2435 sb = journal->j_superblock; 2436 2437 sb->s_feature_compat &= ~cpu_to_be32(compat); 2438 sb->s_feature_ro_compat &= ~cpu_to_be32(ro); 2439 sb->s_feature_incompat &= ~cpu_to_be32(incompat); 2440 journal->j_revoke_records_per_block = 2441 journal_revoke_records_per_block(journal); 2442 } 2443 EXPORT_SYMBOL(jbd2_journal_clear_features); 2444 2445 /** 2446 * jbd2_journal_flush() - Flush journal 2447 * @journal: Journal to act on. 2448 * @flags: optional operation on the journal blocks after the flush (see below) 2449 * 2450 * Flush all data for a given journal to disk and empty the journal. 2451 * Filesystems can use this when remounting readonly to ensure that 2452 * recovery does not need to happen on remount. Optionally, a discard or zeroout 2453 * can be issued on the journal blocks after flushing. 2454 * 2455 * flags: 2456 * JBD2_JOURNAL_FLUSH_DISCARD: issues discards for the journal blocks 2457 * JBD2_JOURNAL_FLUSH_ZEROOUT: issues zeroouts for the journal blocks 2458 */ 2459 int jbd2_journal_flush(journal_t *journal, unsigned int flags) 2460 { 2461 int err = 0; 2462 transaction_t *transaction = NULL; 2463 2464 write_lock(&journal->j_state_lock); 2465 2466 /* Force everything buffered to the log... */ 2467 if (journal->j_running_transaction) { 2468 transaction = journal->j_running_transaction; 2469 __jbd2_log_start_commit(journal, transaction->t_tid); 2470 } else if (journal->j_committing_transaction) 2471 transaction = journal->j_committing_transaction; 2472 2473 /* Wait for the log commit to complete... */ 2474 if (transaction) { 2475 tid_t tid = transaction->t_tid; 2476 2477 write_unlock(&journal->j_state_lock); 2478 jbd2_log_wait_commit(journal, tid); 2479 } else { 2480 write_unlock(&journal->j_state_lock); 2481 } 2482 2483 /* ...and flush everything in the log out to disk. */ 2484 spin_lock(&journal->j_list_lock); 2485 while (!err && journal->j_checkpoint_transactions != NULL) { 2486 spin_unlock(&journal->j_list_lock); 2487 mutex_lock_io(&journal->j_checkpoint_mutex); 2488 err = jbd2_log_do_checkpoint(journal); 2489 mutex_unlock(&journal->j_checkpoint_mutex); 2490 spin_lock(&journal->j_list_lock); 2491 } 2492 spin_unlock(&journal->j_list_lock); 2493 2494 if (is_journal_aborted(journal)) 2495 return -EIO; 2496 2497 mutex_lock_io(&journal->j_checkpoint_mutex); 2498 if (!err) { 2499 err = jbd2_cleanup_journal_tail(journal); 2500 if (err < 0) { 2501 mutex_unlock(&journal->j_checkpoint_mutex); 2502 goto out; 2503 } 2504 err = 0; 2505 } 2506 2507 /* Finally, mark the journal as really needing no recovery. 2508 * This sets s_start==0 in the underlying superblock, which is 2509 * the magic code for a fully-recovered superblock. Any future 2510 * commits of data to the journal will restore the current 2511 * s_start value. */ 2512 jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA); 2513 2514 if (flags) 2515 err = __jbd2_journal_erase(journal, flags); 2516 2517 mutex_unlock(&journal->j_checkpoint_mutex); 2518 write_lock(&journal->j_state_lock); 2519 J_ASSERT(!journal->j_running_transaction); 2520 J_ASSERT(!journal->j_committing_transaction); 2521 J_ASSERT(!journal->j_checkpoint_transactions); 2522 J_ASSERT(journal->j_head == journal->j_tail); 2523 J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence); 2524 write_unlock(&journal->j_state_lock); 2525 out: 2526 return err; 2527 } 2528 2529 /** 2530 * jbd2_journal_wipe() - Wipe journal contents 2531 * @journal: Journal to act on. 2532 * @write: flag (see below) 2533 * 2534 * Wipe out all of the contents of a journal, safely. This will produce 2535 * a warning if the journal contains any valid recovery information. 2536 * Must be called between journal_init_*() and jbd2_journal_load(). 2537 * 2538 * If 'write' is non-zero, then we wipe out the journal on disk; otherwise 2539 * we merely suppress recovery. 2540 */ 2541 2542 int jbd2_journal_wipe(journal_t *journal, int write) 2543 { 2544 int err = 0; 2545 2546 J_ASSERT (!(journal->j_flags & JBD2_LOADED)); 2547 2548 err = load_superblock(journal); 2549 if (err) 2550 return err; 2551 2552 if (!journal->j_tail) 2553 goto no_recovery; 2554 2555 printk(KERN_WARNING "JBD2: %s recovery information on journal\n", 2556 write ? "Clearing" : "Ignoring"); 2557 2558 err = jbd2_journal_skip_recovery(journal); 2559 if (write) { 2560 /* Lock to make assertions happy... */ 2561 mutex_lock_io(&journal->j_checkpoint_mutex); 2562 jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA); 2563 mutex_unlock(&journal->j_checkpoint_mutex); 2564 } 2565 2566 no_recovery: 2567 return err; 2568 } 2569 2570 /** 2571 * jbd2_journal_abort () - Shutdown the journal immediately. 2572 * @journal: the journal to shutdown. 2573 * @errno: an error number to record in the journal indicating 2574 * the reason for the shutdown. 2575 * 2576 * Perform a complete, immediate shutdown of the ENTIRE 2577 * journal (not of a single transaction). This operation cannot be 2578 * undone without closing and reopening the journal. 2579 * 2580 * The jbd2_journal_abort function is intended to support higher level error 2581 * recovery mechanisms such as the ext2/ext3 remount-readonly error 2582 * mode. 2583 * 2584 * Journal abort has very specific semantics. Any existing dirty, 2585 * unjournaled buffers in the main filesystem will still be written to 2586 * disk by bdflush, but the journaling mechanism will be suspended 2587 * immediately and no further transaction commits will be honoured. 2588 * 2589 * Any dirty, journaled buffers will be written back to disk without 2590 * hitting the journal. Atomicity cannot be guaranteed on an aborted 2591 * filesystem, but we _do_ attempt to leave as much data as possible 2592 * behind for fsck to use for cleanup. 2593 * 2594 * Any attempt to get a new transaction handle on a journal which is in 2595 * ABORT state will just result in an -EROFS error return. A 2596 * jbd2_journal_stop on an existing handle will return -EIO if we have 2597 * entered abort state during the update. 2598 * 2599 * Recursive transactions are not disturbed by journal abort until the 2600 * final jbd2_journal_stop, which will receive the -EIO error. 2601 * 2602 * Finally, the jbd2_journal_abort call allows the caller to supply an errno 2603 * which will be recorded (if possible) in the journal superblock. This 2604 * allows a client to record failure conditions in the middle of a 2605 * transaction without having to complete the transaction to record the 2606 * failure to disk. ext3_error, for example, now uses this 2607 * functionality. 2608 * 2609 */ 2610 2611 void jbd2_journal_abort(journal_t *journal, int errno) 2612 { 2613 transaction_t *transaction; 2614 2615 /* 2616 * Lock the aborting procedure until everything is done, this avoid 2617 * races between filesystem's error handling flow (e.g. ext4_abort()), 2618 * ensure panic after the error info is written into journal's 2619 * superblock. 2620 */ 2621 mutex_lock(&journal->j_abort_mutex); 2622 /* 2623 * ESHUTDOWN always takes precedence because a file system check 2624 * caused by any other journal abort error is not required after 2625 * a shutdown triggered. 2626 */ 2627 write_lock(&journal->j_state_lock); 2628 if (journal->j_flags & JBD2_ABORT) { 2629 int old_errno = journal->j_errno; 2630 2631 write_unlock(&journal->j_state_lock); 2632 if (old_errno != -ESHUTDOWN && errno == -ESHUTDOWN) { 2633 journal->j_errno = errno; 2634 jbd2_journal_update_sb_errno(journal); 2635 } 2636 mutex_unlock(&journal->j_abort_mutex); 2637 return; 2638 } 2639 2640 /* 2641 * Mark the abort as occurred and start current running transaction 2642 * to release all journaled buffer. 2643 */ 2644 pr_err("Aborting journal on device %s.\n", journal->j_devname); 2645 2646 journal->j_flags |= JBD2_ABORT; 2647 journal->j_errno = errno; 2648 transaction = journal->j_running_transaction; 2649 if (transaction) 2650 __jbd2_log_start_commit(journal, transaction->t_tid); 2651 write_unlock(&journal->j_state_lock); 2652 2653 /* 2654 * Record errno to the journal super block, so that fsck and jbd2 2655 * layer could realise that a filesystem check is needed. 2656 */ 2657 jbd2_journal_update_sb_errno(journal); 2658 mutex_unlock(&journal->j_abort_mutex); 2659 } 2660 2661 /** 2662 * jbd2_journal_errno() - returns the journal's error state. 2663 * @journal: journal to examine. 2664 * 2665 * This is the errno number set with jbd2_journal_abort(), the last 2666 * time the journal was mounted - if the journal was stopped 2667 * without calling abort this will be 0. 2668 * 2669 * If the journal has been aborted on this mount time -EROFS will 2670 * be returned. 2671 */ 2672 int jbd2_journal_errno(journal_t *journal) 2673 { 2674 int err; 2675 2676 read_lock(&journal->j_state_lock); 2677 if (journal->j_flags & JBD2_ABORT) 2678 err = -EROFS; 2679 else 2680 err = journal->j_errno; 2681 read_unlock(&journal->j_state_lock); 2682 return err; 2683 } 2684 2685 /** 2686 * jbd2_journal_clear_err() - clears the journal's error state 2687 * @journal: journal to act on. 2688 * 2689 * An error must be cleared or acked to take a FS out of readonly 2690 * mode. 2691 */ 2692 int jbd2_journal_clear_err(journal_t *journal) 2693 { 2694 int err = 0; 2695 2696 write_lock(&journal->j_state_lock); 2697 if (journal->j_flags & JBD2_ABORT) 2698 err = -EROFS; 2699 else 2700 journal->j_errno = 0; 2701 write_unlock(&journal->j_state_lock); 2702 return err; 2703 } 2704 2705 /** 2706 * jbd2_journal_ack_err() - Ack journal err. 2707 * @journal: journal to act on. 2708 * 2709 * An error must be cleared or acked to take a FS out of readonly 2710 * mode. 2711 */ 2712 void jbd2_journal_ack_err(journal_t *journal) 2713 { 2714 write_lock(&journal->j_state_lock); 2715 if (journal->j_errno) 2716 journal->j_flags |= JBD2_ACK_ERR; 2717 write_unlock(&journal->j_state_lock); 2718 } 2719 2720 int jbd2_journal_blocks_per_page(struct inode *inode) 2721 { 2722 return 1 << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits); 2723 } 2724 2725 /* 2726 * helper functions to deal with 32 or 64bit block numbers. 2727 */ 2728 size_t journal_tag_bytes(journal_t *journal) 2729 { 2730 size_t sz; 2731 2732 if (jbd2_has_feature_csum3(journal)) 2733 return sizeof(journal_block_tag3_t); 2734 2735 sz = sizeof(journal_block_tag_t); 2736 2737 if (jbd2_has_feature_csum2(journal)) 2738 sz += sizeof(__u16); 2739 2740 if (jbd2_has_feature_64bit(journal)) 2741 return sz; 2742 else 2743 return sz - sizeof(__u32); 2744 } 2745 2746 /* 2747 * JBD memory management 2748 * 2749 * These functions are used to allocate block-sized chunks of memory 2750 * used for making copies of buffer_head data. Very often it will be 2751 * page-sized chunks of data, but sometimes it will be in 2752 * sub-page-size chunks. (For example, 16k pages on Power systems 2753 * with a 4k block file system.) For blocks smaller than a page, we 2754 * use a SLAB allocator. There are slab caches for each block size, 2755 * which are allocated at mount time, if necessary, and we only free 2756 * (all of) the slab caches when/if the jbd2 module is unloaded. For 2757 * this reason we don't need to a mutex to protect access to 2758 * jbd2_slab[] allocating or releasing memory; only in 2759 * jbd2_journal_create_slab(). 2760 */ 2761 #define JBD2_MAX_SLABS 8 2762 static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS]; 2763 2764 static const char *jbd2_slab_names[JBD2_MAX_SLABS] = { 2765 "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k", 2766 "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k" 2767 }; 2768 2769 2770 static void jbd2_journal_destroy_slabs(void) 2771 { 2772 int i; 2773 2774 for (i = 0; i < JBD2_MAX_SLABS; i++) { 2775 kmem_cache_destroy(jbd2_slab[i]); 2776 jbd2_slab[i] = NULL; 2777 } 2778 } 2779 2780 static int jbd2_journal_create_slab(size_t size) 2781 { 2782 static DEFINE_MUTEX(jbd2_slab_create_mutex); 2783 int i = order_base_2(size) - 10; 2784 size_t slab_size; 2785 2786 if (size == PAGE_SIZE) 2787 return 0; 2788 2789 if (i >= JBD2_MAX_SLABS) 2790 return -EINVAL; 2791 2792 if (unlikely(i < 0)) 2793 i = 0; 2794 mutex_lock(&jbd2_slab_create_mutex); 2795 if (jbd2_slab[i]) { 2796 mutex_unlock(&jbd2_slab_create_mutex); 2797 return 0; /* Already created */ 2798 } 2799 2800 slab_size = 1 << (i+10); 2801 jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size, 2802 slab_size, 0, NULL); 2803 mutex_unlock(&jbd2_slab_create_mutex); 2804 if (!jbd2_slab[i]) { 2805 printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n"); 2806 return -ENOMEM; 2807 } 2808 return 0; 2809 } 2810 2811 static struct kmem_cache *get_slab(size_t size) 2812 { 2813 int i = order_base_2(size) - 10; 2814 2815 BUG_ON(i >= JBD2_MAX_SLABS); 2816 if (unlikely(i < 0)) 2817 i = 0; 2818 BUG_ON(jbd2_slab[i] == NULL); 2819 return jbd2_slab[i]; 2820 } 2821 2822 void *jbd2_alloc(size_t size, gfp_t flags) 2823 { 2824 void *ptr; 2825 2826 BUG_ON(size & (size-1)); /* Must be a power of 2 */ 2827 2828 if (size < PAGE_SIZE) 2829 ptr = kmem_cache_alloc(get_slab(size), flags); 2830 else 2831 ptr = (void *)__get_free_pages(flags, get_order(size)); 2832 2833 /* Check alignment; SLUB has gotten this wrong in the past, 2834 * and this can lead to user data corruption! */ 2835 BUG_ON(((unsigned long) ptr) & (size-1)); 2836 2837 return ptr; 2838 } 2839 2840 void jbd2_free(void *ptr, size_t size) 2841 { 2842 if (size < PAGE_SIZE) 2843 kmem_cache_free(get_slab(size), ptr); 2844 else 2845 free_pages((unsigned long)ptr, get_order(size)); 2846 }; 2847 2848 /* 2849 * Journal_head storage management 2850 */ 2851 static struct kmem_cache *jbd2_journal_head_cache; 2852 #ifdef CONFIG_JBD2_DEBUG 2853 static atomic_t nr_journal_heads = ATOMIC_INIT(0); 2854 #endif 2855 2856 static int __init jbd2_journal_init_journal_head_cache(void) 2857 { 2858 J_ASSERT(!jbd2_journal_head_cache); 2859 jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head", 2860 sizeof(struct journal_head), 2861 0, /* offset */ 2862 SLAB_TEMPORARY | SLAB_TYPESAFE_BY_RCU, 2863 NULL); /* ctor */ 2864 if (!jbd2_journal_head_cache) { 2865 printk(KERN_EMERG "JBD2: no memory for journal_head cache\n"); 2866 return -ENOMEM; 2867 } 2868 return 0; 2869 } 2870 2871 static void jbd2_journal_destroy_journal_head_cache(void) 2872 { 2873 kmem_cache_destroy(jbd2_journal_head_cache); 2874 jbd2_journal_head_cache = NULL; 2875 } 2876 2877 /* 2878 * journal_head splicing and dicing 2879 */ 2880 static struct journal_head *journal_alloc_journal_head(void) 2881 { 2882 struct journal_head *ret; 2883 2884 #ifdef CONFIG_JBD2_DEBUG 2885 atomic_inc(&nr_journal_heads); 2886 #endif 2887 ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS); 2888 if (!ret) { 2889 jbd_debug(1, "out of memory for journal_head\n"); 2890 pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__); 2891 ret = kmem_cache_zalloc(jbd2_journal_head_cache, 2892 GFP_NOFS | __GFP_NOFAIL); 2893 } 2894 if (ret) 2895 spin_lock_init(&ret->b_state_lock); 2896 return ret; 2897 } 2898 2899 static void journal_free_journal_head(struct journal_head *jh) 2900 { 2901 #ifdef CONFIG_JBD2_DEBUG 2902 atomic_dec(&nr_journal_heads); 2903 memset(jh, JBD2_POISON_FREE, sizeof(*jh)); 2904 #endif 2905 kmem_cache_free(jbd2_journal_head_cache, jh); 2906 } 2907 2908 /* 2909 * A journal_head is attached to a buffer_head whenever JBD has an 2910 * interest in the buffer. 2911 * 2912 * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit 2913 * is set. This bit is tested in core kernel code where we need to take 2914 * JBD-specific actions. Testing the zeroness of ->b_private is not reliable 2915 * there. 2916 * 2917 * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one. 2918 * 2919 * When a buffer has its BH_JBD bit set it is immune from being released by 2920 * core kernel code, mainly via ->b_count. 2921 * 2922 * A journal_head is detached from its buffer_head when the journal_head's 2923 * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint 2924 * transaction (b_cp_transaction) hold their references to b_jcount. 2925 * 2926 * Various places in the kernel want to attach a journal_head to a buffer_head 2927 * _before_ attaching the journal_head to a transaction. To protect the 2928 * journal_head in this situation, jbd2_journal_add_journal_head elevates the 2929 * journal_head's b_jcount refcount by one. The caller must call 2930 * jbd2_journal_put_journal_head() to undo this. 2931 * 2932 * So the typical usage would be: 2933 * 2934 * (Attach a journal_head if needed. Increments b_jcount) 2935 * struct journal_head *jh = jbd2_journal_add_journal_head(bh); 2936 * ... 2937 * (Get another reference for transaction) 2938 * jbd2_journal_grab_journal_head(bh); 2939 * jh->b_transaction = xxx; 2940 * (Put original reference) 2941 * jbd2_journal_put_journal_head(jh); 2942 */ 2943 2944 /* 2945 * Give a buffer_head a journal_head. 2946 * 2947 * May sleep. 2948 */ 2949 struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh) 2950 { 2951 struct journal_head *jh; 2952 struct journal_head *new_jh = NULL; 2953 2954 repeat: 2955 if (!buffer_jbd(bh)) 2956 new_jh = journal_alloc_journal_head(); 2957 2958 jbd_lock_bh_journal_head(bh); 2959 if (buffer_jbd(bh)) { 2960 jh = bh2jh(bh); 2961 } else { 2962 J_ASSERT_BH(bh, 2963 (atomic_read(&bh->b_count) > 0) || 2964 (bh->b_page && bh->b_page->mapping)); 2965 2966 if (!new_jh) { 2967 jbd_unlock_bh_journal_head(bh); 2968 goto repeat; 2969 } 2970 2971 jh = new_jh; 2972 new_jh = NULL; /* We consumed it */ 2973 set_buffer_jbd(bh); 2974 bh->b_private = jh; 2975 jh->b_bh = bh; 2976 get_bh(bh); 2977 BUFFER_TRACE(bh, "added journal_head"); 2978 } 2979 jh->b_jcount++; 2980 jbd_unlock_bh_journal_head(bh); 2981 if (new_jh) 2982 journal_free_journal_head(new_jh); 2983 return bh->b_private; 2984 } 2985 2986 /* 2987 * Grab a ref against this buffer_head's journal_head. If it ended up not 2988 * having a journal_head, return NULL 2989 */ 2990 struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh) 2991 { 2992 struct journal_head *jh = NULL; 2993 2994 jbd_lock_bh_journal_head(bh); 2995 if (buffer_jbd(bh)) { 2996 jh = bh2jh(bh); 2997 jh->b_jcount++; 2998 } 2999 jbd_unlock_bh_journal_head(bh); 3000 return jh; 3001 } 3002 3003 static void __journal_remove_journal_head(struct buffer_head *bh) 3004 { 3005 struct journal_head *jh = bh2jh(bh); 3006 3007 J_ASSERT_JH(jh, jh->b_transaction == NULL); 3008 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 3009 J_ASSERT_JH(jh, jh->b_cp_transaction == NULL); 3010 J_ASSERT_JH(jh, jh->b_jlist == BJ_None); 3011 J_ASSERT_BH(bh, buffer_jbd(bh)); 3012 J_ASSERT_BH(bh, jh2bh(jh) == bh); 3013 BUFFER_TRACE(bh, "remove journal_head"); 3014 3015 /* Unlink before dropping the lock */ 3016 bh->b_private = NULL; 3017 jh->b_bh = NULL; /* debug, really */ 3018 clear_buffer_jbd(bh); 3019 } 3020 3021 static void journal_release_journal_head(struct journal_head *jh, size_t b_size) 3022 { 3023 if (jh->b_frozen_data) { 3024 printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__); 3025 jbd2_free(jh->b_frozen_data, b_size); 3026 } 3027 if (jh->b_committed_data) { 3028 printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__); 3029 jbd2_free(jh->b_committed_data, b_size); 3030 } 3031 journal_free_journal_head(jh); 3032 } 3033 3034 /* 3035 * Drop a reference on the passed journal_head. If it fell to zero then 3036 * release the journal_head from the buffer_head. 3037 */ 3038 void jbd2_journal_put_journal_head(struct journal_head *jh) 3039 { 3040 struct buffer_head *bh = jh2bh(jh); 3041 3042 jbd_lock_bh_journal_head(bh); 3043 J_ASSERT_JH(jh, jh->b_jcount > 0); 3044 --jh->b_jcount; 3045 if (!jh->b_jcount) { 3046 __journal_remove_journal_head(bh); 3047 jbd_unlock_bh_journal_head(bh); 3048 journal_release_journal_head(jh, bh->b_size); 3049 __brelse(bh); 3050 } else { 3051 jbd_unlock_bh_journal_head(bh); 3052 } 3053 } 3054 3055 /* 3056 * Initialize jbd inode head 3057 */ 3058 void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode) 3059 { 3060 jinode->i_transaction = NULL; 3061 jinode->i_next_transaction = NULL; 3062 jinode->i_vfs_inode = inode; 3063 jinode->i_flags = 0; 3064 jinode->i_dirty_start = 0; 3065 jinode->i_dirty_end = 0; 3066 INIT_LIST_HEAD(&jinode->i_list); 3067 } 3068 3069 /* 3070 * Function to be called before we start removing inode from memory (i.e., 3071 * clear_inode() is a fine place to be called from). It removes inode from 3072 * transaction's lists. 3073 */ 3074 void jbd2_journal_release_jbd_inode(journal_t *journal, 3075 struct jbd2_inode *jinode) 3076 { 3077 if (!journal) 3078 return; 3079 restart: 3080 spin_lock(&journal->j_list_lock); 3081 /* Is commit writing out inode - we have to wait */ 3082 if (jinode->i_flags & JI_COMMIT_RUNNING) { 3083 wait_queue_head_t *wq; 3084 DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING); 3085 wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING); 3086 prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE); 3087 spin_unlock(&journal->j_list_lock); 3088 schedule(); 3089 finish_wait(wq, &wait.wq_entry); 3090 goto restart; 3091 } 3092 3093 if (jinode->i_transaction) { 3094 list_del(&jinode->i_list); 3095 jinode->i_transaction = NULL; 3096 } 3097 spin_unlock(&journal->j_list_lock); 3098 } 3099 3100 3101 #ifdef CONFIG_PROC_FS 3102 3103 #define JBD2_STATS_PROC_NAME "fs/jbd2" 3104 3105 static void __init jbd2_create_jbd_stats_proc_entry(void) 3106 { 3107 proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL); 3108 } 3109 3110 static void __exit jbd2_remove_jbd_stats_proc_entry(void) 3111 { 3112 if (proc_jbd2_stats) 3113 remove_proc_entry(JBD2_STATS_PROC_NAME, NULL); 3114 } 3115 3116 #else 3117 3118 #define jbd2_create_jbd_stats_proc_entry() do {} while (0) 3119 #define jbd2_remove_jbd_stats_proc_entry() do {} while (0) 3120 3121 #endif 3122 3123 struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache; 3124 3125 static int __init jbd2_journal_init_inode_cache(void) 3126 { 3127 J_ASSERT(!jbd2_inode_cache); 3128 jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0); 3129 if (!jbd2_inode_cache) { 3130 pr_emerg("JBD2: failed to create inode cache\n"); 3131 return -ENOMEM; 3132 } 3133 return 0; 3134 } 3135 3136 static int __init jbd2_journal_init_handle_cache(void) 3137 { 3138 J_ASSERT(!jbd2_handle_cache); 3139 jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY); 3140 if (!jbd2_handle_cache) { 3141 printk(KERN_EMERG "JBD2: failed to create handle cache\n"); 3142 return -ENOMEM; 3143 } 3144 return 0; 3145 } 3146 3147 static void jbd2_journal_destroy_inode_cache(void) 3148 { 3149 kmem_cache_destroy(jbd2_inode_cache); 3150 jbd2_inode_cache = NULL; 3151 } 3152 3153 static void jbd2_journal_destroy_handle_cache(void) 3154 { 3155 kmem_cache_destroy(jbd2_handle_cache); 3156 jbd2_handle_cache = NULL; 3157 } 3158 3159 /* 3160 * Module startup and shutdown 3161 */ 3162 3163 static int __init journal_init_caches(void) 3164 { 3165 int ret; 3166 3167 ret = jbd2_journal_init_revoke_record_cache(); 3168 if (ret == 0) 3169 ret = jbd2_journal_init_revoke_table_cache(); 3170 if (ret == 0) 3171 ret = jbd2_journal_init_journal_head_cache(); 3172 if (ret == 0) 3173 ret = jbd2_journal_init_handle_cache(); 3174 if (ret == 0) 3175 ret = jbd2_journal_init_inode_cache(); 3176 if (ret == 0) 3177 ret = jbd2_journal_init_transaction_cache(); 3178 return ret; 3179 } 3180 3181 static void jbd2_journal_destroy_caches(void) 3182 { 3183 jbd2_journal_destroy_revoke_record_cache(); 3184 jbd2_journal_destroy_revoke_table_cache(); 3185 jbd2_journal_destroy_journal_head_cache(); 3186 jbd2_journal_destroy_handle_cache(); 3187 jbd2_journal_destroy_inode_cache(); 3188 jbd2_journal_destroy_transaction_cache(); 3189 jbd2_journal_destroy_slabs(); 3190 } 3191 3192 static int __init journal_init(void) 3193 { 3194 int ret; 3195 3196 BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024); 3197 3198 ret = journal_init_caches(); 3199 if (ret == 0) { 3200 jbd2_create_jbd_stats_proc_entry(); 3201 } else { 3202 jbd2_journal_destroy_caches(); 3203 } 3204 return ret; 3205 } 3206 3207 static void __exit journal_exit(void) 3208 { 3209 #ifdef CONFIG_JBD2_DEBUG 3210 int n = atomic_read(&nr_journal_heads); 3211 if (n) 3212 printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n); 3213 #endif 3214 jbd2_remove_jbd_stats_proc_entry(); 3215 jbd2_journal_destroy_caches(); 3216 } 3217 3218 MODULE_LICENSE("GPL"); 3219 module_init(journal_init); 3220 module_exit(journal_exit); 3221 3222