LCOV - code coverage report
Current view: top level - fs/ext4 - ext4.h (source / functions) Hit Total Coverage
Test: landlock.info Lines: 207 254 81.5 %
Date: 2021-04-22 12:43:58 Functions: 14 19 73.7 %

          Line data    Source code
       1             : // SPDX-License-Identifier: GPL-2.0
       2             : /*
       3             :  *  ext4.h
       4             :  *
       5             :  * Copyright (C) 1992, 1993, 1994, 1995
       6             :  * Remy Card (card@masi.ibp.fr)
       7             :  * Laboratoire MASI - Institut Blaise Pascal
       8             :  * Universite Pierre et Marie Curie (Paris VI)
       9             :  *
      10             :  *  from
      11             :  *
      12             :  *  linux/include/linux/minix_fs.h
      13             :  *
      14             :  *  Copyright (C) 1991, 1992  Linus Torvalds
      15             :  */
      16             : 
      17             : #ifndef _EXT4_H
      18             : #define _EXT4_H
      19             : 
      20             : #include <linux/types.h>
      21             : #include <linux/blkdev.h>
      22             : #include <linux/magic.h>
      23             : #include <linux/jbd2.h>
      24             : #include <linux/quota.h>
      25             : #include <linux/rwsem.h>
      26             : #include <linux/rbtree.h>
      27             : #include <linux/seqlock.h>
      28             : #include <linux/mutex.h>
      29             : #include <linux/timer.h>
      30             : #include <linux/wait.h>
      31             : #include <linux/sched/signal.h>
      32             : #include <linux/blockgroup_lock.h>
      33             : #include <linux/percpu_counter.h>
      34             : #include <linux/ratelimit.h>
      35             : #include <crypto/hash.h>
      36             : #include <linux/falloc.h>
      37             : #include <linux/percpu-rwsem.h>
      38             : #include <linux/fiemap.h>
      39             : #ifdef __KERNEL__
      40             : #include <linux/compat.h>
      41             : #endif
      42             : 
      43             : #include <linux/fscrypt.h>
      44             : #include <linux/fsverity.h>
      45             : 
      46             : #include <linux/compiler.h>
      47             : 
      48             : /*
      49             :  * The fourth extended filesystem constants/structures
      50             :  */
      51             : 
      52             : /*
      53             :  * with AGGRESSIVE_CHECK allocator runs consistency checks over
      54             :  * structures. these checks slow things down a lot
      55             :  */
      56             : #define AGGRESSIVE_CHECK__
      57             : 
      58             : /*
      59             :  * with DOUBLE_CHECK defined mballoc creates persistent in-core
      60             :  * bitmaps, maintains and uses them to check for double allocations
      61             :  */
      62             : #define DOUBLE_CHECK__
      63             : 
      64             : /*
      65             :  * Define EXT4FS_DEBUG to produce debug messages
      66             :  */
      67             : #undef EXT4FS_DEBUG
      68             : 
      69             : /*
      70             :  * Debug code
      71             :  */
      72             : #ifdef EXT4FS_DEBUG
      73             : #define ext4_debug(f, a...)                                             \
      74             :         do {                                                            \
      75             :                 printk(KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:",      \
      76             :                         __FILE__, __LINE__, __func__);                  \
      77             :                 printk(KERN_DEBUG f, ## a);                             \
      78             :         } while (0)
      79             : #else
      80             : #define ext4_debug(fmt, ...)    no_printk(fmt, ##__VA_ARGS__)
      81             : #endif
      82             : 
      83             :  /*
      84             :   * Turn on EXT_DEBUG to enable ext4_ext_show_path/leaf/move in extents.c
      85             :   */
      86             : #define EXT_DEBUG__
      87             : 
      88             : /*
      89             :  * Dynamic printk for controlled extents debugging.
      90             :  */
      91             : #ifdef CONFIG_EXT4_DEBUG
      92             : #define ext_debug(ino, fmt, ...)                                        \
      93             :         pr_debug("[%s/%d] EXT4-fs (%s): ino %lu: (%s, %d): %s:" fmt,  \
      94             :                  current->comm, task_pid_nr(current),                        \
      95             :                  ino->i_sb->s_id, ino->i_ino, __FILE__, __LINE__,      \
      96             :                  __func__, ##__VA_ARGS__)
      97             : #else
      98             : #define ext_debug(ino, fmt, ...)        no_printk(fmt, ##__VA_ARGS__)
      99             : #endif
     100             : 
     101             : #define ASSERT(assert)                                          \
     102             : do {                                                                    \
     103             :         if (unlikely(!(assert))) {                                      \
     104             :                 printk(KERN_EMERG                                       \
     105             :                        "Assertion failure in %s() at %s:%d: '%s'\n",  \
     106             :                        __func__, __FILE__, __LINE__, #assert);          \
     107             :                 BUG();                                                  \
     108             :         }                                                               \
     109             : } while (0)
     110             : 
     111             : /* data type for block offset of block group */
     112             : typedef int ext4_grpblk_t;
     113             : 
     114             : /* data type for filesystem-wide blocks number */
     115             : typedef unsigned long long ext4_fsblk_t;
     116             : 
     117             : /* data type for file logical block number */
     118             : typedef __u32 ext4_lblk_t;
     119             : 
     120             : /* data type for block group number */
     121             : typedef unsigned int ext4_group_t;
     122             : 
     123             : enum SHIFT_DIRECTION {
     124             :         SHIFT_LEFT = 0,
     125             :         SHIFT_RIGHT,
     126             : };
     127             : 
     128             : /*
     129             :  * Flags used in mballoc's allocation_context flags field.
     130             :  *
     131             :  * Also used to show what's going on for debugging purposes when the
     132             :  * flag field is exported via the traceport interface
     133             :  */
     134             : 
     135             : /* prefer goal again. length */
     136             : #define EXT4_MB_HINT_MERGE              0x0001
     137             : /* blocks already reserved */
     138             : #define EXT4_MB_HINT_RESERVED           0x0002
     139             : /* metadata is being allocated */
     140             : #define EXT4_MB_HINT_METADATA           0x0004
     141             : /* first blocks in the file */
     142             : #define EXT4_MB_HINT_FIRST              0x0008
     143             : /* search for the best chunk */
     144             : #define EXT4_MB_HINT_BEST               0x0010
     145             : /* data is being allocated */
     146             : #define EXT4_MB_HINT_DATA               0x0020
     147             : /* don't preallocate (for tails) */
     148             : #define EXT4_MB_HINT_NOPREALLOC         0x0040
     149             : /* allocate for locality group */
     150             : #define EXT4_MB_HINT_GROUP_ALLOC        0x0080
     151             : /* allocate goal blocks or none */
     152             : #define EXT4_MB_HINT_GOAL_ONLY          0x0100
     153             : /* goal is meaningful */
     154             : #define EXT4_MB_HINT_TRY_GOAL           0x0200
     155             : /* blocks already pre-reserved by delayed allocation */
     156             : #define EXT4_MB_DELALLOC_RESERVED       0x0400
     157             : /* We are doing stream allocation */
     158             : #define EXT4_MB_STREAM_ALLOC            0x0800
     159             : /* Use reserved root blocks if needed */
     160             : #define EXT4_MB_USE_ROOT_BLOCKS         0x1000
     161             : /* Use blocks from reserved pool */
     162             : #define EXT4_MB_USE_RESERVED            0x2000
     163             : /* Do strict check for free blocks while retrying block allocation */
     164             : #define EXT4_MB_STRICT_CHECK            0x4000
     165             : 
     166             : struct ext4_allocation_request {
     167             :         /* target inode for block we're allocating */
     168             :         struct inode *inode;
     169             :         /* how many blocks we want to allocate */
     170             :         unsigned int len;
     171             :         /* logical block in target inode */
     172             :         ext4_lblk_t logical;
     173             :         /* the closest logical allocated block to the left */
     174             :         ext4_lblk_t lleft;
     175             :         /* the closest logical allocated block to the right */
     176             :         ext4_lblk_t lright;
     177             :         /* phys. target (a hint) */
     178             :         ext4_fsblk_t goal;
     179             :         /* phys. block for the closest logical allocated block to the left */
     180             :         ext4_fsblk_t pleft;
     181             :         /* phys. block for the closest logical allocated block to the right */
     182             :         ext4_fsblk_t pright;
     183             :         /* flags. see above EXT4_MB_HINT_* */
     184             :         unsigned int flags;
     185             : };
     186             : 
     187             : /*
     188             :  * Logical to physical block mapping, used by ext4_map_blocks()
     189             :  *
     190             :  * This structure is used to pass requests into ext4_map_blocks() as
     191             :  * well as to store the information returned by ext4_map_blocks().  It
     192             :  * takes less room on the stack than a struct buffer_head.
     193             :  */
     194             : #define EXT4_MAP_NEW            BIT(BH_New)
     195             : #define EXT4_MAP_MAPPED         BIT(BH_Mapped)
     196             : #define EXT4_MAP_UNWRITTEN      BIT(BH_Unwritten)
     197             : #define EXT4_MAP_BOUNDARY       BIT(BH_Boundary)
     198             : #define EXT4_MAP_FLAGS          (EXT4_MAP_NEW | EXT4_MAP_MAPPED |\
     199             :                                  EXT4_MAP_UNWRITTEN | EXT4_MAP_BOUNDARY)
     200             : 
     201             : struct ext4_map_blocks {
     202             :         ext4_fsblk_t m_pblk;
     203             :         ext4_lblk_t m_lblk;
     204             :         unsigned int m_len;
     205             :         unsigned int m_flags;
     206             : };
     207             : 
     208             : /*
     209             :  * Block validity checking, system zone rbtree.
     210             :  */
     211             : struct ext4_system_blocks {
     212             :         struct rb_root root;
     213             :         struct rcu_head rcu;
     214             : };
     215             : 
     216             : /*
     217             :  * Flags for ext4_io_end->flags
     218             :  */
     219             : #define EXT4_IO_END_UNWRITTEN   0x0001
     220             : 
     221             : struct ext4_io_end_vec {
     222             :         struct list_head list;          /* list of io_end_vec */
     223             :         loff_t offset;                  /* offset in the file */
     224             :         ssize_t size;                   /* size of the extent */
     225             : };
     226             : 
     227             : /*
     228             :  * For converting unwritten extents on a work queue. 'handle' is used for
     229             :  * buffered writeback.
     230             :  */
     231             : typedef struct ext4_io_end {
     232             :         struct list_head        list;           /* per-file finished IO list */
     233             :         handle_t                *handle;        /* handle reserved for extent
     234             :                                                  * conversion */
     235             :         struct inode            *inode;         /* file being written to */
     236             :         struct bio              *bio;           /* Linked list of completed
     237             :                                                  * bios covering the extent */
     238             :         unsigned int            flag;           /* unwritten or not */
     239             :         atomic_t                count;          /* reference counter */
     240             :         struct list_head        list_vec;       /* list of ext4_io_end_vec */
     241             : } ext4_io_end_t;
     242             : 
     243             : struct ext4_io_submit {
     244             :         struct writeback_control *io_wbc;
     245             :         struct bio              *io_bio;
     246             :         ext4_io_end_t           *io_end;
     247             :         sector_t                io_next_block;
     248             : };
     249             : 
     250             : /*
     251             :  * Special inodes numbers
     252             :  */
     253             : #define EXT4_BAD_INO             1      /* Bad blocks inode */
     254             : #define EXT4_ROOT_INO            2      /* Root inode */
     255             : #define EXT4_USR_QUOTA_INO       3      /* User quota inode */
     256             : #define EXT4_GRP_QUOTA_INO       4      /* Group quota inode */
     257             : #define EXT4_BOOT_LOADER_INO     5      /* Boot loader inode */
     258             : #define EXT4_UNDEL_DIR_INO       6      /* Undelete directory inode */
     259             : #define EXT4_RESIZE_INO          7      /* Reserved group descriptors inode */
     260             : #define EXT4_JOURNAL_INO         8      /* Journal inode */
     261             : 
     262             : /* First non-reserved inode for old ext4 filesystems */
     263             : #define EXT4_GOOD_OLD_FIRST_INO 11
     264             : 
     265             : /*
     266             :  * Maximal count of links to a file
     267             :  */
     268             : #define EXT4_LINK_MAX           65000
     269             : 
     270             : /*
     271             :  * Macro-instructions used to manage several block sizes
     272             :  */
     273             : #define EXT4_MIN_BLOCK_SIZE             1024
     274             : #define EXT4_MAX_BLOCK_SIZE             65536
     275             : #define EXT4_MIN_BLOCK_LOG_SIZE         10
     276             : #define EXT4_MAX_BLOCK_LOG_SIZE         16
     277             : #define EXT4_MAX_CLUSTER_LOG_SIZE       30
     278             : #ifdef __KERNEL__
     279             : # define EXT4_BLOCK_SIZE(s)             ((s)->s_blocksize)
     280             : #else
     281             : # define EXT4_BLOCK_SIZE(s)             (EXT4_MIN_BLOCK_SIZE << (s)->s_log_block_size)
     282             : #endif
     283             : #define EXT4_ADDR_PER_BLOCK(s)          (EXT4_BLOCK_SIZE(s) / sizeof(__u32))
     284             : #define EXT4_CLUSTER_SIZE(s)            (EXT4_BLOCK_SIZE(s) << \
     285             :                                          EXT4_SB(s)->s_cluster_bits)
     286             : #ifdef __KERNEL__
     287             : # define EXT4_BLOCK_SIZE_BITS(s)        ((s)->s_blocksize_bits)
     288             : # define EXT4_CLUSTER_BITS(s)           (EXT4_SB(s)->s_cluster_bits)
     289             : #else
     290             : # define EXT4_BLOCK_SIZE_BITS(s)        ((s)->s_log_block_size + 10)
     291             : #endif
     292             : #ifdef __KERNEL__
     293             : #define EXT4_ADDR_PER_BLOCK_BITS(s)     (EXT4_SB(s)->s_addr_per_block_bits)
     294             : #define EXT4_INODE_SIZE(s)              (EXT4_SB(s)->s_inode_size)
     295             : #define EXT4_FIRST_INO(s)               (EXT4_SB(s)->s_first_ino)
     296             : #else
     297             : #define EXT4_INODE_SIZE(s)      (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \
     298             :                                  EXT4_GOOD_OLD_INODE_SIZE : \
     299             :                                  (s)->s_inode_size)
     300             : #define EXT4_FIRST_INO(s)       (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \
     301             :                                  EXT4_GOOD_OLD_FIRST_INO : \
     302             :                                  (s)->s_first_ino)
     303             : #endif
     304             : #define EXT4_BLOCK_ALIGN(size, blkbits)         ALIGN((size), (1 << (blkbits)))
     305             : #define EXT4_MAX_BLOCKS(size, offset, blkbits) \
     306             :         ((EXT4_BLOCK_ALIGN(size + offset, blkbits) >> blkbits) - (offset >> \
     307             :                                                                   blkbits))
     308             : 
     309             : /* Translate a block number to a cluster number */
     310             : #define EXT4_B2C(sbi, blk)      ((blk) >> (sbi)->s_cluster_bits)
     311             : /* Translate a cluster number to a block number */
     312             : #define EXT4_C2B(sbi, cluster)  ((cluster) << (sbi)->s_cluster_bits)
     313             : /* Translate # of blks to # of clusters */
     314             : #define EXT4_NUM_B2C(sbi, blks) (((blks) + (sbi)->s_cluster_ratio - 1) >> \
     315             :                                  (sbi)->s_cluster_bits)
     316             : /* Mask out the low bits to get the starting block of the cluster */
     317             : #define EXT4_PBLK_CMASK(s, pblk) ((pblk) &                          \
     318             :                                   ~((ext4_fsblk_t) (s)->s_cluster_ratio - 1))
     319             : #define EXT4_LBLK_CMASK(s, lblk) ((lblk) &                          \
     320             :                                   ~((ext4_lblk_t) (s)->s_cluster_ratio - 1))
     321             : /* Fill in the low bits to get the last block of the cluster */
     322             : #define EXT4_LBLK_CFILL(sbi, lblk) ((lblk) |                            \
     323             :                                     ((ext4_lblk_t) (sbi)->s_cluster_ratio - 1))
     324             : /* Get the cluster offset */
     325             : #define EXT4_PBLK_COFF(s, pblk) ((pblk) &                           \
     326             :                                  ((ext4_fsblk_t) (s)->s_cluster_ratio - 1))
     327             : #define EXT4_LBLK_COFF(s, lblk) ((lblk) &                           \
     328             :                                  ((ext4_lblk_t) (s)->s_cluster_ratio - 1))
     329             : 
     330             : /*
     331             :  * Structure of a blocks group descriptor
     332             :  */
     333             : struct ext4_group_desc
     334             : {
     335             :         __le32  bg_block_bitmap_lo;     /* Blocks bitmap block */
     336             :         __le32  bg_inode_bitmap_lo;     /* Inodes bitmap block */
     337             :         __le32  bg_inode_table_lo;      /* Inodes table block */
     338             :         __le16  bg_free_blocks_count_lo;/* Free blocks count */
     339             :         __le16  bg_free_inodes_count_lo;/* Free inodes count */
     340             :         __le16  bg_used_dirs_count_lo;  /* Directories count */
     341             :         __le16  bg_flags;               /* EXT4_BG_flags (INODE_UNINIT, etc) */
     342             :         __le32  bg_exclude_bitmap_lo;   /* Exclude bitmap for snapshots */
     343             :         __le16  bg_block_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bbitmap) LE */
     344             :         __le16  bg_inode_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+ibitmap) LE */
     345             :         __le16  bg_itable_unused_lo;    /* Unused inodes count */
     346             :         __le16  bg_checksum;            /* crc16(sb_uuid+group+desc) */
     347             :         __le32  bg_block_bitmap_hi;     /* Blocks bitmap block MSB */
     348             :         __le32  bg_inode_bitmap_hi;     /* Inodes bitmap block MSB */
     349             :         __le32  bg_inode_table_hi;      /* Inodes table block MSB */
     350             :         __le16  bg_free_blocks_count_hi;/* Free blocks count MSB */
     351             :         __le16  bg_free_inodes_count_hi;/* Free inodes count MSB */
     352             :         __le16  bg_used_dirs_count_hi;  /* Directories count MSB */
     353             :         __le16  bg_itable_unused_hi;    /* Unused inodes count MSB */
     354             :         __le32  bg_exclude_bitmap_hi;   /* Exclude bitmap block MSB */
     355             :         __le16  bg_block_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+bbitmap) BE */
     356             :         __le16  bg_inode_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+ibitmap) BE */
     357             :         __u32   bg_reserved;
     358             : };
     359             : 
     360             : #define EXT4_BG_INODE_BITMAP_CSUM_HI_END        \
     361             :         (offsetof(struct ext4_group_desc, bg_inode_bitmap_csum_hi) + \
     362             :          sizeof(__le16))
     363             : #define EXT4_BG_BLOCK_BITMAP_CSUM_HI_END        \
     364             :         (offsetof(struct ext4_group_desc, bg_block_bitmap_csum_hi) + \
     365             :          sizeof(__le16))
     366             : 
     367             : /*
     368             :  * Structure of a flex block group info
     369             :  */
     370             : 
     371             : struct flex_groups {
     372             :         atomic64_t      free_clusters;
     373             :         atomic_t        free_inodes;
     374             :         atomic_t        used_dirs;
     375             : };
     376             : 
     377             : #define EXT4_BG_INODE_UNINIT    0x0001 /* Inode table/bitmap not in use */
     378             : #define EXT4_BG_BLOCK_UNINIT    0x0002 /* Block bitmap not in use */
     379             : #define EXT4_BG_INODE_ZEROED    0x0004 /* On-disk itable initialized to zero */
     380             : 
     381             : /*
     382             :  * Macro-instructions used to manage group descriptors
     383             :  */
     384             : #define EXT4_MIN_DESC_SIZE              32
     385             : #define EXT4_MIN_DESC_SIZE_64BIT        64
     386             : #define EXT4_MAX_DESC_SIZE              EXT4_MIN_BLOCK_SIZE
     387             : #define EXT4_DESC_SIZE(s)               (EXT4_SB(s)->s_desc_size)
     388             : #ifdef __KERNEL__
     389             : # define EXT4_BLOCKS_PER_GROUP(s)       (EXT4_SB(s)->s_blocks_per_group)
     390             : # define EXT4_CLUSTERS_PER_GROUP(s)     (EXT4_SB(s)->s_clusters_per_group)
     391             : # define EXT4_DESC_PER_BLOCK(s)         (EXT4_SB(s)->s_desc_per_block)
     392             : # define EXT4_INODES_PER_GROUP(s)       (EXT4_SB(s)->s_inodes_per_group)
     393             : # define EXT4_DESC_PER_BLOCK_BITS(s)    (EXT4_SB(s)->s_desc_per_block_bits)
     394             : #else
     395             : # define EXT4_BLOCKS_PER_GROUP(s)       ((s)->s_blocks_per_group)
     396             : # define EXT4_DESC_PER_BLOCK(s)         (EXT4_BLOCK_SIZE(s) / EXT4_DESC_SIZE(s))
     397             : # define EXT4_INODES_PER_GROUP(s)       ((s)->s_inodes_per_group)
     398             : #endif
     399             : 
     400             : /*
     401             :  * Constants relative to the data blocks
     402             :  */
     403             : #define EXT4_NDIR_BLOCKS                12
     404             : #define EXT4_IND_BLOCK                  EXT4_NDIR_BLOCKS
     405             : #define EXT4_DIND_BLOCK                 (EXT4_IND_BLOCK + 1)
     406             : #define EXT4_TIND_BLOCK                 (EXT4_DIND_BLOCK + 1)
     407             : #define EXT4_N_BLOCKS                   (EXT4_TIND_BLOCK + 1)
     408             : 
     409             : /*
     410             :  * Inode flags
     411             :  */
     412             : #define EXT4_SECRM_FL                   0x00000001 /* Secure deletion */
     413             : #define EXT4_UNRM_FL                    0x00000002 /* Undelete */
     414             : #define EXT4_COMPR_FL                   0x00000004 /* Compress file */
     415             : #define EXT4_SYNC_FL                    0x00000008 /* Synchronous updates */
     416             : #define EXT4_IMMUTABLE_FL               0x00000010 /* Immutable file */
     417             : #define EXT4_APPEND_FL                  0x00000020 /* writes to file may only append */
     418             : #define EXT4_NODUMP_FL                  0x00000040 /* do not dump file */
     419             : #define EXT4_NOATIME_FL                 0x00000080 /* do not update atime */
     420             : /* Reserved for compression usage... */
     421             : #define EXT4_DIRTY_FL                   0x00000100
     422             : #define EXT4_COMPRBLK_FL                0x00000200 /* One or more compressed clusters */
     423             : #define EXT4_NOCOMPR_FL                 0x00000400 /* Don't compress */
     424             :         /* nb: was previously EXT2_ECOMPR_FL */
     425             : #define EXT4_ENCRYPT_FL                 0x00000800 /* encrypted file */
     426             : /* End compression flags --- maybe not all used */
     427             : #define EXT4_INDEX_FL                   0x00001000 /* hash-indexed directory */
     428             : #define EXT4_IMAGIC_FL                  0x00002000 /* AFS directory */
     429             : #define EXT4_JOURNAL_DATA_FL            0x00004000 /* file data should be journaled */
     430             : #define EXT4_NOTAIL_FL                  0x00008000 /* file tail should not be merged */
     431             : #define EXT4_DIRSYNC_FL                 0x00010000 /* dirsync behaviour (directories only) */
     432             : #define EXT4_TOPDIR_FL                  0x00020000 /* Top of directory hierarchies*/
     433             : #define EXT4_HUGE_FILE_FL               0x00040000 /* Set to each huge file */
     434             : #define EXT4_EXTENTS_FL                 0x00080000 /* Inode uses extents */
     435             : #define EXT4_VERITY_FL                  0x00100000 /* Verity protected inode */
     436             : #define EXT4_EA_INODE_FL                0x00200000 /* Inode used for large EA */
     437             : /* 0x00400000 was formerly EXT4_EOFBLOCKS_FL */
     438             : 
     439             : #define EXT4_DAX_FL                     0x02000000 /* Inode is DAX */
     440             : 
     441             : #define EXT4_INLINE_DATA_FL             0x10000000 /* Inode has inline data. */
     442             : #define EXT4_PROJINHERIT_FL             0x20000000 /* Create with parents projid */
     443             : #define EXT4_CASEFOLD_FL                0x40000000 /* Casefolded directory */
     444             : #define EXT4_RESERVED_FL                0x80000000 /* reserved for ext4 lib */
     445             : 
     446             : /* User modifiable flags */
     447             : #define EXT4_FL_USER_MODIFIABLE         (EXT4_SECRM_FL | \
     448             :                                          EXT4_UNRM_FL | \
     449             :                                          EXT4_COMPR_FL | \
     450             :                                          EXT4_SYNC_FL | \
     451             :                                          EXT4_IMMUTABLE_FL | \
     452             :                                          EXT4_APPEND_FL | \
     453             :                                          EXT4_NODUMP_FL | \
     454             :                                          EXT4_NOATIME_FL | \
     455             :                                          EXT4_JOURNAL_DATA_FL | \
     456             :                                          EXT4_NOTAIL_FL | \
     457             :                                          EXT4_DIRSYNC_FL | \
     458             :                                          EXT4_TOPDIR_FL | \
     459             :                                          EXT4_EXTENTS_FL | \
     460             :                                          0x00400000 /* EXT4_EOFBLOCKS_FL */ | \
     461             :                                          EXT4_DAX_FL | \
     462             :                                          EXT4_PROJINHERIT_FL | \
     463             :                                          EXT4_CASEFOLD_FL)
     464             : 
     465             : /* User visible flags */
     466             : #define EXT4_FL_USER_VISIBLE            (EXT4_FL_USER_MODIFIABLE | \
     467             :                                          EXT4_DIRTY_FL | \
     468             :                                          EXT4_COMPRBLK_FL | \
     469             :                                          EXT4_NOCOMPR_FL | \
     470             :                                          EXT4_ENCRYPT_FL | \
     471             :                                          EXT4_INDEX_FL | \
     472             :                                          EXT4_VERITY_FL | \
     473             :                                          EXT4_INLINE_DATA_FL)
     474             : 
     475             : /* Flags we can manipulate with through FS_IOC_FSSETXATTR */
     476             : #define EXT4_FL_XFLAG_VISIBLE           (EXT4_SYNC_FL | \
     477             :                                          EXT4_IMMUTABLE_FL | \
     478             :                                          EXT4_APPEND_FL | \
     479             :                                          EXT4_NODUMP_FL | \
     480             :                                          EXT4_NOATIME_FL | \
     481             :                                          EXT4_PROJINHERIT_FL | \
     482             :                                          EXT4_DAX_FL)
     483             : 
     484             : /* Flags that should be inherited by new inodes from their parent. */
     485             : #define EXT4_FL_INHERITED (EXT4_SECRM_FL | EXT4_UNRM_FL | EXT4_COMPR_FL |\
     486             :                            EXT4_SYNC_FL | EXT4_NODUMP_FL | EXT4_NOATIME_FL |\
     487             :                            EXT4_NOCOMPR_FL | EXT4_JOURNAL_DATA_FL |\
     488             :                            EXT4_NOTAIL_FL | EXT4_DIRSYNC_FL |\
     489             :                            EXT4_PROJINHERIT_FL | EXT4_CASEFOLD_FL |\
     490             :                            EXT4_DAX_FL)
     491             : 
     492             : /* Flags that are appropriate for regular files (all but dir-specific ones). */
     493             : #define EXT4_REG_FLMASK (~(EXT4_DIRSYNC_FL | EXT4_TOPDIR_FL | EXT4_CASEFOLD_FL |\
     494             :                            EXT4_PROJINHERIT_FL))
     495             : 
     496             : /* Flags that are appropriate for non-directories/regular files. */
     497             : #define EXT4_OTHER_FLMASK (EXT4_NODUMP_FL | EXT4_NOATIME_FL)
     498             : 
     499             : /* The only flags that should be swapped */
     500             : #define EXT4_FL_SHOULD_SWAP (EXT4_HUGE_FILE_FL | EXT4_EXTENTS_FL)
     501             : 
     502             : /* Flags which are mutually exclusive to DAX */
     503             : #define EXT4_DAX_MUT_EXCL (EXT4_VERITY_FL | EXT4_ENCRYPT_FL |\
     504             :                            EXT4_JOURNAL_DATA_FL | EXT4_INLINE_DATA_FL)
     505             : 
     506             : /* Mask out flags that are inappropriate for the given type of inode. */
     507         628 : static inline __u32 ext4_mask_flags(umode_t mode, __u32 flags)
     508             : {
     509         628 :         if (S_ISDIR(mode))
     510             :                 return flags;
     511         455 :         else if (S_ISREG(mode))
     512         455 :                 return flags & EXT4_REG_FLMASK;
     513             :         else
     514           0 :                 return flags & EXT4_OTHER_FLMASK;
     515             : }
     516             : 
     517             : /*
     518             :  * Inode flags used for atomic set/get
     519             :  */
     520             : enum {
     521             :         EXT4_INODE_SECRM        = 0,    /* Secure deletion */
     522             :         EXT4_INODE_UNRM         = 1,    /* Undelete */
     523             :         EXT4_INODE_COMPR        = 2,    /* Compress file */
     524             :         EXT4_INODE_SYNC         = 3,    /* Synchronous updates */
     525             :         EXT4_INODE_IMMUTABLE    = 4,    /* Immutable file */
     526             :         EXT4_INODE_APPEND       = 5,    /* writes to file may only append */
     527             :         EXT4_INODE_NODUMP       = 6,    /* do not dump file */
     528             :         EXT4_INODE_NOATIME      = 7,    /* do not update atime */
     529             : /* Reserved for compression usage... */
     530             :         EXT4_INODE_DIRTY        = 8,
     531             :         EXT4_INODE_COMPRBLK     = 9,    /* One or more compressed clusters */
     532             :         EXT4_INODE_NOCOMPR      = 10,   /* Don't compress */
     533             :         EXT4_INODE_ENCRYPT      = 11,   /* Encrypted file */
     534             : /* End compression flags --- maybe not all used */
     535             :         EXT4_INODE_INDEX        = 12,   /* hash-indexed directory */
     536             :         EXT4_INODE_IMAGIC       = 13,   /* AFS directory */
     537             :         EXT4_INODE_JOURNAL_DATA = 14,   /* file data should be journaled */
     538             :         EXT4_INODE_NOTAIL       = 15,   /* file tail should not be merged */
     539             :         EXT4_INODE_DIRSYNC      = 16,   /* dirsync behaviour (directories only) */
     540             :         EXT4_INODE_TOPDIR       = 17,   /* Top of directory hierarchies*/
     541             :         EXT4_INODE_HUGE_FILE    = 18,   /* Set to each huge file */
     542             :         EXT4_INODE_EXTENTS      = 19,   /* Inode uses extents */
     543             :         EXT4_INODE_VERITY       = 20,   /* Verity protected inode */
     544             :         EXT4_INODE_EA_INODE     = 21,   /* Inode used for large EA */
     545             : /* 22 was formerly EXT4_INODE_EOFBLOCKS */
     546             :         EXT4_INODE_DAX          = 25,   /* Inode is DAX */
     547             :         EXT4_INODE_INLINE_DATA  = 28,   /* Data in inode. */
     548             :         EXT4_INODE_PROJINHERIT  = 29,   /* Create with parents projid */
     549             :         EXT4_INODE_CASEFOLD     = 30,   /* Casefolded directory */
     550             :         EXT4_INODE_RESERVED     = 31,   /* reserved for ext4 lib */
     551             : };
     552             : 
     553             : /*
     554             :  * Since it's pretty easy to mix up bit numbers and hex values, we use a
     555             :  * build-time check to make sure that EXT4_XXX_FL is consistent with respect to
     556             :  * EXT4_INODE_XXX. If all is well, the macros will be dropped, so, it won't cost
     557             :  * any extra space in the compiled kernel image, otherwise, the build will fail.
     558             :  * It's important that these values are the same, since we are using
     559             :  * EXT4_INODE_XXX to test for flag values, but EXT4_XXX_FL must be consistent
     560             :  * with the values of FS_XXX_FL defined in include/linux/fs.h and the on-disk
     561             :  * values found in ext2, ext3 and ext4 filesystems, and of course the values
     562             :  * defined in e2fsprogs.
     563             :  *
     564             :  * It's not paranoia if the Murphy's Law really *is* out to get you.  :-)
     565             :  */
     566             : #define TEST_FLAG_VALUE(FLAG) (EXT4_##FLAG##_FL == (1 << EXT4_INODE_##FLAG))
     567             : #define CHECK_FLAG_VALUE(FLAG) BUILD_BUG_ON(!TEST_FLAG_VALUE(FLAG))
     568             : 
     569           1 : static inline void ext4_check_flag_values(void)
     570             : {
     571           1 :         CHECK_FLAG_VALUE(SECRM);
     572           1 :         CHECK_FLAG_VALUE(UNRM);
     573           1 :         CHECK_FLAG_VALUE(COMPR);
     574           1 :         CHECK_FLAG_VALUE(SYNC);
     575           1 :         CHECK_FLAG_VALUE(IMMUTABLE);
     576           1 :         CHECK_FLAG_VALUE(APPEND);
     577           1 :         CHECK_FLAG_VALUE(NODUMP);
     578           1 :         CHECK_FLAG_VALUE(NOATIME);
     579           1 :         CHECK_FLAG_VALUE(DIRTY);
     580           1 :         CHECK_FLAG_VALUE(COMPRBLK);
     581           1 :         CHECK_FLAG_VALUE(NOCOMPR);
     582           1 :         CHECK_FLAG_VALUE(ENCRYPT);
     583           1 :         CHECK_FLAG_VALUE(INDEX);
     584           1 :         CHECK_FLAG_VALUE(IMAGIC);
     585           1 :         CHECK_FLAG_VALUE(JOURNAL_DATA);
     586           1 :         CHECK_FLAG_VALUE(NOTAIL);
     587           1 :         CHECK_FLAG_VALUE(DIRSYNC);
     588           1 :         CHECK_FLAG_VALUE(TOPDIR);
     589           1 :         CHECK_FLAG_VALUE(HUGE_FILE);
     590           1 :         CHECK_FLAG_VALUE(EXTENTS);
     591           1 :         CHECK_FLAG_VALUE(VERITY);
     592           1 :         CHECK_FLAG_VALUE(EA_INODE);
     593           1 :         CHECK_FLAG_VALUE(INLINE_DATA);
     594           1 :         CHECK_FLAG_VALUE(PROJINHERIT);
     595           1 :         CHECK_FLAG_VALUE(CASEFOLD);
     596           1 :         CHECK_FLAG_VALUE(RESERVED);
     597             : }
     598             : 
     599             : /* Used to pass group descriptor data when online resize is done */
     600             : struct ext4_new_group_input {
     601             :         __u32 group;            /* Group number for this data */
     602             :         __u64 block_bitmap;     /* Absolute block number of block bitmap */
     603             :         __u64 inode_bitmap;     /* Absolute block number of inode bitmap */
     604             :         __u64 inode_table;      /* Absolute block number of inode table start */
     605             :         __u32 blocks_count;     /* Total number of blocks in this group */
     606             :         __u16 reserved_blocks;  /* Number of reserved blocks in this group */
     607             :         __u16 unused;
     608             : };
     609             : 
     610             : #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
     611             : struct compat_ext4_new_group_input {
     612             :         u32 group;
     613             :         compat_u64 block_bitmap;
     614             :         compat_u64 inode_bitmap;
     615             :         compat_u64 inode_table;
     616             :         u32 blocks_count;
     617             :         u16 reserved_blocks;
     618             :         u16 unused;
     619             : };
     620             : #endif
     621             : 
     622             : /* The struct ext4_new_group_input in kernel space, with free_blocks_count */
     623             : struct ext4_new_group_data {
     624             :         __u32 group;
     625             :         __u64 block_bitmap;
     626             :         __u64 inode_bitmap;
     627             :         __u64 inode_table;
     628             :         __u32 blocks_count;
     629             :         __u16 reserved_blocks;
     630             :         __u16 mdata_blocks;
     631             :         __u32 free_clusters_count;
     632             : };
     633             : 
     634             : /* Indexes used to index group tables in ext4_new_group_data */
     635             : enum {
     636             :         BLOCK_BITMAP = 0,       /* block bitmap */
     637             :         INODE_BITMAP,           /* inode bitmap */
     638             :         INODE_TABLE,            /* inode tables */
     639             :         GROUP_TABLE_COUNT,
     640             : };
     641             : 
     642             : /*
     643             :  * Flags used by ext4_map_blocks()
     644             :  */
     645             :         /* Allocate any needed blocks and/or convert an unwritten
     646             :            extent to be an initialized ext4 */
     647             : #define EXT4_GET_BLOCKS_CREATE                  0x0001
     648             :         /* Request the creation of an unwritten extent */
     649             : #define EXT4_GET_BLOCKS_UNWRIT_EXT              0x0002
     650             : #define EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT       (EXT4_GET_BLOCKS_UNWRIT_EXT|\
     651             :                                                  EXT4_GET_BLOCKS_CREATE)
     652             :         /* Caller is from the delayed allocation writeout path
     653             :          * finally doing the actual allocation of delayed blocks */
     654             : #define EXT4_GET_BLOCKS_DELALLOC_RESERVE        0x0004
     655             :         /* caller is from the direct IO path, request to creation of an
     656             :         unwritten extents if not allocated, split the unwritten
     657             :         extent if blocks has been preallocated already*/
     658             : #define EXT4_GET_BLOCKS_PRE_IO                  0x0008
     659             : #define EXT4_GET_BLOCKS_CONVERT                 0x0010
     660             : #define EXT4_GET_BLOCKS_IO_CREATE_EXT           (EXT4_GET_BLOCKS_PRE_IO|\
     661             :                                          EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)
     662             :         /* Convert extent to initialized after IO complete */
     663             : #define EXT4_GET_BLOCKS_IO_CONVERT_EXT          (EXT4_GET_BLOCKS_CONVERT|\
     664             :                                          EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)
     665             :         /* Eventual metadata allocation (due to growing extent tree)
     666             :          * should not fail, so try to use reserved blocks for that.*/
     667             : #define EXT4_GET_BLOCKS_METADATA_NOFAIL         0x0020
     668             :         /* Don't normalize allocation size (used for fallocate) */
     669             : #define EXT4_GET_BLOCKS_NO_NORMALIZE            0x0040
     670             :         /* Convert written extents to unwritten */
     671             : #define EXT4_GET_BLOCKS_CONVERT_UNWRITTEN       0x0100
     672             :         /* Write zeros to newly created written extents */
     673             : #define EXT4_GET_BLOCKS_ZERO                    0x0200
     674             : #define EXT4_GET_BLOCKS_CREATE_ZERO             (EXT4_GET_BLOCKS_CREATE |\
     675             :                                         EXT4_GET_BLOCKS_ZERO)
     676             :         /* Caller will submit data before dropping transaction handle. This
     677             :          * allows jbd2 to avoid submitting data before commit. */
     678             : #define EXT4_GET_BLOCKS_IO_SUBMIT               0x0400
     679             : 
     680             : /*
     681             :  * The bit position of these flags must not overlap with any of the
     682             :  * EXT4_GET_BLOCKS_*.  They are used by ext4_find_extent(),
     683             :  * read_extent_tree_block(), ext4_split_extent_at(),
     684             :  * ext4_ext_insert_extent(), and ext4_ext_create_new_leaf().
     685             :  * EXT4_EX_NOCACHE is used to indicate that the we shouldn't be
     686             :  * caching the extents when reading from the extent tree while a
     687             :  * truncate or punch hole operation is in progress.
     688             :  */
     689             : #define EXT4_EX_NOCACHE                         0x40000000
     690             : #define EXT4_EX_FORCE_CACHE                     0x20000000
     691             : #define EXT4_EX_NOFAIL                          0x10000000
     692             : 
     693             : /*
     694             :  * Flags used by ext4_free_blocks
     695             :  */
     696             : #define EXT4_FREE_BLOCKS_METADATA               0x0001
     697             : #define EXT4_FREE_BLOCKS_FORGET                 0x0002
     698             : #define EXT4_FREE_BLOCKS_VALIDATED              0x0004
     699             : #define EXT4_FREE_BLOCKS_NO_QUOT_UPDATE         0x0008
     700             : #define EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER   0x0010
     701             : #define EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER    0x0020
     702             : #define EXT4_FREE_BLOCKS_RERESERVE_CLUSTER      0x0040
     703             : 
     704             : /*
     705             :  * ioctl commands
     706             :  */
     707             : #define EXT4_IOC_GETVERSION             _IOR('f', 3, long)
     708             : #define EXT4_IOC_SETVERSION             _IOW('f', 4, long)
     709             : #define EXT4_IOC_GETVERSION_OLD         FS_IOC_GETVERSION
     710             : #define EXT4_IOC_SETVERSION_OLD         FS_IOC_SETVERSION
     711             : #define EXT4_IOC_GETRSVSZ               _IOR('f', 5, long)
     712             : #define EXT4_IOC_SETRSVSZ               _IOW('f', 6, long)
     713             : #define EXT4_IOC_GROUP_EXTEND           _IOW('f', 7, unsigned long)
     714             : #define EXT4_IOC_GROUP_ADD              _IOW('f', 8, struct ext4_new_group_input)
     715             : #define EXT4_IOC_MIGRATE                _IO('f', 9)
     716             :  /* note ioctl 10 reserved for an early version of the FIEMAP ioctl */
     717             :  /* note ioctl 11 reserved for filesystem-independent FIEMAP ioctl */
     718             : #define EXT4_IOC_ALLOC_DA_BLKS          _IO('f', 12)
     719             : #define EXT4_IOC_MOVE_EXT               _IOWR('f', 15, struct move_extent)
     720             : #define EXT4_IOC_RESIZE_FS              _IOW('f', 16, __u64)
     721             : #define EXT4_IOC_SWAP_BOOT              _IO('f', 17)
     722             : #define EXT4_IOC_PRECACHE_EXTENTS       _IO('f', 18)
     723             : /* ioctl codes 19--39 are reserved for fscrypt */
     724             : #define EXT4_IOC_CLEAR_ES_CACHE         _IO('f', 40)
     725             : #define EXT4_IOC_GETSTATE               _IOW('f', 41, __u32)
     726             : #define EXT4_IOC_GET_ES_CACHE           _IOWR('f', 42, struct fiemap)
     727             : 
     728             : #define EXT4_IOC_SHUTDOWN _IOR ('X', 125, __u32)
     729             : 
     730             : /*
     731             :  * Flags for going down operation
     732             :  */
     733             : #define EXT4_GOING_FLAGS_DEFAULT                0x0     /* going down */
     734             : #define EXT4_GOING_FLAGS_LOGFLUSH               0x1     /* flush log but not data */
     735             : #define EXT4_GOING_FLAGS_NOLOGFLUSH             0x2     /* don't flush log nor data */
     736             : 
     737             : /*
     738             :  * Flags returned by EXT4_IOC_GETSTATE
     739             :  *
     740             :  * We only expose to userspace a subset of the state flags in
     741             :  * i_state_flags
     742             :  */
     743             : #define EXT4_STATE_FLAG_EXT_PRECACHED   0x00000001
     744             : #define EXT4_STATE_FLAG_NEW             0x00000002
     745             : #define EXT4_STATE_FLAG_NEWENTRY        0x00000004
     746             : #define EXT4_STATE_FLAG_DA_ALLOC_CLOSE  0x00000008
     747             : 
     748             : #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
     749             : /*
     750             :  * ioctl commands in 32 bit emulation
     751             :  */
     752             : #define EXT4_IOC32_GETVERSION           _IOR('f', 3, int)
     753             : #define EXT4_IOC32_SETVERSION           _IOW('f', 4, int)
     754             : #define EXT4_IOC32_GETRSVSZ             _IOR('f', 5, int)
     755             : #define EXT4_IOC32_SETRSVSZ             _IOW('f', 6, int)
     756             : #define EXT4_IOC32_GROUP_EXTEND         _IOW('f', 7, unsigned int)
     757             : #define EXT4_IOC32_GROUP_ADD            _IOW('f', 8, struct compat_ext4_new_group_input)
     758             : #define EXT4_IOC32_GETVERSION_OLD       FS_IOC32_GETVERSION
     759             : #define EXT4_IOC32_SETVERSION_OLD       FS_IOC32_SETVERSION
     760             : #endif
     761             : 
     762             : /*
     763             :  * Returned by EXT4_IOC_GET_ES_CACHE as an additional possible flag.
     764             :  * It indicates that the entry in extent status cache is for a hole.
     765             :  */
     766             : #define EXT4_FIEMAP_EXTENT_HOLE         0x08000000
     767             : 
     768             : /* Max physical block we can address w/o extents */
     769             : #define EXT4_MAX_BLOCK_FILE_PHYS        0xFFFFFFFF
     770             : 
     771             : /* Max logical block we can support */
     772             : #define EXT4_MAX_LOGICAL_BLOCK          0xFFFFFFFE
     773             : 
     774             : /*
     775             :  * Structure of an inode on the disk
     776             :  */
     777             : struct ext4_inode {
     778             :         __le16  i_mode;         /* File mode */
     779             :         __le16  i_uid;          /* Low 16 bits of Owner Uid */
     780             :         __le32  i_size_lo;      /* Size in bytes */
     781             :         __le32  i_atime;        /* Access time */
     782             :         __le32  i_ctime;        /* Inode Change time */
     783             :         __le32  i_mtime;        /* Modification time */
     784             :         __le32  i_dtime;        /* Deletion Time */
     785             :         __le16  i_gid;          /* Low 16 bits of Group Id */
     786             :         __le16  i_links_count;  /* Links count */
     787             :         __le32  i_blocks_lo;    /* Blocks count */
     788             :         __le32  i_flags;        /* File flags */
     789             :         union {
     790             :                 struct {
     791             :                         __le32  l_i_version;
     792             :                 } linux1;
     793             :                 struct {
     794             :                         __u32  h_i_translator;
     795             :                 } hurd1;
     796             :                 struct {
     797             :                         __u32  m_i_reserved1;
     798             :                 } masix1;
     799             :         } osd1;                         /* OS dependent 1 */
     800             :         __le32  i_block[EXT4_N_BLOCKS];/* Pointers to blocks */
     801             :         __le32  i_generation;   /* File version (for NFS) */
     802             :         __le32  i_file_acl_lo;  /* File ACL */
     803             :         __le32  i_size_high;
     804             :         __le32  i_obso_faddr;   /* Obsoleted fragment address */
     805             :         union {
     806             :                 struct {
     807             :                         __le16  l_i_blocks_high; /* were l_i_reserved1 */
     808             :                         __le16  l_i_file_acl_high;
     809             :                         __le16  l_i_uid_high;   /* these 2 fields */
     810             :                         __le16  l_i_gid_high;   /* were reserved2[0] */
     811             :                         __le16  l_i_checksum_lo;/* crc32c(uuid+inum+inode) LE */
     812             :                         __le16  l_i_reserved;
     813             :                 } linux2;
     814             :                 struct {
     815             :                         __le16  h_i_reserved1;  /* Obsoleted fragment number/size which are removed in ext4 */
     816             :                         __u16   h_i_mode_high;
     817             :                         __u16   h_i_uid_high;
     818             :                         __u16   h_i_gid_high;
     819             :                         __u32   h_i_author;
     820             :                 } hurd2;
     821             :                 struct {
     822             :                         __le16  h_i_reserved1;  /* Obsoleted fragment number/size which are removed in ext4 */
     823             :                         __le16  m_i_file_acl_high;
     824             :                         __u32   m_i_reserved2[2];
     825             :                 } masix2;
     826             :         } osd2;                         /* OS dependent 2 */
     827             :         __le16  i_extra_isize;
     828             :         __le16  i_checksum_hi;  /* crc32c(uuid+inum+inode) BE */
     829             :         __le32  i_ctime_extra;  /* extra Change time      (nsec << 2 | epoch) */
     830             :         __le32  i_mtime_extra;  /* extra Modification time(nsec << 2 | epoch) */
     831             :         __le32  i_atime_extra;  /* extra Access time      (nsec << 2 | epoch) */
     832             :         __le32  i_crtime;       /* File Creation time */
     833             :         __le32  i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
     834             :         __le32  i_version_hi;   /* high 32 bits for 64-bit version */
     835             :         __le32  i_projid;       /* Project ID */
     836             : };
     837             : 
     838             : struct move_extent {
     839             :         __u32 reserved;         /* should be zero */
     840             :         __u32 donor_fd;         /* donor file descriptor */
     841             :         __u64 orig_start;       /* logical start offset in block for orig */
     842             :         __u64 donor_start;      /* logical start offset in block for donor */
     843             :         __u64 len;              /* block length to be moved */
     844             :         __u64 moved_len;        /* moved block length */
     845             : };
     846             : 
     847             : #define EXT4_EPOCH_BITS 2
     848             : #define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
     849             : #define EXT4_NSEC_MASK  (~0UL << EXT4_EPOCH_BITS)
     850             : 
     851             : /*
     852             :  * Extended fields will fit into an inode if the filesystem was formatted
     853             :  * with large inodes (-I 256 or larger) and there are not currently any EAs
     854             :  * consuming all of the available space. For new inodes we always reserve
     855             :  * enough space for the kernel's known extended fields, but for inodes
     856             :  * created with an old kernel this might not have been the case. None of
     857             :  * the extended inode fields is critical for correct filesystem operation.
     858             :  * This macro checks if a certain field fits in the inode. Note that
     859             :  * inode-size = GOOD_OLD_INODE_SIZE + i_extra_isize
     860             :  */
     861             : #define EXT4_FITS_IN_INODE(ext4_inode, einode, field)   \
     862             :         ((offsetof(typeof(*ext4_inode), field) +        \
     863             :           sizeof((ext4_inode)->field))                       \
     864             :         <= (EXT4_GOOD_OLD_INODE_SIZE +                       \
     865             :             (einode)->i_extra_isize))                        \
     866             : 
     867             : /*
     868             :  * We use an encoding that preserves the times for extra epoch "00":
     869             :  *
     870             :  * extra  msb of                         adjust for signed
     871             :  * epoch  32-bit                         32-bit tv_sec to
     872             :  * bits   time    decoded 64-bit tv_sec  64-bit tv_sec      valid time range
     873             :  * 0 0    1    -0x80000000..-0x00000001  0x000000000 1901-12-13..1969-12-31
     874             :  * 0 0    0    0x000000000..0x07fffffff  0x000000000 1970-01-01..2038-01-19
     875             :  * 0 1    1    0x080000000..0x0ffffffff  0x100000000 2038-01-19..2106-02-07
     876             :  * 0 1    0    0x100000000..0x17fffffff  0x100000000 2106-02-07..2174-02-25
     877             :  * 1 0    1    0x180000000..0x1ffffffff  0x200000000 2174-02-25..2242-03-16
     878             :  * 1 0    0    0x200000000..0x27fffffff  0x200000000 2242-03-16..2310-04-04
     879             :  * 1 1    1    0x280000000..0x2ffffffff  0x300000000 2310-04-04..2378-04-22
     880             :  * 1 1    0    0x300000000..0x37fffffff  0x300000000 2378-04-22..2446-05-10
     881             :  *
     882             :  * Note that previous versions of the kernel on 64-bit systems would
     883             :  * incorrectly use extra epoch bits 1,1 for dates between 1901 and
     884             :  * 1970.  e2fsck will correct this, assuming that it is run on the
     885             :  * affected filesystem before 2242.
     886             :  */
     887             : 
     888       41731 : static inline __le32 ext4_encode_extra_time(struct timespec64 *time)
     889             : {
     890       41731 :         u32 extra =((time->tv_sec - (s32)time->tv_sec) >> 32) & EXT4_EPOCH_MASK;
     891       41731 :         return cpu_to_le32(extra | (time->tv_nsec << EXT4_EPOCH_BITS));
     892             : }
     893             : 
     894       19740 : static inline void ext4_decode_extra_time(struct timespec64 *time,
     895             :                                           __le32 extra)
     896             : {
     897       19740 :         if (unlikely(extra & cpu_to_le32(EXT4_EPOCH_MASK)))
     898           0 :                 time->tv_sec += (u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK) << 32;
     899       19740 :         time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
     900       19740 : }
     901             : 
     902             : #define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)                           \
     903             : do {                                                                            \
     904             :         if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     {\
     905             :                 (raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);  \
     906             :                 (raw_inode)->xtime ## _extra =                                       \
     907             :                                 ext4_encode_extra_time(&(inode)->xtime); \
     908             :                 }                                                               \
     909             :         else    \
     910             :                 (raw_inode)->xtime = cpu_to_le32(clamp_t(int32_t, (inode)->xtime.tv_sec, S32_MIN, S32_MAX));      \
     911             : } while (0)
     912             : 
     913             : #define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode)                        \
     914             : do {                                                                           \
     915             :         if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                      \
     916             :                 (raw_inode)->xtime = cpu_to_le32((einode)->xtime.tv_sec);      \
     917             :         if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))            \
     918             :                 (raw_inode)->xtime ## _extra =                                      \
     919             :                                 ext4_encode_extra_time(&(einode)->xtime);      \
     920             : } while (0)
     921             : 
     922             : #define EXT4_INODE_GET_XTIME(xtime, inode, raw_inode)                           \
     923             : do {                                                                            \
     924             :         (inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);  \
     925             :         if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra)) {    \
     926             :                 ext4_decode_extra_time(&(inode)->xtime,                          \
     927             :                                        raw_inode->xtime ## _extra);          \
     928             :                 }                                                               \
     929             :         else                                                                    \
     930             :                 (inode)->xtime.tv_nsec = 0;                                  \
     931             : } while (0)
     932             : 
     933             : 
     934             : #define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode)                        \
     935             : do {                                                                           \
     936             :         if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                      \
     937             :                 (einode)->xtime.tv_sec =                                    \
     938             :                         (signed)le32_to_cpu((raw_inode)->xtime);            \
     939             :         else                                                                   \
     940             :                 (einode)->xtime.tv_sec = 0;                                 \
     941             :         if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))            \
     942             :                 ext4_decode_extra_time(&(einode)->xtime,                \
     943             :                                        raw_inode->xtime ## _extra);         \
     944             :         else                                                                   \
     945             :                 (einode)->xtime.tv_nsec = 0;                                \
     946             : } while (0)
     947             : 
     948             : #define i_disk_version osd1.linux1.l_i_version
     949             : 
     950             : #if defined(__KERNEL__) || defined(__linux__)
     951             : #define i_reserved1     osd1.linux1.l_i_reserved1
     952             : #define i_file_acl_high osd2.linux2.l_i_file_acl_high
     953             : #define i_blocks_high   osd2.linux2.l_i_blocks_high
     954             : #define i_uid_low       i_uid
     955             : #define i_gid_low       i_gid
     956             : #define i_uid_high      osd2.linux2.l_i_uid_high
     957             : #define i_gid_high      osd2.linux2.l_i_gid_high
     958             : #define i_checksum_lo   osd2.linux2.l_i_checksum_lo
     959             : 
     960             : #elif defined(__GNU__)
     961             : 
     962             : #define i_translator    osd1.hurd1.h_i_translator
     963             : #define i_uid_high      osd2.hurd2.h_i_uid_high
     964             : #define i_gid_high      osd2.hurd2.h_i_gid_high
     965             : #define i_author        osd2.hurd2.h_i_author
     966             : 
     967             : #elif defined(__masix__)
     968             : 
     969             : #define i_reserved1     osd1.masix1.m_i_reserved1
     970             : #define i_file_acl_high osd2.masix2.m_i_file_acl_high
     971             : #define i_reserved2     osd2.masix2.m_i_reserved2
     972             : 
     973             : #endif /* defined(__KERNEL__) || defined(__linux__) */
     974             : 
     975             : #include "extents_status.h"
     976             : #include "fast_commit.h"
     977             : 
     978             : /*
     979             :  * Lock subclasses for i_data_sem in the ext4_inode_info structure.
     980             :  *
     981             :  * These are needed to avoid lockdep false positives when we need to
     982             :  * allocate blocks to the quota inode during ext4_map_blocks(), while
     983             :  * holding i_data_sem for a normal (non-quota) inode.  Since we don't
     984             :  * do quota tracking for the quota inode, this avoids deadlock (as
     985             :  * well as infinite recursion, since it isn't turtles all the way
     986             :  * down...)
     987             :  *
     988             :  *  I_DATA_SEM_NORMAL - Used for most inodes
     989             :  *  I_DATA_SEM_OTHER  - Used by move_inode.c for the second normal inode
     990             :  *                        where the second inode has larger inode number
     991             :  *                        than the first
     992             :  *  I_DATA_SEM_QUOTA  - Used for quota inodes only
     993             :  */
     994             : enum {
     995             :         I_DATA_SEM_NORMAL = 0,
     996             :         I_DATA_SEM_OTHER,
     997             :         I_DATA_SEM_QUOTA,
     998             : };
     999             : 
    1000             : 
    1001             : /*
    1002             :  * fourth extended file system inode data in memory
    1003             :  */
    1004             : struct ext4_inode_info {
    1005             :         __le32  i_data[15];     /* unconverted */
    1006             :         __u32   i_dtime;
    1007             :         ext4_fsblk_t    i_file_acl;
    1008             : 
    1009             :         /*
    1010             :          * i_block_group is the number of the block group which contains
    1011             :          * this file's inode.  Constant across the lifetime of the inode,
    1012             :          * it is used for making block allocation decisions - we try to
    1013             :          * place a file's data blocks near its inode block, and new inodes
    1014             :          * near to their parent directory's inode.
    1015             :          */
    1016             :         ext4_group_t    i_block_group;
    1017             :         ext4_lblk_t     i_dir_start_lookup;
    1018             : #if (BITS_PER_LONG < 64)
    1019             :         unsigned long   i_state_flags;          /* Dynamic state flags */
    1020             : #endif
    1021             :         unsigned long   i_flags;
    1022             : 
    1023             :         /*
    1024             :          * Extended attributes can be read independently of the main file
    1025             :          * data. Taking i_mutex even when reading would cause contention
    1026             :          * between readers of EAs and writers of regular file data, so
    1027             :          * instead we synchronize on xattr_sem when reading or changing
    1028             :          * EAs.
    1029             :          */
    1030             :         struct rw_semaphore xattr_sem;
    1031             : 
    1032             :         struct list_head i_orphan;      /* unlinked but open inodes */
    1033             : 
    1034             :         /* Fast commit related info */
    1035             : 
    1036             :         struct list_head i_fc_list;     /*
    1037             :                                          * inodes that need fast commit
    1038             :                                          * protected by sbi->s_fc_lock.
    1039             :                                          */
    1040             : 
    1041             :         /* Start of lblk range that needs to be committed in this fast commit */
    1042             :         ext4_lblk_t i_fc_lblk_start;
    1043             : 
    1044             :         /* End of lblk range that needs to be committed in this fast commit */
    1045             :         ext4_lblk_t i_fc_lblk_len;
    1046             : 
    1047             :         /* Number of ongoing updates on this inode */
    1048             :         atomic_t  i_fc_updates;
    1049             : 
    1050             :         /* Fast commit wait queue for this inode */
    1051             :         wait_queue_head_t i_fc_wait;
    1052             : 
    1053             :         /* Protect concurrent accesses on i_fc_lblk_start, i_fc_lblk_len */
    1054             :         struct mutex i_fc_lock;
    1055             : 
    1056             :         /*
    1057             :          * i_disksize keeps track of what the inode size is ON DISK, not
    1058             :          * in memory.  During truncate, i_size is set to the new size by
    1059             :          * the VFS prior to calling ext4_truncate(), but the filesystem won't
    1060             :          * set i_disksize to 0 until the truncate is actually under way.
    1061             :          *
    1062             :          * The intent is that i_disksize always represents the blocks which
    1063             :          * are used by this file.  This allows recovery to restart truncate
    1064             :          * on orphans if we crash during truncate.  We actually write i_disksize
    1065             :          * into the on-disk inode when writing inodes out, instead of i_size.
    1066             :          *
    1067             :          * The only time when i_disksize and i_size may be different is when
    1068             :          * a truncate is in progress.  The only things which change i_disksize
    1069             :          * are ext4_get_block (growth) and ext4_truncate (shrinkth).
    1070             :          */
    1071             :         loff_t  i_disksize;
    1072             : 
    1073             :         /*
    1074             :          * i_data_sem is for serialising ext4_truncate() against
    1075             :          * ext4_getblock().  In the 2.4 ext2 design, great chunks of inode's
    1076             :          * data tree are chopped off during truncate. We can't do that in
    1077             :          * ext4 because whenever we perform intermediate commits during
    1078             :          * truncate, the inode and all the metadata blocks *must* be in a
    1079             :          * consistent state which allows truncation of the orphans to restart
    1080             :          * during recovery.  Hence we must fix the get_block-vs-truncate race
    1081             :          * by other means, so we have i_data_sem.
    1082             :          */
    1083             :         struct rw_semaphore i_data_sem;
    1084             :         /*
    1085             :          * i_mmap_sem is for serializing page faults with truncate / punch hole
    1086             :          * operations. We have to make sure that new page cannot be faulted in
    1087             :          * a section of the inode that is being punched. We cannot easily use
    1088             :          * i_data_sem for this since we need protection for the whole punch
    1089             :          * operation and i_data_sem ranks below transaction start so we have
    1090             :          * to occasionally drop it.
    1091             :          */
    1092             :         struct rw_semaphore i_mmap_sem;
    1093             :         struct inode vfs_inode;
    1094             :         struct jbd2_inode *jinode;
    1095             : 
    1096             :         spinlock_t i_raw_lock;  /* protects updates to the raw inode */
    1097             : 
    1098             :         /*
    1099             :          * File creation time. Its function is same as that of
    1100             :          * struct timespec64 i_{a,c,m}time in the generic inode.
    1101             :          */
    1102             :         struct timespec64 i_crtime;
    1103             : 
    1104             :         /* mballoc */
    1105             :         atomic_t i_prealloc_active;
    1106             :         struct list_head i_prealloc_list;
    1107             :         spinlock_t i_prealloc_lock;
    1108             : 
    1109             :         /* extents status tree */
    1110             :         struct ext4_es_tree i_es_tree;
    1111             :         rwlock_t i_es_lock;
    1112             :         struct list_head i_es_list;
    1113             :         unsigned int i_es_all_nr;       /* protected by i_es_lock */
    1114             :         unsigned int i_es_shk_nr;       /* protected by i_es_lock */
    1115             :         ext4_lblk_t i_es_shrink_lblk;   /* Offset where we start searching for
    1116             :                                            extents to shrink. Protected by
    1117             :                                            i_es_lock  */
    1118             : 
    1119             :         /* ialloc */
    1120             :         ext4_group_t    i_last_alloc_group;
    1121             : 
    1122             :         /* allocation reservation info for delalloc */
    1123             :         /* In case of bigalloc, this refer to clusters rather than blocks */
    1124             :         unsigned int i_reserved_data_blocks;
    1125             : 
    1126             :         /* pending cluster reservations for bigalloc file systems */
    1127             :         struct ext4_pending_tree i_pending_tree;
    1128             : 
    1129             :         /* on-disk additional length */
    1130             :         __u16 i_extra_isize;
    1131             : 
    1132             :         /* Indicate the inline data space. */
    1133             :         u16 i_inline_off;
    1134             :         u16 i_inline_size;
    1135             : 
    1136             : #ifdef CONFIG_QUOTA
    1137             :         /* quota space reservation, managed internally by quota code */
    1138             :         qsize_t i_reserved_quota;
    1139             : #endif
    1140             : 
    1141             :         /* Lock protecting lists below */
    1142             :         spinlock_t i_completed_io_lock;
    1143             :         /*
    1144             :          * Completed IOs that need unwritten extents handling and have
    1145             :          * transaction reserved
    1146             :          */
    1147             :         struct list_head i_rsv_conversion_list;
    1148             :         struct work_struct i_rsv_conversion_work;
    1149             :         atomic_t i_unwritten; /* Nr. of inflight conversions pending */
    1150             : 
    1151             :         spinlock_t i_block_reservation_lock;
    1152             : 
    1153             :         /*
    1154             :          * Transactions that contain inode's metadata needed to complete
    1155             :          * fsync and fdatasync, respectively.
    1156             :          */
    1157             :         tid_t i_sync_tid;
    1158             :         tid_t i_datasync_tid;
    1159             : 
    1160             : #ifdef CONFIG_QUOTA
    1161             :         struct dquot *i_dquot[MAXQUOTAS];
    1162             : #endif
    1163             : 
    1164             :         /* Precomputed uuid+inum+igen checksum for seeding inode checksums */
    1165             :         __u32 i_csum_seed;
    1166             : 
    1167             :         kprojid_t i_projid;
    1168             : };
    1169             : 
    1170             : /*
    1171             :  * File system states
    1172             :  */
    1173             : #define EXT4_VALID_FS                   0x0001  /* Unmounted cleanly */
    1174             : #define EXT4_ERROR_FS                   0x0002  /* Errors detected */
    1175             : #define EXT4_ORPHAN_FS                  0x0004  /* Orphans being recovered */
    1176             : #define EXT4_FC_REPLAY                  0x0020  /* Fast commit replay ongoing */
    1177             : 
    1178             : /*
    1179             :  * Misc. filesystem flags
    1180             :  */
    1181             : #define EXT2_FLAGS_SIGNED_HASH          0x0001  /* Signed dirhash in use */
    1182             : #define EXT2_FLAGS_UNSIGNED_HASH        0x0002  /* Unsigned dirhash in use */
    1183             : #define EXT2_FLAGS_TEST_FILESYS         0x0004  /* to test development code */
    1184             : 
    1185             : /*
    1186             :  * Mount flags set via mount options or defaults
    1187             :  */
    1188             : #define EXT4_MOUNT_NO_MBCACHE           0x00001 /* Do not use mbcache */
    1189             : #define EXT4_MOUNT_GRPID                0x00004 /* Create files with directory's group */
    1190             : #define EXT4_MOUNT_DEBUG                0x00008 /* Some debugging messages */
    1191             : #define EXT4_MOUNT_ERRORS_CONT          0x00010 /* Continue on errors */
    1192             : #define EXT4_MOUNT_ERRORS_RO            0x00020 /* Remount fs ro on errors */
    1193             : #define EXT4_MOUNT_ERRORS_PANIC         0x00040 /* Panic on errors */
    1194             : #define EXT4_MOUNT_ERRORS_MASK          0x00070
    1195             : #define EXT4_MOUNT_MINIX_DF             0x00080 /* Mimics the Minix statfs */
    1196             : #define EXT4_MOUNT_NOLOAD               0x00100 /* Don't use existing journal*/
    1197             : #ifdef CONFIG_FS_DAX
    1198             : #define EXT4_MOUNT_DAX_ALWAYS           0x00200 /* Direct Access */
    1199             : #else
    1200             : #define EXT4_MOUNT_DAX_ALWAYS           0
    1201             : #endif
    1202             : #define EXT4_MOUNT_DATA_FLAGS           0x00C00 /* Mode for data writes: */
    1203             : #define EXT4_MOUNT_JOURNAL_DATA         0x00400 /* Write data to journal */
    1204             : #define EXT4_MOUNT_ORDERED_DATA         0x00800 /* Flush data before commit */
    1205             : #define EXT4_MOUNT_WRITEBACK_DATA       0x00C00 /* No data ordering */
    1206             : #define EXT4_MOUNT_UPDATE_JOURNAL       0x01000 /* Update the journal format */
    1207             : #define EXT4_MOUNT_NO_UID32             0x02000  /* Disable 32-bit UIDs */
    1208             : #define EXT4_MOUNT_XATTR_USER           0x04000 /* Extended user attributes */
    1209             : #define EXT4_MOUNT_POSIX_ACL            0x08000 /* POSIX Access Control Lists */
    1210             : #define EXT4_MOUNT_NO_AUTO_DA_ALLOC     0x10000 /* No auto delalloc mapping */
    1211             : #define EXT4_MOUNT_BARRIER              0x20000 /* Use block barriers */
    1212             : #define EXT4_MOUNT_QUOTA                0x40000 /* Some quota option set */
    1213             : #define EXT4_MOUNT_USRQUOTA             0x80000 /* "old" user quota,
    1214             :                                                  * enable enforcement for hidden
    1215             :                                                  * quota files */
    1216             : #define EXT4_MOUNT_GRPQUOTA             0x100000 /* "old" group quota, enable
    1217             :                                                   * enforcement for hidden quota
    1218             :                                                   * files */
    1219             : #define EXT4_MOUNT_PRJQUOTA             0x200000 /* Enable project quota
    1220             :                                                   * enforcement */
    1221             : #define EXT4_MOUNT_DIOREAD_NOLOCK       0x400000 /* Enable support for dio read nolocking */
    1222             : #define EXT4_MOUNT_JOURNAL_CHECKSUM     0x800000 /* Journal checksums */
    1223             : #define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT 0x1000000 /* Journal Async Commit */
    1224             : #define EXT4_MOUNT_WARN_ON_ERROR        0x2000000 /* Trigger WARN_ON on error */
    1225             : #define EXT4_MOUNT_PREFETCH_BLOCK_BITMAPS 0x4000000
    1226             : #define EXT4_MOUNT_DELALLOC             0x8000000 /* Delalloc support */
    1227             : #define EXT4_MOUNT_DATA_ERR_ABORT       0x10000000 /* Abort on file data write */
    1228             : #define EXT4_MOUNT_BLOCK_VALIDITY       0x20000000 /* Block validity checking */
    1229             : #define EXT4_MOUNT_DISCARD              0x40000000 /* Issue DISCARD requests */
    1230             : #define EXT4_MOUNT_INIT_INODE_TABLE     0x80000000 /* Initialize uninitialized itables */
    1231             : 
    1232             : /*
    1233             :  * Mount flags set either automatically (could not be set by mount option)
    1234             :  * based on per file system feature or property or in special cases such as
    1235             :  * distinguishing between explicit mount option definition and default.
    1236             :  */
    1237             : #define EXT4_MOUNT2_EXPLICIT_DELALLOC   0x00000001 /* User explicitly
    1238             :                                                       specified delalloc */
    1239             : #define EXT4_MOUNT2_STD_GROUP_SIZE      0x00000002 /* We have standard group
    1240             :                                                       size of blocksize * 8
    1241             :                                                       blocks */
    1242             : #define EXT4_MOUNT2_HURD_COMPAT         0x00000004 /* Support HURD-castrated
    1243             :                                                       file systems */
    1244             : #define EXT4_MOUNT2_EXPLICIT_JOURNAL_CHECKSUM   0x00000008 /* User explicitly
    1245             :                                                 specified journal checksum */
    1246             : 
    1247             : #define EXT4_MOUNT2_JOURNAL_FAST_COMMIT 0x00000010 /* Journal fast commit */
    1248             : #define EXT4_MOUNT2_DAX_NEVER           0x00000020 /* Do not allow Direct Access */
    1249             : #define EXT4_MOUNT2_DAX_INODE           0x00000040 /* For printing options only */
    1250             : 
    1251             : 
    1252             : #define clear_opt(sb, opt)              EXT4_SB(sb)->s_mount_opt &= \
    1253             :                                                 ~EXT4_MOUNT_##opt
    1254             : #define set_opt(sb, opt)                EXT4_SB(sb)->s_mount_opt |= \
    1255             :                                                 EXT4_MOUNT_##opt
    1256             : #define test_opt(sb, opt)               (EXT4_SB(sb)->s_mount_opt & \
    1257             :                                          EXT4_MOUNT_##opt)
    1258             : 
    1259             : #define clear_opt2(sb, opt)             EXT4_SB(sb)->s_mount_opt2 &= \
    1260             :                                                 ~EXT4_MOUNT2_##opt
    1261             : #define set_opt2(sb, opt)               EXT4_SB(sb)->s_mount_opt2 |= \
    1262             :                                                 EXT4_MOUNT2_##opt
    1263             : #define test_opt2(sb, opt)              (EXT4_SB(sb)->s_mount_opt2 & \
    1264             :                                          EXT4_MOUNT2_##opt)
    1265             : 
    1266             : #define ext4_test_and_set_bit           __test_and_set_bit_le
    1267             : #define ext4_set_bit                    __set_bit_le
    1268             : #define ext4_set_bit_atomic             ext2_set_bit_atomic
    1269             : #define ext4_test_and_clear_bit         __test_and_clear_bit_le
    1270             : #define ext4_clear_bit                  __clear_bit_le
    1271             : #define ext4_clear_bit_atomic           ext2_clear_bit_atomic
    1272             : #define ext4_test_bit                   test_bit_le
    1273             : #define ext4_find_next_zero_bit         find_next_zero_bit_le
    1274             : #define ext4_find_next_bit              find_next_bit_le
    1275             : 
    1276             : extern void ext4_set_bits(void *bm, int cur, int len);
    1277             : 
    1278             : /*
    1279             :  * Maximal mount counts between two filesystem checks
    1280             :  */
    1281             : #define EXT4_DFL_MAX_MNT_COUNT          20      /* Allow 20 mounts */
    1282             : #define EXT4_DFL_CHECKINTERVAL          0       /* Don't use interval check */
    1283             : 
    1284             : /*
    1285             :  * Behaviour when detecting errors
    1286             :  */
    1287             : #define EXT4_ERRORS_CONTINUE            1       /* Continue execution */
    1288             : #define EXT4_ERRORS_RO                  2       /* Remount fs read-only */
    1289             : #define EXT4_ERRORS_PANIC               3       /* Panic */
    1290             : #define EXT4_ERRORS_DEFAULT             EXT4_ERRORS_CONTINUE
    1291             : 
    1292             : /* Metadata checksum algorithm codes */
    1293             : #define EXT4_CRC32C_CHKSUM              1
    1294             : 
    1295             : /*
    1296             :  * Structure of the super block
    1297             :  */
    1298             : struct ext4_super_block {
    1299             : /*00*/  __le32  s_inodes_count;         /* Inodes count */
    1300             :         __le32  s_blocks_count_lo;      /* Blocks count */
    1301             :         __le32  s_r_blocks_count_lo;    /* Reserved blocks count */
    1302             :         __le32  s_free_blocks_count_lo; /* Free blocks count */
    1303             : /*10*/  __le32  s_free_inodes_count;    /* Free inodes count */
    1304             :         __le32  s_first_data_block;     /* First Data Block */
    1305             :         __le32  s_log_block_size;       /* Block size */
    1306             :         __le32  s_log_cluster_size;     /* Allocation cluster size */
    1307             : /*20*/  __le32  s_blocks_per_group;     /* # Blocks per group */
    1308             :         __le32  s_clusters_per_group;   /* # Clusters per group */
    1309             :         __le32  s_inodes_per_group;     /* # Inodes per group */
    1310             :         __le32  s_mtime;                /* Mount time */
    1311             : /*30*/  __le32  s_wtime;                /* Write time */
    1312             :         __le16  s_mnt_count;            /* Mount count */
    1313             :         __le16  s_max_mnt_count;        /* Maximal mount count */
    1314             :         __le16  s_magic;                /* Magic signature */
    1315             :         __le16  s_state;                /* File system state */
    1316             :         __le16  s_errors;               /* Behaviour when detecting errors */
    1317             :         __le16  s_minor_rev_level;      /* minor revision level */
    1318             : /*40*/  __le32  s_lastcheck;            /* time of last check */
    1319             :         __le32  s_checkinterval;        /* max. time between checks */
    1320             :         __le32  s_creator_os;           /* OS */
    1321             :         __le32  s_rev_level;            /* Revision level */
    1322             : /*50*/  __le16  s_def_resuid;           /* Default uid for reserved blocks */
    1323             :         __le16  s_def_resgid;           /* Default gid for reserved blocks */
    1324             :         /*
    1325             :          * These fields are for EXT4_DYNAMIC_REV superblocks only.
    1326             :          *
    1327             :          * Note: the difference between the compatible feature set and
    1328             :          * the incompatible feature set is that if there is a bit set
    1329             :          * in the incompatible feature set that the kernel doesn't
    1330             :          * know about, it should refuse to mount the filesystem.
    1331             :          *
    1332             :          * e2fsck's requirements are more strict; if it doesn't know
    1333             :          * about a feature in either the compatible or incompatible
    1334             :          * feature set, it must abort and not try to meddle with
    1335             :          * things it doesn't understand...
    1336             :          */
    1337             :         __le32  s_first_ino;            /* First non-reserved inode */
    1338             :         __le16  s_inode_size;           /* size of inode structure */
    1339             :         __le16  s_block_group_nr;       /* block group # of this superblock */
    1340             :         __le32  s_feature_compat;       /* compatible feature set */
    1341             : /*60*/  __le32  s_feature_incompat;     /* incompatible feature set */
    1342             :         __le32  s_feature_ro_compat;    /* readonly-compatible feature set */
    1343             : /*68*/  __u8    s_uuid[16];             /* 128-bit uuid for volume */
    1344             : /*78*/  char    s_volume_name[16];      /* volume name */
    1345             : /*88*/  char    s_last_mounted[64] __nonstring; /* directory where last mounted */
    1346             : /*C8*/  __le32  s_algorithm_usage_bitmap; /* For compression */
    1347             :         /*
    1348             :          * Performance hints.  Directory preallocation should only
    1349             :          * happen if the EXT4_FEATURE_COMPAT_DIR_PREALLOC flag is on.
    1350             :          */
    1351             :         __u8    s_prealloc_blocks;      /* Nr of blocks to try to preallocate*/
    1352             :         __u8    s_prealloc_dir_blocks;  /* Nr to preallocate for dirs */
    1353             :         __le16  s_reserved_gdt_blocks;  /* Per group desc for online growth */
    1354             :         /*
    1355             :          * Journaling support valid if EXT4_FEATURE_COMPAT_HAS_JOURNAL set.
    1356             :          */
    1357             : /*D0*/  __u8    s_journal_uuid[16];     /* uuid of journal superblock */
    1358             : /*E0*/  __le32  s_journal_inum;         /* inode number of journal file */
    1359             :         __le32  s_journal_dev;          /* device number of journal file */
    1360             :         __le32  s_last_orphan;          /* start of list of inodes to delete */
    1361             :         __le32  s_hash_seed[4];         /* HTREE hash seed */
    1362             :         __u8    s_def_hash_version;     /* Default hash version to use */
    1363             :         __u8    s_jnl_backup_type;
    1364             :         __le16  s_desc_size;            /* size of group descriptor */
    1365             : /*100*/ __le32  s_default_mount_opts;
    1366             :         __le32  s_first_meta_bg;        /* First metablock block group */
    1367             :         __le32  s_mkfs_time;            /* When the filesystem was created */
    1368             :         __le32  s_jnl_blocks[17];       /* Backup of the journal inode */
    1369             :         /* 64bit support valid if EXT4_FEATURE_COMPAT_64BIT */
    1370             : /*150*/ __le32  s_blocks_count_hi;      /* Blocks count */
    1371             :         __le32  s_r_blocks_count_hi;    /* Reserved blocks count */
    1372             :         __le32  s_free_blocks_count_hi; /* Free blocks count */
    1373             :         __le16  s_min_extra_isize;      /* All inodes have at least # bytes */
    1374             :         __le16  s_want_extra_isize;     /* New inodes should reserve # bytes */
    1375             :         __le32  s_flags;                /* Miscellaneous flags */
    1376             :         __le16  s_raid_stride;          /* RAID stride */
    1377             :         __le16  s_mmp_update_interval;  /* # seconds to wait in MMP checking */
    1378             :         __le64  s_mmp_block;            /* Block for multi-mount protection */
    1379             :         __le32  s_raid_stripe_width;    /* blocks on all data disks (N*stride)*/
    1380             :         __u8    s_log_groups_per_flex;  /* FLEX_BG group size */
    1381             :         __u8    s_checksum_type;        /* metadata checksum algorithm used */
    1382             :         __u8    s_encryption_level;     /* versioning level for encryption */
    1383             :         __u8    s_reserved_pad;         /* Padding to next 32bits */
    1384             :         __le64  s_kbytes_written;       /* nr of lifetime kilobytes written */
    1385             :         __le32  s_snapshot_inum;        /* Inode number of active snapshot */
    1386             :         __le32  s_snapshot_id;          /* sequential ID of active snapshot */
    1387             :         __le64  s_snapshot_r_blocks_count; /* reserved blocks for active
    1388             :                                               snapshot's future use */
    1389             :         __le32  s_snapshot_list;        /* inode number of the head of the
    1390             :                                            on-disk snapshot list */
    1391             : #define EXT4_S_ERR_START offsetof(struct ext4_super_block, s_error_count)
    1392             :         __le32  s_error_count;          /* number of fs errors */
    1393             :         __le32  s_first_error_time;     /* first time an error happened */
    1394             :         __le32  s_first_error_ino;      /* inode involved in first error */
    1395             :         __le64  s_first_error_block;    /* block involved of first error */
    1396             :         __u8    s_first_error_func[32] __nonstring;     /* function where the error happened */
    1397             :         __le32  s_first_error_line;     /* line number where error happened */
    1398             :         __le32  s_last_error_time;      /* most recent time of an error */
    1399             :         __le32  s_last_error_ino;       /* inode involved in last error */
    1400             :         __le32  s_last_error_line;      /* line number where error happened */
    1401             :         __le64  s_last_error_block;     /* block involved of last error */
    1402             :         __u8    s_last_error_func[32] __nonstring;      /* function where the error happened */
    1403             : #define EXT4_S_ERR_END offsetof(struct ext4_super_block, s_mount_opts)
    1404             :         __u8    s_mount_opts[64];
    1405             :         __le32  s_usr_quota_inum;       /* inode for tracking user quota */
    1406             :         __le32  s_grp_quota_inum;       /* inode for tracking group quota */
    1407             :         __le32  s_overhead_clusters;    /* overhead blocks/clusters in fs */
    1408             :         __le32  s_backup_bgs[2];        /* groups with sparse_super2 SBs */
    1409             :         __u8    s_encrypt_algos[4];     /* Encryption algorithms in use  */
    1410             :         __u8    s_encrypt_pw_salt[16];  /* Salt used for string2key algorithm */
    1411             :         __le32  s_lpf_ino;              /* Location of the lost+found inode */
    1412             :         __le32  s_prj_quota_inum;       /* inode for tracking project quota */
    1413             :         __le32  s_checksum_seed;        /* crc32c(uuid) if csum_seed set */
    1414             :         __u8    s_wtime_hi;
    1415             :         __u8    s_mtime_hi;
    1416             :         __u8    s_mkfs_time_hi;
    1417             :         __u8    s_lastcheck_hi;
    1418             :         __u8    s_first_error_time_hi;
    1419             :         __u8    s_last_error_time_hi;
    1420             :         __u8    s_first_error_errcode;
    1421             :         __u8    s_last_error_errcode;
    1422             :         __le16  s_encoding;             /* Filename charset encoding */
    1423             :         __le16  s_encoding_flags;       /* Filename charset encoding flags */
    1424             :         __le32  s_reserved[95];         /* Padding to the end of the block */
    1425             :         __le32  s_checksum;             /* crc32c(superblock) */
    1426             : };
    1427             : 
    1428             : #define EXT4_S_ERR_LEN (EXT4_S_ERR_END - EXT4_S_ERR_START)
    1429             : 
    1430             : #ifdef __KERNEL__
    1431             : 
    1432             : #ifdef CONFIG_FS_ENCRYPTION
    1433             : #define DUMMY_ENCRYPTION_ENABLED(sbi) ((sbi)->s_dummy_enc_policy.policy != NULL)
    1434             : #else
    1435             : #define DUMMY_ENCRYPTION_ENABLED(sbi) (0)
    1436             : #endif
    1437             : 
    1438             : /* Number of quota types we support */
    1439             : #define EXT4_MAXQUOTAS 3
    1440             : 
    1441             : #define EXT4_ENC_UTF8_12_1      1
    1442             : 
    1443             : /*
    1444             :  * fourth extended-fs super-block data in memory
    1445             :  */
    1446             : struct ext4_sb_info {
    1447             :         unsigned long s_desc_size;      /* Size of a group descriptor in bytes */
    1448             :         unsigned long s_inodes_per_block;/* Number of inodes per block */
    1449             :         unsigned long s_blocks_per_group;/* Number of blocks in a group */
    1450             :         unsigned long s_clusters_per_group; /* Number of clusters in a group */
    1451             :         unsigned long s_inodes_per_group;/* Number of inodes in a group */
    1452             :         unsigned long s_itb_per_group;  /* Number of inode table blocks per group */
    1453             :         unsigned long s_gdb_count;      /* Number of group descriptor blocks */
    1454             :         unsigned long s_desc_per_block; /* Number of group descriptors per block */
    1455             :         ext4_group_t s_groups_count;    /* Number of groups in the fs */
    1456             :         ext4_group_t s_blockfile_groups;/* Groups acceptable for non-extent files */
    1457             :         unsigned long s_overhead;  /* # of fs overhead clusters */
    1458             :         unsigned int s_cluster_ratio;   /* Number of blocks per cluster */
    1459             :         unsigned int s_cluster_bits;    /* log2 of s_cluster_ratio */
    1460             :         loff_t s_bitmap_maxbytes;       /* max bytes for bitmap files */
    1461             :         struct buffer_head * s_sbh;     /* Buffer containing the super block */
    1462             :         struct ext4_super_block *s_es;  /* Pointer to the super block in the buffer */
    1463             :         struct buffer_head * __rcu *s_group_desc;
    1464             :         unsigned int s_mount_opt;
    1465             :         unsigned int s_mount_opt2;
    1466             :         unsigned long s_mount_flags;
    1467             :         unsigned int s_def_mount_opt;
    1468             :         ext4_fsblk_t s_sb_block;
    1469             :         atomic64_t s_resv_clusters;
    1470             :         kuid_t s_resuid;
    1471             :         kgid_t s_resgid;
    1472             :         unsigned short s_mount_state;
    1473             :         unsigned short s_pad;
    1474             :         int s_addr_per_block_bits;
    1475             :         int s_desc_per_block_bits;
    1476             :         int s_inode_size;
    1477             :         int s_first_ino;
    1478             :         unsigned int s_inode_readahead_blks;
    1479             :         unsigned int s_inode_goal;
    1480             :         u32 s_hash_seed[4];
    1481             :         int s_def_hash_version;
    1482             :         int s_hash_unsigned;    /* 3 if hash should be signed, 0 if not */
    1483             :         struct percpu_counter s_freeclusters_counter;
    1484             :         struct percpu_counter s_freeinodes_counter;
    1485             :         struct percpu_counter s_dirs_counter;
    1486             :         struct percpu_counter s_dirtyclusters_counter;
    1487             :         struct blockgroup_lock *s_blockgroup_lock;
    1488             :         struct proc_dir_entry *s_proc;
    1489             :         struct kobject s_kobj;
    1490             :         struct completion s_kobj_unregister;
    1491             :         struct super_block *s_sb;
    1492             : 
    1493             :         /* Journaling */
    1494             :         struct journal_s *s_journal;
    1495             :         struct list_head s_orphan;
    1496             :         struct mutex s_orphan_lock;
    1497             :         unsigned long s_ext4_flags;             /* Ext4 superblock flags */
    1498             :         unsigned long s_commit_interval;
    1499             :         u32 s_max_batch_time;
    1500             :         u32 s_min_batch_time;
    1501             :         struct block_device *s_journal_bdev;
    1502             : #ifdef CONFIG_QUOTA
    1503             :         /* Names of quota files with journalled quota */
    1504             :         char __rcu *s_qf_names[EXT4_MAXQUOTAS];
    1505             :         int s_jquota_fmt;                       /* Format of quota to use */
    1506             : #endif
    1507             :         unsigned int s_want_extra_isize; /* New inodes should reserve # bytes */
    1508             :         struct ext4_system_blocks __rcu *s_system_blks;
    1509             : 
    1510             : #ifdef EXTENTS_STATS
    1511             :         /* ext4 extents stats */
    1512             :         unsigned long s_ext_min;
    1513             :         unsigned long s_ext_max;
    1514             :         unsigned long s_depth_max;
    1515             :         spinlock_t s_ext_stats_lock;
    1516             :         unsigned long s_ext_blocks;
    1517             :         unsigned long s_ext_extents;
    1518             : #endif
    1519             : 
    1520             :         /* for buddy allocator */
    1521             :         struct ext4_group_info ** __rcu *s_group_info;
    1522             :         struct inode *s_buddy_cache;
    1523             :         spinlock_t s_md_lock;
    1524             :         unsigned short *s_mb_offsets;
    1525             :         unsigned int *s_mb_maxs;
    1526             :         unsigned int s_group_info_size;
    1527             :         unsigned int s_mb_free_pending;
    1528             :         struct list_head s_freed_data_list;     /* List of blocks to be freed
    1529             :                                                    after commit completed */
    1530             : 
    1531             :         /* tunables */
    1532             :         unsigned long s_stripe;
    1533             :         unsigned int s_mb_stream_request;
    1534             :         unsigned int s_mb_max_to_scan;
    1535             :         unsigned int s_mb_min_to_scan;
    1536             :         unsigned int s_mb_stats;
    1537             :         unsigned int s_mb_order2_reqs;
    1538             :         unsigned int s_mb_group_prealloc;
    1539             :         unsigned int s_mb_max_inode_prealloc;
    1540             :         unsigned int s_max_dir_size_kb;
    1541             :         /* where last allocation was done - for stream allocation */
    1542             :         unsigned long s_mb_last_group;
    1543             :         unsigned long s_mb_last_start;
    1544             :         unsigned int s_mb_prefetch;
    1545             :         unsigned int s_mb_prefetch_limit;
    1546             : 
    1547             :         /* stats for buddy allocator */
    1548             :         atomic_t s_bal_reqs;    /* number of reqs with len > 1 */
    1549             :         atomic_t s_bal_success; /* we found long enough chunks */
    1550             :         atomic_t s_bal_allocated;       /* in blocks */
    1551             :         atomic_t s_bal_ex_scanned;      /* total extents scanned */
    1552             :         atomic_t s_bal_goals;   /* goal hits */
    1553             :         atomic_t s_bal_breaks;  /* too long searches */
    1554             :         atomic_t s_bal_2orders; /* 2^order hits */
    1555             :         spinlock_t s_bal_lock;
    1556             :         unsigned long s_mb_buddies_generated;
    1557             :         unsigned long long s_mb_generation_time;
    1558             :         atomic_t s_mb_lost_chunks;
    1559             :         atomic_t s_mb_preallocated;
    1560             :         atomic_t s_mb_discarded;
    1561             :         atomic_t s_lock_busy;
    1562             : 
    1563             :         /* locality groups */
    1564             :         struct ext4_locality_group __percpu *s_locality_groups;
    1565             : 
    1566             :         /* for write statistics */
    1567             :         unsigned long s_sectors_written_start;
    1568             :         u64 s_kbytes_written;
    1569             : 
    1570             :         /* the size of zero-out chunk */
    1571             :         unsigned int s_extent_max_zeroout_kb;
    1572             : 
    1573             :         unsigned int s_log_groups_per_flex;
    1574             :         struct flex_groups * __rcu *s_flex_groups;
    1575             :         ext4_group_t s_flex_groups_allocated;
    1576             : 
    1577             :         /* workqueue for reserved extent conversions (buffered io) */
    1578             :         struct workqueue_struct *rsv_conversion_wq;
    1579             : 
    1580             :         /* timer for periodic error stats printing */
    1581             :         struct timer_list s_err_report;
    1582             : 
    1583             :         /* Lazy inode table initialization info */
    1584             :         struct ext4_li_request *s_li_request;
    1585             :         /* Wait multiplier for lazy initialization thread */
    1586             :         unsigned int s_li_wait_mult;
    1587             : 
    1588             :         /* Kernel thread for multiple mount protection */
    1589             :         struct task_struct *s_mmp_tsk;
    1590             : 
    1591             :         /* record the last minlen when FITRIM is called. */
    1592             :         atomic_t s_last_trim_minblks;
    1593             : 
    1594             :         /* Reference to checksum algorithm driver via cryptoapi */
    1595             :         struct crypto_shash *s_chksum_driver;
    1596             : 
    1597             :         /* Precomputed FS UUID checksum for seeding other checksums */
    1598             :         __u32 s_csum_seed;
    1599             : 
    1600             :         /* Reclaim extents from extent status tree */
    1601             :         struct shrinker s_es_shrinker;
    1602             :         struct list_head s_es_list;     /* List of inodes with reclaimable extents */
    1603             :         long s_es_nr_inode;
    1604             :         struct ext4_es_stats s_es_stats;
    1605             :         struct mb_cache *s_ea_block_cache;
    1606             :         struct mb_cache *s_ea_inode_cache;
    1607             :         spinlock_t s_es_lock ____cacheline_aligned_in_smp;
    1608             : 
    1609             :         /* Ratelimit ext4 messages. */
    1610             :         struct ratelimit_state s_err_ratelimit_state;
    1611             :         struct ratelimit_state s_warning_ratelimit_state;
    1612             :         struct ratelimit_state s_msg_ratelimit_state;
    1613             :         atomic_t s_warning_count;
    1614             :         atomic_t s_msg_count;
    1615             : 
    1616             :         /* Encryption policy for '-o test_dummy_encryption' */
    1617             :         struct fscrypt_dummy_policy s_dummy_enc_policy;
    1618             : 
    1619             :         /*
    1620             :          * Barrier between writepages ops and changing any inode's JOURNAL_DATA
    1621             :          * or EXTENTS flag.
    1622             :          */
    1623             :         struct percpu_rw_semaphore s_writepages_rwsem;
    1624             :         struct dax_device *s_daxdev;
    1625             : #ifdef CONFIG_EXT4_DEBUG
    1626             :         unsigned long s_simulate_fail;
    1627             : #endif
    1628             :         /* Record the errseq of the backing block device */
    1629             :         errseq_t s_bdev_wb_err;
    1630             :         spinlock_t s_bdev_wb_lock;
    1631             : 
    1632             :         /* Information about errors that happened during this mount */
    1633             :         spinlock_t s_error_lock;
    1634             :         int s_add_error_count;
    1635             :         int s_first_error_code;
    1636             :         __u32 s_first_error_line;
    1637             :         __u32 s_first_error_ino;
    1638             :         __u64 s_first_error_block;
    1639             :         const char *s_first_error_func;
    1640             :         time64_t s_first_error_time;
    1641             :         int s_last_error_code;
    1642             :         __u32 s_last_error_line;
    1643             :         __u32 s_last_error_ino;
    1644             :         __u64 s_last_error_block;
    1645             :         const char *s_last_error_func;
    1646             :         time64_t s_last_error_time;
    1647             :         /*
    1648             :          * If we are in a context where we cannot update error information in
    1649             :          * the on-disk superblock, we queue this work to do it.
    1650             :          */
    1651             :         struct work_struct s_error_work;
    1652             : 
    1653             :         /* Ext4 fast commit stuff */
    1654             :         atomic_t s_fc_subtid;
    1655             :         atomic_t s_fc_ineligible_updates;
    1656             :         /*
    1657             :          * After commit starts, the main queue gets locked, and the further
    1658             :          * updates get added in the staging queue.
    1659             :          */
    1660             : #define FC_Q_MAIN       0
    1661             : #define FC_Q_STAGING    1
    1662             :         struct list_head s_fc_q[2];     /* Inodes staged for fast commit
    1663             :                                          * that have data changes in them.
    1664             :                                          */
    1665             :         struct list_head s_fc_dentry_q[2];      /* directory entry updates */
    1666             :         unsigned int s_fc_bytes;
    1667             :         /*
    1668             :          * Main fast commit lock. This lock protects accesses to the
    1669             :          * following fields:
    1670             :          * ei->i_fc_list, s_fc_dentry_q, s_fc_q, s_fc_bytes, s_fc_bh.
    1671             :          */
    1672             :         spinlock_t s_fc_lock;
    1673             :         struct buffer_head *s_fc_bh;
    1674             :         struct ext4_fc_stats s_fc_stats;
    1675             :         u64 s_fc_avg_commit_time;
    1676             : #ifdef CONFIG_EXT4_DEBUG
    1677             :         int s_fc_debug_max_replay;
    1678             : #endif
    1679             :         struct ext4_fc_replay_state s_fc_replay_state;
    1680             : };
    1681             : 
    1682     1034259 : static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
    1683             : {
    1684      604529 :         return sb->s_fs_info;
    1685             : }
    1686      251991 : static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
    1687             : {
    1688      110544 :         return container_of(inode, struct ext4_inode_info, vfs_inode);
    1689             : }
    1690             : 
    1691        5017 : static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
    1692             : {
    1693        5017 :         return ino == EXT4_ROOT_INO ||
    1694        5017 :                 (ino >= EXT4_FIRST_INO(sb) &&
    1695        5017 :                  ino <= le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count));
    1696             : }
    1697             : 
    1698             : /*
    1699             :  * Returns: sbi->field[index]
    1700             :  * Used to access an array element from the following sbi fields which require
    1701             :  * rcu protection to avoid dereferencing an invalid pointer due to reassignment
    1702             :  * - s_group_desc
    1703             :  * - s_group_info
    1704             :  * - s_flex_group
    1705             :  */
    1706             : #define sbi_array_rcu_deref(sbi, field, index)                             \
    1707             : ({                                                                         \
    1708             :         typeof(*((sbi)->field)) _v;                                     \
    1709             :         rcu_read_lock();                                                   \
    1710             :         _v = ((typeof(_v)*)rcu_dereference((sbi)->field))[index];       \
    1711             :         rcu_read_unlock();                                                 \
    1712             :         _v;                                                                \
    1713             : })
    1714             : 
    1715             : /*
    1716             :  * run-time mount flags
    1717             :  */
    1718             : enum {
    1719             :         EXT4_MF_MNTDIR_SAMPLED,
    1720             :         EXT4_MF_FS_ABORTED,     /* Fatal error detected */
    1721             :         EXT4_MF_FC_INELIGIBLE,  /* Fast commit ineligible */
    1722             :         EXT4_MF_FC_COMMITTING   /* File system underoing a fast
    1723             :                                  * commit.
    1724             :                                  */
    1725             : };
    1726             : 
    1727           1 : static inline void ext4_set_mount_flag(struct super_block *sb, int bit)
    1728             : {
    1729           1 :         set_bit(bit, &EXT4_SB(sb)->s_mount_flags);
    1730             : }
    1731             : 
    1732           2 : static inline void ext4_clear_mount_flag(struct super_block *sb, int bit)
    1733             : {
    1734           1 :         clear_bit(bit, &EXT4_SB(sb)->s_mount_flags);
    1735             : }
    1736             : 
    1737       11499 : static inline int ext4_test_mount_flag(struct super_block *sb, int bit)
    1738             : {
    1739       11499 :         return test_bit(bit, &EXT4_SB(sb)->s_mount_flags);
    1740             : }
    1741             : 
    1742             : 
    1743             : /*
    1744             :  * Simulate_fail codes
    1745             :  */
    1746             : #define EXT4_SIM_BBITMAP_EIO    1
    1747             : #define EXT4_SIM_BBITMAP_CRC    2
    1748             : #define EXT4_SIM_IBITMAP_EIO    3
    1749             : #define EXT4_SIM_IBITMAP_CRC    4
    1750             : #define EXT4_SIM_INODE_EIO      5
    1751             : #define EXT4_SIM_INODE_CRC      6
    1752             : #define EXT4_SIM_DIRBLOCK_EIO   7
    1753             : #define EXT4_SIM_DIRBLOCK_CRC   8
    1754             : 
    1755       23384 : static inline bool ext4_simulate_fail(struct super_block *sb,
    1756             :                                      unsigned long code)
    1757             : {
    1758             : #ifdef CONFIG_EXT4_DEBUG
    1759             :         struct ext4_sb_info *sbi = EXT4_SB(sb);
    1760             : 
    1761             :         if (unlikely(sbi->s_simulate_fail == code)) {
    1762             :                 sbi->s_simulate_fail = 0;
    1763             :                 return true;
    1764             :         }
    1765             : #endif
    1766       23384 :         return false;
    1767             : }
    1768             : 
    1769          22 : static inline void ext4_simulate_fail_bh(struct super_block *sb,
    1770             :                                          struct buffer_head *bh,
    1771             :                                          unsigned long code)
    1772             : {
    1773          22 :         if (!IS_ERR(bh) && ext4_simulate_fail(sb, code))
    1774          22 :                 clear_buffer_uptodate(bh);
    1775             : }
    1776             : 
    1777             : /*
    1778             :  * Error number codes for s_{first,last}_error_errno
    1779             :  *
    1780             :  * Linux errno numbers are architecture specific, so we need to translate
    1781             :  * them into something which is architecture independent.   We don't define
    1782             :  * codes for all errno's; just the ones which are most likely to be the cause
    1783             :  * of an ext4_error() call.
    1784             :  */
    1785             : #define EXT4_ERR_UNKNOWN         1
    1786             : #define EXT4_ERR_EIO             2
    1787             : #define EXT4_ERR_ENOMEM          3
    1788             : #define EXT4_ERR_EFSBADCRC       4
    1789             : #define EXT4_ERR_EFSCORRUPTED    5
    1790             : #define EXT4_ERR_ENOSPC          6
    1791             : #define EXT4_ERR_ENOKEY          7
    1792             : #define EXT4_ERR_EROFS           8
    1793             : #define EXT4_ERR_EFBIG           9
    1794             : #define EXT4_ERR_EEXIST         10
    1795             : #define EXT4_ERR_ERANGE         11
    1796             : #define EXT4_ERR_EOVERFLOW      12
    1797             : #define EXT4_ERR_EBUSY          13
    1798             : #define EXT4_ERR_ENOTDIR        14
    1799             : #define EXT4_ERR_ENOTEMPTY      15
    1800             : #define EXT4_ERR_ESHUTDOWN      16
    1801             : #define EXT4_ERR_EFAULT         17
    1802             : 
    1803             : /*
    1804             :  * Inode dynamic state flags
    1805             :  */
    1806             : enum {
    1807             :         EXT4_STATE_JDATA,               /* journaled data exists */
    1808             :         EXT4_STATE_NEW,                 /* inode is newly created */
    1809             :         EXT4_STATE_XATTR,               /* has in-inode xattrs */
    1810             :         EXT4_STATE_NO_EXPAND,           /* No space for expansion */
    1811             :         EXT4_STATE_DA_ALLOC_CLOSE,      /* Alloc DA blks on close */
    1812             :         EXT4_STATE_EXT_MIGRATE,         /* Inode is migrating */
    1813             :         EXT4_STATE_NEWENTRY,            /* File just added to dir */
    1814             :         EXT4_STATE_MAY_INLINE_DATA,     /* may have in-inode data */
    1815             :         EXT4_STATE_EXT_PRECACHED,       /* extents have been precached */
    1816             :         EXT4_STATE_LUSTRE_EA_INODE,     /* Lustre-style ea_inode */
    1817             :         EXT4_STATE_VERITY_IN_PROGRESS,  /* building fs-verity Merkle tree */
    1818             :         EXT4_STATE_FC_COMMITTING,       /* Fast commit ongoing */
    1819             : };
    1820             : 
    1821             : #define EXT4_INODE_BIT_FNS(name, field, offset)                         \
    1822             : static inline int ext4_test_inode_##name(struct inode *inode, int bit)  \
    1823             : {                                                                       \
    1824             :         return test_bit(bit + (offset), &EXT4_I(inode)->i_##field);      \
    1825             : }                                                                       \
    1826             : static inline void ext4_set_inode_##name(struct inode *inode, int bit)  \
    1827             : {                                                                       \
    1828             :         set_bit(bit + (offset), &EXT4_I(inode)->i_##field);              \
    1829             : }                                                                       \
    1830             : static inline void ext4_clear_inode_##name(struct inode *inode, int bit) \
    1831             : {                                                                       \
    1832             :         clear_bit(bit + (offset), &EXT4_I(inode)->i_##field);            \
    1833             : }
    1834             : 
    1835             : /* Add these declarations here only so that these functions can be
    1836             :  * found by name.  Otherwise, they are very hard to locate. */
    1837             : static inline int ext4_test_inode_flag(struct inode *inode, int bit);
    1838             : static inline void ext4_set_inode_flag(struct inode *inode, int bit);
    1839             : static inline void ext4_clear_inode_flag(struct inode *inode, int bit);
    1840       98744 : EXT4_INODE_BIT_FNS(flag, flags, 0)
    1841             : 
    1842             : /* Add these declarations here only so that these functions can be
    1843             :  * found by name.  Otherwise, they are very hard to locate. */
    1844             : static inline int ext4_test_inode_state(struct inode *inode, int bit);
    1845             : static inline void ext4_set_inode_state(struct inode *inode, int bit);
    1846             : static inline void ext4_clear_inode_state(struct inode *inode, int bit);
    1847             : #if (BITS_PER_LONG < 64)
    1848             : EXT4_INODE_BIT_FNS(state, state_flags, 0)
    1849             : 
    1850             : static inline void ext4_clear_state_flags(struct ext4_inode_info *ei)
    1851             : {
    1852             :         (ei)->i_state_flags = 0;
    1853             : }
    1854             : #else
    1855       66536 : EXT4_INODE_BIT_FNS(state, flags, 32)
    1856             : 
    1857        5563 : static inline void ext4_clear_state_flags(struct ext4_inode_info *ei)
    1858             : {
    1859             :         /* We depend on the fact that callers will set i_flags */
    1860        5563 : }
    1861             : #endif
    1862             : #else
    1863             : /* Assume that user mode programs are passing in an ext4fs superblock, not
    1864             :  * a kernel struct super_block.  This will allow us to call the feature-test
    1865             :  * macros from user land. */
    1866             : #define EXT4_SB(sb)     (sb)
    1867             : #endif
    1868             : 
    1869        3383 : static inline bool ext4_verity_in_progress(struct inode *inode)
    1870             : {
    1871        3383 :         return IS_ENABLED(CONFIG_FS_VERITY) &&
    1872             :                ext4_test_inode_state(inode, EXT4_STATE_VERITY_IN_PROGRESS);
    1873             : }
    1874             : 
    1875             : #define NEXT_ORPHAN(inode) EXT4_I(inode)->i_dtime
    1876             : 
    1877             : /*
    1878             :  * Codes for operating systems
    1879             :  */
    1880             : #define EXT4_OS_LINUX           0
    1881             : #define EXT4_OS_HURD            1
    1882             : #define EXT4_OS_MASIX           2
    1883             : #define EXT4_OS_FREEBSD         3
    1884             : #define EXT4_OS_LITES           4
    1885             : 
    1886             : /*
    1887             :  * Revision levels
    1888             :  */
    1889             : #define EXT4_GOOD_OLD_REV       0       /* The good old (original) format */
    1890             : #define EXT4_DYNAMIC_REV        1       /* V2 format w/ dynamic inode sizes */
    1891             : 
    1892             : #define EXT4_MAX_SUPP_REV       EXT4_DYNAMIC_REV
    1893             : 
    1894             : #define EXT4_GOOD_OLD_INODE_SIZE 128
    1895             : 
    1896             : #define EXT4_EXTRA_TIMESTAMP_MAX        (((s64)1 << 34) - 1  + S32_MIN)
    1897             : #define EXT4_NON_EXTRA_TIMESTAMP_MAX    S32_MAX
    1898             : #define EXT4_TIMESTAMP_MIN              S32_MIN
    1899             : 
    1900             : /*
    1901             :  * Feature set definitions
    1902             :  */
    1903             : 
    1904             : #define EXT4_FEATURE_COMPAT_DIR_PREALLOC        0x0001
    1905             : #define EXT4_FEATURE_COMPAT_IMAGIC_INODES       0x0002
    1906             : #define EXT4_FEATURE_COMPAT_HAS_JOURNAL         0x0004
    1907             : #define EXT4_FEATURE_COMPAT_EXT_ATTR            0x0008
    1908             : #define EXT4_FEATURE_COMPAT_RESIZE_INODE        0x0010
    1909             : #define EXT4_FEATURE_COMPAT_DIR_INDEX           0x0020
    1910             : #define EXT4_FEATURE_COMPAT_SPARSE_SUPER2       0x0200
    1911             : /*
    1912             :  * The reason why "FAST_COMMIT" is a compat feature is that, FS becomes
    1913             :  * incompatible only if fast commit blocks are present in the FS. Since we
    1914             :  * clear the journal (and thus the fast commit blocks), we don't mark FS as
    1915             :  * incompatible. We also have a JBD2 incompat feature, which gets set when
    1916             :  * there are fast commit blocks present in the journal.
    1917             :  */
    1918             : #define EXT4_FEATURE_COMPAT_FAST_COMMIT         0x0400
    1919             : #define EXT4_FEATURE_COMPAT_STABLE_INODES       0x0800
    1920             : 
    1921             : #define EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER     0x0001
    1922             : #define EXT4_FEATURE_RO_COMPAT_LARGE_FILE       0x0002
    1923             : #define EXT4_FEATURE_RO_COMPAT_BTREE_DIR        0x0004
    1924             : #define EXT4_FEATURE_RO_COMPAT_HUGE_FILE        0x0008
    1925             : #define EXT4_FEATURE_RO_COMPAT_GDT_CSUM         0x0010
    1926             : #define EXT4_FEATURE_RO_COMPAT_DIR_NLINK        0x0020
    1927             : #define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE      0x0040
    1928             : #define EXT4_FEATURE_RO_COMPAT_QUOTA            0x0100
    1929             : #define EXT4_FEATURE_RO_COMPAT_BIGALLOC         0x0200
    1930             : /*
    1931             :  * METADATA_CSUM also enables group descriptor checksums (GDT_CSUM).  When
    1932             :  * METADATA_CSUM is set, group descriptor checksums use the same algorithm as
    1933             :  * all other data structures' checksums.  However, the METADATA_CSUM and
    1934             :  * GDT_CSUM bits are mutually exclusive.
    1935             :  */
    1936             : #define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM    0x0400
    1937             : #define EXT4_FEATURE_RO_COMPAT_READONLY         0x1000
    1938             : #define EXT4_FEATURE_RO_COMPAT_PROJECT          0x2000
    1939             : #define EXT4_FEATURE_RO_COMPAT_VERITY           0x8000
    1940             : 
    1941             : #define EXT4_FEATURE_INCOMPAT_COMPRESSION       0x0001
    1942             : #define EXT4_FEATURE_INCOMPAT_FILETYPE          0x0002
    1943             : #define EXT4_FEATURE_INCOMPAT_RECOVER           0x0004 /* Needs recovery */
    1944             : #define EXT4_FEATURE_INCOMPAT_JOURNAL_DEV       0x0008 /* Journal device */
    1945             : #define EXT4_FEATURE_INCOMPAT_META_BG           0x0010
    1946             : #define EXT4_FEATURE_INCOMPAT_EXTENTS           0x0040 /* extents support */
    1947             : #define EXT4_FEATURE_INCOMPAT_64BIT             0x0080
    1948             : #define EXT4_FEATURE_INCOMPAT_MMP               0x0100
    1949             : #define EXT4_FEATURE_INCOMPAT_FLEX_BG           0x0200
    1950             : #define EXT4_FEATURE_INCOMPAT_EA_INODE          0x0400 /* EA in inode */
    1951             : #define EXT4_FEATURE_INCOMPAT_DIRDATA           0x1000 /* data in dirent */
    1952             : #define EXT4_FEATURE_INCOMPAT_CSUM_SEED         0x2000
    1953             : #define EXT4_FEATURE_INCOMPAT_LARGEDIR          0x4000 /* >2GB or 3-lvl htree */
    1954             : #define EXT4_FEATURE_INCOMPAT_INLINE_DATA       0x8000 /* data in inode */
    1955             : #define EXT4_FEATURE_INCOMPAT_ENCRYPT           0x10000
    1956             : #define EXT4_FEATURE_INCOMPAT_CASEFOLD          0x20000
    1957             : 
    1958             : extern void ext4_update_dynamic_rev(struct super_block *sb);
    1959             : 
    1960             : #define EXT4_FEATURE_COMPAT_FUNCS(name, flagname) \
    1961             : static inline bool ext4_has_feature_##name(struct super_block *sb) \
    1962             : { \
    1963             :         return ((EXT4_SB(sb)->s_es->s_feature_compat & \
    1964             :                 cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname)) != 0); \
    1965             : } \
    1966             : static inline void ext4_set_feature_##name(struct super_block *sb) \
    1967             : { \
    1968             :         ext4_update_dynamic_rev(sb); \
    1969             :         EXT4_SB(sb)->s_es->s_feature_compat |= \
    1970             :                 cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname); \
    1971             : } \
    1972             : static inline void ext4_clear_feature_##name(struct super_block *sb) \
    1973             : { \
    1974             :         EXT4_SB(sb)->s_es->s_feature_compat &= \
    1975             :                 ~cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname); \
    1976             : }
    1977             : 
    1978             : #define EXT4_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
    1979             : static inline bool ext4_has_feature_##name(struct super_block *sb) \
    1980             : { \
    1981             :         return ((EXT4_SB(sb)->s_es->s_feature_ro_compat & \
    1982             :                 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname)) != 0); \
    1983             : } \
    1984             : static inline void ext4_set_feature_##name(struct super_block *sb) \
    1985             : { \
    1986             :         ext4_update_dynamic_rev(sb); \
    1987             :         EXT4_SB(sb)->s_es->s_feature_ro_compat |= \
    1988             :                 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname); \
    1989             : } \
    1990             : static inline void ext4_clear_feature_##name(struct super_block *sb) \
    1991             : { \
    1992             :         EXT4_SB(sb)->s_es->s_feature_ro_compat &= \
    1993             :                 ~cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname); \
    1994             : }
    1995             : 
    1996             : #define EXT4_FEATURE_INCOMPAT_FUNCS(name, flagname) \
    1997             : static inline bool ext4_has_feature_##name(struct super_block *sb) \
    1998             : { \
    1999             :         return ((EXT4_SB(sb)->s_es->s_feature_incompat & \
    2000             :                 cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname)) != 0); \
    2001             : } \
    2002             : static inline void ext4_set_feature_##name(struct super_block *sb) \
    2003             : { \
    2004             :         ext4_update_dynamic_rev(sb); \
    2005             :         EXT4_SB(sb)->s_es->s_feature_incompat |= \
    2006             :                 cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname); \
    2007             : } \
    2008             : static inline void ext4_clear_feature_##name(struct super_block *sb) \
    2009             : { \
    2010             :         EXT4_SB(sb)->s_es->s_feature_incompat &= \
    2011             :                 ~cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname); \
    2012             : }
    2013             : 
    2014             : EXT4_FEATURE_COMPAT_FUNCS(dir_prealloc,         DIR_PREALLOC)
    2015             : EXT4_FEATURE_COMPAT_FUNCS(imagic_inodes,        IMAGIC_INODES)
    2016       16103 : EXT4_FEATURE_COMPAT_FUNCS(journal,              HAS_JOURNAL)
    2017           0 : EXT4_FEATURE_COMPAT_FUNCS(xattr,                EXT_ATTR)
    2018           0 : EXT4_FEATURE_COMPAT_FUNCS(resize_inode,         RESIZE_INODE)
    2019       33614 : EXT4_FEATURE_COMPAT_FUNCS(dir_index,            DIR_INDEX)
    2020          50 : EXT4_FEATURE_COMPAT_FUNCS(sparse_super2,        SPARSE_SUPER2)
    2021           2 : EXT4_FEATURE_COMPAT_FUNCS(fast_commit,          FAST_COMMIT)
    2022             : EXT4_FEATURE_COMPAT_FUNCS(stable_inodes,        STABLE_INODES)
    2023             : 
    2024          46 : EXT4_FEATURE_RO_COMPAT_FUNCS(sparse_super,      SPARSE_SUPER)
    2025        2203 : EXT4_FEATURE_RO_COMPAT_FUNCS(large_file,        LARGE_FILE)
    2026             : EXT4_FEATURE_RO_COMPAT_FUNCS(btree_dir,         BTREE_DIR)
    2027        4936 : EXT4_FEATURE_RO_COMPAT_FUNCS(huge_file,         HUGE_FILE)
    2028        3616 : EXT4_FEATURE_RO_COMPAT_FUNCS(gdt_csum,          GDT_CSUM)
    2029           0 : EXT4_FEATURE_RO_COMPAT_FUNCS(dir_nlink,         DIR_NLINK)
    2030           2 : EXT4_FEATURE_RO_COMPAT_FUNCS(extra_isize,       EXTRA_ISIZE)
    2031           1 : EXT4_FEATURE_RO_COMPAT_FUNCS(quota,             QUOTA)
    2032          18 : EXT4_FEATURE_RO_COMPAT_FUNCS(bigalloc,          BIGALLOC)
    2033       73946 : EXT4_FEATURE_RO_COMPAT_FUNCS(metadata_csum,     METADATA_CSUM)
    2034           2 : EXT4_FEATURE_RO_COMPAT_FUNCS(readonly,          READONLY)
    2035       15997 : EXT4_FEATURE_RO_COMPAT_FUNCS(project,           PROJECT)
    2036           1 : EXT4_FEATURE_RO_COMPAT_FUNCS(verity,            VERITY)
    2037             : 
    2038             : EXT4_FEATURE_INCOMPAT_FUNCS(compression,        COMPRESSION)
    2039        6804 : EXT4_FEATURE_INCOMPAT_FUNCS(filetype,           FILETYPE)
    2040           4 : EXT4_FEATURE_INCOMPAT_FUNCS(journal_needs_recovery,     RECOVER)
    2041             : EXT4_FEATURE_INCOMPAT_FUNCS(journal_dev,        JOURNAL_DEV)
    2042          39 : EXT4_FEATURE_INCOMPAT_FUNCS(meta_bg,            META_BG)
    2043        1724 : EXT4_FEATURE_INCOMPAT_FUNCS(extents,            EXTENTS)
    2044        6254 : EXT4_FEATURE_INCOMPAT_FUNCS(64bit,              64BIT)
    2045           2 : EXT4_FEATURE_INCOMPAT_FUNCS(mmp,                MMP)
    2046         232 : EXT4_FEATURE_INCOMPAT_FUNCS(flex_bg,            FLEX_BG)
    2047         840 : EXT4_FEATURE_INCOMPAT_FUNCS(ea_inode,           EA_INODE)
    2048             : EXT4_FEATURE_INCOMPAT_FUNCS(dirdata,            DIRDATA)
    2049           2 : EXT4_FEATURE_INCOMPAT_FUNCS(csum_seed,          CSUM_SEED)
    2050       18693 : EXT4_FEATURE_INCOMPAT_FUNCS(largedir,           LARGEDIR)
    2051         628 : EXT4_FEATURE_INCOMPAT_FUNCS(inline_data,        INLINE_DATA)
    2052           1 : EXT4_FEATURE_INCOMPAT_FUNCS(encrypt,            ENCRYPT)
    2053           3 : EXT4_FEATURE_INCOMPAT_FUNCS(casefold,           CASEFOLD)
    2054             : 
    2055             : #define EXT2_FEATURE_COMPAT_SUPP        EXT4_FEATURE_COMPAT_EXT_ATTR
    2056             : #define EXT2_FEATURE_INCOMPAT_SUPP      (EXT4_FEATURE_INCOMPAT_FILETYPE| \
    2057             :                                          EXT4_FEATURE_INCOMPAT_META_BG)
    2058             : #define EXT2_FEATURE_RO_COMPAT_SUPP     (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
    2059             :                                          EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
    2060             :                                          EXT4_FEATURE_RO_COMPAT_BTREE_DIR)
    2061             : 
    2062             : #define EXT3_FEATURE_COMPAT_SUPP        EXT4_FEATURE_COMPAT_EXT_ATTR
    2063             : #define EXT3_FEATURE_INCOMPAT_SUPP      (EXT4_FEATURE_INCOMPAT_FILETYPE| \
    2064             :                                          EXT4_FEATURE_INCOMPAT_RECOVER| \
    2065             :                                          EXT4_FEATURE_INCOMPAT_META_BG)
    2066             : #define EXT3_FEATURE_RO_COMPAT_SUPP     (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
    2067             :                                          EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
    2068             :                                          EXT4_FEATURE_RO_COMPAT_BTREE_DIR)
    2069             : 
    2070             : #define EXT4_FEATURE_COMPAT_SUPP        EXT4_FEATURE_COMPAT_EXT_ATTR
    2071             : #define EXT4_FEATURE_INCOMPAT_SUPP      (EXT4_FEATURE_INCOMPAT_FILETYPE| \
    2072             :                                          EXT4_FEATURE_INCOMPAT_RECOVER| \
    2073             :                                          EXT4_FEATURE_INCOMPAT_META_BG| \
    2074             :                                          EXT4_FEATURE_INCOMPAT_EXTENTS| \
    2075             :                                          EXT4_FEATURE_INCOMPAT_64BIT| \
    2076             :                                          EXT4_FEATURE_INCOMPAT_FLEX_BG| \
    2077             :                                          EXT4_FEATURE_INCOMPAT_EA_INODE| \
    2078             :                                          EXT4_FEATURE_INCOMPAT_MMP | \
    2079             :                                          EXT4_FEATURE_INCOMPAT_INLINE_DATA | \
    2080             :                                          EXT4_FEATURE_INCOMPAT_ENCRYPT | \
    2081             :                                          EXT4_FEATURE_INCOMPAT_CASEFOLD | \
    2082             :                                          EXT4_FEATURE_INCOMPAT_CSUM_SEED | \
    2083             :                                          EXT4_FEATURE_INCOMPAT_LARGEDIR)
    2084             : #define EXT4_FEATURE_RO_COMPAT_SUPP     (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
    2085             :                                          EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
    2086             :                                          EXT4_FEATURE_RO_COMPAT_GDT_CSUM| \
    2087             :                                          EXT4_FEATURE_RO_COMPAT_DIR_NLINK | \
    2088             :                                          EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE | \
    2089             :                                          EXT4_FEATURE_RO_COMPAT_BTREE_DIR |\
    2090             :                                          EXT4_FEATURE_RO_COMPAT_HUGE_FILE |\
    2091             :                                          EXT4_FEATURE_RO_COMPAT_BIGALLOC |\
    2092             :                                          EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|\
    2093             :                                          EXT4_FEATURE_RO_COMPAT_QUOTA |\
    2094             :                                          EXT4_FEATURE_RO_COMPAT_PROJECT |\
    2095             :                                          EXT4_FEATURE_RO_COMPAT_VERITY)
    2096             : 
    2097             : #define EXTN_FEATURE_FUNCS(ver) \
    2098             : static inline bool ext4_has_unknown_ext##ver##_compat_features(struct super_block *sb) \
    2099             : { \
    2100             :         return ((EXT4_SB(sb)->s_es->s_feature_compat & \
    2101             :                 cpu_to_le32(~EXT##ver##_FEATURE_COMPAT_SUPP)) != 0); \
    2102             : } \
    2103             : static inline bool ext4_has_unknown_ext##ver##_ro_compat_features(struct super_block *sb) \
    2104             : { \
    2105             :         return ((EXT4_SB(sb)->s_es->s_feature_ro_compat & \
    2106             :                 cpu_to_le32(~EXT##ver##_FEATURE_RO_COMPAT_SUPP)) != 0); \
    2107             : } \
    2108             : static inline bool ext4_has_unknown_ext##ver##_incompat_features(struct super_block *sb) \
    2109             : { \
    2110             :         return ((EXT4_SB(sb)->s_es->s_feature_incompat & \
    2111             :                 cpu_to_le32(~EXT##ver##_FEATURE_INCOMPAT_SUPP)) != 0); \
    2112             : }
    2113             : 
    2114             : EXTN_FEATURE_FUNCS(2)
    2115           1 : EXTN_FEATURE_FUNCS(3)
    2116           4 : EXTN_FEATURE_FUNCS(4)
    2117             : 
    2118           0 : static inline bool ext4_has_compat_features(struct super_block *sb)
    2119             : {
    2120           0 :         return (EXT4_SB(sb)->s_es->s_feature_compat != 0);
    2121             : }
    2122           0 : static inline bool ext4_has_ro_compat_features(struct super_block *sb)
    2123             : {
    2124           0 :         return (EXT4_SB(sb)->s_es->s_feature_ro_compat != 0);
    2125             : }
    2126           0 : static inline bool ext4_has_incompat_features(struct super_block *sb)
    2127             : {
    2128           0 :         return (EXT4_SB(sb)->s_es->s_feature_incompat != 0);
    2129             : }
    2130             : 
    2131             : /*
    2132             :  * Superblock flags
    2133             :  */
    2134             : #define EXT4_FLAGS_RESIZING     0
    2135             : #define EXT4_FLAGS_SHUTDOWN     1
    2136             : #define EXT4_FLAGS_BDEV_IS_DAX  2
    2137             : 
    2138       90725 : static inline int ext4_forced_shutdown(struct ext4_sb_info *sbi)
    2139             : {
    2140       90725 :         return test_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
    2141             : }
    2142             : 
    2143             : 
    2144             : /*
    2145             :  * Default values for user and/or group using reserved blocks
    2146             :  */
    2147             : #define EXT4_DEF_RESUID         0
    2148             : #define EXT4_DEF_RESGID         0
    2149             : 
    2150             : /*
    2151             :  * Default project ID
    2152             :  */
    2153             : #define EXT4_DEF_PROJID         0
    2154             : 
    2155             : #define EXT4_DEF_INODE_READAHEAD_BLKS   32
    2156             : 
    2157             : /*
    2158             :  * Default mount options
    2159             :  */
    2160             : #define EXT4_DEFM_DEBUG         0x0001
    2161             : #define EXT4_DEFM_BSDGROUPS     0x0002
    2162             : #define EXT4_DEFM_XATTR_USER    0x0004
    2163             : #define EXT4_DEFM_ACL           0x0008
    2164             : #define EXT4_DEFM_UID16         0x0010
    2165             : #define EXT4_DEFM_JMODE         0x0060
    2166             : #define EXT4_DEFM_JMODE_DATA    0x0020
    2167             : #define EXT4_DEFM_JMODE_ORDERED 0x0040
    2168             : #define EXT4_DEFM_JMODE_WBACK   0x0060
    2169             : #define EXT4_DEFM_NOBARRIER     0x0100
    2170             : #define EXT4_DEFM_BLOCK_VALIDITY 0x0200
    2171             : #define EXT4_DEFM_DISCARD       0x0400
    2172             : #define EXT4_DEFM_NODELALLOC    0x0800
    2173             : 
    2174             : /*
    2175             :  * Default journal batch times
    2176             :  */
    2177             : #define EXT4_DEF_MIN_BATCH_TIME 0
    2178             : #define EXT4_DEF_MAX_BATCH_TIME 15000 /* 15ms */
    2179             : 
    2180             : /*
    2181             :  * Minimum number of groups in a flexgroup before we separate out
    2182             :  * directories into the first block group of a flexgroup
    2183             :  */
    2184             : #define EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME 4
    2185             : 
    2186             : /*
    2187             :  * Structure of a directory entry
    2188             :  */
    2189             : #define EXT4_NAME_LEN 255
    2190             : 
    2191             : struct ext4_dir_entry {
    2192             :         __le32  inode;                  /* Inode number */
    2193             :         __le16  rec_len;                /* Directory entry length */
    2194             :         __le16  name_len;               /* Name length */
    2195             :         char    name[EXT4_NAME_LEN];    /* File name */
    2196             : };
    2197             : 
    2198             : /*
    2199             :  * The new version of the directory entry.  Since EXT4 structures are
    2200             :  * stored in intel byte order, and the name_len field could never be
    2201             :  * bigger than 255 chars, it's safe to reclaim the extra byte for the
    2202             :  * file_type field.
    2203             :  */
    2204             : struct ext4_dir_entry_2 {
    2205             :         __le32  inode;                  /* Inode number */
    2206             :         __le16  rec_len;                /* Directory entry length */
    2207             :         __u8    name_len;               /* Name length */
    2208             :         __u8    file_type;              /* See file type macros EXT4_FT_* below */
    2209             :         char    name[EXT4_NAME_LEN];    /* File name */
    2210             : };
    2211             : 
    2212             : /*
    2213             :  * This is a bogus directory entry at the end of each leaf block that
    2214             :  * records checksums.
    2215             :  */
    2216             : struct ext4_dir_entry_tail {
    2217             :         __le32  det_reserved_zero1;     /* Pretend to be unused */
    2218             :         __le16  det_rec_len;            /* 12 */
    2219             :         __u8    det_reserved_zero2;     /* Zero name length */
    2220             :         __u8    det_reserved_ft;        /* 0xDE, fake file type */
    2221             :         __le32  det_checksum;           /* crc32c(uuid+inum+dirblock) */
    2222             : };
    2223             : 
    2224             : #define EXT4_DIRENT_TAIL(block, blocksize) \
    2225             :         ((struct ext4_dir_entry_tail *)(((void *)(block)) + \
    2226             :                                         ((blocksize) - \
    2227             :                                          sizeof(struct ext4_dir_entry_tail))))
    2228             : 
    2229             : /*
    2230             :  * Ext4 directory file types.  Only the low 3 bits are used.  The
    2231             :  * other bits are reserved for now.
    2232             :  */
    2233             : #define EXT4_FT_UNKNOWN         0
    2234             : #define EXT4_FT_REG_FILE        1
    2235             : #define EXT4_FT_DIR             2
    2236             : #define EXT4_FT_CHRDEV          3
    2237             : #define EXT4_FT_BLKDEV          4
    2238             : #define EXT4_FT_FIFO            5
    2239             : #define EXT4_FT_SOCK            6
    2240             : #define EXT4_FT_SYMLINK         7
    2241             : 
    2242             : #define EXT4_FT_MAX             8
    2243             : 
    2244             : #define EXT4_FT_DIR_CSUM        0xDE
    2245             : 
    2246             : /*
    2247             :  * EXT4_DIR_PAD defines the directory entries boundaries
    2248             :  *
    2249             :  * NOTE: It must be a multiple of 4
    2250             :  */
    2251             : #define EXT4_DIR_PAD                    4
    2252             : #define EXT4_DIR_ROUND                  (EXT4_DIR_PAD - 1)
    2253             : #define EXT4_DIR_REC_LEN(name_len)      (((name_len) + 8 + EXT4_DIR_ROUND) & \
    2254             :                                          ~EXT4_DIR_ROUND)
    2255             : #define EXT4_MAX_REC_LEN                ((1<<16)-1)
    2256             : 
    2257             : /*
    2258             :  * If we ever get support for fs block sizes > page_size, we'll need
    2259             :  * to remove the #if statements in the next two functions...
    2260             :  */
    2261             : static inline unsigned int
    2262      290801 : ext4_rec_len_from_disk(__le16 dlen, unsigned blocksize)
    2263             : {
    2264      290801 :         unsigned len = le16_to_cpu(dlen);
    2265             : 
    2266             : #if (PAGE_SIZE >= 65536)
    2267             :         if (len == EXT4_MAX_REC_LEN || len == 0)
    2268             :                 return blocksize;
    2269             :         return (len & 65532) | ((len & 3) << 16);
    2270             : #else
    2271      290628 :         return len;
    2272             : #endif
    2273             : }
    2274             : 
    2275        2024 : static inline __le16 ext4_rec_len_to_disk(unsigned len, unsigned blocksize)
    2276             : {
    2277        2024 :         if ((len > blocksize) || (blocksize > (1 << 18)) || (len & 3))
    2278           0 :                 BUG();
    2279             : #if (PAGE_SIZE >= 65536)
    2280             :         if (len < 65536)
    2281             :                 return cpu_to_le16(len);
    2282             :         if (len == blocksize) {
    2283             :                 if (blocksize == 65536)
    2284             :                         return cpu_to_le16(EXT4_MAX_REC_LEN);
    2285             :                 else
    2286             :                         return cpu_to_le16(0);
    2287             :         }
    2288             :         return cpu_to_le16((len & 65532) | ((len >> 16) & 3));
    2289             : #else
    2290        2024 :         return cpu_to_le16(len);
    2291             : #endif
    2292             : }
    2293             : 
    2294             : /*
    2295             :  * Hash Tree Directory indexing
    2296             :  * (c) Daniel Phillips, 2001
    2297             :  */
    2298             : 
    2299             : #define is_dx(dir) (ext4_has_feature_dir_index((dir)->i_sb) && \
    2300             :                     ext4_test_inode_flag((dir), EXT4_INODE_INDEX))
    2301             : #define EXT4_DIR_LINK_MAX(dir) unlikely((dir)->i_nlink >= EXT4_LINK_MAX && \
    2302             :                     !(ext4_has_feature_dir_nlink((dir)->i_sb) && is_dx(dir)))
    2303             : #define EXT4_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1)
    2304             : 
    2305             : /* Legal values for the dx_root hash_version field: */
    2306             : 
    2307             : #define DX_HASH_LEGACY                  0
    2308             : #define DX_HASH_HALF_MD4                1
    2309             : #define DX_HASH_TEA                     2
    2310             : #define DX_HASH_LEGACY_UNSIGNED         3
    2311             : #define DX_HASH_HALF_MD4_UNSIGNED       4
    2312             : #define DX_HASH_TEA_UNSIGNED            5
    2313             : 
    2314           0 : static inline u32 ext4_chksum(struct ext4_sb_info *sbi, u32 crc,
    2315             :                               const void *address, unsigned int length)
    2316             : {
    2317           0 :         struct {
    2318             :                 struct shash_desc shash;
    2319             :                 char ctx[4];
    2320             :         } desc;
    2321             : 
    2322           0 :         BUG_ON(crypto_shash_descsize(sbi->s_chksum_driver)!=sizeof(desc.ctx));
    2323             : 
    2324           0 :         desc.shash.tfm = sbi->s_chksum_driver;
    2325           0 :         *(u32 *)desc.ctx = crc;
    2326             : 
    2327           0 :         BUG_ON(crypto_shash_update(&desc.shash, address, length));
    2328             : 
    2329           0 :         return *(u32 *)desc.ctx;
    2330             : }
    2331             : 
    2332             : #ifdef __KERNEL__
    2333             : 
    2334             : /* hash info structure used by the directory hash */
    2335             : struct dx_hash_info
    2336             : {
    2337             :         u32             hash;
    2338             :         u32             minor_hash;
    2339             :         int             hash_version;
    2340             :         u32             *seed;
    2341             : };
    2342             : 
    2343             : 
    2344             : /* 32 and 64 bit signed EOF for dx directories */
    2345             : #define EXT4_HTREE_EOF_32BIT   ((1UL  << (32 - 1)) - 1)
    2346             : #define EXT4_HTREE_EOF_64BIT   ((1ULL << (64 - 1)) - 1)
    2347             : 
    2348             : 
    2349             : /*
    2350             :  * Control parameters used by ext4_htree_next_block
    2351             :  */
    2352             : #define HASH_NB_ALWAYS          1
    2353             : 
    2354             : struct ext4_filename {
    2355             :         const struct qstr *usr_fname;
    2356             :         struct fscrypt_str disk_name;
    2357             :         struct dx_hash_info hinfo;
    2358             : #ifdef CONFIG_FS_ENCRYPTION
    2359             :         struct fscrypt_str crypto_buf;
    2360             : #endif
    2361             : #ifdef CONFIG_UNICODE
    2362             :         struct fscrypt_str cf_name;
    2363             : #endif
    2364             : };
    2365             : 
    2366             : #define fname_name(p) ((p)->disk_name.name)
    2367             : #define fname_len(p)  ((p)->disk_name.len)
    2368             : 
    2369             : /*
    2370             :  * Describe an inode's exact location on disk and in memory
    2371             :  */
    2372             : struct ext4_iloc
    2373             : {
    2374             :         struct buffer_head *bh;
    2375             :         unsigned long offset;
    2376             :         ext4_group_t block_group;
    2377             : };
    2378             : 
    2379       15368 : static inline struct ext4_inode *ext4_raw_inode(struct ext4_iloc *iloc)
    2380             : {
    2381       15368 :         return (struct ext4_inode *) (iloc->bh->b_data + iloc->offset);
    2382             : }
    2383             : 
    2384         418 : static inline bool ext4_is_quota_file(struct inode *inode)
    2385             : {
    2386         418 :         return IS_NOQUOTA(inode) &&
    2387           0 :                !(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL);
    2388             : }
    2389             : 
    2390             : /*
    2391             :  * This structure is stuffed into the struct file's private_data field
    2392             :  * for directories.  It is where we put information so that we can do
    2393             :  * readdir operations in hash tree order.
    2394             :  */
    2395             : struct dir_private_info {
    2396             :         struct rb_root  root;
    2397             :         struct rb_node  *curr_node;
    2398             :         struct fname    *extra_fname;
    2399             :         loff_t          last_pos;
    2400             :         __u32           curr_hash;
    2401             :         __u32           curr_minor_hash;
    2402             :         __u32           next_hash;
    2403             : };
    2404             : 
    2405             : /* calculate the first block number of the group */
    2406             : static inline ext4_fsblk_t
    2407         777 : ext4_group_first_block_no(struct super_block *sb, ext4_group_t group_no)
    2408             : {
    2409         777 :         return group_no * (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
    2410         777 :                 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
    2411             : }
    2412             : 
    2413             : /*
    2414             :  * Special error return code only used by dx_probe() and its callers.
    2415             :  */
    2416             : #define ERR_BAD_DX_DIR  (-(MAX_ERRNO - 1))
    2417             : 
    2418             : /* htree levels for ext4 */
    2419             : #define EXT4_HTREE_LEVEL_COMPAT 2
    2420             : #define EXT4_HTREE_LEVEL        3
    2421             : 
    2422        3325 : static inline int ext4_dir_htree_level(struct super_block *sb)
    2423             : {
    2424           0 :         return ext4_has_feature_largedir(sb) ?
    2425        3325 :                 EXT4_HTREE_LEVEL : EXT4_HTREE_LEVEL_COMPAT;
    2426             : }
    2427             : 
    2428             : /*
    2429             :  * Timeout and state flag for lazy initialization inode thread.
    2430             :  */
    2431             : #define EXT4_DEF_LI_WAIT_MULT                   10
    2432             : #define EXT4_DEF_LI_MAX_START_DELAY             5
    2433             : #define EXT4_LAZYINIT_QUIT                      0x0001
    2434             : #define EXT4_LAZYINIT_RUNNING                   0x0002
    2435             : 
    2436             : /*
    2437             :  * Lazy inode table initialization info
    2438             :  */
    2439             : struct ext4_lazy_init {
    2440             :         unsigned long           li_state;
    2441             :         struct list_head        li_request_list;
    2442             :         struct mutex            li_list_mtx;
    2443             : };
    2444             : 
    2445             : enum ext4_li_mode {
    2446             :         EXT4_LI_MODE_PREFETCH_BBITMAP,
    2447             :         EXT4_LI_MODE_ITABLE,
    2448             : };
    2449             : 
    2450             : struct ext4_li_request {
    2451             :         struct super_block      *lr_super;
    2452             :         enum ext4_li_mode       lr_mode;
    2453             :         ext4_group_t            lr_first_not_zeroed;
    2454             :         ext4_group_t            lr_next_group;
    2455             :         struct list_head        lr_request;
    2456             :         unsigned long           lr_next_sched;
    2457             :         unsigned long           lr_timeout;
    2458             : };
    2459             : 
    2460             : struct ext4_features {
    2461             :         struct kobject f_kobj;
    2462             :         struct completion f_kobj_unregister;
    2463             : };
    2464             : 
    2465             : /*
    2466             :  * This structure will be used for multiple mount protection. It will be
    2467             :  * written into the block number saved in the s_mmp_block field in the
    2468             :  * superblock. Programs that check MMP should assume that if
    2469             :  * SEQ_FSCK (or any unknown code above SEQ_MAX) is present then it is NOT safe
    2470             :  * to use the filesystem, regardless of how old the timestamp is.
    2471             :  */
    2472             : #define EXT4_MMP_MAGIC     0x004D4D50U /* ASCII for MMP */
    2473             : #define EXT4_MMP_SEQ_CLEAN 0xFF4D4D50U /* mmp_seq value for clean unmount */
    2474             : #define EXT4_MMP_SEQ_FSCK  0xE24D4D50U /* mmp_seq value when being fscked */
    2475             : #define EXT4_MMP_SEQ_MAX   0xE24D4D4FU /* maximum valid mmp_seq value */
    2476             : 
    2477             : struct mmp_struct {
    2478             :         __le32  mmp_magic;              /* Magic number for MMP */
    2479             :         __le32  mmp_seq;                /* Sequence no. updated periodically */
    2480             : 
    2481             :         /*
    2482             :          * mmp_time, mmp_nodename & mmp_bdevname are only used for information
    2483             :          * purposes and do not affect the correctness of the algorithm
    2484             :          */
    2485             :         __le64  mmp_time;               /* Time last updated */
    2486             :         char    mmp_nodename[64];       /* Node which last updated MMP block */
    2487             :         char    mmp_bdevname[32];       /* Bdev which last updated MMP block */
    2488             : 
    2489             :         /*
    2490             :          * mmp_check_interval is used to verify if the MMP block has been
    2491             :          * updated on the block device. The value is updated based on the
    2492             :          * maximum time to write the MMP block during an update cycle.
    2493             :          */
    2494             :         __le16  mmp_check_interval;
    2495             : 
    2496             :         __le16  mmp_pad1;
    2497             :         __le32  mmp_pad2[226];
    2498             :         __le32  mmp_checksum;           /* crc32c(uuid+mmp_block) */
    2499             : };
    2500             : 
    2501             : /* arguments passed to the mmp thread */
    2502             : struct mmpd_data {
    2503             :         struct buffer_head *bh; /* bh from initial read_mmp_block() */
    2504             :         struct super_block *sb;  /* super block of the fs */
    2505             : };
    2506             : 
    2507             : /*
    2508             :  * Check interval multiplier
    2509             :  * The MMP block is written every update interval and initially checked every
    2510             :  * update interval x the multiplier (the value is then adapted based on the
    2511             :  * write latency). The reason is that writes can be delayed under load and we
    2512             :  * don't want readers to incorrectly assume that the filesystem is no longer
    2513             :  * in use.
    2514             :  */
    2515             : #define EXT4_MMP_CHECK_MULT             2UL
    2516             : 
    2517             : /*
    2518             :  * Minimum interval for MMP checking in seconds.
    2519             :  */
    2520             : #define EXT4_MMP_MIN_CHECK_INTERVAL     5UL
    2521             : 
    2522             : /*
    2523             :  * Maximum interval for MMP checking in seconds.
    2524             :  */
    2525             : #define EXT4_MMP_MAX_CHECK_INTERVAL     300UL
    2526             : 
    2527             : /*
    2528             :  * Function prototypes
    2529             :  */
    2530             : 
    2531             : /*
    2532             :  * Ok, these declarations are also in <linux/kernel.h> but none of the
    2533             :  * ext4 source programs needs to include it so they are duplicated here.
    2534             :  */
    2535             : # define NORET_TYPE     /**/
    2536             : # define ATTRIB_NORET   __attribute__((noreturn))
    2537             : # define NORET_AND      noreturn,
    2538             : 
    2539             : /* bitmap.c */
    2540             : extern unsigned int ext4_count_free(char *bitmap, unsigned numchars);
    2541             : void ext4_inode_bitmap_csum_set(struct super_block *sb, ext4_group_t group,
    2542             :                                 struct ext4_group_desc *gdp,
    2543             :                                 struct buffer_head *bh, int sz);
    2544             : int ext4_inode_bitmap_csum_verify(struct super_block *sb, ext4_group_t group,
    2545             :                                   struct ext4_group_desc *gdp,
    2546             :                                   struct buffer_head *bh, int sz);
    2547             : void ext4_block_bitmap_csum_set(struct super_block *sb, ext4_group_t group,
    2548             :                                 struct ext4_group_desc *gdp,
    2549             :                                 struct buffer_head *bh);
    2550             : int ext4_block_bitmap_csum_verify(struct super_block *sb, ext4_group_t group,
    2551             :                                   struct ext4_group_desc *gdp,
    2552             :                                   struct buffer_head *bh);
    2553             : 
    2554             : /* balloc.c */
    2555             : extern void ext4_get_group_no_and_offset(struct super_block *sb,
    2556             :                                          ext4_fsblk_t blocknr,
    2557             :                                          ext4_group_t *blockgrpp,
    2558             :                                          ext4_grpblk_t *offsetp);
    2559             : extern ext4_group_t ext4_get_group_number(struct super_block *sb,
    2560             :                                           ext4_fsblk_t block);
    2561             : 
    2562             : extern unsigned int ext4_block_group(struct super_block *sb,
    2563             :                         ext4_fsblk_t blocknr);
    2564             : extern ext4_grpblk_t ext4_block_group_offset(struct super_block *sb,
    2565             :                         ext4_fsblk_t blocknr);
    2566             : extern int ext4_bg_has_super(struct super_block *sb, ext4_group_t group);
    2567             : extern unsigned long ext4_bg_num_gdb(struct super_block *sb,
    2568             :                         ext4_group_t group);
    2569             : extern ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
    2570             :                                          ext4_fsblk_t goal,
    2571             :                                          unsigned int flags,
    2572             :                                          unsigned long *count,
    2573             :                                          int *errp);
    2574             : extern int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
    2575             :                                     s64 nclusters, unsigned int flags);
    2576             : extern ext4_fsblk_t ext4_count_free_clusters(struct super_block *);
    2577             : extern void ext4_check_blocks_bitmap(struct super_block *);
    2578             : extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
    2579             :                                                     ext4_group_t block_group,
    2580             :                                                     struct buffer_head ** bh);
    2581             : extern int ext4_should_retry_alloc(struct super_block *sb, int *retries);
    2582             : 
    2583             : extern struct buffer_head *ext4_read_block_bitmap_nowait(struct super_block *sb,
    2584             :                                                 ext4_group_t block_group,
    2585             :                                                 bool ignore_locked);
    2586             : extern int ext4_wait_block_bitmap(struct super_block *sb,
    2587             :                                   ext4_group_t block_group,
    2588             :                                   struct buffer_head *bh);
    2589             : extern struct buffer_head *ext4_read_block_bitmap(struct super_block *sb,
    2590             :                                                   ext4_group_t block_group);
    2591             : extern unsigned ext4_free_clusters_after_init(struct super_block *sb,
    2592             :                                               ext4_group_t block_group,
    2593             :                                               struct ext4_group_desc *gdp);
    2594             : ext4_fsblk_t ext4_inode_to_goal_block(struct inode *);
    2595             : 
    2596             : #ifdef CONFIG_UNICODE
    2597             : extern void ext4_fname_setup_ci_filename(struct inode *dir,
    2598             :                                          const struct qstr *iname,
    2599             :                                          struct fscrypt_str *fname);
    2600             : #endif
    2601             : 
    2602             : #ifdef CONFIG_FS_ENCRYPTION
    2603             : static inline void ext4_fname_from_fscrypt_name(struct ext4_filename *dst,
    2604             :                                                 const struct fscrypt_name *src)
    2605             : {
    2606             :         memset(dst, 0, sizeof(*dst));
    2607             : 
    2608             :         dst->usr_fname = src->usr_fname;
    2609             :         dst->disk_name = src->disk_name;
    2610             :         dst->hinfo.hash = src->hash;
    2611             :         dst->hinfo.minor_hash = src->minor_hash;
    2612             :         dst->crypto_buf = src->crypto_buf;
    2613             : }
    2614             : 
    2615             : static inline int ext4_fname_setup_filename(struct inode *dir,
    2616             :                                             const struct qstr *iname,
    2617             :                                             int lookup,
    2618             :                                             struct ext4_filename *fname)
    2619             : {
    2620             :         struct fscrypt_name name;
    2621             :         int err;
    2622             : 
    2623             :         err = fscrypt_setup_filename(dir, iname, lookup, &name);
    2624             :         if (err)
    2625             :                 return err;
    2626             : 
    2627             :         ext4_fname_from_fscrypt_name(fname, &name);
    2628             : 
    2629             : #ifdef CONFIG_UNICODE
    2630             :         ext4_fname_setup_ci_filename(dir, iname, &fname->cf_name);
    2631             : #endif
    2632             :         return 0;
    2633             : }
    2634             : 
    2635             : static inline int ext4_fname_prepare_lookup(struct inode *dir,
    2636             :                                             struct dentry *dentry,
    2637             :                                             struct ext4_filename *fname)
    2638             : {
    2639             :         struct fscrypt_name name;
    2640             :         int err;
    2641             : 
    2642             :         err = fscrypt_prepare_lookup(dir, dentry, &name);
    2643             :         if (err)
    2644             :                 return err;
    2645             : 
    2646             :         ext4_fname_from_fscrypt_name(fname, &name);
    2647             : 
    2648             : #ifdef CONFIG_UNICODE
    2649             :         ext4_fname_setup_ci_filename(dir, &dentry->d_name, &fname->cf_name);
    2650             : #endif
    2651             :         return 0;
    2652             : }
    2653             : 
    2654             : static inline void ext4_fname_free_filename(struct ext4_filename *fname)
    2655             : {
    2656             :         struct fscrypt_name name;
    2657             : 
    2658             :         name.crypto_buf = fname->crypto_buf;
    2659             :         fscrypt_free_filename(&name);
    2660             : 
    2661             :         fname->crypto_buf.name = NULL;
    2662             :         fname->usr_fname = NULL;
    2663             :         fname->disk_name.name = NULL;
    2664             : 
    2665             : #ifdef CONFIG_UNICODE
    2666             :         kfree(fname->cf_name.name);
    2667             :         fname->cf_name.name = NULL;
    2668             : #endif
    2669             : }
    2670             : #else /* !CONFIG_FS_ENCRYPTION */
    2671        8109 : static inline int ext4_fname_setup_filename(struct inode *dir,
    2672             :                                             const struct qstr *iname,
    2673             :                                             int lookup,
    2674             :                                             struct ext4_filename *fname)
    2675             : {
    2676        8109 :         fname->usr_fname = iname;
    2677        8109 :         fname->disk_name.name = (unsigned char *) iname->name;
    2678        8109 :         fname->disk_name.len = iname->len;
    2679             : 
    2680             : #ifdef CONFIG_UNICODE
    2681             :         ext4_fname_setup_ci_filename(dir, iname, &fname->cf_name);
    2682             : #endif
    2683             : 
    2684        1073 :         return 0;
    2685             : }
    2686             : 
    2687        7036 : static inline int ext4_fname_prepare_lookup(struct inode *dir,
    2688             :                                             struct dentry *dentry,
    2689             :                                             struct ext4_filename *fname)
    2690             : {
    2691        7036 :         return ext4_fname_setup_filename(dir, &dentry->d_name, 1, fname);
    2692             : }
    2693             : 
    2694        8109 : static inline void ext4_fname_free_filename(struct ext4_filename *fname)
    2695             : {
    2696             : #ifdef CONFIG_UNICODE
    2697             :         kfree(fname->cf_name.name);
    2698             :         fname->cf_name.name = NULL;
    2699             : #endif
    2700         708 : }
    2701             : #endif /* !CONFIG_FS_ENCRYPTION */
    2702             : 
    2703             : /* dir.c */
    2704             : extern int __ext4_check_dir_entry(const char *, unsigned int, struct inode *,
    2705             :                                   struct file *,
    2706             :                                   struct ext4_dir_entry_2 *,
    2707             :                                   struct buffer_head *, char *, int,
    2708             :                                   unsigned int);
    2709             : #define ext4_check_dir_entry(dir, filp, de, bh, buf, size, offset)      \
    2710             :         unlikely(__ext4_check_dir_entry(__func__, __LINE__, (dir), (filp), \
    2711             :                                         (de), (bh), (buf), (size), (offset)))
    2712             : extern int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
    2713             :                                 __u32 minor_hash,
    2714             :                                 struct ext4_dir_entry_2 *dirent,
    2715             :                                 struct fscrypt_str *ent_name);
    2716             : extern void ext4_htree_free_dir_info(struct dir_private_info *p);
    2717             : extern int ext4_find_dest_de(struct inode *dir, struct inode *inode,
    2718             :                              struct buffer_head *bh,
    2719             :                              void *buf, int buf_size,
    2720             :                              struct ext4_filename *fname,
    2721             :                              struct ext4_dir_entry_2 **dest_de);
    2722             : void ext4_insert_dentry(struct inode *inode,
    2723             :                         struct ext4_dir_entry_2 *de,
    2724             :                         int buf_size,
    2725             :                         struct ext4_filename *fname);
    2726        1145 : static inline void ext4_update_dx_flag(struct inode *inode)
    2727             : {
    2728        1145 :         if (!ext4_has_feature_dir_index(inode->i_sb) &&
    2729           0 :             ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) {
    2730             :                 /* ext4_iget() should have caught this... */
    2731           0 :                 WARN_ON_ONCE(ext4_has_feature_metadata_csum(inode->i_sb));
    2732           0 :                 ext4_clear_inode_flag(inode, EXT4_INODE_INDEX);
    2733             :         }
    2734        1145 : }
    2735             : static const unsigned char ext4_filetype_table[] = {
    2736             :         DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
    2737             : };
    2738             : 
    2739        6774 : static inline  unsigned char get_dtype(struct super_block *sb, int filetype)
    2740             : {
    2741        6774 :         if (!ext4_has_feature_filetype(sb) || filetype >= EXT4_FT_MAX)
    2742             :                 return DT_UNKNOWN;
    2743             : 
    2744        6774 :         return ext4_filetype_table[filetype];
    2745             : }
    2746             : extern int ext4_check_all_de(struct inode *dir, struct buffer_head *bh,
    2747             :                              void *buf, int buf_size);
    2748             : 
    2749             : /* fsync.c */
    2750             : extern int ext4_sync_file(struct file *, loff_t, loff_t, int);
    2751             : 
    2752             : /* hash.c */
    2753             : extern int ext4fs_dirhash(const struct inode *dir, const char *name, int len,
    2754             :                           struct dx_hash_info *hinfo);
    2755             : 
    2756             : /* ialloc.c */
    2757             : extern int ext4_mark_inode_used(struct super_block *sb, int ino);
    2758             : extern struct inode *__ext4_new_inode(struct user_namespace *, handle_t *,
    2759             :                                       struct inode *, umode_t,
    2760             :                                       const struct qstr *qstr, __u32 goal,
    2761             :                                       uid_t *owner, __u32 i_flags,
    2762             :                                       int handle_type, unsigned int line_no,
    2763             :                                       int nblocks);
    2764             : 
    2765             : #define ext4_new_inode(handle, dir, mode, qstr, goal, owner, i_flags)          \
    2766             :         __ext4_new_inode(&init_user_ns, (handle), (dir), (mode), (qstr),       \
    2767             :                          (goal), (owner), i_flags, 0, 0, 0)
    2768             : #define ext4_new_inode_start_handle(mnt_userns, dir, mode, qstr, goal, owner, \
    2769             :                                     type, nblocks)                  \
    2770             :         __ext4_new_inode((mnt_userns), NULL, (dir), (mode), (qstr), (goal), (owner), \
    2771             :                          0, (type), __LINE__, (nblocks))
    2772             : 
    2773             : 
    2774             : extern void ext4_free_inode(handle_t *, struct inode *);
    2775             : extern struct inode * ext4_orphan_get(struct super_block *, unsigned long);
    2776             : extern unsigned long ext4_count_free_inodes(struct super_block *);
    2777             : extern unsigned long ext4_count_dirs(struct super_block *);
    2778             : extern void ext4_check_inodes_bitmap(struct super_block *);
    2779             : extern void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap);
    2780             : extern int ext4_init_inode_table(struct super_block *sb,
    2781             :                                  ext4_group_t group, int barrier);
    2782             : extern void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate);
    2783             : 
    2784             : /* fast_commit.c */
    2785             : int ext4_fc_info_show(struct seq_file *seq, void *v);
    2786             : void ext4_fc_init(struct super_block *sb, journal_t *journal);
    2787             : void ext4_fc_init_inode(struct inode *inode);
    2788             : void ext4_fc_track_range(handle_t *handle, struct inode *inode, ext4_lblk_t start,
    2789             :                          ext4_lblk_t end);
    2790             : void __ext4_fc_track_unlink(handle_t *handle, struct inode *inode,
    2791             :         struct dentry *dentry);
    2792             : void __ext4_fc_track_link(handle_t *handle, struct inode *inode,
    2793             :         struct dentry *dentry);
    2794             : void ext4_fc_track_unlink(handle_t *handle, struct dentry *dentry);
    2795             : void ext4_fc_track_link(handle_t *handle, struct dentry *dentry);
    2796             : void ext4_fc_track_create(handle_t *handle, struct dentry *dentry);
    2797             : void ext4_fc_track_inode(handle_t *handle, struct inode *inode);
    2798             : void ext4_fc_mark_ineligible(struct super_block *sb, int reason);
    2799             : void ext4_fc_start_ineligible(struct super_block *sb, int reason);
    2800             : void ext4_fc_stop_ineligible(struct super_block *sb);
    2801             : void ext4_fc_start_update(struct inode *inode);
    2802             : void ext4_fc_stop_update(struct inode *inode);
    2803             : void ext4_fc_del(struct inode *inode);
    2804             : bool ext4_fc_replay_check_excluded(struct super_block *sb, ext4_fsblk_t block);
    2805             : void ext4_fc_replay_cleanup(struct super_block *sb);
    2806             : int ext4_fc_commit(journal_t *journal, tid_t commit_tid);
    2807             : int __init ext4_fc_init_dentry_cache(void);
    2808             : 
    2809             : /* mballoc.c */
    2810             : extern const struct seq_operations ext4_mb_seq_groups_ops;
    2811             : extern long ext4_mb_stats;
    2812             : extern long ext4_mb_max_to_scan;
    2813             : extern int ext4_mb_init(struct super_block *);
    2814             : extern int ext4_mb_release(struct super_block *);
    2815             : extern ext4_fsblk_t ext4_mb_new_blocks(handle_t *,
    2816             :                                 struct ext4_allocation_request *, int *);
    2817             : extern int ext4_mb_reserve_blocks(struct super_block *, int);
    2818             : extern void ext4_discard_preallocations(struct inode *, unsigned int);
    2819             : extern int __init ext4_init_mballoc(void);
    2820             : extern void ext4_exit_mballoc(void);
    2821             : extern ext4_group_t ext4_mb_prefetch(struct super_block *sb,
    2822             :                                      ext4_group_t group,
    2823             :                                      unsigned int nr, int *cnt);
    2824             : extern void ext4_mb_prefetch_fini(struct super_block *sb, ext4_group_t group,
    2825             :                                   unsigned int nr);
    2826             : 
    2827             : extern void ext4_free_blocks(handle_t *handle, struct inode *inode,
    2828             :                              struct buffer_head *bh, ext4_fsblk_t block,
    2829             :                              unsigned long count, int flags);
    2830             : extern int ext4_mb_alloc_groupinfo(struct super_block *sb,
    2831             :                                    ext4_group_t ngroups);
    2832             : extern int ext4_mb_add_groupinfo(struct super_block *sb,
    2833             :                 ext4_group_t i, struct ext4_group_desc *desc);
    2834             : extern int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
    2835             :                                 ext4_fsblk_t block, unsigned long count);
    2836             : extern int ext4_trim_fs(struct super_block *, struct fstrim_range *);
    2837             : extern void ext4_process_freed_data(struct super_block *sb, tid_t commit_tid);
    2838             : extern void ext4_mb_mark_bb(struct super_block *sb, ext4_fsblk_t block,
    2839             :                        int len, int state);
    2840             : 
    2841             : /* inode.c */
    2842             : void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw,
    2843             :                          struct ext4_inode_info *ei);
    2844             : int ext4_inode_is_fast_symlink(struct inode *inode);
    2845             : struct buffer_head *ext4_getblk(handle_t *, struct inode *, ext4_lblk_t, int);
    2846             : struct buffer_head *ext4_bread(handle_t *, struct inode *, ext4_lblk_t, int);
    2847             : int ext4_bread_batch(struct inode *inode, ext4_lblk_t block, int bh_count,
    2848             :                      bool wait, struct buffer_head **bhs);
    2849             : int ext4_get_block_unwritten(struct inode *inode, sector_t iblock,
    2850             :                              struct buffer_head *bh_result, int create);
    2851             : int ext4_get_block(struct inode *inode, sector_t iblock,
    2852             :                    struct buffer_head *bh_result, int create);
    2853             : int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
    2854             :                            struct buffer_head *bh, int create);
    2855             : int ext4_walk_page_buffers(handle_t *handle,
    2856             :                            struct buffer_head *head,
    2857             :                            unsigned from,
    2858             :                            unsigned to,
    2859             :                            int *partial,
    2860             :                            int (*fn)(handle_t *handle,
    2861             :                                      struct buffer_head *bh));
    2862             : int do_journal_get_write_access(handle_t *handle,
    2863             :                                 struct buffer_head *bh);
    2864             : #define FALL_BACK_TO_NONDELALLOC 1
    2865             : #define CONVERT_INLINE_DATA      2
    2866             : 
    2867             : typedef enum {
    2868             :         EXT4_IGET_NORMAL =      0,
    2869             :         EXT4_IGET_SPECIAL =     0x0001, /* OK to iget a system inode */
    2870             :         EXT4_IGET_HANDLE =      0x0002  /* Inode # is from a handle */
    2871             : } ext4_iget_flags;
    2872             : 
    2873             : extern struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
    2874             :                                  ext4_iget_flags flags, const char *function,
    2875             :                                  unsigned int line);
    2876             : 
    2877             : #define ext4_iget(sb, ino, flags) \
    2878             :         __ext4_iget((sb), (ino), (flags), __func__, __LINE__)
    2879             : 
    2880             : extern int  ext4_write_inode(struct inode *, struct writeback_control *);
    2881             : extern int  ext4_setattr(struct user_namespace *, struct dentry *,
    2882             :                          struct iattr *);
    2883             : extern int  ext4_getattr(struct user_namespace *, const struct path *,
    2884             :                          struct kstat *, u32, unsigned int);
    2885             : extern void ext4_evict_inode(struct inode *);
    2886             : extern void ext4_clear_inode(struct inode *);
    2887             : extern int  ext4_file_getattr(struct user_namespace *, const struct path *,
    2888             :                               struct kstat *, u32, unsigned int);
    2889             : extern int  ext4_sync_inode(handle_t *, struct inode *);
    2890             : extern void ext4_dirty_inode(struct inode *, int);
    2891             : extern int ext4_change_inode_journal_flag(struct inode *, int);
    2892             : extern int ext4_get_inode_loc(struct inode *, struct ext4_iloc *);
    2893             : extern int ext4_get_fc_inode_loc(struct super_block *sb, unsigned long ino,
    2894             :                           struct ext4_iloc *iloc);
    2895             : extern int ext4_inode_attach_jinode(struct inode *inode);
    2896             : extern int ext4_can_truncate(struct inode *inode);
    2897             : extern int ext4_truncate(struct inode *);
    2898             : extern int ext4_break_layouts(struct inode *);
    2899             : extern int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length);
    2900             : extern void ext4_set_inode_flags(struct inode *, bool init);
    2901             : extern int ext4_alloc_da_blocks(struct inode *inode);
    2902             : extern void ext4_set_aops(struct inode *inode);
    2903             : extern int ext4_writepage_trans_blocks(struct inode *);
    2904             : extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
    2905             : extern int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
    2906             :                              loff_t lstart, loff_t lend);
    2907             : extern vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf);
    2908             : extern vm_fault_t ext4_filemap_fault(struct vm_fault *vmf);
    2909             : extern qsize_t *ext4_get_reserved_space(struct inode *inode);
    2910             : extern int ext4_get_projid(struct inode *inode, kprojid_t *projid);
    2911             : extern void ext4_da_release_space(struct inode *inode, int to_free);
    2912             : extern void ext4_da_update_reserve_space(struct inode *inode,
    2913             :                                         int used, int quota_claim);
    2914             : extern int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk,
    2915             :                               ext4_fsblk_t pblk, ext4_lblk_t len);
    2916             : 
    2917             : /* indirect.c */
    2918             : extern int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
    2919             :                                 struct ext4_map_blocks *map, int flags);
    2920             : extern int ext4_ind_trans_blocks(struct inode *inode, int nrblocks);
    2921             : extern void ext4_ind_truncate(handle_t *, struct inode *inode);
    2922             : extern int ext4_ind_remove_space(handle_t *handle, struct inode *inode,
    2923             :                                  ext4_lblk_t start, ext4_lblk_t end);
    2924             : 
    2925             : /* ioctl.c */
    2926             : extern long ext4_ioctl(struct file *, unsigned int, unsigned long);
    2927             : extern long ext4_compat_ioctl(struct file *, unsigned int, unsigned long);
    2928             : extern void ext4_reset_inode_seed(struct inode *inode);
    2929             : 
    2930             : /* migrate.c */
    2931             : extern int ext4_ext_migrate(struct inode *);
    2932             : extern int ext4_ind_migrate(struct inode *inode);
    2933             : 
    2934             : /* namei.c */
    2935             : extern int ext4_init_new_dir(handle_t *handle, struct inode *dir,
    2936             :                              struct inode *inode);
    2937             : extern int ext4_dirblock_csum_verify(struct inode *inode,
    2938             :                                      struct buffer_head *bh);
    2939             : extern int ext4_orphan_add(handle_t *, struct inode *);
    2940             : extern int ext4_orphan_del(handle_t *, struct inode *);
    2941             : extern int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
    2942             :                                 __u32 start_minor_hash, __u32 *next_hash);
    2943             : extern int ext4_search_dir(struct buffer_head *bh,
    2944             :                            char *search_buf,
    2945             :                            int buf_size,
    2946             :                            struct inode *dir,
    2947             :                            struct ext4_filename *fname,
    2948             :                            unsigned int offset,
    2949             :                            struct ext4_dir_entry_2 **res_dir);
    2950             : extern int ext4_generic_delete_entry(struct inode *dir,
    2951             :                                      struct ext4_dir_entry_2 *de_del,
    2952             :                                      struct buffer_head *bh,
    2953             :                                      void *entry_buf,
    2954             :                                      int buf_size,
    2955             :                                      int csum_size);
    2956             : extern bool ext4_empty_dir(struct inode *inode);
    2957             : 
    2958             : /* resize.c */
    2959             : extern void ext4_kvfree_array_rcu(void *to_free);
    2960             : extern int ext4_group_add(struct super_block *sb,
    2961             :                                 struct ext4_new_group_data *input);
    2962             : extern int ext4_group_extend(struct super_block *sb,
    2963             :                                 struct ext4_super_block *es,
    2964             :                                 ext4_fsblk_t n_blocks_count);
    2965             : extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count);
    2966             : 
    2967             : /* super.c */
    2968             : extern struct buffer_head *ext4_sb_bread(struct super_block *sb,
    2969             :                                          sector_t block, int op_flags);
    2970             : extern struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,
    2971             :                                                    sector_t block);
    2972             : extern void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,
    2973             :                                 bh_end_io_t *end_io);
    2974             : extern int ext4_read_bh(struct buffer_head *bh, int op_flags,
    2975             :                         bh_end_io_t *end_io);
    2976             : extern int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait);
    2977             : extern void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block);
    2978             : extern int ext4_seq_options_show(struct seq_file *seq, void *offset);
    2979             : extern int ext4_calculate_overhead(struct super_block *sb);
    2980             : extern void ext4_superblock_csum_set(struct super_block *sb);
    2981             : extern int ext4_alloc_flex_bg_array(struct super_block *sb,
    2982             :                                     ext4_group_t ngroup);
    2983             : extern const char *ext4_decode_error(struct super_block *sb, int errno,
    2984             :                                      char nbuf[16]);
    2985             : extern void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
    2986             :                                              ext4_group_t block_group,
    2987             :                                              unsigned int flags);
    2988             : 
    2989             : extern __printf(7, 8)
    2990             : void __ext4_error(struct super_block *, const char *, unsigned int, bool,
    2991             :                   int, __u64, const char *, ...);
    2992             : extern __printf(6, 7)
    2993             : void __ext4_error_inode(struct inode *, const char *, unsigned int,
    2994             :                         ext4_fsblk_t, int, const char *, ...);
    2995             : extern __printf(5, 6)
    2996             : void __ext4_error_file(struct file *, const char *, unsigned int, ext4_fsblk_t,
    2997             :                      const char *, ...);
    2998             : extern void __ext4_std_error(struct super_block *, const char *,
    2999             :                              unsigned int, int);
    3000             : extern __printf(4, 5)
    3001             : void __ext4_warning(struct super_block *, const char *, unsigned int,
    3002             :                     const char *, ...);
    3003             : extern __printf(4, 5)
    3004             : void __ext4_warning_inode(const struct inode *inode, const char *function,
    3005             :                           unsigned int line, const char *fmt, ...);
    3006             : extern __printf(3, 4)
    3007             : void __ext4_msg(struct super_block *, const char *, const char *, ...);
    3008             : extern void __dump_mmp_msg(struct super_block *, struct mmp_struct *mmp,
    3009             :                            const char *, unsigned int, const char *);
    3010             : extern __printf(7, 8)
    3011             : void __ext4_grp_locked_error(const char *, unsigned int,
    3012             :                              struct super_block *, ext4_group_t,
    3013             :                              unsigned long, ext4_fsblk_t,
    3014             :                              const char *, ...);
    3015             : 
    3016             : #define EXT4_ERROR_INODE(inode, fmt, a...) \
    3017             :         ext4_error_inode((inode), __func__, __LINE__, 0, (fmt), ## a)
    3018             : 
    3019             : #define EXT4_ERROR_INODE_ERR(inode, err, fmt, a...)                     \
    3020             :         __ext4_error_inode((inode), __func__, __LINE__, 0, (err), (fmt), ## a)
    3021             : 
    3022             : #define ext4_error_inode_block(inode, block, err, fmt, a...)            \
    3023             :         __ext4_error_inode((inode), __func__, __LINE__, (block), (err), \
    3024             :                            (fmt), ## a)
    3025             : 
    3026             : #define EXT4_ERROR_FILE(file, block, fmt, a...)                         \
    3027             :         ext4_error_file((file), __func__, __LINE__, (block), (fmt), ## a)
    3028             : 
    3029             : #define ext4_abort(sb, err, fmt, a...)                                  \
    3030             :         __ext4_error((sb), __func__, __LINE__, true, (err), 0, (fmt), ## a)
    3031             : 
    3032             : #ifdef CONFIG_PRINTK
    3033             : 
    3034             : #define ext4_error_inode(inode, func, line, block, fmt, ...)            \
    3035             :         __ext4_error_inode(inode, func, line, block, 0, fmt, ##__VA_ARGS__)
    3036             : #define ext4_error_inode_err(inode, func, line, block, err, fmt, ...)   \
    3037             :         __ext4_error_inode((inode), (func), (line), (block),            \
    3038             :                            (err), (fmt), ##__VA_ARGS__)
    3039             : #define ext4_error_file(file, func, line, block, fmt, ...)              \
    3040             :         __ext4_error_file(file, func, line, block, fmt, ##__VA_ARGS__)
    3041             : #define ext4_error(sb, fmt, ...)                                        \
    3042             :         __ext4_error((sb), __func__, __LINE__, false, 0, 0, (fmt),      \
    3043             :                 ##__VA_ARGS__)
    3044             : #define ext4_error_err(sb, err, fmt, ...)                               \
    3045             :         __ext4_error((sb), __func__, __LINE__, false, (err), 0, (fmt),  \
    3046             :                 ##__VA_ARGS__)
    3047             : #define ext4_warning(sb, fmt, ...)                                      \
    3048             :         __ext4_warning(sb, __func__, __LINE__, fmt, ##__VA_ARGS__)
    3049             : #define ext4_warning_inode(inode, fmt, ...)                             \
    3050             :         __ext4_warning_inode(inode, __func__, __LINE__, fmt, ##__VA_ARGS__)
    3051             : #define ext4_msg(sb, level, fmt, ...)                           \
    3052             :         __ext4_msg(sb, level, fmt, ##__VA_ARGS__)
    3053             : #define dump_mmp_msg(sb, mmp, msg)                                      \
    3054             :         __dump_mmp_msg(sb, mmp, __func__, __LINE__, msg)
    3055             : #define ext4_grp_locked_error(sb, grp, ino, block, fmt, ...)            \
    3056             :         __ext4_grp_locked_error(__func__, __LINE__, sb, grp, ino, block, \
    3057             :                                 fmt, ##__VA_ARGS__)
    3058             : 
    3059             : #else
    3060             : 
    3061             : #define ext4_error_inode(inode, func, line, block, fmt, ...)            \
    3062             : do {                                                                    \
    3063             :         no_printk(fmt, ##__VA_ARGS__);                                  \
    3064             :         __ext4_error_inode(inode, "", 0, block, 0, " ");            \
    3065             : } while (0)
    3066             : #define ext4_error_inode_err(inode, func, line, block, err, fmt, ...)   \
    3067             : do {                                                                    \
    3068             :         no_printk(fmt, ##__VA_ARGS__);                                  \
    3069             :         __ext4_error_inode(inode, "", 0, block, err, " ");          \
    3070             : } while (0)
    3071             : #define ext4_error_file(file, func, line, block, fmt, ...)              \
    3072             : do {                                                                    \
    3073             :         no_printk(fmt, ##__VA_ARGS__);                                  \
    3074             :         __ext4_error_file(file, "", 0, block, " ");                 \
    3075             : } while (0)
    3076             : #define ext4_error(sb, fmt, ...)                                        \
    3077             : do {                                                                    \
    3078             :         no_printk(fmt, ##__VA_ARGS__);                                  \
    3079             :         __ext4_error(sb, "", 0, false, 0, 0, " ");                  \
    3080             : } while (0)
    3081             : #define ext4_error_err(sb, err, fmt, ...)                               \
    3082             : do {                                                                    \
    3083             :         no_printk(fmt, ##__VA_ARGS__);                                  \
    3084             :         __ext4_error(sb, "", 0, false, err, 0, " ");                        \
    3085             : } while (0)
    3086             : #define ext4_warning(sb, fmt, ...)                                      \
    3087             : do {                                                                    \
    3088             :         no_printk(fmt, ##__VA_ARGS__);                                  \
    3089             :         __ext4_warning(sb, "", 0, " ");                                     \
    3090             : } while (0)
    3091             : #define ext4_warning_inode(inode, fmt, ...)                             \
    3092             : do {                                                                    \
    3093             :         no_printk(fmt, ##__VA_ARGS__);                                  \
    3094             :         __ext4_warning_inode(inode, "", 0, " ");                    \
    3095             : } while (0)
    3096             : #define ext4_msg(sb, level, fmt, ...)                                   \
    3097             : do {                                                                    \
    3098             :         no_printk(fmt, ##__VA_ARGS__);                                  \
    3099             :         __ext4_msg(sb, "", " ");                                    \
    3100             : } while (0)
    3101             : #define dump_mmp_msg(sb, mmp, msg)                                      \
    3102             :         __dump_mmp_msg(sb, mmp, "", 0, "")
    3103             : #define ext4_grp_locked_error(sb, grp, ino, block, fmt, ...)            \
    3104             : do {                                                                    \
    3105             :         no_printk(fmt, ##__VA_ARGS__);                          \
    3106             :         __ext4_grp_locked_error("", 0, sb, grp, ino, block, " ");   \
    3107             : } while (0)
    3108             : 
    3109             : #endif
    3110             : 
    3111             : extern ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
    3112             :                                       struct ext4_group_desc *bg);
    3113             : extern ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
    3114             :                                       struct ext4_group_desc *bg);
    3115             : extern ext4_fsblk_t ext4_inode_table(struct super_block *sb,
    3116             :                                      struct ext4_group_desc *bg);
    3117             : extern __u32 ext4_free_group_clusters(struct super_block *sb,
    3118             :                                       struct ext4_group_desc *bg);
    3119             : extern __u32 ext4_free_inodes_count(struct super_block *sb,
    3120             :                                  struct ext4_group_desc *bg);
    3121             : extern __u32 ext4_used_dirs_count(struct super_block *sb,
    3122             :                                 struct ext4_group_desc *bg);
    3123             : extern __u32 ext4_itable_unused_count(struct super_block *sb,
    3124             :                                    struct ext4_group_desc *bg);
    3125             : extern void ext4_block_bitmap_set(struct super_block *sb,
    3126             :                                   struct ext4_group_desc *bg, ext4_fsblk_t blk);
    3127             : extern void ext4_inode_bitmap_set(struct super_block *sb,
    3128             :                                   struct ext4_group_desc *bg, ext4_fsblk_t blk);
    3129             : extern void ext4_inode_table_set(struct super_block *sb,
    3130             :                                  struct ext4_group_desc *bg, ext4_fsblk_t blk);
    3131             : extern void ext4_free_group_clusters_set(struct super_block *sb,
    3132             :                                          struct ext4_group_desc *bg,
    3133             :                                          __u32 count);
    3134             : extern void ext4_free_inodes_set(struct super_block *sb,
    3135             :                                 struct ext4_group_desc *bg, __u32 count);
    3136             : extern void ext4_used_dirs_set(struct super_block *sb,
    3137             :                                 struct ext4_group_desc *bg, __u32 count);
    3138             : extern void ext4_itable_unused_set(struct super_block *sb,
    3139             :                                    struct ext4_group_desc *bg, __u32 count);
    3140             : extern int ext4_group_desc_csum_verify(struct super_block *sb, __u32 group,
    3141             :                                        struct ext4_group_desc *gdp);
    3142             : extern void ext4_group_desc_csum_set(struct super_block *sb, __u32 group,
    3143             :                                      struct ext4_group_desc *gdp);
    3144             : extern int ext4_register_li_request(struct super_block *sb,
    3145             :                                     ext4_group_t first_not_zeroed);
    3146             : 
    3147       38694 : static inline int ext4_has_metadata_csum(struct super_block *sb)
    3148             : {
    3149       38694 :         WARN_ON_ONCE(ext4_has_feature_metadata_csum(sb) &&
    3150             :                      !EXT4_SB(sb)->s_chksum_driver);
    3151             : 
    3152       38694 :         return ext4_has_feature_metadata_csum(sb) &&
    3153           0 :                (EXT4_SB(sb)->s_chksum_driver != NULL);
    3154             : }
    3155             : 
    3156        3617 : static inline int ext4_has_group_desc_csum(struct super_block *sb)
    3157             : {
    3158        3617 :         return ext4_has_feature_gdt_csum(sb) || ext4_has_metadata_csum(sb);
    3159             : }
    3160             : 
    3161             : #define ext4_read_incompat_64bit_val(es, name) \
    3162             :         (((es)->s_feature_incompat & cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT) \
    3163             :                 ? (ext4_fsblk_t)le32_to_cpu(es->name##_hi) << 32 : 0) | \
    3164             :                 le32_to_cpu(es->name##_lo))
    3165             : 
    3166       23151 : static inline ext4_fsblk_t ext4_blocks_count(struct ext4_super_block *es)
    3167             : {
    3168       23150 :         return ext4_read_incompat_64bit_val(es, s_blocks_count);
    3169             : }
    3170             : 
    3171        2080 : static inline ext4_fsblk_t ext4_r_blocks_count(struct ext4_super_block *es)
    3172             : {
    3173        2080 :         return ext4_read_incompat_64bit_val(es, s_r_blocks_count);
    3174             : }
    3175             : 
    3176           0 : static inline ext4_fsblk_t ext4_free_blocks_count(struct ext4_super_block *es)
    3177             : {
    3178           0 :         return ext4_read_incompat_64bit_val(es, s_free_blocks_count);
    3179             : }
    3180             : 
    3181           0 : static inline void ext4_blocks_count_set(struct ext4_super_block *es,
    3182             :                                          ext4_fsblk_t blk)
    3183             : {
    3184           0 :         es->s_blocks_count_lo = cpu_to_le32((u32)blk);
    3185           0 :         es->s_blocks_count_hi = cpu_to_le32(blk >> 32);
    3186             : }
    3187             : 
    3188           2 : static inline void ext4_free_blocks_count_set(struct ext4_super_block *es,
    3189             :                                               ext4_fsblk_t blk)
    3190             : {
    3191           2 :         es->s_free_blocks_count_lo = cpu_to_le32((u32)blk);
    3192           1 :         es->s_free_blocks_count_hi = cpu_to_le32(blk >> 32);
    3193           1 : }
    3194             : 
    3195           0 : static inline void ext4_r_blocks_count_set(struct ext4_super_block *es,
    3196             :                                            ext4_fsblk_t blk)
    3197             : {
    3198           0 :         es->s_r_blocks_count_lo = cpu_to_le32((u32)blk);
    3199           0 :         es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32);
    3200             : }
    3201             : 
    3202       15368 : static inline loff_t ext4_isize(struct super_block *sb,
    3203             :                                 struct ext4_inode *raw_inode)
    3204             : {
    3205       15368 :         if (ext4_has_feature_largedir(sb) ||
    3206       15368 :             S_ISREG(le16_to_cpu(raw_inode->i_mode)))
    3207       10330 :                 return ((loff_t)le32_to_cpu(raw_inode->i_size_high) << 32) |
    3208       10330 :                         le32_to_cpu(raw_inode->i_size_lo);
    3209             : 
    3210        5038 :         return (loff_t) le32_to_cpu(raw_inode->i_size_lo);
    3211             : }
    3212             : 
    3213         413 : static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size)
    3214             : {
    3215         413 :         raw_inode->i_size_lo = cpu_to_le32(i_size);
    3216         413 :         raw_inode->i_size_high = cpu_to_le32(i_size >> 32);
    3217             : }
    3218             : 
    3219             : static inline
    3220        8183 : struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
    3221             :                                             ext4_group_t group)
    3222             : {
    3223        8183 :          struct ext4_group_info **grp_info;
    3224        8183 :          long indexv, indexh;
    3225        8183 :          BUG_ON(group >= EXT4_SB(sb)->s_groups_count);
    3226        8183 :          indexv = group >> (EXT4_DESC_PER_BLOCK_BITS(sb));
    3227        8183 :          indexh = group & ((EXT4_DESC_PER_BLOCK(sb)) - 1);
    3228       16366 :          grp_info = sbi_array_rcu_deref(EXT4_SB(sb), s_group_info, indexv);
    3229        8183 :          return grp_info[indexh];
    3230             : }
    3231             : 
    3232             : /*
    3233             :  * Reading s_groups_count requires using smp_rmb() afterwards.  See
    3234             :  * the locking protocol documented in the comments of ext4_group_add()
    3235             :  * in resize.c
    3236             :  */
    3237       25159 : static inline ext4_group_t ext4_get_groups_count(struct super_block *sb)
    3238             : {
    3239       25159 :         ext4_group_t    ngroups = EXT4_SB(sb)->s_groups_count;
    3240             : 
    3241       25155 :         smp_rmb();
    3242       25159 :         return ngroups;
    3243             : }
    3244             : 
    3245        1462 : static inline ext4_group_t ext4_flex_group(struct ext4_sb_info *sbi,
    3246             :                                              ext4_group_t block_group)
    3247             : {
    3248        1462 :         return block_group >> sbi->s_log_groups_per_flex;
    3249             : }
    3250             : 
    3251        1437 : static inline unsigned int ext4_flex_bg_size(struct ext4_sb_info *sbi)
    3252             : {
    3253        1437 :         return 1 << sbi->s_log_groups_per_flex;
    3254             : }
    3255             : 
    3256             : #define ext4_std_error(sb, errno)                               \
    3257             : do {                                                            \
    3258             :         if ((errno))                                            \
    3259             :                 __ext4_std_error((sb), __func__, __LINE__, (errno));    \
    3260             : } while (0)
    3261             : 
    3262             : #ifdef CONFIG_SMP
    3263             : /* Each CPU can accumulate percpu_counter_batch clusters in their local
    3264             :  * counters. So we need to make sure we have free clusters more
    3265             :  * than percpu_counter_batch  * nr_cpu_ids. Also add a window of 4 times.
    3266             :  */
    3267             : #define EXT4_FREECLUSTERS_WATERMARK (4 * (percpu_counter_batch * nr_cpu_ids))
    3268             : #else
    3269             : #define EXT4_FREECLUSTERS_WATERMARK 0
    3270             : #endif
    3271             : 
    3272             : /* Update i_disksize. Requires i_mutex to avoid races with truncate */
    3273          33 : static inline void ext4_update_i_disksize(struct inode *inode, loff_t newsize)
    3274             : {
    3275          99 :         WARN_ON_ONCE(S_ISREG(inode->i_mode) &&
    3276             :                      !inode_is_locked(inode));
    3277          33 :         down_write(&EXT4_I(inode)->i_data_sem);
    3278          33 :         if (newsize > EXT4_I(inode)->i_disksize)
    3279          33 :                 WRITE_ONCE(EXT4_I(inode)->i_disksize, newsize);
    3280          33 :         up_write(&EXT4_I(inode)->i_data_sem);
    3281          33 : }
    3282             : 
    3283             : /* Update i_size, i_disksize. Requires i_mutex to avoid races with truncate */
    3284           0 : static inline int ext4_update_inode_size(struct inode *inode, loff_t newsize)
    3285             : {
    3286           0 :         int changed = 0;
    3287             : 
    3288           0 :         if (newsize > inode->i_size) {
    3289           0 :                 i_size_write(inode, newsize);
    3290           0 :                 changed = 1;
    3291             :         }
    3292           0 :         if (newsize > EXT4_I(inode)->i_disksize) {
    3293           0 :                 ext4_update_i_disksize(inode, newsize);
    3294           0 :                 changed |= 2;
    3295             :         }
    3296           0 :         return changed;
    3297             : }
    3298             : 
    3299             : int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset,
    3300             :                                       loff_t len);
    3301             : 
    3302             : struct ext4_group_info {
    3303             :         unsigned long   bb_state;
    3304             : #ifdef AGGRESSIVE_CHECK
    3305             :         unsigned long   bb_check_counter;
    3306             : #endif
    3307             :         struct rb_root  bb_free_root;
    3308             :         ext4_grpblk_t   bb_first_free;  /* first free block */
    3309             :         ext4_grpblk_t   bb_free;        /* total free blocks */
    3310             :         ext4_grpblk_t   bb_fragments;   /* nr of freespace fragments */
    3311             :         ext4_grpblk_t   bb_largest_free_order;/* order of largest frag in BG */
    3312             :         struct          list_head bb_prealloc_list;
    3313             : #ifdef DOUBLE_CHECK
    3314             :         void            *bb_bitmap;
    3315             : #endif
    3316             :         struct rw_semaphore alloc_sem;
    3317             :         ext4_grpblk_t   bb_counters[];  /* Nr of free power-of-two-block
    3318             :                                          * regions, index is order.
    3319             :                                          * bb_counters[3] = 5 means
    3320             :                                          * 5 free 8-block regions. */
    3321             : };
    3322             : 
    3323             : #define EXT4_GROUP_INFO_NEED_INIT_BIT           0
    3324             : #define EXT4_GROUP_INFO_WAS_TRIMMED_BIT         1
    3325             : #define EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT     2
    3326             : #define EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT     3
    3327             : #define EXT4_GROUP_INFO_BBITMAP_CORRUPT         \
    3328             :         (1 << EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT)
    3329             : #define EXT4_GROUP_INFO_IBITMAP_CORRUPT         \
    3330             :         (1 << EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT)
    3331             : #define EXT4_GROUP_INFO_BBITMAP_READ_BIT        4
    3332             : 
    3333             : #define EXT4_MB_GRP_NEED_INIT(grp)      \
    3334             :         (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state)))
    3335             : #define EXT4_MB_GRP_BBITMAP_CORRUPT(grp)        \
    3336             :         (test_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &((grp)->bb_state)))
    3337             : #define EXT4_MB_GRP_IBITMAP_CORRUPT(grp)        \
    3338             :         (test_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &((grp)->bb_state)))
    3339             : 
    3340             : #define EXT4_MB_GRP_WAS_TRIMMED(grp)    \
    3341             :         (test_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
    3342             : #define EXT4_MB_GRP_SET_TRIMMED(grp)    \
    3343             :         (set_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
    3344             : #define EXT4_MB_GRP_CLEAR_TRIMMED(grp)  \
    3345             :         (clear_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
    3346             : #define EXT4_MB_GRP_TEST_AND_SET_READ(grp)      \
    3347             :         (test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_READ_BIT, &((grp)->bb_state)))
    3348             : 
    3349             : #define EXT4_MAX_CONTENTION             8
    3350             : #define EXT4_CONTENTION_THRESHOLD       2
    3351             : 
    3352        8176 : static inline spinlock_t *ext4_group_lock_ptr(struct super_block *sb,
    3353             :                                               ext4_group_t group)
    3354             : {
    3355        6452 :         return bgl_lock_ptr(EXT4_SB(sb)->s_blockgroup_lock, group);
    3356             : }
    3357             : 
    3358             : /*
    3359             :  * Returns true if the filesystem is busy enough that attempts to
    3360             :  * access the block group locks has run into contention.
    3361             :  */
    3362          70 : static inline int ext4_fs_is_busy(struct ext4_sb_info *sbi)
    3363             : {
    3364          70 :         return (atomic_read(&sbi->s_lock_busy) > EXT4_CONTENTION_THRESHOLD);
    3365             : }
    3366             : 
    3367        2371 : static inline void ext4_lock_group(struct super_block *sb, ext4_group_t group)
    3368             : {
    3369        2371 :         spinlock_t *lock = ext4_group_lock_ptr(sb, group);
    3370        2371 :         if (spin_trylock(lock))
    3371             :                 /*
    3372             :                  * We're able to grab the lock right away, so drop the
    3373             :                  * lock contention counter.
    3374             :                  */
    3375        2371 :                 atomic_add_unless(&EXT4_SB(sb)->s_lock_busy, -1, 0);
    3376             :         else {
    3377             :                 /*
    3378             :                  * The lock is busy, so bump the contention counter,
    3379             :                  * and then wait on the spin lock.
    3380             :                  */
    3381           0 :                 atomic_add_unless(&EXT4_SB(sb)->s_lock_busy, 1,
    3382             :                                   EXT4_MAX_CONTENTION);
    3383           0 :                 spin_lock(lock);
    3384             :         }
    3385        2371 : }
    3386             : 
    3387        2371 : static inline void ext4_unlock_group(struct super_block *sb,
    3388             :                                         ext4_group_t group)
    3389             : {
    3390        2371 :         spin_unlock(ext4_group_lock_ptr(sb, group));
    3391           0 : }
    3392             : 
    3393             : #ifdef CONFIG_QUOTA
    3394             : static inline bool ext4_quota_capable(struct super_block *sb)
    3395             : {
    3396             :         return (test_opt(sb, QUOTA) || ext4_has_feature_quota(sb));
    3397             : }
    3398             : 
    3399             : static inline bool ext4_is_quota_journalled(struct super_block *sb)
    3400             : {
    3401             :         struct ext4_sb_info *sbi = EXT4_SB(sb);
    3402             : 
    3403             :         return (ext4_has_feature_quota(sb) ||
    3404             :                 sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]);
    3405             : }
    3406             : #endif
    3407             : 
    3408             : /*
    3409             :  * Block validity checking
    3410             :  */
    3411             : #define ext4_check_indirect_blockref(inode, bh)                         \
    3412             :         ext4_check_blockref(__func__, __LINE__, inode,                  \
    3413             :                             (__le32 *)(bh)->b_data,                  \
    3414             :                             EXT4_ADDR_PER_BLOCK((inode)->i_sb))
    3415             : 
    3416             : #define ext4_ind_check_inode(inode)                                     \
    3417             :         ext4_check_blockref(__func__, __LINE__, inode,                  \
    3418             :                             EXT4_I(inode)->i_data,                   \
    3419             :                             EXT4_NDIR_BLOCKS)
    3420             : 
    3421             : /*
    3422             :  * Inodes and files operations
    3423             :  */
    3424             : 
    3425             : /* dir.c */
    3426             : extern const struct file_operations ext4_dir_operations;
    3427             : 
    3428             : /* file.c */
    3429             : extern const struct inode_operations ext4_file_inode_operations;
    3430             : extern const struct file_operations ext4_file_operations;
    3431             : extern loff_t ext4_llseek(struct file *file, loff_t offset, int origin);
    3432             : 
    3433             : /* inline.c */
    3434             : extern int ext4_get_max_inline_size(struct inode *inode);
    3435             : extern int ext4_find_inline_data_nolock(struct inode *inode);
    3436             : extern int ext4_init_inline_data(handle_t *handle, struct inode *inode,
    3437             :                                  unsigned int len);
    3438             : extern int ext4_destroy_inline_data(handle_t *handle, struct inode *inode);
    3439             : 
    3440             : extern int ext4_readpage_inline(struct inode *inode, struct page *page);
    3441             : extern int ext4_try_to_write_inline_data(struct address_space *mapping,
    3442             :                                          struct inode *inode,
    3443             :                                          loff_t pos, unsigned len,
    3444             :                                          unsigned flags,
    3445             :                                          struct page **pagep);
    3446             : extern int ext4_write_inline_data_end(struct inode *inode,
    3447             :                                       loff_t pos, unsigned len,
    3448             :                                       unsigned copied,
    3449             :                                       struct page *page);
    3450             : extern struct buffer_head *
    3451             : ext4_journalled_write_inline_data(struct inode *inode,
    3452             :                                   unsigned len,
    3453             :                                   struct page *page);
    3454             : extern int ext4_da_write_inline_data_begin(struct address_space *mapping,
    3455             :                                            struct inode *inode,
    3456             :                                            loff_t pos, unsigned len,
    3457             :                                            unsigned flags,
    3458             :                                            struct page **pagep,
    3459             :                                            void **fsdata);
    3460             : extern int ext4_da_write_inline_data_end(struct inode *inode, loff_t pos,
    3461             :                                          unsigned len, unsigned copied,
    3462             :                                          struct page *page);
    3463             : extern int ext4_try_add_inline_entry(handle_t *handle,
    3464             :                                      struct ext4_filename *fname,
    3465             :                                      struct inode *dir, struct inode *inode);
    3466             : extern int ext4_try_create_inline_dir(handle_t *handle,
    3467             :                                       struct inode *parent,
    3468             :                                       struct inode *inode);
    3469             : extern int ext4_read_inline_dir(struct file *filp,
    3470             :                                 struct dir_context *ctx,
    3471             :                                 int *has_inline_data);
    3472             : extern int ext4_inlinedir_to_tree(struct file *dir_file,
    3473             :                                   struct inode *dir, ext4_lblk_t block,
    3474             :                                   struct dx_hash_info *hinfo,
    3475             :                                   __u32 start_hash, __u32 start_minor_hash,
    3476             :                                   int *has_inline_data);
    3477             : extern struct buffer_head *ext4_find_inline_entry(struct inode *dir,
    3478             :                                         struct ext4_filename *fname,
    3479             :                                         struct ext4_dir_entry_2 **res_dir,
    3480             :                                         int *has_inline_data);
    3481             : extern int ext4_delete_inline_entry(handle_t *handle,
    3482             :                                     struct inode *dir,
    3483             :                                     struct ext4_dir_entry_2 *de_del,
    3484             :                                     struct buffer_head *bh,
    3485             :                                     int *has_inline_data);
    3486             : extern bool empty_inline_dir(struct inode *dir, int *has_inline_data);
    3487             : extern struct buffer_head *ext4_get_first_inline_block(struct inode *inode,
    3488             :                                         struct ext4_dir_entry_2 **parent_de,
    3489             :                                         int *retval);
    3490             : extern int ext4_inline_data_fiemap(struct inode *inode,
    3491             :                                    struct fiemap_extent_info *fieinfo,
    3492             :                                    int *has_inline, __u64 start, __u64 len);
    3493             : 
    3494             : struct iomap;
    3495             : extern int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap);
    3496             : 
    3497             : extern int ext4_inline_data_truncate(struct inode *inode, int *has_inline);
    3498             : 
    3499             : extern int ext4_convert_inline_data(struct inode *inode);
    3500             : 
    3501       53906 : static inline int ext4_has_inline_data(struct inode *inode)
    3502             : {
    3503       53906 :         return ext4_test_inode_flag(inode, EXT4_INODE_INLINE_DATA) &&
    3504           0 :                EXT4_I(inode)->i_inline_off;
    3505             : }
    3506             : 
    3507             : /* namei.c */
    3508             : extern const struct inode_operations ext4_dir_inode_operations;
    3509             : extern const struct inode_operations ext4_special_inode_operations;
    3510             : extern struct dentry *ext4_get_parent(struct dentry *child);
    3511             : extern struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode,
    3512             :                                  struct ext4_dir_entry_2 *de,
    3513             :                                  int blocksize, int csum_size,
    3514             :                                  unsigned int parent_ino, int dotdot_real_len);
    3515             : extern void ext4_initialize_dirent_tail(struct buffer_head *bh,
    3516             :                                         unsigned int blocksize);
    3517             : extern int ext4_handle_dirty_dirblock(handle_t *handle, struct inode *inode,
    3518             :                                       struct buffer_head *bh);
    3519             : extern int ext4_ci_compare(const struct inode *parent,
    3520             :                            const struct qstr *fname,
    3521             :                            const struct qstr *entry, bool quick);
    3522             : extern int __ext4_unlink(handle_t *handle, struct inode *dir, const struct qstr *d_name,
    3523             :                          struct inode *inode);
    3524             : extern int __ext4_link(struct inode *dir, struct inode *inode,
    3525             :                        struct dentry *dentry);
    3526             : 
    3527             : #define S_SHIFT 12
    3528             : static const unsigned char ext4_type_by_mode[(S_IFMT >> S_SHIFT) + 1] = {
    3529             :         [S_IFREG >> S_SHIFT]      = EXT4_FT_REG_FILE,
    3530             :         [S_IFDIR >> S_SHIFT]      = EXT4_FT_DIR,
    3531             :         [S_IFCHR >> S_SHIFT]      = EXT4_FT_CHRDEV,
    3532             :         [S_IFBLK >> S_SHIFT]      = EXT4_FT_BLKDEV,
    3533             :         [S_IFIFO >> S_SHIFT]      = EXT4_FT_FIFO,
    3534             :         [S_IFSOCK >> S_SHIFT]     = EXT4_FT_SOCK,
    3535             :         [S_IFLNK >> S_SHIFT]      = EXT4_FT_SYMLINK,
    3536             : };
    3537             : 
    3538        1054 : static inline void ext4_set_de_type(struct super_block *sb,
    3539             :                                 struct ext4_dir_entry_2 *de,
    3540             :                                 umode_t mode) {
    3541        1054 :         if (ext4_has_feature_filetype(sb))
    3542        1054 :                 de->file_type = ext4_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
    3543             : }
    3544             : 
    3545             : /* readpages.c */
    3546             : extern int ext4_mpage_readpages(struct inode *inode,
    3547             :                 struct readahead_control *rac, struct page *page);
    3548             : extern int __init ext4_init_post_read_processing(void);
    3549             : extern void ext4_exit_post_read_processing(void);
    3550             : 
    3551             : /* symlink.c */
    3552             : extern const struct inode_operations ext4_encrypted_symlink_inode_operations;
    3553             : extern const struct inode_operations ext4_symlink_inode_operations;
    3554             : extern const struct inode_operations ext4_fast_symlink_inode_operations;
    3555             : 
    3556             : /* sysfs.c */
    3557             : extern int ext4_register_sysfs(struct super_block *sb);
    3558             : extern void ext4_unregister_sysfs(struct super_block *sb);
    3559             : extern int __init ext4_init_sysfs(void);
    3560             : extern void ext4_exit_sysfs(void);
    3561             : 
    3562             : /* block_validity */
    3563             : extern void ext4_release_system_zone(struct super_block *sb);
    3564             : extern int ext4_setup_system_zone(struct super_block *sb);
    3565             : extern int __init ext4_init_system_zone(void);
    3566             : extern void ext4_exit_system_zone(void);
    3567             : extern int ext4_inode_block_valid(struct inode *inode,
    3568             :                                   ext4_fsblk_t start_blk,
    3569             :                                   unsigned int count);
    3570             : extern int ext4_check_blockref(const char *, unsigned int,
    3571             :                                struct inode *, __le32 *, unsigned int);
    3572             : 
    3573             : /* extents.c */
    3574             : struct ext4_ext_path;
    3575             : struct ext4_extent;
    3576             : 
    3577             : /*
    3578             :  * Maximum number of logical blocks in a file; ext4_extent's ee_block is
    3579             :  * __le32.
    3580             :  */
    3581             : #define EXT_MAX_BLOCKS  0xffffffff
    3582             : 
    3583             : extern void ext4_ext_tree_init(handle_t *handle, struct inode *inode);
    3584             : extern int ext4_ext_index_trans_blocks(struct inode *inode, int extents);
    3585             : extern int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
    3586             :                                struct ext4_map_blocks *map, int flags);
    3587             : extern int ext4_ext_truncate(handle_t *, struct inode *);
    3588             : extern int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
    3589             :                                  ext4_lblk_t end);
    3590             : extern void ext4_ext_init(struct super_block *);
    3591             : extern void ext4_ext_release(struct super_block *);
    3592             : extern long ext4_fallocate(struct file *file, int mode, loff_t offset,
    3593             :                           loff_t len);
    3594             : extern int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode,
    3595             :                                           loff_t offset, ssize_t len);
    3596             : extern int ext4_convert_unwritten_io_end_vec(handle_t *handle,
    3597             :                                              ext4_io_end_t *io_end);
    3598             : extern int ext4_map_blocks(handle_t *handle, struct inode *inode,
    3599             :                            struct ext4_map_blocks *map, int flags);
    3600             : extern int ext4_ext_calc_credits_for_single_extent(struct inode *inode,
    3601             :                                                    int num,
    3602             :                                                    struct ext4_ext_path *path);
    3603             : extern int ext4_ext_insert_extent(handle_t *, struct inode *,
    3604             :                                   struct ext4_ext_path **,
    3605             :                                   struct ext4_extent *, int);
    3606             : extern struct ext4_ext_path *ext4_find_extent(struct inode *, ext4_lblk_t,
    3607             :                                               struct ext4_ext_path **,
    3608             :                                               int flags);
    3609             : extern void ext4_ext_drop_refs(struct ext4_ext_path *);
    3610             : extern int ext4_ext_check_inode(struct inode *inode);
    3611             : extern ext4_lblk_t ext4_ext_next_allocated_block(struct ext4_ext_path *path);
    3612             : extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
    3613             :                         __u64 start, __u64 len);
    3614             : extern int ext4_get_es_cache(struct inode *inode,
    3615             :                              struct fiemap_extent_info *fieinfo,
    3616             :                              __u64 start, __u64 len);
    3617             : extern int ext4_ext_precache(struct inode *inode);
    3618             : extern int ext4_swap_extents(handle_t *handle, struct inode *inode1,
    3619             :                                 struct inode *inode2, ext4_lblk_t lblk1,
    3620             :                              ext4_lblk_t lblk2,  ext4_lblk_t count,
    3621             :                              int mark_unwritten,int *err);
    3622             : extern int ext4_clu_mapped(struct inode *inode, ext4_lblk_t lclu);
    3623             : extern int ext4_datasem_ensure_credits(handle_t *handle, struct inode *inode,
    3624             :                                        int check_cred, int restart_cred,
    3625             :                                        int revoke_cred);
    3626             : extern void ext4_ext_replay_shrink_inode(struct inode *inode, ext4_lblk_t end);
    3627             : extern int ext4_ext_replay_set_iblocks(struct inode *inode);
    3628             : extern int ext4_ext_replay_update_ex(struct inode *inode, ext4_lblk_t start,
    3629             :                 int len, int unwritten, ext4_fsblk_t pblk);
    3630             : extern int ext4_ext_clear_bb(struct inode *inode);
    3631             : 
    3632             : 
    3633             : /* move_extent.c */
    3634             : extern void ext4_double_down_write_data_sem(struct inode *first,
    3635             :                                             struct inode *second);
    3636             : extern void ext4_double_up_write_data_sem(struct inode *orig_inode,
    3637             :                                           struct inode *donor_inode);
    3638             : extern int ext4_move_extents(struct file *o_filp, struct file *d_filp,
    3639             :                              __u64 start_orig, __u64 start_donor,
    3640             :                              __u64 len, __u64 *moved_len);
    3641             : 
    3642             : /* page-io.c */
    3643             : extern int __init ext4_init_pageio(void);
    3644             : extern void ext4_exit_pageio(void);
    3645             : extern ext4_io_end_t *ext4_init_io_end(struct inode *inode, gfp_t flags);
    3646             : extern ext4_io_end_t *ext4_get_io_end(ext4_io_end_t *io_end);
    3647             : extern int ext4_put_io_end(ext4_io_end_t *io_end);
    3648             : extern void ext4_put_io_end_defer(ext4_io_end_t *io_end);
    3649             : extern void ext4_io_submit_init(struct ext4_io_submit *io,
    3650             :                                 struct writeback_control *wbc);
    3651             : extern void ext4_end_io_rsv_work(struct work_struct *work);
    3652             : extern void ext4_io_submit(struct ext4_io_submit *io);
    3653             : extern int ext4_bio_write_page(struct ext4_io_submit *io,
    3654             :                                struct page *page,
    3655             :                                int len,
    3656             :                                bool keep_towrite);
    3657             : extern struct ext4_io_end_vec *ext4_alloc_io_end_vec(ext4_io_end_t *io_end);
    3658             : extern struct ext4_io_end_vec *ext4_last_io_end_vec(ext4_io_end_t *io_end);
    3659             : 
    3660             : /* mmp.c */
    3661             : extern int ext4_multi_mount_protect(struct super_block *, ext4_fsblk_t);
    3662             : 
    3663             : /* verity.c */
    3664             : extern const struct fsverity_operations ext4_verityops;
    3665             : 
    3666             : /*
    3667             :  * Add new method to test whether block and inode bitmaps are properly
    3668             :  * initialized. With uninit_bg reading the block from disk is not enough
    3669             :  * to mark the bitmap uptodate. We need to also zero-out the bitmap
    3670             :  */
    3671             : #define BH_BITMAP_UPTODATE BH_JBDPrivateStart
    3672             : 
    3673        1343 : static inline int bitmap_uptodate(struct buffer_head *bh)
    3674             : {
    3675        1343 :         return (buffer_uptodate(bh) &&
    3676        1299 :                         test_bit(BH_BITMAP_UPTODATE, &(bh)->b_state));
    3677             : }
    3678          22 : static inline void set_bitmap_uptodate(struct buffer_head *bh)
    3679             : {
    3680          22 :         set_bit(BH_BITMAP_UPTODATE, &(bh)->b_state);
    3681          22 : }
    3682             : 
    3683             : #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
    3684             : 
    3685             : /* For ioend & aio unwritten conversion wait queues */
    3686             : #define EXT4_WQ_HASH_SZ         37
    3687             : #define ext4_ioend_wq(v)   (&ext4__ioend_wq[((unsigned long)(v)) %\
    3688             :                                             EXT4_WQ_HASH_SZ])
    3689             : extern wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
    3690             : 
    3691             : extern int ext4_resize_begin(struct super_block *sb);
    3692             : extern void ext4_resize_end(struct super_block *sb);
    3693             : 
    3694          70 : static inline void ext4_set_io_unwritten_flag(struct inode *inode,
    3695             :                                               struct ext4_io_end *io_end)
    3696             : {
    3697          70 :         if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
    3698          70 :                 io_end->flag |= EXT4_IO_END_UNWRITTEN;
    3699          70 :                 atomic_inc(&EXT4_I(inode)->i_unwritten);
    3700             :         }
    3701          70 : }
    3702             : 
    3703          70 : static inline void ext4_clear_io_unwritten_flag(ext4_io_end_t *io_end)
    3704             : {
    3705          70 :         struct inode *inode = io_end->inode;
    3706             : 
    3707          70 :         if (io_end->flag & EXT4_IO_END_UNWRITTEN) {
    3708          70 :                 io_end->flag &= ~EXT4_IO_END_UNWRITTEN;
    3709             :                 /* Wake up anyone waiting on unwritten extent conversion */
    3710         140 :                 if (atomic_dec_and_test(&EXT4_I(inode)->i_unwritten))
    3711          63 :                         wake_up_all(ext4_ioend_wq(inode));
    3712             :         }
    3713          70 : }
    3714             : 
    3715             : extern const struct iomap_ops ext4_iomap_ops;
    3716             : extern const struct iomap_ops ext4_iomap_overwrite_ops;
    3717             : extern const struct iomap_ops ext4_iomap_report_ops;
    3718             : 
    3719       16429 : static inline int ext4_buffer_uptodate(struct buffer_head *bh)
    3720             : {
    3721             :         /*
    3722             :          * If the buffer has the write error flag, we have failed
    3723             :          * to write out data in the block.  In this  case, we don't
    3724             :          * have to read the block because we may read the old data
    3725             :          * successfully.
    3726             :          */
    3727       21011 :         if (!buffer_uptodate(bh) && buffer_write_io_error(bh))
    3728           0 :                 set_buffer_uptodate(bh);
    3729       16429 :         return buffer_uptodate(bh);
    3730             : }
    3731             : 
    3732             : #endif  /* __KERNEL__ */
    3733             : 
    3734             : #define EFSBADCRC       EBADMSG         /* Bad CRC detected */
    3735             : #define EFSCORRUPTED    EUCLEAN         /* Filesystem is corrupted */
    3736             : 
    3737             : #endif  /* _EXT4_H */

Generated by: LCOV version 1.14