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