e2image.c revision e6a4571eec5ce0e75fb8a5a41c30bf0e68d90efe
1/* 2 * e2image.c --- Program which writes an image file backing up 3 * critical metadata for the filesystem. 4 * 5 * Copyright 2000, 2001 by Theodore Ts'o. 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#define _LARGEFILE_SOURCE 14#define _LARGEFILE64_SOURCE 15 16#include <fcntl.h> 17#include <grp.h> 18#ifdef HAVE_GETOPT_H 19#include <getopt.h> 20#else 21extern char *optarg; 22extern int optind; 23#endif 24#include <pwd.h> 25#include <stdio.h> 26#include <stdlib.h> 27#include <string.h> 28#include <time.h> 29#include <unistd.h> 30#include <fcntl.h> 31#include <errno.h> 32#include <sys/stat.h> 33#include <sys/types.h> 34 35#include "ext2fs/ext2_fs.h" 36#include "ext2fs/ext2fs.h" 37#include "et/com_err.h" 38#include "uuid/uuid.h" 39#include "e2p/e2p.h" 40#include "ext2fs/e2image.h" 41 42#include "../version.h" 43#include "nls-enable.h" 44 45const char * program_name = "e2image"; 46char * device_name = NULL; 47 48static void usage(void) 49{ 50 fprintf(stderr, _("Usage: %s [-rsI] device image_file\n"), 51 program_name); 52 exit (1); 53} 54 55static void write_header(int fd, struct ext2_image_hdr *hdr, int blocksize) 56{ 57 char *header_buf; 58 int actual; 59 60 header_buf = malloc(blocksize); 61 if (!header_buf) { 62 fputs(_("Couldn't allocate header buffer\n"), stderr); 63 exit(1); 64 } 65 66 if (lseek(fd, 0, SEEK_SET) < 0) { 67 perror("lseek while writing header"); 68 exit(1); 69 } 70 memset(header_buf, 0, blocksize); 71 72 if (hdr) 73 memcpy(header_buf, hdr, sizeof(struct ext2_image_hdr)); 74 75 actual = write(fd, header_buf, blocksize); 76 if (actual < 0) { 77 perror("write header"); 78 exit(1); 79 } 80 if (actual != blocksize) { 81 fprintf(stderr, _("short write (only %d bytes) for " 82 "writing image header"), actual); 83 exit(1); 84 } 85 free(header_buf); 86} 87 88static void write_image_file(ext2_filsys fs, int fd) 89{ 90 struct ext2_image_hdr hdr; 91 struct stat st; 92 errcode_t retval; 93 94 write_header(fd, NULL, fs->blocksize); 95 memset(&hdr, 0, sizeof(struct ext2_image_hdr)); 96 97 hdr.offset_super = lseek(fd, 0, SEEK_CUR); 98 retval = ext2fs_image_super_write(fs, fd, 0); 99 if (retval) { 100 com_err(program_name, retval, _("while writing superblock")); 101 exit(1); 102 } 103 104 hdr.offset_inode = lseek(fd, 0, SEEK_CUR); 105 retval = ext2fs_image_inode_write(fs, fd, 106 (fd != 1) ? IMAGER_FLAG_SPARSEWRITE : 0); 107 if (retval) { 108 com_err(program_name, retval, _("while writing inode table")); 109 exit(1); 110 } 111 112 hdr.offset_blockmap = lseek(fd, 0, SEEK_CUR); 113 retval = ext2fs_image_bitmap_write(fs, fd, 0); 114 if (retval) { 115 com_err(program_name, retval, _("while writing block bitmap")); 116 exit(1); 117 } 118 119 hdr.offset_inodemap = lseek(fd, 0, SEEK_CUR); 120 retval = ext2fs_image_bitmap_write(fs, fd, IMAGER_FLAG_INODEMAP); 121 if (retval) { 122 com_err(program_name, retval, _("while writing inode bitmap")); 123 exit(1); 124 } 125 126 hdr.magic_number = EXT2_ET_MAGIC_E2IMAGE; 127 strcpy(hdr.magic_descriptor, "Ext2 Image 1.0"); 128 gethostname(hdr.fs_hostname, sizeof(hdr.fs_hostname)); 129 strncat(hdr.fs_device_name, device_name, sizeof(hdr.fs_device_name) - 1); 130 hdr.fs_blocksize = fs->blocksize; 131 132 if (stat(device_name, &st) == 0) 133 hdr.fs_device = st.st_rdev; 134 135 if (fstat(fd, &st) == 0) { 136 hdr.image_device = st.st_dev; 137 hdr.image_inode = st.st_ino; 138 } 139 memcpy(hdr.fs_uuid, fs->super->s_uuid, sizeof(hdr.fs_uuid)); 140 141 hdr.image_time = time(0); 142 write_header(fd, &hdr, fs->blocksize); 143} 144 145/* 146 * These set of functions are used to write a RAW image file. 147 */ 148ext2fs_block_bitmap meta_block_map; 149ext2fs_block_bitmap scramble_block_map; /* Directory blocks to be scrambled */ 150 151struct process_block_struct { 152 ext2_ino_t ino; 153 int is_dir; 154}; 155 156/* 157 * These subroutines short circuits ext2fs_get_blocks and 158 * ext2fs_check_directory; we use them since we already have the inode 159 * structure, so there's no point in letting the ext2fs library read 160 * the inode again. 161 */ 162static ino_t stashed_ino = 0; 163static struct ext2_inode *stashed_inode; 164 165static errcode_t meta_get_blocks(ext2_filsys fs EXT2FS_ATTR((unused)), 166 ext2_ino_t ino, 167 blk_t *blocks) 168{ 169 int i; 170 171 if ((ino != stashed_ino) || !stashed_inode) 172 return EXT2_ET_CALLBACK_NOTHANDLED; 173 174 for (i=0; i < EXT2_N_BLOCKS; i++) 175 blocks[i] = stashed_inode->i_block[i]; 176 return 0; 177} 178 179static errcode_t meta_check_directory(ext2_filsys fs EXT2FS_ATTR((unused)), 180 ext2_ino_t ino) 181{ 182 if ((ino != stashed_ino) || !stashed_inode) 183 return EXT2_ET_CALLBACK_NOTHANDLED; 184 185 if (!LINUX_S_ISDIR(stashed_inode->i_mode)) 186 return EXT2_ET_NO_DIRECTORY; 187 return 0; 188} 189 190static errcode_t meta_read_inode(ext2_filsys fs EXT2FS_ATTR((unused)), 191 ext2_ino_t ino, 192 struct ext2_inode *inode) 193{ 194 if ((ino != stashed_ino) || !stashed_inode) 195 return EXT2_ET_CALLBACK_NOTHANDLED; 196 *inode = *stashed_inode; 197 return 0; 198} 199 200static void use_inode_shortcuts(ext2_filsys fs, int bool) 201{ 202 if (bool) { 203 fs->get_blocks = meta_get_blocks; 204 fs->check_directory = meta_check_directory; 205 fs->read_inode = meta_read_inode; 206 stashed_ino = 0; 207 } else { 208 fs->get_blocks = 0; 209 fs->check_directory = 0; 210 fs->read_inode = 0; 211 } 212} 213 214static int process_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)), 215 blk_t *block_nr, 216 e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), 217 blk_t ref_block EXT2FS_ATTR((unused)), 218 int ref_offset EXT2FS_ATTR((unused)), 219 void *priv_data EXT2FS_ATTR((unused))) 220{ 221 struct process_block_struct *p; 222 223 p = (struct process_block_struct *) priv_data; 224 225 ext2fs_mark_block_bitmap(meta_block_map, *block_nr); 226 if (scramble_block_map && p->is_dir && blockcnt >= 0) 227 ext2fs_mark_block_bitmap(scramble_block_map, *block_nr); 228 return 0; 229} 230 231static int process_file_block(ext2_filsys fs EXT2FS_ATTR((unused)), 232 blk_t *block_nr, 233 e2_blkcnt_t blockcnt, 234 blk_t ref_block EXT2FS_ATTR((unused)), 235 int ref_offset EXT2FS_ATTR((unused)), 236 void *priv_data EXT2FS_ATTR((unused))) 237{ 238 if (blockcnt < 0) { 239 ext2fs_mark_block_bitmap(meta_block_map, *block_nr); 240 } 241 return 0; 242} 243 244static void mark_table_blocks(ext2_filsys fs) 245{ 246 blk_t first_block, b; 247 unsigned int i,j; 248 249 first_block = fs->super->s_first_data_block; 250 /* 251 * Mark primary superblock 252 */ 253 ext2fs_mark_block_bitmap(meta_block_map, first_block); 254 255 /* 256 * Mark the primary superblock descriptors 257 */ 258 for (j = 0; j < fs->desc_blocks; j++) { 259 ext2fs_mark_block_bitmap(meta_block_map, 260 ext2fs_descriptor_block_loc(fs, first_block, j)); 261 } 262 263 for (i = 0; i < fs->group_desc_count; i++) { 264 /* 265 * Mark the blocks used for the inode table 266 */ 267 if (fs->group_desc[i].bg_inode_table) { 268 for (j = 0, b = fs->group_desc[i].bg_inode_table; 269 j < (unsigned) fs->inode_blocks_per_group; 270 j++, b++) 271 ext2fs_mark_block_bitmap(meta_block_map, b); 272 } 273 274 /* 275 * Mark block used for the block bitmap 276 */ 277 if (fs->group_desc[i].bg_block_bitmap) { 278 ext2fs_mark_block_bitmap(meta_block_map, 279 fs->group_desc[i].bg_block_bitmap); 280 } 281 282 /* 283 * Mark block used for the inode bitmap 284 */ 285 if (fs->group_desc[i].bg_inode_bitmap) { 286 ext2fs_mark_block_bitmap(meta_block_map, 287 fs->group_desc[i].bg_inode_bitmap); 288 } 289 } 290} 291 292/* 293 * This function returns 1 if the specified block is all zeros 294 */ 295static int check_zero_block(char *buf, int blocksize) 296{ 297 char *cp = buf; 298 int left = blocksize; 299 300 while (left > 0) { 301 if (*cp++) 302 return 0; 303 left--; 304 } 305 return 1; 306} 307 308static void write_block(int fd, char *buf, int sparse_offset, 309 int blocksize, blk_t block) 310{ 311 int count; 312 errcode_t err; 313 314 if (sparse_offset) { 315#ifdef HAVE_LSEEK64 316 if (lseek64(fd, sparse_offset, SEEK_CUR) < 0) 317 perror("lseek"); 318#else 319 if (lseek(fd, sparse_offset, SEEK_CUR) < 0) 320 perror("lseek"); 321#endif 322 } 323 if (blocksize) { 324 count = write(fd, buf, blocksize); 325 if (count != blocksize) { 326 if (count == -1) 327 err = errno; 328 else 329 err = 0; 330 com_err(program_name, err, "error writing block %u", 331 block); 332 } 333 } 334} 335 336int name_id[256]; 337 338static void scramble_dir_block(ext2_filsys fs, blk_t blk, char *buf) 339{ 340 char *p, *end, *cp; 341 struct ext2_dir_entry_2 *dirent; 342 int rec_len, id, len; 343 344 end = buf + fs->blocksize; 345 for (p = buf; p < end-8; p += rec_len) { 346 dirent = (struct ext2_dir_entry_2 *) p; 347 rec_len = dirent->rec_len; 348#ifdef WORDS_BIGENDIAN 349 rec_len = ext2fs_swab16(rec_len); 350#endif 351#if 0 352 printf("rec_len = %d, name_len = %d\n", rec_len, dirent->name_len); 353#endif 354 if (rec_len < 8 || (rec_len % 4) || 355 (p+rec_len > end)) { 356 printf("Corrupt directory block %lu: " 357 "bad rec_len (%d)\n", (unsigned long) blk, 358 rec_len); 359 rec_len = end - p; 360#ifdef WORDS_BIGENDIAN 361 dirent->rec_len = ext2fs_swab16(rec_len); 362#endif 363 continue; 364 } 365 if (dirent->name_len + 8 > rec_len) { 366 printf("Corrupt directory block %lu: " 367 "bad name_len (%d)\n", (unsigned long) blk, 368 dirent->name_len); 369 dirent->name_len = rec_len - 8; 370 continue; 371 } 372 cp = p+8; 373 len = rec_len - dirent->name_len - 8; 374 if (len > 0) 375 memset(cp+dirent->name_len, 0, len); 376 if (dirent->name_len==1 && cp[0] == '.') 377 continue; 378 if (dirent->name_len==2 && cp[0] == '.' && cp[1] == '.') 379 continue; 380 381 memset(cp, 'A', dirent->name_len); 382 len = dirent->name_len; 383 id = name_id[len]++; 384 while ((len > 0) && (id > 0)) { 385 *cp += id % 26; 386 id = id / 26; 387 cp++; 388 len--; 389 } 390 } 391} 392 393static void output_meta_data_blocks(ext2_filsys fs, int fd) 394{ 395 errcode_t retval; 396 blk_t blk; 397 char *buf, *zero_buf; 398 int sparse = 0; 399 400 buf = malloc(fs->blocksize); 401 if (!buf) { 402 com_err(program_name, ENOMEM, "while allocating buffer"); 403 exit(1); 404 } 405 zero_buf = malloc(fs->blocksize); 406 if (!zero_buf) { 407 com_err(program_name, ENOMEM, "while allocating buffer"); 408 exit(1); 409 } 410 memset(zero_buf, 0, fs->blocksize); 411 for (blk = 0; blk < fs->super->s_blocks_count; blk++) { 412 if ((blk >= fs->super->s_first_data_block) && 413 ext2fs_test_block_bitmap(meta_block_map, blk)) { 414 retval = io_channel_read_blk(fs->io, blk, 1, buf); 415 if (retval) { 416 com_err(program_name, retval, 417 "error reading block %u", blk); 418 } 419 if (scramble_block_map && 420 ext2fs_test_block_bitmap(scramble_block_map, blk)) 421 scramble_dir_block(fs, blk, buf); 422 if ((fd != 1) && check_zero_block(buf, fs->blocksize)) 423 goto sparse_write; 424 write_block(fd, buf, sparse, fs->blocksize, blk); 425 sparse = 0; 426 } else { 427 sparse_write: 428 if (fd == 1) { 429 write_block(fd, zero_buf, 0, 430 fs->blocksize, blk); 431 continue; 432 } 433 sparse += fs->blocksize; 434 if (sparse >= 1024*1024) { 435 write_block(fd, 0, sparse, 0, 0); 436 sparse = 0; 437 } 438 } 439 } 440 if (sparse) 441 write_block(fd, zero_buf, sparse-1, 1, -1); 442 free(zero_buf); 443 free(buf); 444} 445 446static void write_raw_image_file(ext2_filsys fs, int fd, int scramble_flag) 447{ 448 struct process_block_struct pb; 449 struct ext2_inode inode; 450 ext2_inode_scan scan; 451 ext2_ino_t ino; 452 errcode_t retval; 453 char * block_buf; 454 455 retval = ext2fs_allocate_block_bitmap(fs, "in-use block map", 456 &meta_block_map); 457 if (retval) { 458 com_err(program_name, retval, "while allocating block bitmap"); 459 exit(1); 460 } 461 462 if (scramble_flag) { 463 retval = ext2fs_allocate_block_bitmap(fs, "scramble block map", 464 &scramble_block_map); 465 if (retval) { 466 com_err(program_name, retval, 467 "while allocating scramble block bitmap"); 468 exit(1); 469 } 470 } 471 472 mark_table_blocks(fs); 473 474 retval = ext2fs_open_inode_scan(fs, 0, &scan); 475 if (retval) { 476 com_err(program_name, retval, _("while opening inode scan")); 477 exit(1); 478 } 479 480 block_buf = malloc(fs->blocksize * 3); 481 if (!block_buf) { 482 com_err(program_name, 0, "Can't allocate block buffer"); 483 exit(1); 484 } 485 486 use_inode_shortcuts(fs, 1); 487 stashed_inode = &inode; 488 while (1) { 489 retval = ext2fs_get_next_inode(scan, &ino, &inode); 490 if (retval == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) 491 continue; 492 if (retval) { 493 com_err(program_name, retval, 494 _("while getting next inode")); 495 exit(1); 496 } 497 if (ino == 0) 498 break; 499 if (!inode.i_links_count) 500 continue; 501 if (inode.i_file_acl) { 502 ext2fs_mark_block_bitmap(meta_block_map, 503 inode.i_file_acl); 504 } 505 if (!ext2fs_inode_has_valid_blocks(&inode)) 506 continue; 507 508 stashed_ino = ino; 509 pb.ino = ino; 510 pb.is_dir = LINUX_S_ISDIR(inode.i_mode); 511 if (LINUX_S_ISDIR(inode.i_mode) || 512 (LINUX_S_ISLNK(inode.i_mode) && 513 ext2fs_inode_has_valid_blocks(&inode)) || 514 ino == fs->super->s_journal_inum) { 515 retval = ext2fs_block_iterate2(fs, ino, 0, 516 block_buf, process_dir_block, &pb); 517 if (retval) { 518 com_err(program_name, retval, 519 "while iterating over inode %u", 520 ino); 521 exit(1); 522 } 523 } else { 524 if (inode.i_block[EXT2_IND_BLOCK] || 525 inode.i_block[EXT2_DIND_BLOCK] || 526 inode.i_block[EXT2_TIND_BLOCK]) { 527 retval = ext2fs_block_iterate2(fs, 528 ino, 0, block_buf, 529 process_file_block, &pb); 530 if (retval) { 531 com_err(program_name, retval, 532 "while iterating over inode %u", ino); 533 exit(1); 534 } 535 } 536 } 537 } 538 use_inode_shortcuts(fs, 0); 539 output_meta_data_blocks(fs, fd); 540 free(block_buf); 541} 542 543static void install_image(char *device, char *image_fn, int raw_flag) 544{ 545 errcode_t retval; 546 ext2_filsys fs; 547 int open_flag = EXT2_FLAG_IMAGE_FILE; 548 int fd = 0; 549 io_manager io_ptr; 550 io_channel io, image_io; 551 552 if (raw_flag) { 553 com_err(program_name, 0, "Raw images cannot be installed"); 554 exit(1); 555 } 556 557#ifdef CONFIG_TESTIO_DEBUG 558 io_ptr = test_io_manager; 559 test_io_backing_manager = unix_io_manager; 560#else 561 io_ptr = unix_io_manager; 562#endif 563 564 retval = ext2fs_open (image_fn, open_flag, 0, 0, 565 io_ptr, &fs); 566 if (retval) { 567 com_err (program_name, retval, _("while trying to open %s"), 568 image_fn); 569 exit(1); 570 } 571 572 retval = ext2fs_read_bitmaps (fs); 573 if (retval) { 574 com_err(program_name, retval, "error reading bitmaps"); 575 exit(1); 576 } 577 578 579 fd = open(image_fn, O_RDONLY); 580 if (fd < 0) { 581 perror(image_fn); 582 exit(1); 583 } 584 585 retval = io_ptr->open(device, IO_FLAG_RW, &io); 586 if (retval) { 587 com_err(device, 0, "while opening device file"); 588 exit(1); 589 } 590 591 image_io = fs->io; 592 593 ext2fs_rewrite_to_io(fs, io); 594 595 if (lseek(fd, fs->image_header->offset_inode, SEEK_SET) < 0) { 596 perror("lseek"); 597 exit(1); 598 } 599 600 retval = ext2fs_image_inode_read(fs, fd, 0); 601 if (retval) { 602 com_err(image_fn, 0, "while restoring the image table"); 603 exit(1); 604 } 605 606 ext2fs_close (fs); 607 exit (0); 608} 609 610int main (int argc, char ** argv) 611{ 612 int c; 613 errcode_t retval; 614 ext2_filsys fs; 615 char *image_fn; 616 int open_flag = 0; 617 int raw_flag = 0; 618 int install_flag = 0; 619 int scramble_flag = 0; 620 int fd = 0; 621 622#ifdef ENABLE_NLS 623 setlocale(LC_MESSAGES, ""); 624 setlocale(LC_CTYPE, ""); 625 bindtextdomain(NLS_CAT_NAME, LOCALEDIR); 626 textdomain(NLS_CAT_NAME); 627#endif 628 fprintf (stderr, "e2image %s (%s)\n", E2FSPROGS_VERSION, 629 E2FSPROGS_DATE); 630 if (argc && *argv) 631 program_name = *argv; 632 add_error_table(&et_ext2_error_table); 633 while ((c = getopt (argc, argv, "rsI")) != EOF) 634 switch (c) { 635 case 'r': 636 raw_flag++; 637 break; 638 case 's': 639 scramble_flag++; 640 break; 641 case 'I': 642 install_flag++; 643 break; 644 default: 645 usage(); 646 } 647 if (optind != argc - 2 ) 648 usage(); 649 device_name = argv[optind]; 650 image_fn = argv[optind+1]; 651 652 if (install_flag) { 653 install_image(device_name, image_fn, raw_flag); 654 exit (0); 655 } 656 657 retval = ext2fs_open (device_name, open_flag, 0, 0, 658 unix_io_manager, &fs); 659 if (retval) { 660 com_err (program_name, retval, _("while trying to open %s"), 661 device_name); 662 fputs(_("Couldn't find valid filesystem superblock.\n"), stdout); 663 exit(1); 664 } 665 666 if (strcmp(image_fn, "-") == 0) 667 fd = 1; 668 else { 669#ifdef HAVE_OPEN64 670 fd = open64(image_fn, O_CREAT|O_TRUNC|O_WRONLY, 0600); 671#else 672 fd = open(image_fn, O_CREAT|O_TRUNC|O_WRONLY, 0600); 673#endif 674 if (fd < 0) { 675 com_err(program_name, errno, 676 _("while trying to open %s"), argv[optind+1]); 677 exit(1); 678 } 679 } 680 681 if (raw_flag) 682 write_raw_image_file(fs, fd, scramble_flag); 683 else 684 write_image_file(fs, fd); 685 686 ext2fs_close (fs); 687 remove_error_table(&et_ext2_error_table); 688 exit (0); 689} 690