dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / fs.d / ufs / mkfs / mkfs.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*
 * The maximum supported file system size (in sectors) is the
 * number of frags that can be represented in an int32_t field
 * (INT_MAX) times the maximum number of sectors per frag.  Since
 * the maximum frag size is MAXBSIZE, the maximum number of sectors
 * per frag is MAXBSIZE/DEV_BSIZE.
 */
#define FS_MAX  (((diskaddr_t)INT_MAX) * (MAXBSIZE/DEV_BSIZE))

/*
 * make file system for cylinder-group style file systems
 *
 * usage:
 *
 *    mkfs [-F FSType] [-V] [-G [-P]] [-M dirname] [-m] [options]
 *      [-o specific_options]  special size
 *      [nsect ntrack bsize fsize cpg   minfree rps nbpi opt apc rotdelay
 *        2     3      4     5     6    7       8   9    10  11  12
 *      nrpos maxcontig mtb]
 *      13    14        15
 *
 *  where specific_options are:
 *      N - no create
 *      nsect - The number of sectors per track
 *      ntrack - The number of tracks per cylinder
 *      bsize - block size
 *      fragsize - fragment size
 *      cgsize - The number of disk cylinders per cylinder group.
 *      free - minimum free space
 *      rps - rotational speed (rev/sec).
 *      nbpi - number of data bytes per allocated inode
 *      opt - optimization (space, time)
 *      apc - number of alternates
 *      gap - gap size
 *      nrpos - number of rotational positions
 *      maxcontig - maximum number of logical blocks that will be
 *              allocated contiguously before inserting rotational delay
 *      mtb - if "y", set up file system for eventual growth to over a
 *              a terabyte
 * -P Do not grow the file system, but print on stdout the maximal
 *    size in sectors to which the file system can be increased. The calculated
 *    size is limited by the value provided by the operand size.
 *
 * Note that -P is a project-private interface and together with -G intended
 * to be used only by the growfs script. It is therefore purposely not
 * documented in the man page.
 * The -P option is covered by PSARC case 2003/422.
 */

/*
 * The following constants set the defaults used for the number
 * of sectors/track (fs_nsect), and number of tracks/cyl (fs_ntrak).
 *
 *                      NSECT           NTRAK
 *      72MB CDC        18              9
 *      30MB CDC        18              5
 *      720KB Diskette  9               2
 *
 * However the defaults will be different for disks larger than CHSLIMIT.
 */

#define DFLNSECT        32
#define DFLNTRAK        16

/*
 * The following default sectors and tracks values are used for
 * non-efi disks that are larger than the CHS addressing limit. The
 * existing default cpg of 16 (DESCPG) holds good for larger disks too.
 */
#define DEF_SECTORS_EFI 128
#define DEF_TRACKS_EFI  48

/*
 * The maximum number of cylinders in a group depends upon how much
 * information can be stored on a single cylinder. The default is to
 * use 16 cylinders per group.  This is effectively tradition - it was
 * the largest value acceptable under SunOs 4.1
 */
#define DESCPG          16      /* desired fs_cpg */

/*
 * The following two constants set the default block and fragment sizes.
 * Both constants must be a power of 2 and meet the following constraints:
 *      MINBSIZE <= DESBLKSIZE <= MAXBSIZE
 *      DEV_BSIZE <= DESFRAGSIZE <= DESBLKSIZE
 *      DESBLKSIZE / DESFRAGSIZE <= 8
 */
#define DESBLKSIZE      8192
#define DESFRAGSIZE     1024

/*
 * MINFREE gives the minimum acceptable percentage of file system
 * blocks which may be free. If the freelist drops below this level
 * only the superuser may continue to allocate blocks. This may
 * be set to 0 if no reserve of free blocks is deemed necessary,
 * however throughput drops by fifty percent if the file system
 * is run at between 90% and 100% full; thus the default value of
 * fs_minfree is 10%. With 10% free space, fragmentation is not a
 * problem, so we choose to optimize for time.
 */
#define MINFREE         10
#define DEFAULTOPT      FS_OPTTIME

/*
 * ROTDELAY gives the minimum number of milliseconds to initiate
 * another disk transfer on the same cylinder. It is no longer used
 * and will always default to 0.
 */
#define ROTDELAY        0

/*
 * MAXBLKPG determines the maximum number of data blocks which are
 * placed in a single cylinder group. The default is one indirect
 * block worth of data blocks.
 */
#define MAXBLKPG(bsize) ((bsize) / sizeof (daddr32_t))

/*
 * Each file system has a number of inodes statically allocated.
 * We allocate one inode slot per NBPI bytes, expecting this
 * to be far more than we will ever need.
 */
#define NBPI            2048    /* Number Bytes Per Inode */
#define MTB_NBPI        (MB)    /* Number Bytes Per Inode for multi-terabyte */

/*
 * Disks are assumed to rotate at 60HZ, unless otherwise specified.
 */
#define DEFHZ           60

/*
 * Cylinder group related limits.
 *
 * For each cylinder we keep track of the availability of blocks at different
 * rotational positions, so that we can lay out the data to be picked
 * up with minimum rotational latency.  NRPOS is the number of rotational
 * positions which we distinguish.  With NRPOS 8 the resolution of our
 * summary information is 2ms for a typical 3600 rpm drive.
 */
#define NRPOS           8       /* number distinct rotational positions */

#ifdef DEBUG
#define dprintf(x)      printf x
#else
#define dprintf(x)
#endif

/*
 * For the -N option, when calculating the backup superblocks, do not print
 * them if we are not really sure. We may have to try an alternate method of
 * arriving at the superblocks. So defer printing till a handful of superblocks
 * look good.
 */
#define tprintf(x)      if (Nflag && retry) \
                                (void) strncat(tmpbuf, x, strlen(x)); \
                        else \
                                (void) fprintf(stderr, x);

#define ALTSB           32      /* Location of first backup superblock */

/*
 * range_check "user_supplied" flag values.
 */
#define RC_DEFAULT      0
#define RC_KEYWORD      1
#define RC_POSITIONAL   2

/*
 * ufs hole
 */
#define UFS_HOLE        -1

#ifndef STANDALONE
#include        <stdio.h>
#include        <sys/mnttab.h>
#endif

#include        <stdlib.h>
#include        <unistd.h>
#include        <malloc.h>
#include        <string.h>
#include        <strings.h>
#include        <ctype.h>
#include        <errno.h>
#include        <sys/param.h>
#include        <time.h>
#include        <sys/types.h>
#include        <sys/sysmacros.h>
#include        <sys/vnode.h>
#include        <sys/fs/ufs_fsdir.h>
#include        <sys/fs/ufs_inode.h>
#include        <sys/fs/ufs_fs.h>
#include        <sys/fs/ufs_log.h>
#include        <sys/mntent.h>
#include        <sys/filio.h>
#include        <limits.h>
#include        <sys/int_const.h>
#include        <signal.h>
#include        <sys/efi_partition.h>
#include        "roll_log.h"

#define bcopy(f, t, n)    (void) memcpy(t, f, n)
#define bzero(s, n)     (void) memset(s, 0, n)
#define bcmp(s, d, n)   memcmp(s, d, n)

#define index(s, r)     strchr(s, r)
#define rindex(s, r)    strrchr(s, r)

#include        <sys/stat.h>
#include        <sys/statvfs.h>
#include        <locale.h>
#include        <fcntl.h>
#include        <sys/isa_defs.h>        /* for ENDIAN defines */
#include        <sys/vtoc.h>

#include        <sys/dkio.h>
#include        <sys/asynch.h>

extern offset_t llseek();
extern char     *getfullblkname();
extern long     lrand48();

extern int      optind;
extern char     *optarg;


/*
 * The size of a cylinder group is calculated by CGSIZE. The maximum size
 * is limited by the fact that cylinder groups are at most one block.
 * Its size is derived from the size of the maps maintained in the
 * cylinder group and the (struct cg) size.
 */
#define CGSIZE(fs) \
        /* base cg              */ (sizeof (struct cg) + \
        /* blktot size  */ (fs)->fs_cpg * sizeof (long) + \
        /* blks size    */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof (short) + \
        /* inode map    */ howmany((fs)->fs_ipg, NBBY) + \
        /* block map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY))

/*
 * We limit the size of the inode map to be no more than a
 * third of the cylinder group space, since we must leave at
 * least an equal amount of space for the block map.
 *
 * N.B.: MAXIpG must be a multiple of INOPB(fs).
 */
#define MAXIpG(fs)      roundup((fs)->fs_bsize * NBBY / 3, INOPB(fs))

/*
 * Same as MAXIpG, but parameterized by the block size (b) and the
 * cylinder group divisor (d), which is the reciprocal of the fraction of the
 * cylinder group overhead block that is used for the inode map.  So for
 * example, if d = 5, the macro's computation assumes that 1/5 of the
 * cylinder group overhead block can be dedicated to the inode map.
 */
#define MAXIpG_B(b, d)  roundup((b) * NBBY / (d), (b) / sizeof (struct dinode))

#define UMASK           0755
#define MAXINOPB        (MAXBSIZE / sizeof (struct dinode))
#define POWEROF2(num)   (((num) & ((num) - 1)) == 0)
#define MB              (1024*1024)
#define BETWEEN(x, l, h)        ((x) >= (l) && (x) <= (h))

/*
 * Used to set the inode generation number. Since both inodes and dinodes
 * are dealt with, we really need a pointer to an icommon here.
 */
#define IRANDOMIZE(icp) (icp)->ic_gen = lrand48();

/*
 * Flags for number()
 */
#define ALLOW_PERCENT   0x01    /* allow trailing `%' on number */
#define ALLOW_MS1       0x02    /* allow trailing `ms', state 1 */
#define ALLOW_MS2       0x04    /* allow trailing `ms', state 2 */
#define ALLOW_END_ONLY  0x08    /* must be at end of number & suffixes */

#define MAXAIO  1000    /* maximum number of outstanding I/O's we'll manage */
#define BLOCK   1       /* block in aiowait */
#define NOBLOCK 0       /* don't block in aiowait */

#define RELEASE 1       /* free an aio buffer after use */
#define SAVE    0       /* don't free the buffer */

typedef struct aio_trans {
        aio_result_t resultbuf;
        diskaddr_t bno;
        char *buffer;
        int size;
        int release;
        struct aio_trans *next;
} aio_trans;

typedef struct aio_results {
        int max;
        int outstanding;
        int maxpend;
        aio_trans *trans;
} aio_results;

int aio_inited = 0;
aio_results results;

/*
 * Allow up to MAXBUF aio requests that each have a unique buffer.
 * More aio's might be done, but not using memory through the getbuf()
 * interface.  This can be raised, but you run into the potential of
 * using more memory than is physically available on the machine,
 * and if you start swapping, you can forget about performance.
 * To prevent this, we also limit the total memory used for a given
 * type of buffer to MAXBUFMEM.
 *
 * Tests indicate a cylinder group's worth of inodes takes:
 *
 *      NBPI    Size of Inode Buffer
 *       2k     1688k
 *       8k      424k
 *
 * initcg() stores all the inodes for a cylinder group in one buffer,
 * so allowing 20 buffers could take 32 MB if not limited by MAXBUFMEM.
 */
#define MAXBUF          20
#define MAXBUFMEM       (8 * 1024 * 1024)

/*
 * header information for buffers managed by getbuf() and freebuf()
 */
typedef struct bufhdr {
        struct bufhdr *head;
        struct bufhdr *next;
} bufhdr;

int bufhdrsize;

bufhdr inodebuf = { NULL, NULL };
bufhdr cgsumbuf = { NULL, NULL };

#define SECTORS_PER_TERABYTE    (1LL << 31)
/*
 * The following constant specifies an upper limit for file system size
 * that is actually a lot bigger than we expect to support with UFS. (Since
 * it's specified in sectors, the file system size would be 2**44 * 512,
 * which is 2**53, which is 8192 Terabytes.)  However, it's useful
 * for checking the basic sanity of a size value that is input on the
 * command line.
 */
#define FS_SIZE_UPPER_LIMIT     0x100000000000LL

/*
 * Forward declarations
 */
static char *getbuf(bufhdr *bufhead, int size);
static void freebuf(char *buf);
static void freetrans(aio_trans *transp);
static aio_trans *get_aiop();
static aio_trans *wait_for_write(int block);
static void initcg(int cylno);
static void fsinit();
static int makedir(struct direct *protodir, int entries);
static void iput(struct inode *ip);
static void rdfs(diskaddr_t bno, int size, char *bf);
static void wtfs(diskaddr_t bno, int size, char *bf);
static void awtfs(diskaddr_t bno, int size, char *bf, int release);
static void wtfs_breakup(diskaddr_t bno, int size, char *bf);
static int isblock(struct fs *fs, unsigned char *cp, int h);
static void clrblock(struct fs *fs, unsigned char *cp, int h);
static void setblock(struct fs *fs, unsigned char *cp, int h);
static void usage();
static void dump_fscmd(char *fsys, int fsi);
static uint64_t number(uint64_t d_value, char *param, int flags);
static int match(char *s);
static char checkopt(char *optim);
static char checkmtb(char *mtbarg);
static void range_check(long *varp, char *name, long minimum,
    long maximum, long def_val, int user_supplied);
static void range_check_64(uint64_t *varp, char *name, uint64_t minimum,
    uint64_t maximum, uint64_t def_val, int user_supplied);
static daddr32_t alloc(int size, int mode);
static diskaddr_t get_max_size(int fd);
static long get_max_track_size(int fd);
static void block_sigint(sigset_t *old_mask);
static void unblock_sigint(sigset_t *old_mask);
static void recover_from_sigint(int signum);
static int confirm_abort(void);
static int getaline(FILE *fp, char *loc, int maxlen);
static void flush_writes(void);
static long compute_maxcpg(long, long, long, long, long);
static int in_64bit_mode(void);
static int validate_size(int fd, diskaddr_t size);
static void dump_sblock(void);

/*
 * Workaround for mkfs to function properly on disks attached to XMIT 2.X
 * controller. If the address is not aligned at 8 byte boundary, mkfs on
 * disks attached to XMIT 2.X controller exhibts un-predictable behaviour.
 */
#define XMIT_2_X_ALIGN  8
#pragma align XMIT_2_X_ALIGN(fsun, altfsun, cgun)

union {
        struct fs fs;
        char pad[SBSIZE];
} fsun, altfsun;
#define sblock  fsun.fs
#define altsblock       altfsun.fs

struct  csum *fscs;

union cgun {
        struct cg cg;
        char pad[MAXBSIZE];
} cgun;

#define acg     cgun.cg
/*
 * Size of screen in cols in which to fit output
 */
#define WIDTH   80

struct dinode zino[MAXBSIZE / sizeof (struct dinode)];

/*
 * file descriptors used for rdfs(fsi) and wtfs(fso).
 * Initialized to an illegal file descriptor number.
 */
int     fsi = -1;
int     fso = -1;

/*
 * The BIG parameter is machine dependent.  It should be a longlong integer
 * constant that can be used by the number parser to check the validity
 * of numeric parameters.
 */

#define BIG             0x7fffffffffffffffLL

/* Used to indicate to number() that a bogus value should cause us to exit */
#define NO_DEFAULT      LONG_MIN

/*
 * INVALIDSBLIMIT is the number of bad backup superblocks that will be
 * tolerated before we decide to try arriving at a different set of them
 * using a different logic. This is applicable for non-EFI disks only.
 */
#define INVALIDSBLIMIT  10

/*
 * The *_flag variables are used to indicate that the user specified
 * the values, rather than that we made them up ourselves.  We can
 * complain about the user giving us bogus values.
 */

/* semi-constants */
long    sectorsize = DEV_BSIZE;         /* bytes/sector from param.h */
long    bbsize = BBSIZE;                /* boot block size */
long    sbsize = SBSIZE;                /* superblock size */

/* parameters */
diskaddr_t      fssize_db;              /* file system size in disk blocks */
diskaddr_t      fssize_frag;            /* file system size in frags */
long    cpg;                            /* cylinders/cylinder group */
int     cpg_flag = RC_DEFAULT;
long    rotdelay = -1;                  /* rotational delay between blocks */
int     rotdelay_flag = RC_DEFAULT;
long    maxcontig;                      /* max contiguous blocks to allocate */
int     maxcontig_flag = RC_DEFAULT;
long    nsect = DFLNSECT;               /* sectors per track */
int     nsect_flag = RC_DEFAULT;
long    ntrack = DFLNTRAK;              /* tracks per cylinder group */
int     ntrack_flag = RC_DEFAULT;
long    bsize = DESBLKSIZE;             /* filesystem block size */
int     bsize_flag = RC_DEFAULT;
long    fragsize = DESFRAGSIZE;         /* filesystem fragment size */
int     fragsize_flag = RC_DEFAULT;
long    minfree = MINFREE;              /* fs_minfree */
int     minfree_flag = RC_DEFAULT;
long    rps = DEFHZ;                    /* revolutions/second of drive */
int     rps_flag = RC_DEFAULT;
long    nbpi = NBPI;                    /* number of bytes per inode */
int     nbpi_flag = RC_DEFAULT;
long    nrpos = NRPOS;                  /* number of rotational positions */
int     nrpos_flag = RC_DEFAULT;
long    apc = 0;                        /* alternate sectors per cylinder */
int     apc_flag = RC_DEFAULT;
char    opt = 't';                      /* optimization style, `t' or `s' */
char    mtb = 'n';                      /* multi-terabyte format, 'y' or 'n' */
#define DEFAULT_SECT_TRAK_CPG   (nsect_flag == RC_DEFAULT && \
                                ntrack_flag == RC_DEFAULT && \
                                cpg_flag == RC_DEFAULT)

long    debug = 0;                      /* enable debugging output */

int     spc_flag = 0;                   /* alternate sectors specified or */
                                        /* found */

/* global state */
int     Nflag;          /* do not write to disk */
int     mflag;          /* return the command line used to create this FS */
int     rflag;          /* report the superblock in an easily-parsed form */
int     Rflag;          /* dump the superblock in binary */
char    *fsys;
time_t  mkfstime;
char    *string;
int     label_type;

/*
 * logging support
 */
int     islog;                  /* true if ufs logging is enabled */
int     islogok;                /* true if ufs log state is good */
int     waslog;                 /* true when ufs logging disabled during grow */

/*
 * growfs defines, globals, and forward references
 */
#define NOTENOUGHSPACE 33
int             grow;
#define GROW_WITH_DEFAULT_TRAK  (grow && ntrack_flag == RC_DEFAULT)

static int      Pflag;          /* probe to which size the fs can be grown */
int             ismounted;
char            *directory;
diskaddr_t      grow_fssize;
long            grow_fs_size;
long            grow_fs_ncg;
diskaddr_t              grow_fs_csaddr;
long            grow_fs_cssize;
int             grow_fs_clean;
struct csum     *grow_fscs;
diskaddr_t              grow_sifrag;
int             test;
int             testforce;
diskaddr_t              testfrags;
int             inlockexit;
int             isbad;

void            lockexit(int);
void            randomgeneration(void);
void            checksummarysize(void);
int             checksblock(struct fs, int);
void            growinit(char *);
void            checkdev(char *, char  *);
void            checkmount(struct mnttab *, char *);
struct dinode   *gdinode(ino_t);
int             csfraginrange(daddr32_t);
struct csfrag   *findcsfrag(daddr32_t, struct csfrag **);
void            checkindirect(ino_t, daddr32_t *, daddr32_t, int);
void            addcsfrag(ino_t, daddr32_t, struct csfrag **);
void            delcsfrag(daddr32_t, struct csfrag **);
void            checkdirect(ino_t, daddr32_t *, daddr32_t *, int);
void            findcsfragino(void);
void            fixindirect(daddr32_t, int);
void            fixdirect(caddr_t, daddr32_t, daddr32_t *, int);
void            fixcsfragino(void);
void            extendsummaryinfo(void);
int             notenoughspace(void);
void            unalloccsfragino(void);
void            unalloccsfragfree(void);
void            findcsfragfree(void);
void            copycsfragino(void);
void            rdcg(long);
void            wtcg(void);
void            flcg(void);
void            allocfrags(long, daddr32_t *, long *);
void            alloccsfragino(void);
void            alloccsfragfree(void);
void            freefrags(daddr32_t, long, long);
int             findfreerange(long *, long *);
void            resetallocinfo(void);
void            extendcg(long);
void            ulockfs(void);
void            wlockfs(void);
void            clockfs(void);
void            wtsb(void);
static int64_t  checkfragallocated(daddr32_t);
static struct csum      *read_summaryinfo(struct fs *);
static diskaddr_t       probe_summaryinfo();

int
main(int argc, char *argv[])
{
        long i, mincpc, mincpg, ibpcl;
        long cylno, rpos, blk, j, warn = 0;
        long mincpgcnt, maxcpg;
        uint64_t used, bpcg, inospercg;
        long mapcramped, inodecramped;
        long postblsize, rotblsize, totalsbsize;
        FILE *mnttab;
        struct mnttab mntp;
        char *special;
        struct statvfs64 fs;
        struct dk_geom dkg;
        struct dk_minfo dkminfo;
        char pbuf[sizeof (uint64_t) * 3 + 1];
        char *tmpbuf;
        int width, plen;
        uint64_t num;
        int c, saverr;
        diskaddr_t max_fssize;
        long tmpmaxcontig = -1;
        struct sigaction sigact;
        uint64_t nbytes64;
        int remaining_cg;
        int do_dot = 0;
        int use_efi_dflts = 0, retry = 0, isremovable = 0, ishotpluggable = 0;
        int invalid_sb_cnt, ret, skip_this_sb, cg_too_small;
        int geom_nsect, geom_ntrack, geom_cpg;

        (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
        (void) textdomain(TEXT_DOMAIN);

        while ((c = getopt(argc, argv, "F:bmo:VPGM:T:t:")) != EOF) {
                switch (c) {

                case 'F':
                        string = optarg;
                        if (strcmp(string, "ufs") != 0)
                                usage();
                        break;

                case 'm':       /* return command line used to create this FS */
                        mflag++;
                        break;

                case 'o':
                        /*
                         * ufs specific options.
                         */
                        string = optarg;
                        while (*string != '\0') {
                                if (match("nsect=")) {
                                        nsect = number(DFLNSECT, "nsect", 0);
                                        nsect_flag = RC_KEYWORD;
                                } else if (match("ntrack=")) {
                                        ntrack = number(DFLNTRAK, "ntrack", 0);
                                        ntrack_flag = RC_KEYWORD;
                                } else if (match("bsize=")) {
                                        bsize = number(DESBLKSIZE, "bsize", 0);
                                        bsize_flag = RC_KEYWORD;
                                } else if (match("fragsize=")) {
                                        fragsize = number(DESFRAGSIZE,
                                            "fragsize", 0);
                                        fragsize_flag = RC_KEYWORD;
                                } else if (match("cgsize=")) {
                                        cpg = number(DESCPG, "cgsize", 0);
                                        cpg_flag = RC_KEYWORD;
                                } else if (match("free=")) {
                                        minfree = number(MINFREE, "free",
                                            ALLOW_PERCENT);
                                        minfree_flag = RC_KEYWORD;
                                } else if (match("maxcontig=")) {
                                        tmpmaxcontig =
                                            number(-1, "maxcontig", 0);
                                        maxcontig_flag = RC_KEYWORD;
                                } else if (match("nrpos=")) {
                                        nrpos = number(NRPOS, "nrpos", 0);
                                        nrpos_flag = RC_KEYWORD;
                                } else if (match("rps=")) {
                                        rps = number(DEFHZ, "rps", 0);
                                        rps_flag = RC_KEYWORD;
                                } else if (match("nbpi=")) {
                                        nbpi = number(NBPI, "nbpi", 0);
                                        nbpi_flag = RC_KEYWORD;
                                } else if (match("opt=")) {
                                        opt = checkopt(string);
                                } else if (match("mtb=")) {
                                        mtb = checkmtb(string);
                                } else if (match("apc=")) {
                                        apc = number(0, "apc", 0);
                                        apc_flag = RC_KEYWORD;
                                } else if (match("gap=")) {
                                        (void) number(0, "gap", ALLOW_MS1);
                                        rotdelay = ROTDELAY;
                                        rotdelay_flag = RC_DEFAULT;
                                } else if (match("debug=")) {
                                        debug = number(0, "debug", 0);
                                } else if (match("N")) {
                                        Nflag++;
                                } else if (match("calcsb")) {
                                        rflag++;
                                        Nflag++;
                                } else if (match("calcbinsb")) {
                                        rflag++;
                                        Rflag++;
                                        Nflag++;
                                } else if (*string == '\0') {
                                        break;
                                } else {
                                        (void) fprintf(stderr, gettext(
                                            "illegal option: %s\n"), string);
                                        usage();
                                }

                                if (*string == ',') string++;
                                if (*string == ' ') string++;
                        }
                        break;

                case 'V':
                        {
                                char    *opt_text;
                                int     opt_count;

                                (void) fprintf(stdout, gettext("mkfs -F ufs "));
                                for (opt_count = 1; opt_count < argc;
                                    opt_count++) {
                                        opt_text = argv[opt_count];
                                        if (opt_text)
                                                (void) fprintf(stdout, " %s ",
                                                    opt_text);
                                }
                                (void) fprintf(stdout, "\n");
                        }
                        break;

                case 'b':       /* do nothing for this */
                        break;

                case 'M':       /* grow the mounted file system */
                        directory = optarg;

                        /* FALLTHROUGH */
                case 'G':       /* grow the file system */
                        grow = 1;
                        break;
                case 'P':       /* probe the file system growing size   */
                        Pflag = 1;
                        grow = 1; /* probe mode implies fs growing      */
                        break;
                case 'T':       /* For testing */
                        testforce = 1;

                        /* FALLTHROUGH */
                case 't':
                        test = 1;
                        string = optarg;
                        testfrags = number(NO_DEFAULT, "testfrags", 0);
                        break;

                case '?':
                        usage();
                        break;
                }
        }
#ifdef MKFS_DEBUG
        /*
         * Turning on MKFS_DEBUG causes mkfs to produce a filesystem
         * that can be reproduced by setting the time to 0 and seeding
         * the random number generator to a constant.
         */
        mkfstime = 0;   /* reproducible results */
#else
        (void) time(&mkfstime);
#endif

        if (optind >= (argc - 1)) {
                if (optind > (argc - 1)) {
                        (void) fprintf(stderr,
                            gettext("special not specified\n"));
                        usage();
                } else if (mflag == 0) {
                        (void) fprintf(stderr,
                            gettext("size not specified\n"));
                        usage();
                }
        }
        argc -= optind;
        argv = &argv[optind];

        fsys = argv[0];
        fsi = open64(fsys, O_RDONLY);
        if (fsi < 0) {
                (void) fprintf(stderr, gettext("%s: cannot open\n"), fsys);
                lockexit(32);
        }

        if (mflag) {
                dump_fscmd(fsys, fsi);
                lockexit(0);
        }

        /*
         * The task of setting all of the configuration parameters for a
         * UFS file system is basically a matter of solving n equations
         * in m variables.  Typically, m is greater than n, so there is
         * usually more than one valid solution.  Since this is usually
         * an under-constrained problem, it's not always obvious what the
         * "best" configuration is.
         *
         * In general, the approach is to
         * 1. Determine the values for the file system parameters
         *    that are externally contrained and therefore not adjustable
         *    by mkfs (such as the device's size and maxtransfer size).
         * 2. Acquire the user's requested setting for all configuration
         *    values that can be set on the command line.
         * 3. Determine the final value of all configuration values, by
         *    the following approach:
         *      - set the file system block size (fs_bsize).  Although
         *        this could be regarded as an adjustable parameter, in
         *        fact, it's pretty much a constant.  At this time, it's
         *        generally set to 8k (with older hardware, it can
         *        sometimes make sense to set it to 4k, but those
         *        situations are pretty rare now).
         *      - re-adjust the maximum file system size based on the
         *        value of the file system block size.  Since the
         *        frag size can't be any larger than a file system
         *        block, and the number of frags in the file system
         *        has to fit into 31 bits, the file system block size
         *        affects the maximum file system size.
         *      - now that the real maximum file system is known, set the
         *        actual size of the file system to be created to
         *        MIN(requested size, maximum file system size).
         *      - now validate, and if necessary, adjust the following
         *        values:
         *              rotdelay
         *              nsect
         *              maxcontig
         *              apc
         *              frag_size
         *              rps
         *              minfree
         *              nrpos
         *              nrack
         *              nbpi
         *      - calculate maxcpg (the maximum value of the cylinders-per-
         *        cylinder-group configuration parameters).  There are two
         *        algorithms for calculating maxcpg:  an old one, which is
         *        used for file systems of less than 1 terabyte, and a
         *        new one, implemented in the function compute_maxcpg(),
         *        which is used for file systems of greater than 1 TB.
         *        The difference between them is that compute_maxcpg()
         *        really tries to maximize the cpg value.  The old
         *        algorithm fails to take advantage of smaller frags and
         *        lower inode density when determining the maximum cpg,
         *        and thus comes up with much lower numbers in some
         *        configurations.  At some point, we might use the
         *        new algorithm for determining maxcpg for all file
         *        systems, but at this time, the changes implemented for
         *        multi-terabyte UFS are NOT being automatically applied
         *        to UFS file systems of less than a terabyte (in the
         *        interest of not changing existing UFS policy too much
         *        until the ramifications of the changes are well-understood
         *        and have been evaluated for their effects on performance.)
         *      - check the current values of the configuration parameters
         *        against the various constraints imposed by UFS.  These
         *        include:
         *              * There must be at least one inode in each
         *                cylinder group.
         *              * The cylinder group overhead block, which
         *                contains the inode and frag bigmaps, must fit
         *                within one file system block.
         *              * The space required for inode maps should
         *                occupy no more than a third of the cylinder
         *                group overhead block.
         *              * The rotational position tables have to fit
         *                within the available space in the super block.
         *        Adjust the configuration values that can be adjusted
         *        so that these constraints are satisfied.  The
         *        configuration values that are adjustable are:
         *              * frag size
         *              * cylinders per group
         *              * inode density (can be increased)
         *              * number of rotational positions (the rotational
         *                position tables are eliminated altogether if
         *                there isn't enough room for them.)
         * 4. Set the values for all the dependent configuration
         *    values (those that aren't settable on the command
         *    line and which are completely dependent on the
         *    adjustable parameters).  This include cpc (cycles
         *    per cylinder, spc (sectors-per-cylinder), and many others.
         */

        /*
         * Figure out the partition size and initialize the label_type.
         */
        max_fssize = get_max_size(fsi);

        /*
         * Get and check positional arguments, if any.
         */
        switch (argc - 1) {
        default:
                usage();
                /*NOTREACHED*/
        case 15:
                mtb = checkmtb(argv[15]);
                /* FALLTHROUGH */
        case 14:
                string = argv[14];
                tmpmaxcontig = number(-1, "maxcontig", 0);
                maxcontig_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 13:
                string = argv[13];
                nrpos = number(NRPOS, "nrpos", 0);
                nrpos_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 12:
                string = argv[12];
                rotdelay = ROTDELAY;
                rotdelay_flag = RC_DEFAULT;
                /* FALLTHROUGH */
        case 11:
                string = argv[11];
                apc = number(0, "apc", 0);
                apc_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 10:
                opt = checkopt(argv[10]);
                /* FALLTHROUGH */
        case 9:
                string = argv[9];
                nbpi = number(NBPI, "nbpi", 0);
                nbpi_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 8:
                string = argv[8];
                rps = number(DEFHZ, "rps", 0);
                rps_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 7:
                string = argv[7];
                minfree = number(MINFREE, "free", ALLOW_PERCENT);
                minfree_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 6:
                string = argv[6];
                cpg = number(DESCPG, "cgsize", 0);
                cpg_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 5:
                string = argv[5];
                fragsize = number(DESFRAGSIZE, "fragsize", 0);
                fragsize_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 4:
                string = argv[4];
                bsize = number(DESBLKSIZE, "bsize", 0);
                bsize_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 3:
                string = argv[3];
                ntrack = number(DFLNTRAK, "ntrack", 0);
                ntrack_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 2:
                string = argv[2];
                nsect = number(DFLNSECT, "nsect", 0);
                nsect_flag = RC_POSITIONAL;
                /* FALLTHROUGH */
        case 1:
                string = argv[1];
                fssize_db = number(max_fssize, "size", 0);
        }

        /*
         * Initialize the parameters in the same way as newfs so that
         * newfs and mkfs would result in the same file system layout
         * for EFI labelled disks. Do this only in the absence of user
         * specified values for these parameters.
         */
        if (label_type == LABEL_TYPE_EFI) {
                if (apc_flag == RC_DEFAULT) apc = 0;
                if (nrpos_flag == RC_DEFAULT) nrpos = 1;
                if (ntrack_flag == RC_DEFAULT) ntrack = DEF_TRACKS_EFI;
                if (rps_flag == RC_DEFAULT) rps = DEFHZ;
                if (nsect_flag == RC_DEFAULT) nsect = DEF_SECTORS_EFI;
        }

        if ((maxcontig_flag == RC_DEFAULT) || (tmpmaxcontig == -1) ||
            (maxcontig == -1)) {
                long maxtrax = get_max_track_size(fsi);
                maxcontig = maxtrax / bsize;

        } else {
                maxcontig = tmpmaxcontig;
        }
        dprintf(("DeBuG maxcontig : %ld\n", maxcontig));

        if (rotdelay == -1) {   /* default by newfs and mkfs */
                rotdelay = ROTDELAY;
        }

        if (cpg_flag == RC_DEFAULT) { /* If not explicity set, use default */
                cpg = DESCPG;
        }
        dprintf(("DeBuG cpg : %ld\n", cpg));

        /*
         * Now that we have the semi-sane args, either positional, via -o,
         * or by defaulting, handle inter-dependencies and range checks.
         */

        /*
         * Settle the file system block size first, since it's a fixed
         * parameter once set and so many other parameters, including
         * max_fssize, depend on it.
         */
        range_check(&bsize, "bsize", MINBSIZE, MAXBSIZE, DESBLKSIZE,
            bsize_flag);

        if (!POWEROF2(bsize)) {
                (void) fprintf(stderr,
                    gettext("block size must be a power of 2, not %ld\n"),
                    bsize);
                bsize = DESBLKSIZE;
                (void) fprintf(stderr,
                    gettext("mkfs: bsize reset to default %ld\n"),
                    bsize);
        }

        if (fssize_db > max_fssize && validate_size(fsi, fssize_db)) {
                (void) fprintf(stderr, gettext(
                    "Warning: the requested size of this file system\n"
                    "(%lld sectors) is greater than the size of the\n"
                    "device reported by the driver (%lld sectors).\n"
                    "However, a read of the device at the requested size\n"
                    "does succeed, so the requested size will be used.\n"),
                    fssize_db, max_fssize);
                max_fssize = fssize_db;
        }
        /*
         * Since the maximum allocatable unit (the frag) must be less than
         * or equal to bsize, and the number of frags must be less than or
         * equal to INT_MAX, the total size of the file system (in
         * bytes) must be less than or equal to bsize * INT_MAX.
         */

        if (max_fssize > ((diskaddr_t)bsize/DEV_BSIZE) * INT_MAX)
                max_fssize = ((diskaddr_t)bsize/DEV_BSIZE) * INT_MAX;

        range_check_64(&fssize_db, "size", 1024LL, max_fssize, max_fssize, 1);

        if (fssize_db >= SECTORS_PER_TERABYTE) {
                mtb = 'y';
                if (!in_64bit_mode()) {
                        (void) fprintf(stderr, gettext(
"mkfs:  Warning: Creating a file system greater than 1 terabyte on a\n"
"       system running a 32-bit kernel.  This file system will not be\n"
"       accessible until the system is rebooted with a 64-bit kernel.\n"));
                }
        }
        dprintf(("DeBuG mtb : %c\n", mtb));

        /*
         * With newer and much larger disks, the newfs(1M) and mkfs_ufs(1M)
         * commands had problems in correctly handling the "native" geometries
         * for various storage devices.
         *
         * To handle the new age disks, mkfs_ufs(1M) will use the EFI style
         * for non-EFI disks that are larger than the CHS addressing limit
         * ( > 8GB approx ) and ignore the disk geometry information for
         * these drives. This is what is currently done for multi-terrabyte
         * filesystems on EFI disks.
         *
         * However if the user asked for a specific layout by supplying values
         * for even one of the three parameters (nsect, ntrack, cpg), honour
         * the user supplied parameters.
         *
         * Choosing EFI style or native geometry style can make a lot of
         * difference, because the size of a cylinder group is dependent on
         * this choice. This in turn means that the position of alternate
         * superblocks varies depending on the style chosen. It is not
         * necessary that all disks of size > CHSLIMIT have EFI style layout.
         * There can be disks which are > CHSLIMIT size, but have native
         * geometry style layout, thereby warranting the need for alternate
         * logic in superblock detection.
         */
        if (mtb != 'y' && (ntrack == -1 || GROW_WITH_DEFAULT_TRAK ||
            DEFAULT_SECT_TRAK_CPG)) {
                /*
                 * "-1" indicates that we were called from newfs and ntracks
                 * was not specified in newfs command line. Calculate nsect
                 * and ntrack in the same manner as newfs.
                 *
                 * This is required because, the defaults for nsect and ntrack
                 * is hardcoded in mkfs, whereas to generate the alternate
                 * superblock locations for the -N option, there is a need for
                 * the geometry based values that newfs would have arrived at.
                 * Newfs would have arrived at these values as below.
                 */
                if (label_type == LABEL_TYPE_EFI ||
                    label_type == LABEL_TYPE_OTHER) {
                        use_efi_dflts = 1;
                        retry = 1;
                } else if (ioctl(fsi, DKIOCGGEOM, &dkg)) {
                        dprintf(("%s: Unable to read Disk geometry", fsys));
                        perror(gettext("Unable to read Disk geometry"));
                        lockexit(32);
                } else {
                        nsect = dkg.dkg_nsect;
                        ntrack = dkg.dkg_nhead;
#ifdef i386     /* Bug 1170182 */
                        if (ntrack > 32 && (ntrack % 16) != 0) {
                                ntrack -= (ntrack % 16);
                        }
#endif
                        if (ioctl(fsi, DKIOCREMOVABLE, &isremovable)) {
                                dprintf(("DeBuG Unable to determine if %s is"
                                    " Removable Media. Proceeding with system"
                                    " determined parameters.\n", fsys));
                                isremovable = 0;
                        }
                        if (ioctl(fsi, DKIOCHOTPLUGGABLE, &ishotpluggable)) {
                                dprintf(("DeBuG Unable to determine if %s is"
                                    " Hotpluggable Media. Proceeding with "
                                    "system determined parameters.\n", fsys));
                                ishotpluggable = 0;
                        }
                        if ((((diskaddr_t)dkg.dkg_ncyl * dkg.dkg_nhead *
                            dkg.dkg_nsect) > CHSLIMIT) || isremovable ||
                            ishotpluggable) {
                                use_efi_dflts = 1;
                                retry = 1;
                        }
                }
        }
        dprintf(("DeBuG CHSLIMIT = %d geom = %llu\n", CHSLIMIT,
            (diskaddr_t)dkg.dkg_ncyl * dkg.dkg_nhead * dkg.dkg_nsect));
        dprintf(("DeBuG label_type = %d isremovable = %d ishotpluggable = %d "
            "use_efi_dflts = %d\n", label_type, isremovable, ishotpluggable,
            use_efi_dflts));

        /*
         * For the newfs -N case, even if the disksize is > CHSLIMIT, do not
         * blindly follow EFI style. If the fs_version indicates a geometry
         * based layout, try that one first. If it fails we can always try the
         * other logic.
         *
         * If we were called from growfs, we will have a problem if we mix
         * and match the filesystem creation and growth styles. For example,
         * if we create using EFI style, we have to also grow using EFI
         * style. So follow the style indicated by the fs_version.
         *
         * Read and verify the primary superblock. If it looks sane, use the
         * fs_version from the superblock. If the primary superblock does
         * not look good, read and verify the first alternate superblock at
         * ALTSB. Use the fs_version to decide whether to use the
         * EFI style logic or the old geometry based logic to calculate
         * the alternate superblock locations.
         */
        if ((Nflag && use_efi_dflts) || (grow)) {
                if (grow && ntrack_flag != RC_DEFAULT)
                        goto start_fs_creation;
                rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize,
                    (char *)&altsblock);
                ret = checksblock(altsblock, 1);

                if (!ret) {
                        if (altsblock.fs_magic == MTB_UFS_MAGIC) {
                                mtb = 'y';
                                goto start_fs_creation;
                        }
                        use_efi_dflts = (altsblock.fs_version ==
                            UFS_EFISTYLE4NONEFI_VERSION_2) ? 1 : 0;
                } else {
                        /*
                         * The primary superblock didn't help in determining
                         * the fs_version. Try the first alternate superblock.
                         */
                        dprintf(("DeBuG checksblock() failed - error : %d"
                            " for sb : %d\n", ret, SBOFF/sectorsize));
                        rdfs((diskaddr_t)ALTSB, (int)sbsize,
                            (char *)&altsblock);
                        ret = checksblock(altsblock, 1);

                        if (!ret) {
                                if (altsblock.fs_magic == MTB_UFS_MAGIC) {
                                        mtb = 'y';
                                        goto start_fs_creation;
                                }
                                use_efi_dflts = (altsblock.fs_version ==
                                    UFS_EFISTYLE4NONEFI_VERSION_2) ? 1 : 0;
                        }
                        dprintf(("DeBuG checksblock() returned : %d"
                            " for sb : %d\n", ret, ALTSB));
                }
        }

        geom_nsect = nsect;
        geom_ntrack = ntrack;
        geom_cpg = cpg;
        dprintf(("DeBuG geom_nsect=%d, geom_ntrack=%d, geom_cpg=%d\n",
            geom_nsect, geom_ntrack, geom_cpg));

start_fs_creation:
retry_alternate_logic:
        invalid_sb_cnt = 0;
        cg_too_small = 0;
        if (use_efi_dflts) {
                nsect = DEF_SECTORS_EFI;
                ntrack = DEF_TRACKS_EFI;
                cpg = DESCPG;
                dprintf(("\nDeBuG Using EFI defaults\n"));
        } else {
                nsect = geom_nsect;
                ntrack = geom_ntrack;
                cpg = geom_cpg;
                dprintf(("\nDeBuG Using Geometry\n"));
                /*
                 * 32K based on max block size of 64K, and rotational layout
                 * test of nsect <= (256 * sectors/block).  Current block size
                 * limit is not 64K, but it's growing soon.
                 */
                range_check(&nsect, "nsect", 1, 32768, DFLNSECT, nsect_flag);
                /*
                 * ntrack is the number of tracks per cylinder.
                 * The ntrack value must be between 1 and the total number of
                 * sectors in the file system.
                 */
                range_check(&ntrack, "ntrack", 1,
                    fssize_db > INT_MAX ? INT_MAX : (uint32_t)fssize_db,
                    DFLNTRAK, ntrack_flag);
        }

        range_check(&apc, "apc", 0, nsect - 1, 0, apc_flag);

        if (mtb == 'y')
                fragsize = bsize;

        range_check(&fragsize, "fragsize", sectorsize, bsize,
            MAX(bsize / MAXFRAG, MIN(DESFRAGSIZE, bsize)), fragsize_flag);

        if ((bsize / MAXFRAG) > fragsize) {
                (void) fprintf(stderr, gettext(
"fragment size %ld is too small, minimum with block size %ld is %ld\n"),
                    fragsize, bsize, bsize / MAXFRAG);
                (void) fprintf(stderr,
                    gettext("mkfs: fragsize reset to minimum %ld\n"),
                    bsize / MAXFRAG);
                fragsize = bsize / MAXFRAG;
        }

        if (!POWEROF2(fragsize)) {
                (void) fprintf(stderr,
                    gettext("fragment size must be a power of 2, not %ld\n"),
                    fragsize);
                fragsize = MAX(bsize / MAXFRAG, MIN(DESFRAGSIZE, bsize));
                (void) fprintf(stderr,
                    gettext("mkfs: fragsize reset to %ld\n"),
                    fragsize);
        }

        /* At this point, bsize must be >= fragsize, so no need to check it */

        if (bsize < PAGESIZE) {
                (void) fprintf(stderr, gettext(
                    "WARNING: filesystem block size (%ld) is smaller than "
                    "memory page size (%ld).\nResulting filesystem can not be "
                    "mounted on this system.\n\n"),
                    bsize, (long)PAGESIZE);
        }

        range_check(&rps, "rps", 1, 1000, DEFHZ, rps_flag);
        range_check(&minfree, "free", 0, 99, MINFREE, minfree_flag);
        range_check(&nrpos, "nrpos", 1, nsect, MIN(nsect, NRPOS), nrpos_flag);

        /*
         * nbpi is variable, but 2MB seems a reasonable upper limit,
         * as 4MB tends to cause problems (using otherwise-default
         * parameters).  The true limit is where we end up with one
         * inode per cylinder group.  If this file system is being
         * configured for multi-terabyte access, nbpi must be at least 1MB.
         */
        if (mtb == 'y' && nbpi < MTB_NBPI) {
                if (nbpi_flag != RC_DEFAULT)
                        (void) fprintf(stderr, gettext("mkfs: bad value for "
                            "nbpi: must be at least 1048576 for multi-terabyte,"
                            " nbpi reset to default 1048576\n"));
                nbpi = MTB_NBPI;
        }

        if (mtb == 'y')
                range_check(&nbpi, "nbpi", MTB_NBPI, 2 * MB, MTB_NBPI,
                    nbpi_flag);
        else
                range_check(&nbpi, "nbpi", DEV_BSIZE, 2 * MB, NBPI, nbpi_flag);

        /*
         * maxcpg is another variably-limited parameter.  Calculate
         * the limit based on what we've got for its dependent
         * variables.  Effectively, it's how much space is left in the
         * superblock after all the other bits are accounted for.  We
         * only fill in sblock fields so we can use MAXIpG.
         *
         * If the calculation of maxcpg below (for the mtb == 'n'
         * case) is changed, update newfs as well.
         *
         * For old-style, non-MTB format file systems, use the old
         * algorithm for calculating the maximum cylinder group size,
         * even though it limits the cylinder group more than necessary.
         * Since layout can affect performance, we don't want to change
         * the default layout for non-MTB file systems at this time.
         * However, for MTB file systems, use the new maxcpg calculation,
         * which really maxes out the cylinder group size.
         */

        sblock.fs_bsize = bsize;
        sblock.fs_inopb = sblock.fs_bsize / sizeof (struct dinode);

        if (mtb == 'n') {
                maxcpg = (bsize - sizeof (struct cg) -
                    howmany(MAXIpG(&sblock), NBBY)) /
                    (sizeof (long) + nrpos * sizeof (short) +
                    nsect / (MAXFRAG * NBBY));
        } else {
                maxcpg = compute_maxcpg(bsize, fragsize, nbpi, nrpos,
                    nsect * ntrack);
        }

        dprintf(("DeBuG cpg : %ld\n", cpg));
        /*
         * Increase the cpg to maxcpg if either newfs was invoked
         * with -T option or if mkfs wants to create a mtb file system
         * and if the user has not specified the cpg.
         */
        if (cpg == -1 || (mtb == 'y' && cpg_flag == RC_DEFAULT))
                cpg = maxcpg;
        dprintf(("DeBuG cpg : %ld\n", cpg));

        /*
         * mincpg is variable in complex ways, so we really can't
         * do a sane lower-end limit check at this point.
         */
        range_check(&cpg, "cgsize", 1, maxcpg, MIN(maxcpg, DESCPG), cpg_flag);

        /*
         * get the controller info
         */
        islog = 0;
        islogok = 0;
        waslog = 0;

        /*
         * Do not grow the file system, but print on stdout the maximum
         * size in sectors to which the file system can be increased.
         * The calculated size is limited by fssize_db.
         * Note that we don't lock the filesystem and therefore under rare
         * conditions (the filesystem is mounted, the free block count is
         * almost zero, and the superuser is still changing it) the calculated
         * size can be imprecise.
         */
        if (Pflag) {
                (void) printf("%llu\n", probe_summaryinfo());
                exit(0);
        }

        /*
         * If we're growing an existing filesystem, then we're about
         * to start doing things that can require recovery efforts if
         * we get interrupted, so make sure we get a chance to do so.
         */
        if (grow) {
                sigact.sa_handler = recover_from_sigint;
                sigemptyset(&sigact.sa_mask);
                sigact.sa_flags = SA_RESTART;

                if (sigaction(SIGINT, &sigact, NULL) < 0) {
                        perror(gettext("Could not register SIGINT handler"));
                        lockexit(3);
                }
        }

        if (!Nflag) {
                /*
                 * Check if MNTTAB is trustable
                 */
                if (statvfs64(MNTTAB, &fs) < 0) {
                        (void) fprintf(stderr, gettext("can't statvfs %s\n"),
                            MNTTAB);
                        exit(32);
                }

                if (strcmp(MNTTYPE_MNTFS, fs.f_basetype) != 0) {
                        (void) fprintf(stderr, gettext(
                            "%s file system type is not %s, can't mkfs\n"),
                            MNTTAB, MNTTYPE_MNTFS);
                        exit(32);
                }

                special = getfullblkname(fsys);
                checkdev(fsys, special);

                /*
                 * If we found the block device name,
                 * then check the mount table.
                 * if mounted, and growing write lock the file system
                 *
                 */
                if ((special != NULL) && (*special != '\0')) {
                        if ((mnttab = fopen(MNTTAB, "r")) == NULL) {
                                (void) fprintf(stderr, gettext(
                                    "can't open %s\n"), MNTTAB);
                                exit(32);
                        }
                        while ((getmntent(mnttab, &mntp)) == 0) {
                                if (grow) {
                                        checkmount(&mntp, special);
                                        continue;
                                }
                                if (strcmp(special, mntp.mnt_special) == 0) {
                                        (void) fprintf(stderr, gettext(
                                            "%s is mounted, can't mkfs\n"),
                                            special);
                                        exit(32);
                                }
                        }
                        (void) fclose(mnttab);
                }

                if (directory && (ismounted == 0)) {
                        (void) fprintf(stderr, gettext("%s is not mounted\n"),
                            special);
                        lockexit(32);
                }

                fso = (grow) ? open64(fsys, O_WRONLY) : creat64(fsys, 0666);
                if (fso < 0) {
                        saverr = errno;
                        (void) fprintf(stderr,
                            gettext("%s: cannot create: %s\n"),
                            fsys, strerror(saverr));
                        lockexit(32);
                }

        } else {

                /*
                 * For the -N case, a file descriptor is needed for the llseek()
                 * in wtfs(). See the comment in wtfs() for more information.
                 *
                 * Get a file descriptor that's read-only so that this code
                 * doesn't accidentally write to the file.
                 */
                fso = open64(fsys, O_RDONLY);
                if (fso < 0) {
                        saverr = errno;
                        (void) fprintf(stderr, gettext("%s: cannot open: %s\n"),
                            fsys, strerror(saverr));
                        lockexit(32);
                }
        }

        /*
         * Check the media sector size
         */
        if (ioctl(fso, DKIOCGMEDIAINFO, &dkminfo) != -1) {
                if (dkminfo.dki_lbsize != 0 &&
                    POWEROF2(dkminfo.dki_lbsize / DEV_BSIZE) &&
                    dkminfo.dki_lbsize != DEV_BSIZE) {
                        fprintf(stderr,
                            gettext("The device sector size %u is not "
                            "supported by ufs!\n"), dkminfo.dki_lbsize);
                        (void) close(fso);
                        exit(1);
                }
        }

        /*
         * seed random # generator (for ic_generation)
         */
#ifdef MKFS_DEBUG
        srand48(12962); /* reproducible results */
#else
        srand48((long)(time(NULL) + getpid()));
#endif

        if (grow) {
                growinit(fsys);
                goto grow00;
        }

        /*
         * Validate the given file system size.
         * Verify that its last block can actually be accessed.
         *
         * Note: it's ok to use sblock as a buffer because it is immediately
         * overwritten by the rdfs() of the superblock in the next line.
         *
         * ToDo: Because the size checking is done in rdfs()/wtfs(), the
         * error message for specifying an illegal size is very unfriendly.
         * In the future, one could replace the rdfs()/wtfs() calls
         * below with in-line calls to read() or write(). This allows better
         * error messages to be put in place.
         */
        rdfs(fssize_db - 1, (int)sectorsize, (char *)&sblock);

        /*
         * make the fs unmountable
         */
        rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock);
        sblock.fs_magic = -1;
        sblock.fs_clean = FSBAD;
        sblock.fs_state = FSOKAY - sblock.fs_time;
        wtfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock);
        bzero(&sblock, (size_t)sbsize);

        sblock.fs_nsect = nsect;
        sblock.fs_ntrak = ntrack;

        /*
         * Validate specified/determined spc
         * and calculate minimum cylinders per group.
         */

        /*
         * sectors/cyl = tracks/cyl * sectors/track
         */
        sblock.fs_spc = sblock.fs_ntrak * sblock.fs_nsect;

grow00:
        if (apc_flag) {
                sblock.fs_spc -= apc;
        }
        /*
         * Have to test for this separately from apc_flag, due to
         * the growfs case....
         */
        if (sblock.fs_spc != sblock.fs_ntrak * sblock.fs_nsect) {
                spc_flag = 1;
        }
        if (grow)
                goto grow10;

        sblock.fs_nrpos = nrpos;
        sblock.fs_bsize = bsize;
        sblock.fs_fsize = fragsize;
        sblock.fs_minfree = minfree;

grow10:
        if (nbpi < sblock.fs_fsize) {
                (void) fprintf(stderr, gettext(
                "warning: wasteful data byte allocation / inode (nbpi):\n"));
                (void) fprintf(stderr, gettext(
                    "%ld smaller than allocatable fragment size of %d\n"),
                    nbpi, sblock.fs_fsize);
        }
        if (grow)
                goto grow20;

        if (opt == 's')
                sblock.fs_optim = FS_OPTSPACE;
        else
                sblock.fs_optim = FS_OPTTIME;

        sblock.fs_bmask = ~(sblock.fs_bsize - 1);
        sblock.fs_fmask = ~(sblock.fs_fsize - 1);
        /*
         * Planning now for future expansion.
         */
#if defined(_BIG_ENDIAN)
                sblock.fs_qbmask.val[0] = 0;
                sblock.fs_qbmask.val[1] = ~sblock.fs_bmask;
                sblock.fs_qfmask.val[0] = 0;
                sblock.fs_qfmask.val[1] = ~sblock.fs_fmask;
#endif
#if defined(_LITTLE_ENDIAN)
                sblock.fs_qbmask.val[0] = ~sblock.fs_bmask;
                sblock.fs_qbmask.val[1] = 0;
                sblock.fs_qfmask.val[0] = ~sblock.fs_fmask;
                sblock.fs_qfmask.val[1] = 0;
#endif
        for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)
                sblock.fs_bshift++;
        for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
                sblock.fs_fshift++;
        sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
        for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1)
                sblock.fs_fragshift++;
        if (sblock.fs_frag > MAXFRAG) {
                (void) fprintf(stderr, gettext(
        "fragment size %d is too small, minimum with block size %d is %d\n"),
                    sblock.fs_fsize, sblock.fs_bsize,
                    sblock.fs_bsize / MAXFRAG);
                lockexit(32);
        }
        sblock.fs_nindir = sblock.fs_bsize / sizeof (daddr32_t);
        sblock.fs_inopb = sblock.fs_bsize / sizeof (struct dinode);
        sblock.fs_nspf = sblock.fs_fsize / sectorsize;
        for (sblock.fs_fsbtodb = 0, i = NSPF(&sblock); i > 1; i >>= 1)
                sblock.fs_fsbtodb++;

        /*
         * Compute the super-block, cylinder group, and inode blocks.
         * Note that these "blkno" are really fragment addresses.
         * For example, on an 8K/1K (block/fragment) system, fs_sblkno is 16,
         * fs_cblkno is 24, and fs_iblkno is 32. This is why CGSIZE is so
         * important: only 1 FS block is allocated for the cg struct (fragment
         * numbers 24 through 31).
         */
        sblock.fs_sblkno =
            roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag);
        sblock.fs_cblkno = (daddr32_t)(sblock.fs_sblkno +
            roundup(howmany(sbsize, sblock.fs_fsize), sblock.fs_frag));
        sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;

        sblock.fs_cgoffset = roundup(
            howmany(sblock.fs_nsect, NSPF(&sblock)), sblock.fs_frag);
        for (sblock.fs_cgmask = -1, i = sblock.fs_ntrak; i > 1; i >>= 1)
                sblock.fs_cgmask <<= 1;
        if (!POWEROF2(sblock.fs_ntrak))
                sblock.fs_cgmask <<= 1;
        /*
         * Validate specified/determined spc
         * and calculate minimum cylinders per group.
         */

        for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;
            sblock.fs_cpc > 1 && (i & 1) == 0;
            sblock.fs_cpc >>= 1, i >>= 1)
                /* void */;
        mincpc = sblock.fs_cpc;

        /* if these calculations are changed, check dump_fscmd also */
        bpcg = (uint64_t)sblock.fs_spc * sectorsize;
        inospercg = (uint64_t)roundup(bpcg / sizeof (struct dinode),
            INOPB(&sblock));
        if (inospercg > MAXIpG(&sblock))
                inospercg = MAXIpG(&sblock);
        used = (uint64_t)(sblock.fs_iblkno + inospercg /
            INOPF(&sblock)) * NSPF(&sblock);
        mincpgcnt = (long)howmany((uint64_t)sblock.fs_cgoffset *
            (~sblock.fs_cgmask) + used, sblock.fs_spc);
        mincpg = roundup(mincpgcnt, mincpc);
        /*
         * Insure that cylinder group with mincpg has enough space
         * for block maps
         */
        sblock.fs_cpg = mincpg;
        sblock.fs_ipg = (int32_t)inospercg;
        mapcramped = 0;

        /*
         * Make sure the cg struct fits within the file system block.
         * Use larger block sizes until it fits
         */
        while (CGSIZE(&sblock) > sblock.fs_bsize) {
                mapcramped = 1;
                if (sblock.fs_bsize < MAXBSIZE) {
                        sblock.fs_bsize <<= 1;
                        if ((i & 1) == 0) {
                                i >>= 1;
                        } else {
                                sblock.fs_cpc <<= 1;
                                mincpc <<= 1;
                                mincpg = roundup(mincpgcnt, mincpc);
                                sblock.fs_cpg = mincpg;
                        }
                        sblock.fs_frag <<= 1;
                        sblock.fs_fragshift += 1;
                        if (sblock.fs_frag <= MAXFRAG)
                                continue;
                }

                /*
                 * Looped far enough. The fragment is now as large as the
                 * filesystem block!
                 */
                if (sblock.fs_fsize == sblock.fs_bsize) {
                        (void) fprintf(stderr, gettext(
                    "There is no block size that can support this disk\n"));
                        lockexit(32);
                }

                /*
                 * Try a larger fragment. Double the fragment size.
                 */
                sblock.fs_frag >>= 1;
                sblock.fs_fragshift -= 1;
                sblock.fs_fsize <<= 1;
                sblock.fs_nspf <<= 1;
        }
        /*
         * Insure that cylinder group with mincpg has enough space for inodes
         */
        inodecramped = 0;
        used *= sectorsize;
        nbytes64 = (uint64_t)mincpg * bpcg - used;
        inospercg = (uint64_t)roundup((nbytes64 / nbpi), INOPB(&sblock));
        sblock.fs_ipg = (int32_t)inospercg;
        while (inospercg > MAXIpG(&sblock)) {
                inodecramped = 1;
                if (mincpc == 1 || sblock.fs_frag == 1 ||
                    sblock.fs_bsize == MINBSIZE)
                        break;
                nbytes64 = (uint64_t)mincpg * bpcg - used;
                (void) fprintf(stderr,
                    gettext("With a block size of %d %s %lu\n"),
                    sblock.fs_bsize, gettext("minimum bytes per inode is"),
                    (uint32_t)(nbytes64 / MAXIpG(&sblock) + 1));
                sblock.fs_bsize >>= 1;
                sblock.fs_frag >>= 1;
                sblock.fs_fragshift -= 1;
                mincpc >>= 1;
                sblock.fs_cpg = roundup(mincpgcnt, mincpc);
                if (CGSIZE(&sblock) > sblock.fs_bsize) {
                        sblock.fs_bsize <<= 1;
                        break;
                }
                mincpg = sblock.fs_cpg;
                nbytes64 = (uint64_t)mincpg * bpcg - used;
                inospercg = (uint64_t)roundup((nbytes64 / nbpi),
                    INOPB(&sblock));
                sblock.fs_ipg = (int32_t)inospercg;
        }
        if (inodecramped) {
                if (inospercg > MAXIpG(&sblock)) {
                        nbytes64 = (uint64_t)mincpg * bpcg - used;
                        (void) fprintf(stderr, gettext(
                            "Minimum bytes per inode is %d\n"),
                            (uint32_t)(nbytes64 / MAXIpG(&sblock) + 1));
                } else if (!mapcramped) {
                        (void) fprintf(stderr, gettext(
            "With %ld bytes per inode, minimum cylinders per group is %ld\n"),
                            nbpi, mincpg);
                }
        }
        if (mapcramped) {
                (void) fprintf(stderr, gettext(
                    "With %d sectors per cylinder, minimum cylinders "
                    "per group is %ld\n"),
                    sblock.fs_spc, mincpg);
        }
        if (inodecramped || mapcramped) {
                /*
                 * To make this at least somewhat comprehensible in
                 * the world of i18n, figure out what we're going to
                 * say and then say it all at one time.  The days of
                 * needing to scrimp on string space are behind us....
                 */
                if ((sblock.fs_bsize != bsize) &&
                    (sblock.fs_fsize != fragsize)) {
                        (void) fprintf(stderr, gettext(
            "This requires the block size to be changed from %ld to %d\n"
            "and the fragment size to be changed from %ld to %d\n"),
                            bsize, sblock.fs_bsize,
                            fragsize, sblock.fs_fsize);
                } else if (sblock.fs_bsize != bsize) {
                        (void) fprintf(stderr, gettext(
            "This requires the block size to be changed from %ld to %d\n"),
                            bsize, sblock.fs_bsize);
                } else if (sblock.fs_fsize != fragsize) {
                        (void) fprintf(stderr, gettext(
            "This requires the fragment size to be changed from %ld to %d\n"),
                            fragsize, sblock.fs_fsize);
                } else {
                        (void) fprintf(stderr, gettext(
            "Unable to make filesystem fit with the given constraints\n"));
                }
                (void) fprintf(stderr, gettext(
                    "Please re-run mkfs with corrected parameters\n"));
                lockexit(32);
        }
        /*
         * Calculate the number of cylinders per group
         */
        sblock.fs_cpg = cpg;
        if (sblock.fs_cpg % mincpc != 0) {
                (void) fprintf(stderr, gettext(
                    "Warning: cylinder groups must have a multiple "
                    "of %ld cylinders with the given\n         parameters\n"),
                    mincpc);
                sblock.fs_cpg = roundup(sblock.fs_cpg, mincpc);
                (void) fprintf(stderr, gettext("Rounded cgsize up to %d\n"),
                    sblock.fs_cpg);
        }
        /*
         * Must insure there is enough space for inodes
         */
        /* if these calculations are changed, check dump_fscmd also */
        nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used;
        sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi), INOPB(&sblock));

        /*
         * Slim down cylinders per group, until the inodes can fit.
         */
        while (sblock.fs_ipg > MAXIpG(&sblock)) {
                inodecramped = 1;
                sblock.fs_cpg -= mincpc;
                nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used;
                sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi),
                    INOPB(&sblock));
        }
        /*
         * Must insure there is enough space to hold block map.
         * Cut down on cylinders per group, until the cg struct fits in a
         * filesystem block.
         */
        while (CGSIZE(&sblock) > sblock.fs_bsize) {
                mapcramped = 1;
                sblock.fs_cpg -= mincpc;
                nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used;
                sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi),
                    INOPB(&sblock));
        }
        sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
        if ((sblock.fs_cpg * sblock.fs_spc) % NSPB(&sblock) != 0) {
                (void) fprintf(stderr,
                gettext("newfs: panic (fs_cpg * fs_spc) %% NSPF != 0\n"));
                lockexit(32);
        }
        if (sblock.fs_cpg < mincpg) {
                (void) fprintf(stderr, gettext(
"With the given parameters, cgsize must be at least %ld; please re-run mkfs\n"),
                    mincpg);
                lockexit(32);
        }
        sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock));
grow20:
        /*
         * Now have size for file system and nsect and ntrak.
         * Determine number of cylinders and blocks in the file system.
         */
        fssize_frag = (int64_t)dbtofsb(&sblock, fssize_db);
        if (fssize_frag > INT_MAX) {
                (void) fprintf(stderr, gettext(
"There are too many fragments in the system, increase fragment size\n"),
                    mincpg);
                lockexit(32);
        }
        sblock.fs_size = (int32_t)fssize_frag;
        sblock.fs_ncyl = (int32_t)(fssize_frag * NSPF(&sblock) / sblock.fs_spc);
        if (fssize_frag * NSPF(&sblock) >
            (uint64_t)sblock.fs_ncyl * sblock.fs_spc) {
                sblock.fs_ncyl++;
                warn = 1;
        }
        if (sblock.fs_ncyl < 1) {
                (void) fprintf(stderr, gettext(
                    "file systems must have at least one cylinder\n"));
                lockexit(32);
        }
        if (grow)
                goto grow30;
        /*
         * Determine feasability/values of rotational layout tables.
         *
         * The size of the rotational layout tables is limited by the size
         * of the file system block, fs_bsize.  The amount of space
         * available for tables is calculated as (fs_bsize - sizeof (struct
         * fs)).  The size of these tables is inversely proportional to the
         * block size of the file system. The size increases if sectors per
         * track are not powers of two, because more cylinders must be
         * described by the tables before the rotational pattern repeats
         * (fs_cpc).
         */
        sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
        sblock.fs_sbsize = fragroundup(&sblock, sizeof (struct fs));
        sblock.fs_npsect = sblock.fs_nsect;
        if (sblock.fs_ntrak == 1) {
                sblock.fs_cpc = 0;
                goto next;
        }
        postblsize = sblock.fs_nrpos * sblock.fs_cpc * sizeof (short);
        rotblsize = sblock.fs_cpc * sblock.fs_spc / NSPB(&sblock);
        totalsbsize = sizeof (struct fs) + rotblsize;

        /* do static allocation if nrpos == 8 and fs_cpc == 16  */
        if (sblock.fs_nrpos == 8 && sblock.fs_cpc <= 16) {
                /* use old static table space */
                sblock.fs_postbloff = (char *)(&sblock.fs_opostbl[0][0]) -
                    (char *)(&sblock.fs_link);
                sblock.fs_rotbloff = &sblock.fs_space[0] -
                    (uchar_t *)(&sblock.fs_link);
        } else {
                /* use 4.3 dynamic table space */
                sblock.fs_postbloff = &sblock.fs_space[0] -
                    (uchar_t *)(&sblock.fs_link);
                sblock.fs_rotbloff = sblock.fs_postbloff + postblsize;
                totalsbsize += postblsize;
        }
        if (totalsbsize > sblock.fs_bsize ||
            sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) {
                (void) fprintf(stderr, gettext(
                    "Warning: insufficient space in super block for\n"
                    "rotational layout tables with nsect %d, ntrack %d, "
                    "and nrpos %d.\nOmitting tables - file system "
                    "performance may be impaired.\n"),
                    sblock.fs_nsect, sblock.fs_ntrak, sblock.fs_nrpos);

                /*
                 * Setting fs_cpc to 0 tells alloccgblk() in ufs_alloc.c to
                 * ignore the positional layout table and rotational
                 * position table.
                 */
                sblock.fs_cpc = 0;
                goto next;
        }
        sblock.fs_sbsize = fragroundup(&sblock, totalsbsize);


        /*
         * calculate the available blocks for each rotational position
         */
        for (cylno = 0; cylno < sblock.fs_cpc; cylno++)
                for (rpos = 0; rpos < sblock.fs_nrpos; rpos++)
                        fs_postbl(&sblock, cylno)[rpos] = -1;
        for (i = (rotblsize - 1) * sblock.fs_frag;
            i >= 0; i -= sblock.fs_frag) {
                cylno = cbtocylno(&sblock, i);
                rpos = cbtorpos(&sblock, i);
                blk = fragstoblks(&sblock, i);
                if (fs_postbl(&sblock, cylno)[rpos] == -1)
                        fs_rotbl(&sblock)[blk] = 0;
                else
                        fs_rotbl(&sblock)[blk] =
                            fs_postbl(&sblock, cylno)[rpos] - blk;
                fs_postbl(&sblock, cylno)[rpos] = blk;
        }
next:
grow30:
        /*
         * Compute/validate number of cylinder groups.
         * Note that if an excessively large filesystem is specified
         * (e.g., more than 16384 cylinders for an 8K filesystem block), it
         * does not get detected until checksummarysize()
         */
        sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
        if (sblock.fs_ncyl % sblock.fs_cpg)
                sblock.fs_ncg++;
        sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
        i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1);
        ibpcl = cgdmin(&sblock, i) - cgbase(&sblock, i);
        if (ibpcl >= sblock.fs_fpg) {
                (void) fprintf(stderr, gettext(
                    "inode blocks/cyl group (%d) >= data blocks (%d)\n"),
                    cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag,
                    sblock.fs_fpg / sblock.fs_frag);
                if ((ibpcl < 0) || (sblock.fs_fpg < 0)) {
                        (void) fprintf(stderr, gettext(
            "number of cylinders per cylinder group (%d) must be decreased.\n"),
                            sblock.fs_cpg);
                } else {
                        (void) fprintf(stderr, gettext(
            "number of cylinders per cylinder group (%d) must be increased.\n"),
                            sblock.fs_cpg);
                }
                (void) fprintf(stderr, gettext(
"Note that cgsize may have been adjusted to allow struct cg to fit.\n"));
                lockexit(32);
        }
        j = sblock.fs_ncg - 1;
        if ((i = fssize_frag - j * sblock.fs_fpg) < sblock.fs_fpg &&
            cgdmin(&sblock, j) - cgbase(&sblock, j) > i) {
                (void) fprintf(stderr, gettext(
                    "Warning: inode blocks/cyl group (%d) >= data "
                    "blocks (%ld) in last\n    cylinder group. This "
                    "implies %ld sector(s) cannot be allocated.\n"),
                    (cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag,
                    i / sblock.fs_frag, i * NSPF(&sblock));
                /*
                 * If there is only one cylinder group and that is not even
                 * big enough to hold the inodes, exit.
                 */
                if (sblock.fs_ncg == 1)
                        cg_too_small = 1;
                sblock.fs_ncg--;
                sblock.fs_ncyl = sblock.fs_ncg * sblock.fs_cpg;
                sblock.fs_size = fssize_frag =
                    (int64_t)sblock.fs_ncyl * (int64_t)sblock.fs_spc /
                    (int64_t)NSPF(&sblock);
                warn = 0;
        }
        if (warn && !spc_flag) {
                (void) fprintf(stderr, gettext(
                    "Warning: %d sector(s) in last cylinder unallocated\n"),
                    sblock.fs_spc - (uint32_t)(fssize_frag * NSPF(&sblock) -
                    (uint64_t)(sblock.fs_ncyl - 1) * sblock.fs_spc));
        }
        /*
         * fill in remaining fields of the super block
         */

        /*
         * The csum records are stored in cylinder group 0, starting at
         * cgdmin, the first data block.
         */
        sblock.fs_csaddr = cgdmin(&sblock, 0);
        sblock.fs_cssize =
            fragroundup(&sblock, sblock.fs_ncg * sizeof (struct csum));
        i = sblock.fs_bsize / sizeof (struct csum);
        sblock.fs_csmask = ~(i - 1);
        for (sblock.fs_csshift = 0; i > 1; i >>= 1)
                sblock.fs_csshift++;
        fscs = (struct csum *)calloc(1, sblock.fs_cssize);

        checksummarysize();
        if (mtb == 'y') {
                sblock.fs_magic = MTB_UFS_MAGIC;
                sblock.fs_version = MTB_UFS_VERSION_1;
        } else {
                sblock.fs_magic = FS_MAGIC;
                if (use_efi_dflts)
                        sblock.fs_version = UFS_EFISTYLE4NONEFI_VERSION_2;
                else
                        sblock.fs_version = UFS_VERSION_MIN;
        }

        if (grow) {
                bcopy((caddr_t)grow_fscs, (caddr_t)fscs, (int)grow_fs_cssize);
                extendsummaryinfo();
                goto grow40;
        }
        sblock.fs_rotdelay = rotdelay;
        sblock.fs_maxcontig = maxcontig;
        sblock.fs_maxbpg = MAXBLKPG(sblock.fs_bsize);

        sblock.fs_rps = rps;
        sblock.fs_cgrotor = 0;
        sblock.fs_cstotal.cs_ndir = 0;
        sblock.fs_cstotal.cs_nbfree = 0;
        sblock.fs_cstotal.cs_nifree = 0;
        sblock.fs_cstotal.cs_nffree = 0;
        sblock.fs_fmod = 0;
        sblock.fs_ronly = 0;
        sblock.fs_time = mkfstime;
        sblock.fs_state = FSOKAY - sblock.fs_time;
        sblock.fs_clean = FSCLEAN;
grow40:

        /*
         * If all that's needed is a dump of the superblock we
         * would use by default, we've got it now.  So, splat it
         * out and leave.
         */
        if (rflag) {
                dump_sblock();
                lockexit(0);
        }
        /*
         * Dump out summary information about file system.
         */
        (void) fprintf(stderr, gettext(
            "%s:\t%lld sectors in %d cylinders of %d tracks, %d sectors\n"),
            fsys, (uint64_t)sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,
            sblock.fs_ntrak, sblock.fs_nsect);
        (void) fprintf(stderr, gettext(
            "\t%.1fMB in %d cyl groups (%d c/g, %.2fMB/g, %d i/g)\n"),
            (float)sblock.fs_size * sblock.fs_fsize / MB, sblock.fs_ncg,
            sblock.fs_cpg, (float)sblock.fs_fpg * sblock.fs_fsize / MB,
            sblock.fs_ipg);

        tmpbuf = calloc(sblock.fs_ncg / 50 + 500, 1);
        if (tmpbuf == NULL) {
                perror("calloc");
                lockexit(32);
        }
        if (cg_too_small) {
                (void) fprintf(stderr, gettext("File system creation failed. "
                    "There is only one cylinder group and\nthat is "
                    "not even big enough to hold the inodes.\n"));
                lockexit(32);
        }
        /*
         * Now build the cylinders group blocks and
         * then print out indices of cylinder groups.
         */
        tprintf(gettext(
            "super-block backups (for fsck -F ufs -o b=#) at:\n"));
        for (width = cylno = 0; cylno < sblock.fs_ncg && cylno < 10; cylno++) {
                if ((grow == 0) || (cylno >= grow_fs_ncg))
                        initcg(cylno);
                num = fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno));
                /*
                 * If Nflag and if the disk is larger than the CHSLIMIT,
                 * then sanity test the superblocks before reporting. If there
                 * are too many superblocks which look insane, we have
                 * to retry with alternate logic. If both methods have
                 * failed, then our efforts to arrive at alternate
                 * superblocks failed, so complain and exit.
                 */
                if (Nflag && retry) {
                        skip_this_sb = 0;
                        rdfs((diskaddr_t)num, sbsize, (char *)&altsblock);
                        ret = checksblock(altsblock, 1);
                        if (ret) {
                                skip_this_sb = 1;
                                invalid_sb_cnt++;
                                dprintf(("DeBuG checksblock() failed - error :"
                                    " %d for sb : %llu invalid_sb_cnt : %d\n",
                                    ret, num, invalid_sb_cnt));
                        } else {
                                /*
                                 * Though the superblock looks sane, verify if
                                 * the fs_version in the superblock and the
                                 * logic that we are using to arrive at the
                                 * superblocks match.
                                 */
                                if (use_efi_dflts && altsblock.fs_version
                                    != UFS_EFISTYLE4NONEFI_VERSION_2) {
                                        skip_this_sb = 1;
                                        invalid_sb_cnt++;
                                }
                        }
                        if (invalid_sb_cnt >= INVALIDSBLIMIT) {
                                if (retry > 1) {
                                        (void) fprintf(stderr, gettext(
                                            "Error determining alternate "
                                            "superblock locations\n"));
                                        free(tmpbuf);
                                        lockexit(32);
                                }
                                retry++;
                                use_efi_dflts = !use_efi_dflts;
                                free(tmpbuf);
                                goto retry_alternate_logic;
                        }
                        if (skip_this_sb)
                                continue;
                }
                (void) sprintf(pbuf, " %llu,", num);
                plen = strlen(pbuf);
                if ((width + plen) > (WIDTH - 1)) {
                        width = plen;
                        tprintf("\n");
                } else {
                        width += plen;
                }
                if (Nflag && retry)
                        (void) strncat(tmpbuf, pbuf, strlen(pbuf));
                else
                        (void) fprintf(stderr, "%s", pbuf);
        }
        tprintf("\n");

        remaining_cg = sblock.fs_ncg - cylno;

        /*
         * If there are more than 300 cylinder groups still to be
         * initialized, print a "." for every 50 cylinder groups.
         */
        if (remaining_cg > 300) {
                tprintf(gettext("Initializing cylinder groups:\n"));
                do_dot = 1;
        }

        /*
         * Now initialize all cylinder groups between the first ten
         * and the last ten.
         *
         * If the number of cylinder groups was less than 10, all of the
         * cylinder group offsets would have printed in the last loop
         * and cylno will already be equal to sblock.fs_ncg and so this
         * loop will not be entered.  If there are less than 20 cylinder
         * groups, cylno is already less than fs_ncg - 10, so this loop
         * won't be entered in that case either.
         */

        i = 0;
        for (; cylno < sblock.fs_ncg - 10; cylno++) {
                if ((grow == 0) || (cylno >= grow_fs_ncg))
                        initcg(cylno);
                if (do_dot && cylno % 50 == 0) {
                        tprintf(".");
                        i++;
                        if (i == WIDTH - 1) {
                                tprintf("\n");
                                i = 0;
                        }
                }
        }

        /*
         * Now print the cylinder group offsets for the last 10
         * cylinder groups, if any are left.
         */

        if (do_dot) {
                tprintf(gettext(
            "\nsuper-block backups for last 10 cylinder groups at:\n"));
        }
        for (width = 0; cylno < sblock.fs_ncg; cylno++) {
                if ((grow == 0) || (cylno >= grow_fs_ncg))
                        initcg(cylno);
                num = fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno));
                if (Nflag && retry) {
                        skip_this_sb = 0;
                        rdfs((diskaddr_t)num, sbsize, (char *)&altsblock);
                        ret = checksblock(altsblock, 1);
                        if (ret) {
                                skip_this_sb = 1;
                                invalid_sb_cnt++;
                                dprintf(("DeBuG checksblock() failed - error :"
                                    " %d for sb : %llu invalid_sb_cnt : %d\n",
                                    ret, num, invalid_sb_cnt));
                        } else {
                                /*
                                 * Though the superblock looks sane, verify if
                                 * the fs_version in the superblock and the
                                 * logic that we are using to arrive at the
                                 * superblocks match.
                                 */
                                if (use_efi_dflts && altsblock.fs_version
                                    != UFS_EFISTYLE4NONEFI_VERSION_2) {
                                        skip_this_sb = 1;
                                        invalid_sb_cnt++;
                                }
                        }
                        if (invalid_sb_cnt >= INVALIDSBLIMIT) {
                                if (retry > 1) {
                                        (void) fprintf(stderr, gettext(
                                            "Error determining alternate "
                                            "superblock locations\n"));
                                        free(tmpbuf);
                                        lockexit(32);
                                }
                                retry++;
                                use_efi_dflts = !use_efi_dflts;
                                free(tmpbuf);
                                goto retry_alternate_logic;
                        }
                        if (skip_this_sb)
                                continue;
                }
                /* Don't print ',' for the last superblock */
                if (cylno == sblock.fs_ncg-1)
                        (void) sprintf(pbuf, " %llu", num);
                else
                        (void) sprintf(pbuf, " %llu,", num);
                plen = strlen(pbuf);
                if ((width + plen) > (WIDTH - 1)) {
                        width = plen;
                        tprintf("\n");
                } else {
                        width += plen;
                }
                if (Nflag && retry)
                        (void) strncat(tmpbuf, pbuf, strlen(pbuf));
                else
                        (void) fprintf(stderr, "%s", pbuf);
        }
        tprintf("\n");
        if (Nflag) {
                if (retry)
                        (void) fprintf(stderr, "%s", tmpbuf);
                free(tmpbuf);
                lockexit(0);
        }

        free(tmpbuf);
        if (grow)
                goto grow50;

        /*
         * Now construct the initial file system,
         * then write out the super-block.
         */
        fsinit();
grow50:
        /*
         * write the superblock and csum information
         */
        wtsb();

        /*
         * extend the last cylinder group in the original file system
         */
        if (grow) {
                extendcg(grow_fs_ncg-1);
                wtsb();
        }

        /*
         * Write out the duplicate super blocks to the first 10
         * cylinder groups (or fewer, if there are fewer than 10
         * cylinder groups).
         */
        for (cylno = 0; cylno < sblock.fs_ncg && cylno < 10; cylno++)
                awtfs(fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno)),
                    (int)sbsize, (char *)&sblock, SAVE);

        /*
         * Now write out duplicate super blocks to the remaining
         * cylinder groups.  In the case of multi-terabyte file
         * systems, just write out the super block to the last ten
         * cylinder groups (or however many are left).
         */
        if (mtb == 'y') {
                if (sblock.fs_ncg <= 10)
                        cylno = sblock.fs_ncg;
                else if (sblock.fs_ncg <= 20)
                        cylno = 10;
                else
                        cylno = sblock.fs_ncg - 10;
        }

        for (; cylno < sblock.fs_ncg; cylno++)
                awtfs(fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno)),
                    (int)sbsize, (char *)&sblock, SAVE);

        /*
         * Flush out all the AIO writes we've done.  It's not
         * necessary to do this explicitly, but it's the only
         * way to report any errors from those writes.
         */
        flush_writes();

        /*
         * set clean flag
         */
        if (grow)
                sblock.fs_clean = grow_fs_clean;
        else
                sblock.fs_clean = FSCLEAN;
        sblock.fs_time = mkfstime;
        sblock.fs_state = FSOKAY - sblock.fs_time;
        wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock);
        isbad = 0;

        if (fsync(fso) == -1) {
                saverr = errno;
                (void) fprintf(stderr,
                    gettext("mkfs: fsync failed on write disk: %s\n"),
                    strerror(saverr));
                /* we're just cleaning up, so keep going */
        }
        if (close(fsi) == -1) {
                saverr = errno;
                (void) fprintf(stderr,
                    gettext("mkfs: close failed on read disk: %s\n"),
                    strerror(saverr));
                /* we're just cleaning up, so keep going */
        }
        if (close(fso) == -1) {
                saverr = errno;
                (void) fprintf(stderr,
                    gettext("mkfs: close failed on write disk: %s\n"),
                    strerror(saverr));
                /* we're just cleaning up, so keep going */
        }
        fsi = fso = -1;

#ifndef STANDALONE
        lockexit(0);
#endif

        return (0);
}

/*
 * Figure out how big the partition we're dealing with is.
 * The value returned is in disk blocks (sectors);
 */
static diskaddr_t
get_max_size(int fd)
{
        struct extvtoc vtoc;
        dk_gpt_t *efi_vtoc;
        diskaddr_t      slicesize;

        int index = read_extvtoc(fd, &vtoc);

        if (index >= 0) {
                label_type = LABEL_TYPE_VTOC;
        } else {
                if (index == VT_ENOTSUP || index == VT_ERROR) {
                        /* it might be an EFI label */
                        index = efi_alloc_and_read(fd, &efi_vtoc);
                        label_type = LABEL_TYPE_EFI;
                }
        }

        if (index < 0) {
                switch (index) {
                case VT_ERROR:
                        break;
                case VT_EIO:
                        errno = EIO;
                        break;
                case VT_EINVAL:
                        errno = EINVAL;
                }
                perror(gettext("Can not determine partition size"));
                lockexit(32);
        }

        if (label_type == LABEL_TYPE_EFI) {
                slicesize = efi_vtoc->efi_parts[index].p_size;
                efi_free(efi_vtoc);
        } else {
                /*
                 * In the vtoc struct, p_size is a 32-bit signed quantity.
                 * In the dk_gpt struct (efi's version of the vtoc), p_size
                 * is an unsigned 64-bit quantity.  By casting the vtoc's
                 * psize to an unsigned 32-bit quantity, it will be copied
                 * to 'slicesize' (an unsigned 64-bit diskaddr_t) without
                 * sign extension.
                 */

                slicesize = (uint32_t)vtoc.v_part[index].p_size;
        }

        dprintf(("DeBuG get_max_size index = %d, p_size = %lld, dolimit = %d\n",
            index, slicesize, (slicesize > FS_MAX)));

        /*
         * The next line limits a UFS file system to the maximum
         * supported size.
         */

        if (slicesize > FS_MAX)
                return (FS_MAX);
        return (slicesize);
}

static long
get_max_track_size(int fd)
{
        struct dk_cinfo ci;
        long track_size = -1;

        if (ioctl(fd, DKIOCINFO, &ci) == 0) {
                track_size = ci.dki_maxtransfer * DEV_BSIZE;
        }

        if ((track_size < 0)) {
                int     error = 0;
                int     maxphys;
                int     gotit = 0;

                gotit = fsgetmaxphys(&maxphys, &error);
                if (gotit) {
                        track_size = MIN(MB, maxphys);
                } else {
                        (void) fprintf(stderr, gettext(
"Warning: Could not get system value for maxphys. The value for\n"
"maxcontig will default to 1MB.\n"));
                        track_size = MB;
                }
        }
        return (track_size);
}

/*
 * Initialize a cylinder group.
 */
static void
initcg(int cylno)
{
        diskaddr_t cbase, d;
        diskaddr_t dlower;      /* last data block before cg metadata */
        diskaddr_t dupper;      /* first data block after cg metadata */
        diskaddr_t dmax;
        int64_t i;
        struct csum *cs;
        struct dinode *inode_buffer;
        int size;

        /*
         * Variables used to store intermediate results as a part of
         * the internal implementation of the cbtocylno() macros.
         */
        diskaddr_t bno;         /* UFS block number (not sector number) */
        int     cbcylno;        /* current cylinder number */
        int     cbcylno_sect;   /* sector offset within cylinder */
        int     cbsect_incr;    /* amount to increment sector offset */

        /*
         * Variables used to store intermediate results as a part of
         * the internal implementation of the cbtorpos() macros.
         */
        short   *cgblks;        /* pointer to array of free blocks in cg */
        int     trackrpos;      /* tmp variable for rotation position */
        int     trackoff;       /* offset within a track */
        int     trackoff_incr;  /* amount to increment trackoff */
        int     rpos;           /* rotation position of current block */
        int     rpos_incr;      /* amount to increment rpos per block */

        union cgun *icgun;      /* local pointer to a cg summary block */
#define icg     (icgun->cg)

        icgun = (union cgun *)getbuf(&cgsumbuf, sizeof (union cgun));

        /*
         * Determine block bounds for cylinder group.
         * Allow space for super block summary information in first
         * cylinder group.
         */
        cbase = cgbase(&sblock, cylno);
        dmax = cbase + sblock.fs_fpg;
        if (dmax > sblock.fs_size)      /* last cg may be smaller than normal */
                dmax = sblock.fs_size;
        dlower = cgsblock(&sblock, cylno) - cbase;
        dupper = cgdmin(&sblock, cylno) - cbase;
        if (cylno == 0)
                dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
        cs = fscs + cylno;
        icg.cg_time = mkfstime;
        icg.cg_magic = CG_MAGIC;
        icg.cg_cgx = cylno;
        /* last one gets whatever's left */
        if (cylno == sblock.fs_ncg - 1)
                icg.cg_ncyl = sblock.fs_ncyl - (sblock.fs_cpg * cylno);
        else
                icg.cg_ncyl = sblock.fs_cpg;
        icg.cg_niblk = sblock.fs_ipg;
        icg.cg_ndblk = dmax - cbase;
        icg.cg_cs.cs_ndir = 0;
        icg.cg_cs.cs_nffree = 0;
        icg.cg_cs.cs_nbfree = 0;
        icg.cg_cs.cs_nifree = 0;
        icg.cg_rotor = 0;
        icg.cg_frotor = 0;
        icg.cg_irotor = 0;
        icg.cg_btotoff = &icg.cg_space[0] - (uchar_t *)(&icg.cg_link);
        icg.cg_boff = icg.cg_btotoff + sblock.fs_cpg * sizeof (long);
        icg.cg_iusedoff = icg.cg_boff +
            sblock.fs_cpg * sblock.fs_nrpos * sizeof (short);
        icg.cg_freeoff = icg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
        icg.cg_nextfreeoff = icg.cg_freeoff +
            howmany(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY);
        for (i = 0; i < sblock.fs_frag; i++) {
                icg.cg_frsum[i] = 0;
        }
        bzero((caddr_t)cg_inosused(&icg), icg.cg_freeoff - icg.cg_iusedoff);
        icg.cg_cs.cs_nifree += sblock.fs_ipg;
        if (cylno == 0)
                for (i = 0; i < UFSROOTINO; i++) {
                        setbit(cg_inosused(&icg), i);
                        icg.cg_cs.cs_nifree--;
                }

        /*
         * Initialize all the inodes in the cylinder group using
         * random numbers.
         */
        size = sblock.fs_ipg * sizeof (struct dinode);
        inode_buffer = (struct dinode *)getbuf(&inodebuf, size);

        for (i = 0; i < sblock.fs_ipg; i++) {
                IRANDOMIZE(&(inode_buffer[i].di_ic));
        }

        /*
         * Write all inodes in a single write for performance.
         */
        awtfs(fsbtodb(&sblock, (uint64_t)cgimin(&sblock, cylno)), (int)size,
            (char *)inode_buffer, RELEASE);

        bzero((caddr_t)cg_blktot(&icg), icg.cg_boff - icg.cg_btotoff);
        bzero((caddr_t)cg_blks(&sblock, &icg, 0),
            icg.cg_iusedoff - icg.cg_boff);
        bzero((caddr_t)cg_blksfree(&icg), icg.cg_nextfreeoff - icg.cg_freeoff);

        if (cylno > 0) {
                for (d = 0; d < dlower; d += sblock.fs_frag) {
                        setblock(&sblock, cg_blksfree(&icg), d/sblock.fs_frag);
                        icg.cg_cs.cs_nbfree++;
                        cg_blktot(&icg)[cbtocylno(&sblock, d)]++;
                        cg_blks(&sblock, &icg, cbtocylno(&sblock, d))
                            [cbtorpos(&sblock, d)]++;
                }
                sblock.fs_dsize += dlower;
        }
        sblock.fs_dsize += icg.cg_ndblk - dupper;
        if ((i = dupper % sblock.fs_frag) != 0) {
                icg.cg_frsum[sblock.fs_frag - i]++;
                for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
                        setbit(cg_blksfree(&icg), dupper);
                        icg.cg_cs.cs_nffree++;
                }
        }

        /*
         * WARNING: The following code is somewhat confusing, but
         * results in a substantial performance improvement in mkfs.
         *
         * Instead of using cbtocylno() and cbtorpos() macros, we
         * keep track of all the intermediate state of those macros
         * in some variables.  This allows simple addition to be
         * done to calculate the results as we step through the
         * blocks in an orderly fashion instead of the slower
         * multiplication and division the macros are forced to
         * used so they can support random input.  (Multiplication,
         * division, and remainder operations typically take about
         * 10x as many processor cycles as other operations.)
         *
         * The basic idea is to take code:
         *
         *      for (x = starting_x; x < max; x++)
         *              y = (x * c) / z
         *
         * and rewrite it to take advantage of the fact that
         * the variable x is incrementing in an orderly way:
         *
         *      intermediate = starting_x * c
         *      yval = intermediate / z
         *      for (x = starting_x; x < max; x++) {
         *              y = yval;
         *              intermediate += c
         *              if (intermediate > z) {
         *                      yval++;
         *                      intermediate -= z
         *              }
         *      }
         *
         * Performance has improved as much as 4X using this code.
         */

        /*
         * Initialize the starting points for all the cbtocylno()
         * macro variables and figure out the increments needed each
         * time through the loop.
         */
        cbcylno_sect = dupper * NSPF(&sblock);
        cbsect_incr = sblock.fs_frag * NSPF(&sblock);
        cbcylno = cbcylno_sect / sblock.fs_spc;
        cbcylno_sect %= sblock.fs_spc;
        cgblks = cg_blks(&sblock, &icg, cbcylno);
        bno = dupper / sblock.fs_frag;

        /*
         * Initialize the starting points for all the cbtorpos()
         * macro variables and figure out the increments needed each
         * time through the loop.
         *
         * It's harder to simplify the cbtorpos() macro if there were
         * alternate sectors specified (or if they previously existed
         * in the growfs case).  Since this is rare, we just revert to
         * using the macros in this case and skip the variable setup.
         */
        if (!spc_flag) {
                trackrpos = (cbcylno_sect % sblock.fs_nsect) * sblock.fs_nrpos;
                rpos = trackrpos / sblock.fs_nsect;
                trackoff = trackrpos % sblock.fs_nsect;
                trackoff_incr = cbsect_incr * sblock.fs_nrpos;
                rpos_incr = (trackoff_incr / sblock.fs_nsect) % sblock.fs_nrpos;
                trackoff_incr = trackoff_incr % sblock.fs_nsect;
        }

        /*
         * Loop through all the blocks, marking them free and
         * updating totals kept in the superblock and cg summary.
         */
        for (d = dupper; d + sblock.fs_frag <= dmax - cbase; ) {
                setblock(&sblock, cg_blksfree(&icg),  bno);
                icg.cg_cs.cs_nbfree++;

                cg_blktot(&icg)[cbcylno]++;

                if (!spc_flag)
                        cgblks[rpos]++;
                else
                        cg_blks(&sblock, &icg, cbtocylno(&sblock, d))
                            [cbtorpos(&sblock, d)]++;

                d += sblock.fs_frag;
                bno++;

                /*
                 * Increment the sector offset within the cylinder
                 * for the cbtocylno() macro reimplementation.  If
                 * we're beyond the end of the cylinder, update the
                 * cylinder number, calculate the offset in the
                 * new cylinder, and update the cgblks pointer
                 * to the next rotational position.
                 */
                cbcylno_sect += cbsect_incr;
                if (cbcylno_sect >= sblock.fs_spc) {
                        cbcylno++;
                        cbcylno_sect -= sblock.fs_spc;
                        cgblks += sblock.fs_nrpos;
                }

                /*
                 * If there aren't alternate sectors, increment the
                 * rotational position variables for the cbtorpos()
                 * reimplementation.  Note that we potentially
                 * increment rpos twice.  Once by rpos_incr, and one
                 * more time when we wrap to a new track because
                 * trackoff >= fs_nsect.
                 */
                if (!spc_flag) {
                        trackoff += trackoff_incr;
                        rpos += rpos_incr;
                        if (trackoff >= sblock.fs_nsect) {
                                trackoff -= sblock.fs_nsect;
                                rpos++;
                        }
                        if (rpos >= sblock.fs_nrpos)
                                rpos -= sblock.fs_nrpos;
                }
        }

        if (d < dmax - cbase) {
                icg.cg_frsum[dmax - cbase - d]++;
                for (; d < dmax - cbase; d++) {
                        setbit(cg_blksfree(&icg), d);
                        icg.cg_cs.cs_nffree++;
                }
        }
        sblock.fs_cstotal.cs_ndir += icg.cg_cs.cs_ndir;
        sblock.fs_cstotal.cs_nffree += icg.cg_cs.cs_nffree;
        sblock.fs_cstotal.cs_nbfree += icg.cg_cs.cs_nbfree;
        sblock.fs_cstotal.cs_nifree += icg.cg_cs.cs_nifree;
        *cs = icg.cg_cs;
        awtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, cylno)),
            sblock.fs_bsize, (char *)&icg, RELEASE);
}

/*
 * initialize the file system
 */
struct inode node;

#define LOSTDIR
#ifdef LOSTDIR
#define PREDEFDIR 3
#else
#define PREDEFDIR 2
#endif

struct direct root_dir[] = {
        { UFSROOTINO, sizeof (struct direct), 1, "." },
        { UFSROOTINO, sizeof (struct direct), 2, ".." },
#ifdef LOSTDIR
        { LOSTFOUNDINO, sizeof (struct direct), 10, "lost+found" },
#endif
};
#ifdef LOSTDIR
struct direct lost_found_dir[] = {
        { LOSTFOUNDINO, sizeof (struct direct), 1, "." },
        { UFSROOTINO, sizeof (struct direct), 2, ".." },
        { 0, DIRBLKSIZ, 0, 0 },
};
#endif
char buf[MAXBSIZE];

static void
fsinit()
{
        int i;


        /*
         * initialize the node
         */
        node.i_atime = mkfstime;
        node.i_mtime = mkfstime;
        node.i_ctime = mkfstime;
#ifdef LOSTDIR
        /*
         * create the lost+found directory
         */
        (void) makedir(lost_found_dir, 2);
        for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ) {
                bcopy(&lost_found_dir[2], &buf[i], DIRSIZ(&lost_found_dir[2]));
        }
        node.i_number = LOSTFOUNDINO;
        node.i_smode = IFDIR | 0700;
        node.i_nlink = 2;
        node.i_size = sblock.fs_bsize;
        node.i_db[0] = alloc((int)node.i_size, node.i_mode);
        node.i_blocks = btodb(fragroundup(&sblock, (int)node.i_size));
        IRANDOMIZE(&node.i_ic);
        wtfs(fsbtodb(&sblock, (uint64_t)node.i_db[0]), (int)node.i_size, buf);
        iput(&node);
#endif
        /*
         * create the root directory
         */
        node.i_number = UFSROOTINO;
        node.i_mode = IFDIR | UMASK;
        node.i_nlink = PREDEFDIR;
        node.i_size = makedir(root_dir, PREDEFDIR);
        node.i_db[0] = alloc(sblock.fs_fsize, node.i_mode);
        /* i_size < 2GB because we are initializing the file system */
        node.i_blocks = btodb(fragroundup(&sblock, (int)node.i_size));
        IRANDOMIZE(&node.i_ic);
        wtfs(fsbtodb(&sblock, (uint64_t)node.i_db[0]), sblock.fs_fsize, buf);
        iput(&node);
}

/*
 * construct a set of directory entries in "buf".
 * return size of directory.
 */
static int
makedir(struct direct *protodir, int entries)
{
        char *cp;
        int i;
        ushort_t spcleft;

        spcleft = DIRBLKSIZ;
        for (cp = buf, i = 0; i < entries - 1; i++) {
                protodir[i].d_reclen = DIRSIZ(&protodir[i]);
                bcopy(&protodir[i], cp, protodir[i].d_reclen);
                cp += protodir[i].d_reclen;
                spcleft -= protodir[i].d_reclen;
        }
        protodir[i].d_reclen = spcleft;
        bcopy(&protodir[i], cp, DIRSIZ(&protodir[i]));
        return (DIRBLKSIZ);
}

/*
 * allocate a block or frag
 */
static daddr32_t
alloc(int size, int mode)
{
        int i, frag;
        daddr32_t d;

        rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize,
            (char *)&acg);
        if (acg.cg_magic != CG_MAGIC) {
                (void) fprintf(stderr, gettext("cg 0: bad magic number\n"));
                lockexit(32);
        }
        if (acg.cg_cs.cs_nbfree == 0) {
                (void) fprintf(stderr,
                    gettext("first cylinder group ran out of space\n"));
                lockexit(32);
        }
        for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)
                if (isblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag))
                        goto goth;
        (void) fprintf(stderr,
            gettext("internal error: can't find block in cyl 0\n"));
        lockexit(32);
goth:
        clrblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag);
        acg.cg_cs.cs_nbfree--;
        sblock.fs_cstotal.cs_nbfree--;
        fscs[0].cs_nbfree--;
        if (mode & IFDIR) {
                acg.cg_cs.cs_ndir++;
                sblock.fs_cstotal.cs_ndir++;
                fscs[0].cs_ndir++;
        }
        cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
        cg_blks(&sblock, &acg, cbtocylno(&sblock, d))[cbtorpos(&sblock, d)]--;
        if (size != sblock.fs_bsize) {
                frag = howmany(size, sblock.fs_fsize);
                fscs[0].cs_nffree += sblock.fs_frag - frag;
                sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag;
                acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
                acg.cg_frsum[sblock.fs_frag - frag]++;
                for (i = frag; i < sblock.fs_frag; i++)
                        setbit(cg_blksfree(&acg), d + i);
        }
        wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize,
            (char *)&acg);
        return (d);
}

/*
 * Allocate an inode on the disk
 */
static void
iput(struct inode *ip)
{
        struct dinode buf[MAXINOPB];
        diskaddr_t d;

        rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize,
            (char *)&acg);
        if (acg.cg_magic != CG_MAGIC) {
                (void) fprintf(stderr, gettext("cg 0: bad magic number\n"));
                lockexit(32);
        }
        acg.cg_cs.cs_nifree--;
        setbit(cg_inosused(&acg), ip->i_number);
        wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize,
            (char *)&acg);
        sblock.fs_cstotal.cs_nifree--;
        fscs[0].cs_nifree--;
        if ((int)ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
                (void) fprintf(stderr,
                    gettext("fsinit: inode value out of range (%d).\n"),
                    ip->i_number);
                lockexit(32);
        }
        d = fsbtodb(&sblock, (uint64_t)itod(&sblock, (int)ip->i_number));
        rdfs(d, sblock.fs_bsize, (char *)buf);
        buf[itoo(&sblock, (int)ip->i_number)].di_ic = ip->i_ic;
        wtfs(d, sblock.fs_bsize, (char *)buf);
}

/*
 * getbuf()     -- Get a buffer for use in an AIO operation.  Buffer
 *              is zero'd the first time returned, left with whatever
 *              was in memory after that.  This function actually gets
 *              enough memory the first time it's called to support
 *              MAXBUF buffers like a slab allocator.  When all the
 *              buffers are in use, it waits for an aio to complete
 *              and make a buffer available.
 *
 *              Never returns an error.  Either succeeds or exits.
 */
static char *
getbuf(bufhdr *bufhead, int size)
{
        bufhdr *pbuf;
        bufhdr *prev;
        int i;
        int buf_size, max_bufs;

        /*
         * Initialize all the buffers
         */
        if (bufhead->head == NULL) {
                /*
                 * round up the size of our buffer header to a
                 * 16 byte boundary so the address we return to
                 * the caller is "suitably aligned".
                 */
                bufhdrsize = (sizeof (bufhdr) + 15) & ~15;

                /*
                 * Add in our header to the buffer and round it all up to
                 * a 16 byte boundry so each member of the slab is aligned.
                 */
                buf_size = (size + bufhdrsize + 15) & ~15;

                /*
                 * Limit number of buffers to lesser of MAXBUFMEM's worth
                 * or MAXBUF, whichever is less.
                 */
                max_bufs = MAXBUFMEM / buf_size;
                if (max_bufs > MAXBUF)
                        max_bufs = MAXBUF;

                pbuf = (bufhdr *)calloc(max_bufs, buf_size);
                if (pbuf == NULL) {
                        perror("calloc");
                        lockexit(32);
                }

                bufhead->head = bufhead;
                prev = bufhead;
                for (i = 0; i < max_bufs; i++) {
                        pbuf->head = bufhead;
                        prev->next = pbuf;
                        prev = pbuf;
                        pbuf = (bufhdr *)((char *)pbuf + buf_size);
                }
        }

        /*
         * Get an available buffer, waiting for I/O if necessary
         */
        wait_for_write(NOBLOCK);
        while (bufhead->next == NULL)
                wait_for_write(BLOCK);

        /*
         * Take the buffer off the list
         */
        pbuf = bufhead->next;
        bufhead->next = pbuf->next;
        pbuf->next = NULL;

        /*
         * return the empty buffer space just past the header
         */
        return ((char *)pbuf + bufhdrsize);
}

/*
 * freebuf()    -- Free a buffer gotten previously through getbuf.
 *              Puts the buffer back on the appropriate list for
 *              later use.  Never calls free().
 *
 * Assumes that SIGINT is blocked.
 */
static void
freebuf(char *buf)
{
        bufhdr *pbuf;
        bufhdr *bufhead;

        /*
         * get the header for this buffer
         */
        pbuf = (bufhdr *)(buf - bufhdrsize);

        /*
         * Put it back on the list of available buffers
         */
        bufhead = pbuf->head;
        pbuf->next = bufhead->next;
        bufhead->next = pbuf;
}

/*
 * freetrans()  -- Free a transaction gotten previously through getaiop.
 *              Puts the transaction struct back on the appropriate list for
 *              later use.  Never calls free().
 *
 * Assumes that SIGINT is blocked.
 */
static void
freetrans(aio_trans *transp)
{
        /*
         * free the buffer associated with this AIO if needed
         */
        if (transp->release == RELEASE)
                freebuf(transp->buffer);

        /*
         * Put transaction on the free list
         */
        transp->next = results.trans;
        results.trans = transp;
}

/*
 * wait_for_write()     -- Wait for an aio write to complete.  Return
 *                      the transaction structure for that write.
 *
 * Blocks SIGINT if necessary.
 */
aio_trans *
wait_for_write(int block)
{
        aio_trans       *transp;
        aio_result_t    *resultp;
        static struct timeval  zero_wait = { 0, 0 };
        sigset_t        old_mask;

        /*
         * If we know there aren't any outstanding transactions, just return
         */
        if (results.outstanding == 0)
                return ((aio_trans *) 0);

        block_sigint(&old_mask);

        resultp = aiowait(block ? NULL : &zero_wait);
        if (resultp == NULL ||
            (resultp == (aio_result_t *)-1 && errno == EINVAL)) {
                unblock_sigint(&old_mask);
                return ((aio_trans *) 0);
        }

        results.outstanding--;
        transp = (aio_trans *)resultp;

        if (resultp->aio_return != transp->size) {
                if (resultp->aio_return == -1) {
                        /*
                         * The aiowrite() may have failed because the
                         * kernel didn't have enough memory to do the job.
                         * Flush all pending writes and try a normal
                         * write().  wtfs_breakup() will call exit if it
                         * fails, so we don't worry about errors here.
                         */
                        flush_writes();
                        wtfs_breakup(transp->bno, transp->size, transp->buffer);
                } else {
                        (void) fprintf(stderr, gettext(
                            "short write (%d of %d bytes) on sector %lld\n"),
                            resultp->aio_return, transp->size,
                            transp->bno);
                        /*
                         * Don't unblock SIGINT, to avoid potential
                         * looping due to queued interrupts and
                         * error handling.
                         */
                        lockexit(32);
                }
        }

        resultp->aio_return = 0;
        freetrans(transp);
        unblock_sigint(&old_mask);
        return (transp);
}

/*
 * flush_writes()       -- flush all the outstanding aio writes.
 */
static void
flush_writes(void)
{
        while (wait_for_write(BLOCK))
                ;
}

/*
 * get_aiop()   -- find and return an aio_trans structure on which a new
 *              aio can be done.  Blocks on aiowait() if needed.  Reaps
 *              all outstanding completed aio's.
 *
 * Assumes that SIGINT is blocked.
 */
aio_trans *
get_aiop()
{
        int i;
        aio_trans *transp;
        aio_trans *prev;

        /*
         * initialize aio stuff
         */
        if (!aio_inited) {
                aio_inited = 1;

                results.maxpend = 0;
                results.outstanding = 0;
                results.max = MAXAIO;

                results.trans = (aio_trans *)calloc(results.max,
                    sizeof (aio_trans));
                if (results.trans == NULL) {
                        perror("calloc");
                        lockexit(32);
                }

                /*
                 * Initialize the linked list of aio transaction
                 * structures.  Note that the final "next" pointer
                 * will be NULL since we got the buffer from calloc().
                 */
                prev = results.trans;
                for (i = 1; i < results.max; i++) {
                        prev->next = &(results.trans[i]);
                        prev = prev->next;
                }
        }

        wait_for_write(NOBLOCK);
        while (results.trans == NULL)
                wait_for_write(BLOCK);
        transp = results.trans;
        results.trans = results.trans->next;

        transp->next = 0;
        transp->resultbuf.aio_return = AIO_INPROGRESS;
        return (transp);
}

/*
 * read a block from the file system
 */
static void
rdfs(diskaddr_t bno, int size, char *bf)
{
        int n, saverr;

        /*
         * In case we need any data that's pending in an aiowrite(),
         * we wait for them all to complete before doing a read.
         */
        flush_writes();

        /*
         * Note: the llseek() can succeed, even if the offset is out of range.
         * It's not until the file i/o operation (the read()) that one knows
         * for sure if the raw device can handle the offset.
         */
        if (llseek(fsi, (offset_t)bno * sectorsize, 0) < 0) {
                saverr = errno;
                (void) fprintf(stderr,
                    gettext("seek error on sector %lld: %s\n"),
                    bno, strerror(saverr));
                lockexit(32);
        }
        n = read(fsi, bf, size);
        if (n != size) {
                saverr = errno;
                if (n == -1)
                        (void) fprintf(stderr,
                            gettext("read error on sector %lld: %s\n"),
                            bno, strerror(saverr));
                else
                        (void) fprintf(stderr, gettext(
                            "short read (%d of %d bytes) on sector %lld\n"),
                            n, size, bno);
                lockexit(32);
        }
}

/*
 * write a block to the file system
 */
static void
wtfs(diskaddr_t bno, int size, char *bf)
{
        int n, saverr;

        if (fso == -1)
                return;

        /*
         * Note: the llseek() can succeed, even if the offset is out of range.
         * It's not until the file i/o operation (the write()) that one knows
         * for sure if the raw device can handle the offset.
         */
        if (llseek(fso, (offset_t)bno * sectorsize, 0) < 0) {
                saverr = errno;
                (void) fprintf(stderr,
                    gettext("seek error on sector %lld: %s\n"),
                    bno, strerror(saverr));
                lockexit(32);
        }
        if (Nflag)
                return;
        n = write(fso, bf, size);
        if (n != size) {
                saverr = errno;
                if (n == -1)
                        (void) fprintf(stderr,
                            gettext("write error on sector %lld: %s\n"),
                            bno, strerror(saverr));
                else
                        (void) fprintf(stderr, gettext(
                            "short write (%d of %d bytes) on sector %lld\n"),
                            n, size, bno);
                lockexit(32);
        }
}

/*
 * write a block to the file system -- buffered with aio
 */
static void
awtfs(diskaddr_t bno, int size, char *bf, int release)
{
        int n;
        aio_trans       *transp;
        sigset_t        old_mask;

        if (fso == -1)
                return;

        /*
         * We need to keep things consistent if we get interrupted,
         * so defer any expected interrupts for the time being.
         */
        block_sigint(&old_mask);

        if (Nflag) {
                if (release == RELEASE)
                        freebuf(bf);
        } else {
                transp = get_aiop();
                transp->bno = bno;
                transp->buffer = bf;
                transp->size = size;
                transp->release = release;

                n = aiowrite(fso, bf, size, (off_t)bno * sectorsize,
                    SEEK_SET, &transp->resultbuf);

                if (n < 0) {
                        /*
                         * The aiowrite() may have failed because the
                         * kernel didn't have enough memory to do the job.
                         * Flush all pending writes and try a normal
                         * write().  wtfs_breakup() will call exit if it
                         * fails, so we don't worry about errors here.
                         */
                        flush_writes();
                        wtfs_breakup(transp->bno, transp->size, transp->buffer);
                        freetrans(transp);
                } else {
                        /*
                         * Keep track of our pending writes.
                         */
                        results.outstanding++;
                        if (results.outstanding > results.maxpend)
                                results.maxpend = results.outstanding;
                }
        }

        unblock_sigint(&old_mask);
}


/*
 * write a block to the file system, but break it up into sbsize
 * chunks to avoid forcing a large amount of memory to be locked down.
 * Only used as a fallback when an aio write has failed.
 */
static void
wtfs_breakup(diskaddr_t bno, int size, char *bf)
{
        int n, saverr;
        int wsize;
        int block_incr = sbsize / sectorsize;

        if (size < sbsize)
                wsize = size;
        else
                wsize = sbsize;

        n = 0;
        while (size) {
                /*
                 * Note: the llseek() can succeed, even if the offset is
                 * out of range.  It's not until the file i/o operation
                 * (the write()) that one knows for sure if the raw device
                 * can handle the offset.
                 */
                if (llseek(fso, (offset_t)bno * sectorsize, 0) < 0) {
                        saverr = errno;
                        (void) fprintf(stderr,
                            gettext("seek error on sector %lld: %s\n"),
                            bno, strerror(saverr));
                        lockexit(32);
                }

                n = write(fso, bf, wsize);
                if (n == -1) {
                        saverr = errno;
                        (void) fprintf(stderr,
                            gettext("write error on sector %lld: %s\n"),
                            bno, strerror(saverr));
                        lockexit(32);
                }
                if (n != wsize) {
                        saverr = errno;
                        (void) fprintf(stderr, gettext(
                            "short write (%d of %d bytes) on sector %lld\n"),
                            n, size, bno);
                        lockexit(32);
                }

                bno += block_incr;
                bf += wsize;
                size -= wsize;
                if (size < wsize)
                        wsize = size;
        }
}


/*
 * check if a block is available
 */
static int
isblock(struct fs *fs, unsigned char *cp, int h)
{
        unsigned char mask;

        switch (fs->fs_frag) {
        case 8:
                return (cp[h] == 0xff);
        case 4:
                mask = 0x0f << ((h & 0x1) << 2);
                return ((cp[h >> 1] & mask) == mask);
        case 2:
                mask = 0x03 << ((h & 0x3) << 1);
                return ((cp[h >> 2] & mask) == mask);
        case 1:
                mask = 0x01 << (h & 0x7);
                return ((cp[h >> 3] & mask) == mask);
        default:
                (void) fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
                return (0);
        }
}

/*
 * take a block out of the map
 */
static void
clrblock(struct fs *fs, unsigned char *cp, int h)
{
        switch ((fs)->fs_frag) {
        case 8:
                cp[h] = 0;
                return;
        case 4:
                cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
                return;
        case 2:
                cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
                return;
        case 1:
                cp[h >> 3] &= ~(0x01 << (h & 0x7));
                return;
        default:
                (void) fprintf(stderr,
                    gettext("clrblock: bad fs_frag value %d\n"), fs->fs_frag);
                return;
        }
}

/*
 * put a block into the map
 */
static void
setblock(struct fs *fs, unsigned char *cp, int h)
{
        switch (fs->fs_frag) {
        case 8:
                cp[h] = 0xff;
                return;
        case 4:
                cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
                return;
        case 2:
                cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
                return;
        case 1:
                cp[h >> 3] |= (0x01 << (h & 0x7));
                return;
        default:
                (void) fprintf(stderr,
                    gettext("setblock: bad fs_frag value %d\n"), fs->fs_frag);
                return;
        }
}

static void
usage()
{
        (void) fprintf(stderr,
            gettext("ufs usage: mkfs [-F FSType] [-V] [-m] [-o options] "
            "special "                          /* param 0 */
            "size(sectors) \\ \n"));            /* param 1 */
        (void) fprintf(stderr,
            "[nsect "                           /* param 2 */
            "ntrack "                           /* param 3 */
            "bsize "                            /* param 4 */
            "fragsize "                         /* param 5 */
            "cpg "                              /* param 6 */
            "free "                             /* param 7 */
            "rps "                              /* param 8 */
            "nbpi "                             /* param 9 */
            "opt "                              /* param 10 */
            "apc "                              /* param 11 */
            "gap "                              /* param 12 */
            "nrpos "                            /* param 13 */
            "maxcontig "                        /* param 14 */
            "mtb]\n");                          /* param 15 */
        (void) fprintf(stderr,
            gettext(" -m : dump fs cmd line used to make this partition\n"
            " -V :print this command line and return\n"
            " -o :ufs options: :nsect=%d,ntrack=%d,bsize=%d,fragsize=%d\n"
            " -o :ufs options: :cgsize=%d,free=%d,rps=%d,nbpi=%d,opt=%c\n"
            " -o :ufs options: :apc=%d,gap=%d,nrpos=%d,maxcontig=%d\n"
            " -o :ufs options: :mtb=%c,calcsb,calcbinsb\n"
"NOTE that all -o suboptions: must be separated only by commas so as to\n"
"be parsed as a single argument\n"),
            nsect, ntrack, bsize, fragsize, cpg, sblock.fs_minfree, rps,
            nbpi, opt, apc, (rotdelay == -1) ? 0 : rotdelay,
            sblock.fs_nrpos, maxcontig, mtb);
        lockexit(32);
}

/*ARGSUSED*/
static void
dump_fscmd(char *fsys, int fsi)
{
        int64_t used, bpcg, inospercg;
        int64_t nbpi;
        uint64_t nbytes64;

        bzero((char *)&sblock, sizeof (sblock));
        rdfs((diskaddr_t)SBLOCK, SBSIZE, (char *)&sblock);

        /*
         * ensure a valid file system and if not, exit with error or else
         * we will end up computing block numbers etc and dividing by zero
         * which will cause floating point errors in this routine.
         */

        if ((sblock.fs_magic != FS_MAGIC) &&
            (sblock.fs_magic != MTB_UFS_MAGIC)) {
                (void) fprintf(stderr, gettext(
                    "[not currently a valid file system - bad superblock]\n"));
                lockexit(32);
        }

        if (sblock.fs_magic == FS_MAGIC &&
            (sblock.fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
            sblock.fs_version != UFS_VERSION_MIN)) {
                (void) fprintf(stderr, gettext(
                    "Unknown version of UFS format: %d\n"), sblock.fs_version);
                lockexit(32);
        }

        if (sblock.fs_magic == MTB_UFS_MAGIC &&
            (sblock.fs_version > MTB_UFS_VERSION_1 ||
            sblock.fs_version < MTB_UFS_VERSION_MIN)) {
                (void) fprintf(stderr, gettext(
                    "Unknown version of UFS format: %d\n"), sblock.fs_version);
                lockexit(32);
        }

        /*
         * Compute a reasonable nbpi value.
         * The algorithm for "used" is copied from code
         * in main() verbatim.
         * The nbpi equation is taken from main where the
         * fs_ipg value is set for the last time.  The INOPB(...) - 1
         * is used to account for the roundup.
         * The problem is that a range of nbpi values map to
         * the same file system layout.  So it is not possible
         * to calculate the exact value specified when the file
         * system was created.  So instead we determine the top
         * end of the range of values.
         */
        bpcg = sblock.fs_spc * sectorsize;
        inospercg = (int64_t)roundup(bpcg / sizeof (struct dinode),
            INOPB(&sblock));
        if (inospercg > MAXIpG(&sblock))
                inospercg = MAXIpG(&sblock);
        used = (int64_t)
            (sblock.fs_iblkno + inospercg / INOPF(&sblock)) * NSPF(&sblock);
        used *= sectorsize;
        nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used;

        /*
         * The top end of the range of values for nbpi may not be
         * a valid command line value for mkfs. Report the bottom
         * end instead.
         */
        nbpi = (int64_t)(nbytes64 / (sblock.fs_ipg));

        (void) fprintf(stdout, gettext("mkfs -F ufs -o "), fsys);
        (void) fprintf(stdout, "nsect=%d,ntrack=%d,",
            sblock.fs_nsect, sblock.fs_ntrak);
        (void) fprintf(stdout, "bsize=%d,fragsize=%d,cgsize=%d,free=%d,",
            sblock.fs_bsize, sblock.fs_fsize, sblock.fs_cpg, sblock.fs_minfree);
        (void) fprintf(stdout, "rps=%d,nbpi=%lld,opt=%c,apc=%d,gap=%d,",
            sblock.fs_rps, nbpi, (sblock.fs_optim == FS_OPTSPACE) ? 's' : 't',
            (sblock.fs_ntrak * sblock.fs_nsect) - sblock.fs_spc,
            sblock.fs_rotdelay);
        (void) fprintf(stdout, "nrpos=%d,maxcontig=%d,mtb=%c ",
            sblock.fs_nrpos, sblock.fs_maxcontig,
            ((sblock.fs_magic == MTB_UFS_MAGIC) ? 'y' : 'n'));
        (void) fprintf(stdout, "%s %lld\n", fsys,
            fsbtodb(&sblock, sblock.fs_size));

        bzero((char *)&sblock, sizeof (sblock));
}

/* number ************************************************************* */
/*                                                                      */
/* Convert a numeric string arg to binary                               */
/*                                                                      */
/* Args:        d_value - default value, if have parse error            */
/*              param - the name of the argument, for error messages    */
/*              flags - parser state and what's allowed in the arg      */
/* Global arg:  string - pointer to command arg                         */
/*                                                                      */
/* Valid forms: 123 | 123k | 123*123 | 123x123                          */
/*                                                                      */
/* Return:      converted number                                        */
/*                                                                      */
/* ******************************************************************** */

static uint64_t
number(uint64_t d_value, char *param, int flags)
{
        char *cs;
        uint64_t n, t;
        uint64_t cut = BIG / 10;    /* limit to avoid overflow */
        int minus = 0;

        cs = string;
        if (*cs == '-') {
                minus = 1;
                cs += 1;
        }
        if ((*cs < '0') || (*cs > '9')) {
                goto bail_out;
        }
        n = 0;
        while ((*cs >= '0') && (*cs <= '9') && (n <= cut)) {
                n = n*10 + *cs++ - '0';
        }
        if (minus)
                n = -n;
        for (;;) {
                switch (*cs++) {
                case 'k':
                        if (flags & ALLOW_END_ONLY)
                                goto bail_out;
                        if (n > (BIG / 1024))
                                goto overflow;
                        n *= 1024;
                        continue;

                case '*':
                case 'x':
                        if (flags & ALLOW_END_ONLY)
                                goto bail_out;
                        string = cs;
                        t = number(d_value, param, flags);
                        if (n > (BIG / t))
                                goto overflow;
                        n *= t;
                        cs = string + 1; /* adjust for -- below */

                        /* recursion has read rest of expression */
                        /* FALLTHROUGH */

                case ',':
                case '\0':
                        cs--;
                        string = cs;
                        return (n);

                case '%':
                        if (flags & ALLOW_END_ONLY)
                                goto bail_out;
                        if (flags & ALLOW_PERCENT) {
                                flags &= ~ALLOW_PERCENT;
                                flags |= ALLOW_END_ONLY;
                                continue;
                        }
                        goto bail_out;

                case 'm':
                        if (flags & ALLOW_END_ONLY)
                                goto bail_out;
                        if (flags & ALLOW_MS1) {
                                flags &= ~ALLOW_MS1;
                                flags |= ALLOW_MS2;
                                continue;
                        }
                        goto bail_out;

                case 's':
                        if (flags & ALLOW_END_ONLY)
                                goto bail_out;
                        if (flags & ALLOW_MS2) {
                                flags &= ~ALLOW_MS2;
                                flags |= ALLOW_END_ONLY;
                                continue;
                        }
                        goto bail_out;

                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
overflow:
                        (void) fprintf(stderr,
                            gettext("mkfs: value for %s overflowed\n"),
                            param);
                        while ((*cs != '\0') && (*cs != ','))
                                cs++;
                        string = cs;
                        return (BIG);

                default:
bail_out:
                        (void) fprintf(stderr, gettext(
                            "mkfs: bad numeric arg for %s: \"%s\"\n"),
                            param, string);
                        while ((*cs != '\0') && (*cs != ','))
                                cs++;
                        string = cs;
                        if (d_value != NO_DEFAULT) {
                                (void) fprintf(stderr,
                                    gettext("mkfs: %s reset to default %lld\n"),
                                    param, d_value);
                                return (d_value);
                        }
                        lockexit(2);

                }
        } /* never gets here */
}

/* match ************************************************************** */
/*                                                                      */
/* Compare two text strings for equality                                */
/*                                                                      */
/* Arg:  s - pointer to string to match with a command arg              */
/* Global arg:  string - pointer to command arg                         */
/*                                                                      */
/* Return:      1 if match, 0 if no match                               */
/*              If match, also reset `string' to point to the text      */
/*              that follows the matching text.                         */
/*                                                                      */
/* ******************************************************************** */

static int
match(char *s)
{
        char *cs;

        cs = string;
        while (*cs++ == *s) {
                if (*s++ == '\0') {
                        goto t;
                }
        }
        if (*s != '\0') {
                return (0);
        }

t:
        cs--;
        string = cs;
        return (1);
}

/*
 * GROWFS ROUTINES
 */

/* ARGSUSED */
void
lockexit(int exitstatus)
{
        if (Pflag) {
                /* the probe mode neither changes nor locks the filesystem */
                exit(exitstatus);
        }

        /*
         * flush the dirty cylinder group
         */
        if (inlockexit == 0) {
                inlockexit = 1;
                flcg();
        }

        if (aio_inited) {
                flush_writes();
        }

        /*
         * make sure the file system is unlocked before exiting
         */
        if ((inlockexit == 1) && (!isbad)) {
                inlockexit = 2;
                ulockfs();
                /*
                 * if logging was enabled, then re-enable it
                 */
                if (waslog) {
                        if (rl_log_control(fsys, _FIOLOGENABLE) != RL_SUCCESS) {
                                (void) fprintf(stderr, gettext(
                                    "failed to re-enable logging\n"));
                        }
                }
        } else if (grow) {
                if (isbad) {
                        (void) fprintf(stderr, gettext(
                            "Filesystem is currently inconsistent.  It "
                            "must be repaired with fsck(1M)\nbefore being "
                            "used.  Use the following command to "
                            "do this:\n\n\tfsck %s\n\n"), fsys);

                        if (ismounted) {
                                (void) fprintf(stderr, gettext(
                                    "You will be told that the filesystem "
                                    "is already mounted, and asked if you\n"
                                    "wish to continue.  Answer `yes' to "
                                    "this question.\n\n"));
                        }

                        (void) fprintf(stderr, gettext(
                            "One problem should be reported, that the summary "
                            "information is bad.\nYou will then be asked if it "
                            "should be salvaged.  Answer `yes' to\nthis "
                            "question.\n\n"));
                }

                if (ismounted) {
                        /*
                         * In theory, there's no way to get here without
                         * isbad also being set, but be robust in the
                         * face of future code changes.
                         */
                        (void) fprintf(stderr, gettext(
                            "The filesystem is currently mounted "
                            "read-only and write-locked.  "));
                        if (isbad) {
                                (void) fprintf(stderr, gettext(
                                    "After\nrunning fsck, unlock the "
                                    "filesystem and "));
                        } else {
                                (void) fprintf(stderr, gettext(
                                    "Unlock the filesystem\nand "));
                        }

                        (void) fprintf(stderr, gettext(
                            "re-enable writing with\nthe following "
                            "command:\n\n\tlockfs -u %s\n\n"), directory);
                }
        }

        exit(exitstatus);
}

void
randomgeneration()
{
        int              i;
        struct dinode   *dp;

        /*
         * always perform fsirand(1) function... newfs will notice that
         * the inodes have been randomized and will not call fsirand itself
         */
        for (i = 0, dp = zino; i < sblock.fs_inopb; ++i, ++dp)
                IRANDOMIZE(&dp->di_ic);
}

/*
 * Check the size of the summary information.
 * Fields in sblock are not changed in this function.
 *
 * For an 8K filesystem block, the maximum number of cylinder groups is 16384.
 *     MAXCSBUFS {32}  *   8K  {FS block size}
 *                         divided by (sizeof csum) {16}
 *
 * Note that MAXCSBUFS is not used in the kernel; as of Solaris 2.6 build 32,
 * this is the only place where it's referenced.
 */
void
checksummarysize()
{
        diskaddr_t      dmax;
        diskaddr_t      dmin;
        int64_t cg0frags;
        int64_t cg0blocks;
        int64_t maxncg;
        int64_t maxfrags;
        uint64_t        fs_size;
        uint64_t maxfs_blocks; /* filesystem blocks for max filesystem size */

        /*
         * compute the maximum summary info size
         */
        dmin = cgdmin(&sblock, 0);
        dmax = cgbase(&sblock, 0) + sblock.fs_fpg;
        fs_size = (grow) ? grow_fs_size : sblock.fs_size;
        if (dmax > fs_size)
                dmax = fs_size;
        cg0frags  = dmax - dmin;
        cg0blocks = cg0frags / sblock.fs_frag;
        cg0frags = cg0blocks * sblock.fs_frag;
        maxncg   = (longlong_t)cg0blocks *
            (longlong_t)(sblock.fs_bsize / sizeof (struct csum));

        maxfs_blocks = FS_MAX;

        if (maxncg > ((longlong_t)maxfs_blocks / (longlong_t)sblock.fs_fpg) + 1)
                maxncg = ((longlong_t)maxfs_blocks /
                    (longlong_t)sblock.fs_fpg) + 1;

        maxfrags = maxncg * (longlong_t)sblock.fs_fpg;

        if (maxfrags > maxfs_blocks)
                maxfrags = maxfs_blocks;


        /*
         * remember for later processing in extendsummaryinfo()
         */
        if (test)
                grow_sifrag = dmin + (cg0blocks * sblock.fs_frag);
        if (testfrags == 0)
                testfrags = cg0frags;
        if (testforce)
                if (testfrags > cg0frags) {
                        (void) fprintf(stderr,
                            gettext("Too many test frags (%lld); "
                            "try %lld\n"), testfrags, cg0frags);
                        lockexit(32);
                }

        /*
         * if summary info is too large (too many cg's) tell the user and exit
         */
        if ((longlong_t)sblock.fs_size > maxfrags) {
                (void) fprintf(stderr, gettext(
                    "Too many cylinder groups with %llu sectors;\n    try "
                    "increasing cgsize, or decreasing fssize to %llu\n"),
                    fsbtodb(&sblock, (uint64_t)sblock.fs_size),
                    fsbtodb(&sblock, (uint64_t)maxfrags));
                lockexit(32);
        }
}

/*
 * checksblock() has two uses:
 *      - One is to sanity test the superblock and is used when newfs(1M)
 *        is invoked with the "-N" option. If any discrepancy was found,
 *        just return whatever error was found and do not exit.
 *      - the other use of it is in places where you expect the superblock
 *        to be sane, and if it isn't, then we exit.
 * Which of the above two actions to take is indicated with the second argument.
 */

int
checksblock(struct fs sb, int proceed)
{
        int err = 0;
        char *errmsg;

        if ((sb.fs_magic != FS_MAGIC) && (sb.fs_magic != MTB_UFS_MAGIC)) {
                err = 1;
                errmsg = gettext("Bad superblock; magic number wrong\n");
        } else if ((sb.fs_magic == FS_MAGIC &&
            (sb.fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
            sb.fs_version != UFS_VERSION_MIN)) ||
            (sb.fs_magic == MTB_UFS_MAGIC &&
            (sb.fs_version > MTB_UFS_VERSION_1 ||
            sb.fs_version < MTB_UFS_VERSION_MIN))) {
                err = 2;
                errmsg = gettext("Unrecognized version of UFS\n");
        } else if (sb.fs_ncg < 1) {
                err = 3;
                errmsg = gettext("Bad superblock; ncg out of range\n");
        } else if (sb.fs_cpg < 1) {
                err = 4;
                errmsg = gettext("Bad superblock; cpg out of range\n");
        } else if (sb.fs_ncg * sb.fs_cpg < sb.fs_ncyl ||
            (sb.fs_ncg - 1) * sb.fs_cpg >= sb.fs_ncyl) {
                err = 5;
                errmsg = gettext("Bad superblock; ncyl out of range\n");
        } else if (sb.fs_sbsize <= 0 || sb.fs_sbsize > sb.fs_bsize) {
                err = 6;
                errmsg = gettext("Bad superblock; superblock size out of "
                    "range\n");
        }

        if (proceed) {
                if (err) dprintf(("%s", errmsg));
                return (err);
        }

        if (err) {
                fprintf(stderr, "%s", errmsg);
                lockexit(32);
        }
        return (32);
}

/*
 * Roll the embedded log, if any, and set up the global variables
 * islog and islogok.
 */
static void
logsetup(char *devstr)
{
        void            *buf, *ud_buf;
        extent_block_t  *ebp;
        ml_unit_t       *ul;
        ml_odunit_t     *ud;

        /*
         * Does the superblock indicate that we are supposed to have a log ?
         */
        if (sblock.fs_logbno == 0) {
                /*
                 * No log present, nothing to do.
                 */
                islog = 0;
                islogok = 0;
                return;
        } else {
                /*
                 * There's a log in a yet unknown state, attempt to roll it.
                 */
                islogok = 0;

                /*
                 * We failed to roll the log, bail out.
                 */
                if (rl_roll_log(devstr) != RL_SUCCESS)
                        return;

                islog = 1;

                /* log is not okay; check the fs */
                if ((FSOKAY != (sblock.fs_state + sblock.fs_time)) ||
                    (sblock.fs_clean != FSLOG))
                        return;

                /* get the log allocation block */
                buf = (void *)malloc(DEV_BSIZE);
                if (buf == NULL)
                        return;

                ud_buf = (void *)malloc(DEV_BSIZE);
                if (ud_buf == NULL) {
                        free(buf);
                        return;
                }

                rdfs((diskaddr_t)logbtodb(&sblock, sblock.fs_logbno),
                    DEV_BSIZE, buf);
                ebp = (extent_block_t *)buf;

                /* log allocation block is not okay; check the fs */
                if (ebp->type != LUFS_EXTENTS) {
                        free(buf);
                        free(ud_buf);
                        return;
                }

                /* get the log state block(s) */
                rdfs((diskaddr_t)logbtodb(&sblock, ebp->extents[0].pbno),
                    DEV_BSIZE, ud_buf);
                ud = (ml_odunit_t *)ud_buf;
                ul = (ml_unit_t *)malloc(sizeof (*ul));
                ul->un_ondisk = *ud;

                /* log state is okay */
                if ((ul->un_chksum == ul->un_head_ident + ul->un_tail_ident) &&
                    (ul->un_version == LUFS_VERSION_LATEST) &&
                    (ul->un_badlog == 0))
                        islogok = 1;
                free(ud_buf);
                free(buf);
                free(ul);
        }
}

void
growinit(char *devstr)
{
        int     i;
        char    buf[DEV_BSIZE];

        /*
         * Read and verify the superblock
         */
        rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock);
        (void) checksblock(sblock, 0);
        if (sblock.fs_postblformat != FS_DYNAMICPOSTBLFMT) {
                (void) fprintf(stderr,
                    gettext("old file system format; can't growfs\n"));
                lockexit(32);
        }

        /*
         * can't shrink a file system
         */
        grow_fssize = fsbtodb(&sblock, (uint64_t)sblock.fs_size);
        if (fssize_db < grow_fssize) {
                (void) fprintf(stderr,
                    gettext("%lld sectors < current size of %lld sectors\n"),
                    fssize_db, grow_fssize);
                lockexit(32);
        }

        /*
         * can't grow a system to over a terabyte unless it was set up
         * as an MTB UFS file system.
         */
        if (mtb == 'y' && sblock.fs_magic != MTB_UFS_MAGIC) {
                if (fssize_db >= SECTORS_PER_TERABYTE) {
                        (void) fprintf(stderr, gettext(
"File system was not set up with the multi-terabyte format.\n"));
                        (void) fprintf(stderr, gettext(
"Its size cannot be increased to a terabyte or more.\n"));
                } else {
                        (void) fprintf(stderr, gettext(
"Cannot convert file system to multi-terabyte format.\n"));
                }
                lockexit(32);
        }

        logsetup(devstr);

        /*
         * can't growfs when logging device has errors
         */
        if ((islog && !islogok) ||
            ((FSOKAY == (sblock.fs_state + sblock.fs_time)) &&
            (sblock.fs_clean == FSLOG && !islog))) {
                (void) fprintf(stderr,
                    gettext("logging device has errors; can't growfs\n"));
                lockexit(32);
        }

        /*
         * disable ufs logging for growing
         */
        if (islog) {
                if (rl_log_control(devstr, _FIOLOGDISABLE) != RL_SUCCESS) {
                        (void) fprintf(stderr, gettext(
                            "failed to disable logging\n"));
                        lockexit(32);
                }
                islog = 0;
                waslog = 1;
        }

        /*
         * if mounted write lock the file system to be grown
         */
        if (ismounted)
                wlockfs();

        /*
         * refresh dynamic superblock state - disabling logging will have
         * changed the amount of free space available in the file system
         */
        rdfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock);

        /*
         * make sure device is big enough
         */
        rdfs((diskaddr_t)fssize_db - 1, DEV_BSIZE, buf);
        wtfs((diskaddr_t)fssize_db - 1, DEV_BSIZE, buf);

        /*
         * read current summary information
         */
        grow_fscs = read_summaryinfo(&sblock);

        /*
         * save some current size related fields from the superblock
         * These are used in extendsummaryinfo()
         */
        grow_fs_size    = sblock.fs_size;
        grow_fs_ncg     = sblock.fs_ncg;
        grow_fs_csaddr  = (diskaddr_t)sblock.fs_csaddr;
        grow_fs_cssize  = sblock.fs_cssize;

        /*
         * save and reset the clean flag
         */
        if (FSOKAY == (sblock.fs_state + sblock.fs_time))
                grow_fs_clean = sblock.fs_clean;
        else
                grow_fs_clean = FSBAD;
        sblock.fs_clean = FSBAD;
        sblock.fs_state = FSOKAY - sblock.fs_time;
        isbad = 1;
        wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock);
}

void
checkdev(char *rdev, char *bdev)
{
        struct stat64   statarea;

        if (stat64(bdev, &statarea) < 0) {
                (void) fprintf(stderr, gettext("can't check mount point; "));
                (void) fprintf(stderr, gettext("can't stat %s\n"), bdev);
                lockexit(32);
        }
        if ((statarea.st_mode & S_IFMT) != S_IFBLK) {
                (void) fprintf(stderr, gettext(
                    "can't check mount point; %s is not a block device\n"),
                    bdev);
                lockexit(32);
        }
        if (stat64(rdev, &statarea) < 0) {
                (void) fprintf(stderr, gettext("can't stat %s\n"), rdev);
                lockexit(32);
        }
        if ((statarea.st_mode & S_IFMT) != S_IFCHR) {
                (void) fprintf(stderr,
                    gettext("%s is not a character device\n"), rdev);
                lockexit(32);
        }
}

void
checkmount(struct mnttab *mntp, char *bdevname)
{
        struct stat64   statdir;
        struct stat64   statdev;

        if (strcmp(bdevname, mntp->mnt_special) == 0) {
                if (stat64(mntp->mnt_mountp, &statdir) == -1) {
                        (void) fprintf(stderr, gettext("can't stat %s\n"),
                            mntp->mnt_mountp);
                        lockexit(32);
                }
                if (stat64(mntp->mnt_special, &statdev) == -1) {
                        (void) fprintf(stderr, gettext("can't stat %s\n"),
                            mntp->mnt_special);
                        lockexit(32);
                }
                if (statdir.st_dev != statdev.st_rdev) {
                        (void) fprintf(stderr, gettext(
                            "%s is not mounted on %s; mnttab(4) wrong\n"),
                            mntp->mnt_special, mntp->mnt_mountp);
                        lockexit(32);
                }
                ismounted = 1;
                if (directory) {
                        if (strcmp(mntp->mnt_mountp, directory) != 0) {
                                (void) fprintf(stderr,
                                    gettext("%s is mounted on %s, not %s\n"),
                                    bdevname, mntp->mnt_mountp, directory);
                                lockexit(32);
                        }
                } else {
                        if (grow)
                                (void) fprintf(stderr, gettext(
                                    "%s is mounted on %s; can't growfs\n"),
                                    bdevname, mntp->mnt_mountp);
                        else
                                (void) fprintf(stderr,
                                    gettext("%s is mounted, can't mkfs\n"),
                                    bdevname);
                        lockexit(32);
                }
        }
}

struct dinode   *dibuf  = 0;
diskaddr_t      difrag  = 0;

struct dinode *
gdinode(ino_t ino)
{
        /*
         * read the block of inodes containing inode number ino
         */
        if (dibuf == 0)
                dibuf = (struct dinode *)malloc((unsigned)sblock.fs_bsize);
        if (itod(&sblock, ino) != difrag) {
                difrag = itod(&sblock, ino);
                rdfs(fsbtodb(&sblock, (uint64_t)difrag), (int)sblock.fs_bsize,
                    (char *)dibuf);
        }
        return (dibuf + (ino % INOPB(&sblock)));
}

/*
 * structure that manages the frags we need for extended summary info
 *      These frags can be:
 *              free
 *              data  block
 *              alloc block
 */
struct csfrag {
        struct csfrag   *next;          /* next entry */
        daddr32_t        ofrag;         /* old frag */
        daddr32_t        nfrag;         /* new frag */
        long             cylno;         /* cylno of nfrag */
        long             frags;         /* number of frags */
        long             size;          /* size in bytes */
        ino_t            ino;           /* inode number */
        long             fixed;         /* Boolean - Already fixed? */
};
struct csfrag   *csfrag;                /* state unknown */
struct csfrag   *csfragino;             /* frags belonging to an inode */
struct csfrag   *csfragfree;            /* frags that are free */

daddr32_t maxcsfrag     = 0;            /* maximum in range */
daddr32_t mincsfrag     = 0x7fffffff;   /* minimum in range */

int
csfraginrange(daddr32_t frag)
{
        return ((frag >= mincsfrag) && (frag <= maxcsfrag));
}

struct csfrag *
findcsfrag(daddr32_t frag, struct csfrag **cfap)
{
        struct csfrag   *cfp;

        if (!csfraginrange(frag))
                return (NULL);

        for (cfp = *cfap; cfp; cfp = cfp->next)
                if (cfp->ofrag == frag)
                        return (cfp);
        return (NULL);
}

void
checkindirect(ino_t ino, daddr32_t *fragsp, daddr32_t frag, int level)
{
        int                     i;
        int                     ne      = sblock.fs_bsize / sizeof (daddr32_t);
        daddr32_t                       fsb[MAXBSIZE / sizeof (daddr32_t)];

        if (frag == 0)
                return;

        rdfs(fsbtodb(&sblock, frag), (int)sblock.fs_bsize,
            (char *)fsb);

        checkdirect(ino, fragsp, fsb, sblock.fs_bsize / sizeof (daddr32_t));

        if (level)
                for (i = 0; i < ne && *fragsp; ++i)
                        checkindirect(ino, fragsp, fsb[i], level-1);
}

void
addcsfrag(ino_t ino, daddr32_t frag, struct csfrag **cfap)
{
        struct csfrag   *cfp, *curr, *prev;

        /*
         * establish a range for faster checking in csfraginrange()
         */
        if (frag > maxcsfrag)
                maxcsfrag = frag;
        if (frag < mincsfrag)
                mincsfrag = frag;

        /*
         * if this frag belongs to an inode and is not the start of a block
         *      then see if it is part of a frag range for this inode
         */
        if (ino && (frag % sblock.fs_frag))
                for (cfp = *cfap; cfp; cfp = cfp->next) {
                        if (ino != cfp->ino)
                                continue;
                        if (frag != cfp->ofrag + cfp->frags)
                                continue;
                        cfp->frags++;
                        cfp->size += sblock.fs_fsize;
                        return;
                }
        /*
         * allocate a csfrag entry and insert it in an increasing order into the
         * specified list
         */
        cfp = (struct csfrag *)calloc(1, sizeof (struct csfrag));
        cfp->ino        = ino;
        cfp->ofrag      = frag;
        cfp->frags      = 1;
        cfp->size       = sblock.fs_fsize;
        for (prev = NULL, curr = *cfap; curr != NULL;
            prev = curr, curr = curr->next) {
                if (frag < curr->ofrag) {
                        cfp->next = curr;
                        if (prev)
                                prev->next = cfp;       /* middle element */
                        else
                                *cfap = cfp;            /* first element */
                        break;
                }
                if (curr->next == NULL) {
                        curr->next = cfp;               /* last element */
                        break;
                }
        }
        if (*cfap == NULL)      /* will happen only once */
                *cfap = cfp;
}

void
delcsfrag(daddr32_t frag, struct csfrag **cfap)
{
        struct csfrag   *cfp;
        struct csfrag   **cfpp;

        /*
         * free up entry whose beginning frag matches
         */
        for (cfpp = cfap; *cfpp; cfpp = &(*cfpp)->next) {
                if (frag == (*cfpp)->ofrag) {
                        cfp = *cfpp;
                        *cfpp = (*cfpp)->next;
                        free((char *)cfp);
                        return;
                }
        }
}

/*
 * See whether any of the direct blocks in the array pointed by "db" and of
 * length "ne" are within the range of frags needed to extend the cylinder
 * summary. If so, remove those frags from the "as-yet-unclassified" list
 * (csfrag) and add them to the "owned-by-inode" list (csfragino).
 * For each such frag found, decrement the frag count pointed to by fragsp.
 * "ino" is the inode that contains (either directly or indirectly) the frags
 * being checked.
 */
void
checkdirect(ino_t ino, daddr32_t *fragsp, daddr32_t *db, int ne)
{
        int      i;
        int      j;
        int      found;
        diskaddr_t       frag;

        /*
         * scan for allocation within the new summary info range
         */
        for (i = 0; i < ne && *fragsp; ++i) {
                if ((frag = *db++) != 0) {
                        found = 0;
                        for (j = 0; j < sblock.fs_frag && *fragsp; ++j) {
                                if (found || (found = csfraginrange(frag))) {
                                        addcsfrag(ino, frag, &csfragino);
                                        delcsfrag(frag, &csfrag);
                                }
                                ++frag;
                                --(*fragsp);
                        }
                }
        }
}

void
findcsfragino()
{
        int              i;
        int              j;
        daddr32_t                frags;
        struct dinode   *dp;

        /*
         * scan all old inodes looking for allocations in the new
         * summary info range.  Move the affected frag from the
         * generic csfrag list onto the `owned-by-inode' list csfragino.
         */
        for (i = UFSROOTINO; i < grow_fs_ncg*sblock.fs_ipg && csfrag; ++i) {
                dp = gdinode((ino_t)i);
                switch (dp->di_mode & IFMT) {
                        case IFSHAD     :
                        case IFLNK      :
                        case IFDIR      :
                        case IFREG      : break;
                        default         : continue;
                }

                frags   = dbtofsb(&sblock, dp->di_blocks);

                checkdirect((ino_t)i, &frags, &dp->di_db[0], NDADDR+NIADDR);
                for (j = 0; j < NIADDR && frags; ++j) {
                        /* Negate the block if its an fallocate'd block */
                        if (dp->di_ib[j] < 0 && dp->di_ib[j] != UFS_HOLE)
                                checkindirect((ino_t)i, &frags,
                                    -(dp->di_ib[j]), j);
                        else
                                checkindirect((ino_t)i, &frags,
                                    dp->di_ib[j], j);
                }
        }
}

void
fixindirect(daddr32_t frag, int level)
{
        int                      i;
        int                      ne     = sblock.fs_bsize / sizeof (daddr32_t);
        daddr32_t                       fsb[MAXBSIZE / sizeof (daddr32_t)];

        if (frag == 0)
                return;

        rdfs(fsbtodb(&sblock, (uint64_t)frag), (int)sblock.fs_bsize,
            (char *)fsb);

        fixdirect((caddr_t)fsb, frag, fsb, ne);

        if (level)
                for (i = 0; i < ne; ++i)
                        fixindirect(fsb[i], level-1);
}

void
fixdirect(caddr_t bp, daddr32_t frag, daddr32_t *db, int ne)
{
        int      i;
        struct csfrag   *cfp;

        for (i = 0; i < ne; ++i, ++db) {
                if (*db == 0)
                        continue;
                if ((cfp = findcsfrag(*db, &csfragino)) == NULL)
                        continue;
                *db = cfp->nfrag;
                cfp->fixed = 1;
                wtfs(fsbtodb(&sblock, (uint64_t)frag), (int)sblock.fs_bsize,
                    bp);
        }
}

void
fixcsfragino()
{
        int              i;
        struct dinode   *dp;
        struct csfrag   *cfp;

        for (cfp = csfragino; cfp; cfp = cfp->next) {
                if (cfp->fixed)
                        continue;
                dp = gdinode((ino_t)cfp->ino);
                fixdirect((caddr_t)dibuf, difrag, dp->di_db, NDADDR+NIADDR);
                for (i = 0; i < NIADDR; ++i)
                        fixindirect(dp->di_ib[i], i);
        }
}

/*
 * Read the cylinders summary information specified by settings in the
 * passed 'fs' structure into a new allocated array of csum structures.
 * The caller is responsible for freeing the returned array.
 * Return a pointer to an array of csum structures.
 */
static struct csum *
read_summaryinfo(struct fs *fsp)
{
        struct csum     *csp;
        int             i;

        if ((csp = malloc((size_t)fsp->fs_cssize)) == NULL) {
                (void) fprintf(stderr, gettext("cannot create csum list,"
                    " not enough memory\n"));
                exit(32);
        }

        for (i = 0; i < fsp->fs_cssize; i += fsp->fs_bsize) {
                rdfs(fsbtodb(fsp,
                    (uint64_t)(fsp->fs_csaddr + numfrags(fsp, i))),
                    (int)(fsp->fs_cssize - i < fsp->fs_bsize ?
                    fsp->fs_cssize - i : fsp->fs_bsize), ((caddr_t)csp) + i);
        }

        return (csp);
}

/*
 * Check the allocation of fragments that are to be made part of a csum block.
 * A fragment is allocated if it is either in the csfragfree list or, it is
 * in the csfragino list and has new frags associated with it.
 * Return the number of allocated fragments.
 */
int64_t
checkfragallocated(daddr32_t frag)
{
        struct  csfrag  *cfp;
        /*
         * Since the lists are sorted we can break the search if the asked
         * frag is smaller then the one in the list.
         */
        for (cfp = csfragfree; cfp != NULL && frag >= cfp->ofrag;
            cfp = cfp->next) {
                if (frag == cfp->ofrag)
                        return (1);
        }
        for (cfp = csfragino; cfp != NULL && frag >= cfp->ofrag;
            cfp = cfp->next) {
                if (frag == cfp->ofrag && cfp->nfrag != 0)
                        return (cfp->frags);
        }

        return (0);
}

/*
 * Figure out how much the filesystem can be grown. The limiting factor is
 * the available free space needed to extend the cg summary info block.
 * The free space is determined in three steps:
 * - Try to extend the cg summary block to the required size.
 * - Find free blocks in last cg.
 * - Find free space in the last already allocated fragment of the summary info
 *   block, and use it for additional csum structures.
 * Return the maximum size of the new filesystem or 0 if it can't be grown.
 * Please note that this function leaves the global list pointers csfrag,
 * csfragfree, and csfragino initialized, and the caller is responsible for
 * freeing the lists.
 */
diskaddr_t
probe_summaryinfo()
{
        /* fragments by which the csum block can be extended. */
        int64_t         growth_csum_frags = 0;
        /* fragments by which the filesystem can be extended. */
        int64_t         growth_fs_frags = 0;
        int64_t         new_fs_cssize;  /* size of csum blk in the new FS */
        int64_t         new_fs_ncg;     /* number of cg in the new FS */
        int64_t         spare_csum;
        daddr32_t       oldfrag_daddr;
        daddr32_t       newfrag_daddr;
        daddr32_t       daddr;
        int             i;

        /*
         * read and verify the superblock
         */
        rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock);
        (void) checksblock(sblock, 0);

        /*
         * check how much we can extend the cg summary info block
         */

        /*
         * read current summary information
         */
        fscs = read_summaryinfo(&sblock);

        /*
         * build list of frags needed for cg summary info block extension
         */
        oldfrag_daddr = howmany(sblock.fs_cssize, sblock.fs_fsize) +
            sblock.fs_csaddr;
        new_fs_ncg = howmany(dbtofsb(&sblock, fssize_db), sblock.fs_fpg);
        new_fs_cssize = fragroundup(&sblock, new_fs_ncg * sizeof (struct csum));
        newfrag_daddr = howmany(new_fs_cssize, sblock.fs_fsize) +
            sblock.fs_csaddr;
        /*
         * add all of the frags that are required to grow the cyl summary to the
         * csfrag list, which is the generic/unknown list, since at this point
         * we don't yet know the state of those frags.
         */
        for (daddr = oldfrag_daddr; daddr < newfrag_daddr; daddr++)
                addcsfrag((ino_t)0, daddr, &csfrag);

        /*
         * filter free fragments and allocate them. Note that the free frags
         * must be allocated first otherwise they could be grabbed by
         * alloccsfragino() for data frags.
         */
        findcsfragfree();
        alloccsfragfree();

        /*
         * filter fragments owned by inodes and allocate them
         */
        grow_fs_ncg = sblock.fs_ncg; /* findcsfragino() needs this glob. var. */
        findcsfragino();
        alloccsfragino();

        if (notenoughspace()) {
                /*
                 * check how many consecutive fragments could be allocated
                 * in both lists.
                 */
                int64_t tmp_frags;
                for (daddr = oldfrag_daddr; daddr < newfrag_daddr;
                    daddr += tmp_frags) {
                        if ((tmp_frags = checkfragallocated(daddr)) > 0)
                                growth_csum_frags += tmp_frags;
                        else
                                break;
                }
        } else {
                /*
                 * We have all we need for the new desired size,
                 * so clean up and report back.
                 */
                return (fssize_db);
        }

        /*
         * given the number of fragments by which the csum block can be grown
         * compute by how many new fragments the FS can be increased.
         * It is the number of csum instances per fragment multiplied by
         * `growth_csum_frags' and the number of fragments per cylinder group.
         */
        growth_fs_frags = howmany(sblock.fs_fsize, sizeof (struct csum)) *
            growth_csum_frags * sblock.fs_fpg;

        /*
         * compute free fragments in the last cylinder group
         */
        rdcg(sblock.fs_ncg - 1);
        growth_fs_frags += sblock.fs_fpg - acg.cg_ndblk;

        /*
         * compute how many csum instances are unused in the old csum block.
         * For each unused csum instance the FS can be grown by one cylinder
         * group without extending the csum block.
         */
        spare_csum = howmany(sblock.fs_cssize, sizeof (struct csum)) -
            sblock.fs_ncg;
        if (spare_csum > 0)
                growth_fs_frags += spare_csum * sblock.fs_fpg;

        /*
         * recalculate the new filesystem size in sectors, shorten it by
         * the requested size `fssize_db' if necessary.
         */
        if (growth_fs_frags > 0) {
                diskaddr_t sect;
                sect = (sblock.fs_size + growth_fs_frags) * sblock.fs_nspf;
                return ((sect > fssize_db) ? fssize_db : sect);
        }

        return (0);
}

void
extendsummaryinfo()
{
        int64_t         i;
        int             localtest       = test;
        int64_t         frags;
        daddr32_t               oldfrag;
        daddr32_t               newfrag;

        /*
         * if no-write (-N), don't bother
         */
        if (Nflag)
                return;

again:
        flcg();
        /*
         * summary info did not change size -- do nothing unless in test mode
         */
        if (grow_fs_cssize == sblock.fs_cssize)
                if (!localtest)
                        return;

        /*
         * build list of frags needed for additional summary information
         */
        oldfrag = howmany(grow_fs_cssize, sblock.fs_fsize) + grow_fs_csaddr;
        newfrag = howmany(sblock.fs_cssize, sblock.fs_fsize) + grow_fs_csaddr;
        /*
         * add all of the frags that are required to grow the cyl summary to the
         * csfrag list, which is the generic/unknown list, since at this point
         * we don't yet know the state of those frags.
         */
        for (i = oldfrag, frags = 0; i < newfrag; ++i, ++frags)
                addcsfrag((ino_t)0, (diskaddr_t)i, &csfrag);
        /*
         * reduce the number of data blocks in the file system (fs_dsize) by
         * the number of frags that need to be added to the cyl summary
         */
        sblock.fs_dsize -= (newfrag - oldfrag);

        /*
         * In test mode, we move more data than necessary from
         * cylinder group 0.  The lookup/allocate/move code can be
         * better stressed without having to create HUGE file systems.
         */
        if (localtest)
                for (i = newfrag; i < grow_sifrag; ++i) {
                        if (frags >= testfrags)
                                break;
                        frags++;
                        addcsfrag((ino_t)0, (diskaddr_t)i, &csfrag);
                }

        /*
         * move frags to free or inode lists, depending on owner
         */
        findcsfragfree();
        findcsfragino();

        /*
         * if not all frags can be located, file system must be inconsistent
         */
        if (csfrag) {
                isbad = 1;      /* should already be set, but make sure */
                lockexit(32);
        }

        /*
         * allocate the free frags. Note that the free frags must be allocated
         * first otherwise they could be grabbed by alloccsfragino() for data
         * frags.
         */
        alloccsfragfree();
        /*
         * allocate extra space for inode frags
         */
        alloccsfragino();

        /*
         * not enough space
         */
        if (notenoughspace()) {
                unalloccsfragfree();
                unalloccsfragino();
                if (localtest && !testforce) {
                        localtest = 0;
                        goto again;
                }
                (void) fprintf(stderr, gettext("Not enough free space\n"));
                lockexit(NOTENOUGHSPACE);
        }

        /*
         * copy the data from old frags to new frags
         */
        copycsfragino();

        /*
         * fix the inodes to point to the new frags
         */
        fixcsfragino();

        /*
         * We may have moved more frags than we needed.  Free them.
         */
        rdcg((long)0);
        for (i = newfrag; i <= maxcsfrag; ++i)
                setbit(cg_blksfree(&acg), i-cgbase(&sblock, 0));
        wtcg();

        flcg();
}

/*
 * Check if all fragments in the `csfragino' list were reallocated.
 */
int
notenoughspace()
{
        struct csfrag   *cfp;

        /*
         * If any element in the csfragino array has a "new frag location"
         * of 0, the allocfrags() function was unsuccessful in allocating
         * space for moving the frag represented by this array element.
         */
        for (cfp = csfragino; cfp; cfp = cfp->next)
                if (cfp->nfrag == 0)
                        return (1);
        return (0);
}

void
unalloccsfragino()
{
        struct csfrag   *cfp;

        while ((cfp = csfragino) != NULL) {
                if (cfp->nfrag)
                        freefrags(cfp->nfrag, cfp->frags, cfp->cylno);
                delcsfrag(cfp->ofrag, &csfragino);
        }
}

void
unalloccsfragfree()
{
        struct csfrag   *cfp;

        while ((cfp = csfragfree) != NULL) {
                freefrags(cfp->ofrag, cfp->frags, cfp->cylno);
                delcsfrag(cfp->ofrag, &csfragfree);
        }
}

/*
 * For each frag in the "as-yet-unclassified" list (csfrag), see if
 * it's free (i.e., its bit is set in the free frag bit map).  If so,
 * move it from the "as-yet-unclassified" list to the csfragfree list.
 */
void
findcsfragfree()
{
        struct csfrag   *cfp;
        struct csfrag   *cfpnext;

        /*
         * move free frags onto the free-frag list
         */
        rdcg((long)0);
        for (cfp = csfrag; cfp; cfp = cfpnext) {
                cfpnext = cfp->next;
                if (isset(cg_blksfree(&acg), cfp->ofrag - cgbase(&sblock, 0))) {
                        addcsfrag(cfp->ino, cfp->ofrag, &csfragfree);
                        delcsfrag(cfp->ofrag, &csfrag);
                }
        }
}

void
copycsfragino()
{
        struct csfrag   *cfp;
        char            buf[MAXBSIZE];

        /*
         * copy data from old frags to newly allocated frags
         */
        for (cfp = csfragino; cfp; cfp = cfp->next) {
                rdfs(fsbtodb(&sblock, (uint64_t)cfp->ofrag), (int)cfp->size,
                    buf);
                wtfs(fsbtodb(&sblock, (uint64_t)cfp->nfrag), (int)cfp->size,
                    buf);
        }
}

long    curcylno        = -1;
int     cylnodirty      = 0;

void
rdcg(long cylno)
{
        if (cylno != curcylno) {
                flcg();
                curcylno = cylno;
                rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, curcylno)),
                    (int)sblock.fs_cgsize, (char *)&acg);
        }
}

void
flcg()
{
        if (cylnodirty) {
                if (debug && Pflag) {
                        (void) fprintf(stderr,
                            "Assert: cylnodirty set in probe mode\n");
                        return;
                }
                resetallocinfo();
                wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, curcylno)),
                    (int)sblock.fs_cgsize, (char *)&acg);
                cylnodirty = 0;
        }
        curcylno = -1;
}

void
wtcg()
{
        if (!Pflag) {
                /* probe mode should never write to disk */
                cylnodirty = 1;
        }
}

void
allocfrags(long frags, daddr32_t *fragp, long *cylnop)
{
        int      i;
        int      j;
        long     bits;
        long     bit;

        /*
         * Allocate a free-frag range in an old cylinder group
         */
        for (i = 0, *fragp = 0; i < grow_fs_ncg; ++i) {
                if (((fscs+i)->cs_nffree < frags) && ((fscs+i)->cs_nbfree == 0))
                        continue;
                rdcg((long)i);
                bit = bits = 0;
                while (findfreerange(&bit, &bits)) {
                        if (frags <= bits)  {
                                for (j = 0; j < frags; ++j)
                                        clrbit(cg_blksfree(&acg), bit+j);
                                wtcg();
                                *cylnop = i;
                                *fragp  = bit + cgbase(&sblock, i);
                                return;
                        }
                        bit += bits;
                }
        }
}

/*
 * Allocate space for frags that need to be moved in order to free up space for
 * expanding the cylinder summary info.
 * For each frag that needs to be moved (each frag or range of frags in
 * the csfragino list), allocate a new location and store the frag number
 * of that new location in the nfrag field of the csfrag struct.
 * If a new frag can't be allocated for any element in the csfragino list,
 * set the new frag number for that element to 0 and return immediately.
 * The notenoughspace() function will detect this condition.
 */
void
alloccsfragino()
{
        struct csfrag   *cfp;

        /*
         * allocate space for inode frag ranges
         */
        for (cfp = csfragino; cfp; cfp = cfp->next) {
                allocfrags(cfp->frags, &cfp->nfrag, &cfp->cylno);
                if (cfp->nfrag == 0)
                        break;
        }
}

void
alloccsfragfree()
{
        struct csfrag   *cfp;

        /*
         * allocate the free frags needed for extended summary info
         */
        rdcg((long)0);

        for (cfp = csfragfree; cfp; cfp = cfp->next)
                clrbit(cg_blksfree(&acg), cfp->ofrag - cgbase(&sblock, 0));

        wtcg();
}

void
freefrags(daddr32_t frag, long frags, long cylno)
{
        int     i;

        /*
         * free frags
         */
        rdcg(cylno);
        for (i = 0; i < frags; ++i) {
                setbit(cg_blksfree(&acg), (frag+i) - cgbase(&sblock, cylno));
        }
        wtcg();
}

int
findfreerange(long *bitp, long *bitsp)
{
        long     bit;

        /*
         * find a range of free bits in a cylinder group bit map
         */
        for (bit = *bitp, *bitsp = 0; bit < acg.cg_ndblk; ++bit)
                if (isset(cg_blksfree(&acg), bit))
                        break;

        if (bit >= acg.cg_ndblk)
                return (0);

        *bitp  = bit;
        *bitsp = 1;
        for (++bit; bit < acg.cg_ndblk; ++bit, ++(*bitsp)) {
                if ((bit % sblock.fs_frag) == 0)
                        break;
                if (isclr(cg_blksfree(&acg), bit))
                        break;
        }
        return (1);
}

void
resetallocinfo()
{
        long    cno;
        long    bit;
        long    bits;

        /*
         * Compute the free blocks/frags info and update the appropriate
         * inmemory superblock, summary info, and cylinder group fields
         */
        sblock.fs_cstotal.cs_nffree -= acg.cg_cs.cs_nffree;
        sblock.fs_cstotal.cs_nbfree -= acg.cg_cs.cs_nbfree;

        acg.cg_cs.cs_nffree = 0;
        acg.cg_cs.cs_nbfree = 0;

        bzero((caddr_t)acg.cg_frsum, sizeof (acg.cg_frsum));
        bzero((caddr_t)cg_blktot(&acg), (int)(acg.cg_iusedoff-acg.cg_btotoff));

        bit = bits = 0;
        while (findfreerange(&bit, &bits)) {
                if (bits == sblock.fs_frag) {
                        acg.cg_cs.cs_nbfree++;
                        cno = cbtocylno(&sblock, bit);
                        cg_blktot(&acg)[cno]++;
                        cg_blks(&sblock, &acg, cno)[cbtorpos(&sblock, bit)]++;
                } else {
                        acg.cg_cs.cs_nffree += bits;
                        acg.cg_frsum[bits]++;
                }
                bit += bits;
        }

        *(fscs + acg.cg_cgx) = acg.cg_cs;

        sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
        sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
}

void
extendcg(long cylno)
{
        int     i;
        diskaddr_t      dupper;
        diskaddr_t      cbase;
        diskaddr_t      dmax;

        /*
         * extend the cylinder group at the end of the old file system
         * if it was partially allocated becase of lack of space
         */
        flcg();
        rdcg(cylno);

        dupper = acg.cg_ndblk;
        if (cylno == sblock.fs_ncg - 1)
                acg.cg_ncyl = sblock.fs_ncyl - (sblock.fs_cpg * cylno);
        else
                acg.cg_ncyl = sblock.fs_cpg;
        cbase = cgbase(&sblock, cylno);
        dmax = cbase + sblock.fs_fpg;
        if (dmax > sblock.fs_size)
                dmax = sblock.fs_size;
        acg.cg_ndblk = dmax - cbase;

        for (i = dupper; i < acg.cg_ndblk; ++i)
                setbit(cg_blksfree(&acg), i);

        sblock.fs_dsize += (acg.cg_ndblk - dupper);

        wtcg();
        flcg();
}

struct lockfs   lockfs;
int             lockfd;
int             islocked;
int             lockfskey;
char            lockfscomment[128];

void
ulockfs()
{
        /*
         * if the file system was locked, unlock it before exiting
         */
        if (islocked == 0)
                return;

        /*
         * first, check if the lock held
         */
        lockfs.lf_flags = LOCKFS_MOD;
        if (ioctl(lockfd, _FIOLFSS, &lockfs) == -1) {
                perror(directory);
                lockexit(32);
        }

        if (LOCKFS_IS_MOD(&lockfs)) {
                (void) fprintf(stderr,
                    gettext("FILE SYSTEM CHANGED DURING GROWFS!\n"));
                (void) fprintf(stderr,
                    gettext("   See lockfs(1), umount(1), and fsck(1)\n"));
                lockexit(32);
        }
        /*
         * unlock the file system
         */
        lockfs.lf_lock  = LOCKFS_ULOCK;
        lockfs.lf_flags = 0;
        lockfs.lf_key   = lockfskey;
        clockfs();
        if (ioctl(lockfd, _FIOLFS, &lockfs) == -1) {
                perror(directory);
                lockexit(32);
        }
}

void
wlockfs()
{

        /*
         * if no-write (-N), don't bother
         */
        if (Nflag)
                return;
        /*
         * open the mountpoint, and write lock the file system
         */
        if ((lockfd = open64(directory, O_RDONLY)) == -1) {
                perror(directory);
                lockexit(32);
        }

        /*
         * check if it is already locked
         */
        if (ioctl(lockfd, _FIOLFSS, &lockfs) == -1) {
                perror(directory);
                lockexit(32);
        }

        if (lockfs.lf_lock != LOCKFS_WLOCK) {
                lockfs.lf_lock  = LOCKFS_WLOCK;
                lockfs.lf_flags = 0;
                lockfs.lf_key   = 0;
                clockfs();
                if (ioctl(lockfd, _FIOLFS, &lockfs) == -1) {
                        perror(directory);
                        lockexit(32);
                }
        }
        islocked = 1;
        lockfskey = lockfs.lf_key;
}

void
clockfs()
{
        time_t  t;
        char    *ct;

        (void) time(&t);
        ct = ctime(&t);
        ct[strlen(ct)-1] = '\0';

        (void) sprintf(lockfscomment, "%s -- mkfs pid %d", ct, getpid());
        lockfs.lf_comlen  = strlen(lockfscomment)+1;
        lockfs.lf_comment = lockfscomment;
}

/*
 * Write the csum records and the superblock
 */
void
wtsb()
{
        long    i;

        /*
         * write summary information
         */
        for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)
                wtfs(fsbtodb(&sblock, (uint64_t)(sblock.fs_csaddr +
                    numfrags(&sblock, i))),
                    (int)(sblock.fs_cssize - i < sblock.fs_bsize ?
                    sblock.fs_cssize - i : sblock.fs_bsize),
                    ((char *)fscs) + i);

        /*
         * write superblock
         */
        sblock.fs_time = mkfstime;
        wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock);
}

/*
 * Verify that the optimization selection is reasonable, and advance
 * the global "string" appropriately.
 */
static char
checkopt(char *optim)
{
        char    opt;
        int     limit = strcspn(optim, ",");

        switch (limit) {
        case 0: /* missing indicator (have comma or nul) */
                (void) fprintf(stderr, gettext(
                    "mkfs: missing optimization flag reset to `t' (time)\n"));
                opt = 't';
                break;

        case 1: /* single-character indicator */
                opt = *optim;
                if ((opt != 's') && (opt != 't')) {
                        (void) fprintf(stderr, gettext(
                    "mkfs: bad optimization value `%c' reset to `t' (time)\n"),
                            opt);
                        opt = 't';
                }
                break;

        default: /* multi-character indicator */
                (void) fprintf(stderr, gettext(
            "mkfs: bad optimization value `%*.*s' reset to `t' (time)\n"),
                    limit, limit, optim);
                opt = 't';
                break;
        }

        string += limit;

        return (opt);
}

/*
 * Verify that the mtb selection is reasonable, and advance
 * the global "string" appropriately.
 */
static char
checkmtb(char *mtbarg)
{
        char    mtbc;
        int     limit = strcspn(mtbarg, ",");

        switch (limit) {
        case 0: /* missing indicator (have comma or nul) */
                (void) fprintf(stderr, gettext(
                    "mkfs: missing mtb flag reset to `n' (no mtb support)\n"));
                mtbc = 'n';
                break;

        case 1: /* single-character indicator */
                mtbc = tolower(*mtbarg);
                if ((mtbc != 'y') && (mtbc != 'n')) {
                        (void) fprintf(stderr, gettext(
                    "mkfs: bad mtb value `%c' reset to `n' (no mtb support)\n"),
                            mtbc);
                        mtbc = 'n';
                }
                break;

        default: /* multi-character indicator */
                (void) fprintf(stderr, gettext(
            "mkfs: bad mtb value `%*.*s' reset to `n' (no mtb support)\n"),
                    limit, limit, mtbarg);
                opt = 'n';
                break;
        }

        string += limit;

        return (mtbc);
}

/*
 * Verify that a value is in a range.  If it is not, resets it to
 * its default value if one is supplied, exits otherwise.
 *
 * When testing, can compare user_supplied to RC_KEYWORD or RC_POSITIONAL.
 */
static void
range_check(long *varp, char *name, long minimum, long maximum,
    long def_val, int user_supplied)
{
        dprintf(("DeBuG %s : %ld (%ld %ld %ld)\n",
            name, *varp, minimum, maximum, def_val));

        if ((*varp < minimum) || (*varp > maximum)) {
                if (user_supplied != RC_DEFAULT) {
                        (void) fprintf(stderr, gettext(
            "mkfs: bad value for %s: %ld must be between %ld and %ld\n"),
                            name, *varp, minimum, maximum);
                }
                if (def_val != NO_DEFAULT) {
                        if (user_supplied) {
                                (void) fprintf(stderr,
                                    gettext("mkfs: %s reset to default %ld\n"),
                                    name, def_val);
                        }
                        *varp = def_val;
                        dprintf(("DeBuG %s : %ld\n", name, *varp));
                        return;
                }
                lockexit(2);
                /*NOTREACHED*/
        }
}

/*
 * Verify that a value is in a range.  If it is not, resets it to
 * its default value if one is supplied, exits otherwise.
 *
 * When testing, can compare user_supplied to RC_KEYWORD or RC_POSITIONAL.
 */
static void
range_check_64(uint64_t *varp, char *name, uint64_t minimum, uint64_t maximum,
    uint64_t def_val, int user_supplied)
{
        if ((*varp < minimum) || (*varp > maximum)) {
                if (user_supplied != RC_DEFAULT) {
                        (void) fprintf(stderr, gettext(
            "mkfs: bad value for %s: %lld must be between %lld and %lld\n"),
                            name, *varp, minimum, maximum);
                }
                if (def_val != NO_DEFAULT) {
                        if (user_supplied) {
                                (void) fprintf(stderr,
                                    gettext("mkfs: %s reset to default %lld\n"),
                                    name, def_val);
                        }
                        *varp = def_val;
                        return;
                }
                lockexit(2);
                /*NOTREACHED*/
        }
}

/*
 * Blocks SIGINT from delivery.  Returns the previous mask in the
 * buffer provided, so that mask may be later restored.
 */
static void
block_sigint(sigset_t *old_mask)
{
        sigset_t block_mask;

        if (sigemptyset(&block_mask) < 0) {
                fprintf(stderr, gettext("Could not clear signal mask\n"));
                lockexit(3);
        }
        if (sigaddset(&block_mask, SIGINT) < 0) {
                fprintf(stderr, gettext("Could not set signal mask\n"));
                lockexit(3);
        }
        if (sigprocmask(SIG_BLOCK, &block_mask, old_mask) < 0) {
                fprintf(stderr, gettext("Could not block SIGINT\n"));
                lockexit(3);
        }
}

/*
 * Restores the signal mask that was in force before a call
 * to block_sigint().  This may actually still have SIGINT blocked,
 * if we've been recursively invoked.
 */
static void
unblock_sigint(sigset_t *old_mask)
{
        if (sigprocmask(SIG_UNBLOCK, old_mask, (sigset_t *)NULL) < 0) {
                fprintf(stderr, gettext("Could not restore signal mask\n"));
                lockexit(3);
        }
}

/*
 * Attempt to be somewhat graceful about being interrupted, rather than
 * just silently leaving the filesystem in an unusable state.
 *
 * The kernel has blocked SIGINT upon entry, so we don't have to worry
 * about recursion if the user starts pounding on the keyboard.
 */
static void
recover_from_sigint(int signum)
{
        if (fso > -1) {
                if ((Nflag != 0) || confirm_abort()) {
                        lockexit(4);
                }
        }
}

static int
confirm_abort(void)
{
        char line[80];

        printf(gettext("\n\nAborting at this point will leave the filesystem "
            "in an inconsistent\nstate.  If you do choose to stop, "
            "you will be given instructions on how to\nrecover "
            "the filesystem.  Do you wish to cancel the filesystem "
            "grow\noperation (y/n)?"));
        if (getaline(stdin, line, sizeof (line)) == EOF)
                line[0] = 'y';

        printf("\n");
        if (line[0] == 'y' || line[0] == 'Y')
                return (1);
        else {
                return (0);
        }
}

static int
getaline(FILE *fp, char *loc, int maxlen)
{
        int n;
        char *p, *lastloc;

        p = loc;
        lastloc = &p[maxlen-1];
        while ((n = getc(fp)) != '\n') {
                if (n == EOF)
                        return (EOF);
                if (!isspace(n) && p < lastloc)
                        *p++ = n;
        }
        *p = 0;
        return (p - loc);
}

/*
 * Calculate the maximum value of cylinders-per-group for a file
 * system with the characteristics:
 *
 *      bsize - file system block size
 *      fragsize - frag size
 *      nbpi - number of bytes of disk space per inode
 *      nrpos - number of rotational positions
 *      spc - sectors per cylinder
 *
 * These five characteristic are not adjustable (by this function).
 * The only attribute of the file system which IS adjusted by this
 * function in order to maximize cylinders-per-group is the proportion
 * of the cylinder group overhead block used for the inode map.  The
 * inode map cannot occupy more than one-third of the cylinder group
 * overhead block, but it's OK for it to occupy less than one-third
 * of the overhead block.
 *
 * The setting of nbpi determines one possible value for the maximum
 * size of a cylinder group.  It does so because it determines the total
 * number of inodes in the file system (file system size is fixed, and
 * nbpi is fixed, so the total number of inodes is fixed too).  The
 * cylinder group has to be small enough so that the number of inodes
 * in the cylinder group is less than or equal to the number of bits
 * in one-third (or whatever proportion is assumed) of a file system
 * block.  The details of the calculation are:
 *
 *     The macro MAXIpG_B(bsize, inode_divisor) determines the maximum
 *     number of inodes that can be in a cylinder group, given the
 *     proportion of the cylinder group overhead block used for the
 *     inode bitmaps (an inode_divisor of 3 means that 1/3 of the
 *     block is used for inode bitmaps; an inode_divisor of 12 means
 *     that 1/12 of the block is used for inode bitmaps.)
 *
 *     Once the number of inodes per cylinder group is known, the
 *     maximum value of cylinders-per-group (determined by nbpi)
 *     is calculated by the formula
 *
 *     maxcpg_given_nbpi = (size of a cylinder group)/(size of a cylinder)
 *
 *                       = (inodes-per-cg * nbpi)/(spc * DEV_BSIZE)
 *
 *     (Interestingly, the size of the file system never enters
 *     into this calculation.)
 *
 * Another possible value for the maximum cylinder group size is determined
 * by frag_size and nrpos.  The frags in the cylinder group must be
 * representable in the frag bitmaps in the cylinder overhead block and the
 * rotational positions for each cylinder must be represented in the
 * rotational position tables.  The calculation of the maximum cpg
 * value, given the frag and nrpos vales, is:
 *
 *     maxcpg_given_fragsize =
 *        (available space in the overhead block) / (size of per-cylinder data)
 *
 *     The available space in the overhead block =
 *        bsize - sizeof (struct cg) - space_used_for_inode_bitmaps
 *
 *     The size of the per-cylinder data is:
 *          sizeof(long)            # for the "blocks avail per cylinder" field
 *          + nrpos * sizeof(short)   # for the rotational position table entry
 *          + frags-per-cylinder/NBBY # number of bytes to represent this
 *                                    # cylinder in the frag bitmap
 *
 * The two calculated maximum values of cylinder-per-group will typically
 * turn out to be different, since they are derived from two different
 * constraints.  Usually, maxcpg_given_nbpi is much bigger than
 * maxcpg_given_fragsize.  But they can be brought together by
 * adjusting the proportion of the overhead block dedicated to
 * the inode bitmaps.  Decreasing the proportion of the cylinder
 * group overhead block used for inode maps will decrease
 * maxcpg_given_nbpi and increase maxcpg_given_fragsize.
 *
 * This function calculates the initial values of maxcpg_given_nbpi
 * and maxcpg_given_fragsize assuming that 1/3 of the cg overhead
 * block is used for inode bitmaps.  Then it decreases the proportion
 * of the cg overhead block used for inode bitmaps (by increasing
 * the value of inode_divisor) until maxcpg_given_nbpi and
 * maxcpg_given_fragsize are the same, or stop changing, or
 * maxcpg_given_nbpi is less than maxcpg_given_fragsize.
 *
 * The loop terminates when any of the following occur:
 *      * maxcpg_given_fragsize is greater than or equal to
 *        maxcpg_given_nbpi
 *      * neither maxcpg_given_fragsize nor maxcpg_given_nbpi
 *        change in the expected direction
 *
 * The loop is guaranteed to terminate because it only continues
 * while maxcpg_given_fragsize and maxcpg_given_nbpi are approaching
 * each other.  As soon they cross each other, or neither one changes
 * in the direction of the other, or one of them moves in the wrong
 * direction, the loop completes.
 */

static long
compute_maxcpg(long bsize, long fragsize, long nbpi, long nrpos, long spc)
{
        int     maxcpg_given_nbpi;      /* in cylinders */
        int     maxcpg_given_fragsize;  /* in cylinders */
        int     spf;                    /* sectors per frag */
        int     inode_divisor;
        int     old_max_given_frag = 0;
        int     old_max_given_nbpi = INT_MAX;

        spf = fragsize / DEV_BSIZE;
        inode_divisor = 3;

        while (1) {
                maxcpg_given_nbpi =
                    (((int64_t)(MAXIpG_B(bsize, inode_divisor))) * nbpi) /
                    (DEV_BSIZE * ((int64_t)spc));
                maxcpg_given_fragsize =
                    (bsize - (sizeof (struct cg)) - (bsize / inode_divisor)) /
                    (sizeof (long) + nrpos * sizeof (short) +
                    (spc / spf) / NBBY);

                if (maxcpg_given_fragsize >= maxcpg_given_nbpi)
                        return (maxcpg_given_nbpi);

                /*
                 * If neither value moves toward the other, return the
                 * least of the old values (we use the old instead of the
                 * new because: if the old is the same as the new, it
                 * doesn't matter which ones we use.  If one of the
                 * values changed, but in the wrong direction, the
                 * new values are suspect.  Better use the old.  This
                 * shouldn't happen, but it's best to check.
                 */

                if (!(maxcpg_given_nbpi < old_max_given_nbpi) &&
                    !(maxcpg_given_fragsize > old_max_given_frag))
                        return (MIN(old_max_given_nbpi, old_max_given_frag));

                /*
                 * This is probably impossible, but if one of the maxcpg
                 * values moved in the "right" direction and one moved
                 * in the "wrong" direction (that is, the two values moved
                 * in the same direction), the previous conditional won't
                 * recognize that the values aren't converging (since at
                 * least one value moved in the "right" direction, the
                 * last conditional says "keep going").
                 *
                 * Just to make absolutely certain that the loop terminates,
                 * check for one of the values moving in the "wrong" direction
                 * and terminate the loop if it happens.
                 */

                if (maxcpg_given_nbpi > old_max_given_nbpi ||
                    maxcpg_given_fragsize < old_max_given_frag)
                        return (MIN(old_max_given_nbpi, old_max_given_frag));

                old_max_given_nbpi = maxcpg_given_nbpi;
                old_max_given_frag = maxcpg_given_fragsize;

                inode_divisor++;
        }
}

static int
in_64bit_mode(void)
{
        /*  cmd must be an absolute path, for security */
        char *cmd = "/usr/bin/isainfo -b";
        char buf[BUFSIZ];
        FILE *ptr;
        int retval = 0;

        putenv("IFS= \t");
        if ((ptr = popen(cmd, "r")) != NULL) {
                if (fgets(buf, BUFSIZ, ptr) != NULL &&
                    strncmp(buf, "64", 2) == 0)
                        retval = 1;
                (void) pclose(ptr);
        }
        return (retval);
}

/*
 * validate_size
 *
 * Return 1 if the device appears to be at least "size" sectors long.
 * Return 0 if it's shorter or we can't read it.
 */

static int
validate_size(int fd, diskaddr_t size)
{
        char            buf[DEV_BSIZE];
        int rc;

        if ((llseek(fd, (offset_t)((size - 1) * DEV_BSIZE), SEEK_SET) == -1) ||
            (read(fd, buf, DEV_BSIZE)) != DEV_BSIZE)
                rc = 0;
        else
                rc = 1;
        return (rc);
}

/*
 * Print every field of the calculated superblock, along with
 * its value.  To make parsing easier on the caller, the value
 * is printed first, then the name.  Additionally, there's only
 * one name/value pair per line.  All values are reported in
 * hexadecimal (with the traditional 0x prefix), as that's slightly
 * easier for humans to read.  Not that they're expected to, but
 * debugging happens.
 */
static void
dump_sblock(void)
{
        int row, column, pending, written;
        caddr_t source;

        if (Rflag) {
                pending = sizeof (sblock);
                source = (caddr_t)&sblock;
                do {
                        written = write(fileno(stdout), source, pending);
                        pending -= written;
                        source += written;
                } while ((pending > 0) && (written > 0));

                if (written < 0) {
                        perror(gettext("Binary dump of superblock failed"));
                        lockexit(1);
                }
                return;
        } else {
                printf("0x%x sblock.fs_link\n", sblock.fs_link);
                printf("0x%x sblock.fs_rolled\n", sblock.fs_rolled);
                printf("0x%x sblock.fs_sblkno\n", sblock.fs_sblkno);
                printf("0x%x sblock.fs_cblkno\n", sblock.fs_cblkno);
                printf("0x%x sblock.fs_iblkno\n", sblock.fs_iblkno);
                printf("0x%x sblock.fs_dblkno\n", sblock.fs_dblkno);
                printf("0x%x sblock.fs_cgoffset\n", sblock.fs_cgoffset);
                printf("0x%x sblock.fs_cgmask\n", sblock.fs_cgmask);
                printf("0x%x sblock.fs_time\n", sblock.fs_time);
                printf("0x%x sblock.fs_size\n", sblock.fs_size);
                printf("0x%x sblock.fs_dsize\n", sblock.fs_dsize);
                printf("0x%x sblock.fs_ncg\n", sblock.fs_ncg);
                printf("0x%x sblock.fs_bsize\n", sblock.fs_bsize);
                printf("0x%x sblock.fs_fsize\n", sblock.fs_fsize);
                printf("0x%x sblock.fs_frag\n", sblock.fs_frag);
                printf("0x%x sblock.fs_minfree\n", sblock.fs_minfree);
                printf("0x%x sblock.fs_rotdelay\n", sblock.fs_rotdelay);
                printf("0x%x sblock.fs_rps\n", sblock.fs_rps);
                printf("0x%x sblock.fs_bmask\n", sblock.fs_bmask);
                printf("0x%x sblock.fs_fmask\n", sblock.fs_fmask);
                printf("0x%x sblock.fs_bshift\n", sblock.fs_bshift);
                printf("0x%x sblock.fs_fshift\n", sblock.fs_fshift);
                printf("0x%x sblock.fs_maxcontig\n", sblock.fs_maxcontig);
                printf("0x%x sblock.fs_maxbpg\n", sblock.fs_maxbpg);
                printf("0x%x sblock.fs_fragshift\n", sblock.fs_fragshift);
                printf("0x%x sblock.fs_fsbtodb\n", sblock.fs_fsbtodb);
                printf("0x%x sblock.fs_sbsize\n", sblock.fs_sbsize);
                printf("0x%x sblock.fs_csmask\n", sblock.fs_csmask);
                printf("0x%x sblock.fs_csshift\n", sblock.fs_csshift);
                printf("0x%x sblock.fs_nindir\n", sblock.fs_nindir);
                printf("0x%x sblock.fs_inopb\n", sblock.fs_inopb);
                printf("0x%x sblock.fs_nspf\n", sblock.fs_nspf);
                printf("0x%x sblock.fs_optim\n", sblock.fs_optim);
#ifdef _LITTLE_ENDIAN
                printf("0x%x sblock.fs_state\n", sblock.fs_state);
#else
                printf("0x%x sblock.fs_npsect\n", sblock.fs_npsect);
#endif
                printf("0x%x sblock.fs_si\n", sblock.fs_si);
                printf("0x%x sblock.fs_trackskew\n", sblock.fs_trackskew);
                printf("0x%x sblock.fs_id[0]\n", sblock.fs_id[0]);
                printf("0x%x sblock.fs_id[1]\n", sblock.fs_id[1]);
                printf("0x%x sblock.fs_csaddr\n", sblock.fs_csaddr);
                printf("0x%x sblock.fs_cssize\n", sblock.fs_cssize);
                printf("0x%x sblock.fs_cgsize\n", sblock.fs_cgsize);
                printf("0x%x sblock.fs_ntrak\n", sblock.fs_ntrak);
                printf("0x%x sblock.fs_nsect\n", sblock.fs_nsect);
                printf("0x%x sblock.fs_spc\n", sblock.fs_spc);
                printf("0x%x sblock.fs_ncyl\n", sblock.fs_ncyl);
                printf("0x%x sblock.fs_cpg\n", sblock.fs_cpg);
                printf("0x%x sblock.fs_ipg\n", sblock.fs_ipg);
                printf("0x%x sblock.fs_fpg\n", sblock.fs_fpg);
                printf("0x%x sblock.fs_cstotal\n", sblock.fs_cstotal);
                printf("0x%x sblock.fs_fmod\n", sblock.fs_fmod);
                printf("0x%x sblock.fs_clean\n", sblock.fs_clean);
                printf("0x%x sblock.fs_ronly\n", sblock.fs_ronly);
                printf("0x%x sblock.fs_flags\n", sblock.fs_flags);
                printf("0x%x sblock.fs_fsmnt\n", sblock.fs_fsmnt);
                printf("0x%x sblock.fs_cgrotor\n", sblock.fs_cgrotor);
                printf("0x%x sblock.fs_u.fs_csp\n", sblock.fs_u.fs_csp);
                printf("0x%x sblock.fs_cpc\n", sblock.fs_cpc);

                /*
                 * No macros are defined for the dimensions of the
                 * opostbl array.
                 */
                for (row = 0; row < 16; row++) {
                        for (column = 0; column < 8; column++) {
                                printf("0x%x sblock.fs_opostbl[%d][%d]\n",
                                    sblock.fs_opostbl[row][column],
                                    row, column);
                        }
                }

                /*
                 * Ditto the size of sparecon.
                 */
                for (row = 0; row < 51; row++) {
                        printf("0x%x sblock.fs_sparecon[%d]\n",
                            sblock.fs_sparecon[row], row);
                }

                printf("0x%x sblock.fs_version\n", sblock.fs_version);
                printf("0x%x sblock.fs_logbno\n", sblock.fs_logbno);
                printf("0x%x sblock.fs_reclaim\n", sblock.fs_reclaim);
                printf("0x%x sblock.fs_sparecon2\n", sblock.fs_sparecon2);
#ifdef _LITTLE_ENDIAN
                printf("0x%x sblock.fs_npsect\n", sblock.fs_npsect);
#else
                printf("0x%x sblock.fs_state\n", sblock.fs_state);
#endif
                printf("0x%llx sblock.fs_qbmask\n", sblock.fs_qbmask);
                printf("0x%llx sblock.fs_qfmask\n", sblock.fs_qfmask);
                printf("0x%x sblock.fs_postblformat\n", sblock.fs_postblformat);
                printf("0x%x sblock.fs_nrpos\n", sblock.fs_nrpos);
                printf("0x%x sblock.fs_postbloff\n", sblock.fs_postbloff);
                printf("0x%x sblock.fs_rotbloff\n", sblock.fs_rotbloff);
                printf("0x%x sblock.fs_magic\n", sblock.fs_magic);

                /*
                 * fs_space isn't of much use in this context, so we'll
                 * just ignore it for now.
                 */
        }
}