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@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 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 <stdio.h>
87 #include <stdlib.h>
88 #include <string.h>
89 #include <unistd.h>
90 #include <errno.h>
91 #include <fcntl.h>
92 #include <time.h>
93
94 #include "ext2fs/ext2_fs.h"
95 #include "ext2fs/ext2fs.h"
96 #include "nls-enable.h"
97
98 #undef DEBUG
99
100 #ifdef DEBUG
101 #define WHY(fmt, arg...) { printf("\r%Ld: " fmt, sk, ##arg) ; continue; }
102 #else
103 #define WHY(fmt, arg...) { continue; }
104 #endif
105
usage(void)106 static void usage(void)
107 {
108 fprintf(stderr,
109 _("Usage: findsuper device [skipbytes [startkb]]\n"));
110 exit(1);
111 }
112
113
main(int argc,char * argv[])114 int main(int argc, char *argv[])
115 {
116 int skiprate=512; /* one sector */
117 loff_t sk=0, skl=0;
118 int fd;
119 char *s;
120 time_t tm, last = time(0);
121 loff_t interval = 1024 * 1024;
122 int c, print_jnl_copies = 0;
123 const char * device_name;
124 struct ext2_super_block ext2;
125 /* interesting fields: EXT2_SUPER_MAGIC
126 * s_blocks_count s_log_block_size s_mtime s_magic s_lastcheck */
127
128 #ifdef ENABLE_NLS
129 setlocale(LC_MESSAGES, "");
130 setlocale(LC_CTYPE, "");
131 bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
132 textdomain(NLS_CAT_NAME);
133 set_com_err_gettext(gettext);
134 #endif
135
136 while ((c = getopt (argc, argv, "j")) != EOF) {
137 switch (c) {
138 case 'j':
139 print_jnl_copies++;
140 break;
141 default:
142 usage();
143 }
144 }
145
146 if (optind == argc)
147 usage();
148
149 device_name = argv[optind++];
150
151 if (optind < argc) {
152 skiprate = strtol(argv[optind], &s, 0);
153 if (s == argv[optind]) {
154 fprintf(stderr,_("skipbytes should be a number, not %s\n"), s);
155 exit(1);
156 }
157 optind++;
158 }
159 if (skiprate & 0x1ff) {
160 fprintf(stderr,
161 _("skipbytes must be a multiple of the sector size\n"));
162 exit(2);
163 }
164 if (optind < argc) {
165 sk = skl = strtoll(argv[optind], &s, 0) << 10;
166 if (s == argv[optind]) {
167 fprintf(stderr,
168 _("startkb should be a number, not %s\n"), s);
169 exit(1);
170 }
171 optind++;
172 }
173 if (sk < 0) {
174 fprintf(stderr, _("startkb should be positive, not %llu\n"),sk);
175 exit(1);
176 }
177
178 fd = open(device_name, O_RDONLY);
179 if (fd < 0) {
180 perror(device_name);
181 exit(1);
182 }
183
184 /* Now, go looking for the superblock! */
185 printf(_("starting at %llu, with %u byte increments\n"), sk, skiprate);
186 if (print_jnl_copies)
187 printf(_("[*] probably superblock written in the ext3 "
188 "journal superblock,\n\tso start/end/grp wrong\n"));
189 printf(_("byte_offset byte_start byte_end fs_blocks blksz grp last_mount_time sb_uuid label\n"));
190 for (; lseek64(fd, sk, SEEK_SET) != -1 &&
191 read(fd, &ext2, 512) == 512; sk += skiprate) {
192 static unsigned char last_uuid[16] = "blah";
193 unsigned long long bsize, grpsize;
194 int jnl_copy, sb_offset;
195
196 if (sk && !(sk & (interval - 1))) {
197 time_t now, diff;
198
199 now = time(0);
200 diff = now - last;
201
202 if (diff > 0) {
203 s = ctime(&now);
204 s[24] = 0;
205 printf("\r%11Lu: %8LukB/s @ %s", sk,
206 (((sk - skl)) / diff) >> 10, s);
207 fflush(stdout);
208 }
209 if (diff < 5)
210 interval <<= 1;
211 else if (diff > 20)
212 interval >>= 1;
213 last = now;
214 skl = sk;
215 }
216 if (ext2.s_magic != EXT2_SUPER_MAGIC)
217 continue;
218 if (ext2.s_log_block_size > 6)
219 WHY("log block size > 6 (%u)\n", ext2.s_log_block_size);
220 if (ext2fs_r_blocks_count(&ext2) > ext2fs_blocks_count(&ext2))
221 WHY("r_blocks_count > blocks_count (%u > %u)\n",
222 ext2fs_r_blocks_count(&ext2),
223 ext2fs_blocks_count(&ext2));
224 if (ext2fs_free_blocks_count(&ext2) > ext2fs_blocks_count(&ext2))
225 WHY("free_blocks_count > blocks_count\n (%u > %u)\n",
226 ext2fs_free_blocks_count(&ext2),
227 ext2fs_blocks_count(&ext2));
228 if (ext2.s_free_inodes_count > ext2.s_inodes_count)
229 WHY("free_inodes_count > inodes_count (%u > %u)\n",
230 ext2.s_free_inodes_count, ext2.s_inodes_count);
231
232 tm = ext2.s_mtime;
233 s = ctime(&tm);
234 s[24] = 0;
235 bsize = 1 << (ext2.s_log_block_size + 10);
236 grpsize = bsize * ext2.s_blocks_per_group;
237 if (memcmp(ext2.s_uuid, last_uuid, sizeof(last_uuid)) == 0 &&
238 ext2.s_rev_level > 0 && ext2.s_block_group_nr == 0) {
239 jnl_copy = 1;
240 } else {
241 jnl_copy = 0;
242 memcpy(last_uuid, ext2.s_uuid, sizeof(last_uuid));
243 }
244 if (ext2.s_block_group_nr == 0 || bsize == 1024)
245 sb_offset = 1024;
246 else
247 sb_offset = 0;
248 if (jnl_copy && !print_jnl_copies)
249 continue;
250 printf("\r%11Lu %11Lu%s %11Lu%s %9u %5Lu %4u%s %s %02x%02x%02x%02x %s\n",
251 sk, sk - ext2.s_block_group_nr * grpsize - sb_offset,
252 jnl_copy ? "*":" ",
253 sk + ext2fs_blocks_count(&ext2) * bsize -
254 ext2.s_block_group_nr * grpsize - sb_offset,
255 jnl_copy ? "*" : " ", ext2fs_blocks_count(&ext2), bsize,
256 ext2.s_block_group_nr, jnl_copy ? "*" : " ", s,
257 ext2.s_uuid[0], ext2.s_uuid[1],
258 ext2.s_uuid[2], ext2.s_uuid[3], ext2.s_volume_name);
259 }
260 printf(_("\n%11Lu: finished with errno %d\n"), sk, errno);
261 close(fd);
262
263 return errno;
264 }
265