ldiskfs/kernel_patches/patches/rhel7.6/ext4-introduce-aging-to-extent-status-tree.patch

   1 From 1da6da1563df986dd35080d7edcf59b739696c40 Mon Sep 17 00:00:00 2001
   2 From: Jan Kara <jack@suse.cz>
   3 Date: Tue, 25 Nov 2014 11:55:24 -0500
   4 Subject: [PATCH 7/7] ext4: introduce aging to extent status tree
   5
   6 Introduce a simple aging to extent status tree. Each extent has a
   7 REFERENCED bit which gets set when the extent is used. Shrinker then
   8 skips entries with referenced bit set and clears the bit. Thus
   9 frequently used extents have higher chances of staying in memory.
  10
  11 Signed-off-by: Jan Kara <jack@suse.cz>
  12 Signed-off-by: Theodore Ts'o <tytso@mit.edu>
  13 ---
  14  fs/ext4/extents_status.c | 22 +++++++++++++++++-----
  15  fs/ext4/extents_status.h | 35 +++++++++++++++++++++++++++++++----
  16  2 files changed, 48 insertions(+), 9 deletions(-)
  17
  18 diff --git a/fs/ext4/extents_status.c b/fs/ext4/extents_status.c
  19 index a29708c0..0305f308 100644
  20 --- a/fs/ext4/extents_status.c
  21 +++ b/fs/ext4/extents_status.c
  22 @@ -382,7 +382,7 @@ static void ext4_es_free_extent(struct inode *inode, struct extent_status *es)
  23  static int ext4_es_can_be_merged(struct extent_status *es1,
  24                                  struct extent_status *es2)
  25  {
  26 -       if (ext4_es_status(es1) != ext4_es_status(es2))
  27 +       if (ext4_es_type(es1) != ext4_es_type(es2))
  28                 return 0;
  29
  30         if (((__u64) es1->es_len) + es2->es_len > EXT_MAX_BLOCKS) {
  31 @@ -425,6 +425,8 @@ ext4_es_try_to_merge_left(struct inode *inode, struct extent_status *es)
  32         es1 = rb_entry(node, struct extent_status, rb_node);
  33         if (ext4_es_can_be_merged(es1, es)) {
  34                 es1->es_len += es->es_len;
  35 +               if (ext4_es_is_referenced(es))
  36 +                       ext4_es_set_referenced(es1);
  37                 rb_erase(&es->rb_node, &tree->root);
  38                 ext4_es_free_extent(inode, es);
  39                 es = es1;
  40 @@ -447,6 +449,8 @@ ext4_es_try_to_merge_right(struct inode *inode, struct extent_status *es)
  41         es1 = rb_entry(node, struct extent_status, rb_node);
  42         if (ext4_es_can_be_merged(es, es1)) {
  43                 es->es_len += es1->es_len;
  44 +               if (ext4_es_is_referenced(es1))
  45 +                       ext4_es_set_referenced(es);
  46                 rb_erase(node, &tree->root);
  47                 ext4_es_free_extent(inode, es1);
  48         }
  49 @@ -823,6 +827,8 @@ out:
  50                 es->es_lblk = es1->es_lblk;
  51                 es->es_len = es1->es_len;
  52                 es->es_pblk = es1->es_pblk;
  53 +               if (!ext4_es_is_referenced(es))
  54 +                       ext4_es_set_referenced(es);
  55                 stats->es_stats_cache_hits++;
  56         } else {
  57                 stats->es_stats_cache_misses++;
  58 @@ -1243,11 +1249,17 @@ static int es_do_reclaim_extents(struct ext4_inode_info *ei, ext4_lblk_t end,
  59                  * We can't reclaim delayed extent from status tree because
  60                  * fiemap, bigallic, and seek_data/hole need to use it.
  61                  */
  62 -               if (!ext4_es_is_delayed(es)) {
  63 -                       rb_erase(&es->rb_node, &tree->root);
  64 -                       ext4_es_free_extent(inode, es);
  65 -                       (*nr_shrunk)++;
  66 +               if (ext4_es_is_delayed(es))
  67 +                       goto next;
  68 +               if (ext4_es_is_referenced(es)) {
  69 +                       ext4_es_clear_referenced(es);
  70 +                       goto next;
  71                 }
  72 +
  73 +               rb_erase(&es->rb_node, &tree->root);
  74 +               ext4_es_free_extent(inode, es);
  75 +               (*nr_shrunk)++;
  76 +next:
  77                 if (!node)
  78                         goto out_wrap;
  79                 es = rb_entry(node, struct extent_status, rb_node);
  80 diff --git a/fs/ext4/extents_status.h b/fs/ext4/extents_status.h
  81 index e86b1f34..691b5261 100644
  82 --- a/fs/ext4/extents_status.h
  83 +++ b/fs/ext4/extents_status.h
  84 @@ -34,6 +34,7 @@ enum {
  85         ES_UNWRITTEN_B,
  86         ES_DELAYED_B,
  87         ES_HOLE_B,
  88 +       ES_REFERENCED_B,
  89         ES_FLAGS
  90  };
  91
  92 @@ -44,6 +45,12 @@ enum {
  93  #define EXTENT_STATUS_UNWRITTEN (1 << ES_UNWRITTEN_B)
  94  #define EXTENT_STATUS_DELAYED  (1 << ES_DELAYED_B)
  95  #define EXTENT_STATUS_HOLE     (1 << ES_HOLE_B)
  96 +#define EXTENT_STATUS_REFERENCED       (1 << ES_REFERENCED_B)
  97 +
  98 +#define ES_TYPE_MASK   ((ext4_fsblk_t)(EXTENT_STATUS_WRITTEN | \
  99 +                         EXTENT_STATUS_UNWRITTEN | \
 100 +                         EXTENT_STATUS_DELAYED | \
 101 +                         EXTENT_STATUS_HOLE) << ES_SHIFT)
 102
 103  struct ext4_sb_info;
 104  struct ext4_extent;
 105 @@ -93,24 +100,44 @@ static inline unsigned int ext4_es_status(struct extent_status *es)
 106         return es->es_pblk >> ES_SHIFT;
 107  }
 108
 109 +static inline unsigned int ext4_es_type(struct extent_status *es)
 110 +{
 111 +       return (es->es_pblk & ES_TYPE_MASK) >> ES_SHIFT;
 112 +}
 113 +
 114  static inline int ext4_es_is_written(struct extent_status *es)
 115  {
 116 -       return (ext4_es_status(es) & EXTENT_STATUS_WRITTEN) != 0;
 117 +       return (ext4_es_type(es) & EXTENT_STATUS_WRITTEN) != 0;
 118  }
 119
 120  static inline int ext4_es_is_unwritten(struct extent_status *es)
 121  {
 122 -       return (ext4_es_status(es) & EXTENT_STATUS_UNWRITTEN) != 0;
 123 +       return (ext4_es_type(es) & EXTENT_STATUS_UNWRITTEN) != 0;
 124  }
 125
 126  static inline int ext4_es_is_delayed(struct extent_status *es)
 127  {
 128 -       return (ext4_es_status(es) & EXTENT_STATUS_DELAYED) != 0;
 129 +       return (ext4_es_type(es) & EXTENT_STATUS_DELAYED) != 0;
 130  }
 131
 132  static inline int ext4_es_is_hole(struct extent_status *es)
 133  {
 134 -       return (ext4_es_status(es) & EXTENT_STATUS_HOLE) != 0;
 135 +       return (ext4_es_type(es) & EXTENT_STATUS_HOLE) != 0;
 136 +}
 137 +
 138 +static inline void ext4_es_set_referenced(struct extent_status *es)
 139 +{
 140 +       es->es_pblk |= ((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT;
 141 +}
 142 +
 143 +static inline void ext4_es_clear_referenced(struct extent_status *es)
 144 +{
 145 +       es->es_pblk &= ~(((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT);
 146 +}
 147 +
 148 +static inline int ext4_es_is_referenced(struct extent_status *es)
 149 +{
 150 +       return (ext4_es_status(es) & EXTENT_STATUS_REFERENCED) != 0;
 151  }
 152
 153  static inline ext4_fsblk_t ext4_es_pblock(struct extent_status *es)
 154 --
 155 2.24.1
 156