From 464df1d5e5ab1322e2dd0a7796939fff1aeefa9a Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 17:49:25 +0200 Subject: Adding upstream version 1.47.0. Signed-off-by: Daniel Baumann --- lib/ext2fs/undo_io.c | 1108 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1108 insertions(+) create mode 100644 lib/ext2fs/undo_io.c (limited to 'lib/ext2fs/undo_io.c') diff --git a/lib/ext2fs/undo_io.c b/lib/ext2fs/undo_io.c new file mode 100644 index 0000000..f4a6d52 --- /dev/null +++ b/lib/ext2fs/undo_io.c @@ -0,0 +1,1108 @@ +/* + * undo_io.c --- This is the undo io manager that copies the old data that + * copies the old data being overwritten into a tdb database + * + * Copyright IBM Corporation, 2007 + * Author Aneesh Kumar K.V + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Library + * General Public License, version 2. + * %End-Header% + */ + +#ifndef _LARGEFILE_SOURCE +#define _LARGEFILE_SOURCE +#endif +#ifndef _LARGEFILE64_SOURCE +#define _LARGEFILE64_SOURCE +#endif + +#include "config.h" +#include +#include +#if HAVE_UNISTD_H +#include +#endif +#if HAVE_ERRNO_H +#include +#endif +#include +#include +#ifdef __linux__ +#include +#endif +#if HAVE_SYS_STAT_H +#include +#endif +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_SYS_RESOURCE_H +#include +#endif +#include + +#include "ext2_fs.h" +#include "ext2fs.h" +#include "ext2fsP.h" + +#ifdef __GNUC__ +#define ATTR(x) __attribute__(x) +#else +#define ATTR(x) +#endif + +#undef DEBUG + +#ifdef DEBUG +# define dbg_printf(f, a...) do {printf(f, ## a); fflush(stdout); } while (0) +#else +# define dbg_printf(f, a...) +#endif + +/* + * For checking structure magic numbers... + */ + +#define EXT2_CHECK_MAGIC(struct, code) \ + if ((struct)->magic != (code)) return (code) +/* + * Undo file format: The file is cut up into undo_header.block_size blocks. + * The first block contains the header. + * The second block contains the superblock. + * There is then a repeating series of blocks as follows: + * A key block, which contains undo_keys to map the following data blocks. + * Data blocks + * (Note that there are pointers to the first key block and the sb, so this + * order isn't strictly necessary.) + */ +#define E2UNDO_MAGIC "E2UNDO02" +#define KEYBLOCK_MAGIC 0xCADECADE + +#define E2UNDO_STATE_FINISHED 0x1 /* undo file is complete */ + +#define E2UNDO_MIN_BLOCK_SIZE 1024 /* undo blocks are no less than 1KB */ +#define E2UNDO_MAX_BLOCK_SIZE 1048576 /* undo blocks are no more than 1MB */ + +struct undo_header { + char magic[8]; /* "E2UNDO02" */ + __le64 num_keys; /* how many keys? */ + __le64 super_offset; /* where in the file is the superblock copy? */ + __le64 key_offset; /* where do the key/data block chunks start? */ + __le32 block_size; /* block size of the undo file */ + __le32 fs_block_size; /* block size of the target device */ + __le32 sb_crc; /* crc32c of the superblock */ + __le32 state; /* e2undo state flags */ + __le32 f_compat; /* compatible features */ + __le32 f_incompat; /* incompatible features (none so far) */ + __le32 f_rocompat; /* ro compatible features (none so far) */ + __le32 pad32; /* padding for fs_offset */ + __le64 fs_offset; /* filesystem offset */ + __u8 padding[436]; /* padding */ + __le32 header_crc; /* crc32c of this header (but not this field) */ +}; + +#define E2UNDO_MAX_EXTENT_BLOCKS 512 /* max extent size, in blocks */ + +struct undo_key { + __le64 fsblk; /* where in the fs does the block go */ + __le32 blk_crc; /* crc32c of the block */ + __le32 size; /* how many bytes in this block? */ +}; + +struct undo_key_block { + __le32 magic; /* KEYBLOCK_MAGIC number */ + __le32 crc; /* block checksum */ + __le64 reserved; /* zero */ + +#if __STDC_VERSION__ >= 199901L + struct undo_key keys[]; /* keys, which come immediately after */ +#else + struct undo_key keys[0]; /* keys, which come immediately after */ +#endif +}; + +struct undo_private_data { + int magic; + + /* the undo file io channel */ + io_channel undo_file; + blk64_t undo_blk_num; /* next free block */ + blk64_t key_blk_num; /* current key block location */ + blk64_t super_blk_num; /* superblock location */ + blk64_t first_key_blk; /* first key block location */ + struct undo_key_block *keyb; + size_t num_keys, keys_in_block; + + /* The backing io channel */ + io_channel real; + + unsigned long long tdb_data_size; + int tdb_written; + + /* to support offset in unix I/O manager */ + ext2_loff_t offset; + + ext2fs_block_bitmap written_block_map; + struct struct_ext2_filsys fake_fs; + char *tdb_file; + struct undo_header hdr; +}; +#define KEYS_PER_BLOCK(d) (((d)->tdb_data_size / sizeof(struct undo_key)) - 1) + +#define E2UNDO_FEATURE_COMPAT_FS_OFFSET 0x1 /* the filesystem offset */ + +static inline void e2undo_set_feature_fs_offset(struct undo_header *header) { + header->f_compat |= ext2fs_le32_to_cpu(E2UNDO_FEATURE_COMPAT_FS_OFFSET); +} + +static inline void e2undo_clear_feature_fs_offset(struct undo_header *header) { + header->f_compat &= ~ext2fs_le32_to_cpu(E2UNDO_FEATURE_COMPAT_FS_OFFSET); +} + +static io_manager undo_io_backing_manager; +static char *tdb_file; +static int actual_size; + +errcode_t set_undo_io_backing_manager(io_manager manager) +{ + /* + * We may want to do some validation later + */ + undo_io_backing_manager = manager; + return 0; +} + +errcode_t set_undo_io_backup_file(char *file_name) +{ + tdb_file = strdup(file_name); + + if (tdb_file == NULL) { + return EXT2_ET_NO_MEMORY; + } + + return 0; +} + +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); + data->hdr.fs_offset = ext2fs_cpu_to_le64(data->offset); + if (data->offset) + e2undo_set_feature_fs_offset(&data->hdr); + else + e2undo_clear_feature_fs_offset(&data->hdr); + 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; +} + +static errcode_t undo_setup_tdb(struct undo_private_data *data) +{ + int i; + errcode_t retval; + + if (data->tdb_written == 1) + return 0; + + data->tdb_written = 1; + + /* Make a bitmap to track what we've written */ + memset(&data->fake_fs, 0, sizeof(data->fake_fs)); + data->fake_fs.blocksize = data->tdb_data_size; + retval = ext2fs_alloc_generic_bmap(&data->fake_fs, + EXT2_ET_MAGIC_BLOCK_BITMAP64, + EXT2FS_BMAP64_RBTREE, + 0, ~1ULL, ~1ULL, + "undo block map", &data->written_block_map); + if (retval) + return retval; + + /* Allocate key block */ + retval = ext2fs_get_mem(data->tdb_data_size, &data->keyb); + if (retval) + return retval; + data->key_blk_num = data->first_key_blk; + + /* Record block size */ + dbg_printf("Undo block size %llu\n", data->tdb_data_size); + dbg_printf("Keys per block %llu\n", KEYS_PER_BLOCK(data)); + data->hdr.block_size = ext2fs_cpu_to_le32(data->tdb_data_size); + io_channel_set_blksize(data->undo_file, data->tdb_data_size); + + /* Ensure that we have space for header blocks */ + for (i = 0; i <= 2; i++) { + retval = io_channel_read_blk64(data->undo_file, i, 1, + data->keyb); + if (retval) + memset(data->keyb, 0, data->tdb_data_size); + retval = io_channel_write_blk64(data->undo_file, i, 1, + data->keyb); + if (retval) + return retval; + retval = io_channel_flush(data->undo_file); + if (retval) + return retval; + } + memset(data->keyb, 0, data->tdb_data_size); + return 0; +} + +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; + 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 recalculate the block number with respect + * to the backing I/O manager. + */ + offset = block_num * data->tdb_data_size + + (data->offset % data->tdb_data_size); + backing_blk_num = (offset - data->offset) / channel->block_size; + + retval = ext2fs_get_mem(data->tdb_data_size, &read_ptr); + if (retval) { + return retval; + } + + memset(read_ptr, 0, data->tdb_data_size); + actual_size = 0; + if ((data->tdb_data_size % channel->block_size) == 0) + sz = data->tdb_data_size / channel->block_size; + else + sz = -data->tdb_data_size; + 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=%llu)\n", + data_size, backing_blk_num, block, data->tdb_data_size); + if ((data_size % data->undo_file->block_size) == 0) + sz = data_size / data->undo_file->block_size; + else + sz = -data_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) * channel->block_size + + channel->block_size - 1 + + keysz) / channel->block_size == backing_blk_num && + E2UNDO_MAX_EXTENT_BLOCKS * data->tdb_data_size > + keysz + data_size) { + blk_crc = ext2fs_le32_to_cpu(key->blk_crc); + blk_crc = ext2fs_crc32c_le(blk_crc, read_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, read_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, read_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 undo_io_read_error(io_channel channel ATTR((unused)), + unsigned long block ATTR((unused)), + int count ATTR((unused)), + void *data ATTR((unused)), + size_t size ATTR((unused)), + int actual, + errcode_t error ATTR((unused))) +{ + actual_size = actual; + return error; +} + +static void undo_err_handler_init(io_channel channel) +{ + channel->read_error = undo_io_read_error; +} + +static int check_filesystem(struct undo_header *hdr, io_channel undo_file, + unsigned int blocksize, blk64_t super_block, + 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) + return retval; + + /* + * Compare the FS and the undo file superblock so that we don't + * append to something that doesn't match this FS. + */ + retval = ext2fs_get_mem(blocksize, &buf); + if (retval) + return retval; + retval = io_channel_read_blk64(undo_file, super_block, + -SUPERBLOCK_SIZE, buf); + if (retval) + goto out; + sb = (struct ext2_super_block *)buf; + sb->s_magic = ~sb->s_magic; + if (memcmp(&super, buf, sizeof(super))) { + retval = -1; + goto out; + } + sb_crc = ext2fs_crc32c_le(~0, (unsigned char *)buf, SUPERBLOCK_SIZE); + if (ext2fs_le32_to_cpu(hdr->sb_crc) != sb_crc) { + retval = -1; + goto out; + } + +out: + ext2fs_free_mem(&buf); + return retval; +} + +/* + * Try to re-open the undo file, so that we can resume where we left off. + * That way, the user can pass the same undo file to various programs as + * part of an FS upgrade instead of having to create multiple files and + * then apply them in correct order. + */ +static errcode_t try_reopen_undo_file(int undo_fd, + struct undo_private_data *data) +{ + struct undo_header hdr; + struct undo_key *dkey; + ext2fs_struct_stat statbuf; + unsigned int blocksize, fs_blocksize; + blk64_t super_block, lblk; + size_t num_keys, keys_per_block, i; + __u32 hdr_crc, key_crc; + errcode_t retval; + + /* Zero size already? */ + retval = ext2fs_fstat(undo_fd, &statbuf); + if (retval) + goto bad_file; + if (statbuf.st_size == 0) + goto out; + + /* check the file header */ + retval = io_channel_read_blk64(data->undo_file, 0, -(int)sizeof(hdr), + &hdr); + if (retval) + goto bad_file; + + if (memcmp(hdr.magic, E2UNDO_MAGIC, + sizeof(hdr.magic))) + goto bad_file; + hdr_crc = ext2fs_crc32c_le(~0, (unsigned char *)&hdr, + sizeof(struct undo_header) - + sizeof(__u32)); + if (ext2fs_le32_to_cpu(hdr.header_crc) != hdr_crc) + goto bad_file; + blocksize = ext2fs_le32_to_cpu(hdr.block_size); + fs_blocksize = ext2fs_le32_to_cpu(hdr.fs_block_size); + if (blocksize > E2UNDO_MAX_BLOCK_SIZE || + blocksize < E2UNDO_MIN_BLOCK_SIZE || + !blocksize || !fs_blocksize) + goto bad_file; + super_block = ext2fs_le64_to_cpu(hdr.super_offset); + num_keys = ext2fs_le64_to_cpu(hdr.num_keys); + io_channel_set_blksize(data->undo_file, blocksize); + /* + * Do not compare hdr.f_compat with the available compatible + * features set, because a "missing" compatible feature should + * not cause any problems. + */ + if (hdr.f_incompat || hdr.f_rocompat) + goto bad_file; + + /* Superblock matches this FS? */ + if (check_filesystem(&hdr, data->undo_file, blocksize, super_block, + data->real) != 0) { + retval = EXT2_ET_UNDO_FILE_WRONG; + goto out; + } + + /* Try to set ourselves up */ + data->tdb_data_size = blocksize; + retval = undo_setup_tdb(data); + if (retval) + goto bad_file; + data->num_keys = num_keys; + data->super_blk_num = super_block; + data->first_key_blk = ext2fs_le64_to_cpu(hdr.key_offset); + + /* load the written block map */ + keys_per_block = KEYS_PER_BLOCK(data); + lblk = data->first_key_blk; + dbg_printf("nr_keys=%lu, kpb=%zu, blksz=%u\n", + num_keys, keys_per_block, blocksize); + for (i = 0; i < num_keys; i += keys_per_block) { + size_t j, max_j; + __le32 crc; + + data->key_blk_num = lblk; + retval = io_channel_read_blk64(data->undo_file, + lblk, 1, data->keyb); + if (retval) + goto bad_key_replay; + + /* check keys */ + if (ext2fs_le32_to_cpu(data->keyb->magic) != KEYBLOCK_MAGIC) { + retval = EXT2_ET_UNDO_FILE_CORRUPT; + goto bad_key_replay; + } + crc = data->keyb->crc; + data->keyb->crc = 0; + key_crc = ext2fs_crc32c_le(~0, (unsigned char *)data->keyb, + blocksize); + if (ext2fs_le32_to_cpu(crc) != key_crc) { + retval = EXT2_ET_UNDO_FILE_CORRUPT; + goto bad_key_replay; + } + + /* load keys from key block */ + lblk++; + max_j = data->num_keys - i; + if (max_j > keys_per_block) + max_j = keys_per_block; + for (j = 0, dkey = data->keyb->keys; + j < max_j; + j++, dkey++) { + blk64_t fsblk = ext2fs_le64_to_cpu(dkey->fsblk); + blk64_t undo_blk = fsblk * fs_blocksize / blocksize; + size_t size = ext2fs_le32_to_cpu(dkey->size); + + ext2fs_mark_block_bitmap_range2(data->written_block_map, + undo_blk, + (size + blocksize - 1) / blocksize); + lblk += (size + blocksize - 1) / blocksize; + data->undo_blk_num = lblk; + data->keys_in_block = j + 1; + } + } + dbg_printf("Reopen undo, keyblk=%llu undoblk=%llu nrkeys=%zu kib=%zu\n", + data->key_blk_num, data->undo_blk_num, data->num_keys, + data->keys_in_block); + + data->hdr.state = hdr.state & ~E2UNDO_STATE_FINISHED; + data->hdr.f_compat = hdr.f_compat; + data->hdr.f_incompat = hdr.f_incompat; + data->hdr.f_rocompat = hdr.f_rocompat; + return retval; + +bad_key_replay: + data->key_blk_num = data->undo_blk_num = 0; + data->keys_in_block = 0; + ext2fs_free_mem(&data->keyb); + ext2fs_free_generic_bitmap(data->written_block_map); + data->tdb_written = 0; + goto out; +bad_file: + retval = EXT2_ET_UNDO_FILE_CORRUPT; +out: + return retval; +} + +static void undo_atexit(void *p) +{ + struct undo_private_data *data = p; + errcode_t err; + + err = write_undo_indexes(data, 1); + io_channel_close(data->undo_file); + + com_err(data->tdb_file, err, "while force-closing undo file"); +} + +static errcode_t undo_open(const char *name, int flags, io_channel *channel) +{ + io_channel io = NULL; + struct undo_private_data *data = NULL; + int undo_fd = -1; + errcode_t retval; + + /* We don't support multi-threading, at least for now */ + flags &= ~IO_FLAG_THREADS; + if (name == 0) + return EXT2_ET_BAD_DEVICE_NAME; + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); + if (retval) + goto cleanup; + memset(io, 0, sizeof(struct struct_io_channel)); + io->magic = EXT2_ET_MAGIC_IO_CHANNEL; + retval = ext2fs_get_mem(sizeof(struct undo_private_data), &data); + if (retval) + goto cleanup; + + io->manager = undo_io_manager; + retval = ext2fs_get_mem(strlen(name)+1, &io->name); + if (retval) + goto cleanup; + + strcpy(io->name, name); + io->private_data = data; + io->block_size = 1024; + io->read_error = 0; + io->write_error = 0; + io->refcount = 1; + + memset(data, 0, sizeof(struct undo_private_data)); + data->magic = EXT2_ET_MAGIC_UNIX_IO_CHANNEL; + data->super_blk_num = 1; + data->first_key_blk = 2; + data->undo_blk_num = 3; + + if (undo_io_backing_manager) { + retval = undo_io_backing_manager->open(name, flags, + &data->real); + if (retval) + goto cleanup; + + data->tdb_file = strdup(tdb_file); + if (data->tdb_file == NULL) + goto cleanup; + undo_fd = ext2fs_open_file(data->tdb_file, O_RDWR | O_CREAT, + 0600); + if (undo_fd < 0) + goto cleanup; + + retval = undo_io_backing_manager->open(data->tdb_file, + IO_FLAG_RW, + &data->undo_file); + if (retval) + goto cleanup; + } else { + data->real = NULL; + data->undo_file = NULL; + } + + if (data->real) + io->flags = (io->flags & ~CHANNEL_FLAGS_DISCARD_ZEROES) | + (data->real->flags & CHANNEL_FLAGS_DISCARD_ZEROES); + + /* + * setup err handler for read so that we know + * when the backing manager fails do short read + */ + if (data->real) + undo_err_handler_init(data->real); + + if (data->undo_file) { + retval = try_reopen_undo_file(undo_fd, data); + if (retval) + goto cleanup; + } + retval = ext2fs_add_exit_fn(undo_atexit, data); + if (retval) + goto cleanup; + + *channel = io; + if (undo_fd >= 0) + close(undo_fd); + return retval; + +cleanup: + ext2fs_remove_exit_fn(undo_atexit, data); + if (undo_fd >= 0) + close(undo_fd); + if (data && data->undo_file) + io_channel_close(data->undo_file); + if (data && data->tdb_file) + free(data->tdb_file); + if (data && data->real) + io_channel_close(data->real); + if (data) + ext2fs_free_mem(&data); + if (io && io->name) + ext2fs_free_mem(&io->name); + if (io) + ext2fs_free_mem(&io); + return retval; +} + +static errcode_t undo_close(io_channel channel) +{ + struct undo_private_data *data; + errcode_t err, retval = 0; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (--channel->refcount > 0) + return 0; + /* Before closing write the file system identity */ + if (!getenv("UNDO_IO_SIMULATE_UNFINISHED")) + data->hdr.state = ext2fs_cpu_to_le32(E2UNDO_STATE_FINISHED); + err = write_undo_indexes(data, 1); + ext2fs_remove_exit_fn(undo_atexit, data); + if (data->real) + retval = io_channel_close(data->real); + if (data->tdb_file) + free(data->tdb_file); + if (data->undo_file) + io_channel_close(data->undo_file); + ext2fs_free_mem(&data->keyb); + if (data->written_block_map) + ext2fs_free_generic_bitmap(data->written_block_map); + ext2fs_free_mem(&channel->private_data); + if (channel->name) + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); + + if (err) + return err; + return retval; +} + +static errcode_t undo_set_blksize(io_channel channel, int blksize) +{ + struct undo_private_data *data; + errcode_t retval = 0; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (blksize > E2UNDO_MAX_BLOCK_SIZE || blksize < E2UNDO_MIN_BLOCK_SIZE) + return EXT2_ET_INVALID_ARGUMENT; + + if (data->real) + retval = io_channel_set_blksize(data->real, blksize); + /* + * Set the block size used for tdb + */ + if (!data->tdb_data_size || !data->tdb_written) + data->tdb_data_size = blksize; + channel->block_size = blksize; + return retval; +} + +static errcode_t undo_read_blk64(io_channel channel, unsigned long long block, + int count, void *buf) +{ + errcode_t retval = 0; + struct undo_private_data *data; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (data->real) + retval = io_channel_read_blk64(data->real, block, count, buf); + + return retval; +} + +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *buf) +{ + return undo_read_blk64(channel, block, count, buf); +} + +static errcode_t undo_write_blk64(io_channel channel, unsigned long long block, + int count, const void *buf) +{ + struct undo_private_data *data; + errcode_t retval = 0; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + /* + * First write the existing content into database + */ + retval = undo_write_tdb(channel, block, count); + if (retval) + return retval; + if (data->real) + retval = io_channel_write_blk64(data->real, block, count, buf); + + return retval; +} + +static errcode_t undo_write_blk(io_channel channel, unsigned long block, + int count, const void *buf) +{ + return undo_write_blk64(channel, block, count, buf); +} + +static errcode_t undo_write_byte(io_channel channel, unsigned long offset, + int size, const void *buf) +{ + struct undo_private_data *data; + errcode_t retval = 0; + ext2_loff_t location; + unsigned long blk_num, count;; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + location = offset + data->offset; + blk_num = location/channel->block_size; + /* + * the size specified may spread across multiple blocks + * also make sure we account for the fact that block start + * offset for tdb is different from the backing I/O manager + * due to possible different block size + */ + count = (size + (location % channel->block_size) + + channel->block_size -1)/channel->block_size; + retval = undo_write_tdb(channel, blk_num, count); + if (retval) + return retval; + if (data->real && data->real->manager->write_byte) + retval = io_channel_write_byte(data->real, offset, size, buf); + + return retval; +} + +static errcode_t undo_discard(io_channel channel, unsigned long long block, + unsigned long long count) +{ + struct undo_private_data *data; + errcode_t retval = 0; + int icount; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (count > INT_MAX) + return EXT2_ET_UNIMPLEMENTED; + icount = count; + + /* + * First write the existing content into database + */ + retval = undo_write_tdb(channel, block, icount); + if (retval) + return retval; + if (data->real) + retval = io_channel_discard(data->real, block, count); + + return retval; +} + +static errcode_t undo_zeroout(io_channel channel, unsigned long long block, + unsigned long long count) +{ + struct undo_private_data *data; + errcode_t retval = 0; + int icount; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (count > INT_MAX) + return EXT2_ET_UNIMPLEMENTED; + icount = count; + + /* + * First write the existing content into database + */ + retval = undo_write_tdb(channel, block, icount); + if (retval) + return retval; + if (data->real) + retval = io_channel_zeroout(data->real, block, count); + + return retval; +} + +static errcode_t undo_cache_readahead(io_channel channel, + unsigned long long block, + unsigned long long count) +{ + struct undo_private_data *data; + errcode_t retval = 0; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (data->real) + retval = io_channel_cache_readahead(data->real, block, count); + + return retval; +} + +/* + * Flush data buffers to disk. + */ +static errcode_t undo_flush(io_channel channel) +{ + errcode_t retval = 0; + struct undo_private_data *data; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (data->real) + retval = io_channel_flush(data->real); + + return retval; +} + +static errcode_t undo_set_option(io_channel channel, const char *option, + const char *arg) +{ + errcode_t retval = 0; + struct undo_private_data *data; + unsigned long tmp; + char *end; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (!strcmp(option, "tdb_data_size")) { + if (!arg) + return EXT2_ET_INVALID_ARGUMENT; + + tmp = strtoul(arg, &end, 0); + if (*end) + return EXT2_ET_INVALID_ARGUMENT; + if (tmp > E2UNDO_MAX_BLOCK_SIZE || tmp < E2UNDO_MIN_BLOCK_SIZE) + return EXT2_ET_INVALID_ARGUMENT; + if (!data->tdb_data_size || !data->tdb_written) { + data->tdb_written = -1; + data->tdb_data_size = tmp; + } + return 0; + } + /* + * Need to support offset option to work with + * Unix I/O manager + */ + if (data->real && data->real->manager->set_option) { + retval = data->real->manager->set_option(data->real, + option, arg); + } + if (!retval && !strcmp(option, "offset")) { + if (!arg) + return EXT2_ET_INVALID_ARGUMENT; + + tmp = strtoul(arg, &end, 0); + if (*end) + return EXT2_ET_INVALID_ARGUMENT; + data->offset = tmp; + } + return retval; +} + +static errcode_t undo_get_stats(io_channel channel, io_stats *stats) +{ + errcode_t retval = 0; + struct undo_private_data *data; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct undo_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (data->real) + retval = (data->real->manager->get_stats)(data->real, stats); + + return retval; +} + +static struct struct_io_manager struct_undo_manager = { + .magic = EXT2_ET_MAGIC_IO_MANAGER, + .name = "Undo I/O Manager", + .open = undo_open, + .close = undo_close, + .set_blksize = undo_set_blksize, + .read_blk = undo_read_blk, + .write_blk = undo_write_blk, + .flush = undo_flush, + .write_byte = undo_write_byte, + .set_option = undo_set_option, + .get_stats = undo_get_stats, + .read_blk64 = undo_read_blk64, + .write_blk64 = undo_write_blk64, + .discard = undo_discard, + .zeroout = undo_zeroout, + .cache_readahead = undo_cache_readahead, +}; + +io_manager undo_io_manager = &struct_undo_manager; -- cgit v1.2.3