LCOV - code coverage report
Current view: top level - fs/jbd2 - journal.c (source / functions) Hit Total Coverage
Test: Real Lines: 494 872 56.7 %
Date: 2020-10-17 15:46:16 Functions: 1 75 1.3 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14