Commit | Line | Data |
---|---|---|
aca50d72 | 1 | static char *sccsid = "@(#)icheck.c 1.13 (Berkeley) %G%"; |
955f6ff8 | 2 | |
b42940ce KM |
3 | /* |
4 | * icheck | |
5 | */ | |
6 | #define NB 500 | |
b42940ce | 7 | #define MAXFN 500 |
c312eebd | 8 | #define MAXNINDIR (MAXBSIZE / sizeof (daddr_t)) |
b42940ce KM |
9 | |
10 | #ifndef STANDALONE | |
11 | #include <stdio.h> | |
12 | #endif | |
13 | #include "../h/param.h" | |
14 | #include "../h/inode.h" | |
b42940ce KM |
15 | #include "../h/fs.h" |
16 | ||
b42940ce KM |
17 | union { |
18 | struct fs sb; | |
b6407c9d | 19 | char pad[MAXBSIZE]; |
b42940ce KM |
20 | } sbun; |
21 | #define sblock sbun.sb | |
22 | ||
23 | union { | |
24 | struct cg cg; | |
b6407c9d | 25 | char pad[MAXBSIZE]; |
b42940ce KM |
26 | } cgun; |
27 | #define cgrp cgun.cg | |
28 | ||
29 | struct dinode itab[MAXIPG]; | |
b42940ce KM |
30 | daddr_t blist[NB]; |
31 | char *bmap; | |
32 | ||
b42940ce | 33 | int mflg; |
19f19804 | 34 | int sflg; |
b42940ce KM |
35 | int dflg; |
36 | int fi; | |
37 | ino_t ino; | |
38 | int cginit; | |
39 | ||
40 | ino_t nrfile; | |
41 | ino_t ndfile; | |
42 | ino_t nbfile; | |
43 | ino_t ncfile; | |
44 | ino_t nmcfile; | |
45 | ||
46 | daddr_t nblock; | |
47 | daddr_t nfrag; | |
b42940ce | 48 | daddr_t nindir; |
b42940ce KM |
49 | daddr_t niindir; |
50 | ||
51 | daddr_t nffree; | |
b42940ce KM |
52 | daddr_t nbfree; |
53 | ||
54 | daddr_t ndup; | |
55 | ||
56 | int nerror; | |
57 | ||
19f19804 | 58 | extern int inside[], around[]; |
b6407c9d | 59 | extern unsigned char *fragtbl[]; |
19f19804 | 60 | |
b42940ce | 61 | long atol(); |
b42940ce KM |
62 | #ifndef STANDALONE |
63 | char *malloc(); | |
19f19804 | 64 | char *calloc(); |
b42940ce KM |
65 | #endif |
66 | ||
67 | main(argc, argv) | |
19f19804 KM |
68 | int argc; |
69 | char *argv[]; | |
b42940ce KM |
70 | { |
71 | register i; | |
72 | long n; | |
73 | ||
74 | blist[0] = -1; | |
75 | #ifndef STANDALONE | |
76 | while (--argc) { | |
77 | argv++; | |
78 | if (**argv=='-') | |
79 | switch ((*argv)[1]) { | |
80 | case 'd': | |
81 | dflg++; | |
82 | continue; | |
83 | ||
84 | case 'm': | |
85 | mflg++; | |
86 | continue; | |
87 | ||
19f19804 KM |
88 | case 's': |
89 | sflg++; | |
90 | continue; | |
91 | ||
b42940ce KM |
92 | case 'b': |
93 | for(i=0; i<NB; i++) { | |
94 | n = atol(argv[1]); | |
95 | if(n == 0) | |
96 | break; | |
97 | blist[i] = n; | |
98 | argv++; | |
99 | argc--; | |
100 | } | |
101 | blist[i] = -1; | |
102 | continue; | |
103 | ||
104 | default: | |
105 | printf("Bad flag\n"); | |
106 | } | |
107 | check(*argv); | |
108 | } | |
109 | #else | |
110 | { | |
111 | static char fname[128]; | |
112 | ||
113 | printf("File: "); | |
114 | gets(fname); | |
115 | check(fname); | |
116 | } | |
117 | #endif | |
118 | return(nerror); | |
119 | } | |
120 | ||
121 | check(file) | |
19f19804 | 122 | char *file; |
b42940ce KM |
123 | { |
124 | register i, j, c; | |
125 | daddr_t d, cgd, cbase, b; | |
126 | long n; | |
127 | ||
19f19804 | 128 | fi = open(file, sflg ? 2 : 0); |
b42940ce | 129 | if (fi < 0) { |
19f19804 | 130 | perror(file); |
b42940ce KM |
131 | nerror |= 04; |
132 | return; | |
133 | } | |
134 | printf("%s:\n", file); | |
135 | nrfile = 0; | |
136 | ndfile = 0; | |
137 | ncfile = 0; | |
138 | nbfile = 0; | |
139 | nmcfile = 0; | |
140 | ||
141 | nblock = 0; | |
142 | nfrag = 0; | |
b42940ce | 143 | nindir = 0; |
b42940ce KM |
144 | niindir = 0; |
145 | ||
146 | ndup = 0; | |
147 | #ifndef STANDALONE | |
148 | sync(); | |
149 | #endif | |
b6407c9d KM |
150 | getsb(&sblock, file); |
151 | if (nerror) | |
b42940ce | 152 | return; |
b42940ce | 153 | ino = 0; |
19f19804 | 154 | n = roundup(howmany(sblock.fs_size, NBBY), sizeof(short)); |
b42940ce KM |
155 | #ifdef STANDALONE |
156 | bmap = NULL; | |
157 | #else | |
158 | bmap = malloc((unsigned)n); | |
159 | #endif | |
160 | if (bmap==NULL) { | |
161 | printf("Not enough core; duplicates unchecked\n"); | |
162 | dflg++; | |
19f19804 KM |
163 | if (sflg) { |
164 | printf("No Updates\n"); | |
165 | sflg = 0; | |
166 | } | |
b42940ce KM |
167 | } |
168 | ino = 0; | |
169 | cginit = 1; | |
170 | if(!dflg) { | |
171 | for (i=0; i<(unsigned)n; i++) | |
172 | bmap[i] = 0; | |
173 | for (c=0; c < sblock.fs_ncg; c++) { | |
174 | cgd = cgtod(c, &sblock); | |
b6407c9d KM |
175 | for (d = cgbase(c, &sblock); d < cgd; d += sblock.fs_frag) |
176 | chk(d, "badcg", sblock.fs_bsize); | |
b42940ce KM |
177 | d = cgimin(c, &sblock); |
178 | while (cgd < d) { | |
b6407c9d KM |
179 | chk(cgd, "cg", sblock.fs_bsize); |
180 | cgd += sblock.fs_frag; | |
b42940ce KM |
181 | } |
182 | d = cgdmin(c, &sblock); | |
b6407c9d KM |
183 | for (; cgd < d; cgd += sblock.fs_frag) |
184 | chk(cgd, "inode", sblock.fs_bsize); | |
b42940ce | 185 | if (c == 0) { |
b6407c9d KM |
186 | d += howmany(sblock.fs_cssize, sblock.fs_bsize) |
187 | * sblock.fs_frag; | |
188 | for (; cgd < d; cgd += sblock.fs_frag) | |
189 | chk(cgd, "csum", sblock.fs_bsize); | |
b42940ce KM |
190 | } |
191 | } | |
192 | } | |
193 | cginit = 0; | |
194 | for (c = 0; c < sblock.fs_ncg; c++) { | |
b6407c9d | 195 | bread(fsbtodb(&sblock, cgimin(c,&sblock)), (char *)itab, |
b42940ce KM |
196 | sblock.fs_ipg * sizeof (struct dinode)); |
197 | for (j=0; j < sblock.fs_ipg; j++) { | |
198 | pass1(&itab[j]); | |
199 | ino++; | |
200 | } | |
201 | } | |
202 | ino = 0; | |
203 | #ifndef STANDALONE | |
204 | sync(); | |
205 | #endif | |
19f19804 KM |
206 | if (sflg) { |
207 | makecg(); | |
208 | close(fi); | |
209 | #ifndef STANDALONE | |
210 | if (bmap) | |
211 | free(bmap); | |
212 | #endif | |
213 | return; | |
214 | } | |
b42940ce | 215 | nffree = 0; |
b42940ce KM |
216 | nbfree = 0; |
217 | for (c = 0; c < sblock.fs_ncg; c++) { | |
218 | cbase = cgbase(c,&sblock); | |
b6407c9d KM |
219 | bread(fsbtodb(&sblock, cgtod(c,&sblock)), (char *)&cgrp, |
220 | sblock.fs_cgsize); | |
221 | for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) { | |
222 | if (isblock(&sblock, cgrp.cg_free, | |
223 | b / sblock.fs_frag)) { | |
b42940ce | 224 | nbfree++; |
b6407c9d | 225 | chk(cbase+b, "block", sblock.fs_bsize); |
b42940ce | 226 | } else { |
b6407c9d | 227 | for (d = 0; d < sblock.fs_frag; d++) |
b42940ce | 228 | if (isset(cgrp.cg_free, b+d)) { |
b6407c9d | 229 | chk(cbase+b+d, "frag", sblock.fs_fsize); |
b42940ce | 230 | nffree++; |
b42940ce KM |
231 | } |
232 | } | |
233 | } | |
234 | } | |
235 | close(fi); | |
236 | #ifndef STANDALONE | |
237 | if (bmap) | |
238 | free(bmap); | |
239 | #endif | |
240 | ||
241 | i = nrfile + ndfile + ncfile + nbfile + nmcfile; | |
242 | #ifndef STANDALONE | |
243 | printf("files %6u (r=%u,d=%u,b=%u,c=%u,mc=%u)\n", | |
244 | i, nrfile, ndfile, nbfile, ncfile, nmcfile); | |
245 | #else | |
246 | printf("files %u (r=%u,d=%u,b=%u,c=%u,mc=%u)\n", | |
247 | i, nrfile, ndfile, nbfile, ncfile, nmcfile); | |
248 | #endif | |
b6407c9d | 249 | n = (nblock + nindir + niindir) * sblock.fs_frag + nfrag; |
b42940ce KM |
250 | #ifdef STANDALONE |
251 | printf("used %ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n", | |
252 | n, nindir, niindir, nblock, nfrag); | |
b6407c9d | 253 | printf("free %ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree, |
b42940ce KM |
254 | nbfree, nffree); |
255 | #else | |
256 | printf("used %7ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n", | |
257 | n, nindir, niindir, nblock, nfrag); | |
b6407c9d | 258 | printf("free %7ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree, |
b42940ce KM |
259 | nbfree, nffree); |
260 | #endif | |
261 | if(!dflg) { | |
262 | n = 0; | |
955f6ff8 | 263 | for (d = 0; d < sblock.fs_size; d++) |
b6407c9d | 264 | if(!duped(d, sblock.fs_fsize)) { |
b42940ce KM |
265 | if(mflg) |
266 | printf("%ld missing\n", d); | |
267 | n++; | |
268 | } | |
269 | printf("missing%5ld\n", n); | |
270 | } | |
271 | } | |
272 | ||
273 | pass1(ip) | |
955f6ff8 | 274 | register struct dinode *ip; |
b42940ce | 275 | { |
b6407c9d KM |
276 | daddr_t ind1[MAXNINDIR]; |
277 | daddr_t ind2[MAXNINDIR]; | |
07670f7d KM |
278 | daddr_t db, ib; |
279 | register int i, j, k, siz; | |
b42940ce KM |
280 | |
281 | i = ip->di_mode & IFMT; | |
0947395d | 282 | if(i == 0) |
b42940ce | 283 | return; |
b42940ce KM |
284 | switch (i) { |
285 | case IFCHR: | |
286 | ncfile++; | |
287 | return; | |
288 | case IFBLK: | |
289 | nbfile++; | |
290 | return; | |
291 | case IFDIR: | |
292 | ndfile++; | |
293 | break; | |
294 | case IFREG: | |
295 | nrfile++; | |
296 | break; | |
297 | default: | |
298 | printf("bad mode %u\n", ino); | |
299 | return; | |
300 | } | |
955f6ff8 KM |
301 | for (i = 0; i < NDADDR; i++) { |
302 | db = ip->di_db[i]; | |
303 | if (db == 0) | |
b42940ce | 304 | continue; |
b6407c9d | 305 | siz = dblksize(&sblock, ip, i); |
07670f7d | 306 | chk(db, "data (block)", siz); |
b6407c9d | 307 | if (siz == sblock.fs_bsize) |
07670f7d KM |
308 | nblock++; |
309 | else | |
b6407c9d | 310 | nfrag += howmany(siz, sblock.fs_fsize); |
b42940ce | 311 | } |
955f6ff8 KM |
312 | for(i = 0; i < NIADDR; i++) { |
313 | ib = ip->di_ib[i]; | |
314 | if(ib == 0) | |
315 | continue; | |
b6407c9d | 316 | if (chk(ib, "1st indirect", sblock.fs_bsize)) |
b42940ce | 317 | continue; |
b6407c9d | 318 | bread(fsbtodb(&sblock, ib), (char *)ind1, sblock.fs_bsize); |
b42940ce | 319 | nindir++; |
b6407c9d | 320 | for (j = 0; j < NINDIR(&sblock); j++) { |
955f6ff8 KM |
321 | ib = ind1[j]; |
322 | if (ib == 0) | |
b42940ce | 323 | continue; |
955f6ff8 | 324 | if (i == 0) { |
b6407c9d | 325 | siz = dblksize(&sblock, ip, NDADDR + j); |
07670f7d | 326 | chk(ib, "data (large)", siz); |
b6407c9d | 327 | if (siz == sblock.fs_bsize) |
07670f7d KM |
328 | nblock++; |
329 | else | |
b6407c9d | 330 | nfrag += howmany(siz, sblock.fs_fsize); |
b42940ce KM |
331 | continue; |
332 | } | |
b6407c9d | 333 | if (chk(ib, "2nd indirect", sblock.fs_bsize)) |
955f6ff8 | 334 | continue; |
b6407c9d KM |
335 | bread(fsbtodb(&sblock, ib), (char *)ind2, |
336 | sblock.fs_bsize); | |
b42940ce | 337 | niindir++; |
b6407c9d | 338 | for (k = 0; k < NINDIR(&sblock); k++) { |
955f6ff8 KM |
339 | ib = ind2[k]; |
340 | if (ib == 0) | |
b42940ce | 341 | continue; |
b6407c9d KM |
342 | siz = dblksize(&sblock, ip, |
343 | NDADDR + NINDIR(&sblock) * (i + j) + k); | |
07670f7d | 344 | chk(ib, "data (huge)", siz); |
b6407c9d | 345 | if (siz == sblock.fs_bsize) |
07670f7d KM |
346 | nblock++; |
347 | else | |
b6407c9d | 348 | nfrag += howmany(siz, sblock.fs_fsize); |
b42940ce | 349 | } |
b42940ce KM |
350 | } |
351 | } | |
352 | } | |
353 | ||
07670f7d | 354 | chk(bno, s, size) |
955f6ff8 KM |
355 | daddr_t bno; |
356 | char *s; | |
07670f7d | 357 | int size; |
b42940ce KM |
358 | { |
359 | register n, cg; | |
360 | ||
361 | cg = dtog(bno, &sblock); | |
07670f7d | 362 | if (cginit==0 && |
b6407c9d | 363 | bno<cgdmin(cg,&sblock) || bno >= sblock.fs_frag * sblock.fs_size) { |
b42940ce KM |
364 | printf("%ld bad; inode=%u, class=%s\n", bno, ino, s); |
365 | return(1); | |
366 | } | |
b6407c9d | 367 | if (size == sblock.fs_bsize) { |
07670f7d KM |
368 | if (duped(bno, size)) { |
369 | printf("%ld dup block; inode=%u, class=%s\n", | |
370 | bno, ino, s); | |
b6407c9d | 371 | ndup += sblock.fs_frag; |
07670f7d KM |
372 | } |
373 | } else { | |
b6407c9d KM |
374 | for (n = 0; n < size / sblock.fs_fsize; n++) { |
375 | if (duped(bno + n, sblock.fs_fsize)) { | |
07670f7d KM |
376 | printf("%ld dup frag; inode=%u, class=%s\n", |
377 | bno, ino, s); | |
378 | ndup++; | |
379 | } | |
380 | } | |
b42940ce KM |
381 | } |
382 | for (n=0; blist[n] != -1; n++) | |
383 | if (bno == blist[n]) | |
384 | printf("%ld arg; inode=%u, class=%s\n", bno, ino, s); | |
385 | return(0); | |
386 | } | |
387 | ||
07670f7d | 388 | duped(bno, size) |
955f6ff8 | 389 | daddr_t bno; |
07670f7d | 390 | int size; |
b42940ce | 391 | { |
b42940ce KM |
392 | if(dflg) |
393 | return(0); | |
b6407c9d | 394 | if (size != sblock.fs_fsize && size != sblock.fs_bsize) |
07670f7d | 395 | printf("bad size %d to duped\n", size); |
b6407c9d | 396 | if (size == sblock.fs_fsize) { |
955f6ff8 KM |
397 | if (isset(bmap, bno)) |
398 | return(1); | |
399 | setbit(bmap, bno); | |
400 | return (0); | |
401 | } | |
b6407c9d | 402 | if (bno % sblock.fs_frag != 0) |
955f6ff8 | 403 | printf("bad bno %d to duped\n", bno); |
b6407c9d | 404 | if (isblock(&sblock, bmap, bno/sblock.fs_frag)) |
955f6ff8 | 405 | return (1); |
b6407c9d | 406 | setblock(&sblock, bmap, bno/sblock.fs_frag); |
b42940ce KM |
407 | return(0); |
408 | } | |
409 | ||
19f19804 KM |
410 | makecg() |
411 | { | |
412 | int c, blk; | |
413 | daddr_t dbase, d, dmin, dmax; | |
414 | long i, j, s; | |
415 | register struct csum *cs; | |
416 | register struct dinode *dp; | |
417 | ||
418 | sblock.fs_cstotal.cs_nbfree = 0; | |
419 | sblock.fs_cstotal.cs_nffree = 0; | |
420 | sblock.fs_cstotal.cs_nifree = 0; | |
421 | sblock.fs_cstotal.cs_ndir = 0; | |
19f19804 KM |
422 | for (c = 0; c < sblock.fs_ncg; c++) { |
423 | dbase = cgbase(c, &sblock); | |
424 | dmax = dbase + sblock.fs_fpg; | |
425 | if (dmax > sblock.fs_size) | |
426 | dmax = sblock.fs_size; | |
427 | dmin = cgdmin(c, &sblock) - dbase; | |
b6407c9d | 428 | cs = &sblock.fs_cs(&sblock, c); |
19f19804 KM |
429 | cgrp.cg_time = time(0); |
430 | cgrp.cg_magic = CG_MAGIC; | |
431 | cgrp.cg_cgx = c; | |
432 | cgrp.cg_ncyl = sblock.fs_cpg; | |
433 | cgrp.cg_niblk = sblock.fs_ipg; | |
434 | cgrp.cg_ndblk = dmax - dbase; | |
435 | cgrp.cg_cs.cs_ndir = 0; | |
436 | cgrp.cg_cs.cs_nffree = 0; | |
437 | cgrp.cg_cs.cs_nbfree = 0; | |
438 | cgrp.cg_cs.cs_nifree = 0; | |
439 | cgrp.cg_rotor = dmin; | |
440 | cgrp.cg_frotor = dmin; | |
441 | cgrp.cg_irotor = 0; | |
b6407c9d | 442 | for (i = 0; i < sblock.fs_frag; i++) |
19f19804 | 443 | cgrp.cg_frsum[i] = 0; |
b6407c9d | 444 | bread(fsbtodb(&sblock, cgimin(c, &sblock)), (char *)itab, |
19f19804 KM |
445 | sblock.fs_ipg * sizeof(struct dinode)); |
446 | for (i = 0; i < sblock.fs_ipg; i++) { | |
447 | dp = &itab[i]; | |
448 | if (dp == NULL) | |
449 | continue; | |
450 | if ((dp->di_mode & IFMT) != 0) { | |
451 | if ((dp->di_mode & IFMT) == IFDIR) | |
452 | cgrp.cg_cs.cs_ndir++; | |
453 | setbit(cgrp.cg_iused, i); | |
454 | continue; | |
455 | } | |
456 | cgrp.cg_cs.cs_nifree++; | |
457 | clrbit(cgrp.cg_iused, i); | |
458 | } | |
459 | while (i < MAXIPG) { | |
460 | clrbit(cgrp.cg_iused, i); | |
461 | i++; | |
462 | } | |
8e5c1c7c KM |
463 | if (c == 0) |
464 | for (i = 0; i < ROOTINO; i++) { | |
465 | setbit(cgrp.cg_iused, i); | |
466 | cgrp.cg_cs.cs_nifree--; | |
467 | } | |
19f19804 KM |
468 | for (s = 0; s < MAXCPG; s++) |
469 | for (i = 0; i < NRPOS; i++) | |
470 | cgrp.cg_b[s][i] = 0; | |
471 | if (c == 0) { | |
b6407c9d KM |
472 | dmin += howmany(sblock.fs_cssize, sblock.fs_bsize) * |
473 | sblock.fs_frag; | |
19f19804 KM |
474 | } |
475 | for (d = 0; d < dmin; d++) | |
476 | clrbit(cgrp.cg_free, d); | |
b6407c9d | 477 | for (; (d + sblock.fs_frag) <= dmax - dbase; d += sblock.fs_frag) { |
19f19804 | 478 | j = 0; |
b6407c9d | 479 | for (i = 0; i < sblock.fs_frag; i++) { |
19f19804 KM |
480 | if (!isset(bmap, dbase+d+i)) { |
481 | setbit(cgrp.cg_free, d+i); | |
482 | j++; | |
483 | } else | |
484 | clrbit(cgrp.cg_free, d+i); | |
485 | } | |
b6407c9d | 486 | if (j == sblock.fs_frag) { |
19f19804 | 487 | cgrp.cg_cs.cs_nbfree++; |
aca50d72 KM |
488 | cgrp.cg_b[cbtocylno(&sblock, d)] |
489 | [cbtorpos(&sblock, d)]++; | |
19f19804 KM |
490 | } else if (j > 0) { |
491 | cgrp.cg_cs.cs_nffree += j; | |
492 | blk = ((cgrp.cg_free[d / NBBY] >> (d % NBBY)) & | |
b6407c9d KM |
493 | (0xff >> (NBBY - sblock.fs_frag))); |
494 | fragacct(&sblock, blk, cgrp.cg_frsum, 1); | |
19f19804 KM |
495 | } |
496 | } | |
497 | for (j = d; d < dmax - dbase; d++) { | |
498 | if (!isset(bmap, dbase+d)) { | |
499 | setbit(cgrp.cg_free, d); | |
500 | cgrp.cg_cs.cs_nffree++; | |
501 | } else | |
502 | clrbit(cgrp.cg_free, d); | |
503 | } | |
504 | if (j != d) { | |
505 | blk = ((cgrp.cg_free[j / NBBY] >> (j % NBBY)) & | |
b6407c9d KM |
506 | (0xff >> (NBBY - sblock.fs_frag))); |
507 | fragacct(&sblock, blk, cgrp.cg_frsum, 1); | |
19f19804 | 508 | } |
b6407c9d | 509 | for (; d < MAXBPG(&sblock); d++) |
19f19804 KM |
510 | clrbit(cgrp.cg_free, d); |
511 | sblock.fs_cstotal.cs_nffree += cgrp.cg_cs.cs_nffree; | |
512 | sblock.fs_cstotal.cs_nbfree += cgrp.cg_cs.cs_nbfree; | |
513 | sblock.fs_cstotal.cs_nifree += cgrp.cg_cs.cs_nifree; | |
514 | sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir; | |
515 | *cs = cgrp.cg_cs; | |
b6407c9d KM |
516 | bwrite(fsbtodb(&sblock, cgtod(c, &sblock)), &cgrp, |
517 | sblock.fs_cgsize); | |
19f19804 | 518 | } |
b6407c9d KM |
519 | for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) { |
520 | bwrite(fsbtodb(&sblock, | |
521 | sblock.fs_csaddr + (i * sblock.fs_frag)), | |
522 | (char *)sblock.fs_csp[i], sblock.fs_bsize); | |
19f19804 KM |
523 | } |
524 | sblock.fs_ronly = 0; | |
525 | sblock.fs_fmod = 0; | |
c312eebd | 526 | bwrite(SBLOCK, (char *)&sblock, SBSIZE); |
19f19804 KM |
527 | } |
528 | ||
529 | /* | |
530 | * update the frsum fields to reflect addition or deletion | |
531 | * of some frags | |
532 | */ | |
b6407c9d KM |
533 | fragacct(fs, fragmap, fraglist, cnt) |
534 | struct fs *fs; | |
19f19804 KM |
535 | int fragmap; |
536 | long fraglist[]; | |
537 | int cnt; | |
538 | { | |
539 | int inblk; | |
540 | register int field, subfield; | |
541 | register int siz, pos; | |
542 | ||
b6407c9d | 543 | inblk = (int)(fragtbl[fs->fs_frag][fragmap] << 1); |
19f19804 | 544 | fragmap <<= 1; |
b6407c9d | 545 | for (siz = 1; siz < fs->fs_frag; siz++) { |
19f19804 KM |
546 | if (((1 << siz) & inblk) == 0) |
547 | continue; | |
548 | field = around[siz]; | |
549 | subfield = inside[siz]; | |
b6407c9d | 550 | for (pos = siz; pos <= fs->fs_frag; pos++) { |
19f19804 KM |
551 | if ((fragmap & field) == subfield) { |
552 | fraglist[siz] += cnt; | |
553 | pos += siz; | |
554 | field <<= siz; | |
555 | subfield <<= siz; | |
556 | } | |
557 | field <<= 1; | |
558 | subfield <<= 1; | |
559 | } | |
560 | } | |
561 | } | |
562 | ||
b6407c9d KM |
563 | getsb(fs, file) |
564 | register struct fs *fs; | |
565 | char *file; | |
566 | { | |
567 | int i; | |
568 | ||
c312eebd | 569 | if (bread(SBLOCK, fs, SBSIZE)) { |
b6407c9d KM |
570 | printf("bad super block"); |
571 | perror(file); | |
572 | nerror |= 04; | |
573 | return; | |
574 | } | |
575 | if (fs->fs_magic != FS_MAGIC) { | |
576 | printf("%s: bad magic number\n", file); | |
577 | nerror |= 04; | |
578 | return; | |
579 | } | |
580 | for (i = 0; i < howmany(fs->fs_cssize, fs->fs_bsize); i++) { | |
581 | fs->fs_csp[i] = (struct csum *)calloc(1, fs->fs_bsize); | |
582 | bread(fsbtodb(fs, fs->fs_csaddr + (i * fs->fs_frag)), | |
583 | (char *)fs->fs_csp[i], fs->fs_bsize); | |
584 | } | |
585 | } | |
586 | ||
19f19804 KM |
587 | bwrite(blk, buf, size) |
588 | char *buf; | |
589 | daddr_t blk; | |
590 | register size; | |
591 | { | |
b6407c9d | 592 | if (lseek(fi, blk * DEV_BSIZE, 0) < 0) { |
19f19804 KM |
593 | perror("FS SEEK"); |
594 | return(1); | |
595 | } | |
596 | if (write(fi, buf, size) != size) { | |
597 | perror("FS WRITE"); | |
598 | return(1); | |
599 | } | |
b6407c9d | 600 | return (0); |
19f19804 KM |
601 | } |
602 | ||
b42940ce | 603 | bread(bno, buf, cnt) |
955f6ff8 KM |
604 | daddr_t bno; |
605 | char *buf; | |
b42940ce KM |
606 | { |
607 | register i; | |
608 | ||
b6407c9d | 609 | lseek(fi, bno * DEV_BSIZE, 0); |
b42940ce | 610 | if ((i = read(fi, buf, cnt)) != cnt) { |
19f19804 KM |
611 | if (sflg) { |
612 | printf("No Update\n"); | |
613 | sflg = 0; | |
614 | } | |
b6407c9d | 615 | for(i=0; i<sblock.fs_bsize; i++) |
b42940ce | 616 | buf[i] = 0; |
b6407c9d KM |
617 | return (1); |
618 | } | |
619 | return (0); | |
620 | } | |
621 | ||
622 | /* | |
623 | * block operations | |
624 | */ | |
625 | ||
626 | isblock(fs, cp, h) | |
627 | struct fs *fs; | |
628 | unsigned char *cp; | |
629 | int h; | |
630 | { | |
631 | unsigned char mask; | |
632 | ||
633 | switch (fs->fs_frag) { | |
634 | case 8: | |
635 | return (cp[h] == 0xff); | |
636 | case 4: | |
637 | mask = 0x0f << ((h & 0x1) << 2); | |
638 | return ((cp[h >> 1] & mask) == mask); | |
639 | case 2: | |
640 | mask = 0x03 << ((h & 0x3) << 1); | |
641 | return ((cp[h >> 2] & mask) == mask); | |
642 | case 1: | |
643 | mask = 0x01 << (h & 0x7); | |
644 | return ((cp[h >> 3] & mask) == mask); | |
645 | default: | |
646 | fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag); | |
647 | return; | |
648 | } | |
649 | } | |
650 | ||
651 | setblock(fs, cp, h) | |
652 | struct fs *fs; | |
653 | unsigned char *cp; | |
654 | int h; | |
655 | { | |
656 | switch (fs->fs_frag) { | |
657 | case 8: | |
658 | cp[h] = 0xff; | |
659 | return; | |
660 | case 4: | |
661 | cp[h >> 1] |= (0x0f << ((h & 0x1) << 2)); | |
662 | return; | |
663 | case 2: | |
664 | cp[h >> 2] |= (0x03 << ((h & 0x3) << 1)); | |
665 | return; | |
666 | case 1: | |
667 | cp[h >> 3] |= (0x01 << (h & 0x7)); | |
668 | return; | |
669 | default: | |
670 | fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag); | |
671 | return; | |
b42940ce KM |
672 | } |
673 | } |