home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / jbd2.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  37.6 KB  |  1,251 lines
  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. #define jfs_debug jbd_debug
  24. #else
  25.  
  26. #include <linux/types.h>
  27. #include <linux/buffer_head.h>
  28. #include <linux/journal-head.h>
  29. #include <linux/stddef.h>
  30. #include <linux/bit_spinlock.h>
  31. #include <linux/mutex.h>
  32. #include <linux/timer.h>
  33. #endif
  34.  
  35. #define journal_oom_retry 1
  36.  
  37. /*
  38.  * Define JBD2_PARANIOD_IOFAIL to cause a kernel BUG() if ext4 finds
  39.  * certain classes of error which can occur due to failed IOs.  Under
  40.  * normal use we want ext4 to continue after such errors, because
  41.  * hardware _can_ fail, but for debugging purposes when running tests on
  42.  * known-good hardware we may want to trap these errors.
  43.  */
  44. #undef JBD2_PARANOID_IOFAIL
  45.  
  46. /*
  47.  * The default maximum commit age, in seconds.
  48.  */
  49. #define JBD2_DEFAULT_MAX_COMMIT_AGE 5
  50.  
  51. #ifdef CONFIG_JBD2_DEBUG
  52. /*
  53.  * Define JBD2_EXPENSIVE_CHECKING to enable more expensive internal
  54.  * consistency checks.  By default we don't do this unless
  55.  * CONFIG_JBD2_DEBUG is on.
  56.  */
  57. #define JBD2_EXPENSIVE_CHECKING
  58. extern u8 jbd2_journal_enable_debug;
  59.  
  60. #define jbd_debug(n, f, a...)                        \
  61.     do {                                \
  62.         if ((n) <= jbd2_journal_enable_debug) {            \
  63.             printk (KERN_DEBUG "(%s, %d): %s: ",        \
  64.                 __FILE__, __LINE__, __func__);    \
  65.             printk (f, ## a);                \
  66.         }                            \
  67.     } while (0)
  68. #else
  69. #define jbd_debug(f, a...)    /**/
  70. #endif
  71.  
  72. static inline void *jbd2_alloc(size_t size, gfp_t flags)
  73. {
  74.     return (void *)__get_free_pages(flags, get_order(size));
  75. }
  76.  
  77. static inline void jbd2_free(void *ptr, size_t size)
  78. {
  79.     free_pages((unsigned long)ptr, get_order(size));
  80. };
  81.  
  82. #define JBD2_MIN_JOURNAL_BLOCKS 1024
  83.  
  84. #ifdef __KERNEL__
  85.  
  86. /**
  87.  * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
  88.  *
  89.  * All filesystem modifications made by the process go
  90.  * through this handle.  Recursive operations (such as quota operations)
  91.  * are gathered into a single update.
  92.  *
  93.  * The buffer credits field is used to account for journaled buffers
  94.  * being modified by the running process.  To ensure that there is
  95.  * enough log space for all outstanding operations, we need to limit the
  96.  * number of outstanding buffers possible at any time.  When the
  97.  * operation completes, any buffer credits not used are credited back to
  98.  * the transaction, so that at all times we know how many buffers the
  99.  * outstanding updates on a transaction might possibly touch.
  100.  *
  101.  * This is an opaque datatype.
  102.  **/
  103. typedef struct handle_s        handle_t;    /* Atomic operation type */
  104.  
  105.  
  106. /**
  107.  * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
  108.  *
  109.  * journal_t is linked to from the fs superblock structure.
  110.  *
  111.  * We use the journal_t to keep track of all outstanding transaction
  112.  * activity on the filesystem, and to manage the state of the log
  113.  * writing process.
  114.  *
  115.  * This is an opaque datatype.
  116.  **/
  117. typedef struct journal_s    journal_t;    /* Journal control structure */
  118. #endif
  119.  
  120. /*
  121.  * Internal structures used by the logging mechanism:
  122.  */
  123.  
  124. #define JBD2_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
  125.  
  126. /*
  127.  * On-disk structures
  128.  */
  129.  
  130. /*
  131.  * Descriptor block types:
  132.  */
  133.  
  134. #define JBD2_DESCRIPTOR_BLOCK    1
  135. #define JBD2_COMMIT_BLOCK    2
  136. #define JBD2_SUPERBLOCK_V1    3
  137. #define JBD2_SUPERBLOCK_V2    4
  138. #define JBD2_REVOKE_BLOCK    5
  139.  
  140. /*
  141.  * Standard header for all descriptor blocks:
  142.  */
  143. typedef struct journal_header_s
  144. {
  145.     __be32        h_magic;
  146.     __be32        h_blocktype;
  147.     __be32        h_sequence;
  148. } journal_header_t;
  149.  
  150. /*
  151.  * Checksum types.
  152.  */
  153. #define JBD2_CRC32_CHKSUM   1
  154. #define JBD2_MD5_CHKSUM     2
  155. #define JBD2_SHA1_CHKSUM    3
  156.  
  157. #define JBD2_CRC32_CHKSUM_SIZE 4
  158.  
  159. #define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
  160. /*
  161.  * Commit block header for storing transactional checksums:
  162.  */
  163. struct commit_header {
  164.     __be32        h_magic;
  165.     __be32          h_blocktype;
  166.     __be32          h_sequence;
  167.     unsigned char   h_chksum_type;
  168.     unsigned char   h_chksum_size;
  169.     unsigned char     h_padding[2];
  170.     __be32         h_chksum[JBD2_CHECKSUM_BYTES];
  171.     __be64        h_commit_sec;
  172.     __be32        h_commit_nsec;
  173. };
  174.  
  175. /*
  176.  * The block tag: used to describe a single buffer in the journal.
  177.  * t_blocknr_high is only used if INCOMPAT_64BIT is set, so this
  178.  * raw struct shouldn't be used for pointer math or sizeof() - use
  179.  * journal_tag_bytes(journal) instead to compute this.
  180.  */
  181. typedef struct journal_block_tag_s
  182. {
  183.     __be32        t_blocknr;    /* The on-disk block number */
  184.     __be32        t_flags;    /* See below */
  185.     __be32        t_blocknr_high; /* most-significant high 32bits. */
  186. } journal_block_tag_t;
  187.  
  188. #define JBD2_TAG_SIZE32 (offsetof(journal_block_tag_t, t_blocknr_high))
  189. #define JBD2_TAG_SIZE64 (sizeof(journal_block_tag_t))
  190.  
  191. /*
  192.  * The revoke descriptor: used on disk to describe a series of blocks to
  193.  * be revoked from the log
  194.  */
  195. typedef struct jbd2_journal_revoke_header_s
  196. {
  197.     journal_header_t r_header;
  198.     __be32         r_count;    /* Count of bytes used in the block */
  199. } jbd2_journal_revoke_header_t;
  200.  
  201.  
  202. /* Definitions for the journal tag flags word: */
  203. #define JBD2_FLAG_ESCAPE        1    /* on-disk block is escaped */
  204. #define JBD2_FLAG_SAME_UUID    2    /* block has same uuid as previous */
  205. #define JBD2_FLAG_DELETED    4    /* block deleted by this transaction */
  206. #define JBD2_FLAG_LAST_TAG    8    /* last tag in this descriptor block */
  207.  
  208.  
  209. /*
  210.  * The journal superblock.  All fields are in big-endian byte order.
  211.  */
  212. typedef struct journal_superblock_s
  213. {
  214. /* 0x0000 */
  215.     journal_header_t s_header;
  216.  
  217. /* 0x000C */
  218.     /* Static information describing the journal */
  219.     __be32    s_blocksize;        /* journal device blocksize */
  220.     __be32    s_maxlen;        /* total blocks in journal file */
  221.     __be32    s_first;        /* first block of log information */
  222.  
  223. /* 0x0018 */
  224.     /* Dynamic information describing the current state of the log */
  225.     __be32    s_sequence;        /* first commit ID expected in log */
  226.     __be32    s_start;        /* blocknr of start of log */
  227.  
  228. /* 0x0020 */
  229.     /* Error value, as set by jbd2_journal_abort(). */
  230.     __be32    s_errno;
  231.  
  232. /* 0x0024 */
  233.     /* Remaining fields are only valid in a version-2 superblock */
  234.     __be32    s_feature_compat;    /* compatible feature set */
  235.     __be32    s_feature_incompat;    /* incompatible feature set */
  236.     __be32    s_feature_ro_compat;    /* readonly-compatible feature set */
  237. /* 0x0030 */
  238.     __u8    s_uuid[16];        /* 128-bit uuid for journal */
  239.  
  240. /* 0x0040 */
  241.     __be32    s_nr_users;        /* Nr of filesystems sharing log */
  242.  
  243.     __be32    s_dynsuper;        /* Blocknr of dynamic superblock copy*/
  244.  
  245. /* 0x0048 */
  246.     __be32    s_max_transaction;    /* Limit of journal blocks per trans.*/
  247.     __be32    s_max_trans_data;    /* Limit of data blocks per trans. */
  248.  
  249. /* 0x0050 */
  250.     __u32    s_padding[44];
  251.  
  252. /* 0x0100 */
  253.     __u8    s_users[16*48];        /* ids of all fs'es sharing the log */
  254. /* 0x0400 */
  255. } journal_superblock_t;
  256.  
  257. #define JBD2_HAS_COMPAT_FEATURE(j,mask)                    \
  258.     ((j)->j_format_version >= 2 &&                    \
  259.      ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
  260. #define JBD2_HAS_RO_COMPAT_FEATURE(j,mask)                \
  261.     ((j)->j_format_version >= 2 &&                    \
  262.      ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
  263. #define JBD2_HAS_INCOMPAT_FEATURE(j,mask)                \
  264.     ((j)->j_format_version >= 2 &&                    \
  265.      ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
  266.  
  267. #define JBD2_FEATURE_COMPAT_CHECKSUM    0x00000001
  268.  
  269. #define JBD2_FEATURE_INCOMPAT_REVOKE        0x00000001
  270. #define JBD2_FEATURE_INCOMPAT_64BIT        0x00000002
  271. #define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT    0x00000004
  272.  
  273. /* Features known to this kernel version: */
  274. #define JBD2_KNOWN_COMPAT_FEATURES    JBD2_FEATURE_COMPAT_CHECKSUM
  275. #define JBD2_KNOWN_ROCOMPAT_FEATURES    0
  276. #define JBD2_KNOWN_INCOMPAT_FEATURES    (JBD2_FEATURE_INCOMPAT_REVOKE | \
  277.                     JBD2_FEATURE_INCOMPAT_64BIT | \
  278.                     JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)
  279.  
  280. #ifdef __KERNEL__
  281.  
  282. #include <linux/fs.h>
  283. #include <linux/sched.h>
  284.  
  285. #define J_ASSERT(assert)    BUG_ON(!(assert))
  286.  
  287. #if defined(CONFIG_BUFFER_DEBUG)
  288. void buffer_assertion_failure(struct buffer_head *bh);
  289. #define J_ASSERT_BH(bh, expr)                        \
  290.     do {                                \
  291.         if (!(expr))                        \
  292.             buffer_assertion_failure(bh);            \
  293.         J_ASSERT(expr);                        \
  294.     } while (0)
  295. #define J_ASSERT_JH(jh, expr)    J_ASSERT_BH(jh2bh(jh), expr)
  296. #else
  297. #define J_ASSERT_BH(bh, expr)    J_ASSERT(expr)
  298. #define J_ASSERT_JH(jh, expr)    J_ASSERT(expr)
  299. #endif
  300.  
  301. #if defined(JBD2_PARANOID_IOFAIL)
  302. #define J_EXPECT(expr, why...)        J_ASSERT(expr)
  303. #define J_EXPECT_BH(bh, expr, why...)    J_ASSERT_BH(bh, expr)
  304. #define J_EXPECT_JH(jh, expr, why...)    J_ASSERT_JH(jh, expr)
  305. #else
  306. #define __journal_expect(expr, why...)                         \
  307.     ({                                     \
  308.         int val = (expr);                         \
  309.         if (!val) {                             \
  310.             printk(KERN_ERR                         \
  311.                    "JBD2 unexpected failure: %s: %s;\n",         \
  312.                    __func__, #expr);                 \
  313.             printk(KERN_ERR why "\n");                 \
  314.         }                                 \
  315.         val;                                 \
  316.     })
  317. #define J_EXPECT(expr, why...)        __journal_expect(expr, ## why)
  318. #define J_EXPECT_BH(bh, expr, why...)    __journal_expect(expr, ## why)
  319. #define J_EXPECT_JH(jh, expr, why...)    __journal_expect(expr, ## why)
  320. #endif
  321.  
  322. enum jbd_state_bits {
  323.     BH_JBD            /* Has an attached ext3 journal_head */
  324.       = BH_PrivateStart,
  325.     BH_JWrite,        /* Being written to log (@@@ DEBUGGING) */
  326.     BH_Freed,        /* Has been freed (truncated) */
  327.     BH_Revoked,        /* Has been revoked from the log */
  328.     BH_RevokeValid,        /* Revoked flag is valid */
  329.     BH_JBDDirty,        /* Is dirty but journaled */
  330.     BH_State,        /* Pins most journal_head state */
  331.     BH_JournalHead,        /* Pins bh->b_private and jh->b_bh */
  332.     BH_Unshadow,        /* Dummy bit, for BJ_Shadow wakeup filtering */
  333.     BH_JBDPrivateStart,    /* First bit available for private use by FS */
  334. };
  335.  
  336. BUFFER_FNS(JBD, jbd)
  337. BUFFER_FNS(JWrite, jwrite)
  338. BUFFER_FNS(JBDDirty, jbddirty)
  339. TAS_BUFFER_FNS(JBDDirty, jbddirty)
  340. BUFFER_FNS(Revoked, revoked)
  341. TAS_BUFFER_FNS(Revoked, revoked)
  342. BUFFER_FNS(RevokeValid, revokevalid)
  343. TAS_BUFFER_FNS(RevokeValid, revokevalid)
  344. BUFFER_FNS(Freed, freed)
  345.  
  346. static inline struct buffer_head *jh2bh(struct journal_head *jh)
  347. {
  348.     return jh->b_bh;
  349. }
  350.  
  351. static inline struct journal_head *bh2jh(struct buffer_head *bh)
  352. {
  353.     return bh->b_private;
  354. }
  355.  
  356. static inline void jbd_lock_bh_state(struct buffer_head *bh)
  357. {
  358.     bit_spin_lock(BH_State, &bh->b_state);
  359. }
  360.  
  361. static inline int jbd_trylock_bh_state(struct buffer_head *bh)
  362. {
  363.     return bit_spin_trylock(BH_State, &bh->b_state);
  364. }
  365.  
  366. static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
  367. {
  368.     return bit_spin_is_locked(BH_State, &bh->b_state);
  369. }
  370.  
  371. static inline void jbd_unlock_bh_state(struct buffer_head *bh)
  372. {
  373.     bit_spin_unlock(BH_State, &bh->b_state);
  374. }
  375.  
  376. static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
  377. {
  378.     bit_spin_lock(BH_JournalHead, &bh->b_state);
  379. }
  380.  
  381. static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
  382. {
  383.     bit_spin_unlock(BH_JournalHead, &bh->b_state);
  384. }
  385.  
  386. /* Flags in jbd_inode->i_flags */
  387. #define __JI_COMMIT_RUNNING 0
  388. /* Commit of the inode data in progress. We use this flag to protect us from
  389.  * concurrent deletion of inode. We cannot use reference to inode for this
  390.  * since we cannot afford doing last iput() on behalf of kjournald
  391.  */
  392. #define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
  393.  
  394. /**
  395.  * struct jbd_inode is the structure linking inodes in ordered mode
  396.  *   present in a transaction so that we can sync them during commit.
  397.  */
  398. struct jbd2_inode {
  399.     /* Which transaction does this inode belong to? Either the running
  400.      * transaction or the committing one. [j_list_lock] */
  401.     transaction_t *i_transaction;
  402.  
  403.     /* Pointer to the running transaction modifying inode's data in case
  404.      * there is already a committing transaction touching it. [j_list_lock] */
  405.     transaction_t *i_next_transaction;
  406.  
  407.     /* List of inodes in the i_transaction [j_list_lock] */
  408.     struct list_head i_list;
  409.  
  410.     /* VFS inode this inode belongs to [constant during the lifetime
  411.      * of the structure] */
  412.     struct inode *i_vfs_inode;
  413.  
  414.     /* Flags of inode [j_list_lock] */
  415.     unsigned int i_flags;
  416. };
  417.  
  418. struct jbd2_revoke_table_s;
  419.  
  420. /**
  421.  * struct handle_s - The handle_s type is the concrete type associated with
  422.  *     handle_t.
  423.  * @h_transaction: Which compound transaction is this update a part of?
  424.  * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
  425.  * @h_ref: Reference count on this handle
  426.  * @h_err: Field for caller's use to track errors through large fs operations
  427.  * @h_sync: flag for sync-on-close
  428.  * @h_jdata: flag to force data journaling
  429.  * @h_aborted: flag indicating fatal error on handle
  430.  **/
  431.  
  432. /* Docbook can't yet cope with the bit fields, but will leave the documentation
  433.  * in so it can be fixed later.
  434.  */
  435.  
  436. struct handle_s
  437. {
  438.     /* Which compound transaction is this update a part of? */
  439.     transaction_t        *h_transaction;
  440.  
  441.     /* Number of remaining buffers we are allowed to dirty: */
  442.     int            h_buffer_credits;
  443.  
  444.     /* Reference count on this handle */
  445.     int            h_ref;
  446.  
  447.     /* Field for caller's use to track errors through large fs */
  448.     /* operations */
  449.     int            h_err;
  450.  
  451.     /* Flags [no locking] */
  452.     unsigned int    h_sync:        1;    /* sync-on-close */
  453.     unsigned int    h_jdata:    1;    /* force data journaling */
  454.     unsigned int    h_aborted:    1;    /* fatal error on handle */
  455.  
  456. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  457.     struct lockdep_map    h_lockdep_map;
  458. #endif
  459. };
  460.  
  461.  
  462. /*
  463.  * Some stats for checkpoint phase
  464.  */
  465. struct transaction_chp_stats_s {
  466.     unsigned long        cs_chp_time;
  467.     unsigned long        cs_forced_to_close;
  468.     unsigned long        cs_written;
  469.     unsigned long        cs_dropped;
  470. };
  471.  
  472. /* The transaction_t type is the guts of the journaling mechanism.  It
  473.  * tracks a compound transaction through its various states:
  474.  *
  475.  * RUNNING:    accepting new updates
  476.  * LOCKED:    Updates still running but we don't accept new ones
  477.  * RUNDOWN:    Updates are tidying up but have finished requesting
  478.  *        new buffers to modify (state not used for now)
  479.  * FLUSH:       All updates complete, but we are still writing to disk
  480.  * COMMIT:      All data on disk, writing commit record
  481.  * FINISHED:    We still have to keep the transaction for checkpointing.
  482.  *
  483.  * The transaction keeps track of all of the buffers modified by a
  484.  * running transaction, and all of the buffers committed but not yet
  485.  * flushed to home for finished transactions.
  486.  */
  487.  
  488. /*
  489.  * Lock ranking:
  490.  *
  491.  *    j_list_lock
  492.  *      ->jbd_lock_bh_journal_head()    (This is "innermost")
  493.  *
  494.  *    j_state_lock
  495.  *    ->jbd_lock_bh_state()
  496.  *
  497.  *    jbd_lock_bh_state()
  498.  *    ->j_list_lock
  499.  *
  500.  *    j_state_lock
  501.  *    ->t_handle_lock
  502.  *
  503.  *    j_state_lock
  504.  *    ->j_list_lock            (journal_unmap_buffer)
  505.  *
  506.  */
  507.  
  508. struct transaction_s
  509. {
  510.     /* Pointer to the journal for this transaction. [no locking] */
  511.     journal_t        *t_journal;
  512.  
  513.     /* Sequence number for this transaction [no locking] */
  514.     tid_t            t_tid;
  515.  
  516.     /*
  517.      * Transaction's current state
  518.      * [no locking - only kjournald2 alters this]
  519.      * [j_list_lock] guards transition of a transaction into T_FINISHED
  520.      * state and subsequent call of __jbd2_journal_drop_transaction()
  521.      * FIXME: needs barriers
  522.      * KLUDGE: [use j_state_lock]
  523.      */
  524.     enum {
  525.         T_RUNNING,
  526.         T_LOCKED,
  527.         T_RUNDOWN,
  528.         T_FLUSH,
  529.         T_COMMIT,
  530.         T_FINISHED
  531.     }            t_state;
  532.  
  533.     /*
  534.      * Where in the log does this transaction's commit start? [no locking]
  535.      */
  536.     unsigned long        t_log_start;
  537.  
  538.     /* Number of buffers on the t_buffers list [j_list_lock] */
  539.     int            t_nr_buffers;
  540.  
  541.     /*
  542.      * Doubly-linked circular list of all buffers reserved but not yet
  543.      * modified by this transaction [j_list_lock]
  544.      */
  545.     struct journal_head    *t_reserved_list;
  546.  
  547.     /*
  548.      * Doubly-linked circular list of all metadata buffers owned by this
  549.      * transaction [j_list_lock]
  550.      */
  551.     struct journal_head    *t_buffers;
  552.  
  553.     /*
  554.      * Doubly-linked circular list of all forget buffers (superseded
  555.      * buffers which we can un-checkpoint once this transaction commits)
  556.      * [j_list_lock]
  557.      */
  558.     struct journal_head    *t_forget;
  559.  
  560.     /*
  561.      * Doubly-linked circular list of all buffers still to be flushed before
  562.      * this transaction can be checkpointed. [j_list_lock]
  563.      */
  564.     struct journal_head    *t_checkpoint_list;
  565.  
  566.     /*
  567.      * Doubly-linked circular list of all buffers submitted for IO while
  568.      * checkpointing. [j_list_lock]
  569.      */
  570.     struct journal_head    *t_checkpoint_io_list;
  571.  
  572.     /*
  573.      * Doubly-linked circular list of temporary buffers currently undergoing
  574.      * IO in the log [j_list_lock]
  575.      */
  576.     struct journal_head    *t_iobuf_list;
  577.  
  578.     /*
  579.      * Doubly-linked circular list of metadata buffers being shadowed by log
  580.      * IO.  The IO buffers on the iobuf list and the shadow buffers on this
  581.      * list match each other one for one at all times. [j_list_lock]
  582.      */
  583.     struct journal_head    *t_shadow_list;
  584.  
  585.     /*
  586.      * Doubly-linked circular list of control buffers being written to the
  587.      * log. [j_list_lock]
  588.      */
  589.     struct journal_head    *t_log_list;
  590.  
  591.     /*
  592.      * List of inodes whose data we've modified in data=ordered mode.
  593.      * [j_list_lock]
  594.      */
  595.     struct list_head    t_inode_list;
  596.  
  597.     /*
  598.      * Protects info related to handles
  599.      */
  600.     spinlock_t        t_handle_lock;
  601.  
  602.     /*
  603.      * Longest time some handle had to wait for running transaction
  604.      */
  605.     unsigned long        t_max_wait;
  606.  
  607.     /*
  608.      * When transaction started
  609.      */
  610.     unsigned long        t_start;
  611.  
  612.     /*
  613.      * Checkpointing stats [j_checkpoint_sem]
  614.      */
  615.     struct transaction_chp_stats_s t_chp_stats;
  616.  
  617.     /*
  618.      * Number of outstanding updates running on this transaction
  619.      * [t_handle_lock]
  620.      */
  621.     int            t_updates;
  622.  
  623.     /*
  624.      * Number of buffers reserved for use by all handles in this transaction
  625.      * handle but not yet modified. [t_handle_lock]
  626.      */
  627.     int            t_outstanding_credits;
  628.  
  629.     /*
  630.      * Forward and backward links for the circular list of all transactions
  631.      * awaiting checkpoint. [j_list_lock]
  632.      */
  633.     transaction_t        *t_cpnext, *t_cpprev;
  634.  
  635.     /*
  636.      * When will the transaction expire (become due for commit), in jiffies?
  637.      * [no locking]
  638.      */
  639.     unsigned long        t_expires;
  640.  
  641.     /*
  642.      * How many handles used this transaction? [t_handle_lock]
  643.      */
  644.     int t_handle_count;
  645.  
  646.     /*
  647.      * For use by the filesystem to store fs-specific data
  648.      * structures associated with the transaction
  649.      */
  650.     struct list_head    t_private_list;
  651. };
  652.  
  653. struct transaction_run_stats_s {
  654.     unsigned long        rs_wait;
  655.     unsigned long        rs_running;
  656.     unsigned long        rs_locked;
  657.     unsigned long        rs_flushing;
  658.     unsigned long        rs_logging;
  659.  
  660.     unsigned long        rs_handle_count;
  661.     unsigned long        rs_blocks;
  662.     unsigned long        rs_blocks_logged;
  663. };
  664.  
  665. struct transaction_stats_s {
  666.     int             ts_type;
  667.     unsigned long        ts_tid;
  668.     union {
  669.         struct transaction_run_stats_s run;
  670.         struct transaction_chp_stats_s chp;
  671.     } u;
  672. };
  673.  
  674. #define JBD2_STATS_RUN        1
  675. #define JBD2_STATS_CHECKPOINT    2
  676.  
  677. static inline unsigned long
  678. jbd2_time_diff(unsigned long start, unsigned long end)
  679. {
  680.     if (end >= start)
  681.         return end - start;
  682.  
  683.     return end + (MAX_JIFFY_OFFSET - start);
  684. }
  685.  
  686. /**
  687.  * struct journal_s - The journal_s type is the concrete type associated with
  688.  *     journal_t.
  689.  * @j_flags:  General journaling state flags
  690.  * @j_errno:  Is there an outstanding uncleared error on the journal (from a
  691.  *     prior abort)?
  692.  * @j_sb_buffer: First part of superblock buffer
  693.  * @j_superblock: Second part of superblock buffer
  694.  * @j_format_version: Version of the superblock format
  695.  * @j_state_lock: Protect the various scalars in the journal
  696.  * @j_barrier_count:  Number of processes waiting to create a barrier lock
  697.  * @j_barrier: The barrier lock itself
  698.  * @j_running_transaction: The current running transaction..
  699.  * @j_committing_transaction: the transaction we are pushing to disk
  700.  * @j_checkpoint_transactions: a linked circular list of all transactions
  701.  *  waiting for checkpointing
  702.  * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
  703.  *  to start committing, or for a barrier lock to be released
  704.  * @j_wait_logspace: Wait queue for waiting for checkpointing to complete
  705.  * @j_wait_done_commit: Wait queue for waiting for commit to complete
  706.  * @j_wait_checkpoint:  Wait queue to trigger checkpointing
  707.  * @j_wait_commit: Wait queue to trigger commit
  708.  * @j_wait_updates: Wait queue to wait for updates to complete
  709.  * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
  710.  * @j_head: Journal head - identifies the first unused block in the journal
  711.  * @j_tail: Journal tail - identifies the oldest still-used block in the
  712.  *  journal.
  713.  * @j_free: Journal free - how many free blocks are there in the journal?
  714.  * @j_first: The block number of the first usable block
  715.  * @j_last: The block number one beyond the last usable block
  716.  * @j_dev: Device where we store the journal
  717.  * @j_blocksize: blocksize for the location where we store the journal.
  718.  * @j_blk_offset: starting block offset for into the device where we store the
  719.  *     journal
  720.  * @j_fs_dev: Device which holds the client fs.  For internal journal this will
  721.  *     be equal to j_dev
  722.  * @j_maxlen: Total maximum capacity of the journal region on disk.
  723.  * @j_list_lock: Protects the buffer lists and internal buffer state.
  724.  * @j_inode: Optional inode where we store the journal.  If present, all journal
  725.  *     block numbers are mapped into this inode via bmap().
  726.  * @j_tail_sequence:  Sequence number of the oldest transaction in the log
  727.  * @j_transaction_sequence: Sequence number of the next transaction to grant
  728.  * @j_commit_sequence: Sequence number of the most recently committed
  729.  *  transaction
  730.  * @j_commit_request: Sequence number of the most recent transaction wanting
  731.  *     commit
  732.  * @j_uuid: Uuid of client object.
  733.  * @j_task: Pointer to the current commit thread for this journal
  734.  * @j_max_transaction_buffers:  Maximum number of metadata buffers to allow in a
  735.  *     single compound commit transaction
  736.  * @j_commit_interval: What is the maximum transaction lifetime before we begin
  737.  *  a commit?
  738.  * @j_commit_timer:  The timer used to wakeup the commit thread
  739.  * @j_revoke_lock: Protect the revoke table
  740.  * @j_revoke: The revoke table - maintains the list of revoked blocks in the
  741.  *     current transaction.
  742.  * @j_revoke_table: alternate revoke tables for j_revoke
  743.  * @j_wbuf: array of buffer_heads for jbd2_journal_commit_transaction
  744.  * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the
  745.  *    number that will fit in j_blocksize
  746.  * @j_last_sync_writer: most recent pid which did a synchronous write
  747.  * @j_history: Buffer storing the transactions statistics history
  748.  * @j_history_max: Maximum number of transactions in the statistics history
  749.  * @j_history_cur: Current number of transactions in the statistics history
  750.  * @j_history_lock: Protect the transactions statistics history
  751.  * @j_proc_entry: procfs entry for the jbd statistics directory
  752.  * @j_stats: Overall statistics
  753.  * @j_private: An opaque pointer to fs-private information.
  754.  */
  755.  
  756. struct journal_s
  757. {
  758.     /* General journaling state flags [j_state_lock] */
  759.     unsigned long        j_flags;
  760.  
  761.     /*
  762.      * Is there an outstanding uncleared error on the journal (from a prior
  763.      * abort)? [j_state_lock]
  764.      */
  765.     int            j_errno;
  766.  
  767.     /* The superblock buffer */
  768.     struct buffer_head    *j_sb_buffer;
  769.     journal_superblock_t    *j_superblock;
  770.  
  771.     /* Version of the superblock format */
  772.     int            j_format_version;
  773.  
  774.     /*
  775.      * Protect the various scalars in the journal
  776.      */
  777.     spinlock_t        j_state_lock;
  778.  
  779.     /*
  780.      * Number of processes waiting to create a barrier lock [j_state_lock]
  781.      */
  782.     int            j_barrier_count;
  783.  
  784.     /* The barrier lock itself */
  785.     struct mutex        j_barrier;
  786.  
  787.     /*
  788.      * Transactions: The current running transaction...
  789.      * [j_state_lock] [caller holding open handle]
  790.      */
  791.     transaction_t        *j_running_transaction;
  792.  
  793.     /*
  794.      * the transaction we are pushing to disk
  795.      * [j_state_lock] [caller holding open handle]
  796.      */
  797.     transaction_t        *j_committing_transaction;
  798.  
  799.     /*
  800.      * ... and a linked circular list of all transactions waiting for
  801.      * checkpointing. [j_list_lock]
  802.      */
  803.     transaction_t        *j_checkpoint_transactions;
  804.  
  805.     /*
  806.      * Wait queue for waiting for a locked transaction to start committing,
  807.      * or for a barrier lock to be released
  808.      */
  809.     wait_queue_head_t    j_wait_transaction_locked;
  810.  
  811.     /* Wait queue for waiting for checkpointing to complete */
  812.     wait_queue_head_t    j_wait_logspace;
  813.  
  814.     /* Wait queue for waiting for commit to complete */
  815.     wait_queue_head_t    j_wait_done_commit;
  816.  
  817.     /* Wait queue to trigger checkpointing */
  818.     wait_queue_head_t    j_wait_checkpoint;
  819.  
  820.     /* Wait queue to trigger commit */
  821.     wait_queue_head_t    j_wait_commit;
  822.  
  823.     /* Wait queue to wait for updates to complete */
  824.     wait_queue_head_t    j_wait_updates;
  825.  
  826.     /* Semaphore for locking against concurrent checkpoints */
  827.     struct mutex        j_checkpoint_mutex;
  828.  
  829.     /*
  830.      * Journal head: identifies the first unused block in the journal.
  831.      * [j_state_lock]
  832.      */
  833.     unsigned long        j_head;
  834.  
  835.     /*
  836.      * Journal tail: identifies the oldest still-used block in the journal.
  837.      * [j_state_lock]
  838.      */
  839.     unsigned long        j_tail;
  840.  
  841.     /*
  842.      * Journal free: how many free blocks are there in the journal?
  843.      * [j_state_lock]
  844.      */
  845.     unsigned long        j_free;
  846.  
  847.     /*
  848.      * Journal start and end: the block numbers of the first usable block
  849.      * and one beyond the last usable block in the journal. [j_state_lock]
  850.      */
  851.     unsigned long        j_first;
  852.     unsigned long        j_last;
  853.  
  854.     /*
  855.      * Device, blocksize and starting block offset for the location where we
  856.      * store the journal.
  857.      */
  858.     struct block_device    *j_dev;
  859.     int            j_blocksize;
  860.     unsigned long long    j_blk_offset;
  861.     char            j_devname[BDEVNAME_SIZE+24];
  862.  
  863.     /*
  864.      * Device which holds the client fs.  For internal journal this will be
  865.      * equal to j_dev.
  866.      */
  867.     struct block_device    *j_fs_dev;
  868.  
  869.     /* Total maximum capacity of the journal region on disk. */
  870.     unsigned int        j_maxlen;
  871.  
  872.     /*
  873.      * Protects the buffer lists and internal buffer state.
  874.      */
  875.     spinlock_t        j_list_lock;
  876.  
  877.     /* Optional inode where we store the journal.  If present, all */
  878.     /* journal block numbers are mapped into this inode via */
  879.     /* bmap(). */
  880.     struct inode        *j_inode;
  881.  
  882.     /*
  883.      * Sequence number of the oldest transaction in the log [j_state_lock]
  884.      */
  885.     tid_t            j_tail_sequence;
  886.  
  887.     /*
  888.      * Sequence number of the next transaction to grant [j_state_lock]
  889.      */
  890.     tid_t            j_transaction_sequence;
  891.  
  892.     /*
  893.      * Sequence number of the most recently committed transaction
  894.      * [j_state_lock].
  895.      */
  896.     tid_t            j_commit_sequence;
  897.  
  898.     /*
  899.      * Sequence number of the most recent transaction wanting commit
  900.      * [j_state_lock]
  901.      */
  902.     tid_t            j_commit_request;
  903.  
  904.     /*
  905.      * Journal uuid: identifies the object (filesystem, LVM volume etc)
  906.      * backed by this journal.  This will eventually be replaced by an array
  907.      * of uuids, allowing us to index multiple devices within a single
  908.      * journal and to perform atomic updates across them.
  909.      */
  910.     __u8            j_uuid[16];
  911.  
  912.     /* Pointer to the current commit thread for this journal */
  913.     struct task_struct    *j_task;
  914.  
  915.     /*
  916.      * Maximum number of metadata buffers to allow in a single compound
  917.      * commit transaction
  918.      */
  919.     int            j_max_transaction_buffers;
  920.  
  921.     /*
  922.      * What is the maximum transaction lifetime before we begin a commit?
  923.      */
  924.     unsigned long        j_commit_interval;
  925.  
  926.     /* The timer used to wakeup the commit thread: */
  927.     struct timer_list    j_commit_timer;
  928.  
  929.     /*
  930.      * The revoke table: maintains the list of revoked blocks in the
  931.      * current transaction.  [j_revoke_lock]
  932.      */
  933.     spinlock_t        j_revoke_lock;
  934.     struct jbd2_revoke_table_s *j_revoke;
  935.     struct jbd2_revoke_table_s *j_revoke_table[2];
  936.  
  937.     /*
  938.      * array of bhs for jbd2_journal_commit_transaction
  939.      */
  940.     struct buffer_head    **j_wbuf;
  941.     int            j_wbufsize;
  942.  
  943.     pid_t            j_last_sync_writer;
  944.  
  945.     /* This function is called when a transaction is closed */
  946.     void            (*j_commit_callback)(journal_t *,
  947.                              transaction_t *);
  948.  
  949.     /*
  950.      * Journal statistics
  951.      */
  952.     struct transaction_stats_s *j_history;
  953.     int            j_history_max;
  954.     int            j_history_cur;
  955.     /*
  956.      * Protect the transactions statistics history
  957.      */
  958.     spinlock_t        j_history_lock;
  959.     struct proc_dir_entry    *j_proc_entry;
  960.     struct transaction_stats_s j_stats;
  961.  
  962.     /* Failed journal commit ID */
  963.     unsigned int        j_failed_commit;
  964.  
  965.     /*
  966.      * An opaque pointer to fs-private information.  ext3 puts its
  967.      * superblock pointer here
  968.      */
  969.     void *j_private;
  970. };
  971.  
  972. /*
  973.  * Journal flag definitions
  974.  */
  975. #define JBD2_UNMOUNT    0x001    /* Journal thread is being destroyed */
  976. #define JBD2_ABORT    0x002    /* Journaling has been aborted for errors. */
  977. #define JBD2_ACK_ERR    0x004    /* The errno in the sb has been acked */
  978. #define JBD2_FLUSHED    0x008    /* The journal superblock has been flushed */
  979. #define JBD2_LOADED    0x010    /* The journal superblock has been loaded */
  980. #define JBD2_BARRIER    0x020    /* Use IDE barriers */
  981. #define JBD2_ABORT_ON_SYNCDATA_ERR    0x040    /* Abort the journal on file
  982.                          * data write error in ordered
  983.                          * mode */
  984.  
  985. /*
  986.  * Function declarations for the journaling transaction and buffer
  987.  * management
  988.  */
  989.  
  990. /* Filing buffers */
  991. extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
  992. extern void __jbd2_journal_unfile_buffer(struct journal_head *);
  993. extern void __jbd2_journal_refile_buffer(struct journal_head *);
  994. extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
  995. extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
  996. extern void __journal_free_buffer(struct journal_head *bh);
  997. extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
  998. extern void __journal_clean_data_list(transaction_t *transaction);
  999.  
  1000. /* Log buffer allocation */
  1001. extern struct journal_head * jbd2_journal_get_descriptor_buffer(journal_t *);
  1002. int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
  1003.  
  1004. /* Commit management */
  1005. extern void jbd2_journal_commit_transaction(journal_t *);
  1006.  
  1007. /* Checkpoint list management */
  1008. int __jbd2_journal_clean_checkpoint_list(journal_t *journal);
  1009. int __jbd2_journal_remove_checkpoint(struct journal_head *);
  1010. void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
  1011.  
  1012. /* Buffer IO */
  1013. extern int
  1014. jbd2_journal_write_metadata_buffer(transaction_t      *transaction,
  1015.                   struct journal_head  *jh_in,
  1016.                   struct journal_head **jh_out,
  1017.                   unsigned long long   blocknr);
  1018.  
  1019. /* Transaction locking */
  1020. extern void        __wait_on_journal (journal_t *);
  1021.  
  1022. /*
  1023.  * Journal locking.
  1024.  *
  1025.  * We need to lock the journal during transaction state changes so that nobody
  1026.  * ever tries to take a handle on the running transaction while we are in the
  1027.  * middle of moving it to the commit phase.  j_state_lock does this.
  1028.  *
  1029.  * Note that the locking is completely interrupt unsafe.  We never touch
  1030.  * journal structures from interrupts.
  1031.  */
  1032.  
  1033. static inline handle_t *journal_current_handle(void)
  1034. {
  1035.     return current->journal_info;
  1036. }
  1037.  
  1038. /* The journaling code user interface:
  1039.  *
  1040.  * Create and destroy handles
  1041.  * Register buffer modifications against the current transaction.
  1042.  */
  1043.  
  1044. extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
  1045. extern int     jbd2_journal_restart (handle_t *, int nblocks);
  1046. extern int     jbd2_journal_extend (handle_t *, int nblocks);
  1047. extern int     jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
  1048. extern int     jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
  1049. extern int     jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
  1050. extern int     jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
  1051. extern void     jbd2_journal_release_buffer (handle_t *, struct buffer_head *);
  1052. extern int     jbd2_journal_forget (handle_t *, struct buffer_head *);
  1053. extern void     journal_sync_buffer (struct buffer_head *);
  1054. extern void     jbd2_journal_invalidatepage(journal_t *,
  1055.                 struct page *, unsigned long);
  1056. extern int     jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
  1057. extern int     jbd2_journal_stop(handle_t *);
  1058. extern int     jbd2_journal_flush (journal_t *);
  1059. extern void     jbd2_journal_lock_updates (journal_t *);
  1060. extern void     jbd2_journal_unlock_updates (journal_t *);
  1061.  
  1062. extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
  1063.                 struct block_device *fs_dev,
  1064.                 unsigned long long start, int len, int bsize);
  1065. extern journal_t * jbd2_journal_init_inode (struct inode *);
  1066. extern int       jbd2_journal_update_format (journal_t *);
  1067. extern int       jbd2_journal_check_used_features
  1068.            (journal_t *, unsigned long, unsigned long, unsigned long);
  1069. extern int       jbd2_journal_check_available_features
  1070.            (journal_t *, unsigned long, unsigned long, unsigned long);
  1071. extern int       jbd2_journal_set_features
  1072.            (journal_t *, unsigned long, unsigned long, unsigned long);
  1073. extern void       jbd2_journal_clear_features
  1074.            (journal_t *, unsigned long, unsigned long, unsigned long);
  1075. extern int       jbd2_journal_create     (journal_t *);
  1076. extern int       jbd2_journal_load       (journal_t *journal);
  1077. extern int       jbd2_journal_destroy    (journal_t *);
  1078. extern int       jbd2_journal_recover    (journal_t *journal);
  1079. extern int       jbd2_journal_wipe       (journal_t *, int);
  1080. extern int       jbd2_journal_skip_recovery    (journal_t *);
  1081. extern void       jbd2_journal_update_superblock    (journal_t *, int);
  1082. extern void       __jbd2_journal_abort_hard    (journal_t *);
  1083. extern void       jbd2_journal_abort      (journal_t *, int);
  1084. extern int       jbd2_journal_errno      (journal_t *);
  1085. extern void       jbd2_journal_ack_err    (journal_t *);
  1086. extern int       jbd2_journal_clear_err  (journal_t *);
  1087. extern int       jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
  1088. extern int       jbd2_journal_force_commit(journal_t *);
  1089. extern int       jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
  1090. extern int       jbd2_journal_begin_ordered_truncate(journal_t *journal,
  1091.                 struct jbd2_inode *inode, loff_t new_size);
  1092. extern void       jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
  1093. extern void       jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
  1094.  
  1095. /*
  1096.  * journal_head management
  1097.  */
  1098. struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
  1099. struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
  1100. void jbd2_journal_remove_journal_head(struct buffer_head *bh);
  1101. void jbd2_journal_put_journal_head(struct journal_head *jh);
  1102.  
  1103. /*
  1104.  * handle management
  1105.  */
  1106. extern struct kmem_cache *jbd2_handle_cache;
  1107.  
  1108. static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
  1109. {
  1110.     return kmem_cache_alloc(jbd2_handle_cache, gfp_flags);
  1111. }
  1112.  
  1113. static inline void jbd2_free_handle(handle_t *handle)
  1114. {
  1115.     kmem_cache_free(jbd2_handle_cache, handle);
  1116. }
  1117.  
  1118. /* Primary revoke support */
  1119. #define JOURNAL_REVOKE_DEFAULT_HASH 256
  1120. extern int       jbd2_journal_init_revoke(journal_t *, int);
  1121. extern void       jbd2_journal_destroy_revoke_caches(void);
  1122. extern int       jbd2_journal_init_revoke_caches(void);
  1123.  
  1124. extern void       jbd2_journal_destroy_revoke(journal_t *);
  1125. extern int       jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
  1126. extern int       jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
  1127. extern void       jbd2_journal_write_revoke_records(journal_t *, transaction_t *);
  1128.  
  1129. /* Recovery revoke support */
  1130. extern int    jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
  1131. extern int    jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
  1132. extern void    jbd2_journal_clear_revoke(journal_t *);
  1133. extern void    jbd2_journal_switch_revoke_table(journal_t *journal);
  1134.  
  1135. /*
  1136.  * The log thread user interface:
  1137.  *
  1138.  * Request space in the current transaction, and force transaction commit
  1139.  * transitions on demand.
  1140.  */
  1141.  
  1142. int __jbd2_log_space_left(journal_t *); /* Called with journal locked */
  1143. int jbd2_log_start_commit(journal_t *journal, tid_t tid);
  1144. int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
  1145. int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
  1146. int jbd2_journal_force_commit_nested(journal_t *journal);
  1147. int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
  1148. int jbd2_log_do_checkpoint(journal_t *journal);
  1149.  
  1150. void __jbd2_log_wait_for_space(journal_t *journal);
  1151. extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
  1152. extern int jbd2_cleanup_journal_tail(journal_t *);
  1153.  
  1154. /* Debugging code only: */
  1155.  
  1156. #define jbd_ENOSYS() \
  1157. do {                                           \
  1158.     printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \
  1159.     current->state = TASK_UNINTERRUPTIBLE;                       \
  1160.     schedule();                                   \
  1161. } while (1)
  1162.  
  1163. /*
  1164.  * is_journal_abort
  1165.  *
  1166.  * Simple test wrapper function to test the JBD2_ABORT state flag.  This
  1167.  * bit, when set, indicates that we have had a fatal error somewhere,
  1168.  * either inside the journaling layer or indicated to us by the client
  1169.  * (eg. ext3), and that we and should not commit any further
  1170.  * transactions.
  1171.  */
  1172.  
  1173. static inline int is_journal_aborted(journal_t *journal)
  1174. {
  1175.     return journal->j_flags & JBD2_ABORT;
  1176. }
  1177.  
  1178. static inline int is_handle_aborted(handle_t *handle)
  1179. {
  1180.     if (handle->h_aborted)
  1181.         return 1;
  1182.     return is_journal_aborted(handle->h_transaction->t_journal);
  1183. }
  1184.  
  1185. static inline void jbd2_journal_abort_handle(handle_t *handle)
  1186. {
  1187.     handle->h_aborted = 1;
  1188. }
  1189.  
  1190. #endif /* __KERNEL__   */
  1191.  
  1192. /* Comparison functions for transaction IDs: perform comparisons using
  1193.  * modulo arithmetic so that they work over sequence number wraps. */
  1194.  
  1195. static inline int tid_gt(tid_t x, tid_t y)
  1196. {
  1197.     int difference = (x - y);
  1198.     return (difference > 0);
  1199. }
  1200.  
  1201. static inline int tid_geq(tid_t x, tid_t y)
  1202. {
  1203.     int difference = (x - y);
  1204.     return (difference >= 0);
  1205. }
  1206.  
  1207. extern int jbd2_journal_blocks_per_page(struct inode *inode);
  1208. extern size_t journal_tag_bytes(journal_t *journal);
  1209.  
  1210. /*
  1211.  * Return the minimum number of blocks which must be free in the journal
  1212.  * before a new transaction may be started.  Must be called under j_state_lock.
  1213.  */
  1214. static inline int jbd_space_needed(journal_t *journal)
  1215. {
  1216.     int nblocks = journal->j_max_transaction_buffers;
  1217.     if (journal->j_committing_transaction)
  1218.         nblocks += journal->j_committing_transaction->
  1219.                     t_outstanding_credits;
  1220.     return nblocks;
  1221. }
  1222.  
  1223. /*
  1224.  * Definitions which augment the buffer_head layer
  1225.  */
  1226.  
  1227. /* journaling buffer types */
  1228. #define BJ_None        0    /* Not journaled */
  1229. #define BJ_Metadata    1    /* Normal journaled metadata */
  1230. #define BJ_Forget    2    /* Buffer superseded by this transaction */
  1231. #define BJ_IO        3    /* Buffer is for temporary IO use */
  1232. #define BJ_Shadow    4    /* Buffer contents being shadowed to the log */
  1233. #define BJ_LogCtl    5    /* Buffer contains log descriptors */
  1234. #define BJ_Reserved    6    /* Buffer is reserved for access by journal */
  1235. #define BJ_Types    7
  1236.  
  1237. extern int jbd_blocks_per_page(struct inode *inode);
  1238.  
  1239. #ifdef __KERNEL__
  1240.  
  1241. #define buffer_trace_init(bh)    do {} while (0)
  1242. #define print_buffer_fields(bh)    do {} while (0)
  1243. #define print_buffer_trace(bh)    do {} while (0)
  1244. #define BUFFER_TRACE(bh, info)    do {} while (0)
  1245. #define BUFFER_TRACE2(bh, bh2, info)    do {} while (0)
  1246. #define JBUFFER_TRACE(jh, info)    do {} while (0)
  1247.  
  1248. #endif    /* __KERNEL__ */
  1249.  
  1250. #endif    /* _LINUX_JBD2_H */
  1251.