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