122054Sdist /*
261492Sbostic * Copyright (c) 1980, 1986, 1993
361492Sbostic * The Regents of the University of California. All rights reserved.
439976Smckusick *
542702Sbostic * %sccs.include.redist.c%
622054Sdist */
722054Sdist
816268Smckusick #ifndef lint
9*69319Smckusick static char sccsid[] = "@(#)setup.c 8.10 (Berkeley) 05/09/95";
1039976Smckusick #endif /* not lint */
1116268Smckusick
1230399Smckusick #define DKTYPENAMES
1316268Smckusick #include <sys/param.h>
1453703Smckusick #include <sys/time.h>
1516268Smckusick #include <sys/stat.h>
1630399Smckusick #include <sys/ioctl.h>
1730399Smckusick #include <sys/disklabel.h>
1830399Smckusick #include <sys/file.h>
1968908Smckusick
2068908Smckusick #include <ufs/ufs/dinode.h>
2168908Smckusick #include <ufs/ffs/fs.h>
2268908Smckusick
2368908Smckusick #include <ctype.h>
2468908Smckusick #include <err.h>
2544934Smckusick #include <errno.h>
2644934Smckusick #include <string.h>
2768908Smckusick
2816268Smckusick #include "fsck.h"
2916268Smckusick
3039973Smckusick struct bufarea asblk;
3134225Smckusick #define altsblock (*asblk.b_un.b_fs)
3230399Smckusick #define POWEROF2(num) (((num) & ((num) - 1)) == 0)
3330399Smckusick
3468908Smckusick static void badsb __P((int listerr, char *s));
3568908Smckusick static int calcsb __P((char *dev, int devfd, struct fs *fs));
3668908Smckusick static struct disklabel *getdisklabel __P((char *s, int fd));
3768908Smckusick static int readsb __P((int listerr));
3816268Smckusick
39*69319Smckusick /*
40*69319Smckusick * Read in a superblock finding an alternate if necessary.
41*69319Smckusick * Return 1 if successful, 0 if unsuccessful, -1 if filesystem
42*69319Smckusick * is already clean (preen mode only).
43*69319Smckusick */
4468908Smckusick int
setup(dev)4516268Smckusick setup(dev)
4616268Smckusick char *dev;
4716268Smckusick {
4839973Smckusick long cg, size, asked, i, j;
49*69319Smckusick long skipclean, bmapsize;
5038376Smckusick struct disklabel *lp;
5154207Smckusick off_t sizepb;
5216268Smckusick struct stat statb;
5330399Smckusick struct fs proto;
5416268Smckusick
5530859Skarels havesb = 0;
5656809Smckusick fswritefd = -1;
57*69319Smckusick skipclean = preen;
5816268Smckusick if (stat(dev, &statb) < 0) {
5944934Smckusick printf("Can't stat %s: %s\n", dev, strerror(errno));
6016268Smckusick return (0);
6116268Smckusick }
6241418Smckusick if ((statb.st_mode & S_IFMT) != S_IFCHR) {
6341418Smckusick pfatal("%s is not a character device", dev);
6441418Smckusick if (reply("CONTINUE") == 0)
6541418Smckusick return (0);
6641418Smckusick }
6739973Smckusick if ((fsreadfd = open(dev, O_RDONLY)) < 0) {
6844934Smckusick printf("Can't open %s: %s\n", dev, strerror(errno));
6916268Smckusick return (0);
7016268Smckusick }
7116268Smckusick if (preen == 0)
7216268Smckusick printf("** %s", dev);
7339973Smckusick if (nflag || (fswritefd = open(dev, O_WRONLY)) < 0) {
7439973Smckusick fswritefd = -1;
7516268Smckusick if (preen)
7616268Smckusick pfatal("NO WRITE ACCESS");
7716268Smckusick printf(" (NO WRITE)");
7816268Smckusick }
7916268Smckusick if (preen == 0)
8016268Smckusick printf("\n");
8139973Smckusick fsmodified = 0;
8216268Smckusick lfdir = 0;
8316268Smckusick initbarea(&sblk);
8434140Smckusick initbarea(&asblk);
8538376Smckusick sblk.b_un.b_buf = malloc(SBSIZE);
8638376Smckusick asblk.b_un.b_buf = malloc(SBSIZE);
8738376Smckusick if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
8868908Smckusick errx(EEXIT, "cannot allocate space for superblock");
8968908Smckusick if (lp = getdisklabel(NULL, fsreadfd))
9030859Skarels dev_bsize = secsize = lp->d_secsize;
9134140Smckusick else
9234140Smckusick dev_bsize = secsize = DEV_BSIZE;
9316268Smckusick /*
9430399Smckusick * Read in the superblock, looking for alternates if necessary
9516268Smckusick */
9630399Smckusick if (readsb(1) == 0) {
97*69319Smckusick skipclean = 0;
9839973Smckusick if (bflag || preen || calcsb(dev, fsreadfd, &proto) == 0)
9930399Smckusick return(0);
10030399Smckusick if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
10130399Smckusick return (0);
10230399Smckusick for (cg = 0; cg < proto.fs_ncg; cg++) {
10330399Smckusick bflag = fsbtodb(&proto, cgsblock(&proto, cg));
10430399Smckusick if (readsb(0) != 0)
10530399Smckusick break;
10630399Smckusick }
10730399Smckusick if (cg >= proto.fs_ncg) {
10830399Smckusick printf("%s %s\n%s %s\n%s %s\n",
10930399Smckusick "SEARCH FOR ALTERNATE SUPER-BLOCK",
11030399Smckusick "FAILED. YOU MUST USE THE",
11130399Smckusick "-b OPTION TO FSCK TO SPECIFY THE",
11230399Smckusick "LOCATION OF AN ALTERNATE",
11330399Smckusick "SUPER-BLOCK TO SUPPLY NEEDED",
11430399Smckusick "INFORMATION; SEE fsck(8).");
11530399Smckusick return(0);
11630399Smckusick }
11730399Smckusick pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
11830399Smckusick }
119*69319Smckusick if (skipclean && sblock.fs_clean) {
120*69319Smckusick pwarn("FILESYSTEM CLEAN; SKIPPING CHECKS\n");
121*69319Smckusick return (-1);
122*69319Smckusick }
12339973Smckusick maxfsblock = sblock.fs_size;
12439973Smckusick maxino = sblock.fs_ncg * sblock.fs_ipg;
12516268Smckusick /*
12628213Smckusick * Check and potentially fix certain fields in the super block.
12728213Smckusick */
12828213Smckusick if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
12928213Smckusick pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
13028213Smckusick if (reply("SET TO DEFAULT") == 1) {
13128213Smckusick sblock.fs_optim = FS_OPTTIME;
13228213Smckusick sbdirty();
13328213Smckusick }
13428213Smckusick }
13528213Smckusick if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
13628213Smckusick pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
13728213Smckusick sblock.fs_minfree);
13828213Smckusick if (reply("SET TO DEFAULT") == 1) {
13928213Smckusick sblock.fs_minfree = 10;
14028213Smckusick sbdirty();
14128213Smckusick }
14228213Smckusick }
14344941Smckusick if (sblock.fs_interleave < 1 ||
14444941Smckusick sblock.fs_interleave > sblock.fs_nsect) {
14530597Smckusick pwarn("IMPOSSIBLE INTERLEAVE=%d IN SUPERBLOCK",
14630400Smckusick sblock.fs_interleave);
14730586Smckusick sblock.fs_interleave = 1;
14830597Smckusick if (preen)
14930597Smckusick printf(" (FIXED)\n");
15034140Smckusick if (preen || reply("SET TO DEFAULT") == 1) {
15130400Smckusick sbdirty();
15234140Smckusick dirty(&asblk);
15334140Smckusick }
15430400Smckusick }
15544941Smckusick if (sblock.fs_npsect < sblock.fs_nsect ||
15644941Smckusick sblock.fs_npsect > sblock.fs_nsect*2) {
15730597Smckusick pwarn("IMPOSSIBLE NPSECT=%d IN SUPERBLOCK",
15830400Smckusick sblock.fs_npsect);
15930586Smckusick sblock.fs_npsect = sblock.fs_nsect;
16030597Smckusick if (preen)
16130597Smckusick printf(" (FIXED)\n");
16234140Smckusick if (preen || reply("SET TO DEFAULT") == 1) {
16330400Smckusick sbdirty();
16434140Smckusick dirty(&asblk);
16534140Smckusick }
16630400Smckusick }
16754504Smckusick if (sblock.fs_inodefmt >= FS_44INODEFMT) {
16855290Smckusick newinofmt = 1;
16954504Smckusick } else {
17054504Smckusick sblock.fs_qbmask = ~sblock.fs_bmask;
17154504Smckusick sblock.fs_qfmask = ~sblock.fs_fmask;
17255290Smckusick newinofmt = 0;
17354504Smckusick }
17454504Smckusick /*
17554504Smckusick * Convert to new inode format.
17654504Smckusick */
17754504Smckusick if (cvtlevel >= 2 && sblock.fs_inodefmt < FS_44INODEFMT) {
17854504Smckusick if (preen)
17954504Smckusick pwarn("CONVERTING TO NEW INODE FORMAT\n");
18054504Smckusick else if (!reply("CONVERT TO NEW INODE FORMAT"))
18154504Smckusick return(0);
18254504Smckusick doinglevel2++;
18354504Smckusick sblock.fs_inodefmt = FS_44INODEFMT;
18454207Smckusick sizepb = sblock.fs_bsize;
18554207Smckusick sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
18654207Smckusick for (i = 0; i < NIADDR; i++) {
18754207Smckusick sizepb *= NINDIR(&sblock);
18854207Smckusick sblock.fs_maxfilesize += sizepb;
18954207Smckusick }
19054504Smckusick sblock.fs_maxsymlinklen = MAXSYMLINKLEN;
19154207Smckusick sblock.fs_qbmask = ~sblock.fs_bmask;
19254207Smckusick sblock.fs_qfmask = ~sblock.fs_fmask;
19354504Smckusick sbdirty();
19454504Smckusick dirty(&asblk);
19554207Smckusick }
19654504Smckusick /*
19754504Smckusick * Convert to new cylinder group format.
19854504Smckusick */
19954504Smckusick if (cvtlevel >= 1 && sblock.fs_postblformat == FS_42POSTBLFMT) {
20054504Smckusick if (preen)
20154504Smckusick pwarn("CONVERTING TO NEW CYLINDER GROUP FORMAT\n");
20254504Smckusick else if (!reply("CONVERT TO NEW CYLINDER GROUP FORMAT"))
20354504Smckusick return(0);
20454504Smckusick doinglevel1++;
20554504Smckusick sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
20654504Smckusick sblock.fs_nrpos = 8;
20754504Smckusick sblock.fs_postbloff =
20854504Smckusick (char *)(&sblock.fs_opostbl[0][0]) -
20967669Smckusick (char *)(&sblock.fs_firstfield);
21054504Smckusick sblock.fs_rotbloff = &sblock.fs_space[0] -
21167669Smckusick (u_char *)(&sblock.fs_firstfield);
21254504Smckusick sblock.fs_cgsize =
21354504Smckusick fragroundup(&sblock, CGSIZE(&sblock));
21454504Smckusick sbdirty();
21554504Smckusick dirty(&asblk);
21634140Smckusick }
21768140Smckusick if (asblk.b_dirty && !bflag) {
21868992Sbostic memmove(&altsblock, &sblock, (size_t)sblock.fs_sbsize);
21939973Smckusick flush(fswritefd, &asblk);
22034140Smckusick }
22128213Smckusick /*
22216268Smckusick * read in the summary info.
22316268Smckusick */
22433979Smckusick asked = 0;
22516268Smckusick for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
22616268Smckusick size = sblock.fs_cssize - i < sblock.fs_bsize ?
22716268Smckusick sblock.fs_cssize - i : sblock.fs_bsize;
22816268Smckusick sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
22939973Smckusick if (bread(fsreadfd, (char *)sblock.fs_csp[j],
23016268Smckusick fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
23133979Smckusick size) != 0 && !asked) {
23233979Smckusick pfatal("BAD SUMMARY INFORMATION");
23333979Smckusick if (reply("CONTINUE") == 0)
23468908Smckusick exit(EEXIT);
23533979Smckusick asked++;
23633979Smckusick }
23716268Smckusick }
23816268Smckusick /*
23916268Smckusick * allocate and initialize the necessary maps
24016268Smckusick */
24139973Smckusick bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(short));
24239973Smckusick blockmap = calloc((unsigned)bmapsize, sizeof (char));
24316268Smckusick if (blockmap == NULL) {
24444934Smckusick printf("cannot alloc %u bytes for blockmap\n",
24544934Smckusick (unsigned)bmapsize);
24616268Smckusick goto badsb;
24716268Smckusick }
24839973Smckusick statemap = calloc((unsigned)(maxino + 1), sizeof(char));
24916268Smckusick if (statemap == NULL) {
25044934Smckusick printf("cannot alloc %u bytes for statemap\n",
25144934Smckusick (unsigned)(maxino + 1));
25216268Smckusick goto badsb;
25316268Smckusick }
25454504Smckusick typemap = calloc((unsigned)(maxino + 1), sizeof(char));
25554504Smckusick if (typemap == NULL) {
25654504Smckusick printf("cannot alloc %u bytes for typemap\n",
25754504Smckusick (unsigned)(maxino + 1));
25854504Smckusick goto badsb;
25954504Smckusick }
26039973Smckusick lncntp = (short *)calloc((unsigned)(maxino + 1), sizeof(short));
26116268Smckusick if (lncntp == NULL) {
26244934Smckusick printf("cannot alloc %u bytes for lncntp\n",
26344934Smckusick (unsigned)(maxino + 1) * sizeof(short));
26416268Smckusick goto badsb;
26516268Smckusick }
26640020Smckusick numdirs = sblock.fs_cstotal.cs_ndir;
26740360Smckusick inplast = 0;
26840020Smckusick listmax = numdirs + 10;
26940020Smckusick inpsort = (struct inoinfo **)calloc((unsigned)listmax,
27040020Smckusick sizeof(struct inoinfo *));
27140020Smckusick inphead = (struct inoinfo **)calloc((unsigned)numdirs,
27240020Smckusick sizeof(struct inoinfo *));
27340020Smckusick if (inpsort == NULL || inphead == NULL) {
27444934Smckusick printf("cannot alloc %u bytes for inphead\n",
27544934Smckusick (unsigned)numdirs * sizeof(struct inoinfo *));
27640020Smckusick goto badsb;
27740020Smckusick }
27834225Smckusick bufinit();
27916268Smckusick return (1);
28016268Smckusick
28116268Smckusick badsb:
282*69319Smckusick ckfini(0);
28316268Smckusick return (0);
28430399Smckusick }
28530399Smckusick
28630399Smckusick /*
28730399Smckusick * Read in the super block and its summary info.
28830399Smckusick */
28968908Smckusick static int
readsb(listerr)29030399Smckusick readsb(listerr)
29130399Smckusick int listerr;
29230399Smckusick {
29368548Smckusick ufs_daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
29430399Smckusick
29539973Smckusick if (bread(fsreadfd, (char *)&sblock, super, (long)SBSIZE) != 0)
29630399Smckusick return (0);
29730399Smckusick sblk.b_bno = super;
29830399Smckusick sblk.b_size = SBSIZE;
29930399Smckusick /*
30030399Smckusick * run a few consistency checks of the super block
30130399Smckusick */
30230399Smckusick if (sblock.fs_magic != FS_MAGIC)
30330399Smckusick { badsb(listerr, "MAGIC NUMBER WRONG"); return (0); }
30430399Smckusick if (sblock.fs_ncg < 1)
30530399Smckusick { badsb(listerr, "NCG OUT OF RANGE"); return (0); }
30634140Smckusick if (sblock.fs_cpg < 1)
30730399Smckusick { badsb(listerr, "CPG OUT OF RANGE"); return (0); }
30830399Smckusick if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
30930399Smckusick (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
31030399Smckusick { badsb(listerr, "NCYL LESS THAN NCG*CPG"); return (0); }
31130399Smckusick if (sblock.fs_sbsize > SBSIZE)
31230399Smckusick { badsb(listerr, "SIZE PREPOSTEROUSLY LARGE"); return (0); }
31330399Smckusick /*
31430859Skarels * Compute block size that the filesystem is based on,
31530859Skarels * according to fsbtodb, and adjust superblock block number
31630859Skarels * so we can tell if this is an alternate later.
31730859Skarels */
31830859Skarels super *= dev_bsize;
31930859Skarels dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
32030859Skarels sblk.b_bno = super / dev_bsize;
32153613Smckusick if (bflag) {
32253613Smckusick havesb = 1;
32353613Smckusick return (1);
32453613Smckusick }
32530859Skarels /*
32630399Smckusick * Set all possible fields that could differ, then do check
32730399Smckusick * of whole super block against an alternate super block.
32830399Smckusick * When an alternate super-block is specified this check is skipped.
32930399Smckusick */
33034140Smckusick getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
33138376Smckusick if (asblk.b_errs)
33234140Smckusick return (0);
33368140Smckusick altsblock.fs_firstfield = sblock.fs_firstfield;
33468140Smckusick altsblock.fs_unused_1 = sblock.fs_unused_1;
33530399Smckusick altsblock.fs_time = sblock.fs_time;
33630399Smckusick altsblock.fs_cstotal = sblock.fs_cstotal;
33730399Smckusick altsblock.fs_cgrotor = sblock.fs_cgrotor;
33830399Smckusick altsblock.fs_fmod = sblock.fs_fmod;
33930399Smckusick altsblock.fs_clean = sblock.fs_clean;
34030399Smckusick altsblock.fs_ronly = sblock.fs_ronly;
34130399Smckusick altsblock.fs_flags = sblock.fs_flags;
34230399Smckusick altsblock.fs_maxcontig = sblock.fs_maxcontig;
34330399Smckusick altsblock.fs_minfree = sblock.fs_minfree;
34430399Smckusick altsblock.fs_optim = sblock.fs_optim;
34530399Smckusick altsblock.fs_rotdelay = sblock.fs_rotdelay;
34630399Smckusick altsblock.fs_maxbpg = sblock.fs_maxbpg;
34768992Sbostic memmove(altsblock.fs_csp, sblock.fs_csp, sizeof sblock.fs_csp);
34867986Smckusick altsblock.fs_maxcluster = sblock.fs_maxcluster;
34968992Sbostic memmove(altsblock.fs_fsmnt, sblock.fs_fsmnt, sizeof sblock.fs_fsmnt);
35068992Sbostic memmove(altsblock.fs_sparecon,
35168992Sbostic sblock.fs_sparecon, sizeof sblock.fs_sparecon);
35234140Smckusick /*
35334140Smckusick * The following should not have to be copied.
35434140Smckusick */
35534140Smckusick altsblock.fs_fsbtodb = sblock.fs_fsbtodb;
35634140Smckusick altsblock.fs_interleave = sblock.fs_interleave;
35734140Smckusick altsblock.fs_npsect = sblock.fs_npsect;
35834140Smckusick altsblock.fs_nrpos = sblock.fs_nrpos;
35967103Smckusick altsblock.fs_state = sblock.fs_state;
36054023Smckusick altsblock.fs_qbmask = sblock.fs_qbmask;
36154023Smckusick altsblock.fs_qfmask = sblock.fs_qfmask;
36254023Smckusick altsblock.fs_state = sblock.fs_state;
36354023Smckusick altsblock.fs_maxfilesize = sblock.fs_maxfilesize;
36468992Sbostic if (memcmp(&sblock, &altsblock, (int)sblock.fs_sbsize)) {
36567986Smckusick if (debug) {
36667986Smckusick long *nlp, *olp, *endlp;
36767986Smckusick
36867986Smckusick printf("superblock mismatches\n");
36967986Smckusick nlp = (long *)&altsblock;
37067986Smckusick olp = (long *)&sblock;
37167986Smckusick endlp = olp + (sblock.fs_sbsize / sizeof *olp);
37267986Smckusick for ( ; olp < endlp; olp++, nlp++) {
37367986Smckusick if (*olp == *nlp)
37467986Smckusick continue;
37567986Smckusick printf("offset %d, original %d, alternate %d\n",
37667986Smckusick olp - (long *)&sblock, *olp, *nlp);
37767986Smckusick }
37867986Smckusick }
37930565Skarels badsb(listerr,
38030565Skarels "VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
38130565Skarels return (0);
38230565Skarels }
38330859Skarels havesb = 1;
38430399Smckusick return (1);
38516268Smckusick }
38616268Smckusick
38768908Smckusick static void
badsb(listerr,s)38830399Smckusick badsb(listerr, s)
38930399Smckusick int listerr;
39016268Smckusick char *s;
39116268Smckusick {
39216268Smckusick
39330399Smckusick if (!listerr)
39430399Smckusick return;
39516268Smckusick if (preen)
39661110Sbostic printf("%s: ", cdevname);
39730399Smckusick pfatal("BAD SUPER BLOCK: %s\n", s);
39816268Smckusick }
39930399Smckusick
40030399Smckusick /*
40130399Smckusick * Calculate a prototype superblock based on information in the disk label.
40230399Smckusick * When done the cgsblock macro can be calculated and the fs_ncg field
40330399Smckusick * can be used. Do NOT attempt to use other macros without verifying that
40430399Smckusick * their needed information is available!
40530399Smckusick */
40668908Smckusick static int
calcsb(dev,devfd,fs)40730399Smckusick calcsb(dev, devfd, fs)
40830399Smckusick char *dev;
40930399Smckusick int devfd;
41030399Smckusick register struct fs *fs;
41130399Smckusick {
41230399Smckusick register struct disklabel *lp;
41330399Smckusick register struct partition *pp;
41430399Smckusick register char *cp;
41530399Smckusick int i;
41630399Smckusick
41768992Sbostic cp = strchr(dev, '\0') - 1;
41868908Smckusick if (cp == (char *)-1 || ((*cp < 'a' || *cp > 'h') && !isdigit(*cp))) {
41930399Smckusick pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
42030399Smckusick return (0);
42130399Smckusick }
42230399Smckusick lp = getdisklabel(dev, devfd);
42330399Smckusick if (isdigit(*cp))
42430399Smckusick pp = &lp->d_partitions[0];
42530399Smckusick else
42630399Smckusick pp = &lp->d_partitions[*cp - 'a'];
42730399Smckusick if (pp->p_fstype != FS_BSDFFS) {
42830859Skarels pfatal("%s: NOT LABELED AS A BSD FILE SYSTEM (%s)\n",
42930399Smckusick dev, pp->p_fstype < FSMAXTYPES ?
43030399Smckusick fstypenames[pp->p_fstype] : "unknown");
43130399Smckusick return (0);
43230399Smckusick }
43368992Sbostic memset(fs, 0, sizeof(struct fs));
43430399Smckusick fs->fs_fsize = pp->p_fsize;
43530399Smckusick fs->fs_frag = pp->p_frag;
43630399Smckusick fs->fs_cpg = pp->p_cpg;
43730399Smckusick fs->fs_size = pp->p_size;
43830399Smckusick fs->fs_ntrak = lp->d_ntracks;
43930399Smckusick fs->fs_nsect = lp->d_nsectors;
44030399Smckusick fs->fs_spc = lp->d_secpercyl;
44130399Smckusick fs->fs_nspf = fs->fs_fsize / lp->d_secsize;
44230399Smckusick fs->fs_sblkno = roundup(
44330399Smckusick howmany(lp->d_bbsize + lp->d_sbsize, fs->fs_fsize),
44430399Smckusick fs->fs_frag);
44530399Smckusick fs->fs_cgmask = 0xffffffff;
44630399Smckusick for (i = fs->fs_ntrak; i > 1; i >>= 1)
44730399Smckusick fs->fs_cgmask <<= 1;
44830399Smckusick if (!POWEROF2(fs->fs_ntrak))
44930399Smckusick fs->fs_cgmask <<= 1;
45030399Smckusick fs->fs_cgoffset = roundup(
45130399Smckusick howmany(fs->fs_nsect, NSPF(fs)), fs->fs_frag);
45230399Smckusick fs->fs_fpg = (fs->fs_cpg * fs->fs_spc) / NSPF(fs);
45330399Smckusick fs->fs_ncg = howmany(fs->fs_size / fs->fs_spc, fs->fs_cpg);
45430399Smckusick for (fs->fs_fsbtodb = 0, i = NSPF(fs); i > 1; i >>= 1)
45530399Smckusick fs->fs_fsbtodb++;
45630859Skarels dev_bsize = lp->d_secsize;
45730399Smckusick return (1);
45830399Smckusick }
45930399Smckusick
46068908Smckusick static struct disklabel *
getdisklabel(s,fd)46130399Smckusick getdisklabel(s, fd)
46230399Smckusick char *s;
46330399Smckusick int fd;
46430399Smckusick {
46530399Smckusick static struct disklabel lab;
46630399Smckusick
46730399Smckusick if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
46830609Skarels if (s == NULL)
46930609Skarels return ((struct disklabel *)NULL);
47044934Smckusick pwarn("ioctl (GCINFO): %s\n", strerror(errno));
47168908Smckusick errx(EEXIT, "%s: can't read disk label", s);
47230399Smckusick }
47330399Smckusick return (&lab);
47430399Smckusick }
475