87d35aadd9
to create it. A small number of options are not marshalled as they are things it would be dumb to spit out, as they are used by internal computations, and newfs may change them, or they may not be directly apparent.
400 lines
11 KiB
C
400 lines
11 KiB
C
/*
|
|
* Copyright (c) 2002 Networks Associates Technology, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This software was developed for the FreeBSD Project by Marshall
|
|
* Kirk McKusick and Network Associates Laboratories, the Security
|
|
* Research Division of Network Associates, Inc. under DARPA/SPAWAR
|
|
* contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
|
|
* research program
|
|
*
|
|
* Copyright (c) 1982, 1989, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
* (c) UNIX System Laboratories, Inc.
|
|
* Copyright (c) 1983, 1992, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static const char copyright[] =
|
|
"@(#) Copyright (c) 1983, 1992, 1993\n\
|
|
The Regents of the University of California. All rights reserved.\n";
|
|
#endif /* not lint */
|
|
|
|
#ifndef lint
|
|
#if 0
|
|
static char sccsid[] = "@(#)dumpfs.c 8.5 (Berkeley) 4/29/95";
|
|
#endif
|
|
static const char rcsid[] =
|
|
"$FreeBSD$";
|
|
#endif /* not lint */
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/time.h>
|
|
#include <sys/disklabel.h>
|
|
|
|
#include <ufs/ufs/dinode.h>
|
|
#include <ufs/ffs/fs.h>
|
|
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <fstab.h>
|
|
#include <libufs.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
|
|
#define afs disk.d_fs
|
|
#define acg disk.d_cg
|
|
|
|
struct uufsd disk;
|
|
|
|
int dumpfs(const char *);
|
|
int dumpcg(void);
|
|
int marshal(const char *);
|
|
void pbits(void *, int);
|
|
void ufserr(const char *);
|
|
void usage(void) __dead2;
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
const char *name;
|
|
int ch, domarshal, eval;
|
|
|
|
domarshal = eval = 0;
|
|
|
|
while ((ch = getopt(argc, argv, "m")) != -1) {
|
|
switch (ch) {
|
|
case 'm':
|
|
domarshal = 1;
|
|
break;
|
|
case '?':
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (argc < 1)
|
|
usage();
|
|
|
|
while ((name = *argv++) != NULL) {
|
|
if (ufs_disk_fillout(&disk, name) == -1) {
|
|
ufserr(name);
|
|
eval |= 1;
|
|
continue;
|
|
}
|
|
if (domarshal)
|
|
eval |= marshal(name);
|
|
else
|
|
eval |= dumpfs(name);
|
|
ufs_disk_close(&disk);
|
|
}
|
|
exit(eval);
|
|
}
|
|
|
|
int
|
|
dumpfs(const char *name)
|
|
{
|
|
time_t time;
|
|
int64_t fssize;
|
|
int i;
|
|
|
|
switch (disk.d_ufs) {
|
|
case 2:
|
|
fssize = afs.fs_size;
|
|
time = afs.fs_time;
|
|
printf("magic\t%x (UFS2)\ttime\t%s",
|
|
afs.fs_magic, ctime(&time));
|
|
printf("superblock location\t%qd\tid\t[ %x %x ]\n",
|
|
afs.fs_sblockloc, afs.fs_id[0], afs.fs_id[1]);
|
|
printf("ncg\t%d\tsize\t%qd\tblocks\t%d\n",
|
|
afs.fs_ncg, fssize, afs.fs_dsize);
|
|
break;
|
|
case 1:
|
|
fssize = afs.fs_old_size;
|
|
time = afs.fs_old_time;
|
|
printf("magic\t%x (UFS1)\ttime\t%s",
|
|
afs.fs_magic, ctime(&time));
|
|
printf("id\t[ %x %x ]\n", afs.fs_id[0], afs.fs_id[1]);
|
|
printf("ncg\t%d\tsize\t%qd\tblocks\t%d\n",
|
|
afs.fs_ncg, fssize, afs.fs_dsize);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
printf("bsize\t%d\tshift\t%d\tmask\t0x%08x\n",
|
|
afs.fs_bsize, afs.fs_bshift, afs.fs_bmask);
|
|
printf("fsize\t%d\tshift\t%d\tmask\t0x%08x\n",
|
|
afs.fs_fsize, afs.fs_fshift, afs.fs_fmask);
|
|
printf("frag\t%d\tshift\t%d\tfsbtodb\t%d\n",
|
|
afs.fs_frag, afs.fs_fragshift, afs.fs_fsbtodb);
|
|
printf("minfree\t%d%%\toptim\t%s\tsymlinklen %d\n",
|
|
afs.fs_minfree, afs.fs_optim == FS_OPTSPACE ? "space" : "time",
|
|
afs.fs_maxsymlinklen);
|
|
switch (disk.d_ufs) {
|
|
case 2:
|
|
printf("%s %d\tmaxbpg\t%d\tmaxcontig %d\tcontigsumsize %d\n",
|
|
"maxbsize", afs.fs_maxbsize, afs.fs_maxbpg,
|
|
afs.fs_maxcontig, afs.fs_contigsumsize);
|
|
printf("nbfree\t%qd\tndir\t%qd\tnifree\t%qd\tnffree\t%qd\n",
|
|
afs.fs_cstotal.cs_nbfree, afs.fs_cstotal.cs_ndir,
|
|
afs.fs_cstotal.cs_nifree, afs.fs_cstotal.cs_nffree);
|
|
printf("bpg\t%d\tfpg\t%d\tipg\t%d\n",
|
|
afs.fs_fpg / afs.fs_frag, afs.fs_fpg, afs.fs_ipg);
|
|
printf("nindir\t%d\tinopb\t%d\tmaxfilesize\t%qu\n",
|
|
afs.fs_nindir, afs.fs_inopb, afs.fs_maxfilesize);
|
|
printf("sbsize\t%d\tcgsize\t%d\tcsaddr\t%d\tcssize\t%d\n",
|
|
afs.fs_sbsize, afs.fs_cgsize, afs.fs_csaddr, afs.fs_cssize);
|
|
break;
|
|
case 1:
|
|
printf("maxbpg\t%d\tmaxcontig %d\tcontigsumsize %d\n",
|
|
afs.fs_maxbpg, afs.fs_maxcontig, afs.fs_contigsumsize);
|
|
printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n",
|
|
afs.fs_old_cstotal.cs_nbfree, afs.fs_old_cstotal.cs_ndir,
|
|
afs.fs_old_cstotal.cs_nifree, afs.fs_old_cstotal.cs_nffree);
|
|
printf("cpg\t%d\tbpg\t%d\tfpg\t%d\tipg\t%d\n",
|
|
afs.fs_old_cpg, afs.fs_fpg / afs.fs_frag, afs.fs_fpg,
|
|
afs.fs_ipg);
|
|
printf("nindir\t%d\tinopb\t%d\tnspf\t%d\tmaxfilesize\t%qu\n",
|
|
afs.fs_nindir, afs.fs_inopb, afs.fs_old_nspf,
|
|
afs.fs_maxfilesize);
|
|
printf("sbsize\t%d\tcgsize\t%d\tcgoffset %d\tcgmask\t0x%08x\n",
|
|
afs.fs_sbsize, afs.fs_cgsize, afs.fs_old_cgoffset,
|
|
afs.fs_old_cgmask);
|
|
printf("csaddr\t%d\tcssize\t%d\n",
|
|
afs.fs_old_csaddr, afs.fs_cssize);
|
|
printf("rotdelay %dms\trps\t%d\ttrackskew %d\tinterleave %d\n",
|
|
afs.fs_old_rotdelay, afs.fs_old_rps, afs.fs_old_trackskew,
|
|
afs.fs_old_interleave);
|
|
printf("nsect\t%d\tnpsect\t%d\tspc\t%d\n",
|
|
afs.fs_old_nsect, afs.fs_old_npsect, afs.fs_old_spc);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
printf("sblkno\t%d\tcblkno\t%d\tiblkno\t%d\tdblkno\t%d\n",
|
|
afs.fs_sblkno, afs.fs_cblkno, afs.fs_iblkno, afs.fs_dblkno);
|
|
printf("cgrotor\t%d\tfmod\t%d\tronly\t%d\tclean\t%d\n",
|
|
afs.fs_cgrotor, afs.fs_fmod, afs.fs_ronly, afs.fs_clean);
|
|
printf("flags\t");
|
|
if (afs.fs_flags == 0)
|
|
printf("none");
|
|
if (afs.fs_flags & FS_UNCLEAN)
|
|
printf("unclean ");
|
|
if (afs.fs_flags & FS_DOSOFTDEP)
|
|
printf("soft-updates ");
|
|
if (afs.fs_flags & FS_NEEDSFSCK)
|
|
printf("needs fsck run ");
|
|
if (afs.fs_flags & FS_INDEXDIRS)
|
|
printf("indexed directories ");
|
|
if ((afs.fs_flags &
|
|
~(FS_UNCLEAN | FS_DOSOFTDEP | FS_NEEDSFSCK | FS_INDEXDIRS)) != 0)
|
|
printf("unknown flags (%#x)", afs.fs_flags &
|
|
~(FS_UNCLEAN | FS_DOSOFTDEP |
|
|
FS_NEEDSFSCK | FS_INDEXDIRS));
|
|
putchar('\n');
|
|
printf("\ncs[].cs_(nbfree,ndir,nifree,nffree):\n\t");
|
|
afs.fs_csp = calloc(1, afs.fs_cssize);
|
|
if (bread(&disk, fsbtodb(&afs, afs.fs_csaddr), afs.fs_csp, afs.fs_cssize) == -1)
|
|
goto err;
|
|
for (i = 0; i < afs.fs_ncg; i++) {
|
|
struct csum *cs = &afs.fs_cs(&afs, i);
|
|
if (i && i % 4 == 0)
|
|
printf("\n\t");
|
|
printf("(%d,%d,%d,%d) ",
|
|
cs->cs_nbfree, cs->cs_ndir, cs->cs_nifree, cs->cs_nffree);
|
|
}
|
|
printf("\n");
|
|
if (fssize % afs.fs_fpg) {
|
|
if (disk.d_ufs == 1)
|
|
printf("cylinders in last group %d\n",
|
|
howmany(afs.fs_old_size % afs.fs_fpg,
|
|
afs.fs_old_spc / afs.fs_old_nspf));
|
|
printf("blocks in last group %d\n\n",
|
|
(fssize % afs.fs_fpg) / afs.fs_frag);
|
|
}
|
|
while ((i = cgread(&disk)) != 0) {
|
|
if (i == -1 || dumpcg())
|
|
goto err;
|
|
}
|
|
return (0);
|
|
|
|
err: ufserr(name);
|
|
return (1);
|
|
}
|
|
|
|
int
|
|
dumpcg(void)
|
|
{
|
|
time_t time;
|
|
off_t cur;
|
|
int i, j;
|
|
|
|
printf("\ncg %d:\n", disk.d_lcg);
|
|
cur = fsbtodb(&afs, cgtod(&afs, disk.d_lcg)) * disk.d_bsize;
|
|
switch (disk.d_ufs) {
|
|
case 2:
|
|
time = acg.cg_time;
|
|
printf("magic\t%x\ttell\t%qx\ttime\t%s",
|
|
acg.cg_magic, cur, ctime(&time));
|
|
printf("cgx\t%d\tndblk\t%d\tniblk\t%d\tinitiblk %d\n",
|
|
acg.cg_cgx, acg.cg_ndblk, acg.cg_niblk, acg.cg_initediblk);
|
|
break;
|
|
case 1:
|
|
time = acg.cg_old_time;
|
|
printf("magic\t%x\ttell\t%qx\ttime\t%s",
|
|
acg.cg_magic, cur, ctime(&time));
|
|
printf("cgx\t%d\tncyl\t%d\tniblk\t%d\tndblk\t%d\n",
|
|
acg.cg_cgx, acg.cg_old_ncyl, acg.cg_old_niblk,
|
|
acg.cg_ndblk);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n",
|
|
acg.cg_cs.cs_nbfree, acg.cg_cs.cs_ndir,
|
|
acg.cg_cs.cs_nifree, acg.cg_cs.cs_nffree);
|
|
printf("rotor\t%d\tirotor\t%d\tfrotor\t%d\nfrsum",
|
|
acg.cg_rotor, acg.cg_irotor, acg.cg_frotor);
|
|
for (i = 1, j = 0; i < afs.fs_frag; i++) {
|
|
printf("\t%d", acg.cg_frsum[i]);
|
|
j += i * acg.cg_frsum[i];
|
|
}
|
|
printf("\nsum of frsum: %d", j);
|
|
if (afs.fs_contigsumsize > 0) {
|
|
for (i = 1; i < afs.fs_contigsumsize; i++) {
|
|
if ((i - 1) % 8 == 0)
|
|
printf("\nclusters %d-%d:", i,
|
|
afs.fs_contigsumsize - 1 < i + 7 ?
|
|
afs.fs_contigsumsize - 1 : i + 7);
|
|
printf("\t%d", cg_clustersum(&acg)[i]);
|
|
}
|
|
printf("\nclusters size %d and over: %d\n",
|
|
afs.fs_contigsumsize,
|
|
cg_clustersum(&acg)[afs.fs_contigsumsize]);
|
|
printf("clusters free:\t");
|
|
pbits(cg_clustersfree(&acg), acg.cg_nclusterblks);
|
|
} else
|
|
printf("\n");
|
|
printf("inodes used:\t");
|
|
pbits(cg_inosused(&acg), afs.fs_ipg);
|
|
printf("blks free:\t");
|
|
pbits(cg_blksfree(&acg), afs.fs_fpg);
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
marshal(const char *name)
|
|
{
|
|
struct fs *fs;
|
|
|
|
fs = &disk.d_fs;
|
|
|
|
printf("# newfs command for %s (%s)\n", name, disk.d_name);
|
|
printf("newfs ");
|
|
printf("-O %d ", disk.d_ufs);
|
|
if (fs->fs_flags & FS_DOSOFTDEP)
|
|
printf("-U ");
|
|
printf("-a %d ", fs->fs_maxcontig);
|
|
printf("-b %d ", fs->fs_bsize);
|
|
/* -c is dumb */
|
|
printf("-d %d ", fs->fs_maxbsize);
|
|
printf("-e %d ", fs->fs_maxbpg);
|
|
printf("-f %d ", fs->fs_fsize);
|
|
printf("-g %d ", fs->fs_avgfilesize);
|
|
printf("-h %d ", fs->fs_avgfpdir);
|
|
/* -i is dumb */
|
|
/* -j..l unimplemented */
|
|
printf("-m %d ", fs->fs_minfree);
|
|
/* -n unimplemented */
|
|
printf("-o ");
|
|
switch (fs->fs_optim) {
|
|
case FS_OPTSPACE:
|
|
printf("space ");
|
|
break;
|
|
case FS_OPTTIME:
|
|
printf("time ");
|
|
break;
|
|
default:
|
|
printf("unknown ");
|
|
break;
|
|
}
|
|
/* -p..r unimplemented */
|
|
printf("-s %jd ", (intmax_t)fs->fs_size);
|
|
printf("%s ", disk.d_name);
|
|
printf("\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
pbits(void *vp, int max)
|
|
{
|
|
int i;
|
|
char *p;
|
|
int count, j;
|
|
|
|
for (count = i = 0, p = vp; i < max; i++)
|
|
if (isset(p, i)) {
|
|
if (count)
|
|
printf(",%s", count % 6 ? " " : "\n\t");
|
|
count++;
|
|
printf("%d", i);
|
|
j = i;
|
|
while ((i+1)<max && isset(p, i+1))
|
|
i++;
|
|
if (i != j)
|
|
printf("-%d", i);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
ufserr(const char *name)
|
|
{
|
|
if (disk.d_error != NULL)
|
|
warnx("%s: %s", name, disk.d_error);
|
|
else if (errno)
|
|
warn("%s", name);
|
|
}
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
(void)fprintf(stderr, "usage: dumpfs [-m] filesys | device\n");
|
|
exit(1);
|
|
}
|