fs/ext4/extents_status.h

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  fs/ext4/extents_status.h
   4  *
   5  * Written by Yongqiang Yang <[email protected]>
   6  * Modified by
   7  *      Allison Henderson <[email protected]>
   8  *      Zheng Liu <[email protected]>
   9  *
  10  */
  11
  12 #ifndef _EXT4_EXTENTS_STATUS_H
  13 #define _EXT4_EXTENTS_STATUS_H
  14
  15 /*
  16  * Turn on ES_DEBUG__ to get lots of info about extent status operations.
  17  */
  18 #ifdef ES_DEBUG__
  19 #define es_debug(fmt, ...)      printk(fmt, ##__VA_ARGS__)
  20 #else
  21 #define es_debug(fmt, ...)      no_printk(fmt, ##__VA_ARGS__)
  22 #endif
  23
  24 /*
  25  * With ES_AGGRESSIVE_TEST defined, the result of es caching will be
  26  * checked with old map_block's result.
  27  */
  28 #define ES_AGGRESSIVE_TEST__
  29
  30 /*
  31  * These flags live in the high bits of extent_status.es_pblk
  32  */
  33 enum {
  34         ES_WRITTEN_B,
  35         ES_UNWRITTEN_B,
  36         ES_DELAYED_B,
  37         ES_HOLE_B,
  38         ES_REFERENCED_B,
  39         ES_FLAGS
  40 };
  41
  42 #define ES_SHIFT (sizeof(ext4_fsblk_t)*8 - ES_FLAGS)
  43 #define ES_MASK (~((ext4_fsblk_t)0) << ES_SHIFT)
  44
  45 /*
  46  * Besides EXTENT_STATUS_REFERENCED, all these extent type masks
  47  * are exclusive, only one type can be set at a time.
  48  */
  49 #define EXTENT_STATUS_WRITTEN   (1 << ES_WRITTEN_B)
  50 #define EXTENT_STATUS_UNWRITTEN (1 << ES_UNWRITTEN_B)
  51 #define EXTENT_STATUS_DELAYED   (1 << ES_DELAYED_B)
  52 #define EXTENT_STATUS_HOLE      (1 << ES_HOLE_B)
  53 #define EXTENT_STATUS_REFERENCED        (1 << ES_REFERENCED_B)
  54
  55 #define ES_TYPE_MASK    ((ext4_fsblk_t)(EXTENT_STATUS_WRITTEN | \
  56                           EXTENT_STATUS_UNWRITTEN | \
  57                           EXTENT_STATUS_DELAYED | \
  58                           EXTENT_STATUS_HOLE))
  59
  60 #define ES_TYPE_VALID(type)     ((type) && !((type) & ((type) - 1)))
  61
  62 struct ext4_sb_info;
  63 struct ext4_extent;
  64
  65 struct extent_status {
  66         struct rb_node rb_node;
  67         ext4_lblk_t es_lblk;    /* first logical block extent covers */
  68         ext4_lblk_t es_len;     /* length of extent in block */
  69         ext4_fsblk_t es_pblk;   /* first physical block */
  70 };
  71
  72 struct ext4_es_tree {
  73         struct rb_root root;
  74         struct extent_status *cache_es; /* recently accessed extent */
  75 };
  76
  77 struct ext4_es_stats {
  78         unsigned long es_stats_shrunk;
  79         struct percpu_counter es_stats_cache_hits;
  80         struct percpu_counter es_stats_cache_misses;
  81         u64 es_stats_scan_time;
  82         u64 es_stats_max_scan_time;
  83         struct percpu_counter es_stats_all_cnt;
  84         struct percpu_counter es_stats_shk_cnt;
  85 };
  86
  87 /*
  88  * Pending cluster reservations for bigalloc file systems
  89  *
  90  * A cluster with a pending reservation is a logical cluster shared by at
  91  * least one extent in the extents status tree with delayed and unwritten
  92  * status and at least one other written or unwritten extent.  The
  93  * reservation is said to be pending because a cluster reservation would
  94  * have to be taken in the event all blocks in the cluster shared with
  95  * written or unwritten extents were deleted while the delayed and
  96  * unwritten blocks remained.
  97  *
  98  * The set of pending cluster reservations is an auxiliary data structure
  99  * used with the extents status tree to implement reserved cluster/block
 100  * accounting for bigalloc file systems.  The set is kept in memory and
 101  * records all pending cluster reservations.
 102  *
 103  * Its primary function is to avoid the need to read extents from the
 104  * disk when invalidating pages as a result of a truncate, punch hole, or
 105  * collapse range operation.  Page invalidation requires a decrease in the
 106  * reserved cluster count if it results in the removal of all delayed
 107  * and unwritten extents (blocks) from a cluster that is not shared with a
 108  * written or unwritten extent, and no decrease otherwise.  Determining
 109  * whether the cluster is shared can be done by searching for a pending
 110  * reservation on it.
 111  *
 112  * Secondarily, it provides a potentially faster method for determining
 113  * whether the reserved cluster count should be increased when a physical
 114  * cluster is deallocated as a result of a truncate, punch hole, or
 115  * collapse range operation.  The necessary information is also present
 116  * in the extents status tree, but might be more rapidly accessed in
 117  * the pending reservation set in many cases due to smaller size.
 118  *
 119  * The pending cluster reservation set is implemented as a red-black tree
 120  * with the goal of minimizing per page search time overhead.
 121  */
 122
 123 struct pending_reservation {
 124         struct rb_node rb_node;
 125         ext4_lblk_t lclu;
 126 };
 127
 128 struct ext4_pending_tree {
 129         struct rb_root root;
 130 };
 131
 132 extern int __init ext4_init_es(void);
 133 extern void ext4_exit_es(void);
 134 extern void ext4_es_init_tree(struct ext4_es_tree *tree);
 135
 136 extern void ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk,
 137                                   ext4_lblk_t len, ext4_fsblk_t pblk,
 138                                   unsigned int status,
 139                                   bool delalloc_reserve_used);
 140 extern void ext4_es_cache_extent(struct inode *inode, ext4_lblk_t lblk,
 141                                  ext4_lblk_t len, ext4_fsblk_t pblk,
 142                                  unsigned int status);
 143 extern void ext4_es_remove_extent(struct inode *inode, ext4_lblk_t lblk,
 144                                   ext4_lblk_t len);
 145 extern void ext4_es_find_extent_range(struct inode *inode,
 146                                       int (*match_fn)(struct extent_status *es),
 147                                       ext4_lblk_t lblk, ext4_lblk_t end,
 148                                       struct extent_status *es);
 149 extern int ext4_es_lookup_extent(struct inode *inode, ext4_lblk_t lblk,
 150                                  ext4_lblk_t *next_lblk,
 151                                  struct extent_status *es);
 152 extern bool ext4_es_scan_range(struct inode *inode,
 153                                int (*matching_fn)(struct extent_status *es),
 154                                ext4_lblk_t lblk, ext4_lblk_t end);
 155 extern bool ext4_es_scan_clu(struct inode *inode,
 156                              int (*matching_fn)(struct extent_status *es),
 157                              ext4_lblk_t lblk);
 158
 159 static inline unsigned int ext4_es_status(struct extent_status *es)
 160 {
 161         return es->es_pblk >> ES_SHIFT;
 162 }
 163
 164 static inline unsigned int ext4_es_type(struct extent_status *es)
 165 {
 166         return (es->es_pblk >> ES_SHIFT) & ES_TYPE_MASK;
 167 }
 168
 169 static inline int ext4_es_is_written(struct extent_status *es)
 170 {
 171         return (ext4_es_type(es) & EXTENT_STATUS_WRITTEN) != 0;
 172 }
 173
 174 static inline int ext4_es_is_unwritten(struct extent_status *es)
 175 {
 176         return (ext4_es_type(es) & EXTENT_STATUS_UNWRITTEN) != 0;
 177 }
 178
 179 static inline int ext4_es_is_delayed(struct extent_status *es)
 180 {
 181         return (ext4_es_type(es) & EXTENT_STATUS_DELAYED) != 0;
 182 }
 183
 184 static inline int ext4_es_is_hole(struct extent_status *es)
 185 {
 186         return (ext4_es_type(es) & EXTENT_STATUS_HOLE) != 0;
 187 }
 188
 189 static inline int ext4_es_is_mapped(struct extent_status *es)
 190 {
 191         return (ext4_es_is_written(es) || ext4_es_is_unwritten(es));
 192 }
 193
 194 static inline void ext4_es_set_referenced(struct extent_status *es)
 195 {
 196         es->es_pblk |= ((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT;
 197 }
 198
 199 static inline void ext4_es_clear_referenced(struct extent_status *es)
 200 {
 201         es->es_pblk &= ~(((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT);
 202 }
 203
 204 static inline int ext4_es_is_referenced(struct extent_status *es)
 205 {
 206         return (ext4_es_status(es) & EXTENT_STATUS_REFERENCED) != 0;
 207 }
 208
 209 static inline ext4_fsblk_t ext4_es_pblock(struct extent_status *es)
 210 {
 211         return es->es_pblk & ~ES_MASK;
 212 }
 213
 214 static inline ext4_fsblk_t ext4_es_show_pblock(struct extent_status *es)
 215 {
 216         ext4_fsblk_t pblock = ext4_es_pblock(es);
 217         return pblock == ~ES_MASK ? 0 : pblock;
 218 }
 219
 220 static inline void ext4_es_store_pblock(struct extent_status *es,
 221                                         ext4_fsblk_t pb)
 222 {
 223         ext4_fsblk_t block;
 224
 225         block = (pb & ~ES_MASK) | (es->es_pblk & ES_MASK);
 226         es->es_pblk = block;
 227 }
 228
 229 static inline void ext4_es_store_pblock_status(struct extent_status *es,
 230                                                ext4_fsblk_t pb,
 231                                                unsigned int status)
 232 {
 233         WARN_ON_ONCE(!ES_TYPE_VALID(status & ES_TYPE_MASK));
 234
 235         es->es_pblk = (((ext4_fsblk_t)status << ES_SHIFT) & ES_MASK) |
 236                       (pb & ~ES_MASK);
 237 }
 238
 239 extern int ext4_es_register_shrinker(struct ext4_sb_info *sbi);
 240 extern void ext4_es_unregister_shrinker(struct ext4_sb_info *sbi);
 241
 242 extern int ext4_seq_es_shrinker_info_show(struct seq_file *seq, void *v);
 243
 244 extern int __init ext4_init_pending(void);
 245 extern void ext4_exit_pending(void);
 246 extern void ext4_init_pending_tree(struct ext4_pending_tree *tree);
 247 extern void ext4_remove_pending(struct inode *inode, ext4_lblk_t lblk);
 248 extern bool ext4_is_pending(struct inode *inode, ext4_lblk_t lblk);
 249 extern void ext4_es_insert_delayed_extent(struct inode *inode, ext4_lblk_t lblk,
 250                                           ext4_lblk_t len, bool lclu_allocated,
 251                                           bool end_allocated);
 252 extern void ext4_clear_inode_es(struct inode *inode);
 253
 254 #endif /* _EXT4_EXTENTS_STATUS_H */