1 /*
2 * Copyright (c) 1980, 1986 The Regents of the University of California.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #ifndef lint
35 static char sccsid[] = "@(#)pass5.c 5.13 (Berkeley) 7/20/90";
36 #endif /* not lint */
37
38 #include <sys/param.h>
39 #include <ufs/dinode.h>
40 #include <ufs/fs.h>
41 #include <string.h>
42 #include "fsck.h"
43
pass5()44 pass5()
45 {
46 int c, blk, frags, basesize, sumsize, mapsize, savednrpos;
47 register struct fs *fs = &sblock;
48 register struct cg *cg = &cgrp;
49 daddr_t dbase, dmax;
50 register daddr_t d;
51 register long i, j;
52 struct csum *cs;
53 time_t now;
54 struct csum cstotal;
55 struct inodesc idesc[3];
56 char buf[MAXBSIZE];
57 register struct cg *newcg = (struct cg *)buf;
58 struct ocg *ocg = (struct ocg *)buf;
59
60 bzero((char *)newcg, (size_t)fs->fs_cgsize);
61 newcg->cg_niblk = fs->fs_ipg;
62 switch ((int)fs->fs_postblformat) {
63
64 case FS_42POSTBLFMT:
65 basesize = (char *)(&ocg->cg_btot[0]) - (char *)(&ocg->cg_link);
66 sumsize = &ocg->cg_iused[0] - (char *)(&ocg->cg_btot[0]);
67 mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -
68 (u_char *)&ocg->cg_iused[0];
69 ocg->cg_magic = CG_MAGIC;
70 savednrpos = fs->fs_nrpos;
71 fs->fs_nrpos = 8;
72 break;
73
74 case FS_DYNAMICPOSTBLFMT:
75 newcg->cg_btotoff =
76 &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
77 newcg->cg_boff =
78 newcg->cg_btotoff + fs->fs_cpg * sizeof(long);
79 newcg->cg_iusedoff = newcg->cg_boff +
80 fs->fs_cpg * fs->fs_nrpos * sizeof(short);
81 newcg->cg_freeoff =
82 newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY);
83 newcg->cg_nextfreeoff = newcg->cg_freeoff +
84 howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs),
85 NBBY);
86 newcg->cg_magic = CG_MAGIC;
87 basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
88 sumsize = newcg->cg_iusedoff - newcg->cg_btotoff;
89 mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff;
90 break;
91
92 default:
93 errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d\n",
94 fs->fs_postblformat);
95 }
96 bzero((char *)&idesc[0], sizeof idesc);
97 for (i = 0; i < 3; i++)
98 idesc[i].id_type = ADDR;
99 bzero((char *)&cstotal, sizeof(struct csum));
100 (void)time(&now);
101 j = blknum(fs, fs->fs_size + fs->fs_frag - 1);
102 for (i = fs->fs_size; i < j; i++)
103 setbmap(i);
104 for (c = 0; c < fs->fs_ncg; c++) {
105 getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize);
106 if (!cg_chkmagic(cg))
107 pfatal("CG %d: BAD MAGIC NUMBER\n", c);
108 dbase = cgbase(fs, c);
109 dmax = dbase + fs->fs_fpg;
110 if (dmax > fs->fs_size)
111 dmax = fs->fs_size;
112 if (now > cg->cg_time)
113 newcg->cg_time = cg->cg_time;
114 else
115 newcg->cg_time = now;
116 newcg->cg_cgx = c;
117 if (c == fs->fs_ncg - 1)
118 newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg;
119 else
120 newcg->cg_ncyl = fs->fs_cpg;
121 newcg->cg_ndblk = dmax - dbase;
122 newcg->cg_cs.cs_ndir = 0;
123 newcg->cg_cs.cs_nffree = 0;
124 newcg->cg_cs.cs_nbfree = 0;
125 newcg->cg_cs.cs_nifree = fs->fs_ipg;
126 if (cg->cg_rotor < newcg->cg_ndblk)
127 newcg->cg_rotor = cg->cg_rotor;
128 else
129 newcg->cg_rotor = 0;
130 if (cg->cg_frotor < newcg->cg_ndblk)
131 newcg->cg_frotor = cg->cg_frotor;
132 else
133 newcg->cg_frotor = 0;
134 if (cg->cg_irotor < newcg->cg_niblk)
135 newcg->cg_irotor = cg->cg_irotor;
136 else
137 newcg->cg_irotor = 0;
138 bzero((char *)&newcg->cg_frsum[0], sizeof newcg->cg_frsum);
139 bzero((char *)&cg_blktot(newcg)[0],
140 (size_t)(sumsize + mapsize));
141 if (fs->fs_postblformat == FS_42POSTBLFMT)
142 ocg->cg_magic = CG_MAGIC;
143 j = fs->fs_ipg * c;
144 for (i = 0; i < fs->fs_ipg; j++, i++) {
145 switch (statemap[j]) {
146
147 case USTATE:
148 break;
149
150 case DSTATE:
151 case DCLEAR:
152 case DFOUND:
153 newcg->cg_cs.cs_ndir++;
154 /* fall through */
155
156 case FSTATE:
157 case FCLEAR:
158 newcg->cg_cs.cs_nifree--;
159 setbit(cg_inosused(newcg), i);
160 break;
161
162 default:
163 if (j < ROOTINO)
164 break;
165 errexit("BAD STATE %d FOR INODE I=%d",
166 statemap[j], j);
167 }
168 }
169 if (c == 0)
170 for (i = 0; i < ROOTINO; i++) {
171 setbit(cg_inosused(newcg), i);
172 newcg->cg_cs.cs_nifree--;
173 }
174 for (i = 0, d = dbase;
175 d < dmax;
176 d += fs->fs_frag, i += fs->fs_frag) {
177 frags = 0;
178 for (j = 0; j < fs->fs_frag; j++) {
179 if (testbmap(d + j))
180 continue;
181 setbit(cg_blksfree(newcg), i + j);
182 frags++;
183 }
184 if (frags == fs->fs_frag) {
185 newcg->cg_cs.cs_nbfree++;
186 j = cbtocylno(fs, i);
187 cg_blktot(newcg)[j]++;
188 cg_blks(fs, newcg, j)[cbtorpos(fs, i)]++;
189 } else if (frags > 0) {
190 newcg->cg_cs.cs_nffree += frags;
191 blk = blkmap(fs, cg_blksfree(newcg), i);
192 fragacct(fs, blk, newcg->cg_frsum, 1);
193 }
194 }
195 cstotal.cs_nffree += newcg->cg_cs.cs_nffree;
196 cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree;
197 cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
198 cstotal.cs_ndir += newcg->cg_cs.cs_ndir;
199 cs = &fs->fs_cs(fs, c);
200 if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&
201 dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
202 bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
203 sbdirty();
204 }
205 if (cvtflag) {
206 bcopy((char *)newcg, (char *)cg, (size_t)fs->fs_cgsize);
207 cgdirty();
208 continue;
209 }
210 if (bcmp(cg_inosused(newcg),
211 cg_inosused(cg), mapsize) != 0 &&
212 dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
213 bcopy(cg_inosused(newcg), cg_inosused(cg),
214 (size_t)mapsize);
215 cgdirty();
216 }
217 if ((bcmp((char *)newcg, (char *)cg, basesize) != 0 ||
218 bcmp((char *)&cg_blktot(newcg)[0],
219 (char *)&cg_blktot(cg)[0], sumsize) != 0) &&
220 dofix(&idesc[2], "SUMMARY INFORMATION BAD")) {
221 bcopy((char *)newcg, (char *)cg, (size_t)basesize);
222 bcopy((char *)&cg_blktot(newcg)[0],
223 (char *)&cg_blktot(cg)[0], (size_t)sumsize);
224 cgdirty();
225 }
226 }
227 if (fs->fs_postblformat == FS_42POSTBLFMT)
228 fs->fs_nrpos = savednrpos;
229 if (bcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
230 && dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
231 bcopy((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs);
232 fs->fs_ronly = 0;
233 fs->fs_fmod = 0;
234 sbdirty();
235 }
236 }
237