static char *sccsid
= "@(#)icheck.c 2.4 (Berkeley) %G%";
#define MAXNINDIR (MAXBSIZE / sizeof (daddr_t))
struct dinode itab
[MAXIPG
];
extern int inside
[], around
[];
extern unsigned char *fragtbl
[];
daddr_t d
, cgd
, cbase
, b
;
fi
= open(file
, sflg
? 2 : 0);
for (n
=0; blist
[n
] != -1; n
++)
fsblist
[n
] = dbtofsb(&sblock
, blist
[n
]);
n
= roundup(howmany(sblock
.fs_size
, NBBY
), sizeof(short));
bmap
= malloc((unsigned)n
);
printf("Not enough core; duplicates unchecked\n");
for (i
= 0; i
< (unsigned)n
; i
++)
for (c
= 0; c
< sblock
.fs_ncg
; c
++) {
d
= cgsblock(&sblock
, c
);
sprintf(buf
, "spare super block %d", c
);
for (; d
< cgd
; d
+= sblock
.fs_frag
)
chk(d
, buf
, sblock
.fs_bsize
);
sprintf(buf
, "cylinder group %d", c
);
chk(cgd
, buf
, sblock
.fs_bsize
);
for (; cgd
< d
; cgd
+= sblock
.fs_frag
) {
sprintf(buf
, "inodes %d-%d", ino
, ino
+ i
);
chk(cgd
, buf
, sblock
.fs_bsize
);
d
+= howmany(sblock
.fs_cssize
, sblock
.fs_fsize
);
chk(cgd
, "csum", sblock
.fs_fsize
);
for (c
= 0; c
< sblock
.fs_ncg
; c
++) {
bread(fsbtodb(&sblock
, cgimin(&sblock
, c
)), (char *)itab
,
sblock
.fs_ipg
* sizeof (struct dinode
));
for (j
=0; j
< sblock
.fs_ipg
; j
++) {
for (c
= 0; c
< sblock
.fs_ncg
; c
++) {
cbase
= cgbase(&sblock
, c
);
bread(fsbtodb(&sblock
, cgtod(&sblock
, c
)), (char *)&cgrp
,
if (cgrp
.cg_magic
!= CG_MAGIC
)
printf("cg %d: bad magic number\n", c
);
for (b
= 0; b
< sblock
.fs_fpg
; b
+= sblock
.fs_frag
) {
if (isblock(&sblock
, cgrp
.cg_free
,
chk(cbase
+b
, "free block", sblock
.fs_bsize
);
for (d
= 0; d
< sblock
.fs_frag
; d
++)
if (isset(cgrp
.cg_free
, b
+d
)) {
chk(cbase
+b
+d
, "free frag", sblock
.fs_fsize
);
i
= nrfile
+ ndfile
+ ncfile
+ nbfile
+ nlfile
;
printf("files %6u (r=%u,d=%u,b=%u,c=%u,sl=%u)\n",
i
, nrfile
, ndfile
, nbfile
, ncfile
, nlfile
);
printf("files %u (r=%u,d=%u,b=%u,c=%u,sl=%u)\n",
i
, nrfile
, ndfile
, nbfile
, ncfile
, nlfile
);
n
= (nblock
+ nindir
+ niindir
) * sblock
.fs_frag
+ nfrag
;
printf("used %ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
n
, nindir
, niindir
, nblock
, nfrag
);
printf("free %ld (b=%ld,f=%ld)\n", nffree
+ sblock
.fs_frag
* nbfree
,
printf("used %7ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
n
, nindir
, niindir
, nblock
, nfrag
);
printf("free %7ld (b=%ld,f=%ld)\n", nffree
+ sblock
.fs_frag
* nbfree
,
for (d
= 0; d
< sblock
.fs_size
; d
++)
if(!duped(d
, sblock
.fs_fsize
)) {
printf("%ld missing\n", d
);
printf("missing%5ld\n", n
);
register struct dinode
*ip
;
register int i
, j
, k
, siz
;
printf("bad mode %u\n", ino
);
for (i
= 0; i
< NDADDR
; i
++) {
siz
= dblksize(&sblock
, ip
, i
);
sprintf(buf
, "logical data block %d", i
);
if (siz
== sblock
.fs_bsize
)
nfrag
+= howmany(siz
, sblock
.fs_fsize
);
for(i
= 0; i
< NIADDR
; i
++) {
if (chk(ib
, "1st indirect", sblock
.fs_bsize
))
bread(fsbtodb(&sblock
, ib
), (char *)ind1
, sblock
.fs_bsize
);
for (j
= 0; j
< NINDIR(&sblock
); j
++) {
siz
= dblksize(&sblock
, ip
, lbn
);
sprintf(buf
, "logical data block %d", lbn
);
if (siz
== sblock
.fs_bsize
)
nfrag
+= howmany(siz
, sblock
.fs_fsize
);
if (chk(ib
, "2nd indirect", sblock
.fs_bsize
))
bread(fsbtodb(&sblock
, ib
), (char *)ind2
,
for (k
= 0; k
< NINDIR(&sblock
); k
++) {
lbn
= NDADDR
+ NINDIR(&sblock
) * (i
+ j
) + k
;
siz
= dblksize(&sblock
, ip
, lbn
);
sprintf(buf
, "logical data block %d", lbn
);
if (siz
== sblock
.fs_bsize
)
nfrag
+= howmany(siz
, sblock
.fs_fsize
);
if (cginit
== 0 && bno
>= sblock
.fs_frag
* sblock
.fs_size
) {
printf("%ld bad; inode=%u, class=%s\n", bno
, ino
, s
);
frags
= numfrags(&sblock
, size
);
if (frags
== sblock
.fs_frag
) {
printf("%ld dup block; inode=%u, class=%s\n",
for (n
= 0; n
< frags
; n
++) {
if (duped(bno
+ n
, sblock
.fs_fsize
)) {
printf("%ld dup frag; inode=%u, class=%s\n",
for (n
=0; blist
[n
] != -1; n
++)
if (fsblist
[n
] >= bno
&& fsblist
[n
] < bno
+ frags
)
printf("%ld arg; frag %d of %d, inode=%u, class=%s\n",
blist
[n
], fsblist
[n
] - bno
, frags
, ino
, s
);
if (size
!= sblock
.fs_fsize
&& size
!= sblock
.fs_bsize
)
printf("bad size %d to duped\n", size
);
if (size
== sblock
.fs_fsize
) {
if (bno
% sblock
.fs_frag
!= 0)
printf("bad bno %d to duped\n", bno
);
if (isblock(&sblock
, bmap
, bno
/sblock
.fs_frag
))
setblock(&sblock
, bmap
, bno
/sblock
.fs_frag
);
daddr_t dbase
, d
, dlower
, dupper
, dmax
;
register struct csum
*cs
;
register struct dinode
*dp
;
sblock
.fs_cstotal
.cs_nbfree
= 0;
sblock
.fs_cstotal
.cs_nffree
= 0;
sblock
.fs_cstotal
.cs_nifree
= 0;
sblock
.fs_cstotal
.cs_ndir
= 0;
for (c
= 0; c
< sblock
.fs_ncg
; c
++) {
dbase
= cgbase(&sblock
, c
);
dmax
= dbase
+ sblock
.fs_fpg
;
if (dmax
> sblock
.fs_size
) {
for ( ; dmax
>= sblock
.fs_size
; dmax
--)
clrbit(cgrp
.cg_free
, dmax
- dbase
);
dlower
= cgsblock(&sblock
, c
) - dbase
;
dupper
= cgdmin(&sblock
, c
) - dbase
;
cs
= &sblock
.fs_cs(&sblock
, c
);
cgrp
.cg_magic
= CG_MAGIC
;
if (c
== sblock
.fs_ncg
- 1)
cgrp
.cg_ncyl
= sblock
.fs_ncyl
% sblock
.fs_cpg
;
cgrp
.cg_ncyl
= sblock
.fs_cpg
;
cgrp
.cg_niblk
= sblock
.fs_ipg
;
cgrp
.cg_ndblk
= dmax
- dbase
;
cgrp
.cg_cs
.cs_nffree
= 0;
cgrp
.cg_cs
.cs_nbfree
= 0;
cgrp
.cg_cs
.cs_nifree
= 0;
for (i
= 0; i
< sblock
.fs_frag
; i
++)
bread(fsbtodb(&sblock
, cgimin(&sblock
, c
)), (char *)itab
,
sblock
.fs_ipg
* sizeof(struct dinode
));
for (i
= 0; i
< sblock
.fs_ipg
; i
++) {
clrbit(cgrp
.cg_iused
, i
);
if ((dp
->di_mode
& IFMT
) != 0) {
if ((dp
->di_mode
& IFMT
) == IFDIR
)
setbit(cgrp
.cg_iused
, i
);
clrbit(cgrp
.cg_iused
, i
);
for (i
= 0; i
< ROOTINO
; i
++) {
setbit(cgrp
.cg_iused
, i
);
for (s
= 0; s
< MAXCPG
; s
++) {
for (i
= 0; i
< NRPOS
; i
++)
dupper
+= howmany(sblock
.fs_cssize
, sblock
.fs_fsize
);
for (d
= dlower
; d
< dupper
; d
++)
for (d
= 0; (d
+ sblock
.fs_frag
) <= dmax
- dbase
;
for (i
= 0; i
< sblock
.fs_frag
; i
++) {
if (!isset(bmap
, dbase
+ d
+ i
)) {
setbit(cgrp
.cg_free
, d
+ i
);
clrbit(cgrp
.cg_free
, d
+i
);
if (j
== sblock
.fs_frag
) {
cgrp
.cg_btot
[cbtocylno(&sblock
, d
)]++;
cgrp
.cg_b
[cbtocylno(&sblock
, d
)]
[cbtorpos(&sblock
, d
)]++;
cgrp
.cg_cs
.cs_nffree
+= j
;
blk
= blkmap(&sblock
, cgrp
.cg_free
, d
);
fragacct(&sblock
, blk
, cgrp
.cg_frsum
, 1);
for (j
= d
; d
< dmax
- dbase
; d
++) {
if (!isset(bmap
, dbase
+ d
)) {
for (; d
% sblock
.fs_frag
!= 0; d
++)
blk
= blkmap(&sblock
, cgrp
.cg_free
, j
);
fragacct(&sblock
, blk
, cgrp
.cg_frsum
, 1);
for (d
/= sblock
.fs_frag
; d
< MAXBPG(&sblock
); d
++)
clrblock(&sblock
, cgrp
.cg_free
, d
);
sblock
.fs_cstotal
.cs_nffree
+= cgrp
.cg_cs
.cs_nffree
;
sblock
.fs_cstotal
.cs_nbfree
+= cgrp
.cg_cs
.cs_nbfree
;
sblock
.fs_cstotal
.cs_nifree
+= cgrp
.cg_cs
.cs_nifree
;
sblock
.fs_cstotal
.cs_ndir
+= cgrp
.cg_cs
.cs_ndir
;
bwrite(fsbtodb(&sblock
, cgtod(&sblock
, c
)), &cgrp
,
for (i
= 0, j
= 0; i
< sblock
.fs_cssize
; i
+= sblock
.fs_bsize
, j
++) {
bwrite(fsbtodb(&sblock
, sblock
.fs_csaddr
+ j
* sblock
.fs_frag
),
(char *)sblock
.fs_csp
[j
],
sblock
.fs_cssize
- i
< sblock
.fs_bsize
?
sblock
.fs_cssize
- i
: sblock
.fs_bsize
);
bwrite(SBLOCK
, (char *)&sblock
, SBSIZE
);
* update the frsum fields to reflect addition or deletion
fragacct(fs
, fragmap
, fraglist
, cnt
)
register int field
, subfield
;
inblk
= (int)(fragtbl
[fs
->fs_frag
][fragmap
] << 1);
for (siz
= 1; siz
< fs
->fs_frag
; siz
++) {
if ((inblk
& (1 << (siz
+ (fs
->fs_frag
% NBBY
)))) == 0)
for (pos
= siz
; pos
<= fs
->fs_frag
; pos
++) {
if ((fragmap
& field
) == subfield
) {
if (bread(SBLOCK
, fs
, SBSIZE
)) {
printf("bad super block");
if (fs
->fs_magic
!= FS_MAGIC
) {
printf("%s: bad magic number\n", file
);
for (i
= 0, j
= 0; i
< sblock
.fs_cssize
; i
+= sblock
.fs_bsize
, j
++) {
size
= sblock
.fs_cssize
- i
< sblock
.fs_bsize
?
sblock
.fs_cssize
- i
: sblock
.fs_bsize
;
sblock
.fs_csp
[j
] = (struct csum
*)calloc(1, size
);
bread(fsbtodb(fs
, fs
->fs_csaddr
+ (j
* fs
->fs_frag
)),
(char *)fs
->fs_csp
[j
], size
);
if (lseek(fi
, blk
* DEV_BSIZE
, 0) < 0) {
if (write(fi
, buf
, size
) != size
) {
lseek(fi
, bno
* DEV_BSIZE
, 0);
if ((i
= read(fi
, buf
, cnt
)) != cnt
) {
for(i
=0; i
<sblock
.fs_bsize
; i
++)
* check if a block is available
mask
= 0x0f << ((h
& 0x1) << 2);
return ((cp
[h
>> 1] & mask
) == mask
);
mask
= 0x03 << ((h
& 0x3) << 1);
return ((cp
[h
>> 2] & mask
) == mask
);
mask
= 0x01 << (h
& 0x7);
return ((cp
[h
>> 3] & mask
) == mask
);
printf("isblock bad fs_frag %d\n", fs
->fs_frag
);
fprintf(stderr
, "isblock bad fs_frag %d\n", fs
->fs_frag
);
* take a block out of the map
cp
[h
>> 1] &= ~(0x0f << ((h
& 0x1) << 2));
cp
[h
>> 2] &= ~(0x03 << ((h
& 0x3) << 1));
cp
[h
>> 3] &= ~(0x01 << (h
& 0x7));
printf("clrblock bad fs_frag %d\n", fs
->fs_frag
);
fprintf(stderr
, "clrblock bad fs_frag %d\n", fs
->fs_frag
);
* put a block into the map
cp
[h
>> 1] |= (0x0f << ((h
& 0x1) << 2));
cp
[h
>> 2] |= (0x03 << ((h
& 0x3) << 1));
cp
[h
>> 3] |= (0x01 << (h
& 0x7));
printf("setblock bad fs_frag %d\n", fs
->fs_frag
);
fprintf(stderr
, "setblock bad fs_frag %d\n", fs
->fs_frag
);
/* tables.c 4.1 82/03/25 */
/* merged into kernel: tables.c 2.1 3/25/82 */
/* last monet version: partab.c 4.2 81/03/08 */
* bit patterns for identifying fragments in the block map
* used as ((map & around) == inside)
0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff
0x0, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe
* given a block map bit pattern, the frag tables tell whether a
* particular size fragment is available.
* if ((1 << (size - 1)) & fragtbl[fs->fs_frag][map] {
* at least one fragment of the indicated size is available
* These tables are used by the scanc instruction on the VAX to
* quickly find an appropriate fragment.
unsigned char fragtbl124
[256] = {
0x00, 0x16, 0x16, 0x2a, 0x16, 0x16, 0x26, 0x4e,
0x16, 0x16, 0x16, 0x3e, 0x2a, 0x3e, 0x4e, 0x8a,
0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e,
0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e,
0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e,
0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e,
0x2a, 0x3e, 0x3e, 0x2a, 0x3e, 0x3e, 0x2e, 0x6e,
0x3e, 0x3e, 0x3e, 0x3e, 0x2a, 0x3e, 0x6e, 0xaa,
0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e,
0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e,
0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e,
0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e,
0x26, 0x36, 0x36, 0x2e, 0x36, 0x36, 0x26, 0x6e,
0x36, 0x36, 0x36, 0x3e, 0x2e, 0x3e, 0x6e, 0xae,
0x4e, 0x5e, 0x5e, 0x6e, 0x5e, 0x5e, 0x6e, 0x4e,
0x5e, 0x5e, 0x5e, 0x7e, 0x6e, 0x7e, 0x4e, 0xce,
0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e,
0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e,
0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e,
0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e,
0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e,
0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e,
0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x7e,
0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x7e, 0xbe,
0x2a, 0x3e, 0x3e, 0x2a, 0x3e, 0x3e, 0x2e, 0x6e,
0x3e, 0x3e, 0x3e, 0x3e, 0x2a, 0x3e, 0x6e, 0xaa,
0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x7e,
0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x7e, 0xbe,
0x4e, 0x5e, 0x5e, 0x6e, 0x5e, 0x5e, 0x6e, 0x4e,
0x5e, 0x5e, 0x5e, 0x7e, 0x6e, 0x7e, 0x4e, 0xce,
0x8a, 0x9e, 0x9e, 0xaa, 0x9e, 0x9e, 0xae, 0xce,
0x9e, 0x9e, 0x9e, 0xbe, 0xaa, 0xbe, 0xce, 0x8a,
unsigned char fragtbl8
[256] = {
0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x04,
0x01, 0x01, 0x01, 0x03, 0x02, 0x03, 0x04, 0x08,
0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05,
0x02, 0x03, 0x03, 0x02, 0x04, 0x05, 0x08, 0x10,
0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05,
0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06,
0x04, 0x05, 0x05, 0x06, 0x08, 0x09, 0x10, 0x20,
0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05,
0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05,
0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11,
0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06,
0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0a,
0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04,
0x08, 0x09, 0x09, 0x0a, 0x10, 0x11, 0x20, 0x40,
0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05,
0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05,
0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11,
0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05,
0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07,
0x05, 0x05, 0x05, 0x07, 0x09, 0x09, 0x11, 0x21,
0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06,
0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0a,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07,
0x02, 0x03, 0x03, 0x02, 0x06, 0x07, 0x0a, 0x12,
0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04,
0x05, 0x05, 0x05, 0x07, 0x06, 0x07, 0x04, 0x0c,
0x08, 0x09, 0x09, 0x0a, 0x09, 0x09, 0x0a, 0x0c,
0x10, 0x11, 0x11, 0x12, 0x20, 0x21, 0x40, 0x80,
* the actual fragtbl array
unsigned char *fragtbl
[MAXFRAG
+ 1] = {
0, fragtbl124
, fragtbl124
, 0, fragtbl124
, 0, 0, 0, fragtbl8
,