344 lines
9.4 KiB
C
344 lines
9.4 KiB
C
/* $NetBSD: newfs_msdos.c,v 1.4 1999/07/26 00:28:57 cgd Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1997 Christos Zoulas
|
|
* Copyright (c) 1995, 1996 Joerg Wunsch
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* This program is free software.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE DEVELOPERS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* Create an MS-DOS (FAT) file system.
|
|
*
|
|
* Id: mkdosfs.c,v 1.4 1997/02/22 16:06:38 peter Exp
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: newfs_msdos.c,v 1.4 1999/07/26 00:28:57 cgd Exp $");
|
|
#endif /* not lint */
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
#include <sys/stat.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <memory.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <assert.h>
|
|
|
|
/* From msdosfs */
|
|
#include <direntry.h>
|
|
#include <bpb.h>
|
|
#include <bootsect.h>
|
|
|
|
#include "bootcode.h"
|
|
|
|
struct descrip {
|
|
/* our database key */
|
|
unsigned kilobytes;
|
|
/* MSDOS 3.3 BPB fields */
|
|
u_short sectsiz;
|
|
u_char clustsiz;
|
|
u_short ressecs;
|
|
u_char fatcnt;
|
|
u_short rootsiz;
|
|
u_short totsecs;
|
|
u_char media;
|
|
u_short fatsize;
|
|
u_short trksecs;
|
|
u_short headcnt;
|
|
u_short hidnsec;
|
|
/* MSDOS 4 BPB extensions */
|
|
u_long ext_totsecs;
|
|
u_short ext_physdrv;
|
|
u_char ext_extboot;
|
|
char ext_label[11];
|
|
char ext_fsysid[8];
|
|
};
|
|
|
|
static struct descrip table[] = {
|
|
/* NB: must be sorted, starting with the largest format! */
|
|
/*
|
|
* KB sec cls res fat rot tot med fsz spt hds hid
|
|
* tot phs ebt label fsysid
|
|
*/
|
|
{ 1440, 512, 1, 1, 2, 224, 2880, 0xf0, 9, 18, 2, 0,
|
|
0, 0, 0, "4.4BSD ", "FAT12 " },
|
|
{ 1200, 512, 1, 1, 2, 224, 2400, 0xf9, 7, 15, 2, 0,
|
|
0, 0, 0, "4.4BSD ", "FAT12 " },
|
|
{ 720, 512, 2, 1, 2, 112, 1440, 0xf9, 3, 9, 2, 0,
|
|
0, 0, 0, "4.4BSD ", "FAT12 " },
|
|
{ 360, 512, 2, 1, 2, 112, 720, 0xfd, 2, 9, 2, 0,
|
|
0, 0, 0, "4.4BSD ", "FAT12 " },
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0x00, 0, 0, 0, 0,
|
|
0, 0, 0, " ", " " }
|
|
};
|
|
|
|
struct fat {
|
|
u_int8_t media; /* the media descriptor again */
|
|
u_int8_t padded; /* always 0xff */
|
|
u_int8_t contents[1]; /* the `1' is a placeholder only */
|
|
};
|
|
|
|
|
|
int main __P((int, char *[]));
|
|
|
|
static void usage __P((void));
|
|
static size_t findformat __P((int));
|
|
static void setup_boot_sector_from_template __P((union bootsector *,
|
|
struct descrip *));
|
|
|
|
|
|
static void
|
|
usage()
|
|
{
|
|
extern char *__progname;
|
|
|
|
(void) fprintf(stderr,
|
|
"Usage: %s [-f <kbytes>] [-L <label>] <device>\n", __progname);
|
|
exit(1);
|
|
}
|
|
|
|
/*
|
|
* Try to deduce a format appropriate for our disk.
|
|
* This is a bit tricky. If the argument is a regular file, we can
|
|
* lseek() to its end and get the size reported. If it's a device
|
|
* however, lseeking doesn't report us any useful number. Instead,
|
|
* we try to seek just to the end of the device and try reading a
|
|
* block there. In the case where we've hit exactly the device
|
|
* boundary, we get a zero read, and thus have found the size.
|
|
* Since our knowledge of distinct formats is limited anyway, this
|
|
* is not a big deal at all.
|
|
*/
|
|
static size_t
|
|
findformat(fd)
|
|
int fd;
|
|
{
|
|
struct stat sb;
|
|
off_t offs;
|
|
|
|
|
|
if (fstat(fd, &sb) == -1)
|
|
err(1, "Cannot fstat disk"); /* Cannot happen */
|
|
|
|
if (S_ISREG(sb.st_mode)) {
|
|
if (lseek(fd, (off_t) 0, SEEK_END) == -1 ||
|
|
(offs = lseek(fd, (off_t) 0, SEEK_CUR)) == -1)
|
|
/* Hmm, hmm. Hard luck. */
|
|
return 0;
|
|
(void) lseek(fd, (off_t) 0, SEEK_SET);
|
|
return (size_t) (offs / 1024);
|
|
} else if (S_ISCHR(sb.st_mode) || S_ISBLK(sb.st_mode)) {
|
|
char b[512];
|
|
int rv;
|
|
struct descrip *dp;
|
|
|
|
for (dp = table; dp->kilobytes != 0; dp++) {
|
|
offs = dp->kilobytes * 1024;
|
|
|
|
if (lseek(fd, offs, SEEK_SET) == -1)
|
|
/* Uh-oh, lseek() is not supposed to fail. */
|
|
return 0;
|
|
|
|
if ((rv = read(fd, b, 512)) == 0)
|
|
break;
|
|
/*
|
|
* XXX The ENOSPC is for the bogus fd(4) driver
|
|
* return value.
|
|
*/
|
|
if (rv == -1 && errno != EINVAL && errno != ENOSPC)
|
|
return 0;
|
|
/* else: continue */
|
|
}
|
|
(void) lseek(fd, (off_t) 0, SEEK_SET);
|
|
return dp->kilobytes;
|
|
} else
|
|
/* Outta luck. */
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void
|
|
setup_boot_sector_from_template(bs, dp)
|
|
union bootsector *bs;
|
|
struct descrip *dp;
|
|
{
|
|
struct byte_bpb50 bpb;
|
|
struct extboot *exb = (struct extboot *)bs->bs50.bsExt;
|
|
|
|
assert(sizeof(bs->bs50) == 512);
|
|
assert(sizeof(bootcode) == 512);
|
|
|
|
(void) memcpy(&bs->bs50, bootcode, 512);
|
|
|
|
putushort(bpb.bpbBytesPerSec, dp->sectsiz);
|
|
bpb.bpbSecPerClust = dp->clustsiz;
|
|
putushort(bpb.bpbResSectors, dp->ressecs);
|
|
bpb.bpbFATs = dp->fatcnt;
|
|
putushort(bpb.bpbRootDirEnts, dp->rootsiz);
|
|
putushort(bpb.bpbSectors, dp->totsecs);
|
|
bpb.bpbMedia = dp->media;
|
|
putushort(bpb.bpbFATsecs, dp->fatsize);
|
|
putushort(bpb.bpbSecPerTrack, dp->trksecs);
|
|
putushort(bpb.bpbHeads, dp->headcnt);
|
|
putulong(bpb.bpbHiddenSecs, dp->hidnsec);
|
|
putulong(bpb.bpbHugeSectors, dp->ext_totsecs);
|
|
|
|
exb->exDriveNumber = dp->ext_physdrv;
|
|
exb->exBootSignature = dp->ext_extboot;
|
|
|
|
/* assign a "serial number" :) */
|
|
srandom((unsigned) time((time_t) 0));
|
|
putulong(exb->exVolumeID, random());
|
|
|
|
(void) memcpy(exb->exVolumeLabel, dp->ext_label,
|
|
MIN(sizeof(dp->ext_label), sizeof(exb->exVolumeLabel)));
|
|
(void) memcpy(exb->exFileSysType, dp->ext_fsysid,
|
|
MIN(sizeof(dp->ext_fsysid), sizeof(exb->exFileSysType)));
|
|
(void) memcpy(bs->bs50.bsBPB, &bpb,
|
|
MIN(sizeof(bpb), sizeof(bs->bs50.bsBPB)));
|
|
}
|
|
|
|
int
|
|
main(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
union bootsector bs;
|
|
struct descrip *dp;
|
|
struct fat *fat;
|
|
struct direntry *rootdir;
|
|
struct tm *tp;
|
|
time_t now;
|
|
int c, i, fd, format = 0, rootdirsize, fatsz;
|
|
const char *label = 0;
|
|
|
|
while ((c = getopt(argc, argv, "f:L:")) != -1)
|
|
switch (c) {
|
|
case 'f':
|
|
format = atoi(optarg);
|
|
break;
|
|
|
|
case 'L':
|
|
label = optarg;
|
|
break;
|
|
|
|
case '?':
|
|
default:
|
|
usage();
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (argc != 1)
|
|
usage();
|
|
|
|
if ((fd = open(argv[0], O_RDWR | O_EXCL, 0)) == -1)
|
|
err(1, "Cannot open `%s'", argv[0]);
|
|
|
|
/* If no format specified, try to figure it out. */
|
|
if (format == 0 && (format = findformat(fd)) == 0)
|
|
errx(1, "Cannot determine size, must use -f format");
|
|
|
|
for (dp = table; dp->kilobytes != 0; dp++)
|
|
if (dp->kilobytes == format)
|
|
break;
|
|
|
|
if (dp->kilobytes == 0)
|
|
errx(1, "Cannot find format description for %d KB", format);
|
|
|
|
/* prepare and write the boot sector */
|
|
setup_boot_sector_from_template(&bs, dp);
|
|
|
|
/* if we've got an explicit label, use it */
|
|
if (label)
|
|
(void) strncpy(((struct extboot *)(bs.bs50.bsExt))
|
|
->exVolumeLabel, label, 11);
|
|
|
|
if (write(fd, &bs, sizeof bs) != sizeof bs)
|
|
err(1, "Writing boot sector");
|
|
|
|
/* now, go on with the FATs */
|
|
if ((fat = (struct fat *) malloc(dp->sectsiz * dp->fatsize)) == NULL)
|
|
err(1, "Out of memory (FAT table)");
|
|
|
|
(void) memset(fat, 0, dp->sectsiz * dp->fatsize);
|
|
|
|
fat->media = dp->media;
|
|
fat->padded = 0xff;
|
|
fat->contents[0] = 0xff;
|
|
if (dp->totsecs > 20740 ||
|
|
(dp->totsecs == 0 && dp->ext_totsecs > 20740))
|
|
/* 16-bit FAT */
|
|
fat->contents[1] = 0xff;
|
|
|
|
fatsz = dp->sectsiz * dp->fatsize;
|
|
for (i = 0; i < dp->fatcnt; i++)
|
|
if (write(fd, fat, fatsz) != fatsz)
|
|
err(1, "Writing FAT %d", i);
|
|
|
|
free(fat);
|
|
|
|
/* finally, build the root dir */
|
|
rootdirsize = dp->rootsiz * sizeof(struct direntry);
|
|
rootdirsize = roundup(rootdirsize, dp->clustsiz * dp->sectsiz);
|
|
|
|
if ((rootdir = (struct direntry *) malloc(rootdirsize)) == NULL)
|
|
err(1, "Out of memory (root directory)");
|
|
|
|
(void) memset(rootdir, 0, rootdirsize);
|
|
|
|
/* set up a volume label inside the root dir :) */
|
|
if (label)
|
|
(void) strncpy(rootdir->deName, label, 11);
|
|
else
|
|
(void) memcpy(rootdir->deName, dp->ext_label, 11);
|
|
|
|
rootdir->deAttributes = ATTR_VOLUME;
|
|
now = time((time_t) 0);
|
|
tp = localtime(&now);
|
|
rootdir->deCTime[0] = tp->tm_sec / 2;
|
|
rootdir->deCTime[0] |= (tp->tm_min & 7) << 5;
|
|
rootdir->deCTime[1] = ((tp->tm_min >> 3) & 7);
|
|
rootdir->deCTime[1] |= tp->tm_hour << 3;
|
|
rootdir->deCDate[0] = tp->tm_mday;
|
|
rootdir->deCDate[0] |= ((tp->tm_mon + 1) & 7) << 5;
|
|
rootdir->deCDate[1] = ((tp->tm_mon + 1) >> 3) & 1;
|
|
rootdir->deCDate[1] |= (tp->tm_year - 80) << 1;
|
|
|
|
if (write(fd, rootdir, rootdirsize) != rootdirsize)
|
|
err(1, "Writing root directory");
|
|
|
|
(void) close(fd);
|
|
|
|
return 0;
|
|
}
|