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