misc/e2undo.c

   1 /*
   2  * e2undo.c - Replay an undo log onto an ext2/3/4 filesystem
   3  *
   4  * Copyright IBM Corporation, 2007
   5  * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
   6  *
   7  * %Begin-Header%
   8  * This file may be redistributed under the terms of the GNU Public
   9  * License.
  10  * %End-Header%
  11  */
  12
  13 #include "config.h"
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #ifdef HAVE_GETOPT_H
  17 #include <getopt.h>
  18 #endif
  19 #include <fcntl.h>
  20 #if HAVE_ERRNO_H
  21 #include <errno.h>
  22 #endif
  23 #include <unistd.h>
  24 #include <libgen.h>
  25 #include "ext2fs/ext2fs.h"
  26 #include "support/nls-enable.h"
  27
  28 #undef DEBUG
  29
  30 #ifdef DEBUG
  31 # define dbg_printf(f, a...)  do {printf(f, ## a); fflush(stdout); } while (0)
  32 #else
  33 # define dbg_printf(f, a...)
  34 #endif
  35
  36 /*
  37  * Undo file format: The file is cut up into undo_header.block_size blocks.
  38  * The first block contains the header.
  39  * The second block contains the superblock.
  40  * There is then a repeating series of blocks as follows:
  41  *   A key block, which contains undo_keys to map the following data blocks.
  42  *   Data blocks
  43  * (Note that there are pointers to the first key block and the sb, so this
  44  * order isn't strictly necessary.)
  45  */
  46 #define E2UNDO_MAGIC "E2UNDO02"
  47 #define KEYBLOCK_MAGIC 0xCADECADE
  48
  49 #define E2UNDO_STATE_FINISHED   0x1     /* undo file is complete */
  50
  51 #define E2UNDO_MIN_BLOCK_SIZE   1024    /* undo blocks are no less than 1KB */
  52 #define E2UNDO_MAX_BLOCK_SIZE   1048576 /* undo blocks are no more than 1MB */
  53
  54 struct undo_header {
  55         char magic[8];          /* "E2UNDO02" */
  56         __le64 num_keys;        /* how many keys? */
  57         __le64 super_offset;    /* where in the file is the superblock copy? */
  58         __le64 key_offset;      /* where do the key/data block chunks start? */
  59         __le32 block_size;      /* block size of the undo file */
  60         __le32 fs_block_size;   /* block size of the target device */
  61         __le32 sb_crc;          /* crc32c of the superblock */
  62         __le32 state;           /* e2undo state flags */
  63         __le32 f_compat;        /* compatible features (none so far) */
  64         __le32 f_incompat;      /* incompatible features (none so far) */
  65         __le32 f_rocompat;      /* ro compatible features (none so far) */
  66         __le32 pad32;           /* padding for fs_offset */
  67         __le64 fs_offset;       /* filesystem offset */
  68         __u8 padding[436];      /* padding */
  69         __le32 header_crc;      /* crc32c of the header (but not this field) */
  70 };
  71
  72 #define E2UNDO_MAX_EXTENT_BLOCKS        512     /* max extent size, in blocks */
  73
  74 struct undo_key {
  75         __le64 fsblk;           /* where in the fs does the block go */
  76         __le32 blk_crc;         /* crc32c of the block */
  77         __le32 size;            /* how many bytes in this block? */
  78 };
  79
  80 struct undo_key_block {
  81         __le32 magic;           /* KEYBLOCK_MAGIC number */
  82         __le32 crc;             /* block checksum */
  83         __le64 reserved;        /* zero */
  84 #if __GNUC_PREREQ (4, 8)
  85 #pragma GCC diagnostic push
  86 #pragma GCC diagnostic ignored "-Wpedantic"
  87 #endif
  88         struct undo_key keys[0];        /* keys, which come immediately after */
  89 #if __GNUC_PREREQ (4, 8)
  90 #pragma GCC diagnostic pop
  91 #endif
  92 };
  93
  94 struct undo_key_info {
  95         blk64_t fsblk;
  96         blk64_t fileblk;
  97         __u32 blk_crc;
  98         unsigned int size;
  99 };
 100
 101 struct undo_context {
 102         struct undo_header hdr;
 103         io_channel undo_file;
 104         unsigned int blocksize, fs_blocksize;
 105         blk64_t super_block;
 106         size_t num_keys;
 107         struct undo_key_info *keys;
 108 };
 109 #define KEYS_PER_BLOCK(d) (((d)->blocksize / sizeof(struct undo_key)) - 1)
 110
 111 #define E2UNDO_FEATURE_COMPAT_FS_OFFSET 0x1     /* the filesystem offset */
 112
 113 static inline int e2undo_has_feature_fs_offset(struct undo_header *header) {
 114         return ext2fs_le32_to_cpu(header->f_compat) &
 115                 E2UNDO_FEATURE_COMPAT_FS_OFFSET;
 116 }
 117
 118 static char *prg_name;
 119 static char *undo_file;
 120
 121 static void usage(void)
 122 {
 123         fprintf(stderr,
 124                 _("Usage: %s [-f] [-h] [-n] [-o offset] [-v] [-z undo_file] <transaction file> <filesystem>\n"), prg_name);
 125         exit(1);
 126 }
 127
 128 static void dump_header(struct undo_header *hdr)
 129 {
 130         printf("nr keys:\t%llu\n",
 131                (unsigned long long) ext2fs_le64_to_cpu(hdr->num_keys));
 132         printf("super block:\t%llu\n",
 133                (unsigned long long) ext2fs_le64_to_cpu(hdr->super_offset));
 134         printf("key block:\t%llu\n",
 135                (unsigned long long) ext2fs_le64_to_cpu(hdr->key_offset));
 136         printf("block size:\t%u\n", ext2fs_le32_to_cpu(hdr->block_size));
 137         printf("fs block size:\t%u\n", ext2fs_le32_to_cpu(hdr->fs_block_size));
 138         printf("super crc:\t0x%x\n", ext2fs_le32_to_cpu(hdr->sb_crc));
 139         printf("state:\t\t0x%x\n", ext2fs_le32_to_cpu(hdr->state));
 140         printf("compat:\t\t0x%x\n", ext2fs_le32_to_cpu(hdr->f_compat));
 141         printf("incompat:\t0x%x\n", ext2fs_le32_to_cpu(hdr->f_incompat));
 142         printf("rocompat:\t0x%x\n", ext2fs_le32_to_cpu(hdr->f_rocompat));
 143         if (e2undo_has_feature_fs_offset(hdr))
 144                 printf("fs offset:\t%llu\n",
 145                        (unsigned long long) ext2fs_le64_to_cpu(hdr->fs_offset));
 146         printf("header crc:\t0x%x\n", ext2fs_le32_to_cpu(hdr->header_crc));
 147 }
 148
 149 static void print_undo_mismatch(struct ext2_super_block *fs_super,
 150                                 struct ext2_super_block *undo_super)
 151 {
 152         printf("%s",
 153                _("The file system superblock doesn't match the undo file.\n"));
 154         if (memcmp(fs_super->s_uuid, undo_super->s_uuid,
 155                    sizeof(fs_super->s_uuid)))
 156                 printf("%s", _("UUID does not match.\n"));
 157         if (fs_super->s_mtime != undo_super->s_mtime)
 158                 printf("%s", _("Last mount time does not match.\n"));
 159         if (fs_super->s_wtime != undo_super->s_wtime)
 160                 printf("%s", _("Last write time does not match.\n"));
 161         if (fs_super->s_kbytes_written != undo_super->s_kbytes_written)
 162                 printf("%s", _("Lifetime write counter does not match.\n"));
 163 }
 164
 165 static int check_filesystem(struct undo_context *ctx, io_channel channel)
 166 {
 167         struct ext2_super_block super, *sb;
 168         char *buf;
 169         __u32 sb_crc;
 170         errcode_t retval;
 171
 172         io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);
 173         retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);
 174         if (retval) {
 175                 com_err(prg_name, retval,
 176                         "%s", _("while reading filesystem superblock."));
 177                 return retval;
 178         }
 179
 180         /*
 181          * Compare the FS and the undo file superblock so that we can't apply
 182          * e2undo "patches" out of order.
 183          */
 184         retval = ext2fs_get_mem(ctx->blocksize, &buf);
 185         if (retval) {
 186                 com_err(prg_name, retval, "%s", _("while allocating memory"));
 187                 return retval;
 188         }
 189         retval = io_channel_read_blk64(ctx->undo_file, ctx->super_block,
 190                                        -SUPERBLOCK_SIZE, buf);
 191         if (retval) {
 192                 com_err(prg_name, retval, "%s", _("while fetching superblock"));
 193                 goto out;
 194         }
 195         sb = (struct ext2_super_block *)buf;
 196         sb->s_magic = ~sb->s_magic;
 197         if (memcmp(&super, buf, sizeof(super))) {
 198                 print_undo_mismatch(&super, (struct ext2_super_block *)buf);
 199                 retval = -1;
 200                 goto out;
 201         }
 202         sb_crc = ext2fs_crc32c_le(~0, (unsigned char *)buf, SUPERBLOCK_SIZE);
 203         if (ext2fs_le32_to_cpu(ctx->hdr.sb_crc) != sb_crc) {
 204                 fprintf(stderr,
 205                         _("Undo file superblock checksum doesn't match.\n"));
 206                 retval = -1;
 207                 goto out;
 208         }
 209
 210 out:
 211         ext2fs_free_mem(&buf);
 212         return retval;
 213 }
 214
 215 static int key_compare(const void *a, const void *b)
 216 {
 217         const struct undo_key_info *ka, *kb;
 218
 219         ka = a;
 220         kb = b;
 221         return ka->fsblk - kb->fsblk;
 222 }
 223
 224 static int e2undo_setup_tdb(const char *name, io_manager *io_ptr)
 225 {
 226         errcode_t retval = 0;
 227         const char *tdb_dir;
 228         char *tdb_file = NULL;
 229         char *dev_name, *tmp_name;
 230
 231         /* (re)open a specific undo file */
 232         if (undo_file && undo_file[0] != 0) {
 233                 retval = set_undo_io_backing_manager(*io_ptr);
 234                 if (retval)
 235                         goto err;
 236                 *io_ptr = undo_io_manager;
 237                 retval = set_undo_io_backup_file(undo_file);
 238                 if (retval)
 239                         goto err;
 240                 printf(_("Overwriting existing filesystem; this can be undone "
 241                          "using the command:\n"
 242                          "    e2undo %s %s\n\n"),
 243                          undo_file, name);
 244                 return retval;
 245         }
 246
 247         /*
 248          * Configuration via a conf file would be
 249          * nice
 250          */
 251         tdb_dir = getenv("E2FSPROGS_UNDO_DIR");
 252         if (!tdb_dir)
 253                 tdb_dir = "/var/lib/e2fsprogs";
 254
 255         if (!strcmp(tdb_dir, "none") || (tdb_dir[0] == 0) ||
 256             access(tdb_dir, W_OK))
 257                 return 0;
 258
 259         tmp_name = strdup(name);
 260         if (!tmp_name)
 261                 goto errout;
 262         dev_name = basename(tmp_name);
 263         tdb_file = malloc(strlen(tdb_dir) + 8 + strlen(dev_name) + 7 + 1);
 264         if (!tdb_file) {
 265                 free(tmp_name);
 266                 goto errout;
 267         }
 268         sprintf(tdb_file, "%s/e2undo-%s.e2undo", tdb_dir, dev_name);
 269         free(tmp_name);
 270
 271         if ((unlink(tdb_file) < 0) && (errno != ENOENT)) {
 272                 retval = errno;
 273                 com_err(prg_name, retval,
 274                         _("while trying to delete %s"), tdb_file);
 275                 goto errout;
 276         }
 277
 278         retval = set_undo_io_backing_manager(*io_ptr);
 279         if (retval)
 280                 goto errout;
 281         *io_ptr = undo_io_manager;
 282         retval = set_undo_io_backup_file(tdb_file);
 283         if (retval)
 284                 goto errout;
 285         printf(_("Overwriting existing filesystem; this can be undone "
 286                  "using the command:\n"
 287                  "    e2undo %s %s\n\n"),
 288                  tdb_file, name);
 289
 290         free(tdb_file);
 291         return 0;
 292 errout:
 293         free(tdb_file);
 294 err:
 295         com_err(prg_name, retval, "while trying to setup undo file\n");
 296         return retval;
 297 }
 298
 299 int main(int argc, char *argv[])
 300 {
 301         int c, force = 0, dry_run = 0, verbose = 0, dump = 0;
 302         io_channel channel;
 303         errcode_t retval;
 304         int mount_flags, csum_error = 0, io_error = 0;
 305         size_t i, keys_per_block;
 306         char *device_name, *tdb_file;
 307         io_manager manager = unix_io_manager;
 308         struct undo_context undo_ctx;
 309         char *buf;
 310         struct undo_key_block *keyb;
 311         struct undo_key *dkey;
 312         struct undo_key_info *ikey;
 313         __u32 key_crc, blk_crc, hdr_crc;
 314         blk64_t lblk;
 315         ext2_filsys fs;
 316         __u64 offset = 0;
 317         char opt_offset_string[40] = { 0 };
 318
 319 #ifdef ENABLE_NLS
 320         setlocale(LC_MESSAGES, "");
 321         setlocale(LC_CTYPE, "");
 322         bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
 323         textdomain(NLS_CAT_NAME);
 324         set_com_err_gettext(gettext);
 325 #endif
 326         add_error_table(&et_ext2_error_table);
 327
 328         prg_name = argv[0];
 329         while ((c = getopt(argc, argv, "fhno:vz:")) != EOF) {
 330                 switch (c) {
 331                 case 'f':
 332                         force = 1;
 333                         break;
 334                 case 'h':
 335                         dump = 1;
 336                         break;
 337                 case 'n':
 338                         dry_run = 1;
 339                         break;
 340                 case 'o':
 341                         offset = strtoull(optarg, &buf, 0);
 342                         if (*buf) {
 343                                 com_err(prg_name, 0,
 344                                                 _("illegal offset - %s"), optarg);
 345                                 exit(1);
 346                         }
 347                         /* used to indicate that an offset was specified */
 348                         opt_offset_string[0] = 1;
 349                         break;
 350                 case 'v':
 351                         verbose = 1;
 352                         break;
 353                 case 'z':
 354                         undo_file = optarg;
 355                         break;
 356                 default:
 357                         usage();
 358                 }
 359         }
 360
 361         if (argc != optind + 2)
 362                 usage();
 363
 364         tdb_file = argv[optind];
 365         device_name = argv[optind+1];
 366
 367         if (undo_file && strcmp(tdb_file, undo_file) == 0) {
 368                 printf(_("Will not write to an undo file while replaying it.\n"));
 369                 exit(1);
 370         }
 371
 372         /* Interpret the undo file */
 373         retval = manager->open(tdb_file, IO_FLAG_EXCLUSIVE,
 374                                &undo_ctx.undo_file);
 375         if (retval) {
 376                 com_err(prg_name, errno,
 377                                 _("while opening undo file `%s'\n"), tdb_file);
 378                 exit(1);
 379         }
 380         retval = io_channel_read_blk64(undo_ctx.undo_file, 0,
 381                                        -(int)sizeof(undo_ctx.hdr),
 382                                        &undo_ctx.hdr);
 383         if (retval) {
 384                 com_err(prg_name, retval, _("while reading undo file"));
 385                 exit(1);
 386         }
 387         if (memcmp(undo_ctx.hdr.magic, E2UNDO_MAGIC,
 388                     sizeof(undo_ctx.hdr.magic))) {
 389                 fprintf(stderr, _("%s: Not an undo file.\n"), tdb_file);
 390                 exit(1);
 391         }
 392         if (dump) {
 393                 dump_header(&undo_ctx.hdr);
 394                 exit(1);
 395         }
 396         hdr_crc = ext2fs_crc32c_le(~0, (unsigned char *)&undo_ctx.hdr,
 397                                    sizeof(struct undo_header) -
 398                                    sizeof(__u32));
 399         if (!force && ext2fs_le32_to_cpu(undo_ctx.hdr.header_crc) != hdr_crc) {
 400                 fprintf(stderr, _("%s: Header checksum doesn't match.\n"),
 401                         tdb_file);
 402                 exit(1);
 403         }
 404         undo_ctx.blocksize = ext2fs_le32_to_cpu(undo_ctx.hdr.block_size);
 405         undo_ctx.fs_blocksize = ext2fs_le32_to_cpu(undo_ctx.hdr.fs_block_size);
 406         if (undo_ctx.blocksize == 0 || undo_ctx.fs_blocksize == 0) {
 407                 fprintf(stderr, _("%s: Corrupt undo file header.\n"), tdb_file);
 408                 exit(1);
 409         }
 410         if (!force && undo_ctx.blocksize > E2UNDO_MAX_BLOCK_SIZE) {
 411                 fprintf(stderr, _("%s: Undo block size too large.\n"),
 412                         tdb_file);
 413                 exit(1);
 414         }
 415         if (!force && undo_ctx.blocksize < E2UNDO_MIN_BLOCK_SIZE) {
 416                 fprintf(stderr, _("%s: Undo block size too small.\n"),
 417                         tdb_file);
 418                 exit(1);
 419         }
 420         undo_ctx.super_block = ext2fs_le64_to_cpu(undo_ctx.hdr.super_offset);
 421         undo_ctx.num_keys = ext2fs_le64_to_cpu(undo_ctx.hdr.num_keys);
 422         io_channel_set_blksize(undo_ctx.undo_file, undo_ctx.blocksize);
 423         /*
 424          * Do not compare undo_ctx.hdr.f_compat with the available compatible
 425          * features set, because a "missing" compatible feature should
 426          * not cause any problems.
 427          */
 428         if (!force && (undo_ctx.hdr.f_incompat || undo_ctx.hdr.f_rocompat)) {
 429                 fprintf(stderr, _("%s: Unknown undo file feature set.\n"),
 430                         tdb_file);
 431                 exit(1);
 432         }
 433
 434         /* open the fs */
 435         retval = ext2fs_check_if_mounted(device_name, &mount_flags);
 436         if (retval) {
 437                 com_err(prg_name, retval, _("Error while determining whether "
 438                                 "%s is mounted."), device_name);
 439                 exit(1);
 440         }
 441
 442         if (mount_flags & EXT2_MF_MOUNTED) {
 443                 com_err(prg_name, retval, "%s", _("e2undo should only be run "
 444                                                 "on unmounted filesystems"));
 445                 exit(1);
 446         }
 447
 448         if (undo_file) {
 449                 retval = e2undo_setup_tdb(device_name, &manager);
 450                 if (retval)
 451                         exit(1);
 452         }
 453
 454         retval = manager->open(device_name,
 455                                IO_FLAG_EXCLUSIVE | (dry_run ? 0 : IO_FLAG_RW),
 456                                &channel);
 457         if (retval) {
 458                 com_err(prg_name, retval,
 459                                 _("while opening `%s'"), device_name);
 460                 exit(1);
 461         }
 462
 463         if (*opt_offset_string || e2undo_has_feature_fs_offset(&undo_ctx.hdr)) {
 464                 if (!*opt_offset_string)
 465                         offset = ext2fs_le64_to_cpu(undo_ctx.hdr.fs_offset);
 466                 retval = snprintf(opt_offset_string, sizeof(opt_offset_string),
 467                                   "offset=%llu", (unsigned long long) offset);
 468                 if ((size_t) retval >= sizeof(opt_offset_string)) {
 469                         /* should not happen... */
 470                         com_err(prg_name, 0, _("specified offset is too large"));
 471                         exit(1);
 472                 }
 473                 io_channel_set_options(channel, opt_offset_string);
 474         }
 475
 476         if (!force && check_filesystem(&undo_ctx, channel))
 477                 exit(1);
 478
 479         /* prepare to read keys */
 480         retval = ext2fs_get_mem(sizeof(struct undo_key_info) * undo_ctx.num_keys,
 481                                 &undo_ctx.keys);
 482         if (retval) {
 483                 com_err(prg_name, retval, "%s", _("while allocating memory"));
 484                 exit(1);
 485         }
 486         ikey = undo_ctx.keys;
 487         retval = ext2fs_get_mem(undo_ctx.blocksize, &keyb);
 488         if (retval) {
 489                 com_err(prg_name, retval, "%s", _("while allocating memory"));
 490                 exit(1);
 491         }
 492         retval = ext2fs_get_mem(E2UNDO_MAX_EXTENT_BLOCKS * undo_ctx.blocksize,
 493                                 &buf);
 494         if (retval) {
 495                 com_err(prg_name, retval, "%s", _("while allocating memory"));
 496                 exit(1);
 497         }
 498
 499         /* load keys */
 500         keys_per_block = KEYS_PER_BLOCK(&undo_ctx);
 501         lblk = ext2fs_le64_to_cpu(undo_ctx.hdr.key_offset);
 502         dbg_printf("nr_keys=%lu, kpb=%zu, blksz=%u\n",
 503                    undo_ctx.num_keys, keys_per_block, undo_ctx.blocksize);
 504         for (i = 0; i < undo_ctx.num_keys; i += keys_per_block) {
 505                 size_t j, max_j;
 506                 __le32 crc;
 507
 508                 retval = io_channel_read_blk64(undo_ctx.undo_file,
 509                                                lblk, 1, keyb);
 510                 if (retval) {
 511                         com_err(prg_name, retval, "%s", _("while reading keys"));
 512                         if (force) {
 513                                 io_error = 1;
 514                                 undo_ctx.num_keys = i - 1;
 515                                 break;
 516                         }
 517                         exit(1);
 518                 }
 519
 520                 /* check keys */
 521                 if (!force &&
 522                     ext2fs_le32_to_cpu(keyb->magic) != KEYBLOCK_MAGIC) {
 523                         fprintf(stderr, _("%s: wrong key magic at %llu\n"),
 524                                 tdb_file, (unsigned long long) lblk);
 525                         exit(1);
 526                 }
 527                 crc = keyb->crc;
 528                 keyb->crc = 0;
 529                 key_crc = ext2fs_crc32c_le(~0, (unsigned char *)keyb,
 530                                            undo_ctx.blocksize);
 531                 if (!force && ext2fs_le32_to_cpu(crc) != key_crc) {
 532                         fprintf(stderr,
 533                                 _("%s: key block checksum error at %llu.\n"),
 534                                 tdb_file, (unsigned long long) lblk);
 535                         exit(1);
 536                 }
 537
 538                 /* load keys from key block */
 539                 lblk++;
 540                 max_j = undo_ctx.num_keys - i;
 541                 if (max_j > keys_per_block)
 542                         max_j = keys_per_block;
 543                 for (j = 0, dkey = keyb->keys;
 544                      j < max_j;
 545                      j++, ikey++, dkey++) {
 546                         ikey->fsblk = ext2fs_le64_to_cpu(dkey->fsblk);
 547                         ikey->fileblk = lblk;
 548                         ikey->blk_crc = ext2fs_le32_to_cpu(dkey->blk_crc);
 549                         ikey->size = ext2fs_le32_to_cpu(dkey->size);
 550                         lblk += (ikey->size + undo_ctx.blocksize - 1) /
 551                                 undo_ctx.blocksize;
 552
 553                         if (E2UNDO_MAX_EXTENT_BLOCKS * undo_ctx.blocksize <
 554                             ikey->size) {
 555                                 com_err(prg_name, retval,
 556                                         _("%s: block %llu is too long."),
 557                                         tdb_file,
 558                                         (unsigned long long) ikey->fsblk);
 559                                 exit(1);
 560                         }
 561
 562                         /* check each block's crc */
 563                         retval = io_channel_read_blk64(undo_ctx.undo_file,
 564                                                        ikey->fileblk,
 565                                                        -(int)ikey->size,
 566                                                        buf);
 567                         if (retval) {
 568                                 com_err(prg_name, retval,
 569                                         _("while fetching block %llu."),
 570                                         (unsigned long long) ikey->fileblk);
 571                                 if (!force)
 572                                         exit(1);
 573                                 io_error = 1;
 574                                 continue;
 575                         }
 576
 577                         blk_crc = ext2fs_crc32c_le(~0, (unsigned char *)buf,
 578                                                    ikey->size);
 579                         if (blk_crc != ikey->blk_crc) {
 580                                 fprintf(stderr,
 581                                         _("checksum error in filesystem block "
 582                                           "%llu (undo blk %llu)\n"),
 583                                         (unsigned long long) ikey->fsblk,
 584                                         (unsigned long long) ikey->fileblk);
 585                                 if (!force)
 586                                         exit(1);
 587                                 csum_error = 1;
 588                         }
 589                 }
 590         }
 591         ext2fs_free_mem(&keyb);
 592
 593         /* sort keys in fs block order */
 594         qsort(undo_ctx.keys, undo_ctx.num_keys, sizeof(struct undo_key_info),
 595               key_compare);
 596
 597         /* replay */
 598         io_channel_set_blksize(channel, undo_ctx.fs_blocksize);
 599         for (i = 0, ikey = undo_ctx.keys; i < undo_ctx.num_keys; i++, ikey++) {
 600                 retval = io_channel_read_blk64(undo_ctx.undo_file,
 601                                                ikey->fileblk,
 602                                                -(int)ikey->size,
 603                                                buf);
 604                 if (retval) {
 605                         com_err(prg_name, retval,
 606                                 _("while fetching block %llu."),
 607                                 (unsigned long long) ikey->fileblk);
 608                         io_error = 1;
 609                         continue;
 610                 }
 611
 612                 if (verbose)
 613                         printf("Replayed block of size %u from %llu to %llu\n",
 614                                ikey->size, (unsigned long long) ikey->fileblk,
 615                                (unsigned long long) ikey->fsblk);
 616                 if (dry_run)
 617                         continue;
 618                 retval = io_channel_write_blk64(channel, ikey->fsblk,
 619                                                 -(int)ikey->size, buf);
 620                 if (retval) {
 621                         com_err(prg_name, retval,
 622                                 _("while writing block %llu."),
 623                                 (unsigned long long) ikey->fsblk);
 624                         io_error = 1;
 625                 }
 626         }
 627
 628         if (csum_error)
 629                 fprintf(stderr, _("Undo file corruption; run e2fsck NOW!\n"));
 630         if (io_error)
 631                 fprintf(stderr, _("IO error during replay; run e2fsck NOW!\n"));
 632         if (!(ext2fs_le32_to_cpu(undo_ctx.hdr.state) & E2UNDO_STATE_FINISHED)) {
 633                 force = 1;
 634                 fprintf(stderr, _("Incomplete undo record; run e2fsck.\n"));
 635         }
 636         ext2fs_free_mem(&buf);
 637         ext2fs_free_mem(&undo_ctx.keys);
 638         io_channel_close(channel);
 639
 640         /* If there were problems, try to force a fsck */
 641         if (!dry_run && (force || csum_error || io_error)) {
 642                 retval = ext2fs_open2(device_name, NULL,
 643                                    EXT2_FLAG_RW | EXT2_FLAG_64BITS, 0, 0,
 644                                    manager, &fs);
 645                 if (retval)
 646                         goto out;
 647                 fs->super->s_state &= ~EXT2_VALID_FS;
 648                 if (csum_error || io_error)
 649                         fs->super->s_state |= EXT2_ERROR_FS;
 650                 ext2fs_mark_super_dirty(fs);
 651                 ext2fs_close_free(&fs);
 652         }
 653
 654 out:
 655         io_channel_close(undo_ctx.undo_file);
 656
 657         return csum_error;
 658 }