setup.c revision 1.14 1 1.1 cgd /*
2 1.10 mycroft * Copyright (c) 1980, 1986, 1993
3 1.10 mycroft * The Regents of the University of California. All rights reserved.
4 1.1 cgd *
5 1.1 cgd * Redistribution and use in source and binary forms, with or without
6 1.1 cgd * modification, are permitted provided that the following conditions
7 1.1 cgd * are met:
8 1.1 cgd * 1. Redistributions of source code must retain the above copyright
9 1.1 cgd * notice, this list of conditions and the following disclaimer.
10 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
11 1.1 cgd * notice, this list of conditions and the following disclaimer in the
12 1.1 cgd * documentation and/or other materials provided with the distribution.
13 1.1 cgd * 3. All advertising materials mentioning features or use of this software
14 1.1 cgd * must display the following acknowledgement:
15 1.1 cgd * This product includes software developed by the University of
16 1.1 cgd * California, Berkeley and its contributors.
17 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
18 1.1 cgd * may be used to endorse or promote products derived from this software
19 1.1 cgd * without specific prior written permission.
20 1.1 cgd *
21 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 1.1 cgd * SUCH DAMAGE.
32 1.1 cgd */
33 1.1 cgd
34 1.1 cgd #ifndef lint
35 1.10 mycroft /*static char sccsid[] = "from: @(#)setup.c 8.2 (Berkeley) 2/21/94";*/
36 1.14 mycroft static char *rcsid = "$Id: setup.c,v 1.14 1994/10/28 16:55:11 mycroft Exp $";
37 1.1 cgd #endif /* not lint */
38 1.1 cgd
39 1.1 cgd #define DKTYPENAMES
40 1.1 cgd #include <sys/param.h>
41 1.8 cgd #include <sys/time.h>
42 1.10 mycroft #include <ufs/ufs/dinode.h>
43 1.10 mycroft #include <ufs/ffs/fs.h>
44 1.1 cgd #include <sys/stat.h>
45 1.1 cgd #include <sys/ioctl.h>
46 1.1 cgd #include <sys/disklabel.h>
47 1.1 cgd #include <sys/file.h>
48 1.1 cgd #include <errno.h>
49 1.1 cgd #include <stdlib.h>
50 1.1 cgd #include <string.h>
51 1.1 cgd #include <ctype.h>
52 1.1 cgd #include "fsck.h"
53 1.1 cgd
54 1.1 cgd struct bufarea asblk;
55 1.1 cgd #define altsblock (*asblk.b_un.b_fs)
56 1.1 cgd #define POWEROF2(num) (((num) & ((num) - 1)) == 0)
57 1.1 cgd
58 1.1 cgd struct disklabel *getdisklabel();
59 1.1 cgd
60 1.1 cgd setup(dev)
61 1.1 cgd char *dev;
62 1.1 cgd {
63 1.1 cgd long cg, size, asked, i, j;
64 1.1 cgd long bmapsize;
65 1.1 cgd struct disklabel *lp;
66 1.10 mycroft off_t sizepb;
67 1.10 mycroft struct stat statb;
68 1.1 cgd struct fs proto;
69 1.1 cgd
70 1.1 cgd havesb = 0;
71 1.10 mycroft fswritefd = -1;
72 1.1 cgd if (stat(dev, &statb) < 0) {
73 1.1 cgd printf("Can't stat %s: %s\n", dev, strerror(errno));
74 1.1 cgd return (0);
75 1.1 cgd }
76 1.14 mycroft if (!S_ISCHR(statb.st_mode)) {
77 1.1 cgd pfatal("%s is not a character device", dev);
78 1.1 cgd if (reply("CONTINUE") == 0)
79 1.1 cgd return (0);
80 1.1 cgd }
81 1.1 cgd if ((fsreadfd = open(dev, O_RDONLY)) < 0) {
82 1.1 cgd printf("Can't open %s: %s\n", dev, strerror(errno));
83 1.1 cgd return (0);
84 1.1 cgd }
85 1.1 cgd if (preen == 0)
86 1.1 cgd printf("** %s", dev);
87 1.1 cgd if (nflag || (fswritefd = open(dev, O_WRONLY)) < 0) {
88 1.1 cgd fswritefd = -1;
89 1.1 cgd if (preen)
90 1.1 cgd pfatal("NO WRITE ACCESS");
91 1.1 cgd printf(" (NO WRITE)");
92 1.1 cgd }
93 1.1 cgd if (preen == 0)
94 1.1 cgd printf("\n");
95 1.1 cgd fsmodified = 0;
96 1.1 cgd lfdir = 0;
97 1.1 cgd initbarea(&sblk);
98 1.1 cgd initbarea(&asblk);
99 1.1 cgd sblk.b_un.b_buf = malloc(SBSIZE);
100 1.1 cgd asblk.b_un.b_buf = malloc(SBSIZE);
101 1.1 cgd if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
102 1.1 cgd errexit("cannot allocate space for superblock\n");
103 1.1 cgd if (lp = getdisklabel((char *)NULL, fsreadfd))
104 1.1 cgd dev_bsize = secsize = lp->d_secsize;
105 1.1 cgd else
106 1.1 cgd dev_bsize = secsize = DEV_BSIZE;
107 1.1 cgd /*
108 1.1 cgd * Read in the superblock, looking for alternates if necessary
109 1.1 cgd */
110 1.1 cgd if (readsb(1) == 0) {
111 1.1 cgd if (bflag || preen || calcsb(dev, fsreadfd, &proto) == 0)
112 1.1 cgd return(0);
113 1.1 cgd if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
114 1.1 cgd return (0);
115 1.1 cgd for (cg = 0; cg < proto.fs_ncg; cg++) {
116 1.1 cgd bflag = fsbtodb(&proto, cgsblock(&proto, cg));
117 1.1 cgd if (readsb(0) != 0)
118 1.1 cgd break;
119 1.1 cgd }
120 1.1 cgd if (cg >= proto.fs_ncg) {
121 1.1 cgd printf("%s %s\n%s %s\n%s %s\n",
122 1.1 cgd "SEARCH FOR ALTERNATE SUPER-BLOCK",
123 1.1 cgd "FAILED. YOU MUST USE THE",
124 1.1 cgd "-b OPTION TO FSCK TO SPECIFY THE",
125 1.1 cgd "LOCATION OF AN ALTERNATE",
126 1.1 cgd "SUPER-BLOCK TO SUPPLY NEEDED",
127 1.1 cgd "INFORMATION; SEE fsck(8).");
128 1.1 cgd return(0);
129 1.1 cgd }
130 1.1 cgd pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
131 1.1 cgd }
132 1.1 cgd maxfsblock = sblock.fs_size;
133 1.1 cgd maxino = sblock.fs_ncg * sblock.fs_ipg;
134 1.1 cgd /*
135 1.1 cgd * Check and potentially fix certain fields in the super block.
136 1.1 cgd */
137 1.1 cgd if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
138 1.1 cgd pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
139 1.1 cgd if (reply("SET TO DEFAULT") == 1) {
140 1.1 cgd sblock.fs_optim = FS_OPTTIME;
141 1.1 cgd sbdirty();
142 1.1 cgd }
143 1.1 cgd }
144 1.1 cgd if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
145 1.1 cgd pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
146 1.1 cgd sblock.fs_minfree);
147 1.1 cgd if (reply("SET TO DEFAULT") == 1) {
148 1.1 cgd sblock.fs_minfree = 10;
149 1.1 cgd sbdirty();
150 1.1 cgd }
151 1.1 cgd }
152 1.1 cgd if (sblock.fs_interleave < 1 ||
153 1.1 cgd sblock.fs_interleave > sblock.fs_nsect) {
154 1.1 cgd pwarn("IMPOSSIBLE INTERLEAVE=%d IN SUPERBLOCK",
155 1.1 cgd sblock.fs_interleave);
156 1.1 cgd sblock.fs_interleave = 1;
157 1.1 cgd if (preen)
158 1.1 cgd printf(" (FIXED)\n");
159 1.1 cgd if (preen || reply("SET TO DEFAULT") == 1) {
160 1.1 cgd sbdirty();
161 1.1 cgd dirty(&asblk);
162 1.1 cgd }
163 1.1 cgd }
164 1.1 cgd if (sblock.fs_npsect < sblock.fs_nsect ||
165 1.1 cgd sblock.fs_npsect > sblock.fs_nsect*2) {
166 1.1 cgd pwarn("IMPOSSIBLE NPSECT=%d IN SUPERBLOCK",
167 1.1 cgd sblock.fs_npsect);
168 1.1 cgd sblock.fs_npsect = sblock.fs_nsect;
169 1.1 cgd if (preen)
170 1.1 cgd printf(" (FIXED)\n");
171 1.1 cgd if (preen || reply("SET TO DEFAULT") == 1) {
172 1.1 cgd sbdirty();
173 1.1 cgd dirty(&asblk);
174 1.1 cgd }
175 1.1 cgd }
176 1.10 mycroft if (sblock.fs_inodefmt >= FS_44INODEFMT) {
177 1.10 mycroft newinofmt = 1;
178 1.10 mycroft } else {
179 1.10 mycroft sblock.fs_qbmask = ~sblock.fs_bmask;
180 1.10 mycroft sblock.fs_qfmask = ~sblock.fs_fmask;
181 1.10 mycroft newinofmt = 0;
182 1.10 mycroft }
183 1.10 mycroft /*
184 1.10 mycroft * Convert to new inode format.
185 1.10 mycroft */
186 1.10 mycroft if (cvtlevel >= 2 && sblock.fs_inodefmt < FS_44INODEFMT) {
187 1.10 mycroft if (preen)
188 1.10 mycroft pwarn("CONVERTING TO NEW INODE FORMAT\n");
189 1.10 mycroft else if (!reply("CONVERT TO NEW INODE FORMAT"))
190 1.10 mycroft return(0);
191 1.10 mycroft doinglevel2++;
192 1.10 mycroft sblock.fs_inodefmt = FS_44INODEFMT;
193 1.10 mycroft sizepb = sblock.fs_bsize;
194 1.10 mycroft sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
195 1.10 mycroft for (i = 0; i < NIADDR; i++) {
196 1.10 mycroft sizepb *= NINDIR(&sblock);
197 1.10 mycroft sblock.fs_maxfilesize += sizepb;
198 1.1 cgd }
199 1.10 mycroft sblock.fs_maxsymlinklen = MAXSYMLINKLEN;
200 1.10 mycroft sblock.fs_qbmask = ~sblock.fs_bmask;
201 1.10 mycroft sblock.fs_qfmask = ~sblock.fs_fmask;
202 1.10 mycroft sbdirty();
203 1.10 mycroft dirty(&asblk);
204 1.10 mycroft }
205 1.10 mycroft /*
206 1.10 mycroft * Convert to new cylinder group format.
207 1.10 mycroft */
208 1.10 mycroft if (cvtlevel >= 1 && sblock.fs_postblformat == FS_42POSTBLFMT) {
209 1.10 mycroft if (preen)
210 1.10 mycroft pwarn("CONVERTING TO NEW CYLINDER GROUP FORMAT\n");
211 1.10 mycroft else if (!reply("CONVERT TO NEW CYLINDER GROUP FORMAT"))
212 1.10 mycroft return(0);
213 1.10 mycroft doinglevel1++;
214 1.10 mycroft sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
215 1.10 mycroft sblock.fs_nrpos = 8;
216 1.10 mycroft sblock.fs_postbloff =
217 1.10 mycroft (char *)(&sblock.fs_opostbl[0][0]) -
218 1.14 mycroft (char *)(&sblock.fs_unused_1);
219 1.10 mycroft sblock.fs_rotbloff = &sblock.fs_space[0] -
220 1.14 mycroft (u_char *)(&sblock.fs_unused_1);
221 1.10 mycroft sblock.fs_cgsize =
222 1.10 mycroft fragroundup(&sblock, CGSIZE(&sblock));
223 1.10 mycroft sbdirty();
224 1.10 mycroft dirty(&asblk);
225 1.1 cgd }
226 1.11 ws if (asblk.b_dirty && !bflag) {
227 1.12 mycroft memcpy(&altsblock, &sblock, (size_t)sblock.fs_sbsize);
228 1.1 cgd flush(fswritefd, &asblk);
229 1.1 cgd }
230 1.1 cgd /*
231 1.1 cgd * read in the summary info.
232 1.1 cgd */
233 1.1 cgd asked = 0;
234 1.1 cgd for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
235 1.1 cgd size = sblock.fs_cssize - i < sblock.fs_bsize ?
236 1.1 cgd sblock.fs_cssize - i : sblock.fs_bsize;
237 1.1 cgd sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
238 1.1 cgd if (bread(fsreadfd, (char *)sblock.fs_csp[j],
239 1.1 cgd fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
240 1.1 cgd size) != 0 && !asked) {
241 1.1 cgd pfatal("BAD SUMMARY INFORMATION");
242 1.1 cgd if (reply("CONTINUE") == 0)
243 1.1 cgd errexit("");
244 1.1 cgd asked++;
245 1.1 cgd }
246 1.1 cgd }
247 1.1 cgd /*
248 1.1 cgd * allocate and initialize the necessary maps
249 1.1 cgd */
250 1.1 cgd bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(short));
251 1.1 cgd blockmap = calloc((unsigned)bmapsize, sizeof (char));
252 1.1 cgd if (blockmap == NULL) {
253 1.1 cgd printf("cannot alloc %u bytes for blockmap\n",
254 1.1 cgd (unsigned)bmapsize);
255 1.1 cgd goto badsb;
256 1.1 cgd }
257 1.1 cgd statemap = calloc((unsigned)(maxino + 1), sizeof(char));
258 1.1 cgd if (statemap == NULL) {
259 1.1 cgd printf("cannot alloc %u bytes for statemap\n",
260 1.1 cgd (unsigned)(maxino + 1));
261 1.1 cgd goto badsb;
262 1.1 cgd }
263 1.10 mycroft typemap = calloc((unsigned)(maxino + 1), sizeof(char));
264 1.10 mycroft if (typemap == NULL) {
265 1.10 mycroft printf("cannot alloc %u bytes for typemap\n",
266 1.10 mycroft (unsigned)(maxino + 1));
267 1.10 mycroft goto badsb;
268 1.10 mycroft }
269 1.1 cgd lncntp = (short *)calloc((unsigned)(maxino + 1), sizeof(short));
270 1.1 cgd if (lncntp == NULL) {
271 1.1 cgd printf("cannot alloc %u bytes for lncntp\n",
272 1.1 cgd (unsigned)(maxino + 1) * sizeof(short));
273 1.1 cgd goto badsb;
274 1.1 cgd }
275 1.1 cgd numdirs = sblock.fs_cstotal.cs_ndir;
276 1.1 cgd inplast = 0;
277 1.1 cgd listmax = numdirs + 10;
278 1.1 cgd inpsort = (struct inoinfo **)calloc((unsigned)listmax,
279 1.1 cgd sizeof(struct inoinfo *));
280 1.1 cgd inphead = (struct inoinfo **)calloc((unsigned)numdirs,
281 1.1 cgd sizeof(struct inoinfo *));
282 1.1 cgd if (inpsort == NULL || inphead == NULL) {
283 1.1 cgd printf("cannot alloc %u bytes for inphead\n",
284 1.1 cgd (unsigned)numdirs * sizeof(struct inoinfo *));
285 1.1 cgd goto badsb;
286 1.1 cgd }
287 1.1 cgd bufinit();
288 1.1 cgd return (1);
289 1.1 cgd
290 1.1 cgd badsb:
291 1.1 cgd ckfini();
292 1.1 cgd return (0);
293 1.1 cgd }
294 1.1 cgd
295 1.1 cgd /*
296 1.1 cgd * Read in the super block and its summary info.
297 1.1 cgd */
298 1.1 cgd readsb(listerr)
299 1.1 cgd int listerr;
300 1.1 cgd {
301 1.1 cgd daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
302 1.1 cgd
303 1.1 cgd if (bread(fsreadfd, (char *)&sblock, super, (long)SBSIZE) != 0)
304 1.1 cgd return (0);
305 1.1 cgd sblk.b_bno = super;
306 1.1 cgd sblk.b_size = SBSIZE;
307 1.1 cgd /*
308 1.1 cgd * run a few consistency checks of the super block
309 1.1 cgd */
310 1.1 cgd if (sblock.fs_magic != FS_MAGIC)
311 1.1 cgd { badsb(listerr, "MAGIC NUMBER WRONG"); return (0); }
312 1.1 cgd if (sblock.fs_ncg < 1)
313 1.1 cgd { badsb(listerr, "NCG OUT OF RANGE"); return (0); }
314 1.1 cgd if (sblock.fs_cpg < 1)
315 1.1 cgd { badsb(listerr, "CPG OUT OF RANGE"); return (0); }
316 1.1 cgd if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
317 1.1 cgd (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
318 1.1 cgd { badsb(listerr, "NCYL LESS THAN NCG*CPG"); return (0); }
319 1.1 cgd if (sblock.fs_sbsize > SBSIZE)
320 1.1 cgd { badsb(listerr, "SIZE PREPOSTEROUSLY LARGE"); return (0); }
321 1.1 cgd /*
322 1.1 cgd * Compute block size that the filesystem is based on,
323 1.1 cgd * according to fsbtodb, and adjust superblock block number
324 1.1 cgd * so we can tell if this is an alternate later.
325 1.1 cgd */
326 1.1 cgd super *= dev_bsize;
327 1.1 cgd dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
328 1.1 cgd sblk.b_bno = super / dev_bsize;
329 1.10 mycroft if (bflag) {
330 1.10 mycroft havesb = 1;
331 1.10 mycroft return (1);
332 1.10 mycroft }
333 1.1 cgd /*
334 1.1 cgd * Set all possible fields that could differ, then do check
335 1.1 cgd * of whole super block against an alternate super block.
336 1.1 cgd * When an alternate super-block is specified this check is skipped.
337 1.1 cgd */
338 1.1 cgd getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
339 1.1 cgd if (asblk.b_errs)
340 1.1 cgd return (0);
341 1.14 mycroft altsblock.fs_unused_1 = sblock.fs_unused_1;
342 1.14 mycroft altsblock.fs_unused_2 = sblock.fs_unused_2;
343 1.1 cgd altsblock.fs_time = sblock.fs_time;
344 1.1 cgd altsblock.fs_cstotal = sblock.fs_cstotal;
345 1.1 cgd altsblock.fs_cgrotor = sblock.fs_cgrotor;
346 1.1 cgd altsblock.fs_fmod = sblock.fs_fmod;
347 1.1 cgd altsblock.fs_clean = sblock.fs_clean;
348 1.1 cgd altsblock.fs_ronly = sblock.fs_ronly;
349 1.1 cgd altsblock.fs_flags = sblock.fs_flags;
350 1.1 cgd altsblock.fs_maxcontig = sblock.fs_maxcontig;
351 1.1 cgd altsblock.fs_minfree = sblock.fs_minfree;
352 1.1 cgd altsblock.fs_optim = sblock.fs_optim;
353 1.1 cgd altsblock.fs_rotdelay = sblock.fs_rotdelay;
354 1.1 cgd altsblock.fs_maxbpg = sblock.fs_maxbpg;
355 1.12 mycroft memcpy(altsblock.fs_csp, sblock.fs_csp,
356 1.1 cgd sizeof sblock.fs_csp);
357 1.12 mycroft memcpy(altsblock.fs_fsmnt, sblock.fs_fsmnt,
358 1.1 cgd sizeof sblock.fs_fsmnt);
359 1.12 mycroft memcpy(altsblock.fs_sparecon, sblock.fs_sparecon,
360 1.1 cgd sizeof sblock.fs_sparecon);
361 1.1 cgd /*
362 1.1 cgd * The following should not have to be copied.
363 1.1 cgd */
364 1.1 cgd altsblock.fs_fsbtodb = sblock.fs_fsbtodb;
365 1.1 cgd altsblock.fs_interleave = sblock.fs_interleave;
366 1.1 cgd altsblock.fs_npsect = sblock.fs_npsect;
367 1.1 cgd altsblock.fs_nrpos = sblock.fs_nrpos;
368 1.10 mycroft altsblock.fs_qbmask = sblock.fs_qbmask;
369 1.10 mycroft altsblock.fs_qfmask = sblock.fs_qfmask;
370 1.10 mycroft altsblock.fs_state = sblock.fs_state;
371 1.10 mycroft altsblock.fs_maxfilesize = sblock.fs_maxfilesize;
372 1.13 mycroft if (memcmp(&sblock, &altsblock, (int)sblock.fs_sbsize)) {
373 1.1 cgd badsb(listerr,
374 1.1 cgd "VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
375 1.1 cgd return (0);
376 1.1 cgd }
377 1.1 cgd havesb = 1;
378 1.1 cgd return (1);
379 1.1 cgd }
380 1.1 cgd
381 1.1 cgd badsb(listerr, s)
382 1.1 cgd int listerr;
383 1.1 cgd char *s;
384 1.1 cgd {
385 1.1 cgd
386 1.1 cgd if (!listerr)
387 1.1 cgd return;
388 1.1 cgd if (preen)
389 1.10 mycroft printf("%s: ", cdevname);
390 1.1 cgd pfatal("BAD SUPER BLOCK: %s\n", s);
391 1.1 cgd }
392 1.1 cgd
393 1.1 cgd /*
394 1.1 cgd * Calculate a prototype superblock based on information in the disk label.
395 1.1 cgd * When done the cgsblock macro can be calculated and the fs_ncg field
396 1.1 cgd * can be used. Do NOT attempt to use other macros without verifying that
397 1.1 cgd * their needed information is available!
398 1.1 cgd */
399 1.1 cgd calcsb(dev, devfd, fs)
400 1.1 cgd char *dev;
401 1.1 cgd int devfd;
402 1.1 cgd register struct fs *fs;
403 1.1 cgd {
404 1.1 cgd register struct disklabel *lp;
405 1.1 cgd register struct partition *pp;
406 1.1 cgd register char *cp;
407 1.1 cgd int i;
408 1.1 cgd
409 1.12 mycroft cp = strchr(dev, '\0') - 1;
410 1.1 cgd if (cp == (char *)-1 || (*cp < 'a' || *cp > 'h') && !isdigit(*cp)) {
411 1.1 cgd pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
412 1.1 cgd return (0);
413 1.1 cgd }
414 1.1 cgd lp = getdisklabel(dev, devfd);
415 1.1 cgd if (isdigit(*cp))
416 1.1 cgd pp = &lp->d_partitions[0];
417 1.1 cgd else
418 1.1 cgd pp = &lp->d_partitions[*cp - 'a'];
419 1.1 cgd if (pp->p_fstype != FS_BSDFFS) {
420 1.1 cgd pfatal("%s: NOT LABELED AS A BSD FILE SYSTEM (%s)\n",
421 1.1 cgd dev, pp->p_fstype < FSMAXTYPES ?
422 1.1 cgd fstypenames[pp->p_fstype] : "unknown");
423 1.1 cgd return (0);
424 1.1 cgd }
425 1.12 mycroft memset(fs, 0, sizeof(struct fs));
426 1.1 cgd fs->fs_fsize = pp->p_fsize;
427 1.1 cgd fs->fs_frag = pp->p_frag;
428 1.1 cgd fs->fs_cpg = pp->p_cpg;
429 1.1 cgd fs->fs_size = pp->p_size;
430 1.1 cgd fs->fs_ntrak = lp->d_ntracks;
431 1.1 cgd fs->fs_nsect = lp->d_nsectors;
432 1.1 cgd fs->fs_spc = lp->d_secpercyl;
433 1.1 cgd fs->fs_nspf = fs->fs_fsize / lp->d_secsize;
434 1.1 cgd fs->fs_sblkno = roundup(
435 1.1 cgd howmany(lp->d_bbsize + lp->d_sbsize, fs->fs_fsize),
436 1.1 cgd fs->fs_frag);
437 1.1 cgd fs->fs_cgmask = 0xffffffff;
438 1.1 cgd for (i = fs->fs_ntrak; i > 1; i >>= 1)
439 1.1 cgd fs->fs_cgmask <<= 1;
440 1.1 cgd if (!POWEROF2(fs->fs_ntrak))
441 1.1 cgd fs->fs_cgmask <<= 1;
442 1.1 cgd fs->fs_cgoffset = roundup(
443 1.1 cgd howmany(fs->fs_nsect, NSPF(fs)), fs->fs_frag);
444 1.1 cgd fs->fs_fpg = (fs->fs_cpg * fs->fs_spc) / NSPF(fs);
445 1.1 cgd fs->fs_ncg = howmany(fs->fs_size / fs->fs_spc, fs->fs_cpg);
446 1.1 cgd for (fs->fs_fsbtodb = 0, i = NSPF(fs); i > 1; i >>= 1)
447 1.1 cgd fs->fs_fsbtodb++;
448 1.1 cgd dev_bsize = lp->d_secsize;
449 1.1 cgd return (1);
450 1.1 cgd }
451 1.1 cgd
452 1.1 cgd struct disklabel *
453 1.1 cgd getdisklabel(s, fd)
454 1.1 cgd char *s;
455 1.1 cgd int fd;
456 1.1 cgd {
457 1.1 cgd static struct disklabel lab;
458 1.1 cgd
459 1.1 cgd if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
460 1.1 cgd if (s == NULL)
461 1.1 cgd return ((struct disklabel *)NULL);
462 1.1 cgd pwarn("ioctl (GCINFO): %s\n", strerror(errno));
463 1.1 cgd errexit("%s: can't read disk label\n", s);
464 1.1 cgd }
465 1.1 cgd return (&lab);
466 1.1 cgd }
467