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