2007-08-13 14:26:21 +04:00
|
|
|
/*
|
|
|
|
* 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%
|
2010-05-18 05:31:56 +04:00
|
|
|
* This file may be redistributed under the terms of the GNU Library
|
|
|
|
* General Public License, version 2.
|
2007-08-13 14:26:21 +04:00
|
|
|
* %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"
|
|
|
|
|
2008-06-07 19:53:56 +04:00
|
|
|
#ifdef __GNUC__
|
|
|
|
#define ATTR(x) __attribute__(x)
|
|
|
|
#else
|
|
|
|
#define ATTR(x)
|
|
|
|
#endif
|
|
|
|
|
2007-08-13 14:26:21 +04:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
int tdb_data_size;
|
|
|
|
int tdb_written;
|
|
|
|
|
|
|
|
/* 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);
|
2009-07-12 08:53:57 +04:00
|
|
|
static errcode_t undo_read_blk64(io_channel channel, unsigned long long block,
|
|
|
|
int count, void *data);
|
|
|
|
static errcode_t undo_write_blk64(io_channel channel, unsigned long long block,
|
|
|
|
int count, const void *data);
|
2007-08-13 14:26:21 +04:00
|
|
|
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);
|
2009-07-12 08:53:57 +04:00
|
|
|
static errcode_t undo_get_stats(io_channel channel, io_stats *stats);
|
2007-08-13 14:26:21 +04:00
|
|
|
|
|
|
|
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,
|
2009-07-12 08:53:57 +04:00
|
|
|
undo_set_option,
|
|
|
|
undo_get_stats,
|
|
|
|
undo_read_blk64,
|
|
|
|
undo_write_blk64,
|
2007-08-13 14:26:21 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
io_manager undo_io_manager = &struct_undo_manager;
|
|
|
|
static io_manager undo_io_backing_manager ;
|
|
|
|
static char *tdb_file;
|
|
|
|
static int actual_size;
|
|
|
|
|
2008-06-07 19:53:56 +04:00
|
|
|
static unsigned char mtime_key[] = "filesystem MTIME";
|
|
|
|
static unsigned char blksize_key[] = "filesystem BLKSIZE";
|
|
|
|
static unsigned char uuid_key[] = "filesystem UUID";
|
|
|
|
|
2007-08-13 14:26:21 +04:00
|
|
|
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_file_system_identity(io_channel undo_channel,
|
|
|
|
TDB_CONTEXT *tdb)
|
|
|
|
{
|
|
|
|
errcode_t retval;
|
|
|
|
struct ext2_super_block super;
|
|
|
|
TDB_DATA tdb_key, tdb_data;
|
|
|
|
struct undo_private_data *data;
|
|
|
|
io_channel channel;
|
|
|
|
int block_size ;
|
|
|
|
|
|
|
|
data = (struct undo_private_data *) undo_channel->private_data;
|
|
|
|
channel = data->real;
|
|
|
|
block_size = channel->block_size;
|
|
|
|
|
|
|
|
io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);
|
2009-09-08 05:14:24 +04:00
|
|
|
retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);
|
2007-08-13 14:26:21 +04:00
|
|
|
if (retval)
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
/* Write to tdb file in the file system byte order */
|
2008-06-07 19:53:56 +04:00
|
|
|
tdb_key.dptr = mtime_key;
|
|
|
|
tdb_key.dsize = sizeof(mtime_key);
|
2007-08-13 14:26:21 +04:00
|
|
|
tdb_data.dptr = (unsigned char *) &(super.s_mtime);
|
|
|
|
tdb_data.dsize = sizeof(super.s_mtime);
|
|
|
|
|
|
|
|
retval = tdb_store(tdb, tdb_key, tdb_data, TDB_INSERT);
|
|
|
|
if (retval == -1) {
|
|
|
|
retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
2008-06-07 19:53:56 +04:00
|
|
|
tdb_key.dptr = uuid_key;
|
|
|
|
tdb_key.dsize = sizeof(uuid_key);
|
2007-08-13 14:26:21 +04:00
|
|
|
tdb_data.dptr = (unsigned char *)&(super.s_uuid);
|
|
|
|
tdb_data.dsize = sizeof(super.s_uuid);
|
|
|
|
|
|
|
|
retval = tdb_store(tdb, tdb_key, tdb_data, TDB_INSERT);
|
|
|
|
if (retval == -1) {
|
|
|
|
retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);
|
|
|
|
}
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
io_channel_set_blksize(channel, block_size);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static errcode_t write_block_size(TDB_CONTEXT *tdb, int block_size)
|
|
|
|
{
|
|
|
|
errcode_t retval;
|
|
|
|
TDB_DATA tdb_key, tdb_data;
|
|
|
|
|
2008-06-07 19:53:56 +04:00
|
|
|
tdb_key.dptr = blksize_key;
|
|
|
|
tdb_key.dsize = sizeof(blksize_key);
|
2007-08-13 14:26:21 +04:00
|
|
|
tdb_data.dptr = (unsigned char *)&(block_size);
|
|
|
|
tdb_data.dsize = sizeof(block_size);
|
|
|
|
|
|
|
|
retval = tdb_store(tdb, tdb_key, tdb_data, TDB_INSERT);
|
|
|
|
if (retval == -1) {
|
|
|
|
retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static errcode_t undo_write_tdb(io_channel channel,
|
2009-07-12 08:53:57 +04:00
|
|
|
unsigned long long block, int count)
|
2007-08-13 14:26:21 +04:00
|
|
|
|
|
|
|
{
|
2008-06-07 19:53:56 +04:00
|
|
|
int size, sz;
|
2009-07-12 08:53:57 +04:00
|
|
|
unsigned long long block_num, backing_blk_num;
|
2007-08-13 14:26:21 +04:00
|
|
|
errcode_t retval = 0;
|
|
|
|
ext2_loff_t offset;
|
|
|
|
struct undo_private_data *data;
|
|
|
|
TDB_DATA tdb_key, tdb_data;
|
2008-06-07 19:53:56 +04:00
|
|
|
unsigned char *read_ptr;
|
2009-07-12 08:53:57 +04:00
|
|
|
unsigned long long end_block;
|
2007-08-13 14:26:21 +04:00
|
|
|
|
|
|
|
data = (struct undo_private_data *) channel->private_data;
|
|
|
|
|
|
|
|
if (data->tdb == 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;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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) / data->tdb_data_size;
|
|
|
|
|
|
|
|
tdb_transaction_start(data->tdb);
|
|
|
|
while (block_num <= end_block ) {
|
|
|
|
|
|
|
|
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 * data->tdb_data_size;
|
|
|
|
backing_blk_num = (offset - data->offset) / channel->block_size;
|
|
|
|
|
|
|
|
count = data->tdb_data_size +
|
|
|
|
((offset - data->offset) % channel->block_size);
|
|
|
|
retval = ext2fs_get_mem(count, &read_ptr);
|
|
|
|
if (retval) {
|
|
|
|
tdb_transaction_cancel(data->tdb);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(read_ptr, 0, count);
|
|
|
|
actual_size = 0;
|
|
|
|
if ((count % channel->block_size) == 0)
|
|
|
|
sz = count / channel->block_size;
|
|
|
|
else
|
|
|
|
sz = -count;
|
2009-07-12 08:53:57 +04:00
|
|
|
retval = io_channel_read_blk64(data->real, backing_blk_num,
|
2007-08-13 14:26:21 +04:00
|
|
|
sz, read_ptr);
|
|
|
|
if (retval) {
|
|
|
|
if (retval != EXT2_ET_SHORT_READ) {
|
|
|
|
free(read_ptr);
|
|
|
|
tdb_transaction_cancel(data->tdb);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* short read so update the record size
|
|
|
|
* accordingly
|
|
|
|
*/
|
|
|
|
tdb_data.dsize = actual_size;
|
|
|
|
} else {
|
|
|
|
tdb_data.dsize = data->tdb_data_size;
|
|
|
|
}
|
|
|
|
tdb_data.dptr = read_ptr +
|
|
|
|
((offset - data->offset) % channel->block_size);
|
|
|
|
#ifdef DEBUG
|
2009-07-12 08:53:57 +04:00
|
|
|
printf("Printing with key %lld data %x and size %d\n",
|
2007-08-13 14:26:21 +04:00
|
|
|
block_num,
|
|
|
|
tdb_data.dptr,
|
|
|
|
tdb_data.dsize);
|
|
|
|
#endif
|
|
|
|
if (!data->tdb_written) {
|
|
|
|
data->tdb_written = 1;
|
|
|
|
/* Write the blocksize to tdb file */
|
|
|
|
retval = write_block_size(data->tdb,
|
|
|
|
data->tdb_data_size);
|
|
|
|
if (retval) {
|
|
|
|
tdb_transaction_cancel(data->tdb);
|
|
|
|
retval = EXT2_ET_TDB_ERR_IO;
|
|
|
|
free(read_ptr);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-06-07 19:53:56 +04:00
|
|
|
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)))
|
2007-08-13 14:26:21 +04:00
|
|
|
{
|
|
|
|
actual_size = actual;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void undo_err_handler_init(io_channel channel)
|
|
|
|
{
|
|
|
|
channel->read_error = undo_io_read_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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 */
|
|
|
|
data->tdb = tdb_open(tdb_file, 0, TDB_CLEAR_IF_FIRST,
|
|
|
|
O_RDWR | O_CREAT | O_TRUNC | O_EXCL, 0600);
|
|
|
|
if (!data->tdb) {
|
|
|
|
retval = errno;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* setup err handler for read so that we know
|
|
|
|
* when the backing manager fails do short read
|
|
|
|
*/
|
|
|
|
undo_err_handler_init(data->real);
|
|
|
|
|
|
|
|
*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;
|
|
|
|
/* Before closing write the file system identity */
|
|
|
|
retval = write_file_system_identity(channel, data->tdb);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
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;
|
2008-06-07 19:53:56 +04:00
|
|
|
errcode_t retval = 0;
|
2007-08-13 14:26:21 +04:00
|
|
|
|
|
|
|
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);
|
|
|
|
/*
|
|
|
|
* Set the block size used for tdb
|
|
|
|
*/
|
|
|
|
if (!data->tdb_data_size) {
|
|
|
|
data->tdb_data_size = blksize;
|
|
|
|
}
|
|
|
|
channel->block_size = blksize;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2009-07-12 08:53:57 +04:00
|
|
|
static errcode_t undo_read_blk64(io_channel channel, unsigned long long block,
|
2007-08-13 14:26:21 +04:00
|
|
|
int count, void *buf)
|
|
|
|
{
|
2008-06-07 19:53:56 +04:00
|
|
|
errcode_t retval = 0;
|
2007-08-13 14:26:21 +04:00
|
|
|
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)
|
2009-07-12 08:53:57 +04:00
|
|
|
retval = io_channel_read_blk64(data->real, block, count, buf);
|
2007-08-13 14:26:21 +04:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2009-07-12 08:53:57 +04:00
|
|
|
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,
|
2007-08-13 14:26:21 +04:00
|
|
|
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)
|
2009-07-12 08:53:57 +04:00
|
|
|
retval = io_channel_write_blk64(data->real, block, count, buf);
|
2007-08-13 14:26:21 +04:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2009-07-12 08:53:57 +04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-08-13 14:26:21 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 (!data->tdb_data_size || !data->tdb_written) {
|
|
|
|
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;
|
|
|
|
}
|
2009-07-12 08:53:57 +04:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|