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