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         unsigned long es_stats_cache_hits;
  74         unsigned long 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                                  struct extent_status *es);
 144 extern bool ext4_es_scan_range(struct inode *inode,
 145                                int (*matching_fn)(struct extent_status *es),
 146                                ext4_lblk_t lblk, ext4_lblk_t end);
 147 extern bool ext4_es_scan_clu(struct inode *inode,
 148                              int (*matching_fn)(struct extent_status *es),
 149                              ext4_lblk_t lblk);
 150
 151 static inline unsigned int ext4_es_status(struct extent_status *es)
 152 {
 153         return es->es_pblk >> ES_SHIFT;
 154 }
 155
 156 static inline unsigned int ext4_es_type(struct extent_status *es)
 157 {
 158         return (es->es_pblk & ES_TYPE_MASK) >> ES_SHIFT;
 159 }
 160
 161 static inline int ext4_es_is_written(struct extent_status *es)
 162 {
 163         return (ext4_es_type(es) & EXTENT_STATUS_WRITTEN) != 0;
 164 }
 165
 166 static inline int ext4_es_is_unwritten(struct extent_status *es)
 167 {
 168         return (ext4_es_type(es) & EXTENT_STATUS_UNWRITTEN) != 0;
 169 }
 170
 171 static inline int ext4_es_is_delayed(struct extent_status *es)
 172 {
 173         return (ext4_es_type(es) & EXTENT_STATUS_DELAYED) != 0;
 174 }
 175
 176 static inline int ext4_es_is_hole(struct extent_status *es)
 177 {
 178         return (ext4_es_type(es) & EXTENT_STATUS_HOLE) != 0;
 179 }
 180
 181 static inline int ext4_es_is_mapped(struct extent_status *es)
 182 {
 183         return (ext4_es_is_written(es) || ext4_es_is_unwritten(es));
 184 }
 185
 186 static inline int ext4_es_is_delonly(struct extent_status *es)
 187 {
 188         return (ext4_es_is_delayed(es) && !ext4_es_is_unwritten(es));
 189 }
 190
 191 static inline void ext4_es_set_referenced(struct extent_status *es)
 192 {
 193         es->es_pblk |= ((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT;
 194 }
 195
 196 static inline void ext4_es_clear_referenced(struct extent_status *es)
 197 {
 198         es->es_pblk &= ~(((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT);
 199 }
 200
 201 static inline int ext4_es_is_referenced(struct extent_status *es)
 202 {
 203         return (ext4_es_status(es) & EXTENT_STATUS_REFERENCED) != 0;
 204 }
 205
 206 static inline ext4_fsblk_t ext4_es_pblock(struct extent_status *es)
 207 {
 208         return es->es_pblk & ~ES_MASK;
 209 }
 210
 211 static inline void ext4_es_store_pblock(struct extent_status *es,
 212                                         ext4_fsblk_t pb)
 213 {
 214         ext4_fsblk_t block;
 215
 216         block = (pb & ~ES_MASK) | (es->es_pblk & ES_MASK);
 217         es->es_pblk = block;
 218 }
 219
 220 static inline void ext4_es_store_status(struct extent_status *es,
 221                                         unsigned int status)
 222 {
 223         es->es_pblk = (((ext4_fsblk_t)status << ES_SHIFT) & ES_MASK) |
 224                       (es->es_pblk & ~ES_MASK);
 225 }
 226
 227 static inline void ext4_es_store_pblock_status(struct extent_status *es,
 228                                                ext4_fsblk_t pb,
 229                                                unsigned int status)
 230 {
 231         es->es_pblk = (((ext4_fsblk_t)status << ES_SHIFT) & ES_MASK) |
 232                       (pb & ~ES_MASK);
 233 }
 234
 235 extern int ext4_es_register_shrinker(struct ext4_sb_info *sbi);
 236 extern void ext4_es_unregister_shrinker(struct ext4_sb_info *sbi);
 237
 238 extern int ext4_seq_es_shrinker_info_show(struct seq_file *seq, void *v);
 239
 240 extern int __init ext4_init_pending(void);
 241 extern void ext4_exit_pending(void);
 242 extern void ext4_init_pending_tree(struct ext4_pending_tree *tree);
 243 extern void ext4_remove_pending(struct inode *inode, ext4_lblk_t lblk);
 244 extern bool ext4_is_pending(struct inode *inode, ext4_lblk_t lblk);
 245 extern int ext4_es_insert_delayed_block(struct inode *inode, ext4_lblk_t lblk,
 246                                         bool allocated);
 247 extern unsigned int ext4_es_delayed_clu(struct inode *inode, ext4_lblk_t lblk,
 248                                         ext4_lblk_t len);
 249 extern void ext4_es_remove_blks(struct inode *inode, ext4_lblk_t lblk,
 250                                 ext4_lblk_t len);
 251
 252 #endif /* _EXT4_EXTENTS_STATUS_H */