LCOV - code coverage report
Current view: top level - fs/ext4 - ext4_jbd2.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 40 59 67.8 %
Date: 2022-03-28 16:04:14 Functions: 4 4 100.0 %
Branches: 49 186 26.3 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0+
       2                 :            : /*
       3                 :            :  * ext4_jbd2.h
       4                 :            :  *
       5                 :            :  * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
       6                 :            :  *
       7                 :            :  * Copyright 1998--1999 Red Hat corp --- All Rights Reserved
       8                 :            :  *
       9                 :            :  * Ext4-specific journaling extensions.
      10                 :            :  */
      11                 :            : 
      12                 :            : #ifndef _EXT4_JBD2_H
      13                 :            : #define _EXT4_JBD2_H
      14                 :            : 
      15                 :            : #include <linux/fs.h>
      16                 :            : #include <linux/jbd2.h>
      17                 :            : #include "ext4.h"
      18                 :            : 
      19                 :            : #define EXT4_JOURNAL(inode)     (EXT4_SB((inode)->i_sb)->s_journal)
      20                 :            : 
      21                 :            : /* Define the number of blocks we need to account to a transaction to
      22                 :            :  * modify one block of data.
      23                 :            :  *
      24                 :            :  * We may have to touch one inode, one bitmap buffer, up to three
      25                 :            :  * indirection blocks, the group and superblock summaries, and the data
      26                 :            :  * block to complete the transaction.
      27                 :            :  *
      28                 :            :  * For extents-enabled fs we may have to allocate and modify up to
      29                 :            :  * 5 levels of tree, data block (for each of these we need bitmap + group
      30                 :            :  * summaries), root which is stored in the inode, sb
      31                 :            :  */
      32                 :            : 
      33                 :            : #define EXT4_SINGLEDATA_TRANS_BLOCKS(sb)                                \
      34                 :            :         (ext4_has_feature_extents(sb) ? 20U : 8U)
      35                 :            : 
      36                 :            : /* Extended attribute operations touch at most two data buffers,
      37                 :            :  * two bitmap buffers, and two group summaries, in addition to the inode
      38                 :            :  * and the superblock, which are already accounted for. */
      39                 :            : 
      40                 :            : #define EXT4_XATTR_TRANS_BLOCKS         6U
      41                 :            : 
      42                 :            : /* Define the minimum size for a transaction which modifies data.  This
      43                 :            :  * needs to take into account the fact that we may end up modifying two
      44                 :            :  * quota files too (one for the group, one for the user quota).  The
      45                 :            :  * superblock only gets updated once, of course, so don't bother
      46                 :            :  * counting that again for the quota updates. */
      47                 :            : 
      48                 :            : #define EXT4_DATA_TRANS_BLOCKS(sb)      (EXT4_SINGLEDATA_TRANS_BLOCKS(sb) + \
      49                 :            :                                          EXT4_XATTR_TRANS_BLOCKS - 2 + \
      50                 :            :                                          EXT4_MAXQUOTAS_TRANS_BLOCKS(sb))
      51                 :            : 
      52                 :            : /*
      53                 :            :  * Define the number of metadata blocks we need to account to modify data.
      54                 :            :  *
      55                 :            :  * This include super block, inode block, quota blocks and xattr blocks
      56                 :            :  */
      57                 :            : #define EXT4_META_TRANS_BLOCKS(sb)      (EXT4_XATTR_TRANS_BLOCKS + \
      58                 :            :                                         EXT4_MAXQUOTAS_TRANS_BLOCKS(sb))
      59                 :            : 
      60                 :            : /* Define an arbitrary limit for the amount of data we will anticipate
      61                 :            :  * writing to any given transaction.  For unbounded transactions such as
      62                 :            :  * write(2) and truncate(2) we can write more than this, but we always
      63                 :            :  * start off at the maximum transaction size and grow the transaction
      64                 :            :  * optimistically as we go. */
      65                 :            : 
      66                 :            : #define EXT4_MAX_TRANS_DATA             64U
      67                 :            : 
      68                 :            : /* We break up a large truncate or write transaction once the handle's
      69                 :            :  * buffer credits gets this low, we need either to extend the
      70                 :            :  * transaction or to start a new one.  Reserve enough space here for
      71                 :            :  * inode, bitmap, superblock, group and indirection updates for at least
      72                 :            :  * one block, plus two quota updates.  Quota allocations are not
      73                 :            :  * needed. */
      74                 :            : 
      75                 :            : #define EXT4_RESERVE_TRANS_BLOCKS       12U
      76                 :            : 
      77                 :            : /*
      78                 :            :  * Number of credits needed if we need to insert an entry into a
      79                 :            :  * directory.  For each new index block, we need 4 blocks (old index
      80                 :            :  * block, new index block, bitmap block, bg summary).  For normal
      81                 :            :  * htree directories there are 2 levels; if the largedir feature
      82                 :            :  * enabled it's 3 levels.
      83                 :            :  */
      84                 :            : #define EXT4_INDEX_EXTRA_TRANS_BLOCKS   12U
      85                 :            : 
      86                 :            : #ifdef CONFIG_QUOTA
      87                 :            : /* Amount of blocks needed for quota update - we know that the structure was
      88                 :            :  * allocated so we need to update only data block */
      89                 :            : #define EXT4_QUOTA_TRANS_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
      90                 :            :                 ext4_has_feature_quota(sb)) ? 1 : 0)
      91                 :            : /* Amount of blocks needed for quota insert/delete - we do some block writes
      92                 :            :  * but inode, sb and group updates are done only once */
      93                 :            : #define EXT4_QUOTA_INIT_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
      94                 :            :                 ext4_has_feature_quota(sb)) ?\
      95                 :            :                 (DQUOT_INIT_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\
      96                 :            :                  +3+DQUOT_INIT_REWRITE) : 0)
      97                 :            : 
      98                 :            : #define EXT4_QUOTA_DEL_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
      99                 :            :                 ext4_has_feature_quota(sb)) ?\
     100                 :            :                 (DQUOT_DEL_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\
     101                 :            :                  +3+DQUOT_DEL_REWRITE) : 0)
     102                 :            : #else
     103                 :            : #define EXT4_QUOTA_TRANS_BLOCKS(sb) 0
     104                 :            : #define EXT4_QUOTA_INIT_BLOCKS(sb) 0
     105                 :            : #define EXT4_QUOTA_DEL_BLOCKS(sb) 0
     106                 :            : #endif
     107                 :            : #define EXT4_MAXQUOTAS_TRANS_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_TRANS_BLOCKS(sb))
     108                 :            : #define EXT4_MAXQUOTAS_INIT_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_INIT_BLOCKS(sb))
     109                 :            : #define EXT4_MAXQUOTAS_DEL_BLOCKS(sb) (EXT4_MAXQUOTAS*EXT4_QUOTA_DEL_BLOCKS(sb))
     110                 :            : 
     111                 :            : /*
     112                 :            :  * Ext4 handle operation types -- for logging purposes
     113                 :            :  */
     114                 :            : #define EXT4_HT_MISC             0
     115                 :            : #define EXT4_HT_INODE            1
     116                 :            : #define EXT4_HT_WRITE_PAGE       2
     117                 :            : #define EXT4_HT_MAP_BLOCKS       3
     118                 :            : #define EXT4_HT_DIR              4
     119                 :            : #define EXT4_HT_TRUNCATE         5
     120                 :            : #define EXT4_HT_QUOTA            6
     121                 :            : #define EXT4_HT_RESIZE           7
     122                 :            : #define EXT4_HT_MIGRATE          8
     123                 :            : #define EXT4_HT_MOVE_EXTENTS     9
     124                 :            : #define EXT4_HT_XATTR           10
     125                 :            : #define EXT4_HT_EXT_CONVERT     11
     126                 :            : #define EXT4_HT_MAX             12
     127                 :            : 
     128                 :            : /**
     129                 :            :  *   struct ext4_journal_cb_entry - Base structure for callback information.
     130                 :            :  *
     131                 :            :  *   This struct is a 'seed' structure for a using with your own callback
     132                 :            :  *   structs. If you are using callbacks you must allocate one of these
     133                 :            :  *   or another struct of your own definition which has this struct
     134                 :            :  *   as it's first element and pass it to ext4_journal_callback_add().
     135                 :            :  */
     136                 :            : struct ext4_journal_cb_entry {
     137                 :            :         /* list information for other callbacks attached to the same handle */
     138                 :            :         struct list_head jce_list;
     139                 :            : 
     140                 :            :         /*  Function to call with this callback structure */
     141                 :            :         void (*jce_func)(struct super_block *sb,
     142                 :            :                          struct ext4_journal_cb_entry *jce, int error);
     143                 :            : 
     144                 :            :         /* user data goes here */
     145                 :            : };
     146                 :            : 
     147                 :            : /**
     148                 :            :  * ext4_journal_callback_add: add a function to call after transaction commit
     149                 :            :  * @handle: active journal transaction handle to register callback on
     150                 :            :  * @func: callback function to call after the transaction has committed:
     151                 :            :  *        @sb: superblock of current filesystem for transaction
     152                 :            :  *        @jce: returned journal callback data
     153                 :            :  *        @rc: journal state at commit (0 = transaction committed properly)
     154                 :            :  * @jce: journal callback data (internal and function private data struct)
     155                 :            :  *
     156                 :            :  * The registered function will be called in the context of the journal thread
     157                 :            :  * after the transaction for which the handle was created has completed.
     158                 :            :  *
     159                 :            :  * No locks are held when the callback function is called, so it is safe to
     160                 :            :  * call blocking functions from within the callback, but the callback should
     161                 :            :  * not block or run for too long, or the filesystem will be blocked waiting for
     162                 :            :  * the next transaction to commit. No journaling functions can be used, or
     163                 :            :  * there is a risk of deadlock.
     164                 :            :  *
     165                 :            :  * There is no guaranteed calling order of multiple registered callbacks on
     166                 :            :  * the same transaction.
     167                 :            :  */
     168                 :            : static inline void _ext4_journal_callback_add(handle_t *handle,
     169                 :            :                         struct ext4_journal_cb_entry *jce)
     170                 :            : {
     171                 :            :         /* Add the jce to transaction's private list */
     172                 :            :         list_add_tail(&jce->jce_list, &handle->h_transaction->t_private_list);
     173                 :            : }
     174                 :            : 
     175                 :            : static inline void ext4_journal_callback_add(handle_t *handle,
     176                 :            :                         void (*func)(struct super_block *sb,
     177                 :            :                                      struct ext4_journal_cb_entry *jce,
     178                 :            :                                      int rc),
     179                 :            :                         struct ext4_journal_cb_entry *jce)
     180                 :            : {
     181                 :            :         struct ext4_sb_info *sbi =
     182                 :            :                         EXT4_SB(handle->h_transaction->t_journal->j_private);
     183                 :            : 
     184                 :            :         /* Add the jce to transaction's private list */
     185                 :            :         jce->jce_func = func;
     186                 :            :         spin_lock(&sbi->s_md_lock);
     187                 :            :         _ext4_journal_callback_add(handle, jce);
     188                 :            :         spin_unlock(&sbi->s_md_lock);
     189                 :            : }
     190                 :            : 
     191                 :            : 
     192                 :            : /**
     193                 :            :  * ext4_journal_callback_del: delete a registered callback
     194                 :            :  * @handle: active journal transaction handle on which callback was registered
     195                 :            :  * @jce: registered journal callback entry to unregister
     196                 :            :  * Return true if object was successfully removed
     197                 :            :  */
     198                 :            : static inline bool ext4_journal_callback_try_del(handle_t *handle,
     199                 :            :                                              struct ext4_journal_cb_entry *jce)
     200                 :            : {
     201                 :            :         bool deleted;
     202                 :            :         struct ext4_sb_info *sbi =
     203                 :            :                         EXT4_SB(handle->h_transaction->t_journal->j_private);
     204                 :            : 
     205                 :            :         spin_lock(&sbi->s_md_lock);
     206                 :            :         deleted = !list_empty(&jce->jce_list);
     207                 :            :         list_del_init(&jce->jce_list);
     208                 :            :         spin_unlock(&sbi->s_md_lock);
     209                 :            :         return deleted;
     210                 :            : }
     211                 :            : 
     212                 :            : int
     213                 :            : ext4_mark_iloc_dirty(handle_t *handle,
     214                 :            :                      struct inode *inode,
     215                 :            :                      struct ext4_iloc *iloc);
     216                 :            : 
     217                 :            : /*
     218                 :            :  * On success, We end up with an outstanding reference count against
     219                 :            :  * iloc->bh.  This _must_ be cleaned up later.
     220                 :            :  */
     221                 :            : 
     222                 :            : int ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
     223                 :            :                         struct ext4_iloc *iloc);
     224                 :            : 
     225                 :            : int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode);
     226                 :            : 
     227                 :            : int ext4_expand_extra_isize(struct inode *inode,
     228                 :            :                             unsigned int new_extra_isize,
     229                 :            :                             struct ext4_iloc *iloc);
     230                 :            : /*
     231                 :            :  * Wrapper functions with which ext4 calls into JBD.
     232                 :            :  */
     233                 :            : int __ext4_journal_get_write_access(const char *where, unsigned int line,
     234                 :            :                                     handle_t *handle, struct buffer_head *bh);
     235                 :            : 
     236                 :            : int __ext4_forget(const char *where, unsigned int line, handle_t *handle,
     237                 :            :                   int is_metadata, struct inode *inode,
     238                 :            :                   struct buffer_head *bh, ext4_fsblk_t blocknr);
     239                 :            : 
     240                 :            : int __ext4_journal_get_create_access(const char *where, unsigned int line,
     241                 :            :                                 handle_t *handle, struct buffer_head *bh);
     242                 :            : 
     243                 :            : int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
     244                 :            :                                  handle_t *handle, struct inode *inode,
     245                 :            :                                  struct buffer_head *bh);
     246                 :            : 
     247                 :            : int __ext4_handle_dirty_super(const char *where, unsigned int line,
     248                 :            :                               handle_t *handle, struct super_block *sb);
     249                 :            : 
     250                 :            : #define ext4_journal_get_write_access(handle, bh) \
     251                 :            :         __ext4_journal_get_write_access(__func__, __LINE__, (handle), (bh))
     252                 :            : #define ext4_forget(handle, is_metadata, inode, bh, block_nr) \
     253                 :            :         __ext4_forget(__func__, __LINE__, (handle), (is_metadata), (inode), \
     254                 :            :                       (bh), (block_nr))
     255                 :            : #define ext4_journal_get_create_access(handle, bh) \
     256                 :            :         __ext4_journal_get_create_access(__func__, __LINE__, (handle), (bh))
     257                 :            : #define ext4_handle_dirty_metadata(handle, inode, bh) \
     258                 :            :         __ext4_handle_dirty_metadata(__func__, __LINE__, (handle), (inode), \
     259                 :            :                                      (bh))
     260                 :            : #define ext4_handle_dirty_super(handle, sb) \
     261                 :            :         __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb))
     262                 :            : 
     263                 :            : handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
     264                 :            :                                   int type, int blocks, int rsv_blocks,
     265                 :            :                                   int revoke_creds);
     266                 :            : int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle);
     267                 :            : 
     268                 :            : #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096)
     269                 :            : 
     270                 :            : /* Note:  Do not use this for NULL handles.  This is only to determine if
     271                 :            :  * a properly allocated handle is using a journal or not. */
     272                 :     331406 : static inline int ext4_handle_valid(handle_t *handle)
     273                 :            : {
     274   [ +  -  +  +  :     262214 :         if ((unsigned long)handle < EXT4_NOJOURNAL_MAX_REF_COUNT)
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
     275   [ #  #  #  #  :          0 :                 return 0;
             #  #  #  # ]
     276                 :            :         return 1;
     277                 :            : }
     278                 :            : 
     279                 :          0 : static inline void ext4_handle_sync(handle_t *handle)
     280                 :            : {
     281   [ #  #  #  #  :          0 :         if (ext4_handle_valid(handle))
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     282                 :          0 :                 handle->h_sync = 1;
     283                 :            : }
     284                 :            : 
     285                 :          0 : static inline int ext4_handle_is_aborted(handle_t *handle)
     286                 :            : {
     287   [ #  #  #  # ]:          0 :         if (ext4_handle_valid(handle))
     288   [ #  #  #  # ]:          0 :                 return is_handle_aborted(handle);
     289                 :            :         return 0;
     290                 :            : }
     291                 :            : 
     292                 :      41518 : static inline int ext4_free_metadata_revoke_credits(struct super_block *sb,
     293                 :            :                                                     int blocks)
     294                 :            : {
     295                 :            :         /* Freeing each metadata block can result in freeing one cluster */
     296         [ -  - ]:      41388 :         return blocks * EXT4_SB(sb)->s_cluster_ratio;
     297                 :            : }
     298                 :            : 
     299                 :      41128 : static inline int ext4_trans_default_revoke_credits(struct super_block *sb)
     300                 :            : {
     301   [ -  -  +  -  :      41128 :         return ext4_free_metadata_revoke_credits(sb, 8);
          -  +  -  -  -  
                      + ]
     302                 :            : }
     303                 :            : 
     304                 :            : #define ext4_journal_start_sb(sb, type, nblocks)                        \
     305                 :            :         __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks), 0,   \
     306                 :            :                                 ext4_trans_default_revoke_credits(sb))
     307                 :            : 
     308                 :            : #define ext4_journal_start(inode, type, nblocks)                        \
     309                 :            :         __ext4_journal_start((inode), __LINE__, (type), (nblocks), 0,   \
     310                 :            :                              ext4_trans_default_revoke_credits((inode)->i_sb))
     311                 :            : 
     312                 :            : #define ext4_journal_start_with_reserve(inode, type, blocks, rsv_blocks)\
     313                 :            :         __ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks),\
     314                 :            :                              ext4_trans_default_revoke_credits((inode)->i_sb))
     315                 :            : 
     316                 :            : #define ext4_journal_start_with_revoke(inode, type, blocks, revoke_creds) \
     317                 :            :         __ext4_journal_start((inode), __LINE__, (type), (blocks), 0,    \
     318                 :            :                              (revoke_creds))
     319                 :            : 
     320                 :      32288 : static inline handle_t *__ext4_journal_start(struct inode *inode,
     321                 :            :                                              unsigned int line, int type,
     322                 :            :                                              int blocks, int rsv_blocks,
     323                 :            :                                              int revoke_creds)
     324                 :            : {
     325                 :      32288 :         return __ext4_journal_start_sb(inode->i_sb, line, type, blocks,
     326                 :            :                                        rsv_blocks, revoke_creds);
     327                 :            : }
     328                 :            : 
     329                 :            : #define ext4_journal_stop(handle) \
     330                 :            :         __ext4_journal_stop(__func__, __LINE__, (handle))
     331                 :            : 
     332                 :            : #define ext4_journal_start_reserved(handle, type) \
     333                 :            :         __ext4_journal_start_reserved((handle), __LINE__, (type))
     334                 :            : 
     335                 :            : handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line,
     336                 :            :                                         int type);
     337                 :            : 
     338                 :            : static inline void ext4_journal_free_reserved(handle_t *handle)
     339                 :            : {
     340                 :            :         if (ext4_handle_valid(handle))
     341                 :            :                 jbd2_journal_free_reserved(handle);
     342                 :            : }
     343                 :            : 
     344                 :      20813 : static inline handle_t *ext4_journal_current_handle(void)
     345                 :            : {
     346   [ -  +  -  +  :      20813 :         return journal_current_handle();
          -  -  -  -  +  
                      - ]
     347                 :            : }
     348                 :            : 
     349                 :          0 : static inline int ext4_journal_extend(handle_t *handle, int nblocks, int revoke)
     350                 :            : {
     351         [ #  # ]:          0 :         if (ext4_handle_valid(handle))
     352                 :          0 :                 return jbd2_journal_extend(handle, nblocks, revoke);
     353                 :            :         return 0;
     354                 :            : }
     355                 :            : 
     356                 :          0 : static inline int ext4_journal_restart(handle_t *handle, int nblocks,
     357                 :            :                                        int revoke)
     358                 :            : {
     359         [ #  # ]:          0 :         if (ext4_handle_valid(handle))
     360                 :          0 :                 return jbd2__journal_restart(handle, nblocks, revoke, GFP_NOFS);
     361                 :            :         return 0;
     362                 :            : }
     363                 :            : 
     364                 :            : int __ext4_journal_ensure_credits(handle_t *handle, int check_cred,
     365                 :            :                                   int extend_cred, int revoke_cred);
     366                 :            : 
     367                 :            : 
     368                 :            : /*
     369                 :            :  * Ensure @handle has at least @check_creds credits available. If not,
     370                 :            :  * transaction will be extended or restarted to contain at least @extend_cred
     371                 :            :  * credits. Before restarting transaction @fn is executed to allow for cleanup
     372                 :            :  * before the transaction is restarted.
     373                 :            :  *
     374                 :            :  * The return value is < 0 in case of error, 0 in case the handle has enough
     375                 :            :  * credits or transaction extension succeeded, 1 in case transaction had to be
     376                 :            :  * restarted.
     377                 :            :  */
     378                 :            : #define ext4_journal_ensure_credits_fn(handle, check_cred, extend_cred, \
     379                 :            :                                        revoke_cred, fn) \
     380                 :            : ({                                                                      \
     381                 :            :         __label__ __ensure_end;                                         \
     382                 :            :         int err = __ext4_journal_ensure_credits((handle), (check_cred), \
     383                 :            :                                         (extend_cred), (revoke_cred));  \
     384                 :            :                                                                         \
     385                 :            :         if (err <= 0)                                                        \
     386                 :            :                 goto __ensure_end;                                      \
     387                 :            :         err = (fn);                                                     \
     388                 :            :         if (err < 0)                                                 \
     389                 :            :                 goto __ensure_end;                                      \
     390                 :            :         err = ext4_journal_restart((handle), (extend_cred), (revoke_cred)); \
     391                 :            :         if (err == 0)                                                   \
     392                 :            :                 err = 1;                                                \
     393                 :            : __ensure_end:                                                           \
     394                 :            :         err;                                                            \
     395                 :            : })
     396                 :            : 
     397                 :            : /*
     398                 :            :  * Ensure given handle has at least requested amount of credits available,
     399                 :            :  * possibly restarting transaction if needed. We also make sure the transaction
     400                 :            :  * has space for at least ext4_trans_default_revoke_credits(sb) revoke records
     401                 :            :  * as freeing one or two blocks is very common pattern and requesting this is
     402                 :            :  * very cheap.
     403                 :            :  */
     404                 :        130 : static inline int ext4_journal_ensure_credits(handle_t *handle, int credits,
     405                 :            :                                               int revoke_creds)
     406                 :            : {
     407   [ +  -  -  -  :        130 :         return ext4_journal_ensure_credits_fn(handle, credits, credits,
                   -  - ]
     408                 :            :                                 revoke_creds, 0);
     409                 :            : }
     410                 :            : 
     411                 :        338 : static inline int ext4_journal_blocks_per_page(struct inode *inode)
     412                 :            : {
     413   [ +  -  +  - ]:        338 :         if (EXT4_JOURNAL(inode) != NULL)
     414                 :        338 :                 return jbd2_journal_blocks_per_page(inode);
     415                 :            :         return 0;
     416                 :            : }
     417                 :            : 
     418                 :         91 : static inline int ext4_journal_force_commit(journal_t *journal)
     419                 :            : {
     420         [ +  - ]:         91 :         if (journal)
     421                 :         91 :                 return jbd2_journal_force_commit(journal);
     422                 :            :         return 0;
     423                 :            : }
     424                 :            : 
     425                 :          0 : static inline int ext4_jbd2_inode_add_write(handle_t *handle,
     426                 :            :                 struct inode *inode, loff_t start_byte, loff_t length)
     427                 :            : {
     428   [ #  #  #  # ]:          0 :         if (ext4_handle_valid(handle))
     429                 :          0 :                 return jbd2_journal_inode_ranged_write(handle,
     430                 :            :                                 EXT4_I(inode)->jinode, start_byte, length);
     431                 :            :         return 0;
     432                 :            : }
     433                 :            : 
     434                 :          0 : static inline int ext4_jbd2_inode_add_wait(handle_t *handle,
     435                 :            :                 struct inode *inode, loff_t start_byte, loff_t length)
     436                 :            : {
     437         [ #  # ]:          0 :         if (ext4_handle_valid(handle))
     438                 :          0 :                 return jbd2_journal_inode_ranged_wait(handle,
     439                 :            :                                 EXT4_I(inode)->jinode, start_byte, length);
     440                 :            :         return 0;
     441                 :            : }
     442                 :            : 
     443                 :      69192 : static inline void ext4_update_inode_fsync_trans(handle_t *handle,
     444                 :            :                                                  struct inode *inode,
     445                 :            :                                                  int datasync)
     446                 :            : {
     447   [ -  -  +  -  :      69192 :         struct ext4_inode_info *ei = EXT4_I(inode);
          -  -  -  -  +  
          -  +  -  +  -  
             -  -  -  - ]
     448                 :            : 
     449   [ -  -  -  -  :     138384 :         if (ext4_handle_valid(handle) && !is_handle_aborted(handle)) {
          +  -  +  -  -  
          -  -  -  -  -  
          -  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  -  
          -  -  -  -  -  
                   -  - ]
     450                 :      69192 :                 ei->i_sync_tid = handle->h_transaction->t_tid;
     451         [ +  + ]:      65838 :                 if (datasync)
     452                 :       6851 :                         ei->i_datasync_tid = handle->h_transaction->t_tid;
     453                 :            :         }
     454                 :      65734 : }
     455                 :            : 
     456                 :            : /* super.c */
     457                 :            : int ext4_force_commit(struct super_block *sb);
     458                 :            : 
     459                 :            : /*
     460                 :            :  * Ext4 inode journal modes
     461                 :            :  */
     462                 :            : #define EXT4_INODE_JOURNAL_DATA_MODE    0x01 /* journal data mode */
     463                 :            : #define EXT4_INODE_ORDERED_DATA_MODE    0x02 /* ordered data mode */
     464                 :            : #define EXT4_INODE_WRITEBACK_DATA_MODE  0x04 /* writeback data mode */
     465                 :            : 
     466                 :            : int ext4_inode_journal_mode(struct inode *inode);
     467                 :            : 
     468                 :       1066 : static inline int ext4_should_journal_data(struct inode *inode)
     469                 :            : {
     470   [ +  +  -  -  :        728 :         return ext4_inode_journal_mode(inode) & EXT4_INODE_JOURNAL_DATA_MODE;
          +  +  -  -  -  
          +  -  -  -  +  
          -  -  -  -  -  
                      - ]
     471                 :            : }
     472                 :            : 
     473                 :       3380 : static inline int ext4_should_order_data(struct inode *inode)
     474                 :            : {
     475   [ -  -  -  -  :       3380 :         return ext4_inode_journal_mode(inode) & EXT4_INODE_ORDERED_DATA_MODE;
             -  +  +  + ]
     476                 :            : }
     477                 :            : 
     478                 :        104 : static inline int ext4_should_writeback_data(struct inode *inode)
     479                 :            : {
     480         [ +  - ]:        104 :         return ext4_inode_journal_mode(inode) & EXT4_INODE_WRITEBACK_DATA_MODE;
     481                 :            : }
     482                 :            : 
     483                 :        130 : static inline int ext4_free_data_revoke_credits(struct inode *inode, int blocks)
     484                 :            : {
     485         [ +  - ]:        130 :         if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
     486                 :            :                 return 0;
     487         [ +  + ]:        130 :         if (!ext4_should_journal_data(inode))
     488                 :            :                 return 0;
     489                 :            :         /*
     490                 :            :          * Data blocks in one extent are contiguous, just account for partial
     491                 :            :          * clusters at extent boundaries
     492                 :            :          */
     493                 :         26 :         return blocks + 2*(EXT4_SB(inode->i_sb)->s_cluster_ratio - 1);
     494                 :            : }
     495                 :            : 
     496                 :            : /*
     497                 :            :  * This function controls whether or not we should try to go down the
     498                 :            :  * dioread_nolock code paths, which makes it safe to avoid taking
     499                 :            :  * i_mutex for direct I/O reads.  This only works for extent-based
     500                 :            :  * files, and it doesn't work if data journaling is enabled, since the
     501                 :            :  * dioread_nolock code uses b_private to pass information back to the
     502                 :            :  * I/O completion handler, and this conflicts with the jbd's use of
     503                 :            :  * b_private.
     504                 :            :  */
     505                 :        208 : static inline int ext4_should_dioread_nolock(struct inode *inode)
     506                 :            : {
     507         [ +  - ]:        208 :         if (!test_opt(inode->i_sb, DIOREAD_NOLOCK))
     508                 :            :                 return 0;
     509         [ +  - ]:        208 :         if (!S_ISREG(inode->i_mode))
     510                 :            :                 return 0;
     511         [ +  - ]:        208 :         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
     512                 :            :                 return 0;
     513                 :        208 :         if (ext4_should_journal_data(inode))
     514                 :            :                 return 0;
     515                 :            :         return 1;
     516                 :            : }
     517                 :            : 
     518                 :            : #endif  /* _EXT4_JBD2_H */

Generated by: LCOV version 1.14