static errcode_t
ext2fs_inline_data_dir_expand(ext2_filsys fs, ext2_ino_t ino,
struct ext2_inode *inode, char *buf, size_t size)
{
errcode_t retval;
blk64_t blk;
char *blk_buf;
retval = ext2fs_get_memzero(fs->blocksize, &blk_buf);
if (retval)
return retval;
#ifdef WORDS_BIGENDIAN
retval = ext2fs_dirent_swab_in2(fs, buf + EXT4_INLINE_DATA_DOTDOT_SIZE,
size, 0);
if (retval)
goto errout;
#endif
/* Adjust the rec_len */
retval = ext2fs_inline_data_convert_dir(fs, ino, blk_buf, buf, size);
if (retval)
goto errout;
/* Allocate a new block */
retval = ext2fs_new_block2(fs, 0, 0, &blk);
if (retval)
goto errout;
retval = ext2fs_write_dir_block4(fs, blk, blk_buf, 0, ino);
if (retval)
goto errout;
/* Update inode */
if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT3_FEATURE_INCOMPAT_EXTENTS))
inode->i_flags |= EXT4_EXTENTS_FL;
inode->i_flags &= ~EXT4_INLINE_DATA_FL;
retval = ext2fs_iblk_add_blocks(fs, inode, 1);
if (retval)
goto errout;
inode->i_size = fs->blocksize;
retval = ext2fs_bmap2(fs, ino, inode, 0, BMAP_SET, 0, 0, &blk);
if (retval)
goto errout;
retval = ext2fs_write_inode(fs, ino, inode);
if (retval)
goto errout;
ext2fs_block_alloc_stats(fs, blk, +1);
errout:
ext2fs_free_mem(&blk_buf);
return retval;
}
/*
* Helper function which writes out a directory block.
*/
static int write_dir_block(ext2_filsys fs,
blk64_t *block_nr,
e2_blkcnt_t blockcnt,
blk64_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct write_dir_struct *wd = (struct write_dir_struct *) priv_data;
blk64_t blk;
char *dir, *buf = 0;
if (*block_nr == 0)
return 0;
if (blockcnt < 0)
return 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 {
/* We don't need this block, so release it */
e2fsck_read_bitmaps(wd->ctx);
blk = *block_nr;
/*
* In theory, we only release blocks from the end of the
* directory file, so it's fine to clobber a whole cluster at
* once.
*/
if (blk % EXT2FS_CLUSTER_RATIO(fs) == 0) {
ext2fs_block_alloc_stats2(fs, blk, -1);
wd->cleared++;
}
*block_nr = 0;
return BLOCK_CHANGED;
}
wd->err = ext2fs_write_dir_block4(fs, *block_nr, dir, 0, wd->dir);
if (buf)
ext2fs_free_mem(&buf);
if (wd->err)
return BLOCK_ABORT;
return 0;
}
/*
* Helper function which writes out a directory block.
*/
static int write_dir_block(ext2_filsys fs,
blk64_t *block_nr,
e2_blkcnt_t blockcnt,
blk64_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct write_dir_struct *wd = (struct write_dir_struct *) priv_data;
blk64_t blk;
char *dir, *buf = 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)
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);
#ifdef REHASH_DEBUG
printf(" - write (%d)\n", wd->err);
#endif
if (wd->err)
return BLOCK_ABORT;
return 0;
}
/*
* This routine gets the lost_and_found inode, making it a directory
* if necessary
*/
ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix)
{
ext2_filsys fs = ctx->fs;
ext2_ino_t ino;
blk64_t blk;
errcode_t retval;
struct ext2_inode inode;
char * block;
static const char name[] = "lost+found";
struct problem_context pctx;
if (ctx->lost_and_found)
return ctx->lost_and_found;
clear_problem_context(&pctx);
retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name,
sizeof(name)-1, 0, &ino);
if (retval && !fix)
return 0;
if (!retval) {
if (ext2fs_check_directory(fs, ino) == 0) {
ctx->lost_and_found = ino;
return ino;
}
/* Lost+found isn't a directory! */
if (!fix)
return 0;
pctx.ino = ino;
if (!fix_problem(ctx, PR_3_LPF_NOTDIR, &pctx))
return 0;
/* OK, unlink the old /lost+found file. */
pctx.errcode = ext2fs_unlink(fs, EXT2_ROOT_INO, name, ino, 0);
if (pctx.errcode) {
pctx.str = "ext2fs_unlink";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
(void) e2fsck_dir_info_set_parent(ctx, ino, 0);
e2fsck_adjust_inode_count(ctx, ino, -1);
} else if (retval != EXT2_ET_FILE_NOT_FOUND) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx);
}
if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0))
return 0;
/*
* Read the inode and block bitmaps in; we'll be messing with
* them.
*/
e2fsck_read_bitmaps(ctx);
/*
* First, find a free block
*/
retval = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx);
return 0;
}
ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
ext2fs_block_alloc_stats2(fs, blk, +1);
/*
* Next find a free inode.
*/
retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700,
ctx->inode_used_map, &ino);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx);
return 0;
}
ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino);
ext2fs_inode_alloc_stats2(fs, ino, +1, 1);
/*
* Now let's create the actual data block for the inode
*/
retval = ext2fs_new_dir_block(fs, ino, EXT2_ROOT_INO, &block);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_DIR_BLOCK, &pctx);
return 0;
}
retval = ext2fs_write_dir_block4(fs, blk, block, 0, ino);
ext2fs_free_mem(&block);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx);
return 0;
}
/*
* Set up the inode structure
*/
memset(&inode, 0, sizeof(inode));
inode.i_mode = 040700;
inode.i_size = fs->blocksize;
inode.i_atime = inode.i_ctime = inode.i_mtime = ctx->now;
inode.i_links_count = 2;
ext2fs_iblk_set(fs, &inode, 1);
inode.i_block[0] = blk;
/*
* Next, write out the inode.
*/
pctx.errcode = ext2fs_write_new_inode(fs, ino, &inode);
if (pctx.errcode) {
pctx.str = "ext2fs_write_inode";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
/*
* Finally, create the directory link
*/
pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR);
if (pctx.errcode) {
pctx.str = "ext2fs_link";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
/*
* Miscellaneous bookkeeping that needs to be kept straight.
*/
e2fsck_add_dir_info(ctx, ino, EXT2_ROOT_INO);
e2fsck_adjust_inode_count(ctx, EXT2_ROOT_INO, 1);
ext2fs_icount_store(ctx->inode_count, ino, 2);
ext2fs_icount_store(ctx->inode_link_info, ino, 2);
ctx->lost_and_found = ino;
quota_data_add(ctx->qctx, &inode, ino, fs->blocksize);
quota_data_inodes(ctx->qctx, &inode, ino, +1);
#if 0
printf("/lost+found created; inode #%lu\n", ino);
#endif
return ino;
}
/*
* This makes sure the root inode is present; if not, we ask if the
* user wants us to create it. Not creating it is a fatal error.
*/
static void check_root(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
blk64_t blk;
struct ext2_inode inode;
char * block;
struct problem_context pctx;
clear_problem_context(&pctx);
if (ext2fs_test_inode_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO)) {
/*
* If the root inode is not a directory, die here. The
* user must have answered 'no' in pass1 when we
* offered to clear it.
*/
if (!(ext2fs_test_inode_bitmap2(ctx->inode_dir_map,
EXT2_ROOT_INO))) {
fix_problem(ctx, PR_3_ROOT_NOT_DIR_ABORT, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
}
return;
}
if (!fix_problem(ctx, PR_3_NO_ROOT_INODE, &pctx)) {
fix_problem(ctx, PR_3_NO_ROOT_INODE_ABORT, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
e2fsck_read_bitmaps(ctx);
/*
* 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_3_CREATE_ROOT_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
ext2fs_mark_block_bitmap2(fs->block_map, blk);
ext2fs_mark_bb_dirty(fs);
/*
* Now let's create the actual data block for the inode
*/
pctx.errcode = ext2fs_new_dir_block(fs, EXT2_ROOT_INO, EXT2_ROOT_INO,
&block);
if (pctx.errcode) {
pctx.str = "ext2fs_new_dir_block";
fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
pctx.errcode = ext2fs_write_dir_block4(fs, blk, block, 0,
EXT2_ROOT_INO);
if (pctx.errcode) {
pctx.str = "ext2fs_write_dir_block";
fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
ext2fs_free_mem(&block);
/*
* Set up the inode structure
*/
memset(&inode, 0, sizeof(inode));
inode.i_mode = 040755;
inode.i_size = fs->blocksize;
inode.i_atime = inode.i_ctime = inode.i_mtime = ctx->now;
inode.i_links_count = 2;
ext2fs_iblk_set(fs, &inode, 1);
inode.i_block[0] = blk;
/*
* Write out the inode.
*/
pctx.errcode = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode);
if (pctx.errcode) {
pctx.str = "ext2fs_write_inode";
fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
/*
* Miscellaneous bookkeeping...
*/
e2fsck_add_dir_info(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO);
ext2fs_icount_store(ctx->inode_count, EXT2_ROOT_INO, 2);
ext2fs_icount_store(ctx->inode_link_info, EXT2_ROOT_INO, 2);
ext2fs_mark_inode_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO);
ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, EXT2_ROOT_INO);
ext2fs_mark_inode_bitmap2(fs->inode_map, EXT2_ROOT_INO);
ext2fs_mark_ib_dirty(fs);
}
static int check_dir_block(ext2_filsys fs,
struct ext2_db_entry2 *db,
void *priv_data)
{
struct dx_dir_info *dx_dir;
#ifdef ENABLE_HTREE
struct dx_dirblock_info *dx_db = 0;
#endif /* ENABLE_HTREE */
struct ext2_dir_entry *dirent, *prev;
ext2_dirhash_t hash;
unsigned int offset = 0;
int dir_modified = 0;
int dot_state;
unsigned int rec_len;
blk64_t block_nr = db->blk;
ext2_ino_t ino = db->ino;
ext2_ino_t subdir_parent;
__u16 links;
struct check_dir_struct *cd;
char *buf;
e2fsck_t ctx;
int problem;
struct ext2_dx_root_info *root;
struct ext2_dx_countlimit *limit;
static dict_t de_dict;
struct problem_context pctx;
int dups_found = 0;
int ret;
int dx_csum_size = 0, de_csum_size = 0;
int failed_csum = 0;
int is_leaf = 1;
cd = (struct check_dir_struct *) priv_data;
buf = cd->buf;
ctx = cd->ctx;
if (ctx->flags & E2F_FLAG_SIGNAL_MASK || ctx->flags & E2F_FLAG_RESTART)
return DIRENT_ABORT;
if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max))
return DIRENT_ABORT;
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
dx_csum_size = sizeof(struct ext2_dx_tail);
de_csum_size = sizeof(struct ext2_dir_entry_tail);
}
/*
* Make sure the inode is still in use (could have been
* deleted in the duplicate/bad blocks pass.
*/
if (!(ext2fs_test_inode_bitmap2(ctx->inode_used_map, ino)))
return 0;
cd->pctx.ino = ino;
cd->pctx.blk = block_nr;
cd->pctx.blkcount = db->blockcnt;
cd->pctx.ino2 = 0;
cd->pctx.dirent = 0;
cd->pctx.num = 0;
if (db->blk == 0) {
if (allocate_dir_block(ctx, db, buf, &cd->pctx))
return 0;
block_nr = db->blk;
}
if (db->blockcnt)
dot_state = 2;
else
dot_state = 0;
if (ctx->dirs_to_hash &&
ext2fs_u32_list_test(ctx->dirs_to_hash, ino))
dups_found++;
#if 0
printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr,
db->blockcnt, ino);
#endif
ehandler_operation(_("reading directory block"));
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 */
else if (cd->pctx.errcode == EXT2_ET_DIR_CSUM_INVALID) {
cd->pctx.errcode = 0; /* We'll handle this ourselves */
failed_csum = 1;
}
if (cd->pctx.errcode) {
char *buf2;
if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) {
ctx->flags |= E2F_FLAG_ABORT;
return DIRENT_ABORT;
}
ext2fs_new_dir_block(fs, db->blockcnt == 0 ? ino : 0,
EXT2_ROOT_INO, &buf2);
memcpy(buf, buf2, fs->blocksize);
ext2fs_free_mem(&buf2);
}
#ifdef ENABLE_HTREE
dx_dir = e2fsck_get_dx_dir_info(ctx, ino);
if (dx_dir && dx_dir->numblocks) {
if (db->blockcnt >= dx_dir->numblocks) {
if (fix_problem(ctx, PR_2_UNEXPECTED_HTREE_BLOCK,
&pctx)) {
clear_htree(ctx, ino);
dx_dir->numblocks = 0;
dx_db = 0;
goto out_htree;
}
fatal_error(ctx, _("Can not continue."));
}
dx_db = &dx_dir->dx_block[db->blockcnt];
dx_db->type = DX_DIRBLOCK_LEAF;
dx_db->phys = block_nr;
dx_db->min_hash = ~0;
dx_db->max_hash = 0;
dirent = (struct ext2_dir_entry *) buf;
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
limit = (struct ext2_dx_countlimit *) (buf+8);
if (db->blockcnt == 0) {
root = (struct ext2_dx_root_info *) (buf + 24);
dx_db->type = DX_DIRBLOCK_ROOT;
dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST;
if ((root->reserved_zero ||
root->info_length < 8 ||
root->indirect_levels > 1) &&
fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) {
clear_htree(ctx, ino);
dx_dir->numblocks = 0;
dx_db = 0;
}
dx_dir->hashversion = root->hash_version;
if ((dx_dir->hashversion <= EXT2_HASH_TEA) &&
(fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
dx_dir->hashversion += 3;
dx_dir->depth = root->indirect_levels + 1;
} else if ((dirent->inode == 0) &&
(rec_len == fs->blocksize) &&
(dirent->name_len == 0) &&
(ext2fs_le16_to_cpu(limit->limit) ==
((fs->blocksize - (8 + dx_csum_size)) /
sizeof(struct ext2_dx_entry))))
dx_db->type = DX_DIRBLOCK_NODE;
is_leaf = 0;
}
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);
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;
}
}
/* htree nodes don't use fake dirents to store checksums */
if (!is_leaf)
de_csum_size = 0;
skip_checksum:
dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp);
prev = 0;
do {
int group;
ext2_ino_t first_unused_inode;
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) ||
(((dirent->name_len & (unsigned) 0xFF)+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 (dot_state == 0) {
if (check_dot(ctx, dirent, ino, &cd->pctx))
dir_modified++;
} else if (dot_state == 1) {
ret = check_dotdot(ctx, dirent, ino, &cd->pctx);
if (ret < 0)
goto abort_free_dict;
if (ret)
dir_modified++;
} else if (dirent->inode == ino) {
problem = PR_2_LINK_DOT;
if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
}
if (!dirent->inode)
goto next;
/*
* Make sure the inode listed is a legal one.
*/
if (((dirent->inode != EXT2_ROOT_INO) &&
(dirent->inode < EXT2_FIRST_INODE(fs->super))) ||
(dirent->inode > fs->super->s_inodes_count)) {
problem = PR_2_BAD_INO;
} else if (ctx->inode_bb_map &&
(ext2fs_test_inode_bitmap2(ctx->inode_bb_map,
dirent->inode))) {
/*
* If the inode is in a bad block, offer to
* clear it.
*/
problem = PR_2_BB_INODE;
} else if ((dot_state > 1) &&
((dirent->name_len & 0xFF) == 1) &&
(dirent->name[0] == '.')) {
/*
* If there's a '.' entry in anything other
* than the first directory entry, it's a
* duplicate entry that should be removed.
*/
problem = PR_2_DUP_DOT;
} else if ((dot_state > 1) &&
((dirent->name_len & 0xFF) == 2) &&
(dirent->name[0] == '.') &&
(dirent->name[1] == '.')) {
/*
* If there's a '..' entry in anything other
* than the second directory entry, it's a
* duplicate entry that should be removed.
*/
problem = PR_2_DUP_DOT_DOT;
} else if ((dot_state > 1) &&
(dirent->inode == EXT2_ROOT_INO)) {
/*
* Don't allow links to the root directory.
* We check this specially to make sure we
* catch this error case even if the root
* directory hasn't been created yet.
*/
problem = PR_2_LINK_ROOT;
} else if ((dot_state > 1) &&
(dirent->name_len & 0xFF) == 0) {
/*
* Don't allow zero-length directory names.
*/
problem = PR_2_NULL_NAME;
}
if (problem) {
if (fix_problem(ctx, problem, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
/*
* If the inode was marked as having bad fields in
* pass1, process it and offer to fix/clear it.
* (We wait until now so that we can display the
* pathname to the user.)
*/
if (ctx->inode_bad_map &&
ext2fs_test_inode_bitmap2(ctx->inode_bad_map,
dirent->inode)) {
if (e2fsck_process_bad_inode(ctx, ino,
dirent->inode,
buf + fs->blocksize)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
return DIRENT_ABORT;
}
group = ext2fs_group_of_ino(fs, dirent->inode);
first_unused_inode = group * fs->super->s_inodes_per_group +
1 + fs->super->s_inodes_per_group -
ext2fs_bg_itable_unused(fs, group);
cd->pctx.group = group;
/*
* Check if the inode was missed out because
* _INODE_UNINIT flag was set or bg_itable_unused was
* incorrect. If so, clear the _INODE_UNINIT flag and
* restart e2fsck. In the future it would be nice if
* we could call a function in pass1.c that checks the
* newly visible inodes.
*/
if (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)) {
pctx.num = dirent->inode;
if (fix_problem(ctx, PR_2_INOREF_BG_INO_UNINIT,
&cd->pctx)){
ext2fs_bg_flags_clear(fs, group,
EXT2_BG_INODE_UNINIT);
ext2fs_mark_super_dirty(fs);
ctx->flags |= E2F_FLAG_RESTART_LATER;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
} else if (dirent->inode >= first_unused_inode) {
pctx.num = dirent->inode;
if (fix_problem(ctx, PR_2_INOREF_IN_UNUSED, &cd->pctx)){
ext2fs_bg_itable_unused_set(fs, group, 0);
ext2fs_mark_super_dirty(fs);
ctx->flags |= E2F_FLAG_RESTART_LATER;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
/*
* Offer to clear unused inodes; if we are going to be
* restarting the scan due to bg_itable_unused being
* wrong, then don't clear any inodes to avoid zapping
* inodes that were skipped during pass1 due to an
* incorrect bg_itable_unused; we'll get any real
* problems after we restart.
*/
if (!(ctx->flags & E2F_FLAG_RESTART_LATER) &&
!(ext2fs_test_inode_bitmap2(ctx->inode_used_map,
dirent->inode)))
problem = PR_2_UNUSED_INODE;
if (problem) {
if (fix_problem(ctx, problem, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
if (check_name(ctx, dirent, ino, &cd->pctx))
dir_modified++;
if (check_filetype(ctx, dirent, ino, &cd->pctx))
dir_modified++;
#ifdef ENABLE_HTREE
if (dx_db) {
ext2fs_dirhash(dx_dir->hashversion, dirent->name,
(dirent->name_len & 0xFF),
fs->super->s_hash_seed, &hash, 0);
if (hash < dx_db->min_hash)
dx_db->min_hash = hash;
if (hash > dx_db->max_hash)
dx_db->max_hash = hash;
}
#endif
/*
* If this is a directory, then mark its parent in its
* dir_info structure. If the parent field is already
* filled in, then this directory has more than one
* hard link. We assume the first link is correct,
* and ask the user if he/she wants to clear this one.
*/
if ((dot_state > 1) &&
(ext2fs_test_inode_bitmap2(ctx->inode_dir_map,
dirent->inode))) {
if (e2fsck_dir_info_get_parent(ctx, dirent->inode,
&subdir_parent)) {
cd->pctx.ino = dirent->inode;
fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
goto abort_free_dict;
}
if (subdir_parent) {
cd->pctx.ino2 = subdir_parent;
if (fix_problem(ctx, PR_2_LINK_DIR,
&cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
cd->pctx.ino2 = 0;
} else {
(void) e2fsck_dir_info_set_parent(ctx,
dirent->inode, ino);
}
}
if (dups_found) {
;
} else if (dict_lookup(&de_dict, dirent)) {
clear_problem_context(&pctx);
pctx.ino = ino;
pctx.dirent = dirent;
fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx);
e2fsck_rehash_dir_later(ctx, ino);
dups_found++;
} else
dict_alloc_insert(&de_dict, dirent, dirent);
ext2fs_icount_increment(ctx->inode_count, dirent->inode,
&links);
if (links > 1)
ctx->fs_links_count++;
ctx->fs_total_count++;
next:
prev = dirent;
if (dir_modified)
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
offset += rec_len;
dot_state++;
} while (offset < fs->blocksize - de_csum_size);
#if 0
printf("\n");
#endif
#ifdef ENABLE_HTREE
if (dx_db) {
#ifdef DX_DEBUG
printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n",
db->blockcnt, dx_db->type,
dx_db->min_hash, dx_db->max_hash);
#endif
cd->pctx.dir = cd->pctx.ino;
if ((dx_db->type == DX_DIRBLOCK_ROOT) ||
(dx_db->type == DX_DIRBLOCK_NODE))
parse_int_node(fs, db, cd, dx_dir, buf, failed_csum);
}
#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 (dir_modified) {
/* leaf block with no tail? Rehash dirs later. */
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))
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 (e2fsck_dir_will_be_rehashed(ctx, ino))
ctx->fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
if (cd->pctx.errcode) {
if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK,
&cd->pctx))
goto abort_free_dict;
}
ext2fs_mark_changed(fs);
} else if (is_leaf && failed_csum && !dir_modified) {
/*
* If a leaf node that fails csum makes it this far without
* alteration, ask the user if the checksum should be fixed.
*/
if (fix_problem(ctx, PR_2_LEAF_NODE_ONLY_CSUM_INVALID,
&cd->pctx))
goto write_and_fix;
}
dict_free_nodes(&de_dict);
return 0;
abort_free_dict:
ctx->flags |= E2F_FLAG_ABORT;
dict_free_nodes(&de_dict);
return DIRENT_ABORT;
}
static int expand_dir_proc(ext2_filsys fs,
blk64_t *blocknr,
e2_blkcnt_t blockcnt,
blk64_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct expand_dir_struct *es = (struct expand_dir_struct *) priv_data;
blk64_t new_blk;
char *block;
errcode_t retval;
if (*blocknr) {
if (blockcnt >= 0)
es->goal = *blocknr;
return 0;
}
if (blockcnt &&
(EXT2FS_B2C(fs, es->goal) == EXT2FS_B2C(fs, es->goal+1)))
new_blk = es->goal+1;
else {
es->goal &= ~EXT2FS_CLUSTER_MASK(fs);
retval = ext2fs_new_block2(fs, es->goal, 0, &new_blk);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
es->newblocks++;
}
if (blockcnt > 0) {
retval = ext2fs_new_dir_block(fs, 0, 0, &block);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
es->done = 1;
retval = ext2fs_write_dir_block4(fs, new_blk, block, 0,
es->dir);
} else {
retval = ext2fs_get_mem(fs->blocksize, &block);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
memset(block, 0, fs->blocksize);
retval = io_channel_write_blk64(fs->io, new_blk, 1, block);
}
if (blockcnt >= 0)
es->goal = new_blk;
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
ext2fs_free_mem(&block);
*blocknr = new_blk;
ext2fs_block_alloc_stats2(fs, new_blk, +1);
if (es->done)
return (BLOCK_CHANGED | BLOCK_ABORT);
else
return BLOCK_CHANGED;
}
/*
* This routine gets the lost_and_found inode, making it a directory
* if necessary
*/
ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix)
{
ext2_filsys fs = ctx->fs;
ext2_ino_t ino;
blk64_t blk;
errcode_t retval;
struct ext2_inode inode;
char * block;
static const char name[] = "lost+found";
struct problem_context pctx;
int will_rehash, flags;
if (ctx->lost_and_found)
return ctx->lost_and_found;
clear_problem_context(&pctx);
will_rehash = e2fsck_dir_will_be_rehashed(ctx, EXT2_ROOT_INO);
if (will_rehash) {
flags = ctx->fs->flags;
ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
}
retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name,
sizeof(name)-1, 0, &ino);
if (will_rehash)
ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
(ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
if (retval && !fix)
return 0;
if (!retval) {
/* Lost+found shouldn't have inline data */
retval = ext2fs_read_inode(fs, ino, &inode);
if (fix && retval)
return 0;
if (fix && (inode.i_flags & EXT4_INLINE_DATA_FL)) {
if (!fix_problem(ctx, PR_3_LPF_INLINE_DATA, &pctx))
return 0;
goto unlink;
}
if (fix && (inode.i_flags & EXT4_ENCRYPT_FL)) {
if (!fix_problem(ctx, PR_3_LPF_ENCRYPTED, &pctx))
return 0;
goto unlink;
}
if (ext2fs_check_directory(fs, ino) == 0) {
ctx->lost_and_found = ino;
return ino;
}
/* Lost+found isn't a directory! */
if (!fix)
return 0;
pctx.ino = ino;
if (!fix_problem(ctx, PR_3_LPF_NOTDIR, &pctx))
return 0;
unlink:
/* OK, unlink the old /lost+found file. */
pctx.errcode = ext2fs_unlink(fs, EXT2_ROOT_INO, name, ino, 0);
if (pctx.errcode) {
pctx.str = "ext2fs_unlink";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
(void) e2fsck_dir_info_set_parent(ctx, ino, 0);
e2fsck_adjust_inode_count(ctx, ino, -1);
/*
* If the old lost+found was a directory, we've just
* disconnected it from the directory tree, which
* means we need to restart the directory tree scan.
* The simplest way to do this is restart the whole
* e2fsck operation.
*/
if (LINUX_S_ISDIR(inode.i_mode))
ctx->flags |= E2F_FLAG_RESTART;
} else if (retval != EXT2_ET_FILE_NOT_FOUND) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx);
}
if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0))
return 0;
/*
* Read the inode and block bitmaps in; we'll be messing with
* them.
*/
e2fsck_read_bitmaps(ctx);
/*
* First, find a free block
*/
if (ctx->lnf_repair_block) {
blk = ctx->lnf_repair_block;
ctx->lnf_repair_block = 0;
goto skip_new_block;
}
retval = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
if (retval == EXT2_ET_BLOCK_ALLOC_FAIL &&
fix_problem(ctx, PR_3_LPF_NO_SPACE, &pctx)) {
fix_problem(ctx, PR_3_NO_SPACE_TO_RECOVER, &pctx);
ctx->lost_and_found = EXT2_ROOT_INO;
return 0;
}
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx);
return 0;
}
ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
skip_new_block:
ext2fs_block_alloc_stats2(fs, blk, +1);
/*
* Next find a free inode.
*/
retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700,
ctx->inode_used_map, &ino);
if (retval == EXT2_ET_INODE_ALLOC_FAIL &&
fix_problem(ctx, PR_3_LPF_NO_SPACE, &pctx)) {
fix_problem(ctx, PR_3_NO_SPACE_TO_RECOVER, &pctx);
ctx->lost_and_found = EXT2_ROOT_INO;
return 0;
}
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx);
return 0;
}
ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino);
ext2fs_inode_alloc_stats2(fs, ino, +1, 1);
/*
* Set up the inode structure
*/
memset(&inode, 0, sizeof(inode));
inode.i_mode = 040700;
inode.i_size = fs->blocksize;
inode.i_atime = inode.i_ctime = inode.i_mtime = ctx->now;
inode.i_links_count = 2;
ext2fs_iblk_set(fs, &inode, 1);
inode.i_block[0] = blk;
/*
* Next, write out the inode.
*/
pctx.errcode = ext2fs_write_new_inode(fs, ino, &inode);
if (pctx.errcode) {
pctx.str = "ext2fs_write_inode";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
/*
* Now let's create the actual data block for the inode.
* Due to metadata_csum, the directory block MUST be written
* after the inode is written to disk!
*/
retval = ext2fs_new_dir_block(fs, ino, EXT2_ROOT_INO, &block);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_DIR_BLOCK, &pctx);
return 0;
}
retval = ext2fs_write_dir_block4(fs, blk, block, 0, ino);
ext2fs_free_mem(&block);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx);
return 0;
}
/*
* Finally, create the directory link
*/
pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR);
if (pctx.errcode == EXT2_ET_DIR_NO_SPACE) {
pctx.errcode = ext2fs_expand_dir(fs, EXT2_ROOT_INO);
if (pctx.errcode)
goto link_error;
pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino,
EXT2_FT_DIR);
}
if (pctx.errcode) {
link_error:
pctx.str = "ext2fs_link";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
/*
* Miscellaneous bookkeeping that needs to be kept straight.
*/
e2fsck_add_dir_info(ctx, ino, EXT2_ROOT_INO);
e2fsck_adjust_inode_count(ctx, EXT2_ROOT_INO, 1);
ext2fs_icount_store(ctx->inode_count, ino, 2);
ext2fs_icount_store(ctx->inode_link_info, ino, 2);
ctx->lost_and_found = ino;
quota_data_add(ctx->qctx, &inode, ino, fs->blocksize);
quota_data_inodes(ctx->qctx, &inode, ino, +1);
#if 0
printf("/lost+found created; inode #%lu\n", ino);
#endif
return ino;
}