afs
} else for (p = afs; p->af_name; p++) {
} afs[] = {
for (afp = rafp = afs; rafp->af_name; rafp++)
for (p = afs; p->af_name; p++) {
n = pread(fd, &afs, SBLOCKSIZE, (off_t)sbtry[i]);
if (n == SBLOCKSIZE && (afs.fs_magic == FS_UFS1_MAGIC ||
(afs.fs_magic == FS_UFS2_MAGIC &&
afs.fs_sblockloc == sbtry[i])) &&
!(afs.fs_magic == FS_UFS1_MAGIC &&
afs.fs_bsize <= MAXBSIZE &&
afs.fs_bsize >= sizeof(struct fs))
switch (afs.fs_magic) {
fssize = afs.fs_size;
fstime = afs.fs_time;
afs.fs_magic, ctime(&fstime));
afs.fs_magic, fstime);
(intmax_t)afs.fs_sblockloc, afs.fs_id[0], afs.fs_id[1]);
afs.fs_ncg, (intmax_t)fssize, (intmax_t)afs.fs_dsize);
fssize = afs.fs_ffs1_size;
fstime = afs.fs_ffs1_time;
afs.fs_magic, ctime(&fstime));
afs.fs_magic, fstime);
printf("id\t[ %x %x ]\n", afs.fs_id[0], afs.fs_id[1]);
if (afs.fs_postblformat != FS_42POSTBLFMT) {
if (afs.fs_inodefmt >= FS_44INODEFMT) {
max = afs.fs_maxcontig;
size = afs.fs_contigsumsize;
afs.fs_ncg, afs.fs_ncyl, afs.fs_ffs1_size, afs.fs_ffs1_dsize);
afs.fs_bsize, afs.fs_bshift, afs.fs_bmask);
afs.fs_fsize, afs.fs_fshift, afs.fs_fmask);
afs.fs_frag, afs.fs_fragshift, afs.fs_fsbtodb);
afs.fs_minfree, afs.fs_optim == FS_OPTSPACE ? "space" : "time",
afs.fs_maxsymlinklen);
switch (afs.fs_magic) {
"maxbsize", afs.fs_maxbsize, afs.fs_maxbpg,
afs.fs_maxcontig, afs.fs_contigsumsize);
(intmax_t)afs.fs_cstotal.cs_nbfree,
(intmax_t)afs.fs_cstotal.cs_ndir,
(intmax_t)afs.fs_cstotal.cs_nifree,
(intmax_t)afs.fs_cstotal.cs_nffree);
afs.fs_fpg / afs.fs_frag, afs.fs_fpg, afs.fs_ipg);
afs.fs_nindir, afs.fs_inopb,
(uintmax_t)afs.fs_maxfilesize);
afs.fs_sbsize, afs.fs_cgsize, (intmax_t)afs.fs_csaddr,
afs.fs_cssize);
afs.fs_maxbpg, afs.fs_maxcontig, afs.fs_contigsumsize);
afs.fs_ffs1_cstotal.cs_nbfree, afs.fs_ffs1_cstotal.cs_ndir,
afs.fs_ffs1_cstotal.cs_nifree, afs.fs_ffs1_cstotal.cs_nffree);
afs.fs_cpg, afs.fs_fpg / afs.fs_frag, afs.fs_fpg,
afs.fs_ipg);
afs.fs_nindir, afs.fs_inopb, afs.fs_nspf,
(uintmax_t)afs.fs_maxfilesize);
afs.fs_sbsize, afs.fs_cgsize, afs.fs_cgoffset,
afs.fs_cgmask);
afs.fs_ffs1_csaddr, afs.fs_cssize);
afs.fs_rotdelay, afs.fs_rps, afs.fs_interleave);
afs.fs_nsect, afs.fs_npsect, afs.fs_spc);
afs.fs_sblkno, afs.fs_cblkno, afs.fs_iblkno, afs.fs_dblkno);
afs.fs_cgrotor, afs.fs_fmod, afs.fs_ronly, afs.fs_clean);
afs.fs_avgfpdir, afs.fs_avgfilesize);
if (afs.fs_magic == FS_UFS2_MAGIC ||
afs.fs_ffs1_flags & FS_FLAGS_UPDATED)
fsflags = afs.fs_flags;
fsflags = afs.fs_ffs1_flags;
printf("fsmnt\t%s\n", afs.fs_fsmnt);
afs.fs_volname, (uintmax_t)afs.fs_swuid);
afs.fs_csp = calloc(1, afs.fs_cssize);
for (i = 0, j = 0; i < afs.fs_cssize; i += afs.fs_bsize, j++) {
size = afs.fs_cssize - i < afs.fs_bsize ?
afs.fs_cssize - i : afs.fs_bsize;
off = (off_t)(fsbtodb(&afs, (afs.fs_csaddr + j *
afs.fs_frag))) * DEV_BSIZE;
if (pread(fd, (char *)afs.fs_csp + i, size, off) != size)
for (cg = 0; cg < afs.fs_ncg; cg++) {
struct csum *cs = &afs.fs_cs(&afs, cg);
if (fssize % afs.fs_fpg) {
if (afs.fs_magic == FS_UFS1_MAGIC)
howmany(afs.fs_ffs1_size % afs.fs_fpg,
afs.fs_spc / afs.fs_nspf));
(long)((fssize % afs.fs_fpg) / afs.fs_frag));
for (cg = 0; cg < afs.fs_ncg; cg++)
cur = (off_t)fsbtodb(&afs, cgtod(&afs, c)) * DEV_BSIZE;
if (pread(fd, &acg, afs.fs_bsize, cur) != afs.fs_bsize) {
switch (afs.fs_magic) {
afs.fs_postblformat == FS_42POSTBLFMT ?
afs.fs_postblformat == FS_42POSTBLFMT ?
for (i = 1, j = 0; i < afs.fs_frag; i++) {
if (afs.fs_contigsumsize > 0) {
for (i = 1; i < afs.fs_contigsumsize; i++) {
afs.fs_contigsumsize - 1 < i + 7 ?
afs.fs_contigsumsize - 1 : i + 7);
afs.fs_contigsumsize,
cg_clustersum(&acg)[afs.fs_contigsumsize]);
pbits(cg_inosused(&acg), afs.fs_ipg);
pbits(cg_blksfree(&acg), afs.fs_fpg);
if (afs.fs_magic == FS_UFS1_MAGIC) {
for (i = 0; i < afs.fs_cpg; i++) {
if (afs.fs_volname[0] != '\0')
printf("-L %s ", afs.fs_volname);
Oflag = (afs.fs_magic == FS_UFS2_MAGIC) +
(afs.fs_inodefmt == FS_44INODEFMT);
printf("-b %d ", afs.fs_bsize);
printf("-e %d ", afs.fs_maxbpg);
printf("-f %d ", afs.fs_fsize);
printf("-g %u ", afs.fs_avgfilesize);
printf("-h %u ", afs.fs_avgfpdir);
printf("-m %d ", afs.fs_minfree);
switch (afs.fs_optim) {
printf("-s %jd ", (intmax_t)afs.fs_size * (afs.fs_fsize / DEV_BSIZE));
for (p = afs; p->af_name; p++) {
} else for (p = afs; p->af_name; p++) {
} afs[] = {
for (afp = rafp = afs; rafp->af_name; rafp++)
rde_filterset_equal(const struct rde_filter_set *afs,
if (afs->len != bfs->len)
a = afs->set;
for (i = 0; i < afs->len; i++, a++, b++) {