/*
** Sizeable RAMDisk formatter
** Version 1.10
**
** Compiled with Turbo C++ 1.0
**
** Released to PUBLIC DOMAIN by author Marko Kohtala 1991
**
** Some documentation available in accompanying file SRDISK.DOC.
** If not, contact author by sending E-mail from
**
** Internet, Bitnet etc. to 'mkohtala@niksula.hut.fi'
** CompuServe to '>INTERNET:mkohtala@niksula.hut.fi'
**
** or by calling Airline QBBS, 24H, HST, V.32, V.42, MNP,
** +358-0-8725380, and leaving mail to me, Marko Kohtala.
*/
#define VERSION "1.10"
/* History
**
** 1.00 09-06-91 Initial release
** 1.10 06-09-91 Added full support for multiple FATs. 1.00 had the /F
** switch, but no support for it in formatter. Updated to
** IOCTL_msg versio 1.10 so that media byte is no longer
** used to indicate the media change but to indicate the
** drive is RAM disk. Some minor fixes.
*/
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <dir.h>
#include <dos.h>
#include <string.h>
/* IOCTL_msg exchanged with ramdrive (byte aligned) */
#pragma option -a-
#pragma pack(1)
const struct IOCTL_msg_hdr_s { /* Header of the structure for comparison */
unsigned short len; /* The size of the structure */
char unused; /* A byte to make it look like boot sector */
char OEM[8]; /* OEM and structure version number */
};
struct IOCTL_msg_s { /* The whole structure */
struct IOCTL_msg_hdr_s hdr;
unsigned short bytes_per_sector;
unsigned char sectors_per_cluster;
unsigned short reserved_sectors;
unsigned char FATs; /* Number of FATs on disk */
unsigned short dir_entries; /* Root directory entries */
unsigned short sectors; /* Total number of sectors on disk */
unsigned char media; /* Identifies the media (default 0xFA) */
unsigned short FAT_sectors; /* Sectors in one copy of FAT */
unsigned short disk_size; /* Disk size in kilobytes */
char volume[12]; /* This is returned in the Check Media call */
unsigned char RW_access;
signed char media_change; /* -1 if media changed, 1 if not */
unsigned short open_files; /* These last two are not accepted in the */
int (far *IO_entry)(void); /* driver but must be sent anyway */
} IOCTL_msg;
#define READ_ACCESS 1 /* Bit masks for RW_access in IOCTL_msg_s */
#define WRITE_ACCESS 2
#pragma pack()
#pragma option -a
struct IOCTL_msg_hdr_s IOCTL_msg_hdr =
{
sizeof (struct IOCTL_msg_s),
0x90,
"SRD 1.10"
};
/* Variables possibly supplied in command line */
int drive=0;
int format_f=0; /* Nonzero if new format given */
int force_f=0; /* Nonzero if ok to format */
enum {same, set, clear} write_f = same; /* Write protect flag */
int disk_size=-1; /* Size in kilobytes, -1 not set */
int sector_size=-1; /* Sector size, -1 not set */
int cluster_size=-1; /* Allocation unit size, -1 not set */
int dir_entries=-1; /* Directory entries in root directory, -1 not set */
int FATs=-1; /* FAT copies on the disk */
/*
** SYNTAX
*/
void print_syntax(void)
{
fprintf(stderr,
"Syntax: SRDISK [<drive letter>[:]] [<size>] [S:<sector size>]\n"
"\t\t[C:<cluster size>] [D:<dir entries>] [F:<FAT copies>]\n"
"\t\t[/W[-]] [/Y]\n\n"
"Cluster and sector sizes may be one of 128, 256, 512, 1024, 2048 or 4096.\n"
"The following switches may remain unclear from the above:\n\n"
"\t/W[-] Write protect disk, /W- enables writes\n"
"\t/Y Yes, to all queries i.e. no talking, just do it\n"
"\n");
}
/*
** ERROR HANDLING FUNCTIONS
*/
void syntax(char *err)
{
fprintf(stderr, "Syntax error: %s\n\n", err);
print_syntax();
exit(3);
}
void fatal(char *err)
{
fprintf(stderr, "Fatal error: %s\n\n", err);
exit(1);
}
void error(char *err)
{
fprintf(stderr, "Error: %s\n\n", err);
return;
}
/*
** COMMAND LINE PARSER
*/
int parse_narg(char *argp, char **next)
{
int res;
if (*argp == ':') argp++;
res = strtol(argp, next, 10);
if (argp == *next) return -1;
return res;
}
int test_sec_size(int size)
{
switch(size) {
case 128:
case 256:
case 512:
case 1024:
case 2048:
case 4096:
return 0; /* Return 0 for good size */
default:
return 1; /* Return 1 for bad size */
}
}
void parse_cmdline(int argc, char *argv[])
{
int arg;
char *argp;
for(arg=1; arg < argc; arg++) {
argp = argv[arg];
while(*argp) {
if (*argp == '/' || *argp == '-') {
argp++;
switch(toupper(*argp++)) {
case '?':
case 'H':
print_syntax();
exit(0);
case 'W':
switch(*argp) {
case '-': argp++;
write_f = clear;
break;
case '+': argp++;
default: write_f = set;
}
break;
case 'Y':
force_f++;
break;
case 'S': /* Sector size */
sector_size = parse_narg(argp, &argp);
if (test_sec_size(sector_size)) syntax("Invalid sector size");
format_f++;
break;
case 'C': /* Cluster size */
cluster_size = parse_narg(argp, &argp);
if (test_sec_size(cluster_size)) syntax("Invalid cluster size");
format_f++;
break;
case 'D': /* Directory entries */
dir_entries = parse_narg(argp, &argp);
if (dir_entries < -1 || !dir_entries || dir_entries == 1
|| dir_entries > 1000)
syntax("Invalid number of directory entries");
format_f++;
break;
case 'F': /* FATs */
FATs = parse_narg(argp, &argp);
if (FATs < -1 || !FATs)
syntax("Invalid number of FAT copies");
format_f++;
break;
default:
syntax("Unknown switch");
}
}
else {
if (*argp == ' ' || *argp == '\t') argp++;
else if (isdigit(*argp)) {
disk_size = strtol(argp, &argp, 10);
if (disk_size < 0 || disk_size > 32767)
syntax("Invalid disk size");
format_f++;
}
else {
if (drive) syntax("Unrecognised character on command line");
drive = toupper(*argp++)-'A'+1;
if (drive < 1 || drive > 'Z'-'A'+1) syntax("Invalid drive");
if (*argp == ':') argp++;
}
}
}
}
}
/*
** IOCTL messages
*/
void read_IOCTL_msg(void)
{
if (ioctl(drive, 4, &IOCTL_msg, sizeof IOCTL_msg) != sizeof IOCTL_msg
|| memcmp(&IOCTL_msg, &IOCTL_msg_hdr, sizeof IOCTL_msg_hdr))
fatal("Drive not proper Sizeable RAMDisk");
}
int write_IOCTL_msg(void)
{
if (ioctl(drive, 5, &IOCTL_msg, sizeof (struct IOCTL_msg_s))
!= sizeof (struct IOCTL_msg_s))
{
error("RAMDisk driver won't accept new setup");
return 1;
}
return 0;
}
void print_IOCTL_msg()
{
int cluster_size = IOCTL_msg.bytes_per_sector * IOCTL_msg.sectors_per_cluster;
int dir_sectors = IOCTL_msg.dir_entries * 32 / IOCTL_msg.bytes_per_sector;
int clusters = (IOCTL_msg.sectors - IOCTL_msg.reserved_sectors
- IOCTL_msg.FAT_sectors * IOCTL_msg.FATs - dir_sectors)
/ IOCTL_msg.sectors_per_cluster;
printf(" Disk size: %iK\n"
" Cluster size: %i bytes\n"
" Sector size: %i bytes\n"
" Directory entries: %i\n"
" FAT copies: %i\n"
" Bytes available: %li\n"
" Write protection: %s\n"
#ifdef VERBOSE
" Sectors: %i\n"
" Reserved sectors: %i\n"
" FAT sectors: %i\n"
" Directory sectors: %i\n"
" Sectors per cluster: %i\n"
" Clusters: %i\n"
#endif
"\n"
,IOCTL_msg.disk_size
,cluster_size
,IOCTL_msg.bytes_per_sector
,IOCTL_msg.dir_entries
,IOCTL_msg.FATs
,(long)clusters*cluster_size
,((IOCTL_msg.RW_access & WRITE_ACCESS) ? "OFF" : "ON")
#ifdef VERBOSE
,IOCTL_msg.sectors
,IOCTL_msg.reserved_sectors
,IOCTL_msg.FAT_sectors
,dir_sectors
,IOCTL_msg.sectors_per_cluster
,clusters
#endif
);
}
/*
** Write sectors to disk
**
** Return 0 for success and 1 for failure
*/
int write_sector(int count, int start, void *buffer)
{
if (!IOCTL_msg.IO_entry) fatal("Internal error writing sector");
_BH = 1; /* Write */
_CX = count;
_DX = start;
_ES = FP_SEG(buffer);
_DI = FP_OFF(buffer);
return IOCTL_msg.IO_entry();
}
/*
** INITIALIZE DRIVE
*/
void init_drive(void)
{
read_IOCTL_msg();
if (!force_f) {
if (IOCTL_msg.disk_size) {
printf("Current configuration for drive %c:\n\n", drive-1+'A');
print_IOCTL_msg();
}
else
printf("Drive %c: disabled\n\n", drive-1+'A');
}
}
/*
** SET WRITE PROTECT
*/
void set_write_protect()
{
switch(write_f) {
case set:
IOCTL_msg.RW_access &= ~WRITE_ACCESS;
if (!write_IOCTL_msg())
printf("Write protect enabled\n\n");
break;
case clear:
IOCTL_msg.RW_access |= WRITE_ACCESS;
if (!write_IOCTL_msg())
printf("Write protect disabled\n\n");
break;
}
}
/*
** FORMAT DISK
*/
int getYN(void)
{
int reply;
if (force_f) reply = 'Y';
else {
do reply = toupper(getch());
while (reply != 'Y' && reply != 'N');
}
printf("%c\n\n", reply);
if (reply == 'N') return 0;
return 1;
}
int licence_to_kill(void)
{
if (!force_f) {
int reply;
printf("\aAbout to destroy all files on drive %c!\n\a"
"Continue (Y/N) ? ", drive-1+'A');
if (!getYN()) {
printf("\nOperation aborted\n\n");
return 0;
}
}
return 1;
}
void format_disk(void)
{
unsigned short old_disk_size = IOCTL_msg.disk_size;
unsigned short FAT_sectors;
unsigned short data_sectors;
unsigned short system_sectors;
unsigned short clusters;
unsigned short dir_start;
unsigned short dir_sectors;
unsigned long sectors;
ldiv_t ldivr;
int Fsec;
int i;
void *sector;
if (!force_f && IOCTL_msg.open_files) {
error("Files open on drive");
return;
}
/* Check disk configuration for changes */
if (disk_size != -1)
IOCTL_msg.disk_size = disk_size;
if (cluster_size == -1) {
cluster_size = IOCTL_msg.bytes_per_sector * IOCTL_msg.sectors_per_cluster;
} else {
if (cluster_size < IOCTL_msg.bytes_per_sector)
cluster_size = IOCTL_msg.bytes_per_sector;
IOCTL_msg.sectors_per_cluster = cluster_size / IOCTL_msg.bytes_per_sector;
}
if (sector_size != -1)
IOCTL_msg.bytes_per_sector = sector_size;
if (dir_entries != -1)
IOCTL_msg.dir_entries = dir_entries;
if (FATs != -1)
IOCTL_msg.FATs = FATs;
/* If Disk will be disabled */
if (!IOCTL_msg.disk_size) {
if (!old_disk_size) {
/* If was disabled also before */
write_IOCTL_msg();
printf("New configuration saved for later use\n\n");
} else {
/* If disk now get's disabled */
if (!licence_to_kill()) return;
IOCTL_msg.RW_access = ~READ_ACCESS & ~WRITE_ACCESS;
IOCTL_msg.media_change = -1;
write_IOCTL_msg();
printf("RAMDisk disabled\n\n");
}
return;
}
/* Count the new BPB for disk and see if it can be made */
/* Make sure sectors are big enough for the disk */
while((sectors = (long)IOCTL_msg.disk_size * 1024
/ IOCTL_msg.bytes_per_sector) > 0xFFFFL)
IOCTL_msg.bytes_per_sector <<= 1;
IOCTL_msg.sectors = sectors;
if (cluster_size < IOCTL_msg.bytes_per_sector)
cluster_size = IOCTL_msg.bytes_per_sector;
IOCTL_msg.sectors_per_cluster = cluster_size / IOCTL_msg.bytes_per_sector;
{ div_t divr;
divr = div(IOCTL_msg.dir_entries * 32, IOCTL_msg.bytes_per_sector);
dir_sectors = divr.quot + (divr.rem ? 1 : 0);
}
system_sectors = IOCTL_msg.reserved_sectors + dir_sectors;
data_sectors = IOCTL_msg.sectors - system_sectors;
{ ldiv_t divr;
divr = ldiv((long)3 * data_sectors + 6 * IOCTL_msg.sectors_per_cluster,
(long)2 * cluster_size + 3 * IOCTL_msg.FATs);
IOCTL_msg.FAT_sectors = divr.quot + (divr.rem ? 1 : 0);
}
FAT_sectors = IOCTL_msg.FAT_sectors * IOCTL_msg.FATs;
system_sectors += FAT_sectors;
data_sectors -= FAT_sectors;
clusters = data_sectors / IOCTL_msg.sectors_per_cluster;
if (IOCTL_msg.sectors <= system_sectors || !clusters)
{
error("Impossible format for disk");
return;
}
IOCTL_msg.media_change = -1; /* The media change */
IOCTL_msg.RW_access = (write_f == set ? 0 : WRITE_ACCESS);
if (!force_f) {
printf("New disk configuration:\n\n");
print_IOCTL_msg();
}
if (old_disk_size && !licence_to_kill()) return;
sector = malloc(IOCTL_msg.bytes_per_sector);
if (!sector) fatal("Insufficient memory");
/* Enable disk */
IOCTL_msg.RW_access |= READ_ACCESS;
/* Request the new disk space by sending the BPB */
if (write_IOCTL_msg()) return; /* Return if failed */
/* Write the new disk */
/* Make the boot sector */
memset(sector, 0, IOCTL_msg.bytes_per_sector);
memmove(sector, &IOCTL_msg, sizeof IOCTL_msg);
*((short *)sector) = 0x1DEB; /* Boot record JMP instruction */
*((short *)sector+12) = 1; /* Sectors per track */
*((short *)sector+13) = 1; /* Sides */
*((short *)sector+14) = 0; /* Hidden sectors */
*(short *)((char *)sector+31) = 0xFEEB; /* Boot code (JMP $) */
write_sector(1, 0, sector); /* Write boot sector */
for (i = 0; i < IOCTL_msg.FATs; i++) {
unsigned short sector_n =
IOCTL_msg.reserved_sectors + IOCTL_msg.FAT_sectors * i;
/* Write 1st FAT sector */
memset(sector, 0, IOCTL_msg.bytes_per_sector); /* Make 1st FAT sector */
((long *)sector)[0] = 0xFFFF00L | IOCTL_msg.media;
write_sector(1, sector_n++, sector);
/* Write FAT sectors from 2nd to last */
((long *)sector)[0] = 0L;
for (Fsec = 1; Fsec < IOCTL_msg.FAT_sectors; Fsec++)
write_sector(1, sector_n++, sector);
}
/* Write 1st directory sector */
dir_start = IOCTL_msg.reserved_sectors + FAT_sectors;
memcpy(sector, IOCTL_msg.volume, 11);
((char*)sector)[11] = FA_LABEL;
write_sector(1, dir_start, sector);
/* Write directory sectors from 2nd to last */
memset(sector, 0, 12);
for (Fsec = 1; Fsec < dir_sectors; Fsec++)
write_sector(1, dir_start+Fsec, sector);
free(sector);
printf("Disk formatted\n\n");
}
/*
** MAIN FUNCTION
*/
int main(int argc, char *argv[])
{
printf("Sizeable RAMDisk Formatter, version "VERSION", "
"PUBLIC DOMAIN, 1991\n\n");
parse_cmdline(argc, argv);
if (!drive) /* If no drive specified */
drive = getdisk()+1; /* operate on current drive */
init_drive();
if (format_f) format_disk();
else
if (write_f != same) set_write_protect();
return 0;
}
