projects / unix-history / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
This commit was manufactured by cvs2svn to create tag 'FreeBSD-release/1.0'.
[unix-history] / sbin / fsck / setup.c
CommitLineData
15637ed4
RG		 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
35static char sccsid[] = "@(#)setup.c 5.33 (Berkeley) 2/22/91";
78ed81a3 36static char rcsid[] = "$Header: /b/source/CVS/src/sbin/fsck/setup.c,v 1.3 1993/03/23 00:28:14 cgd Exp $";
15637ed4
RG		 37#endif /* not lint */
38
39#define DKTYPENAMES
40#include <sys/param.h>
41#include <ufs/dinode.h>
42#include <ufs/fs.h>
43#include <sys/stat.h>
44#include <sys/ioctl.h>
45#include <sys/disklabel.h>
46#include <sys/file.h>
47#include <errno.h>
48#include <stdlib.h>
49#include <string.h>
50#include <ctype.h>
51#include "fsck.h"
52
53struct bufarea asblk;
54#define altsblock (*asblk.b_un.b_fs)
55#define POWEROF2(num) (((num) & ((num) - 1)) == 0)
56
57/*
58 * The size of a cylinder group is calculated by CGSIZE. The maximum size
59 * is limited by the fact that cylinder groups are at most one block.
60 * Its size is derived from the size of the maps maintained in the
61 * cylinder group and the (struct cg) size.
62 */
63#define CGSIZE(fs) \
64 /* base cg */ (sizeof(struct cg) + \
65 /* blktot size */ (fs)->fs_cpg * sizeof(long) + \
66 /* blks size */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(short) + \
67 /* inode map */ howmany((fs)->fs_ipg, NBBY) + \
68 /* block map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY))
69
70char *index();
71struct disklabel *getdisklabel();
72
73setup(dev)
74 char *dev;
75{
76 long cg, size, asked, i, j;
77 long bmapsize;
78 struct disklabel *lp;
79 struct stat statb;
80 struct fs proto;
81
82 havesb = 0;
83 if (stat(dev, &statb) < 0) {
84 printf("Can't stat %s: %s\n", dev, strerror(errno));
85 return (0);
86 }
87 if ((statb.st_mode & S_IFMT) != S_IFCHR) {
88 pfatal("%s is not a character device", dev);
89 if (reply("CONTINUE") == 0)
90 return (0);
91 }
92 if ((fsreadfd = open(dev, O_RDONLY)) < 0) {
93 printf("Can't open %s: %s\n", dev, strerror(errno));
94 return (0);
95 }
96 if (preen == 0)
97 printf("** %s", dev);
98 if (nflag || (fswritefd = open(dev, O_WRONLY)) < 0) {
99 fswritefd = -1;
100 if (preen)
101 pfatal("NO WRITE ACCESS");
102 printf(" (NO WRITE)");
103 }
104 if (preen == 0)
105 printf("\n");
106 fsmodified = 0;
107 lfdir = 0;
108 initbarea(&sblk);
109 initbarea(&asblk);
110 sblk.b_un.b_buf = malloc(SBSIZE);
111 asblk.b_un.b_buf = malloc(SBSIZE);
112 if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
113 errexit("cannot allocate space for superblock\n");
114 if (lp = getdisklabel((char *)NULL, fsreadfd))
115 dev_bsize = secsize = lp->d_secsize;
116 else
117 dev_bsize = secsize = DEV_BSIZE;
118#ifdef tahoe
119 /*
120 * On the tahoe, the disk label and the disk driver disagree.
121 * The label knows that sectors are 512 bytes, but the disk
122 * drivers will only transfer in 1024 sized pieces.
123 */
124 secsize = 1024;
125#endif
126 /*
127 * Read in the superblock, looking for alternates if necessary
128 */
129 if (readsb(1) == 0) {
130 if (bflag || preen || calcsb(dev, fsreadfd, &proto) == 0)
131 return(0);
132 if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
133 return (0);
134 for (cg = 0; cg < proto.fs_ncg; cg++) {
135 bflag = fsbtodb(&proto, cgsblock(&proto, cg));
136 if (readsb(0) != 0)
137 break;
138 }
139 if (cg >= proto.fs_ncg) {
140 printf("%s %s\n%s %s\n%s %s\n",
141 "SEARCH FOR ALTERNATE SUPER-BLOCK",
142 "FAILED. YOU MUST USE THE",
143 "-b OPTION TO FSCK TO SPECIFY THE",
144 "LOCATION OF AN ALTERNATE",
145 "SUPER-BLOCK TO SUPPLY NEEDED",
146 "INFORMATION; SEE fsck(8).");
147 return(0);
148 }
149 pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
150 }
151 maxfsblock = sblock.fs_size;
152 maxino = sblock.fs_ncg * sblock.fs_ipg;
153 /*
154 * Check and potentially fix certain fields in the super block.
155 */
156 if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
157 pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
158 if (reply("SET TO DEFAULT") == 1) {
159 sblock.fs_optim = FS_OPTTIME;
160 sbdirty();
161 }
162 }
163 if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
164 pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
165 sblock.fs_minfree);
166 if (reply("SET TO DEFAULT") == 1) {
167 sblock.fs_minfree = 10;
168 sbdirty();
169 }
170 }
171 if (sblock.fs_interleave < 1 ||
172 sblock.fs_interleave > sblock.fs_nsect) {
173 pwarn("IMPOSSIBLE INTERLEAVE=%d IN SUPERBLOCK",
174 sblock.fs_interleave);
175 sblock.fs_interleave = 1;
176 if (preen)
177 printf(" (FIXED)\n");
178 if (preen || reply("SET TO DEFAULT") == 1) {
179 sbdirty();
180 dirty(&asblk);
181 }
182 }
183 if (sblock.fs_npsect < sblock.fs_nsect ||
184 sblock.fs_npsect > sblock.fs_nsect*2) {
185 pwarn("IMPOSSIBLE NPSECT=%d IN SUPERBLOCK",
186 sblock.fs_npsect);
187 sblock.fs_npsect = sblock.fs_nsect;
188 if (preen)
189 printf(" (FIXED)\n");
190 if (preen || reply("SET TO DEFAULT") == 1) {
191 sbdirty();
192 dirty(&asblk);
193 }
194 }
195 if (cvtflag) {
196 if (sblock.fs_postblformat == FS_42POSTBLFMT) {
197 /*
198 * Requested to convert from old format to new format
199 */
200 if (preen)
201 pwarn("CONVERTING TO NEW FILE SYSTEM FORMAT\n");
202 else if (!reply("CONVERT TO NEW FILE SYSTEM FORMAT"))
203 return(0);
204 sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
205 sblock.fs_nrpos = 8;
206 sblock.fs_postbloff =
207 (char *)(&sblock.fs_opostbl[0][0]) -
208 (char *)(&sblock.fs_link);
209 sblock.fs_rotbloff = &sblock.fs_space[0] -
210 (u_char *)(&sblock.fs_link);
211 sblock.fs_cgsize =
212 fragroundup(&sblock, CGSIZE(&sblock));
213 /*
214 * Planning now for future expansion.
215 */
216# if (BYTE_ORDER == BIG_ENDIAN)
217 sblock.fs_qbmask.val[0] = 0;
218 sblock.fs_qbmask.val[1] = ~sblock.fs_bmask;
219 sblock.fs_qfmask.val[0] = 0;
220 sblock.fs_qfmask.val[1] = ~sblock.fs_fmask;
221# endif /* BIG_ENDIAN */
222# if (BYTE_ORDER == LITTLE_ENDIAN)
223 sblock.fs_qbmask.val[0] = ~sblock.fs_bmask;
224 sblock.fs_qbmask.val[1] = 0;
225 sblock.fs_qfmask.val[0] = ~sblock.fs_fmask;
226 sblock.fs_qfmask.val[1] = 0;
227# endif /* LITTLE_ENDIAN */
228 sbdirty();
229 dirty(&asblk);
230 } else if (sblock.fs_postblformat == FS_DYNAMICPOSTBLFMT) {
231 /*
232 * Requested to convert from new format to old format
233 */
234 if (sblock.fs_nrpos != 8 || sblock.fs_ipg > 2048 ||
235 sblock.fs_cpg > 32 || sblock.fs_cpc > 16) {
236 printf(
237 "PARAMETERS OF CURRENT FILE SYSTEM DO NOT\n\t");
238 errexit(
239 "ALLOW CONVERSION TO OLD FILE SYSTEM FORMAT\n");
240 }
241 if (preen)
242 pwarn("CONVERTING TO OLD FILE SYSTEM FORMAT\n");
243 else if (!reply("CONVERT TO OLD FILE SYSTEM FORMAT"))
244 return(0);
245 sblock.fs_postblformat = FS_42POSTBLFMT;
246 sblock.fs_cgsize = fragroundup(&sblock,
247 sizeof(struct ocg) + howmany(sblock.fs_fpg, NBBY));
248 sbdirty();
249 dirty(&asblk);
250 } else {
251 errexit("UNKNOWN FILE SYSTEM FORMAT\n");
252 }
253 }
254 if (asblk.b_dirty) {
255 bcopy((char *)&sblock, (char *)&altsblock,
256 (size_t)sblock.fs_sbsize);
257 flush(fswritefd, &asblk);
258 }
259 /*
260 * read in the summary info.
261 */
262 asked = 0;
263 for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
264 size = sblock.fs_cssize - i < sblock.fs_bsize ?
265 sblock.fs_cssize - i : sblock.fs_bsize;
266 sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
267 if (bread(fsreadfd, (char *)sblock.fs_csp[j],
268 fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
269 size) != 0 && !asked) {
270 pfatal("BAD SUMMARY INFORMATION");
271 if (reply("CONTINUE") == 0)
272 errexit("");
273 asked++;
274 }
275 }
276 /*
277 * allocate and initialize the necessary maps
278 */
279 bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(short));
280 blockmap = calloc((unsigned)bmapsize, sizeof (char));
281 if (blockmap == NULL) {
282 printf("cannot alloc %u bytes for blockmap\n",
283 (unsigned)bmapsize);
284 goto badsb;
285 }
286 statemap = calloc((unsigned)(maxino + 1), sizeof(char));
287 if (statemap == NULL) {
288 printf("cannot alloc %u bytes for statemap\n",
289 (unsigned)(maxino + 1));
290 goto badsb;
291 }
292 lncntp = (short *)calloc((unsigned)(maxino + 1), sizeof(short));
293 if (lncntp == NULL) {
294 printf("cannot alloc %u bytes for lncntp\n",
295 (unsigned)(maxino + 1) * sizeof(short));
296 goto badsb;
297 }
298 numdirs = sblock.fs_cstotal.cs_ndir;
299 inplast = 0;
300 listmax = numdirs + 10;
301 inpsort = (struct inoinfo **)calloc((unsigned)listmax,
302 sizeof(struct inoinfo *));
303 inphead = (struct inoinfo **)calloc((unsigned)numdirs,
304 sizeof(struct inoinfo *));
305 if (inpsort == NULL || inphead == NULL) {
306 printf("cannot alloc %u bytes for inphead\n",
307 (unsigned)numdirs * sizeof(struct inoinfo *));
308 goto badsb;
309 }
310 bufinit();
311 return (1);
312
313badsb:
314 ckfini();
315 return (0);
316}
317
318/*
319 * Read in the super block and its summary info.
320 */
321readsb(listerr)
322 int listerr;
323{
324 daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
325
326 if (bread(fsreadfd, (char *)&sblock, super, (long)SBSIZE) != 0)
327 return (0);
328 sblk.b_bno = super;
329 sblk.b_size = SBSIZE;
330 /*
331 * run a few consistency checks of the super block
332 */
333 if (sblock.fs_magic != FS_MAGIC)
334 { badsb(listerr, "MAGIC NUMBER WRONG"); return (0); }
335 if (sblock.fs_ncg < 1)
336 { badsb(listerr, "NCG OUT OF RANGE"); return (0); }
337 if (sblock.fs_cpg < 1)
338 { badsb(listerr, "CPG OUT OF RANGE"); return (0); }
339 if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
340 (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
341 { badsb(listerr, "NCYL LESS THAN NCG*CPG"); return (0); }
342 if (sblock.fs_sbsize > SBSIZE)
343 { badsb(listerr, "SIZE PREPOSTEROUSLY LARGE"); return (0); }
344 /*
345 * Compute block size that the filesystem is based on,
346 * according to fsbtodb, and adjust superblock block number
347 * so we can tell if this is an alternate later.
348 */
349 super *= dev_bsize;
350 dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
351 sblk.b_bno = super / dev_bsize;
352 /*
353 * Set all possible fields that could differ, then do check
354 * of whole super block against an alternate super block.
355 * When an alternate super-block is specified this check is skipped.
356 */
357 getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
358 if (asblk.b_errs)
359 return (0);
360 if (bflag) {
361 havesb = 1;
362 return (1);
363 }
364 altsblock.fs_link = sblock.fs_link;
365 altsblock.fs_rlink = sblock.fs_rlink;
366 altsblock.fs_time = sblock.fs_time;
367 altsblock.fs_cstotal = sblock.fs_cstotal;
368 altsblock.fs_cgrotor = sblock.fs_cgrotor;
369 altsblock.fs_fmod = sblock.fs_fmod;
370 altsblock.fs_clean = sblock.fs_clean;
371 altsblock.fs_ronly = sblock.fs_ronly;
372 altsblock.fs_flags = sblock.fs_flags;
373 altsblock.fs_maxcontig = sblock.fs_maxcontig;
374 altsblock.fs_minfree = sblock.fs_minfree;
375 altsblock.fs_optim = sblock.fs_optim;
376 altsblock.fs_rotdelay = sblock.fs_rotdelay;
377 altsblock.fs_maxbpg = sblock.fs_maxbpg;
378 bcopy((char *)sblock.fs_csp, (char *)altsblock.fs_csp,
379 sizeof sblock.fs_csp);
380 bcopy((char *)sblock.fs_fsmnt, (char *)altsblock.fs_fsmnt,
381 sizeof sblock.fs_fsmnt);
382 bcopy((char *)sblock.fs_sparecon, (char *)altsblock.fs_sparecon,
383 sizeof sblock.fs_sparecon);
384 /*
385 * The following should not have to be copied.
386 */
387 altsblock.fs_fsbtodb = sblock.fs_fsbtodb;
388 altsblock.fs_interleave = sblock.fs_interleave;
389 altsblock.fs_npsect = sblock.fs_npsect;
390 altsblock.fs_nrpos = sblock.fs_nrpos;
391 if (bcmp((char *)&sblock, (char *)&altsblock, (int)sblock.fs_sbsize)) {
392 badsb(listerr,
393 "VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
394 return (0);
395 }
396 havesb = 1;
397 return (1);
398}
399
400badsb(listerr, s)
401 int listerr;
402 char *s;
403{
404
405 if (!listerr)
406 return;
407 if (preen)
408 printf("%s: ", devname);
409 pfatal("BAD SUPER BLOCK: %s\n", s);
410}
411
412/*
413 * Calculate a prototype superblock based on information in the disk label.
414 * When done the cgsblock macro can be calculated and the fs_ncg field
415 * can be used. Do NOT attempt to use other macros without verifying that
416 * their needed information is available!
417 */
418calcsb(dev, devfd, fs)
419 char *dev;
420 int devfd;
421 register struct fs *fs;
422{
423 register struct disklabel *lp;
424 register struct partition *pp;
425 register char *cp;
426 int i;
427
428 cp = index(dev, '\0') - 1;
429 if (cp == (char *)-1 || (*cp < 'a' || *cp > 'h') && !isdigit(*cp)) {
430 pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
431 return (0);
432 }
433 lp = getdisklabel(dev, devfd);
434 if (isdigit(*cp))
435 pp = &lp->d_partitions[0];
436 else
437 pp = &lp->d_partitions[*cp - 'a'];
438 if (pp->p_fstype != FS_BSDFFS) {
439 pfatal("%s: NOT LABELED AS A BSD FILE SYSTEM (%s)\n",
440 dev, pp->p_fstype < FSMAXTYPES ?
441 fstypenames[pp->p_fstype] : "unknown");
442 return (0);
443 }
444 bzero((char *)fs, sizeof(struct fs));
445 fs->fs_fsize = pp->p_fsize;
446 fs->fs_frag = pp->p_frag;
447 fs->fs_cpg = pp->p_cpg;
448 fs->fs_size = pp->p_size;
449 fs->fs_ntrak = lp->d_ntracks;
450 fs->fs_nsect = lp->d_nsectors;
451 fs->fs_spc = lp->d_secpercyl;
452 fs->fs_nspf = fs->fs_fsize / lp->d_secsize;
453 fs->fs_sblkno = roundup(
454 howmany(lp->d_bbsize + lp->d_sbsize, fs->fs_fsize),
455 fs->fs_frag);
456 fs->fs_cgmask = 0xffffffff;
457 for (i = fs->fs_ntrak; i > 1; i >>= 1)
458 fs->fs_cgmask <<= 1;
459 if (!POWEROF2(fs->fs_ntrak))
460 fs->fs_cgmask <<= 1;
461 fs->fs_cgoffset = roundup(
462 howmany(fs->fs_nsect, NSPF(fs)), fs->fs_frag);
463 fs->fs_fpg = (fs->fs_cpg * fs->fs_spc) / NSPF(fs);
464 fs->fs_ncg = howmany(fs->fs_size / fs->fs_spc, fs->fs_cpg);
465 for (fs->fs_fsbtodb = 0, i = NSPF(fs); i > 1; i >>= 1)
466 fs->fs_fsbtodb++;
467 dev_bsize = lp->d_secsize;
468 return (1);
469}
470
471struct disklabel *
472getdisklabel(s, fd)
473 char *s;
474 int fd;
475{
476 static struct disklabel lab;
477
478 if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
479 if (s == NULL)
480 return ((struct disklabel *)NULL);
481 pwarn("ioctl (GCINFO): %s\n", strerror(errno));
482 errexit("%s: can't read disk label\n", s);
483 }
484 return (&lab);
485}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.