void ext2fs_free(ext2_filsys fs)
{
if (!fs || (fs->magic != EXT2_ET_MAGIC_EXT2FS_FILSYS))
return;
if (fs->image_io != fs->io) {
if (fs->image_io)
io_channel_close(fs->image_io);
}
if (fs->io) {
io_channel_close(fs->io);
}
ext2fs_free_mem(&fs->device_name);
ext2fs_free_mem(&fs->super);
ext2fs_free_mem(&fs->orig_super);
ext2fs_free_mem(&fs->group_desc);
ext2fs_free_block_bitmap(fs->block_map);
ext2fs_free_inode_bitmap(fs->inode_map);
ext2fs_badblocks_list_free(fs->badblocks);
fs->badblocks = 0;
ext2fs_free_dblist(fs->dblist);
if (fs->icache)
ext2fs_free_inode_cache(fs->icache);
fs->magic = 0;
ext2fs_free_mem(&fs);
}
static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal,
int reset, int drop)
{
journal_superblock_t *jsb;
if (drop)
mark_buffer_clean(journal->j_sb_buffer);
else if (!(ctx->options & E2F_OPT_READONLY)) {
jsb = journal->j_superblock;
jsb->s_sequence = htonl(journal->j_transaction_sequence);
if (reset)
jsb->s_start = 0; /* this marks the journal as empty */
mark_buffer_dirty(journal->j_sb_buffer);
}
brelse(journal->j_sb_buffer);
if (ctx->journal_io) {
if (ctx->fs && ctx->fs->io != ctx->journal_io)
io_channel_close(ctx->journal_io);
ctx->journal_io = 0;
}
#ifndef USE_INODE_IO
if (journal->j_inode)
ext2fs_free_mem(&journal->j_inode);
#endif
if (journal->j_fs_dev)
ext2fs_free_mem(&journal->j_fs_dev);
ext2fs_free_mem(&journal);
}
static void ext2fs_journal_release(ext2_filsys fs, journal_t *journal,
int reset, int drop)
{
journal_superblock_t *jsb;
if (drop)
mark_buffer_clean(journal->j_sb_buffer);
else if (fs->flags & EXT2_FLAG_RW) {
jsb = journal->j_superblock;
jsb->s_sequence = htonl(journal->j_tail_sequence);
if (reset)
jsb->s_start = 0; /* this marks the journal as empty */
ext2fs_journal_sb_csum_set(journal, jsb);
mark_buffer_dirty(journal->j_sb_buffer);
}
brelse(journal->j_sb_buffer);
if (fs && fs->journal_io) {
if (fs->io != fs->journal_io)
io_channel_close(fs->journal_io);
fs->journal_io = NULL;
}
#ifndef USE_INODE_IO
if (journal->j_inode)
ext2fs_free_mem(&journal->j_inode);
#endif
if (journal->j_fs_dev)
ext2fs_free_mem(&journal->j_fs_dev);
ext2fs_free_mem(&journal);
}
errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io)
{
errcode_t err;
if ((fs->flags & EXT2_FLAG_IMAGE_FILE) == 0)
return EXT2_ET_NOT_IMAGE_FILE;
err = io_channel_set_blksize(new_io, fs->blocksize);
if (err)
return err;
if ((new_io == fs->image_io) || (new_io == fs->io))
return 0;
if ((fs->image_io != fs->io) &&
fs->image_io)
io_channel_close(fs->image_io);
if (fs->io)
io_channel_close(fs->io);
fs->io = fs->image_io = new_io;
fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_RW |
EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY;
fs->flags &= ~EXT2_FLAG_IMAGE_FILE;
return 0;
}
int main(int argc, char **argv) {
struct sigaction act;
io_handle_t serv1, serv2, serv3, servr, watcher;
sdp_session_t *session;
memset(&act, 0, sizeof(act));
act.sa_handler = sigint_handler;
DIE_IF_ERR(storage_segregate(&storage, 12, 512));
DIE_IF_ERR(io_loop_init(&loop));
DIE_IF_ERR(io_file(&loop, &backup, "backup.txt", O_RDWR));
DIE_IF_ERR(io_inotify(&loop, &watcher));
DIE_IF_ERR(io_tcp_server(&loop, &serv1, "0.0.0.0", "3000"));
DIE_IF_ERR(io_tcp_server(&loop, &serv2, "0.0.0.0", "4000"));
DIE_IF_ERR(io_tcp_server(&loop, &serv3, "0.0.0.0", "5000"));
DIE_IF_ERR(io_rfcomm_server(&loop, &servr, BDADDR_ANY, 4));
lseek(backup.fd, 0, SEEK_END);
DIE_IF_ERR(io_watch_start(&watcher, "/dev", IN_CREATE | IN_DELETE, file_changed));
DIE_IF_ERR(io_channel(&channel));
DIE_IF_ERR(io_channel_join(&channel, &backup, backup_updated));
DIE_IF_ERR(io_channel_join(&channel, &tcp1, serl_updated));
if(try_serial(&loop, &serl) == -1) puts("warning: arduino not connected.");
else DIE_IF_ERR(io_publish_start(&serl, &channel, data_published));
DIE_IF_ERR(io_listen_start(&serv1, new_tcp1_conn));
DIE_IF_ERR(io_listen_start(&serv2, new_tcp2_conn));
DIE_IF_ERR(io_listen_start(&serv3, new_tcp3_conn));
DIE_IF_ERR(io_listen_start(&servr, new_rfcm_conn));
session = io_rfcomm_advertise(4, name, desc, uuid128);
DIE_IF_ERR(sigaction(SIGINT, &act, NULL));
puts("pi server is up...");
DIE_IF_ERR(io_loop_run(&loop));
io_channel_close(&channel);
storage_collapse(&storage);
io_rfcomm_unadvertise(session);
return 0;
}
static errcode_t test_close(io_channel channel)
{
struct test_private_data *data;
errcode_t retval = 0;
EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
data = (struct test_private_data *) channel->private_data;
EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL);
if (--channel->refcount > 0)
return 0;
if (data->real)
retval = io_channel_close(data->real);
ext2fs_free_mem((void **) &channel->private_data);
if (channel->name)
ext2fs_free_mem((void **) &channel->name);
ext2fs_free_mem((void **) &channel);
return retval;
}
/*
* This function resets an e2fsck context; it is called when e2fsck
* needs to be restarted.
*/
errcode_t e2fsck_reset_context(e2fsck_t ctx)
{
ctx->flags = 0;
ctx->lost_and_found = 0;
ctx->bad_lost_and_found = 0;
if (ctx->inode_used_map) {
ext2fs_free_inode_bitmap(ctx->inode_used_map);
ctx->inode_used_map = 0;
}
if (ctx->inode_dir_map) {
ext2fs_free_inode_bitmap(ctx->inode_dir_map);
ctx->inode_dir_map = 0;
}
if (ctx->inode_reg_map) {
ext2fs_free_inode_bitmap(ctx->inode_reg_map);
ctx->inode_reg_map = 0;
}
if (ctx->block_found_map) {
ext2fs_free_block_bitmap(ctx->block_found_map);
ctx->block_found_map = 0;
}
if (ctx->inode_link_info) {
ext2fs_free_icount(ctx->inode_link_info);
ctx->inode_link_info = 0;
}
if (ctx->journal_io) {
if (ctx->fs && ctx->fs->io != ctx->journal_io)
io_channel_close(ctx->journal_io);
ctx->journal_io = 0;
}
if (ctx->fs && ctx->fs->dblist) {
ext2fs_free_dblist(ctx->fs->dblist);
ctx->fs->dblist = 0;
}
e2fsck_free_dir_info(ctx);
#ifdef ENABLE_HTREE
e2fsck_free_dx_dir_info(ctx);
#endif
if (ctx->refcount) {
ea_refcount_free(ctx->refcount);
ctx->refcount = 0;
}
if (ctx->refcount_extra) {
ea_refcount_free(ctx->refcount_extra);
ctx->refcount_extra = 0;
}
if (ctx->block_dup_map) {
ext2fs_free_block_bitmap(ctx->block_dup_map);
ctx->block_dup_map = 0;
}
if (ctx->block_ea_map) {
ext2fs_free_block_bitmap(ctx->block_ea_map);
ctx->block_ea_map = 0;
}
if (ctx->inode_bb_map) {
ext2fs_free_inode_bitmap(ctx->inode_bb_map);
ctx->inode_bb_map = 0;
}
if (ctx->inode_bad_map) {
ext2fs_free_inode_bitmap(ctx->inode_bad_map);
ctx->inode_bad_map = 0;
}
if (ctx->inode_imagic_map) {
ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
ctx->inode_imagic_map = 0;
}
if (ctx->dirs_to_hash) {
ext2fs_u32_list_free(ctx->dirs_to_hash);
ctx->dirs_to_hash = 0;
}
/*
* Clear the array of invalid meta-data flags
*/
if (ctx->invalid_inode_bitmap_flag) {
ext2fs_free_mem(&ctx->invalid_inode_bitmap_flag);
ctx->invalid_inode_bitmap_flag = 0;
}
if (ctx->invalid_block_bitmap_flag) {
ext2fs_free_mem(&ctx->invalid_block_bitmap_flag);
ctx->invalid_block_bitmap_flag = 0;
}
if (ctx->invalid_inode_table_flag) {
ext2fs_free_mem(&ctx->invalid_inode_table_flag);
ctx->invalid_inode_table_flag = 0;
}
/* Clear statistic counters */
ctx->fs_directory_count = 0;
ctx->fs_regular_count = 0;
ctx->fs_blockdev_count = 0;
ctx->fs_chardev_count = 0;
ctx->fs_links_count = 0;
ctx->fs_symlinks_count = 0;
ctx->fs_fast_symlinks_count = 0;
ctx->fs_fifo_count = 0;
ctx->fs_total_count = 0;
ctx->fs_badblocks_count = 0;
ctx->fs_sockets_count = 0;
ctx->fs_ind_count = 0;
ctx->fs_dind_count = 0;
ctx->fs_tind_count = 0;
ctx->fs_fragmented = 0;
ctx->large_files = 0;
/* Reset the superblock to the user's requested value */
ctx->superblock = ctx->use_superblock;
return 0;
}
int main(int argc, char *argv[])
{
int c,force = 0;
TDB_CONTEXT *tdb;
TDB_DATA key, data;
io_channel channel;
errcode_t retval;
int mount_flags;
blk64_t blk_num;
char *device_name, *tdb_file;
io_manager manager = unix_io_manager;
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
#endif
add_error_table(&et_ext2_error_table);
prg_name = argv[0];
while((c = getopt(argc, argv, "f")) != EOF) {
switch (c) {
case 'f':
force = 1;
break;
default:
usage(prg_name);
}
}
if (argc != optind+2)
usage(prg_name);
tdb_file = argv[optind];
device_name = argv[optind+1];
tdb = tdb_open(tdb_file, 0, 0, O_RDONLY, 0600);
if (!tdb) {
com_err(prg_name, errno,
_("Failed tdb_open %s\n"), tdb_file);
exit(1);
}
retval = ext2fs_check_if_mounted(device_name, &mount_flags);
if (retval) {
com_err(prg_name, retval, _("Error while determining whether "
"%s is mounted.\n"), device_name);
exit(1);
}
if (mount_flags & EXT2_MF_MOUNTED) {
com_err(prg_name, retval, _("e2undo should only be run on "
"unmounted file system\n"));
exit(1);
}
retval = manager->open(device_name,
IO_FLAG_EXCLUSIVE | IO_FLAG_RW, &channel);
if (retval) {
com_err(prg_name, retval,
_("Failed to open %s\n"), device_name);
exit(1);
}
if (!force && check_filesystem(tdb, channel)) {
exit(1);
}
if (set_blk_size(tdb, channel)) {
exit(1);
}
for (key = tdb_firstkey(tdb); key.dptr; key = tdb_nextkey(tdb, key)) {
if (!strcmp((char *) key.dptr, (char *) mtime_key) ||
!strcmp((char *) key.dptr, (char *) uuid_key) ||
!strcmp((char *) key.dptr, (char *) blksize_key)) {
continue;
}
data = tdb_fetch(tdb, key);
if (!data.dptr) {
com_err(prg_name, 0,
_("Failed tdb_fetch %s\n"), tdb_errorstr(tdb));
exit(1);
}
blk_num = *(unsigned long *)key.dptr;
printf(_("Replayed transaction of size %zd at location %llu\n"),
data.dsize, blk_num);
retval = io_channel_write_blk64(channel, blk_num,
-data.dsize, data.dptr);
if (retval == -1) {
com_err(prg_name, retval,
_("Failed write %s\n"),
strerror(errno));
exit(1);
}
}
io_channel_close(channel);
tdb_close(tdb);
return 0;
}
blk64_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name,
io_manager manager)
{
struct ext2_super_block *sb;
io_channel io = NULL;
void *buf = NULL;
int blocksize;
blk64_t superblock, ret_sb = 8193;
if (fs && fs->super) {
ret_sb = (fs->super->s_blocks_per_group +
fs->super->s_first_data_block);
if (ctx) {
ctx->superblock = ret_sb;
ctx->blocksize = fs->blocksize;
}
return ret_sb;
}
if (ctx) {
if (ctx->blocksize) {
ret_sb = ctx->blocksize * 8;
if (ctx->blocksize == 1024)
ret_sb++;
ctx->superblock = ret_sb;
return ret_sb;
}
ctx->superblock = ret_sb;
ctx->blocksize = 1024;
}
if (!name || !manager)
goto cleanup;
if (manager->open(name, 0, &io) != 0)
goto cleanup;
if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf))
goto cleanup;
sb = (struct ext2_super_block *) buf;
for (blocksize = EXT2_MIN_BLOCK_SIZE;
blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) {
superblock = blocksize*8;
if (blocksize == 1024)
superblock++;
io_channel_set_blksize(io, blocksize);
if (io_channel_read_blk64(io, superblock,
-SUPERBLOCK_SIZE, buf))
continue;
#ifdef WORDS_BIGENDIAN
if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
ext2fs_swap_super(sb);
#endif
if ((sb->s_magic == EXT2_SUPER_MAGIC) &&
(EXT2_BLOCK_SIZE(sb) == blocksize)) {
ret_sb = superblock;
if (ctx) {
ctx->superblock = superblock;
ctx->blocksize = blocksize;
}
break;
}
}
cleanup:
if (io)
io_channel_close(io);
if (buf)
ext2fs_free_mem(&buf);
return (ret_sb);
}
/*
* This function resets an e2fsck context; it is called when e2fsck
* needs to be restarted.
*/
errcode_t e2fsck_reset_context(e2fsck_t ctx)
{
int i;
ctx->flags &= E2F_RESET_FLAGS;
ctx->lost_and_found = 0;
ctx->bad_lost_and_found = 0;
if (ctx->inode_used_map) {
ext2fs_free_inode_bitmap(ctx->inode_used_map);
ctx->inode_used_map = 0;
}
if (ctx->inode_dir_map) {
ext2fs_free_inode_bitmap(ctx->inode_dir_map);
ctx->inode_dir_map = 0;
}
if (ctx->inode_reg_map) {
ext2fs_free_inode_bitmap(ctx->inode_reg_map);
ctx->inode_reg_map = 0;
}
if (ctx->block_found_map) {
ext2fs_free_block_bitmap(ctx->block_found_map);
ctx->block_found_map = 0;
}
if (ctx->inode_link_info) {
ext2fs_free_icount(ctx->inode_link_info);
ctx->inode_link_info = 0;
}
if (ctx->journal_io) {
if (ctx->fs && ctx->fs->io != ctx->journal_io)
io_channel_close(ctx->journal_io);
ctx->journal_io = 0;
}
if (ctx->fs && ctx->fs->dblist) {
ext2fs_free_dblist(ctx->fs->dblist);
ctx->fs->dblist = 0;
}
e2fsck_free_dir_info(ctx);
e2fsck_free_dx_dir_info(ctx);
if (ctx->refcount) {
ea_refcount_free(ctx->refcount);
ctx->refcount = 0;
}
if (ctx->refcount_extra) {
ea_refcount_free(ctx->refcount_extra);
ctx->refcount_extra = 0;
}
if (ctx->block_dup_map) {
ext2fs_free_block_bitmap(ctx->block_dup_map);
ctx->block_dup_map = 0;
}
if (ctx->block_ea_map) {
ext2fs_free_block_bitmap(ctx->block_ea_map);
ctx->block_ea_map = 0;
}
if (ctx->block_metadata_map) {
ext2fs_free_block_bitmap(ctx->block_metadata_map);
ctx->block_metadata_map = 0;
}
if (ctx->inode_bb_map) {
ext2fs_free_inode_bitmap(ctx->inode_bb_map);
ctx->inode_bb_map = 0;
}
if (ctx->inode_bad_map) {
ext2fs_free_inode_bitmap(ctx->inode_bad_map);
ctx->inode_bad_map = 0;
}
if (ctx->inode_imagic_map) {
ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
ctx->inode_imagic_map = 0;
}
if (ctx->dirs_to_hash) {
ext2fs_u32_list_free(ctx->dirs_to_hash);
ctx->dirs_to_hash = 0;
}
/*
* Clear the array of invalid meta-data flags
*/
if (ctx->invalid_inode_bitmap_flag) {
ext2fs_free_mem(&ctx->invalid_inode_bitmap_flag);
ctx->invalid_inode_bitmap_flag = 0;
}
if (ctx->invalid_block_bitmap_flag) {
ext2fs_free_mem(&ctx->invalid_block_bitmap_flag);
ctx->invalid_block_bitmap_flag = 0;
}
if (ctx->invalid_inode_table_flag) {
ext2fs_free_mem(&ctx->invalid_inode_table_flag);
ctx->invalid_inode_table_flag = 0;
}
if (ctx->encrypted_dirs) {
ext2fs_u32_list_free(ctx->encrypted_dirs);
ctx->encrypted_dirs = 0;
}
if (ctx->inode_count) {
ext2fs_free_icount(ctx->inode_count);
ctx->inode_count = 0;
}
/* Clear statistic counters */
ctx->fs_directory_count = 0;
ctx->fs_regular_count = 0;
ctx->fs_blockdev_count = 0;
ctx->fs_chardev_count = 0;
ctx->fs_links_count = 0;
ctx->fs_symlinks_count = 0;
ctx->fs_fast_symlinks_count = 0;
ctx->fs_fifo_count = 0;
ctx->fs_total_count = 0;
ctx->fs_badblocks_count = 0;
ctx->fs_sockets_count = 0;
ctx->fs_ind_count = 0;
ctx->fs_dind_count = 0;
ctx->fs_tind_count = 0;
ctx->fs_fragmented = 0;
ctx->fs_fragmented_dir = 0;
ctx->large_files = 0;
for (i=0; i < MAX_EXTENT_DEPTH_COUNT; i++)
ctx->extent_depth_count[i] = 0;
/* Reset the superblock to the user's requested value */
ctx->superblock = ctx->use_superblock;
return 0;
}
int main(int argc, char *argv[])
{
int c, force = 0, dry_run = 0, verbose = 0, dump = 0;
io_channel channel;
errcode_t retval;
int mount_flags, csum_error = 0, io_error = 0;
size_t i, keys_per_block;
char *device_name, *tdb_file;
io_manager manager = unix_io_manager;
struct undo_context undo_ctx;
char *buf;
struct undo_key_block *keyb;
struct undo_key *dkey;
struct undo_key_info *ikey;
__u32 key_crc, blk_crc, hdr_crc;
blk64_t lblk;
ext2_filsys fs;
__u64 offset = 0;
char opt_offset_string[40] = { 0 };
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
set_com_err_gettext(gettext);
#endif
add_error_table(&et_ext2_error_table);
prg_name = argv[0];
while ((c = getopt(argc, argv, "fhno:vz:")) != EOF) {
switch (c) {
case 'f':
force = 1;
break;
case 'h':
dump = 1;
break;
case 'n':
dry_run = 1;
break;
case 'o':
offset = strtoull(optarg, &buf, 0);
if (*buf) {
com_err(prg_name, 0,
_("illegal offset - %s"), optarg);
exit(1);
}
/* used to indicate that an offset was specified */
opt_offset_string[0] = 1;
break;
case 'v':
verbose = 1;
break;
case 'z':
undo_file = optarg;
break;
default:
usage();
}
}
if (argc != optind + 2)
usage();
tdb_file = argv[optind];
device_name = argv[optind+1];
if (undo_file && strcmp(tdb_file, undo_file) == 0) {
printf(_("Will not write to an undo file while replaying it.\n"));
exit(1);
}
/* Interpret the undo file */
retval = manager->open(tdb_file, IO_FLAG_EXCLUSIVE,
&undo_ctx.undo_file);
if (retval) {
com_err(prg_name, errno,
_("while opening undo file `%s'\n"), tdb_file);
exit(1);
}
retval = io_channel_read_blk64(undo_ctx.undo_file, 0,
-(int)sizeof(undo_ctx.hdr),
&undo_ctx.hdr);
if (retval) {
com_err(prg_name, retval, _("while reading undo file"));
exit(1);
}
if (memcmp(undo_ctx.hdr.magic, E2UNDO_MAGIC,
sizeof(undo_ctx.hdr.magic))) {
fprintf(stderr, _("%s: Not an undo file.\n"), tdb_file);
exit(1);
}
if (dump) {
dump_header(&undo_ctx.hdr);
exit(1);
}
hdr_crc = ext2fs_crc32c_le(~0, (unsigned char *)&undo_ctx.hdr,
sizeof(struct undo_header) -
sizeof(__u32));
if (!force && ext2fs_le32_to_cpu(undo_ctx.hdr.header_crc) != hdr_crc) {
fprintf(stderr, _("%s: Header checksum doesn't match.\n"),
tdb_file);
exit(1);
}
undo_ctx.blocksize = ext2fs_le32_to_cpu(undo_ctx.hdr.block_size);
undo_ctx.fs_blocksize = ext2fs_le32_to_cpu(undo_ctx.hdr.fs_block_size);
if (undo_ctx.blocksize == 0 || undo_ctx.fs_blocksize == 0) {
fprintf(stderr, _("%s: Corrupt undo file header.\n"), tdb_file);
exit(1);
}
if (!force && undo_ctx.blocksize > E2UNDO_MAX_BLOCK_SIZE) {
fprintf(stderr, _("%s: Undo block size too large.\n"),
tdb_file);
exit(1);
}
if (!force && undo_ctx.blocksize < E2UNDO_MIN_BLOCK_SIZE) {
fprintf(stderr, _("%s: Undo block size too small.\n"),
tdb_file);
exit(1);
}
undo_ctx.super_block = ext2fs_le64_to_cpu(undo_ctx.hdr.super_offset);
undo_ctx.num_keys = ext2fs_le64_to_cpu(undo_ctx.hdr.num_keys);
io_channel_set_blksize(undo_ctx.undo_file, undo_ctx.blocksize);
/*
* Do not compare undo_ctx.hdr.f_compat with the available compatible
* features set, because a "missing" compatible feature should
* not cause any problems.
*/
if (!force && (undo_ctx.hdr.f_incompat || undo_ctx.hdr.f_rocompat)) {
fprintf(stderr, _("%s: Unknown undo file feature set.\n"),
tdb_file);
exit(1);
}
/* open the fs */
retval = ext2fs_check_if_mounted(device_name, &mount_flags);
if (retval) {
com_err(prg_name, retval, _("Error while determining whether "
"%s is mounted."), device_name);
exit(1);
}
if (mount_flags & EXT2_MF_MOUNTED) {
com_err(prg_name, retval, "%s", _("e2undo should only be run "
"on unmounted filesystems"));
exit(1);
}
if (undo_file) {
retval = e2undo_setup_tdb(device_name, &manager);
if (retval)
exit(1);
}
retval = manager->open(device_name,
IO_FLAG_EXCLUSIVE | (dry_run ? 0 : IO_FLAG_RW),
&channel);
if (retval) {
com_err(prg_name, retval,
_("while opening `%s'"), device_name);
exit(1);
}
if (*opt_offset_string || e2undo_has_feature_fs_offset(&undo_ctx.hdr)) {
if (!*opt_offset_string)
offset = ext2fs_le64_to_cpu(undo_ctx.hdr.fs_offset);
retval = snprintf(opt_offset_string, sizeof(opt_offset_string),
"offset=%llu", offset);
if ((size_t) retval >= sizeof(opt_offset_string)) {
/* should not happen... */
com_err(prg_name, 0, _("specified offset is too large"));
exit(1);
}
io_channel_set_options(channel, opt_offset_string);
}
if (!force && check_filesystem(&undo_ctx, channel))
exit(1);
/* prepare to read keys */
retval = ext2fs_get_mem(sizeof(struct undo_key_info) * undo_ctx.num_keys,
&undo_ctx.keys);
if (retval) {
com_err(prg_name, retval, "%s", _("while allocating memory"));
exit(1);
}
ikey = undo_ctx.keys;
retval = ext2fs_get_mem(undo_ctx.blocksize, &keyb);
if (retval) {
com_err(prg_name, retval, "%s", _("while allocating memory"));
exit(1);
}
retval = ext2fs_get_mem(E2UNDO_MAX_EXTENT_BLOCKS * undo_ctx.blocksize,
&buf);
if (retval) {
com_err(prg_name, retval, "%s", _("while allocating memory"));
exit(1);
}
/* load keys */
keys_per_block = KEYS_PER_BLOCK(&undo_ctx);
lblk = ext2fs_le64_to_cpu(undo_ctx.hdr.key_offset);
dbg_printf("nr_keys=%lu, kpb=%zu, blksz=%u\n",
undo_ctx.num_keys, keys_per_block, undo_ctx.blocksize);
for (i = 0; i < undo_ctx.num_keys; i += keys_per_block) {
size_t j, max_j;
__le32 crc;
retval = io_channel_read_blk64(undo_ctx.undo_file,
lblk, 1, keyb);
if (retval) {
com_err(prg_name, retval, "%s", _("while reading keys"));
if (force) {
io_error = 1;
undo_ctx.num_keys = i - 1;
break;
}
exit(1);
}
/* check keys */
if (!force &&
ext2fs_le32_to_cpu(keyb->magic) != KEYBLOCK_MAGIC) {
fprintf(stderr, _("%s: wrong key magic at %llu\n"),
tdb_file, lblk);
exit(1);
}
crc = keyb->crc;
keyb->crc = 0;
key_crc = ext2fs_crc32c_le(~0, (unsigned char *)keyb,
undo_ctx.blocksize);
if (!force && ext2fs_le32_to_cpu(crc) != key_crc) {
fprintf(stderr,
_("%s: key block checksum error at %llu.\n"),
tdb_file, lblk);
exit(1);
}
/* load keys from key block */
lblk++;
max_j = undo_ctx.num_keys - i;
if (max_j > keys_per_block)
max_j = keys_per_block;
for (j = 0, dkey = keyb->keys;
j < max_j;
j++, ikey++, dkey++) {
ikey->fsblk = ext2fs_le64_to_cpu(dkey->fsblk);
ikey->fileblk = lblk;
ikey->blk_crc = ext2fs_le32_to_cpu(dkey->blk_crc);
ikey->size = ext2fs_le32_to_cpu(dkey->size);
lblk += (ikey->size + undo_ctx.blocksize - 1) /
undo_ctx.blocksize;
if (E2UNDO_MAX_EXTENT_BLOCKS * undo_ctx.blocksize <
ikey->size) {
com_err(prg_name, retval,
_("%s: block %llu is too long."),
tdb_file, ikey->fsblk);
exit(1);
}
/* check each block's crc */
retval = io_channel_read_blk64(undo_ctx.undo_file,
ikey->fileblk,
-(int)ikey->size,
buf);
if (retval) {
com_err(prg_name, retval,
_("while fetching block %llu."),
ikey->fileblk);
if (!force)
exit(1);
io_error = 1;
continue;
}
blk_crc = ext2fs_crc32c_le(~0, (unsigned char *)buf,
ikey->size);
if (blk_crc != ikey->blk_crc) {
fprintf(stderr,
_("checksum error in filesystem block "
"%llu (undo blk %llu)\n"),
ikey->fsblk, ikey->fileblk);
if (!force)
exit(1);
csum_error = 1;
}
}
}
ext2fs_free_mem(&keyb);
/* sort keys in fs block order */
qsort(undo_ctx.keys, undo_ctx.num_keys, sizeof(struct undo_key_info),
key_compare);
/* replay */
io_channel_set_blksize(channel, undo_ctx.fs_blocksize);
for (i = 0, ikey = undo_ctx.keys; i < undo_ctx.num_keys; i++, ikey++) {
retval = io_channel_read_blk64(undo_ctx.undo_file,
ikey->fileblk,
-(int)ikey->size,
buf);
if (retval) {
com_err(prg_name, retval,
_("while fetching block %llu."),
ikey->fileblk);
io_error = 1;
continue;
}
if (verbose)
printf("Replayed block of size %u from %llu to %llu\n",
ikey->size, ikey->fileblk, ikey->fsblk);
if (dry_run)
continue;
retval = io_channel_write_blk64(channel, ikey->fsblk,
-(int)ikey->size, buf);
if (retval) {
com_err(prg_name, retval,
_("while writing block %llu."), ikey->fsblk);
io_error = 1;
}
}
if (csum_error)
fprintf(stderr, _("Undo file corruption; run e2fsck NOW!\n"));
if (io_error)
fprintf(stderr, _("IO error during replay; run e2fsck NOW!\n"));
if (!(ext2fs_le32_to_cpu(undo_ctx.hdr.state) & E2UNDO_STATE_FINISHED)) {
force = 1;
fprintf(stderr, _("Incomplete undo record; run e2fsck.\n"));
}
ext2fs_free_mem(&buf);
ext2fs_free_mem(&undo_ctx.keys);
io_channel_close(channel);
/* If there were problems, try to force a fsck */
if (!dry_run && (force || csum_error || io_error)) {
retval = ext2fs_open2(device_name, NULL,
EXT2_FLAG_RW | EXT2_FLAG_64BITS, 0, 0,
manager, &fs);
if (retval)
goto out;
fs->super->s_state &= ~EXT2_VALID_FS;
if (csum_error || io_error)
fs->super->s_state |= EXT2_ERROR_FS;
ext2fs_mark_super_dirty(fs);
ext2fs_close_free(&fs);
}
out:
io_channel_close(undo_ctx.undo_file);
return csum_error;
}
