639 lines
16 KiB
C
639 lines
16 KiB
C
/* Copyright 1986-1992 Emmet P. Gray.
|
|
* Copyright 1996-2002,2006-2009 Alain Knaff.
|
|
* This file is part of mtools.
|
|
*
|
|
* Mtools 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Mtools 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 Mtools. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* 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 "device.h"
|
|
#include "old_dos.h"
|
|
#include "fsP.h"
|
|
#include "buffer.h"
|
|
#include "file_name.h"
|
|
#include "open_image.h"
|
|
|
|
#define FULL_CYL
|
|
|
|
mt_off_t sectorsToBytes(Fs_t *This, uint32_t off)
|
|
{
|
|
return (mt_off_t) off << This->sectorShift;
|
|
}
|
|
|
|
/*
|
|
* Read the boot sector. We glean the disk parameters from this sector.
|
|
*/
|
|
static int read_boot(Stream_t *Stream, union bootsector * boot, size_t size)
|
|
{
|
|
size_t boot_sector_size; /* sector size, as stored in boot sector */
|
|
|
|
/* read the first sector, or part of it */
|
|
if(!size)
|
|
size = BOOTSIZE;
|
|
if(size > MAX_BOOT)
|
|
size = MAX_BOOT;
|
|
|
|
if (force_pread(Stream, boot->characters, 0, size) != (ssize_t) size)
|
|
return -1;
|
|
|
|
boot_sector_size = WORD(secsiz);
|
|
if(boot_sector_size < sizeof(boot->bytes)) {
|
|
/* zero rest of in-memory boot sector */
|
|
memset(boot->bytes+boot_sector_size, 0,
|
|
sizeof(boot->bytes) - boot_sector_size);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fs_flush(Stream_t *Stream)
|
|
{
|
|
DeclareThis(Fs_t);
|
|
|
|
fat_write(This);
|
|
return 0;
|
|
}
|
|
|
|
static doscp_t *get_dosConvert(Stream_t *Stream)
|
|
{
|
|
DeclareThis(Fs_t);
|
|
return This->cp;
|
|
}
|
|
|
|
Class_t FsClass = {
|
|
0,
|
|
0,
|
|
pread_pass_through, /* read */
|
|
pwrite_pass_through, /* write */
|
|
fs_flush,
|
|
fs_free, /* free */
|
|
0, /* set geometry */
|
|
get_data_pass_through,
|
|
0, /* pre allocate */
|
|
get_dosConvert, /* dosconvert */
|
|
0 /* discard */
|
|
};
|
|
|
|
/**
|
|
* Get media type byte from boot sector (BIOS Parameter Block 2) or
|
|
* from FAT (if media byte from BPB 2 looks fishy)
|
|
* Return the media byte + 0x100 if found in BPB 2, or as is if found in FAT.
|
|
*/
|
|
static int get_media_type(Stream_t *St, union bootsector *boot)
|
|
{
|
|
int media;
|
|
|
|
media = boot->boot.descr;
|
|
if(media < 0xf0){
|
|
char temp[512];
|
|
/* old DOS disk. Media descriptor in the first FAT byte */
|
|
/* we assume 512-byte sectors here */
|
|
if (force_pread(St,temp,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;
|
|
}
|
|
|
|
static void boot_to_geom(struct device *dev, int media,
|
|
union bootsector *boot) {
|
|
uint32_t tot_sectors;
|
|
int BootP, Infp0, InfpX, InfTm;
|
|
int j;
|
|
unsigned char sum;
|
|
uint16_t sect_per_track;
|
|
struct label_blk_t *labelBlock;
|
|
|
|
dev->ssize = 2; /* allow for init_geom to change it */
|
|
dev->use_2m = 0x80; /* disable 2m mode to begin */
|
|
|
|
if(media == 0xf0 || media >= 0x100){
|
|
dev->heads = WORD(nheads);
|
|
dev->sectors = WORD(nsect);
|
|
tot_sectors = DWORD(bigsect);
|
|
SET_INT(tot_sectors, WORD(psect));
|
|
sect_per_track = dev->heads * dev->sectors;
|
|
if(sect_per_track == 0) {
|
|
if(mtools_skip_check) {
|
|
/* add some fake values if sect_per_track is
|
|
* zero. Indeed, some atari disks lack the
|
|
* geometry values (i.e. have zeroes in their
|
|
* place). In order to avoid division by zero
|
|
* errors later on, plug 1 everywhere
|
|
*/
|
|
dev->heads = 1;
|
|
dev->sectors = 1;
|
|
sect_per_track = 1;
|
|
} else {
|
|
fprintf(stderr, "The devil is in the details: zero number of heads or sectors\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
dev->tracks = tot_sectors / sect_per_track;
|
|
if(tot_sectors % sect_per_track)
|
|
/* round size up */
|
|
dev->tracks++;
|
|
|
|
BootP = WORD(ext.old.BootP);
|
|
Infp0 = WORD(ext.old.Infp0);
|
|
InfpX = WORD(ext.old.InfpX);
|
|
InfTm = WORD(ext.old.InfTm);
|
|
|
|
if(WORD(fatlen)) {
|
|
labelBlock = &boot->boot.ext.old.labelBlock;
|
|
} else {
|
|
labelBlock = &boot->boot.ext.fat32.labelBlock;
|
|
}
|
|
|
|
if (boot->boot.descr >= 0xf0 &&
|
|
has_BPB4 &&
|
|
strncmp( boot->boot.banner,"2M", 2 ) == 0 &&
|
|
BootP < 512 && Infp0 < 512 && InfpX < 512 && InfTm < 512 &&
|
|
BootP >= InfTm + 2 && InfTm >= InfpX && InfpX >= Infp0 &&
|
|
Infp0 >= 76 ){
|
|
for (sum=0, j=63; j < BootP; j++)
|
|
sum += boot->bytes[j];/* checksum */
|
|
dev->ssize = boot->bytes[InfTm];
|
|
if (!sum && dev->ssize <= 7){
|
|
dev->use_2m = 0xff;
|
|
dev->ssize |= 0x80; /* is set */
|
|
}
|
|
}
|
|
dev->sector_size = WORD(secsiz);
|
|
} else
|
|
if(setDeviceFromOldDos(media, dev) < 0)
|
|
exit(1);
|
|
}
|
|
|
|
/**
|
|
* Tries out one device definition for the given drive number
|
|
* Parameters
|
|
* - dev: device definition to try
|
|
* - mode: file open mode
|
|
* - out_dev: device parameters (geometry, etc.) are returned here
|
|
* - boot: boot sector is read from the disk into this structure
|
|
* - name: "name" of device definition (returned)
|
|
* - media: media byte is returned here (ored with 0x100 if there is a
|
|
* BIOS Parameter block present)
|
|
* - maxSize: maximal size supported by (physical) drive returned here
|
|
* - try_writable: whether to try opening it writable from the get-go,
|
|
* even if not specified as writable in mode (used for mlabel)
|
|
* - isRop: whether device is read-only is returned here
|
|
* Return value:
|
|
* - a Stream allowing to read from this device, must be closed by caller
|
|
*
|
|
* If a geometry change is needed, drive is re-opened RW, as geometry
|
|
* change ioctl needs write access. However, in such case, the lock
|
|
* acquired is still only a read lock.
|
|
*/
|
|
static Stream_t *try_device(struct device *dev,
|
|
int mode, struct device *out_dev,
|
|
union bootsector *boot,
|
|
char *name, int *media, mt_off_t *maxSize,
|
|
int *isRop, int try_writable,
|
|
char *errmsg)
|
|
{
|
|
int retry_write;
|
|
int have_read_bootsector=0;
|
|
int modeFlags = mode & ~O_ACCMODE;
|
|
int openMode;
|
|
int lockMode;
|
|
|
|
*out_dev = *dev;
|
|
expand(dev->name,name);
|
|
#ifdef USING_NEW_VOLD
|
|
strcpy(name, getVoldName(dev, name));
|
|
#endif
|
|
|
|
if(try_writable) {
|
|
/* Caller asks up to try first read-write, and only fall back
|
|
* if not feasible */
|
|
openMode = O_RDWR | modeFlags;
|
|
} else {
|
|
openMode = mode;
|
|
}
|
|
lockMode = openMode;
|
|
|
|
for(retry_write=0; retry_write<2; retry_write++) {
|
|
Stream_t *Stream;
|
|
int r;
|
|
int geomFailure=0;
|
|
|
|
if(retry_write)
|
|
mode |= O_RDWR;
|
|
|
|
Stream = OpenImage(out_dev, dev, name, openMode, errmsg,
|
|
0, lockMode,
|
|
maxSize, &geomFailure, NULL);
|
|
if(Stream == NULL) {
|
|
if(geomFailure && (mode & O_ACCMODE) == O_RDONLY) {
|
|
/* Our first attempt was to open read-only,
|
|
but this resulted in failure setting the
|
|
geometry */
|
|
openMode = modeFlags | O_RDWR;
|
|
continue;
|
|
}
|
|
|
|
if(try_writable &&
|
|
(errno == EPERM ||
|
|
errno == EACCES ||
|
|
errno == EROFS)) {
|
|
/* Our first attempt was to open
|
|
* read-write, but this resulted in a
|
|
* read-protection problem */
|
|
lockMode = openMode = modeFlags | O_RDONLY;
|
|
continue;
|
|
}
|
|
return NULL;
|
|
}
|
|
if(!have_read_bootsector) {
|
|
/* read the boot sector */
|
|
if ((r=read_boot(Stream, boot, out_dev->blocksize)) < 0){
|
|
sprintf(errmsg,
|
|
"init %c: could not read boot sector",
|
|
dev->drive);
|
|
FREE(&Stream);
|
|
return NULL;
|
|
}
|
|
|
|
if((*media= get_media_type(Stream, boot)) <= 0xf0 ){
|
|
if (boot->boot.jump[2]=='L')
|
|
sprintf(errmsg,
|
|
"diskette %c: is Linux LILO, not DOS",
|
|
dev->drive);
|
|
else
|
|
sprintf(errmsg,"init %c: non DOS media", dev->drive);
|
|
FREE(&Stream);
|
|
return NULL;
|
|
}
|
|
have_read_bootsector=1;
|
|
}
|
|
|
|
/* set new parameters, if needed */
|
|
errno = 0;
|
|
boot_to_geom(out_dev, *media, boot);
|
|
if(SET_GEOM(Stream, out_dev, dev)){
|
|
if(errno == EBADF || errno == EPERM) {
|
|
/* Retry with write */
|
|
FREE(&Stream);
|
|
openMode = modeFlags | O_RDWR;
|
|
continue;
|
|
}
|
|
if(errno)
|
|
#ifdef HAVE_SNPRINTF
|
|
snprintf(errmsg, 199,
|
|
"Can't set disk parameters for %c: %s",
|
|
dev->drive, strerror(errno));
|
|
#else
|
|
sprintf(errmsg,
|
|
"Can't set disk parameters for %c: %s",
|
|
drive, strerror(errno));
|
|
#endif
|
|
else
|
|
sprintf(errmsg,
|
|
"Can't set disk parameters for %c",
|
|
dev->drive);
|
|
FREE(&Stream);
|
|
return NULL;
|
|
}
|
|
if(isRop) {
|
|
*isRop = (openMode & O_ACCMODE) == O_RDONLY;
|
|
}
|
|
return Stream;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
uint32_t calc_clus_start(Fs_t *Fs) {
|
|
return Fs->fat_start + Fs->fat_len*Fs->num_fat + Fs->dir_len;
|
|
}
|
|
|
|
/* Calculates number of clusters, and fills it in into Fs->num_clus
|
|
* Returns 0 if calculation could be performed, and -1 if less sectors than
|
|
* clus_start
|
|
*/
|
|
int calc_num_clus(Fs_t *Fs, uint32_t tot_sectors)
|
|
{
|
|
Fs->clus_start = calc_clus_start(Fs);
|
|
if(tot_sectors <= Fs->clus_start)
|
|
return -1;
|
|
Fs->num_clus = (tot_sectors - Fs->clus_start) / Fs->cluster_size;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Tries out all device definitions for the given drive letter, until one
|
|
* is found that is able to read from the device
|
|
* Parameters
|
|
* - drive: drive letter to check
|
|
* - mode: file open mode
|
|
* - out_dev: device parameters (geometry, etc.) are returned here
|
|
* - boot: boot sector is read from the disk into this structure
|
|
* - name: "name" of device definition (returned)
|
|
* - media: media byte is returned here (ored with 0x100 if there is a
|
|
* BIOS Parameter block present)
|
|
* - maxSize: maximal size supported by (physical) drive returned here
|
|
* - isRop: whether device is read-only is returned here
|
|
* Return value:
|
|
* - a Stream allowing to read from this device, must be closed by caller
|
|
*/
|
|
Stream_t *find_device(char drive, int mode, struct device *out_dev,
|
|
union bootsector *boot,
|
|
char *name, int *media, mt_off_t *maxSize,
|
|
int *isRop)
|
|
{
|
|
char errmsg[200];
|
|
struct device *dev;
|
|
|
|
sprintf(errmsg, "Drive '%c:' not supported", drive);
|
|
/* open the device */
|
|
for (dev=devices; dev->name; dev++) {
|
|
Stream_t *Stream;
|
|
int isRo;
|
|
isRo=0;
|
|
if (dev->drive != drive)
|
|
continue;
|
|
|
|
Stream = try_device(dev, mode, out_dev,
|
|
boot,
|
|
name, media, maxSize,
|
|
&isRo, isRop != NULL,
|
|
errmsg);
|
|
if(Stream) {
|
|
if(isRop)
|
|
*isRop = isRo;
|
|
return Stream;
|
|
}
|
|
}
|
|
|
|
/* print error msg if needed */
|
|
fprintf(stderr,"%s\n",errmsg);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
uint32_t parseFsParams( Fs_t *This,
|
|
union bootsector *boot,
|
|
int media,
|
|
unsigned int cylinder_size)
|
|
{
|
|
uint32_t tot_sectors;
|
|
|
|
if ((media & ~7) == 0xf8){
|
|
/* This bit of code is only entered if there is no BPB, or
|
|
* else result of the AND would be 0x1xx
|
|
*/
|
|
struct OldDos_t *params=getOldDosByMedia(media);
|
|
if(params == NULL) {
|
|
fprintf(stderr, "Unknown media byte %02x\n", media);
|
|
return 0;
|
|
}
|
|
This->cluster_size = params->cluster_size;
|
|
tot_sectors = cylinder_size * params->tracks;
|
|
This->fat_start = 1;
|
|
This->fat_len = params->fat_len;
|
|
This->dir_len = params->dir_len;
|
|
This->num_fat = 2;
|
|
This->sector_size = 512;
|
|
This->sectorShift = 9;
|
|
This->sectorMask = 511;
|
|
} else {
|
|
struct label_blk_t *labelBlock;
|
|
unsigned int i;
|
|
|
|
This->sector_size = WORD(secsiz);
|
|
if(This->sector_size > MAX_SECTOR){
|
|
fprintf(stderr,"init: sector size too big\n");
|
|
return 0;
|
|
}
|
|
|
|
i = log_2(This->sector_size);
|
|
|
|
if(i == 24) {
|
|
fprintf(stderr,
|
|
"init: sector size (%d) not a small power of two\n",
|
|
This->sector_size);
|
|
return 0;
|
|
}
|
|
This->sectorShift = i;
|
|
This->sectorMask = This->sector_size - 1;
|
|
|
|
/*
|
|
* all numbers are in sectors, except num_clus
|
|
* (which is in clusters)
|
|
*/
|
|
tot_sectors = WORD(psect);
|
|
if(!tot_sectors)
|
|
tot_sectors = DWORD(bigsect);
|
|
|
|
This->cluster_size = boot->boot.clsiz;
|
|
This->fat_start = WORD(nrsvsect);
|
|
This->fat_len = WORD(fatlen);
|
|
This->dir_len = WORD(dirents) * MDIR_SIZE / This->sector_size;
|
|
This->num_fat = boot->boot.nfat;
|
|
|
|
if (This->fat_len) {
|
|
labelBlock = &boot->boot.ext.old.labelBlock;
|
|
} else {
|
|
labelBlock = &boot->boot.ext.fat32.labelBlock;
|
|
This->fat_len = DWORD(ext.fat32.bigFat);
|
|
This->backupBoot = WORD(ext.fat32.backupBoot);
|
|
}
|
|
|
|
if(has_BPB4) {
|
|
This->serialized = 1;
|
|
This->serial_number = _DWORD(labelBlock->serial);
|
|
}
|
|
}
|
|
|
|
if(calc_num_clus(This, tot_sectors) < 0)
|
|
/* Too few sectors */
|
|
return 0;
|
|
set_fat(This);
|
|
|
|
return tot_sectors;
|
|
}
|
|
|
|
|
|
Stream_t *fs_init(char drive, int mode, int *isRop)
|
|
{
|
|
uint32_t blocksize;
|
|
int media;
|
|
size_t disk_size = 0; /* In case we don't happen to set this below */
|
|
uint32_t tot_sectors;
|
|
char name[EXPAND_BUF];
|
|
unsigned int cylinder_size;
|
|
struct device dev;
|
|
mt_off_t maxSize;
|
|
char errmsg[81];
|
|
|
|
union bootsector boot;
|
|
|
|
Fs_t *This;
|
|
|
|
This = New(Fs_t);
|
|
if (!This)
|
|
return NULL;
|
|
|
|
init_head(&This->head, &FsClass, NULL);
|
|
This->preallocatedClusters = 0;
|
|
This->lastFatSectorNr = 0;
|
|
This->lastFatAccessMode = 0;
|
|
This->lastFatSectorData = 0;
|
|
This->drive = drive;
|
|
This->last = 0;
|
|
|
|
This->head.Next = find_device(drive, mode, &dev, &boot, name, &media,
|
|
&maxSize, isRop);
|
|
if(!This->head.Next)
|
|
return NULL;
|
|
|
|
cylinder_size = dev.heads * dev.sectors;
|
|
This->serialized = 0;
|
|
|
|
tot_sectors = parseFsParams(This, &boot, media, cylinder_size);
|
|
if(tot_sectors == 0) {
|
|
/* Error raised by parseFsParams */
|
|
return NULL;
|
|
}
|
|
|
|
if (check_if_sectors_fit(tot_sectors, maxSize,
|
|
This->sector_size, errmsg) < 0) {
|
|
fprintf(stderr, "%s", errmsg);
|
|
return NULL;
|
|
}
|
|
|
|
/* 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) {
|
|
Stream_t *Buffer = buf_init(This->head.Next,
|
|
8 * disk_size * blocksize,
|
|
disk_size * blocksize,
|
|
This->sector_size);
|
|
|
|
if (Buffer != NULL)
|
|
This->head.Next = Buffer;
|
|
else
|
|
perror("init: allocate buffer");
|
|
}
|
|
|
|
/* read the FAT sectors */
|
|
if(fat_read(This, &boot, dev.use_2m&0x7f)){
|
|
fprintf(stderr, "Error reading FAT\n");
|
|
This->num_fat = 1;
|
|
FREE(&This->head.Next);
|
|
Free(This->head.Next);
|
|
return NULL;
|
|
}
|
|
|
|
/* Set the codepage */
|
|
This->cp = cp_open(dev.codepage);
|
|
if(This->cp == NULL) {
|
|
fprintf(stderr, "Error setting code page\n");
|
|
fs_free((Stream_t *)This);
|
|
FREE(&This->head.Next);
|
|
Free(This->head.Next);
|
|
return NULL;
|
|
}
|
|
|
|
return (Stream_t *) This;
|
|
}
|
|
|
|
char getDrive(Stream_t *Stream)
|
|
{
|
|
DeclareThis(Fs_t);
|
|
|
|
if(This->head.Class != &FsClass)
|
|
return getDrive(GetFs(Stream));
|
|
else
|
|
return This->drive;
|
|
}
|
|
|
|
/*
|
|
* Upper layer asks to pre-allocated more additional clusters
|
|
* Parameters:
|
|
* size: new additional clusters to pre-allocate
|
|
* Return:
|
|
* 0 if pre-allocation was granted
|
|
* -1 if not enough clusters could be found
|
|
*/
|
|
int fsPreallocateClusters(Fs_t *Fs, uint32_t size)
|
|
{
|
|
if(size > 0 && getfreeMinClusters((Stream_t *)Fs, size) != 1)
|
|
return -1;
|
|
|
|
Fs->preallocatedClusters += size;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Upper layer wants to release some clusters that it had
|
|
* pre-allocated before Usually done because they have now been really
|
|
* allocated, and thus pre-allocation needs to be released to prevent
|
|
* counting them twice.
|
|
* Parameters:
|
|
* size: new additional clusters to pre-allocate
|
|
*/
|
|
void fsReleasePreallocateClusters(Fs_t *Fs, uint32_t size)
|
|
{
|
|
Fs->preallocatedClusters -= size;
|
|
}
|