* - The inode_reg_map bitmap
*/
+#define _GNU_SOURCE 1 /* get strnlen() */
+#include <string.h>
+
#include "e2fsck.h"
#include "problem.h"
#include "dict.h"
#ifdef RESOURCE_TRACK
struct resource_track rtrack;
#endif
- struct dir_info *dir;
struct check_dir_struct cd;
struct dx_dir_info *dx_dir;
struct dx_dirblock_info *dx_db, *dx_parent;
- blk_t b;
+ int b;
int i, depth;
problem_t code;
int bad_dir;
if (!(ctx->options & E2F_OPT_PREEN))
fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx);
- cd.pctx.errcode = ext2fs_create_icount2(fs, EXT2_ICOUNT_OPT_INCREMENT,
+ e2fsck_setup_tdb_icount(ctx, EXT2_ICOUNT_OPT_INCREMENT,
+ &ctx->inode_count);
+ if (ctx->inode_count)
+ cd.pctx.errcode = 0;
+ else
+ cd.pctx.errcode = ext2fs_create_icount2(fs,
+ EXT2_ICOUNT_OPT_INCREMENT,
0, ctx->inode_link_info,
&ctx->inode_count);
if (cd.pctx.errcode) {
* present. (If the root directory is not present, we will
* create it in pass 3.)
*/
- dir = e2fsck_get_dir_info(ctx, EXT2_ROOT_INO);
- if (dir)
- dir->parent = EXT2_ROOT_INO;
+ (void) e2fsck_dir_info_set_parent(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO);
cd.buf = buf;
cd.ctx = ctx;
clear_htree(ctx, dx_dir->ino);
dx_dir->numblocks = 0;
}
-#ifdef ENABLE_HTREE_CLEAR
- if (dx_dir->numblocks) {
- fix_problem(ctx, PR_2_HTREE_FCLR, &pctx);
- clear_htree(ctx, dx_dir->ino);
- dx_dir->numblocks = 0;
- }
-#endif
}
#endif
- ext2fs_free_mem((void **) &buf);
+ ext2fs_free_mem(&buf);
ext2fs_free_dblist(fs->dblist);
if (ctx->inode_bad_map) {
*/
static int check_dotdot(e2fsck_t ctx,
struct ext2_dir_entry *dirent,
- struct dir_info *dir, struct problem_context *pctx)
+ ext2_ino_t ino, struct problem_context *pctx)
{
- int problem = 0;
+ int problem = 0;
if (!dirent->inode)
problem = PR_2_MISSING_DOT_DOT;
}
return 0;
}
- dir->dotdot = dirent->inode;
+ if (e2fsck_dir_info_set_dotdot(ctx, ino, dirent->inode)) {
+ fix_problem(ctx, PR_2_NO_DIRINFO, pctx);
+ return -1;
+ }
return 0;
}
*/
static int check_name(e2fsck_t ctx,
struct ext2_dir_entry *dirent,
- ext2_ino_t dir_ino, struct problem_context *pctx)
+ ext2_ino_t dir_ino EXT2FS_ATTR((unused)),
+ struct problem_context *pctx)
{
int i;
int fixup = -1;
* Check the directory filetype (if present)
*/
static _INLINE_ int check_filetype(e2fsck_t ctx,
- struct ext2_dir_entry *dirent,
- ext2_ino_t dir_ino, struct problem_context *pctx)
+ struct ext2_dir_entry *dirent,
+ ext2_ino_t dir_ino EXT2FS_ATTR((unused)),
+ struct problem_context *pctx)
{
int filetype = dirent->name_len >> 8;
int should_be = EXT2_FT_UNKNOWN;
#ifdef DX_DEBUG
printf("Root node dump:\n");
- printf("\t Reserved zero: %d\n", root->reserved_zero);
+ printf("\t Reserved zero: %u\n", root->reserved_zero);
printf("\t Hash Version: %d\n", root->hash_version);
printf("\t Info length: %d\n", root->info_length);
printf("\t Indirect levels: %d\n", root->indirect_levels);
prev_hash = hash;
hash = i ? (ext2fs_le32_to_cpu(ent[i].hash) & ~1) : 0;
#ifdef DX_DEBUG
- printf("Entry #%d: Hash 0x%08x, block %d\n", i,
+ printf("Entry #%d: Hash 0x%08x, block %u\n", i,
hash, ext2fs_le32_to_cpu(ent[i].block));
#endif
blk = ext2fs_le32_to_cpu(ent[i].block) & 0x0ffffff;
/* Check to make sure the block is valid */
- if (blk > dx_dir->numblocks) {
+ if (blk >= (blk_t) dx_dir->numblocks) {
cd->pctx.blk = blk;
if (fix_problem(cd->ctx, PR_2_HTREE_BADBLK,
&cd->pctx))
goto clear_and_exit;
+ continue;
}
if (hash < prev_hash &&
fix_problem(cd->ctx, PR_2_HTREE_HASH_ORDER, &cd->pctx))
static void salvage_directory(ext2_filsys fs,
struct ext2_dir_entry *dirent,
struct ext2_dir_entry *prev,
- int *offset)
+ unsigned int *offset)
{
char *cp = (char *) dirent;
int left = fs->blocksize - *offset - dirent->rec_len;
- int name_len = dirent->name_len & 0xFF;
+ unsigned int name_len = dirent->name_len & 0xFF;
/*
* Special case of directory entry of size 8: copy what's left
* record length.
*/
if ((left < 0) &&
- (name_len + 8 <= dirent->rec_len + left) &&
+ (name_len + 8 <= dirent->rec_len + (unsigned) left) &&
dirent->inode <= fs->super->s_inodes_count &&
strnlen(dirent->name, name_len) == name_len) {
dirent->rec_len += left;
struct ext2_db_entry *db,
void *priv_data)
{
- struct dir_info *subdir, *dir;
+ struct dir_info *subdir;
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;
- int offset = 0;
+ unsigned int offset = 0;
int dir_modified = 0;
int dot_state;
blk_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;
static dict_t de_dict;
struct problem_context pctx;
int dups_found = 0;
+ int ret;
cd = (struct check_dir_struct *) priv_data;
buf = cd->buf;
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) &&
(dirent->rec_len == fs->blocksize) &&
if (check_dot(ctx, dirent, ino, &cd->pctx))
dir_modified++;
} else if (dot_state == 1) {
- dir = e2fsck_get_dir_info(ctx, ino);
- if (!dir) {
- fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
+ ret = check_dotdot(ctx, dirent, ino, &cd->pctx);
+ if (ret < 0)
goto abort_free_dict;
- }
- if (check_dotdot(ctx, dirent, dir, &cd->pctx))
+ if (ret)
dir_modified++;
} else if (dirent->inode == ino) {
problem = PR_2_LINK_DOT;
if ((dot_state > 1) &&
(ext2fs_test_inode_bitmap(ctx->inode_dir_map,
dirent->inode))) {
- subdir = e2fsck_get_dir_info(ctx, dirent->inode);
- if (!subdir) {
+ 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 (subdir_parent) {
+ cd->pctx.ino2 = subdir_parent;
if (fix_problem(ctx, PR_2_LINK_DIR,
&cd->pctx)) {
dirent->inode = 0;
goto next;
}
cd->pctx.ino2 = 0;
- } else
- subdir->parent = ino;
+ } else {
+ (void) e2fsck_dir_info_set_parent(ctx,
+ dirent->inode, ino);
+ }
}
if (dups_found) {
*/
static int deallocate_inode_block(ext2_filsys fs,
blk_t *block_nr,
- e2_blkcnt_t blockcnt,
- blk_t ref_block,
- int ref_offset,
+ e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
+ blk_t ref_block EXT2FS_ATTR((unused)),
+ int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
e2fsck_t ctx = (e2fsck_t) priv_data;
if (HOLE_BLKADDR(*block_nr))
return 0;
+ if ((*block_nr < fs->super->s_first_data_block) ||
+ (*block_nr >= fs->super->s_blocks_count))
+ return 0;
ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
ext2fs_block_alloc_stats(fs, *block_nr, -1);
return 0;
ext2fs_icount_store(ctx->inode_link_info, ino, 0);
e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
inode.i_links_count = 0;
- inode.i_dtime = time(0);
+ inode.i_dtime = ctx->now;
e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode");
clear_problem_context(&pctx);
pctx.ino = ino;
ext2_filsys fs = ctx->fs;
struct ext2_inode inode;
int inode_modified = 0;
+ int not_fixed = 0;
unsigned char *frag, *fsize;
struct problem_context pctx;
int problem = 0;
pctx.dir = dir;
pctx.inode = &inode;
+ if (inode.i_file_acl &&
+ !(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
+ if (fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) {
+ inode.i_file_acl = 0;
+#ifdef EXT2FS_ENABLE_SWAPFS
+ /*
+ * This is a special kludge to deal with long
+ * symlinks on big endian systems. i_blocks
+ * had already been decremented earlier in
+ * pass 1, but since i_file_acl hadn't yet
+ * been cleared, ext2fs_read_inode() assumed
+ * that the file was short symlink and would
+ * not have byte swapped i_block[0]. Hence,
+ * we have to byte-swap it here.
+ */
+ if (LINUX_S_ISLNK(inode.i_mode) &&
+ (fs->flags & EXT2_FLAG_SWAP_BYTES) &&
+ (inode.i_blocks == fs->blocksize >> 9))
+ inode.i_block[0] = ext2fs_swab32(inode.i_block[0]);
+#endif
+ inode_modified++;
+ } else
+ not_fixed++;
+ }
+
if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) &&
!LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) &&
!LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) &&
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
return 0;
return 1;
- }
+ } else
+ not_fixed++;
problem = 0;
}
- if (inode.i_faddr &&
- fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) {
- inode.i_faddr = 0;
- inode_modified++;
+ if (inode.i_faddr) {
+ if (fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) {
+ inode.i_faddr = 0;
+ inode_modified++;
+ } else
+ not_fixed++;
}
switch (fs->super->s_creator_os) {
- case EXT2_OS_LINUX:
- frag = &inode.osd2.linux2.l_i_frag;
- fsize = &inode.osd2.linux2.l_i_fsize;
- break;
case EXT2_OS_HURD:
frag = &inode.osd2.hurd2.h_i_frag;
fsize = &inode.osd2.hurd2.h_i_fsize;
if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) {
*frag = 0;
inode_modified++;
- }
+ } else
+ not_fixed++;
pctx.num = 0;
}
if (fsize && *fsize) {
if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) {
*fsize = 0;
inode_modified++;
- }
+ } else
+ not_fixed++;
pctx.num = 0;
}
- if (inode.i_file_acl &&
- !(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) &&
- fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) {
- inode.i_file_acl = 0;
- inode_modified++;
+ if ((fs->super->s_creator_os == EXT2_OS_LINUX) &&
+ !(fs->super->s_feature_ro_compat &
+ EXT4_FEATURE_RO_COMPAT_HUGE_FILE) &&
+ (inode.osd2.linux2.l_i_blocks_hi != 0)) {
+ pctx.num = inode.osd2.linux2.l_i_blocks_hi;
+ if (fix_problem(ctx, PR_2_BLOCKS_HI_ZERO, &pctx)) {
+ inode.osd2.linux2.l_i_blocks_hi = 0;
+ inode_modified++;
+ }
}
+
if (inode.i_file_acl &&
((inode.i_file_acl < fs->super->s_first_data_block) ||
- (inode.i_file_acl >= fs->super->s_blocks_count)) &&
- fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
- inode.i_file_acl = 0;
- inode_modified++;
+ (inode.i_file_acl >= fs->super->s_blocks_count))) {
+ if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
+ inode.i_file_acl = 0;
+ inode_modified++;
+ } else
+ not_fixed++;
}
if (inode.i_dir_acl &&
- LINUX_S_ISDIR(inode.i_mode) &&
- fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) {
- inode.i_dir_acl = 0;
- inode_modified++;
+ LINUX_S_ISDIR(inode.i_mode)) {
+ if (fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) {
+ inode.i_dir_acl = 0;
+ inode_modified++;
+ } else
+ not_fixed++;
}
+
if (inode_modified)
e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode");
+ if (!not_fixed && ctx->inode_bad_map)
+ ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
return 0;
}
*/
static int allocate_dir_block(e2fsck_t ctx,
struct ext2_db_entry *db,
- char *buf, struct problem_context *pctx)
+ char *buf EXT2FS_ATTR((unused)),
+ struct problem_context *pctx)
{
ext2_filsys fs = ctx->fs;
blk_t blk;
}
pctx->errcode = ext2fs_write_dir_block(fs, blk, block);
- ext2fs_free_mem((void **) &block);
+ ext2fs_free_mem(&block);
if (pctx->errcode) {
pctx->str = "ext2fs_write_dir_block";
fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
/*
* This is a helper function for allocate_dir_block().
*/
-static int update_dir_block(ext2_filsys fs,
+static int update_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
blk_t *block_nr,
e2_blkcnt_t blockcnt,
- blk_t ref_block,
- int ref_offset,
+ blk_t ref_block EXT2FS_ATTR((unused)),
+ int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct ext2_db_entry *db;
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff