extents_status.h 8.0 KB

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