* [Take 2]e2fsprogs: Undo I/O manager @ 2007-07-19 17:58 Aneesh Kumar K.V 2007-07-19 17:58 ` Aneesh Kumar K.V 2007-07-19 21:20 ` [Take 2]e2fsprogs: Undo I/O manager Theodore Tso 0 siblings, 2 replies; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-19 17:58 UTC (permalink / raw) To: linux-ext4; +Cc: tytso This patch fixes some bugs found during testing of the large inode migration patches. -aneesh ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 1/2] e2fsprogs: Add undo I/O manager @ 2007-07-19 17:58 ` Aneesh Kumar K.V 0 siblings, 0 replies; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-19 17:58 UTC (permalink / raw) To: linux-ext4; +Cc: tytso, Aneesh Kumar K.V From: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> This I/O manager saves the contents of the location being overwritten to a tdb database. This helps in undoing the changes done to the file system. The call sequence involve set_undo_io_backing_manager(unix_io_manager); set_undo_io_backup_file("/tmp/test.tdb"); retval = ext2fs_open2(dev_name, 0, flags, superblock, block_size, undo_io_manager, ¤t_fs); Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> --- lib/ext2fs/Makefile.in | 7 +- lib/ext2fs/ext2_io.h | 5 + lib/ext2fs/undo_io.c | 491 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 501 insertions(+), 2 deletions(-) create mode 100644 lib/ext2fs/undo_io.c diff --git a/lib/ext2fs/Makefile.in b/lib/ext2fs/Makefile.in index 199164a..8644565 100644 --- a/lib/ext2fs/Makefile.in +++ b/lib/ext2fs/Makefile.in @@ -66,7 +66,8 @@ OBJS= $(DEBUGFS_LIB_OBJS) $(RESIZE_LIB_OBJS) $(E2IMAGE_LIB_OBJS) \ unix_io.o \ unlink.o \ valid_blk.o \ - version.o + version.o \ + undo_io.o SRCS= ext2_err.c \ $(srcdir)/alloc.c \ @@ -134,7 +135,8 @@ SRCS= ext2_err.c \ $(srcdir)/tst_bitops.c \ $(srcdir)/tst_byteswap.c \ $(srcdir)/tst_getsize.c \ - $(srcdir)/tst_iscan.c + $(srcdir)/tst_iscan.c \ + $(srcdir)/undo_io.c HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \ tdb.h @@ -583,3 +585,4 @@ tst_iscan.o: $(srcdir)/tst_iscan.c $(srcdir)/ext2_fs.h \ $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h $(srcdir)/bitops.h +undo_io.o: $(srcdir)/undo_io.c $(srcdir)/ext2_fs.h $(srcdir)/ext2fs.h diff --git a/lib/ext2fs/ext2_io.h b/lib/ext2fs/ext2_io.h index eada278..476eb4d 100644 --- a/lib/ext2fs/ext2_io.h +++ b/lib/ext2fs/ext2_io.h @@ -96,6 +96,11 @@ extern errcode_t io_channel_write_byte(io_channel channel, /* unix_io.c */ extern io_manager unix_io_manager; +/* undo_io.c */ +extern io_manager undo_io_manager; +extern errcode_t set_undo_io_backing_manager(io_manager manager); +extern errcode_t set_undo_io_backup_file(char *file_name); + /* test_io.c */ extern io_manager test_io_manager, test_io_backing_manager; extern void (*test_io_cb_read_blk) diff --git a/lib/ext2fs/undo_io.c b/lib/ext2fs/undo_io.c new file mode 100644 index 0000000..ea37398 --- /dev/null +++ b/lib/ext2fs/undo_io.c @@ -0,0 +1,491 @@ +/* + * 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 <aneesh.kumar@linux.vnet.ibm.com> + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#define _LARGEFILE_SOURCE +#define _LARGEFILE64_SOURCE + +#include <stdio.h> +#include <string.h> +#if HAVE_UNISTD_H +#include <unistd.h> +#endif +#if HAVE_ERRNO_H +#include <errno.h> +#endif +#include <fcntl.h> +#include <time.h> +#ifdef __linux__ +#include <sys/utsname.h> +#endif +#if HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif +#if HAVE_SYS_TYPES_H +#include <sys/types.h> +#endif +#if HAVE_SYS_RESOURCE_H +#include <sys/resource.h> +#endif + +#include "tdb.h" + +#include "ext2_fs.h" +#include "ext2fs.h" + +/* + * For checking structure magic numbers... + */ + +#define EXT2_CHECK_MAGIC(struct, code) \ + if ((struct)->magic != (code)) return (code) + + + +struct undo_private_data { + int magic; + TDB_CONTEXT *tdb; + char *tdb_file; + + /* The backing io channel */ + io_channel real; + + /* to support offset in unix I/O manager */ + ext2_loff_t offset; +}; + +static errcode_t undo_open(const char *name, int flags, io_channel *channel); +static errcode_t undo_close(io_channel channel); +static errcode_t undo_set_blksize(io_channel channel, int blksize); +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *data); +static errcode_t undo_write_blk(io_channel channel, unsigned long block, + int count, const void *data); +static errcode_t undo_flush(io_channel channel); +static errcode_t undo_write_byte(io_channel channel, unsigned long offset, + int size, const void *data); +static errcode_t undo_set_option(io_channel channel, const char *option, + const char *arg); + +static struct struct_io_manager struct_undo_manager = { + EXT2_ET_MAGIC_IO_MANAGER, + "Undo I/O Manager", + undo_open, + undo_close, + undo_set_blksize, + undo_read_blk, + undo_write_blk, + undo_flush, + undo_write_byte, + undo_set_option +}; + +io_manager undo_io_manager = &struct_undo_manager; +static io_manager undo_io_backing_manager ; +static char *tdb_file ; +static int tdb_data_size = 0; + +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 undo_write_tdb(io_channel channel, + unsigned long block, int count) + +{ + int size, loop_count = 0, i; + unsigned long block_num, backing_blk_num; + errcode_t retval = 0; + ext2_loff_t offset; + struct undo_private_data *data; + TDB_DATA tdb_key, tdb_data; + char *read_ptr; + + data = (struct undo_private_data *) channel->private_data; + + + if (data->tdb == NULL) { + /* + * Transaction database not initialized + */ + return 0; + } + + /* + * Set the block size used to read for tdb + */ + if (!tdb_data_size) + tdb_data_size = channel->block_size; + + if (count == 1) + size = channel->block_size; + else { + if (count < 0) + size = -count; + else + size = count * channel->block_size; + } + + /* + * 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. + */ + + block_num = ((block*channel->block_size)+data->offset)/tdb_data_size; + + + loop_count = (size + tdb_data_size -1)/tdb_data_size; + + tdb_transaction_start(data->tdb); + for (i = 0; i < loop_count; i++) { + + tdb_key.dptr = (unsigned char *)&block_num; + tdb_key.dsize = sizeof(block_num); + + /* + * Check if we have the record already + */ + if (tdb_exists(data->tdb, tdb_key)) { + + /* Try the next block */ + block_num++; + continue; + } + + /* + * 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 * tdb_data_size; + backing_blk_num = (offset - data->offset) / channel->block_size; + + count = tdb_data_size + + ((offset - data->offset) % channel->block_size); + + retval = ext2fs_get_mem(count, &read_ptr); + if (retval) { + tdb_transaction_cancel(data->tdb); + return retval; + } + + memset(read_ptr, 0, count); + + retval = io_channel_read_blk(data->real, + backing_blk_num, + -count, read_ptr); + if (retval) { + free(read_ptr); + tdb_transaction_cancel(data->tdb); + return retval; + } + + + tdb_data.dptr = read_ptr + + ((offset - data->offset) % channel->block_size); + + tdb_data.dsize = tdb_data_size; + +#ifdef DEBUG + printf("Printing with key %ld data %x and size %d\n", + block_num, + tdb_data.dptr, tdb_data_size); +#endif + + retval = tdb_store(data->tdb, tdb_key, tdb_data, TDB_INSERT); + if (retval == -1) { + /* + * TDB_ERR_EXISTS cannot happen because we + * have already verified it doesn't exist + */ + tdb_transaction_cancel(data->tdb); + retval = EXT2_ET_TDB_ERR_IO; + free(read_ptr); + return retval; + + } + free(read_ptr); + /* Next block */ + block_num++; + } + + tdb_transaction_commit(data->tdb); + + + return retval; +} + +static TDB_CONTEXT *undo_setup_tdb(char *tdb_file, + struct undo_private_data *data) +{ + errcode_t retval; + + data->tdb = tdb_open(tdb_file, 0, TDB_CLEAR_IF_FIRST, + O_RDWR | O_CREAT | O_TRUNC, 0600); + return data->tdb; + +} +static errcode_t undo_open(const char *name, int flags, io_channel *channel) +{ + io_channel io = NULL; + struct undo_private_data *data = NULL; + errcode_t retval; + int open_flags; + struct stat st; + + if (name == 0) + return EXT2_ET_BAD_DEVICE_NAME; + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); + if (retval) + return retval; + 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; + + if (undo_io_backing_manager) { + retval = undo_io_backing_manager->open(name, flags, + &data->real); + if (retval) + goto cleanup; + } else { + data->real = 0; + } + + /* setup the tdb file */ + if (undo_setup_tdb(tdb_file, data) == NULL ) + goto cleanup; + + *channel = io; + return 0; + +cleanup: + if (data->real) + io_channel_close(data->real); + + if (data) + ext2fs_free_mem(&data); + + if (io) + ext2fs_free_mem(&io); + + return retval; +} + +static errcode_t undo_close(io_channel channel) +{ + 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 (--channel->refcount > 0) + return 0; + + if (data->real) + retval = io_channel_close(data->real); + + if (data->tdb) + tdb_close(data->tdb); + + ext2fs_free_mem(&channel->private_data); + if (channel->name) + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); + + return retval; +} + +static errcode_t undo_set_blksize(io_channel channel, int blksize) +{ + struct undo_private_data *data; + errcode_t retval; + + 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_set_blksize(data->real, blksize); + + channel->block_size = blksize; + return retval; +} + + +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *buf) +{ + errcode_t retval; + 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_blk(data->real, block, count, buf); + + return retval; +} + +static errcode_t undo_write_blk(io_channel channel, unsigned 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_blk(data->real, block, count, buf); + + return retval; + +} + +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; + ssize_t actual; + 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; +} + +/* + * 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); + + /* + * 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; +} -- 1.5.3.rc2-dirty ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 1/2] e2fsprogs: Add undo I/O manager @ 2007-07-19 17:58 ` Aneesh Kumar K.V 0 siblings, 0 replies; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-19 17:58 UTC (permalink / raw) To: linux-ext4; +Cc: tytso, Aneesh Kumar K.V From: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> This I/O manager saves the contents of the location being overwritten to a tdb database. This helps in undoing the changes done to the file system. The call sequence involve set_undo_io_backing_manager(unix_io_manager); set_undo_io_backup_file("/tmp/test.tdb"); retval = ext2fs_open2(dev_name, 0, flags, superblock, block_size, undo_io_manager, ¤t_fs); Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> --- lib/ext2fs/Makefile.in | 7 +- lib/ext2fs/ext2_io.h | 5 + lib/ext2fs/undo_io.c | 491 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 501 insertions(+), 2 deletions(-) create mode 100644 lib/ext2fs/undo_io.c diff --git a/lib/ext2fs/Makefile.in b/lib/ext2fs/Makefile.in index 199164a..8644565 100644 --- a/lib/ext2fs/Makefile.in +++ b/lib/ext2fs/Makefile.in @@ -66,7 +66,8 @@ OBJS= $(DEBUGFS_LIB_OBJS) $(RESIZE_LIB_OBJS) $(E2IMAGE_LIB_OBJS) \ unix_io.o \ unlink.o \ valid_blk.o \ - version.o + version.o \ + undo_io.o SRCS= ext2_err.c \ $(srcdir)/alloc.c \ @@ -134,7 +135,8 @@ SRCS= ext2_err.c \ $(srcdir)/tst_bitops.c \ $(srcdir)/tst_byteswap.c \ $(srcdir)/tst_getsize.c \ - $(srcdir)/tst_iscan.c + $(srcdir)/tst_iscan.c \ + $(srcdir)/undo_io.c HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \ tdb.h @@ -583,3 +585,4 @@ tst_iscan.o: $(srcdir)/tst_iscan.c $(srcdir)/ext2_fs.h \ $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h $(srcdir)/bitops.h +undo_io.o: $(srcdir)/undo_io.c $(srcdir)/ext2_fs.h $(srcdir)/ext2fs.h diff --git a/lib/ext2fs/ext2_io.h b/lib/ext2fs/ext2_io.h index eada278..476eb4d 100644 --- a/lib/ext2fs/ext2_io.h +++ b/lib/ext2fs/ext2_io.h @@ -96,6 +96,11 @@ extern errcode_t io_channel_write_byte(io_channel channel, /* unix_io.c */ extern io_manager unix_io_manager; +/* undo_io.c */ +extern io_manager undo_io_manager; +extern errcode_t set_undo_io_backing_manager(io_manager manager); +extern errcode_t set_undo_io_backup_file(char *file_name); + /* test_io.c */ extern io_manager test_io_manager, test_io_backing_manager; extern void (*test_io_cb_read_blk) diff --git a/lib/ext2fs/undo_io.c b/lib/ext2fs/undo_io.c new file mode 100644 index 0000000..ea37398 --- /dev/null +++ b/lib/ext2fs/undo_io.c @@ -0,0 +1,491 @@ +/* + * 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 <aneesh.kumar@linux.vnet.ibm.com> + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#define _LARGEFILE_SOURCE +#define _LARGEFILE64_SOURCE + +#include <stdio.h> +#include <string.h> +#if HAVE_UNISTD_H +#include <unistd.h> +#endif +#if HAVE_ERRNO_H +#include <errno.h> +#endif +#include <fcntl.h> +#include <time.h> +#ifdef __linux__ +#include <sys/utsname.h> +#endif +#if HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif +#if HAVE_SYS_TYPES_H +#include <sys/types.h> +#endif +#if HAVE_SYS_RESOURCE_H +#include <sys/resource.h> +#endif + +#include "tdb.h" + +#include "ext2_fs.h" +#include "ext2fs.h" + +/* + * For checking structure magic numbers... + */ + +#define EXT2_CHECK_MAGIC(struct, code) \ + if ((struct)->magic != (code)) return (code) + + + +struct undo_private_data { + int magic; + TDB_CONTEXT *tdb; + char *tdb_file; + + /* The backing io channel */ + io_channel real; + + /* to support offset in unix I/O manager */ + ext2_loff_t offset; +}; + +static errcode_t undo_open(const char *name, int flags, io_channel *channel); +static errcode_t undo_close(io_channel channel); +static errcode_t undo_set_blksize(io_channel channel, int blksize); +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *data); +static errcode_t undo_write_blk(io_channel channel, unsigned long block, + int count, const void *data); +static errcode_t undo_flush(io_channel channel); +static errcode_t undo_write_byte(io_channel channel, unsigned long offset, + int size, const void *data); +static errcode_t undo_set_option(io_channel channel, const char *option, + const char *arg); + +static struct struct_io_manager struct_undo_manager = { + EXT2_ET_MAGIC_IO_MANAGER, + "Undo I/O Manager", + undo_open, + undo_close, + undo_set_blksize, + undo_read_blk, + undo_write_blk, + undo_flush, + undo_write_byte, + undo_set_option +}; + +io_manager undo_io_manager = &struct_undo_manager; +static io_manager undo_io_backing_manager ; +static char *tdb_file ; +static int tdb_data_size = 0; + +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 undo_write_tdb(io_channel channel, + unsigned long block, int count) + +{ + int size, loop_count = 0, i; + unsigned long block_num, backing_blk_num; + errcode_t retval = 0; + ext2_loff_t offset; + struct undo_private_data *data; + TDB_DATA tdb_key, tdb_data; + char *read_ptr; + + data = (struct undo_private_data *) channel->private_data; + + + if (data->tdb == NULL) { + /* + * Transaction database not initialized + */ + return 0; + } + + /* + * Set the block size used to read for tdb + */ + if (!tdb_data_size) + tdb_data_size = channel->block_size; + + if (count == 1) + size = channel->block_size; + else { + if (count < 0) + size = -count; + else + size = count * channel->block_size; + } + + /* + * 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. + */ + + block_num = ((block*channel->block_size)+data->offset)/tdb_data_size; + + + loop_count = (size + tdb_data_size -1)/tdb_data_size; + + tdb_transaction_start(data->tdb); + for (i = 0; i < loop_count; i++) { + + tdb_key.dptr = (unsigned char *)&block_num; + tdb_key.dsize = sizeof(block_num); + + /* + * Check if we have the record already + */ + if (tdb_exists(data->tdb, tdb_key)) { + + /* Try the next block */ + block_num++; + continue; + } + + /* + * 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 * tdb_data_size; + backing_blk_num = (offset - data->offset) / channel->block_size; + + count = tdb_data_size + + ((offset - data->offset) % channel->block_size); + + retval = ext2fs_get_mem(count, &read_ptr); + if (retval) { + tdb_transaction_cancel(data->tdb); + return retval; + } + + memset(read_ptr, 0, count); + + retval = io_channel_read_blk(data->real, + backing_blk_num, + -count, read_ptr); + if (retval) { + free(read_ptr); + tdb_transaction_cancel(data->tdb); + return retval; + } + + + tdb_data.dptr = read_ptr + + ((offset - data->offset) % channel->block_size); + + tdb_data.dsize = tdb_data_size; + +#ifdef DEBUG + printf("Printing with key %ld data %x and size %d\n", + block_num, + tdb_data.dptr, tdb_data_size); +#endif + + retval = tdb_store(data->tdb, tdb_key, tdb_data, TDB_INSERT); + if (retval == -1) { + /* + * TDB_ERR_EXISTS cannot happen because we + * have already verified it doesn't exist + */ + tdb_transaction_cancel(data->tdb); + retval = EXT2_ET_TDB_ERR_IO; + free(read_ptr); + return retval; + + } + free(read_ptr); + /* Next block */ + block_num++; + } + + tdb_transaction_commit(data->tdb); + + + return retval; +} + +static TDB_CONTEXT *undo_setup_tdb(char *tdb_file, + struct undo_private_data *data) +{ + errcode_t retval; + + data->tdb = tdb_open(tdb_file, 0, TDB_CLEAR_IF_FIRST, + O_RDWR | O_CREAT | O_TRUNC, 0600); + return data->tdb; + +} +static errcode_t undo_open(const char *name, int flags, io_channel *channel) +{ + io_channel io = NULL; + struct undo_private_data *data = NULL; + errcode_t retval; + int open_flags; + struct stat st; + + if (name == 0) + return EXT2_ET_BAD_DEVICE_NAME; + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); + if (retval) + return retval; + 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; + + if (undo_io_backing_manager) { + retval = undo_io_backing_manager->open(name, flags, + &data->real); + if (retval) + goto cleanup; + } else { + data->real = 0; + } + + /* setup the tdb file */ + if (undo_setup_tdb(tdb_file, data) == NULL ) + goto cleanup; + + *channel = io; + return 0; + +cleanup: + if (data->real) + io_channel_close(data->real); + + if (data) + ext2fs_free_mem(&data); + + if (io) + ext2fs_free_mem(&io); + + return retval; +} + +static errcode_t undo_close(io_channel channel) +{ + 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 (--channel->refcount > 0) + return 0; + + if (data->real) + retval = io_channel_close(data->real); + + if (data->tdb) + tdb_close(data->tdb); + + ext2fs_free_mem(&channel->private_data); + if (channel->name) + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); + + return retval; +} + +static errcode_t undo_set_blksize(io_channel channel, int blksize) +{ + struct undo_private_data *data; + errcode_t retval; + + 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_set_blksize(data->real, blksize); + + channel->block_size = blksize; + return retval; +} + + +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *buf) +{ + errcode_t retval; + 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_blk(data->real, block, count, buf); + + return retval; +} + +static errcode_t undo_write_blk(io_channel channel, unsigned 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_blk(data->real, block, count, buf); + + return retval; + +} + +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; + ssize_t actual; + 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; +} + +/* + * 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); + + /* + * 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; +} -- 1.5.3.rc2-dirty ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 2/2] e2fsprogs: Add undoe2fs @ 2007-07-19 17:58 ` Aneesh Kumar K.V 0 siblings, 0 replies; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-19 17:58 UTC (permalink / raw) To: linux-ext4; +Cc: tytso, Aneesh Kumar K.V From: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> undoe2fs can be used to replay the transaction saved in the transaction file using undo I/O Manager Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> --- misc/Makefile.in | 10 +++++- misc/undoe2fs.c | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 2 deletions(-) create mode 100644 misc/undoe2fs.c diff --git a/misc/Makefile.in b/misc/Makefile.in index ccad78c..51bb17a 100644 --- a/misc/Makefile.in +++ b/misc/Makefile.in @@ -15,7 +15,7 @@ INSTALL = @INSTALL@ @IMAGER_CMT@E2IMAGE_MAN= e2image.8 SPROGS= mke2fs badblocks tune2fs dumpe2fs blkid logsave \ - $(E2IMAGE_PROG) @FSCK_PROG@ + $(E2IMAGE_PROG) @FSCK_PROG@ undoe2fs USPROGS= mklost+found filefrag SMANPAGES= tune2fs.8 mklost+found.8 mke2fs.8 dumpe2fs.8 badblocks.8 \ e2label.8 findfs.8 blkid.8 $(E2IMAGE_MAN) \ @@ -39,6 +39,7 @@ E2IMAGE_OBJS= e2image.o FSCK_OBJS= fsck.o base_device.o BLKID_OBJS= blkid.o FILEFRAG_OBJS= filefrag.o +UNDOE2FS_OBJS= undoe2fs.o XTRA_CFLAGS= -I$(srcdir)/../e2fsck -I. @@ -47,7 +48,7 @@ SRCS= $(srcdir)/tune2fs.c $(srcdir)/mklost+found.c $(srcdir)/mke2fs.c \ $(srcdir)/badblocks.c $(srcdir)/fsck.c $(srcdir)/util.c \ $(srcdir)/uuidgen.c $(srcdir)/blkid.c $(srcdir)/logsave.c \ $(srcdir)/filefrag.c $(srcdir)/base_device.c \ - $(srcdir)/../e2fsck/profile.c + $(srcdir)/../e2fsck/profile.c $(srcdir)/undoe2fs.c LIBS= $(LIBEXT2FS) $(LIBCOM_ERR) DEPLIBS= $(LIBEXT2FS) $(LIBCOM_ERR) @@ -108,6 +109,10 @@ e2image: $(E2IMAGE_OBJS) $(DEPLIBS) @echo " LD $@" @$(CC) $(ALL_LDFLAGS) -o e2image $(E2IMAGE_OBJS) $(LIBS) $(LIBINTL) +undoe2fs: $(UNDOE2FS_OBJS) $(DEPLIBS) + @echo " LD $@" + @$(CC) $(ALL_LDFLAGS) -o undoe2fs $(UNDOE2FS_OBJS) $(LIBS) + base_device: base_device.c @echo " LD $@" @$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) $(srcdir)/base_device.c \ @@ -434,3 +439,4 @@ filefrag.o: $(srcdir)/filefrag.c base_device.o: $(srcdir)/base_device.c $(srcdir)/fsck.h profile.o: $(srcdir)/../e2fsck/profile.c $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/../e2fsck/profile.h prof_err.h +undoe2fs.o: $(srcdir)/undoe2fs.c $(top_srcdir)/lib/ext2fs/tdb.h diff --git a/misc/undoe2fs.c b/misc/undoe2fs.c new file mode 100644 index 0000000..d14d44a --- /dev/null +++ b/misc/undoe2fs.c @@ -0,0 +1,77 @@ +/* + * Copyright IBM Corporation, 2007 + * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#include <stdio.h> +#include <stdlib.h> +#include <fcntl.h> +#if HAVE_ERRNO_H +#include <errno.h> +#endif +#include "ext2fs/tdb.h" + +void usage(char *prg_name) +{ + fprintf(stderr, + "Usage: %s <transaction file> <filesystem>\n", prg_name); + exit(1); + +} + + +main(int argc, char *argv[]) +{ + TDB_CONTEXT *tdb; + TDB_DATA key, data; + unsigned long blk_num; + unsigned long long int location; + int fd, retval; + + if (argc != 3) + usage(argv[0]); + + tdb = tdb_open(argv[1], 0, 0, O_RDONLY, 0600); + + if (!tdb) { + fprintf(stderr, "Failed tdb_open %s\n", strerror(errno)); + exit(1); + } + + fd = open(argv[2], O_WRONLY); + if (fd == -1) { + fprintf(stderr, "Failed open %s\n", strerror(errno)); + exit(1); + } + + for (key = tdb_firstkey(tdb); key.dptr; key = tdb_nextkey(tdb, key)) { + data = tdb_fetch(tdb, key); + if (!data.dptr) { + fprintf(stderr, + "Failed tdb_fetch %s\n", tdb_errorstr(tdb)); + exit(1); + } + blk_num = *(unsigned long *)key.dptr; + location = blk_num * data.dsize; + printf("Replayed transaction of size %d at location %ld\n", + data.dsize, blk_num); + retval = lseek(fd, location, SEEK_SET); + if (retval == -1) { + fprintf(stderr, "Failed lseek %s\n", strerror(errno)); + exit(1); + } + retval = write(fd, data.dptr, data.dsize); + if (retval == -1) { + fprintf(stderr, "Failed write %s\n", strerror(errno)); + exit(1); + } + } + close(fd); + tdb_close(tdb); + +} -- 1.5.3.rc2-dirty ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 2/2] e2fsprogs: Add undoe2fs @ 2007-07-19 17:58 ` Aneesh Kumar K.V 0 siblings, 0 replies; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-19 17:58 UTC (permalink / raw) To: linux-ext4; +Cc: tytso, Aneesh Kumar K.V From: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> undoe2fs can be used to replay the transaction saved in the transaction file using undo I/O Manager Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> --- misc/Makefile.in | 10 +++++- misc/undoe2fs.c | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 2 deletions(-) create mode 100644 misc/undoe2fs.c diff --git a/misc/Makefile.in b/misc/Makefile.in index ccad78c..51bb17a 100644 --- a/misc/Makefile.in +++ b/misc/Makefile.in @@ -15,7 +15,7 @@ INSTALL = @INSTALL@ @IMAGER_CMT@E2IMAGE_MAN= e2image.8 SPROGS= mke2fs badblocks tune2fs dumpe2fs blkid logsave \ - $(E2IMAGE_PROG) @FSCK_PROG@ + $(E2IMAGE_PROG) @FSCK_PROG@ undoe2fs USPROGS= mklost+found filefrag SMANPAGES= tune2fs.8 mklost+found.8 mke2fs.8 dumpe2fs.8 badblocks.8 \ e2label.8 findfs.8 blkid.8 $(E2IMAGE_MAN) \ @@ -39,6 +39,7 @@ E2IMAGE_OBJS= e2image.o FSCK_OBJS= fsck.o base_device.o BLKID_OBJS= blkid.o FILEFRAG_OBJS= filefrag.o +UNDOE2FS_OBJS= undoe2fs.o XTRA_CFLAGS= -I$(srcdir)/../e2fsck -I. @@ -47,7 +48,7 @@ SRCS= $(srcdir)/tune2fs.c $(srcdir)/mklost+found.c $(srcdir)/mke2fs.c \ $(srcdir)/badblocks.c $(srcdir)/fsck.c $(srcdir)/util.c \ $(srcdir)/uuidgen.c $(srcdir)/blkid.c $(srcdir)/logsave.c \ $(srcdir)/filefrag.c $(srcdir)/base_device.c \ - $(srcdir)/../e2fsck/profile.c + $(srcdir)/../e2fsck/profile.c $(srcdir)/undoe2fs.c LIBS= $(LIBEXT2FS) $(LIBCOM_ERR) DEPLIBS= $(LIBEXT2FS) $(LIBCOM_ERR) @@ -108,6 +109,10 @@ e2image: $(E2IMAGE_OBJS) $(DEPLIBS) @echo " LD $@" @$(CC) $(ALL_LDFLAGS) -o e2image $(E2IMAGE_OBJS) $(LIBS) $(LIBINTL) +undoe2fs: $(UNDOE2FS_OBJS) $(DEPLIBS) + @echo " LD $@" + @$(CC) $(ALL_LDFLAGS) -o undoe2fs $(UNDOE2FS_OBJS) $(LIBS) + base_device: base_device.c @echo " LD $@" @$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) $(srcdir)/base_device.c \ @@ -434,3 +439,4 @@ filefrag.o: $(srcdir)/filefrag.c base_device.o: $(srcdir)/base_device.c $(srcdir)/fsck.h profile.o: $(srcdir)/../e2fsck/profile.c $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/../e2fsck/profile.h prof_err.h +undoe2fs.o: $(srcdir)/undoe2fs.c $(top_srcdir)/lib/ext2fs/tdb.h diff --git a/misc/undoe2fs.c b/misc/undoe2fs.c new file mode 100644 index 0000000..d14d44a --- /dev/null +++ b/misc/undoe2fs.c @@ -0,0 +1,77 @@ +/* + * Copyright IBM Corporation, 2007 + * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#include <stdio.h> +#include <stdlib.h> +#include <fcntl.h> +#if HAVE_ERRNO_H +#include <errno.h> +#endif +#include "ext2fs/tdb.h" + +void usage(char *prg_name) +{ + fprintf(stderr, + "Usage: %s <transaction file> <filesystem>\n", prg_name); + exit(1); + +} + + +main(int argc, char *argv[]) +{ + TDB_CONTEXT *tdb; + TDB_DATA key, data; + unsigned long blk_num; + unsigned long long int location; + int fd, retval; + + if (argc != 3) + usage(argv[0]); + + tdb = tdb_open(argv[1], 0, 0, O_RDONLY, 0600); + + if (!tdb) { + fprintf(stderr, "Failed tdb_open %s\n", strerror(errno)); + exit(1); + } + + fd = open(argv[2], O_WRONLY); + if (fd == -1) { + fprintf(stderr, "Failed open %s\n", strerror(errno)); + exit(1); + } + + for (key = tdb_firstkey(tdb); key.dptr; key = tdb_nextkey(tdb, key)) { + data = tdb_fetch(tdb, key); + if (!data.dptr) { + fprintf(stderr, + "Failed tdb_fetch %s\n", tdb_errorstr(tdb)); + exit(1); + } + blk_num = *(unsigned long *)key.dptr; + location = blk_num * data.dsize; + printf("Replayed transaction of size %d at location %ld\n", + data.dsize, blk_num); + retval = lseek(fd, location, SEEK_SET); + if (retval == -1) { + fprintf(stderr, "Failed lseek %s\n", strerror(errno)); + exit(1); + } + retval = write(fd, data.dptr, data.dsize); + if (retval == -1) { + fprintf(stderr, "Failed write %s\n", strerror(errno)); + exit(1); + } + } + close(fd); + tdb_close(tdb); + +} -- 1.5.3.rc2-dirty ^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [Take 2]e2fsprogs: Undo I/O manager 2007-07-19 17:58 [Take 2]e2fsprogs: Undo I/O manager Aneesh Kumar K.V 2007-07-19 17:58 ` Aneesh Kumar K.V @ 2007-07-19 21:20 ` Theodore Tso 2007-07-20 3:05 ` Aneesh Kumar K.V 1 sibling, 1 reply; 6+ messages in thread From: Theodore Tso @ 2007-07-19 21:20 UTC (permalink / raw) To: Aneesh Kumar K.V; +Cc: linux-ext4 On Thu, Jul 19, 2007 at 11:28:06PM +0530, Aneesh Kumar K.V wrote: > This patch fixes some bugs found during testing of the large > inode migration patches. How are you testing it? I notice you haven't wired these into any of the existing e2fsprogs programs. Regards, - Ted ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [Take 2]e2fsprogs: Undo I/O manager 2007-07-19 21:20 ` [Take 2]e2fsprogs: Undo I/O manager Theodore Tso @ 2007-07-20 3:05 ` Aneesh Kumar K.V 0 siblings, 0 replies; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-20 3:05 UTC (permalink / raw) To: Theodore Tso; +Cc: linux-ext4 Theodore Tso wrote: > On Thu, Jul 19, 2007 at 11:28:06PM +0530, Aneesh Kumar K.V wrote: >> This patch fixes some bugs found during testing of the large >> inode migration patches. > > How are you testing it? I notice you haven't wired these into any of > the existing e2fsprogs programs. > > Regards, > Attaching below is a simple test program i used to verify this. I also used this along with the ext3 ext4 migration tool. -aneesh diff --git a/test.aneesh/test.c b/test.aneesh/test.c new file mode 100644 index 0000000..7d0a3e3 --- /dev/null +++ b/test.aneesh/test.c @@ -0,0 +1,25 @@ + +#include "ext2fs/ext2_fs.h" +#include "ext2fs/ext2fs.h" + +main(int argc, char *argv[]) +{ + char *dev_name, *file_name; + int flags, superblock = 0; + unsigned int block_size = 0; + ext2_filsys current_fs = NULL; + + dev_name = argv[1]; + file_name = argv[2]; + flags = EXT2_FLAG_SOFTSUPP_FEATURES | EXT2_FLAG_RW; + set_undo_io_backing_manager(unix_io_manager); + set_undo_io_backup_file(file_name); + ext2fs_open2(dev_name, 0, + flags, superblock, block_size, + undo_io_manager, ¤t_fs); + + /* Now write super block with junk */ + memcpy(current_fs->super, "crash me", 8); + ext2fs_mark_super_dirty(current_fs); + ext2fs_close(current_fs); +} ^ permalink raw reply related [flat|nested] 6+ messages in thread
* e2fsprogs: Undo I/O manager @ 2007-07-11 11:00 Aneesh Kumar K.V 2007-07-11 11:00 ` Aneesh Kumar K.V 0 siblings, 1 reply; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-11 11:00 UTC (permalink / raw) To: linux-ext4; +Cc: tytso Hi Ted, Following patch implement the Undo I/O manager and undoe2fs. The patches are on top of latest git(23edf9b4674ced1cdf8625bd609d95dbd62923b3) -aneesh ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 1/2] e2fsprogs: Add undo I/O manager @ 2007-07-11 11:00 ` Aneesh Kumar K.V 0 siblings, 0 replies; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-11 11:00 UTC (permalink / raw) To: linux-ext4; +Cc: tytso, Aneesh Kumar K.V From: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> This I/O manager saves the contents of the location being overwritten to a tdb database. This helps in undoing the changes done to the file system. The call sequence involve set_undo_io_backing_manager(unix_io_manager); set_undo_io_backup_file("/tmp/test.tdb"); retval = ext2fs_open2(dev_name, 0, flags, superblock, block_size, undo_io_manager, ¤t_fs); Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> --- lib/ext2fs/Makefile.in | 7 +- lib/ext2fs/ext2_io.h | 5 + lib/ext2fs/undo_io.c | 486 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 496 insertions(+), 2 deletions(-) create mode 100644 lib/ext2fs/undo_io.c diff --git a/lib/ext2fs/Makefile.in b/lib/ext2fs/Makefile.in index 199164a..8644565 100644 --- a/lib/ext2fs/Makefile.in +++ b/lib/ext2fs/Makefile.in @@ -66,7 +66,8 @@ OBJS= $(DEBUGFS_LIB_OBJS) $(RESIZE_LIB_OBJS) $(E2IMAGE_LIB_OBJS) \ unix_io.o \ unlink.o \ valid_blk.o \ - version.o + version.o \ + undo_io.o SRCS= ext2_err.c \ $(srcdir)/alloc.c \ @@ -134,7 +135,8 @@ SRCS= ext2_err.c \ $(srcdir)/tst_bitops.c \ $(srcdir)/tst_byteswap.c \ $(srcdir)/tst_getsize.c \ - $(srcdir)/tst_iscan.c + $(srcdir)/tst_iscan.c \ + $(srcdir)/undo_io.c HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \ tdb.h @@ -583,3 +585,4 @@ tst_iscan.o: $(srcdir)/tst_iscan.c $(srcdir)/ext2_fs.h \ $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h $(srcdir)/bitops.h +undo_io.o: $(srcdir)/undo_io.c $(srcdir)/ext2_fs.h $(srcdir)/ext2fs.h diff --git a/lib/ext2fs/ext2_io.h b/lib/ext2fs/ext2_io.h index eada278..476eb4d 100644 --- a/lib/ext2fs/ext2_io.h +++ b/lib/ext2fs/ext2_io.h @@ -96,6 +96,11 @@ extern errcode_t io_channel_write_byte(io_channel channel, /* unix_io.c */ extern io_manager unix_io_manager; +/* undo_io.c */ +extern io_manager undo_io_manager; +extern errcode_t set_undo_io_backing_manager(io_manager manager); +extern errcode_t set_undo_io_backup_file(char *file_name); + /* test_io.c */ extern io_manager test_io_manager, test_io_backing_manager; extern void (*test_io_cb_read_blk) diff --git a/lib/ext2fs/undo_io.c b/lib/ext2fs/undo_io.c new file mode 100644 index 0000000..de74912 --- /dev/null +++ b/lib/ext2fs/undo_io.c @@ -0,0 +1,486 @@ +/* + * 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 <aneesh.kumar@linux.vnet.ibm.com> + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#define _LARGEFILE_SOURCE +#define _LARGEFILE64_SOURCE + +#include <stdio.h> +#include <string.h> +#if HAVE_UNISTD_H +#include <unistd.h> +#endif +#if HAVE_ERRNO_H +#include <errno.h> +#endif +#include <fcntl.h> +#include <time.h> +#ifdef __linux__ +#include <sys/utsname.h> +#endif +#if HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif +#if HAVE_SYS_TYPES_H +#include <sys/types.h> +#endif +#if HAVE_SYS_RESOURCE_H +#include <sys/resource.h> +#endif + +#include "tdb.h" + +#include "ext2_fs.h" +#include "ext2fs.h" + +/* + * For checking structure magic numbers... + */ + +#define EXT2_CHECK_MAGIC(struct, code) \ + if ((struct)->magic != (code)) return (code) + + + +struct undo_private_data { + int magic; + TDB_CONTEXT *tdb; + char *tdb_file; + + /* The backing io channel */ + io_channel real; + + /* to support offset in unix I/O manager */ + ext2_loff_t offset; +}; + +static errcode_t undo_open(const char *name, int flags, io_channel *channel); +static errcode_t undo_close(io_channel channel); +static errcode_t undo_set_blksize(io_channel channel, int blksize); +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *data); +static errcode_t undo_write_blk(io_channel channel, unsigned long block, + int count, const void *data); +static errcode_t undo_flush(io_channel channel); +static errcode_t undo_write_byte(io_channel channel, unsigned long offset, + int size, const void *data); +static errcode_t undo_set_option(io_channel channel, const char *option, + const char *arg); + +static struct struct_io_manager struct_undo_manager = { + EXT2_ET_MAGIC_IO_MANAGER, + "Undo I/O Manager", + undo_open, + undo_close, + undo_set_blksize, + undo_read_blk, + undo_write_blk, + undo_flush, + undo_write_byte, + undo_set_option +}; + +io_manager undo_io_manager = &struct_undo_manager; +static io_manager undo_io_backing_manager ; +static char *tdb_file ; +static int tdb_data_size = 0; + +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 undo_write_tdb(io_channel channel, + unsigned long block, int count) + +{ + int size, loop_count = 0, i; + unsigned long block_num, backing_blk_num; + errcode_t retval = 0; + ext2_loff_t offset; + struct undo_private_data *data; + TDB_DATA tdb_key, tdb_data; + char *read_ptr; + + data = (struct undo_private_data *) channel->private_data; + + + if (data->tdb == NULL) { + /* + * Transaction database not initialized + */ + return 0; + } + + /* + * Set the block size used to read for tdb + */ + if (!tdb_data_size) + tdb_data_size = channel->block_size; + + if (count == 1) + size = channel->block_size; + else { + if (count < 0) + size = -count; + else + size = count * channel->block_size; + } + + /* + * 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. + */ + + block_num = ((block*channel->block_size)+data->offset)/tdb_data_size; + + + loop_count = (size + tdb_data_size -1)/tdb_data_size; + + tdb_transaction_start(data->tdb); + for (i = 0; i < loop_count; i++) { + + block_num += i; + tdb_key.dptr = (unsigned char *)&block_num; + tdb_key.dsize = sizeof(block_num); + + /* + * Check if we have the record already + */ + if (tdb_exists(data->tdb, tdb_key)) { + + /* Try the next block */ + continue; + } + + /* + * 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 * tdb_data_size; + backing_blk_num = (offset - data->offset) / channel->block_size; + + count = 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); + + retval = io_channel_read_blk(data->real, + backing_blk_num, + -count, read_ptr); + if (retval) { + free(read_ptr); + return retval; + } + + + tdb_data.dptr = read_ptr + + ((offset - data->offset) % channel->block_size); + + tdb_data.dsize = tdb_data_size; + +#ifdef DEBUG + printf("Printing with key %ld data %x and size %d\n", + block_num, + tdb_data.dptr, tdb_data_size); +#endif + + retval = tdb_store(data->tdb, tdb_key, tdb_data, TDB_INSERT); + if (retval == -1) { + /* + * TDB_ERR_EXISTS cannot happen because we + * have already verified it doesn't exist + */ + tdb_transaction_cancel(data->tdb); + retval = EXT2_ET_TDB_ERR_IO; + free(read_ptr); + return retval; + + } + free(read_ptr); + } + + tdb_transaction_commit(data->tdb); + + return retval; + +} + +static TDB_CONTEXT *undo_setup_tdb(char *tdb_file, + struct undo_private_data *data) +{ + errcode_t retval; + + data->tdb = tdb_open(tdb_file, 0, TDB_CLEAR_IF_FIRST, + O_RDWR | O_CREAT | O_TRUNC, 0600); + return data->tdb; + +} +static errcode_t undo_open(const char *name, int flags, io_channel *channel) +{ + io_channel io = NULL; + struct undo_private_data *data = NULL; + errcode_t retval; + int open_flags; + struct stat st; + + if (name == 0) + return EXT2_ET_BAD_DEVICE_NAME; + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); + if (retval) + return retval; + 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; + + if (undo_io_backing_manager) { + retval = undo_io_backing_manager->open(name, flags, + &data->real); + if (retval) + goto cleanup; + } else { + data->real = 0; + } + + /* setup the tdb file */ + if (undo_setup_tdb(tdb_file, data) == NULL ) + goto cleanup; + + *channel = io; + return 0; + +cleanup: + if (data->real) + io_channel_close(data->real); + + if (data) + ext2fs_free_mem(&data); + + if (io) + ext2fs_free_mem(&io); + + return retval; +} + +static errcode_t undo_close(io_channel channel) +{ + 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 (--channel->refcount > 0) + return 0; + + if (data->real) + retval = io_channel_close(data->real); + + if (data->tdb) + tdb_close(data->tdb); + + ext2fs_free_mem(&channel->private_data); + if (channel->name) + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); + + return retval; +} + +static errcode_t undo_set_blksize(io_channel channel, int blksize) +{ + struct undo_private_data *data; + errcode_t retval; + + 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_set_blksize(data->real, blksize); + + channel->block_size = blksize; + return retval; +} + + +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *buf) +{ + errcode_t retval; + 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_blk(data->real, block, count, buf); + + return retval; +} + +static errcode_t undo_write_blk(io_channel channel, unsigned 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_blk(data->real, block, count, buf); + + return retval; + +} + +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; + ssize_t actual; + 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; +} + +/* + * 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); + + /* + * 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; +} -- 1.5.3.rc0.63.gc956-dirty ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 1/2] e2fsprogs: Add undo I/O manager @ 2007-07-11 11:00 ` Aneesh Kumar K.V 0 siblings, 0 replies; 6+ messages in thread From: Aneesh Kumar K.V @ 2007-07-11 11:00 UTC (permalink / raw) To: linux-ext4; +Cc: tytso, Aneesh Kumar K.V From: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> This I/O manager saves the contents of the location being overwritten to a tdb database. This helps in undoing the changes done to the file system. The call sequence involve set_undo_io_backing_manager(unix_io_manager); set_undo_io_backup_file("/tmp/test.tdb"); retval = ext2fs_open2(dev_name, 0, flags, superblock, block_size, undo_io_manager, ¤t_fs); Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> --- lib/ext2fs/Makefile.in | 7 +- lib/ext2fs/ext2_io.h | 5 + lib/ext2fs/undo_io.c | 486 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 496 insertions(+), 2 deletions(-) create mode 100644 lib/ext2fs/undo_io.c diff --git a/lib/ext2fs/Makefile.in b/lib/ext2fs/Makefile.in index 199164a..8644565 100644 --- a/lib/ext2fs/Makefile.in +++ b/lib/ext2fs/Makefile.in @@ -66,7 +66,8 @@ OBJS= $(DEBUGFS_LIB_OBJS) $(RESIZE_LIB_OBJS) $(E2IMAGE_LIB_OBJS) \ unix_io.o \ unlink.o \ valid_blk.o \ - version.o + version.o \ + undo_io.o SRCS= ext2_err.c \ $(srcdir)/alloc.c \ @@ -134,7 +135,8 @@ SRCS= ext2_err.c \ $(srcdir)/tst_bitops.c \ $(srcdir)/tst_byteswap.c \ $(srcdir)/tst_getsize.c \ - $(srcdir)/tst_iscan.c + $(srcdir)/tst_iscan.c \ + $(srcdir)/undo_io.c HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \ tdb.h @@ -583,3 +585,4 @@ tst_iscan.o: $(srcdir)/tst_iscan.c $(srcdir)/ext2_fs.h \ $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h $(srcdir)/bitops.h +undo_io.o: $(srcdir)/undo_io.c $(srcdir)/ext2_fs.h $(srcdir)/ext2fs.h diff --git a/lib/ext2fs/ext2_io.h b/lib/ext2fs/ext2_io.h index eada278..476eb4d 100644 --- a/lib/ext2fs/ext2_io.h +++ b/lib/ext2fs/ext2_io.h @@ -96,6 +96,11 @@ extern errcode_t io_channel_write_byte(io_channel channel, /* unix_io.c */ extern io_manager unix_io_manager; +/* undo_io.c */ +extern io_manager undo_io_manager; +extern errcode_t set_undo_io_backing_manager(io_manager manager); +extern errcode_t set_undo_io_backup_file(char *file_name); + /* test_io.c */ extern io_manager test_io_manager, test_io_backing_manager; extern void (*test_io_cb_read_blk) diff --git a/lib/ext2fs/undo_io.c b/lib/ext2fs/undo_io.c new file mode 100644 index 0000000..de74912 --- /dev/null +++ b/lib/ext2fs/undo_io.c @@ -0,0 +1,486 @@ +/* + * 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 <aneesh.kumar@linux.vnet.ibm.com> + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#define _LARGEFILE_SOURCE +#define _LARGEFILE64_SOURCE + +#include <stdio.h> +#include <string.h> +#if HAVE_UNISTD_H +#include <unistd.h> +#endif +#if HAVE_ERRNO_H +#include <errno.h> +#endif +#include <fcntl.h> +#include <time.h> +#ifdef __linux__ +#include <sys/utsname.h> +#endif +#if HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif +#if HAVE_SYS_TYPES_H +#include <sys/types.h> +#endif +#if HAVE_SYS_RESOURCE_H +#include <sys/resource.h> +#endif + +#include "tdb.h" + +#include "ext2_fs.h" +#include "ext2fs.h" + +/* + * For checking structure magic numbers... + */ + +#define EXT2_CHECK_MAGIC(struct, code) \ + if ((struct)->magic != (code)) return (code) + + + +struct undo_private_data { + int magic; + TDB_CONTEXT *tdb; + char *tdb_file; + + /* The backing io channel */ + io_channel real; + + /* to support offset in unix I/O manager */ + ext2_loff_t offset; +}; + +static errcode_t undo_open(const char *name, int flags, io_channel *channel); +static errcode_t undo_close(io_channel channel); +static errcode_t undo_set_blksize(io_channel channel, int blksize); +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *data); +static errcode_t undo_write_blk(io_channel channel, unsigned long block, + int count, const void *data); +static errcode_t undo_flush(io_channel channel); +static errcode_t undo_write_byte(io_channel channel, unsigned long offset, + int size, const void *data); +static errcode_t undo_set_option(io_channel channel, const char *option, + const char *arg); + +static struct struct_io_manager struct_undo_manager = { + EXT2_ET_MAGIC_IO_MANAGER, + "Undo I/O Manager", + undo_open, + undo_close, + undo_set_blksize, + undo_read_blk, + undo_write_blk, + undo_flush, + undo_write_byte, + undo_set_option +}; + +io_manager undo_io_manager = &struct_undo_manager; +static io_manager undo_io_backing_manager ; +static char *tdb_file ; +static int tdb_data_size = 0; + +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 undo_write_tdb(io_channel channel, + unsigned long block, int count) + +{ + int size, loop_count = 0, i; + unsigned long block_num, backing_blk_num; + errcode_t retval = 0; + ext2_loff_t offset; + struct undo_private_data *data; + TDB_DATA tdb_key, tdb_data; + char *read_ptr; + + data = (struct undo_private_data *) channel->private_data; + + + if (data->tdb == NULL) { + /* + * Transaction database not initialized + */ + return 0; + } + + /* + * Set the block size used to read for tdb + */ + if (!tdb_data_size) + tdb_data_size = channel->block_size; + + if (count == 1) + size = channel->block_size; + else { + if (count < 0) + size = -count; + else + size = count * channel->block_size; + } + + /* + * 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. + */ + + block_num = ((block*channel->block_size)+data->offset)/tdb_data_size; + + + loop_count = (size + tdb_data_size -1)/tdb_data_size; + + tdb_transaction_start(data->tdb); + for (i = 0; i < loop_count; i++) { + + block_num += i; + tdb_key.dptr = (unsigned char *)&block_num; + tdb_key.dsize = sizeof(block_num); + + /* + * Check if we have the record already + */ + if (tdb_exists(data->tdb, tdb_key)) { + + /* Try the next block */ + continue; + } + + /* + * 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 * tdb_data_size; + backing_blk_num = (offset - data->offset) / channel->block_size; + + count = 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); + + retval = io_channel_read_blk(data->real, + backing_blk_num, + -count, read_ptr); + if (retval) { + free(read_ptr); + return retval; + } + + + tdb_data.dptr = read_ptr + + ((offset - data->offset) % channel->block_size); + + tdb_data.dsize = tdb_data_size; + +#ifdef DEBUG + printf("Printing with key %ld data %x and size %d\n", + block_num, + tdb_data.dptr, tdb_data_size); +#endif + + retval = tdb_store(data->tdb, tdb_key, tdb_data, TDB_INSERT); + if (retval == -1) { + /* + * TDB_ERR_EXISTS cannot happen because we + * have already verified it doesn't exist + */ + tdb_transaction_cancel(data->tdb); + retval = EXT2_ET_TDB_ERR_IO; + free(read_ptr); + return retval; + + } + free(read_ptr); + } + + tdb_transaction_commit(data->tdb); + + return retval; + +} + +static TDB_CONTEXT *undo_setup_tdb(char *tdb_file, + struct undo_private_data *data) +{ + errcode_t retval; + + data->tdb = tdb_open(tdb_file, 0, TDB_CLEAR_IF_FIRST, + O_RDWR | O_CREAT | O_TRUNC, 0600); + return data->tdb; + +} +static errcode_t undo_open(const char *name, int flags, io_channel *channel) +{ + io_channel io = NULL; + struct undo_private_data *data = NULL; + errcode_t retval; + int open_flags; + struct stat st; + + if (name == 0) + return EXT2_ET_BAD_DEVICE_NAME; + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); + if (retval) + return retval; + 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; + + if (undo_io_backing_manager) { + retval = undo_io_backing_manager->open(name, flags, + &data->real); + if (retval) + goto cleanup; + } else { + data->real = 0; + } + + /* setup the tdb file */ + if (undo_setup_tdb(tdb_file, data) == NULL ) + goto cleanup; + + *channel = io; + return 0; + +cleanup: + if (data->real) + io_channel_close(data->real); + + if (data) + ext2fs_free_mem(&data); + + if (io) + ext2fs_free_mem(&io); + + return retval; +} + +static errcode_t undo_close(io_channel channel) +{ + 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 (--channel->refcount > 0) + return 0; + + if (data->real) + retval = io_channel_close(data->real); + + if (data->tdb) + tdb_close(data->tdb); + + ext2fs_free_mem(&channel->private_data); + if (channel->name) + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); + + return retval; +} + +static errcode_t undo_set_blksize(io_channel channel, int blksize) +{ + struct undo_private_data *data; + errcode_t retval; + + 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_set_blksize(data->real, blksize); + + channel->block_size = blksize; + return retval; +} + + +static errcode_t undo_read_blk(io_channel channel, unsigned long block, + int count, void *buf) +{ + errcode_t retval; + 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_blk(data->real, block, count, buf); + + return retval; +} + +static errcode_t undo_write_blk(io_channel channel, unsigned 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_blk(data->real, block, count, buf); + + return retval; + +} + +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; + ssize_t actual; + 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; +} + +/* + * 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); + + /* + * 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; +} -- 1.5.3.rc0.63.gc956-dirty ^ permalink raw reply related [flat|nested] 6+ messages in thread
end of thread, other threads:[~2007-07-20 3:05 UTC | newest] Thread overview: 6+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2007-07-19 17:58 [Take 2]e2fsprogs: Undo I/O manager Aneesh Kumar K.V 2007-07-19 17:58 ` [PATCH 1/2] e2fsprogs: Add undo " Aneesh Kumar K.V 2007-07-19 17:58 ` Aneesh Kumar K.V 2007-07-19 17:58 ` [PATCH 2/2] e2fsprogs: Add undoe2fs Aneesh Kumar K.V 2007-07-19 17:58 ` Aneesh Kumar K.V 2007-07-19 21:20 ` [Take 2]e2fsprogs: Undo I/O manager Theodore Tso 2007-07-20 3:05 ` Aneesh Kumar K.V -- strict thread matches above, loose matches on Subject: below -- 2007-07-11 11:00 e2fsprogs: " Aneesh Kumar K.V 2007-07-11 11:00 ` [PATCH 1/2] e2fsprogs: Add undo " Aneesh Kumar K.V 2007-07-11 11:00 ` Aneesh Kumar K.V
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.