Style(9) cleanup to src/sys/vfs, stage 20/21: umapfs.
[dragonfly.git] / sbin / newfs / newfs.c
1 /*
2  * Copyright (c) 1983, 1989, 1993, 1994
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
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  * @(#) Copyright (c) 1983, 1989, 1993, 1994 The Regents of the University of California.  All rights reserved.
34  * @(#)newfs.c  8.13 (Berkeley) 5/1/95
35  * $FreeBSD: src/sbin/newfs/newfs.c,v 1.30.2.9 2003/05/13 12:03:55 joerg Exp $
36  * $DragonFly: src/sbin/newfs/newfs.c,v 1.8 2004/03/04 00:03:23 dillon Exp $
37  */
38
39 /*
40  * newfs: friendly front end to mkfs
41  */
42 #include <sys/param.h>
43 #include <sys/stat.h>
44 #include <sys/disklabel.h>
45 #include <sys/file.h>
46 #include <sys/mount.h>
47
48 #include <vfs/ufs/dir.h>
49 #include <vfs/ufs/dinode.h>
50 #include <vfs/ufs/fs.h>
51 #include <vfs/ufs/ufsmount.h>
52
53 #include <ctype.h>
54 #include <err.h>
55 #include <errno.h>
56 #include <paths.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <string.h>
60 #include <syslog.h>
61 #include <unistd.h>
62
63 #ifdef MFS
64 #include <sys/types.h>
65 #include <sys/mman.h>
66 #endif
67
68 #if __STDC__
69 #include <stdarg.h>
70 #else
71 #include <varargs.h>
72 #endif
73
74 #include "mntopts.h"
75 #include "defs.h"
76
77 struct mntopt mopts[] = {
78         MOPT_STDOPTS,
79         MOPT_ASYNC,
80         { NULL },
81 };
82
83 void    fatal(const char *fmt, ...);
84
85 #define COMPAT                  /* allow non-labeled disks */
86
87 /*
88  * The following two constants set the default block and fragment sizes.
89  * Both constants must be a power of 2 and meet the following constraints:
90  *      MINBSIZE <= DESBLKSIZE <= MAXBSIZE
91  *      sectorsize <= DESFRAGSIZE <= DESBLKSIZE
92  *      DESBLKSIZE / DESFRAGSIZE <= 8
93  */
94 #define DFL_FRAGSIZE    2048
95 #define DFL_BLKSIZE     16384
96
97 /*
98  * Cylinder groups may have up to many cylinders. The actual
99  * number used depends upon how much information can be stored
100  * on a single cylinder. The default is to use as many as possible
101  * cylinders per group.
102  */
103 #define DESCPG          65536   /* desired fs_cpg ("infinity") */
104
105 /*
106  * Once upon a time...
107  *    ROTDELAY gives the minimum number of milliseconds to initiate
108  *    another disk transfer on the same cylinder. It is used in
109  *    determining the rotationally optimal layout for disk blocks
110  *    within a file; the default of fs_rotdelay is 4ms.
111  *
112  * ...but now we make this 0 to disable the rotdelay delay because
113  * modern drives with read/write-behind achieve higher performance
114  * without the delay.
115  */
116 #define ROTDELAY        0
117
118 /*
119  * MAXBLKPG determines the maximum number of data blocks which are
120  * placed in a single cylinder group. The default is one indirect
121  * block worth of data blocks.
122  */
123 #define MAXBLKPG(bsize) ((bsize) / sizeof(daddr_t))
124
125 /*
126  * Each file system has a number of inodes statically allocated.
127  * We allocate one inode slot per NFPI fragments, expecting this
128  * to be far more than we will ever need.
129  */
130 #define NFPI            4
131
132 /*
133  * Once upon a time...
134  *    For each cylinder we keep track of the availability of blocks at different
135  *    rotational positions, so that we can lay out the data to be picked
136  *    up with minimum rotational latency.  NRPOS is the default number of
137  *    rotational positions that we distinguish.  With NRPOS of 8 the resolution
138  *    of our summary information is 2ms for a typical 3600 rpm drive.
139  *
140  * ...but now we make this 1 (which essentially disables the rotational
141  * position table because modern drives with read-ahead and write-behind do
142  * better without the rotational position table.
143  */
144 #define NRPOS           1       /* number distinct rotational positions */
145
146 /*
147  * About the same time as the above, we knew what went where on the disks.
148  * no longer so, so kill the code which finds the different platters too...
149  * We do this by saying one head, with a lot of sectors on it.
150  * The number of sectors are used to determine the size of a cyl-group.
151  * Kirk suggested one or two meg per "cylinder" so we say two.
152  */
153 #define NTRACKS         1       /* number of heads */
154 #define NSECTORS        4096    /* number of sectors */
155
156 int     mfs;                    /* run as the memory based filesystem */
157 char    *mfs_mtpt;              /* mount point for mfs          */
158 struct stat mfs_mtstat;         /* stat prior to mount          */
159 int     Nflag;                  /* run without writing file system */
160 int     Oflag;                  /* format as an 4.3BSD file system */
161 int     Cflag;                  /* copy underlying filesystem (mfs only) */
162 int     Uflag;                  /* enable soft updates for file system */
163 int     fssize;                 /* file system size */
164 int     ntracks = NTRACKS;      /* # tracks/cylinder */
165 int     nsectors = NSECTORS;    /* # sectors/track */
166 int     nphyssectors;           /* # sectors/track including spares */
167 int     secpercyl;              /* sectors per cylinder */
168 int     trackspares = -1;       /* spare sectors per track */
169 int     cylspares = -1;         /* spare sectors per cylinder */
170 int     sectorsize;             /* bytes/sector */
171 int     realsectorsize;         /* bytes/sector in hardware */
172 int     rpm;                    /* revolutions/minute of drive */
173 int     interleave;             /* hardware sector interleave */
174 int     trackskew = -1;         /* sector 0 skew, per track */
175 int     headswitch;             /* head switch time, usec */
176 int     trackseek;              /* track-to-track seek, usec */
177 int     fsize = 0;              /* fragment size */
178 int     bsize = 0;              /* block size */
179 int     cpg = DESCPG;           /* cylinders/cylinder group */
180 int     cpgflg;                 /* cylinders/cylinder group flag was given */
181 int     minfree = MINFREE;      /* free space threshold */
182 int     opt = DEFAULTOPT;       /* optimization preference (space or time) */
183 int     density;                /* number of bytes per inode */
184 int     maxcontig = 0;          /* max contiguous blocks to allocate */
185 int     rotdelay = ROTDELAY;    /* rotational delay between blocks */
186 int     maxbpg;                 /* maximum blocks per file in a cyl group */
187 int     nrpos = NRPOS;          /* # of distinguished rotational positions */
188 int     avgfilesize = AVFILESIZ;/* expected average file size */
189 int     avgfilesperdir = AFPDIR;/* expected number of files per directory */
190 int     bbsize = BBSIZE;        /* boot block size */
191 int     sbsize = SBSIZE;        /* superblock size */
192 int     mntflags = MNT_ASYNC;   /* flags to be passed to mount */
193 int     t_or_u_flag = 0;        /* user has specified -t or -u */
194 u_long  memleft;                /* virtual memory available */
195 caddr_t membase;                /* start address of memory based filesystem */
196 char    *filename;
197 #ifdef COMPAT
198 char    *disktype;
199 int     unlabeled;
200 #endif
201
202 char    device[MAXPATHLEN];
203 char    *progname;
204
205 struct disklabel *getdisklabel(char *, int);
206 static void rewritelabel(char *, int, struct disklabel *);
207 static void usage(void);
208
209 int
210 main(int argc, char **argv)
211 {
212         register int ch;
213         register struct partition *pp;
214         register struct disklabel *lp;
215         struct disklabel mfsfakelabel;
216         struct disklabel *getdisklabel();
217         struct partition oldpartition;
218         struct stat st;
219         struct statfs *mp;
220         int fsi = 0, fso, len, n, vflag;
221         char *cp = NULL, *s1, *s2, *special, *opstring;
222 #ifdef MFS
223         struct vfsconf vfc;
224         int error;
225         char buf[BUFSIZ];
226 #endif
227
228         vflag = 0;
229         if ((progname = strrchr(*argv, '/')))
230                 ++progname;
231         else
232                 progname = *argv;
233
234         if (strstr(progname, "mfs")) {
235                 mfs = 1;
236                 Nflag++;
237         }
238
239         opstring = mfs ?
240             "NCF:T:Ua:b:c:d:e:f:g:h:i:m:o:s:v" :
241             "NOS:T:Ua:b:c:d:e:f:g:h:i:k:l:m:n:o:p:r:s:t:u:vx:";
242         while ((ch = getopt(argc, argv, opstring)) != -1)
243                 switch (ch) {
244                 case 'N':
245                         Nflag = 1;
246                         break;
247                 case 'O':
248                         Oflag = 1;
249                         break;
250                 case 'C':
251                         Cflag = 1;      /* MFS only */
252                         break;
253                 case 'S':
254                         if ((sectorsize = atoi(optarg)) <= 0)
255                                 fatal("%s: bad sector size", optarg);
256                         break;
257 #ifdef COMPAT
258                 case 'T':
259                         disktype = optarg;
260                         break;
261 #endif
262                 case 'F':
263                         filename = optarg;
264                         break;
265                 case 'U':
266                         Uflag = 1;
267                         break;
268                 case 'a':
269                         if ((maxcontig = atoi(optarg)) <= 0)
270                                 fatal("%s: bad maximum contiguous blocks",
271                                     optarg);
272                         break;
273                 case 'b':
274                         if ((bsize = atoi(optarg)) < MINBSIZE)
275                                 fatal("%s: bad block size", optarg);
276                         break;
277                 case 'c':
278                         if ((cpg = atoi(optarg)) <= 0)
279                                 fatal("%s: bad cylinders/group", optarg);
280                         cpgflg++;
281                         break;
282                 case 'd':
283                         if ((rotdelay = atoi(optarg)) < 0)
284                                 fatal("%s: bad rotational delay", optarg);
285                         break;
286                 case 'e':
287                         if ((maxbpg = atoi(optarg)) <= 0)
288                 fatal("%s: bad blocks per file in a cylinder group",
289                                     optarg);
290                         break;
291                 case 'f':
292                         if ((fsize = atoi(optarg)) <= 0)
293                                 fatal("%s: bad fragment size", optarg);
294                         break;
295                 case 'g':
296                         if ((avgfilesize = atoi(optarg)) <= 0)
297                                 fatal("%s: bad average file size", optarg);
298                         break;
299                 case 'h':
300                         if ((avgfilesperdir = atoi(optarg)) <= 0)
301                                 fatal("%s: bad average files per dir", optarg);
302                         break;
303                 case 'i':
304                         if ((density = atoi(optarg)) <= 0)
305                                 fatal("%s: bad bytes per inode", optarg);
306                         break;
307                 case 'k':
308                         if ((trackskew = atoi(optarg)) < 0)
309                                 fatal("%s: bad track skew", optarg);
310                         break;
311                 case 'l':
312                         if ((interleave = atoi(optarg)) <= 0)
313                                 fatal("%s: bad interleave", optarg);
314                         break;
315                 case 'm':
316                         if ((minfree = atoi(optarg)) < 0 || minfree > 99)
317                                 fatal("%s: bad free space %%", optarg);
318                         break;
319                 case 'n':
320                         if ((nrpos = atoi(optarg)) < 0)
321                                 fatal("%s: bad rotational layout count",
322                                     optarg);
323                         if (nrpos == 0)
324                                 nrpos = 1;
325                         break;
326                 case 'o':
327                         if (mfs)
328                                 getmntopts(optarg, mopts, &mntflags, 0);
329                         else {
330                                 if (strcmp(optarg, "space") == 0)
331                                         opt = FS_OPTSPACE;
332                                 else if (strcmp(optarg, "time") == 0)
333                                         opt = FS_OPTTIME;
334                                 else
335         fatal("%s: unknown optimization preference: use `space' or `time'", optarg);
336                         }
337                         break;
338                 case 'p':
339                         if ((trackspares = atoi(optarg)) < 0)
340                                 fatal("%s: bad spare sectors per track",
341                                     optarg);
342                         break;
343                 case 'r':
344                         if ((rpm = atoi(optarg)) <= 0)
345                                 fatal("%s: bad revolutions/minute", optarg);
346                         break;
347                 case 's':
348                         if ((fssize = atoi(optarg)) <= 0)
349                                 fatal("%s: bad file system size", optarg);
350                         break;
351                 case 't':
352                         t_or_u_flag++;
353                         if ((ntracks = atoi(optarg)) < 0)
354                                 fatal("%s: bad total tracks", optarg);
355                         break;
356                 case 'u':
357                         t_or_u_flag++;
358                         if ((nsectors = atoi(optarg)) < 0)
359                                 fatal("%s: bad sectors/track", optarg);
360                         break;
361                 case 'v':
362                         vflag = 1;
363                         break;
364                 case 'x':
365                         if ((cylspares = atoi(optarg)) < 0)
366                                 fatal("%s: bad spare sectors per cylinder",
367                                     optarg);
368                         break;
369                 case '?':
370                 default:
371                         usage();
372                 }
373         argc -= optind;
374         argv += optind;
375
376         if (argc != 2 && (mfs || argc != 1))
377                 usage();
378
379         special = argv[0];
380         /* Copy the NetBSD way of faking up a disk label */
381         if (mfs && !strcmp(special, "swap")) {
382                 /* 
383                  * it's an MFS, mounted on "swap."  fake up a label.
384                  * XXX XXX XXX
385                  */
386                 fso = -1;       /* XXX; normally done below. */
387  
388                 memset(&mfsfakelabel, 0, sizeof(mfsfakelabel));
389                 mfsfakelabel.d_secsize = 512;
390                 mfsfakelabel.d_nsectors = 64;
391                 mfsfakelabel.d_ntracks = 16;
392                 mfsfakelabel.d_ncylinders = 16; 
393                 mfsfakelabel.d_secpercyl = 1024;
394                 mfsfakelabel.d_secperunit = 16384;
395                 mfsfakelabel.d_rpm = 3600;
396                 mfsfakelabel.d_interleave = 1;
397                 mfsfakelabel.d_npartitions = 1;
398                 mfsfakelabel.d_partitions[0].p_size = 16384;
399                 mfsfakelabel.d_partitions[0].p_fsize = 1024;
400                 mfsfakelabel.d_partitions[0].p_frag = 8;
401                 mfsfakelabel.d_partitions[0].p_cpg = 16;
402
403                 lp = &mfsfakelabel;
404                 pp = &mfsfakelabel.d_partitions[0];
405
406                 goto havelabel;
407         }
408
409         cp = strrchr(special, '/');
410         if (cp == 0) {
411                 /*
412                  * No path prefix; try /dev/%s.
413                  */
414                 (void)snprintf(device, sizeof(device), "%s%s", _PATH_DEV, special);
415                 special = device;
416         }
417         if (Nflag) {
418                 fso = -1;
419         } else {
420                 fso = open(special, O_WRONLY);
421                 if (fso < 0)
422                         fatal("%s: %s", special, strerror(errno));
423
424                 /* Bail if target special is mounted */
425                 n = getmntinfo(&mp, MNT_NOWAIT);
426                 if (n == 0)
427                         fatal("%s: getmntinfo: %s", special, strerror(errno));
428
429                 len = sizeof(_PATH_DEV) - 1;
430                 s1 = special;
431                 if (strncmp(_PATH_DEV, s1, len) == 0)
432                         s1 += len;
433
434                 while (--n >= 0) {
435                         s2 = mp->f_mntfromname;
436                         if (strncmp(_PATH_DEV, s2, len) == 0) {
437                                 s2 += len - 1;
438                                 *s2 = 'r';
439                         }
440                         if (strcmp(s1, s2) == 0 || strcmp(s1, &s2[1]) == 0)
441                                 fatal("%s is mounted on %s",
442                                     special, mp->f_mntonname);
443                         ++mp;
444                 }
445         }
446         if (mfs && disktype != NULL) {
447                 lp = (struct disklabel *)getdiskbyname(disktype);
448                 if (lp == NULL)
449                         fatal("%s: unknown disk type", disktype);
450                 pp = &lp->d_partitions[1];
451         } else {
452                 fsi = open(special, O_RDONLY);
453                 if (fsi < 0)
454                         fatal("%s: %s", special, strerror(errno));
455                 if (fstat(fsi, &st) < 0)
456                         fatal("%s: %s", special, strerror(errno));
457                 if ((st.st_mode & S_IFMT) != S_IFCHR && !mfs)
458                         printf("%s: %s: not a character-special device\n",
459                             progname, special);
460                 cp = strchr(argv[0], '\0');
461                 if (cp == argv[0])
462                         fatal("null special file name");
463                 cp--;
464                 if (!vflag && (*cp < 'a' || *cp >= 'a' + MAXPARTITIONS) && !isdigit(*cp)) {
465                         fatal("%s: can't figure out file system partition",
466                             argv[0]);
467                 }
468 #ifdef COMPAT
469                 if (!mfs && disktype == NULL)
470                         disktype = argv[1];
471 #endif
472                 lp = getdisklabel(special, fsi);
473                 if (vflag || isdigit(*cp))
474                         pp = &lp->d_partitions[0];
475                 else
476                         pp = &lp->d_partitions[*cp - 'a'];
477                 if (pp->p_size == 0)
478                         fatal("%s: `%c' partition is unavailable",
479                             argv[0], *cp);
480                 if (pp->p_fstype == FS_BOOT)
481                         fatal("%s: `%c' partition overlaps boot program",
482                               argv[0], *cp);
483         }
484 havelabel:
485         if (fssize == 0)
486                 fssize = pp->p_size;
487         if (fssize > pp->p_size && !mfs)
488                fatal("%s: maximum file system size on the `%c' partition is %d",
489                         argv[0], *cp, pp->p_size);
490         if (rpm == 0) {
491                 rpm = lp->d_rpm;
492                 if (rpm <= 0)
493                         rpm = 3600;
494         }
495         if (ntracks == 0) {
496                 ntracks = lp->d_ntracks;
497                 if (ntracks <= 0)
498                         fatal("%s: no default #tracks", argv[0]);
499         }
500         if (nsectors == 0) {
501                 nsectors = lp->d_nsectors;
502                 if (nsectors <= 0)
503                         fatal("%s: no default #sectors/track", argv[0]);
504         }
505         if (sectorsize == 0) {
506                 sectorsize = lp->d_secsize;
507                 if (sectorsize <= 0)
508                         fatal("%s: no default sector size", argv[0]);
509         }
510         if (trackskew == -1) {
511                 trackskew = lp->d_trackskew;
512                 if (trackskew < 0)
513                         trackskew = 0;
514         }
515         if (interleave == 0) {
516                 interleave = lp->d_interleave;
517                 if (interleave <= 0)
518                         interleave = 1;
519         }
520         if (fsize == 0) {
521                 fsize = pp->p_fsize;
522                 if (fsize <= 0)
523                         fsize = MAX(DFL_FRAGSIZE, lp->d_secsize);
524         }
525         if (bsize == 0) {
526                 bsize = pp->p_frag * pp->p_fsize;
527                 if (bsize <= 0)
528                         bsize = MIN(DFL_BLKSIZE, 8 * fsize);
529         }
530         /*
531          * Maxcontig sets the default for the maximum number of blocks
532          * that may be allocated sequentially. With filesystem clustering
533          * it is possible to allocate contiguous blocks up to the maximum
534          * transfer size permitted by the controller or buffering.
535          */
536         if (maxcontig == 0)
537                 maxcontig = MAX(1, MAXPHYS / bsize - 1);
538         if (density == 0)
539                 density = NFPI * fsize;
540         if (minfree < MINFREE && opt != FS_OPTSPACE) {
541                 fprintf(stderr, "Warning: changing optimization to space ");
542                 fprintf(stderr, "because minfree is less than %d%%\n", MINFREE);
543                 opt = FS_OPTSPACE;
544         }
545         if (trackspares == -1) {
546                 trackspares = lp->d_sparespertrack;
547                 if (trackspares < 0)
548                         trackspares = 0;
549         }
550         nphyssectors = nsectors + trackspares;
551         if (cylspares == -1) {
552                 cylspares = lp->d_sparespercyl;
553                 if (cylspares < 0)
554                         cylspares = 0;
555         }
556         secpercyl = nsectors * ntracks - cylspares;
557         /*
558          * Only complain if -t or -u have been specified; the default
559          * case (4096 sectors per cylinder) is intended to disagree
560          * with the disklabel.
561          */
562         if (t_or_u_flag && secpercyl != lp->d_secpercyl)
563                 fprintf(stderr, "%s (%d) %s (%lu)\n",
564                         "Warning: calculated sectors per cylinder", secpercyl,
565                         "disagrees with disk label", (u_long)lp->d_secpercyl);
566         if (maxbpg == 0)
567                 maxbpg = MAXBLKPG(bsize);
568         headswitch = lp->d_headswitch;
569         trackseek = lp->d_trkseek;
570 #ifdef notdef /* label may be 0 if faked up by kernel */
571         bbsize = lp->d_bbsize;
572         sbsize = lp->d_sbsize;
573 #endif
574         oldpartition = *pp;
575 #ifdef tahoe
576         realsectorsize = sectorsize;
577         if (sectorsize != DEV_BSIZE) {          /* XXX */
578                 int secperblk = DEV_BSIZE / sectorsize;
579
580                 sectorsize = DEV_BSIZE;
581                 nsectors /= secperblk;
582                 nphyssectors /= secperblk;
583                 secpercyl /= secperblk;
584                 fssize /= secperblk;
585                 pp->p_size /= secperblk;
586         }
587 #else
588         realsectorsize = sectorsize;
589         if (sectorsize != DEV_BSIZE) {          /* XXX */
590                 int secperblk = sectorsize / DEV_BSIZE;
591
592                 sectorsize = DEV_BSIZE;
593                 nsectors *= secperblk;
594                 nphyssectors *= secperblk;
595                 secpercyl *= secperblk;
596                 fssize *= secperblk;
597                 pp->p_size *= secperblk;
598         }
599 #endif
600         if (mfs) {
601                 mfs_mtpt = argv[1];
602                 if (
603                     stat(mfs_mtpt, &mfs_mtstat) < 0 ||
604                     !S_ISDIR(mfs_mtstat.st_mode)
605                 ) {
606                         fatal("mount point not dir: %s", mfs_mtpt);
607                 }
608         }
609         mkfs(pp, special, fsi, fso, (Cflag && mfs) ? argv[1] : NULL);
610 #ifdef tahoe
611         if (realsectorsize != DEV_BSIZE)
612                 pp->p_size *= DEV_BSIZE / realsectorsize;
613 #else
614         if (realsectorsize != DEV_BSIZE)
615                 pp->p_size /= realsectorsize /DEV_BSIZE;
616 #endif
617         if (!Nflag && bcmp(pp, &oldpartition, sizeof(oldpartition)))
618                 rewritelabel(special, fso, lp);
619         if (!Nflag)
620                 close(fso);
621         close(fsi);
622 #ifdef MFS
623         if (mfs) {
624                 struct mfs_args args;
625
626                 snprintf(buf, sizeof(buf), "mfs:%d", getpid());
627                 args.fspec = buf;
628                 args.export.ex_root = -2;
629                 if (mntflags & MNT_RDONLY)
630                         args.export.ex_flags = MNT_EXRDONLY;
631                 else
632                         args.export.ex_flags = 0;
633                 args.base = membase;
634                 args.size = fssize * sectorsize;
635
636                 error = getvfsbyname("mfs", &vfc);
637                 if (error && vfsisloadable("mfs")) {
638                         if (vfsload("mfs"))
639                                 fatal("vfsload(mfs)");
640                         endvfsent();    /* flush cache */
641                         error = getvfsbyname("mfs", &vfc);
642                 }
643                 if (error)
644                         fatal("mfs filesystem not available");
645
646                 if (mount(vfc.vfc_name, argv[1], mntflags, &args) < 0)
647                         fatal("%s: %s", argv[1], strerror(errno));
648                 if (filename) {
649                         munmap(membase,fssize * sectorsize);
650                 }
651         }
652 #endif
653         exit(0);
654 }
655
656 #ifdef COMPAT
657 char lmsg[] = "%s: can't read disk label; disk type must be specified";
658 #else
659 char lmsg[] = "%s: can't read disk label";
660 #endif
661
662 struct disklabel *
663 getdisklabel(char *s, int fd)
664 {
665         static struct disklabel lab;
666
667         if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
668 #ifdef COMPAT
669                 if (disktype) {
670                         struct disklabel *lp, *getdiskbyname();
671
672                         unlabeled++;
673                         lp = getdiskbyname(disktype);
674                         if (lp == NULL)
675                                 fatal("%s: unknown disk type", disktype);
676                         return (lp);
677                 }
678 #endif
679                 warn("ioctl (GDINFO)");
680                 fatal(lmsg, s);
681         }
682         return (&lab);
683 }
684
685 static void
686 rewritelabel(char *s, int fd, struct disklabel *lp)
687 {
688 #ifdef COMPAT
689         if (unlabeled)
690                 return;
691 #endif
692         lp->d_checksum = 0;
693         lp->d_checksum = dkcksum(lp);
694         if (ioctl(fd, DIOCWDINFO, (char *)lp) < 0) {
695                 warn("ioctl (WDINFO)");
696                 fatal("%s: can't rewrite disk label", s);
697         }
698 }
699
700 /*VARARGS*/
701 void
702 fatal(const char *fmt, ...)
703 {
704         va_list ap;
705
706         va_start(ap, fmt);
707         if (fcntl(STDERR_FILENO, F_GETFL) < 0) {
708                 openlog(progname, LOG_CONS, LOG_DAEMON);
709                 vsyslog(LOG_ERR, fmt, ap);
710                 closelog();
711         } else {
712                 vwarnx(fmt, ap);
713         }
714         va_end(ap);
715         exit(1);
716         /*NOTREACHED*/
717 }
718
719 static void
720 usage(void)
721 {
722         if (mfs) {
723                 fprintf(stderr,
724                     "usage: %s [ -fsoptions ] special-device mount-point\n",
725                         progname);
726         } else
727                 fprintf(stderr,
728                     "usage: %s [ -fsoptions ] special-device%s\n",
729                     progname,
730 #ifdef COMPAT
731                     " [device-type]");
732 #else
733                     "");
734 #endif
735         fprintf(stderr, "where fsoptions are:\n");
736         fprintf(stderr,
737             "\t-N do not create file system, just print out parameters\n");
738         fprintf(stderr, "\t-O create a 4.3BSD format filesystem\n");
739         fprintf(stderr, "\t-S sector size\n");
740 #ifdef COMPAT
741         fprintf(stderr, "\t-T disktype\n");
742 #endif
743         fprintf(stderr, "\t-U enable soft updates\n");
744         fprintf(stderr, "\t-a maximum contiguous blocks\n");
745         fprintf(stderr, "\t-b block size\n");
746         fprintf(stderr, "\t-c cylinders/group\n");
747         fprintf(stderr, "\t-d rotational delay between contiguous blocks\n");
748         fprintf(stderr, "\t-e maximum blocks per file in a cylinder group\n");
749         fprintf(stderr, "\t-f frag size\n");
750         fprintf(stderr, "\t-g average file size\n");
751         fprintf(stderr, "\t-h average files per directory\n");
752         fprintf(stderr, "\t-i number of bytes per inode\n");
753         fprintf(stderr, "\t-k sector 0 skew, per track\n");
754         fprintf(stderr, "\t-l hardware sector interleave\n");
755         fprintf(stderr, "\t-m minimum free space %%\n");
756         fprintf(stderr, "\t-n number of distinguished rotational positions\n");
757         fprintf(stderr, "\t-o optimization preference (`space' or `time')\n");
758         fprintf(stderr, "\t-p spare sectors per track\n");
759         fprintf(stderr, "\t-s file system size (sectors)\n");
760         fprintf(stderr, "\t-r revolutions/minute\n");
761         fprintf(stderr, "\t-t tracks/cylinder\n");
762         fprintf(stderr, "\t-u sectors/track\n");
763         fprintf(stderr,
764         "\t-v do not attempt to determine partition name from device name\n");
765         fprintf(stderr, "\t-x spare sectors per cylinder\n");
766         exit(1);
767 }