/* * findsuper --- quick hacked up program to find ext2 superblocks. * * This is a hack, and really shouldn't be installed anywhere. If you * need a program which does this sort of functionality, please try * using gpart program. * * Portions Copyright 1998-2000, Theodore Ts'o. * * This program may be used under the provisions of the GNU Public * License, *EXCEPT* that a binary copy of the executable may not be * packaged as a part of binary package which is distributed as part * of a Linux distribution. (Yes, this violates the Debian Free * Software Guidelines in terms of restricting its field of use. * That's the point. I don't want this program being distributed in * Debian, because I don't care to support it, and the maintainer, * Yann Dirson, doesn't seem to pay attention to my wishes on this * matter. So I'm delibiately adding this clause so it violates the * Debian Free Software Guidelines to force him to take it out. If * this doesn't work, I'll have to remove it from the upstream source * distribution at the next release. End of Rant. :-) * * * Well, here's my linux version of findsuper. * I'm sure you coulda done it faster. :) * IMHO there isn't as much interesting data to print in the * linux superblock as there is in the SunOS superblock--disk geometry is * not there...and linux seems to update the dates in all the superblocks. * SunOS doesn't ever touch the backup superblocks after the fs is created, * as far as I can tell, so the date is more interesting IMHO and certainly * marks which superblocks are backup ones. * * I wanted to add msdos support, but I couldn't make heads or tails * of the kernel include files to find anything I could look for in msdos. * * Reading every block of a Sun partition is fairly quick. Doing the * same under linux (slower hardware I suppose) just isn't the same. * It might be more useful to default to reading the first (second?) block * on each cyl; however, if the disk geometry is wrong, this is useless. * But ya could still get the cyl size to print the numbers as cyls instead * of blocks... * * run this as (for example) * findsuper /dev/hda * findsuper /dev/hda 437760 1024 (my disk has cyls of 855*512) * * I suppose the next step is to figgure out a way to determine if * the block found is the first superblock somehow, and if so, build * a partition table from the superblocks found... but this is still * useful as is. * * Steve * ssd@nevets.oau.org * ssd@mae.engr.ucf.edu * * Additional notes by Andreas Dilger : * - fixed to support > 2G devices by using lseek64 * - add reliability checking for the superblock to avoid random garbage * - add adaptive progress meter * * It _should_ also handle signals and tell you the ending block, so * that you can resume at a later time, but it doesn't yet... * * Note that gpart does not appear to find all superblocks that aren't aligned * with the start of a possible partition, so it is not useful in systems * with LVM or similar setups which don't use fat partition alignment. */ /* * Documentation addendum added by Andreas dwguest@win.tue.nl/aeb@cwi.nl * * The program findsuper is a utility that scans a disk and finds * copies of ext2 superblocks (by checking for the ext2 signature * * For each superblock found, it prints the offset in bytes, the * offset in 1024-byte blocks, the size of ext2 partition in fs * blocks, the filesystem blocksize (in bytes), the block group number * (always 0 for older ext2 systems), and a timestamp (s_mtime). * * This program can be used to retrieve partitions that have been * lost. The superblock for block group 0 is found 1 block (2 * sectors) after the partition start. * * For new systems that have a block group number in the superblock it * is immediately clear which superblock is the first of a partition. * For old systems where no group numbers are given, the first * superblock can be recognised by the timestamp: all superblock * copies have the creation time in s_mtime, except the first, which * has the last time e2fsck or tune2fs wrote to the filesystem. * */ #define _FILE_OFFSET_BITS 64 #include #include #include #include #include #include #include #include "ext2fs/ext2_fs.h" #include "nls-enable.h" #undef DEBUG #ifdef DEBUG #define WHY(fmt, arg...) { printf("\r%Ld: " fmt, sk, ##arg) ; continue; } #else #define WHY(fmt, arg...) { continue; } #endif int main(int argc, char *argv[]) { int skiprate=512; /* one sector */ loff_t sk=0, skl=0; int fd; char *s; time_t tm, last = time(0); loff_t interval = 1024 * 1024; struct ext2_super_block ext2; /* interesting fields: EXT2_SUPER_MAGIC * s_blocks_count s_log_block_size s_mtime s_magic s_lastcheck */ #ifdef ENABLE_NLS setlocale(LC_MESSAGES, ""); setlocale(LC_CTYPE, ""); bindtextdomain(NLS_CAT_NAME, LOCALEDIR); textdomain(NLS_CAT_NAME); #endif if (argc<2) { fprintf(stderr, _("Usage: findsuper device [skipbytes [startkb]]\n")); exit(1); } if (argc>2) skiprate = strtol(argv[2], &s, 0); if (s == argv[2]) { fprintf(stderr,_("skiprate should be a number, not %s\n"), s); exit(1); } if (skiprate & 0x1ff) { fprintf(stderr, _("skipbytes must be a multiple of the sector size\n")); exit(2); } if (argc>3) sk = skl = strtoll(argv[3], &s, 0) << 10; if (s == argv[3]) { fprintf(stderr,_("startkb should be a number, not %s\n"), s); exit(1); } if (sk < 0) { fprintf(stderr,_("startkb should be positive, not %Ld\n"), sk); exit(1); } fd = open(argv[1], O_RDONLY); if (fd < 0) { perror(argv[1]); exit(1); } /* Now, go looking for the superblock ! */ printf(_("starting at %Ld, with %d byte increments\n"), sk, skiprate); printf(_(" thisoff block fs_blk_sz blksz grp last_mount\n")); for (; lseek64(fd, sk, SEEK_SET) != -1 && read(fd, &ext2, 512) == 512; sk += skiprate) { if (sk && !(sk & (interval - 1))) { time_t now, diff; now = time(0); diff = now - last; if (diff > 0) { s = ctime(&now); s[24] = 0; printf("\r%14Ld: %8LdkB/s @ %s", sk, (((sk - skl)) / diff) >> 10, s); fflush(stdout); } if (diff < 5) interval <<= 1; else if (diff > 20) interval >>= 1; last = now; skl = sk; } if (ext2.s_magic != EXT2_SUPER_MAGIC) continue; if (ext2.s_log_block_size > 4) WHY("log block size > 4 (%d)\n", ext2.s_log_block_size); if (ext2.s_r_blocks_count > ext2.s_blocks_count) WHY("r_blocks_count > blocks_count (%d > %d)\n", ext2.s_r_blocks_count, ext2.s_blocks_count); if (ext2.s_free_blocks_count > ext2.s_blocks_count) WHY("free_blocks_count > blocks_count\n (%d > %d)\n", ext2.s_free_blocks_count, ext2.s_blocks_count); if (ext2.s_free_inodes_count > ext2.s_inodes_count) WHY("free_inodes_count > inodes_count (%d > %d)\n", ext2.s_free_inodes_count, ext2.s_inodes_count); tm = ext2.s_mtime; s=ctime(&tm); s[24]=0; printf("\r%14Ld %9Ld %9d %5d %4d %s\n", sk, sk >> 10, ext2.s_blocks_count, 1 << (ext2.s_log_block_size + 10), ext2.s_block_group_nr, s); } printf(_("\n%14Ld: finished with errno %d\n"), sk, errno); close(fd); return errno; }