![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to setup.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 setup.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[] = "@(#)setup.c 5.3 (Berkeley) 5/15/86";
9: #endif not lint
10:
11: #include <sys/param.h>
12: #include <sys/inode.h>
13: #include <sys/fs.h>
14: #include <sys/stat.h>
15: #include "fsck.h"
16:
17: char *calloc();
18:
19: setup(dev)
20: char *dev;
21: {
22: dev_t rootdev;
23: struct stat statb;
24: daddr_t super = bflag ? bflag : SBLOCK;
25: int i, j;
26: long size;
27: BUFAREA asblk;
28: # define altsblock asblk.b_un.b_fs
29:
30: if (stat("/", &statb) < 0)
31: errexit("Can't stat root\n");
32: rootdev = statb.st_dev;
33: if (stat(dev, &statb) < 0) {
34: printf("Can't stat %s\n", dev);
35: return (0);
36: }
37: rawflg = 0;
38: if ((statb.st_mode & S_IFMT) == S_IFBLK)
39: ;
40: else if ((statb.st_mode & S_IFMT) == S_IFCHR)
41: rawflg++;
42: else {
43: if (reply("file is not a block or character device; OK") == 0)
44: return (0);
45: }
46: if (rootdev == statb.st_rdev)
47: hotroot++;
48: if ((dfile.rfdes = open(dev, 0)) < 0) {
49: printf("Can't open %s\n", dev);
50: return (0);
51: }
52: if (preen == 0)
53: printf("** %s", dev);
54: if (nflag || (dfile.wfdes = open(dev, 1)) < 0) {
55: dfile.wfdes = -1;
56: if (preen)
57: pfatal("NO WRITE ACCESS");
58: printf(" (NO WRITE)");
59: }
60: if (preen == 0)
61: printf("\n");
62: dfile.mod = 0;
63: lfdir = 0;
64: initbarea(&sblk);
65: initbarea(&fileblk);
66: initbarea(&inoblk);
67: initbarea(&cgblk);
68: initbarea(&asblk);
69: /*
70: * Read in the super block and its summary info.
71: */
72: if (bread(&dfile, (char *)&sblock, super, (long)SBSIZE) != 0)
73: return (0);
74: sblk.b_bno = super;
75: sblk.b_size = SBSIZE;
76: /*
77: * run a few consistency checks of the super block
78: */
79: if (sblock.fs_magic != FS_MAGIC)
80: { badsb("MAGIC NUMBER WRONG"); return (0); }
81: if (sblock.fs_ncg < 1)
82: { badsb("NCG OUT OF RANGE"); return (0); }
83: if (sblock.fs_cpg < 1 || sblock.fs_cpg > MAXCPG)
84: { badsb("CPG OUT OF RANGE"); return (0); }
85: if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
86: (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
87: { badsb("NCYL DOES NOT JIVE WITH NCG*CPG"); return (0); }
88: if (sblock.fs_sbsize > SBSIZE)
89: { badsb("SIZE PREPOSTEROUSLY LARGE"); return (0); }
90: /*
91: * Check and potentially fix certain fields in the super block.
92: */
93: if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
94: pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
95: if (reply("SET TO DEFAULT") == 1) {
96: sblock.fs_optim = FS_OPTTIME;
97: sbdirty();
98: }
99: }
100: if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
101: pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
102: sblock.fs_minfree);
103: if (reply("SET TO DEFAULT") == 1) {
104: sblock.fs_minfree = 10;
105: sbdirty();
106: }
107: }
108: /*
109: * Set all possible fields that could differ, then do check
110: * of whole super block against an alternate super block.
111: * When an alternate super-block is specified this check is skipped.
112: */
113: if (bflag)
114: goto sbok;
115: getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
116: if (asblk.b_errs != NULL)
117: return (0);
118: altsblock.fs_link = sblock.fs_link;
119: altsblock.fs_rlink = sblock.fs_rlink;
120: altsblock.fs_time = sblock.fs_time;
121: altsblock.fs_cstotal = sblock.fs_cstotal;
122: altsblock.fs_cgrotor = sblock.fs_cgrotor;
123: altsblock.fs_fmod = sblock.fs_fmod;
124: altsblock.fs_clean = sblock.fs_clean;
125: altsblock.fs_ronly = sblock.fs_ronly;
126: altsblock.fs_flags = sblock.fs_flags;
127: altsblock.fs_maxcontig = sblock.fs_maxcontig;
128: altsblock.fs_minfree = sblock.fs_minfree;
129: altsblock.fs_optim = sblock.fs_optim;
130: altsblock.fs_rotdelay = sblock.fs_rotdelay;
131: altsblock.fs_maxbpg = sblock.fs_maxbpg;
132: bcopy((char *)sblock.fs_csp, (char *)altsblock.fs_csp,
133: sizeof sblock.fs_csp);
134: bcopy((char *)sblock.fs_fsmnt, (char *)altsblock.fs_fsmnt,
135: sizeof sblock.fs_fsmnt);
136: if (bcmp((char *)&sblock, (char *)&altsblock, (int)sblock.fs_sbsize))
137: { badsb("TRASHED VALUES IN SUPER BLOCK"); return (0); }
138: sbok:
139: fmax = sblock.fs_size;
140: imax = sblock.fs_ncg * sblock.fs_ipg;
141: /*
142: * read in the summary info.
143: */
144: for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
145: size = sblock.fs_cssize - i < sblock.fs_bsize ?
146: sblock.fs_cssize - i : sblock.fs_bsize;
147: sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
148: if (bread(&dfile, (char *)sblock.fs_csp[j],
149: fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
150: size) != 0)
151: return (0);
152: }
153: /*
154: * allocate and initialize the necessary maps
155: */
156: bmapsz = roundup(howmany(fmax, NBBY), sizeof(short));
157: blockmap = calloc((unsigned)bmapsz, sizeof (char));
158: if (blockmap == NULL) {
159: printf("cannot alloc %d bytes for blockmap\n", bmapsz);
160: goto badsb;
161: }
162: statemap = calloc((unsigned)(imax + 1), sizeof(char));
163: if (statemap == NULL) {
164: printf("cannot alloc %d bytes for statemap\n", imax + 1);
165: goto badsb;
166: }
167: lncntp = (short *)calloc((unsigned)(imax + 1), sizeof(short));
168: if (lncntp == NULL) {
169: printf("cannot alloc %d bytes for lncntp\n",
170: (imax + 1) * sizeof(short));
171: goto badsb;
172: }
173:
174: return (1);
175:
176: badsb:
177: ckfini();
178: return (0);
179: # undef altsblock
180: }
181:
182: badsb(s)
183: char *s;
184: {
185:
186: if (preen)
187: printf("%s: ", devname);
188: printf("BAD SUPER BLOCK: %s\n", s);
189: pwarn("USE -b OPTION TO FSCK TO SPECIFY LOCATION OF AN ALTERNATE\n");
190: pfatal("SUPER-BLOCK TO SUPPLY NEEDED INFORMATION; SEE fsck(8).\n");
191: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.