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 figgure 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 (at) nevets.oau.org 40 * ssd (at) mae.engr.ucf.edu 41 * 42 * Additional notes by Andreas Dilger <adilger (at) 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 (at) win.tue.nl/aeb (at) 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 recognised 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 loff_t sk=0, skl=0; 119 int fd; 120 char *s; 121 time_t tm, last = time(0); 122 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], ext2.s_volume_name); 263 } 264 printf(_("\n%11Lu: finished with errno %d\n"), sk, errno); 265 close(fd); 266 267 return errno; 268 } 269
