lib/ext2fs/undo_io.c

   1 /*
   2  * undo_io.c --- This is the undo io manager that copies the old data that
   3  * copies the old data being overwritten into a tdb database
   4  *
   5  * Copyright IBM Corporation, 2007
   6  * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
   7  *
   8  * %Begin-Header%
   9  * This file may be redistributed under the terms of the GNU Library
  10  * General Public License, version 2.
  11  * %End-Header%
  12  */
  13
  14 #ifndef _LARGEFILE_SOURCE
  15 #define _LARGEFILE_SOURCE
  16 #endif
  17 #ifndef _LARGEFILE64_SOURCE
  18 #define _LARGEFILE64_SOURCE
  19 #endif
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include <string.h>
  24 #if HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27 #if HAVE_ERRNO_H
  28 #include <errno.h>
  29 #endif
  30 #include <fcntl.h>
  31 #include <time.h>
  32 #ifdef __linux__
  33 #include <sys/utsname.h>
  34 #endif
  35 #if HAVE_SYS_STAT_H
  36 #include <sys/stat.h>
  37 #endif
  38 #if HAVE_SYS_TYPES_H
  39 #include <sys/types.h>
  40 #endif
  41 #if HAVE_SYS_RESOURCE_H
  42 #include <sys/resource.h>
  43 #endif
  44 #include <limits.h>
  45
  46 #include "ext2_fs.h"
  47 #include "ext2fs.h"
  48 #include "ext2fsP.h"
  49
  50 #ifdef __GNUC__
  51 #define ATTR(x) __attribute__(x)
  52 #else
  53 #define ATTR(x)
  54 #endif
  55
  56 #undef DEBUG
  57
  58 #ifdef DEBUG
  59 # define dbg_printf(f, a...)  do {printf(f, ## a); fflush(stdout); } while (0)
  60 #else
  61 # define dbg_printf(f, a...)
  62 #endif
  63
  64 /*
  65  * For checking structure magic numbers...
  66  */
  67
  68 #define EXT2_CHECK_MAGIC(struct, code) \
  69           if ((struct)->magic != (code)) return (code)
  70 /*
  71  * Undo file format: The file is cut up into undo_header.block_size blocks.
  72  * The first block contains the header.
  73  * The second block contains the superblock.
  74  * There is then a repeating series of blocks as follows:
  75  *   A key block, which contains undo_keys to map the following data blocks.
  76  *   Data blocks
  77  * (Note that there are pointers to the first key block and the sb, so this
  78  * order isn't strictly necessary.)
  79  */
  80 #define E2UNDO_MAGIC "E2UNDO02"
  81 #define KEYBLOCK_MAGIC 0xCADECADE
  82
  83 #define E2UNDO_STATE_FINISHED   0x1     /* undo file is complete */
  84
  85 #define E2UNDO_MIN_BLOCK_SIZE   1024    /* undo blocks are no less than 1KB */
  86 #define E2UNDO_MAX_BLOCK_SIZE   1048576 /* undo blocks are no more than 1MB */
  87
  88 struct undo_header {
  89         char magic[8];          /* "E2UNDO02" */
  90         __le64 num_keys;        /* how many keys? */
  91         __le64 super_offset;    /* where in the file is the superblock copy? */
  92         __le64 key_offset;      /* where do the key/data block chunks start? */
  93         __le32 block_size;      /* block size of the undo file */
  94         __le32 fs_block_size;   /* block size of the target device */
  95         __le32 sb_crc;          /* crc32c of the superblock */
  96         __le32 state;           /* e2undo state flags */
  97         __le32 f_compat;        /* compatible features */
  98         __le32 f_incompat;      /* incompatible features (none so far) */
  99         __le32 f_rocompat;      /* ro compatible features (none so far) */
 100         __le32 pad32;           /* padding for fs_offset */
 101         __le64 fs_offset;       /* filesystem offset */
 102         __u8 padding[436];      /* padding */
 103         __le32 header_crc;      /* crc32c of this header (but not this field) */
 104 };
 105
 106 #define E2UNDO_MAX_EXTENT_BLOCKS        512     /* max extent size, in blocks */
 107
 108 struct undo_key {
 109         __le64 fsblk;           /* where in the fs does the block go */
 110         __le32 blk_crc;         /* crc32c of the block */
 111         __le32 size;            /* how many bytes in this block? */
 112 };
 113
 114 struct undo_key_block {
 115         __le32 magic;           /* KEYBLOCK_MAGIC number */
 116         __le32 crc;             /* block checksum */
 117         __le64 reserved;        /* zero */
 118
 119 #if __STDC_VERSION__ >= 199901L
 120         struct undo_key keys[];         /* keys, which come immediately after */
 121 #else
 122         struct undo_key keys[0];        /* keys, which come immediately after */
 123 #endif
 124 };
 125
 126 struct undo_private_data {
 127         int     magic;
 128
 129         /* the undo file io channel */
 130         io_channel undo_file;
 131         blk64_t undo_blk_num;                   /* next free block */
 132         blk64_t key_blk_num;                    /* current key block location */
 133         blk64_t super_blk_num;                  /* superblock location */
 134         blk64_t first_key_blk;                  /* first key block location */
 135         struct undo_key_block *keyb;
 136         size_t num_keys, keys_in_block;
 137
 138         /* The backing io channel */
 139         io_channel real;
 140
 141         unsigned long long tdb_data_size;
 142         int tdb_written;
 143
 144         /* to support offset in unix I/O manager */
 145         ext2_loff_t offset;
 146
 147         ext2fs_block_bitmap written_block_map;
 148         struct struct_ext2_filsys fake_fs;
 149         char *tdb_file;
 150         struct undo_header hdr;
 151 };
 152 #define KEYS_PER_BLOCK(d) (((d)->tdb_data_size / sizeof(struct undo_key)) - 1)
 153
 154 #define E2UNDO_FEATURE_COMPAT_FS_OFFSET 0x1     /* the filesystem offset */
 155
 156 static inline void e2undo_set_feature_fs_offset(struct undo_header *header) {
 157         header->f_compat |= ext2fs_le32_to_cpu(E2UNDO_FEATURE_COMPAT_FS_OFFSET);
 158 }
 159
 160 static inline void e2undo_clear_feature_fs_offset(struct undo_header *header) {
 161         header->f_compat &= ~ext2fs_le32_to_cpu(E2UNDO_FEATURE_COMPAT_FS_OFFSET);
 162 }
 163
 164 static io_manager undo_io_backing_manager;
 165 static char *tdb_file;
 166 static int actual_size;
 167
 168 errcode_t set_undo_io_backing_manager(io_manager manager)
 169 {
 170         /*
 171          * We may want to do some validation later
 172          */
 173         undo_io_backing_manager = manager;
 174         return 0;
 175 }
 176
 177 errcode_t set_undo_io_backup_file(char *file_name)
 178 {
 179         tdb_file = strdup(file_name);
 180
 181         if (tdb_file == NULL) {
 182                 return EXT2_ET_NO_MEMORY;
 183         }
 184
 185         return 0;
 186 }
 187
 188 static errcode_t write_undo_indexes(struct undo_private_data *data, int flush)
 189 {
 190         errcode_t retval;
 191         struct ext2_super_block super;
 192         io_channel channel;
 193         int block_size;
 194         __u32 sb_crc, hdr_crc;
 195
 196         /* Spit out a key block, if there's any data */
 197         if (data->keys_in_block) {
 198                 data->keyb->magic = ext2fs_cpu_to_le32(KEYBLOCK_MAGIC);
 199                 data->keyb->crc = 0;
 200                 data->keyb->crc = ext2fs_cpu_to_le32(
 201                                          ext2fs_crc32c_le(~0,
 202                                          (unsigned char *)data->keyb,
 203                                          data->tdb_data_size));
 204                 dbg_printf("Writing keyblock to blk %llu\n", data->key_blk_num);
 205                 retval = io_channel_write_blk64(data->undo_file,
 206                                                 data->key_blk_num,
 207                                                 1, data->keyb);
 208                 if (retval)
 209                         return retval;
 210                 /* Move on to the next key block if it's full. */
 211                 if (data->keys_in_block == KEYS_PER_BLOCK(data)) {
 212                         memset(data->keyb, 0, data->tdb_data_size);
 213                         data->keys_in_block = 0;
 214                         data->key_blk_num = data->undo_blk_num;
 215                         data->undo_blk_num++;
 216                 }
 217         }
 218
 219         /* Prepare superblock for write */
 220         channel = data->real;
 221         block_size = channel->block_size;
 222
 223         io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);
 224         retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);
 225         if (retval)
 226                 goto err_out;
 227         sb_crc = ext2fs_crc32c_le(~0, (unsigned char *)&super, SUPERBLOCK_SIZE);
 228         super.s_magic = ~super.s_magic;
 229
 230         /* Write the undo header to disk. */
 231         memcpy(data->hdr.magic, E2UNDO_MAGIC, sizeof(data->hdr.magic));
 232         data->hdr.num_keys = ext2fs_cpu_to_le64(data->num_keys);
 233         data->hdr.super_offset = ext2fs_cpu_to_le64(data->super_blk_num);
 234         data->hdr.key_offset = ext2fs_cpu_to_le64(data->first_key_blk);
 235         data->hdr.fs_block_size = ext2fs_cpu_to_le32(block_size);
 236         data->hdr.sb_crc = ext2fs_cpu_to_le32(sb_crc);
 237         data->hdr.fs_offset = ext2fs_cpu_to_le64(data->offset);
 238         if (data->offset)
 239                 e2undo_set_feature_fs_offset(&data->hdr);
 240         else
 241                 e2undo_clear_feature_fs_offset(&data->hdr);
 242         hdr_crc = ext2fs_crc32c_le(~0, (unsigned char *)&data->hdr,
 243                                    sizeof(data->hdr) -
 244                                    sizeof(data->hdr.header_crc));
 245         data->hdr.header_crc = ext2fs_cpu_to_le32(hdr_crc);
 246         retval = io_channel_write_blk64(data->undo_file, 0,
 247                                         -(int)sizeof(data->hdr),
 248                                         &data->hdr);
 249         if (retval)
 250                 goto err_out;
 251
 252         /*
 253          * Record the entire superblock (in FS byte order) so that we can't
 254          * apply e2undo files to the wrong FS or out of order.
 255          */
 256         dbg_printf("Writing superblock to block %llu\n", data->super_blk_num);
 257         retval = io_channel_write_blk64(data->undo_file, data->super_blk_num,
 258                                         -SUPERBLOCK_SIZE, &super);
 259         if (retval)
 260                 goto err_out;
 261
 262         if (flush)
 263                 retval = io_channel_flush(data->undo_file);
 264 err_out:
 265         io_channel_set_blksize(channel, block_size);
 266         return retval;
 267 }
 268
 269 static errcode_t undo_setup_tdb(struct undo_private_data *data)
 270 {
 271         int i;
 272         errcode_t retval;
 273
 274         if (data->tdb_written == 1)
 275                 return 0;
 276
 277         data->tdb_written = 1;
 278
 279         /* Make a bitmap to track what we've written */
 280         memset(&data->fake_fs, 0, sizeof(data->fake_fs));
 281         data->fake_fs.blocksize = data->tdb_data_size;
 282         retval = ext2fs_alloc_generic_bmap(&data->fake_fs,
 283                                 EXT2_ET_MAGIC_BLOCK_BITMAP64,
 284                                 EXT2FS_BMAP64_RBTREE,
 285                                 0, ~1ULL, ~1ULL,
 286                                 "undo block map", &data->written_block_map);
 287         if (retval)
 288                 return retval;
 289
 290         /* Allocate key block */
 291         retval = ext2fs_get_mem(data->tdb_data_size, &data->keyb);
 292         if (retval)
 293                 return retval;
 294         data->key_blk_num = data->first_key_blk;
 295
 296         /* Record block size */
 297         dbg_printf("Undo block size %llu\n", data->tdb_data_size);
 298         dbg_printf("Keys per block %llu\n", KEYS_PER_BLOCK(data));
 299         data->hdr.block_size = ext2fs_cpu_to_le32(data->tdb_data_size);
 300         io_channel_set_blksize(data->undo_file, data->tdb_data_size);
 301
 302         /* Ensure that we have space for header blocks */
 303         for (i = 0; i <= 2; i++) {
 304                 retval = io_channel_read_blk64(data->undo_file, i, 1,
 305                                                data->keyb);
 306                 if (retval)
 307                         memset(data->keyb, 0, data->tdb_data_size);
 308                 retval = io_channel_write_blk64(data->undo_file, i, 1,
 309                                                 data->keyb);
 310                 if (retval)
 311                         return retval;
 312                 retval = io_channel_flush(data->undo_file);
 313                 if (retval)
 314                         return retval;
 315         }
 316         memset(data->keyb, 0, data->tdb_data_size);
 317         return 0;
 318 }
 319
 320 static errcode_t undo_write_tdb(io_channel channel,
 321                                 unsigned long long block, int count)
 322
 323 {
 324         int size, sz;
 325         unsigned long long block_num, backing_blk_num;
 326         errcode_t retval = 0;
 327         ext2_loff_t offset;
 328         struct undo_private_data *data;
 329         unsigned char *read_ptr;
 330         unsigned long long end_block;
 331         unsigned long long data_size;
 332         struct undo_key *key;
 333         __u32 blk_crc;
 334
 335         data = (struct undo_private_data *) channel->private_data;
 336
 337         if (data->undo_file == NULL) {
 338                 /*
 339                  * Transaction database not initialized
 340                  */
 341                 return 0;
 342         }
 343
 344         if (count == 1)
 345                 size = channel->block_size;
 346         else {
 347                 if (count < 0)
 348                         size = -count;
 349                 else
 350                         size = count * channel->block_size;
 351         }
 352
 353         retval = undo_setup_tdb(data);
 354         if (retval)
 355                 return retval;
 356         /*
 357          * Data is stored in tdb database as blocks of tdb_data_size size
 358          * This helps in efficient lookup further.
 359          *
 360          * We divide the disk to blocks of tdb_data_size.
 361          */
 362         offset = (block * channel->block_size) + data->offset ;
 363         block_num = offset / data->tdb_data_size;
 364         end_block = (offset + size - 1) / data->tdb_data_size;
 365
 366         while (block_num <= end_block) {
 367                 __u32 keysz;
 368
 369                 /*
 370                  * Check if we have the record already
 371                  */
 372                 if (ext2fs_test_block_bitmap2(data->written_block_map,
 373                                                    block_num)) {
 374                         /* Try the next block */
 375                         block_num++;
 376                         continue;
 377                 }
 378                 ext2fs_mark_block_bitmap2(data->written_block_map, block_num);
 379
 380                 /*
 381                  * Read one block using the backing I/O manager
 382                  * The backing I/O manager block size may be
 383                  * different from the tdb_data_size.
 384                  * Also we need to recalculate the block number with respect
 385                  * to the backing I/O manager.
 386                  */
 387                 offset = block_num * data->tdb_data_size +
 388                                 (data->offset % data->tdb_data_size);
 389                 backing_blk_num = (offset - data->offset) / channel->block_size;
 390
 391                 retval = ext2fs_get_mem(data->tdb_data_size, &read_ptr);
 392                 if (retval) {
 393                         return retval;
 394                 }
 395
 396                 memset(read_ptr, 0, data->tdb_data_size);
 397                 actual_size = 0;
 398                 if ((data->tdb_data_size % channel->block_size) == 0)
 399                         sz = data->tdb_data_size / channel->block_size;
 400                 else
 401                         sz = -data->tdb_data_size;
 402                 retval = io_channel_read_blk64(data->real, backing_blk_num,
 403                                              sz, read_ptr);
 404                 if (retval) {
 405                         if (retval != EXT2_ET_SHORT_READ) {
 406                                 free(read_ptr);
 407                                 return retval;
 408                         }
 409                         /*
 410                          * short read so update the record size
 411                          * accordingly
 412                          */
 413                         data_size = actual_size;
 414                 } else {
 415                         data_size = data->tdb_data_size;
 416                 }
 417                 if (data_size == 0) {
 418                         free(read_ptr);
 419                         block_num++;
 420                         continue;
 421                 }
 422                 dbg_printf("Read %llu bytes from FS block %llu (blk=%llu cnt=%llu)\n",
 423                        data_size, backing_blk_num, block, data->tdb_data_size);
 424                 if ((data_size % data->undo_file->block_size) == 0)
 425                         sz = data_size / data->undo_file->block_size;
 426                 else
 427                         sz = -data_size;;
 428                 /* extend this key? */
 429                 if (data->keys_in_block) {
 430                         key = data->keyb->keys + data->keys_in_block - 1;
 431                         keysz = ext2fs_le32_to_cpu(key->size);
 432                 } else {
 433                         key = NULL;
 434                         keysz = 0;
 435                 }
 436                 if (key != NULL &&
 437                     (ext2fs_le64_to_cpu(key->fsblk) * channel->block_size +
 438                      channel->block_size - 1 +
 439                      keysz) / channel->block_size == backing_blk_num &&
 440                     E2UNDO_MAX_EXTENT_BLOCKS * data->tdb_data_size >
 441                     keysz + data_size) {
 442                         blk_crc = ext2fs_le32_to_cpu(key->blk_crc);
 443                         blk_crc = ext2fs_crc32c_le(blk_crc, read_ptr, data_size);
 444                         key->blk_crc = ext2fs_cpu_to_le32(blk_crc);
 445                         key->size = ext2fs_cpu_to_le32(keysz + data_size);
 446                 } else {
 447                         data->num_keys++;
 448                         key = data->keyb->keys + data->keys_in_block;
 449                         data->keys_in_block++;
 450                         key->fsblk = ext2fs_cpu_to_le64(backing_blk_num);
 451                         blk_crc = ext2fs_crc32c_le(~0, read_ptr, data_size);
 452                         key->blk_crc = ext2fs_cpu_to_le32(blk_crc);
 453                         key->size = ext2fs_cpu_to_le32(data_size);
 454                 }
 455                 dbg_printf("Writing block %llu to offset %llu size %d key %zu\n",
 456                        block_num,
 457                        data->undo_blk_num,
 458                        sz, data->num_keys - 1);
 459                 retval = io_channel_write_blk64(data->undo_file,
 460                                         data->undo_blk_num, sz, read_ptr);
 461                 if (retval) {
 462                         free(read_ptr);
 463                         return retval;
 464                 }
 465                 data->undo_blk_num++;
 466                 free(read_ptr);
 467
 468                 /* Write out the key block */
 469                 retval = write_undo_indexes(data, 0);
 470                 if (retval)
 471                         return retval;
 472
 473                 /* Next block */
 474                 block_num++;
 475         }
 476
 477         return retval;
 478 }
 479
 480 static errcode_t undo_io_read_error(io_channel channel ATTR((unused)),
 481                                     unsigned long block ATTR((unused)),
 482                                     int count ATTR((unused)),
 483                                     void *data ATTR((unused)),
 484                                     size_t size ATTR((unused)),
 485                                     int actual,
 486                                     errcode_t error ATTR((unused)))
 487 {
 488         actual_size = actual;
 489         return error;
 490 }
 491
 492 static void undo_err_handler_init(io_channel channel)
 493 {
 494         channel->read_error = undo_io_read_error;
 495 }
 496
 497 static int check_filesystem(struct undo_header *hdr, io_channel undo_file,
 498                             unsigned int blocksize, blk64_t super_block,
 499                             io_channel channel)
 500 {
 501         struct ext2_super_block super, *sb;
 502         char *buf;
 503         __u32 sb_crc;
 504         errcode_t retval;
 505
 506         io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);
 507         retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);
 508         if (retval)
 509                 return retval;
 510
 511         /*
 512          * Compare the FS and the undo file superblock so that we don't
 513          * append to something that doesn't match this FS.
 514          */
 515         retval = ext2fs_get_mem(blocksize, &buf);
 516         if (retval)
 517                 return retval;
 518         retval = io_channel_read_blk64(undo_file, super_block,
 519                                        -SUPERBLOCK_SIZE, buf);
 520         if (retval)
 521                 goto out;
 522         sb = (struct ext2_super_block *)buf;
 523         sb->s_magic = ~sb->s_magic;
 524         if (memcmp(&super, buf, sizeof(super))) {
 525                 retval = -1;
 526                 goto out;
 527         }
 528         sb_crc = ext2fs_crc32c_le(~0, (unsigned char *)buf, SUPERBLOCK_SIZE);
 529         if (ext2fs_le32_to_cpu(hdr->sb_crc) != sb_crc) {
 530                 retval = -1;
 531                 goto out;
 532         }
 533
 534 out:
 535         ext2fs_free_mem(&buf);
 536         return retval;
 537 }
 538
 539 /*
 540  * Try to re-open the undo file, so that we can resume where we left off.
 541  * That way, the user can pass the same undo file to various programs as
 542  * part of an FS upgrade instead of having to create multiple files and
 543  * then apply them in correct order.
 544  */
 545 static errcode_t try_reopen_undo_file(int undo_fd,
 546                                       struct undo_private_data *data)
 547 {
 548         struct undo_header hdr;
 549         struct undo_key *dkey;
 550         ext2fs_struct_stat statbuf;
 551         unsigned int blocksize, fs_blocksize;
 552         blk64_t super_block, lblk;
 553         size_t num_keys, keys_per_block, i;
 554         __u32 hdr_crc, key_crc;
 555         errcode_t retval;
 556
 557         /* Zero size already? */
 558         retval = ext2fs_fstat(undo_fd, &statbuf);
 559         if (retval)
 560                 goto bad_file;
 561         if (statbuf.st_size == 0)
 562                 goto out;
 563
 564         /* check the file header */
 565         retval = io_channel_read_blk64(data->undo_file, 0, -(int)sizeof(hdr),
 566                                        &hdr);
 567         if (retval)
 568                 goto bad_file;
 569
 570         if (memcmp(hdr.magic, E2UNDO_MAGIC,
 571                     sizeof(hdr.magic)))
 572                 goto bad_file;
 573         hdr_crc = ext2fs_crc32c_le(~0, (unsigned char *)&hdr,
 574                                    sizeof(struct undo_header) -
 575                                    sizeof(__u32));
 576         if (ext2fs_le32_to_cpu(hdr.header_crc) != hdr_crc)
 577                 goto bad_file;
 578         blocksize = ext2fs_le32_to_cpu(hdr.block_size);
 579         fs_blocksize = ext2fs_le32_to_cpu(hdr.fs_block_size);
 580         if (blocksize > E2UNDO_MAX_BLOCK_SIZE ||
 581             blocksize < E2UNDO_MIN_BLOCK_SIZE ||
 582             !blocksize || !fs_blocksize)
 583                 goto bad_file;
 584         super_block = ext2fs_le64_to_cpu(hdr.super_offset);
 585         num_keys = ext2fs_le64_to_cpu(hdr.num_keys);
 586         io_channel_set_blksize(data->undo_file, blocksize);
 587         /*
 588          * Do not compare hdr.f_compat with the available compatible
 589          * features set, because a "missing" compatible feature should
 590          * not cause any problems.
 591          */
 592         if (hdr.f_incompat || hdr.f_rocompat)
 593                 goto bad_file;
 594
 595         /* Superblock matches this FS? */
 596         if (check_filesystem(&hdr, data->undo_file, blocksize, super_block,
 597                              data->real) != 0) {
 598                 retval = EXT2_ET_UNDO_FILE_WRONG;
 599                 goto out;
 600         }
 601
 602         /* Try to set ourselves up */
 603         data->tdb_data_size = blocksize;
 604         retval = undo_setup_tdb(data);
 605         if (retval)
 606                 goto bad_file;
 607         data->num_keys = num_keys;
 608         data->super_blk_num = super_block;
 609         data->first_key_blk = ext2fs_le64_to_cpu(hdr.key_offset);
 610
 611         /* load the written block map */
 612         keys_per_block = KEYS_PER_BLOCK(data);
 613         lblk = data->first_key_blk;
 614         dbg_printf("nr_keys=%lu, kpb=%zu, blksz=%u\n",
 615                    num_keys, keys_per_block, blocksize);
 616         for (i = 0; i < num_keys; i += keys_per_block) {
 617                 size_t j, max_j;
 618                 __le32 crc;
 619
 620                 data->key_blk_num = lblk;
 621                 retval = io_channel_read_blk64(data->undo_file,
 622                                                lblk, 1, data->keyb);
 623                 if (retval)
 624                         goto bad_key_replay;
 625
 626                 /* check keys */
 627                 if (ext2fs_le32_to_cpu(data->keyb->magic) != KEYBLOCK_MAGIC) {
 628                         retval = EXT2_ET_UNDO_FILE_CORRUPT;
 629                         goto bad_key_replay;
 630                 }
 631                 crc = data->keyb->crc;
 632                 data->keyb->crc = 0;
 633                 key_crc = ext2fs_crc32c_le(~0, (unsigned char *)data->keyb,
 634                                            blocksize);
 635                 if (ext2fs_le32_to_cpu(crc) != key_crc) {
 636                         retval = EXT2_ET_UNDO_FILE_CORRUPT;
 637                         goto bad_key_replay;
 638                 }
 639
 640                 /* load keys from key block */
 641                 lblk++;
 642                 max_j = data->num_keys - i;
 643                 if (max_j > keys_per_block)
 644                         max_j = keys_per_block;
 645                 for (j = 0, dkey = data->keyb->keys;
 646                      j < max_j;
 647                      j++, dkey++) {
 648                         blk64_t fsblk = ext2fs_le64_to_cpu(dkey->fsblk);
 649                         blk64_t undo_blk = fsblk * fs_blocksize / blocksize;
 650                         size_t size = ext2fs_le32_to_cpu(dkey->size);
 651
 652                         ext2fs_mark_block_bitmap_range2(data->written_block_map,
 653                                          undo_blk,
 654                                         (size + blocksize - 1) / blocksize);
 655                         lblk += (size + blocksize - 1) / blocksize;
 656                         data->undo_blk_num = lblk;
 657                         data->keys_in_block = j + 1;
 658                 }
 659         }
 660         dbg_printf("Reopen undo, keyblk=%llu undoblk=%llu nrkeys=%zu kib=%zu\n",
 661                    data->key_blk_num, data->undo_blk_num, data->num_keys,
 662                    data->keys_in_block);
 663
 664         data->hdr.state = hdr.state & ~E2UNDO_STATE_FINISHED;
 665         data->hdr.f_compat = hdr.f_compat;
 666         data->hdr.f_incompat = hdr.f_incompat;
 667         data->hdr.f_rocompat = hdr.f_rocompat;
 668         return retval;
 669
 670 bad_key_replay:
 671         data->key_blk_num = data->undo_blk_num = 0;
 672         data->keys_in_block = 0;
 673         ext2fs_free_mem(&data->keyb);
 674         ext2fs_free_generic_bitmap(data->written_block_map);
 675         data->tdb_written = 0;
 676         goto out;
 677 bad_file:
 678         retval = EXT2_ET_UNDO_FILE_CORRUPT;
 679 out:
 680         return retval;
 681 }
 682
 683 static void undo_atexit(void *p)
 684 {
 685         struct undo_private_data *data = p;
 686         errcode_t err;
 687
 688         err = write_undo_indexes(data, 1);
 689         io_channel_close(data->undo_file);
 690
 691         com_err(data->tdb_file, err, "while force-closing undo file");
 692 }
 693
 694 static errcode_t undo_open(const char *name, int flags, io_channel *channel)
 695 {
 696         io_channel      io = NULL;
 697         struct undo_private_data *data = NULL;
 698         int             undo_fd = -1;
 699         errcode_t       retval;
 700
 701         /* We don't support multi-threading, at least for now */
 702         flags &= ~IO_FLAG_THREADS;
 703         if (name == 0)
 704                 return EXT2_ET_BAD_DEVICE_NAME;
 705         retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io);
 706         if (retval)
 707                 goto cleanup;
 708         memset(io, 0, sizeof(struct struct_io_channel));
 709         io->magic = EXT2_ET_MAGIC_IO_CHANNEL;
 710         retval = ext2fs_get_mem(sizeof(struct undo_private_data), &data);
 711         if (retval)
 712                 goto cleanup;
 713
 714         io->manager = undo_io_manager;
 715         retval = ext2fs_get_mem(strlen(name)+1, &io->name);
 716         if (retval)
 717                 goto cleanup;
 718
 719         strcpy(io->name, name);
 720         io->private_data = data;
 721         io->block_size = 1024;
 722         io->read_error = 0;
 723         io->write_error = 0;
 724         io->refcount = 1;
 725
 726         memset(data, 0, sizeof(struct undo_private_data));
 727         data->magic = EXT2_ET_MAGIC_UNIX_IO_CHANNEL;
 728         data->super_blk_num = 1;
 729         data->first_key_blk = 2;
 730         data->undo_blk_num = 3;
 731
 732         if (undo_io_backing_manager) {
 733                 retval = undo_io_backing_manager->open(name, flags,
 734                                                        &data->real);
 735                 if (retval)
 736                         goto cleanup;
 737
 738                 data->tdb_file = strdup(tdb_file);
 739                 if (data->tdb_file == NULL)
 740                         goto cleanup;
 741                 undo_fd = ext2fs_open_file(data->tdb_file, O_RDWR | O_CREAT,
 742                                            0600);
 743                 if (undo_fd < 0)
 744                         goto cleanup;
 745
 746                 retval = undo_io_backing_manager->open(data->tdb_file,
 747                                                        IO_FLAG_RW,
 748                                                        &data->undo_file);
 749                 if (retval)
 750                         goto cleanup;
 751         } else {
 752                 data->real = NULL;
 753                 data->undo_file = NULL;
 754         }
 755
 756         if (data->real)
 757                 io->flags = (io->flags & ~CHANNEL_FLAGS_DISCARD_ZEROES) |
 758                             (data->real->flags & CHANNEL_FLAGS_DISCARD_ZEROES);
 759
 760         /*
 761          * setup err handler for read so that we know
 762          * when the backing manager fails do short read
 763          */
 764         if (data->real)
 765                 undo_err_handler_init(data->real);
 766
 767         if (data->undo_file) {
 768                 retval = try_reopen_undo_file(undo_fd, data);
 769                 if (retval)
 770                         goto cleanup;
 771         }
 772         retval = ext2fs_add_exit_fn(undo_atexit, data);
 773         if (retval)
 774                 goto cleanup;
 775
 776         *channel = io;
 777         if (undo_fd >= 0)
 778                 close(undo_fd);
 779         return retval;
 780
 781 cleanup:
 782         ext2fs_remove_exit_fn(undo_atexit, data);
 783         if (undo_fd >= 0)
 784                 close(undo_fd);
 785         if (data && data->undo_file)
 786                 io_channel_close(data->undo_file);
 787         if (data && data->tdb_file)
 788                 free(data->tdb_file);
 789         if (data && data->real)
 790                 io_channel_close(data->real);
 791         if (data)
 792                 ext2fs_free_mem(&data);
 793         if (io)
 794                 ext2fs_free_mem(&io);
 795         return retval;
 796 }
 797
 798 static errcode_t undo_close(io_channel channel)
 799 {
 800         struct undo_private_data *data;
 801         errcode_t       err, retval = 0;
 802
 803         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 804         data = (struct undo_private_data *) channel->private_data;
 805         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
 806
 807         if (--channel->refcount > 0)
 808                 return 0;
 809         /* Before closing write the file system identity */
 810         if (!getenv("UNDO_IO_SIMULATE_UNFINISHED"))
 811                 data->hdr.state = ext2fs_cpu_to_le32(E2UNDO_STATE_FINISHED);
 812         err = write_undo_indexes(data, 1);
 813         ext2fs_remove_exit_fn(undo_atexit, data);
 814         if (data->real)
 815                 retval = io_channel_close(data->real);
 816         if (data->tdb_file)
 817                 free(data->tdb_file);
 818         if (data->undo_file)
 819                 io_channel_close(data->undo_file);
 820         ext2fs_free_mem(&data->keyb);
 821         if (data->written_block_map)
 822                 ext2fs_free_generic_bitmap(data->written_block_map);
 823         ext2fs_free_mem(&channel->private_data);
 824         if (channel->name)
 825                 ext2fs_free_mem(&channel->name);
 826         ext2fs_free_mem(&channel);
 827
 828         if (err)
 829                 return err;
 830         return retval;
 831 }
 832
 833 static errcode_t undo_set_blksize(io_channel channel, int blksize)
 834 {
 835         struct undo_private_data *data;
 836         errcode_t               retval = 0;
 837
 838         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 839         data = (struct undo_private_data *) channel->private_data;
 840         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
 841
 842         if (blksize > E2UNDO_MAX_BLOCK_SIZE || blksize < E2UNDO_MIN_BLOCK_SIZE)
 843                 return EXT2_ET_INVALID_ARGUMENT;
 844
 845         if (data->real)
 846                 retval = io_channel_set_blksize(data->real, blksize);
 847         /*
 848          * Set the block size used for tdb
 849          */
 850         if (!data->tdb_data_size || !data->tdb_written)
 851                 data->tdb_data_size = blksize;
 852         channel->block_size = blksize;
 853         return retval;
 854 }
 855
 856 static errcode_t undo_read_blk64(io_channel channel, unsigned long long block,
 857                                int count, void *buf)
 858 {
 859         errcode_t       retval = 0;
 860         struct undo_private_data *data;
 861
 862         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 863         data = (struct undo_private_data *) channel->private_data;
 864         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
 865
 866         if (data->real)
 867                 retval = io_channel_read_blk64(data->real, block, count, buf);
 868
 869         return retval;
 870 }
 871
 872 static errcode_t undo_read_blk(io_channel channel, unsigned long block,
 873                                int count, void *buf)
 874 {
 875         return undo_read_blk64(channel, block, count, buf);
 876 }
 877
 878 static errcode_t undo_write_blk64(io_channel channel, unsigned long long block,
 879                                 int count, const void *buf)
 880 {
 881         struct undo_private_data *data;
 882         errcode_t       retval = 0;
 883
 884         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 885         data = (struct undo_private_data *) channel->private_data;
 886         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
 887         /*
 888          * First write the existing content into database
 889          */
 890         retval = undo_write_tdb(channel, block, count);
 891         if (retval)
 892                  return retval;
 893         if (data->real)
 894                 retval = io_channel_write_blk64(data->real, block, count, buf);
 895
 896         return retval;
 897 }
 898
 899 static errcode_t undo_write_blk(io_channel channel, unsigned long block,
 900                                 int count, const void *buf)
 901 {
 902         return undo_write_blk64(channel, block, count, buf);
 903 }
 904
 905 static errcode_t undo_write_byte(io_channel channel, unsigned long offset,
 906                                  int size, const void *buf)
 907 {
 908         struct undo_private_data *data;
 909         errcode_t       retval = 0;
 910         ext2_loff_t     location;
 911         unsigned long blk_num, count;;
 912
 913         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 914         data = (struct undo_private_data *) channel->private_data;
 915         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
 916
 917         location = offset + data->offset;
 918         blk_num = location/channel->block_size;
 919         /*
 920          * the size specified may spread across multiple blocks
 921          * also make sure we account for the fact that block start
 922          * offset for tdb is different from the backing I/O manager
 923          * due to possible different block size
 924          */
 925         count = (size + (location % channel->block_size) +
 926                         channel->block_size  -1)/channel->block_size;
 927         retval = undo_write_tdb(channel, blk_num, count);
 928         if (retval)
 929                 return retval;
 930         if (data->real && data->real->manager->write_byte)
 931                 retval = io_channel_write_byte(data->real, offset, size, buf);
 932
 933         return retval;
 934 }
 935
 936 static errcode_t undo_discard(io_channel channel, unsigned long long block,
 937                               unsigned long long count)
 938 {
 939         struct undo_private_data *data;
 940         errcode_t       retval = 0;
 941         int icount;
 942
 943         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 944         data = (struct undo_private_data *) channel->private_data;
 945         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
 946
 947         if (count > INT_MAX)
 948                 return EXT2_ET_UNIMPLEMENTED;
 949         icount = count;
 950
 951         /*
 952          * First write the existing content into database
 953          */
 954         retval = undo_write_tdb(channel, block, icount);
 955         if (retval)
 956                 return retval;
 957         if (data->real)
 958                 retval = io_channel_discard(data->real, block, count);
 959
 960         return retval;
 961 }
 962
 963 static errcode_t undo_zeroout(io_channel channel, unsigned long long block,
 964                               unsigned long long count)
 965 {
 966         struct undo_private_data *data;
 967         errcode_t       retval = 0;
 968         int icount;
 969
 970         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 971         data = (struct undo_private_data *) channel->private_data;
 972         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
 973
 974         if (count > INT_MAX)
 975                 return EXT2_ET_UNIMPLEMENTED;
 976         icount = count;
 977
 978         /*
 979          * First write the existing content into database
 980          */
 981         retval = undo_write_tdb(channel, block, icount);
 982         if (retval)
 983                 return retval;
 984         if (data->real)
 985                 retval = io_channel_zeroout(data->real, block, count);
 986
 987         return retval;
 988 }
 989
 990 static errcode_t undo_cache_readahead(io_channel channel,
 991                                       unsigned long long block,
 992                                       unsigned long long count)
 993 {
 994         struct undo_private_data *data;
 995         errcode_t       retval = 0;
 996
 997         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 998         data = (struct undo_private_data *) channel->private_data;
 999         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
1000
1001         if (data->real)
1002                 retval = io_channel_cache_readahead(data->real, block, count);
1003
1004         return retval;
1005 }
1006
1007 /*
1008  * Flush data buffers to disk.
1009  */
1010 static errcode_t undo_flush(io_channel channel)
1011 {
1012         errcode_t       retval = 0;
1013         struct undo_private_data *data;
1014
1015         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
1016         data = (struct undo_private_data *) channel->private_data;
1017         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
1018
1019         if (data->real)
1020                 retval = io_channel_flush(data->real);
1021
1022         return retval;
1023 }
1024
1025 static errcode_t undo_set_option(io_channel channel, const char *option,
1026                                  const char *arg)
1027 {
1028         errcode_t       retval = 0;
1029         struct undo_private_data *data;
1030         unsigned long tmp;
1031         char *end;
1032
1033         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
1034         data = (struct undo_private_data *) channel->private_data;
1035         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
1036
1037         if (!strcmp(option, "tdb_data_size")) {
1038                 if (!arg)
1039                         return EXT2_ET_INVALID_ARGUMENT;
1040
1041                 tmp = strtoul(arg, &end, 0);
1042                 if (*end)
1043                         return EXT2_ET_INVALID_ARGUMENT;
1044                 if (tmp > E2UNDO_MAX_BLOCK_SIZE || tmp < E2UNDO_MIN_BLOCK_SIZE)
1045                         return EXT2_ET_INVALID_ARGUMENT;
1046                 if (!data->tdb_data_size || !data->tdb_written) {
1047                         data->tdb_written = -1;
1048                         data->tdb_data_size = tmp;
1049                 }
1050                 return 0;
1051         }
1052         /*
1053          * Need to support offset option to work with
1054          * Unix I/O manager
1055          */
1056         if (data->real && data->real->manager->set_option) {
1057                 retval = data->real->manager->set_option(data->real,
1058                                                         option, arg);
1059         }
1060         if (!retval && !strcmp(option, "offset")) {
1061                 if (!arg)
1062                         return EXT2_ET_INVALID_ARGUMENT;
1063
1064                 tmp = strtoul(arg, &end, 0);
1065                 if (*end)
1066                         return EXT2_ET_INVALID_ARGUMENT;
1067                 data->offset = tmp;
1068         }
1069         return retval;
1070 }
1071
1072 static errcode_t undo_get_stats(io_channel channel, io_stats *stats)
1073 {
1074         errcode_t       retval = 0;
1075         struct undo_private_data *data;
1076
1077         EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
1078         data = (struct undo_private_data *) channel->private_data;
1079         EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
1080
1081         if (data->real)
1082                 retval = (data->real->manager->get_stats)(data->real, stats);
1083
1084         return retval;
1085 }
1086
1087 static struct struct_io_manager struct_undo_manager = {
1088         .magic          = EXT2_ET_MAGIC_IO_MANAGER,
1089         .name           = "Undo I/O Manager",
1090         .open           = undo_open,
1091         .close          = undo_close,
1092         .set_blksize    = undo_set_blksize,
1093         .read_blk       = undo_read_blk,
1094         .write_blk      = undo_write_blk,
1095         .flush          = undo_flush,
1096         .write_byte     = undo_write_byte,
1097         .set_option     = undo_set_option,
1098         .get_stats      = undo_get_stats,
1099         .read_blk64     = undo_read_blk64,
1100         .write_blk64    = undo_write_blk64,
1101         .discard        = undo_discard,
1102         .zeroout        = undo_zeroout,
1103         .cache_readahead        = undo_cache_readahead,
1104 };
1105
1106 io_manager undo_io_manager = &struct_undo_manager;