static void salvage_directory(ext2_filsys fs,
struct ext2_dir_entry *dirent,
struct ext2_dir_entry *prev,
- unsigned int *offset)
+ unsigned int *offset,
+ unsigned int block_len)
{
char *cp = (char *) dirent;
int left;
unsigned int name_len = ext2fs_dirent_name_len(dirent);
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
- left = fs->blocksize - *offset - rec_len;
+ left = block_len - *offset - rec_len;
/*
* Special case of directory entry of size 8: copy what's left
* previous directory entry absorb the invalid one.
*/
if (prev && rec_len && (rec_len % 4) == 0 &&
- (*offset + rec_len <= fs->blocksize)) {
+ (*offset + rec_len <= block_len)) {
(void) ext2fs_get_rec_len(fs, prev, &prev_rec_len);
prev_rec_len += rec_len;
(void) ext2fs_set_rec_len(fs, prev_rec_len, prev);
*/
if (prev) {
(void) ext2fs_get_rec_len(fs, prev, &prev_rec_len);
- prev_rec_len += fs->blocksize - *offset;
+ prev_rec_len += block_len - *offset;
(void) ext2fs_set_rec_len(fs, prev_rec_len, prev);
*offset = fs->blocksize;
} else {
- rec_len = fs->blocksize - *offset;
+ rec_len = block_len - *offset;
(void) ext2fs_set_rec_len(fs, rec_len, dirent);
ext2fs_dirent_set_name_len(dirent, 0);
ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
}
}
+static int is_last_entry(ext2_filsys fs, int inline_data_size,
+ unsigned int offset, int csum_size)
+{
+ if (inline_data_size)
+ return (offset < inline_data_size);
+ else
+ return (offset < fs->blocksize - csum_size);
+}
+
+#define NEXT_DIRENT(d) ((void *)((char *)(d) + (d)->rec_len))
+static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf)
+{
+ struct ext2_dir_entry *d;
+ void *top;
+ struct ext2_dir_entry_tail *t;
+ unsigned int rec_len;
+
+ d = dirbuf;
+ top = EXT2_DIRENT_TAIL(dirbuf, fs->blocksize);
+
+ while (d->rec_len && !(d->rec_len & 0x3) && NEXT_DIRENT(d) <= top)
+ d = NEXT_DIRENT(d);
+
+ if (d != top) {
+ size_t min_size = EXT2_DIR_REC_LEN(
+ ext2fs_dirent_name_len(dirbuf));
+ if (min_size > top - (void *)d)
+ return EXT2_ET_DIR_NO_SPACE_FOR_CSUM;
+ d->rec_len = top - (void *)d;
+ }
+
+ t = (struct ext2_dir_entry_tail *)top;
+ if (t->det_reserved_zero1 ||
+ t->det_rec_len != sizeof(struct ext2_dir_entry_tail) ||
+ t->det_reserved_name_len != EXT2_DIR_NAME_LEN_CSUM)
+ ext2fs_initialize_dirent_tail(fs, t);
+
+ return 0;
+}
+#undef NEXT_DIRENT
+
static int check_dir_block(ext2_filsys fs,
struct ext2_db_entry2 *db,
void *priv_data)
#ifdef ENABLE_HTREE
struct dx_dirblock_info *dx_db = 0;
#endif /* ENABLE_HTREE */
- struct ext2_dir_entry *dirent, *prev;
+ struct ext2_dir_entry *dirent, *prev, dot, dotdot;
ext2_dirhash_t hash;
unsigned int offset = 0;
int dir_modified = 0;
int dx_csum_size = 0, de_csum_size = 0;
int failed_csum = 0;
int is_leaf = 1;
+ size_t inline_data_size = 0;
+ int filetype = 0;
cd = (struct check_dir_struct *) priv_data;
buf = cd->buf;
de_csum_size = sizeof(struct ext2_dir_entry_tail);
}
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
+ EXT2_FEATURE_INCOMPAT_FILETYPE))
+ filetype = EXT2_FT_DIR << 8;
+
/*
* Make sure the inode is still in use (could have been
* deleted in the duplicate/bad blocks pass.
cd->pctx.dirent = 0;
cd->pctx.num = 0;
- if (db->blk == 0) {
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
+ EXT4_FEATURE_INCOMPAT_INLINE_DATA)) {
+ errcode_t ec;
+
+ ec = ext2fs_inline_data_size(fs, ino, &inline_data_size);
+ if (ec && ec != EXT2_ET_NO_INLINE_DATA)
+ return DIRENT_ABORT;
+ }
+
+ if (db->blk == 0 && !inline_data_size) {
if (allocate_dir_block(ctx, db, buf, &cd->pctx))
return 0;
block_nr = db->blk;
#endif
ehandler_operation(_("reading directory block"));
- cd->pctx.errcode = ext2fs_read_dir_block4(fs, block_nr, buf, 0, ino);
+ if (inline_data_size)
+ cd->pctx.errcode = ext2fs_inline_data_get(fs, ino, 0, buf, 0);
+ else
+ cd->pctx.errcode = ext2fs_read_dir_block4(fs, block_nr,
+ buf, 0, ino);
ehandler_operation(0);
if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED)
cd->pctx.errcode = 0; /* We'll handle this ourselves */
out_htree:
#endif /* ENABLE_HTREE */
- /* Verify checksum. */
- if (is_leaf && de_csum_size) {
- /* No space for csum? Rebuild dirs in pass 3A. */
- if (!ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
- de_csum_size = 0;
- if (e2fsck_dir_will_be_rehashed(ctx, ino))
- goto skip_checksum;
- if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_MISSING_CSUM,
- &cd->pctx))
- goto skip_checksum;
- e2fsck_rehash_dir_later(ctx, ino);
+ /* Leaf node with no space for csum? Rebuild dirs in pass 3A. */
+ if (is_leaf && !inline_data_size && failed_csum &&
+ !ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
+ de_csum_size = 0;
+ if (e2fsck_dir_will_be_rehashed(ctx, ino) ||
+ !fix_problem(cd->ctx, PR_2_LEAF_NODE_MISSING_CSUM,
+ &cd->pctx))
goto skip_checksum;
- }
- if (failed_csum) {
- char *buf2;
- if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_CSUM_INVALID,
- &cd->pctx))
- goto skip_checksum;
- ext2fs_new_dir_block(fs,
- db->blockcnt == 0 ? ino : 0,
- EXT2_ROOT_INO, &buf2);
- memcpy(buf, buf2, fs->blocksize);
- ext2fs_free_mem(&buf2);
- dir_modified++;
- failed_csum = 0;
- }
+ e2fsck_rehash_dir_later(ctx, ino);
+ goto skip_checksum;
}
/* htree nodes don't use fake dirents to store checksums */
if (!is_leaf)
unsigned int name_len;
problem = 0;
- dirent = (struct ext2_dir_entry *) (buf + offset);
- (void) ext2fs_get_rec_len(fs, dirent, &rec_len);
- cd->pctx.dirent = dirent;
- cd->pctx.num = offset;
- if (((offset + rec_len) > fs->blocksize) ||
- (rec_len < 12) ||
- ((rec_len % 4) != 0) ||
- ((ext2fs_dirent_name_len(dirent) + 8) > rec_len)) {
- if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) {
- salvage_directory(fs, dirent, prev, &offset);
- dir_modified++;
- continue;
- } else
- goto abort_free_dict;
+ if (!inline_data_size || dot_state > 1) {
+ dirent = (struct ext2_dir_entry *) (buf + offset);
+ (void) ext2fs_get_rec_len(fs, dirent, &rec_len);
+ cd->pctx.dirent = dirent;
+ cd->pctx.num = offset;
+ if (((offset + rec_len) > fs->blocksize) ||
+ (rec_len < 12) ||
+ ((rec_len % 4) != 0) ||
+ ((ext2fs_dirent_name_len(dirent) + 8) > rec_len)) {
+ if (fix_problem(ctx, PR_2_DIR_CORRUPTED,
+ &cd->pctx)) {
+ salvage_directory(fs, dirent, prev,
+ &offset,
+ fs->blocksize -
+ de_csum_size);
+ dir_modified++;
+ continue;
+ } else
+ goto abort_free_dict;
+ }
+ } else {
+ if (dot_state == 0) {
+ memset(&dot, 0, sizeof(dot));
+ dirent = ˙
+ dirent->inode = ino;
+ dirent->rec_len = EXT2_DIR_REC_LEN(1);
+ dirent->name_len = 1 | filetype;
+ dirent->name[0] = '.';
+ } else if (dot_state == 1) {
+ memset(&dotdot, 0, sizeof(dotdot));
+ dirent = &dotdot;
+ dirent->inode =
+ ((struct ext2_dir_entry *)buf)->inode;
+ dirent->rec_len = EXT2_DIR_REC_LEN(2);
+ dirent->name_len = 2 | filetype;
+ dirent->name[0] = '.';
+ dirent->name[1] = '.';
+ } else {
+ fatal_error(ctx, _("Can not continue."));
+ }
+ cd->pctx.dirent = dirent;
+ cd->pctx.num = offset;
}
if (dot_state == 0) {
prev = dirent;
if (dir_modified)
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
- offset += rec_len;
+ if (!inline_data_size || dot_state > 1) {
+ offset += rec_len;
+ } else {
+ if (dot_state == 1)
+ offset = 4;
+ }
dot_state++;
- } while (offset < fs->blocksize - de_csum_size);
+ } while (is_last_entry(fs, inline_data_size, offset, de_csum_size));
#if 0
printf("\n");
#endif
}
#endif /* ENABLE_HTREE */
- if (offset != fs->blocksize - de_csum_size) {
- cd->pctx.num = rec_len - (fs->blocksize - de_csum_size) +
- offset;
- if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
- dirent->rec_len = cd->pctx.num;
- dir_modified++;
+ if (inline_data_size) {
+ if (offset != inline_data_size) {
+ cd->pctx.num = rec_len + offset - inline_data_size;
+ if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
+ dirent->rec_len = cd->pctx.num;
+ dir_modified++;
+ }
+ }
+ } else {
+ if (offset != fs->blocksize - de_csum_size) {
+ cd->pctx.num = rec_len - (fs->blocksize - de_csum_size) +
+ offset;
+ if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
+ dirent->rec_len = cd->pctx.num;
+ dir_modified++;
+ }
}
}
if (dir_modified) {
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
is_leaf &&
- !ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf))
+ !inline_data_size &&
+ !ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
+ if (insert_dirent_tail(fs, buf) == 0)
+ goto write_and_fix;
e2fsck_rehash_dir_later(ctx, ino);
+ }
write_and_fix:
if (e2fsck_dir_will_be_rehashed(ctx, ino))
ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
- cd->pctx.errcode = ext2fs_write_dir_block4(fs, block_nr, buf,
- 0, ino);
+ if (inline_data_size) {
+ cd->pctx.errcode =
+ ext2fs_inline_data_set(fs, ino, 0, buf,
+ inline_data_size);
+ } else
+ cd->pctx.errcode = ext2fs_write_dir_block4(fs, block_nr,
+ buf, 0, ino);
if (e2fsck_dir_will_be_rehashed(ctx, ino))
ctx->fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
if (cd->pctx.errcode) {
if ((*block_nr < fs->super->s_first_data_block) ||
(*block_nr >= ext2fs_blocks_count(fs->super)))
return 0;
- ext2fs_unmark_block_bitmap2(p->ctx->block_found_map, *block_nr);
- ext2fs_block_alloc_stats2(fs, *block_nr, -1);
+ if ((*block_nr % EXT2FS_CLUSTER_RATIO(fs)) == 0)
+ ext2fs_block_alloc_stats2(fs, *block_nr, -1);
p->num++;
return 0;
}
return;
}
if (count == 0) {
- ext2fs_unmark_block_bitmap2(ctx->block_found_map,
- ext2fs_file_acl_block(fs, &inode));
ext2fs_block_alloc_stats2(fs,
ext2fs_file_acl_block(fs, &inode), -1);
}
struct problem_context *pctx)
{
ext2_filsys fs = ctx->fs;
- blk64_t blk;
+ blk64_t blk = 0;
char *block;
struct ext2_inode inode;
/*
* First, find a free block
*/
- pctx->errcode = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
- if (pctx->errcode) {
- pctx->str = "ext2fs_new_block";
- fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
- return 1;
+ e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block");
+ pctx->errcode = ext2fs_map_cluster_block(fs, db->ino, &inode,
+ db->blockcnt, &blk);
+ if (pctx->errcode || blk == 0) {
+ pctx->errcode = ext2fs_new_block2(fs, 0,
+ ctx->block_found_map, &blk);
+ if (pctx->errcode) {
+ pctx->str = "ext2fs_new_block";
+ fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
+ return 1;
+ }
}
ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
ext2fs_mark_block_bitmap2(fs->block_map, blk);
/*
* Update the inode block count
*/
- e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block");
ext2fs_iblk_add_blocks(fs, &inode, 1);
- if (inode.i_size < (db->blockcnt+1) * fs->blocksize)
- inode.i_size = (db->blockcnt+1) * fs->blocksize;
+ if (EXT2_I_SIZE(&inode) < (db->blockcnt+1) * fs->blocksize) {
+ pctx->errcode = ext2fs_inode_size_set(fs, &inode,
+ (db->blockcnt+1) * fs->blocksize);
+ if (pctx->errcode) {
+ pctx->str = "ext2fs_inode_size_set";
+ fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
+ return 1;
+ }
+ }
e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block");
/*
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff