LCOV - code coverage report
Current view: top level - include/linux - jbd2.h (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 53 63 84.1 %
Date: 2020-09-30 20:25:40 Functions: 3 4 75.0 %
Branches: 79 160 49.4 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0-or-later */
       2                 :            : /*
       3                 :            :  * linux/include/linux/jbd2.h
       4                 :            :  *
       5                 :            :  * Written by Stephen C. Tweedie <sct@redhat.com>
       6                 :            :  *
       7                 :            :  * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
       8                 :            :  *
       9                 :            :  * Definitions for transaction data structures for the buffer cache
      10                 :            :  * filesystem journaling support.
      11                 :            :  */
      12                 :            : 
      13                 :            : #ifndef _LINUX_JBD2_H
      14                 :            : #define _LINUX_JBD2_H
      15                 :            : 
      16                 :            : /* Allow this file to be included directly into e2fsprogs */
      17                 :            : #ifndef __KERNEL__
      18                 :            : #include "jfs_compat.h"
      19                 :            : #define JBD2_DEBUG
      20                 :            : #else
      21                 :            : 
      22                 :            : #include <linux/types.h>
      23                 :            : #include <linux/buffer_head.h>
      24                 :            : #include <linux/journal-head.h>
      25                 :            : #include <linux/stddef.h>
      26                 :            : #include <linux/mutex.h>
      27                 :            : #include <linux/timer.h>
      28                 :            : #include <linux/slab.h>
      29                 :            : #include <linux/bit_spinlock.h>
      30                 :            : #include <crypto/hash.h>
      31                 :            : #endif
      32                 :            : 
      33                 :            : #define journal_oom_retry 1
      34                 :            : 
      35                 :            : /*
      36                 :            :  * Define JBD2_PARANIOD_IOFAIL to cause a kernel BUG() if ext4 finds
      37                 :            :  * certain classes of error which can occur due to failed IOs.  Under
      38                 :            :  * normal use we want ext4 to continue after such errors, because
      39                 :            :  * hardware _can_ fail, but for debugging purposes when running tests on
      40                 :            :  * known-good hardware we may want to trap these errors.
      41                 :            :  */
      42                 :            : #undef JBD2_PARANOID_IOFAIL
      43                 :            : 
      44                 :            : /*
      45                 :            :  * The default maximum commit age, in seconds.
      46                 :            :  */
      47                 :            : #define JBD2_DEFAULT_MAX_COMMIT_AGE 5
      48                 :            : 
      49                 :            : #ifdef CONFIG_JBD2_DEBUG
      50                 :            : /*
      51                 :            :  * Define JBD2_EXPENSIVE_CHECKING to enable more expensive internal
      52                 :            :  * consistency checks.  By default we don't do this unless
      53                 :            :  * CONFIG_JBD2_DEBUG is on.
      54                 :            :  */
      55                 :            : #define JBD2_EXPENSIVE_CHECKING
      56                 :            : extern ushort jbd2_journal_enable_debug;
      57                 :            : void __jbd2_debug(int level, const char *file, const char *func,
      58                 :            :                   unsigned int line, const char *fmt, ...);
      59                 :            : 
      60                 :            : #define jbd_debug(n, fmt, a...) \
      61                 :            :         __jbd2_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a)
      62                 :            : #else
      63                 :            : #define jbd_debug(n, fmt, a...)    /**/
      64                 :            : #endif
      65                 :            : 
      66                 :            : extern void *jbd2_alloc(size_t size, gfp_t flags);
      67                 :            : extern void jbd2_free(void *ptr, size_t size);
      68                 :            : 
      69                 :            : #define JBD2_MIN_JOURNAL_BLOCKS 1024
      70                 :            : 
      71                 :            : #ifdef __KERNEL__
      72                 :            : 
      73                 :            : /**
      74                 :            :  * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
      75                 :            :  *
      76                 :            :  * All filesystem modifications made by the process go
      77                 :            :  * through this handle.  Recursive operations (such as quota operations)
      78                 :            :  * are gathered into a single update.
      79                 :            :  *
      80                 :            :  * The buffer credits field is used to account for journaled buffers
      81                 :            :  * being modified by the running process.  To ensure that there is
      82                 :            :  * enough log space for all outstanding operations, we need to limit the
      83                 :            :  * number of outstanding buffers possible at any time.  When the
      84                 :            :  * operation completes, any buffer credits not used are credited back to
      85                 :            :  * the transaction, so that at all times we know how many buffers the
      86                 :            :  * outstanding updates on a transaction might possibly touch.
      87                 :            :  *
      88                 :            :  * This is an opaque datatype.
      89                 :            :  **/
      90                 :            : typedef struct jbd2_journal_handle handle_t;    /* Atomic operation type */
      91                 :            : 
      92                 :            : 
      93                 :            : /**
      94                 :            :  * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
      95                 :            :  *
      96                 :            :  * journal_t is linked to from the fs superblock structure.
      97                 :            :  *
      98                 :            :  * We use the journal_t to keep track of all outstanding transaction
      99                 :            :  * activity on the filesystem, and to manage the state of the log
     100                 :            :  * writing process.
     101                 :            :  *
     102                 :            :  * This is an opaque datatype.
     103                 :            :  **/
     104                 :            : typedef struct journal_s        journal_t;      /* Journal control structure */
     105                 :            : #endif
     106                 :            : 
     107                 :            : /*
     108                 :            :  * Internal structures used by the logging mechanism:
     109                 :            :  */
     110                 :            : 
     111                 :            : #define JBD2_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
     112                 :            : 
     113                 :            : /*
     114                 :            :  * On-disk structures
     115                 :            :  */
     116                 :            : 
     117                 :            : /*
     118                 :            :  * Descriptor block types:
     119                 :            :  */
     120                 :            : 
     121                 :            : #define JBD2_DESCRIPTOR_BLOCK   1
     122                 :            : #define JBD2_COMMIT_BLOCK       2
     123                 :            : #define JBD2_SUPERBLOCK_V1      3
     124                 :            : #define JBD2_SUPERBLOCK_V2      4
     125                 :            : #define JBD2_REVOKE_BLOCK       5
     126                 :            : 
     127                 :            : /*
     128                 :            :  * Standard header for all descriptor blocks:
     129                 :            :  */
     130                 :            : typedef struct journal_header_s
     131                 :            : {
     132                 :            :         __be32          h_magic;
     133                 :            :         __be32          h_blocktype;
     134                 :            :         __be32          h_sequence;
     135                 :            : } journal_header_t;
     136                 :            : 
     137                 :            : /*
     138                 :            :  * Checksum types.
     139                 :            :  */
     140                 :            : #define JBD2_CRC32_CHKSUM   1
     141                 :            : #define JBD2_MD5_CHKSUM     2
     142                 :            : #define JBD2_SHA1_CHKSUM    3
     143                 :            : #define JBD2_CRC32C_CHKSUM  4
     144                 :            : 
     145                 :            : #define JBD2_CRC32_CHKSUM_SIZE 4
     146                 :            : 
     147                 :            : #define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
     148                 :            : /*
     149                 :            :  * Commit block header for storing transactional checksums:
     150                 :            :  *
     151                 :            :  * NOTE: If FEATURE_COMPAT_CHECKSUM (checksum v1) is set, the h_chksum*
     152                 :            :  * fields are used to store a checksum of the descriptor and data blocks.
     153                 :            :  *
     154                 :            :  * If FEATURE_INCOMPAT_CSUM_V2 (checksum v2) is set, then the h_chksum
     155                 :            :  * field is used to store crc32c(uuid+commit_block).  Each journal metadata
     156                 :            :  * block gets its own checksum, and data block checksums are stored in
     157                 :            :  * journal_block_tag (in the descriptor).  The other h_chksum* fields are
     158                 :            :  * not used.
     159                 :            :  *
     160                 :            :  * If FEATURE_INCOMPAT_CSUM_V3 is set, the descriptor block uses
     161                 :            :  * journal_block_tag3_t to store a full 32-bit checksum.  Everything else
     162                 :            :  * is the same as v2.
     163                 :            :  *
     164                 :            :  * Checksum v1, v2, and v3 are mutually exclusive features.
     165                 :            :  */
     166                 :            : struct commit_header {
     167                 :            :         __be32          h_magic;
     168                 :            :         __be32          h_blocktype;
     169                 :            :         __be32          h_sequence;
     170                 :            :         unsigned char   h_chksum_type;
     171                 :            :         unsigned char   h_chksum_size;
     172                 :            :         unsigned char   h_padding[2];
     173                 :            :         __be32          h_chksum[JBD2_CHECKSUM_BYTES];
     174                 :            :         __be64          h_commit_sec;
     175                 :            :         __be32          h_commit_nsec;
     176                 :            : };
     177                 :            : 
     178                 :            : /*
     179                 :            :  * The block tag: used to describe a single buffer in the journal.
     180                 :            :  * t_blocknr_high is only used if INCOMPAT_64BIT is set, so this
     181                 :            :  * raw struct shouldn't be used for pointer math or sizeof() - use
     182                 :            :  * journal_tag_bytes(journal) instead to compute this.
     183                 :            :  */
     184                 :            : typedef struct journal_block_tag3_s
     185                 :            : {
     186                 :            :         __be32          t_blocknr;      /* The on-disk block number */
     187                 :            :         __be32          t_flags;        /* See below */
     188                 :            :         __be32          t_blocknr_high; /* most-significant high 32bits. */
     189                 :            :         __be32          t_checksum;     /* crc32c(uuid+seq+block) */
     190                 :            : } journal_block_tag3_t;
     191                 :            : 
     192                 :            : typedef struct journal_block_tag_s
     193                 :            : {
     194                 :            :         __be32          t_blocknr;      /* The on-disk block number */
     195                 :            :         __be16          t_checksum;     /* truncated crc32c(uuid+seq+block) */
     196                 :            :         __be16          t_flags;        /* See below */
     197                 :            :         __be32          t_blocknr_high; /* most-significant high 32bits. */
     198                 :            : } journal_block_tag_t;
     199                 :            : 
     200                 :            : /* Tail of descriptor or revoke block, for checksumming */
     201                 :            : struct jbd2_journal_block_tail {
     202                 :            :         __be32          t_checksum;     /* crc32c(uuid+descr_block) */
     203                 :            : };
     204                 :            : 
     205                 :            : /*
     206                 :            :  * The revoke descriptor: used on disk to describe a series of blocks to
     207                 :            :  * be revoked from the log
     208                 :            :  */
     209                 :            : typedef struct jbd2_journal_revoke_header_s
     210                 :            : {
     211                 :            :         journal_header_t r_header;
     212                 :            :         __be32           r_count;       /* Count of bytes used in the block */
     213                 :            : } jbd2_journal_revoke_header_t;
     214                 :            : 
     215                 :            : /* Definitions for the journal tag flags word: */
     216                 :            : #define JBD2_FLAG_ESCAPE                1       /* on-disk block is escaped */
     217                 :            : #define JBD2_FLAG_SAME_UUID     2       /* block has same uuid as previous */
     218                 :            : #define JBD2_FLAG_DELETED       4       /* block deleted by this transaction */
     219                 :            : #define JBD2_FLAG_LAST_TAG      8       /* last tag in this descriptor block */
     220                 :            : 
     221                 :            : 
     222                 :            : /*
     223                 :            :  * The journal superblock.  All fields are in big-endian byte order.
     224                 :            :  */
     225                 :            : typedef struct journal_superblock_s
     226                 :            : {
     227                 :            : /* 0x0000 */
     228                 :            :         journal_header_t s_header;
     229                 :            : 
     230                 :            : /* 0x000C */
     231                 :            :         /* Static information describing the journal */
     232                 :            :         __be32  s_blocksize;            /* journal device blocksize */
     233                 :            :         __be32  s_maxlen;               /* total blocks in journal file */
     234                 :            :         __be32  s_first;                /* first block of log information */
     235                 :            : 
     236                 :            : /* 0x0018 */
     237                 :            :         /* Dynamic information describing the current state of the log */
     238                 :            :         __be32  s_sequence;             /* first commit ID expected in log */
     239                 :            :         __be32  s_start;                /* blocknr of start of log */
     240                 :            : 
     241                 :            : /* 0x0020 */
     242                 :            :         /* Error value, as set by jbd2_journal_abort(). */
     243                 :            :         __be32  s_errno;
     244                 :            : 
     245                 :            : /* 0x0024 */
     246                 :            :         /* Remaining fields are only valid in a version-2 superblock */
     247                 :            :         __be32  s_feature_compat;       /* compatible feature set */
     248                 :            :         __be32  s_feature_incompat;     /* incompatible feature set */
     249                 :            :         __be32  s_feature_ro_compat;    /* readonly-compatible feature set */
     250                 :            : /* 0x0030 */
     251                 :            :         __u8    s_uuid[16];             /* 128-bit uuid for journal */
     252                 :            : 
     253                 :            : /* 0x0040 */
     254                 :            :         __be32  s_nr_users;             /* Nr of filesystems sharing log */
     255                 :            : 
     256                 :            :         __be32  s_dynsuper;             /* Blocknr of dynamic superblock copy*/
     257                 :            : 
     258                 :            : /* 0x0048 */
     259                 :            :         __be32  s_max_transaction;      /* Limit of journal blocks per trans.*/
     260                 :            :         __be32  s_max_trans_data;       /* Limit of data blocks per trans. */
     261                 :            : 
     262                 :            : /* 0x0050 */
     263                 :            :         __u8    s_checksum_type;        /* checksum type */
     264                 :            :         __u8    s_padding2[3];
     265                 :            :         __u32   s_padding[42];
     266                 :            :         __be32  s_checksum;             /* crc32c(superblock) */
     267                 :            : 
     268                 :            : /* 0x0100 */
     269                 :            :         __u8    s_users[16*48];         /* ids of all fs'es sharing the log */
     270                 :            : /* 0x0400 */
     271                 :            : } journal_superblock_t;
     272                 :            : 
     273                 :            : /* Use the jbd2_{has,set,clear}_feature_* helpers; these will be removed */
     274                 :            : #define JBD2_HAS_COMPAT_FEATURE(j,mask)                                 \
     275                 :            :         ((j)->j_format_version >= 2 &&                                    \
     276                 :            :          ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
     277                 :            : #define JBD2_HAS_RO_COMPAT_FEATURE(j,mask)                              \
     278                 :            :         ((j)->j_format_version >= 2 &&                                    \
     279                 :            :          ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
     280                 :            : #define JBD2_HAS_INCOMPAT_FEATURE(j,mask)                               \
     281                 :            :         ((j)->j_format_version >= 2 &&                                    \
     282                 :            :          ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
     283                 :            : 
     284                 :            : #define JBD2_FEATURE_COMPAT_CHECKSUM            0x00000001
     285                 :            : 
     286                 :            : #define JBD2_FEATURE_INCOMPAT_REVOKE            0x00000001
     287                 :            : #define JBD2_FEATURE_INCOMPAT_64BIT             0x00000002
     288                 :            : #define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT      0x00000004
     289                 :            : #define JBD2_FEATURE_INCOMPAT_CSUM_V2           0x00000008
     290                 :            : #define JBD2_FEATURE_INCOMPAT_CSUM_V3           0x00000010
     291                 :            : 
     292                 :            : /* See "journal feature predicate functions" below */
     293                 :            : 
     294                 :            : /* Features known to this kernel version: */
     295                 :            : #define JBD2_KNOWN_COMPAT_FEATURES      JBD2_FEATURE_COMPAT_CHECKSUM
     296                 :            : #define JBD2_KNOWN_ROCOMPAT_FEATURES    0
     297                 :            : #define JBD2_KNOWN_INCOMPAT_FEATURES    (JBD2_FEATURE_INCOMPAT_REVOKE | \
     298                 :            :                                         JBD2_FEATURE_INCOMPAT_64BIT | \
     299                 :            :                                         JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT | \
     300                 :            :                                         JBD2_FEATURE_INCOMPAT_CSUM_V2 | \
     301                 :            :                                         JBD2_FEATURE_INCOMPAT_CSUM_V3)
     302                 :            : 
     303                 :            : #ifdef __KERNEL__
     304                 :            : 
     305                 :            : #include <linux/fs.h>
     306                 :            : #include <linux/sched.h>
     307                 :            : 
     308                 :            : enum jbd_state_bits {
     309                 :            :         BH_JBD                  /* Has an attached ext3 journal_head */
     310                 :            :           = BH_PrivateStart,
     311                 :            :         BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
     312                 :            :         BH_Freed,               /* Has been freed (truncated) */
     313                 :            :         BH_Revoked,             /* Has been revoked from the log */
     314                 :            :         BH_RevokeValid,         /* Revoked flag is valid */
     315                 :            :         BH_JBDDirty,            /* Is dirty but journaled */
     316                 :            :         BH_State,               /* Pins most journal_head state */
     317                 :            :         BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
     318                 :            :         BH_Shadow,              /* IO on shadow buffer is running */
     319                 :            :         BH_Verified,            /* Metadata block has been verified ok */
     320                 :            :         BH_JBDPrivateStart,     /* First bit available for private use by FS */
     321                 :            : };
     322                 :            : 
     323         [ +  - ]:    4706234 : BUFFER_FNS(JBD, jbd)
     324         [ +  - ]:     103103 : BUFFER_FNS(JWrite, jwrite)
     325   [ +  -  +  -  :     819550 : BUFFER_FNS(JBDDirty, jbddirty)
             +  +  +  - ]
     326                 :     794064 : TAS_BUFFER_FNS(JBDDirty, jbddirty)
     327         [ +  + ]:      74372 : BUFFER_FNS(Revoked, revoked)
     328                 :      32843 : TAS_BUFFER_FNS(Revoked, revoked)
     329         [ +  + ]:       1464 : BUFFER_FNS(RevokeValid, revokevalid)
     330                 :     102827 : TAS_BUFFER_FNS(RevokeValid, revokevalid)
     331   [ #  #  #  # ]:     100264 : BUFFER_FNS(Freed, freed)
     332         [ +  - ]:     199219 : BUFFER_FNS(Shadow, shadow)
     333   [ +  +  +  +  :    2496477 : BUFFER_FNS(Verified, verified)
             #  #  #  # ]
     334                 :            : 
     335                 :            : static inline struct buffer_head *jh2bh(struct journal_head *jh)
     336                 :            : {
     337                 :    2693334 :         return jh->b_bh;
     338                 :            : }
     339                 :            : 
     340                 :            : static inline struct journal_head *bh2jh(struct buffer_head *bh)
     341                 :            : {
     342                 :    2369945 :         return bh->b_private;
     343                 :            : }
     344                 :            : 
     345                 :            : static inline void jbd_lock_bh_state(struct buffer_head *bh)
     346                 :            : {
     347                 :     500973 :         bit_spin_lock(BH_State, &bh->b_state);
     348                 :            : }
     349                 :            : 
     350                 :            : static inline int jbd_trylock_bh_state(struct buffer_head *bh)
     351                 :            : {
     352                 :            :         return bit_spin_trylock(BH_State, &bh->b_state);
     353                 :            : }
     354                 :            : 
     355                 :            : static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
     356                 :            : {
     357                 :            :         return bit_spin_is_locked(BH_State, &bh->b_state);
     358                 :            : }
     359                 :            : 
     360                 :            : static inline void jbd_unlock_bh_state(struct buffer_head *bh)
     361                 :            : {
     362                 :     154505 :         bit_spin_unlock(BH_State, &bh->b_state);
     363                 :            : }
     364                 :            : 
     365                 :            : static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
     366                 :            : {
     367                 :     544481 :         bit_spin_lock(BH_JournalHead, &bh->b_state);
     368                 :            : }
     369                 :            : 
     370                 :            : static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
     371                 :            : {
     372                 :     102832 :         bit_spin_unlock(BH_JournalHead, &bh->b_state);
     373                 :            : }
     374                 :            : 
     375                 :            : #define J_ASSERT(assert)        BUG_ON(!(assert))
     376                 :            : 
     377                 :            : #define J_ASSERT_BH(bh, expr)   J_ASSERT(expr)
     378                 :            : #define J_ASSERT_JH(jh, expr)   J_ASSERT(expr)
     379                 :            : 
     380                 :            : #if defined(JBD2_PARANOID_IOFAIL)
     381                 :            : #define J_EXPECT(expr, why...)          J_ASSERT(expr)
     382                 :            : #define J_EXPECT_BH(bh, expr, why...)   J_ASSERT_BH(bh, expr)
     383                 :            : #define J_EXPECT_JH(jh, expr, why...)   J_ASSERT_JH(jh, expr)
     384                 :            : #else
     385                 :            : #define __journal_expect(expr, why...)                                       \
     386                 :            :         ({                                                                   \
     387                 :            :                 int val = (expr);                                            \
     388                 :            :                 if (!val) {                                                  \
     389                 :            :                         printk(KERN_ERR                                      \
     390                 :            :                                "JBD2 unexpected failure: %s: %s;\n",       \
     391                 :            :                                __func__, #expr);                             \
     392                 :            :                         printk(KERN_ERR why "\n");                         \
     393                 :            :                 }                                                            \
     394                 :            :                 val;                                                         \
     395                 :            :         })
     396                 :            : #define J_EXPECT(expr, why...)          __journal_expect(expr, ## why)
     397                 :            : #define J_EXPECT_BH(bh, expr, why...)   __journal_expect(expr, ## why)
     398                 :            : #define J_EXPECT_JH(jh, expr, why...)   __journal_expect(expr, ## why)
     399                 :            : #endif
     400                 :            : 
     401                 :            : /* Flags in jbd_inode->i_flags */
     402                 :            : #define __JI_COMMIT_RUNNING 0
     403                 :            : #define __JI_WRITE_DATA 1
     404                 :            : #define __JI_WAIT_DATA 2
     405                 :            : 
     406                 :            : /*
     407                 :            :  * Commit of the inode data in progress. We use this flag to protect us from
     408                 :            :  * concurrent deletion of inode. We cannot use reference to inode for this
     409                 :            :  * since we cannot afford doing last iput() on behalf of kjournald
     410                 :            :  */
     411                 :            : #define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
     412                 :            : /* Write allocated dirty buffers in this inode before commit */
     413                 :            : #define JI_WRITE_DATA (1 << __JI_WRITE_DATA)
     414                 :            : /* Wait for outstanding data writes for this inode before commit */
     415                 :            : #define JI_WAIT_DATA (1 << __JI_WAIT_DATA)
     416                 :            : 
     417                 :            : /**
     418                 :            :  * struct jbd_inode - The jbd_inode type is the structure linking inodes in
     419                 :            :  * ordered mode present in a transaction so that we can sync them during commit.
     420                 :            :  */
     421                 :            : struct jbd2_inode {
     422                 :            :         /**
     423                 :            :          * @i_transaction:
     424                 :            :          *
     425                 :            :          * Which transaction does this inode belong to? Either the running
     426                 :            :          * transaction or the committing one. [j_list_lock]
     427                 :            :          */
     428                 :            :         transaction_t *i_transaction;
     429                 :            : 
     430                 :            :         /**
     431                 :            :          * @i_next_transaction:
     432                 :            :          *
     433                 :            :          * Pointer to the running transaction modifying inode's data in case
     434                 :            :          * there is already a committing transaction touching it. [j_list_lock]
     435                 :            :          */
     436                 :            :         transaction_t *i_next_transaction;
     437                 :            : 
     438                 :            :         /**
     439                 :            :          * @i_list: List of inodes in the i_transaction [j_list_lock]
     440                 :            :          */
     441                 :            :         struct list_head i_list;
     442                 :            : 
     443                 :            :         /**
     444                 :            :          * @i_vfs_inode:
     445                 :            :          *
     446                 :            :          * VFS inode this inode belongs to [constant for lifetime of structure]
     447                 :            :          */
     448                 :            :         struct inode *i_vfs_inode;
     449                 :            : 
     450                 :            :         /**
     451                 :            :          * @i_flags: Flags of inode [j_list_lock]
     452                 :            :          */
     453                 :            :         unsigned long i_flags;
     454                 :            : 
     455                 :            :         /**
     456                 :            :          * @i_dirty_start:
     457                 :            :          *
     458                 :            :          * Offset in bytes where the dirty range for this inode starts.
     459                 :            :          * [j_list_lock]
     460                 :            :          */
     461                 :            :         loff_t i_dirty_start;
     462                 :            : 
     463                 :            :         /**
     464                 :            :          * @i_dirty_end:
     465                 :            :          *
     466                 :            :          * Inclusive offset in bytes where the dirty range for this inode
     467                 :            :          * ends. [j_list_lock]
     468                 :            :          */
     469                 :            :         loff_t i_dirty_end;
     470                 :            : };
     471                 :            : 
     472                 :            : struct jbd2_revoke_table_s;
     473                 :            : 
     474                 :            : /**
     475                 :            :  * struct handle_s - The handle_s type is the concrete type associated with
     476                 :            :  *     handle_t.
     477                 :            :  * @h_transaction: Which compound transaction is this update a part of?
     478                 :            :  * @h_journal: Which journal handle belongs to - used iff h_reserved set.
     479                 :            :  * @h_rsv_handle: Handle reserved for finishing the logical operation.
     480                 :            :  * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
     481                 :            :  * @h_ref: Reference count on this handle.
     482                 :            :  * @h_err: Field for caller's use to track errors through large fs operations.
     483                 :            :  * @h_sync: Flag for sync-on-close.
     484                 :            :  * @h_jdata: Flag to force data journaling.
     485                 :            :  * @h_reserved: Flag for handle for reserved credits.
     486                 :            :  * @h_aborted: Flag indicating fatal error on handle.
     487                 :            :  * @h_type: For handle statistics.
     488                 :            :  * @h_line_no: For handle statistics.
     489                 :            :  * @h_start_jiffies: Handle Start time.
     490                 :            :  * @h_requested_credits: Holds @h_buffer_credits after handle is started.
     491                 :            :  * @saved_alloc_context: Saved context while transaction is open.
     492                 :            :  **/
     493                 :            : 
     494                 :            : /* Docbook can't yet cope with the bit fields, but will leave the documentation
     495                 :            :  * in so it can be fixed later.
     496                 :            :  */
     497                 :            : 
     498                 :            : struct jbd2_journal_handle
     499                 :            : {
     500                 :            :         union {
     501                 :            :                 transaction_t   *h_transaction;
     502                 :            :                 /* Which journal handle belongs to - used iff h_reserved set */
     503                 :            :                 journal_t       *h_journal;
     504                 :            :         };
     505                 :            : 
     506                 :            :         handle_t                *h_rsv_handle;
     507                 :            :         int                     h_buffer_credits;
     508                 :            :         int                     h_ref;
     509                 :            :         int                     h_err;
     510                 :            : 
     511                 :            :         /* Flags [no locking] */
     512                 :            :         unsigned int    h_sync:         1;
     513                 :            :         unsigned int    h_jdata:        1;
     514                 :            :         unsigned int    h_reserved:     1;
     515                 :            :         unsigned int    h_aborted:      1;
     516                 :            :         unsigned int    h_type:         8;
     517                 :            :         unsigned int    h_line_no:      16;
     518                 :            : 
     519                 :            :         unsigned long           h_start_jiffies;
     520                 :            :         unsigned int            h_requested_credits;
     521                 :            : 
     522                 :            :         unsigned int            saved_alloc_context;
     523                 :            : };
     524                 :            : 
     525                 :            : 
     526                 :            : /*
     527                 :            :  * Some stats for checkpoint phase
     528                 :            :  */
     529                 :            : struct transaction_chp_stats_s {
     530                 :            :         unsigned long           cs_chp_time;
     531                 :            :         __u32                   cs_forced_to_close;
     532                 :            :         __u32                   cs_written;
     533                 :            :         __u32                   cs_dropped;
     534                 :            : };
     535                 :            : 
     536                 :            : /* The transaction_t type is the guts of the journaling mechanism.  It
     537                 :            :  * tracks a compound transaction through its various states:
     538                 :            :  *
     539                 :            :  * RUNNING:     accepting new updates
     540                 :            :  * LOCKED:      Updates still running but we don't accept new ones
     541                 :            :  * RUNDOWN:     Updates are tidying up but have finished requesting
     542                 :            :  *              new buffers to modify (state not used for now)
     543                 :            :  * FLUSH:       All updates complete, but we are still writing to disk
     544                 :            :  * COMMIT:      All data on disk, writing commit record
     545                 :            :  * FINISHED:    We still have to keep the transaction for checkpointing.
     546                 :            :  *
     547                 :            :  * The transaction keeps track of all of the buffers modified by a
     548                 :            :  * running transaction, and all of the buffers committed but not yet
     549                 :            :  * flushed to home for finished transactions.
     550                 :            :  */
     551                 :            : 
     552                 :            : /*
     553                 :            :  * Lock ranking:
     554                 :            :  *
     555                 :            :  *    j_list_lock
     556                 :            :  *      ->jbd_lock_bh_journal_head() (This is "innermost")
     557                 :            :  *
     558                 :            :  *    j_state_lock
     559                 :            :  *    ->jbd_lock_bh_state()
     560                 :            :  *
     561                 :            :  *    jbd_lock_bh_state()
     562                 :            :  *    ->j_list_lock
     563                 :            :  *
     564                 :            :  *    j_state_lock
     565                 :            :  *    ->t_handle_lock
     566                 :            :  *
     567                 :            :  *    j_state_lock
     568                 :            :  *    ->j_list_lock                  (journal_unmap_buffer)
     569                 :            :  *
     570                 :            :  */
     571                 :            : 
     572                 :            : struct transaction_s
     573                 :            : {
     574                 :            :         /* Pointer to the journal for this transaction. [no locking] */
     575                 :            :         journal_t               *t_journal;
     576                 :            : 
     577                 :            :         /* Sequence number for this transaction [no locking] */
     578                 :            :         tid_t                   t_tid;
     579                 :            : 
     580                 :            :         /*
     581                 :            :          * Transaction's current state
     582                 :            :          * [no locking - only kjournald2 alters this]
     583                 :            :          * [j_list_lock] guards transition of a transaction into T_FINISHED
     584                 :            :          * state and subsequent call of __jbd2_journal_drop_transaction()
     585                 :            :          * FIXME: needs barriers
     586                 :            :          * KLUDGE: [use j_state_lock]
     587                 :            :          */
     588                 :            :         enum {
     589                 :            :                 T_RUNNING,
     590                 :            :                 T_LOCKED,
     591                 :            :                 T_SWITCH,
     592                 :            :                 T_FLUSH,
     593                 :            :                 T_COMMIT,
     594                 :            :                 T_COMMIT_DFLUSH,
     595                 :            :                 T_COMMIT_JFLUSH,
     596                 :            :                 T_COMMIT_CALLBACK,
     597                 :            :                 T_FINISHED
     598                 :            :         }                       t_state;
     599                 :            : 
     600                 :            :         /*
     601                 :            :          * Where in the log does this transaction's commit start? [no locking]
     602                 :            :          */
     603                 :            :         unsigned long           t_log_start;
     604                 :            : 
     605                 :            :         /* Number of buffers on the t_buffers list [j_list_lock] */
     606                 :            :         int                     t_nr_buffers;
     607                 :            : 
     608                 :            :         /*
     609                 :            :          * Doubly-linked circular list of all buffers reserved but not yet
     610                 :            :          * modified by this transaction [j_list_lock]
     611                 :            :          */
     612                 :            :         struct journal_head     *t_reserved_list;
     613                 :            : 
     614                 :            :         /*
     615                 :            :          * Doubly-linked circular list of all metadata buffers owned by this
     616                 :            :          * transaction [j_list_lock]
     617                 :            :          */
     618                 :            :         struct journal_head     *t_buffers;
     619                 :            : 
     620                 :            :         /*
     621                 :            :          * Doubly-linked circular list of all forget buffers (superseded
     622                 :            :          * buffers which we can un-checkpoint once this transaction commits)
     623                 :            :          * [j_list_lock]
     624                 :            :          */
     625                 :            :         struct journal_head     *t_forget;
     626                 :            : 
     627                 :            :         /*
     628                 :            :          * Doubly-linked circular list of all buffers still to be flushed before
     629                 :            :          * this transaction can be checkpointed. [j_list_lock]
     630                 :            :          */
     631                 :            :         struct journal_head     *t_checkpoint_list;
     632                 :            : 
     633                 :            :         /*
     634                 :            :          * Doubly-linked circular list of all buffers submitted for IO while
     635                 :            :          * checkpointing. [j_list_lock]
     636                 :            :          */
     637                 :            :         struct journal_head     *t_checkpoint_io_list;
     638                 :            : 
     639                 :            :         /*
     640                 :            :          * Doubly-linked circular list of metadata buffers being shadowed by log
     641                 :            :          * IO.  The IO buffers on the iobuf list and the shadow buffers on this
     642                 :            :          * list match each other one for one at all times. [j_list_lock]
     643                 :            :          */
     644                 :            :         struct journal_head     *t_shadow_list;
     645                 :            : 
     646                 :            :         /*
     647                 :            :          * List of inodes whose data we've modified in data=ordered mode.
     648                 :            :          * [j_list_lock]
     649                 :            :          */
     650                 :            :         struct list_head        t_inode_list;
     651                 :            : 
     652                 :            :         /*
     653                 :            :          * Protects info related to handles
     654                 :            :          */
     655                 :            :         spinlock_t              t_handle_lock;
     656                 :            : 
     657                 :            :         /*
     658                 :            :          * Longest time some handle had to wait for running transaction
     659                 :            :          */
     660                 :            :         unsigned long           t_max_wait;
     661                 :            : 
     662                 :            :         /*
     663                 :            :          * When transaction started
     664                 :            :          */
     665                 :            :         unsigned long           t_start;
     666                 :            : 
     667                 :            :         /*
     668                 :            :          * When commit was requested
     669                 :            :          */
     670                 :            :         unsigned long           t_requested;
     671                 :            : 
     672                 :            :         /*
     673                 :            :          * Checkpointing stats [j_checkpoint_sem]
     674                 :            :          */
     675                 :            :         struct transaction_chp_stats_s t_chp_stats;
     676                 :            : 
     677                 :            :         /*
     678                 :            :          * Number of outstanding updates running on this transaction
     679                 :            :          * [none]
     680                 :            :          */
     681                 :            :         atomic_t                t_updates;
     682                 :            : 
     683                 :            :         /*
     684                 :            :          * Number of buffers reserved for use by all handles in this transaction
     685                 :            :          * handle but not yet modified. [none]
     686                 :            :          */
     687                 :            :         atomic_t                t_outstanding_credits;
     688                 :            : 
     689                 :            :         /*
     690                 :            :          * Forward and backward links for the circular list of all transactions
     691                 :            :          * awaiting checkpoint. [j_list_lock]
     692                 :            :          */
     693                 :            :         transaction_t           *t_cpnext, *t_cpprev;
     694                 :            : 
     695                 :            :         /*
     696                 :            :          * When will the transaction expire (become due for commit), in jiffies?
     697                 :            :          * [no locking]
     698                 :            :          */
     699                 :            :         unsigned long           t_expires;
     700                 :            : 
     701                 :            :         /*
     702                 :            :          * When this transaction started, in nanoseconds [no locking]
     703                 :            :          */
     704                 :            :         ktime_t                 t_start_time;
     705                 :            : 
     706                 :            :         /*
     707                 :            :          * How many handles used this transaction? [none]
     708                 :            :          */
     709                 :            :         atomic_t                t_handle_count;
     710                 :            : 
     711                 :            :         /*
     712                 :            :          * This transaction is being forced and some process is
     713                 :            :          * waiting for it to finish.
     714                 :            :          */
     715                 :            :         unsigned int t_synchronous_commit:1;
     716                 :            : 
     717                 :            :         /* Disk flush needs to be sent to fs partition [no locking] */
     718                 :            :         int                     t_need_data_flush;
     719                 :            : 
     720                 :            :         /*
     721                 :            :          * For use by the filesystem to store fs-specific data
     722                 :            :          * structures associated with the transaction
     723                 :            :          */
     724                 :            :         struct list_head        t_private_list;
     725                 :            : };
     726                 :            : 
     727                 :            : struct transaction_run_stats_s {
     728                 :            :         unsigned long           rs_wait;
     729                 :            :         unsigned long           rs_request_delay;
     730                 :            :         unsigned long           rs_running;
     731                 :            :         unsigned long           rs_locked;
     732                 :            :         unsigned long           rs_flushing;
     733                 :            :         unsigned long           rs_logging;
     734                 :            : 
     735                 :            :         __u32                   rs_handle_count;
     736                 :            :         __u32                   rs_blocks;
     737                 :            :         __u32                   rs_blocks_logged;
     738                 :            : };
     739                 :            : 
     740                 :            : struct transaction_stats_s {
     741                 :            :         unsigned long           ts_tid;
     742                 :            :         unsigned long           ts_requested;
     743                 :            :         struct transaction_run_stats_s run;
     744                 :            : };
     745                 :            : 
     746                 :            : static inline unsigned long
     747                 :            : jbd2_time_diff(unsigned long start, unsigned long end)
     748                 :            : {
     749   [ +  -  +  -  :      69633 :         if (end >= start)
          +  -  +  -  +  
                      - ]
     750                 :      69633 :                 return end - start;
     751                 :            : 
     752                 :          0 :         return end + (MAX_JIFFY_OFFSET - start);
     753                 :            : }
     754                 :            : 
     755                 :            : #define JBD2_NR_BATCH   64
     756                 :            : 
     757                 :            : /**
     758                 :            :  * struct journal_s - The journal_s type is the concrete type associated with
     759                 :            :  *     journal_t.
     760                 :            :  */
     761                 :            : struct journal_s
     762                 :            : {
     763                 :            :         /**
     764                 :            :          * @j_flags: General journaling state flags [j_state_lock]
     765                 :            :          */
     766                 :            :         unsigned long           j_flags;
     767                 :            : 
     768                 :            :         /**
     769                 :            :          * @j_errno:
     770                 :            :          *
     771                 :            :          * Is there an outstanding uncleared error on the journal (from a prior
     772                 :            :          * abort)? [j_state_lock]
     773                 :            :          */
     774                 :            :         int                     j_errno;
     775                 :            : 
     776                 :            :         /**
     777                 :            :          * @j_sb_buffer: The first part of the superblock buffer.
     778                 :            :          */
     779                 :            :         struct buffer_head      *j_sb_buffer;
     780                 :            : 
     781                 :            :         /**
     782                 :            :          * @j_superblock: The second part of the superblock buffer.
     783                 :            :          */
     784                 :            :         journal_superblock_t    *j_superblock;
     785                 :            : 
     786                 :            :         /**
     787                 :            :          * @j_format_version: Version of the superblock format.
     788                 :            :          */
     789                 :            :         int                     j_format_version;
     790                 :            : 
     791                 :            :         /**
     792                 :            :          * @j_state_lock: Protect the various scalars in the journal.
     793                 :            :          */
     794                 :            :         rwlock_t                j_state_lock;
     795                 :            : 
     796                 :            :         /**
     797                 :            :          * @j_barrier_count:
     798                 :            :          *
     799                 :            :          * Number of processes waiting to create a barrier lock [j_state_lock]
     800                 :            :          */
     801                 :            :         int                     j_barrier_count;
     802                 :            : 
     803                 :            :         /**
     804                 :            :          * @j_barrier: The barrier lock itself.
     805                 :            :          */
     806                 :            :         struct mutex            j_barrier;
     807                 :            : 
     808                 :            :         /**
     809                 :            :          * @j_running_transaction:
     810                 :            :          *
     811                 :            :          * Transactions: The current running transaction...
     812                 :            :          * [j_state_lock] [caller holding open handle]
     813                 :            :          */
     814                 :            :         transaction_t           *j_running_transaction;
     815                 :            : 
     816                 :            :         /**
     817                 :            :          * @j_committing_transaction:
     818                 :            :          *
     819                 :            :          * the transaction we are pushing to disk
     820                 :            :          * [j_state_lock] [caller holding open handle]
     821                 :            :          */
     822                 :            :         transaction_t           *j_committing_transaction;
     823                 :            : 
     824                 :            :         /**
     825                 :            :          * @j_checkpoint_transactions:
     826                 :            :          *
     827                 :            :          * ... and a linked circular list of all transactions waiting for
     828                 :            :          * checkpointing. [j_list_lock]
     829                 :            :          */
     830                 :            :         transaction_t           *j_checkpoint_transactions;
     831                 :            : 
     832                 :            :         /**
     833                 :            :          * @j_wait_transaction_locked:
     834                 :            :          *
     835                 :            :          * Wait queue for waiting for a locked transaction to start committing,
     836                 :            :          * or for a barrier lock to be released.
     837                 :            :          */
     838                 :            :         wait_queue_head_t       j_wait_transaction_locked;
     839                 :            : 
     840                 :            :         /**
     841                 :            :          * @j_wait_done_commit: Wait queue for waiting for commit to complete.
     842                 :            :          */
     843                 :            :         wait_queue_head_t       j_wait_done_commit;
     844                 :            : 
     845                 :            :         /**
     846                 :            :          * @j_wait_commit: Wait queue to trigger commit.
     847                 :            :          */
     848                 :            :         wait_queue_head_t       j_wait_commit;
     849                 :            : 
     850                 :            :         /**
     851                 :            :          * @j_wait_updates: Wait queue to wait for updates to complete.
     852                 :            :          */
     853                 :            :         wait_queue_head_t       j_wait_updates;
     854                 :            : 
     855                 :            :         /**
     856                 :            :          * @j_wait_reserved:
     857                 :            :          *
     858                 :            :          * Wait queue to wait for reserved buffer credits to drop.
     859                 :            :          */
     860                 :            :         wait_queue_head_t       j_wait_reserved;
     861                 :            : 
     862                 :            :         /**
     863                 :            :          * @j_checkpoint_mutex:
     864                 :            :          *
     865                 :            :          * Semaphore for locking against concurrent checkpoints.
     866                 :            :          */
     867                 :            :         struct mutex            j_checkpoint_mutex;
     868                 :            : 
     869                 :            :         /**
     870                 :            :          * @j_chkpt_bhs:
     871                 :            :          *
     872                 :            :          * List of buffer heads used by the checkpoint routine.  This
     873                 :            :          * was moved from jbd2_log_do_checkpoint() to reduce stack
     874                 :            :          * usage.  Access to this array is controlled by the
     875                 :            :          * @j_checkpoint_mutex.  [j_checkpoint_mutex]
     876                 :            :          */
     877                 :            :         struct buffer_head      *j_chkpt_bhs[JBD2_NR_BATCH];
     878                 :            : 
     879                 :            :         /**
     880                 :            :          * @j_head:
     881                 :            :          *
     882                 :            :          * Journal head: identifies the first unused block in the journal.
     883                 :            :          * [j_state_lock]
     884                 :            :          */
     885                 :            :         unsigned long           j_head;
     886                 :            : 
     887                 :            :         /**
     888                 :            :          * @j_tail:
     889                 :            :          *
     890                 :            :          * Journal tail: identifies the oldest still-used block in the journal.
     891                 :            :          * [j_state_lock]
     892                 :            :          */
     893                 :            :         unsigned long           j_tail;
     894                 :            : 
     895                 :            :         /**
     896                 :            :          * @j_free:
     897                 :            :          *
     898                 :            :          * Journal free: how many free blocks are there in the journal?
     899                 :            :          * [j_state_lock]
     900                 :            :          */
     901                 :            :         unsigned long           j_free;
     902                 :            : 
     903                 :            :         /**
     904                 :            :          * @j_first:
     905                 :            :          *
     906                 :            :          * The block number of the first usable block in the journal
     907                 :            :          * [j_state_lock].
     908                 :            :          */
     909                 :            :         unsigned long           j_first;
     910                 :            : 
     911                 :            :         /**
     912                 :            :          * @j_last:
     913                 :            :          *
     914                 :            :          * The block number one beyond the last usable block in the journal
     915                 :            :          * [j_state_lock].
     916                 :            :          */
     917                 :            :         unsigned long           j_last;
     918                 :            : 
     919                 :            :         /**
     920                 :            :          * @j_dev: Device where we store the journal.
     921                 :            :          */
     922                 :            :         struct block_device     *j_dev;
     923                 :            : 
     924                 :            :         /**
     925                 :            :          * @j_blocksize: Block size for the location where we store the journal.
     926                 :            :          */
     927                 :            :         int                     j_blocksize;
     928                 :            : 
     929                 :            :         /**
     930                 :            :          * @j_blk_offset:
     931                 :            :          *
     932                 :            :          * Starting block offset into the device where we store the journal.
     933                 :            :          */
     934                 :            :         unsigned long long      j_blk_offset;
     935                 :            : 
     936                 :            :         /**
     937                 :            :          * @j_devname: Journal device name.
     938                 :            :          */
     939                 :            :         char                    j_devname[BDEVNAME_SIZE+24];
     940                 :            : 
     941                 :            :         /**
     942                 :            :          * @j_fs_dev:
     943                 :            :          *
     944                 :            :          * Device which holds the client fs.  For internal journal this will be
     945                 :            :          * equal to j_dev.
     946                 :            :          */
     947                 :            :         struct block_device     *j_fs_dev;
     948                 :            : 
     949                 :            :         /**
     950                 :            :          * @j_maxlen: Total maximum capacity of the journal region on disk.
     951                 :            :          */
     952                 :            :         unsigned int            j_maxlen;
     953                 :            : 
     954                 :            :         /**
     955                 :            :          * @j_reserved_credits:
     956                 :            :          *
     957                 :            :          * Number of buffers reserved from the running transaction.
     958                 :            :          */
     959                 :            :         atomic_t                j_reserved_credits;
     960                 :            : 
     961                 :            :         /**
     962                 :            :          * @j_list_lock: Protects the buffer lists and internal buffer state.
     963                 :            :          */
     964                 :            :         spinlock_t              j_list_lock;
     965                 :            : 
     966                 :            :         /**
     967                 :            :          * @j_inode:
     968                 :            :          *
     969                 :            :          * Optional inode where we store the journal.  If present, all
     970                 :            :          * journal block numbers are mapped into this inode via bmap().
     971                 :            :          */
     972                 :            :         struct inode            *j_inode;
     973                 :            : 
     974                 :            :         /**
     975                 :            :          * @j_tail_sequence:
     976                 :            :          *
     977                 :            :          * Sequence number of the oldest transaction in the log [j_state_lock]
     978                 :            :          */
     979                 :            :         tid_t                   j_tail_sequence;
     980                 :            : 
     981                 :            :         /**
     982                 :            :          * @j_transaction_sequence:
     983                 :            :          *
     984                 :            :          * Sequence number of the next transaction to grant [j_state_lock]
     985                 :            :          */
     986                 :            :         tid_t                   j_transaction_sequence;
     987                 :            : 
     988                 :            :         /**
     989                 :            :          * @j_commit_sequence:
     990                 :            :          *
     991                 :            :          * Sequence number of the most recently committed transaction
     992                 :            :          * [j_state_lock].
     993                 :            :          */
     994                 :            :         tid_t                   j_commit_sequence;
     995                 :            : 
     996                 :            :         /**
     997                 :            :          * @j_commit_request:
     998                 :            :          *
     999                 :            :          * Sequence number of the most recent transaction wanting commit
    1000                 :            :          * [j_state_lock]
    1001                 :            :          */
    1002                 :            :         tid_t                   j_commit_request;
    1003                 :            : 
    1004                 :            :         /**
    1005                 :            :          * @j_uuid:
    1006                 :            :          *
    1007                 :            :          * Journal uuid: identifies the object (filesystem, LVM volume etc)
    1008                 :            :          * backed by this journal.  This will eventually be replaced by an array
    1009                 :            :          * of uuids, allowing us to index multiple devices within a single
    1010                 :            :          * journal and to perform atomic updates across them.
    1011                 :            :          */
    1012                 :            :         __u8                    j_uuid[16];
    1013                 :            : 
    1014                 :            :         /**
    1015                 :            :          * @j_task: Pointer to the current commit thread for this journal.
    1016                 :            :          */
    1017                 :            :         struct task_struct      *j_task;
    1018                 :            : 
    1019                 :            :         /**
    1020                 :            :          * @j_max_transaction_buffers:
    1021                 :            :          *
    1022                 :            :          * Maximum number of metadata buffers to allow in a single compound
    1023                 :            :          * commit transaction.
    1024                 :            :          */
    1025                 :            :         int                     j_max_transaction_buffers;
    1026                 :            : 
    1027                 :            :         /**
    1028                 :            :          * @j_commit_interval:
    1029                 :            :          *
    1030                 :            :          * What is the maximum transaction lifetime before we begin a commit?
    1031                 :            :          */
    1032                 :            :         unsigned long           j_commit_interval;
    1033                 :            : 
    1034                 :            :         /**
    1035                 :            :          * @j_commit_timer: The timer used to wakeup the commit thread.
    1036                 :            :          */
    1037                 :            :         struct timer_list       j_commit_timer;
    1038                 :            : 
    1039                 :            :         /**
    1040                 :            :          * @j_revoke_lock: Protect the revoke table.
    1041                 :            :          */
    1042                 :            :         spinlock_t              j_revoke_lock;
    1043                 :            : 
    1044                 :            :         /**
    1045                 :            :          * @j_revoke:
    1046                 :            :          *
    1047                 :            :          * The revoke table - maintains the list of revoked blocks in the
    1048                 :            :          * current transaction.
    1049                 :            :          */
    1050                 :            :         struct jbd2_revoke_table_s *j_revoke;
    1051                 :            : 
    1052                 :            :         /**
    1053                 :            :          * @j_revoke_table: Alternate revoke tables for j_revoke.
    1054                 :            :          */
    1055                 :            :         struct jbd2_revoke_table_s *j_revoke_table[2];
    1056                 :            : 
    1057                 :            :         /**
    1058                 :            :          * @j_wbuf: Array of bhs for jbd2_journal_commit_transaction.
    1059                 :            :          */
    1060                 :            :         struct buffer_head      **j_wbuf;
    1061                 :            : 
    1062                 :            :         /**
    1063                 :            :          * @j_wbufsize:
    1064                 :            :          *
    1065                 :            :          * Size of @j_wbuf array.
    1066                 :            :          */
    1067                 :            :         int                     j_wbufsize;
    1068                 :            : 
    1069                 :            :         /**
    1070                 :            :          * @j_last_sync_writer:
    1071                 :            :          *
    1072                 :            :          * The pid of the last person to run a synchronous operation
    1073                 :            :          * through the journal.
    1074                 :            :          */
    1075                 :            :         pid_t                   j_last_sync_writer;
    1076                 :            : 
    1077                 :            :         /**
    1078                 :            :          * @j_average_commit_time:
    1079                 :            :          *
    1080                 :            :          * The average amount of time in nanoseconds it takes to commit a
    1081                 :            :          * transaction to disk. [j_state_lock]
    1082                 :            :          */
    1083                 :            :         u64                     j_average_commit_time;
    1084                 :            : 
    1085                 :            :         /**
    1086                 :            :          * @j_min_batch_time:
    1087                 :            :          *
    1088                 :            :          * Minimum time that we should wait for additional filesystem operations
    1089                 :            :          * to get batched into a synchronous handle in microseconds.
    1090                 :            :          */
    1091                 :            :         u32                     j_min_batch_time;
    1092                 :            : 
    1093                 :            :         /**
    1094                 :            :          * @j_max_batch_time:
    1095                 :            :          *
    1096                 :            :          * Maximum time that we should wait for additional filesystem operations
    1097                 :            :          * to get batched into a synchronous handle in microseconds.
    1098                 :            :          */
    1099                 :            :         u32                     j_max_batch_time;
    1100                 :            : 
    1101                 :            :         /**
    1102                 :            :          * @j_commit_callback:
    1103                 :            :          *
    1104                 :            :          * This function is called when a transaction is closed.
    1105                 :            :          */
    1106                 :            :         void                    (*j_commit_callback)(journal_t *,
    1107                 :            :                                                      transaction_t *);
    1108                 :            : 
    1109                 :            :         /*
    1110                 :            :          * Journal statistics
    1111                 :            :          */
    1112                 :            : 
    1113                 :            :         /**
    1114                 :            :          * @j_history_lock: Protect the transactions statistics history.
    1115                 :            :          */
    1116                 :            :         spinlock_t              j_history_lock;
    1117                 :            : 
    1118                 :            :         /**
    1119                 :            :          * @j_proc_entry: procfs entry for the jbd statistics directory.
    1120                 :            :          */
    1121                 :            :         struct proc_dir_entry   *j_proc_entry;
    1122                 :            : 
    1123                 :            :         /**
    1124                 :            :          * @j_stats: Overall statistics.
    1125                 :            :          */
    1126                 :            :         struct transaction_stats_s j_stats;
    1127                 :            : 
    1128                 :            :         /**
    1129                 :            :          * @j_failed_commit: Failed journal commit ID.
    1130                 :            :          */
    1131                 :            :         unsigned int            j_failed_commit;
    1132                 :            : 
    1133                 :            :         /**
    1134                 :            :          * @j_private:
    1135                 :            :          *
    1136                 :            :          * An opaque pointer to fs-private information.  ext3 puts its
    1137                 :            :          * superblock pointer here.
    1138                 :            :          */
    1139                 :            :         void *j_private;
    1140                 :            : 
    1141                 :            :         /**
    1142                 :            :          * @j_chksum_driver:
    1143                 :            :          *
    1144                 :            :          * Reference to checksum algorithm driver via cryptoapi.
    1145                 :            :          */
    1146                 :            :         struct crypto_shash *j_chksum_driver;
    1147                 :            : 
    1148                 :            :         /**
    1149                 :            :          * @j_csum_seed:
    1150                 :            :          *
    1151                 :            :          * Precomputed journal UUID checksum for seeding other checksums.
    1152                 :            :          */
    1153                 :            :         __u32 j_csum_seed;
    1154                 :            : 
    1155                 :            : #ifdef CONFIG_DEBUG_LOCK_ALLOC
    1156                 :            :         /**
    1157                 :            :          * @j_trans_commit_map:
    1158                 :            :          *
    1159                 :            :          * Lockdep entity to track transaction commit dependencies. Handles
    1160                 :            :          * hold this "lock" for read, when we wait for commit, we acquire the
    1161                 :            :          * "lock" for writing. This matches the properties of jbd2 journalling
    1162                 :            :          * where the running transaction has to wait for all handles to be
    1163                 :            :          * dropped to commit that transaction and also acquiring a handle may
    1164                 :            :          * require transaction commit to finish.
    1165                 :            :          */
    1166                 :            :         struct lockdep_map      j_trans_commit_map;
    1167                 :            : #endif
    1168                 :            : };
    1169                 :            : 
    1170                 :            : #define jbd2_might_wait_for_commit(j) \
    1171                 :            :         do { \
    1172                 :            :                 rwsem_acquire(&j->j_trans_commit_map, 0, 0, _THIS_IP_); \
    1173                 :            :                 rwsem_release(&j->j_trans_commit_map, 1, _THIS_IP_); \
    1174                 :            :         } while (0)
    1175                 :            : 
    1176                 :            : /* journal feature predicate functions */
    1177                 :            : #define JBD2_FEATURE_COMPAT_FUNCS(name, flagname) \
    1178                 :            : static inline bool jbd2_has_feature_##name(journal_t *j) \
    1179                 :            : { \
    1180                 :            :         return ((j)->j_format_version >= 2 && \
    1181                 :            :                 ((j)->j_superblock->s_feature_compat & \
    1182                 :            :                  cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname)) != 0); \
    1183                 :            : } \
    1184                 :            : static inline void jbd2_set_feature_##name(journal_t *j) \
    1185                 :            : { \
    1186                 :            :         (j)->j_superblock->s_feature_compat |= \
    1187                 :            :                 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
    1188                 :            : } \
    1189                 :            : static inline void jbd2_clear_feature_##name(journal_t *j) \
    1190                 :            : { \
    1191                 :            :         (j)->j_superblock->s_feature_compat &= \
    1192                 :            :                 ~cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
    1193                 :            : }
    1194                 :            : 
    1195                 :            : #define JBD2_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
    1196                 :            : static inline bool jbd2_has_feature_##name(journal_t *j) \
    1197                 :            : { \
    1198                 :            :         return ((j)->j_format_version >= 2 && \
    1199                 :            :                 ((j)->j_superblock->s_feature_ro_compat & \
    1200                 :            :                  cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname)) != 0); \
    1201                 :            : } \
    1202                 :            : static inline void jbd2_set_feature_##name(journal_t *j) \
    1203                 :            : { \
    1204                 :            :         (j)->j_superblock->s_feature_ro_compat |= \
    1205                 :            :                 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
    1206                 :            : } \
    1207                 :            : static inline void jbd2_clear_feature_##name(journal_t *j) \
    1208                 :            : { \
    1209                 :            :         (j)->j_superblock->s_feature_ro_compat &= \
    1210                 :            :                 ~cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
    1211                 :            : }
    1212                 :            : 
    1213                 :            : #define JBD2_FEATURE_INCOMPAT_FUNCS(name, flagname) \
    1214                 :            : static inline bool jbd2_has_feature_##name(journal_t *j) \
    1215                 :            : { \
    1216                 :            :         return ((j)->j_format_version >= 2 && \
    1217                 :            :                 ((j)->j_superblock->s_feature_incompat & \
    1218                 :            :                  cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname)) != 0); \
    1219                 :            : } \
    1220                 :            : static inline void jbd2_set_feature_##name(journal_t *j) \
    1221                 :            : { \
    1222                 :            :         (j)->j_superblock->s_feature_incompat |= \
    1223                 :            :                 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
    1224                 :            : } \
    1225                 :            : static inline void jbd2_clear_feature_##name(journal_t *j) \
    1226                 :            : { \
    1227                 :            :         (j)->j_superblock->s_feature_incompat &= \
    1228                 :            :                 ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
    1229                 :            : }
    1230                 :            : 
    1231   [ +  -  +  -  :     102706 : JBD2_FEATURE_COMPAT_FUNCS(checksum,             CHECKSUM)
             +  -  +  - ]
    1232                 :            : 
    1233                 :            : JBD2_FEATURE_INCOMPAT_FUNCS(revoke,             REVOKE)
    1234   [ +  -  +  -  :     103139 : JBD2_FEATURE_INCOMPAT_FUNCS(64bit,              64BIT)
             +  -  +  - ]
    1235   [ +  -  +  -  :      10096 : JBD2_FEATURE_INCOMPAT_FUNCS(async_commit,       ASYNC_COMMIT)
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
    1236   [ +  -  +  -  :     110265 : JBD2_FEATURE_INCOMPAT_FUNCS(csum2,              CSUM_V2)
          +  -  +  -  +  
                -  +  - ]
    1237   [ +  -  +  -  :     110058 : JBD2_FEATURE_INCOMPAT_FUNCS(csum3,              CSUM_V3)
          +  -  +  -  +  
                -  +  - ]
    1238                 :            : 
    1239                 :            : /*
    1240                 :            :  * Journal flag definitions
    1241                 :            :  */
    1242                 :            : #define JBD2_UNMOUNT    0x001   /* Journal thread is being destroyed */
    1243                 :            : #define JBD2_ABORT      0x002   /* Journaling has been aborted for errors. */
    1244                 :            : #define JBD2_ACK_ERR    0x004   /* The errno in the sb has been acked */
    1245                 :            : #define JBD2_FLUSHED    0x008   /* The journal superblock has been flushed */
    1246                 :            : #define JBD2_LOADED     0x010   /* The journal superblock has been loaded */
    1247                 :            : #define JBD2_BARRIER    0x020   /* Use IDE barriers */
    1248                 :            : #define JBD2_ABORT_ON_SYNCDATA_ERR      0x040   /* Abort the journal on file
    1249                 :            :                                                  * data write error in ordered
    1250                 :            :                                                  * mode */
    1251                 :            : #define JBD2_REC_ERR    0x080   /* The errno in the sb has been recorded */
    1252                 :            : 
    1253                 :            : /*
    1254                 :            :  * Function declarations for the journaling transaction and buffer
    1255                 :            :  * management
    1256                 :            :  */
    1257                 :            : 
    1258                 :            : /* Filing buffers */
    1259                 :            : extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
    1260                 :            : extern void __jbd2_journal_refile_buffer(struct journal_head *);
    1261                 :            : extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
    1262                 :            : extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
    1263                 :            : extern void __journal_free_buffer(struct journal_head *bh);
    1264                 :            : extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
    1265                 :            : extern void __journal_clean_data_list(transaction_t *transaction);
    1266                 :            : static inline void jbd2_file_log_bh(struct list_head *head, struct buffer_head *bh)
    1267                 :            : {
    1268                 :     100394 :         list_add_tail(&bh->b_assoc_buffers, head);
    1269                 :            : }
    1270                 :            : static inline void jbd2_unfile_log_bh(struct buffer_head *bh)
    1271                 :            : {
    1272                 :     100394 :         list_del_init(&bh->b_assoc_buffers);
    1273                 :            : }
    1274                 :            : 
    1275                 :            : /* Log buffer allocation */
    1276                 :            : struct buffer_head *jbd2_journal_get_descriptor_buffer(transaction_t *, int);
    1277                 :            : void jbd2_descriptor_block_csum_set(journal_t *, struct buffer_head *);
    1278                 :            : int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
    1279                 :            : int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
    1280                 :            :                               unsigned long *block);
    1281                 :            : int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
    1282                 :            : void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
    1283                 :            : 
    1284                 :            : /* Commit management */
    1285                 :            : extern void jbd2_journal_commit_transaction(journal_t *);
    1286                 :            : 
    1287                 :            : /* Checkpoint list management */
    1288                 :            : void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy);
    1289                 :            : int __jbd2_journal_remove_checkpoint(struct journal_head *);
    1290                 :            : void jbd2_journal_destroy_checkpoint(journal_t *journal);
    1291                 :            : void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
    1292                 :            : 
    1293                 :            : 
    1294                 :            : /*
    1295                 :            :  * Triggers
    1296                 :            :  */
    1297                 :            : 
    1298                 :            : struct jbd2_buffer_trigger_type {
    1299                 :            :         /*
    1300                 :            :          * Fired a the moment data to write to the journal are known to be
    1301                 :            :          * stable - so either at the moment b_frozen_data is created or just
    1302                 :            :          * before a buffer is written to the journal.  mapped_data is a mapped
    1303                 :            :          * buffer that is the frozen data for commit.
    1304                 :            :          */
    1305                 :            :         void (*t_frozen)(struct jbd2_buffer_trigger_type *type,
    1306                 :            :                          struct buffer_head *bh, void *mapped_data,
    1307                 :            :                          size_t size);
    1308                 :            : 
    1309                 :            :         /*
    1310                 :            :          * Fired during journal abort for dirty buffers that will not be
    1311                 :            :          * committed.
    1312                 :            :          */
    1313                 :            :         void (*t_abort)(struct jbd2_buffer_trigger_type *type,
    1314                 :            :                         struct buffer_head *bh);
    1315                 :            : };
    1316                 :            : 
    1317                 :            : extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
    1318                 :            :                                        void *mapped_data,
    1319                 :            :                                        struct jbd2_buffer_trigger_type *triggers);
    1320                 :            : extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
    1321                 :            :                                       struct jbd2_buffer_trigger_type *triggers);
    1322                 :            : 
    1323                 :            : /* Buffer IO */
    1324                 :            : extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
    1325                 :            :                                               struct journal_head *jh_in,
    1326                 :            :                                               struct buffer_head **bh_out,
    1327                 :            :                                               sector_t blocknr);
    1328                 :            : 
    1329                 :            : /* Transaction locking */
    1330                 :            : extern void             __wait_on_journal (journal_t *);
    1331                 :            : 
    1332                 :            : /* Transaction cache support */
    1333                 :            : extern void jbd2_journal_destroy_transaction_cache(void);
    1334                 :            : extern int __init jbd2_journal_init_transaction_cache(void);
    1335                 :            : extern void jbd2_journal_free_transaction(transaction_t *);
    1336                 :            : 
    1337                 :            : /*
    1338                 :            :  * Journal locking.
    1339                 :            :  *
    1340                 :            :  * We need to lock the journal during transaction state changes so that nobody
    1341                 :            :  * ever tries to take a handle on the running transaction while we are in the
    1342                 :            :  * middle of moving it to the commit phase.  j_state_lock does this.
    1343                 :            :  *
    1344                 :            :  * Note that the locking is completely interrupt unsafe.  We never touch
    1345                 :            :  * journal structures from interrupts.
    1346                 :            :  */
    1347                 :            : 
    1348                 :            : static inline handle_t *journal_current_handle(void)
    1349                 :            : {
    1350                 :    8404165 :         return current->journal_info;
    1351                 :            : }
    1352                 :            : 
    1353                 :            : /* The journaling code user interface:
    1354                 :            :  *
    1355                 :            :  * Create and destroy handles
    1356                 :            :  * Register buffer modifications against the current transaction.
    1357                 :            :  */
    1358                 :            : 
    1359                 :            : extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
    1360                 :            : extern handle_t *jbd2__journal_start(journal_t *, int blocks, int rsv_blocks,
    1361                 :            :                                      gfp_t gfp_mask, unsigned int type,
    1362                 :            :                                      unsigned int line_no);
    1363                 :            : extern int       jbd2_journal_restart(handle_t *, int nblocks);
    1364                 :            : extern int       jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
    1365                 :            : extern int       jbd2_journal_start_reserved(handle_t *handle,
    1366                 :            :                                 unsigned int type, unsigned int line_no);
    1367                 :            : extern void      jbd2_journal_free_reserved(handle_t *handle);
    1368                 :            : extern int       jbd2_journal_extend (handle_t *, int nblocks);
    1369                 :            : extern int       jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
    1370                 :            : extern int       jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
    1371                 :            : extern int       jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
    1372                 :            : void             jbd2_journal_set_triggers(struct buffer_head *,
    1373                 :            :                                            struct jbd2_buffer_trigger_type *type);
    1374                 :            : extern int       jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
    1375                 :            : extern int       jbd2_journal_forget (handle_t *, struct buffer_head *);
    1376                 :            : extern int       jbd2_journal_invalidatepage(journal_t *,
    1377                 :            :                                 struct page *, unsigned int, unsigned int);
    1378                 :            : extern int       jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
    1379                 :            : extern int       jbd2_journal_stop(handle_t *);
    1380                 :            : extern int       jbd2_journal_flush (journal_t *);
    1381                 :            : extern void      jbd2_journal_lock_updates (journal_t *);
    1382                 :            : extern void      jbd2_journal_unlock_updates (journal_t *);
    1383                 :            : 
    1384                 :            : extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
    1385                 :            :                                 struct block_device *fs_dev,
    1386                 :            :                                 unsigned long long start, int len, int bsize);
    1387                 :            : extern journal_t * jbd2_journal_init_inode (struct inode *);
    1388                 :            : extern int         jbd2_journal_update_format (journal_t *);
    1389                 :            : extern int         jbd2_journal_check_used_features
    1390                 :            :                    (journal_t *, unsigned long, unsigned long, unsigned long);
    1391                 :            : extern int         jbd2_journal_check_available_features
    1392                 :            :                    (journal_t *, unsigned long, unsigned long, unsigned long);
    1393                 :            : extern int         jbd2_journal_set_features
    1394                 :            :                    (journal_t *, unsigned long, unsigned long, unsigned long);
    1395                 :            : extern void        jbd2_journal_clear_features
    1396                 :            :                    (journal_t *, unsigned long, unsigned long, unsigned long);
    1397                 :            : extern int         jbd2_journal_load       (journal_t *journal);
    1398                 :            : extern int         jbd2_journal_destroy    (journal_t *);
    1399                 :            : extern int         jbd2_journal_recover    (journal_t *journal);
    1400                 :            : extern int         jbd2_journal_wipe       (journal_t *, int);
    1401                 :            : extern int         jbd2_journal_skip_recovery   (journal_t *);
    1402                 :            : extern void        jbd2_journal_update_sb_errno(journal_t *);
    1403                 :            : extern int         jbd2_journal_update_sb_log_tail      (journal_t *, tid_t,
    1404                 :            :                                 unsigned long, int);
    1405                 :            : extern void        jbd2_journal_abort      (journal_t *, int);
    1406                 :            : extern int         jbd2_journal_errno      (journal_t *);
    1407                 :            : extern void        jbd2_journal_ack_err    (journal_t *);
    1408                 :            : extern int         jbd2_journal_clear_err  (journal_t *);
    1409                 :            : extern int         jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
    1410                 :            : extern int         jbd2_journal_force_commit(journal_t *);
    1411                 :            : extern int         jbd2_journal_force_commit_nested(journal_t *);
    1412                 :            : extern int         jbd2_journal_inode_ranged_write(handle_t *handle,
    1413                 :            :                         struct jbd2_inode *inode, loff_t start_byte,
    1414                 :            :                         loff_t length);
    1415                 :            : extern int         jbd2_journal_inode_ranged_wait(handle_t *handle,
    1416                 :            :                         struct jbd2_inode *inode, loff_t start_byte,
    1417                 :            :                         loff_t length);
    1418                 :            : extern int         jbd2_journal_begin_ordered_truncate(journal_t *journal,
    1419                 :            :                                 struct jbd2_inode *inode, loff_t new_size);
    1420                 :            : extern void        jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
    1421                 :            : extern void        jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
    1422                 :            : 
    1423                 :            : /*
    1424                 :            :  * journal_head management
    1425                 :            :  */
    1426                 :            : struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
    1427                 :            : struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
    1428                 :            : void jbd2_journal_put_journal_head(struct journal_head *jh);
    1429                 :            : 
    1430                 :            : /*
    1431                 :            :  * handle management
    1432                 :            :  */
    1433                 :            : extern struct kmem_cache *jbd2_handle_cache;
    1434                 :            : 
    1435                 :            : static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
    1436                 :            : {
    1437                 :     791254 :         return kmem_cache_zalloc(jbd2_handle_cache, gfp_flags);
    1438                 :            : }
    1439                 :            : 
    1440                 :            : static inline void jbd2_free_handle(handle_t *handle)
    1441                 :            : {
    1442                 :     791286 :         kmem_cache_free(jbd2_handle_cache, handle);
    1443                 :            : }
    1444                 :            : 
    1445                 :            : /*
    1446                 :            :  * jbd2_inode management (optional, for those file systems that want to use
    1447                 :            :  * dynamically allocated jbd2_inode structures)
    1448                 :            :  */
    1449                 :            : extern struct kmem_cache *jbd2_inode_cache;
    1450                 :            : 
    1451                 :            : static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
    1452                 :            : {
    1453                 :     102525 :         return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
    1454                 :            : }
    1455                 :            : 
    1456                 :            : static inline void jbd2_free_inode(struct jbd2_inode *jinode)
    1457                 :            : {
    1458                 :        558 :         kmem_cache_free(jbd2_inode_cache, jinode);
    1459                 :            : }
    1460                 :            : 
    1461                 :            : /* Primary revoke support */
    1462                 :            : #define JOURNAL_REVOKE_DEFAULT_HASH 256
    1463                 :            : extern int         jbd2_journal_init_revoke(journal_t *, int);
    1464                 :            : extern void        jbd2_journal_destroy_revoke_record_cache(void);
    1465                 :            : extern void        jbd2_journal_destroy_revoke_table_cache(void);
    1466                 :            : extern int __init jbd2_journal_init_revoke_record_cache(void);
    1467                 :            : extern int __init jbd2_journal_init_revoke_table_cache(void);
    1468                 :            : 
    1469                 :            : extern void        jbd2_journal_destroy_revoke(journal_t *);
    1470                 :            : extern int         jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
    1471                 :            : extern int         jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
    1472                 :            : extern void        jbd2_journal_write_revoke_records(transaction_t *transaction,
    1473                 :            :                                                      struct list_head *log_bufs);
    1474                 :            : 
    1475                 :            : /* Recovery revoke support */
    1476                 :            : extern int      jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
    1477                 :            : extern int      jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
    1478                 :            : extern void     jbd2_journal_clear_revoke(journal_t *);
    1479                 :            : extern void     jbd2_journal_switch_revoke_table(journal_t *journal);
    1480                 :            : extern void     jbd2_clear_buffer_revoked_flags(journal_t *journal);
    1481                 :            : 
    1482                 :            : /*
    1483                 :            :  * The log thread user interface:
    1484                 :            :  *
    1485                 :            :  * Request space in the current transaction, and force transaction commit
    1486                 :            :  * transitions on demand.
    1487                 :            :  */
    1488                 :            : 
    1489                 :            : int jbd2_log_start_commit(journal_t *journal, tid_t tid);
    1490                 :            : int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
    1491                 :            : int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
    1492                 :            : int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
    1493                 :            : int jbd2_transaction_committed(journal_t *journal, tid_t tid);
    1494                 :            : int jbd2_complete_transaction(journal_t *journal, tid_t tid);
    1495                 :            : int jbd2_log_do_checkpoint(journal_t *journal);
    1496                 :            : int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
    1497                 :            : 
    1498                 :            : void __jbd2_log_wait_for_space(journal_t *journal);
    1499                 :            : extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
    1500                 :            : extern int jbd2_cleanup_journal_tail(journal_t *);
    1501                 :            : 
    1502                 :            : /*
    1503                 :            :  * is_journal_abort
    1504                 :            :  *
    1505                 :            :  * Simple test wrapper function to test the JBD2_ABORT state flag.  This
    1506                 :            :  * bit, when set, indicates that we have had a fatal error somewhere,
    1507                 :            :  * either inside the journaling layer or indicated to us by the client
    1508                 :            :  * (eg. ext3), and that we and should not commit any further
    1509                 :            :  * transactions.
    1510                 :            :  */
    1511                 :            : 
    1512                 :            : static inline int is_journal_aborted(journal_t *journal)
    1513                 :            : {
    1514                 :   11749655 :         return journal->j_flags & JBD2_ABORT;
    1515                 :            : }
    1516                 :            : 
    1517                 :            : static inline int is_handle_aborted(handle_t *handle)
    1518                 :            : {
    1519   [ +  +  +  +  :    9122034 :         if (handle->h_aborted || !handle->h_transaction)
          +  +  +  +  +  
          -  +  -  +  +  
          +  +  #  #  #  
          #  +  -  +  -  
          +  +  +  +  +  
          -  +  -  #  #  
          #  #  #  #  #  
                      # ]
    1520                 :            :                 return 1;
    1521                 :    7840530 :         return is_journal_aborted(handle->h_transaction->t_journal);
    1522                 :            : }
    1523                 :            : 
    1524                 :            : static inline void jbd2_journal_abort_handle(handle_t *handle)
    1525                 :            : {
    1526                 :          0 :         handle->h_aborted = 1;
    1527                 :            : }
    1528                 :            : 
    1529                 :            : #endif /* __KERNEL__   */
    1530                 :            : 
    1531                 :            : /* Comparison functions for transaction IDs: perform comparisons using
    1532                 :            :  * modulo arithmetic so that they work over sequence number wraps. */
    1533                 :            : 
    1534                 :            : static inline int tid_gt(tid_t x, tid_t y)
    1535                 :            : {
    1536                 :       5234 :         int difference = (x - y);
    1537                 :       2528 :         return (difference > 0);
    1538                 :            : }
    1539                 :            : 
    1540                 :            : static inline int tid_geq(tid_t x, tid_t y)
    1541                 :            : {
    1542                 :        836 :         int difference = (x - y);
    1543                 :            :         return (difference >= 0);
    1544                 :            : }
    1545                 :            : 
    1546                 :            : extern int jbd2_journal_blocks_per_page(struct inode *inode);
    1547                 :            : extern size_t journal_tag_bytes(journal_t *journal);
    1548                 :            : 
    1549                 :     107530 : static inline bool jbd2_journal_has_csum_v2or3_feature(journal_t *j)
    1550                 :            : {
    1551   [ +  -  +  - ]:     215060 :         return jbd2_has_feature_csum2(j) || jbd2_has_feature_csum3(j);
    1552                 :            : }
    1553                 :            : 
    1554                 :     107323 : static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)
    1555                 :            : {
    1556   [ -  +  #  #  :     107323 :         WARN_ON_ONCE(jbd2_journal_has_csum_v2or3_feature(journal) &&
             -  +  #  # ]
    1557                 :            :                      journal->j_chksum_driver == NULL);
    1558                 :            : 
    1559                 :     107323 :         return journal->j_chksum_driver != NULL;
    1560                 :            : }
    1561                 :            : 
    1562                 :            : /*
    1563                 :            :  * We reserve t_outstanding_credits >> JBD2_CONTROL_BLOCKS_SHIFT for
    1564                 :            :  * transaction control blocks.
    1565                 :            :  */
    1566                 :            : #define JBD2_CONTROL_BLOCKS_SHIFT 5
    1567                 :            : 
    1568                 :            : /*
    1569                 :            :  * Return the minimum number of blocks which must be free in the journal
    1570                 :            :  * before a new transaction may be started.  Must be called under j_state_lock.
    1571                 :            :  */
    1572                 :            : static inline int jbd2_space_needed(journal_t *journal)
    1573                 :            : {
    1574                 :          0 :         int nblocks = journal->j_max_transaction_buffers;
    1575                 :     791276 :         return nblocks + (nblocks >> JBD2_CONTROL_BLOCKS_SHIFT);
    1576                 :            : }
    1577                 :            : 
    1578                 :            : /*
    1579                 :            :  * Return number of free blocks in the log. Must be called under j_state_lock.
    1580                 :            :  */
    1581                 :            : static inline unsigned long jbd2_log_space_left(journal_t *journal)
    1582                 :            : {
    1583                 :            :         /* Allow for rounding errors */
    1584                 :     791276 :         long free = journal->j_free - 32;
    1585                 :            : 
    1586   [ #  #  +  +  :     791276 :         if (journal->j_committing_transaction) {
                   #  # ]
    1587                 :            :                 unsigned long committing = atomic_read(&journal->
    1588                 :            :                         j_committing_transaction->t_outstanding_credits);
    1589                 :            : 
    1590                 :            :                 /* Transaction + control blocks */
    1591                 :       6210 :                 free -= committing + (committing >> JBD2_CONTROL_BLOCKS_SHIFT);
    1592                 :            :         }
    1593                 :     791276 :         return max_t(long, free, 0);
    1594                 :            : }
    1595                 :            : 
    1596                 :            : /*
    1597                 :            :  * Definitions which augment the buffer_head layer
    1598                 :            :  */
    1599                 :            : 
    1600                 :            : /* journaling buffer types */
    1601                 :            : #define BJ_None         0       /* Not journaled */
    1602                 :            : #define BJ_Metadata     1       /* Normal journaled metadata */
    1603                 :            : #define BJ_Forget       2       /* Buffer superseded by this transaction */
    1604                 :            : #define BJ_Shadow       3       /* Buffer contents being shadowed to the log */
    1605                 :            : #define BJ_Reserved     4       /* Buffer is reserved for access by journal */
    1606                 :            : #define BJ_Types        5
    1607                 :            : 
    1608                 :            : extern int jbd_blocks_per_page(struct inode *inode);
    1609                 :            : 
    1610                 :            : /* JBD uses a CRC32 checksum */
    1611                 :            : #define JBD_MAX_CHECKSUM_SIZE 4
    1612                 :            : 
    1613                 :          0 : static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
    1614                 :            :                               const void *address, unsigned int length)
    1615                 :            : {
    1616                 :            :         struct {
    1617                 :            :                 struct shash_desc shash;
    1618                 :            :                 char ctx[JBD_MAX_CHECKSUM_SIZE];
    1619                 :            :         } desc;
    1620                 :            :         int err;
    1621                 :            : 
    1622         [ #  # ]:          0 :         BUG_ON(crypto_shash_descsize(journal->j_chksum_driver) >
    1623                 :            :                 JBD_MAX_CHECKSUM_SIZE);
    1624                 :            : 
    1625                 :          0 :         desc.shash.tfm = journal->j_chksum_driver;
    1626                 :          0 :         *(u32 *)desc.ctx = crc;
    1627                 :            : 
    1628                 :          0 :         err = crypto_shash_update(&desc.shash, address, length);
    1629         [ #  # ]:          0 :         BUG_ON(err);
    1630                 :            : 
    1631                 :          0 :         return *(u32 *)desc.ctx;
    1632                 :            : }
    1633                 :            : 
    1634                 :            : /* Return most recent uncommitted transaction */
    1635                 :        414 : static inline tid_t  jbd2_get_latest_transaction(journal_t *journal)
    1636                 :            : {
    1637                 :            :         tid_t tid;
    1638                 :            : 
    1639                 :        414 :         read_lock(&journal->j_state_lock);
    1640                 :        414 :         tid = journal->j_commit_request;
    1641         [ +  + ]:        414 :         if (journal->j_running_transaction)
    1642                 :        358 :                 tid = journal->j_running_transaction->t_tid;
    1643                 :            :         read_unlock(&journal->j_state_lock);
    1644                 :        414 :         return tid;
    1645                 :            : }
    1646                 :            : 
    1647                 :            : #ifdef __KERNEL__
    1648                 :            : 
    1649                 :            : #define buffer_trace_init(bh)   do {} while (0)
    1650                 :            : #define print_buffer_fields(bh) do {} while (0)
    1651                 :            : #define print_buffer_trace(bh)  do {} while (0)
    1652                 :            : #define BUFFER_TRACE(bh, info)  do {} while (0)
    1653                 :            : #define BUFFER_TRACE2(bh, bh2, info)    do {} while (0)
    1654                 :            : #define JBUFFER_TRACE(jh, info) do {} while (0)
    1655                 :            : 
    1656                 :            : #endif  /* __KERNEL__ */
    1657                 :            : 
    1658                 :            : #define EFSBADCRC       EBADMSG         /* Bad CRC detected */
    1659                 :            : #define EFSCORRUPTED    EUCLEAN         /* Filesystem is corrupted */
    1660                 :            : 
    1661                 :            : #endif  /* _LINUX_JBD2_H */

Generated by: LCOV version 1.14