LCOV - code coverage report
Current view: top level - lkbce/include/linux - jbd.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 17 60 28.3 %
Date: 2017-01-25 Functions: 0 38 0.0 %

          Line data    Source code
       1             : /*
       2             :  * linux/include/linux/jbd.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_JBD_H
      17             : #define _LINUX_JBD_H
      18             : 
      19             : /* Allow this file to be included directly into e2fsprogs */
      20             : #ifndef __KERNEL__
      21             : #include "jfs_compat.h"
      22             : #define JFS_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             : #include <linux/lockdep.h>
      34             : 
      35             : #define journal_oom_retry 1
      36             : 
      37             : /*
      38             :  * Define JBD_PARANOID_IOFAIL to cause a kernel BUG() if ext3 finds
      39             :  * certain classes of error which can occur due to failed IOs.  Under
      40             :  * normal use we want ext3 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 JBD_PARANOID_IOFAIL
      45             : 
      46             : /*
      47             :  * The default maximum commit age, in seconds.
      48             :  */
      49             : #define JBD_DEFAULT_MAX_COMMIT_AGE 5
      50             : 
      51             : #ifdef CONFIG_JBD_DEBUG
      52             : /*
      53             :  * Define JBD_EXPENSIVE_CHECKING to enable more expensive internal
      54             :  * consistency checks.  By default we don't do this unless
      55             :  * CONFIG_JBD_DEBUG is on.
      56             :  */
      57             : #define JBD_EXPENSIVE_CHECKING
      58             : extern u8 journal_enable_debug;
      59             : 
      60             : #define jbd_debug(n, f, a...)                                           \
      61             :         do {                                                            \
      62             :                 if ((n) <= 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 *jbd_alloc(size_t size, gfp_t flags)
      73             : {
      74           0 :         return (void *)__get_free_pages(flags, get_order(size));
      75           0 : }
      76             : 
      77             : static inline void jbd_free(void *ptr, size_t size)
      78             : {
      79           0 :         free_pages((unsigned long)ptr, get_order(size));
      80           0 : };
      81             : 
      82             : #define JFS_MIN_JOURNAL_BLOCKS 1024
      83             : 
      84             : 
      85             : /**
      86             :  * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
      87             :  *
      88             :  * All filesystem modifications made by the process go
      89             :  * through this handle.  Recursive operations (such as quota operations)
      90             :  * are gathered into a single update.
      91             :  *
      92             :  * The buffer credits field is used to account for journaled buffers
      93             :  * being modified by the running process.  To ensure that there is
      94             :  * enough log space for all outstanding operations, we need to limit the
      95             :  * number of outstanding buffers possible at any time.  When the
      96             :  * operation completes, any buffer credits not used are credited back to
      97             :  * the transaction, so that at all times we know how many buffers the
      98             :  * outstanding updates on a transaction might possibly touch.
      99             :  *
     100             :  * This is an opaque datatype.
     101             :  **/
     102           2 : typedef struct handle_s         handle_t;       /* Atomic operation type */
     103             : 
     104             : 
     105             : /**
     106             :  * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
     107             :  *
     108             :  * journal_t is linked to from the fs superblock structure.
     109             :  *
     110             :  * We use the journal_t to keep track of all outstanding transaction
     111             :  * activity on the filesystem, and to manage the state of the log
     112             :  * writing process.
     113             :  *
     114             :  * This is an opaque datatype.
     115             :  **/
     116           2 : typedef struct journal_s        journal_t;      /* Journal control structure */
     117           1 : #endif
     118             : 
     119             : /*
     120             :  * Internal structures used by the logging mechanism:
     121             :  */
     122             : 
     123             : #define JFS_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
     124             : 
     125             : /*
     126             :  * On-disk structures
     127             :  */
     128             : 
     129             : /*
     130             :  * Descriptor block types:
     131             :  */
     132             : 
     133             : #define JFS_DESCRIPTOR_BLOCK    1
     134             : #define JFS_COMMIT_BLOCK        2
     135             : #define JFS_SUPERBLOCK_V1       3
     136             : #define JFS_SUPERBLOCK_V2       4
     137             : #define JFS_REVOKE_BLOCK        5
     138             : 
     139             : /*
     140             :  * Standard header for all descriptor blocks:
     141             :  */
     142             : typedef struct journal_header_s
     143             : {
     144             :         __be32          h_magic;
     145             :         __be32          h_blocktype;
     146             :         __be32          h_sequence;
     147           1 : } journal_header_t;
     148           1 : 
     149             : 
     150             : /*
     151             :  * The block tag: used to describe a single buffer in the journal
     152             :  */
     153             : typedef struct journal_block_tag_s
     154             : {
     155             :         __be32          t_blocknr;      /* The on-disk block number */
     156             :         __be32          t_flags;        /* See below */
     157           1 : } journal_block_tag_t;
     158           1 : 
     159             : /*
     160             :  * The revoke descriptor: used on disk to describe a series of blocks to
     161             :  * be revoked from the log
     162             :  */
     163             : typedef struct journal_revoke_header_s
     164             : {
     165             :         journal_header_t r_header;
     166             :         __be32           r_count;       /* Count of bytes used in the block */
     167           1 : } journal_revoke_header_t;
     168           1 : 
     169             : 
     170             : /* Definitions for the journal tag flags word: */
     171             : #define JFS_FLAG_ESCAPE         1       /* on-disk block is escaped */
     172             : #define JFS_FLAG_SAME_UUID      2       /* block has same uuid as previous */
     173             : #define JFS_FLAG_DELETED        4       /* block deleted by this transaction */
     174             : #define JFS_FLAG_LAST_TAG       8       /* last tag in this descriptor block */
     175             : 
     176             : 
     177             : /*
     178             :  * The journal superblock.  All fields are in big-endian byte order.
     179             :  */
     180             : typedef struct journal_superblock_s
     181             : {
     182             : /* 0x0000 */
     183             :         journal_header_t s_header;
     184             : 
     185             : /* 0x000C */
     186             :         /* Static information describing the journal */
     187             :         __be32  s_blocksize;            /* journal device blocksize */
     188             :         __be32  s_maxlen;               /* total blocks in journal file */
     189             :         __be32  s_first;                /* first block of log information */
     190             : 
     191             : /* 0x0018 */
     192             :         /* Dynamic information describing the current state of the log */
     193             :         __be32  s_sequence;             /* first commit ID expected in log */
     194             :         __be32  s_start;                /* blocknr of start of log */
     195             : 
     196             : /* 0x0020 */
     197             :         /* Error value, as set by journal_abort(). */
     198             :         __be32  s_errno;
     199             : 
     200             : /* 0x0024 */
     201             :         /* Remaining fields are only valid in a version-2 superblock */
     202             :         __be32  s_feature_compat;       /* compatible feature set */
     203             :         __be32  s_feature_incompat;     /* incompatible feature set */
     204             :         __be32  s_feature_ro_compat;    /* readonly-compatible feature set */
     205             : /* 0x0030 */
     206             :         __u8    s_uuid[16];             /* 128-bit uuid for journal */
     207             : 
     208             : /* 0x0040 */
     209             :         __be32  s_nr_users;             /* Nr of filesystems sharing log */
     210             : 
     211             :         __be32  s_dynsuper;             /* Blocknr of dynamic superblock copy*/
     212             : 
     213             : /* 0x0048 */
     214             :         __be32  s_max_transaction;      /* Limit of journal blocks per trans.*/
     215             :         __be32  s_max_trans_data;       /* Limit of data blocks per trans. */
     216             : 
     217             : /* 0x0050 */
     218             :         __u32   s_padding[44];
     219             : 
     220             : /* 0x0100 */
     221             :         __u8    s_users[16*48];         /* ids of all fs'es sharing the log */
     222             : /* 0x0400 */
     223           1 : } journal_superblock_t;
     224             : 
     225             : #define JFS_HAS_COMPAT_FEATURE(j,mask)                                  \
     226             :         ((j)->j_format_version >= 2 &&                                    \
     227             :          ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
     228             : #define JFS_HAS_RO_COMPAT_FEATURE(j,mask)                               \
     229             :         ((j)->j_format_version >= 2 &&                                    \
     230             :          ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
     231             : #define JFS_HAS_INCOMPAT_FEATURE(j,mask)                                \
     232             :         ((j)->j_format_version >= 2 &&                                    \
     233             :          ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
     234             : 
     235             : #define JFS_FEATURE_INCOMPAT_REVOKE     0x00000001
     236             : 
     237             : /* Features known to this kernel version: */
     238             : #define JFS_KNOWN_COMPAT_FEATURES       0
     239             : #define JFS_KNOWN_ROCOMPAT_FEATURES     0
     240             : #define JFS_KNOWN_INCOMPAT_FEATURES     JFS_FEATURE_INCOMPAT_REVOKE
     241             : 
     242             : #ifdef __KERNEL__
     243             : 
     244             : #include <linux/fs.h>
     245             : #include <linux/sched.h>
     246             : 
     247             : #define J_ASSERT(assert)        BUG_ON(!(assert))
     248             : 
     249             : #if defined(CONFIG_BUFFER_DEBUG)
     250             : void buffer_assertion_failure(struct buffer_head *bh);
     251             : #define J_ASSERT_BH(bh, expr)                                           \
     252             :         do {                                                            \
     253             :                 if (!(expr))                                            \
     254             :                         buffer_assertion_failure(bh);                   \
     255             :                 J_ASSERT(expr);                                         \
     256             :         } while (0)
     257             : #define J_ASSERT_JH(jh, expr)   J_ASSERT_BH(jh2bh(jh), expr)
     258             : #else
     259             : #define J_ASSERT_BH(bh, expr)   J_ASSERT(expr)
     260             : #define J_ASSERT_JH(jh, expr)   J_ASSERT(expr)
     261             : #endif
     262             : 
     263             : #if defined(JBD_PARANOID_IOFAIL)
     264             : #define J_EXPECT(expr, why...)          J_ASSERT(expr)
     265             : #define J_EXPECT_BH(bh, expr, why...)   J_ASSERT_BH(bh, expr)
     266             : #define J_EXPECT_JH(jh, expr, why...)   J_ASSERT_JH(jh, expr)
     267             : #else
     268             : #define __journal_expect(expr, why...)                                       \
     269             :         ({                                                                   \
     270             :                 int val = (expr);                                            \
     271             :                 if (!val) {                                                  \
     272             :                         printk(KERN_ERR                                      \
     273             :                                 "EXT3-fs unexpected failure: %s;\n",# expr); \
     274             :                         printk(KERN_ERR why "\n");                         \
     275             :                 }                                                            \
     276             :                 val;                                                         \
     277             :         })
     278             : #define J_EXPECT(expr, why...)          __journal_expect(expr, ## why)
     279             : #define J_EXPECT_BH(bh, expr, why...)   __journal_expect(expr, ## why)
     280             : #define J_EXPECT_JH(jh, expr, why...)   __journal_expect(expr, ## why)
     281             : #endif
     282             : 
     283             : enum jbd_state_bits {
     284             :         BH_JBD                  /* Has an attached ext3 journal_head */
     285             :           = BH_PrivateStart,
     286             :         BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
     287             :         BH_Freed,               /* Has been freed (truncated) */
     288             :         BH_Revoked,             /* Has been revoked from the log */
     289             :         BH_RevokeValid,         /* Revoked flag is valid */
     290             :         BH_JBDDirty,            /* Is dirty but journaled */
     291             :         BH_State,               /* Pins most journal_head state */
     292             :         BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
     293             :         BH_Unshadow,            /* Dummy bit, for BJ_Shadow wakeup filtering */
     294             : };
     295             : 
     296           0 : BUFFER_FNS(JBD, jbd)
     297           0 : BUFFER_FNS(JWrite, jwrite)
     298           0 : BUFFER_FNS(JBDDirty, jbddirty)
     299           0 : TAS_BUFFER_FNS(JBDDirty, jbddirty)
     300           0 : BUFFER_FNS(Revoked, revoked)
     301           0 : TAS_BUFFER_FNS(Revoked, revoked)
     302           0 : BUFFER_FNS(RevokeValid, revokevalid)
     303           0 : TAS_BUFFER_FNS(RevokeValid, revokevalid)
     304           0 : BUFFER_FNS(Freed, freed)
     305           0 : 
     306           0 : static inline struct buffer_head *jh2bh(struct journal_head *jh)
     307             : {
     308           0 :         return jh->b_bh;
     309             : }
     310             : 
     311             : static inline struct journal_head *bh2jh(struct buffer_head *bh)
     312             : {
     313           0 :         return bh->b_private;
     314             : }
     315             : 
     316             : static inline void jbd_lock_bh_state(struct buffer_head *bh)
     317             : {
     318           0 :         bit_spin_lock(BH_State, &bh->b_state);
     319           0 : }
     320             : 
     321             : static inline int jbd_trylock_bh_state(struct buffer_head *bh)
     322             : {
     323           0 :         return bit_spin_trylock(BH_State, &bh->b_state);
     324             : }
     325             : 
     326             : static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
     327             : {
     328           0 :         return bit_spin_is_locked(BH_State, &bh->b_state);
     329             : }
     330             : 
     331             : static inline void jbd_unlock_bh_state(struct buffer_head *bh)
     332             : {
     333           0 :         bit_spin_unlock(BH_State, &bh->b_state);
     334           0 : }
     335             : 
     336             : static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
     337             : {
     338           0 :         bit_spin_lock(BH_JournalHead, &bh->b_state);
     339           0 : }
     340             : 
     341             : static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
     342             : {
     343           0 :         bit_spin_unlock(BH_JournalHead, &bh->b_state);
     344           0 : }
     345           1 : 
     346           1 : struct jbd_revoke_table_s;
     347             : 
     348             : /**
     349             :  * struct handle_s - this is the concrete type associated with handle_t.
     350             :  * @h_transaction: Which compound transaction is this update a part of?
     351             :  * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
     352             :  * @h_ref: Reference count on this handle
     353             :  * @h_err: Field for caller's use to track errors through large fs operations
     354             :  * @h_sync: flag for sync-on-close
     355             :  * @h_jdata: flag to force data journaling
     356             :  * @h_aborted: flag indicating fatal error on handle
     357             :  * @h_lockdep_map: lockdep info for debugging lock problems
     358             :  */
     359             : struct handle_s
     360             : {
     361             :         /* Which compound transaction is this update a part of? */
     362             :         transaction_t           *h_transaction;
     363             : 
     364             :         /* Number of remaining buffers we are allowed to dirty: */
     365             :         int                     h_buffer_credits;
     366             : 
     367             :         /* Reference count on this handle */
     368             :         int                     h_ref;
     369             : 
     370             :         /* Field for caller's use to track errors through large fs */
     371             :         /* operations */
     372             :         int                     h_err;
     373             : 
     374             :         /* Flags [no locking] */
     375             :         unsigned int    h_sync:         1;      /* sync-on-close */
     376             :         unsigned int    h_jdata:        1;      /* force data journaling */
     377             :         unsigned int    h_aborted:      1;      /* fatal error on handle */
     378             : 
     379           1 : #ifdef CONFIG_DEBUG_LOCK_ALLOC
     380             :         struct lockdep_map      h_lockdep_map;
     381             : #endif
     382             : };
     383             : 
     384             : 
     385             : /* The transaction_t type is the guts of the journaling mechanism.  It
     386             :  * tracks a compound transaction through its various states:
     387             :  *
     388           1 :  * RUNNING:     accepting new updates
     389             :  * LOCKED:      Updates still running but we don't accept new ones
     390             :  * RUNDOWN:     Updates are tidying up but have finished requesting
     391             :  *              new buffers to modify (state not used for now)
     392             :  * FLUSH:       All updates complete, but we are still writing to disk
     393             :  * COMMIT:      All data on disk, writing commit record
     394             :  * FINISHED:    We still have to keep the transaction for checkpointing.
     395             :  *
     396             :  * The transaction keeps track of all of the buffers modified by a
     397             :  * running transaction, and all of the buffers committed but not yet
     398             :  * flushed to home for finished transactions.
     399             :  */
     400             : 
     401             : /*
     402             :  * Lock ranking:
     403             :  *
     404             :  *    j_list_lock
     405             :  *      ->jbd_lock_bh_journal_head() (This is "innermost")
     406             :  *
     407             :  *    j_state_lock
     408             :  *    ->jbd_lock_bh_state()
     409             :  *
     410             :  *    jbd_lock_bh_state()
     411             :  *    ->j_list_lock
     412             :  *
     413             :  *    j_state_lock
     414             :  *    ->t_handle_lock
     415             :  *
     416             :  *    j_state_lock
     417             :  *    ->j_list_lock                  (journal_unmap_buffer)
     418             :  *
     419             :  */
     420             : 
     421             : struct transaction_s
     422             : {
     423             :         /* Pointer to the journal for this transaction. [no locking] */
     424             :         journal_t               *t_journal;
     425             : 
     426             :         /* Sequence number for this transaction [no locking] */
     427             :         tid_t                   t_tid;
     428             : 
     429             :         /*
     430             :          * Transaction's current state
     431             :          * [no locking - only kjournald alters this]
     432             :          * [j_list_lock] guards transition of a transaction into T_FINISHED
     433             :          * state and subsequent call of __journal_drop_transaction()
     434             :          * FIXME: needs barriers
     435             :          * KLUDGE: [use j_state_lock]
     436             :          */
     437             :         enum {
     438             :                 T_RUNNING,
     439             :                 T_LOCKED,
     440             :                 T_RUNDOWN,
     441             :                 T_FLUSH,
     442             :                 T_COMMIT,
     443             :                 T_FINISHED
     444             :         }                       t_state;
     445             : 
     446             :         /*
     447             :          * Where in the log does this transaction's commit start? [no locking]
     448             :          */
     449             :         unsigned int            t_log_start;
     450             : 
     451             :         /* Number of buffers on the t_buffers list [j_list_lock] */
     452             :         int                     t_nr_buffers;
     453             : 
     454             :         /*
     455             :          * Doubly-linked circular list of all buffers reserved but not yet
     456             :          * modified by this transaction [j_list_lock]
     457             :          */
     458             :         struct journal_head     *t_reserved_list;
     459             : 
     460             :         /*
     461             :          * Doubly-linked circular list of all buffers under writeout during
     462             :          * commit [j_list_lock]
     463             :          */
     464             :         struct journal_head     *t_locked_list;
     465             : 
     466             :         /*
     467             :          * Doubly-linked circular list of all metadata buffers owned by this
     468             :          * transaction [j_list_lock]
     469             :          */
     470             :         struct journal_head     *t_buffers;
     471             : 
     472             :         /*
     473             :          * Doubly-linked circular list of all data buffers still to be
     474             :          * flushed before this transaction can be committed [j_list_lock]
     475             :          */
     476             :         struct journal_head     *t_sync_datalist;
     477             : 
     478             :         /*
     479             :          * Doubly-linked circular list of all forget buffers (superseded
     480             :          * buffers which we can un-checkpoint once this transaction commits)
     481             :          * [j_list_lock]
     482             :          */
     483             :         struct journal_head     *t_forget;
     484             : 
     485             :         /*
     486             :          * Doubly-linked circular list of all buffers still to be flushed before
     487             :          * this transaction can be checkpointed. [j_list_lock]
     488             :          */
     489             :         struct journal_head     *t_checkpoint_list;
     490             : 
     491             :         /*
     492             :          * Doubly-linked circular list of all buffers submitted for IO while
     493             :          * checkpointing. [j_list_lock]
     494             :          */
     495             :         struct journal_head     *t_checkpoint_io_list;
     496             : 
     497             :         /*
     498             :          * Doubly-linked circular list of temporary buffers currently undergoing
     499             :          * IO in the log [j_list_lock]
     500             :          */
     501             :         struct journal_head     *t_iobuf_list;
     502             : 
     503             :         /*
     504             :          * Doubly-linked circular list of metadata buffers being shadowed by log
     505             :          * IO.  The IO buffers on the iobuf list and the shadow buffers on this
     506             :          * list match each other one for one at all times. [j_list_lock]
     507             :          */
     508             :         struct journal_head     *t_shadow_list;
     509             : 
     510             :         /*
     511             :          * Doubly-linked circular list of control buffers being written to the
     512             :          * log. [j_list_lock]
     513             :          */
     514             :         struct journal_head     *t_log_list;
     515             : 
     516             :         /*
     517             :          * Protects info related to handles
     518             :          */
     519             :         spinlock_t              t_handle_lock;
     520             : 
     521             :         /*
     522             :          * Number of outstanding updates running on this transaction
     523             :          * [t_handle_lock]
     524             :          */
     525             :         int                     t_updates;
     526             : 
     527             :         /*
     528             :          * Number of buffers reserved for use by all handles in this transaction
     529             :          * handle but not yet modified. [t_handle_lock]
     530             :          */
     531             :         int                     t_outstanding_credits;
     532             : 
     533             :         /*
     534             :          * Forward and backward links for the circular list of all transactions
     535             :          * awaiting checkpoint. [j_list_lock]
     536             :          */
     537             :         transaction_t           *t_cpnext, *t_cpprev;
     538             : 
     539             :         /*
     540             :          * When will the transaction expire (become due for commit), in jiffies?
     541             :          * [no locking]
     542             :          */
     543             :         unsigned long           t_expires;
     544             : 
     545             :         /*
     546             :          * When this transaction started, in nanoseconds [no locking]
     547             :          */
     548             :         ktime_t                 t_start_time;
     549             : 
     550             :         /*
     551             :          * How many handles used this transaction? [t_handle_lock]
     552             :          */
     553             :         int t_handle_count;
     554             : 
     555             :         /*
     556             :          * This transaction is being forced and some process is
     557             :          * waiting for it to finish.
     558             :          */
     559             :         unsigned int t_synchronous_commit:1;
     560             : };
     561           1 : 
     562             : /**
     563             :  * struct journal_s - this is the concrete type associated with journal_t.
     564             :  * @j_flags:  General journaling state flags
     565             :  * @j_errno:  Is there an outstanding uncleared error on the journal (from a
     566             :  *     prior abort)?
     567             :  * @j_sb_buffer: First part of superblock buffer
     568             :  * @j_superblock: Second part of superblock buffer
     569             :  * @j_format_version: Version of the superblock format
     570             :  * @j_state_lock: Protect the various scalars in the journal
     571             :  * @j_barrier_count:  Number of processes waiting to create a barrier lock
     572             :  * @j_barrier: The barrier lock itself
     573             :  * @j_running_transaction: The current running transaction..
     574             :  * @j_committing_transaction: the transaction we are pushing to disk
     575             :  * @j_checkpoint_transactions: a linked circular list of all transactions
     576             :  *  waiting for checkpointing
     577             :  * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
     578             :  *  to start committing, or for a barrier lock to be released
     579             :  * @j_wait_logspace: Wait queue for waiting for checkpointing to complete
     580             :  * @j_wait_done_commit: Wait queue for waiting for commit to complete
     581             :  * @j_wait_checkpoint:  Wait queue to trigger checkpointing
     582             :  * @j_wait_commit: Wait queue to trigger commit
     583             :  * @j_wait_updates: Wait queue to wait for updates to complete
     584             :  * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
     585             :  * @j_head: Journal head - identifies the first unused block in the journal
     586             :  * @j_tail: Journal tail - identifies the oldest still-used block in the
     587             :  *  journal.
     588             :  * @j_free: Journal free - how many free blocks are there in the journal?
     589             :  * @j_first: The block number of the first usable block
     590             :  * @j_last: The block number one beyond the last usable block
     591             :  * @j_dev: Device where we store the journal
     592             :  * @j_blocksize: blocksize for the location where we store the journal.
     593             :  * @j_blk_offset: starting block offset for into the device where we store the
     594             :  *     journal
     595             :  * @j_fs_dev: Device which holds the client fs.  For internal journal this will
     596             :  *     be equal to j_dev
     597             :  * @j_maxlen: Total maximum capacity of the journal region on disk.
     598             :  * @j_list_lock: Protects the buffer lists and internal buffer state.
     599             :  * @j_inode: Optional inode where we store the journal.  If present, all journal
     600             :  *     block numbers are mapped into this inode via bmap().
     601             :  * @j_tail_sequence:  Sequence number of the oldest transaction in the log
     602             :  * @j_transaction_sequence: Sequence number of the next transaction to grant
     603             :  * @j_commit_sequence: Sequence number of the most recently committed
     604             :  *  transaction
     605             :  * @j_commit_request: Sequence number of the most recent transaction wanting
     606             :  *     commit
     607             :  * @j_uuid: Uuid of client object.
     608             :  * @j_task: Pointer to the current commit thread for this journal
     609             :  * @j_max_transaction_buffers:  Maximum number of metadata buffers to allow in a
     610             :  *     single compound commit transaction
     611             :  * @j_commit_interval: What is the maximum transaction lifetime before we begin
     612             :  *  a commit?
     613             :  * @j_commit_timer:  The timer used to wakeup the commit thread
     614             :  * @j_revoke_lock: Protect the revoke table
     615             :  * @j_revoke: The revoke table - maintains the list of revoked blocks in the
     616             :  *     current transaction.
     617             :  * @j_revoke_table: alternate revoke tables for j_revoke
     618             :  * @j_wbuf: array of buffer_heads for journal_commit_transaction
     619             :  * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the
     620             :  *      number that will fit in j_blocksize
     621             :  * @j_last_sync_writer: most recent pid which did a synchronous write
     622             :  * @j_average_commit_time: the average amount of time in nanoseconds it
     623             :  *      takes to commit a transaction to the disk.
     624             :  * @j_private: An opaque pointer to fs-private information.
     625             :  */
     626             : 
     627             : struct journal_s
     628             : {
     629             :         /* General journaling state flags [j_state_lock] */
     630             :         unsigned long           j_flags;
     631             : 
     632             :         /*
     633             :          * Is there an outstanding uncleared error on the journal (from a prior
     634             :          * abort)? [j_state_lock]
     635             :          */
     636             :         int                     j_errno;
     637             : 
     638             :         /* The superblock buffer */
     639             :         struct buffer_head      *j_sb_buffer;
     640             :         journal_superblock_t    *j_superblock;
     641             : 
     642             :         /* Version of the superblock format */
     643             :         int                     j_format_version;
     644             : 
     645             :         /*
     646             :          * Protect the various scalars in the journal
     647             :          */
     648             :         spinlock_t              j_state_lock;
     649             : 
     650             :         /*
     651             :          * Number of processes waiting to create a barrier lock [j_state_lock]
     652             :          */
     653             :         int                     j_barrier_count;
     654             : 
     655             :         /* The barrier lock itself */
     656             :         struct mutex            j_barrier;
     657             : 
     658             :         /*
     659             :          * Transactions: The current running transaction...
     660             :          * [j_state_lock] [caller holding open handle]
     661             :          */
     662             :         transaction_t           *j_running_transaction;
     663             : 
     664             :         /*
     665             :          * the transaction we are pushing to disk
     666             :          * [j_state_lock] [caller holding open handle]
     667             :          */
     668             :         transaction_t           *j_committing_transaction;
     669             : 
     670             :         /*
     671             :          * ... and a linked circular list of all transactions waiting for
     672             :          * checkpointing. [j_list_lock]
     673             :          */
     674             :         transaction_t           *j_checkpoint_transactions;
     675             : 
     676             :         /*
     677             :          * Wait queue for waiting for a locked transaction to start committing,
     678             :          * or for a barrier lock to be released
     679             :          */
     680             :         wait_queue_head_t       j_wait_transaction_locked;
     681             : 
     682             :         /* Wait queue for waiting for checkpointing to complete */
     683             :         wait_queue_head_t       j_wait_logspace;
     684             : 
     685             :         /* Wait queue for waiting for commit to complete */
     686             :         wait_queue_head_t       j_wait_done_commit;
     687             : 
     688             :         /* Wait queue to trigger checkpointing */
     689             :         wait_queue_head_t       j_wait_checkpoint;
     690             : 
     691             :         /* Wait queue to trigger commit */
     692             :         wait_queue_head_t       j_wait_commit;
     693             : 
     694             :         /* Wait queue to wait for updates to complete */
     695             :         wait_queue_head_t       j_wait_updates;
     696             : 
     697             :         /* Semaphore for locking against concurrent checkpoints */
     698             :         struct mutex            j_checkpoint_mutex;
     699             : 
     700             :         /*
     701             :          * Journal head: identifies the first unused block in the journal.
     702             :          * [j_state_lock]
     703             :          */
     704             :         unsigned int            j_head;
     705             : 
     706             :         /*
     707             :          * Journal tail: identifies the oldest still-used block in the journal.
     708             :          * [j_state_lock]
     709             :          */
     710             :         unsigned int            j_tail;
     711             : 
     712             :         /*
     713             :          * Journal free: how many free blocks are there in the journal?
     714             :          * [j_state_lock]
     715             :          */
     716             :         unsigned int            j_free;
     717             : 
     718             :         /*
     719             :          * Journal start and end: the block numbers of the first usable block
     720             :          * and one beyond the last usable block in the journal. [j_state_lock]
     721             :          */
     722             :         unsigned int            j_first;
     723             :         unsigned int            j_last;
     724             : 
     725             :         /*
     726             :          * Device, blocksize and starting block offset for the location where we
     727             :          * store the journal.
     728             :          */
     729             :         struct block_device     *j_dev;
     730             :         int                     j_blocksize;
     731             :         unsigned int            j_blk_offset;
     732             : 
     733             :         /*
     734             :          * Device which holds the client fs.  For internal journal this will be
     735             :          * equal to j_dev.
     736             :          */
     737             :         struct block_device     *j_fs_dev;
     738             : 
     739             :         /* Total maximum capacity of the journal region on disk. */
     740             :         unsigned int            j_maxlen;
     741             : 
     742             :         /*
     743             :          * Protects the buffer lists and internal buffer state.
     744             :          */
     745             :         spinlock_t              j_list_lock;
     746             : 
     747             :         /* Optional inode where we store the journal.  If present, all */
     748             :         /* journal block numbers are mapped into this inode via */
     749             :         /* bmap(). */
     750             :         struct inode            *j_inode;
     751             : 
     752             :         /*
     753             :          * Sequence number of the oldest transaction in the log [j_state_lock]
     754             :          */
     755             :         tid_t                   j_tail_sequence;
     756             : 
     757             :         /*
     758             :          * Sequence number of the next transaction to grant [j_state_lock]
     759             :          */
     760             :         tid_t                   j_transaction_sequence;
     761             : 
     762             :         /*
     763             :          * Sequence number of the most recently committed transaction
     764             :          * [j_state_lock].
     765             :          */
     766             :         tid_t                   j_commit_sequence;
     767             : 
     768             :         /*
     769             :          * Sequence number of the most recent transaction wanting commit
     770             :          * [j_state_lock]
     771             :          */
     772             :         tid_t                   j_commit_request;
     773             : 
     774             :         /*
     775             :          * Journal uuid: identifies the object (filesystem, LVM volume etc)
     776             :          * backed by this journal.  This will eventually be replaced by an array
     777             :          * of uuids, allowing us to index multiple devices within a single
     778             :          * journal and to perform atomic updates across them.
     779             :          */
     780             :         __u8                    j_uuid[16];
     781             : 
     782             :         /* Pointer to the current commit thread for this journal */
     783             :         struct task_struct      *j_task;
     784             : 
     785             :         /*
     786             :          * Maximum number of metadata buffers to allow in a single compound
     787             :          * commit transaction
     788             :          */
     789             :         int                     j_max_transaction_buffers;
     790             : 
     791             :         /*
     792             :          * What is the maximum transaction lifetime before we begin a commit?
     793             :          */
     794             :         unsigned long           j_commit_interval;
     795             : 
     796             :         /* The timer used to wakeup the commit thread: */
     797             :         struct timer_list       j_commit_timer;
     798             : 
     799             :         /*
     800             :          * The revoke table: maintains the list of revoked blocks in the
     801             :          * current transaction.  [j_revoke_lock]
     802             :          */
     803             :         spinlock_t              j_revoke_lock;
     804             :         struct jbd_revoke_table_s *j_revoke;
     805             :         struct jbd_revoke_table_s *j_revoke_table[2];
     806             : 
     807             :         /*
     808             :          * array of bhs for journal_commit_transaction
     809             :          */
     810             :         struct buffer_head      **j_wbuf;
     811             :         int                     j_wbufsize;
     812             : 
     813             :         /*
     814             :          * this is the pid of the last person to run a synchronous operation
     815             :          * through the journal.
     816             :          */
     817             :         pid_t                   j_last_sync_writer;
     818             : 
     819             :         /*
     820             :          * the average amount of time in nanoseconds it takes to commit a
     821             :          * transaction to the disk.  [j_state_lock]
     822             :          */
     823             :         u64                     j_average_commit_time;
     824             : 
     825             :         /*
     826             :          * An opaque pointer to fs-private information.  ext3 puts its
     827             :          * superblock pointer here
     828             :          */
     829             :         void *j_private;
     830             : };
     831             : 
     832             : /*
     833             :  * Journal flag definitions
     834             :  */
     835             : #define JFS_UNMOUNT     0x001   /* Journal thread is being destroyed */
     836             : #define JFS_ABORT       0x002   /* Journaling has been aborted for errors. */
     837             : #define JFS_ACK_ERR     0x004   /* The errno in the sb has been acked */
     838             : #define JFS_FLUSHED     0x008   /* The journal superblock has been flushed */
     839             : #define JFS_LOADED      0x010   /* The journal superblock has been loaded */
     840             : #define JFS_BARRIER     0x020   /* Use IDE barriers */
     841             : #define JFS_ABORT_ON_SYNCDATA_ERR       0x040  /* Abort the journal on file
     842             :                                                 * data write error in ordered
     843             :                                                 * mode */
     844             : 
     845             : /*
     846             :  * Function declarations for the journaling transaction and buffer
     847             :  * management
     848             :  */
     849             : 
     850             : /* Filing buffers */
     851             : extern void journal_unfile_buffer(journal_t *, struct journal_head *);
     852             : extern void __journal_unfile_buffer(struct journal_head *);
     853             : extern void __journal_refile_buffer(struct journal_head *);
     854             : extern void journal_refile_buffer(journal_t *, struct journal_head *);
     855             : extern void __journal_file_buffer(struct journal_head *, transaction_t *, int);
     856             : extern void __journal_free_buffer(struct journal_head *bh);
     857             : extern void journal_file_buffer(struct journal_head *, transaction_t *, int);
     858             : extern void __journal_clean_data_list(transaction_t *transaction);
     859             : 
     860             : /* Log buffer allocation */
     861             : extern struct journal_head * journal_get_descriptor_buffer(journal_t *);
     862             : int journal_next_log_block(journal_t *, unsigned int *);
     863             : 
     864             : /* Commit management */
     865             : extern void journal_commit_transaction(journal_t *);
     866             : 
     867             : /* Checkpoint list management */
     868             : int __journal_clean_checkpoint_list(journal_t *journal);
     869             : int __journal_remove_checkpoint(struct journal_head *);
     870             : void __journal_insert_checkpoint(struct journal_head *, transaction_t *);
     871             : 
     872             : /* Buffer IO */
     873             : extern int
     874             : journal_write_metadata_buffer(transaction_t       *transaction,
     875             :                               struct journal_head  *jh_in,
     876             :                               struct journal_head **jh_out,
     877             :                               unsigned int blocknr);
     878             : 
     879             : /* Transaction locking */
     880             : extern void             __wait_on_journal (journal_t *);
     881             : 
     882             : /*
     883             :  * Journal locking.
     884             :  *
     885             :  * We need to lock the journal during transaction state changes so that nobody
     886             :  * ever tries to take a handle on the running transaction while we are in the
     887             :  * middle of moving it to the commit phase.  j_state_lock does this.
     888             :  *
     889             :  * Note that the locking is completely interrupt unsafe.  We never touch
     890             :  * journal structures from interrupts.
     891             :  */
     892             : 
     893             : static inline handle_t *journal_current_handle(void)
     894             : {
     895           0 :         return current->journal_info;
     896             : }
     897             : 
     898             : /* The journaling code user interface:
     899             :  *
     900             :  * Create and destroy handles
     901             :  * Register buffer modifications against the current transaction.
     902             :  */
     903             : 
     904             : extern handle_t *journal_start(journal_t *, int nblocks);
     905             : extern int       journal_restart (handle_t *, int nblocks);
     906             : extern int       journal_extend (handle_t *, int nblocks);
     907             : extern int       journal_get_write_access(handle_t *, struct buffer_head *);
     908             : extern int       journal_get_create_access (handle_t *, struct buffer_head *);
     909             : extern int       journal_get_undo_access(handle_t *, struct buffer_head *);
     910             : extern int       journal_dirty_data (handle_t *, struct buffer_head *);
     911             : extern int       journal_dirty_metadata (handle_t *, struct buffer_head *);
     912             : extern void      journal_release_buffer (handle_t *, struct buffer_head *);
     913             : extern int       journal_forget (handle_t *, struct buffer_head *);
     914             : extern void      journal_sync_buffer (struct buffer_head *);
     915             : extern void      journal_invalidatepage(journal_t *,
     916             :                                 struct page *, unsigned long);
     917             : extern int       journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
     918             : extern int       journal_stop(handle_t *);
     919             : extern int       journal_flush (journal_t *);
     920             : extern void      journal_lock_updates (journal_t *);
     921             : extern void      journal_unlock_updates (journal_t *);
     922             : 
     923             : extern journal_t * journal_init_dev(struct block_device *bdev,
     924             :                                 struct block_device *fs_dev,
     925             :                                 int start, int len, int bsize);
     926             : extern journal_t * journal_init_inode (struct inode *);
     927             : extern int         journal_update_format (journal_t *);
     928             : extern int         journal_check_used_features
     929             :                    (journal_t *, unsigned long, unsigned long, unsigned long);
     930             : extern int         journal_check_available_features
     931             :                    (journal_t *, unsigned long, unsigned long, unsigned long);
     932             : extern int         journal_set_features
     933             :                    (journal_t *, unsigned long, unsigned long, unsigned long);
     934             : extern int         journal_create     (journal_t *);
     935             : extern int         journal_load       (journal_t *journal);
     936             : extern int         journal_destroy    (journal_t *);
     937             : extern int         journal_recover    (journal_t *journal);
     938             : extern int         journal_wipe       (journal_t *, int);
     939             : extern int         journal_skip_recovery        (journal_t *);
     940             : extern void        journal_update_superblock    (journal_t *, int);
     941             : extern void        journal_abort      (journal_t *, int);
     942             : extern int         journal_errno      (journal_t *);
     943             : extern void        journal_ack_err    (journal_t *);
     944             : extern int         journal_clear_err  (journal_t *);
     945             : extern int         journal_bmap(journal_t *, unsigned int, unsigned int *);
     946             : extern int         journal_force_commit(journal_t *);
     947             : 
     948             : /*
     949             :  * journal_head management
     950             :  */
     951             : struct journal_head *journal_add_journal_head(struct buffer_head *bh);
     952             : struct journal_head *journal_grab_journal_head(struct buffer_head *bh);
     953             : void journal_remove_journal_head(struct buffer_head *bh);
     954             : void journal_put_journal_head(struct journal_head *jh);
     955             : 
     956             : /*
     957             :  * handle management
     958             :  */
     959           1 : extern struct kmem_cache *jbd_handle_cache;
     960             : 
     961             : static inline handle_t *jbd_alloc_handle(gfp_t gfp_flags)
     962             : {
     963           0 :         return kmem_cache_alloc(jbd_handle_cache, gfp_flags);
     964             : }
     965             : 
     966             : static inline void jbd_free_handle(handle_t *handle)
     967             : {
     968           0 :         kmem_cache_free(jbd_handle_cache, handle);
     969           0 : }
     970             : 
     971             : /* Primary revoke support */
     972             : #define JOURNAL_REVOKE_DEFAULT_HASH 256
     973             : extern int         journal_init_revoke(journal_t *, int);
     974             : extern void        journal_destroy_revoke_caches(void);
     975             : extern int         journal_init_revoke_caches(void);
     976             : 
     977             : extern void        journal_destroy_revoke(journal_t *);
     978             : extern int         journal_revoke (handle_t *,
     979             :                                 unsigned int, struct buffer_head *);
     980             : extern int         journal_cancel_revoke(handle_t *, struct journal_head *);
     981             : extern void        journal_write_revoke_records(journal_t *,
     982             :                                                 transaction_t *, int);
     983             : 
     984             : /* Recovery revoke support */
     985             : extern int      journal_set_revoke(journal_t *, unsigned int, tid_t);
     986             : extern int      journal_test_revoke(journal_t *, unsigned int, tid_t);
     987             : extern void     journal_clear_revoke(journal_t *);
     988             : extern void     journal_switch_revoke_table(journal_t *journal);
     989             : 
     990             : /*
     991             :  * The log thread user interface:
     992             :  *
     993             :  * Request space in the current transaction, and force transaction commit
     994             :  * transitions on demand.
     995             :  */
     996             : 
     997             : int __log_space_left(journal_t *); /* Called with journal locked */
     998             : int log_start_commit(journal_t *journal, tid_t tid);
     999             : int __log_start_commit(journal_t *journal, tid_t tid);
    1000             : int journal_start_commit(journal_t *journal, tid_t *tid);
    1001             : int journal_force_commit_nested(journal_t *journal);
    1002             : int log_wait_commit(journal_t *journal, tid_t tid);
    1003             : int log_do_checkpoint(journal_t *journal);
    1004             : 
    1005             : void __log_wait_for_space(journal_t *journal);
    1006             : extern void     __journal_drop_transaction(journal_t *, transaction_t *);
    1007             : extern int      cleanup_journal_tail(journal_t *);
    1008             : 
    1009             : /* Debugging code only: */
    1010             : 
    1011             : #define jbd_ENOSYS() \
    1012             : do {                                                                       \
    1013             :         printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \
    1014             :         current->state = TASK_UNINTERRUPTIBLE;                                  \
    1015             :         schedule();                                                        \
    1016             : } while (1)
    1017             : 
    1018             : /*
    1019             :  * is_journal_abort
    1020             :  *
    1021             :  * Simple test wrapper function to test the JFS_ABORT state flag.  This
    1022             :  * bit, when set, indicates that we have had a fatal error somewhere,
    1023             :  * either inside the journaling layer or indicated to us by the client
    1024             :  * (eg. ext3), and that we and should not commit any further
    1025             :  * transactions.
    1026             :  */
    1027             : 
    1028             : static inline int is_journal_aborted(journal_t *journal)
    1029             : {
    1030           0 :         return journal->j_flags & JFS_ABORT;
    1031             : }
    1032             : 
    1033             : static inline int is_handle_aborted(handle_t *handle)
    1034             : {
    1035           0 :         if (handle->h_aborted)
    1036           0 :                 return 1;
    1037           0 :         return is_journal_aborted(handle->h_transaction->t_journal);
    1038             : }
    1039             : 
    1040             : static inline void journal_abort_handle(handle_t *handle)
    1041             : {
    1042             :         handle->h_aborted = 1;
    1043             : }
    1044             : 
    1045             : #endif /* __KERNEL__   */
    1046             : 
    1047             : /* Comparison functions for transaction IDs: perform comparisons using
    1048             :  * modulo arithmetic so that they work over sequence number wraps. */
    1049             : 
    1050             : static inline int tid_gt(tid_t x, tid_t y)
    1051             : {
    1052           0 :         int difference = (x - y);
    1053           0 :         return (difference > 0);
    1054             : }
    1055             : 
    1056             : static inline int tid_geq(tid_t x, tid_t y)
    1057             : {
    1058           0 :         int difference = (x - y);
    1059           0 :         return (difference >= 0);
    1060             : }
    1061             : 
    1062             : extern int journal_blocks_per_page(struct inode *inode);
    1063             : 
    1064             : /*
    1065             :  * Return the minimum number of blocks which must be free in the journal
    1066             :  * before a new transaction may be started.  Must be called under j_state_lock.
    1067             :  */
    1068             : static inline int jbd_space_needed(journal_t *journal)
    1069             : {
    1070           0 :         int nblocks = journal->j_max_transaction_buffers;
    1071           0 :         if (journal->j_committing_transaction)
    1072           0 :                 nblocks += journal->j_committing_transaction->
    1073             :                                         t_outstanding_credits;
    1074           0 :         return nblocks;
    1075             : }
    1076             : 
    1077             : /*
    1078             :  * Definitions which augment the buffer_head layer
    1079             :  */
    1080             : 
    1081             : /* journaling buffer types */
    1082             : #define BJ_None         0       /* Not journaled */
    1083             : #define BJ_SyncData     1       /* Normal data: flush before commit */
    1084             : #define BJ_Metadata     2       /* Normal journaled metadata */
    1085             : #define BJ_Forget       3       /* Buffer superseded by this transaction */
    1086             : #define BJ_IO           4       /* Buffer is for temporary IO use */
    1087             : #define BJ_Shadow       5       /* Buffer contents being shadowed to the log */
    1088             : #define BJ_LogCtl       6       /* Buffer contains log descriptors */
    1089             : #define BJ_Reserved     7       /* Buffer is reserved for access by journal */
    1090             : #define BJ_Locked       8       /* Locked for I/O during commit */
    1091             : #define BJ_Types        9
    1092             : 
    1093             : extern int jbd_blocks_per_page(struct inode *inode);
    1094           1 : 
    1095             : #ifdef __KERNEL__
    1096             : 
    1097             : #define buffer_trace_init(bh)   do {} while (0)
    1098             : #define print_buffer_fields(bh) do {} while (0)
    1099             : #define print_buffer_trace(bh)  do {} while (0)
    1100             : #define BUFFER_TRACE(bh, info)  do {} while (0)
    1101             : #define BUFFER_TRACE2(bh, bh2, info)    do {} while (0)
    1102             : #define JBUFFER_TRACE(jh, info) do {} while (0)
    1103             : 
    1104             : #endif  /* __KERNEL__ */
    1105             : 
    1106             : #endif  /* _LINUX_JBD_H */

Generated by: LCOV version 1.10