include/linux/jbd2.h

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