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