growfs(8)/ffsinfo(8): Use __func__
[dragonfly.git] / sbin / ffsinfo / ffsinfo.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz
3 * Copyright (c) 1980, 1989, 1993 The Regents of the University of California.
4 * All rights reserved.
5 *
6 * This code is derived from software contributed to Berkeley by
7 * Christoph Herrmann and Thomas-Henning von Kamptz, Munich and Frankfurt.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgment:
19 * This product includes software developed by the University of
20 * California, Berkeley and its contributors, as well as Christoph
21 * Herrmann and Thomas-Henning von Kamptz.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 *
38 * $TSHeader: src/sbin/ffsinfo/ffsinfo.c,v 1.4 2000/12/12 19:30:55 tomsoft Exp $
39 * $FreeBSD: src/sbin/ffsinfo/ffsinfo.c,v 1.3.2.1 2001/07/16 15:01:56 tomsoft Exp $
40 *
1de703da
MD
41 * @(#) Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz Copyright (c) 1980, 1989, 1993 The Regents of the University of California. All rights reserved.
42 * $FreeBSD: src/sbin/ffsinfo/ffsinfo.c,v 1.3.2.1 2001/07/16 15:01:56 tomsoft Exp $
984263bc
MD
43 */
44
984263bc
MD
45/* ********************************************************** INCLUDES ***** */
46#include <sys/param.h>
595e3440 47#include <sys/diskslice.h>
984263bc
MD
48#include <sys/stat.h>
49
50#include <stdio.h>
51#include <paths.h>
52#include <ctype.h>
53#include <err.h>
54#include <fcntl.h>
55#include <stdlib.h>
56#include <string.h>
57#include <unistd.h>
58
59#include "debug.h"
60
61/* *********************************************************** GLOBALS ***** */
62#ifdef FS_DEBUG
63int _dbg_lvl_ = (DL_INFO); /* DL_TRC */
64#endif /* FS_DEBUG */
65
66static union {
67 struct fs fs;
68 char pad[SBSIZE];
69} fsun1, fsun2;
70#define sblock fsun1.fs
71#define osblock fsun2.fs
72
73static union {
74 struct cg cg;
75 char pad[MAXBSIZE];
76} cgun1;
77#define acg cgun1.cg
78
79static char ablk[MAXBSIZE];
80static char i1blk[MAXBSIZE];
81static char i2blk[MAXBSIZE];
82static char i3blk[MAXBSIZE];
83
84static struct csum *fscs;
85
86/* ******************************************************** PROTOTYPES ***** */
87static void rdfs(daddr_t, size_t, void *, int);
88static void usage(void);
67ad9090 89static struct ufs1_dinode *ginode(ino_t, int);
984263bc
MD
90static void dump_whole_inode(ino_t, int, int);
91
92/* ************************************************************** rdfs ***** */
93/*
94 * Here we read some block(s) from disk.
95 */
96void
97rdfs(daddr_t bno, size_t size, void *bf, int fsi)
98{
984263bc
MD
99 ssize_t n;
100
101 DBG_ENTER;
102
103 if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) {
104 err(33, "rdfs: seek error: %ld", (long)bno);
105 }
106 n = read(fsi, bf, size);
107 if (n != (ssize_t)size) {
108 err(34, "rdfs: read error: %ld", (long)bno);
109 }
110
111 DBG_LEAVE;
112 return;
113}
114
115/* ************************************************************** main ***** */
116/*
117 * ffsinfo(8) is a tool to dump all metadata of a filesystem. It helps to find
118 * errors is the filesystem much easier. You can run ffsinfo before and after
119 * an fsck(8), and compare the two ascii dumps easy with diff, and you see
120 * directly where the problem is. You can control how much detail you want to
121 * see with some command line arguments. You can also easy check the status
122 * of a filesystem, like is there is enough space for growing a filesystem,
123 * or how many active snapshots do we have. It provides much more detailed
124 * information then dumpfs. Snapshots, as they are very new, are not really
125 * supported. They are just mentioned currently, but it is planned to run
126 * also over active snapshots, to even get that output.
127 */
128int
129main(int argc, char **argv)
130{
984263bc
MD
131 char *device, *special, *cp;
132 char ch;
133 size_t len;
134 struct stat st;
595e3440 135 struct partinfo pinfo;
984263bc
MD
136 int fsi;
137 struct csum *dbg_csp;
138 int dbg_csc;
139 char dbg_line[80];
140 int cylno,i;
141 int cfg_cg, cfg_in, cfg_lv;
142 int cg_start, cg_stop;
143 ino_t in;
595e3440 144 char *out_file = NULL;
984263bc
MD
145 int Lflag=0;
146
147 DBG_ENTER;
148
149 cfg_lv=0xff;
150 cfg_in=-2;
151 cfg_cg=-2;
984263bc
MD
152
153 while ((ch=getopt(argc, argv, "Lg:i:l:o:")) != -1) {
154 switch(ch) {
155 case 'L':
156 Lflag=1;
157 break;
158 case 'g':
159 cfg_cg=atol(optarg);
160 if(cfg_cg < -1) {
161 usage();
162 }
163 break;
164 case 'i':
165 cfg_in=atol(optarg);
166 if(cfg_in < 0) {
167 usage();
168 }
169 break;
170 case 'l':
171 cfg_lv=atol(optarg);
172 if(cfg_lv < 0x1||cfg_lv > 0x3ff) {
173 usage();
174 }
175 break;
176 case 'o':
595e3440
MD
177 if (out_file)
178 free(out_file);
179 out_file = strdup(optarg);
984263bc
MD
180 break;
181 case '?':
182 /* FALLTHROUGH */
183 default:
184 usage();
185 }
186 }
187 argc -= optind;
188 argv += optind;
189
190 if(argc != 1) {
191 usage();
192 }
193 device=*argv;
194
195 /*
196 * Now we try to guess the (raw)device name.
197 */
198 if (0 == strrchr(device, '/') && (stat(device, &st) == -1)) {
199 /*
200 * No path prefix was given, so try in that order:
201 * /dev/r%s
202 * /dev/%s
203 * /dev/vinum/r%s
204 * /dev/vinum/%s.
205 *
206 * FreeBSD now doesn't distinguish between raw and block
207 * devices any longer, but it should still work this way.
208 */
209 len=strlen(device)+strlen(_PATH_DEV)+2+strlen("vinum/");
210 special=(char *)malloc(len);
211 if(special == NULL) {
212 errx(1, "malloc failed");
213 }
214 snprintf(special, len, "%sr%s", _PATH_DEV, device);
215 if (stat(special, &st) == -1) {
216 snprintf(special, len, "%s%s", _PATH_DEV, device);
217 if (stat(special, &st) == -1) {
218 snprintf(special, len, "%svinum/r%s",
219 _PATH_DEV, device);
220 if (stat(special, &st) == -1) {
221 /*
222 * For now this is the 'last resort'.
223 */
224 snprintf(special, len, "%svinum/%s",
225 _PATH_DEV, device);
226 }
227 }
228 }
229 device = special;
230 }
231
232 /*
233 * Open our device for reading.
234 */
235 fsi = open(device, O_RDONLY);
236 if (fsi < 0) {
237 err(1, "%s", device);
238 }
239
240 stat(device, &st);
241
242 if(S_ISREG(st.st_mode)) { /* label check not supported for files */
243 Lflag=1;
244 }
245
246 if(!Lflag) {
247 /*
248 * Try to read a label and gess the slice if not specified.
249 * This code should guess the right thing and avaid to bother
250 * the user user with the task of specifying the option -v on
251 * vinum volumes.
252 */
595e3440
MD
253 cp = device+strlen(device)-1;
254 if (ioctl(fsi, DIOCGPART, &pinfo) < 0) {
255 pinfo.media_size = st.st_size;
256 pinfo.media_blksize = DEV_BSIZE;
257 pinfo.media_blocks = pinfo.media_size / DEV_BSIZE;
984263bc
MD
258 }
259
260 /*
261 * Check if that partition looks suited for dumping.
262 */
595e3440 263 if (pinfo.media_size == 0) {
984263bc
MD
264 errx(1, "partition is unavailable");
265 }
984263bc
MD
266 }
267
268 /*
269 * Read the current superblock.
270 */
4e1af74f 271 rdfs((daddr_t)(SBOFF/DEV_BSIZE), (size_t)SBSIZE, &sblock, fsi);
984263bc
MD
272 if (sblock.fs_magic != FS_MAGIC) {
273 errx(1, "superblock not recognized");
274 }
275
276 DBG_OPEN(out_file); /* already here we need a superblock */
277
278 if(cfg_lv & 0x001) {
279 DBG_DUMP_FS(&sblock,
280 "primary sblock");
281 }
282
283 /*
284 * Determine here what cylinder groups to dump.
285 */
286 if(cfg_cg==-2) {
287 cg_start=0;
288 cg_stop=sblock.fs_ncg;
289 } else if (cfg_cg==-1) {
290 cg_start=sblock.fs_ncg-1;
291 cg_stop=sblock.fs_ncg;
292 } else if (cfg_cg<sblock.fs_ncg) {
293 cg_start=cfg_cg;
294 cg_stop=cfg_cg+1;
295 } else {
296 cg_start=sblock.fs_ncg;
297 cg_stop=sblock.fs_ncg;
298 }
299
300 if (cfg_lv & 0x004) {
301 fscs = (struct csum *)calloc((size_t)1,
302 (size_t)sblock.fs_cssize);
303 if(fscs == NULL) {
304 errx(1, "calloc failed");
305 }
306
307 /*
308 * Get the cylinder summary into the memory ...
309 */
310 for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
311 rdfs(fsbtodb(&sblock, sblock.fs_csaddr +
312 numfrags(&sblock, i)), (size_t)(sblock.fs_cssize-i<
313 sblock.fs_bsize ? sblock.fs_cssize - i :
314 sblock.fs_bsize), (void *)(((char *)fscs)+i), fsi);
315 }
316
317 dbg_csp=fscs;
318 /*
319 * ... and dump it.
320 */
321 for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) {
322 snprintf(dbg_line, sizeof(dbg_line),
323 "%d. csum in fscs", dbg_csc);
324 DBG_DUMP_CSUM(&sblock,
325 dbg_line,
326 dbg_csp++);
327 }
328 }
329
330 /*
331 * For each requested cylinder group ...
332 */
333 for(cylno=cg_start; cylno<cg_stop; cylno++) {
334 snprintf(dbg_line, sizeof(dbg_line), "cgr %d", cylno);
335 if(cfg_lv & 0x002) {
336 /*
337 * ... dump the superblock copies ...
338 */
339 rdfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
4e1af74f 340 (size_t)SBSIZE, &osblock, fsi);
984263bc
MD
341 DBG_DUMP_FS(&osblock,
342 dbg_line);
343 }
344 /*
345 * ... read the cylinder group and dump whatever was requested.
346 */
347 rdfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
4e1af74f 348 (size_t)sblock.fs_cgsize, &acg, fsi);
984263bc
MD
349 if(cfg_lv & 0x008) {
350 DBG_DUMP_CG(&sblock,
351 dbg_line,
352 &acg);
353 }
354 if(cfg_lv & 0x010) {
355 DBG_DUMP_INMAP(&sblock,
356 dbg_line,
357 &acg);
358 }
359 if(cfg_lv & 0x020) {
360 DBG_DUMP_FRMAP(&sblock,
361 dbg_line,
362 &acg);
363 }
364 if(cfg_lv & 0x040) {
365 DBG_DUMP_CLMAP(&sblock,
366 dbg_line,
367 &acg);
368 DBG_DUMP_CLSUM(&sblock,
369 dbg_line,
370 &acg);
371 }
372 if(cfg_lv & 0x080) {
373 DBG_DUMP_SPTBL(&sblock,
374 dbg_line,
375 &acg);
376 }
377 }
378 /*
379 * Dump the requested inode(s).
380 */
381 if(cfg_in != -2) {
382 dump_whole_inode((ino_t)cfg_in, fsi, cfg_lv);
383 } else {
384 for(in=cg_start*sblock.fs_ipg; in<(ino_t)cg_stop*sblock.fs_ipg;
385 in++) {
386 dump_whole_inode(in, fsi, cfg_lv);
387 }
388 }
389
390 DBG_CLOSE;
391
392 close(fsi);
393
394 DBG_LEAVE;
395 return 0;
396}
397
398/* ************************************************** dump_whole_inode ***** */
399/*
400 * Here we dump a list of all blocks allocated by this inode. We follow
401 * all indirect blocks.
402 */
403void
404dump_whole_inode(ino_t inode, int fsi, int level)
405{
67ad9090 406 struct ufs1_dinode *ino;
984263bc
MD
407 int rb;
408 unsigned int ind2ctr, ind3ctr;
409 ufs_daddr_t *ind2ptr, *ind3ptr;
410 char comment[80];
411
412 DBG_ENTER;
413
414 /*
415 * Read the inode from disk/cache.
416 */
417 ino=ginode(inode, fsi);
418
419 if(ino->di_nlink==0) {
420 DBG_LEAVE;
421 return; /* inode not in use */
422 }
423
424 /*
425 * Dump the main inode structure.
426 */
d5d88fdc 427 snprintf(comment, sizeof(comment), "Inode 0x%08jx", (uintmax_t)inode);
984263bc
MD
428 if (level & 0x100) {
429 DBG_DUMP_INO(&sblock,
430 comment,
431 ino);
432 }
433
434 if (!(level & 0x200)) {
435 DBG_LEAVE;
436 return;
437 }
438
439 /*
440 * Ok, now prepare for dumping all direct and indirect pointers.
441 */
442 rb=howmany(ino->di_size, sblock.fs_bsize)-NDADDR;
443 if(rb>0) {
444 /*
445 * Dump single indirect block.
446 */
447 rdfs(fsbtodb(&sblock, ino->di_ib[0]), (size_t)sblock.fs_bsize,
4e1af74f 448 &i1blk, fsi);
d5d88fdc
SW
449 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 0",
450 (uintmax_t)inode);
984263bc
MD
451 DBG_DUMP_IBLK(&sblock,
452 comment,
453 i1blk,
454 (size_t)rb);
455 rb-=howmany(sblock.fs_bsize, sizeof(ufs_daddr_t));
456 }
457 if(rb>0) {
458 /*
459 * Dump double indirect blocks.
460 */
461 rdfs(fsbtodb(&sblock, ino->di_ib[1]), (size_t)sblock.fs_bsize,
4e1af74f 462 &i2blk, fsi);
d5d88fdc
SW
463 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 1",
464 (uintmax_t)inode);
984263bc
MD
465 DBG_DUMP_IBLK(&sblock,
466 comment,
467 i2blk,
468 howmany(rb, howmany(sblock.fs_bsize, sizeof(ufs_daddr_t))));
469 for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize,
470 sizeof(ufs_daddr_t)))&&(rb>0)); ind2ctr++) {
471 ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)[ind2ctr];
472
473 rdfs(fsbtodb(&sblock, *ind2ptr),
4e1af74f 474 (size_t)sblock.fs_bsize, &i1blk, fsi);
984263bc 475 snprintf(comment, sizeof(comment),
d5d88fdc
SW
476 "Inode 0x%08jx: indirect 1->%d", (uintmax_t)inode,
477 ind2ctr);
984263bc
MD
478 DBG_DUMP_IBLK(&sblock,
479 comment,
480 i1blk,
481 (size_t)rb);
482 rb-=howmany(sblock.fs_bsize, sizeof(ufs_daddr_t));
483 }
484 }
485 if(rb>0) {
486 /*
487 * Dump triple indirect blocks.
488 */
489 rdfs(fsbtodb(&sblock, ino->di_ib[2]), (size_t)sblock.fs_bsize,
4e1af74f 490 &i3blk, fsi);
d5d88fdc
SW
491 snprintf(comment, sizeof(comment), "Inode 0x%08jx: indirect 2",
492 (uintmax_t)inode);
984263bc
MD
493#define SQUARE(a) ((a)*(a))
494 DBG_DUMP_IBLK(&sblock,
495 comment,
496 i3blk,
497 howmany(rb,
498 SQUARE(howmany(sblock.fs_bsize, sizeof(ufs_daddr_t)))));
499#undef SQUARE
500 for(ind3ctr=0; ((ind3ctr < howmany(sblock.fs_bsize,
501 sizeof(ufs_daddr_t)))&&(rb>0)); ind3ctr ++) {
502 ind3ptr=&((ufs_daddr_t *)(void *)&i3blk)[ind3ctr];
503
504 rdfs(fsbtodb(&sblock, *ind3ptr),
4e1af74f 505 (size_t)sblock.fs_bsize, &i2blk, fsi);
984263bc 506 snprintf(comment, sizeof(comment),
d5d88fdc
SW
507 "Inode 0x%08jx: indirect 2->%d", (uintmax_t)inode,
508 ind3ctr);
984263bc
MD
509 DBG_DUMP_IBLK(&sblock,
510 comment,
511 i2blk,
512 howmany(rb,
513 howmany(sblock.fs_bsize, sizeof(ufs_daddr_t))));
514 for(ind2ctr=0; ((ind2ctr < howmany(sblock.fs_bsize,
515 sizeof(ufs_daddr_t)))&&(rb>0)); ind2ctr ++) {
516 ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)
517 [ind2ctr];
518 rdfs(fsbtodb(&sblock, *ind2ptr),
4e1af74f 519 (size_t)sblock.fs_bsize, &i1blk, fsi);
984263bc 520 snprintf(comment, sizeof(comment),
d5d88fdc
SW
521 "Inode 0x%08jx: indirect 2->%d->%d",
522 (uintmax_t)inode, ind3ctr, ind3ctr);
984263bc
MD
523 DBG_DUMP_IBLK(&sblock,
524 comment,
525 i1blk,
526 (size_t)rb);
527 rb-=howmany(sblock.fs_bsize,
528 sizeof(ufs_daddr_t));
529 }
530 }
531 }
532
533 DBG_LEAVE;
534 return;
535}
536
984263bc
MD
537/* ************************************************************* usage ***** */
538/*
539 * Dump a line of usage.
540 */
541void
542usage(void)
543{
984263bc
MD
544 DBG_ENTER;
545
546 fprintf(stderr,
547 "usage: ffsinfo [-L] [-g cylgrp] [-i inode] [-l level] "
548 "[-o outfile]\n"
549 " special | file\n");
550
551 DBG_LEAVE;
552 exit(1);
553}
554
555/* ************************************************************ ginode ***** */
556/*
557 * This function provides access to an individual inode. We find out in which
558 * block the requested inode is located, read it from disk if needed, and
559 * return the pointer into that block. We maintain a cache of one block to
560 * not read the same block again and again if we iterate linearly over all
561 * inodes.
562 */
67ad9090 563struct ufs1_dinode *
984263bc
MD
564ginode(ino_t inumber, int fsi)
565{
984263bc
MD
566 ufs_daddr_t iblk;
567 static ino_t startinum=0; /* first inode in cached block */
67ad9090 568 struct ufs1_dinode *pi;
984263bc
MD
569
570 DBG_ENTER;
571
67ad9090 572 pi=(struct ufs1_dinode *)(void *)ablk;
984263bc
MD
573 if (startinum == 0 || inumber < startinum ||
574 inumber >= startinum + INOPB(&sblock)) {
575 /*
576 * The block needed is not cached, so we have to read it from
577 * disk now.
578 */
579 iblk = ino_to_fsba(&sblock, inumber);
580 rdfs(fsbtodb(&sblock, iblk), (size_t)sblock.fs_bsize,
4e1af74f 581 &ablk, fsi);
984263bc
MD
582 startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
583 }
584
585 DBG_LEAVE;
586 return (&(pi[inumber % INOPB(&sblock)]));
587}
588