include/linux/jbd2.h

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