e2fsprogs/misc/findsuper.c

218 lines
7.2 KiB
C

/*
* 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 <adilger@turbolinux.com>:
* - 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <time.h>
#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;
}