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