static int jbd2_block_tag_csum_verify(journal_t *j, journal_block_tag_t *tag,
void *buf, __u32 sequence)
{
__u32 provided, calculated;
if (!JFS_HAS_INCOMPAT_FEATURE(j, JFS_FEATURE_INCOMPAT_CSUM_V2))
return 1;
sequence = ext2fs_cpu_to_be32(sequence);
calculated = ext2fs_crc32c_le(~0, j->j_superblock->s_uuid,
sizeof(j->j_superblock->s_uuid));
calculated = ext2fs_crc32c_le(calculated, (__u8 *)&sequence,
sizeof(sequence));
calculated = ext2fs_crc32c_le(calculated, buf, j->j_blocksize) & 0xffff;
provided = ext2fs_be16_to_cpu(tag->t_checksum);
return provided == ext2fs_cpu_to_be32(calculated);
}
static int jbd2_commit_block_csum_verify(journal_t *j, void *buf)
{
struct commit_header *h;
__u32 provided, calculated;
if (!JFS_HAS_INCOMPAT_FEATURE(j, JFS_FEATURE_INCOMPAT_CSUM_V2))
return 1;
h = buf;
provided = h->h_chksum[0];
h->h_chksum[0] = 0;
calculated = ext2fs_crc32c_le(~0, j->j_superblock->s_uuid,
sizeof(j->j_superblock->s_uuid));
calculated = ext2fs_crc32c_le(calculated, buf, j->j_blocksize);
h->h_chksum[0] = provided;
provided = ext2fs_be32_to_cpu(provided);
return provided == calculated;
}
static int jbd2_revoke_block_csum_verify(journal_t *j,
void *buf)
{
struct journal_revoke_tail *tail;
__u32 provided, calculated;
if (!JFS_HAS_INCOMPAT_FEATURE(j, JFS_FEATURE_INCOMPAT_CSUM_V2))
return 1;
tail = (struct journal_revoke_tail *)(buf + j->j_blocksize -
sizeof(struct journal_revoke_tail));
provided = tail->r_checksum;
tail->r_checksum = 0;
calculated = ext2fs_crc32c_le(~0, j->j_superblock->s_uuid,
sizeof(j->j_superblock->s_uuid));
calculated = ext2fs_crc32c_le(calculated, buf, j->j_blocksize);
tail->r_checksum = provided;
provided = ext2fs_be32_to_cpu(provided);
return provided == calculated;
}
static __u32 e2fsck_journal_sb_csum(journal_superblock_t *jsb)
{
__u32 crc, old_crc;
old_crc = jsb->s_checksum;
jsb->s_checksum = 0;
crc = ext2fs_crc32c_le(~0, (unsigned char *)jsb,
sizeof(journal_superblock_t));
jsb->s_checksum = old_crc;
return crc;
}
static int check_filesystem(struct undo_context *ctx, io_channel channel)
{
struct ext2_super_block super, *sb;
char *buf;
__u32 sb_crc;
errcode_t retval;
io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);
retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);
if (retval) {
com_err(prg_name, retval,
"%s", _("while reading filesystem superblock."));
return retval;
}
/*
* Compare the FS and the undo file superblock so that we can't apply
* e2undo "patches" out of order.
*/
retval = ext2fs_get_mem(ctx->blocksize, &buf);
if (retval) {
com_err(prg_name, retval, "%s", _("while allocating memory"));
return retval;
}
retval = io_channel_read_blk64(ctx->undo_file, ctx->super_block,
-SUPERBLOCK_SIZE, buf);
if (retval) {
com_err(prg_name, retval, "%s", _("while fetching superblock"));
goto out;
}
sb = (struct ext2_super_block *)buf;
sb->s_magic = ~sb->s_magic;
if (memcmp(&super, buf, sizeof(super))) {
print_undo_mismatch(&super, (struct ext2_super_block *)buf);
retval = -1;
goto out;
}
sb_crc = ext2fs_crc32c_le(~0, (unsigned char *)buf, SUPERBLOCK_SIZE);
if (ext2fs_le32_to_cpu(ctx->hdr.sb_crc) != sb_crc) {
fprintf(stderr,
_("Undo file superblock checksum doesn't match.\n"));
retval = -1;
goto out;
}
out:
ext2fs_free_mem(&buf);
return retval;
}
static errcode_t undo_write_tdb(io_channel channel,
unsigned long long block, int count)
{
int size, sz;
unsigned long long block_num, backing_blk_num;
errcode_t retval = 0;
ext2_loff_t offset;
struct undo_private_data *data;
unsigned char *read_ptr;
unsigned long long end_block;
unsigned long long data_size;
void *data_ptr;
struct undo_key *key;
__u32 blk_crc;
data = (struct undo_private_data *) channel->private_data;
if (data->undo_file == NULL) {
/*
* Transaction database not initialized
*/
return 0;
}
if (count == 1)
size = channel->block_size;
else {
if (count < 0)
size = -count;
else
size = count * channel->block_size;
}
retval = undo_setup_tdb(data);
if (retval)
return retval;
/*
* Data is stored in tdb database as blocks of tdb_data_size size
* This helps in efficient lookup further.
*
* We divide the disk to blocks of tdb_data_size.
*/
offset = (block * channel->block_size) + data->offset ;
block_num = offset / data->tdb_data_size;
end_block = (offset + size - 1) / data->tdb_data_size;
while (block_num <= end_block) {
__u32 keysz;
/*
* Check if we have the record already
*/
if (ext2fs_test_block_bitmap2(data->written_block_map,
block_num)) {
/* Try the next block */
block_num++;
continue;
}
ext2fs_mark_block_bitmap2(data->written_block_map, block_num);
/*
* Read one block using the backing I/O manager
* The backing I/O manager block size may be
* different from the tdb_data_size.
* Also we need to recalcuate the block number with respect
* to the backing I/O manager.
*/
offset = block_num * data->tdb_data_size;
backing_blk_num = (offset - data->offset) / channel->block_size;
count = data->tdb_data_size +
((offset - data->offset) % channel->block_size);
retval = ext2fs_get_mem(count, &read_ptr);
if (retval) {
return retval;
}
memset(read_ptr, 0, count);
actual_size = 0;
if ((count % channel->block_size) == 0)
sz = count / channel->block_size;
else
sz = -count;
retval = io_channel_read_blk64(data->real, backing_blk_num,
sz, read_ptr);
if (retval) {
if (retval != EXT2_ET_SHORT_READ) {
free(read_ptr);
return retval;
}
/*
* short read so update the record size
* accordingly
*/
data_size = actual_size;
} else {
data_size = data->tdb_data_size;
}
if (data_size == 0) {
free(read_ptr);
block_num++;
continue;
}
dbg_printf("Read %llu bytes from FS block %llu (blk=%llu cnt=%u)\n",
data_size, backing_blk_num, block, count);
if ((data_size % data->undo_file->block_size) == 0)
sz = data_size / data->undo_file->block_size;
else
sz = -actual_size;
data_ptr = read_ptr + ((offset - data->offset) %
data->undo_file->block_size);
/* extend this key? */
if (data->keys_in_block) {
key = data->keyb->keys + data->keys_in_block - 1;
keysz = ext2fs_le32_to_cpu(key->size);
} else {
key = NULL;
keysz = 0;
}
if (key != NULL &&
ext2fs_le64_to_cpu(key->fsblk) +
((keysz + data->tdb_data_size - 1) /
data->tdb_data_size) == backing_blk_num &&
E2UNDO_MAX_EXTENT_BLOCKS * data->tdb_data_size >
keysz + sz) {
blk_crc = ext2fs_le32_to_cpu(key->blk_crc);
blk_crc = ext2fs_crc32c_le(blk_crc,
(unsigned char *)data_ptr,
data_size);
key->blk_crc = ext2fs_cpu_to_le32(blk_crc);
key->size = ext2fs_cpu_to_le32(keysz + data_size);
} else {
data->num_keys++;
key = data->keyb->keys + data->keys_in_block;
data->keys_in_block++;
key->fsblk = ext2fs_cpu_to_le64(backing_blk_num);
blk_crc = ext2fs_crc32c_le(~0,
(unsigned char *)data_ptr,
data_size);
key->blk_crc = ext2fs_cpu_to_le32(blk_crc);
key->size = ext2fs_cpu_to_le32(data_size);
}
dbg_printf("Writing block %llu to offset %llu size %d key %zu\n",
block_num,
data->undo_blk_num,
sz, data->num_keys - 1);
retval = io_channel_write_blk64(data->undo_file,
data->undo_blk_num, sz, data_ptr);
if (retval) {
free(read_ptr);
return retval;
}
data->undo_blk_num++;
free(read_ptr);
/* Write out the key block */
retval = write_undo_indexes(data, 0);
if (retval)
return retval;
/* Next block */
block_num++;
}
return retval;
}
static errcode_t write_undo_indexes(struct undo_private_data *data, int flush)
{
errcode_t retval;
struct ext2_super_block super;
io_channel channel;
int block_size;
__u32 sb_crc, hdr_crc;
/* Spit out a key block, if there's any data */
if (data->keys_in_block) {
data->keyb->magic = ext2fs_cpu_to_le32(KEYBLOCK_MAGIC);
data->keyb->crc = 0;
data->keyb->crc = ext2fs_cpu_to_le32(
ext2fs_crc32c_le(~0,
(unsigned char *)data->keyb,
data->tdb_data_size));
dbg_printf("Writing keyblock to blk %llu\n", data->key_blk_num);
retval = io_channel_write_blk64(data->undo_file,
data->key_blk_num,
1, data->keyb);
if (retval)
return retval;
/* Move on to the next key block if it's full. */
if (data->keys_in_block == KEYS_PER_BLOCK(data)) {
memset(data->keyb, 0, data->tdb_data_size);
data->keys_in_block = 0;
data->key_blk_num = data->undo_blk_num;
data->undo_blk_num++;
}
}
/* Prepare superblock for write */
channel = data->real;
block_size = channel->block_size;
io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);
retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);
if (retval)
goto err_out;
sb_crc = ext2fs_crc32c_le(~0, (unsigned char *)&super, SUPERBLOCK_SIZE);
super.s_magic = ~super.s_magic;
/* Write the undo header to disk. */
memcpy(data->hdr.magic, E2UNDO_MAGIC, sizeof(data->hdr.magic));
data->hdr.num_keys = ext2fs_cpu_to_le64(data->num_keys);
data->hdr.super_offset = ext2fs_cpu_to_le64(data->super_blk_num);
data->hdr.key_offset = ext2fs_cpu_to_le64(data->first_key_blk);
data->hdr.fs_block_size = ext2fs_cpu_to_le32(block_size);
data->hdr.sb_crc = ext2fs_cpu_to_le32(sb_crc);
hdr_crc = ext2fs_crc32c_le(~0, (unsigned char *)&data->hdr,
sizeof(data->hdr) -
sizeof(data->hdr.header_crc));
data->hdr.header_crc = ext2fs_cpu_to_le32(hdr_crc);
retval = io_channel_write_blk64(data->undo_file, 0,
-(int)sizeof(data->hdr),
&data->hdr);
if (retval)
goto err_out;
/*
* Record the entire superblock (in FS byte order) so that we can't
* apply e2undo files to the wrong FS or out of order.
*/
dbg_printf("Writing superblock to block %llu\n", data->super_blk_num);
retval = io_channel_write_blk64(data->undo_file, data->super_blk_num,
-SUPERBLOCK_SIZE, &super);
if (retval)
goto err_out;
if (flush)
retval = io_channel_flush(data->undo_file);
err_out:
io_channel_set_blksize(channel, block_size);
return retval;
}
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;
}
