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