ldiskfs/kernel_patches/patches/rhel6.3/ext4-large-dir.patch

   1 This INCOMPAT_LARGEDIR feature allows larger directories
   2 to be created in ldiskfs, both with directory sizes over
   3 2GB and and a maximum htree depth of 3 instead of the
   4 current limit of 2. These features are needed in order
   5 to exceed the current limit of approximately 10M entries
   6 in a single directory.
   7
   8 Index: linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/ext4.h
   9 ===================================================================
  10 --- linux-2.6.32-504.3.3.el6.x86_64.orig/fs/ext4/ext4.h
  11 +++ linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/ext4.h
  12 @@ -1344,6 +1344,7 @@ EXT4_INODE_BIT_FNS(state, state_flags)
  13  #define EXT4_FEATURE_INCOMPAT_FLEX_BG          0x0200
  14  #define EXT4_FEATURE_INCOMPAT_EA_INODE         0x0400
  15  #define EXT4_FEATURE_INCOMPAT_DIRDATA          0x1000
  16 +#define EXT4_FEATURE_INCOMPAT_LARGEDIR         0x4000
  17
  18  #define EXT4_FEATURE_COMPAT_SUPP       EXT2_FEATURE_COMPAT_EXT_ATTR
  19  #define EXT4_FEATURE_INCOMPAT_SUPP     (EXT4_FEATURE_INCOMPAT_FILETYPE| \
  20 @@ -1354,7 +1355,8 @@ EXT4_INODE_BIT_FNS(state, state_flags)
  21                                          EXT4_FEATURE_INCOMPAT_FLEX_BG| \
  22                                          EXT4_FEATURE_INCOMPAT_EA_INODE| \
  23                                          EXT4_FEATURE_INCOMPAT_MMP| \
  24 -                                        EXT4_FEATURE_INCOMPAT_DIRDATA)
  25 +                                        EXT4_FEATURE_INCOMPAT_DIRDATA| \
  26 +                                        EXT4_FEATURE_INCOMPAT_LARGEDIR)
  27
  28  #define EXT4_FEATURE_RO_COMPAT_SUPP    (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
  29                                          EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
  30 @@ -1612,6 +1614,17 @@ ext4_group_first_block_no(struct super_b
  31   */
  32  #define ERR_BAD_DX_DIR -75000
  33
  34 +/* htree levels for ext4 */
  35 +#define EXT4_HTREE_LEVEL_COMPAT 2
  36 +#define EXT4_HTREE_LEVEL       3
  37 +
  38 +static inline int
  39 +ext4_dir_htree_level(struct super_block *sb)
  40 +{
  41 +       return EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_LARGEDIR) ?
  42 +               EXT4_HTREE_LEVEL : EXT4_HTREE_LEVEL_COMPAT;
  43 +}
  44 +
  45  void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
  46                         ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp);
  47
  48 @@ -2005,13 +2018,15 @@ static inline void ext4_r_blocks_count_s
  49         es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32);
  50  }
  51
  52 -static inline loff_t ext4_isize(struct ext4_inode *raw_inode)
  53 +static inline loff_t ext4_isize(struct super_block *sb,
  54 +                               struct ext4_inode *raw_inode)
  55  {
  56 -       if (S_ISREG(le16_to_cpu(raw_inode->i_mode)))
  57 +       if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_LARGEDIR) ||
  58 +           S_ISREG(le16_to_cpu(raw_inode->i_mode)))
  59                 return ((loff_t)le32_to_cpu(raw_inode->i_size_high) << 32) |
  60                         le32_to_cpu(raw_inode->i_size_lo);
  61 -       else
  62 -               return (loff_t) le32_to_cpu(raw_inode->i_size_lo);
  63 +
  64 +       return (loff_t) le32_to_cpu(raw_inode->i_size_lo);
  65  }
  66
  67  static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size)
  68 Index: linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/inode.c
  69 ===================================================================
  70 --- linux-2.6.32-504.3.3.el6.x86_64.orig/fs/ext4/inode.c
  71 +++ linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/inode.c
  72 @@ -5470,7 +5470,7 @@ struct inode *ext4_iget(struct super_blo
  73         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
  74                 ei->i_file_acl |=
  75                         ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
  76 -       inode->i_size = ext4_isize(raw_inode);
  77 +       inode->i_size = ext4_isize(sb, raw_inode);
  78         ei->i_disksize = inode->i_size;
  79  #ifdef CONFIG_QUOTA
  80         ei->i_reserved_quota = 0;
  81 Index: linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/namei.c
  82 ===================================================================
  83 --- linux-2.6.32-504.3.3.el6.x86_64.orig/fs/ext4/namei.c
  84 +++ linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/namei.c
  85 @@ -225,7 +225,7 @@ struct dx_root_info * dx_get_dx_info(str
  86
  87  static inline ext4_lblk_t dx_get_block(struct dx_entry *entry)
  88  {
  89 -       return le32_to_cpu(entry->block) & 0x00ffffff;
  90 +       return le32_to_cpu(entry->block) & 0x0fffffff;
  91  }
  92
  93  static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
  94 @@ -388,7 +388,7 @@ dx_probe(const struct qstr *d_name, stru
  95         struct dx_frame *frame = frame_in;
  96         u32 hash;
  97
  98 -       frame->bh = NULL;
  99 +       memset(frame_in, 0, EXT4_HTREE_LEVEL * sizeof(frame_in[0]));
 100         if (!(bh = ext4_bread (NULL,dir, 0, 0, err)))
 101                 goto fail;
 102
 103 @@ -418,9 +418,16 @@ dx_probe(const struct qstr *d_name, stru
 104                 goto fail;
 105         }
 106
 107 -       if ((indirect = info->indirect_levels) > 1) {
 108 -               ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x",
 109 -                            info->indirect_levels);
 110 +       indirect = info->indirect_levels;
 111 +       if (indirect >= ext4_dir_htree_level(dir->i_sb)) {
 112 +               ext4_warning(dir->i_sb,
 113 +                            "Directory (ino: %lu) htree depth %#06x exceed "
 114 +                            "supported value", dir->i_ino,
 115 +                            ext4_dir_htree_level(dir->i_sb));
 116 +               if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) {
 117 +                       ext4_warning(dir->i_sb, "Enable large directory "
 118 +                                               "feature to access it");
 119 +               }
 120                 brelse(bh);
 121                 *err = ERR_BAD_DX_DIR;
 122                 goto fail;
 123 @@ -512,13 +519,18 @@ fail:
 124  static void dx_release (struct dx_frame *frames)
 125  {
 126         struct dx_root_info *info;
 127 +       int i;
 128 +
 129         if (frames[0].bh == NULL)
 130                 return;
 131
 132         info = dx_get_dx_info((struct ext4_dir_entry_2*)frames[0].bh->b_data);
 133 -       if (info->indirect_levels)
 134 -               brelse(frames[1].bh);
 135 -       brelse(frames[0].bh);
 136 +       for (i = 0; i <= info->indirect_levels; i++) {
 137 +               if (frames[i].bh == NULL)
 138 +                       break;
 139 +               brelse(frames[i].bh);
 140 +               frames[i].bh = NULL;
 141 +       }
 142  }
 143
 144  /*
 145 @@ -661,7 +673,7 @@ int ext4_htree_fill_tree(struct file *di
 146  {
 147         struct dx_hash_info hinfo;
 148         struct ext4_dir_entry_2 *de;
 149 -       struct dx_frame frames[2], *frame;
 150 +       struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
 151         struct inode *dir;
 152         ext4_lblk_t block;
 153         int count = 0;
 154 @@ -1003,7 +1015,7 @@ static struct buffer_head * ext4_dx_find
 155         struct super_block * sb;
 156         struct dx_hash_info     hinfo;
 157         u32 hash;
 158 -       struct dx_frame frames[2], *frame;
 159 +       struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
 160         struct ext4_dir_entry_2 *de, *top;
 161         struct buffer_head *bh;
 162         ext4_lblk_t block;
 163 @@ -1443,7 +1455,7 @@ static int add_dirent_to_buf(handle_t *h
 164          */
 165         dir->i_mtime = dir->i_ctime = ext4_current_time(dir);
 166         ext4_update_dx_flag(dir);
 167 -       dir->i_version++;
 168 +       inode_inc_iversion(dir);
 169         ext4_mark_inode_dirty(handle, dir);
 170         BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
 171         err = ext4_handle_dirty_metadata(handle, dir, bh);
 172 @@ -1463,7 +1475,7 @@ static int make_indexed_dir(handle_t *ha
 173         const char      *name = dentry->d_name.name;
 174         int             namelen = dentry->d_name.len;
 175         struct buffer_head *bh2;
 176 -       struct dx_frame frames[2], *frame;
 177 +       struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
 178         struct dx_entry *entries;
 179         struct ext4_dir_entry_2 *de, *de2, *dot_de, *dotdot_de;
 180         char            *data1, *top;
 181 @@ -1712,15 +1724,18 @@ static int ext4_add_entry(handle_t *hand
 182  static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
 183                              struct inode *inode)
 184  {
 185 -       struct dx_frame frames[2], *frame;
 186 +       struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
 187         struct dx_entry *entries, *at;
 188         struct dx_hash_info hinfo;
 189         struct buffer_head *bh;
 190         struct inode *dir = dentry->d_parent->d_inode;
 191         struct super_block *sb = dir->i_sb;
 192         struct ext4_dir_entry_2 *de;
 193 +       int restart;
 194         int err;
 195
 196 +again:
 197 +       restart = 0;
 198         frame = dx_probe(&dentry->d_name, dir, &hinfo, frames, &err);
 199         if (!frame)
 200                 return err;
 201 @@ -1730,33 +1745,48 @@ static int ext4_dx_add_entry(handle_t *h
 202         if (!(bh = ext4_bread(handle,dir, dx_get_block(frame->at), 0, &err)))
 203                 goto cleanup;
 204
 205 -       BUFFER_TRACE(bh, "get_write_access");
 206 -       err = ext4_journal_get_write_access(handle, bh);
 207 -       if (err)
 208 -               goto journal_error;
 209 -
 210         err = add_dirent_to_buf(handle, dentry, inode, NULL, bh);
 211         if (err != -ENOSPC)
 212                 goto cleanup;
 213
 214 +       err = 0;
 215         /* Block full, should compress but for now just split */
 216         dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
 217                        dx_get_count(entries), dx_get_limit(entries)));
 218         /* Need to split index? */
 219         if (dx_get_count(entries) == dx_get_limit(entries)) {
 220                 ext4_lblk_t newblock;
 221 -               unsigned icount = dx_get_count(entries);
 222 -               int levels = frame - frames;
 223 +               int levels = frame - frames + 1;
 224 +               unsigned icount;
 225 +               int add_level = 1;
 226                 struct dx_entry *entries2;
 227                 struct dx_node *node2;
 228                 struct buffer_head *bh2;
 229
 230 -               if (levels && (dx_get_count(frames->entries) ==
 231 -                              dx_get_limit(frames->entries))) {
 232 -                       ext4_warning(sb, "Directory index full!");
 233 +               while (frame > frames) {
 234 +                       if (dx_get_count((frame - 1)->entries) <
 235 +                           dx_get_limit((frame - 1)->entries)) {
 236 +                               add_level = 0;
 237 +                               break;
 238 +                       }
 239 +                       frame--; /* split higher index block */
 240 +                       at = frame->at;
 241 +                       entries = frame->entries;
 242 +                       restart = 1;
 243 +               }
 244 +               if (add_level && levels == ext4_dir_htree_level(sb)) {
 245 +                       ext4_warning(sb, "Directory (ino: %lu) index full, "
 246 +                                        "reach max htree level :%d",
 247 +                                        dir->i_ino, levels);
 248 +                       if (ext4_dir_htree_level(sb) < EXT4_HTREE_LEVEL) {
 249 +                               ext4_warning(sb, "Large directory feature is"
 250 +                                                "not enabled on this "
 251 +                                                "filesystem");
 252 +                       }
 253                         err = -ENOSPC;
 254                         goto cleanup;
 255                 }
 256 +               icount = dx_get_count(entries);
 257                 bh2 = ext4_append (handle, dir, &newblock, &err);
 258                 if (!(bh2))
 259                         goto cleanup;
 260 @@ -1769,7 +1799,7 @@ static int ext4_dx_add_entry(handle_t *h
 261                 err = ext4_journal_get_write_access(handle, frame->bh);
 262                 if (err)
 263                         goto journal_error;
 264 -               if (levels) {
 265 +               if (!add_level) {
 266                         unsigned icount1 = icount/2, icount2 = icount - icount1;
 267                         unsigned hash2 = dx_get_hash(entries + icount1);
 268                         dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
 269 @@ -1777,7 +1807,7 @@ static int ext4_dx_add_entry(handle_t *h
 270
 271                         BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
 272                         err = ext4_journal_get_write_access(handle,
 273 -                                                            frames[0].bh);
 274 +                                                           (frame - 1)->bh);
 275                         if (err)
 276                                 goto journal_error;
 277
 278 @@ -1793,18 +1823,24 @@ static int ext4_dx_add_entry(handle_t *h
 279                                 frame->entries = entries = entries2;
 280                                 swap(frame->bh, bh2);
 281                         }
 282 -                       dx_insert_block(frames + 0, hash2, newblock);
 283 -                       dxtrace(dx_show_index("node", frames[1].entries));
 284 +                       dx_insert_block((frame - 1), hash2, newblock);
 285 +                       dxtrace(dx_show_index("node", frame->entries));
 286                         dxtrace(dx_show_index("node",
 287                                ((struct dx_node *) bh2->b_data)->entries));
 288                         err = ext4_handle_dirty_metadata(handle, dir, bh2);
 289                         if (err)
 290                                 goto journal_error;
 291                         brelse (bh2);
 292 +                       ext4_handle_dirty_metadata(handle, dir,
 293 +                                                  (frame - 1)->bh);
 294 +                       if (restart) {
 295 +                               ext4_handle_dirty_metadata(handle, dir,
 296 +                                                          frame->bh);
 297 +                               goto cleanup;
 298 +                       }
 299                 } else {
 300                         struct dx_root_info * info;
 301 -                       dxtrace(printk(KERN_DEBUG
 302 -                                      "Creating second level index...\n"));
 303 +
 304                         memcpy((char *) entries2, (char *) entries,
 305                                icount * sizeof(struct dx_entry));
 306                         dx_set_limit(entries2, dx_node_limit(dir));
 307 @@ -1814,19 +1850,16 @@ static int ext4_dx_add_entry(handle_t *h
 308                         dx_set_block(entries + 0, newblock);
 309                         info = dx_get_dx_info((struct ext4_dir_entry_2*)
 310                                         frames[0].bh->b_data);
 311 -                       info->indirect_levels = 1;
 312 -
 313 -                       /* Add new access path frame */
 314 -                       frame = frames + 1;
 315 -                       frame->at = at = at - entries + entries2;
 316 -                       frame->entries = entries = entries2;
 317 -                       frame->bh = bh2;
 318 -                       err = ext4_journal_get_write_access(handle,
 319 -                                                            frame->bh);
 320 -                       if (err)
 321 -                               goto journal_error;
 322 +                       info->indirect_levels += 1;
 323 +                       dxtrace(printk(KERN_DEBUG
 324 +                                      "Creating %d level index...\n",
 325 +                                      info->indirect_levels));
 326 +                       ext4_handle_dirty_metadata(handle, dir, frame->bh);
 327 +                       ext4_handle_dirty_metadata(handle, dir, bh2);
 328 +                       brelse(bh2);
 329 +                       restart = 1;
 330 +                       goto cleanup;
 331                 }
 332 -               err = ext4_handle_dirty_metadata(handle, dir, frames[0].bh);
 333                 if (err) {
 334                         ext4_std_error(inode->i_sb, err);
 335                         goto cleanup;
 336 @@ -1840,6 +1873,10 @@ cleanup:
 337         if (bh)
 338                 brelse(bh);
 339         dx_release(frames);
 340 +       /* @restart is true means htree-path has been changed, we need to
 341 +        * repeat dx_probe() to find out valid htree-path */
 342 +       if (restart && err == 0)
 343 +               goto again;
 344         return err;
 345  }
 346
 347 @@ -1874,7 +1911,7 @@ int ext4_delete_entry(handle_t *handle,
 348                                         blocksize);
 349                         else
 350                                 de->inode = 0;
 351 -                       dir->i_version++;
 352 +                       inode_inc_iversion(dir);
 353                         BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
 354                         ext4_handle_dirty_metadata(handle, dir, bh);
 355                         return 0;