415 lines
8.8 KiB
C
Executable File
415 lines
8.8 KiB
C
Executable File
/*
|
|
* Initialize an MSDOS diskette. Read the boot sector, and switch to the
|
|
* proper floppy disk device to match the format on the disk. Sets a bunch
|
|
* of global variables. Returns 0 on success, or 1 on failure.
|
|
*/
|
|
|
|
#include "sysincludes.h"
|
|
#include "msdos.h"
|
|
#include "stream.h"
|
|
#include "mtools.h"
|
|
#include "fsP.h"
|
|
#include "plain_io.h"
|
|
#include "floppyd_io.h"
|
|
#include "xdf_io.h"
|
|
#include "buffer.h"
|
|
|
|
extern int errno;
|
|
|
|
|
|
#ifndef OS_Minix /* Minix is memory starved. */
|
|
#define FULL_CYL
|
|
#endif
|
|
|
|
unsigned int num_clus; /* total number of cluster */
|
|
|
|
|
|
/*
|
|
* Read the boot sector. We glean the disk parameters from this sector.
|
|
*/
|
|
static int read_boot(Stream_t *Stream, struct bootsector * boot, int size)
|
|
{
|
|
/* read the first sector, or part of it */
|
|
if(!size)
|
|
size = BOOTSIZE;
|
|
if(size > 1024)
|
|
size = 1024;
|
|
|
|
if (force_read(Stream, (char *) boot, 0, size) != size)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
static int fs_flush(Stream_t *Stream)
|
|
{
|
|
DeclareThis(Fs_t);
|
|
|
|
fat_write(This);
|
|
return 0;
|
|
}
|
|
|
|
Class_t FsClass = {
|
|
read_pass_through, /* read */
|
|
write_pass_through, /* write */
|
|
fs_flush,
|
|
fs_free, /* free */
|
|
0, /* set geometry */
|
|
get_data_pass_through,
|
|
0 /* pre allocate */
|
|
};
|
|
|
|
static int get_media_type(Stream_t *St, struct bootsector *boot)
|
|
{
|
|
int media;
|
|
|
|
media = boot->descr;
|
|
if(media < 0xf0){
|
|
char temp[512];
|
|
/* old DOS disk. Media descriptor in the first FAT byte */
|
|
/* old DOS disk always have 512-byte sectors */
|
|
if (force_read(St,temp,(mt_off_t) 512,512) == 512)
|
|
media = (unsigned char) temp[0];
|
|
else
|
|
media = 0;
|
|
} else
|
|
media += 0x100;
|
|
return media;
|
|
}
|
|
|
|
|
|
Stream_t *GetFs(Stream_t *Fs)
|
|
{
|
|
while(Fs && Fs->Class != &FsClass)
|
|
Fs = Fs->Next;
|
|
return Fs;
|
|
}
|
|
|
|
Stream_t *find_device(char *drive, int mode, struct device *out_dev,
|
|
struct bootsector *boot,
|
|
char *name, int *media, mt_size_t *maxSize)
|
|
{
|
|
char errmsg[200];
|
|
Stream_t *Stream;
|
|
struct device *dev;
|
|
int r;
|
|
#ifdef OS_Minix
|
|
static char *devname;
|
|
struct device onedevice[2];
|
|
struct stat stbuf;
|
|
|
|
free(devname);
|
|
devname = safe_malloc((9 + strlen(drive)) * sizeof(devname[0]));
|
|
strcpy(devname, "/dev/dosX");
|
|
if (isupper(drive[0]) && drive[1] == 0) {
|
|
/* single letter device name, use /dev/dos$drive */
|
|
devname[8]= drive[0];
|
|
} else
|
|
if (strchr(drive, '/') == NULL) {
|
|
/* a simple name, use /dev/$drive */
|
|
strcpy(devname+5, drive);
|
|
} else {
|
|
/* a pathname, use as is. */
|
|
strcpy(devname, drive);
|
|
}
|
|
if (stat(devname, &stbuf) != -1) {
|
|
memset(onedevice, 0, sizeof(onedevice));
|
|
onedevice[0].name = devname;
|
|
onedevice[0].drive = drive;
|
|
onedevice[1].name = NULL;
|
|
onedevice[1].drive = NULL;
|
|
dev = onedevice;
|
|
} else {
|
|
dev = devices;
|
|
}
|
|
#else
|
|
dev = devices;
|
|
#endif
|
|
|
|
Stream = NULL;
|
|
sprintf(errmsg, "Drive '%s:' not supported", drive);
|
|
/* open the device */
|
|
for (; dev->name; dev++) {
|
|
FREE(&Stream);
|
|
if (strcmp(dev->drive, drive) != 0)
|
|
continue;
|
|
*out_dev = *dev;
|
|
expand(dev->name,name);
|
|
#ifdef USING_NEW_VOLD
|
|
strcpy(name, getVoldName(dev, name));
|
|
#endif
|
|
|
|
Stream = 0;
|
|
#ifdef USE_XDF
|
|
Stream = XdfOpen(out_dev, name, mode, errmsg, 0);
|
|
if(Stream) {
|
|
out_dev->use_2m = 0x7f;
|
|
if(maxSize)
|
|
*maxSize = max_off_t_31;
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_FLOPPYD
|
|
if(!Stream) {
|
|
Stream = FloppydOpen(out_dev, dev, name, mode, errmsg, 0, 1);
|
|
if(Stream && maxSize)
|
|
*maxSize = max_off_t_31;
|
|
}
|
|
#endif
|
|
|
|
if (!Stream)
|
|
Stream = SimpleFileOpen(out_dev, dev, name, mode,
|
|
errmsg, 0, 1, maxSize);
|
|
|
|
if( !Stream)
|
|
continue;
|
|
|
|
/* read the boot sector */
|
|
if ((r=read_boot(Stream, boot, out_dev->blocksize)) < 0){
|
|
sprintf(errmsg,
|
|
"init %s: could not read boot sector",
|
|
drive);
|
|
continue;
|
|
}
|
|
|
|
if((*media= get_media_type(Stream, boot)) <= 0xf0 ){
|
|
if (boot->jump[2]=='L')
|
|
sprintf(errmsg,
|
|
"diskette %s: is Linux LILO, not DOS",
|
|
drive);
|
|
else
|
|
sprintf(errmsg,"init %s: non DOS media", drive);
|
|
continue;
|
|
}
|
|
|
|
/* set new parameters, if needed */
|
|
errno = 0;
|
|
if(SET_GEOM(Stream, out_dev, dev, *media, boot)){
|
|
if(errno)
|
|
#ifdef HAVE_SNPRINTF
|
|
snprintf(errmsg, 199,
|
|
"Can't set disk parameters for %s: %s",
|
|
drive, strerror(errno));
|
|
#else
|
|
sprintf(errmsg,
|
|
"Can't set disk parameters for %s: %s",
|
|
drive, strerror(errno));
|
|
#endif
|
|
else
|
|
sprintf(errmsg,
|
|
"Can't set disk parameters for %s",
|
|
drive);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* print error msg if needed */
|
|
if ( dev->drive == 0 ){
|
|
FREE(&Stream);
|
|
fprintf(stderr,"%s\n",errmsg);
|
|
return NULL;
|
|
}
|
|
#ifdef OS_Minix
|
|
/* Minix can lseek up to 4G. */
|
|
if (maxSize) *maxSize = 0xFFFFFFFFUL;
|
|
#endif
|
|
return Stream;
|
|
}
|
|
|
|
|
|
Stream_t *fs_init(char *drive, int mode)
|
|
{
|
|
int blocksize;
|
|
int media,i;
|
|
int nhs;
|
|
int disk_size = 0; /* In case we don't happen to set this below */
|
|
size_t tot_sectors;
|
|
char name[EXPAND_BUF];
|
|
int cylinder_size;
|
|
struct device dev;
|
|
mt_size_t maxSize;
|
|
|
|
struct bootsector boot0;
|
|
#define boot (&boot0)
|
|
Fs_t *This;
|
|
|
|
This = New(Fs_t);
|
|
if (!This)
|
|
return NULL;
|
|
|
|
This->Direct = NULL;
|
|
This->Next = NULL;
|
|
This->refs = 1;
|
|
This->Buffer = 0;
|
|
This->Class = &FsClass;
|
|
This->preallocatedClusters = 0;
|
|
This->lastFatSectorNr = 0;
|
|
This->lastFatAccessMode = 0;
|
|
This->lastFatSectorData = 0;
|
|
This->drive = drive;
|
|
This->last = 0;
|
|
|
|
This->Direct = find_device(drive, mode, &dev, &boot0, name, &media,
|
|
&maxSize);
|
|
if(!This->Direct)
|
|
return NULL;
|
|
|
|
This->sector_size = WORD(secsiz);
|
|
if(This->sector_size > MAX_SECTOR){
|
|
fprintf(stderr,"init %s: sector size too big\n", drive);
|
|
return NULL;
|
|
}
|
|
|
|
i = log_2(This->sector_size);
|
|
|
|
if(i == 24) {
|
|
fprintf(stderr,
|
|
"init %c: sector size (%d) not a small power of two\n",
|
|
drive, This->sector_size);
|
|
return NULL;
|
|
}
|
|
This->sectorShift = i;
|
|
This->sectorMask = This->sector_size - 1;
|
|
|
|
|
|
cylinder_size = dev.heads * dev.sectors;
|
|
if (!tot_sectors) tot_sectors = dev.tracks * cylinder_size;
|
|
|
|
This->serialized = 0;
|
|
if ((media & ~7) == 0xf8){
|
|
i = media & 3;
|
|
This->cluster_size = old_dos[i].cluster_size;
|
|
tot_sectors = cylinder_size * old_dos[i].tracks;
|
|
This->fat_start = 1;
|
|
This->fat_len = old_dos[i].fat_len;
|
|
This->dir_len = old_dos[i].dir_len;
|
|
This->num_fat = 2;
|
|
This->sector_size = 512;
|
|
This->sectorShift = 9;
|
|
This->sectorMask = 511;
|
|
This->fat_bits = 12;
|
|
nhs = 0;
|
|
} else {
|
|
struct label_blk_t *labelBlock;
|
|
/*
|
|
* all numbers are in sectors, except num_clus
|
|
* (which is in clusters)
|
|
*/
|
|
tot_sectors = WORD(psect);
|
|
if(!tot_sectors) {
|
|
tot_sectors = DWORD(bigsect);
|
|
nhs = DWORD(nhs);
|
|
} else
|
|
nhs = WORD(nhs);
|
|
|
|
|
|
This->cluster_size = boot0.clsiz;
|
|
This->fat_start = WORD(nrsvsect);
|
|
This->fat_len = WORD(fatlen);
|
|
This->dir_len = WORD(dirents) * MDIR_SIZE / This->sector_size;
|
|
This->num_fat = boot0.nfat;
|
|
|
|
if (This->fat_len) {
|
|
labelBlock = &boot0.ext.old.labelBlock;
|
|
} else {
|
|
labelBlock = &boot0.ext.fat32.labelBlock;
|
|
}
|
|
|
|
if(labelBlock->dos4 == 0x29) {
|
|
This->serialized = 1;
|
|
This->serial_number = _DWORD(labelBlock->serial);
|
|
}
|
|
}
|
|
|
|
if (tot_sectors >= (maxSize >> This->sectorShift)) {
|
|
fprintf(stderr, "Big disks not supported on this architecture\n");
|
|
exit(1);
|
|
}
|
|
|
|
#ifndef OS_Minix /* Strange check, MS-DOS isn't that picky. */
|
|
|
|
if(!mtools_skip_check && (tot_sectors % dev.sectors)){
|
|
fprintf(stderr,
|
|
"Total number of sectors not a multiple of"
|
|
" sectors per track!\n");
|
|
fprintf(stderr,
|
|
"Add mtools_skip_check=1 to your .mtoolsrc file "
|
|
"to skip this test\n");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
|
|
/* full cylinder buffering */
|
|
#ifdef FULL_CYL
|
|
disk_size = (dev.tracks) ? cylinder_size : 512;
|
|
#else /* FULL_CYL */
|
|
disk_size = (dev.tracks) ? dev.sectors : 512;
|
|
#endif /* FULL_CYL */
|
|
|
|
#if (defined OS_sysv4 && !defined OS_solaris)
|
|
/*
|
|
* The driver in Dell's SVR4 v2.01 is unreliable with large writes.
|
|
*/
|
|
disk_size = 0;
|
|
#endif /* (defined sysv4 && !defined(solaris)) */
|
|
|
|
#ifdef OS_linux
|
|
disk_size = cylinder_size;
|
|
#endif
|
|
|
|
#if 1
|
|
if(disk_size > 256) {
|
|
disk_size = dev.sectors;
|
|
if(dev.sectors % 2)
|
|
disk_size <<= 1;
|
|
}
|
|
#endif
|
|
if (disk_size % 2)
|
|
disk_size *= 2;
|
|
|
|
if(!dev.blocksize || dev.blocksize < This->sector_size)
|
|
blocksize = This->sector_size;
|
|
else
|
|
blocksize = dev.blocksize;
|
|
if (disk_size)
|
|
This->Next = buf_init(This->Direct,
|
|
8 * disk_size * blocksize,
|
|
disk_size * blocksize,
|
|
This->sector_size);
|
|
else
|
|
This->Next = This->Direct;
|
|
|
|
if (This->Next == NULL) {
|
|
perror("init: allocate buffer");
|
|
This->Next = This->Direct;
|
|
}
|
|
|
|
/* read the FAT sectors */
|
|
if(fat_read(This, &boot0, dev.fat_bits, tot_sectors, dev.use_2m&0x7f)){
|
|
This->num_fat = 1;
|
|
FREE(&This->Next);
|
|
Free(This->Next);
|
|
return NULL;
|
|
}
|
|
return (Stream_t *) This;
|
|
}
|
|
|
|
char *getDrive(Stream_t *Stream)
|
|
{
|
|
DeclareThis(Fs_t);
|
|
|
|
if(This->Class != &FsClass)
|
|
return getDrive(GetFs(Stream));
|
|
else
|
|
return This->drive;
|
|
}
|
|
|
|
int fsPreallocateClusters(Fs_t *Fs, long size)
|
|
{
|
|
if(size > 0 && getfreeMinClusters((Stream_t *)Fs, size) != 1)
|
|
return -1;
|
|
|
|
Fs->preallocatedClusters += size;
|
|
return 0;
|
|
}
|