X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Frehash.c;h=a5fc1be1a2104ca8dc93f7a21c6300e6115cf36e;hb=10c5c5e564206197384e794caca3baca6a970c63;hp=15993b3f31ce8b9d0081461ddfe55ee072d3be92;hpb=d1154eb460efe588eaed3d439c1caaca149fa362;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/rehash.c b/e2fsck/rehash.c index 15993b3..a5fc1be 100644 --- a/e2fsck/rehash.c +++ b/e2fsck/rehash.c @@ -52,16 +52,39 @@ #include "e2fsck.h" #include "problem.h" +/* Schedule a dir to be rebuilt during pass 3A. */ +void e2fsck_rehash_dir_later(e2fsck_t ctx, ext2_ino_t ino) +{ + if (!ctx->dirs_to_hash) + ext2fs_u32_list_create(&ctx->dirs_to_hash, 50); + if (ctx->dirs_to_hash) + ext2fs_u32_list_add(ctx->dirs_to_hash, ino); +} + +/* Ask if a dir will be rebuilt during pass 3A. */ +int e2fsck_dir_will_be_rehashed(e2fsck_t ctx, ext2_ino_t ino) +{ + if (ctx->options & E2F_OPT_COMPRESS_DIRS) + return 1; + if (!ctx->dirs_to_hash) + return 0; + return ext2fs_u32_list_test(ctx->dirs_to_hash, ino); +} + +#undef REHASH_DEBUG + struct fill_dir_struct { char *buf; struct ext2_inode *inode; - int err; + ext2_ino_t ino; + errcode_t err; e2fsck_t ctx; struct hash_entry *harray; int max_array, num_array; - int dir_size; + unsigned int dir_size; int compress; ino_t parent; + ext2_ino_t dir; }; struct hash_entry { @@ -89,8 +112,8 @@ static int fill_dir_block(ext2_filsys fs, struct hash_entry *new_array, *ent; struct ext2_dir_entry *dirent; char *dir; - unsigned int offset, dir_offset, rec_len; - int hash_alg; + unsigned int offset, dir_offset, rec_len, name_len; + int hash_alg, hash_flags; if (blockcnt < 0) return 0; @@ -100,16 +123,23 @@ static int fill_dir_block(ext2_filsys fs, fd->err = EXT2_ET_DIR_CORRUPTED; return BLOCK_ABORT; } + dir = (fd->buf+offset); - if (HOLE_BLKADDR(*block_nr)) { + if (*block_nr == 0) { memset(dir, 0, fs->blocksize); dirent = (struct ext2_dir_entry *) dir; (void) ext2fs_set_rec_len(fs, fs->blocksize, dirent); } else { - fd->err = ext2fs_read_dir_block3(fs, *block_nr, dir, 0); + int flags = fs->flags; + fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + fd->err = ext2fs_read_dir_block4(fs, *block_nr, dir, 0, + fd->dir); + fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); if (fd->err) return BLOCK_ABORT; } + hash_flags = fd->inode->i_flags & EXT4_CASEFOLD_FL; hash_alg = fs->super->s_def_hash_version; if ((hash_alg <= EXT2_HASH_TEA) && (fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH)) @@ -119,20 +149,21 @@ static int fill_dir_block(ext2_filsys fs, while (dir_offset < fs->blocksize) { dirent = (struct ext2_dir_entry *) (dir + dir_offset); (void) ext2fs_get_rec_len(fs, dirent, &rec_len); + name_len = ext2fs_dirent_name_len(dirent); if (((dir_offset + rec_len) > fs->blocksize) || (rec_len < 8) || ((rec_len % 4) != 0) || - (((dirent->name_len & 0xFF)+8) > rec_len)) { + (name_len + 8 > rec_len)) { fd->err = EXT2_ET_DIR_CORRUPTED; return BLOCK_ABORT; } dir_offset += rec_len; if (dirent->inode == 0) continue; - if (!fd->compress && ((dirent->name_len&0xFF) == 1) && + if (!fd->compress && (name_len == 1) && (dirent->name[0] == '.')) continue; - if (!fd->compress && ((dirent->name_len&0xFF) == 2) && + if (!fd->compress && (name_len == 2) && (dirent->name[0] == '.') && (dirent->name[1] == '.')) { fd->parent = dirent->inode; continue; @@ -149,15 +180,16 @@ static int fill_dir_block(ext2_filsys fs, } ent = fd->harray + fd->num_array++; ent->dir = dirent; - fd->dir_size += EXT2_DIR_REC_LEN(dirent->name_len & 0xFF); + fd->dir_size += EXT2_DIR_REC_LEN(name_len); ent->ino = dirent->inode; if (fd->compress) ent->hash = ent->minor_hash = 0; else { - fd->err = ext2fs_dirhash(hash_alg, dirent->name, - dirent->name_len & 0xFF, - fs->super->s_hash_seed, - &ent->hash, &ent->minor_hash); + fd->err = ext2fs_dirhash2(hash_alg, + dirent->name, name_len, + fs->encoding, hash_flags, + fs->super->s_hash_seed, + &ent->hash, &ent->minor_hash); if (fd->err) return BLOCK_ABORT; } @@ -180,18 +212,20 @@ static EXT2_QSORT_TYPE name_cmp(const void *a, const void *b) { const struct hash_entry *he_a = (const struct hash_entry *) a; const struct hash_entry *he_b = (const struct hash_entry *) b; + unsigned int he_a_len, he_b_len, min_len; int ret; - int min_len; - min_len = he_a->dir->name_len; - if (min_len > he_b->dir->name_len) - min_len = he_b->dir->name_len; + he_a_len = ext2fs_dirent_name_len(he_a->dir); + he_b_len = ext2fs_dirent_name_len(he_b->dir); + min_len = he_a_len; + if (min_len > he_b_len) + min_len = he_b_len; - ret = strncmp(he_a->dir->name, he_b->dir->name, min_len); + ret = memcmp(he_a->dir->name, he_b->dir->name, min_len); if (ret == 0) { - if (he_a->dir->name_len > he_b->dir->name_len) + if (he_a_len > he_b_len) ret = 1; - else if (he_a->dir->name_len < he_b->dir->name_len) + else if (he_a_len < he_b_len) ret = -1; else ret = he_b->dir->inode - he_a->dir->inode; @@ -274,10 +308,10 @@ static errcode_t get_next_block(ext2_filsys fs, struct out_dir *outdir, * expand the length of the filename beyond the padding available in * the directory entry. */ -static void mutate_name(char *str, __u16 *len) +static void mutate_name(char *str, unsigned int *len) { - int i; - __u16 l = *len & 0xFF, h = *len & 0xff00; + int i; + unsigned int l = *len; /* * First check to see if it looks the name has been mutated @@ -287,14 +321,14 @@ static void mutate_name(char *str, __u16 *len) if (!isdigit(str[i])) break; } - if ((i == l-1) || (str[i] != '~')) { + if ((i == (int)l - 1) || (str[i] != '~')) { if (((l-1) & 3) < 2) l += 2; else l = (l+3) & ~3; str[l-2] = '~'; str[l-1] = '0'; - *len = l | h; + *len = l; return; } for (i = l-1; i >= 0; i--) { @@ -337,8 +371,9 @@ static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs, int i, j; int fixed = 0; char new_name[256]; - __u16 new_len; + unsigned int new_len; int hash_alg; + int hash_flags = fd->inode->i_flags & EXT4_CASEFOLD_FL; clear_problem_context(&pctx); pctx.ino = ino; @@ -352,10 +387,10 @@ static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs, ent = fd->harray + i; prev = ent - 1; if (!ent->dir->inode || - ((ent->dir->name_len & 0xFF) != - (prev->dir->name_len & 0xFF)) || - (strncmp(ent->dir->name, prev->dir->name, - ent->dir->name_len & 0xFF))) + (ext2fs_dirent_name_len(ent->dir) != + ext2fs_dirent_name_len(prev->dir)) || + memcmp(ent->dir->name, prev->dir->name, + ext2fs_dirent_name_len(ent->dir))) continue; pctx.dirent = ent->dir; if ((ent->dir->inode == prev->dir->inode) && @@ -365,29 +400,28 @@ static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs, fixed++; continue; } - memcpy(new_name, ent->dir->name, ent->dir->name_len & 0xFF); - new_len = ent->dir->name_len; + new_len = ext2fs_dirent_name_len(ent->dir); + memcpy(new_name, ent->dir->name, new_len); mutate_name(new_name, &new_len); for (j=0; j < fd->num_array; j++) { if ((i==j) || - ((ent->dir->name_len & 0xFF) != - (fd->harray[j].dir->name_len & 0xFF)) || - (strncmp(new_name, fd->harray[j].dir->name, - new_len & 0xFF))) + (new_len != + (unsigned) ext2fs_dirent_name_len(fd->harray[j].dir)) || + memcmp(new_name, fd->harray[j].dir->name, new_len)) continue; mutate_name(new_name, &new_len); j = -1; } - new_name[new_len & 0xFF] = 0; + new_name[new_len] = 0; pctx.str = new_name; if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) { - memcpy(ent->dir->name, new_name, new_len & 0xFF); - ent->dir->name_len = new_len; - ext2fs_dirhash(hash_alg, ent->dir->name, - ent->dir->name_len & 0xFF, - fs->super->s_hash_seed, - &ent->hash, &ent->minor_hash); + memcpy(ent->dir->name, new_name, new_len); + ext2fs_dirent_set_name_len(ent->dir, new_len); + ext2fs_dirhash2(hash_alg, new_name, new_len, + fs->encoding, hash_flags, + fs->super->s_hash_seed, + &ent->hash, &ent->minor_hash); fixed++; } } @@ -404,10 +438,11 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, char *block_start; struct hash_entry *ent; struct ext2_dir_entry *dirent; - unsigned int rec_len, prev_rec_len; - int i, left; + unsigned int rec_len, prev_rec_len, left, slack, offset; + int i; ext2_dirhash_t prev_hash; - int offset, slack; + int csum_size = 0; + struct ext2_dir_entry_tail *t; if (ctx->htree_slack_percentage == 255) { profile_get_uint(ctx->profile, "options", @@ -418,6 +453,9 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, ctx->htree_slack_percentage = 20; } + if (ext2fs_has_feature_metadata_csum(fs->super)) + csum_size = sizeof(struct ext2_dir_entry_tail); + outdir->max = 0; retval = alloc_size_dir(fs, outdir, (fd->dir_size / fs->blocksize) + 2); @@ -432,16 +470,16 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, dirent = (struct ext2_dir_entry *) block_start; prev_rec_len = 0; rec_len = 0; - left = fs->blocksize; + left = fs->blocksize - csum_size; slack = fd->compress ? 12 : - (fs->blocksize * ctx->htree_slack_percentage)/100; + ((fs->blocksize - csum_size) * ctx->htree_slack_percentage)/100; if (slack < 12) slack = 12; for (i = 0; i < fd->num_array; i++) { ent = fd->harray + i; if (ent->dir->inode == 0) continue; - rec_len = EXT2_DIR_REC_LEN(ent->dir->name_len & 0xFF); + rec_len = EXT2_DIR_REC_LEN(ext2fs_dirent_name_len(ent->dir)); if (rec_len > left) { if (left) { left += prev_rec_len; @@ -449,12 +487,17 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, if (retval) return retval; } + if (csum_size) { + t = EXT2_DIRENT_TAIL(block_start, + fs->blocksize); + ext2fs_initialize_dirent_tail(fs, t); + } if ((retval = get_next_block(fs, outdir, &block_start))) return retval; offset = 0; } - left = fs->blocksize - offset; + left = (fs->blocksize - csum_size) - offset; dirent = (struct ext2_dir_entry *) (block_start + offset); if (offset == 0) { if (ent->hash == prev_hash) @@ -463,12 +506,16 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, outdir->hashes[outdir->num-1] = ent->hash; } dirent->inode = ent->dir->inode; - dirent->name_len = ent->dir->name_len; + ext2fs_dirent_set_name_len(dirent, + ext2fs_dirent_name_len(ent->dir)); + ext2fs_dirent_set_file_type(dirent, + ext2fs_dirent_file_type(ent->dir)); retval = ext2fs_set_rec_len(fs, rec_len, dirent); if (retval) return retval; prev_rec_len = rec_len; - memcpy(dirent->name, ent->dir->name, dirent->name_len & 0xFF); + memcpy(dirent->name, ent->dir->name, + ext2fs_dirent_name_len(dirent)); offset += rec_len; left -= rec_len; if (left < slack) { @@ -483,6 +530,10 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, } if (left) retval = ext2fs_set_rec_len(fs, rec_len + left, dirent); + if (csum_size) { + t = EXT2_DIRENT_TAIL(block_start, fs->blocksize); + ext2fs_initialize_dirent_tail(fs, t); + } return retval; } @@ -495,21 +546,24 @@ static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf, struct ext2_dx_root_info *root; struct ext2_dx_countlimit *limits; int filetype = 0; + int csum_size = 0; - if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_FILETYPE) - filetype = EXT2_FT_DIR << 8; + if (ext2fs_has_feature_filetype(fs->super)) + filetype = EXT2_FT_DIR; memset(buf, 0, fs->blocksize); dir = (struct ext2_dir_entry *) buf; dir->inode = ino; dir->name[0] = '.'; - dir->name_len = 1 | filetype; + ext2fs_dirent_set_name_len(dir, 1); + ext2fs_dirent_set_file_type(dir, filetype); dir->rec_len = 12; dir = (struct ext2_dir_entry *) (buf + 12); dir->inode = parent; dir->name[0] = '.'; dir->name[1] = '.'; - dir->name_len = 2 | filetype; + ext2fs_dirent_set_name_len(dir, 2); + ext2fs_dirent_set_file_type(dir, filetype); dir->rec_len = fs->blocksize - 12; root = (struct ext2_dx_root_info *) (buf+24); @@ -519,8 +573,12 @@ static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf, root->indirect_levels = 0; root->unused_flags = 0; + if (ext2fs_has_feature_metadata_csum(fs->super)) + csum_size = sizeof(struct ext2_dx_tail); + limits = (struct ext2_dx_countlimit *) (buf+32); - limits->limit = (fs->blocksize - 32) / sizeof(struct ext2_dx_entry); + limits->limit = (fs->blocksize - (32 + csum_size)) / + sizeof(struct ext2_dx_entry); limits->count = 0; return root; @@ -531,19 +589,61 @@ static struct ext2_dx_entry *set_int_node(ext2_filsys fs, char *buf) { struct ext2_dir_entry *dir; struct ext2_dx_countlimit *limits; + int csum_size = 0; memset(buf, 0, fs->blocksize); dir = (struct ext2_dir_entry *) buf; dir->inode = 0; (void) ext2fs_set_rec_len(fs, fs->blocksize, dir); + if (ext2fs_has_feature_metadata_csum(fs->super)) + csum_size = sizeof(struct ext2_dx_tail); + limits = (struct ext2_dx_countlimit *) (buf+8); - limits->limit = (fs->blocksize - 8) / sizeof(struct ext2_dx_entry); + limits->limit = (fs->blocksize - (8 + csum_size)) / + sizeof(struct ext2_dx_entry); limits->count = 0; return (struct ext2_dx_entry *) limits; } +static int alloc_blocks(ext2_filsys fs, + struct ext2_dx_countlimit **limit, + struct ext2_dx_entry **prev_ent, + struct ext2_dx_entry **next_ent, + int *prev_offset, int *next_offset, + struct out_dir *outdir, int i, + int *prev_count, int *next_count) +{ + errcode_t retval; + char *block_start; + + if (*limit) + (*limit)->limit = (*limit)->count = + ext2fs_cpu_to_le16((*limit)->limit); + *prev_ent = (struct ext2_dx_entry *) (outdir->buf + *prev_offset); + (*prev_ent)->block = ext2fs_cpu_to_le32(outdir->num); + + if (i != 1) + (*prev_ent)->hash = + ext2fs_cpu_to_le32(outdir->hashes[i]); + + retval = get_next_block(fs, outdir, &block_start); + if (retval) + return retval; + + *next_ent = set_int_node(fs, block_start); + *limit = (struct ext2_dx_countlimit *)(*next_ent); + if (next_offset) + *next_offset = ((char *) *next_ent - outdir->buf); + + *next_count = (*limit)->limit; + (*prev_offset) += sizeof(struct ext2_dx_entry); + (*prev_count)--; + + return 0; +} + /* * This function takes the leaf nodes which have been written in * outdir, and populates the root node and any necessary interior nodes. @@ -553,13 +653,12 @@ static errcode_t calculate_tree(ext2_filsys fs, ext2_ino_t ino, ext2_ino_t parent) { - struct ext2_dx_root_info *root_info; - struct ext2_dx_entry *root, *dx_ent = 0; - struct ext2_dx_countlimit *root_limit, *limit; + struct ext2_dx_root_info *root_info; + struct ext2_dx_entry *root, *int_ent, *dx_ent = 0; + struct ext2_dx_countlimit *root_limit, *int_limit, *limit; errcode_t retval; - char * block_start; - int i, c1, c2, nblks; - int limit_offset, root_offset; + int i, c1, c2, c3, nblks; + int limit_offset, int_offset, root_offset; root_info = set_root_node(fs, outdir->buf, ino, parent); root_offset = limit_offset = ((char *) root_info - outdir->buf) + @@ -569,7 +668,7 @@ static errcode_t calculate_tree(ext2_filsys fs, nblks = outdir->num; /* Write out the pointer blocks */ - if (nblks-1 <= c1) { + if (nblks - 1 <= c1) { /* Just write out the root block, and we're done */ root = (struct ext2_dx_entry *) (outdir->buf + root_offset); for (i=1; i < nblks; i++) { @@ -580,31 +679,20 @@ static errcode_t calculate_tree(ext2_filsys fs, root++; c1--; } - } else { + } else if (nblks - 1 <= ext2fs_htree_intnode_maxrecs(fs, c1)) { c2 = 0; - limit = 0; + limit = NULL; root_info->indirect_levels = 1; for (i=1; i < nblks; i++) { - if (c1 == 0) + if (c2 == 0 && c1 == 0) return ENOSPC; if (c2 == 0) { - if (limit) - limit->limit = limit->count = - ext2fs_cpu_to_le16(limit->limit); - root = (struct ext2_dx_entry *) - (outdir->buf + root_offset); - root->block = ext2fs_cpu_to_le32(outdir->num); - if (i != 1) - root->hash = - ext2fs_cpu_to_le32(outdir->hashes[i]); - if ((retval = get_next_block(fs, outdir, - &block_start))) + retval = alloc_blocks(fs, &limit, &root, + &dx_ent, &root_offset, + NULL, outdir, i, &c1, + &c2); + if (retval) return retval; - dx_ent = set_int_node(fs, block_start); - limit = (struct ext2_dx_countlimit *) dx_ent; - c2 = limit->limit; - root_offset += sizeof(struct ext2_dx_entry); - c1--; } dx_ent->block = ext2fs_cpu_to_le32(i); if (c2 != limit->limit) @@ -615,6 +703,45 @@ static errcode_t calculate_tree(ext2_filsys fs, } limit->count = ext2fs_cpu_to_le16(limit->limit - c2); limit->limit = ext2fs_cpu_to_le16(limit->limit); + } else { + c2 = 0; + c3 = 0; + limit = NULL; + int_limit = 0; + root_info->indirect_levels = 2; + for (i = 1; i < nblks; i++) { + if (c3 == 0 && c2 == 0 && c1 == 0) + return ENOSPC; + if (c3 == 0 && c2 == 0) { + retval = alloc_blocks(fs, &int_limit, &root, + &int_ent, &root_offset, + &int_offset, outdir, i, + &c1, &c2); + if (retval) + return retval; + } + if (c3 == 0) { + retval = alloc_blocks(fs, &limit, &int_ent, + &dx_ent, &int_offset, + NULL, outdir, i, &c2, + &c3); + if (retval) + return retval; + + } + dx_ent->block = ext2fs_cpu_to_le32(i); + if (c3 != limit->limit) + dx_ent->hash = + ext2fs_cpu_to_le32(outdir->hashes[i]); + dx_ent++; + c3--; + } + int_limit->count = ext2fs_cpu_to_le16(limit->limit - c2); + int_limit->limit = ext2fs_cpu_to_le16(limit->limit); + + limit->count = ext2fs_cpu_to_le16(limit->limit - c3); + limit->limit = ext2fs_cpu_to_le16(limit->limit); + } root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset); root_limit->count = ext2fs_cpu_to_le16(root_limit->limit - c1); @@ -626,8 +753,9 @@ static errcode_t calculate_tree(ext2_filsys fs, struct write_dir_struct { struct out_dir *outdir; errcode_t err; + ext2_ino_t ino; e2fsck_t ctx; - int cleared; + ext2_ino_t dir; }; /* @@ -641,25 +769,41 @@ static int write_dir_block(ext2_filsys fs, void *priv_data) { struct write_dir_struct *wd = (struct write_dir_struct *) priv_data; - blk64_t blk; - char *dir; + char *dir, *buf = 0; - if (*block_nr == 0) +#ifdef REHASH_DEBUG + printf("%u: write_dir_block %lld:%lld", wd->ino, blockcnt, *block_nr); +#endif + if ((*block_nr == 0) || (blockcnt < 0)) { +#ifdef REHASH_DEBUG + printf(" - skip\n"); +#endif return 0; - if (blockcnt >= wd->outdir->num) { - e2fsck_read_bitmaps(wd->ctx); - blk = *block_nr; - ext2fs_unmark_block_bitmap2(wd->ctx->block_found_map, blk); - ext2fs_block_alloc_stats2(fs, blk, -1); - *block_nr = 0; - wd->cleared++; - return BLOCK_CHANGED; } - if (blockcnt < 0) + if (blockcnt < wd->outdir->num) + dir = wd->outdir->buf + (blockcnt * fs->blocksize); + else if (wd->ctx->lost_and_found == wd->dir) { + /* Don't release any extra directory blocks for lost+found */ + wd->err = ext2fs_new_dir_block(fs, 0, 0, &buf); + if (wd->err) + return BLOCK_ABORT; + dir = buf; + wd->outdir->num++; + } else { + /* Don't free blocks at the end of the directory, they + * will be truncated by the caller. */ +#ifdef REHASH_DEBUG + printf(" - not freed\n"); +#endif return 0; + } + wd->err = ext2fs_write_dir_block4(fs, *block_nr, dir, 0, wd->dir); + if (buf) + ext2fs_free_mem(&buf); - dir = wd->outdir->buf + (blockcnt * fs->blocksize); - wd->err = ext2fs_write_dir_block3(fs, *block_nr, dir, 0); +#ifdef REHASH_DEBUG + printf(" - write (%d)\n", wd->err); +#endif if (wd->err) return BLOCK_ABORT; return 0; @@ -667,11 +811,11 @@ static int write_dir_block(ext2_filsys fs, static errcode_t write_directory(e2fsck_t ctx, ext2_filsys fs, struct out_dir *outdir, - ext2_ino_t ino, int compress) + ext2_ino_t ino, struct ext2_inode *inode, + int compress) { struct write_dir_struct wd; errcode_t retval; - struct ext2_inode inode; retval = e2fsck_expand_directory(ctx, ino, -1, outdir->num); if (retval) @@ -679,61 +823,68 @@ static errcode_t write_directory(e2fsck_t ctx, ext2_filsys fs, wd.outdir = outdir; wd.err = 0; + wd.ino = ino; wd.ctx = ctx; - wd.cleared = 0; + wd.dir = ino; - retval = ext2fs_block_iterate3(fs, ino, 0, 0, + retval = ext2fs_block_iterate3(fs, ino, 0, NULL, write_dir_block, &wd); if (retval) return retval; if (wd.err) return wd.err; - e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); + e2fsck_read_inode(ctx, ino, inode, "rehash_dir"); if (compress) - inode.i_flags &= ~EXT2_INDEX_FL; + inode->i_flags &= ~EXT2_INDEX_FL; else - inode.i_flags |= EXT2_INDEX_FL; - inode.i_size = outdir->num * fs->blocksize; - ext2fs_iblk_sub_blocks(fs, &inode, wd.cleared); - e2fsck_write_inode(ctx, ino, &inode, "rehash_dir"); + inode->i_flags |= EXT2_INDEX_FL; +#ifdef REHASH_DEBUG + printf("%u: set inode size to %u blocks = %u bytes\n", + ino, outdir->num, outdir->num * fs->blocksize); +#endif + retval = ext2fs_inode_size_set(fs, inode, (ext2_off64_t)outdir->num * + fs->blocksize); + if (retval) + return retval; - return 0; + /* ext2fs_punch() calls ext2fs_write_inode() which writes the size */ + return ext2fs_punch(fs, ino, inode, NULL, outdir->num, ~0ULL); } -errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino) +errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino, + struct problem_context *pctx) { ext2_filsys fs = ctx->fs; errcode_t retval; struct ext2_inode inode; char *dir_buf = 0; - struct fill_dir_struct fd; - struct out_dir outdir; + struct fill_dir_struct fd = { NULL, NULL, 0, 0, 0, NULL, + 0, 0, 0, 0, 0, 0 }; + struct out_dir outdir = { 0, 0, 0, 0 }; - outdir.max = outdir.num = 0; - outdir.buf = 0; - outdir.hashes = 0; e2fsck_read_inode(ctx, ino, &inode, "rehash_dir"); + if (ext2fs_has_feature_inline_data(fs->super) && + (inode.i_flags & EXT4_INLINE_DATA_FL)) + return 0; + retval = ENOMEM; - fd.harray = 0; dir_buf = malloc(inode.i_size); if (!dir_buf) goto errout; fd.max_array = inode.i_size / 32; - fd.num_array = 0; fd.harray = malloc(fd.max_array * sizeof(struct hash_entry)); if (!fd.harray) goto errout; + fd.ino = ino; fd.ctx = ctx; fd.buf = dir_buf; fd.inode = &inode; - fd.err = 0; - fd.dir_size = 0; - fd.compress = 0; - if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) || + fd.dir = ino; + if (!ext2fs_has_feature_dir_index(fs->super) || (inode.i_size / fs->blocksize) < 2) fd.compress = 1; fd.parent = 0; @@ -765,7 +916,7 @@ retry_nohash: /* Sort the list */ resort: - if (fd.compress) + if (fd.compress && fd.num_array > 1) qsort(fd.harray+2, fd.num_array-2, sizeof(struct hash_entry), hash_cmp); else @@ -784,7 +935,7 @@ resort: } /* Sort non-hashed directories by inode number */ - if (fd.compress) + if (fd.compress && fd.num_array > 1) qsort(fd.harray+2, fd.num_array-2, sizeof(struct hash_entry), ino_cmp); @@ -805,10 +956,14 @@ resort: goto errout; } - retval = write_directory(ctx, fs, &outdir, ino, fd.compress); + retval = write_directory(ctx, fs, &outdir, ino, &inode, fd.compress); if (retval) goto errout; + if (ctx->options & E2F_OPT_CONVERT_BMAP) + retval = e2fsck_rebuild_extents_later(ctx, ino); + else + retval = e2fsck_check_rebuild_extents(ctx, ino, &inode, pctx); errout: free(dir_buf); free(fd.harray); @@ -828,7 +983,7 @@ void e2fsck_rehash_directories(e2fsck_t ctx) struct dir_info_iter * dirinfo_iter = 0; ext2_ino_t ino; errcode_t retval; - int cur, max, all_dirs, dir_index, first = 1; + int cur, max, all_dirs, first = 1; init_resource_track(&rtrack, ctx->fs->io); all_dirs = ctx->options & E2F_OPT_COMPRESS_DIRS; @@ -836,11 +991,10 @@ void e2fsck_rehash_directories(e2fsck_t ctx) if (!ctx->dirs_to_hash && !all_dirs) return; - e2fsck_get_lost_and_found(ctx, 0); + (void) e2fsck_get_lost_and_found(ctx, 0); clear_problem_context(&pctx); - dir_index = ctx->fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX; cur = 0; if (all_dirs) { dirinfo_iter = e2fsck_dir_info_iter_begin(ctx); @@ -865,8 +1019,7 @@ void e2fsck_rehash_directories(e2fsck_t ctx) if (!ext2fs_u32_list_iterate(iter, &ino)) break; } - if (ino == ctx->lost_and_found) - continue; + pctx.dir = ino; if (first) { fix_problem(ctx, PR_3A_PASS_HEADER, &pctx); @@ -875,7 +1028,7 @@ void e2fsck_rehash_directories(e2fsck_t ctx) #if 0 fix_problem(ctx, PR_3A_OPTIMIZE_DIR, &pctx); #endif - pctx.errcode = e2fsck_rehash_dir(ctx, ino); + pctx.errcode = e2fsck_rehash_dir(ctx, ino, &pctx); if (pctx.errcode) { end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR); fix_problem(ctx, PR_3A_OPTIMIZE_DIR_ERR, &pctx);