fs/jbd2/journal.c

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