Deleted Added
sdiff udiff text old ( 96483 ) new ( 98542 )
full compact
setup.c (96483) setup.c (98542)
1/*
2 * Copyright (c) 1980, 1986, 1993
3 * The Regents of the University of California. 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

--- 22 unchanged lines hidden (view full) ---

31 * SUCH DAMAGE.
32 */
33
34#ifndef lint
35#if 0
36static const char sccsid[] = "@(#)setup.c 8.10 (Berkeley) 5/9/95";
37#endif
38static const char rcsid[] =
1/*
2 * Copyright (c) 1980, 1986, 1993
3 * The Regents of the University of California. 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

--- 22 unchanged lines hidden (view full) ---

31 * SUCH DAMAGE.
32 */
33
34#ifndef lint
35#if 0
36static const char sccsid[] = "@(#)setup.c 8.10 (Berkeley) 5/9/95";
37#endif
38static const char rcsid[] =
39 "$FreeBSD: head/sbin/fsck_ffs/setup.c 96483 2002-05-12 23:44:15Z phk $";
39 "$FreeBSD: head/sbin/fsck_ffs/setup.c 98542 2002-06-21 06:18:05Z mckusick $";
40#endif /* not lint */
41
42#define DKTYPENAMES
43#include <sys/param.h>
44#include <sys/stat.h>
45#include <sys/disklabel.h>
46#include <sys/file.h>
47#include <sys/sysctl.h>

--- 157 unchanged lines hidden (view full) ---

205 if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
206 pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
207 sblock.fs_minfree);
208 if (reply("SET TO DEFAULT") == 1) {
209 sblock.fs_minfree = 10;
210 sbdirty();
211 }
212 }
40#endif /* not lint */
41
42#define DKTYPENAMES
43#include <sys/param.h>
44#include <sys/stat.h>
45#include <sys/disklabel.h>
46#include <sys/file.h>
47#include <sys/sysctl.h>

--- 157 unchanged lines hidden (view full) ---

205 if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
206 pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
207 sblock.fs_minfree);
208 if (reply("SET TO DEFAULT") == 1) {
209 sblock.fs_minfree = 10;
210 sbdirty();
211 }
212 }
213 if (sblock.fs_inodefmt < FS_44INODEFMT) {
213 if (sblock.fs_magic == FS_UFS1_MAGIC &&
214 sblock.fs_old_inodefmt < FS_44INODEFMT) {
214 pwarn("Format of filesystem is too old.\n");
215 pwarn("Must update to modern format using a version of fsck\n");
216 pfatal("from before 2002 with the command ``fsck -c 2''\n");
217 exit(EEXIT);
218 }
219 if (asblk.b_dirty && !bflag) {
220 memmove(&altsblock, &sblock, (size_t)sblock.fs_sbsize);
221 flush(fswritefd, &asblk);

--- 59 unchanged lines hidden (view full) ---

281 return (1);
282
283badsb:
284 ckfini(0);
285 return (0);
286}
287
288/*
215 pwarn("Format of filesystem is too old.\n");
216 pwarn("Must update to modern format using a version of fsck\n");
217 pfatal("from before 2002 with the command ``fsck -c 2''\n");
218 exit(EEXIT);
219 }
220 if (asblk.b_dirty && !bflag) {
221 memmove(&altsblock, &sblock, (size_t)sblock.fs_sbsize);
222 flush(fswritefd, &asblk);

--- 59 unchanged lines hidden (view full) ---

282 return (1);
283
284badsb:
285 ckfini(0);
286 return (0);
287}
288
289/*
290 * Possible superblock locations ordered from most to least likely.
291 */
292static int sblock_try[] = SBLOCKSEARCH;
293
294/*
289 * Read in the super block and its summary info.
290 */
291int
292readsb(int listerr)
293{
295 * Read in the super block and its summary info.
296 */
297int
298readsb(int listerr)
299{
294 ufs_daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
300 ufs2_daddr_t super;
301 int i;
295
302
296 if (bread(fsreadfd, (char *)&sblock, super, (long)SBSIZE) != 0)
297 return (0);
298 sblk.b_bno = super;
299 sblk.b_size = SBSIZE;
303 if (bflag) {
304 super = bflag;
305 if ((bread(fsreadfd, (char *)&sblock, super, (long)SBLOCKSIZE)))
306 return (0);
307 } else {
308 for (i = 0; sblock_try[i] != -1; i++) {
309 super = sblock_try[i] / dev_bsize;
310 if ((bread(fsreadfd, (char *)&sblock, super,
311 (long)SBLOCKSIZE)))
312 return (0);
313 if ((sblock.fs_magic == FS_UFS1_MAGIC ||
314 (sblock.fs_magic == FS_UFS2_MAGIC &&
315 sblock.fs_sblockloc ==
316 numfrags(&sblock, sblock_try[i]))) &&
317 sblock.fs_ncg >= 1 &&
318 sblock.fs_bsize >= SBLOCKSIZE &&
319 sblock.fs_bsize >= sizeof(struct fs))
320 break;
321 }
322 if (sblock_try[i] == -1) {
323 fprintf(stderr, "Cannot find filesystem superblock\n");
324 return (0);
325 }
326 }
300 /*
327 /*
301 * run a few consistency checks of the super block
302 */
303 if (sblock.fs_magic != FS_MAGIC)
304 { badsb(listerr, "MAGIC NUMBER WRONG"); return (0); }
305 if (sblock.fs_ncg < 1)
306 { badsb(listerr, "NCG OUT OF RANGE"); return (0); }
307 if (sblock.fs_cpg < 1)
308 { badsb(listerr, "CPG OUT OF RANGE"); return (0); }
309 if (sblock.fs_sbsize > SBSIZE)
310 { badsb(listerr, "SIZE PREPOSTEROUSLY LARGE"); return (0); }
311 /*
312 * Compute block size that the filesystem is based on,
313 * according to fsbtodb, and adjust superblock block number
314 * so we can tell if this is an alternate later.
315 */
316 super *= dev_bsize;
317 dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
318 sblk.b_bno = super / dev_bsize;
328 * Compute block size that the filesystem is based on,
329 * according to fsbtodb, and adjust superblock block number
330 * so we can tell if this is an alternate later.
331 */
332 super *= dev_bsize;
333 dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
334 sblk.b_bno = super / dev_bsize;
335 sblk.b_size = SBLOCKSIZE;
319 if (bflag) {
320 havesb = 1;
321 return (1);
322 }
323 /*
324 * Compare all fields that should not differ in alternate super block.
325 * When an alternate super-block is specified this check is skipped.
326 */
327 getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
328 if (asblk.b_errs)
329 return (0);
330 if (altsblock.fs_sblkno != sblock.fs_sblkno ||
331 altsblock.fs_cblkno != sblock.fs_cblkno ||
332 altsblock.fs_iblkno != sblock.fs_iblkno ||
333 altsblock.fs_dblkno != sblock.fs_dblkno ||
336 if (bflag) {
337 havesb = 1;
338 return (1);
339 }
340 /*
341 * Compare all fields that should not differ in alternate super block.
342 * When an alternate super-block is specified this check is skipped.
343 */
344 getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
345 if (asblk.b_errs)
346 return (0);
347 if (altsblock.fs_sblkno != sblock.fs_sblkno ||
348 altsblock.fs_cblkno != sblock.fs_cblkno ||
349 altsblock.fs_iblkno != sblock.fs_iblkno ||
350 altsblock.fs_dblkno != sblock.fs_dblkno ||
334 altsblock.fs_cgoffset != sblock.fs_cgoffset ||
335 altsblock.fs_cgmask != sblock.fs_cgmask ||
336 altsblock.fs_ncg != sblock.fs_ncg ||
337 altsblock.fs_bsize != sblock.fs_bsize ||
338 altsblock.fs_fsize != sblock.fs_fsize ||
339 altsblock.fs_frag != sblock.fs_frag ||
340 altsblock.fs_bmask != sblock.fs_bmask ||
341 altsblock.fs_fmask != sblock.fs_fmask ||
342 altsblock.fs_bshift != sblock.fs_bshift ||
343 altsblock.fs_fshift != sblock.fs_fshift ||
344 altsblock.fs_fragshift != sblock.fs_fragshift ||
345 altsblock.fs_fsbtodb != sblock.fs_fsbtodb ||
346 altsblock.fs_sbsize != sblock.fs_sbsize ||
347 altsblock.fs_nindir != sblock.fs_nindir ||
348 altsblock.fs_inopb != sblock.fs_inopb ||
349 altsblock.fs_cssize != sblock.fs_cssize ||
351 altsblock.fs_ncg != sblock.fs_ncg ||
352 altsblock.fs_bsize != sblock.fs_bsize ||
353 altsblock.fs_fsize != sblock.fs_fsize ||
354 altsblock.fs_frag != sblock.fs_frag ||
355 altsblock.fs_bmask != sblock.fs_bmask ||
356 altsblock.fs_fmask != sblock.fs_fmask ||
357 altsblock.fs_bshift != sblock.fs_bshift ||
358 altsblock.fs_fshift != sblock.fs_fshift ||
359 altsblock.fs_fragshift != sblock.fs_fragshift ||
360 altsblock.fs_fsbtodb != sblock.fs_fsbtodb ||
361 altsblock.fs_sbsize != sblock.fs_sbsize ||
362 altsblock.fs_nindir != sblock.fs_nindir ||
363 altsblock.fs_inopb != sblock.fs_inopb ||
364 altsblock.fs_cssize != sblock.fs_cssize ||
350 altsblock.fs_cpg != sblock.fs_cpg ||
351 altsblock.fs_ipg != sblock.fs_ipg ||
352 altsblock.fs_fpg != sblock.fs_fpg ||
353 altsblock.fs_magic != sblock.fs_magic) {
354 badsb(listerr,
355 "VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
356 return (0);
357 }
365 altsblock.fs_ipg != sblock.fs_ipg ||
366 altsblock.fs_fpg != sblock.fs_fpg ||
367 altsblock.fs_magic != sblock.fs_magic) {
368 badsb(listerr,
369 "VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
370 return (0);
371 }
372 /*
373 * If not yet done, update UFS1 superblock with new wider fields.
374 */
375 if (sblock.fs_magic == FS_UFS1_MAGIC &&
376 sblock.fs_maxbsize != sblock.fs_bsize) {
377 sblock.fs_maxbsize = sblock.fs_bsize;
378 sblock.fs_time = sblock.fs_old_time;
379 sblock.fs_size = sblock.fs_old_size;
380 sblock.fs_dsize = sblock.fs_old_dsize;
381 sblock.fs_csaddr = sblock.fs_old_csaddr;
382 sblock.fs_cstotal.cs_ndir = sblock.fs_old_cstotal.cs_ndir;
383 sblock.fs_cstotal.cs_nbfree = sblock.fs_old_cstotal.cs_nbfree;
384 sblock.fs_cstotal.cs_nifree = sblock.fs_old_cstotal.cs_nifree;
385 sblock.fs_cstotal.cs_nffree = sblock.fs_old_cstotal.cs_nffree;
386 }
358 havesb = 1;
359 return (1);
360}
361
362static void
363badsb(int listerr, char *s)
364{
365

--- 9 unchanged lines hidden (view full) ---

375{
376 struct disklabel *lp;
377
378 fswritefd = -1;
379 fsmodified = 0;
380 lfdir = 0;
381 initbarea(&sblk);
382 initbarea(&asblk);
387 havesb = 1;
388 return (1);
389}
390
391static void
392badsb(int listerr, char *s)
393{
394

--- 9 unchanged lines hidden (view full) ---

404{
405 struct disklabel *lp;
406
407 fswritefd = -1;
408 fsmodified = 0;
409 lfdir = 0;
410 initbarea(&sblk);
411 initbarea(&asblk);
383 sblk.b_un.b_buf = malloc(SBSIZE);
384 asblk.b_un.b_buf = malloc(SBSIZE);
412 sblk.b_un.b_buf = malloc(SBLOCKSIZE);
413 asblk.b_un.b_buf = malloc(SBLOCKSIZE);
385 if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
386 errx(EEXIT, "cannot allocate space for superblock");
387 if ((lp = getdisklabel(NULL, fsreadfd)))
388 dev_bsize = secsize = lp->d_secsize;
389 else
390 dev_bsize = secsize = DEV_BSIZE;
391}
392

--- 4 unchanged lines hidden (view full) ---

397 * their needed information is available!
398 */
399static int
400calcsb(char *dev, int devfd, struct fs *fs)
401{
402 struct disklabel *lp;
403 struct partition *pp;
404 char *cp;
414 if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
415 errx(EEXIT, "cannot allocate space for superblock");
416 if ((lp = getdisklabel(NULL, fsreadfd)))
417 dev_bsize = secsize = lp->d_secsize;
418 else
419 dev_bsize = secsize = DEV_BSIZE;
420}
421

--- 4 unchanged lines hidden (view full) ---

426 * their needed information is available!
427 */
428static int
429calcsb(char *dev, int devfd, struct fs *fs)
430{
431 struct disklabel *lp;
432 struct partition *pp;
433 char *cp;
405 int i;
434 int i, nspf;
406
407 cp = strchr(dev, '\0') - 1;
408 if (cp == (char *)-1 || ((*cp < 'a' || *cp > 'h') && !isdigit(*cp))) {
409 pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
410 return (0);
411 }
412 lp = getdisklabel(dev, devfd);
413 if (isdigit(*cp))

--- 11 unchanged lines hidden (view full) ---

425 pfatal("%s: %s: type %s fsize %d, frag %d, cpg %d, size %d\n",
426 dev, "INCOMPLETE LABEL", fstypenames[pp->p_fstype],
427 pp->p_fsize, pp->p_frag, pp->p_cpg, pp->p_size);
428 return (0);
429 }
430 memset(fs, 0, sizeof(struct fs));
431 fs->fs_fsize = pp->p_fsize;
432 fs->fs_frag = pp->p_frag;
435
436 cp = strchr(dev, '\0') - 1;
437 if (cp == (char *)-1 || ((*cp < 'a' || *cp > 'h') && !isdigit(*cp))) {
438 pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
439 return (0);
440 }
441 lp = getdisklabel(dev, devfd);
442 if (isdigit(*cp))

--- 11 unchanged lines hidden (view full) ---

454 pfatal("%s: %s: type %s fsize %d, frag %d, cpg %d, size %d\n",
455 dev, "INCOMPLETE LABEL", fstypenames[pp->p_fstype],
456 pp->p_fsize, pp->p_frag, pp->p_cpg, pp->p_size);
457 return (0);
458 }
459 memset(fs, 0, sizeof(struct fs));
460 fs->fs_fsize = pp->p_fsize;
461 fs->fs_frag = pp->p_frag;
433 fs->fs_cpg = pp->p_cpg;
434 fs->fs_size = pp->p_size;
462 fs->fs_size = pp->p_size;
435 fs->fs_ntrak = lp->d_ntracks;
436 fs->fs_nsect = lp->d_nsectors;
437 fs->fs_spc = lp->d_secpercyl;
438 fs->fs_nspf = fs->fs_fsize / lp->d_secsize;
439 fs->fs_cgmask = 0xffffffff;
440 for (i = fs->fs_ntrak; i > 1; i >>= 1)
441 fs->fs_cgmask <<= 1;
442 if (!POWEROF2(fs->fs_ntrak))
443 fs->fs_cgmask <<= 1;
444 fs->fs_cgoffset = roundup(
445 howmany(fs->fs_nsect, NSPF(fs)), fs->fs_frag);
446 fs->fs_fpg = (fs->fs_cpg * fs->fs_spc) / NSPF(fs);
447 fs->fs_ncg = howmany(fs->fs_size / fs->fs_spc, fs->fs_cpg);
448 for (fs->fs_fsbtodb = 0, i = NSPF(fs); i > 1; i >>= 1)
463 fs->fs_sblkno = roundup(
464 howmany(lp->d_bbsize + lp->d_sbsize, fs->fs_fsize),
465 fs->fs_frag);
466 nspf = fs->fs_fsize / lp->d_secsize;
467 for (fs->fs_fsbtodb = 0, i = nspf; i > 1; i >>= 1)
449 fs->fs_fsbtodb++;
450 dev_bsize = lp->d_secsize;
468 fs->fs_fsbtodb++;
469 dev_bsize = lp->d_secsize;
470 if (fs->fs_magic == FS_UFS2_MAGIC) {
471 fs->fs_fpg = pp->p_cpg;
472 fs->fs_ncg = howmany(fs->fs_size, fs->fs_fpg);
473 } else /* if (fs->fs_magic == FS_UFS1_MAGIC) */ {
474 fs->fs_old_cpg = pp->p_cpg;
475 fs->fs_old_cgmask = 0xffffffff;
476 for (i = lp->d_ntracks; i > 1; i >>= 1)
477 fs->fs_old_cgmask <<= 1;
478 if (!POWEROF2(lp->d_ntracks))
479 fs->fs_old_cgmask <<= 1;
480 fs->fs_old_cgoffset = roundup(howmany(lp->d_nsectors, nspf),
481 fs->fs_frag);
482 fs->fs_fpg = (fs->fs_old_cpg * lp->d_secpercyl) / nspf;
483 fs->fs_ncg = howmany(fs->fs_size / lp->d_secpercyl,
484 fs->fs_old_cpg);
485 }
451 return (1);
452}
453
454static struct disklabel *
455getdisklabel(char *s, int fd)
456{
457 static struct disklabel lab;
458
459 if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
460 if (s == NULL)
461 return ((struct disklabel *)NULL);
462 pwarn("ioctl (GCINFO): %s\n", strerror(errno));
463 errx(EEXIT, "%s: can't read disk label", s);
464 }
465 return (&lab);
466}
486 return (1);
487}
488
489static struct disklabel *
490getdisklabel(char *s, int fd)
491{
492 static struct disklabel lab;
493
494 if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
495 if (s == NULL)
496 return ((struct disklabel *)NULL);
497 pwarn("ioctl (GCINFO): %s\n", strerror(errno));
498 errx(EEXIT, "%s: can't read disk label", s);
499 }
500 return (&lab);
501}