xref: /illumos-gate/usr/src/cmd/fs.d/pcfs/mkfs/mkfs_main.c (revision fdc43e978a96b43e8b78e80d9bc6f39c99a8ca83)

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2011 Gary Mills
 * Copyright 2024 MNX Cloud, Inc.
 */

#include <sys/types.h>
#include <ctype.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libintl.h>
#include <locale.h>
#include <sys/fdio.h>
#include <sys/dktp/fdisk.h>
#include <sys/dkio.h>
#include <sys/vtoc.h>
#include <sys/efi_partition.h>
#include <sys/sysmacros.h>
#include <sys/fs/pc_fs.h>
#include <sys/fs/pc_dir.h>
#include <sys/fs/pc_label.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <installboot.h>
#include "getresponse.h"
#include "pcfs_bpb.h"
#include "pcfs_common.h"

/* Drop gettext for debug build, so we can catch format errors. */
#ifdef DEBUG
#define	gettext(x)	x
#endif

/*
 *	mkfs (for pcfs)
 *
 *	Install a boot block, FAT, and (if desired) the first resident
 *	of the new fs.
 *
 *	XXX -- floppy opens need O_NDELAY?
 */
#define	IN_RANGE(n, x, y) (((n) >= (x)) && ((n) <= (y)))
#define	DEFAULT_LABEL "NONAME"

/*
 * Extended boot signature. This byte indicates that VOLID, VOLLAB and
 * FILSYSTYPE fields are present. [fatgen103, pages 11 and 12].
 */
#define	BOOTSIG	0x29

/* Exit codes. */
#define	ERR_USAGE	1
#define	ERR_OS		2	/* open fail, stat  fail etc */
#define	ERR_INVALID	3	/* Validation failed */
#define	ERR_FAIL	4	/* IO error, no memory etc */
#define	ERR_USER	5	/* User input */
#define	ERR_INVAL	6	/* Invalid data */

static char	*BootBlkFn = "/boot/pmbr";
static char	*DiskName = NULL;
static char	*FirstFn = NULL;
static char	*Label = DEFAULT_LABEL;
static char	Firstfileattr = 0x20;
static int	Outputtofile = 0;
static int	SunBPBfields = 0;
static int	GetFsParams = 0;
static int	Fatentsize = 0;
static int	Imagesize = 3;
static int	Notreally = 0;
static int	Verbose = 0;
static int	MakeFAT32 = 0;

/*
 * If there is an FDISK entry for the device where we're about to
 * make the file system, we ought to make a file system that has the
 * same size FAT as the FDISK table claims.  We track the size FDISK
 * thinks in this variable.
 */
static int	FdiskFATsize = 0;

static int	GetSize = 1;	/* Unless we're given as arg, must look it up */
static ulong_t	TotSize;	/* Total size of FS in # of sectors */
static int	GetSPC = 1;	/* Unless we're given as arg, must calculate */
static ulong_t	SecPerClust;	/* # of sectors per cluster */
static int	GetOffset = 1;	/* Unless we're given as arg, must look it up */
static ulong_t	RelOffset;	/* Relative start sector (hidden sectors) */
static int	GetSPT = 1;	/* Unless we're given as arg, must look it up */
static ushort_t	SecPerTrk;	/* # of sectors per track */
static int	GetTPC = 1;	/* Unless we're given as arg, must look it up */
static ushort_t	TrkPerCyl;	/* # of tracks per cylinder */
static int	GetResrvd = 1;	/* Unless we're given as arg, must calculate */
static int	Resrvd;		/* Number of reserved sectors */
static int	GetBPF = 1;	/* Unless we're given as arg, must calculate */
static int	BitsPerFAT;	/* Total size of FS in # of sectors */

static ulong_t	TotalClusters;	/* Computed total number of clusters */

/*
 * Unless we are told otherwise, we should use fdisk table for non-diskettes.
 */
static int	DontUseFdisk = 0;

/*
 * Function prototypes
 */
#ifdef _BIG_ENDIAN
static void swap_pack_grabsebpb(bpb_t *wbpb, struct _boot_sector *bsp);
static void swap_pack_bpb32cpy(struct _boot_sector32 *bsp, bpb_t *wbpb);
static void swap_pack_sebpbcpy(struct _boot_sector *bsp, bpb_t *wbpb);
static void swap_pack_bpbcpy(struct _boot_sector *bsp, bpb_t *wbpb);
#endif

static uchar_t *build_rootdir(bpb_t *wbpb, char *ffn, int fffd,
	ulong_t ffsize, pc_cluster32_t ffstart, ulong_t *rdirsize);
static uchar_t *build_fat(bpb_t *wbpb, struct fat_od_fsi *fsinfop,
	ulong_t *fatsize, char *ffn, int *fffd,
	ulong_t *ffsize, pc_cluster32_t *ffstartclust);

static void compare_existing_with_computed(int fd, char *suffix,
	bpb_t *wbpb, int *prtsize, int *prtspc, int *prtbpf, int *prtnsect,
	int *prtntrk, int *prtfdisk, int *prthidden, int *prtrsrvd,
	int *dashos);
static void print_reproducing_command(int fd, char *actualdisk, char *suffix,
	bpb_t *wbpb);
static void compute_file_area_size(bpb_t *wbpb);
static void write_fat32_bootstuff(int fd, boot_sector_t *bsp, bpb_t *wbpb,
	struct fat_od_fsi *fsinfop, off64_t seekto);
static void sanity_check_options(int argc, int optind);
static void compute_cluster_size(bpb_t *wbpb);
static void find_fixed_details(int fd, bpb_t *wbpb);
static void dirent_fname_fill(struct pcdir *dep, char *fn);
static void floppy_bpb_fillin(bpb_t *wbpb,
	int diam, int hds, int spt);
static void read_existing_bpb(int fd, bpb_t *wbpb);
static void warn_funky_fatsize(void);
static void warn_funky_floppy(void);
static void dirent_time_fill(struct pcdir *dep);
static void parse_suboptions(char *optsstr);
static void write_bootsects(int fd, boot_sector_t *bsp, bpb_t *wbpb,
	struct fat_od_fsi *fsinfop, off64_t seekto);
static void fill_bpb_sizes(bpb_t *wbpb, struct ipart part[],
	int partno, off64_t offset);
static void set_fat_string(bpb_t *wbpb, int fatsize);
static void partn_lecture(char *dn);
static void lookup_floppy(struct fd_char *fdchar, bpb_t *wbpb);
static void label_volume(char *lbl, bpb_t *wbpb);
static void mark_cluster(uchar_t *fatp, pc_cluster32_t clustnum,
	uint32_t value);
static void dashm_bail(int fd);
static void write_rest(bpb_t *wbpb, char *efn,
	int dfd, int sfd, int remaining);
static void write_fat(int fd, off64_t seekto, char *fn, char *lbl,
	char *ffn, bpb_t *wbpb);

static int prepare_image_file(const char *fn, bpb_t *wbpb);
static int verify_bootblkfile(char *fn, boot_sector_t *bs);
static int open_and_examine(char *dn, bpb_t *wbpb);
static int verify_firstfile(char *fn, ulong_t *filesize);
static int lookup_FAT_size(uchar_t partid);
static int open_and_seek(const char *dn, bpb_t *wbpb, off64_t *seekto);
static int warn_mismatch(char *desc, char *src, int expect, int assigned);
static void copy_bootblk(char *fn, boot_sector_t *bootsect);
static int parse_drvnum(char *pn);
static bool seek_nofdisk(int fd, bpb_t *wbpb, off64_t *seekto);
static bool ask_nicely(int bits, char *special);
static bool seek_partn(int fd, char *pn, bpb_t *wbpb, off64_t *seekto);

/*
 *  usage
 *
 *	Display usage message and exit.
 */
void
usage(void)
{
	(void) fprintf(stderr,
	    gettext("pcfs usage: mkfs [-F FSType] [-V] [-m] "
	    "[-o specific_options] special\n"));

	(void) fprintf(stderr,
	    gettext(" -V: print this command line and return\n"
	    " -m: dump command line used to create a FAT on this media\n"
	    "\t(other options are ignored if this option is chosen).\n"
	    " -o: pcfs_specific_options:\n"
	    "\t'pcfs_specific_options' is a comma separated list\n"
	    "\tincluding one or more of the following options:\n"
	    "\t    N,v,r,h,s,b=label,B=filename,i=filename,\n"
	    "\t    spc=n,fat=n,nsect=n,ntrack=n,nofdisk,size=n,\n"
	    "\t    reserve=n,hidden=n\n\n"));

	(void) fprintf(stderr,
	    gettext("'Special' should specify a raw diskette "
	    "or raw fixed disk device.  \"Fixed\"\n"
	    "disks (which include high-capacity removable "
	    "media such as Zip disks)\n"
	    "may be further qualified with a logical "
	    "drive specifier.\n"
	    "Examples are: /dev/rdiskette and "
	    "/dev/rdsk/c0t0d0p0:c\n"));
	exit(ERR_USAGE);
}

static
bool
ask_nicely(int bits, char *special)
{
	/*
	 * 4228473 - No way to non-interactively make a pcfs filesystem
	 *
	 *	If we don't have an input TTY, or we aren't really doing
	 *	anything, then don't ask questions.  Assume a yes answer
	 *	to any questions we would ask.
	 */
	if (Notreally || !isatty(fileno(stdin)))
		return (true);

	(void) printf(
	    gettext("Construct a new FAT%d file system on %s: (y/n)? "),
	    bits, special);
	(void) fflush(stdout);
	return (yes());
}

/*
 *  parse_drvnum
 *	Convert a partition name into a drive number.
 */
static
int
parse_drvnum(char *pn)
{
	int drvnum;

	/*
	 * Determine logical drive to seek after.
	 */
	if (strlen(pn) == 1 && *pn >= 'c' && *pn <= 'z') {
		drvnum = *pn - 'c' + 1;
	} else if (*pn >= '0' && *pn <= '9') {
		char *d;
		int v, m, c;

		v = 0;
		d = pn;
		while (*d && *d >= '0' && *d <= '9') {
			c = strlen(d);
			m = 1;
			while (--c)
				m *= 10;
			v += m * (*d - '0');
			d++;
		}

		if (*d || v > 24) {
			(void) fprintf(stderr,
			    gettext("%s: bogus logical drive specification.\n"),
			    pn);
			return (-1);
		}
		drvnum = v;
	} else if (strcmp(pn, "boot") == 0) {
		drvnum = 99;
	} else {
		(void) fprintf(stderr,
		    gettext("%s: bogus logical drive specification.\n"), pn);
		return (-1);
	}

	return (drvnum);
}

/*
 *  Define some special logical drives we use.
 */
#define	BOOT_PARTITION_DRIVE	99
#define	PRIMARY_DOS_DRIVE	1

/*
 * isDosDrive()
 *	Boolean function.  Give it the systid field for an fdisk partition
 *	and it decides if that's a systid that describes a DOS drive.  We
 *	use systid values defined in sys/dktp/fdisk.h.
 */
static int
isDosDrive(uchar_t checkMe)
{
	return ((checkMe == DOSOS12) || (checkMe == DOSOS16) ||
	    (checkMe == DOSHUGE) || (checkMe == FDISK_WINDOWS) ||
	    (checkMe == FDISK_EXT_WIN) || (checkMe == FDISK_FAT95) ||
	    (checkMe == DIAGPART));
}

/*
 * isDosExtended()
 *	Boolean function.  Give it the systid field for an fdisk partition
 *	and it decides if that's a systid that describes an extended DOS
 *	partition.
 */
static int
isDosExtended(uchar_t checkMe)
{
	return ((checkMe == EXTDOS) || (checkMe == FDISK_EXTLBA));
}

/*
 * isBootPart()
 *	Boolean function.  Give it the systid field for an fdisk partition
 *	and it decides if that's a systid that describes a Solaris boot
 *	partition.
 */
static int
isBootPart(uchar_t checkMe)
{
	return (checkMe == X86BOOT);
}

static
int
warn_mismatch(char *desc, char *src, int expect, int assigned)
{
	if (expect == assigned)
		return (assigned);

	/*
	 * 4228473 - No way to non-interactively make a pcfs filesystem
	 *
	 *	If we don't have an input TTY, or we aren't really doing
	 *	anything, then don't ask questions.  Assume a yes answer
	 *	to any questions we would ask.
	 */
	if (Notreally || !isatty(fileno(stdin))) {
		(void) printf(gettext("WARNING: User supplied %s is %d,"
		    "\nbut value obtained from the %s is %d.\n"
		    "Using user supplied value.\n"),
		    desc, assigned, src, expect);
		return (assigned);
	}

	(void) printf(gettext("User supplied %s is %d."
	    "\nThe value obtained from the %s is %d.\n"),
	    desc, assigned, src, expect);

	(void) printf(
	    gettext("Continue with value given on command line (y/n)? "));
	(void) fflush(stdout);
	if (yes())
		return (assigned);
	else
		exit(ERR_USER);
	/*NOTREACHED*/
}

static
void
fill_fat32_bpb(bpb_t *wbpb)
{
	/*
	 * ExtFlags means (according to MSDN BPB (FAT32) document)
	 *
	 * Bit 8 indicates info written to the active FAT is written
	 * to all copies of the FAT.  (I think they mean bit 7, with
	 * numbering starting at 0)
	 *
	 * Lowest 4 bits of field are the 0 based FAT number of the
	 * Active FAT.  (only meaningful if bit 8 is set)
	 *
	 * Field contains combination of these values:
	 *
	 *	VALUE				DESCRIPTION
	 * BGBPB_F_ActiveFATMsk		Mask for low four bits
	 * (0x000F)
	 * BGBPB_F_NoFATMirror		If set FAT mirroring disabled.
	 * (0x0080)			If clear, FAT mirroring enabled.
	 *
	 * We set the value based on what I've seen on all the FAT32 drives
	 * I've seen created by Windows.
	 *
	 */
	wbpb->bpb32.ext_flags = 0x0;
	/*
	 * No real explanation of the fs_vers file in the BPB doc.  The
	 * high byte is supposed to be the major version and the low the
	 * minor version.  Again I set according to what I've seen on Windows.
	 */
	wbpb->bpb32.fs_vers_lo = '\0';
	wbpb->bpb32.fs_vers_hi = '\0';
	/*
	 * The convention appears to be to place the fs info sector
	 * immediately after the boot sector, and that the backup boot
	 * sector should be at sector 6. (based on what I see with
	 * Windows)
	 */
	wbpb->bpb32.fsinfosec = 1;
	wbpb->bpb32.backupboot = 6;
}

static
void
fill_bpb_sizes(bpb_t *wbpb, struct ipart part[], int partno, off64_t offset)
{
	ulong_t usesize;

	if (GetFsParams || GetSize) {
		usesize = ltohi(part[partno].numsect);
		if (Verbose) {
			(void) printf(
			    gettext("Partition size (from FDISK table) "
			    "= %lu sectors.\n"), usesize);
		}
	} else {
		usesize = warn_mismatch(
		    gettext("length of partition (in sectors)"),
		    gettext("FDISK table"),
		    ltohi(part[partno].numsect), TotSize);
	}

	if (GetFsParams) {
		TotSize = usesize;
	} else {
		if (usesize > 0xffff)
			wbpb->bpb.sectors_in_volume = 0;
		else
			wbpb->bpb.sectors_in_volume = usesize;
		wbpb->bpb.sectors_in_logical_volume = usesize;
	}

	wbpb->bpb.hidden_sectors = offset;

	if (GetFsParams) {
		RelOffset = offset;
	} else {
		wbpb->sunbpb.bs_offset_high = offset >> 16;
		wbpb->sunbpb.bs_offset_low = offset & 0xFFFF;
	}
}

/*
 *  lookup_FAT_size
 *
 *	Given the FDISK partition file system identifier, return the
 *	expected FAT size for the partition.
 */
static
int
lookup_FAT_size(uchar_t partid)
{
	int rval;

	switch (partid) {
	case DOSOS12:
		rval = 12;
		break;
	case DOSOS16:
	case DOSHUGE:
	case FDISK_FAT95:
	case X86BOOT:
		rval = 16;
		break;
	case FDISK_WINDOWS:
	case FDISK_EXT_WIN:
		rval = 32;
		break;
	case EXTDOS:
	case FDISK_EXTLBA:
	default:
		rval = -1;
		break;
	}

	return (rval);
}

/*
 *  seek_partn
 *
 *	Seek to the beginning of the partition where we need to install
 *	the new FAT.  Zero return for any error, but print error
 *	messages here.
 */
static
bool
seek_partn(int fd, char *pn, bpb_t *wbpb, off64_t *seekto)
{
	struct ipart part[FD_NUMPART];
	struct mboot extmboot;
	struct mboot mb;
	diskaddr_t xstartsect;
	off64_t nextseek = 0;
	off64_t lastseek = 0;
	int logicalDriveCount = 0;
	int extendedPart = -1;
	int primaryPart = -1;
	int bootPart = -1;
	uint32_t xnumsect = 0;
	int drvnum;
	int driveIndex;
	int i;
	/*
	 * Count of drives in the current extended partition's
	 * FDISK table, and indexes of the drives themselves.
	 */
	int extndDrives[FD_NUMPART];
	int numDrives = 0;
	/*
	 * Count of drives (beyond primary) in master boot record's
	 * FDISK table, and indexes of the drives themselves.
	 */
	int extraDrives[FD_NUMPART];
	int numExtraDrives = 0;

	if ((drvnum = parse_drvnum(pn)) < 0)
		return (false);

	if (read(fd, &mb, sizeof (mb)) != sizeof (mb)) {
		(void) fprintf(stderr,
		    gettext("Couldn't read a Master Boot Record?!\n"));
		return (false);
	}

	if (ltohs(mb.signature) != BOOTSECSIG) {
		(void) fprintf(stderr,
		    gettext("Bad Sig on master boot record!\n"));
		return (false);
	}

	*seekto = 0;

	/*
	 * Copy partition table into memory
	 */
	(void) memcpy(part, mb.parts, sizeof (part));

	/*
	 * Get a summary of what is in the Master FDISK table.
	 * Normally we expect to find one partition marked as a DOS drive.
	 * This partition is the one Windows calls the primary dos partition.
	 * If the machine has any logical drives then we also expect
	 * to find a partition marked as an extended DOS partition.
	 *
	 * Sometimes we'll find multiple partitions marked as DOS drives.
	 * The Solaris fdisk program allows these partitions
	 * to be created, but Windows fdisk no longer does.  We still need
	 * to support these, though, since Windows does.  We also need to fix
	 * our fdisk to behave like the Windows version.
	 *
	 * It turns out that some off-the-shelf media have *only* an
	 * Extended partition, so we need to deal with that case as
	 * well.
	 *
	 * Only a single (the first) Extended or Boot Partition will
	 * be recognized.  Any others will be ignored.
	 */
	for (i = 0; i < FD_NUMPART; i++) {
		if (isDosDrive(part[i].systid)) {
			if (primaryPart < 0) {
				logicalDriveCount++;
				primaryPart = i;
			} else {
				extraDrives[numExtraDrives++] = i;
			}
			continue;
		}
		if ((extendedPart < 0) && isDosExtended(part[i].systid)) {
			extendedPart = i;
			continue;
		}
		if ((bootPart < 0) && isBootPart(part[i].systid)) {
			bootPart = i;
			continue;
		}
	}

	if (drvnum == BOOT_PARTITION_DRIVE) {
		if (bootPart < 0) {
			(void) fprintf(stderr,
			    gettext("No boot partition found on drive\n"));
			return (false);
		}
		if ((*seekto = ltohi(part[bootPart].relsect)) == 0) {
			(void) fprintf(stderr, gettext("Bogus FDISK entry? "
			    "A boot partition starting\nat sector 0 would "
			    "collide with the FDISK table!\n"));
			return (false);
		}

		fill_bpb_sizes(wbpb, part, bootPart, *seekto);
		*seekto *= wbpb->bpb.bytes_per_sector;
		FdiskFATsize = lookup_FAT_size(part[bootPart].systid);
		if (Verbose)
			(void) printf(gettext("Boot partition's offset: "
			    "Sector %llx.\n"),
			    *seekto / wbpb->bpb.bytes_per_sector);
		if (lseek64(fd, *seekto, SEEK_SET) < 0) {
			(void) fprintf(stderr, gettext("Partition %s: "), pn);
			perror("");
			return (false);
		}
		return (true);
	}

	if (drvnum == PRIMARY_DOS_DRIVE && primaryPart >= 0) {
		if ((*seekto = ltohi(part[primaryPart].relsect)) == 0) {
			(void) fprintf(stderr, gettext("Bogus FDISK entry? "
			    "A partition starting\nat sector 0 would "
			    "collide with the FDISK table!\n"));
			return (false);
		}

		fill_bpb_sizes(wbpb, part, primaryPart, *seekto);
		*seekto *= wbpb->bpb.bytes_per_sector;
		FdiskFATsize = lookup_FAT_size(part[primaryPart].systid);
		if (Verbose)
			(void) printf(gettext("Partition's offset: "
			    "Sector %llx.\n"),
			    *seekto / wbpb->bpb.bytes_per_sector);
		if (lseek64(fd, *seekto, SEEK_SET) < 0) {
			(void) fprintf(stderr, gettext("Partition %s: "), pn);
			perror("");
			return (false);
		}
		return (true);
	}

	/*
	 * We are not looking for the C: drive (or there was no primary
	 * drive found), so we had better have an extended partition or
	 * extra drives in the Master FDISK table.
	 */
	if ((extendedPart < 0) && (numExtraDrives == 0)) {
		(void) fprintf(stderr,
		    gettext("No such logical drive "
		    "(missing extended partition entry)\n"));
		return (false);
	}

	if (extendedPart >= 0) {
		nextseek = xstartsect = ltohi(part[extendedPart].relsect);
		xnumsect = ltohi(part[extendedPart].numsect);
		do {
			/*
			 *  If the seek would not cause us to change
			 *  position on the drive, then we're out of
			 *  extended partitions to examine.
			 */
			if (nextseek == lastseek)
				break;
			logicalDriveCount += numDrives;
			/*
			 *  Seek the next extended partition, and find
			 *  logical drives within it.
			 */
			if (lseek64(fd, nextseek * wbpb->bpb.bytes_per_sector,
			    SEEK_SET) < 0 ||
			    read(fd, &extmboot, sizeof (extmboot)) !=
			    sizeof (extmboot)) {
				perror(gettext("Unable to read extended "
				    "partition record"));
				return (false);
			}
			(void) memcpy(part, extmboot.parts, sizeof (part));
			lastseek = nextseek;
			if (ltohs(extmboot.signature) != MBB_MAGIC) {
				(void) fprintf(stderr,
				    gettext("Bad signature on "
				    "extended partition\n"));
				return (false);
			}
			/*
			 *  Count up drives, and track where the next
			 *  extended partition is in case we need it.  We
			 *  are expecting only one extended partition.  If
			 *  there is more than one we'll only go to the
			 *  first one we see, but warn about ignoring.
			 */
			numDrives = 0;
			for (i = 0; i < FD_NUMPART; i++) {
				if (isDosDrive(part[i].systid)) {
					extndDrives[numDrives++] = i;
					continue;
				} else if (isDosExtended(part[i].systid)) {
					if (nextseek != lastseek) {
						/*
						 * Already found an extended
						 * partition in this table.
						 */
						(void) fprintf(stderr,
						    gettext("WARNING: "
						    "Ignoring unexpected "
						    "additional extended "
						    "partition"));
						continue;
					}
					nextseek = xstartsect +
					    ltohi(part[i].relsect);
					continue;
				}
			}
		} while (drvnum > logicalDriveCount + numDrives);

		if (drvnum <= logicalDriveCount + numDrives) {
			/*
			 * The number of logical drives we've found thus
			 * far is enough to get us to the one we were
			 * searching for.
			 */
			driveIndex = logicalDriveCount + numDrives - drvnum;
			*seekto =
			    ltohi(part[extndDrives[driveIndex]].relsect) +
			    lastseek;
			if (*seekto == lastseek) {
				(void) fprintf(stderr,
				    gettext("Bogus FDISK entry?  A logical "
				    "drive starting at\nsector 0x%llx would "
				    "collide with the\nFDISK information in "
				    "that sector.\n"), *seekto);
				return (false);
			} else if (*seekto <= xstartsect ||
			    *seekto >= (xstartsect + xnumsect)) {
				(void) fprintf(stderr,
				    gettext("Bogus FDISK entry?  "
				    "Logical drive start sector (0x%llx)\n"
				    "not within extended partition! "
				    "(Expected in range 0x%llx - 0x%llx)\n"),
				    *seekto, xstartsect + 1,
				    xstartsect + xnumsect - 1);
				return (false);
			}
			fill_bpb_sizes(wbpb, part, extndDrives[driveIndex],
			    *seekto);
			*seekto *= wbpb->bpb.bytes_per_sector;
			FdiskFATsize = lookup_FAT_size(
			    part[extndDrives[driveIndex]].systid);
			if (Verbose)
				(void) printf(gettext("Partition's offset: "
				    "Sector 0x%llx.\n"),
				    *seekto/wbpb->bpb.bytes_per_sector);
			if (lseek64(fd, *seekto, SEEK_SET) < 0) {
				(void) fprintf(stderr,
				    gettext("Partition %s: "), pn);
				perror("");
				return (false);
			}
			return (true);
		} else {
			/*
			 * We ran out of extended dos partition
			 * drives.  The only hope now is to go
			 * back to extra drives defined in the master
			 * fdisk table.  But we overwrote that table
			 * already, so we must load it in again.
			 */
			logicalDriveCount += numDrives;
			(void) memcpy(part, mb.parts, sizeof (part));
		}
	}
	/*
	 *  Still haven't found the drive, is it an extra
	 *  drive defined in the main FDISK table?
	 */
	if (drvnum <= logicalDriveCount + numExtraDrives) {
		driveIndex = logicalDriveCount + numExtraDrives - drvnum;
		*seekto = ltohi(part[extraDrives[driveIndex]].relsect);
		if (*seekto == 0) {
			(void) fprintf(stderr, gettext("Bogus FDISK entry? "
			    "A partition starting\nat sector 0 would "
			    "collide with the FDISK table!\n"));
			return (false);
		}

		fill_bpb_sizes(wbpb, part, extraDrives[driveIndex], *seekto);
		*seekto *= wbpb->bpb.bytes_per_sector;
		FdiskFATsize =
		    lookup_FAT_size(part[extraDrives[driveIndex]].systid);
		if (Verbose)
			(void) printf(gettext("Partition's offset: "
			    "Sector %llx.\n"),
			    *seekto / wbpb->bpb.bytes_per_sector);
		if (lseek64(fd, *seekto, SEEK_SET) < 0) {
			(void) fprintf(stderr,
			    gettext("Partition %s: "), pn);
			perror("");
			return (false);
		}
		return (true);
	}
	(void) fprintf(stderr, gettext("No such logical drive\n"));
	return (false);
}

/*
 *  seek_nofdisk
 *
 *	User is asking us to trust them that they know best.
 *	We basically won't do much seeking here, the only seeking we'll do
 *	is if the 'hidden' parameter was given.
 */
static
bool
seek_nofdisk(int fd, bpb_t *wbpb, off64_t *seekto)
{
	if (TotSize > 0xffff)
		wbpb->bpb.sectors_in_volume = 0;
	else
		wbpb->bpb.sectors_in_volume = (short)TotSize;
	wbpb->bpb.sectors_in_logical_volume = TotSize;

	*seekto = RelOffset * wbpb->bpb.bytes_per_sector;
	wbpb->bpb.hidden_sectors = RelOffset;
	wbpb->sunbpb.bs_offset_high = RelOffset >> 16;
	wbpb->sunbpb.bs_offset_low = RelOffset & 0xFFFF;

	if (Verbose)
		(void) printf(gettext("Requested offset: Sector %llx.\n"),
		    *seekto/wbpb->bpb.bytes_per_sector);

	if (lseek64(fd, *seekto, SEEK_SET) < 0) {
		(void) fprintf(stderr,
		    gettext("User specified start sector %lu"), RelOffset);
		perror("");
		return (false);
	}
	return (true);
}

/*
 * set_fat_string
 *
 *	Fill in the type string of the FAT
 */
static
void
set_fat_string(bpb_t *wbpb, int fatsize)
{
	if (fatsize == 12) {
		(void) strncpy((char *)wbpb->ebpb.type, FAT12_TYPE_STRING,
		    strlen(FAT12_TYPE_STRING));
	} else if (fatsize == 16) {
		(void) strncpy((char *)wbpb->ebpb.type, FAT16_TYPE_STRING,
		    strlen(FAT16_TYPE_STRING));
	} else {
		(void) strncpy((char *)wbpb->ebpb.type, FAT32_TYPE_STRING,
		    strlen(FAT32_TYPE_STRING));
	}
}

/*
 *  prepare_image_file
 *
 *	Open the file that will hold the image (as opposed to the image
 *	being written to the boot sector of an actual disk).
 */
static
int
prepare_image_file(const char *fn, bpb_t *wbpb)
{
	int fd;
	char zerobyte = '\0';

	if ((fd = open(fn, O_RDWR | O_CREAT | O_EXCL, 0666)) < 0) {
		perror(fn);
		exit(ERR_OS);
	}

	if (Imagesize == 5) {
		/* Disk image of a 1.2M floppy */
		wbpb->bpb.sectors_in_volume = 2 * 80 * 15;
		wbpb->bpb.sectors_in_logical_volume = 2 * 80 * 15;
		wbpb->bpb.sectors_per_track = 15;
		wbpb->bpb.heads = 2;
		wbpb->bpb.media = 0xF9;
		wbpb->bpb.num_root_entries = 224;
		wbpb->bpb.sectors_per_cluster = 1;
		wbpb->bpb.sectors_per_fat = 7;
	} else {
		/* Disk image of a 1.44M floppy */
		wbpb->bpb.sectors_in_volume = 2 * 80 * 18;
		wbpb->bpb.sectors_in_logical_volume = 2 * 80 * 18;
		wbpb->bpb.sectors_per_track = 18;
		wbpb->bpb.heads = 2;
		wbpb->bpb.media = 0xF0;
		wbpb->bpb.num_root_entries = 224;
		wbpb->bpb.sectors_per_cluster = 1;
		wbpb->bpb.sectors_per_fat = 9;
	}

	/*
	 * Make a holey file, with length the exact
	 * size of the floppy image.
	 */
	if (lseek(fd, (wbpb->bpb.sectors_in_volume * MINBPS)-1, SEEK_SET) < 0) {
		(void) close(fd);
		perror(fn);
		exit(ERR_OS);
	}

	if (write(fd, &zerobyte, 1) != 1) {
		(void) close(fd);
		perror(fn);
		exit(ERR_OS);
	}

	if (lseek(fd, 0, SEEK_SET) < 0) {
		(void) close(fd);
		perror(fn);
		exit(ERR_OS);
	}

	Fatentsize = 12;  /* Size of fat entry in bits */
	set_fat_string(wbpb, Fatentsize);

	wbpb->ebpb.phys_drive_num = 0;

	wbpb->sunbpb.bs_offset_high = 0;
	wbpb->sunbpb.bs_offset_low = 0;

	return (fd);
}

/*
 *  partn_lecture
 *
 *	Give a brief sermon on dev_name user should pass to
 *	the program from the command line.
 *
 */
static
void
partn_lecture(char *dn)
{
	(void) fprintf(stderr,
	    gettext("\nDevice %s was assumed to be a diskette.\n"
	    "A diskette specific operation failed on this device.\n"
	    "If the device is a hard disk, provide the name of "
	    "the full physical disk,\n"
	    "and qualify that name with a logical drive specifier.\n\n"
	    "Hint: the device is usually something similar to\n\n"
	    "/dev/rdsk/c0d0p0 or /dev/rdsk/c0t0d0p0 (x86)\n"
	    "/dev/rdsk/c0t5d0s2 (sparc)\n\n"
	    "The drive specifier is appended to the device name."
	    " For example:\n\n"
	    "/dev/rdsk/c0t5d0s2:c or /dev/rdsk/c0d0p0:boot\n\n"), dn);
}

static
void
warn_funky_floppy(void)
{
	(void) fprintf(stderr,
	    gettext("Use the 'nofdisk' option to create file systems\n"
	    "on non-standard floppies.\n\n"));
	exit(ERR_FAIL);
}

static
void
warn_funky_fatsize(void)
{
	(void) fprintf(stderr,
	    gettext("Non-standard FAT size requested for floppy.\n"
	    "The 'nofdisk' option must be used to\n"
	    "override the 12 bit floppy default.\n\n"));
	exit(ERR_FAIL);
}

static
void
floppy_bpb_fillin(bpb_t *wbpb, int diam, int hds, int spt)
{
	switch (diam) {
	case 3:
		switch (hds) {
		case 2:
			switch (spt) {
			case 9:
				wbpb->bpb.media = 0xF9;
				wbpb->bpb.num_root_entries = 112;
				wbpb->bpb.sectors_per_cluster = 2;
				wbpb->bpb.sectors_per_fat = 3;
				break;
			case 18:
				wbpb->bpb.media = 0xF0;
				wbpb->bpb.num_root_entries = 224;
				wbpb->bpb.sectors_per_cluster = 1;
				wbpb->bpb.sectors_per_fat = 9;
				break;
			case 36:
				wbpb->bpb.media = 0xF0;
				wbpb->bpb.num_root_entries = 240;
				wbpb->bpb.sectors_per_cluster = 2;
				wbpb->bpb.sectors_per_fat = 9;
				break;
			default:
				(void) fprintf(stderr,
				    gettext("Unknown diskette parameters!  "
				    "3.5'' diskette with %d heads "
				    "and %d sectors/track.\n"), hds, spt);
				warn_funky_floppy();
			}
			break;
		case 1:
		default:
			(void) fprintf(stderr,
			    gettext("Unknown diskette parameters!  "
			    "3.5'' diskette with %d heads "), hds);
			warn_funky_floppy();
		}
		break;
	case 5:
		switch (hds) {
		case 2:
			switch (spt) {
			case 15:
				wbpb->bpb.media = 0xF9;
				wbpb->bpb.num_root_entries = 224;
				wbpb->bpb.sectors_per_cluster = 1;
				wbpb->bpb.sectors_per_fat = 7;
				break;
			case 9:
				wbpb->bpb.media = 0xFD;
				wbpb->bpb.num_root_entries = 112;
				wbpb->bpb.sectors_per_cluster = 2;
				wbpb->bpb.sectors_per_fat = 2;
				break;
			case 8:
				wbpb->bpb.media = 0xFF;
				wbpb->bpb.num_root_entries = 112;
				wbpb->bpb.sectors_per_cluster = 1;
				wbpb->bpb.sectors_per_fat = 2;
				break;
			default:
				(void) fprintf(stderr,
				    gettext("Unknown diskette parameters!  "
				    "5.25'' diskette with %d heads "
				    "and %d sectors/track.\n"), hds, spt);
				warn_funky_floppy();
			}
			break;
		case 1:
			switch (spt) {
			case 9:
				wbpb->bpb.media = 0xFC;
				wbpb->bpb.num_root_entries = 64;
				wbpb->bpb.sectors_per_cluster = 1;
				wbpb->bpb.sectors_per_fat = 2;
				break;
			case 8:
				wbpb->bpb.media = 0xFE;
				wbpb->bpb.num_root_entries = 64;
				wbpb->bpb.sectors_per_cluster = 1;
				wbpb->bpb.sectors_per_fat = 1;
				break;
			default:
				(void) fprintf(stderr,
				    gettext("Unknown diskette parameters! "
				    "5.25'' diskette with %d heads "
				    "and %d sectors/track.\n"), hds, spt);
				warn_funky_floppy();
			}
			break;
		default:
			(void) fprintf(stderr,
			    gettext("Unknown diskette parameters! "
			    "5.25'' diskette with %d heads."), hds);
			warn_funky_floppy();
		}
		break;
	default:
		(void) fprintf(stderr,
		    gettext("\nUnknown diskette type.  Only know about "
		    "5.25'' and 3.5'' diskettes.\n"));
		warn_funky_floppy();
	}
}

/*
 *  lookup_floppy
 *
 *	Look up a media descriptor byte and other crucial BPB values
 *	based on floppy characteristics.
 */
static
void
lookup_floppy(struct fd_char *fdchar, bpb_t *wbpb)
{
	ulong_t tsize;
	ulong_t cyls, spt, hds, diam;

	cyls = fdchar->fdc_ncyl;
	diam = fdchar->fdc_medium;
	spt = fdchar->fdc_secptrack;
	hds = fdchar->fdc_nhead;

	tsize = cyls * hds * spt;

	if (GetFsParams)
		TotSize = tsize;

	if (GetSize) {
		wbpb->bpb.sectors_in_logical_volume = tsize;
	} else {
		wbpb->bpb.sectors_in_logical_volume =
		    warn_mismatch(
		    gettext("length of partition (in sectors)"),
		    gettext("FDIOGCHAR call"), tsize, TotSize);
	}
	wbpb->bpb.sectors_in_volume =
	    (short)wbpb->bpb.sectors_in_logical_volume;

	if (GetSPT) {
		wbpb->bpb.sectors_per_track = spt;
	} else {
		wbpb->bpb.sectors_per_track =
		    warn_mismatch(
		    gettext("sectors per track"),
		    gettext("FDIOGCHAR call"), spt, SecPerTrk);
		spt = wbpb->bpb.sectors_per_track;
	}

	if (GetTPC) {
		wbpb->bpb.heads = hds;
	} else {
		wbpb->bpb.heads =
		    warn_mismatch(
		    gettext("number of heads"),
		    gettext("FDIOGCHAR call"), hds, TrkPerCyl);
		hds = wbpb->bpb.heads;
	}

	Fatentsize = 12;  /* Size of fat entry in bits */
	if (!GetBPF && BitsPerFAT != Fatentsize) {
		warn_funky_fatsize();
	}
	set_fat_string(wbpb, Fatentsize);

	wbpb->ebpb.phys_drive_num = 0;

	wbpb->bpb.hidden_sectors = 0;
	wbpb->sunbpb.bs_offset_high = 0;
	wbpb->sunbpb.bs_offset_low = 0;

	floppy_bpb_fillin(wbpb, diam, hds, spt);
}

/*
 *  compute_cluster_size
 *
 *	Compute an acceptable sectors/cluster value.
 *
 *	Based on values from the Hardware White Paper
 *	from Microsoft.
 *	"Microsoft Extensible Firmware Initiative
 *	 FAT32 File System Specification
 *	 FAT: General Overview of On-Disk Format"
 *
 *	Version 1.03, December 6, 2000
 *
 */
static
void
compute_cluster_size(bpb_t *wbpb)
{
	ulong_t volsize;
	ulong_t spc;
	ulong_t rds, scale, tmpval1, tmpval2;
	ulong_t fatsz;
	int newfat = 16;

#define	FAT12_MAX_CLUSTERS	0x0FF4
#define	FAT16_MAX_CLUSTERS	0xFFF4
#define	FAT32_MAX_CLUSTERS	0x0FFFFFF0
#define	FAT32_SUGGESTED_NCLUST	0x400000

	/* compute volume size in sectors. */
	volsize = wbpb->bpb.sectors_in_volume ? wbpb->bpb.sectors_in_volume :
	    wbpb->bpb.sectors_in_logical_volume;
	volsize -= wbpb->bpb.resv_sectors;

	if (GetSPC) {
		/*
		 * User indicated what sort of FAT to create,
		 * make sure it is valid with the given size
		 * and compute an SPC value.
		 */
		if (!MakeFAT32) { /* FAT16 */
			/* volsize is in sectors */
			if (volsize < FAT12_MAX_CLUSTERS) {
				(void) fprintf(stderr,
				    gettext("Requested size is too "
				    "small for FAT16.\n"));
				exit(ERR_FAIL);
			}
			/* SPC must be a power of 2 */
			for (spc = 1; spc <= 64; spc = spc * 2) {
				if (volsize < spc * FAT16_MAX_CLUSTERS)
					break;
			}
			if (volsize > (spc * FAT16_MAX_CLUSTERS)) {
				(void) fprintf(stderr,
				    gettext("Requested size is too "
				    "large for FAT16.\n"));
				exit(ERR_FAIL);
			}
		} else { /* FAT32 */
			/* volsize is in sectors */
			if (volsize <= FAT16_MAX_CLUSTERS) {
				(void) fprintf(stderr,
				    gettext("Requested size is too "
				    "small for FAT32.\n"));
				exit(ERR_FAIL);
			}
			/* SPC must be a power of 2 */
			for (spc = 1; spc <= 64; spc = spc * 2) {
				if (volsize < (spc * FAT32_SUGGESTED_NCLUST))
					break;
			}
			if (volsize > (spc * FAT32_MAX_CLUSTERS)) {
				(void) fprintf(stderr,
				    gettext("Requested size is too "
				    "large for FAT32.\n"));
				exit(ERR_FAIL);
			}
		}
	} else {
		/*
		 * User gave the SPC as an explicit option,
		 * make sure it will work with the requested
		 * volume size.
		 */
		int nclust;

		spc = SecPerClust;
		nclust = volsize / spc;

		if (nclust <= FAT16_MAX_CLUSTERS && MakeFAT32) {
			(void) fprintf(stderr, gettext("Requested size is too "
			    "small for FAT32.\n"));
			exit(ERR_FAIL);
		}
		if (!MakeFAT32) {
			/* Determine if FAT12 or FAT16 */
			if (nclust < FAT12_MAX_CLUSTERS)
				newfat = 12;
			else if (nclust < FAT16_MAX_CLUSTERS)
				newfat = 16;
			else {
				(void) fprintf(stderr,
				    gettext("Requested size is too "
				    "small for FAT32.\n"));
				exit(ERR_FAIL);
			}
		}
	}

	/*
	 * RootDirSectors = ((BPB_RootEntCnt * 32) +
	 *	(BPB_BytsPerSec - 1)) / BPB_BytsPerSec;
	 */
	rds = ((wbpb->bpb.num_root_entries * 32) +
	    (wbpb->bpb.bytes_per_sector - 1)) / wbpb->bpb.bytes_per_sector;

	if (GetBPF) {
		if (MakeFAT32)
			Fatentsize = 32;
		else
			Fatentsize = newfat;
	} else {
		Fatentsize = BitsPerFAT;

		if (Fatentsize == 12 &&
		    (volsize - rds) >= DOS_F12MAXC * spc) {
			/*
			 * If we don't have an input TTY, or we aren't
			 * really doing anything, then don't ask
			 * questions.  Assume a yes answer to any
			 * questions we would ask.
			 */
			if (Notreally || !isatty(fileno(stdin))) {
				(void) printf(
				gettext("Volume too large for 12 bit FAT,"
				    " increasing to 16 bit FAT size.\n"));
				(void) fflush(stdout);
				Fatentsize = 16;
			} else {
				(void) printf(
				gettext("Volume too large for a 12 bit FAT.\n"
				    "Increase to 16 bit FAT "
				    "and continue (y/n)? "));
				(void) fflush(stdout);
				if (yes())
					Fatentsize = 16;
				else
					exit(ERR_USER);
			}
		}
	}
	wbpb->bpb.sectors_per_cluster = spc;

	if (!GetFsParams && FdiskFATsize < 0) {
		(void) printf(
		    gettext("Cannot verify chosen/computed FAT "
		    "entry size (%d bits) with FDISK table.\n"
		    "FDISK table has an unknown file system "
		    "type for this device.  Giving up...\n"),
		    Fatentsize);
		exit(ERR_INVAL);
	} else if (!GetFsParams && FdiskFATsize && FdiskFATsize != Fatentsize) {
		(void) printf(
		    gettext("Chosen/computed FAT entry size (%d bits) "
		    "does not match FDISK table (%d bits).\n"),
		    Fatentsize, FdiskFATsize);
		(void) printf(
		    gettext("Use -o fat=%d to build a FAT "
		    "that matches the FDISK entry.\n"), FdiskFATsize);
		exit(ERR_INVAL);
	}
	set_fat_string(wbpb, Fatentsize);
	/*
	 * Compute the FAT sizes according to algorithm from Microsoft:
	 *
	 * RootDirSectors = ((BPB_RootEntCnt * 32) +
	 *	(BPB_BytsPerSec - 1)) / BPB_BytsPerSec;
	 * TmpVal1 = DskSize - (BPB_ResvdSecCnt + RootDirSectors);
	 * TmpVal2 = (256 * BPB_SecPerClus) + BPB_NumFATs;
	 * If (FATType == FAT32)
	 *	TmpVal2 = TmpVal2 / 2;
	 * FATSz = (TMPVal1 + (TmpVal2 - 1)) / TmpVal2;
	 * If (FATType == FAT32) {
	 *	BPB_FATSz16 = 0;
	 *	BPB_FATSz32 = FATSz;
	 * } else {
	 *	BPB_FATSz16 = LOWORD(FATSz);
	 *	// there is no BPB_FATSz32 in a FAT16 BPB
	 * }
	 *
	 * The comment from Microsoft [fatgen103, page 21] is that we should
	 * not think too much about this algorithm and that it works.
	 * However, they neglected to mention, it does work with a 512B sector
	 * size. When using different sector sizes we need to change the
	 * scale factor from 256. Apparently the scale factor is actually
	 * meant to be half of the sector size.
	 */
	scale = wbpb->bpb.bytes_per_sector / 2;
	tmpval1 = volsize - (wbpb->bpb.resv_sectors + rds);

	tmpval2 = (scale * wbpb->bpb.sectors_per_cluster) + wbpb->bpb.num_fats;

	if (Fatentsize == 32)
		tmpval2 = tmpval2 / 2;

	fatsz = (tmpval1 + (tmpval2 - 1)) / tmpval2;

	/* Compute a sector/fat figure */
	switch (Fatentsize) {
	case 32:
		wbpb->bpb.sectors_per_fat = 0;
		wbpb->bpb32.big_sectors_per_fat = fatsz;
		if (Verbose)
			(void) printf("%s: Sectors per FAT32 = %d\n",
			    __func__, wbpb->bpb32.big_sectors_per_fat);
		break;
	case 12:
	default:	/* 16 bit FAT */
		wbpb->bpb.sectors_per_fat = (ushort_t)(fatsz & 0x0000FFFF);
		if (Verbose)
			(void) printf("%s: Sectors per FAT16 = %d\n",
			    __func__, wbpb->bpb.sectors_per_fat);
		break;
	}
}

static
void
find_fixed_details(int fd, bpb_t *wbpb)
{
	struct dk_geom dginfo;

	/*
	 *  Look up the last remaining bits of info we need
	 *  that is specific to the hard drive using a disk ioctl.
	 */
	if (GetSPT || GetTPC) {
		if (ioctl(fd, DKIOCG_VIRTGEOM, &dginfo) == -1 &&
		    ioctl(fd, DKIOCG_PHYGEOM, &dginfo) == -1 &&
		    ioctl(fd, DKIOCGGEOM, &dginfo) == -1) {
			(void) close(fd);
			perror(
			    gettext("Drive geometry lookup (need "
			    "tracks/cylinder and/or sectors/track"));
			exit(ERR_OS);
		}
	}

	wbpb->bpb.heads = (GetTPC ? dginfo.dkg_nhead : TrkPerCyl);
	wbpb->bpb.sectors_per_track = (GetSPT ? dginfo.dkg_nsect : SecPerTrk);

	if (Verbose) {
		if (GetTPC) {
			(void) printf(
			    gettext("DKIOCG determined number of heads = %d\n"),
			    dginfo.dkg_nhead);
		}
		if (GetSPT) {
			(void) printf(
			    gettext("DKIOCG determined sectors per track"
			    " = %d\n"), dginfo.dkg_nsect);
		}
	}

	/*
	 * XXX - MAY need an additional flag (or flags) to set media
	 * and physical drive number fields.  That in the case of weird
	 * floppies that have to go through 'nofdisk' route for formatting.
	 */
	wbpb->bpb.media = 0xF8;
	if (MakeFAT32)
		wbpb->bpb.num_root_entries = 0;
	else
		wbpb->bpb.num_root_entries = 512;
	wbpb->ebpb.phys_drive_num = 0x80;
	compute_cluster_size(wbpb);
}

static
void
compute_file_area_size(bpb_t *wbpb)
{
	int FATSz;
	int TotSec;
	int DataSec;
	int RootDirSectors =
	    ((wbpb->bpb.num_root_entries * 32) +
	    (wbpb->bpb.bytes_per_sector - 1)) /
	    wbpb->bpb.bytes_per_sector;

	if (wbpb->bpb.sectors_per_fat) {
		/*
		 * Good old FAT12 or FAT16
		 */
		FATSz = wbpb->bpb.sectors_per_fat;
		TotSec = wbpb->bpb.sectors_in_volume;
	} else {
		/*
		 *  FAT32
		 */
		FATSz = wbpb->bpb32.big_sectors_per_fat;
		TotSec = wbpb->bpb.sectors_in_logical_volume;
	}

	DataSec = TotSec -
	    (wbpb->bpb.resv_sectors + (wbpb->bpb.num_fats * FATSz) +
	    RootDirSectors);


	/*
	 * Now change sectors to clusters
	 */
	TotalClusters = DataSec / wbpb->bpb.sectors_per_cluster;

	if (Verbose)
		(void) printf(gettext("Disk has a file area of %lu "
		    "allocation units,\neach with %d sectors = %lu "
		    "bytes.\n"), TotalClusters, wbpb->bpb.sectors_per_cluster,
		    TotalClusters * wbpb->bpb.sectors_per_cluster *
		    wbpb->bpb.bytes_per_sector);
}

#ifdef _BIG_ENDIAN
/*
 *  swap_pack_{bpb,bpb32,sebpb}cpy
 *
 *	If not on an x86 we assume the structures making up the bpb
 *	were not packed and that longs and shorts need to be byte swapped
 *	(we've kept everything in host order up until now).  A new architecture
 *	might not need to swap or might not need to pack, in which case
 *	new routines will have to be written.  Of course if an architecture
 *	supports both packing and little-endian host order, it can follow the
 *	same path as the x86 code.
 */
static
void
swap_pack_bpbcpy(struct _boot_sector *bsp, bpb_t *wbpb)
{
	uchar_t *fillp;

	fillp = (uchar_t *)&(bsp->bs_filler[ORIG_BPB_START_INDEX]);

	store_16_bits(&fillp, wbpb->bpb.bytes_per_sector);
	*fillp++ = wbpb->bpb.sectors_per_cluster;
	store_16_bits(&fillp, wbpb->bpb.resv_sectors);
	*fillp++ = wbpb->bpb.num_fats;
	store_16_bits(&fillp, wbpb->bpb.num_root_entries);
	store_16_bits(&fillp, wbpb->bpb.sectors_in_volume);
	*fillp++ = wbpb->bpb.media;
	store_16_bits(&fillp, wbpb->bpb.sectors_per_fat);
	store_16_bits(&fillp, wbpb->bpb.sectors_per_track);
	store_16_bits(&fillp, wbpb->bpb.heads);
	store_32_bits(&fillp, wbpb->bpb.hidden_sectors);
	store_32_bits(&fillp, wbpb->bpb.sectors_in_logical_volume);

	*fillp++ = wbpb->ebpb.phys_drive_num;
	*fillp++ = wbpb->ebpb.reserved;
	*fillp++ = wbpb->ebpb.ext_signature;
	store_32_bits(&fillp, wbpb->ebpb.volume_id);
	(void) strncpy((char *)fillp, (char *)wbpb->ebpb.volume_label, 11);
	fillp += 11;
	(void) strncpy((char *)fillp, (char *)wbpb->ebpb.type, 8);
}

static
void
swap_pack_bpb32cpy(struct _boot_sector32 *bsp, bpb_t *wbpb)
{
	uchar_t *fillp;
	int r;

	fillp = (uchar_t *)&(bsp->bs_filler[ORIG_BPB_START_INDEX]);

	store_16_bits(&fillp, wbpb->bpb.bytes_per_sector);
	*fillp++ = wbpb->bpb.sectors_per_cluster;
	store_16_bits(&fillp, wbpb->bpb.resv_sectors);
	*fillp++ = wbpb->bpb.num_fats;
	store_16_bits(&fillp, wbpb->bpb.num_root_entries);
	store_16_bits(&fillp, wbpb->bpb.sectors_in_volume);
	*fillp++ = wbpb->bpb.media;
	store_16_bits(&fillp, wbpb->bpb.sectors_per_fat);
	store_16_bits(&fillp, wbpb->bpb.sectors_per_track);
	store_16_bits(&fillp, wbpb->bpb.heads);
	store_32_bits(&fillp, wbpb->bpb.hidden_sectors);
	store_32_bits(&fillp, wbpb->bpb.sectors_in_logical_volume);

	store_32_bits(&fillp, wbpb->bpb32.big_sectors_per_fat);
	store_16_bits(&fillp, wbpb->bpb32.ext_flags);
	*fillp++ = wbpb->bpb32.fs_vers_lo;
	*fillp++ = wbpb->bpb32.fs_vers_hi;
	store_32_bits(&fillp, wbpb->bpb32.root_dir_clust);
	store_16_bits(&fillp, wbpb->bpb32.fsinfosec);
	store_16_bits(&fillp, wbpb->bpb32.backupboot);
	for (r = 0; r < 6; r++)
		store_16_bits(&fillp, wbpb->bpb32.reserved[r]);

	*fillp++ = wbpb->ebpb.phys_drive_num;
	*fillp++ = wbpb->ebpb.reserved;
	*fillp++ = wbpb->ebpb.ext_signature;
	store_32_bits(&fillp, wbpb->ebpb.volume_id);
	(void) strncpy((char *)fillp, (char *)wbpb->ebpb.volume_label, 11);
	fillp += 11;
	(void) strncpy((char *)fillp, (char *)wbpb->ebpb.type, 8);
}

static
void
swap_pack_sebpbcpy(struct _boot_sector *bsp, bpb_t *wbpb)
{
	uchar_t *fillp;

	fillp = bsp->bs_sun_bpb;
	store_16_bits(&fillp, wbpb->sunbpb.bs_offset_high);
	store_16_bits(&fillp, wbpb->sunbpb.bs_offset_low);
}

static
void
swap_pack_grabsebpb(bpb_t *wbpb, struct _boot_sector *bsp)
{
	uchar_t *grabp;

	grabp = bsp->bs_sun_bpb;
	((uchar_t *)&(wbpb->sunbpb.bs_offset_high))[1] = *grabp++;
	((uchar_t *)&(wbpb->sunbpb.bs_offset_high))[0] = *grabp++;
	((uchar_t *)&(wbpb->sunbpb.bs_offset_low))[1] = *grabp++;
	((uchar_t *)&(wbpb->sunbpb.bs_offset_low))[0] = *grabp++;
}
#endif	/* ! _BIG_ENDIAN */

static
void
dashm_bail(int fd)
{
	(void) fprintf(stderr,
	    gettext("This media does not appear to be "
	    "formatted with a FAT file system.\n"));
	(void) close(fd);
	exit(ERR_INVAL);
}

/*
 *  read_existing_bpb
 *
 *	Grab the first sector, which we think is a bios parameter block.
 *	If it looks bad, bail.  Otherwise fill in the parameter struct
 *	fields that matter.
 */
static
void
read_existing_bpb(int fd, bpb_t *wbpb)
{
	boot_sector_t ubpb;
	size_t bps;

	bps = wbpb->bpb.bytes_per_sector;
	if (read(fd, ubpb.buf, bps) < (ssize_t)bps) {
		perror(gettext("Read BIOS parameter block "
		    "from previously formatted media"));
		(void) close(fd);
		exit(ERR_INVAL);
	}

	if (ltohs(ubpb.mb.signature) != BOOTSECSIG) {
		dashm_bail(fd);
	}

#ifdef _LITTLE_ENDIAN
	(void) memcpy(&(wbpb->bpb), &(ubpb.bs.bs_front.bs_bpb),
	    sizeof (wbpb->bpb));
	(void) memcpy(&(wbpb->ebpb), &(ubpb.bs.bs_ebpb), sizeof (wbpb->ebpb));
#else
	swap_pack_grabbpb(wbpb, &(ubpb.bs));
#endif
	if (SunBPBfields) {
#ifdef _LITTLE_ENDIAN
		(void) memcpy(&(wbpb->sunbpb), &(ubpb.bs.bs_sebpb),
		    sizeof (wbpb->sunbpb));
#else
		swap_pack_grabsebpb(wbpb, &(ubpb.bs));
#endif
	}
	if (!is_sector_size_valid(wbpb->bpb.bytes_per_sector)) {
		(void) close(fd);
		err(ERR_INVAL,
		    gettext("Invalid bytes/sector (%u): must be 512, 1024, "
		    "2048 or 4096\n"), wbpb->bpb.bytes_per_sector);
	}
	bps = wbpb->bpb.bytes_per_sector;

	if (!(ISP2(wbpb->bpb.sectors_per_cluster) &&
	    IN_RANGE(wbpb->bpb.sectors_per_cluster, 1, 128))) {
		(void) fprintf(stderr,
		    gettext("Bogus sectors per cluster value.\n"));
		(void) fprintf(stderr,
		    gettext("The device name may be missing a "
		    "logical drive specifier.\n"));
		(void) close(fd);
		exit(ERR_INVAL);
	}

	if (wbpb->bpb.sectors_per_fat == 0) {
#ifdef _LITTLE_ENDIAN
		(void) memcpy(&(wbpb->bpb32), &(ubpb.bs32.bs_bpb32),
		    sizeof (wbpb->bpb32));
#else
		swap_pack_grab32bpb(wbpb, &(ubpb.bs));
#endif
		compute_file_area_size(wbpb);
		if ((wbpb->bpb32.big_sectors_per_fat * bps / 4) >=
		    TotalClusters) {
			MakeFAT32 = 1;
		} else {
			dashm_bail(fd);
		}
	} else {
		compute_file_area_size(wbpb);
	}
}

/*
 *  compare_existing_with_computed
 *
 *	We use this function when we the user specifies the -m option.
 *	We compute and look up things like we would if they had asked
 *	us to make the fs, and compare that to what's already layed down
 *	in the existing fs.  If there's a difference we can tell them what
 *	options to specify in order to reproduce their existing layout.
 *	Note that they still may not get an exact duplicate, because we
 *	don't, for example, preserve their existing boot code.  We think
 *	we've got all the fields that matter covered, though.
 *
 *	XXX - We're basically ignoring sbpb at this point.  I'm unsure
 *	if we'll ever care about those fields, in terms of the -m option.
 */
static
void
compare_existing_with_computed(int fd, char *suffix,
    bpb_t *wbpb, int *prtsize, int *prtspc, int *prtbpf, int *prtnsect,
    int *prtntrk, int *prtfdisk, int *prthidden, int *prtrsrvd, int *dashos)
{
	struct dk_geom	dginfo;
	struct fd_char	fdchar;
	bpb_t		compare;
	int		fd_ioctl_worked = 0;
	int		fatents;

	/*
	 *  For all non-floppy cases we expect to find a 16-bit FAT
	 */
	int expectfatsize = 16;

	compare = *wbpb;

	if (!suffix) {
		if (ioctl(fd, FDIOGCHAR, &fdchar) != -1) {
			expectfatsize = 12;
			fd_ioctl_worked++;
		}
	}

	if (fd_ioctl_worked) {
#ifdef sparc
		fdchar.fdc_medium = 3;
#endif
		GetSize = GetSPT = GetSPC = GetTPC = GetBPF = 1;
		lookup_floppy(&fdchar, &compare);
		if (compare.bpb.heads != wbpb->bpb.heads) {
			(*prtntrk)++;
			(*dashos)++;
		}
		if (compare.bpb.sectors_per_track !=
		    wbpb->bpb.sectors_per_track) {
			(*prtnsect)++;
			(*dashos)++;
		}
	} else {
		int dk_ioctl_worked = 1;

		if (!suffix) {
			(*prtfdisk)++;
			(*prtsize)++;
			*dashos += 2;
		}
		if (ioctl(fd, DKIOCG_VIRTGEOM, &dginfo) == -1 &&
		    ioctl(fd, DKIOCG_PHYGEOM, &dginfo) == -1 &&
		    ioctl(fd, DKIOCGGEOM, &dginfo) == -1) {
			*prtnsect = *prtntrk = 1;
			*dashos += 2;
			dk_ioctl_worked = 0;
		}
		if (dk_ioctl_worked) {
			if (dginfo.dkg_nhead != wbpb->bpb.heads) {
				(*prtntrk)++;
				(*dashos)++;
			}
			if (dginfo.dkg_nsect !=
			    wbpb->bpb.sectors_per_track) {
				(*prtnsect)++;
				(*dashos)++;
			}
		}
		GetBPF = GetSPC = 1;
		compute_cluster_size(&compare);
	}

	if (!*prtfdisk && TotSize != wbpb->bpb.sectors_in_volume &&
	    TotSize != wbpb->bpb.sectors_in_logical_volume) {
		(*dashos)++;
		(*prtsize)++;
	}

	if (compare.bpb.sectors_per_cluster != wbpb->bpb.sectors_per_cluster) {
		(*dashos)++;
		(*prtspc)++;
	}

	if (compare.bpb.hidden_sectors != wbpb->bpb.hidden_sectors) {
		(*dashos)++;
		(*prthidden)++;
	}

	if (compare.bpb.resv_sectors != wbpb->bpb.resv_sectors) {
		(*dashos)++;
		(*prtrsrvd)++;
	}

	/*
	 * Compute approximate Fatentsize.  It's approximate because the
	 * size of the FAT may not be exactly a multiple of the number of
	 * clusters.  It should be close, though.
	 */
	if (MakeFAT32) {
		Fatentsize = 32;
		(*dashos)++;
		(*prtbpf)++;
	} else {
		fatents = wbpb->bpb.sectors_per_fat *
		    wbpb->bpb.bytes_per_sector * 2 / 3;
		if (fatents >= TotalClusters && wbpb->ebpb.type[4] == '2')
			Fatentsize = 12;
		else
			Fatentsize = 16;
		if (Fatentsize != expectfatsize) {
			(*dashos)++;
			(*prtbpf)++;
		}
	}
}

static
void
print_reproducing_command(int fd, char *actualdisk, char *suffix, bpb_t *wbpb)
{
	int needcomma = 0;
	int prthidden = 0;
	int prtrsrvd = 0;
	int prtfdisk = 0;
	int prtnsect = 0;
	int prtntrk = 0;
	int prtsize = 0;
	int prtbpf = 0;
	int prtspc = 0;
	int dashos = 0;
	int ll, i;

	compare_existing_with_computed(fd, suffix, wbpb,
	    &prtsize, &prtspc, &prtbpf, &prtnsect, &prtntrk,
	    &prtfdisk, &prthidden, &prtrsrvd, &dashos);

	/*
	 *  Print out the command line they can use to reproduce the
	 *  file system.
	 */
	(void) printf("mkfs -F pcfs");

	ll = MIN(11, (int)strlen((char *)wbpb->ebpb.volume_label));
	/*
	 * First, eliminate trailing spaces. Now compare the name against
	 * our default label.  If there's a match we don't need to print
	 * any label info.
	 */
	i = ll;
	while (wbpb->ebpb.volume_label[--i] == ' ')
		;
	ll = i;

	if (ll == strlen(DEFAULT_LABEL) - 1) {
		char cmpbuf[11];

		(void) strcpy(cmpbuf, DEFAULT_LABEL);
		for (i = ll; i >= 0; i--) {
			if (cmpbuf[i] !=
			    toupper((int)(wbpb->ebpb.volume_label[i]))) {
				break;
			}
		}
		if (i < 0)
			ll = i;
	}

	if (ll >= 0) {
		(void) printf(" -o ");
		(void) printf("b=\"");
		for (i = 0; i <= ll; i++) {
			(void) printf("%c", wbpb->ebpb.volume_label[i]);
		}
		(void) printf("\"");
		needcomma++;
	} else if (dashos) {
		(void) printf(" -o ");
	}

#define	NEXT_DASH_O	dashos--; needcomma++; continue

	while (dashos) {
		if (needcomma) {
			(void) printf(",");
			needcomma = 0;
		}
		if (prtfdisk) {
			(void) printf("nofdisk");
			prtfdisk--;
			NEXT_DASH_O;
		}
		if (prtsize) {
			(void) printf("size=%u", wbpb->bpb.sectors_in_volume ?
			    wbpb->bpb.sectors_in_volume :
			    wbpb->bpb.sectors_in_logical_volume);
			prtsize--;
			NEXT_DASH_O;
		}
		if (prtnsect) {
			(void) printf("nsect=%d", wbpb->bpb.sectors_per_track);
			prtnsect--;
			NEXT_DASH_O;
		}
		if (prtspc) {
			(void) printf("spc=%d", wbpb->bpb.sectors_per_cluster);
			prtspc--;
			NEXT_DASH_O;
		}
		if (prtntrk) {
			(void) printf("ntrack=%d", wbpb->bpb.heads);
			prtntrk--;
			NEXT_DASH_O;
		}
		if (prtbpf) {
			(void) printf("fat=%d", Fatentsize);
			prtbpf--;
			NEXT_DASH_O;
		}
		if (prthidden) {
			(void) printf("hidden=%u", wbpb->bpb.hidden_sectors);
			prthidden--;
			NEXT_DASH_O;
		}
		if (prtrsrvd) {
			(void) printf("reserve=%d", wbpb->bpb.resv_sectors);
			prtrsrvd--;
			NEXT_DASH_O;
		}
	}

	(void) printf(" %s%c%c\n", actualdisk,
	    suffix ? ':' : '\0', suffix ? *suffix : '\0');
}

/*
 *  open_and_examine
 *
 *	Open the requested 'dev_name'.  Seek to point where
 *	we'd expect to find boot sectors, etc., based on any ':partition'
 *	attachments to the dev_name.
 *
 *	Examine the fields of any existing boot sector and display best
 *	approximation of how this fs could be reproduced with this command.
 */
static
int
open_and_examine(char *dn, bpb_t *wbpb)
{
	struct stat di;
	off64_t ignored;
	char *actualdisk = NULL;
	char *suffix = NULL;
	int fd, rv;
	size_t ssize;

	if (Verbose)
		(void) printf(gettext("Opening destination device/file.\n"));

	actualdisk = stat_actual_disk(dn, &di, &suffix);

	/*
	 *  Destination exists, now find more about it.
	 */
	if (!(S_ISCHR(di.st_mode))) {
		(void) fprintf(stderr,
		    gettext("\n%s: device name must be a "
		    "character special device.\n"), actualdisk);
		exit(ERR_OS);
	} else if ((fd = open(actualdisk, O_RDWR)) < 0) {
		perror(actualdisk);
		exit(ERR_OS);
	}

	/*
	 * Get the media sector size.
	 */
	rv = get_media_sector_size(fd, &ssize);
	if (rv != 0) {
		int e = errno;
		(void) close(fd);
		errc(ERR_OS, e, gettext("failed to obtain sector size for %s"),
		    actualdisk);
	}
	if (!is_sector_size_valid(ssize)) {
		(void) close(fd);
		err(ERR_OS,
		    gettext("Invalid bytes/sector (%zu): must be 512, 1024, "
		    "2048 or 4096\n"), ssize);
	}
	wbpb->bpb.bytes_per_sector = ssize;

	/*
	 * Find appropriate partition if we were requested to do so.
	 */
	if (suffix && !(seek_partn(fd, suffix, wbpb, &ignored))) {
		(void) close(fd);
		exit(ERR_OS);
	}

	read_existing_bpb(fd, wbpb);
	print_reproducing_command(fd, actualdisk, suffix, wbpb);

	return (fd);
}

/*
 * getdiskinfo
 *
 * Extracts information about disk path in dn. We need to return both a
 * file descriptor and the device's suffix.
 * Secondarily, we need to detect the FAT type and size when dealing with
 * GPT partitions.
 */
static void
getdiskinfo(const char *dn, char **actualdisk, char **suffix)
{
	struct stat di;
	int rv, fd, reserved;
	dk_gpt_t *gpt = NULL;

	*actualdisk = stat_actual_disk(dn, &di, suffix);

	/*
	 * Destination exists, now find more about it.
	 */
	if (!(S_ISCHR(di.st_mode))) {
		(void) fprintf(stderr,
		    gettext("Device name must indicate a "
		    "character special device: %s\n"), *actualdisk);
		exit(ERR_OS);
	} else if ((fd = open(*actualdisk, O_RDWR)) < 0) {
		err(ERR_OS, "%s: failed to open disk device %s", __func__,
		    *actualdisk);
	}

	rv = efi_alloc_and_read(fd, &gpt);
	/*
	 * We should see only VT_EINVAL, VT_EIO and VT_ERROR.
	 * VT_EINVAL is for the case there is no GPT label.
	 * VT_ERROR will happen if device does no support the ioctl, so
	 * we will exit only in case of VT_EIO and unknown value of rv.
	 */
	if (rv < 0 && rv != VT_EINVAL && rv != VT_ERROR) {
		switch (rv) {
		case VT_EIO:
			(void) fprintf(stderr,
			    gettext("IO Error reading EFI label\n"));
			break;
		default:
			(void) fprintf(stderr,
			    gettext("Unknown Error %d reading EFI label\n"),
			    rv);
			break;
		}
		(void) close(fd);
		exit(ERR_OS);
	}
	if (rv >= 0) {
		DontUseFdisk = 1;
		if (*suffix != NULL) {
			(void) fprintf(stderr,
			    gettext("Can not use drive specifier \"%s\" with "
			    "GPT partitioning.\n"), *suffix);
			efi_free(gpt);
			(void) close(fd);
			exit(ERR_OS);
		}
		/* Can not use whole disk, 7 is GPT minor node "wd" */
		if (rv == 7) {
			(void) fprintf(stderr,
			    gettext("Device name must indicate a "
			    "partition: %s\n"), *actualdisk);
			efi_free(gpt);
			(void) close(fd);
			exit(ERR_OS);
		}

		if (GetSize == 1) {
			TotSize = gpt->efi_parts[rv].p_size;
			GetSize = 0;
		}

		if (GetBPF == 1) {
			if (GetResrvd == 1) {
				/* FAT32 has 32 reserved sectors */
				reserved = 32;
			} else {
				reserved = Resrvd;
			}
			/*
			 * The type of FAT is determined by the size of
			 * the partition - reserved sectors.
			 * The calculation is based on logic used in
			 * compute_cluster_size() and therefore we will not
			 * get into error situation when
			 * compute_cluster_size() will be called.
			 */
			if (TotSize - reserved < FAT16_MAX_CLUSTERS) {
				if (GetResrvd == 1)
					reserved = 1;

				if (TotSize - reserved < FAT12_MAX_CLUSTERS) {
					int spc;
					MakeFAT32 = 0;
					Fatentsize = 12;
					/*
					 * compute sectors per cluster
					 * for fat12
					 */
					for (spc = 1; spc <= 64;
					    spc = spc * 2) {
						if (TotSize - reserved <
						    spc * FAT12_MAX_CLUSTERS)
							break;
					}
					if (GetSPC == 1) {
						GetSPC = 0;
						SecPerClust = spc;
					}
				} else {
					MakeFAT32 = 0;
					Fatentsize = 16;
				}
			} else {
				MakeFAT32 = 1;
				Fatentsize = 32;
				Resrvd = reserved;
				GetResrvd = 0;
			}
		}
		efi_free(gpt);
	}
	(void) close(fd);
}

static void
prepare_wbpb(const char *dn, bpb_t *wbpb, char **actualdisk, char **suffix)
{
	/*
	 * We hold these truths to be self evident, all BPBs we create
	 * will have these values in these fields.
	 */
	wbpb->bpb.num_fats = 2;
	/* Set value for prepare_image_file() */
	wbpb->bpb.bytes_per_sector = MINBPS;

	/* Collect info about device */
	if (!Outputtofile)
		getdiskinfo(dn, actualdisk, suffix);

	/*
	 * Assign or use supplied numbers for hidden and
	 * reserved sectors in the file system.
	 */
	if (GetResrvd)
		if (MakeFAT32)
			wbpb->bpb.resv_sectors = 32;
		else
			wbpb->bpb.resv_sectors = 1;
	else
		wbpb->bpb.resv_sectors = Resrvd;

	wbpb->ebpb.ext_signature = BOOTSIG; /* Magic number for modern format */
	wbpb->ebpb.volume_id = 0;

	if (MakeFAT32)
		fill_fat32_bpb(wbpb);
}

/*
 *  open_and_seek
 *
 *	Open the requested 'dev_name'.  Seek to point where
 *	we'll write boot sectors, etc., based on any ':partition'
 *	attachments to the dev_name.
 *
 *	By the time we are finished here, the entire BPB will be
 *	filled in, excepting the volume label.
 */
static
int
open_and_seek(const char *dn, bpb_t *wbpb, off64_t *seekto)
{
	struct fd_char fdchar;
	struct dk_geom dg;
	char *actualdisk = NULL;
	char *suffix = NULL;
	size_t size = 0;
	int fd, rv;

	if (Verbose)
		(void) printf(gettext("Opening destination device/file.\n"));

	prepare_wbpb(dn, wbpb, &actualdisk, &suffix);
	/*
	 * If all output goes to a simple file, call a routine to setup
	 * that scenario. Otherwise, try to find the device.
	 */
	if (Outputtofile)
		return (prepare_image_file(dn, wbpb));

	fd = open(actualdisk, O_RDWR);
	if (fd < 0) {
		err(ERR_OS, "Failed to open disk device %s",
		    actualdisk);
	}
	/*
	 * Check the media sector size
	 */
	rv = get_media_sector_size(fd, &size);
	if (rv != 0) {
		int e = errno;
		(void) close(fd);
		errc(ERR_OS, e, gettext("Failed to obtain sector size for %s"),
		    actualdisk);
	}

	if (!is_sector_size_valid(size)) {
		(void) close(fd);
		err(ERR_OS,
		    gettext("Invalid bytes/sector (%zu): must be 512, 1024, "
		    "2048 or 4096\n"), size);
	}
	/* record sector size */
	wbpb->bpb.bytes_per_sector = size;

	/*
	 * Sanity check.  If we've been provided a partition-specifying
	 * suffix, we shouldn't also have been told to ignore the
	 * fdisk table.
	 */
	if (DontUseFdisk && suffix) {
		(void) fprintf(stderr,
		    gettext("Using 'nofdisk' option precludes "
		    "appending logical drive\nspecifier "
		    "to the device name.\n"));
		goto err_out;
	}

	/*
	 * Find appropriate partition if we were requested to do so.
	 */
	if (suffix != NULL && !(seek_partn(fd, suffix, wbpb, seekto)))
		goto err_out;

	if (suffix == NULL) {
		/*
		 * We have one of two possibilities.  Chances are we have
		 * a floppy drive.  But the user may be trying to format
		 * some weird drive that we don't know about and is supplying
		 * all the important values.  In that case, they should have set
		 * the 'nofdisk' flag.
		 *
		 * If 'nofdisk' isn't set, do a floppy-specific ioctl to
		 * get the remainder of our info. If the ioctl fails, we have
		 * a good idea that they aren't really on a floppy.  In that
		 * case, they should have given us a partition specifier.
		 */
		if (DontUseFdisk) {
			if (!(seek_nofdisk(fd, wbpb, seekto)))
				goto err_out;

			find_fixed_details(fd, wbpb);
		} else if (ioctl(fd, FDIOGCHAR, &fdchar) == -1) {
			/*
			 * It is possible that we are trying to use floppy
			 * specific FDIOGCHAR ioctl on USB floppy. Since sd
			 * driver, by which USB floppy is handled, doesn't
			 * support it, we can try to use disk DKIOCGGEOM ioctl
			 * to retrieve data we need. sd driver itself
			 * determines floppy disk by number of blocks
			 * (<=0x1000), then it sets geometry to 80 cylinders,
			 * 2 heads.
			 *
			 * Note that DKIOCGGEOM cannot supply us with type
			 * of media (e.g. 3.5" or 5.25"). We will set it to
			 * 3 (3.5") which is most probable value.
			 */
			if (errno == ENOTTY) {
				if (ioctl(fd, DKIOCGGEOM, &dg) != -1 &&
				    dg.dkg_ncyl == 80 && dg.dkg_nhead == 2) {
					fdchar.fdc_ncyl = dg.dkg_ncyl;
					fdchar.fdc_medium = 3;
					fdchar.fdc_secptrack = dg.dkg_nsect;
					fdchar.fdc_nhead = dg.dkg_nhead;
					lookup_floppy(&fdchar, wbpb);
				} else {
					partn_lecture(actualdisk);
					goto err_out;
				}
			}
		} else {
#ifdef sparc
			fdchar.fdc_medium = 3;
#endif
			lookup_floppy(&fdchar, wbpb);
		}
	} else {
		find_fixed_details(fd, wbpb);
	}

	return (fd);

err_out:
	(void) close(fd);
	exit(ERR_OS);
}

/*
 *  verify_bootblkfile
 *
 *	We were provided with the name of a file containing the bootblk
 *	to install.  Verify it has a valid boot sector as best we can. Any
 *	errors and we return a bad file descriptor.  Otherwise we fill up the
 *	provided buffer with the boot sector, return the file
 *	descriptor for later use and leave the file pointer just
 *	past the boot sector part of the boot block file.
 */
static
int
verify_bootblkfile(char *fn, boot_sector_t *bs)
{
	struct stat fi;
	int bsfd = -1;

	if (stat(fn, &fi)) {
		perror(fn);
	} else if (fi.st_size != MINBPS) {
		(void) fprintf(stderr,
		    gettext("%s: File size does not fit for a boot sector.\n"),
		    fn);
	} else if ((bsfd = open(fn, O_RDONLY)) < 0) {
		perror(fn);
	} else if (read(bsfd, bs->buf, MINBPS) < MINBPS) {
		(void) close(bsfd);
		bsfd = -1;
		perror(gettext("Boot block read"));
	} else {
		if ((bs->bs.bs_signature[0] != (BOOTSECSIG & 0xFF) &&
		    bs->bs.bs_signature[1] != ((BOOTSECSIG >> 8) & 0xFF)) ||
#ifdef _LITTLE_ENDIAN
		    (bs->bs.bs_front.bs_jump_code[0] != OPCODE1 &&
		    bs->bs.bs_front.bs_jump_code[0] != OPCODE2)
#else
		    (bs->bs.bs_jump_code[0] != OPCODE1 &&
		    bs->bs.bs_jump_code[0] != OPCODE2)
#endif
		    /* CSTYLED */
		    ) {
			(void) close(bsfd);
			bsfd = -1;
			(void) fprintf(stderr,
			    gettext("Boot block (%s) bogus.\n"), fn);
		}
		bs->bs.bs_front.bs_oem_name[0] = 'M';
		bs->bs.bs_front.bs_oem_name[1] = 'S';
		bs->bs.bs_front.bs_oem_name[2] = 'W';
		bs->bs.bs_front.bs_oem_name[3] = 'I';
		bs->bs.bs_front.bs_oem_name[4] = 'N';
		bs->bs.bs_front.bs_oem_name[5] = '4';
		bs->bs.bs_front.bs_oem_name[6] = '.';
		bs->bs.bs_front.bs_oem_name[7] = '1';
		/*
		 * As we are storing Partition Boot Record, unset
		 * pmbr built in stage2 lba and size.
		 * We do this to stop mdb disk_label module to
		 * try to interpret it.
		 */
		if (*((uint64_t *)(bs->buf + STAGE1_STAGE2_LBA)) == 256 &&
		    *((uint16_t *)(bs->buf + STAGE1_STAGE2_SIZE)) == 1) {
			*((uint64_t *)(bs->buf + STAGE1_STAGE2_LBA)) = 0;
			*((uint16_t *)(bs->buf + STAGE1_STAGE2_SIZE)) = 0;
		}
	}
	return (bsfd);
}

/*
 *  verify_firstfile
 *
 *	We were provided with the name of a file to be the first file
 *	installed on the disk.  We just need to verify it exists and
 *	find out how big it is.  If it doesn't exist, we print a warning
 *	message about how the file wasn't found.  We don't exit fatally,
 *	though, rather we return a size of 0 and the FAT will be built
 *	without installing any first file.  They can then presumably
 *	install the correct first file by hand.
 */
static
int
verify_firstfile(char *fn, ulong_t *filesize)
{
	struct stat fi;
	int fd = -1;

	*filesize = 0;
	if (stat(fn, &fi) || (fd = open(fn, O_RDONLY)) < 0) {
		perror(fn);
		(void) fprintf(stderr,
		    gettext("Could not access requested file.  It will not\n"
		    "be installed in the new file system.\n"));
	} else {
		*filesize = fi.st_size;
	}

	return (fd);
}

/*
 *  label_volume
 *
 *	Fill in BPB with volume label.
 */
static
void
label_volume(char *lbl, bpb_t *wbpb)
{
	int ll, i;

	/* Put a volume label into our BPB. */
	if (!lbl)
		lbl = DEFAULT_LABEL;

	ll = MIN(11, (int)strlen(lbl));
	for (i = 0; i < ll; i++) {
		wbpb->ebpb.volume_label[i] = toupper(lbl[i]);
	}
	for (; i < 11; i++) {
		wbpb->ebpb.volume_label[i] = ' ';
	}
}

static
void
copy_bootblk(char *fn, boot_sector_t *bootsect)
{
	int bsfd = -1;

	if (Verbose)
		(void) printf(gettext("Request to install boot "
		    "block file %s.\n"), fn);

	/*
	 *  Sanity check that block.
	 */
	bsfd = verify_bootblkfile(fn, bootsect);
	if (bsfd < 0) {
		exit(ERR_INVALID);
	}

	(void) close(bsfd);
}

/*
 *  mark_cluster
 *
 *	This routine fills a FAT entry with the value supplied to it as an
 *	argument.  The fatp argument is assumed to be a pointer to the FAT's
 *	0th entry.  The clustnum is the cluster entry that should be updated.
 *	The value is the new value for the entry.
 */
static
void
mark_cluster(uchar_t *fatp, pc_cluster32_t clustnum, uint32_t value)
{
	uchar_t *ep;
	ulong_t idx;

	idx = (Fatentsize == 32) ? clustnum * 4 :
	    (Fatentsize == 16) ? clustnum * 2 : clustnum + clustnum/2;
	ep = fatp + idx;

	if (Fatentsize == 32) {
		store_32_bits(&ep, value);
	} else if (Fatentsize == 16) {
		store_16_bits(&ep, value);
	} else {
		if (clustnum & 1) {
			*ep = (*ep & 0x0f) | ((value << 4) & 0xf0);
			ep++;
			*ep = (value >> 4) & 0xff;
		} else {
			*ep++ = value & 0xff;
			*ep = (*ep & 0xf0) | ((value >> 8) & 0x0f);
		}
	}
}

static
uchar_t *
build_fat(bpb_t *wbpb, struct fat_od_fsi *fsinfop, ulong_t *fatsize,
    char *ffn, int *fffd, ulong_t *ffsize, pc_cluster32_t *ffstartclust)
{
	pc_cluster32_t nextfree, ci;
	uchar_t *fatp;
	ushort_t numclust, numsect;
	int  remclust;

	/* Alloc space for a FAT and then null it out. */
	if (Verbose) {
		(void) printf(gettext("BUILD FAT.\n%d sectors per fat.\n"),
		    wbpb->bpb.sectors_per_fat ? wbpb->bpb.sectors_per_fat :
		    wbpb->bpb32.big_sectors_per_fat);
	}

	if (MakeFAT32) {
		*fatsize = wbpb->bpb.bytes_per_sector *
		    wbpb->bpb32.big_sectors_per_fat;
	} else {
		*fatsize = wbpb->bpb.bytes_per_sector *
		    wbpb->bpb.sectors_per_fat;
	}

	fatp = calloc(1, *fatsize);
	if (fatp == NULL) {
		perror(gettext("FAT table alloc"));
		exit(ERR_FAIL);
	}

	/* Build in-memory FAT */
	*fatp = wbpb->bpb.media;
	*(fatp + 1) = 0xFF;
	*(fatp + 2) = 0xFF;

	if (Fatentsize == 16) {
		*(fatp + 3) = 0xFF;
	} else if (Fatentsize == 32) {
		*(fatp + 3) = 0x0F;
		*(fatp + 4) = 0xFF;
		*(fatp + 5) = 0xFF;
		*(fatp + 6) = 0xFF;
		*(fatp + 7) = 0x0F;
	}

	/*
	 * Keep track of clusters used.
	 */
	remclust = TotalClusters;
	nextfree = 2;

	/*
	 * Get info on first file to install, if any.
	 */
	if (ffn)
		*fffd = verify_firstfile(ffn, ffsize);

	/*
	 * Reserve a cluster for the root directory on a FAT32.
	 */
	if (MakeFAT32) {
		mark_cluster(fatp, nextfree, PCF_LASTCLUSTER32);
		wbpb->bpb32.root_dir_clust = nextfree++;
		remclust--;
	}

	/*
	 * Compute and preserve number of clusters for first file.
	 */
	if (*fffd >= 0) {
		*ffstartclust = nextfree;
		numsect = idivceil(*ffsize, wbpb->bpb.bytes_per_sector);
		numclust = idivceil(numsect, wbpb->bpb.sectors_per_cluster);

		if (numclust > remclust) {
			(void) fprintf(stderr,
			    gettext("Requested first file too large to be\n"
			    "installed in the new file system.\n"));
			(void) close(*fffd);
			*fffd = -1;
			goto finish;
		}

		if (Verbose)
			(void) printf(gettext("Reserving %d first file "
			    "cluster(s).\n"), numclust);
		for (ci = 0; (int)ci < (int)(numclust-1); ci++, nextfree++)
			mark_cluster(fatp, nextfree, nextfree + 1);
		mark_cluster(fatp, nextfree++,
		    MakeFAT32 ? PCF_LASTCLUSTER32 : PCF_LASTCLUSTER);
		remclust -= numclust;
	}

finish:
	if (Verbose) {
		(void) printf(gettext("First sector of FAT"));
		header_for_dump();
		dump_bytes(fatp, wbpb->bpb.bytes_per_sector);
	}

	(void) memset(fsinfop, 0, sizeof (*fsinfop));
	fsinfop->fsi_leadsig = LE_32(FSI_LEADSIG);
	fsinfop->fsi_strucsig = LE_32(FSI_STRUCSIG);
	fsinfop->fsi_trailsig = LE_32(FSI_TRAILSIG);
	fsinfop->fsi_incore.fs_free_clusters = LE_32(remclust);
	fsinfop->fsi_incore.fs_next_free = LE_32(nextfree);
	return (fatp);
}

static
void
dirent_time_fill(struct pcdir *dep)
{
	struct  timeval tv;
	struct	tm	*tp;
	ushort_t	dostime;
	ushort_t	dosday;

	(void) gettimeofday(&tv, (struct timezone *)0);
	tp = localtime(&tv.tv_sec);
	/* get the time & day into DOS format */
	dostime = tp->tm_sec / 2;
	dostime |= tp->tm_min << 5;
	dostime |= tp->tm_hour << 11;
	dosday = tp->tm_mday;
	dosday |= (tp->tm_mon + 1) << 5;
	dosday |= (tp->tm_year - 80) << 9;
	dep->pcd_mtime.pct_time = htols(dostime);
	dep->pcd_mtime.pct_date = htols(dosday);
}

static
void
dirent_label_fill(struct pcdir *dep, char *fn)
{
	int nl, i;

	/*
	 * We spread the volume label across both the NAME and EXT fields
	 */
	nl = MIN(PCFNAMESIZE, strlen(fn));
	for (i = 0; i < nl; i++) {
		dep->pcd_filename[i] = toupper(fn[i]);
	}
	if (i < PCFNAMESIZE) {
		for (; i < PCFNAMESIZE; i++)
			dep->pcd_filename[i] = ' ';
		for (i = 0; i < PCFEXTSIZE; i++)
			dep->pcd_ext[i] = ' ';
		return;
	}
	nl = MIN(PCFEXTSIZE, strlen(fn) - PCFNAMESIZE);
	for (i = 0; i < nl; i++)
		dep->pcd_ext[i] = toupper(fn[i + PCFNAMESIZE]);
	if (i < PCFEXTSIZE) {
		for (; i < PCFEXTSIZE; i++)
			dep->pcd_ext[i] = ' ';
	}
}

static
void
dirent_fname_fill(struct pcdir *dep, char *fn)
{
	char *fname, *fext;
	int nl, i;

	if ((fname = strrchr(fn, '/')) != NULL) {
		fname++;
	} else {
		fname = fn;
	}

	if ((fext = strrchr(fname, '.')) != NULL) {
		fext++;
	} else {
		fext = "";
	}

	fname = strtok(fname, ".");

	nl = MIN(PCFNAMESIZE, (int)strlen(fname));
	for (i = 0; i < nl; i++) {
		dep->pcd_filename[i] = toupper(fname[i]);
	}
	for (; i < PCFNAMESIZE; i++) {
		dep->pcd_filename[i] = ' ';
	}

	nl = MIN(PCFEXTSIZE, (int)strlen(fext));
	for (i = 0; i < nl; i++) {
		dep->pcd_ext[i] = toupper(fext[i]);
	}
	for (; i < PCFEXTSIZE; i++) {
		dep->pcd_ext[i] = ' ';
	}
}

static
uchar_t *
build_rootdir(bpb_t *wbpb, char *ffn, int fffd,
    ulong_t ffsize, pc_cluster32_t ffstart, ulong_t *rdirsize)
{
	struct pcdir *rootdirp;
	struct pcdir *entry;

	/*
	 * Build a root directory.  It will have at least one entry,
	 * the volume label and a second if the first file was defined.
	 */
	if (MakeFAT32) {
		/*
		 * We devote an entire cluster to the root
		 * directory on FAT32.
		 */
		*rdirsize = wbpb->bpb.sectors_per_cluster *
		    wbpb->bpb.bytes_per_sector;
	} else {
		*rdirsize = wbpb->bpb.num_root_entries * sizeof (struct pcdir);
	}
	if ((rootdirp = (struct pcdir *)malloc(*rdirsize)) == NULL) {
		perror(gettext("Root directory allocation"));
		exit(ERR_FAIL);
	} else {
		entry = rootdirp;
		(void) memset((char *)rootdirp, 0, *rdirsize);
	}

	/* Create directory entry for first file, if there is one */
	if (fffd >= 0) {
		dirent_fname_fill(entry, ffn);
		entry->pcd_attr = Firstfileattr;
		dirent_time_fill(entry);
		entry->pcd_scluster_lo = htols(ffstart);
		if (MakeFAT32) {
			ffstart = ffstart >> 16;
			entry->un.pcd_scluster_hi = htols(ffstart);
		}
		entry->pcd_size = htoli(ffsize);
		entry++;
	}

	/* Create directory entry for volume label, if there is one */
	if (Label != NULL) {
		dirent_label_fill(entry, Label);
		entry->pcd_attr = PCA_ARCH | PCA_LABEL;
		dirent_time_fill(entry);
		entry->pcd_scluster_lo = 0;
		if (MakeFAT32) {
			entry->un.pcd_scluster_hi = 0;
		}
		entry->pcd_size = 0;
		entry++;
	}

	if (Verbose) {
		(void) printf(gettext("First two directory entries"));
		header_for_dump();
		dump_bytes((uchar_t *)rootdirp, 2 * sizeof (struct pcdir));
	}

	return ((uchar_t *)rootdirp);
}

/*
 * write_rest
 *
 *	Write all the bytes from the current file pointer to end of file
 *	in the source file out to the destination file.  The writes should
 *	be padded to whole clusters with 0's if necessary.
 */
static
void
write_rest(bpb_t *wbpb, char *efn, int dfd, int sfd, int remaining)
{
	char *buf;
	ushort_t numsect, numclust;
	ushort_t wnumsect, s;
	int doneread = 0;
	int rstat;
	size_t size;

	size = wbpb->bpb.bytes_per_sector;
	buf = malloc(size);
	if (buf == NULL) {
		perror(efn);
		return;
	}
	/*
	 * Compute number of clusters required to contain remaining bytes.
	 */
	numsect = idivceil(remaining, size);
	numclust = idivceil(numsect, wbpb->bpb.sectors_per_cluster);

	wnumsect = numclust * wbpb->bpb.sectors_per_cluster;
	for (s = 0; s < wnumsect; s++) {
		if (!doneread) {
			if ((rstat = read(sfd, buf, size)) < 0) {
				perror(efn);
				doneread = 1;
				rstat = 0;
			} else if (rstat == 0) {
				doneread = 1;
			}
			(void) memset(&(buf[rstat]), 0, size - rstat);
		}
		if (write(dfd, buf, size) != (ssize_t)size) {
			(void) fprintf(stderr, gettext("Copying "));
			perror(efn);
		}
	}
	free(buf);
}

static
void
write_fat32_bootstuff(int fd, boot_sector_t *bsp, bpb_t *wbpb,
    struct fat_od_fsi *fsinfop, off64_t seekto)
{
	char *buf = NULL;
	size_t size = wbpb->bpb.bytes_per_sector;

	if (size != MINBPS && !Notreally) {
		buf = calloc(1, size);
		if (buf == NULL) {
			perror(gettext("FS info buffer alloc"));
			exit(ERR_FAIL);
		}
		(void) memcpy(buf, fsinfop, sizeof (*fsinfop));
	} else {
		buf = (char *)fsinfop;
	}

	if (Verbose) {
		(void) printf(gettext("Dump of the fs info sector"));
		header_for_dump();
		dump_bytes((uchar_t *)fsinfop, sizeof (*fsinfop));
	}

	if (!Notreally) {
		/*
		 * FAT32's have an FS info sector, then a backup of the boot
		 * sector, and a modified backup of the FS Info sector.
		 */
		if (write(fd, buf, size) != (ssize_t)size) {
			perror(gettext("FS info sector write"));
			exit(ERR_FAIL);
		}
		if (lseek64(fd,	seekto + wbpb->bpb32.backupboot * size,
		    SEEK_SET) < 0) {
			(void) close(fd);
			perror(gettext("Boot sector backup seek"));
			exit(ERR_FAIL);
		}
		if (write(fd, bsp->buf, size) != (ssize_t)size) {
			perror(gettext("Boot sector backup write"));
			exit(ERR_FAIL);
		}
	}

	/*
	 * Second copy of fs info sector is modified to have "don't know"
	 * as the number of free clusters
	 */
	fsinfop = (struct fat_od_fsi *)buf;
	fsinfop->fsi_incore.fs_next_free = LE_32(FSINFO_UNKNOWN);

	if (Verbose) {
		(void) printf(gettext("Dump of the backup fs info sector"));
		header_for_dump();
		dump_bytes((uchar_t *)fsinfop, sizeof (*fsinfop));
	}

	if (!Notreally) {
		if (write(fd, buf, size) != (ssize_t)size) {
			perror(gettext("FS info sector backup write"));
			exit(ERR_FAIL);
		}
	}
	if (size != MINBPS && !Notreally)
		free(buf);
}

static
void
write_bootsects(int fd, boot_sector_t *bsp, bpb_t *wbpb,
    struct fat_od_fsi *fsinfop, off64_t seekto)
{
	if (MakeFAT32) {
		/* Copy our BPB into bootsec structure */
#ifdef _LITTLE_ENDIAN
		(void) memcpy(&(bsp->bs32.bs_front.bs_bpb), &(wbpb->bpb),
		    sizeof (wbpb->bpb));
		(void) memcpy(&(bsp->bs32.bs_bpb32), &(wbpb->bpb32),
		    sizeof (wbpb->bpb32));
		(void) memcpy(&(bsp->bs32.bs_ebpb), &(wbpb->ebpb),
		    sizeof (wbpb->ebpb));
#else
		swap_pack_bpb32cpy(&(bsp->bs32), wbpb);
#endif
	} else {
		/* Copy our BPB into bootsec structure */
#ifdef _LITTLE_ENDIAN
		(void) memcpy(&(bsp->bs.bs_front.bs_bpb), &(wbpb->bpb),
		    sizeof (wbpb->bpb));
		(void) memcpy(&(bsp->bs.bs_ebpb), &(wbpb->ebpb),
		    sizeof (wbpb->ebpb));
#else
		swap_pack_bpbcpy(&(bsp->bs), wbpb);
#endif

		/* Copy SUN BPB extensions into bootsec structure */
		if (SunBPBfields) {
#ifdef _LITTLE_ENDIAN
			(void) memcpy(&(bsp->bs.bs_sebpb), &(wbpb->sunbpb),
			    sizeof (wbpb->sunbpb));
#else
			swap_pack_sebpbcpy(&(bsp->bs), wbpb);
#endif
		}
	}

	/* Write boot sector */
	if (!Notreally && write(fd, bsp->buf, wbpb->bpb.bytes_per_sector) !=
	    (ssize_t)wbpb->bpb.bytes_per_sector) {
		perror(gettext("Boot sector write"));
		exit(ERR_FAIL);
	}

	if (Verbose) {
		(void) printf(gettext("Dump of the boot sector"));
		header_for_dump();
		dump_bytes(bsp->buf, MINBPS);
	}

	if (MakeFAT32)
		write_fat32_bootstuff(fd, bsp, wbpb, fsinfop, seekto);
}

static
void
write_fat(int fd, off64_t seekto, char *fn, char *lbl, char *ffn, bpb_t *wbpb)
{
	struct fat_od_fsi fsinfo;
	pc_cluster32_t ffsc;
	boot_sector_t bootsect;
	uchar_t *fatp, *rdirp;
	ulong_t fatsize, rdirsize, ffsize;
	int fffd = -1;

	compute_file_area_size(wbpb);

	/* boot sector structure size is always 512B */
	copy_bootblk(fn, &bootsect);
	label_volume(lbl, wbpb);

	if (Verbose)
		(void) printf(gettext("Building FAT.\n"));
	fatp = build_fat(wbpb, &fsinfo, &fatsize,
	    ffn, &fffd, &ffsize, &ffsc);

	write_bootsects(fd, &bootsect, wbpb, &fsinfo, seekto);

	if (lseek64(fd,
	    seekto + (wbpb->bpb.bytes_per_sector * wbpb->bpb.resv_sectors),
	    SEEK_SET) < 0) {
		(void) close(fd);
		perror(gettext("Seek to end of reserved sectors"));
		exit(ERR_FAIL);
	}

	/* Write FAT */
	if (Verbose)
		(void) printf(gettext("Writing FAT(s). %lu bytes times %u.\n"),
		    fatsize, wbpb->bpb.num_fats);
	if (!Notreally) {
		for (uint_t nf = 0; nf < wbpb->bpb.num_fats; nf++) {
			ssize_t wb;

			wb = write(fd, fatp, fatsize);
			if (wb != (ssize_t)fatsize) {
				perror(gettext("FAT write"));
				exit(ERR_FAIL);
			} else {
				if (Verbose)
					(void) printf(
					    gettext("Wrote %zd bytes\n"), wb);
			}
		}
	}
	free(fatp);

	if (Verbose)
		(void) printf(gettext("Building root directory.\n"));
	rdirp = build_rootdir(wbpb, ffn, fffd, ffsize, ffsc, &rdirsize);

	/*
	 *  In non FAT32, root directory exists outside of the file area
	 */
	if (Verbose)
		(void) printf(gettext("Writing root directory. %lu bytes.\n"),
		    rdirsize);
	if (MakeFAT32) {
		if (lseek64(fd, seekto +
		    wbpb->bpb.bytes_per_sector * wbpb->bpb.resv_sectors +
		    wbpb->bpb.num_fats * fatsize +
		    wbpb->bpb.bytes_per_sector * wbpb->bpb.sectors_per_cluster *
		    (wbpb->bpb32.root_dir_clust - 2),
		    SEEK_SET) < 0) {
			(void) close(fd);
			perror(gettext("Seek to end of reserved sectors"));
			exit(ERR_FAIL);
		}
	}
	if (!Notreally) {
		if (write(fd, rdirp, rdirsize) != rdirsize) {
			perror(gettext("Root directory write"));
			exit(ERR_FAIL);
		}
	}
	free(rdirp);

	/*
	 * Now write anything that needs to be in the file space.
	 */
	if (fffd >= 0) {
		if (Verbose)
			(void) printf(gettext("Writing first file.\n"));
		if (!Notreally)
			write_rest(wbpb, ffn, fd, fffd, ffsize);
	}
}

static
char *LegalOpts[] = {
#define	NFLAG 0
	"N",
#define	VFLAG 1
	"v",
#define	RFLAG 2
	"r",
#define	HFLAG 3
	"h",
#define	SFLAG 4
	"s",
#define	SUNFLAG 5
	"S",
#define	LABFLAG 6
	"b",
#define	BTRFLAG 7
	"B",
#define	INITFLAG 8
	"i",
#define	SZFLAG 9
	"size",
#define	SECTFLAG 10
	"nsect",
#define	TRKFLAG 11
	"ntrack",
#define	SPCFLAG 12
	"spc",
#define	BPFFLAG 13
	"fat",
#define	FFLAG 14
	"f",
#define	DFLAG 15
	"d",
#define	NOFDISKFLAG 16
	"nofdisk",
#define	RESRVFLAG 17
	"reserve",
#define	HIDDENFLAG 18
	"hidden",
	NULL
};

static
void
parse_suboptions(char *optsstr)
{
	char *value;
	int c;

	while (*optsstr != '\0') {
		switch (c = getsubopt(&optsstr, LegalOpts, &value)) {
		case NFLAG:
			Notreally++;
			break;
		case VFLAG:
			Verbose++;
			break;
		case RFLAG:
			Firstfileattr |= 0x01;
			break;
		case HFLAG:
			Firstfileattr |= 0x02;
			break;
		case SFLAG:
			Firstfileattr |= 0x04;
			break;
		case SUNFLAG:
			SunBPBfields = 1;
			break;
		case LABFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				Label = value;
			}
			break;
		case BTRFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				BootBlkFn = value;
			}
			break;
		case INITFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				FirstFn = value;
			}
			break;
		case SZFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				TotSize = atoi(value);
				GetSize = 0;
			}
			break;
		case SECTFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				SecPerTrk = atoi(value);
				GetSPT = 0;
			}
			break;
		case TRKFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				TrkPerCyl = atoi(value);
				GetTPC = 0;
			}
			break;
		case SPCFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				SecPerClust = atoi(value);
				GetSPC = 0;
			}
			break;
		case BPFFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				BitsPerFAT = atoi(value);
				GetBPF = 0;
			}
			break;
		case NOFDISKFLAG:
			DontUseFdisk = 1;
			break;
		case RESRVFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				Resrvd = atoi(value);
				GetResrvd = 0;
			}
			break;
		case HIDDENFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				RelOffset = atoi(value);
				GetOffset = 0;
			}
			break;
		case FFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				DiskName = value;
				Outputtofile = 1;
			}
			break;
		case DFLAG:
			if (value == NULL) {
				missing_arg(LegalOpts[c]);
			} else {
				Imagesize = atoi(value);
			}
			break;
		default:
			bad_arg(value);
			break;
		}
	}
}

static
void
sanity_check_options(int argc, int optind)
{
	if (GetFsParams) {
		if (argc - optind != 1)
			usage();
		return;
	}

	if (DontUseFdisk && GetOffset) {
		/* Set default relative offset of zero */
		RelOffset = 0;
	}

	if (BitsPerFAT == 32)
		MakeFAT32 = 1;

	if (Outputtofile && (argc - optind)) {
		usage();
	} else if (Outputtofile && !DiskName) {
		usage();
	} else if (!Outputtofile && (argc - optind != 1)) {
		usage();
	} else if (SunBPBfields && !BootBlkFn) {
		(void) fprintf(stderr,
		    gettext("Use of the 'S' option requires that\n"
		    "the 'B=' option also be used.\n\n"));
		usage();
	} else if (Firstfileattr != 0x20 && !FirstFn) {
		(void) fprintf(stderr,
		    gettext("Use of the 'r', 'h', or 's' options requires\n"
		    "that the 'i=' option also be used.\n\n"));
		usage();
	} else if (!GetOffset && !DontUseFdisk) {
		(void) fprintf(stderr,
		    gettext("Use of the 'hidden' option requires that\n"
		    "the 'nofdisk' option also be used.\n\n"));
		usage();
	} else if (DontUseFdisk && GetSize) {
		(void) fprintf(stderr,
		    gettext("Use of the 'nofdisk' option requires that\n"
		    "the 'size=' option also be used.\n\n"));
		usage();
	} else if (!GetBPF &&
	    BitsPerFAT != 12 && BitsPerFAT != 16 && BitsPerFAT != 32) {
		(void) fprintf(stderr, gettext("Invalid Bits/Fat value."
		    " Must be 12, 16 or 32.\n"));
		exit(ERR_OS);
	} else if (!GetSPC && !(ISP2(SecPerClust) &&
	    IN_RANGE(SecPerClust, 1, 128))) {
		(void) fprintf(stderr,
		    gettext("Invalid Sectors/Cluster value.  Must be a "
		    "power of 2 between 1 and 128.\n"));
		exit(ERR_OS);
	} else if (!GetResrvd && (Resrvd < 1 || Resrvd > 0xffff)) {
		(void) fprintf(stderr,
		    gettext("Invalid number of reserved sectors.  "
		    "Must be at least 1 but\nno larger than 65535."));
		exit(ERR_OS);
	} else if (!GetResrvd && MakeFAT32 &&
	    (Resrvd < 32 || Resrvd > 0xffff)) {
		(void) fprintf(stderr,
		    gettext("Invalid number of reserved sectors.  "
		    "Must be at least 32 but\nno larger than 65535."));
		exit(ERR_OS);
	} else if (Imagesize != 3 && Imagesize != 5) {
		usage();
	}
}

int
main(int argc, char **argv)
{
	off64_t AbsBootSect = 0;
	bpb_t dskparamblk;
	char *string;
	int  fd;
	int  c;

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);
	if (init_yes() < 0)
		errx(ERR_OS, gettext(ERR_MSG_INIT_YES), strerror(errno));

	while ((c = getopt(argc, argv, "F:Vmo:")) != EOF) {
		switch (c) {
		case 'F':
			string = optarg;
			if (strcmp(string, "pcfs") != 0)
				usage();
			break;
		case 'V':
			{
				char	*opt_text;
				int	opt_count;

				(void) fprintf(stdout,
				    gettext("mkfs -F pcfs "));
				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 'm':
			GetFsParams++;
			break;
		case 'o':
			string = optarg;
			parse_suboptions(string);
			break;
		}
	}

	sanity_check_options(argc, optind);

	if (!Outputtofile)
		DiskName = argv[optind];

	(void) memset(&dskparamblk, 0, sizeof (dskparamblk));

	if (GetFsParams) {
		fd = open_and_examine(DiskName, &dskparamblk);
	} else {
		fd = open_and_seek(DiskName, &dskparamblk, &AbsBootSect);
		if (ask_nicely(Fatentsize, DiskName))
			write_fat(fd, AbsBootSect, BootBlkFn, Label,
			    FirstFn, &dskparamblk);
	}
	(void) close(fd);
	fini_yes();
	return (0);
}