misc/findsuper.c

   1 /*
   2  * findsuper --- quick hacked up program to find ext2 superblocks.
   3  *
   4  * This is a hack, and really shouldn't be installed anywhere.  If you
   5  * need a program which does this sort of functionality, please try
   6  * using gpart program.
   7  *
   8  * Portions Copyright 1998-2000, Theodore Ts'o.
   9  *
  10  * Well, here's my linux version of findsuper.
  11  * I'm sure you coulda done it faster.  :)
  12  * IMHO there isn't as much interesting data to print in the
  13  * linux superblock as there is in the SunOS superblock--disk geometry is
  14  * not there...and linux seems to update the dates in all the superblocks.
  15  * SunOS doesn't ever touch the backup superblocks after the fs is created,
  16  * as far as I can tell, so the date is more interesting IMHO and certainly
  17  * marks which superblocks are backup ones.
  18  *
  19  * I wanted to add msdos support, but I couldn't make heads or tails
  20  * of the kernel include files to find anything I could look for in msdos.
  21  *
  22  * Reading every block of a Sun partition is fairly quick.  Doing the
  23  * same under linux (slower hardware I suppose) just isn't the same.
  24  * It might be more useful to default to reading the first (second?) block
  25  * on each cyl; however, if the disk geometry is wrong, this is useless.
  26  * But ya could still get the cyl size to print the numbers as cyls instead
  27  * of blocks...
  28  *
  29  * run this as (for example)
  30  *   findsuper /dev/hda
  31  *   findsuper /dev/hda 437760 1024   (my disk has cyls of 855*512)
  32  *
  33  * I suppose the next step is to figure out a way to determine if
  34  * the block found is the first superblock somehow, and if so, build
  35  * a partition table from the superblocks found... but this is still
  36  * useful as is.
  37  *
  38  *              Steve
  39  * ssd@nevets.oau.org
  40  * ssd@mae.engr.ucf.edu
  41  *
  42  * Additional notes by Andreas Dilger <adilger@turbolinux.com>:
  43  * - fixed to support > 2G devices by using lseek64
  44  * - add reliability checking for the superblock to avoid random garbage
  45  * - add adaptive progress meter
  46  *
  47  * It _should_ also handle signals and tell you the ending block, so
  48  * that you can resume at a later time, but it doesn't yet...
  49  *
  50  * Note that gpart does not appear to find all superblocks that aren't aligned
  51  * with the start of a possible partition, so it is not useful in systems
  52  * with LVM or similar setups which don't use fat partition alignment.
  53  *
  54  * %Begin-Header%
  55  * This file may be redistributed under the terms of the GNU Public
  56  * License.
  57  * %End-Header%
  58  */
  59
  60 /*
  61  * Documentation addendum added by Andreas dwguest@win.tue.nl/aeb@cwi.nl
  62  *
  63  * The program findsuper is a utility that scans a disk and finds
  64  * copies of ext2 superblocks (by checking for the ext2 signature).
  65  *
  66  * For each superblock found, it prints the offset in bytes, the
  67  * offset in 1024-byte blocks, the size of the ext2 partition in fs
  68  * blocks, the filesystem blocksize (in bytes), the block group number
  69  * (always 0 for older ext2 systems), and a timestamp (s_mtime).
  70  *
  71  * This program can be used to retrieve partitions that have been
  72  * lost.  The superblock for block group 0 is found 1 block (2
  73  * sectors) after the partition start.
  74  *
  75  * For new systems that have a block group number in the superblock it
  76  * is immediately clear which superblock is the first of a partition.
  77  * For old systems where no group numbers are given, the first
  78  * superblock can be recognized by the timestamp: all superblock
  79  * copies have the creation time in s_mtime, except the first, which
  80  * has the last time e2fsck or tune2fs wrote to the filesystem.
  81  *
  82  */
  83
  84 #define _FILE_OFFSET_BITS 64
  85
  86 #include "config.h"
  87 #include <stdio.h>
  88 #include <stdlib.h>
  89 #include <string.h>
  90 #include <unistd.h>
  91 #include <errno.h>
  92 #include <fcntl.h>
  93 #include <time.h>
  94
  95 #include "ext2fs/ext2_fs.h"
  96 #include "ext2fs/ext2fs.h"
  97 #include "support/nls-enable.h"
  98
  99 #undef DEBUG
 100
 101 #ifdef DEBUG
 102 #define WHY(fmt, arg...) { printf("\r%Ld: " fmt, sk, ##arg) ; continue; }
 103 #else
 104 #define WHY(fmt, arg...) { continue; }
 105 #endif
 106
 107 static void usage(void)
 108 {
 109         fprintf(stderr,
 110                 _("Usage:  findsuper device [skipbytes [startkb]]\n"));
 111         exit(1);
 112 }
 113
 114
 115 int main(int argc, char *argv[])
 116 {
 117         int skiprate=512;               /* one sector */
 118         ext2_loff_t sk=0, skl=0;
 119         int fd;
 120         char *s;
 121         time_t tm, last = time(0);
 122         ext2_loff_t interval = 1024 * 1024;
 123         int c, print_jnl_copies = 0;
 124         const char * device_name;
 125         struct ext2_super_block ext2;
 126         /* interesting fields: EXT2_SUPER_MAGIC
 127          *      s_blocks_count s_log_block_size s_mtime s_magic s_lastcheck */
 128
 129 #ifdef ENABLE_NLS
 130         setlocale(LC_MESSAGES, "");
 131         setlocale(LC_CTYPE, "");
 132         bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
 133         textdomain(NLS_CAT_NAME);
 134         set_com_err_gettext(gettext);
 135 #endif
 136
 137         while ((c = getopt (argc, argv, "j")) != EOF) {
 138                 switch (c) {
 139                 case 'j':
 140                         print_jnl_copies++;
 141                         break;
 142                 default:
 143                         usage();
 144                 }
 145         }
 146
 147         if (optind == argc)
 148                 usage();
 149
 150         device_name = argv[optind++];
 151
 152         if (optind < argc) {
 153                 skiprate = strtol(argv[optind], &s, 0);
 154                 if (s == argv[optind]) {
 155                         fprintf(stderr,_("skipbytes should be a number, not %s\n"), s);
 156                         exit(1);
 157                 }
 158                 optind++;
 159         }
 160         if (skiprate & 0x1ff) {
 161                 fprintf(stderr,
 162                         _("skipbytes must be a multiple of the sector size\n"));
 163                 exit(2);
 164         }
 165         if (optind < argc) {
 166                 sk = skl = strtoll(argv[optind], &s, 0) << 10;
 167                 if (s == argv[optind]) {
 168                         fprintf(stderr,
 169                                 _("startkb should be a number, not %s\n"), s);
 170                         exit(1);
 171                 }
 172                 optind++;
 173         }
 174         if (sk < 0) {
 175                 fprintf(stderr, _("startkb should be positive, not %llu\n"),sk);
 176                 exit(1);
 177         }
 178
 179         fd = open(device_name, O_RDONLY);
 180         if (fd < 0) {
 181                 perror(device_name);
 182                 exit(1);
 183         }
 184
 185         /* Now, go looking for the superblock! */
 186         printf(_("starting at %llu, with %u byte increments\n"), sk, skiprate);
 187         if (print_jnl_copies)
 188                 printf(_("[*] probably superblock written in the ext3 "
 189                          "journal superblock,\n\tso start/end/grp wrong\n"));
 190         printf(_("byte_offset  byte_start     byte_end  fs_blocks blksz  grp  mkfs/mount_time           sb_uuid label\n"));
 191         for (; lseek64(fd, sk, SEEK_SET) != -1 &&
 192                read(fd, &ext2, 512) == 512; sk += skiprate) {
 193                 static unsigned char last_uuid[16] = "blah";
 194                 unsigned long long bsize, grpsize;
 195                 int jnl_copy, sb_offset;
 196
 197                 if (sk && !(sk & (interval - 1))) {
 198                         time_t now, diff;
 199
 200                         now = time(0);
 201                         diff = now - last;
 202
 203                         if (diff > 0) {
 204                                 s = ctime(&now);
 205                                 s[24] = 0;
 206                                 printf("\r%11Lu: %8LukB/s @ %s", sk,
 207                                        (((sk - skl)) / diff) >> 10, s);
 208                                 fflush(stdout);
 209                         }
 210                         if (diff < 5)
 211                                 interval <<= 1;
 212                         else if (diff > 20)
 213                                 interval >>= 1;
 214                         last = now;
 215                         skl = sk;
 216                 }
 217                 if (ext2.s_magic != EXT2_SUPER_MAGIC)
 218                         continue;
 219                 if (ext2.s_log_block_size > 6)
 220                         WHY("log block size > 6 (%u)\n", ext2.s_log_block_size);
 221                 if (ext2fs_r_blocks_count(&ext2) > ext2fs_blocks_count(&ext2))
 222                         WHY("r_blocks_count > blocks_count (%u > %u)\n",
 223                             ext2fs_r_blocks_count(&ext2),
 224                             ext2fs_blocks_count(&ext2));
 225                 if (ext2fs_free_blocks_count(&ext2) > ext2fs_blocks_count(&ext2))
 226                         WHY("free_blocks_count > blocks_count\n (%u > %u)\n",
 227                             ext2fs_free_blocks_count(&ext2),
 228                             ext2fs_blocks_count(&ext2));
 229                 if (ext2.s_free_inodes_count > ext2.s_inodes_count)
 230                         WHY("free_inodes_count > inodes_count (%u > %u)\n",
 231                             ext2.s_free_inodes_count, ext2.s_inodes_count);
 232
 233                 if (ext2.s_mkfs_time != 0)
 234                         tm = ext2.s_mkfs_time;
 235                 else
 236                         tm = ext2.s_mtime;
 237                 s = ctime(&tm);
 238                 s[24] = 0;
 239                 bsize = 1 << (ext2.s_log_block_size + 10);
 240                 grpsize = bsize * ext2.s_blocks_per_group;
 241                 if (memcmp(ext2.s_uuid, last_uuid, sizeof(last_uuid)) == 0 &&
 242                     ext2.s_rev_level > 0 && ext2.s_block_group_nr == 0) {
 243                         jnl_copy = 1;
 244                 } else {
 245                         jnl_copy = 0;
 246                         memcpy(last_uuid, ext2.s_uuid, sizeof(last_uuid));
 247                 }
 248                 if (ext2.s_block_group_nr == 0 || bsize == 1024)
 249                         sb_offset = 1024;
 250                 else
 251                         sb_offset = 0;
 252                 if (jnl_copy && !print_jnl_copies)
 253                         continue;
 254                 printf("\r%11Lu %11Lu%s %11Lu%s %9u %5Lu %4u%s %s %02x%02x%02x%02x %.*s\n",
 255                        sk, sk - ext2.s_block_group_nr * grpsize - sb_offset,
 256                        jnl_copy ? "*":" ",
 257                        sk + ext2fs_blocks_count(&ext2) * bsize -
 258                             ext2.s_block_group_nr * grpsize - sb_offset,
 259                        jnl_copy ? "*" : " ", ext2fs_blocks_count(&ext2), bsize,
 260                        ext2.s_block_group_nr, jnl_copy ? "*" : " ", s,
 261                        ext2.s_uuid[0], ext2.s_uuid[1],
 262                        ext2.s_uuid[2], ext2.s_uuid[3],
 263                        EXT2_LEN_STR(ext2.s_volume_name));
 264         }
 265         printf(_("\n%11Lu: finished with errno %d\n"), sk, errno);
 266         close(fd);
 267
 268         return errno;
 269 }