![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pass1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc / fsck|
Return to pass1.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc / fsck |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)pass1.c 5.3 (Berkeley) 5/13/86";
9: #endif not lint
10:
11: #include <sys/param.h>
12: #include <sys/inode.h>
13: #include <sys/fs.h>
14: #include "fsck.h"
15:
16: static daddr_t badblk;
17: static daddr_t dupblk;
18: int pass1check();
19:
20: pass1()
21: {
22: register int c, i, j;
23: register DINODE *dp;
24: struct zlncnt *zlnp;
25: int ndb, partial, cgd;
26: struct inodesc idesc;
27: ino_t inumber;
28:
29: /*
30: * Set file system reserved blocks in used block map.
31: */
32: for (c = 0; c < sblock.fs_ncg; c++) {
33: cgd = cgdmin(&sblock, c);
34: if (c == 0) {
35: i = cgbase(&sblock, c);
36: cgd += howmany(sblock.fs_cssize, sblock.fs_fsize);
37: } else
38: i = cgsblock(&sblock, c);
39: for (; i < cgd; i++)
40: setbmap(i);
41: }
42: /*
43: * Find all allocated blocks.
44: */
45: bzero((char *)&idesc, sizeof(struct inodesc));
46: idesc.id_type = ADDR;
47: idesc.id_func = pass1check;
48: inumber = 0;
49: n_files = n_blks = 0;
50: for (c = 0; c < sblock.fs_ncg; c++) {
51: for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
52: if (inumber < ROOTINO)
53: continue;
54: dp = ginode(inumber);
55: if (!ALLOC(dp)) {
56: if (bcmp((char *)dp->di_db, (char *)zino.di_db,
57: NDADDR * sizeof(daddr_t)) ||
58: bcmp((char *)dp->di_ib, (char *)zino.di_ib,
59: NIADDR * sizeof(daddr_t)) ||
60: dp->di_mode || dp->di_size) {
61: pfatal("PARTIALLY ALLOCATED INODE I=%u",
62: inumber);
63: if (reply("CLEAR") == 1) {
64: zapino(dp);
65: inodirty();
66: }
67: }
68: statemap[inumber] = USTATE;
69: continue;
70: }
71: lastino = inumber;
72: if (dp->di_size < 0) {
73: if (debug)
74: printf("bad size %d:", dp->di_size);
75: goto unknown;
76: }
77: if (!preen && (dp->di_mode & IFMT) == IFMT &&
78: reply("HOLD BAD BLOCK") == 1) {
79: dp->di_size = sblock.fs_fsize;
80: dp->di_mode = IFREG|0600;
81: inodirty();
82: }
83: ndb = howmany(dp->di_size, sblock.fs_bsize);
84: if (SPECIAL(dp))
85: ndb++;
86: for (j = ndb; j < NDADDR; j++)
87: if (dp->di_db[j] != 0) {
88: if (debug)
89: printf("bad direct addr: %d\n",
90: dp->di_db[j]);
91: goto unknown;
92: }
93: for (j = 0, ndb -= NDADDR; ndb > 0; j++)
94: ndb /= NINDIR(&sblock);
95: for (; j < NIADDR; j++)
96: if (dp->di_ib[j] != 0) {
97: if (debug)
98: printf("bad indirect addr: %d\n",
99: dp->di_ib[j]);
100: goto unknown;
101: }
102: if (ftypeok(dp) == 0)
103: goto unknown;
104: n_files++;
105: lncntp[inumber] = dp->di_nlink;
106: if (dp->di_nlink <= 0) {
107: zlnp = (struct zlncnt *)malloc(sizeof *zlnp);
108: if (zlnp == NULL) {
109: pfatal("LINK COUNT TABLE OVERFLOW");
110: if (reply("CONTINUE") == 0)
111: errexit("");
112: } else {
113: zlnp->zlncnt = inumber;
114: zlnp->next = zlnhead;
115: zlnhead = zlnp;
116: }
117: }
118: statemap[inumber] = DIRCT(dp) ? DSTATE : FSTATE;
119: badblk = dupblk = 0; maxblk = 0;
120: idesc.id_number = inumber;
121: (void)ckinode(dp, &idesc);
122: idesc.id_entryno *= btodb(sblock.fs_fsize);
123: if (dp->di_blocks != idesc.id_entryno) {
124: pwarn("INCORRECT BLOCK COUNT I=%u (%ld should be %ld)",
125: inumber, dp->di_blocks, idesc.id_entryno);
126: if (preen)
127: printf(" (CORRECTED)\n");
128: else if (reply("CORRECT") == 0)
129: continue;
130: dp->di_blocks = idesc.id_entryno;
131: inodirty();
132: }
133: continue;
134: unknown:
135: pfatal("UNKNOWN FILE TYPE I=%u", inumber);
136: statemap[inumber] = FCLEAR;
137: if (reply("CLEAR") == 1) {
138: statemap[inumber] = USTATE;
139: zapino(dp);
140: inodirty();
141: }
142: }
143: }
144: }
145:
146: pass1check(idesc)
147: register struct inodesc *idesc;
148: {
149: int res = KEEPON;
150: int anyout, nfrags;
151: daddr_t blkno = idesc->id_blkno;
152: register struct dups *dlp;
153: struct dups *new;
154:
155: if ((anyout = outrange(blkno, idesc->id_numfrags)) != 0) {
156: blkerr(idesc->id_number, "BAD", blkno);
157: if (++badblk >= MAXBAD) {
158: pwarn("EXCESSIVE BAD BLKS I=%u",
159: idesc->id_number);
160: if (preen)
161: printf(" (SKIPPING)\n");
162: else if (reply("CONTINUE") == 0)
163: errexit("");
164: return (STOP);
165: }
166: }
167: for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
168: if (anyout && outrange(blkno, 1)) {
169: res = SKIP;
170: } else if (!getbmap(blkno)) {
171: n_blks++;
172: setbmap(blkno);
173: } else {
174: blkerr(idesc->id_number, "DUP", blkno);
175: if (++dupblk >= MAXDUP) {
176: pwarn("EXCESSIVE DUP BLKS I=%u",
177: idesc->id_number);
178: if (preen)
179: printf(" (SKIPPING)\n");
180: else if (reply("CONTINUE") == 0)
181: errexit("");
182: return (STOP);
183: }
184: new = (struct dups *)malloc(sizeof(struct dups));
185: if (new == NULL) {
186: pfatal("DUP TABLE OVERFLOW.");
187: if (reply("CONTINUE") == 0)
188: errexit("");
189: return (STOP);
190: }
191: new->dup = blkno;
192: if (muldup == 0) {
193: duplist = muldup = new;
194: new->next = 0;
195: } else {
196: new->next = muldup->next;
197: muldup->next = new;
198: }
199: for (dlp = duplist; dlp != muldup; dlp = dlp->next)
200: if (dlp->dup == blkno)
201: break;
202: if (dlp == muldup && dlp->dup != blkno)
203: muldup = new;
204: }
205: /*
206: * count the number of blocks found in id_entryno
207: */
208: idesc->id_entryno++;
209: }
210: return (res);
211: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.