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