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 <xiaoqiangnk@gmail.com>
   6  * Modified by
   7  *      Allison Henderson <achender@linux.vnet.ibm.com>
   8  *      Zheng Liu <wenqing.lz@taobao.com>
   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 #define EXTENT_STATUS_WRITTEN   (1 << ES_WRITTEN_B)
  46 #define EXTENT_STATUS_UNWRITTEN (1 << ES_UNWRITTEN_B)
  47 #define EXTENT_STATUS_DELAYED   (1 << ES_DELAYED_B)
  48 #define EXTENT_STATUS_HOLE      (1 << ES_HOLE_B)
  49 #define EXTENT_STATUS_REFERENCED        (1 << ES_REFERENCED_B)
  50
  51 #define ES_TYPE_MASK    ((ext4_fsblk_t)(EXTENT_STATUS_WRITTEN | \
  52                           EXTENT_STATUS_UNWRITTEN | \
  53                           EXTENT_STATUS_DELAYED | \
  54                           EXTENT_STATUS_HOLE) << ES_SHIFT)
  55
  56 struct ext4_sb_info;
  57 struct ext4_extent;
  58
  59 struct extent_status {
  60         struct rb_node rb_node;
  61         ext4_lblk_t es_lblk;    /* first logical block extent covers */
  62         ext4_lblk_t es_len;     /* length of extent in block */
  63         ext4_fsblk_t es_pblk;   /* first physical block */
  64 };
  65
  66 struct ext4_es_tree {
  67         struct rb_root root;
  68         struct extent_status *cache_es; /* recently accessed extent */
  69 };
  70
  71 struct ext4_es_stats {
  72         unsigned long es_stats_shrunk;
  73         struct percpu_counter es_stats_cache_hits;
  74         struct percpu_counter es_stats_cache_misses;
  75         u64 es_stats_scan_time;
  76         u64 es_stats_max_scan_time;
  77         struct percpu_counter es_stats_all_cnt;
  78         struct percpu_counter es_stats_shk_cnt;
  79 };
  80
  81 /*
  82  * Pending cluster reservations for bigalloc file systems
  83  *
  84  * A cluster with a pending reservation is a logical cluster shared by at
  85  * least one extent in the extents status tree with delayed and unwritten
  86  * status and at least one other written or unwritten extent.  The
  87  * reservation is said to be pending because a cluster reservation would
  88  * have to be taken in the event all blocks in the cluster shared with
  89  * written or unwritten extents were deleted while the delayed and
  90  * unwritten blocks remained.
  91  *
  92  * The set of pending cluster reservations is an auxiliary data structure
  93  * used with the extents status tree to implement reserved cluster/block
  94  * accounting for bigalloc file systems.  The set is kept in memory and
  95  * records all pending cluster reservations.
  96  *
  97  * Its primary function is to avoid the need to read extents from the
  98  * disk when invalidating pages as a result of a truncate, punch hole, or
  99  * collapse range operation.  Page invalidation requires a decrease in the
 100  * reserved cluster count if it results in the removal of all delayed
 101  * and unwritten extents (blocks) from a cluster that is not shared with a
 102  * written or unwritten extent, and no decrease otherwise.  Determining
 103  * whether the cluster is shared can be done by searching for a pending
 104  * reservation on it.
 105  *
 106  * Secondarily, it provides a potentially faster method for determining
 107  * whether the reserved cluster count should be increased when a physical
 108  * cluster is deallocated as a result of a truncate, punch hole, or
 109  * collapse range operation.  The necessary information is also present
 110  * in the extents status tree, but might be more rapidly accessed in
 111  * the pending reservation set in many cases due to smaller size.
 112  *
 113  * The pending cluster reservation set is implemented as a red-black tree
 114  * with the goal of minimizing per page search time overhead.
 115  */
 116
 117 struct pending_reservation {
 118         struct rb_node rb_node;
 119         ext4_lblk_t lclu;
 120 };
 121
 122 struct ext4_pending_tree {
 123         struct rb_root root;
 124 };
 125
 126 extern int __init ext4_init_es(void);
 127 extern void ext4_exit_es(void);
 128 extern void ext4_es_init_tree(struct ext4_es_tree *tree);
 129
 130 extern int ext4_es_insert_extent(struct inode *inode, ext4_lblk_t lblk,
 131                                  ext4_lblk_t len, ext4_fsblk_t pblk,
 132                                  unsigned int status);
 133 extern void ext4_es_cache_extent(struct inode *inode, ext4_lblk_t lblk,
 134                                  ext4_lblk_t len, ext4_fsblk_t pblk,
 135                                  unsigned int status);
 136 extern int ext4_es_remove_extent(struct inode *inode, ext4_lblk_t lblk,
 137                                  ext4_lblk_t len);
 138 extern void ext4_es_find_extent_range(struct inode *inode,
 139                                       int (*match_fn)(struct extent_status *es),
 140                                       ext4_lblk_t lblk, ext4_lblk_t end,
 141                                       struct extent_status *es);
 142 extern int ext4_es_lookup_extent(struct inode *inode, ext4_lblk_t lblk,
 143                                  ext4_lblk_t *next_lblk,
 144                                  struct extent_status *es);
 145 extern bool ext4_es_scan_range(struct inode *inode,
 146                                int (*matching_fn)(struct extent_status *es),
 147                                ext4_lblk_t lblk, ext4_lblk_t end);
 148 extern bool ext4_es_scan_clu(struct inode *inode,
 149                              int (*matching_fn)(struct extent_status *es),
 150                              ext4_lblk_t lblk);
 151
 152 static inline unsigned int ext4_es_status(struct extent_status *es)
 153 {
 154         return es->es_pblk >> ES_SHIFT;
 155 }
 156
 157 static inline unsigned int ext4_es_type(struct extent_status *es)
 158 {
 159         return (es->es_pblk & ES_TYPE_MASK) >> ES_SHIFT;
 160 }
 161
 162 static inline int ext4_es_is_written(struct extent_status *es)
 163 {
 164         return (ext4_es_type(es) & EXTENT_STATUS_WRITTEN) != 0;
 165 }
 166
 167 static inline int ext4_es_is_unwritten(struct extent_status *es)
 168 {
 169         return (ext4_es_type(es) & EXTENT_STATUS_UNWRITTEN) != 0;
 170 }
 171
 172 static inline int ext4_es_is_delayed(struct extent_status *es)
 173 {
 174         return (ext4_es_type(es) & EXTENT_STATUS_DELAYED) != 0;
 175 }
 176
 177 static inline int ext4_es_is_hole(struct extent_status *es)
 178 {
 179         return (ext4_es_type(es) & EXTENT_STATUS_HOLE) != 0;
 180 }
 181
 182 static inline int ext4_es_is_mapped(struct extent_status *es)
 183 {
 184         return (ext4_es_is_written(es) || ext4_es_is_unwritten(es));
 185 }
 186
 187 static inline int ext4_es_is_delonly(struct extent_status *es)
 188 {
 189         return (ext4_es_is_delayed(es) && !ext4_es_is_unwritten(es));
 190 }
 191
 192 static inline void ext4_es_set_referenced(struct extent_status *es)
 193 {
 194         es->es_pblk |= ((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT;
 195 }
 196
 197 static inline void ext4_es_clear_referenced(struct extent_status *es)
 198 {
 199         es->es_pblk &= ~(((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT);
 200 }
 201
 202 static inline int ext4_es_is_referenced(struct extent_status *es)
 203 {
 204         return (ext4_es_status(es) & EXTENT_STATUS_REFERENCED) != 0;
 205 }
 206
 207 static inline ext4_fsblk_t ext4_es_pblock(struct extent_status *es)
 208 {
 209         return es->es_pblk & ~ES_MASK;
 210 }
 211
 212 static inline ext4_fsblk_t ext4_es_show_pblock(struct extent_status *es)
 213 {
 214         ext4_fsblk_t pblock = ext4_es_pblock(es);
 215         return pblock == ~ES_MASK ? 0 : pblock;
 216 }
 217
 218 static inline void ext4_es_store_pblock(struct extent_status *es,
 219                                         ext4_fsblk_t pb)
 220 {
 221         ext4_fsblk_t block;
 222
 223         block = (pb & ~ES_MASK) | (es->es_pblk & ES_MASK);
 224         es->es_pblk = block;
 225 }
 226
 227 static inline void ext4_es_store_status(struct extent_status *es,
 228                                         unsigned int status)
 229 {
 230         es->es_pblk = (((ext4_fsblk_t)status << ES_SHIFT) & ES_MASK) |
 231                       (es->es_pblk & ~ES_MASK);
 232 }
 233
 234 static inline void ext4_es_store_pblock_status(struct extent_status *es,
 235                                                ext4_fsblk_t pb,
 236                                                unsigned int status)
 237 {
 238         es->es_pblk = (((ext4_fsblk_t)status << ES_SHIFT) & ES_MASK) |
 239                       (pb & ~ES_MASK);
 240 }
 241
 242 extern int ext4_es_register_shrinker(struct ext4_sb_info *sbi);
 243 extern void ext4_es_unregister_shrinker(struct ext4_sb_info *sbi);
 244
 245 extern int ext4_seq_es_shrinker_info_show(struct seq_file *seq, void *v);
 246
 247 extern int __init ext4_init_pending(void);
 248 extern void ext4_exit_pending(void);
 249 extern void ext4_init_pending_tree(struct ext4_pending_tree *tree);
 250 extern void ext4_remove_pending(struct inode *inode, ext4_lblk_t lblk);
 251 extern bool ext4_is_pending(struct inode *inode, ext4_lblk_t lblk);
 252 extern int ext4_es_insert_delayed_block(struct inode *inode, ext4_lblk_t lblk,
 253                                         bool allocated);
 254 extern unsigned int ext4_es_delayed_clu(struct inode *inode, ext4_lblk_t lblk,
 255                                         ext4_lblk_t len);
 256 extern void ext4_clear_inode_es(struct inode *inode);
 257
 258 #endif /* _EXT4_EXTENTS_STATUS_H */