mirror of
https://github.com/reactos/reactos.git
synced 2024-10-30 11:35:58 +00:00
4f8cc9596c
svn path=/trunk/; revision=17143
2071 lines
60 KiB
C
2071 lines
60 KiB
C
/*
|
|
Filename: mkdosfs.c
|
|
Version: 0.3b (Yggdrasil)
|
|
Author: Dave Hudson
|
|
Started: 24th August 1994
|
|
Last Updated: 7th May 1998
|
|
Updated by: Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
|
|
Target O/S: Linux (2.x)
|
|
|
|
Description: Utility to allow an MS-DOS filesystem to be created
|
|
under Linux. A lot of the basic structure of this program has been
|
|
borrowed from Remy Card's "mke2fs" code.
|
|
|
|
As far as possible the aim here is to make the "mkdosfs" command
|
|
look almost identical to the other Linux filesystem make utilties,
|
|
eg bad blocks are still specified as blocks, not sectors, but when
|
|
it comes down to it, DOS is tied to the idea of a sector (512 bytes
|
|
as a rule), and not the block. For example the boot block does not
|
|
occupy a full cluster.
|
|
|
|
Fixes/additions May 1998 by Roman Hodek
|
|
<Roman.Hodek@informatik.uni-erlangen.de>:
|
|
- Atari format support
|
|
- New options -A, -S, -C
|
|
- Support for filesystems > 2GB
|
|
- FAT32 support
|
|
|
|
Port to work under Windows NT/2K/XP Dec 2002 by
|
|
Jens-Uwe Mager <jum@anubis.han.de>
|
|
|
|
Copying: Copyright 1993, 1994 David Hudson (dave@humbug.demon.co.uk)
|
|
|
|
Portions copyright 1992, 1993 Remy Card (card@masi.ibp.fr)
|
|
and 1991 Linus Torvalds (torvalds@klaava.helsinki.fi)
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
|
|
/* Include the header files */
|
|
|
|
#include "../version.h"
|
|
|
|
#ifdef _WIN32
|
|
#define _WIN32_WINNT 0x0400
|
|
#include <windows.h>
|
|
#include <winioctl.h>
|
|
#define __LITTLE_ENDIAN 1234
|
|
#define __BIG_ENDIAN 4321
|
|
#define __BYTE_ORDER __LITTLE_ENDIAN
|
|
#define inline
|
|
#define __attribute__(x)
|
|
#define BLOCK_SIZE 512
|
|
#else
|
|
#include <linux/hdreg.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/fd.h>
|
|
#include <endian.h>
|
|
#include <mntent.h>
|
|
#include <signal.h>
|
|
#include <sys/ioctl.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <time.h>
|
|
|
|
#if __BYTE_ORDER == __BIG_ENDIAN
|
|
|
|
#include <asm/byteorder.h>
|
|
#ifdef __le16_to_cpu
|
|
/* ++roman: 2.1 kernel headers define these function, they're probably more
|
|
* efficient then coding the swaps machine-independently. */
|
|
#define CF_LE_W __le16_to_cpu
|
|
#define CF_LE_L __le32_to_cpu
|
|
#define CT_LE_W __cpu_to_le16
|
|
#define CT_LE_L __cpu_to_le32
|
|
#else
|
|
#define CF_LE_W(v) ((((v) & 0xff) << 8) | (((v) >> 8) & 0xff))
|
|
#define CF_LE_L(v) (((unsigned)(v)>>24) | (((unsigned)(v)>>8)&0xff00) | \
|
|
(((unsigned)(v)<<8)&0xff0000) | ((unsigned)(v)<<24))
|
|
#define CT_LE_W(v) CF_LE_W(v)
|
|
#define CT_LE_L(v) CF_LE_L(v)
|
|
#endif /* defined(__le16_to_cpu) */
|
|
|
|
#else
|
|
|
|
#define CF_LE_W(v) (v)
|
|
#define CF_LE_L(v) (v)
|
|
#define CT_LE_W(v) (v)
|
|
#define CT_LE_L(v) (v)
|
|
|
|
#endif /* __BIG_ENDIAN */
|
|
|
|
#ifdef _WIN32
|
|
|
|
typedef unsigned char __u8;
|
|
typedef unsigned short __u16;
|
|
typedef unsigned int __u32;
|
|
typedef unsigned __int64 __u64;
|
|
typedef __int64 loff_t;
|
|
typedef __int64 ll_t;
|
|
|
|
extern char *optarg;
|
|
extern int optind;
|
|
extern int opterr;
|
|
extern int optopt;
|
|
int getopt(int argc, char *const argv[], const char * optstring);
|
|
|
|
static int is_device = 0;
|
|
|
|
#define open WIN32open
|
|
#define close WIN32close
|
|
#define read WIN32read
|
|
#define write WIN32write
|
|
#define llseek WIN32llseek
|
|
|
|
#define O_SHORT_LIVED _O_SHORT_LIVED
|
|
#define O_ACCMODE 3
|
|
#define O_NONE 3
|
|
#define O_BACKUP 0x10000
|
|
#define O_SHARED 0x20000
|
|
|
|
static int WIN32open(const char *path, int oflag, ...)
|
|
{
|
|
HANDLE fh;
|
|
DWORD desiredAccess;
|
|
DWORD shareMode;
|
|
DWORD creationDisposition;
|
|
DWORD flagsAttributes = FILE_ATTRIBUTE_NORMAL;
|
|
SECURITY_ATTRIBUTES securityAttributes;
|
|
va_list ap;
|
|
int pmode;
|
|
int trunc = FALSE;
|
|
|
|
securityAttributes.nLength = sizeof(securityAttributes);
|
|
securityAttributes.lpSecurityDescriptor = NULL;
|
|
securityAttributes.bInheritHandle = oflag & O_NOINHERIT ? FALSE : TRUE;
|
|
switch (oflag & O_ACCMODE) {
|
|
case O_RDONLY:
|
|
desiredAccess = GENERIC_READ;
|
|
shareMode = FILE_SHARE_READ;
|
|
break;
|
|
case O_WRONLY:
|
|
desiredAccess = GENERIC_WRITE;
|
|
shareMode = 0;
|
|
break;
|
|
case O_RDWR:
|
|
desiredAccess = GENERIC_READ|GENERIC_WRITE;
|
|
shareMode = 0;
|
|
break;
|
|
case O_NONE:
|
|
desiredAccess = 0;
|
|
shareMode = FILE_SHARE_READ|FILE_SHARE_WRITE;
|
|
}
|
|
if (oflag & O_APPEND) {
|
|
desiredAccess |= FILE_APPEND_DATA|SYNCHRONIZE;
|
|
shareMode = FILE_SHARE_READ|FILE_SHARE_WRITE;
|
|
}
|
|
if (oflag & O_SHARED)
|
|
shareMode |= FILE_SHARE_READ|FILE_SHARE_WRITE;
|
|
switch (oflag & (O_CREAT|O_EXCL|O_TRUNC)) {
|
|
case 0:
|
|
case O_EXCL:
|
|
creationDisposition = OPEN_EXISTING;
|
|
break;
|
|
case O_CREAT:
|
|
creationDisposition = OPEN_ALWAYS;
|
|
break;
|
|
case O_CREAT|O_EXCL:
|
|
case O_CREAT|O_TRUNC|O_EXCL:
|
|
creationDisposition = CREATE_NEW;
|
|
break;
|
|
case O_TRUNC:
|
|
case O_TRUNC|O_EXCL:
|
|
creationDisposition = TRUNCATE_EXISTING;
|
|
break;
|
|
case O_CREAT|O_TRUNC:
|
|
creationDisposition = OPEN_ALWAYS;
|
|
trunc = TRUE;
|
|
break;
|
|
}
|
|
if (oflag & O_CREAT) {
|
|
va_start(ap, oflag);
|
|
pmode = va_arg(ap, int);
|
|
va_end(ap);
|
|
if ((pmode & 0222) == 0)
|
|
flagsAttributes |= FILE_ATTRIBUTE_READONLY;
|
|
}
|
|
if (oflag & O_TEMPORARY) {
|
|
flagsAttributes |= FILE_FLAG_DELETE_ON_CLOSE;
|
|
desiredAccess |= DELETE;
|
|
}
|
|
if (oflag & O_SHORT_LIVED)
|
|
flagsAttributes |= FILE_ATTRIBUTE_TEMPORARY;
|
|
if (oflag & O_SEQUENTIAL)
|
|
flagsAttributes |= FILE_FLAG_SEQUENTIAL_SCAN;
|
|
else if (oflag & O_RANDOM)
|
|
flagsAttributes |= FILE_FLAG_RANDOM_ACCESS;
|
|
if (oflag & O_BACKUP)
|
|
flagsAttributes |= FILE_FLAG_BACKUP_SEMANTICS;
|
|
if ((fh = CreateFile(path, desiredAccess, shareMode, &securityAttributes,
|
|
creationDisposition, flagsAttributes, NULL)) == INVALID_HANDLE_VALUE) {
|
|
errno = GetLastError();
|
|
return -1;
|
|
}
|
|
if (trunc) {
|
|
if (!SetEndOfFile(fh)) {
|
|
errno = GetLastError();
|
|
CloseHandle(fh);
|
|
DeleteFile(path);
|
|
return -1;
|
|
}
|
|
}
|
|
return (int)fh;
|
|
}
|
|
|
|
static int WIN32close(int fd)
|
|
{
|
|
if (!CloseHandle((HANDLE)fd)) {
|
|
errno = GetLastError();
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int WIN32read(int fd, void *buf, unsigned int len)
|
|
{
|
|
DWORD actualLen;
|
|
|
|
if (!ReadFile((HANDLE)fd, buf, (DWORD)len, &actualLen, NULL)) {
|
|
errno = GetLastError();
|
|
if (errno == ERROR_BROKEN_PIPE)
|
|
return 0;
|
|
else
|
|
return -1;
|
|
}
|
|
return (int)actualLen;
|
|
}
|
|
|
|
static int WIN32write(int fd, void *buf, unsigned int len)
|
|
{
|
|
DWORD actualLen;
|
|
|
|
if (!WriteFile((HANDLE)fd, buf, (DWORD)len, &actualLen, NULL)) {
|
|
errno = GetLastError();
|
|
return -1;
|
|
}
|
|
return (int)actualLen;
|
|
}
|
|
|
|
static loff_t WIN32llseek(int fd, loff_t offset, int whence)
|
|
{
|
|
long lo, hi;
|
|
DWORD err;
|
|
|
|
lo = offset & 0xffffffff;
|
|
hi = offset >> 32;
|
|
lo = SetFilePointer((HANDLE)fd, lo, &hi, whence);
|
|
if (lo == 0xFFFFFFFF && (err = GetLastError()) != NO_ERROR) {
|
|
errno = err;
|
|
return -1;
|
|
}
|
|
return ((loff_t)hi << 32) | (off_t)lo;
|
|
}
|
|
|
|
int fsctl(int fd, int code)
|
|
{
|
|
DWORD ret;
|
|
if (!DeviceIoControl((HANDLE)fd, code, NULL, 0, NULL, 0, &ret, NULL)) {
|
|
errno = GetLastError();
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
|
|
#define O_NOINHERIT 0
|
|
#define O_TEMPORARY 0
|
|
#define O_SHORT_LIVED 0
|
|
#define O_SEQUENTIAL 0
|
|
#define O_RANDOM 0
|
|
#define O_BACKUP 0
|
|
#define O_SHARED 0
|
|
#ifndef O_NONE
|
|
# define O_NONE 0
|
|
#endif
|
|
|
|
typedef long long ll_t;
|
|
/* Use the _llseek system call directly, because there (once?) was a bug in
|
|
* the glibc implementation of it. */
|
|
#include <linux/unistd.h>
|
|
#if defined(__alpha) || defined(__ia64__)
|
|
/* On alpha, the syscall is simply lseek, because it's a 64 bit system. */
|
|
static loff_t llseek( int fd, loff_t offset, int whence )
|
|
{
|
|
return lseek(fd, offset, whence);
|
|
}
|
|
#else
|
|
# ifndef __NR__llseek
|
|
# error _llseek system call not present
|
|
# endif
|
|
static _syscall5( int, _llseek, uint, fd, ulong, hi, ulong, lo,
|
|
loff_t *, res, uint, wh );
|
|
static loff_t llseek( int fd, loff_t offset, int whence )
|
|
{
|
|
loff_t actual;
|
|
|
|
if (_llseek(fd, offset>>32, offset&0xffffffff, &actual, whence) != 0)
|
|
return (loff_t)-1;
|
|
return actual;
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
/* Constant definitions */
|
|
|
|
#define TRUE 1 /* Boolean constants */
|
|
#define FALSE 0
|
|
|
|
#define TEST_BUFFER_BLOCKS 16
|
|
#define HARD_SECTOR_SIZE 512
|
|
#define SECTORS_PER_BLOCK ( BLOCK_SIZE / HARD_SECTOR_SIZE )
|
|
|
|
|
|
/* Macro definitions */
|
|
|
|
/* Report a failure message and return a failure error code */
|
|
|
|
#define die( str ) fatal_error( "%s: " str "\n" )
|
|
|
|
|
|
/* Mark a cluster in the FAT as bad */
|
|
|
|
#define mark_sector_bad( sector ) mark_FAT_sector( sector, FAT_BAD )
|
|
|
|
/* Compute ceil(a/b) */
|
|
|
|
inline int
|
|
cdiv (int a, int b)
|
|
{
|
|
return (a + b - 1) / b;
|
|
}
|
|
|
|
/* MS-DOS filesystem structures -- I included them here instead of
|
|
including linux/msdos_fs.h since that doesn't include some fields we
|
|
need */
|
|
|
|
#define ATTR_RO 1 /* read-only */
|
|
#define ATTR_HIDDEN 2 /* hidden */
|
|
#define ATTR_SYS 4 /* system */
|
|
#define ATTR_VOLUME 8 /* volume label */
|
|
#define ATTR_DIR 16 /* directory */
|
|
#define ATTR_ARCH 32 /* archived */
|
|
|
|
#define ATTR_NONE 0 /* no attribute bits */
|
|
#define ATTR_UNUSED (ATTR_VOLUME | ATTR_ARCH | ATTR_SYS | ATTR_HIDDEN)
|
|
/* attribute bits that are copied "as is" */
|
|
|
|
/* FAT values */
|
|
#define FAT_EOF (atari_format ? 0x0fffffff : 0x0ffffff8)
|
|
#define FAT_BAD 0x0ffffff7
|
|
|
|
#define MSDOS_EXT_SIGN 0x29 /* extended boot sector signature */
|
|
#define MSDOS_FAT12_SIGN "FAT12 " /* FAT12 filesystem signature */
|
|
#define MSDOS_FAT16_SIGN "FAT16 " /* FAT16 filesystem signature */
|
|
#define MSDOS_FAT32_SIGN "FAT32 " /* FAT32 filesystem signature */
|
|
|
|
#define BOOT_SIGN 0xAA55 /* Boot sector magic number */
|
|
|
|
#define MAX_CLUST_12 ((1 << 12) - 16)
|
|
#define MAX_CLUST_16 ((1 << 16) - 16)
|
|
/* M$ says the high 4 bits of a FAT32 FAT entry are reserved and don't belong
|
|
* to the cluster number. So the max. cluster# is based on 2^28 */
|
|
#define MAX_CLUST_32 ((1 << 28) - 16)
|
|
|
|
#define FAT12_THRESHOLD 4078
|
|
|
|
#define OLDGEMDOS_MAX_SECTORS 32765
|
|
#define GEMDOS_MAX_SECTORS 65531
|
|
#define GEMDOS_MAX_SECTOR_SIZE (16*1024)
|
|
|
|
#define BOOTCODE_SIZE 448
|
|
#define BOOTCODE_FAT32_SIZE 420
|
|
|
|
/* __attribute__ ((packed)) is used on all structures to make gcc ignore any
|
|
* alignments */
|
|
|
|
#ifdef _WIN32
|
|
#pragma pack(push, 1)
|
|
#endif
|
|
struct msdos_volume_info {
|
|
__u8 drive_number; /* BIOS drive number */
|
|
__u8 RESERVED; /* Unused */
|
|
__u8 ext_boot_sign; /* 0x29 if fields below exist (DOS 3.3+) */
|
|
__u8 volume_id[4]; /* Volume ID number */
|
|
__u8 volume_label[11];/* Volume label */
|
|
__u8 fs_type[8]; /* Typically FAT12 or FAT16 */
|
|
} __attribute__ ((packed));
|
|
|
|
struct msdos_boot_sector
|
|
{
|
|
__u8 boot_jump[3]; /* Boot strap short or near jump */
|
|
__u8 system_id[8]; /* Name - can be used to special case
|
|
partition manager volumes */
|
|
__u8 sector_size[2]; /* bytes per logical sector */
|
|
__u8 cluster_size; /* sectors/cluster */
|
|
__u16 reserved; /* reserved sectors */
|
|
__u8 fats; /* number of FATs */
|
|
__u8 dir_entries[2]; /* root directory entries */
|
|
__u8 sectors[2]; /* number of sectors */
|
|
__u8 media; /* media code (unused) */
|
|
__u16 fat_length; /* sectors/FAT */
|
|
__u16 secs_track; /* sectors per track */
|
|
__u16 heads; /* number of heads */
|
|
__u32 hidden; /* hidden sectors (unused) */
|
|
__u32 total_sect; /* number of sectors (if sectors == 0) */
|
|
union {
|
|
struct {
|
|
struct msdos_volume_info vi;
|
|
__u8 boot_code[BOOTCODE_SIZE];
|
|
} __attribute__ ((packed)) _oldfat;
|
|
struct {
|
|
__u32 fat32_length; /* sectors/FAT */
|
|
__u16 flags; /* bit 8: fat mirroring, low 4: active fat */
|
|
__u8 version[2]; /* major, minor filesystem version */
|
|
__u32 root_cluster; /* first cluster in root directory */
|
|
__u16 info_sector; /* filesystem info sector */
|
|
__u16 backup_boot; /* backup boot sector */
|
|
__u16 reserved2[6]; /* Unused */
|
|
struct msdos_volume_info vi;
|
|
__u8 boot_code[BOOTCODE_FAT32_SIZE];
|
|
} __attribute__ ((packed)) _fat32;
|
|
} __attribute__ ((packed)) fstype;
|
|
__u16 boot_sign;
|
|
} __attribute__ ((packed));
|
|
#define fat32 fstype._fat32
|
|
#define oldfat fstype._oldfat
|
|
|
|
struct fat32_fsinfo {
|
|
__u32 reserved1; /* Nothing as far as I can tell */
|
|
__u32 signature; /* 0x61417272L */
|
|
__u32 free_clusters; /* Free cluster count. -1 if unknown */
|
|
__u32 next_cluster; /* Most recently allocated cluster.
|
|
* Unused under Linux. */
|
|
__u32 reserved2[4];
|
|
};
|
|
|
|
struct msdos_dir_entry
|
|
{
|
|
char name[8], ext[3]; /* name and extension */
|
|
__u8 attr; /* attribute bits */
|
|
__u8 lcase; /* Case for base and extension */
|
|
__u8 ctime_ms; /* Creation time, milliseconds */
|
|
__u16 ctime; /* Creation time */
|
|
__u16 cdate; /* Creation date */
|
|
__u16 adate; /* Last access date */
|
|
__u16 starthi; /* high 16 bits of first cl. (FAT32) */
|
|
__u16 time, date, start; /* time, date and first cluster */
|
|
__u32 size; /* file size (in bytes) */
|
|
} __attribute__ ((packed));
|
|
|
|
#ifdef _WIN32
|
|
#pragma pack(pop)
|
|
#endif
|
|
|
|
/* The "boot code" we put into the filesystem... it writes a message and
|
|
tells the user to try again */
|
|
|
|
char dummy_boot_jump[3] = { 0xeb, 0x3c, 0x90 };
|
|
|
|
char dummy_boot_jump_m68k[2] = { 0x60, 0x1c };
|
|
|
|
char dummy_boot_code[BOOTCODE_SIZE] =
|
|
"\x0e" /* push cs */
|
|
"\x1f" /* pop ds */
|
|
"\xbe\x5b\x7c" /* mov si, offset message_txt */
|
|
/* write_msg: */
|
|
"\xac" /* lodsb */
|
|
"\x22\xc0" /* and al, al */
|
|
"\x74\x0b" /* jz key_press */
|
|
"\x56" /* push si */
|
|
"\xb4\x0e" /* mov ah, 0eh */
|
|
"\xbb\x07\x00" /* mov bx, 0007h */
|
|
"\xcd\x10" /* int 10h */
|
|
"\x5e" /* pop si */
|
|
"\xeb\xf0" /* jmp write_msg */
|
|
/* key_press: */
|
|
"\x32\xe4" /* xor ah, ah */
|
|
"\xcd\x16" /* int 16h */
|
|
"\xcd\x19" /* int 19h */
|
|
"\xeb\xfe" /* foo: jmp foo */
|
|
/* message_txt: */
|
|
|
|
"This is not a bootable disk. Please insert a bootable floppy and\r\n"
|
|
"press any key to try again ... \r\n";
|
|
|
|
#define MESSAGE_OFFSET 29 /* Offset of message in above code */
|
|
|
|
/* Global variables - the root of all evil :-) - see these and weep! */
|
|
|
|
static char *program_name = "mkdosfs"; /* Name of the program */
|
|
static char *device_name = NULL; /* Name of the device on which to create the filesystem */
|
|
static int atari_format = 0; /* Use Atari variation of MS-DOS FS format */
|
|
static int check = FALSE; /* Default to no readablity checking */
|
|
static int verbose = 0; /* Default to verbose mode off */
|
|
static long volume_id; /* Volume ID number */
|
|
static time_t create_time; /* Creation time */
|
|
static char volume_name[] = " "; /* Volume name */
|
|
static int blocks; /* Number of blocks in filesystem */
|
|
static int sector_size = 512; /* Size of a logical sector */
|
|
static int sector_size_set = 0; /* User selected sector size */
|
|
static int backup_boot = 0; /* Sector# of backup boot sector */
|
|
static int reserved_sectors = 0;/* Number of reserved sectors */
|
|
static int badblocks = 0; /* Number of bad blocks in the filesystem */
|
|
static int nr_fats = 2; /* Default number of FATs to produce */
|
|
static int size_fat = 0; /* Size in bits of FAT entries */
|
|
static int size_fat_by_user = 0; /* 1 if FAT size user selected */
|
|
static int dev = -1; /* FS block device file handle */
|
|
static int ignore_full_disk = 0; /* Ignore warning about 'full' disk devices */
|
|
static unsigned int currently_testing = 0; /* Block currently being tested (if autodetect bad blocks) */
|
|
static struct msdos_boot_sector bs; /* Boot sector data */
|
|
static int start_data_sector; /* Sector number for the start of the data area */
|
|
static int start_data_block; /* Block number for the start of the data area */
|
|
static unsigned char *fat; /* File allocation table */
|
|
static unsigned char *info_sector; /* FAT32 info sector */
|
|
static struct msdos_dir_entry *root_dir; /* Root directory */
|
|
static int size_root_dir; /* Size of the root directory in bytes */
|
|
static int sectors_per_cluster = 0; /* Number of sectors per disk cluster */
|
|
static int root_dir_entries = 0; /* Number of root directory entries */
|
|
static char *blank_sector; /* Blank sector - all zeros */
|
|
|
|
|
|
/* Function prototype definitions */
|
|
|
|
static void fatal_error (const char *fmt_string) __attribute__((noreturn));
|
|
static void mark_FAT_cluster (int cluster, unsigned int value);
|
|
static void mark_FAT_sector (int sector, unsigned int value);
|
|
static long do_check (char *buffer, int try, unsigned int current_block);
|
|
static void alarm_intr (int alnum);
|
|
static void check_blocks (void);
|
|
static void get_list_blocks (char *filename);
|
|
static int valid_offset (int fd, loff_t offset);
|
|
static int count_blocks (char *filename);
|
|
static void check_mount (char *device_name);
|
|
#ifdef _WIN32
|
|
static void establish_params (void);
|
|
#else
|
|
static void establish_params (int device_num, int size);
|
|
#endif
|
|
static void setup_tables (void);
|
|
static void write_tables (void);
|
|
|
|
|
|
/* The function implementations */
|
|
|
|
/* Handle the reporting of fatal errors. Volatile to let gcc know that this doesn't return */
|
|
|
|
static void
|
|
fatal_error (const char *fmt_string)
|
|
{
|
|
fprintf (stderr, fmt_string, program_name, device_name);
|
|
exit (1); /* The error exit code is 1! */
|
|
}
|
|
|
|
|
|
/* Mark the specified cluster as having a particular value */
|
|
|
|
static void
|
|
mark_FAT_cluster (int cluster, unsigned int value)
|
|
{
|
|
switch( size_fat ) {
|
|
case 12:
|
|
value &= 0x0fff;
|
|
if (((cluster * 3) & 0x1) == 0)
|
|
{
|
|
fat[3 * cluster / 2] = (unsigned char) (value & 0x00ff);
|
|
fat[(3 * cluster / 2) + 1] = (unsigned char) ((fat[(3 * cluster / 2) + 1] & 0x00f0)
|
|
| ((value & 0x0f00) >> 8));
|
|
}
|
|
else
|
|
{
|
|
fat[3 * cluster / 2] = (unsigned char) ((fat[3 * cluster / 2] & 0x000f) | ((value & 0x000f) << 4));
|
|
fat[(3 * cluster / 2) + 1] = (unsigned char) ((value & 0x0ff0) >> 4);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
value &= 0xffff;
|
|
fat[2 * cluster] = (unsigned char) (value & 0x00ff);
|
|
fat[(2 * cluster) + 1] = (unsigned char) (value >> 8);
|
|
break;
|
|
|
|
case 32:
|
|
value &= 0xfffffff;
|
|
fat[4 * cluster] = (unsigned char) (value & 0x000000ff);
|
|
fat[(4 * cluster) + 1] = (unsigned char) ((value & 0x0000ff00) >> 8);
|
|
fat[(4 * cluster) + 2] = (unsigned char) ((value & 0x00ff0000) >> 16);
|
|
fat[(4 * cluster) + 3] = (unsigned char) ((value & 0xff000000) >> 24);
|
|
break;
|
|
|
|
default:
|
|
die("Bad FAT size (not 12, 16, or 32)");
|
|
}
|
|
}
|
|
|
|
|
|
/* Mark a specified sector as having a particular value in it's FAT entry */
|
|
|
|
static void
|
|
mark_FAT_sector (int sector, unsigned int value)
|
|
{
|
|
int cluster;
|
|
|
|
cluster = (sector - start_data_sector) / (int) (bs.cluster_size) /
|
|
(sector_size/HARD_SECTOR_SIZE);
|
|
if (cluster < 0)
|
|
die ("Invalid cluster number in mark_FAT_sector: probably bug!");
|
|
|
|
mark_FAT_cluster (cluster, value);
|
|
}
|
|
|
|
|
|
/* Perform a test on a block. Return the number of blocks that could be read successfully */
|
|
|
|
static long
|
|
do_check (char *buffer, int try, unsigned int current_block)
|
|
{
|
|
long got;
|
|
|
|
if (llseek (dev, (loff_t)current_block * BLOCK_SIZE, SEEK_SET) /* Seek to the correct location */
|
|
!= (loff_t)current_block * BLOCK_SIZE)
|
|
die ("seek failed during testing for blocks");
|
|
|
|
got = read (dev, buffer, try * BLOCK_SIZE); /* Try reading! */
|
|
if (got < 0)
|
|
got = 0;
|
|
|
|
if (got & (BLOCK_SIZE - 1))
|
|
printf ("Unexpected values in do_check: probably bugs\n");
|
|
got /= BLOCK_SIZE;
|
|
|
|
return got;
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
/* Alarm clock handler - display the status of the quest for bad blocks! Then retrigger the alarm for five senconds
|
|
later (so we can come here again) */
|
|
|
|
static void
|
|
alarm_intr (int alnum)
|
|
{
|
|
if (currently_testing >= blocks)
|
|
return;
|
|
|
|
signal (SIGALRM, alarm_intr);
|
|
alarm (5);
|
|
if (!currently_testing)
|
|
return;
|
|
|
|
printf ("%d... ", currently_testing);
|
|
fflush (stdout);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
check_blocks (void)
|
|
{
|
|
int try, got;
|
|
int i;
|
|
static char blkbuf[BLOCK_SIZE * TEST_BUFFER_BLOCKS];
|
|
|
|
if (verbose)
|
|
{
|
|
printf ("Searching for bad blocks ");
|
|
fflush (stdout);
|
|
}
|
|
currently_testing = 0;
|
|
#ifndef _WIN32
|
|
if (verbose)
|
|
{
|
|
signal (SIGALRM, alarm_intr);
|
|
alarm (5);
|
|
}
|
|
#endif
|
|
try = TEST_BUFFER_BLOCKS;
|
|
while (currently_testing < blocks)
|
|
{
|
|
if (currently_testing + try > blocks)
|
|
try = blocks - currently_testing;
|
|
got = do_check (blkbuf, try, currently_testing);
|
|
currently_testing += got;
|
|
if (got == try)
|
|
{
|
|
try = TEST_BUFFER_BLOCKS;
|
|
continue;
|
|
}
|
|
else
|
|
try = 1;
|
|
if (currently_testing < start_data_block)
|
|
die ("bad blocks before data-area: cannot make fs");
|
|
|
|
for (i = 0; i < SECTORS_PER_BLOCK; i++) /* Mark all of the sectors in the block as bad */
|
|
mark_sector_bad (currently_testing * SECTORS_PER_BLOCK + i);
|
|
badblocks++;
|
|
currently_testing++;
|
|
}
|
|
|
|
if (verbose)
|
|
printf ("\n");
|
|
|
|
if (badblocks)
|
|
printf ("%d bad block%s\n", badblocks,
|
|
(badblocks > 1) ? "s" : "");
|
|
}
|
|
|
|
|
|
static void
|
|
get_list_blocks (char *filename)
|
|
{
|
|
int i;
|
|
FILE *listfile;
|
|
unsigned long blockno;
|
|
|
|
listfile = fopen (filename, "r");
|
|
if (listfile == (FILE *) NULL)
|
|
die ("Can't open file of bad blocks");
|
|
|
|
while (!feof (listfile))
|
|
{
|
|
fscanf (listfile, "%ld\n", &blockno);
|
|
for (i = 0; i < SECTORS_PER_BLOCK; i++) /* Mark all of the sectors in the block as bad */
|
|
mark_sector_bad (blockno * SECTORS_PER_BLOCK + i);
|
|
badblocks++;
|
|
}
|
|
fclose (listfile);
|
|
|
|
if (badblocks)
|
|
printf ("%d bad block%s\n", badblocks,
|
|
(badblocks > 1) ? "s" : "");
|
|
}
|
|
|
|
|
|
#ifndef _WIN32
|
|
/* Given a file descriptor and an offset, check whether the offset is a valid offset for the file - return FALSE if it
|
|
isn't valid or TRUE if it is */
|
|
|
|
static int
|
|
valid_offset (int fd, loff_t offset)
|
|
{
|
|
char ch;
|
|
|
|
if (llseek (fd, offset, SEEK_SET) < 0)
|
|
return FALSE;
|
|
if (read (fd, &ch, 1) < 1)
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* Given a filename, look to see how many blocks of BLOCK_SIZE are present, returning the answer */
|
|
|
|
static int
|
|
count_blocks (char *filename)
|
|
{
|
|
#ifdef _WIN32
|
|
int fd;
|
|
DISK_GEOMETRY geom;
|
|
BY_HANDLE_FILE_INFORMATION hinfo;
|
|
DWORD ret;
|
|
loff_t len = 0;
|
|
|
|
if ((fd = open(filename, O_RDONLY)) < 0) {
|
|
perror(filename);
|
|
exit(1);
|
|
}
|
|
/*
|
|
* This should probably use IOCTL_DISK_GET_LENGTH_INFO here, but
|
|
* this ioctl is only available in XP and up.
|
|
*/
|
|
if (is_device) {
|
|
if (!DeviceIoControl((HANDLE)fd, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &geom, sizeof(geom), &ret, NULL)) {
|
|
errno = GetLastError();
|
|
die("unable to get length for '%s'");
|
|
}
|
|
len = geom.Cylinders.QuadPart*geom.TracksPerCylinder*geom.SectorsPerTrack*BLOCK_SIZE;
|
|
} else {
|
|
if (!GetFileInformationByHandle((HANDLE)fd, &hinfo)) {
|
|
errno = GetLastError();
|
|
die("unable to get length for '%s'");
|
|
}
|
|
len = ((loff_t)hinfo.nFileSizeHigh << 32) | (loff_t)hinfo.nFileSizeLow;
|
|
}
|
|
close(fd);
|
|
return len/BLOCK_SIZE;
|
|
#else
|
|
loff_t high, low;
|
|
int fd;
|
|
|
|
if ((fd = open (filename, O_RDONLY)) < 0)
|
|
{
|
|
perror (filename);
|
|
exit (1);
|
|
}
|
|
low = 0;
|
|
|
|
for (high = 1; valid_offset (fd, high); high *= 2)
|
|
low = high;
|
|
while (low < high - 1)
|
|
{
|
|
const loff_t mid = (low + high) / 2;
|
|
|
|
if (valid_offset (fd, mid))
|
|
low = mid;
|
|
else
|
|
high = mid;
|
|
}
|
|
valid_offset (fd, 0);
|
|
close (fd);
|
|
|
|
return (low + 1) / BLOCK_SIZE;
|
|
#endif
|
|
}
|
|
|
|
|
|
/* Check to see if the specified device is currently mounted - abort if it is */
|
|
|
|
static void
|
|
check_mount (char *device_name)
|
|
{
|
|
#ifndef _WIN32
|
|
FILE *f;
|
|
struct mntent *mnt;
|
|
|
|
if ((f = setmntent (MOUNTED, "r")) == NULL)
|
|
return;
|
|
while ((mnt = getmntent (f)) != NULL)
|
|
if (strcmp (device_name, mnt->mnt_fsname) == 0)
|
|
die ("%s contains a mounted file system.");
|
|
endmntent (f);
|
|
#endif
|
|
}
|
|
|
|
|
|
/* Establish the geometry and media parameters for the device */
|
|
#ifdef _WIN32
|
|
static void
|
|
establish_params (void)
|
|
{
|
|
DISK_GEOMETRY geometry;
|
|
DWORD ret;
|
|
|
|
if (!is_device) {
|
|
bs.media = (char) 0xf8; /* Set up the media descriptor for a hard drive */
|
|
bs.dir_entries[0] = (char) 0;
|
|
bs.dir_entries[1] = (char) 2;
|
|
/* For FAT32, use 4k clusters on sufficiently large file systems,
|
|
* otherwise 1 sector per cluster. This is also what M$'s format
|
|
* command does for FAT32. */
|
|
bs.cluster_size = (char)
|
|
(size_fat == 32 ?
|
|
((ll_t)blocks*SECTORS_PER_BLOCK >= 512*1024 ? 8 : 1) :
|
|
4); /* FAT12 and FAT16: start at 4 sectors per cluster */
|
|
return;
|
|
}
|
|
if (!DeviceIoControl((HANDLE)dev, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &geometry, sizeof(geometry), &ret, NULL)) {
|
|
errno = GetLastError();
|
|
die ("unable to get geometry for '%s'");
|
|
}
|
|
bs.secs_track = geometry.SectorsPerTrack;
|
|
bs.heads = geometry.TracksPerCylinder;
|
|
switch (geometry.MediaType) {
|
|
case F3_1Pt44_512:
|
|
bs.media = (char) 0xf9;
|
|
bs.cluster_size = (char) 2;
|
|
bs.dir_entries[0] = (char) 112;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
case F3_2Pt88_512:
|
|
bs.media = (char) 0xf0;
|
|
bs.cluster_size = (char)(atari_format ? 2 : 1);
|
|
bs.dir_entries[0] = (char) 224;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
case F3_720_512:
|
|
bs.media = (char) 0xfd;
|
|
bs.cluster_size = (char) 2;
|
|
bs.dir_entries[0] = (char) 112;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
default:
|
|
bs.media = (char) 0xf8; /* Set up the media descriptor for a hard drive */
|
|
bs.dir_entries[0] = (char) 0;
|
|
bs.dir_entries[1] = (char) 2;
|
|
/* For FAT32, use 4k clusters on sufficiently large file systems,
|
|
* otherwise 1 sector per cluster. This is also what M$'s format
|
|
* command does for FAT32. */
|
|
bs.cluster_size = (char)
|
|
(size_fat == 32 ?
|
|
((ll_t)blocks*SECTORS_PER_BLOCK >= 512*1024 ? 8 : 1) :
|
|
4); /* FAT12 and FAT16: start at 4 sectors per cluster */
|
|
}
|
|
}
|
|
#else
|
|
static void
|
|
establish_params (int device_num,int size)
|
|
{
|
|
long loop_size;
|
|
struct hd_geometry geometry;
|
|
struct floppy_struct param;
|
|
|
|
if ((0 == device_num) || ((device_num & 0xff00) == 0x0200))
|
|
/* file image or floppy disk */
|
|
{
|
|
if (0 == device_num)
|
|
{
|
|
param.size = size/512;
|
|
switch(param.size)
|
|
{
|
|
case 720:
|
|
param.sect = 9 ;
|
|
param.head = 2;
|
|
break;
|
|
case 1440:
|
|
param.sect = 9;
|
|
param.head = 2;
|
|
break;
|
|
case 2400:
|
|
param.sect = 15;
|
|
param.head = 2;
|
|
break;
|
|
case 2880:
|
|
param.sect = 18;
|
|
param.head = 2;
|
|
break;
|
|
case 5760:
|
|
param.sect = 36;
|
|
param.head = 2;
|
|
break;
|
|
default:
|
|
/* fake values */
|
|
param.sect = 32;
|
|
param.head = 64;
|
|
break;
|
|
}
|
|
|
|
}
|
|
else /* is a floppy diskette */
|
|
{
|
|
if (ioctl (dev, FDGETPRM, ¶m)) /* Can we get the diskette geometry? */
|
|
die ("unable to get diskette geometry for '%s'");
|
|
}
|
|
bs.secs_track = CT_LE_W(param.sect); /* Set up the geometry information */
|
|
bs.heads = CT_LE_W(param.head);
|
|
switch (param.size) /* Set up the media descriptor byte */
|
|
{
|
|
case 720: /* 5.25", 2, 9, 40 - 360K */
|
|
bs.media = (char) 0xfd;
|
|
bs.cluster_size = (char) 2;
|
|
bs.dir_entries[0] = (char) 112;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
case 1440: /* 3.5", 2, 9, 80 - 720K */
|
|
bs.media = (char) 0xf9;
|
|
bs.cluster_size = (char) 2;
|
|
bs.dir_entries[0] = (char) 112;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
case 2400: /* 5.25", 2, 15, 80 - 1200K */
|
|
bs.media = (char) 0xf9;
|
|
bs.cluster_size = (char)(atari_format ? 2 : 1);
|
|
bs.dir_entries[0] = (char) 224;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
case 5760: /* 3.5", 2, 36, 80 - 2880K */
|
|
bs.media = (char) 0xf0;
|
|
bs.cluster_size = (char) 2;
|
|
bs.dir_entries[0] = (char) 224;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
case 2880: /* 3.5", 2, 18, 80 - 1440K */
|
|
floppy_default:
|
|
bs.media = (char) 0xf0;
|
|
bs.cluster_size = (char)(atari_format ? 2 : 1);
|
|
bs.dir_entries[0] = (char) 224;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
default: /* Anything else */
|
|
if (0 == device_num)
|
|
goto def_hd_params;
|
|
else
|
|
goto floppy_default;
|
|
}
|
|
}
|
|
else if ((device_num & 0xff00) == 0x0700) /* This is a loop device */
|
|
{
|
|
/* Can we get the loop geometry? This is in 512 byte blocks, always? */
|
|
if (ioctl (dev, BLKGETSIZE, &loop_size))
|
|
die ("unable to get loop geometry for '%s'");
|
|
loop_size = loop_size >> 1;
|
|
|
|
switch (loop_size) /* Assuming the loop device -> floppy later */
|
|
{
|
|
case 720: /* 5.25", 2, 9, 40 - 360K */
|
|
bs.secs_track = CF_LE_W(9);
|
|
bs.heads = CF_LE_W(2);
|
|
bs.media = (char) 0xfd;
|
|
bs.cluster_size = (char) 2;
|
|
bs.dir_entries[0] = (char) 112;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
case 1440: /* 3.5", 2, 9, 80 - 720K */
|
|
bs.secs_track = CF_LE_W(9);
|
|
bs.heads = CF_LE_W(2);
|
|
bs.media = (char) 0xf9;
|
|
bs.cluster_size = (char) 2;
|
|
bs.dir_entries[0] = (char) 112;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
case 2400: /* 5.25", 2, 15, 80 - 1200K */
|
|
bs.secs_track = CF_LE_W(15);
|
|
bs.heads = CF_LE_W(2);
|
|
bs.media = (char) 0xf9;
|
|
bs.cluster_size = (char)(atari_format ? 2 : 1);
|
|
bs.dir_entries[0] = (char) 224;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
case 5760: /* 3.5", 2, 36, 80 - 2880K */
|
|
bs.secs_track = CF_LE_W(36);
|
|
bs.heads = CF_LE_W(2);
|
|
bs.media = (char) 0xf0;
|
|
bs.cluster_size = (char) 2;
|
|
bs.dir_entries[0] = (char) 224;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
case 2880: /* 3.5", 2, 18, 80 - 1440K */
|
|
bs.secs_track = CF_LE_W(18);
|
|
bs.heads = CF_LE_W(2);
|
|
bs.media = (char) 0xf0;
|
|
bs.cluster_size = (char)(atari_format ? 2 : 1);
|
|
bs.dir_entries[0] = (char) 224;
|
|
bs.dir_entries[1] = (char) 0;
|
|
break;
|
|
|
|
default: /* Anything else: default hd setup */
|
|
printf("Loop device does not match a floppy size, using "
|
|
"default hd params\n");
|
|
bs.secs_track = CT_LE_W(32); /* these are fake values... */
|
|
bs.heads = CT_LE_W(64);
|
|
goto def_hd_params;
|
|
}
|
|
}
|
|
else
|
|
/* Must be a hard disk then! */
|
|
{
|
|
/* Can we get the drive geometry? (Note I'm not too sure about */
|
|
/* whether to use HDIO_GETGEO or HDIO_REQ) */
|
|
if (ioctl (dev, HDIO_GETGEO, &geometry))
|
|
die ("unable to get drive geometry for '%s'");
|
|
bs.secs_track = CT_LE_W(geometry.sectors); /* Set up the geometry information */
|
|
bs.heads = CT_LE_W(geometry.heads);
|
|
def_hd_params:
|
|
bs.media = (char) 0xf8; /* Set up the media descriptor for a hard drive */
|
|
bs.dir_entries[0] = (char) 0; /* Default to 512 entries */
|
|
bs.dir_entries[1] = (char) 2;
|
|
/* For FAT32, use 4k clusters on sufficiently large file systems,
|
|
* otherwise 1 sector per cluster. This is also what M$'s format
|
|
* command does for FAT32. */
|
|
bs.cluster_size = (char)
|
|
(size_fat == 32 ?
|
|
((ll_t)blocks*SECTORS_PER_BLOCK >= 512*1024 ? 8 : 1) :
|
|
4); /* FAT12 and FAT16: start at 4 sectors per cluster */
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/* Create the filesystem data tables */
|
|
|
|
static void
|
|
setup_tables (void)
|
|
{
|
|
unsigned num_sectors;
|
|
unsigned cluster_count = 0, fat_length;
|
|
unsigned fatdata; /* Sectors for FATs + data area */
|
|
struct tm *ctime;
|
|
struct msdos_volume_info *vi = (size_fat == 32 ? &bs.fat32.vi : &bs.oldfat.vi);
|
|
|
|
if (atari_format)
|
|
/* On Atari, the first few bytes of the boot sector are assigned
|
|
* differently: The jump code is only 2 bytes (and m68k machine code
|
|
* :-), then 6 bytes filler (ignored), then 3 byte serial number. */
|
|
strncpy( bs.system_id-1, "mkdosf", 6 );
|
|
else
|
|
strcpy (bs.system_id, "mkdosfs");
|
|
if (sectors_per_cluster)
|
|
bs.cluster_size = (char) sectors_per_cluster;
|
|
if (size_fat == 32)
|
|
{
|
|
/* Under FAT32, the root dir is in a cluster chain, and this is
|
|
* signalled by bs.dir_entries being 0. */
|
|
bs.dir_entries[0] = bs.dir_entries[1] = (char) 0;
|
|
root_dir_entries = 0;
|
|
}
|
|
else if (root_dir_entries)
|
|
{
|
|
/* Override default from establish_params() */
|
|
bs.dir_entries[0] = (char) (root_dir_entries & 0x00ff);
|
|
bs.dir_entries[1] = (char) ((root_dir_entries & 0xff00) >> 8);
|
|
}
|
|
else
|
|
root_dir_entries = bs.dir_entries[0] + (bs.dir_entries[1] << 8);
|
|
|
|
if (atari_format) {
|
|
bs.system_id[5] = (unsigned char) (volume_id & 0x000000ff);
|
|
bs.system_id[6] = (unsigned char) ((volume_id & 0x0000ff00) >> 8);
|
|
bs.system_id[7] = (unsigned char) ((volume_id & 0x00ff0000) >> 16);
|
|
}
|
|
else {
|
|
vi->volume_id[0] = (unsigned char) (volume_id & 0x000000ff);
|
|
vi->volume_id[1] = (unsigned char) ((volume_id & 0x0000ff00) >> 8);
|
|
vi->volume_id[2] = (unsigned char) ((volume_id & 0x00ff0000) >> 16);
|
|
vi->volume_id[3] = (unsigned char) (volume_id >> 24);
|
|
}
|
|
|
|
if (!atari_format) {
|
|
memcpy(vi->volume_label, volume_name, 11);
|
|
|
|
memcpy(bs.boot_jump, dummy_boot_jump, 3);
|
|
/* Patch in the correct offset to the boot code */
|
|
bs.boot_jump[1] = ((size_fat == 32 ?
|
|
(char *)&bs.fat32.boot_code :
|
|
(char *)&bs.oldfat.boot_code) -
|
|
(char *)&bs) - 2;
|
|
|
|
if (size_fat == 32) {
|
|
if (dummy_boot_code[BOOTCODE_FAT32_SIZE-1])
|
|
printf ("Warning: message too long; truncated\n");
|
|
dummy_boot_code[BOOTCODE_FAT32_SIZE-1] = 0;
|
|
memcpy(bs.fat32.boot_code, dummy_boot_code, BOOTCODE_FAT32_SIZE);
|
|
}
|
|
else {
|
|
memcpy(bs.oldfat.boot_code, dummy_boot_code, BOOTCODE_SIZE);
|
|
}
|
|
bs.boot_sign = CT_LE_W(BOOT_SIGN);
|
|
}
|
|
else {
|
|
memcpy(bs.boot_jump, dummy_boot_jump_m68k, 2);
|
|
}
|
|
if (verbose >= 2)
|
|
printf( "Boot jump code is %02x %02x\n",
|
|
bs.boot_jump[0], bs.boot_jump[1] );
|
|
|
|
if (!reserved_sectors)
|
|
reserved_sectors = (size_fat == 32) ? 32 : 1;
|
|
else {
|
|
if (size_fat == 32 && reserved_sectors < 2)
|
|
die("On FAT32 at least 2 reserved sectors are needed.");
|
|
}
|
|
bs.reserved = CT_LE_W(reserved_sectors);
|
|
if (verbose >= 2)
|
|
printf( "Using %d reserved sectors\n", reserved_sectors );
|
|
bs.fats = (char) nr_fats;
|
|
if (!atari_format || size_fat == 32)
|
|
bs.hidden = CT_LE_L(0);
|
|
else
|
|
/* In Atari format, hidden is a 16 bit field */
|
|
memset( &bs.hidden, 0, 2 );
|
|
|
|
num_sectors = (ll_t)blocks*BLOCK_SIZE/sector_size;
|
|
if (!atari_format) {
|
|
unsigned fatlength12, fatlength16, fatlength32;
|
|
unsigned maxclust12, maxclust16, maxclust32;
|
|
unsigned clust12, clust16, clust32;
|
|
int maxclustsize;
|
|
|
|
fatdata = num_sectors - cdiv (root_dir_entries * 32, sector_size) -
|
|
reserved_sectors;
|
|
|
|
if (sectors_per_cluster)
|
|
bs.cluster_size = maxclustsize = sectors_per_cluster;
|
|
else
|
|
/* An initial guess for bs.cluster_size should already be set */
|
|
maxclustsize = 128;
|
|
|
|
if (verbose >= 2)
|
|
printf( "%d sectors for FAT+data, starting with %d sectors/cluster\n",
|
|
fatdata, bs.cluster_size );
|
|
do {
|
|
if (verbose >= 2)
|
|
printf( "Trying with %d sectors/cluster:\n", bs.cluster_size );
|
|
|
|
/* The factor 2 below avoids cut-off errors for nr_fats == 1.
|
|
* The "nr_fats*3" is for the reserved first two FAT entries */
|
|
clust12 = 2*((ll_t) fatdata *sector_size + nr_fats*3) /
|
|
(2*(int) bs.cluster_size * sector_size + nr_fats*3);
|
|
fatlength12 = cdiv (((clust12+2) * 3 + 1) >> 1, sector_size);
|
|
/* Need to recalculate number of clusters, since the unused parts of the
|
|
* FATS and data area together could make up space for an additional,
|
|
* not really present cluster. */
|
|
clust12 = (fatdata - nr_fats*fatlength12)/bs.cluster_size;
|
|
maxclust12 = (fatlength12 * 2 * sector_size) / 3;
|
|
if (maxclust12 > MAX_CLUST_12)
|
|
maxclust12 = MAX_CLUST_12;
|
|
if (verbose >= 2)
|
|
printf( "FAT12: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n",
|
|
clust12, fatlength12, maxclust12, MAX_CLUST_12 );
|
|
if (clust12 > maxclust12-2) {
|
|
clust12 = 0;
|
|
if (verbose >= 2)
|
|
printf( "FAT12: too much clusters\n" );
|
|
}
|
|
|
|
clust16 = ((ll_t) fatdata *sector_size + nr_fats*4) /
|
|
((int) bs.cluster_size * sector_size + nr_fats*2);
|
|
fatlength16 = cdiv ((clust16+2) * 2, sector_size);
|
|
/* Need to recalculate number of clusters, since the unused parts of the
|
|
* FATS and data area together could make up space for an additional,
|
|
* not really present cluster. */
|
|
clust16 = (fatdata - nr_fats*fatlength16)/bs.cluster_size;
|
|
maxclust16 = (fatlength16 * sector_size) / 2;
|
|
if (maxclust16 > MAX_CLUST_16)
|
|
maxclust16 = MAX_CLUST_16;
|
|
if (verbose >= 2)
|
|
printf( "FAT16: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n",
|
|
clust16, fatlength16, maxclust16, MAX_CLUST_16 );
|
|
if (clust16 > maxclust16-2) {
|
|
if (verbose >= 2)
|
|
printf( "FAT16: too much clusters\n" );
|
|
clust16 = 0;
|
|
}
|
|
/* The < 4078 avoids that the filesystem will be misdetected as having a
|
|
* 12 bit FAT. */
|
|
if (clust16 < FAT12_THRESHOLD && !(size_fat_by_user && size_fat == 16)) {
|
|
if (verbose >= 2)
|
|
printf( clust16 < FAT12_THRESHOLD ?
|
|
"FAT16: would be misdetected as FAT12\n" :
|
|
"FAT16: too much clusters\n" );
|
|
clust16 = 0;
|
|
}
|
|
|
|
clust32 = ((ll_t) fatdata *sector_size + nr_fats*8) /
|
|
((int) bs.cluster_size * sector_size + nr_fats*4);
|
|
fatlength32 = cdiv ((clust32+2) * 4, sector_size);
|
|
/* Need to recalculate number of clusters, since the unused parts of the
|
|
* FATS and data area together could make up space for an additional,
|
|
* not really present cluster. */
|
|
clust32 = (fatdata - nr_fats*fatlength32)/bs.cluster_size;
|
|
maxclust32 = (fatlength32 * sector_size) / 4;
|
|
if (maxclust32 > MAX_CLUST_32)
|
|
maxclust32 = MAX_CLUST_32;
|
|
if (verbose >= 2)
|
|
printf( "FAT32: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n",
|
|
clust32, fatlength32, maxclust32, MAX_CLUST_32 );
|
|
if (clust32 > maxclust32) {
|
|
clust32 = 0;
|
|
if (verbose >= 2)
|
|
printf( "FAT32: too much clusters\n" );
|
|
}
|
|
|
|
if ((clust12 && (size_fat == 0 || size_fat == 12)) ||
|
|
(clust16 && (size_fat == 0 || size_fat == 16)) ||
|
|
(clust32 && size_fat == 32))
|
|
break;
|
|
|
|
bs.cluster_size <<= 1;
|
|
} while (bs.cluster_size && bs.cluster_size <= maxclustsize);
|
|
|
|
/* Use the optimal FAT size if not specified;
|
|
* FAT32 is (not yet) choosen automatically */
|
|
if (!size_fat) {
|
|
size_fat = (clust16 > clust12) ? 16 : 12;
|
|
if (verbose >= 2)
|
|
printf( "Choosing %d bits for FAT\n", size_fat );
|
|
}
|
|
|
|
switch (size_fat) {
|
|
case 12:
|
|
cluster_count = clust12;
|
|
fat_length = fatlength12;
|
|
bs.fat_length = CT_LE_W(fatlength12);
|
|
memcpy(vi->fs_type, MSDOS_FAT12_SIGN, 8);
|
|
break;
|
|
|
|
case 16:
|
|
if (clust16 < FAT12_THRESHOLD) {
|
|
if (size_fat_by_user) {
|
|
fprintf( stderr, "WARNING: Not enough clusters for a "
|
|
"16 bit FAT! The filesystem will be\n"
|
|
"misinterpreted as having a 12 bit FAT without "
|
|
"mount option \"fat=16\".\n" );
|
|
}
|
|
else {
|
|
fprintf( stderr, "This filesystem has an unfortunate size. "
|
|
"A 12 bit FAT cannot provide\n"
|
|
"enough clusters, but a 16 bit FAT takes up a little "
|
|
"bit more space so that\n"
|
|
"the total number of clusters becomes less than the "
|
|
"threshold value for\n"
|
|
"distinction between 12 and 16 bit FATs.\n" );
|
|
die( "Make the file system a bit smaller manually." );
|
|
}
|
|
}
|
|
cluster_count = clust16;
|
|
fat_length = fatlength16;
|
|
bs.fat_length = CT_LE_W(fatlength16);
|
|
memcpy(vi->fs_type, MSDOS_FAT16_SIGN, 8);
|
|
break;
|
|
|
|
case 32:
|
|
cluster_count = clust32;
|
|
fat_length = fatlength32;
|
|
bs.fat_length = CT_LE_W(0);
|
|
bs.fat32.fat32_length = CT_LE_L(fatlength32);
|
|
memcpy(vi->fs_type, MSDOS_FAT32_SIGN, 8);
|
|
break;
|
|
|
|
default:
|
|
die("FAT not 12, 16 or 32 bits");
|
|
}
|
|
}
|
|
else {
|
|
unsigned clusters, maxclust;
|
|
|
|
/* GEMDOS always uses a 12 bit FAT on floppies, and always a 16 bit FAT on
|
|
* hard disks. So use 12 bit if the size of the file system suggests that
|
|
* this fs is for a floppy disk, if the user hasn't explicitly requested a
|
|
* size.
|
|
*/
|
|
if (!size_fat)
|
|
size_fat = (num_sectors == 1440 || num_sectors == 2400 ||
|
|
num_sectors == 2880 || num_sectors == 5760) ? 12 : 16;
|
|
if (verbose >= 2)
|
|
printf( "Choosing %d bits for FAT\n", size_fat );
|
|
|
|
/* Atari format: cluster size should be 2, except explicitly requested by
|
|
* the user, since GEMDOS doesn't like other cluster sizes very much.
|
|
* Instead, tune the sector size for the FS to fit.
|
|
*/
|
|
bs.cluster_size = sectors_per_cluster ? sectors_per_cluster : 2;
|
|
if (!sector_size_set) {
|
|
while( num_sectors > GEMDOS_MAX_SECTORS ) {
|
|
num_sectors >>= 1;
|
|
sector_size <<= 1;
|
|
}
|
|
}
|
|
if (verbose >= 2)
|
|
printf( "Sector size must be %d to have less than %d log. sectors\n",
|
|
sector_size, GEMDOS_MAX_SECTORS );
|
|
|
|
/* Check if there are enough FAT indices for how much clusters we have */
|
|
do {
|
|
fatdata = num_sectors - cdiv (root_dir_entries * 32, sector_size) -
|
|
reserved_sectors;
|
|
/* The factor 2 below avoids cut-off errors for nr_fats == 1 and
|
|
* size_fat == 12
|
|
* The "2*nr_fats*size_fat/8" is for the reserved first two FAT entries
|
|
*/
|
|
clusters = (2*((ll_t)fatdata*sector_size - 2*nr_fats*size_fat/8)) /
|
|
(2*((int)bs.cluster_size*sector_size + nr_fats*size_fat/8));
|
|
fat_length = cdiv( (clusters+2)*size_fat/8, sector_size );
|
|
/* Need to recalculate number of clusters, since the unused parts of the
|
|
* FATS and data area together could make up space for an additional,
|
|
* not really present cluster. */
|
|
clusters = (fatdata - nr_fats*fat_length)/bs.cluster_size;
|
|
maxclust = (fat_length*sector_size*8)/size_fat;
|
|
if (verbose >= 2)
|
|
printf( "ss=%d: #clu=%d, fat_len=%d, maxclu=%d\n",
|
|
sector_size, clusters, fat_length, maxclust );
|
|
|
|
/* last 10 cluster numbers are special (except FAT32: 4 high bits rsvd);
|
|
* first two numbers are reserved */
|
|
if (maxclust <= (size_fat == 32 ? MAX_CLUST_32 : (1<<size_fat)-0x10) &&
|
|
clusters <= maxclust-2)
|
|
break;
|
|
if (verbose >= 2)
|
|
printf( clusters > maxclust-2 ?
|
|
"Too many clusters\n" : "FAT too big\n" );
|
|
|
|
/* need to increment sector_size once more to */
|
|
if (sector_size_set)
|
|
die( "With this sector size, the maximum number of FAT entries "
|
|
"would be exceeded." );
|
|
num_sectors >>= 1;
|
|
sector_size <<= 1;
|
|
} while( sector_size <= GEMDOS_MAX_SECTOR_SIZE );
|
|
|
|
if (sector_size > GEMDOS_MAX_SECTOR_SIZE)
|
|
die( "Would need a sector size > 16k, which GEMDOS can't work with");
|
|
|
|
cluster_count = clusters;
|
|
if (size_fat != 32)
|
|
bs.fat_length = CT_LE_W(fat_length);
|
|
else {
|
|
bs.fat_length = 0;
|
|
bs.fat32.fat32_length = CT_LE_L(fat_length);
|
|
}
|
|
}
|
|
|
|
bs.sector_size[0] = (char) (sector_size & 0x00ff);
|
|
bs.sector_size[1] = (char) ((sector_size & 0xff00) >> 8);
|
|
|
|
if (size_fat == 32)
|
|
{
|
|
/* set up additional FAT32 fields */
|
|
bs.fat32.flags = CT_LE_W(0);
|
|
bs.fat32.version[0] = 0;
|
|
bs.fat32.version[1] = 0;
|
|
bs.fat32.root_cluster = CT_LE_L(2);
|
|
bs.fat32.info_sector = CT_LE_W(1);
|
|
if (!backup_boot)
|
|
backup_boot = (reserved_sectors >= 7) ? 6 :
|
|
(reserved_sectors >= 2) ? reserved_sectors-1 : 0;
|
|
else
|
|
{
|
|
if (backup_boot == 1)
|
|
die("Backup boot sector must be after sector 1");
|
|
else if (backup_boot >= reserved_sectors)
|
|
die("Backup boot sector must be a reserved sector");
|
|
}
|
|
if (verbose >= 2)
|
|
printf( "Using sector %d as backup boot sector (0 = none)\n",
|
|
backup_boot );
|
|
bs.fat32.backup_boot = CT_LE_W(backup_boot);
|
|
memset( &bs.fat32.reserved2, 0, sizeof(bs.fat32.reserved2) );
|
|
}
|
|
|
|
if (atari_format) {
|
|
/* Just some consistency checks */
|
|
if (num_sectors >= GEMDOS_MAX_SECTORS)
|
|
die( "GEMDOS can't handle more than 65531 sectors" );
|
|
else if (num_sectors >= OLDGEMDOS_MAX_SECTORS)
|
|
printf( "Warning: More than 32765 sector need TOS 1.04 "
|
|
"or higher.\n" );
|
|
}
|
|
if (num_sectors >= 65536)
|
|
{
|
|
bs.sectors[0] = (char) 0;
|
|
bs.sectors[1] = (char) 0;
|
|
bs.total_sect = CT_LE_L(num_sectors);
|
|
}
|
|
else
|
|
{
|
|
bs.sectors[0] = (char) (num_sectors & 0x00ff);
|
|
bs.sectors[1] = (char) ((num_sectors & 0xff00) >> 8);
|
|
if (!atari_format)
|
|
bs.total_sect = CT_LE_L(0);
|
|
}
|
|
|
|
if (!atari_format)
|
|
vi->ext_boot_sign = MSDOS_EXT_SIGN;
|
|
|
|
if (!cluster_count)
|
|
{
|
|
if (sectors_per_cluster) /* If yes, die if we'd spec'd sectors per cluster */
|
|
die ("Too many clusters for file system - try more sectors per cluster");
|
|
else
|
|
die ("Attempting to create a too large file system");
|
|
}
|
|
|
|
|
|
/* The two following vars are in hard sectors, i.e. 512 byte sectors! */
|
|
start_data_sector = (reserved_sectors + nr_fats * fat_length) *
|
|
(sector_size/HARD_SECTOR_SIZE);
|
|
start_data_block = (start_data_sector + SECTORS_PER_BLOCK - 1) /
|
|
SECTORS_PER_BLOCK;
|
|
|
|
if (blocks < start_data_block + 32) /* Arbitrary undersize file system! */
|
|
die ("Too few blocks for viable file system");
|
|
|
|
if (verbose)
|
|
{
|
|
printf("%s has %d head%s and %d sector%s per track,\n",
|
|
device_name, CF_LE_W(bs.heads), (CF_LE_W(bs.heads) != 1) ? "s" : "",
|
|
CF_LE_W(bs.secs_track), (CF_LE_W(bs.secs_track) != 1) ? "s" : "");
|
|
printf("logical sector size is %d,\n",sector_size);
|
|
printf("using 0x%02x media descriptor, with %d sectors;\n",
|
|
(int) (bs.media), num_sectors);
|
|
printf("file system has %d %d-bit FAT%s and %d sector%s per cluster.\n",
|
|
(int) (bs.fats), size_fat, (bs.fats != 1) ? "s" : "",
|
|
(int) (bs.cluster_size), (bs.cluster_size != 1) ? "s" : "");
|
|
printf ("FAT size is %d sector%s, and provides %d cluster%s.\n",
|
|
fat_length, (fat_length != 1) ? "s" : "",
|
|
cluster_count, (cluster_count != 1) ? "s" : "");
|
|
if (size_fat != 32)
|
|
printf ("Root directory contains %d slots.\n",
|
|
(int) (bs.dir_entries[0]) + (int) (bs.dir_entries[1]) * 256);
|
|
printf ("Volume ID is %08lx, ", volume_id &
|
|
(atari_format ? 0x00ffffff : 0xffffffff));
|
|
if ( strcmp(volume_name, " ") )
|
|
printf("volume label %s.\n", volume_name);
|
|
else
|
|
printf("no volume label.\n");
|
|
}
|
|
|
|
/* Make the file allocation tables! */
|
|
|
|
if ((fat = (unsigned char *) malloc (fat_length * sector_size)) == NULL)
|
|
die ("unable to allocate space for FAT image in memory");
|
|
|
|
memset( fat, 0, fat_length * sector_size );
|
|
|
|
mark_FAT_cluster (0, 0xffffffff); /* Initial fat entries */
|
|
mark_FAT_cluster (1, 0xffffffff);
|
|
fat[0] = (unsigned char) bs.media; /* Put media type in first byte! */
|
|
if (size_fat == 32) {
|
|
/* Mark cluster 2 as EOF (used for root dir) */
|
|
mark_FAT_cluster (2, FAT_EOF);
|
|
}
|
|
|
|
/* Make the root directory entries */
|
|
|
|
size_root_dir = (size_fat == 32) ?
|
|
bs.cluster_size*sector_size :
|
|
(((int)bs.dir_entries[1]*256+(int)bs.dir_entries[0]) *
|
|
sizeof (struct msdos_dir_entry));
|
|
if ((root_dir = (struct msdos_dir_entry *) malloc (size_root_dir)) == NULL)
|
|
{
|
|
free (fat); /* Tidy up before we die! */
|
|
die ("unable to allocate space for root directory in memory");
|
|
}
|
|
|
|
memset(root_dir, 0, size_root_dir);
|
|
if ( memcmp(volume_name, " ", 11) )
|
|
{
|
|
struct msdos_dir_entry *de = &root_dir[0];
|
|
memcpy(de->name, volume_name, 11);
|
|
de->attr = ATTR_VOLUME;
|
|
ctime = localtime(&create_time);
|
|
de->time = CT_LE_W((unsigned short)((ctime->tm_sec >> 1) +
|
|
(ctime->tm_min << 5) + (ctime->tm_hour << 11)));
|
|
de->date = CT_LE_W((unsigned short)(ctime->tm_mday +
|
|
((ctime->tm_mon+1) << 5) +
|
|
((ctime->tm_year-80) << 9)));
|
|
de->ctime_ms = 0;
|
|
de->ctime = de->time;
|
|
de->cdate = de->date;
|
|
de->adate = de->date;
|
|
de->starthi = CT_LE_W(0);
|
|
de->start = CT_LE_W(0);
|
|
de->size = CT_LE_L(0);
|
|
}
|
|
|
|
if (size_fat == 32) {
|
|
/* For FAT32, create an info sector */
|
|
struct fat32_fsinfo *info;
|
|
|
|
if (!(info_sector = malloc( sector_size )))
|
|
die("Out of memory");
|
|
memset(info_sector, 0, sector_size);
|
|
/* fsinfo structure is at offset 0x1e0 in info sector by observation */
|
|
info = (struct fat32_fsinfo *)(info_sector + 0x1e0);
|
|
|
|
/* Info sector magic */
|
|
info_sector[0] = 'R';
|
|
info_sector[1] = 'R';
|
|
info_sector[2] = 'a';
|
|
info_sector[3] = 'A';
|
|
|
|
/* Magic for fsinfo structure */
|
|
info->signature = CT_LE_L(0x61417272);
|
|
/* We've allocated cluster 2 for the root dir. */
|
|
info->free_clusters = CT_LE_L(cluster_count - 1);
|
|
info->next_cluster = CT_LE_L(2);
|
|
|
|
/* Info sector also must have boot sign */
|
|
*(__u16 *)(info_sector + 0x1fe) = CT_LE_W(BOOT_SIGN);
|
|
}
|
|
|
|
if (!(blank_sector = malloc( sector_size )))
|
|
die( "Out of memory" );
|
|
memset(blank_sector, 0, sector_size);
|
|
}
|
|
|
|
|
|
/* Write the new filesystem's data tables to wherever they're going to end up! */
|
|
|
|
#define error(str) \
|
|
do { \
|
|
free (fat); \
|
|
if (info_sector) free (info_sector); \
|
|
free (root_dir); \
|
|
die (str); \
|
|
} while(0)
|
|
|
|
#define seekto(pos,errstr) \
|
|
do { \
|
|
loff_t __pos = (pos); \
|
|
if (llseek (dev, __pos, SEEK_SET) != __pos) \
|
|
error ("seek to " errstr " failed whilst writing tables"); \
|
|
} while(0)
|
|
|
|
#define writebuf(buf,size,errstr) \
|
|
do { \
|
|
int __size = (size); \
|
|
if (write (dev, buf, __size) != __size) \
|
|
error ("failed whilst writing " errstr); \
|
|
} while(0)
|
|
|
|
|
|
static void
|
|
write_tables (void)
|
|
{
|
|
int x;
|
|
int fat_length;
|
|
#ifdef _WIN32
|
|
int blk;
|
|
#endif
|
|
|
|
fat_length = (size_fat == 32) ?
|
|
CF_LE_L(bs.fat32.fat32_length) : CF_LE_W(bs.fat_length);
|
|
|
|
seekto( 0, "start of device" );
|
|
/* clear all reserved sectors */
|
|
for( x = 0; x < reserved_sectors; ++x )
|
|
writebuf( blank_sector, sector_size, "reserved sector" );
|
|
/* seek back to sector 0 and write the boot sector */
|
|
seekto( 0, "boot sector" );
|
|
writebuf( (char *) &bs, sizeof (struct msdos_boot_sector), "boot sector" );
|
|
/* on FAT32, write the info sector and backup boot sector */
|
|
if (size_fat == 32)
|
|
{
|
|
seekto( CF_LE_W(bs.fat32.info_sector)*sector_size, "info sector" );
|
|
writebuf( info_sector, 512, "info sector" );
|
|
if (backup_boot != 0)
|
|
{
|
|
seekto( backup_boot*sector_size, "backup boot sector" );
|
|
writebuf( (char *) &bs, sizeof (struct msdos_boot_sector),
|
|
"backup boot sector" );
|
|
}
|
|
}
|
|
/* seek to start of FATS and write them all */
|
|
seekto( reserved_sectors*sector_size, "first FAT" );
|
|
for (x = 1; x <= nr_fats; x++)
|
|
#ifdef _WIN32
|
|
/*
|
|
* WIN32 appearently has problems writing very large chunks directly
|
|
* to disk devices. To not produce errors because of resource shortages
|
|
* split up the write in sector size chunks.
|
|
*/
|
|
for (blk = 0; blk < fat_length; blk++)
|
|
writebuf(fat+blk*sector_size, sector_size, "FAT");
|
|
#else
|
|
writebuf( fat, fat_length * sector_size, "FAT" );
|
|
#endif
|
|
/* Write the root directory directly after the last FAT. This is the root
|
|
* dir area on FAT12/16, and the first cluster on FAT32. */
|
|
writebuf( (char *) root_dir, size_root_dir, "root directory" );
|
|
|
|
if (info_sector) free( info_sector );
|
|
free (root_dir); /* Free up the root directory space from setup_tables */
|
|
free (fat); /* Free up the fat table space reserved during setup_tables */
|
|
}
|
|
|
|
|
|
/* Report the command usage and return a failure error code */
|
|
|
|
void
|
|
usage (void)
|
|
{
|
|
fatal_error("\
|
|
Usage: mkdosfs [-A] [-c] [-C] [-v] [-I] [-l bad-block-file] [-b backup-boot-sector]\n\
|
|
[-m boot-msg-file] [-n volume-name] [-i volume-id]\n\
|
|
[-s sectors-per-cluster] [-S logical-sector-size] [-f number-of-FATs]\n\
|
|
[-F fat-size] [-r root-dir-entries] [-R reserved-sectors]\n\
|
|
/dev/name [blocks]\n");
|
|
}
|
|
|
|
/*
|
|
* ++roman: On m68k, check if this is an Atari; if yes, turn on Atari variant
|
|
* of MS-DOS filesystem by default.
|
|
*/
|
|
static void check_atari( void )
|
|
{
|
|
#ifdef __mc68000__
|
|
FILE *f;
|
|
char line[128], *p;
|
|
|
|
if (!(f = fopen( "/proc/hardware", "r" ))) {
|
|
perror( "/proc/hardware" );
|
|
return;
|
|
}
|
|
|
|
while( fgets( line, sizeof(line), f ) ) {
|
|
if (strncmp( line, "Model:", 6 ) == 0) {
|
|
p = line + 6;
|
|
p += strspn( p, " \t" );
|
|
if (strncmp( p, "Atari ", 6 ) == 0)
|
|
atari_format = 1;
|
|
break;
|
|
}
|
|
}
|
|
fclose( f );
|
|
#endif
|
|
}
|
|
|
|
/* The "main" entry point into the utility - we pick up the options and attempt to process them in some sort of sensible
|
|
way. In the event that some/all of the options are invalid we need to tell the user so that something can be done! */
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
int c;
|
|
char *tmp;
|
|
char *listfile = NULL;
|
|
FILE *msgfile;
|
|
#ifdef _WIN32
|
|
static char dev_buf[] = "\\\\.\\X:";
|
|
#else
|
|
struct stat statbuf;
|
|
#endif
|
|
int i = 0, pos, ch;
|
|
int create = 0;
|
|
|
|
if (argc && *argv) { /* What's the program name? */
|
|
char *p;
|
|
program_name = *argv;
|
|
#ifdef _WIN32
|
|
if ((p = strrchr( program_name, '\\' )))
|
|
#else
|
|
if ((p = strrchr( program_name, '/' )))
|
|
#endif
|
|
program_name = p+1;
|
|
}
|
|
|
|
time(&create_time);
|
|
volume_id = (long)create_time; /* Default volume ID = creation time */
|
|
check_atari();
|
|
|
|
printf ("%s " VERSION " (" VERSION_DATE ")\n"
|
|
#ifdef _WIN32
|
|
"Win32 port by Jens-Uwe Mager <jum@anubis.han.de>\n"
|
|
#endif
|
|
, program_name);
|
|
|
|
while ((c = getopt (argc, argv, "AcCf:F:Ii:l:m:n:r:R:s:S:v")) != EOF)
|
|
/* Scan the command line for options */
|
|
switch (c)
|
|
{
|
|
case 'A': /* toggle Atari format */
|
|
atari_format = !atari_format;
|
|
break;
|
|
|
|
case 'b': /* b : location of backup boot sector */
|
|
backup_boot = (int) strtol (optarg, &tmp, 0);
|
|
if (*tmp || backup_boot < 2 || backup_boot > 0xffff)
|
|
{
|
|
printf ("Bad location for backup boot sector : %s\n", optarg);
|
|
usage ();
|
|
}
|
|
break;
|
|
|
|
case 'c': /* c : Check FS as we build it */
|
|
check = TRUE;
|
|
break;
|
|
|
|
case 'C': /* C : Create a new file */
|
|
create = TRUE;
|
|
break;
|
|
|
|
case 'f': /* f : Choose number of FATs */
|
|
nr_fats = (int) strtol (optarg, &tmp, 0);
|
|
if (*tmp || nr_fats < 1 || nr_fats > 4)
|
|
{
|
|
printf ("Bad number of FATs : %s\n", optarg);
|
|
usage ();
|
|
}
|
|
break;
|
|
|
|
case 'F': /* F : Choose FAT size */
|
|
size_fat = (int) strtol (optarg, &tmp, 0);
|
|
if (*tmp || (size_fat != 12 && size_fat != 16 && size_fat != 32))
|
|
{
|
|
printf ("Bad FAT type : %s\n", optarg);
|
|
usage ();
|
|
}
|
|
size_fat_by_user = 1;
|
|
break;
|
|
|
|
case 'I':
|
|
ignore_full_disk = 1;
|
|
break;
|
|
|
|
case 'i': /* i : specify volume ID */
|
|
volume_id = strtol(optarg, &tmp, 16);
|
|
if ( *tmp )
|
|
{
|
|
printf("Volume ID must be a hexadecimal number\n");
|
|
usage();
|
|
}
|
|
break;
|
|
|
|
case 'l': /* l : Bad block filename */
|
|
listfile = optarg;
|
|
break;
|
|
|
|
case 'm': /* m : Set boot message */
|
|
if ( strcmp(optarg, "-") )
|
|
{
|
|
msgfile = fopen(optarg, "r");
|
|
if ( !msgfile )
|
|
perror(optarg);
|
|
}
|
|
else
|
|
msgfile = stdin;
|
|
|
|
if ( msgfile )
|
|
{
|
|
/* The boot code ends at offset 448 and needs a null terminator */
|
|
i = MESSAGE_OFFSET;
|
|
pos = 0; /* We are at beginning of line */
|
|
do
|
|
{
|
|
ch = getc(msgfile);
|
|
switch (ch)
|
|
{
|
|
case '\r': /* Ignore CRs */
|
|
case '\0': /* and nulls */
|
|
break;
|
|
|
|
case '\n': /* LF -> CR+LF if necessary */
|
|
if ( pos ) /* If not at beginning of line */
|
|
{
|
|
dummy_boot_code[i++] = '\r';
|
|
pos = 0;
|
|
}
|
|
dummy_boot_code[i++] = '\n';
|
|
break;
|
|
|
|
case '\t': /* Expand tabs */
|
|
do
|
|
{
|
|
dummy_boot_code[i++] = ' ';
|
|
pos++;
|
|
}
|
|
while ( pos % 8 && i < BOOTCODE_SIZE-1 );
|
|
break;
|
|
|
|
case EOF:
|
|
dummy_boot_code[i++] = '\0'; /* Null terminator */
|
|
break;
|
|
|
|
default:
|
|
dummy_boot_code[i++] = ch; /* Store character */
|
|
pos++; /* Advance position */
|
|
break;
|
|
}
|
|
}
|
|
while ( ch != EOF && i < BOOTCODE_SIZE-1 );
|
|
|
|
/* Fill up with zeros */
|
|
while( i < BOOTCODE_SIZE-1 )
|
|
dummy_boot_code[i++] = '\0';
|
|
dummy_boot_code[BOOTCODE_SIZE-1] = '\0'; /* Just in case */
|
|
|
|
if ( ch != EOF )
|
|
printf ("Warning: message too long; truncated\n");
|
|
|
|
if ( msgfile != stdin )
|
|
fclose(msgfile);
|
|
}
|
|
break;
|
|
|
|
case 'n': /* n : Volume name */
|
|
sprintf(volume_name, "%-11.11s", optarg);
|
|
break;
|
|
|
|
case 'r': /* r : Root directory entries */
|
|
root_dir_entries = (int) strtol (optarg, &tmp, 0);
|
|
if (*tmp || root_dir_entries < 16 || root_dir_entries > 32768)
|
|
{
|
|
printf ("Bad number of root directory entries : %s\n", optarg);
|
|
usage ();
|
|
}
|
|
break;
|
|
|
|
case 'R': /* R : number of reserved sectors */
|
|
reserved_sectors = (int) strtol (optarg, &tmp, 0);
|
|
if (*tmp || reserved_sectors < 1 || reserved_sectors > 0xffff)
|
|
{
|
|
printf ("Bad number of reserved sectors : %s\n", optarg);
|
|
usage ();
|
|
}
|
|
break;
|
|
|
|
case 's': /* s : Sectors per cluster */
|
|
sectors_per_cluster = (int) strtol (optarg, &tmp, 0);
|
|
if (*tmp || (sectors_per_cluster != 1 && sectors_per_cluster != 2
|
|
&& sectors_per_cluster != 4 && sectors_per_cluster != 8
|
|
&& sectors_per_cluster != 16 && sectors_per_cluster != 32
|
|
&& sectors_per_cluster != 64 && sectors_per_cluster != 128))
|
|
{
|
|
printf ("Bad number of sectors per cluster : %s\n", optarg);
|
|
usage ();
|
|
}
|
|
break;
|
|
|
|
case 'S': /* S : Sector size */
|
|
sector_size = (int) strtol (optarg, &tmp, 0);
|
|
if (*tmp || (sector_size != 512 && sector_size != 1024 &&
|
|
sector_size != 2048 && sector_size != 4096 &&
|
|
sector_size != 8192 && sector_size != 16384 &&
|
|
sector_size != 32768))
|
|
{
|
|
printf ("Bad logical sector size : %s\n", optarg);
|
|
usage ();
|
|
}
|
|
sector_size_set = 1;
|
|
break;
|
|
|
|
case 'v': /* v : Verbose execution */
|
|
++verbose;
|
|
break;
|
|
|
|
default:
|
|
printf( "Unknown option: %c\n", c );
|
|
usage ();
|
|
}
|
|
|
|
if (optind >= argc)
|
|
usage();
|
|
device_name = argv[optind]; /* Determine the number of blocks in the FS */
|
|
#ifdef _WIN32
|
|
if (device_name[1] == ':' && device_name[2] == '\0') {
|
|
dev_buf[4] = device_name[0];
|
|
device_name = dev_buf;
|
|
is_device = 1;
|
|
}
|
|
#endif
|
|
if (!create)
|
|
i = count_blocks (device_name); /* Have a look and see! */
|
|
if (optind == argc - 2) /* Either check the user specified number */
|
|
{
|
|
blocks = (int) strtol (argv[optind + 1], &tmp, 0);
|
|
if (!create && blocks != i)
|
|
{
|
|
fprintf (stderr, "Warning: block count mismatch: ");
|
|
fprintf (stderr, "found %d but assuming %d.\n",i,blocks);
|
|
}
|
|
}
|
|
else if (optind == argc - 1) /* Or use value found */
|
|
{
|
|
if (create)
|
|
die( "Need intended size with -C." );
|
|
blocks = i;
|
|
tmp = "";
|
|
}
|
|
else
|
|
usage ();
|
|
if (*tmp)
|
|
{
|
|
printf ("Bad block count : %s\n", argv[optind + 1]);
|
|
usage ();
|
|
}
|
|
|
|
if (check && listfile) /* Auto and specified bad block handling are mutually */
|
|
die ("-c and -l are incompatible"); /* exclusive of each other! */
|
|
|
|
if (!create) {
|
|
check_mount (device_name); /* Is the device already mounted? */
|
|
dev = open (device_name, O_RDWR|O_SHARED); /* Is it a suitable device to build the FS on? */
|
|
if (dev < 0)
|
|
die ("unable to open %s");
|
|
#ifdef _WIN32
|
|
if (is_device) {
|
|
if (fsctl(dev, FSCTL_LOCK_VOLUME) == -1)
|
|
die("unable to lock %s");
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
loff_t offset = blocks*BLOCK_SIZE - 1;
|
|
char null = 0;
|
|
/* create the file */
|
|
dev = open( device_name, O_RDWR|O_CREAT|O_TRUNC, 0775 );
|
|
if (dev < 0)
|
|
die("unable to create %s");
|
|
/* seek to the intended end-1, and write one byte. this creates a
|
|
* sparse-as-possible file of appropriate size. */
|
|
if (llseek( dev, offset, SEEK_SET ) != offset)
|
|
die( "seek failed" );
|
|
if (write( dev, &null, 1 ) < 0)
|
|
die( "write failed" );
|
|
if (llseek( dev, 0, SEEK_SET ) != 0)
|
|
die( "seek failed" );
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
if (!is_device)
|
|
check = 0;
|
|
establish_params();
|
|
#else
|
|
if (fstat (dev, &statbuf) < 0)
|
|
die ("unable to stat %s");
|
|
if (!S_ISBLK (statbuf.st_mode)) {
|
|
statbuf.st_rdev = 0;
|
|
check = 0;
|
|
}
|
|
else
|
|
/*
|
|
* Ignore any 'full' fixed disk devices, if -I is not given.
|
|
* On a MO-disk one doesn't need partitions. The filesytem can go
|
|
* directly to the whole disk. Under other OSes this is known as
|
|
* the 'superfloppy' format. As I don't know how to find out if
|
|
* this is a MO disk I introduce a -I (ignore) switch. -Joey
|
|
*/
|
|
if (!ignore_full_disk && (
|
|
(statbuf.st_rdev & 0xff3f) == 0x0300 || /* hda, hdb */
|
|
(statbuf.st_rdev & 0xff0f) == 0x0800 || /* sd */
|
|
(statbuf.st_rdev & 0xff3f) == 0x0d00 || /* xd */
|
|
(statbuf.st_rdev & 0xff3f) == 0x1600 ) /* hdc, hdd */
|
|
)
|
|
die ("Will not try to make filesystem on '%s'");
|
|
|
|
establish_params (statbuf.st_rdev,statbuf.st_size);
|
|
/* Establish the media parameters */
|
|
#endif
|
|
|
|
setup_tables (); /* Establish the file system tables */
|
|
|
|
if (check) /* Determine any bad block locations and mark them */
|
|
check_blocks ();
|
|
else if (listfile)
|
|
get_list_blocks (listfile);
|
|
|
|
write_tables (); /* Write the file system tables away! */
|
|
|
|
#ifdef _WIN32
|
|
if (is_device) {
|
|
if (fsctl(dev, FSCTL_DISMOUNT_VOLUME) == -1)
|
|
die("unable to dismount %s");
|
|
if (fsctl(dev, FSCTL_UNLOCK_VOLUME) == -1)
|
|
die("unable to unlock %s");
|
|
}
|
|
#endif
|
|
exit (0); /* Terminate with no errors! */
|
|
}
|
|
|
|
|
|
/* That's All Folks */
|
|
/* Local Variables: */
|
|
/* tab-width: 8 */
|
|
/* End: */
|