int open_target(char* target, cmd_opt* opt) {
int ret = 0;
int debug = opt->debug;
char *mp;
int flags = O_WRONLY | O_LARGEFILE;
struct stat st_dev;
log_mesg(1, 0, 0, debug, "open target file/device\n");
if (opt->clone || opt->domain) {
if (strcmp(target, "-") == 0) {
if ((ret = fileno(stdout)) == -1)
log_mesg(0, 1, 1, debug, "clone: open %s(stdout) error\n", target);
} else {
flags |= O_CREAT | O_TRUNC;
if (!opt->overwrite)
flags |= O_EXCL;
if ((ret = open(target, flags, S_IRUSR|S_IWUSR)) == -1) {
if (errno == EEXIST) {
log_mesg(0, 0, 1, debug, "Output file '%s' already exists.\n"
"Use option --overwrite if you want to replace its content.\n", target);
}
log_mesg(0, 0, 1, debug, "open target fail %s: %s (%i)\n", target, strerror(errno), errno);
}
}
} else if ((opt->restore) || (opt->dd)) { /// always is device, restore to device=target
/// check mounted
mp = malloc(PATH_MAX + 1);
if (!mp)
log_mesg(0, 1, 1, debug, "%s, %i, not enough memory\n", __func__, __LINE__);
if (check_mount(target, mp)) {
log_mesg(0, 0, 1, debug, "device (%s) is mounted at %s\n", target, mp);
free(mp);
log_mesg(0, 1, 1, debug, "error exit\n");
}
free(mp);
/// check block device
stat(target, &st_dev);
if (!S_ISBLK(st_dev.st_mode)) {
log_mesg(1, 0, 1, debug, "Warning, did you restore to non-block device(%s)?\n", target);
flags |= O_CREAT;
if (!opt->overwrite)
flags |= O_EXCL;
}
if ((ret = open (target, flags, S_IRUSR)) == -1) {
if (errno == EEXIST) {
log_mesg(0, 0, 1, debug, "Output file '%s' already exists.\n"
"Use option --overwrite if you want to replace its content.\n", target);
}
log_mesg(0, 0, 1, debug, "%s,%s,%i: open %s error(%i)\n", __FILE__, __func__, __LINE__, target, errno);
}
}
return ret;
}
void check_mounts() {
time_t startTime = time(NULL);
int livemountcount = 0;
int mountcount = 0;
#ifdef __linux__
FILE *fp;
struct mntent *entry;
fp = setmntent( _PATH_MOUNTED, "r" );
while ((entry = getmntent(fp)) != NULL ) {
if (check_mount(entry->mnt_dir)) {
livemountcount++;
}
mountcount++;
}
endmntent( fp );
#else
struct statfs *mounts;
mountcount = getmntinfo(&mounts, MNT_NOWAIT);
if (mountcount < 0) {
syslog(LOG_CRIT, "Couldn't retrieve filesystem information: errno %d: %m", errno);
}
for (int i = 0; i < mountcount; i++) {
if (check_mount(mounts[i].f_mntonname)) {
livemountcount++;
}
}
#endif
if (mountcount != livemountcount) {
syslog(LOG_INFO, "Checked %u mounts in %i seconds: %u dead", livemountcount, (int)(time(NULL) - startTime), mountcount - livemountcount);
} else {
syslog(LOG_INFO, "Checked %u mounts in %i seconds", livemountcount, (int)(time(NULL) - startTime));
}
}
int open_source(char* source, cmd_opt* opt) {
int ret = 0;
int debug = opt->debug;
char *mp;
int flags = O_RDONLY | O_LARGEFILE;
struct stat st_dev;
int ddd_block_device = -1;
log_mesg(1, 0, 0, debug, "open source file/device %s\n", source);
if (opt->ddd) {
if (stat(source, &st_dev) != -1) {
if (S_ISBLK(st_dev.st_mode))
ddd_block_device = 1;
else
ddd_block_device = 0;
}else{
ddd_block_device = 0;
}
log_mesg(1, 0, 0, debug, "ddd source file(0) or device(1) ? %i \n", ddd_block_device);
}
if ((opt->clone) || (opt->dd) || (opt->domain) || (ddd_block_device == 1)) { /// always is device, clone from device=source
mp = malloc(PATH_MAX + 1);
if (!mp)
log_mesg(0, 1, 1, debug, "%s, %i, not enough memory\n", __func__, __LINE__);
if (check_mount(source, mp) == 1) {
log_mesg(0, 0, 1, debug, "device (%s) is mounted at %s\n", source, mp);
free(mp);
log_mesg(0, 1, 1, debug, "error exit\n");
}
free(mp);
if ((ret = open(source, flags, S_IRUSR)) == -1)
log_mesg(0, 1, 1, debug, "clone: open %s error\n", source);
} else if ((opt->restore) || (ddd_block_device == 0)) {
if (strcmp(source, "-") == 0) {
if ((ret = fileno(stdin)) == -1)
log_mesg(0, 1, 1, debug, "restore: open %s(stdin) error\n", source);
} else {
if ((ret = open (source, flags, S_IRWXU)) == -1)
log_mesg(0, 1, 1, debug, "restore: open %s error\n", source);
}
}
return ret;
}
int main(int argc, char *argv[])
{
parse_arg(argc, argv);
check_params_before();
check_mount();
stat_dev();
open_dev();
check_params_after();
create_super_block();
init_inodes();
init_root_block();
link_free_blocks();
close_dev();
return 0;
}
void set_cd_device(Window *win, char *str, int blah)
{
if (drive)
close(drive);
if (!str || !check_mount(str))
{
put_it("%s: ERROR: CDROM is already mounted, please unmount, and try again",cparse(cdrom_prompt));
set_string_var(CD_DEVICE_VAR,NULL);
return;
}
if (cd_init(str) < 0)
{
put_it("%s: ERROR: Could not initalize the CDROM, check if a disk is inside",cparse(cdrom_prompt));
set_string_var(CD_DEVICE_VAR,NULL);
return;
}
put_it("%s: CDROM device is now set to - %s",cparse(cdrom_prompt),str);
set_string_var(CD_DEVICE_VAR,str);
}
void make_journal_device(char *journal_device, ext2_filsys fs, int quiet, int force)
{
errcode_t retval;
ext2_filsys jfs;
io_manager io_ptr;
check_plausibility(journal_device, force);
check_mount(journal_device, force, "journal");
io_ptr = unix_io_manager;
retval = ext2fs_open(journal_device, EXT2_FLAG_RW|
EXT2_FLAG_JOURNAL_DEV_OK, 0,
fs->blocksize, io_ptr, &jfs);
if (retval)
bb_error_msg_and_die("can't journal device %s", journal_device);
if (!quiet)
printf("Adding journal to device %s: ", journal_device);
fflush(stdout);
retval = ext2fs_add_journal_device(fs, jfs);
if (retval)
bb_error_msg_and_die("\nFailed to add journal to device %s", journal_device);
if (!quiet)
puts("done");
ext2fs_close(jfs);
}
int main (int argc, char *argv[])
{
errcode_t retval = 0, retval2 = 0, orig_retval = 0;
int exit_value = FSCK_OK;
ext2_filsys fs = 0;
io_manager io_ptr;
struct ext2_super_block *sb;
const char *lib_ver_date;
int my_ver, lib_ver;
e2fsck_t ctx;
blk_t orig_superblock;
struct problem_context pctx;
int flags, run_result;
int journal_size;
int sysval, sys_page_size = 4096;
__u32 features[3];
char *cp;
klog_init();
E2F_DBG_INFO("e2fsck start...");
#ifdef E2FSCK_PIPE_DEBUG_
memset(pipe_msg_temp, 0, MSG_LEN);
memcpy(pipe_msg_temp, argv[2], strlen(argv[2]));
pipe_open();
pipe_write(C_IN_START);
#endif
clear_problem_context(&pctx);
#ifdef MTRACE
mtrace();
#endif
#ifdef MCHECK
mcheck(0);
#endif
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
#endif
my_ver = ext2fs_parse_version_string(my_ver_string);
lib_ver = ext2fs_get_library_version(0, &lib_ver_date);
if (my_ver > lib_ver) {
fprintf( stderr, _("Error: ext2fs library version "
"out of date!\n"));
show_version_only++;
}
retval = PRS(argc, argv, &ctx);
if (retval) {
com_err("e2fsck", retval,
_("while trying to initialize program"));
exit(FSCK_ERROR);
}
reserve_stdio_fds();
init_resource_track(&ctx->global_rtrack, NULL);
if (!(ctx->options & E2F_OPT_PREEN) || show_version_only)
fprintf(stderr, "e2fsck %s (%s)\n", my_ver_string,
my_ver_date);
if (show_version_only) {
fprintf(stderr, _("\tUsing %s, %s\n"),
error_message(EXT2_ET_BASE), lib_ver_date);
exit(FSCK_OK);
}
check_mount(ctx);
if (!(ctx->options & E2F_OPT_PREEN) &&
!(ctx->options & E2F_OPT_NO) &&
!(ctx->options & E2F_OPT_YES)) {
if (!ctx->interactive)
fatal_error(ctx,
_("need terminal for interactive repairs"));
}
ctx->superblock = ctx->use_superblock;
restart:
#ifdef CONFIG_TESTIO_DEBUG
if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
io_ptr = test_io_manager;
test_io_backing_manager = unix_io_manager;
} else
#endif
io_ptr = unix_io_manager;
flags = EXT2_FLAG_NOFREE_ON_ERROR;
if ((ctx->options & E2F_OPT_READONLY) == 0)
flags |= EXT2_FLAG_RW;
if ((ctx->mount_flags & EXT2_MF_MOUNTED) == 0)
flags |= EXT2_FLAG_EXCLUSIVE;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) &&
!(ctx->flags & E2F_FLAG_SB_SPECIFIED) &&
((retval == EXT2_ET_BAD_MAGIC) ||
(retval == EXT2_ET_CORRUPT_SUPERBLOCK) ||
((retval == 0) && (retval2 = ext2fs_check_desc(fs))))) {
if (retval2 == ENOMEM) {
retval = retval2;
goto failure;
}
if (fs->flags & EXT2_FLAG_NOFREE_ON_ERROR) {
ext2fs_free(fs);
fs = NULL;
}
if (!fs || (fs->group_desc_count > 1)) {
printf(_("%s: %s trying backup blocks...\n"),
ctx->program_name,
retval ? _("Superblock invalid,") :
_("Group descriptors look bad..."));
orig_superblock = ctx->superblock;
get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr);
if (fs)
ext2fs_close(fs);
orig_retval = retval;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
if ((orig_retval == 0) && retval != 0) {
if (fs)
ext2fs_close(fs);
com_err(ctx->program_name, retval,
"when using the backup blocks");
printf(_("%s: going back to original "
"superblock\n"), ctx->program_name);
ctx->superblock = orig_superblock;
retval = try_open_fs(ctx, flags, io_ptr, &fs);
}
}
}
if (((retval == EXT2_ET_UNSUPP_FEATURE) ||
(retval == EXT2_ET_RO_UNSUPP_FEATURE)) &&
fs && fs->super) {
sb = fs->super;
features[0] = (sb->s_feature_compat &
~EXT2_LIB_FEATURE_COMPAT_SUPP);
features[1] = (sb->s_feature_incompat &
~EXT2_LIB_FEATURE_INCOMPAT_SUPP);
features[2] = (sb->s_feature_ro_compat &
~EXT2_LIB_FEATURE_RO_COMPAT_SUPP);
if (features[0] || features[1] || features[2])
goto print_unsupp_features;
}
failure:
if (retval) {
if (orig_retval)
retval = orig_retval;
com_err(ctx->program_name, retval, _("while trying to open %s"),
ctx->filesystem_name);
if (retval == EXT2_ET_REV_TOO_HIGH) {
printf(_("The filesystem revision is apparently "
"too high for this version of e2fsck.\n"
"(Or the filesystem superblock "
"is corrupt)\n\n"));
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
} else if (retval == EXT2_ET_SHORT_READ)
printf(_("Could this be a zero-length partition?\n"));
else if ((retval == EPERM) || (retval == EACCES))
printf(_("You must have %s access to the "
"filesystem or be root\n"),
(ctx->options & E2F_OPT_READONLY) ?
"r/o" : "r/w");
else if (retval == ENXIO)
printf(_("Possibly non-existent or swap device?\n"));
else if (retval == EBUSY)
printf(_("Filesystem mounted or opened exclusively "
"by another program?\n"));
else if (retval == ENOENT)
printf(_("Possibly non-existent device?\n"));
#ifdef EROFS
else if (retval == EROFS)
printf(_("Disk write-protected; use the -n option "
"to do a read-only\n"
"check of the device.\n"));
#endif
else
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
fatal_error(ctx, 0);
}
/*
* We only update the master superblock because (a) paranoia;
* we don't want to corrupt the backup superblocks, and (b) we
* don't need to update the mount count and last checked
* fields in the backup superblock (the kernel doesn't update
* the backup superblocks anyway). With newer versions of the
* library this flag is set by ext2fs_open2(), but we set this
* here just to be sure. (No, we don't support e2fsck running
* with some other libext2fs than the one that it was shipped
* with, but just in case....)
*/
fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
if (!(ctx->flags & E2F_FLAG_GOT_DEVSIZE)) {
__u32 blocksize = EXT2_BLOCK_SIZE(fs->super);
int need_restart = 0;
pctx.errcode = ext2fs_get_device_size2(ctx->filesystem_name,
blocksize,
&ctx->num_blocks);
/*
* The floppy driver refuses to allow anyone else to
* open the device if has been opened with O_EXCL;
* this is unlike other block device drivers in Linux.
* To handle this, we close the filesystem and then
* reopen the filesystem after we get the device size.
*/
if (pctx.errcode == EBUSY) {
ext2fs_close(fs);
need_restart++;
pctx.errcode =
ext2fs_get_device_size2(ctx->filesystem_name,
blocksize,
&ctx->num_blocks);
}
if (pctx.errcode == EXT2_ET_UNIMPLEMENTED)
ctx->num_blocks = 0;
else if (pctx.errcode) {
fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
fatal_error(ctx, 0);
}
ctx->flags |= E2F_FLAG_GOT_DEVSIZE;
if (need_restart)
goto restart;
}
ctx->fs = fs;
fs->priv_data = ctx;
fs->now = ctx->now;
sb = fs->super;
if (sb->s_rev_level > E2FSCK_CURRENT_REV) {
com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH,
_("while trying to open %s"),
ctx->filesystem_name);
get_newer:
fatal_error(ctx, _("Get a newer version of e2fsck!"));
}
/*
* Set the device name, which is used whenever we print error
* or informational messages to the user.
*/
if (ctx->device_name == 0 &&
(sb->s_volume_name[0] != 0)) {
ctx->device_name = string_copy(ctx, sb->s_volume_name,
sizeof(sb->s_volume_name));
}
if (ctx->device_name == 0)
ctx->device_name = string_copy(ctx, ctx->filesystem_name, 0);
for (cp = ctx->device_name; *cp; cp++)
if (isspace(*cp) || *cp == ':')
*cp = '_';
ehandler_init(fs->io);
if ((ctx->mount_flags & EXT2_MF_MOUNTED) &&
!(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER))
goto skip_journal;
/*
* Make sure the ext3 superblock fields are consistent.
*/
retval = e2fsck_check_ext3_journal(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while checking ext3 journal for %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
/*
* Check to see if we need to do ext3-style recovery. If so,
* do it, and then restart the fsck.
*/
if (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) {
if (ctx->options & E2F_OPT_READONLY) {
printf(_("Warning: skipping journal recovery "
"because doing a read-only filesystem "
"check.\n"));
io_channel_flush(ctx->fs->io);
} else {
if (ctx->flags & E2F_FLAG_RESTARTED) {
/*
* Whoops, we attempted to run the
* journal twice. This should never
* happen, unless the hardware or
* device driver is being bogus.
*/
com_err(ctx->program_name, 0,
_("unable to set superblock flags on %s\n"), ctx->device_name);
fatal_error(ctx, 0);
}
retval = e2fsck_run_ext3_journal(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while recovering ext3 journal of %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
ext2fs_close(ctx->fs);
ctx->fs = 0;
ctx->flags |= E2F_FLAG_RESTARTED;
goto restart;
}
}
skip_journal:
/*
* Check for compatibility with the feature sets. We need to
* be more stringent than ext2fs_open().
*/
features[0] = sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP;
features[1] = sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP;
features[2] = (sb->s_feature_ro_compat &
~EXT2_LIB_FEATURE_RO_COMPAT_SUPP);
print_unsupp_features:
if (features[0] || features[1] || features[2]) {
int i, j;
__u32 *mask = features, m;
fprintf(stderr, _("%s has unsupported feature(s):"),
ctx->filesystem_name);
for (i=0; i <3; i++,mask++) {
for (j=0,m=1; j < 32; j++, m<<=1) {
if (*mask & m)
fprintf(stderr, " %s",
e2p_feature2string(i, m));
}
}
putc('\n', stderr);
goto get_newer;
}
#ifdef ENABLE_COMPRESSION
if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)
com_err(ctx->program_name, 0,
_("Warning: compression support is experimental.\n"));
#endif
#ifndef ENABLE_HTREE
if (sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) {
com_err(ctx->program_name, 0,
_("E2fsck not compiled with HTREE support,\n\t"
"but filesystem %s has HTREE directories.\n"),
ctx->device_name);
goto get_newer;
}
#endif
/*
* If the user specified a specific superblock, presumably the
* master superblock has been trashed. So we mark the
* superblock as dirty, so it can be written out.
*/
if (ctx->superblock &&
!(ctx->options & E2F_OPT_READONLY))
ext2fs_mark_super_dirty(fs);
/*
* Calculate the number of filesystem blocks per pagesize. If
* fs->blocksize > page_size, set the number of blocks per
* pagesize to 1 to avoid division by zero errors.
*/
#ifdef _SC_PAGESIZE
sysval = sysconf(_SC_PAGESIZE);
if (sysval > 0)
sys_page_size = sysval;
#endif /* _SC_PAGESIZE */
ctx->blocks_per_page = sys_page_size / fs->blocksize;
if (ctx->blocks_per_page == 0)
ctx->blocks_per_page = 1;
if (ctx->superblock)
set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0);
ext2fs_mark_valid(fs);
check_super_block(ctx);
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
check_if_skip(ctx);
check_resize_inode(ctx);
if (bad_blocks_file)
read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks);
else if (cflag)
read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
/*
* Mark the system as valid, 'til proven otherwise
*/
ext2fs_mark_valid(fs);
retval = ext2fs_read_bb_inode(fs, &fs->badblocks);
if (retval) {
com_err(ctx->program_name, retval,
_("while reading bad blocks inode"));
preenhalt(ctx);
printf(_("This doesn't bode well,"
" but we'll try to go on...\n"));
}
/*
* Save the journal size in megabytes.
* Try and use the journal size from the backup else let e2fsck
* find the default journal size.
*/
if (sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS)
journal_size = sb->s_jnl_blocks[16] >> 20;
else
int main (int argc, char *argv[])
{
errcode_t retval = 0;
int exit_value = FSCK_OK;
ext2_filsys fs = 0;
io_manager io_ptr;
struct ext2_super_block *sb;
const char *lib_ver_date;
int my_ver, lib_ver;
e2fsck_t ctx;
struct problem_context pctx;
int flags, run_result;
clear_problem_context(&pctx);
#ifdef MTRACE
mtrace();
#endif
#ifdef MCHECK
mcheck(0);
#endif
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
#endif
my_ver = ext2fs_parse_version_string(my_ver_string);
lib_ver = ext2fs_get_library_version(0, &lib_ver_date);
if (my_ver > lib_ver) {
fprintf( stderr, _("Error: ext2fs library version "
"out of date!\n"));
show_version_only++;
}
retval = PRS(argc, argv, &ctx);
if (retval) {
com_err("e2fsck", retval,
_("while trying to initialize program"));
exit(FSCK_ERROR);
}
reserve_stdio_fds();
#ifdef RESOURCE_TRACK
init_resource_track(&ctx->global_rtrack);
#endif
if (!(ctx->options & E2F_OPT_PREEN) || show_version_only)
fprintf(stderr, "e2fsck %s (%s)\n", my_ver_string,
my_ver_date);
if (show_version_only) {
fprintf(stderr, _("\tUsing %s, %s\n"),
error_message(EXT2_ET_BASE), lib_ver_date);
exit(FSCK_OK);
}
check_mount(ctx);
if (!(ctx->options & E2F_OPT_PREEN) &&
!(ctx->options & E2F_OPT_NO) &&
!(ctx->options & E2F_OPT_YES)) {
if (!ctx->interactive)
fatal_error(ctx,
_("need terminal for interactive repairs"));
}
ctx->superblock = ctx->use_superblock;
restart:
#ifdef CONFIG_TESTIO_DEBUG
io_ptr = test_io_manager;
test_io_backing_manager = unix_io_manager;
#else
io_ptr = unix_io_manager;
#endif
flags = 0;
if ((ctx->options & E2F_OPT_READONLY) == 0)
flags |= EXT2_FLAG_RW;
if ((ctx->mount_flags & EXT2_MF_MOUNTED) == 0)
flags |= EXT2_FLAG_EXCLUSIVE;
if (ctx->superblock && ctx->blocksize) {
retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options,
flags, ctx->superblock, ctx->blocksize,
io_ptr, &fs);
} else if (ctx->superblock) {
int blocksize;
for (blocksize = EXT2_MIN_BLOCK_SIZE;
blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) {
retval = ext2fs_open2(ctx->filesystem_name,
ctx->io_options, flags,
ctx->superblock, blocksize,
io_ptr, &fs);
if (!retval)
break;
}
} else
retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options,
flags, 0, 0, io_ptr, &fs);
if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) &&
!(ctx->flags & E2F_FLAG_SB_SPECIFIED) &&
((retval == EXT2_ET_BAD_MAGIC) ||
((retval == 0) && ext2fs_check_desc(fs)))) {
if (!fs || (fs->group_desc_count > 1)) {
printf(_("%s trying backup blocks...\n"),
retval ? _("Couldn't find ext2 superblock,") :
_("Group descriptors look bad..."));
get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr);
if (fs)
ext2fs_close(fs);
goto restart;
}
}
if (retval) {
com_err(ctx->program_name, retval, _("while trying to open %s"),
ctx->filesystem_name);
if (retval == EXT2_ET_REV_TOO_HIGH) {
printf(_("The filesystem revision is apparently "
"too high for this version of e2fsck.\n"
"(Or the filesystem superblock "
"is corrupt)\n\n"));
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
} else if (retval == EXT2_ET_SHORT_READ)
printf(_("Could this be a zero-length partition?\n"));
else if ((retval == EPERM) || (retval == EACCES))
printf(_("You must have %s access to the "
"filesystem or be root\n"),
(ctx->options & E2F_OPT_READONLY) ?
"r/o" : "r/w");
else if (retval == ENXIO)
printf(_("Possibly non-existent or swap device?\n"));
else if (retval == EBUSY)
printf(_("Filesystem mounted or opened exclusively "
"by another program?\n"));
#ifdef EROFS
else if (retval == EROFS)
printf(_("Disk write-protected; use the -n option "
"to do a read-only\n"
"check of the device.\n"));
#endif
else
fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
fatal_error(ctx, 0);
}
ctx->fs = fs;
fs->priv_data = ctx;
fs->now = ctx->now;
sb = fs->super;
if (sb->s_rev_level > E2FSCK_CURRENT_REV) {
com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH,
_("while trying to open %s"),
ctx->filesystem_name);
get_newer:
fatal_error(ctx, _("Get a newer version of e2fsck!"));
}
/*
* Set the device name, which is used whenever we print error
* or informational messages to the user.
*/
if (ctx->device_name == 0 &&
(sb->s_volume_name[0] != 0)) {
ctx->device_name = string_copy(ctx, sb->s_volume_name,
sizeof(sb->s_volume_name));
}
if (ctx->device_name == 0)
ctx->device_name = ctx->filesystem_name;
/*
* Make sure the ext3 superblock fields are consistent.
*/
retval = e2fsck_check_ext3_journal(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while checking ext3 journal for %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
/*
* Check to see if we need to do ext3-style recovery. If so,
* do it, and then restart the fsck.
*/
if (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) {
if (ctx->options & E2F_OPT_READONLY) {
printf(_("Warning: skipping journal recovery "
"because doing a read-only filesystem "
"check.\n"));
io_channel_flush(ctx->fs->io);
} else {
if (ctx->flags & E2F_FLAG_RESTARTED) {
/*
* Whoops, we attempted to run the
* journal twice. This should never
* happen, unless the hardware or
* device driver is being bogus.
*/
com_err(ctx->program_name, 0,
_("unable to set superblock flags on %s\n"), ctx->device_name);
fatal_error(ctx, 0);
}
retval = e2fsck_run_ext3_journal(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while recovering ext3 journal of %s"),
ctx->device_name);
fatal_error(ctx, 0);
}
ext2fs_close(ctx->fs);
ctx->fs = 0;
ctx->flags |= E2F_FLAG_RESTARTED;
goto restart;
}
}
/*
* Check for compatibility with the feature sets. We need to
* be more stringent than ext2fs_open().
*/
if ((sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) ||
(sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP)) {
com_err(ctx->program_name, EXT2_ET_UNSUPP_FEATURE,
"(%s)", ctx->device_name);
goto get_newer;
}
if (sb->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) {
com_err(ctx->program_name, EXT2_ET_RO_UNSUPP_FEATURE,
"(%s)", ctx->device_name);
goto get_newer;
}
#ifdef ENABLE_COMPRESSION
if (sb->s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)
com_err(ctx->program_name, 0,
_("Warning: compression support is experimental.\n"));
#endif
#ifndef ENABLE_HTREE
if (sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) {
com_err(ctx->program_name, 0,
_("E2fsck not compiled with HTREE support,\n\t"
"but filesystem %s has HTREE directories.\n"),
ctx->device_name);
goto get_newer;
}
#endif
/*
* If the user specified a specific superblock, presumably the
* master superblock has been trashed. So we mark the
* superblock as dirty, so it can be written out.
*/
if (ctx->superblock &&
!(ctx->options & E2F_OPT_READONLY))
ext2fs_mark_super_dirty(fs);
/*
* We only update the master superblock because (a) paranoia;
* we don't want to corrupt the backup superblocks, and (b) we
* don't need to update the mount count and last checked
* fields in the backup superblock (the kernel doesn't
* update the backup superblocks anyway).
*/
fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
ehandler_init(fs->io);
if (ctx->superblock)
set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0);
ext2fs_mark_valid(fs);
check_super_block(ctx);
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
check_if_skip(ctx);
if (bad_blocks_file)
read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks);
else if (cflag)
read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
#ifdef ENABLE_SWAPFS
if (normalize_swapfs) {
if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ==
ext2fs_native_flag()) {
fprintf(stderr, _("%s: Filesystem byte order "
"already normalized.\n"), ctx->device_name);
fatal_error(ctx, 0);
}
}
if (swapfs) {
swap_filesys(ctx);
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
fatal_error(ctx, 0);
}
#endif
/*
* Mark the system as valid, 'til proven otherwise
*/
ext2fs_mark_valid(fs);
retval = ext2fs_read_bb_inode(fs, &fs->badblocks);
if (retval) {
com_err(ctx->program_name, retval,
_("while reading bad blocks inode"));
preenhalt(ctx);
printf(_("This doesn't bode well,"
" but we'll try to go on...\n"));
}
run_result = e2fsck_run(ctx);
e2fsck_clear_progbar(ctx);
if (run_result == E2F_FLAG_RESTART) {
printf(_("Restarting e2fsck from the beginning...\n"));
retval = e2fsck_reset_context(ctx);
if (retval) {
com_err(ctx->program_name, retval,
_("while resetting context"));
fatal_error(ctx, 0);
}
ext2fs_close(fs);
goto restart;
}
if (run_result & E2F_FLAG_CANCEL) {
printf(_("%s: e2fsck canceled.\n"), ctx->device_name ?
ctx->device_name : ctx->filesystem_name);
exit_value |= FSCK_CANCELED;
}
if (run_result & E2F_FLAG_ABORT)
fatal_error(ctx, _("aborted"));
#ifdef MTRACE
mtrace_print("Cleanup");
#endif
if (ext2fs_test_changed(fs)) {
exit_value |= FSCK_NONDESTRUCT;
if (!(ctx->options & E2F_OPT_PREEN))
printf(_("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"),
ctx->device_name);
if (ctx->mount_flags & EXT2_MF_ISROOT) {
printf(_("%s: ***** REBOOT LINUX *****\n"),
ctx->device_name);
exit_value |= FSCK_REBOOT;
}
}
if (!ext2fs_test_valid(fs) ||
((exit_value & FSCK_CANCELED) &&
(sb->s_state & EXT2_ERROR_FS))) {
printf(_("\n%s: ********** WARNING: Filesystem still has "
"errors **********\n\n"), ctx->device_name);
exit_value |= FSCK_UNCORRECTED;
exit_value &= ~FSCK_NONDESTRUCT;
}
if (exit_value & FSCK_CANCELED) {
int allow_cancellation;
profile_get_boolean(ctx->profile, "options",
"allow_cancellation", 0, 0,
&allow_cancellation);
exit_value &= ~FSCK_NONDESTRUCT;
if (allow_cancellation && ext2fs_test_valid(fs) &&
(sb->s_state & EXT2_VALID_FS) &&
!(sb->s_state & EXT2_ERROR_FS))
exit_value = 0;
} else {
show_stats(ctx);
if (!(ctx->options & E2F_OPT_READONLY)) {
if (ext2fs_test_valid(fs)) {
if (!(sb->s_state & EXT2_VALID_FS))
exit_value |= FSCK_NONDESTRUCT;
sb->s_state = EXT2_VALID_FS;
} else
sb->s_state &= ~EXT2_VALID_FS;
sb->s_mnt_count = 0;
sb->s_lastcheck = ctx->now;
ext2fs_mark_super_dirty(fs);
}
}
e2fsck_write_bitmaps(ctx);
ext2fs_close(fs);
ctx->fs = NULL;
free(ctx->filesystem_name);
free(ctx->journal_name);
#ifdef RESOURCE_TRACK
if (ctx->options & E2F_OPT_TIME)
print_resource_track(NULL, &ctx->global_rtrack);
#endif
e2fsck_free_context(ctx);
return exit_value;
}
/*
* Check for a valid statefile pathname, inode and mount status.
*/
int
sfpath(void)
{
static int statefile;
char *err_fmt = NULL;
char *sfile, *sp, ch;
char diskname[256];
struct stat stbuf;
int dir = 0;
dev_t dev = NODEV;
if (statefile) {
mesg(MERR, "ignored redundant statefile entry\n");
return (OKUP);
} else if (ua_err) {
if (ua_err != ENOTSUP)
mesg(MERR, "uadmin(A_FREEZE, A_CHECK, 0): %s\n",
strerror(ua_err));
return (NOUP);
}
/*
* Check for an absolute path and trim any trailing '/'.
*/
sfile = LINEARG(1);
if (*sfile != '/') {
mesg(MERR, "statefile requires an absolute path\n");
return (NOUP);
}
for (sp = sfile + strlen(sfile) - 1; sp > sfile && *sp == '/'; sp--)
*sp = '\0';
/*
* If the statefile doesn't exist, the leading path must be a dir.
*/
if (stat(sfile, &stbuf) == -1) {
if (errno == ENOENT) {
dir = 1;
if ((sp = strrchr(sfile, '/')) == sfile)
sp++;
ch = *sp;
*sp = '\0';
if (stat(sfile, &stbuf) == -1)
err_fmt = stat_fmt;
*sp = ch;
} else
err_fmt = stat_fmt;
if (err_fmt) {
mesg(MERR, err_fmt, sfile, strerror(errno));
return (NOUP);
}
}
/*
* Check for regular/dir/block types, set cf_type and dev.
*/
if (S_ISREG(stbuf.st_mode) || (dir && S_ISDIR(stbuf.st_mode))) {
new_cc.cf_type = CFT_UFS;
dev = stbuf.st_dev;
} else if (S_ISBLK(stbuf.st_mode)) {
if (is_good_slice(sfile, &err_fmt)) {
switch (ztop(sfile, diskname)) {
case 1:
new_cc.cf_type = CFT_ZVOL;
break;
case 0:
new_cc.cf_type = CFT_SPEC;
break;
case -1:
default:
return (NOUP);
}
dev = stbuf.st_rdev;
}
} else
err_fmt = "bad file type for \"%s\"\n"
"statefile must be a regular file or block device\n";
if (err_fmt) {
mesg(MERR, err_fmt, sfile);
return (NOUP);
}
if (check_mount(sfile, dev, (new_cc.cf_type == CFT_UFS)))
return (NOUP);
if (new_cc.cf_type == CFT_ZVOL) {
if (utop(diskname, new_cc.cf_dev_prom))
return (NOUP);
} else if (utop(new_cc.cf_devfs, new_cc.cf_dev_prom)) {
return (NOUP);
}
new_cc.cf_magic = CPR_CONFIG_MAGIC;
statefile = 1;
return (OKUP);
}
int
main(int argc, char ** argv) {
struct stat statbuf;
struct swap_header_v1_2 *hdr;
int i;
unsigned long long maxpages;
unsigned long long goodpages;
unsigned long long sz;
off_t offset;
int force = 0;
int version = 1;
char *block_count = 0;
char *pp;
char *opt_label = NULL;
unsigned char *uuid = NULL;
#ifdef HAVE_LIBUUID
const char *opt_uuid = NULL;
uuid_t uuid_dat;
#endif
program_name = (argc && *argv) ? argv[0] : "mkswap";
if ((pp = strrchr(program_name, '/')) != NULL)
program_name = pp+1;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
if (argc == 2 &&
(!strcmp(argv[1], "-V") || !strcmp(argv[1], "--version"))) {
printf(_("%s (%s)\n"), program_name, PACKAGE_STRING);
exit(0);
}
for (i=1; i<argc; i++) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'c':
check=1;
break;
case 'f':
force=1;
break;
case 'p':
pp = argv[i]+2;
if (!*pp && i+1 < argc)
pp = argv[++i];
if (isnzdigit(*pp))
user_pagesize = atoi(pp);
else
usage();
break;
case 'L':
pp = argv[i]+2;
if (!*pp && i+1 < argc)
pp = argv[++i];
opt_label = pp;
break;
case 'v':
version = atoi(argv[i]+2);
break;
case 'U':
#ifdef HAVE_LIBUUID
opt_uuid = argv[i]+2;
if (!*opt_uuid && i+1 < argc)
opt_uuid = argv[++i];
#else
fprintf(stderr, _("%1$s: warning: ignore -U (UUIDs are unsupported by %1$s)\n"),
program_name);
#endif
break;
default:
usage();
}
} else if (!device_name) {
device_name = argv[i];
} else if (!block_count) {
block_count = argv[i];
} else
usage();
}
if (version != 1) {
fprintf(stderr, _("%s: does not support swapspace version %d.\n"),
program_name, version);
exit(EXIT_FAILURE);
}
#ifdef HAVE_LIBUUID
if(opt_uuid) {
if (uuid_parse(opt_uuid, uuid_dat) != 0)
die(_("error: UUID parsing failed"));
} else
uuid_generate(uuid_dat);
uuid = uuid_dat;
#endif
init_signature_page(); /* get pagesize */
atexit(deinit_signature_page);
if (!device_name) {
fprintf(stderr,
_("%s: error: Nowhere to set up swap on?\n"),
program_name);
usage();
}
if (block_count) {
/* this silly user specified the number of blocks explicitly */
char *tmp = NULL;
long long blks;
errno = 0;
blks = strtoll(block_count, &tmp, 0);
if ((tmp == block_count) ||
(tmp && *tmp) ||
(errno != 0 && (blks == LLONG_MAX || blks == LLONG_MIN)) ||
blks < 0)
usage();
PAGES = blks / (pagesize / 1024);
}
sz = get_size(device_name);
if (!PAGES) {
PAGES = sz;
} else if (PAGES > sz && !force) {
fprintf(stderr,
_("%s: error: "
"size %llu KiB is larger than device size %llu KiB\n"),
program_name,
PAGES*(pagesize/1024), sz*(pagesize/1024));
exit(1);
}
if (PAGES < MIN_GOODPAGES) {
fprintf(stderr,
_("%s: error: swap area needs to be at least %ld KiB\n"),
program_name, (long)(MIN_GOODPAGES * pagesize/1024));
usage();
}
#ifdef __linux__
if (get_linux_version() >= KERNEL_VERSION(2,3,4))
maxpages = UINT_MAX + 1ULL;
else if (get_linux_version() >= KERNEL_VERSION(2,2,1))
maxpages = V1_MAX_PAGES;
else
#endif
maxpages = V1_OLD_MAX_PAGES;
if (PAGES > maxpages) {
PAGES = maxpages;
fprintf(stderr,
_("%s: warning: truncating swap area to %llu KiB\n"),
program_name, PAGES * pagesize / 1024);
}
if (stat(device_name, &statbuf) < 0) {
perror(device_name);
exit(EXIT_FAILURE);
}
if (S_ISBLK(statbuf.st_mode))
DEV = open(device_name, O_RDWR | O_EXCL);
else
DEV = open(device_name, O_RDWR);
if (DEV < 0) {
perror(device_name);
exit(1);
}
/* Want a block device. Probably not /dev/hda or /dev/hdb. */
if (!S_ISBLK(statbuf.st_mode))
check=0;
else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340) {
fprintf(stderr,
_("%s: error: "
"will not try to make swapdevice on '%s'\n"),
program_name, device_name);
exit(1);
} else if (check_mount()) {
fprintf(stderr,
_("%s: error: "
"%s is mounted; will not make swapspace.\n"),
program_name, device_name);
exit(1);
}
if (check)
check_blocks();
zap_bootbits(DEV, device_name, force, S_ISBLK(statbuf.st_mode));
hdr = (struct swap_header_v1_2 *) signature_page;
hdr->version = 1;
hdr->last_page = PAGES - 1;
hdr->nr_badpages = badpages;
if (badpages > PAGES - MIN_GOODPAGES)
die(_("Unable to set up swap-space: unreadable"));
goodpages = PAGES - badpages - 1;
printf(_("Setting up swapspace version 1, size = %llu KiB\n"),
goodpages * pagesize / 1024);
write_signature("SWAPSPACE2");
write_uuid_and_label(uuid, opt_label);
offset = 1024;
if (lseek(DEV, offset, SEEK_SET) != offset)
die(_("unable to rewind swap-device"));
if (write_all(DEV, (char *) signature_page + offset,
pagesize - offset) == -1) {
fprintf(stderr, _("%s: %s: unable to write signature page: %s"),
program_name, device_name, strerror(errno));
exit(1);
}
/*
* A subsequent swapon() will fail if the signature
* is not actually on disk. (This is a kernel bug.)
*/
#ifdef HAVE_FSYNC
if (fsync(DEV))
die(_("fsync failed"));
#endif
#ifdef HAVE_LIBSELINUX
if (S_ISREG(statbuf.st_mode) && is_selinux_enabled() > 0) {
security_context_t context_string;
security_context_t oldcontext;
context_t newcontext;
if (fgetfilecon(DEV, &oldcontext) < 0) {
if (errno != ENODATA) {
fprintf(stderr, _("%s: %s: unable to obtain selinux file label: %s\n"),
program_name, device_name,
strerror(errno));
exit(1);
}
if (matchpathcon(device_name, statbuf.st_mode, &oldcontext))
die(_("unable to matchpathcon()"));
}
if (!(newcontext = context_new(oldcontext)))
die(_("unable to create new selinux context"));
if (context_type_set(newcontext, SELINUX_SWAPFILE_TYPE))
die(_("couldn't compute selinux context"));
context_string = context_str(newcontext);
if (strcmp(context_string, oldcontext)!=0) {
if (fsetfilecon(DEV, context_string)) {
fprintf(stderr, _("%s: unable to relabel %s to %s: %s\n"),
program_name, device_name,
context_string,
strerror(errno));
exit(1);
}
}
context_free(newcontext);
freecon(oldcontext);
}
#endif
return 0;
}
