dumpe2fs.c revision 7fcaabf8e80031b9919128c7cb8a86fdbcacb8f4
1/* 2 * dumpe2fs.c - List the control structures of a second 3 * extended filesystem 4 * 5 * Copyright (C) 1992, 1993, 1994 Remy Card <card@masi.ibp.fr> 6 * Laboratoire MASI, Institut Blaise Pascal 7 * Universite Pierre et Marie Curie (Paris VI) 8 * 9 * Copyright 1995, 1996, 1997 by Theodore Ts'o. 10 * 11 * %Begin-Header% 12 * This file may be redistributed under the terms of the GNU Public 13 * License. 14 * %End-Header% 15 */ 16 17/* 18 * History: 19 * 94/01/09 - Creation 20 * 94/02/27 - Ported to use the ext2fs library 21 */ 22 23#include "config.h" 24#ifdef HAVE_GETOPT_H 25#include <getopt.h> 26#else 27extern char *optarg; 28extern int optind; 29#endif 30#include <fcntl.h> 31#include <stdio.h> 32#include <stdlib.h> 33#include <string.h> 34#include <unistd.h> 35 36#include "ext2fs/ext2_fs.h" 37 38#include "ext2fs/ext2fs.h" 39#include "e2p/e2p.h" 40#include "jfs_user.h" 41#include <uuid/uuid.h> 42 43#include "../version.h" 44#include "nls-enable.h" 45 46#define in_use(m, x) (ext2fs_test_bit ((x), (m))) 47 48static const char * program_name = "dumpe2fs"; 49static char * device_name = NULL; 50static int hex_format = 0; 51static int blocks64 = 0; 52 53static void usage(void) 54{ 55 fprintf (stderr, _("Usage: %s [-bfhixV] [-o superblock=<num>] " 56 "[-o blocksize=<num>] device\n"), program_name); 57 exit (1); 58} 59 60static void print_number(unsigned long long num) 61{ 62 if (hex_format) { 63 if (blocks64) 64 printf("0x%08llx", num); 65 else 66 printf("0x%04llx", num); 67 } else 68 printf("%llu", num); 69} 70 71static void print_range(unsigned long long a, unsigned long long b) 72{ 73 if (hex_format) { 74 if (blocks64) 75 printf("0x%08llx-0x%08llx", a, b); 76 else 77 printf("0x%04llx-0x%04llx", a, b); 78 } else 79 printf("%llu-%llu", a, b); 80} 81 82static void print_free(unsigned long group, char * bitmap, 83 unsigned long num, unsigned long offset, int ratio) 84{ 85 int p = 0; 86 unsigned long i; 87 unsigned long j; 88 89 offset /= ratio; 90 offset += group * num; 91 for (i = 0; i < num; i++) 92 if (!in_use (bitmap, i)) 93 { 94 if (p) 95 printf (", "); 96 print_number((i + offset) * ratio); 97 for (j = i; j < num && !in_use (bitmap, j); j++) 98 ; 99 if (--j != i) { 100 fputc('-', stdout); 101 print_number((j + offset) * ratio); 102 i = j; 103 } 104 p = 1; 105 } 106} 107 108static void print_bg_opt(int bg_flags, int mask, 109 const char *str, int *first) 110{ 111 if (bg_flags & mask) { 112 if (*first) { 113 fputs(" [", stdout); 114 *first = 0; 115 } else 116 fputs(", ", stdout); 117 fputs(str, stdout); 118 } 119} 120static void print_bg_opts(ext2_filsys fs, dgrp_t i) 121{ 122 int first = 1, bg_flags = 0; 123 124 if (fs->super->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) 125 bg_flags = ext2fs_bg_flags(fs, i); 126 127 print_bg_opt(bg_flags, EXT2_BG_INODE_UNINIT, "INODE_UNINIT", 128 &first); 129 print_bg_opt(bg_flags, EXT2_BG_BLOCK_UNINIT, "BLOCK_UNINIT", 130 &first); 131 print_bg_opt(bg_flags, EXT2_BG_INODE_ZEROED, "ITABLE_ZEROED", 132 &first); 133 if (!first) 134 fputc(']', stdout); 135 fputc('\n', stdout); 136} 137 138static void print_bg_rel_offset(ext2_filsys fs, blk64_t block, int itable, 139 blk64_t first_block, blk64_t last_block) 140{ 141 if ((block >= first_block) && (block <= last_block)) { 142 if (itable && block == first_block) 143 return; 144 printf(" (+%u)", (unsigned)(block - first_block)); 145 } else if (fs->super->s_feature_incompat & 146 EXT4_FEATURE_INCOMPAT_FLEX_BG) { 147 dgrp_t flex_grp = ext2fs_group_of_blk2(fs, block); 148 printf(" (bg #%u + %u)", flex_grp, 149 (unsigned)(block-ext2fs_group_first_block2(fs,flex_grp))); 150 } 151} 152 153static void list_desc (ext2_filsys fs) 154{ 155 unsigned long i; 156 blk64_t first_block, last_block; 157 blk64_t super_blk, old_desc_blk, new_desc_blk; 158 char *block_bitmap=NULL, *inode_bitmap=NULL; 159 const char *units = _("blocks"); 160 int inode_blocks_per_group, old_desc_blocks, reserved_gdt; 161 int block_nbytes, inode_nbytes; 162 int has_super; 163 blk64_t blk_itr = EXT2FS_B2C(fs, fs->super->s_first_data_block); 164 ext2_ino_t ino_itr = 1; 165 errcode_t retval; 166 167 if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, 168 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) 169 units = _("clusters"); 170 171 block_nbytes = EXT2_CLUSTERS_PER_GROUP(fs->super) / 8; 172 inode_nbytes = EXT2_INODES_PER_GROUP(fs->super) / 8; 173 174 if (fs->block_map) 175 block_bitmap = malloc(block_nbytes); 176 if (fs->inode_map) 177 inode_bitmap = malloc(inode_nbytes); 178 179 inode_blocks_per_group = ((fs->super->s_inodes_per_group * 180 EXT2_INODE_SIZE(fs->super)) + 181 EXT2_BLOCK_SIZE(fs->super) - 1) / 182 EXT2_BLOCK_SIZE(fs->super); 183 reserved_gdt = fs->super->s_reserved_gdt_blocks; 184 fputc('\n', stdout); 185 first_block = fs->super->s_first_data_block; 186 if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) 187 old_desc_blocks = fs->super->s_first_meta_bg; 188 else 189 old_desc_blocks = fs->desc_blocks; 190 for (i = 0; i < fs->group_desc_count; i++) { 191 first_block = ext2fs_group_first_block2(fs, i); 192 last_block = ext2fs_group_last_block2(fs, i); 193 194 ext2fs_super_and_bgd_loc2(fs, i, &super_blk, 195 &old_desc_blk, &new_desc_blk, 0); 196 197 printf (_("Group %lu: (Blocks "), i); 198 print_range(first_block, last_block); 199 fputs(")", stdout); 200 print_bg_opts(fs, i); 201 if (fs->super->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { 202 unsigned csum = ext2fs_bg_checksum(fs, i); 203 unsigned exp_csum = ext2fs_group_desc_csum(fs, i); 204 205 printf(_(" Checksum 0x%04x"), csum); 206 if (csum != exp_csum) 207 printf(_(" (EXPECTED 0x%04x)"), exp_csum); 208 printf(_(", unused inodes %u\n"), 209 ext2fs_bg_itable_unused(fs, i)); 210 } 211 has_super = ((i==0) || super_blk); 212 if (has_super) { 213 printf (_(" %s superblock at "), 214 i == 0 ? _("Primary") : _("Backup")); 215 print_number(super_blk); 216 } 217 if (old_desc_blk) { 218 printf("%s", _(", Group descriptors at ")); 219 print_range(old_desc_blk, 220 old_desc_blk + old_desc_blocks - 1); 221 if (reserved_gdt) { 222 printf("%s", _("\n Reserved GDT blocks at ")); 223 print_range(old_desc_blk + old_desc_blocks, 224 old_desc_blk + old_desc_blocks + 225 reserved_gdt - 1); 226 } 227 } else if (new_desc_blk) { 228 fputc(has_super ? ',' : ' ', stdout); 229 printf("%s", _(" Group descriptor at ")); 230 print_number(new_desc_blk); 231 has_super++; 232 } 233 if (has_super) 234 fputc('\n', stdout); 235 fputs(_(" Block bitmap at "), stdout); 236 print_number(ext2fs_block_bitmap_loc(fs, i)); 237 print_bg_rel_offset(fs, ext2fs_block_bitmap_loc(fs, i), 0, 238 first_block, last_block); 239 fputs(_(", Inode bitmap at "), stdout); 240 print_number(ext2fs_inode_bitmap_loc(fs, i)); 241 print_bg_rel_offset(fs, ext2fs_inode_bitmap_loc(fs, i), 0, 242 first_block, last_block); 243 fputs(_("\n Inode table at "), stdout); 244 print_range(ext2fs_inode_table_loc(fs, i), 245 ext2fs_inode_table_loc(fs, i) + 246 inode_blocks_per_group - 1); 247 print_bg_rel_offset(fs, ext2fs_inode_table_loc(fs, i), 1, 248 first_block, last_block); 249 printf (_("\n %u free %s, %u free inodes, " 250 "%u directories%s"), 251 ext2fs_bg_free_blocks_count(fs, i), units, 252 ext2fs_bg_free_inodes_count(fs, i), 253 ext2fs_bg_used_dirs_count(fs, i), 254 ext2fs_bg_itable_unused(fs, i) ? "" : "\n"); 255 if (ext2fs_bg_itable_unused(fs, i)) 256 printf (_(", %u unused inodes\n"), 257 ext2fs_bg_itable_unused(fs, i)); 258 if (block_bitmap) { 259 fputs(_(" Free blocks: "), stdout); 260 retval = ext2fs_get_block_bitmap_range2(fs->block_map, 261 blk_itr, block_nbytes << 3, block_bitmap); 262 if (retval) 263 com_err("list_desc", retval, 264 "while reading block bitmap"); 265 else 266 print_free(i, block_bitmap, 267 fs->super->s_clusters_per_group, 268 fs->super->s_first_data_block, 269 EXT2FS_CLUSTER_RATIO(fs)); 270 fputc('\n', stdout); 271 blk_itr += fs->super->s_clusters_per_group; 272 } 273 if (inode_bitmap) { 274 fputs(_(" Free inodes: "), stdout); 275 retval = ext2fs_get_inode_bitmap_range2(fs->inode_map, 276 ino_itr, inode_nbytes << 3, inode_bitmap); 277 if (retval) 278 com_err("list_desc", retval, 279 "while reading inode bitmap"); 280 else 281 print_free(i, inode_bitmap, 282 fs->super->s_inodes_per_group, 283 1, 1); 284 fputc('\n', stdout); 285 ino_itr += fs->super->s_inodes_per_group; 286 } 287 } 288 if (block_bitmap) 289 free(block_bitmap); 290 if (inode_bitmap) 291 free(inode_bitmap); 292} 293 294static void list_bad_blocks(ext2_filsys fs, int dump) 295{ 296 badblocks_list bb_list = 0; 297 badblocks_iterate bb_iter; 298 blk_t blk; 299 errcode_t retval; 300 const char *header, *fmt; 301 302 retval = ext2fs_read_bb_inode(fs, &bb_list); 303 if (retval) { 304 com_err("ext2fs_read_bb_inode", retval, 0); 305 return; 306 } 307 retval = ext2fs_badblocks_list_iterate_begin(bb_list, &bb_iter); 308 if (retval) { 309 com_err("ext2fs_badblocks_list_iterate_begin", retval, 310 "%s", _("while printing bad block list")); 311 return; 312 } 313 if (dump) { 314 header = fmt = "%u\n"; 315 } else { 316 header = _("Bad blocks: %u"); 317 fmt = ", %u"; 318 } 319 while (ext2fs_badblocks_list_iterate(bb_iter, &blk)) { 320 printf(header ? header : fmt, blk); 321 header = 0; 322 } 323 ext2fs_badblocks_list_iterate_end(bb_iter); 324 if (!dump) 325 fputc('\n', stdout); 326 ext2fs_badblocks_list_free(bb_list); 327} 328 329static void print_inline_journal_information(ext2_filsys fs) 330{ 331 journal_superblock_t *jsb; 332 struct ext2_inode inode; 333 ext2_file_t journal_file; 334 errcode_t retval; 335 ino_t ino = fs->super->s_journal_inum; 336 char buf[1024]; 337 __u32 *mask_ptr, mask, m; 338 int i, j, size, printed = 0; 339 340 if (fs->flags & EXT2_FLAG_IMAGE_FILE) 341 return; 342 retval = ext2fs_read_inode(fs, ino, &inode); 343 if (retval) { 344 com_err(program_name, retval, "%s", 345 _("while reading journal inode")); 346 exit(1); 347 } 348 retval = ext2fs_file_open2(fs, ino, &inode, 0, &journal_file); 349 if (retval) { 350 com_err(program_name, retval, "%s", 351 _("while opening journal inode")); 352 exit(1); 353 } 354 retval = ext2fs_file_read(journal_file, buf, sizeof(buf), 0); 355 if (retval) { 356 com_err(program_name, retval, "%s", 357 _("while reading journal super block")); 358 exit(1); 359 } 360 ext2fs_file_close(journal_file); 361 jsb = (journal_superblock_t *) buf; 362 if (be32_to_cpu(jsb->s_header.h_magic) != JFS_MAGIC_NUMBER) { 363 fprintf(stderr, "%s", 364 _("Journal superblock magic number invalid!\n")); 365 exit(1); 366 } 367 printf("%s", _("Journal features: ")); 368 for (i=0, mask_ptr=&jsb->s_feature_compat; i <3; i++,mask_ptr++) { 369 mask = be32_to_cpu(*mask_ptr); 370 for (j=0,m=1; j < 32; j++, m<<=1) { 371 if (mask & m) { 372 printf(" %s", e2p_jrnl_feature2string(i, m)); 373 printed++; 374 } 375 } 376 } 377 if (printed == 0) 378 printf(" (none)"); 379 printf("\n"); 380 fputs(_("Journal size: "), stdout); 381 if ((fs->super->s_feature_ro_compat & 382 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && 383 (inode.i_flags & EXT4_HUGE_FILE_FL)) 384 size = inode.i_blocks / (fs->blocksize / 1024); 385 else 386 size = inode.i_blocks >> 1; 387 if (size < 8192) 388 printf("%uk\n", size); 389 else 390 printf("%uM\n", size >> 10); 391 printf(_("Journal length: %u\n" 392 "Journal sequence: 0x%08x\n" 393 "Journal start: %u\n"), 394 (unsigned int)ntohl(jsb->s_maxlen), 395 (unsigned int)ntohl(jsb->s_sequence), 396 (unsigned int)ntohl(jsb->s_start)); 397 if (jsb->s_errno != 0) 398 printf(_("Journal errno: %d\n"), 399 (int) ntohl(jsb->s_errno)); 400} 401 402static void print_journal_information(ext2_filsys fs) 403{ 404 errcode_t retval; 405 char buf[1024]; 406 char str[80]; 407 unsigned int i; 408 journal_superblock_t *jsb; 409 410 /* Get the journal superblock */ 411 if ((retval = io_channel_read_blk64(fs->io, 412 fs->super->s_first_data_block + 1, 413 -1024, buf))) { 414 com_err(program_name, retval, "%s", 415 _("while reading journal superblock")); 416 exit(1); 417 } 418 jsb = (journal_superblock_t *) buf; 419 if ((jsb->s_header.h_magic != (unsigned) ntohl(JFS_MAGIC_NUMBER)) || 420 (jsb->s_header.h_blocktype != 421 (unsigned) ntohl(JFS_SUPERBLOCK_V2))) { 422 com_err(program_name, 0, "%s", 423 _("Couldn't find journal superblock magic numbers")); 424 exit(1); 425 } 426 427 printf(_("\nJournal block size: %u\n" 428 "Journal length: %u\n" 429 "Journal first block: %u\n" 430 "Journal sequence: 0x%08x\n" 431 "Journal start: %u\n" 432 "Journal number of users: %u\n"), 433 (unsigned int)ntohl(jsb->s_blocksize), (unsigned int)ntohl(jsb->s_maxlen), 434 (unsigned int)ntohl(jsb->s_first), (unsigned int)ntohl(jsb->s_sequence), 435 (unsigned int)ntohl(jsb->s_start), (unsigned int)ntohl(jsb->s_nr_users)); 436 437 for (i=0; i < ntohl(jsb->s_nr_users); i++) { 438 uuid_unparse(&jsb->s_users[i*16], str); 439 printf(i ? " %s\n" 440 : _("Journal users: %s\n"), 441 str); 442 } 443} 444 445static void parse_extended_opts(const char *opts, blk64_t *superblock, 446 int *blocksize) 447{ 448 char *buf, *token, *next, *p, *arg, *badopt = 0; 449 int len; 450 int do_usage = 0; 451 452 len = strlen(opts); 453 buf = malloc(len+1); 454 if (!buf) { 455 fprintf(stderr, "%s", 456 _("Couldn't allocate memory to parse options!\n")); 457 exit(1); 458 } 459 strcpy(buf, opts); 460 for (token = buf; token && *token; token = next) { 461 p = strchr(token, ','); 462 next = 0; 463 if (p) { 464 *p = 0; 465 next = p+1; 466 } 467 arg = strchr(token, '='); 468 if (arg) { 469 *arg = 0; 470 arg++; 471 } 472 if (strcmp(token, "superblock") == 0 || 473 strcmp(token, "sb") == 0) { 474 if (!arg) { 475 do_usage++; 476 badopt = token; 477 continue; 478 } 479 *superblock = strtoul(arg, &p, 0); 480 if (*p) { 481 fprintf(stderr, 482 _("Invalid superblock parameter: %s\n"), 483 arg); 484 do_usage++; 485 continue; 486 } 487 } else if (strcmp(token, "blocksize") == 0 || 488 strcmp(token, "bs") == 0) { 489 if (!arg) { 490 do_usage++; 491 badopt = token; 492 continue; 493 } 494 *blocksize = strtoul(arg, &p, 0); 495 if (*p) { 496 fprintf(stderr, 497 _("Invalid blocksize parameter: %s\n"), 498 arg); 499 do_usage++; 500 continue; 501 } 502 } else { 503 do_usage++; 504 badopt = token; 505 } 506 } 507 if (do_usage) { 508 fprintf(stderr, _("\nBad extended option(s) specified: %s\n\n" 509 "Extended options are separated by commas, " 510 "and may take an argument which\n" 511 "\tis set off by an equals ('=') sign.\n\n" 512 "Valid extended options are:\n" 513 "\tsuperblock=<superblock number>\n" 514 "\tblocksize=<blocksize>\n"), 515 badopt ? badopt : ""); 516 free(buf); 517 exit(1); 518 } 519 free(buf); 520} 521 522int main (int argc, char ** argv) 523{ 524 errcode_t retval; 525 ext2_filsys fs; 526 int print_badblocks = 0; 527 blk64_t use_superblock = 0; 528 int use_blocksize = 0; 529 int image_dump = 0; 530 int force = 0; 531 int flags; 532 int header_only = 0; 533 int c; 534 535#ifdef ENABLE_NLS 536 setlocale(LC_MESSAGES, ""); 537 setlocale(LC_CTYPE, ""); 538 bindtextdomain(NLS_CAT_NAME, LOCALEDIR); 539 textdomain(NLS_CAT_NAME); 540 set_com_err_gettext(gettext); 541#endif 542 add_error_table(&et_ext2_error_table); 543 fprintf (stderr, "dumpe2fs %s (%s)\n", E2FSPROGS_VERSION, 544 E2FSPROGS_DATE); 545 if (argc && *argv) 546 program_name = *argv; 547 548 while ((c = getopt (argc, argv, "bfhixVo:")) != EOF) { 549 switch (c) { 550 case 'b': 551 print_badblocks++; 552 break; 553 case 'f': 554 force++; 555 break; 556 case 'h': 557 header_only++; 558 break; 559 case 'i': 560 image_dump++; 561 break; 562 case 'o': 563 parse_extended_opts(optarg, &use_superblock, 564 &use_blocksize); 565 break; 566 case 'V': 567 /* Print version number and exit */ 568 fprintf(stderr, _("\tUsing %s\n"), 569 error_message(EXT2_ET_BASE)); 570 exit(0); 571 case 'x': 572 hex_format++; 573 break; 574 default: 575 usage(); 576 } 577 } 578 if (optind > argc - 1) 579 usage(); 580 device_name = argv[optind++]; 581 flags = EXT2_FLAG_JOURNAL_DEV_OK | EXT2_FLAG_SOFTSUPP_FEATURES | EXT2_FLAG_64BITS; 582 if (force) 583 flags |= EXT2_FLAG_FORCE; 584 if (image_dump) 585 flags |= EXT2_FLAG_IMAGE_FILE; 586 587 if (use_superblock && !use_blocksize) { 588 for (use_blocksize = EXT2_MIN_BLOCK_SIZE; 589 use_blocksize <= EXT2_MAX_BLOCK_SIZE; 590 use_blocksize *= 2) { 591 retval = ext2fs_open (device_name, flags, 592 use_superblock, 593 use_blocksize, unix_io_manager, 594 &fs); 595 if (!retval) 596 break; 597 } 598 } else 599 retval = ext2fs_open (device_name, flags, use_superblock, 600 use_blocksize, unix_io_manager, &fs); 601 if (retval) { 602 com_err (program_name, retval, _("while trying to open %s"), 603 device_name); 604 printf("%s", _("Couldn't find valid filesystem superblock.\n")); 605 exit (1); 606 } 607 fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE; 608 if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) 609 blocks64 = 1; 610 if (print_badblocks) { 611 list_bad_blocks(fs, 1); 612 } else { 613 list_super (fs->super); 614 if (fs->super->s_feature_incompat & 615 EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) { 616 print_journal_information(fs); 617 ext2fs_close(fs); 618 exit(0); 619 } 620 if ((fs->super->s_feature_compat & 621 EXT3_FEATURE_COMPAT_HAS_JOURNAL) && 622 (fs->super->s_journal_inum != 0)) 623 print_inline_journal_information(fs); 624 list_bad_blocks(fs, 0); 625 if (header_only) { 626 ext2fs_close (fs); 627 exit (0); 628 } 629 retval = ext2fs_read_bitmaps (fs); 630 list_desc (fs); 631 if (retval) { 632 printf(_("\n%s: %s: error reading bitmaps: %s\n"), 633 program_name, device_name, 634 error_message(retval)); 635 } 636 } 637 ext2fs_close (fs); 638 remove_error_table(&et_ext2_error_table); 639 exit (0); 640} 641