![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pass5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / fsck|
Return to pass5.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / 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[] = "@(#)pass5.c 5.5 (Berkeley) 5/7/88";
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: pass5()
17: {
18: int c, blk, frags, basesize, sumsize, mapsize, savednrpos;
19: register struct fs *fs = &sblock;
20: register struct cg *cg = &cgrp;
21: daddr_t dbase, dmax;
22: register daddr_t d;
23: register long i, j;
24: struct csum *cs;
25: time_t now;
26: struct csum cstotal;
27: struct inodesc idesc;
28: char buf[MAXBSIZE];
29: register struct cg *newcg = (struct cg *)buf;
30: struct ocg *ocg = (struct ocg *)buf;
31:
32: bzero((char *)newcg, fs->fs_cgsize);
33: newcg->cg_niblk = fs->fs_ipg;
34: switch (fs->fs_postblformat) {
35:
36: case FS_42POSTBLFMT:
37: basesize = (char *)(&ocg->cg_btot[0]) - (char *)(&ocg->cg_link);
38: sumsize = &ocg->cg_iused[0] - (char *)(&ocg->cg_btot[0]);
39: mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -
40: (u_char *)&ocg->cg_iused[0];
41: ocg->cg_magic = CG_MAGIC;
42: savednrpos = fs->fs_nrpos;
43: fs->fs_nrpos = 8;
44: break;
45:
46: case FS_DYNAMICPOSTBLFMT:
47: newcg->cg_btotoff =
48: &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
49: newcg->cg_boff =
50: newcg->cg_btotoff + fs->fs_cpg * sizeof(long);
51: newcg->cg_iusedoff = newcg->cg_boff +
52: fs->fs_cpg * fs->fs_nrpos * sizeof(short);
53: newcg->cg_freeoff =
54: newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY);
55: newcg->cg_nextfreeoff = newcg->cg_freeoff +
56: howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs),
57: NBBY);
58: newcg->cg_magic = CG_MAGIC;
59: basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
60: sumsize = newcg->cg_iusedoff - newcg->cg_btotoff;
61: mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff;
62: break;
63:
64: default:
65: errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d\n",
66: fs->fs_postblformat);
67: }
68: bzero((char *)&idesc, sizeof(struct inodesc));
69: idesc.id_type = ADDR;
70: bzero((char *)&cstotal, sizeof(struct csum));
71: (void)time(&now);
72: for (i = fs->fs_size; i < fragroundup(fs, fs->fs_size); i++)
73: setbmap(i);
74: for (c = 0; c < fs->fs_ncg; c++) {
75: getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize);
76: if (!cg_chkmagic(cg))
77: pfatal("CG %d: BAD MAGIC NUMBER\n", c);
78: dbase = cgbase(fs, c);
79: dmax = dbase + fs->fs_fpg;
80: if (dmax > fs->fs_size)
81: dmax = fs->fs_size;
82: if (now > cg->cg_time)
83: newcg->cg_time = cg->cg_time;
84: else
85: newcg->cg_time = now;
86: newcg->cg_cgx = c;
87: if (c == fs->fs_ncg - 1)
88: newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg;
89: else
90: newcg->cg_ncyl = fs->fs_cpg;
91: newcg->cg_ndblk = dmax - dbase;
92: newcg->cg_cs.cs_ndir = 0;
93: newcg->cg_cs.cs_nffree = 0;
94: newcg->cg_cs.cs_nbfree = 0;
95: newcg->cg_cs.cs_nifree = fs->fs_ipg;
96: if (cg->cg_rotor < newcg->cg_ndblk)
97: newcg->cg_rotor = cg->cg_rotor;
98: else
99: newcg->cg_rotor = 0;
100: if (cg->cg_frotor < newcg->cg_ndblk)
101: newcg->cg_frotor = cg->cg_frotor;
102: else
103: newcg->cg_frotor = 0;
104: if (cg->cg_irotor < newcg->cg_niblk)
105: newcg->cg_irotor = cg->cg_irotor;
106: else
107: newcg->cg_irotor = 0;
108: bzero((char *)&newcg->cg_frsum[0], sizeof newcg->cg_frsum);
109: bzero((char *)&cg_blktot(newcg)[0], sumsize + mapsize);
110: if (fs->fs_postblformat == FS_42POSTBLFMT)
111: ocg->cg_magic = CG_MAGIC;
112: j = fs->fs_ipg * c;
113: for (i = 0; i < fs->fs_ipg; j++, i++) {
114: switch (statemap[j]) {
115:
116: case USTATE:
117: break;
118:
119: case DSTATE:
120: case DCLEAR:
121: case DFOUND:
122: newcg->cg_cs.cs_ndir++;
123: /* fall through */
124:
125: case FSTATE:
126: case FCLEAR:
127: newcg->cg_cs.cs_nifree--;
128: setbit(cg_inosused(newcg), i);
129: break;
130:
131: default:
132: if (j < ROOTINO)
133: break;
134: errexit("BAD STATE %d FOR INODE I=%d",
135: statemap[j], j);
136: }
137: }
138: if (c == 0)
139: for (i = 0; i < ROOTINO; i++) {
140: setbit(cg_inosused(newcg), i);
141: newcg->cg_cs.cs_nifree--;
142: }
143: for (i = 0, d = dbase;
144: d < dmax;
145: d += fs->fs_frag, i += fs->fs_frag) {
146: frags = 0;
147: for (j = 0; j < fs->fs_frag; j++) {
148: if (getbmap(d + j))
149: continue;
150: setbit(cg_blksfree(newcg), i + j);
151: frags++;
152: }
153: if (frags == fs->fs_frag) {
154: newcg->cg_cs.cs_nbfree++;
155: j = cbtocylno(fs, i);
156: cg_blktot(newcg)[j]++;
157: cg_blks(fs, newcg, j)[cbtorpos(fs, i)]++;
158: } else if (frags > 0) {
159: newcg->cg_cs.cs_nffree += frags;
160: blk = blkmap(fs, cg_blksfree(newcg), i);
161: fragacct(fs, blk, newcg->cg_frsum, 1);
162: }
163: }
164: cstotal.cs_nffree += newcg->cg_cs.cs_nffree;
165: cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree;
166: cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
167: cstotal.cs_ndir += newcg->cg_cs.cs_ndir;
168: cs = &fs->fs_cs(fs, c);
169: if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&
170: dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
171: bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
172: sbdirty();
173: }
174: if (cvtflag) {
175: bcopy((char *)newcg, (char *)cg, fs->fs_cgsize);
176: cgdirty();
177: continue;
178: }
179: if (bcmp(cg_inosused(newcg),
180: cg_inosused(cg), mapsize) != 0 &&
181: dofix(&idesc, "BLK(S) MISSING IN BIT MAPS")) {
182: bcopy(cg_inosused(newcg), cg_inosused(cg), mapsize);
183: cgdirty();
184: }
185: if ((bcmp((char *)newcg, (char *)cg, basesize) != 0 ||
186: bcmp((char *)&cg_blktot(newcg)[0],
187: (char *)&cg_blktot(cg)[0], sumsize) != 0) &&
188: dofix(&idesc, "SUMMARY INFORMATION BAD")) {
189: bcopy((char *)newcg, (char *)cg, basesize);
190: bcopy((char *)&cg_blktot(newcg)[0],
191: (char *)&cg_blktot(cg)[0], sumsize);
192: cgdirty();
193: }
194: }
195: if (fs->fs_postblformat == FS_42POSTBLFMT)
196: fs->fs_nrpos = savednrpos;
197: if (bcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
198: && dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
199: bcopy((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs);
200: fs->fs_ronly = 0;
201: fs->fs_fmod = 0;
202: sbdirty();
203: }
204: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.