vitalif
/
e2fsprogs
mirror of https://github.com/vitalif/e2fsprogs
1
0
Fork 0
Code Issues Releases Wiki Activity
e2fsprogs/e2fsck/pass1.c

1256 lines
33 KiB
C
Raw Blame History

/*
* pass1.c -- pass #1 of e2fsck: sequential scan of the inode table
*
* Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
*
* %Begin-Header%
* This file may be redistributed under the terms of the GNU Public
* License.
* %End-Header%
*
* Pass 1 of e2fsck iterates over all the inodes in the filesystems,
* and applies the following tests to each inode:
*
* - The mode field of the inode must be legal.
* - The size and block count fields of the inode are correct.
* - A data block must not be used by another inode
*
* Pass 1 also gathers the collects the following information:
*
* - A bitmap of which inodes are in use. (inode_used_map)
* - A bitmap of which inodes are directories. (inode_dir_map)
* - A bitmap of which inodes have bad fields. (inode_bad_map)
* - A bitmap of which inodes are in bad blocks. (inode_bb_map)
* - A bitmap of which blocks are in use. (block_found_map)
* - A bitmap of which blocks are in use by two inodes (block_dup_map)
* - The data blocks of the directory inodes. (dir_map)
*
* Pass 1 is designed to stash away enough information so that the
* other passes should not need to read in the inode information
* during the normal course of a filesystem check. (Althogh if an
* inconsistency is detected, other passes may need to read in an
* inode to fix it.)
*
* Note that pass 1B will be invoked if there are any duplicate blocks
* found.
*/
#include <time.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#include <et/com_err.h>
#include "e2fsck.h"
#include "problem.h"
#ifdef NO_INLINE_FUNCS
#define _INLINE_
#else
#define _INLINE_ inline
#endif
/* Files counts */
int fs_directory_count = 0;
int fs_regular_count = 0;
int fs_blockdev_count = 0;
int fs_chardev_count = 0;
int fs_links_count = 0;
int fs_symlinks_count = 0;
int fs_fast_symlinks_count = 0;
int fs_fifo_count = 0;
int fs_total_count = 0;
int fs_badblocks_count = 0;
int fs_sockets_count = 0;
int fs_ind_count = 0;
int fs_dind_count = 0;
int fs_tind_count = 0;
int fs_fragmented = 0;
ext2fs_inode_bitmap inode_used_map = 0; /* Inodes which are in use */
ext2fs_inode_bitmap inode_bad_map = 0; /* Inodes which are bad in some way */
ext2fs_inode_bitmap inode_dir_map = 0; /* Inodes which are directories */
ext2fs_inode_bitmap inode_bb_map = 0; /* Inodes which are in bad blocks */
ext2fs_block_bitmap block_found_map = 0;
ext2fs_block_bitmap block_dup_map = 0;
ext2fs_block_bitmap block_illegal_map = 0;
ext2_icount_t inode_link_info = 0;
static int process_block(ext2_filsys fs, blk_t *blocknr,
int blockcnt, blk_t ref_blk,
int ref_offset, void *private);
static int process_bad_block(ext2_filsys fs, blk_t *block_nr,
int blockcnt, blk_t ref_blk,
int ref_offset, void *private);
static void check_blocks(ext2_filsys fs, struct problem_context *pctx,
char *block_buf);
static void mark_table_blocks(ext2_filsys fs);
static void alloc_bad_map(ext2_filsys fs);
static void alloc_bb_map(ext2_filsys fs);
static void handle_fs_bad_blocks(ext2_filsys fs);
static void process_inodes(ext2_filsys fs, char *block_buf);
static int process_inode_cmp(const void *a, const void *b);
static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
dgrp_t group, void * private);
/* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */
struct process_block_struct {
ino_t ino;
int is_dir:1, clear:1, suppress:1, fragmented:1;
int num_blocks;
int last_block;
int num_illegal_blocks;
blk_t previous_block;
struct ext2_inode *inode;
struct problem_context *pctx;
};
struct process_inode_block {
ino_t ino;
struct ext2_inode inode;
};
/*
* For pass1_check_directory and pass1_get_blocks
*/
ino_t stashed_ino;
struct ext2_inode *stashed_inode;
/*
* For the inodes to process list.
*/
static struct process_inode_block *inodes_to_process;
static int process_inode_count;
int process_inode_size = 256;
/*
* Free all memory allocated by pass1 in preparation for restarting
* things.
*/
static void unwind_pass1(ext2_filsys fs)
{
ext2fs_free_inode_bitmap(inode_used_map); inode_used_map = 0;
ext2fs_free_inode_bitmap(inode_dir_map); inode_dir_map = 0;
ext2fs_free_block_bitmap(block_found_map); block_found_map = 0;
ext2fs_free_icount(inode_link_info); inode_link_info = 0;
free(inodes_to_process);inodes_to_process = 0;
ext2fs_free_dblist(fs->dblist); fs->dblist = 0;
free_dir_info(fs);
if (block_dup_map) {
ext2fs_free_block_bitmap(block_dup_map); block_dup_map = 0;
}
if (inode_bb_map) {
ext2fs_free_inode_bitmap(inode_bb_map); inode_bb_map = 0;
}
if (inode_bad_map) {
ext2fs_free_inode_bitmap(inode_bad_map); inode_bad_map = 0;
}
/* Clear statistic counters */
fs_directory_count = 0;
fs_regular_count = 0;
fs_blockdev_count = 0;
fs_chardev_count = 0;
fs_links_count = 0;
fs_symlinks_count = 0;
fs_fast_symlinks_count = 0;
fs_fifo_count = 0;
fs_total_count = 0;
fs_badblocks_count = 0;
fs_sockets_count = 0;
fs_ind_count = 0;
fs_dind_count = 0;
fs_tind_count = 0;
fs_fragmented = 0;
}
void pass1(ext2_filsys fs)
{
ino_t ino;
struct ext2_inode inode;
ext2_inode_scan scan;
char *block_buf;
errcode_t retval;
struct resource_track rtrack;
unsigned char frag, fsize;
struct problem_context pctx;
init_resource_track(&rtrack);
if (!preen)
printf("Pass 1: Checking inodes, blocks, and sizes\n");
#ifdef MTRACE
mtrace_print("Pass 1");
#endif
/*
* Allocate bitmaps structures
*/
retval = ext2fs_allocate_inode_bitmap(fs, "in-use inode map",
&inode_used_map);
if (retval) {
com_err("ext2fs_allocate_inode_bitmap", retval,
"while allocating inode_used_map");
fatal_error(0);
}
retval = ext2fs_allocate_inode_bitmap(fs, "directory inode map",
&inode_dir_map);
if (retval) {
com_err("ext2fs_allocate_inode_bitmap", retval,
"while allocating inode_dir_map");
fatal_error(0);
}
retval = ext2fs_allocate_block_bitmap(fs, "in-use block map",
&block_found_map);
if (retval) {
com_err("ext2fs_allocate_block_bitmap", retval,
"while allocating block_found_map");
fatal_error(0);
}
retval = ext2fs_allocate_block_bitmap(fs, "illegal block map",
&block_illegal_map);
if (retval) {
com_err("ext2fs_allocate_block_bitmap", retval,
"while allocating block_illegal_map");
fatal_error(0);
}
retval = ext2fs_create_icount(fs, 0, 0, &inode_link_info);
if (retval) {
com_err("ext2fs_create_icount", retval,
"while creating inode_link_info");
fatal_error(0);
}
inodes_to_process = allocate_memory(process_inode_size *
sizeof(struct process_inode_block),
"array of inodes to process");
process_inode_count = 0;
retval = ext2fs_init_dblist(fs, 0);
if (retval) {
com_err(program_name, retval,
"while allocating directory block information");
fatal_error(0);
}
mark_table_blocks(fs);
block_buf = allocate_memory(fs->blocksize * 3, "block interate buffer");
fs->get_blocks = pass1_get_blocks;
fs->check_directory = pass1_check_directory;
fs->read_inode = pass1_read_inode;
fs->write_inode = pass1_write_inode;
ehandler_operation("doing inode scan");
retval = ext2fs_open_inode_scan(fs, inode_buffer_blocks, &scan);
if (retval) {
com_err(program_name, retval, "while opening inode scan");
fatal_error(0);
}
ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
retval = ext2fs_get_next_inode(scan, &ino, &inode);
if (retval) {
com_err(program_name, retval, "while starting inode scan");
fatal_error(0);
}
stashed_inode = &inode;
ext2fs_set_inode_callback(scan, scan_callback, block_buf);
clear_problem_context(&pctx);
while (ino) {
stashed_ino = ino;
if (inode.i_links_count)
retval = ext2fs_icount_store(inode_link_info, ino,
inode.i_links_count);
if (retval) {
com_err("ext2fs_icount_fetch", retval,
"while adding inode %u", ino);
fatal_error(0);
}
pctx.ino = ino;
pctx.inode = &inode;
if (ino == EXT2_BAD_INO) {
struct process_block_struct pb;
pb.ino = EXT2_BAD_INO;
pb.num_blocks = pb.last_block = 0;
pb.num_illegal_blocks = 0;
pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
pb.fragmented = 0;
pb.inode = &inode;
pb.pctx = &pctx;
retval = ext2fs_block_iterate2(fs, ino, 0, block_buf,
process_bad_block, &pb);
if (retval)
com_err(program_name, retval, "while calling e2fsc_block_interate in pass 1");
ext2fs_mark_inode_bitmap(inode_used_map, ino);
clear_problem_context(&pctx);
goto next;
}
if (ino == EXT2_ROOT_INO) {
/*
* Make sure the root inode is a directory; if
* not, offer to clear it. It will be
* regnerated in pass #3.
*/
if (!LINUX_S_ISDIR(inode.i_mode)) {
if (fix_problem(fs, PR_1_ROOT_NO_DIR, &pctx)) {
inode.i_dtime = time(0);
inode.i_links_count = 0;
ext2fs_icount_store(inode_link_info,
ino, 0);
e2fsck_write_inode(fs, ino, &inode,
"pass1");
}
}
/*
* If dtime is set, offer to clear it. mke2fs
* version 0.2b created filesystems with the
* dtime field set for the root and lost+found
* directories. We won't worry about
* /lost+found, since that can be regenerated
* easily. But we will fix the root directory
* as a special case.
*/
if (inode.i_dtime && inode.i_links_count) {
if (fix_problem(fs, PR_1_ROOT_DTIME, &pctx)) {
inode.i_dtime = 0;
e2fsck_write_inode(fs, ino, &inode,
"pass1");
}
}
}
if (ino == EXT2_BOOT_LOADER_INO) {
ext2fs_mark_inode_bitmap(inode_used_map, ino);
check_blocks(fs, &pctx, block_buf);
goto next;
}
if ((ino != EXT2_ROOT_INO) &&
(ino < EXT2_FIRST_INODE(fs->super))) {
ext2fs_mark_inode_bitmap(inode_used_map, ino);
if (inode.i_mode != 0) {
if (fix_problem(fs,
PR_1_RESERVED_BAD_MODE, &pctx)) {
inode.i_mode = 0;
e2fsck_write_inode(fs, ino, &inode,
"pass1");
}
}
check_blocks(fs, &pctx, block_buf);
goto next;
}
/*
* This code assumes that deleted inodes have
* i_links_count set to 0.
*/
if (!inode.i_links_count) {
if (!inode.i_dtime && inode.i_mode) {
if (fix_problem(fs,
PR_1_ZERO_DTIME, &pctx)) {
inode.i_dtime = time(0);
e2fsck_write_inode(fs, ino, &inode,
"pass1");
}
}
goto next;
}
/*
* n.b. 0.3c ext2fs code didn't clear i_links_count for
* deleted files. Oops.
*
* Since all new ext2 implementations get this right,
* we now assume that the case of non-zero
* i_links_count and non-zero dtime means that we
* should keep the file, not delete it.
*
*/
if (inode.i_dtime) {
if (fix_problem(fs, PR_1_SET_DTIME, &pctx)) {
inode.i_dtime = 0;
e2fsck_write_inode(fs, ino, &inode, "pass1");
}
}
ext2fs_mark_inode_bitmap(inode_used_map, ino);
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;
break;
case EXT2_OS_MASIX:
frag = inode.osd2.masix2.m_i_frag;
fsize = inode.osd2.masix2.m_i_fsize;
break;
default:
frag = fsize = 0;
}
if (inode.i_faddr || frag || fsize
|| inode.i_file_acl || inode.i_dir_acl) {
if (!inode_bad_map)
alloc_bad_map(fs);
ext2fs_mark_inode_bitmap(inode_bad_map, ino);
}
if (LINUX_S_ISDIR(inode.i_mode)) {
ext2fs_mark_inode_bitmap(inode_dir_map, ino);
add_dir_info(fs, ino, 0);
fs_directory_count++;
} else if (LINUX_S_ISREG (inode.i_mode))
fs_regular_count++;
else if (LINUX_S_ISCHR (inode.i_mode))
fs_chardev_count++;
else if (LINUX_S_ISBLK (inode.i_mode))
fs_blockdev_count++;
else if (LINUX_S_ISLNK (inode.i_mode)) {
fs_symlinks_count++;
if (!inode.i_blocks) {
fs_fast_symlinks_count++;
goto next;
}
}
else if (LINUX_S_ISFIFO (inode.i_mode))
fs_fifo_count++;
else if (LINUX_S_ISSOCK (inode.i_mode))
fs_sockets_count++;
else {
if (!inode_bad_map)
alloc_bad_map(fs);
ext2fs_mark_inode_bitmap(inode_bad_map, ino);
}
if (inode.i_block[EXT2_IND_BLOCK])
fs_ind_count++;
if (inode.i_block[EXT2_DIND_BLOCK])
fs_dind_count++;
if (inode.i_block[EXT2_TIND_BLOCK])
fs_tind_count++;
if (inode.i_block[EXT2_IND_BLOCK] ||
inode.i_block[EXT2_DIND_BLOCK] ||
inode.i_block[EXT2_TIND_BLOCK]) {
inodes_to_process[process_inode_count].ino = ino;
inodes_to_process[process_inode_count].inode = inode;
process_inode_count++;
} else
check_blocks(fs, &pctx, block_buf);
if (process_inode_count >= process_inode_size)
process_inodes(fs, block_buf);
next:
retval = ext2fs_get_next_inode(scan, &ino, &inode);
if (retval == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
if (!inode_bb_map)
alloc_bb_map(fs);
ext2fs_mark_inode_bitmap(inode_bb_map, ino);
ext2fs_mark_inode_bitmap(inode_used_map, ino);
goto next;
}
if (retval) {
com_err(program_name, retval,
"while doing inode scan");
fatal_error(0);
}
}
process_inodes(fs, block_buf);
ext2fs_close_inode_scan(scan);
ehandler_operation(0);
if (invalid_bitmaps)
handle_fs_bad_blocks(fs);
if (restart_e2fsck) {
unwind_pass1(fs);
goto endit;
}
if (block_dup_map) {
if (preen) {
printf("Duplicate or bad blocks in use!\n");
preenhalt(fs);
}
pass1_dupblocks(fs, block_buf);
}
free(inodes_to_process);
endit:
fs->get_blocks = 0;
fs->check_directory = 0;
fs->read_inode = 0;
fs->write_inode = 0;
free(block_buf);
ext2fs_free_block_bitmap(block_illegal_map);
block_illegal_map = 0;
if (tflag > 1) {
printf("Pass 1: ");
print_resource_track(&rtrack);
}
}
/*
* When the inode_scan routines call this callback at the end of the
* glock group, call process_inodes.
*/
static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
dgrp_t group, void * private)
{
process_inodes(fs, (char *) private);
return 0;
}
/*
* Process the inodes in the "inodes to process" list.
*/
static void process_inodes(ext2_filsys fs, char *block_buf)
{
int i;
struct ext2_inode *old_stashed_inode;
ino_t old_stashed_ino;
const char *old_operation;
char buf[80];
struct problem_context pctx;
#if 0
printf("begin process_inodes: ");
#endif
old_operation = ehandler_operation(0);
old_stashed_inode = stashed_inode;
old_stashed_ino = stashed_ino;
qsort(inodes_to_process, process_inode_count,
sizeof(struct process_inode_block), process_inode_cmp);
clear_problem_context(&pctx);
for (i=0; i < process_inode_count; i++) {
pctx.inode = stashed_inode = &inodes_to_process[i].inode;
pctx.ino = stashed_ino = inodes_to_process[i].ino;
#if 0
printf("%u ", pctx.ino);
#endif
sprintf(buf, "reading indirect blocks of inode %lu", pctx.ino);
ehandler_operation(buf);
check_blocks(fs, &pctx, block_buf);
}
stashed_inode = old_stashed_inode;
stashed_ino = old_stashed_ino;
process_inode_count = 0;
#if 0
printf("end process inodes\n");
#endif
ehandler_operation(old_operation);
}
static int process_inode_cmp(const void *a, const void *b)
{
const struct process_inode_block *ib_a =
(const struct process_inode_block *) a;
const struct process_inode_block *ib_b =
(const struct process_inode_block *) b;
return (ib_a->inode.i_block[EXT2_IND_BLOCK] -
ib_b->inode.i_block[EXT2_IND_BLOCK]);
}
/*
* This procedure will allocate the inode bad map table
*/
static void alloc_bad_map(ext2_filsys fs)
{
errcode_t retval;
retval = ext2fs_allocate_inode_bitmap(fs, "bad inode map",
&inode_bad_map);
if (retval) {
com_err("ext2fs_allocate_inode_bitmap", retval,
"while allocating inode_bad_map");
fatal_error(0);
}
}
/*
* This procedure will allocate the inode "bb" (badblock) map table
*/
static void alloc_bb_map(ext2_filsys fs)
{
errcode_t retval;
retval = ext2fs_allocate_inode_bitmap(fs, "inode in bad block map",
&inode_bb_map);
if (retval) {
com_err("ext2fs_allocate_inode_bitmap", retval,
"while allocating inode in bad block map");
fatal_error(0);
}
}
/*
* Marks a block as in use, setting the dup_map if it's been set
* already. Called by process_block and process_bad_block.
*
* WARNING: Assumes checks have already been done to make sure block
* is valid. This is true in both process_block and process_bad_block.
*/
static _INLINE_ void mark_block_used(ext2_filsys fs, blk_t block)
{
errcode_t retval;
if (ext2fs_fast_test_block_bitmap(block_found_map, block)) {
if (!block_dup_map) {
retval = ext2fs_allocate_block_bitmap(fs,
"multiply claimed block map", &block_dup_map);
if (retval) {
com_err("ext2fs_allocate_block_bitmap", retval,
"while allocating block_dup_map");
fatal_error(0);
}
}
ext2fs_fast_mark_block_bitmap(block_dup_map, block);
} else {
ext2fs_fast_mark_block_bitmap(block_found_map, block);
}
}
/*
* This subroutine is called on each inode to account for all of the
* blocks used by that inode.
*/
static void check_blocks(ext2_filsys fs, struct problem_context *pctx,
char *block_buf)
{
struct process_block_struct pb;
errcode_t retval;
ino_t ino = pctx->ino;
struct ext2_inode *inode = pctx->inode;
if (!ext2fs_inode_has_valid_blocks(pctx->inode))
return;
pb.ino = ino;
pb.num_blocks = pb.last_block = 0;
pb.num_illegal_blocks = 0;
pb.suppress = 0; pb.clear = 0;
pb.fragmented = 0;
pb.previous_block = 0;
pb.is_dir = LINUX_S_ISDIR(pctx->inode->i_mode);
pb.inode = inode;
pb.pctx = pctx;
retval = ext2fs_block_iterate2(fs, ino,
pb.is_dir ? BLOCK_FLAG_HOLE : 0,
block_buf, process_block, &pb);
reset_problem_latch(PR_LATCH_BLOCK);
if (retval)
com_err(program_name, retval,
"while calling ext2fs_block_iterate in check_blocks");
if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group)
fs_fragmented++;
if (pb.clear) {
e2fsck_read_inode(fs, ino, inode, "check_blocks");
if (retval) {
com_err("check_blocks", retval,
"while reading to be cleared inode %d", ino);
fatal_error(0);
}
inode->i_links_count = 0;
ext2fs_icount_store(inode_link_info, ino, 0);
inode->i_dtime = time(0);
e2fsck_write_inode(fs, ino, inode, "check_blocks");
ext2fs_unmark_inode_bitmap(inode_dir_map, ino);
ext2fs_unmark_inode_bitmap(inode_used_map, ino);
/*
* The inode was probably partially accounted for
* before processing was aborted, so we need to
* restart the pass 1 scan.
*/
restart_e2fsck++;
return;
}
pb.num_blocks *= (fs->blocksize / 512);
#if 0
printf("inode %u, i_size = %lu, last_block = %lu, i_blocks=%lu, num_blocks = %lu\n",
ino, inode->i_size, pb.last_block, inode->i_blocks,
pb.num_blocks);
#endif
if (!pb.num_blocks && pb.is_dir) {
if (fix_problem(fs, PR_1_ZERO_LENGTH_DIR, pctx)) {
inode->i_links_count = 0;
ext2fs_icount_store(inode_link_info, ino, 0);
inode->i_dtime = time(0);
e2fsck_write_inode(fs, ino, inode, "check_blocks");
ext2fs_unmark_inode_bitmap(inode_dir_map, ino);
ext2fs_unmark_inode_bitmap(inode_used_map, ino);
fs_directory_count--;
pb.is_dir = 0;
}
}
if ((pb.is_dir && (inode->i_size !=
(pb.last_block + 1) * fs->blocksize)) ||
(inode->i_size < pb.last_block * fs->blocksize)) {
pctx->num = (pb.last_block+1) * fs->blocksize;
if (fix_problem(fs, PR_1_BAD_I_SIZE, pctx)) {
inode->i_size = pctx->num;
e2fsck_write_inode(fs, ino, inode, "check_blocks");
}
pctx->num = 0;
}
if (pb.num_blocks != inode->i_blocks) {
pctx->num = pb.num_blocks;
if (fix_problem(fs, PR_1_BAD_I_BLOCKS, pctx)) {
inode->i_blocks = pb.num_blocks;
e2fsck_write_inode(fs, ino, inode, "check_blocks");
}
pctx->num = 0;
}
}
#if 0
/*
* Helper function called by process block when an illegal block is
* found. It returns a description about why the block is illegal
*/
static char *describe_illegal_block(ext2_filsys fs, blk_t block)
{
blk_t super;
int i;
static char problem[80];
super = fs->super->s_first_data_block;
strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
if (block < super) {
sprintf(problem, "< FIRSTBLOCK (%u)", super);
return(problem);
} else if (block >= fs->super->s_blocks_count) {
sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
return(problem);
}
for (i = 0; i < fs->group_desc_count; i++) {
if (block == super) {
sprintf(problem, "is the superblock in group %d", i);
break;
}
if (block > super &&
block <= (super + fs->desc_blocks)) {
sprintf(problem, "is in the group descriptors "
"of group %d", i);
break;
}
if (block == fs->group_desc[i].bg_block_bitmap) {
sprintf(problem, "is the block bitmap of group %d", i);
break;
}
if (block == fs->group_desc[i].bg_inode_bitmap) {
sprintf(problem, "is the inode bitmap of group %d", i);
break;
}
if (block >= fs->group_desc[i].bg_inode_table &&
(block < fs->group_desc[i].bg_inode_table
+ fs->inode_blocks_per_group)) {
sprintf(problem, "is in the inode table of group %d",
i);
break;
}
super += fs->super->s_blocks_per_group;
}
return(problem);
}
#endif
/*
* This is a helper function for check_blocks().
*/
int process_block(ext2_filsys fs,
blk_t *block_nr,
int blockcnt,
blk_t ref_block,
int ref_offset,
void *private)
{
struct process_block_struct *p;
struct problem_context *pctx;
blk_t blk = *block_nr;
int ret_code = 0;
int problem = 0;
errcode_t retval;
p = (struct process_block_struct *) private;
pctx = p->pctx;
if (blk == 0) {
if (p->is_dir == 0) {
/*
* Should never happen, since only directories
* get called with BLOCK_FLAG_HOLE
*/
printf("process_block() called with blk == 0, "
"blockcnt=%d, inode %lu???\n",
blockcnt, p->ino);
return 0;
}
if (blockcnt < 0)
return 0;
if (blockcnt * fs->blocksize < p->inode->i_size) {
#if 0
printf("Missing block (#%d) in directory inode %lu!\n",
blockcnt, p->ino);
#endif
goto mark_dir;
}
return 0;
}
#if 0
printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
blockcnt);
#endif
/*
* Simplistic fragmentation check. We merely require that the
* file be contiguous. (Which can never be true for really
* big files that are greater than a block group.)
*/
if (p->previous_block) {
if (p->previous_block+1 != blk)
p->fragmented = 1;
}
p->previous_block = blk;
if (blk < fs->super->s_first_data_block ||
blk >= fs->super->s_blocks_count)
problem = PR_1_ILLEGAL_BLOCK_NUM;
else if (ext2fs_test_block_bitmap(block_illegal_map, blk))
problem = PR_1_BLOCK_OVERLAPS_METADATA;
if (problem) {
p->num_illegal_blocks++;
if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
if (fix_problem(fs, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
p->clear = 1;
return BLOCK_ABORT;
}
if (ask("Suppress messages", 0)) {
p->suppress = 1;
suppress_latch_group(PR_LATCH_BLOCK, 1);
}
}
pctx->blk = blk;
pctx->blkcount = blockcnt;
if (fix_problem(fs, problem, pctx)) {
blk = *block_nr = 0;
ret_code = BLOCK_CHANGED;
goto mark_dir;
} else
return 0;
pctx->blk = 0;
pctx->blkcount = -1;
}
mark_block_used(fs, blk);
p->num_blocks++;
if (blockcnt >= 0)
p->last_block = blockcnt;
mark_dir:
if (p->is_dir && (blockcnt >= 0)) {
retval = ext2fs_add_dir_block(fs->dblist, p->ino,
blk, blockcnt);
if (retval) {
com_err(program_name, retval,
"while adding to directory block list");
fatal_error(0);
}
}
return ret_code;
}
static void bad_block_indirect(ext2_filsys fs, blk_t blk)
{
printf("Bad block %u used as bad block indirect block?!?\n", blk);
preenhalt(fs);
printf("\nThis inconsistency can not be fixed with "
"e2fsck; to fix it, use\n"
"""dumpe2fs -b"" to dump out the bad block "
"list and ""e2fsck -L filename""\n"
"to read it back in again.\n");
if (ask("Continue", 0))
return;
fatal_error(0);
}
static int bad_primary_block(ext2_filsys fs, blk_t *block_nr)
{
printf("\nIf the block is really bad, the filesystem can not be "
"fixed.\n");
preenhalt(fs);
printf("You can clear the this block from the bad block list\n");
printf("and hope that block is really OK, but there are no "
"guarantees.\n\n");
if (ask("Clear (and hope for the best)", 1)) {
*block_nr = 0;
return 1;
}
ext2fs_unmark_valid(fs);
return 0;
}
int process_bad_block(ext2_filsys fs,
blk_t *block_nr,
int blockcnt,
blk_t ref_block,
int ref_offset,
void *private)
{
struct process_block_struct *p;
blk_t blk = *block_nr;
int first_block;
int i;
struct problem_context *pctx;
if (!blk)
return 0;
p = (struct process_block_struct *) private;
pctx = p->pctx;
pctx->blk = blk;
pctx->blkcount = blockcnt;
if ((blk < fs->super->s_first_data_block) ||
(blk >= fs->super->s_blocks_count)) {
if (fix_problem(fs, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
*block_nr = 0;
return BLOCK_CHANGED;
} else
return 0;
}
if (blockcnt < 0) {
if (ext2fs_test_block_bitmap(block_found_map, blk))
bad_block_indirect(fs, blk);
else
mark_block_used(fs, blk);
return 0;
}
#if 0
printf ("DEBUG: Marking %u as bad.\n", blk);
#endif
fs_badblocks_count++;
/*
* If the block is not used, then mark it as used and return.
* If it is already marked as found, this must mean that
* there's an overlap between the filesystem table blocks
* (bitmaps and inode table) and the bad block list.
*/
if (!ext2fs_test_block_bitmap(block_found_map, blk)) {
ext2fs_mark_block_bitmap(block_found_map, blk);
return 0;
}
/*
* Try to find the where the filesystem block was used...
*/
first_block = fs->super->s_first_data_block;
for (i = 0; i < fs->group_desc_count; i++ ) {
pctx->group = i;
if (blk == first_block) {
if (i == 0) {
printf("The primary superblock (%u) is "
"on the bad block list.\n", blk);
if (bad_primary_block(fs, block_nr))
return BLOCK_CHANGED;
return 0;
}
if (!preen)
printf("Warning: Group %d's superblock "
"(%u) is bad.\n", i, blk);
return 0;
}
if ((blk > first_block) &&
(blk <= first_block + fs->desc_blocks)) {
if (i == 0) {
printf("Block %u in the primary group "
"descriptors is on the bad block "
"list\n", blk);
if (bad_primary_block(fs, block_nr))
return BLOCK_CHANGED;
return 0;
}
if (!preen)
printf("Warning: Group %d's copy of the "
"group descriptors has a bad "
"block (%u).\n", i, blk);
return 0;
}
if (blk == fs->group_desc[i].bg_block_bitmap) {
if (fix_problem(fs, PR_1_BB_BAD_BLOCK, pctx)) {
invalid_block_bitmap[i]++;
invalid_bitmaps++;
}
return 0;
}
if (blk == fs->group_desc[i].bg_inode_bitmap) {
if (fix_problem(fs, PR_1_IB_BAD_BLOCK, pctx)) {
invalid_inode_bitmap[i]++;
invalid_bitmaps++;
}
return 0;
}
if ((blk >= fs->group_desc[i].bg_inode_table) &&
(blk < (fs->group_desc[i].bg_inode_table +
fs->inode_blocks_per_group))) {
/*
* If there are bad blocks in the inode table,
* the inode scan code will try to do
* something reasonable automatically.
*/
return 0;
}
}
/*
* If we've gotten to this point, then the only
* possibility is that the bad block inode meta data
* is using a bad block.
*/
if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
p->inode->i_block[EXT2_DIND_BLOCK]) {
bad_block_indirect(fs, blk);
return 0;
}
printf("Programming error? block #%u claimed for no reason "
"in process_bad_block.\n", blk);
return 0;
}
static void new_table_block(ext2_filsys fs, blk_t first_block, int group,
const char *name, int num, blk_t *new_block)
{
errcode_t retval;
blk_t old_block = *new_block;
int i;
char *buf;
retval = ext2fs_get_free_blocks(fs, first_block,
first_block + fs->super->s_blocks_per_group,
num, block_found_map, new_block);
if (retval) {
printf("Could not allocate %d block(s) for %s: %s\n",
num, name, error_message(retval));
ext2fs_unmark_valid(fs);
return;
}
buf = malloc(fs->blocksize);
if (!buf) {
printf("Could not allocate block buffer for relocating %s\n",
name);
ext2fs_unmark_valid(fs);
return;
}
ext2fs_mark_super_dirty(fs);
printf("Relocating group %d's %s ", group, name);
if (old_block)
printf("from %u ", old_block);
printf("to %u...\n", *new_block);
for (i = 0; i < num; i++) {
ext2fs_mark_block_bitmap(block_found_map, (*new_block)+i);
if (old_block) {
retval = io_channel_read_blk(fs->io, old_block + i,
1, buf);
if (retval)
printf("Warning: could not read block %u "
"of %s: %s\n",
old_block + i, name,
error_message(retval));
} else
memset(buf, 0, fs->blocksize);
retval = io_channel_write_blk(fs->io, (*new_block) + i,
1, buf);
if (retval)
printf("Warning: could not write block %u for %s: %s\n",
(*new_block) + i, name, error_message(retval));
}
free(buf);
}
/*
* This routine gets called at the end of pass 1 if bad blocks are
* detected in the superblock, group descriptors, inode_bitmaps, or
* block bitmaps. At this point, all of the blocks have been mapped
* out, so we can try to allocate new block(s) to replace the bad
* blocks.
*/
static void handle_fs_bad_blocks(ext2_filsys fs)
{
int i;
int first_block = fs->super->s_first_data_block;
for (i = 0; i < fs->group_desc_count; i++) {
if (invalid_block_bitmap[i]) {
new_table_block(fs, first_block, i, "block bitmap", 1,
&fs->group_desc[i].bg_block_bitmap);
}
if (invalid_inode_bitmap[i]) {
new_table_block(fs, first_block, i, "inode bitmap", 1,
&fs->group_desc[i].bg_inode_bitmap);
}
if (invalid_inode_table[i]) {
new_table_block(fs, first_block, i, "inode table",
fs->inode_blocks_per_group,
&fs->group_desc[i].bg_inode_table);
restart_e2fsck++;
}
first_block += fs->super->s_blocks_per_group;
}
invalid_bitmaps = 0;
}
/*
* This routine marks all blocks which are used by the superblock,
* group descriptors, inode bitmaps, and block bitmaps.
*/
static void mark_table_blocks(ext2_filsys fs)
{
blk_t block, b;
int i,j;
struct problem_context pctx;
clear_problem_context(&pctx);
block = fs->super->s_first_data_block;
for (i = 0; i < fs->group_desc_count; i++) {
pctx.group = i;
/*
* Mark the blocks used for the inode table
*/
if (fs->group_desc[i].bg_inode_table) {
for (j = 0, b = fs->group_desc[i].bg_inode_table;
j < fs->inode_blocks_per_group;
j++, b++) {
if (ext2fs_test_block_bitmap(block_found_map,
b)) {
pctx.blk = b;
if (fix_problem(fs,
PR_1_ITABLE_CONFLICT, &pctx)) {
invalid_inode_table[i]++;
invalid_bitmaps++;
}
} else {
ext2fs_mark_block_bitmap(block_found_map,
b);
ext2fs_mark_block_bitmap(block_illegal_map,
b);
}
}
}
/*
* Mark block used for the block bitmap
*/
if (fs->group_desc[i].bg_block_bitmap) {
if (ext2fs_test_block_bitmap(block_found_map,
fs->group_desc[i].bg_block_bitmap)) {
pctx.blk = fs->group_desc[i].bg_block_bitmap;
if (fix_problem(fs, PR_1_BB_CONFLICT, &pctx)) {
invalid_block_bitmap[i]++;
invalid_bitmaps++;
}
} else {
ext2fs_mark_block_bitmap(block_found_map,
fs->group_desc[i].bg_block_bitmap);
ext2fs_mark_block_bitmap(block_illegal_map,
fs->group_desc[i].bg_block_bitmap);
}
}
/*
* Mark block used for the inode bitmap
*/
if (fs->group_desc[i].bg_inode_bitmap) {
if (ext2fs_test_block_bitmap(block_found_map,
fs->group_desc[i].bg_inode_bitmap)) {
pctx.blk = fs->group_desc[i].bg_inode_bitmap;
if (fix_problem(fs, PR_1_IB_CONFLICT, &pctx)) {
invalid_inode_bitmap[i]++;
invalid_bitmaps++;
}
} else {
ext2fs_mark_block_bitmap(block_found_map,
fs->group_desc[i].bg_inode_bitmap);
ext2fs_mark_block_bitmap(block_illegal_map,
fs->group_desc[i].bg_inode_bitmap);
}
}
/*
* Mark this group's copy of the superblock
*/
ext2fs_mark_block_bitmap(block_found_map, block);
ext2fs_mark_block_bitmap(block_illegal_map, block);
/*
* Mark this group's copy of the descriptors
*/
for (j = 0; j < fs->desc_blocks; j++) {
ext2fs_mark_block_bitmap(block_found_map,
block + j + 1);
ext2fs_mark_block_bitmap(block_illegal_map,
block + j + 1);
}
block += fs->super->s_blocks_per_group;
}
}
/*
* This subroutines short circuits ext2fs_get_blocks and
* ext2fs_check_directory; we use them since we already have the inode
* structure, so there's no point in letting the ext2fs library read
* the inode again.
*/
errcode_t pass1_get_blocks(ext2_filsys fs, ino_t ino, blk_t *blocks)
{
int i;
if (ino == stashed_ino) {
for (i=0; i < EXT2_N_BLOCKS; i++)
blocks[i] = stashed_inode->i_block[i];
return 0;
}
printf("INTERNAL ERROR: pass1_get_blocks: unexpected inode #%lu\n",
ino);
printf("\t(was expecting %lu)\n", stashed_ino);
exit(FSCK_ERROR);
}
errcode_t pass1_read_inode(ext2_filsys fs, ino_t ino, struct ext2_inode *inode)
{
if (ino != stashed_ino)
return EXT2_ET_CALLBACK_NOTHANDLED;
*inode = *stashed_inode;
return 0;
}
errcode_t pass1_write_inode(ext2_filsys fs, ino_t ino,
struct ext2_inode *inode)
{
if (ino == stashed_ino)
*stashed_inode = *inode;
return EXT2_ET_CALLBACK_NOTHANDLED;
}
errcode_t pass1_check_directory(ext2_filsys fs, ino_t ino)
{
if (ino == stashed_ino) {
if (!LINUX_S_ISDIR(stashed_inode->i_mode))
return ENOTDIR;
return 0;
}
printf("INTERNAL ERROR: pass1_check_directory: unexpected inode #%lu\n",
ino);
printf("\t(was expecting %lu)\n", stashed_ino);
exit(FSCK_ERROR);
}
Reference in New Issue View Git Blame Copy Permalink