ldiskfs/kernel_patches/patches/linux-5.8/ext4-prealloc.patch

   1 commit d8d8fd9192a54c7b8caef8cca9b7a1eb5e5e3298
   2 Author: Alex Zhuravlev <alex.zhuravlev@sun.com>
   3 AuthorDate: Thu Oct 23 10:02:19 2008 +0000
   4
   5 Subject: ext4: support for tunable preallocation window
   6 Add support for tunable preallocation window and new tunables
   7 for large/small requests.
   8
   9 Bugzilla-ID: b=12800
  10 Signed-off-by: Alex Zhuravlev <alex.zhuravlev@sun.com>
  11 Reviewed-by: Kalpak Shah <kalpak@clusterfs.com>
  12 Reviewed-by: Andreas Dilger <andreas.dilger@sun.com>
  13 ---
  14  fs/ext4/ext4.h    |    7 +
  15  fs/ext4/inode.c   |    3
  16  fs/ext4/mballoc.c |  215 +++++++++++++++++++++++++++++++++++++++++-------------
  17  fs/ext4/sysfs.c   |    8 +-
  18  4 files changed, 180 insertions(+), 53 deletions(-)
  19
  20 --- a/fs/ext4/ext4.h
  21 +++ b/fs/ext4/ext4.h
  22 @@ -1241,6 +1241,8 @@ extern void ext4_set_bits(void *bm, int
  23  /* Metadata checksum algorithm codes */
  24  #define EXT4_CRC32C_CHKSUM             1
  25
  26 +#define EXT4_MAX_PREALLOC_TABLE        64
  27 +
  28  /*
  29   * Structure of the super block
  30   */
  31 @@ -1497,11 +1499,13 @@ struct ext4_sb_info {
  32
  33         /* tunables */
  34         unsigned long s_stripe;
  35 -       unsigned int s_mb_stream_request;
  36 +       unsigned long s_mb_small_req;
  37 +       unsigned long s_mb_large_req;
  38         unsigned int s_mb_max_to_scan;
  39         unsigned int s_mb_min_to_scan;
  40         unsigned int s_mb_stats;
  41         unsigned int s_mb_order2_reqs;
  42 +       unsigned long *s_mb_prealloc_table;
  43         unsigned int s_mb_group_prealloc;
  44         unsigned int s_max_dir_size_kb;
  45         /* where last allocation was done - for stream allocation */
  46 @@ -2645,6 +2649,7 @@ extern int ext4_init_inode_table(struct
  47  extern void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate);
  48
  49  /* mballoc.c */
  50 +extern const struct proc_ops ext4_seq_prealloc_table_fops;
  51  extern const struct seq_operations ext4_mb_seq_groups_ops;
  52  extern long ext4_mb_stats;
  53  extern long ext4_mb_max_to_scan;
  54 --- a/fs/ext4/inode.c
  55 +++ b/fs/ext4/inode.c
  56 @@ -2698,6 +2698,9 @@ static int ext4_writepages(struct addres
  57                                                 PAGE_SIZE >> inode->i_blkbits);
  58         }
  59
  60 +       if (wbc->nr_to_write < sbi->s_mb_small_req)
  61 +               wbc->nr_to_write = sbi->s_mb_small_req;
  62 +
  63         if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
  64                 range_whole = 1;
  65
  66 --- a/fs/ext4/mballoc.c
  67 +++ b/fs/ext4/mballoc.c
  68 @@ -2455,6 +2455,99 @@ const struct seq_operations ext4_mb_seq_
  69         .show   = ext4_mb_seq_groups_show,
  70  };
  71
  72 +static int ext4_mb_check_and_update_prealloc(struct ext4_sb_info *sbi,
  73 +                                                char *str, size_t cnt,
  74 +                                                int update)
  75 +{
  76 +       unsigned long value;
  77 +       unsigned long prev = 0;
  78 +       char *cur;
  79 +       char *next;
  80 +       char *end;
  81 +       int num = 0;
  82 +
  83 +       cur = str;
  84 +       end = str + cnt;
  85 +       while (cur < end) {
  86 +               while ((cur < end) && (*cur == ' ')) cur++;
  87 +               value = simple_strtol(cur, &next, 0);
  88 +               if (value == 0)
  89 +                       break;
  90 +               if (cur == next)
  91 +                       return -EINVAL;
  92 +
  93 +               cur = next;
  94 +
  95 +               if (value > (sbi->s_blocks_per_group - 1 - 1 - sbi->s_itb_per_group))
  96 +                       return -EINVAL;
  97 +
  98 +               /* they should add values in order */
  99 +               if (value <= prev)
 100 +                       return -EINVAL;
 101 +
 102 +               if (update)
 103 +                       sbi->s_mb_prealloc_table[num] = value;
 104 +
 105 +               prev = value;
 106 +               num++;
 107 +       }
 108 +
 109 +       if (num > EXT4_MAX_PREALLOC_TABLE - 1)
 110 +               return -EOVERFLOW;
 111 +
 112 +       if (update)
 113 +               sbi->s_mb_prealloc_table[num] = 0;
 114 +
 115 +       return 0;
 116 +}
 117 +
 118 +static ssize_t ext4_mb_prealloc_table_proc_write(struct file *file,
 119 +                                            const char __user *buf,
 120 +                                            size_t cnt, loff_t *pos)
 121 +{
 122 +       struct ext4_sb_info *sbi = EXT4_SB(PDE_DATA(file_inode(file)));
 123 +       char str[128];
 124 +       int rc;
 125 +
 126 +       if (cnt >= sizeof(str))
 127 +               return -EINVAL;
 128 +       if (copy_from_user(str, buf, cnt))
 129 +               return -EFAULT;
 130 +
 131 +       rc = ext4_mb_check_and_update_prealloc(sbi, str, cnt, 0);
 132 +       if (rc)
 133 +               return rc;
 134 +
 135 +       rc = ext4_mb_check_and_update_prealloc(sbi, str, cnt, 1);
 136 +       return rc ? rc : cnt;
 137 +}
 138 +
 139 +static int mb_prealloc_table_seq_show(struct seq_file *m, void *v)
 140 +{
 141 +       struct ext4_sb_info *sbi = EXT4_SB(m->private);
 142 +       int i;
 143 +
 144 +       for (i = 0; i < EXT4_MAX_PREALLOC_TABLE &&
 145 +                       sbi->s_mb_prealloc_table[i] != 0; i++)
 146 +               seq_printf(m, "%ld ", sbi->s_mb_prealloc_table[i]);
 147 +       seq_printf(m, "\n");
 148 +
 149 +       return 0;
 150 +}
 151 +
 152 +static int mb_prealloc_table_seq_open(struct inode *inode, struct file *file)
 153 +{
 154 +       return single_open(file, mb_prealloc_table_seq_show, PDE_DATA(inode));
 155 +}
 156 +
 157 +const struct proc_ops ext4_seq_prealloc_table_fops = {
 158 +       .proc_open      = mb_prealloc_table_seq_open,
 159 +       .proc_read      = seq_read,
 160 +       .proc_lseek     = seq_lseek,
 161 +       .proc_release   = single_release,
 162 +       .proc_write     = ext4_mb_prealloc_table_proc_write,
 163 +};
 164 +
 165  static struct kmem_cache *get_groupinfo_cache(int blocksize_bits)
 166  {
 167         int cache_index = blocksize_bits - EXT4_MIN_BLOCK_LOG_SIZE;
 168 @@ -2685,7 +2778,7 @@ static int ext4_groupinfo_create_slab(si
 169  int ext4_mb_init(struct super_block *sb)
 170  {
 171         struct ext4_sb_info *sbi = EXT4_SB(sb);
 172 -       unsigned i, j;
 173 +       unsigned i, j, k, l;
 174         unsigned offset, offset_incr;
 175         unsigned max;
 176         int ret;
 177 @@ -2734,7 +2827,6 @@ int ext4_mb_init(struct super_block *sb)
 178         sbi->s_mb_max_to_scan = MB_DEFAULT_MAX_TO_SCAN;
 179         sbi->s_mb_min_to_scan = MB_DEFAULT_MIN_TO_SCAN;
 180         sbi->s_mb_stats = MB_DEFAULT_STATS;
 181 -       sbi->s_mb_stream_request = MB_DEFAULT_STREAM_THRESHOLD;
 182         sbi->s_mb_order2_reqs = MB_DEFAULT_ORDER2_REQS;
 183         /*
 184          * The default group preallocation is 512, which for 4k block
 185 @@ -2758,9 +2850,29 @@ int ext4_mb_init(struct super_block *sb)
 186          * RAID stripe size so that preallocations don't fragment
 187          * the stripes.
 188          */
 189 -       if (sbi->s_stripe > 1) {
 190 -               sbi->s_mb_group_prealloc = roundup(
 191 -                       sbi->s_mb_group_prealloc, sbi->s_stripe);
 192 +
 193 +       /* Allocate table once */
 194 +       sbi->s_mb_prealloc_table = kzalloc(
 195 +               EXT4_MAX_PREALLOC_TABLE * sizeof(unsigned long), GFP_NOFS);
 196 +       if (sbi->s_mb_prealloc_table == NULL) {
 197 +               ret = -ENOMEM;
 198 +               goto out;
 199 +       }
 200 +
 201 +       if (sbi->s_stripe == 0) {
 202 +               for (k = 0, l = 4; k <= 9; ++k, l *= 2)
 203 +                       sbi->s_mb_prealloc_table[k] = l;
 204 +
 205 +               sbi->s_mb_small_req = 256;
 206 +               sbi->s_mb_large_req = 1024;
 207 +               sbi->s_mb_group_prealloc = 512;
 208 +       } else {
 209 +               for (k = 0, l = sbi->s_stripe; k <= 2; ++k, l *= 2)
 210 +                       sbi->s_mb_prealloc_table[k] = l;
 211 +
 212 +               sbi->s_mb_small_req = sbi->s_stripe;
 213 +               sbi->s_mb_large_req = sbi->s_stripe * 8;
 214 +               sbi->s_mb_group_prealloc = sbi->s_stripe * 4;
 215         }
 216
 217         sbi->s_locality_groups = alloc_percpu(struct ext4_locality_group);
 218 @@ -2788,6 +2900,7 @@ out_free_locality_groups:
 219         free_percpu(sbi->s_locality_groups);
 220         sbi->s_locality_groups = NULL;
 221  out:
 222 +       kfree(sbi->s_mb_prealloc_table);
 223         kfree(sbi->s_mb_offsets);
 224         sbi->s_mb_offsets = NULL;
 225         kfree(sbi->s_mb_maxs);
 226 @@ -3057,7 +3170,6 @@ ext4_mb_mark_diskspace_used(struct ext4_
 227         int err, len;
 228
 229         BUG_ON(ac->ac_status != AC_STATUS_FOUND);
 230 -       BUG_ON(ac->ac_b_ex.fe_len <= 0);
 231
 232         sb = ac->ac_sb;
 233         sbi = EXT4_SB(sb);
 234 @@ -3187,13 +3299,14 @@ ext4_mb_normalize_request(struct ext4_al
 235                                 struct ext4_allocation_request *ar)
 236  {
 237         struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
 238 -       int bsbits, max;
 239 +       int bsbits, i, wind;
 240         ext4_lblk_t end;
 241 -       loff_t size, start_off;
 242 +       loff_t size;
 243         loff_t orig_size __maybe_unused;
 244         ext4_lblk_t start;
 245         struct ext4_inode_info *ei = EXT4_I(ac->ac_inode);
 246         struct ext4_prealloc_space *pa;
 247 +       unsigned long value, last_non_zero;
 248
 249         /* do normalize only data requests, metadata requests
 250            do not need preallocation */
 251 @@ -3222,51 +3335,46 @@ ext4_mb_normalize_request(struct ext4_al
 252         size = size << bsbits;
 253         if (size < i_size_read(ac->ac_inode))
 254                 size = i_size_read(ac->ac_inode);
 255 -       orig_size = size;
 256 +       size = (size + ac->ac_sb->s_blocksize - 1) >> bsbits;
 257 +
 258 +       start = wind = 0;
 259 +       value = last_non_zero = 0;
 260
 261 -       /* max size of free chunks */
 262 -       max = 2 << bsbits;
 263 +       /* let's choose preallocation window depending on file size */
 264 +       for (i = 0; i < EXT4_MAX_PREALLOC_TABLE; i++) {
 265 +               value = sbi->s_mb_prealloc_table[i];
 266 +               if (value == 0)
 267 +                       break;
 268 +               else
 269 +                       last_non_zero = value;
 270
 271 -#define NRL_CHECK_SIZE(req, size, max, chunk_size)     \
 272 -               (req <= (size) || max <= (chunk_size))
 273 +               if (size <= value) {
 274 +                       wind = value;
 275 +                       break;
 276 +               }
 277 +       }
 278
 279 -       /* first, try to predict filesize */
 280 -       /* XXX: should this table be tunable? */
 281 -       start_off = 0;
 282 -       if (size <= 16 * 1024) {
 283 -               size = 16 * 1024;
 284 -       } else if (size <= 32 * 1024) {
 285 -               size = 32 * 1024;
 286 -       } else if (size <= 64 * 1024) {
 287 -               size = 64 * 1024;
 288 -       } else if (size <= 128 * 1024) {
 289 -               size = 128 * 1024;
 290 -       } else if (size <= 256 * 1024) {
 291 -               size = 256 * 1024;
 292 -       } else if (size <= 512 * 1024) {
 293 -               size = 512 * 1024;
 294 -       } else if (size <= 1024 * 1024) {
 295 -               size = 1024 * 1024;
 296 -       } else if (NRL_CHECK_SIZE(size, 4 * 1024 * 1024, max, 2 * 1024)) {
 297 -               start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
 298 -                                               (21 - bsbits)) << 21;
 299 -               size = 2 * 1024 * 1024;
 300 -       } else if (NRL_CHECK_SIZE(size, 8 * 1024 * 1024, max, 4 * 1024)) {
 301 -               start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
 302 -                                                       (22 - bsbits)) << 22;
 303 -               size = 4 * 1024 * 1024;
 304 -       } else if (NRL_CHECK_SIZE(ac->ac_o_ex.fe_len,
 305 -                                       (8<<20)>>bsbits, max, 8 * 1024)) {
 306 -               start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
 307 -                                                       (23 - bsbits)) << 23;
 308 -               size = 8 * 1024 * 1024;
 309 +       if (wind == 0) {
 310 +               if (last_non_zero != 0) {
 311 +                       __u64 tstart, tend;
 312 +                       /* file is quite large, we now preallocate with
 313 +                       * the biggest configured window with regart to
 314 +                       * logical offset */
 315 +                       wind = last_non_zero;
 316 +                       tstart = ac->ac_o_ex.fe_logical;
 317 +                       do_div(tstart, wind);
 318 +                       start = tstart * wind;
 319 +                       tend = ac->ac_o_ex.fe_logical + ac->ac_o_ex.fe_len - 1;
 320 +                       do_div(tend, wind);
 321 +                       tend = tend * wind + wind;
 322 +                       size = tend - start;
 323 +               }
 324         } else {
 325 -               start_off = (loff_t) ac->ac_o_ex.fe_logical << bsbits;
 326 -               size      = (loff_t) EXT4_C2B(EXT4_SB(ac->ac_sb),
 327 -                                             ac->ac_o_ex.fe_len) << bsbits;
 328 +               size = wind;
 329         }
 330 -       size = size >> bsbits;
 331 -       start = start_off >> bsbits;
 332 +
 333 +
 334 +       orig_size = size;
 335
 336         /* don't cover already allocated blocks in selected range */
 337         if (ar->pleft && start <= ar->lleft) {
 338 @@ -3348,7 +3456,6 @@ ext4_mb_normalize_request(struct ext4_al
 339                          (unsigned long) ac->ac_o_ex.fe_logical);
 340                 BUG();
 341         }
 342 -       BUG_ON(size <= 0 || size > EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
 343
 344         /* now prepare goal request */
 345
 346 @@ -4341,11 +4448,19 @@ static void ext4_mb_group_or_file(struct
 347
 348         /* don't use group allocation for large files */
 349         size = max(size, isize);
 350 -       if (size > sbi->s_mb_stream_request) {
 351 +       if ((ac->ac_o_ex.fe_len >= sbi->s_mb_small_req) ||
 352 +           (size >= sbi->s_mb_large_req)) {
 353                 ac->ac_flags |= EXT4_MB_STREAM_ALLOC;
 354                 return;
 355         }
 356
 357 +       /*
 358 +        * request is so large that we don't care about
 359 +        * streaming - it overweights any possible seek
 360 +        */
 361 +       if (ac->ac_o_ex.fe_len >= sbi->s_mb_large_req)
 362 +               return;
 363 +
 364         BUG_ON(ac->ac_lg != NULL);
 365         /*
 366          * locality group prealloc space are per cpu. The reason for having
 367 --- a/fs/ext4/sysfs.c
 368 +++ b/fs/ext4/sysfs.c
 369 @@ -213,7 +213,8 @@ EXT4_RW_ATTR_SBI_UI(mb_stats, s_mb_stats
 370  EXT4_RW_ATTR_SBI_UI(mb_max_to_scan, s_mb_max_to_scan);
 371  EXT4_RW_ATTR_SBI_UI(mb_min_to_scan, s_mb_min_to_scan);
 372  EXT4_RW_ATTR_SBI_UI(mb_order2_req, s_mb_order2_reqs);
 373 -EXT4_RW_ATTR_SBI_UI(mb_stream_req, s_mb_stream_request);
 374 +EXT4_RW_ATTR_SBI_UI(mb_small_req, s_mb_small_req);
 375 +EXT4_RW_ATTR_SBI_UI(mb_large_req, s_mb_large_req);
 376  EXT4_RW_ATTR_SBI_UI(mb_group_prealloc, s_mb_group_prealloc);
 377  EXT4_RW_ATTR_SBI_UI(extent_max_zeroout_kb, s_extent_max_zeroout_kb);
 378  EXT4_ATTR(trigger_fs_error, 0200, trigger_test_error);
 379 @@ -255,7 +256,8 @@ static struct attribute *ext4_attrs[] =
 380         ATTR_LIST(mb_max_to_scan),
 381         ATTR_LIST(mb_min_to_scan),
 382         ATTR_LIST(mb_order2_req),
 383 -       ATTR_LIST(mb_stream_req),
 384 +       ATTR_LIST(mb_small_req),
 385 +       ATTR_LIST(mb_large_req),
 386         ATTR_LIST(mb_group_prealloc),
 387         ATTR_LIST(max_writeback_mb_bump),
 388         ATTR_LIST(extent_max_zeroout_kb),
 389 @@ -510,6 +512,8 @@ int ext4_register_sysfs(struct super_blo
 390                                 sb);
 391                 proc_create_seq_data("mb_groups", S_IRUGO, sbi->s_proc,
 392                                 &ext4_mb_seq_groups_ops, sb);
 393 +               proc_create_data("prealloc_table", S_IRUGO, sbi->s_proc,
 394 +                               &ext4_seq_prealloc_table_fops, sb);
 395         }
 396         return 0;
 397  }