LCOV - code coverage report
Current view: top level - fs/ext4 - ext4_jbd2.h (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 25 44 56.8 %
Date: 2020-09-30 20:25:40 Functions: 3 3 100.0 %
Branches: 35 124 28.2 %

           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 __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle);
     266                 :            : 
     267                 :            : #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096)
     268                 :            : 
     269                 :            : /* Note:  Do not use this for NULL handles.  This is only to determine if
     270                 :            :  * a properly allocated handle is using a journal or not. */
     271                 :            : static inline int ext4_handle_valid(handle_t *handle)
     272                 :            : {
     273   [ +  -  +  +  :    7029057 :         if ((unsigned long)handle < EXT4_NOJOURNAL_MAX_REF_COUNT)
          +  -  +  -  +  
          +  +  -  +  -  
          +  +  #  #  #  
          #  #  #  +  -  
          #  #  #  #  #  
                #  +  + ]
     274                 :            :                 return 0;
     275                 :            :         return 1;
     276                 :            : }
     277                 :            : 
     278                 :            : static inline void ext4_handle_sync(handle_t *handle)
     279                 :            : {
     280   [ #  #  #  #  :          0 :         if (ext4_handle_valid(handle))
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     281                 :          0 :                 handle->h_sync = 1;
     282                 :            : }
     283                 :            : 
     284                 :            : static inline int ext4_handle_is_aborted(handle_t *handle)
     285                 :            : {
     286   [ #  #  #  # ]:          0 :         if (ext4_handle_valid(handle))
     287                 :            :                 return is_handle_aborted(handle);
     288                 :            :         return 0;
     289                 :            : }
     290                 :            : 
     291                 :            : static inline int ext4_handle_has_enough_credits(handle_t *handle, int needed)
     292                 :            : {
     293   [ +  -  +  -  :         11 :         if (ext4_handle_valid(handle) && handle->h_buffer_credits < needed)
             #  #  #  # ]
     294                 :            :                 return 0;
     295                 :            :         return 1;
     296                 :            : }
     297                 :            : 
     298                 :            : #define ext4_journal_start_sb(sb, type, nblocks)                        \
     299                 :            :         __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks), 0)
     300                 :            : 
     301                 :            : #define ext4_journal_start(inode, type, nblocks)                        \
     302                 :            :         __ext4_journal_start((inode), __LINE__, (type), (nblocks), 0)
     303                 :            : 
     304                 :            : #define ext4_journal_start_with_reserve(inode, type, blocks, rsv_blocks) \
     305                 :            :         __ext4_journal_start((inode), __LINE__, (type), (blocks), (rsv_blocks))
     306                 :            : 
     307                 :            : static inline handle_t *__ext4_journal_start(struct inode *inode,
     308                 :            :                                              unsigned int line, int type,
     309                 :            :                                              int blocks, int rsv_blocks)
     310                 :            : {
     311                 :    1105120 :         return __ext4_journal_start_sb(inode->i_sb, line, type, blocks,
     312                 :            :                                        rsv_blocks);
     313                 :            : }
     314                 :            : 
     315                 :            : #define ext4_journal_stop(handle) \
     316                 :            :         __ext4_journal_stop(__func__, __LINE__, (handle))
     317                 :            : 
     318                 :            : #define ext4_journal_start_reserved(handle, type) \
     319                 :            :         __ext4_journal_start_reserved((handle), __LINE__, (type))
     320                 :            : 
     321                 :            : handle_t *__ext4_journal_start_reserved(handle_t *handle, unsigned int line,
     322                 :            :                                         int type);
     323                 :            : 
     324                 :            : static inline void ext4_journal_free_reserved(handle_t *handle)
     325                 :            : {
     326                 :            :         if (ext4_handle_valid(handle))
     327                 :            :                 jbd2_journal_free_reserved(handle);
     328                 :            : }
     329                 :            : 
     330                 :            : static inline handle_t *ext4_journal_current_handle(void)
     331                 :            : {
     332                 :            :         return journal_current_handle();
     333                 :            : }
     334                 :            : 
     335                 :            : static inline int ext4_journal_extend(handle_t *handle, int nblocks)
     336                 :            : {
     337   [ #  #  #  #  :          0 :         if (ext4_handle_valid(handle))
             #  #  #  # ]
     338                 :          0 :                 return jbd2_journal_extend(handle, nblocks);
     339                 :            :         return 0;
     340                 :            : }
     341                 :            : 
     342                 :            : static inline int ext4_journal_restart(handle_t *handle, int nblocks)
     343                 :            : {
     344   [ #  #  #  #  :          0 :         if (ext4_handle_valid(handle))
          #  #  #  #  #  
                      # ]
     345                 :          0 :                 return jbd2_journal_restart(handle, nblocks);
     346                 :            :         return 0;
     347                 :            : }
     348                 :            : 
     349                 :            : static inline int ext4_journal_blocks_per_page(struct inode *inode)
     350                 :            : {
     351   [ +  -  +  - ]:      67528 :         if (EXT4_JOURNAL(inode) != NULL)
     352                 :      33764 :                 return jbd2_journal_blocks_per_page(inode);
     353                 :            :         return 0;
     354                 :            : }
     355                 :            : 
     356                 :            : static inline int ext4_journal_force_commit(journal_t *journal)
     357                 :            : {
     358         [ #  # ]:          0 :         if (journal)
     359                 :          0 :                 return jbd2_journal_force_commit(journal);
     360                 :            :         return 0;
     361                 :            : }
     362                 :            : 
     363                 :            : static inline int ext4_jbd2_inode_add_write(handle_t *handle,
     364                 :            :                 struct inode *inode, loff_t start_byte, loff_t length)
     365                 :            : {
     366   [ #  #  #  # ]:          0 :         if (ext4_handle_valid(handle))
     367                 :          0 :                 return jbd2_journal_inode_ranged_write(handle,
     368                 :            :                                 EXT4_I(inode)->jinode, start_byte, length);
     369                 :            :         return 0;
     370                 :            : }
     371                 :            : 
     372                 :            : static inline int ext4_jbd2_inode_add_wait(handle_t *handle,
     373                 :            :                 struct inode *inode, loff_t start_byte, loff_t length)
     374                 :            : {
     375         [ +  - ]:      13662 :         if (ext4_handle_valid(handle))
     376                 :      13662 :                 return jbd2_journal_inode_ranged_wait(handle,
     377                 :            :                                 EXT4_I(inode)->jinode, start_byte, length);
     378                 :            :         return 0;
     379                 :            : }
     380                 :            : 
     381                 :    1466777 : static inline void ext4_update_inode_fsync_trans(handle_t *handle,
     382                 :            :                                                  struct inode *inode,
     383                 :            :                                                  int datasync)
     384                 :            : {
     385                 :            :         struct ext4_inode_info *ei = EXT4_I(inode);
     386                 :            : 
     387   [ +  +  +  + ]:    2933512 :         if (ext4_handle_valid(handle) && !is_handle_aborted(handle)) {
     388                 :    1466770 :                 ei->i_sync_tid = handle->h_transaction->t_tid;
     389         [ +  + ]:    1466770 :                 if (datasync)
     390                 :     145443 :                         ei->i_datasync_tid = handle->h_transaction->t_tid;
     391                 :            :         }
     392                 :    1466777 : }
     393                 :            : 
     394                 :            : /* super.c */
     395                 :            : int ext4_force_commit(struct super_block *sb);
     396                 :            : 
     397                 :            : /*
     398                 :            :  * Ext4 inode journal modes
     399                 :            :  */
     400                 :            : #define EXT4_INODE_JOURNAL_DATA_MODE    0x01 /* journal data mode */
     401                 :            : #define EXT4_INODE_ORDERED_DATA_MODE    0x02 /* ordered data mode */
     402                 :            : #define EXT4_INODE_WRITEBACK_DATA_MODE  0x04 /* writeback data mode */
     403                 :            : 
     404                 :     570729 : static inline int ext4_inode_journal_mode(struct inode *inode)
     405                 :            : {
     406         [ +  + ]:    1141458 :         if (EXT4_JOURNAL(inode) == NULL)
     407                 :            :                 return EXT4_INODE_WRITEBACK_DATA_MODE;  /* writeback */
     408                 :            :         /* We do not support data journalling with delayed allocation */
     409   [ +  +  +  + ]:    1091673 :         if (!S_ISREG(inode->i_mode) ||
     410         [ -  + ]:    1042886 :             test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA ||
     411         [ #  # ]:          0 :             (ext4_test_inode_flag(inode, EXT4_INODE_JOURNAL_DATA) &&
     412                 :          0 :             !test_opt(inode->i_sb, DELALLOC))) {
     413                 :            :                 /* We do not support data journalling for encrypted data */
     414   [ -  +  #  # ]:      48681 :                 if (S_ISREG(inode->i_mode) && IS_ENCRYPTED(inode))
     415                 :            :                         return EXT4_INODE_ORDERED_DATA_MODE;  /* ordered */
     416                 :      48891 :                 return EXT4_INODE_JOURNAL_DATA_MODE;    /* journal data */
     417                 :            :         }
     418         [ -  + ]:     521644 :         if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
     419                 :            :                 return EXT4_INODE_ORDERED_DATA_MODE;    /* ordered */
     420         [ #  # ]:          0 :         if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
     421                 :            :                 return EXT4_INODE_WRITEBACK_DATA_MODE;  /* writeback */
     422                 :          0 :         BUG();
     423                 :            : }
     424                 :            : 
     425                 :            : static inline int ext4_should_journal_data(struct inode *inode)
     426                 :            : {
     427                 :      54784 :         return ext4_inode_journal_mode(inode) & EXT4_INODE_JOURNAL_DATA_MODE;
     428                 :            : }
     429                 :            : 
     430                 :            : static inline int ext4_should_order_data(struct inode *inode)
     431                 :            : {
     432                 :      63445 :         return ext4_inode_journal_mode(inode) & EXT4_INODE_ORDERED_DATA_MODE;
     433                 :            : }
     434                 :            : 
     435                 :            : static inline int ext4_should_writeback_data(struct inode *inode)
     436                 :            : {
     437                 :       2328 :         return ext4_inode_journal_mode(inode) & EXT4_INODE_WRITEBACK_DATA_MODE;
     438                 :            : }
     439                 :            : 
     440                 :            : /*
     441                 :            :  * This function controls whether or not we should try to go down the
     442                 :            :  * dioread_nolock code paths, which makes it safe to avoid taking
     443                 :            :  * i_mutex for direct I/O reads.  This only works for extent-based
     444                 :            :  * files, and it doesn't work if data journaling is enabled, since the
     445                 :            :  * dioread_nolock code uses b_private to pass information back to the
     446                 :            :  * I/O completion handler, and this conflicts with the jbd's use of
     447                 :            :  * b_private.
     448                 :            :  */
     449                 :      30073 : static inline int ext4_should_dioread_nolock(struct inode *inode)
     450                 :            : {
     451         [ -  + ]:      60146 :         if (!test_opt(inode->i_sb, DIOREAD_NOLOCK))
     452                 :            :                 return 0;
     453         [ #  # ]:          0 :         if (!S_ISREG(inode->i_mode))
     454                 :            :                 return 0;
     455         [ #  # ]:          0 :         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
     456                 :            :                 return 0;
     457         [ #  # ]:          0 :         if (ext4_should_journal_data(inode))
     458                 :            :                 return 0;
     459                 :          0 :         return 1;
     460                 :            : }
     461                 :            : 
     462                 :            : #endif  /* _EXT4_JBD2_H */

Generated by: LCOV version 1.14