minix/commands/i386/mtools-3.9.7/xdf_io.c
2005-04-21 14:53:53 +00:00

696 lines
14 KiB
C
Executable file

/*
* Io to an xdf disk
*
* written by:
*
* Alain L. Knaff
* alain@linux.lu
*
*/
#include "sysincludes.h"
#ifdef OS_linux
#include "msdos.h"
#include "mtools.h"
#include "devices.h"
#include "xdf_io.h"
extern int errno;
/* Algorithms can't be patented */
typedef struct sector_map {
unsigned int head:1;
unsigned int size:7;
} sector_map_t;
struct {
unsigned char track_size;
unsigned int track0_size:7;
unsigned int rootskip:1;
unsigned char rate;
sector_map_t map[9];
} xdf_table[]= {
{
19, 16, 0, 0,
{ {0,3}, {0,6}, {1,2}, {0,2}, {1,6}, {1,3}, {0,0} }
},
{
23, 19, 0, 0,
{ {0,3}, {0,4}, {1,6}, {0,2}, {1,2}, {0,6}, {1,4}, {1,3}, {0,0} }
},
{
46, 37, 0x43, 1,
{ {0,3}, {0,4}, {0,5}, {0,7}, {1,3}, {1,4}, {1,5}, {1,7}, {0,0} }
},
{
24, 20, 0, 1,
{ {0,5}, {1,6}, {0,6}, {1, 5} }
},
{
48, 41, 0, 1,
{ {0,6}, {1,7}, {0,7}, {1, 6} }
}
};
#define NUMBER(x) (sizeof(x)/sizeof(x[0]))
typedef struct {
unsigned char begin; /* where it begins */
unsigned char end;
unsigned char sector;
unsigned char sizecode;
unsigned int dirty:1;
unsigned int phantom:2;
unsigned int valid:1;
unsigned int head:1;
} TrackMap_t;
typedef struct Xdf_t {
Class_t *Class;
int refs;
Stream_t *Next;
Stream_t *Buffer;
int fd;
char *buffer;
int current_track;
sector_map_t *map;
int track_size;
int track0_size;
int sector_size;
int FatSize;
int RootDirSize;
TrackMap_t *track_map;
unsigned char last_sector;
unsigned char rate;
unsigned int stretch:1;
unsigned int rootskip:1;
signed int drive:4;
} Xdf_t;
typedef struct {
unsigned char head;
unsigned char sector;
unsigned char ptr;
} Compactify_t;
static int analyze_reply(RawRequest_t *raw_cmd, int do_print)
{
int ret, bytes, newbytes;
bytes = 0;
while(1) {
ret = analyze_one_reply(raw_cmd, &newbytes, do_print);
bytes += newbytes;
switch(ret) {
case 0:
return bytes;
case 1:
raw_cmd++;
break;
case -1:
if(bytes)
return bytes;
else
return 0;
}
}
}
static int send_cmd(int fd, RawRequest_t *raw_cmd, int nr,
const char *message, int retries)
{
int j;
int ret=-1;
if(!nr)
return 0;
for (j=0; j< retries; j++){
switch(send_one_cmd(fd, raw_cmd, message)) {
case -1:
return -1;
case 1:
j++;
continue;
case 0:
break;
}
if((ret=analyze_reply(raw_cmd, j)) > 0)
return ret; /* ok */
}
if(j > 1 && j == retries) {
fprintf(stderr,"Too many errors, giving up\n");
return 0;
}
return -1;
}
#define REC (This->track_map[ptr])
#define END(x) (This->track_map[(x)].end)
#define BEGIN(x) (This->track_map[(x)].begin)
static int add_to_request(Xdf_t *This, int ptr,
RawRequest_t *request, int *nr,
int direction, Compactify_t *compactify)
{
#if 0
if(direction == MT_WRITE) {
printf("writing %d: %d %d %d %d [%02x]\n",
ptr, This->current_track,
REC.head, REC.sector, REC.sizecode,
*(This->buffer + ptr * This->sector_size));
} else
printf(" load %d.%d\n", This->current_track, ptr);
#endif
if(REC.phantom) {
if(direction== MT_READ)
memset(This->buffer + ptr * This->sector_size, 0,
128 << REC.sizecode);
return 0;
}
if(*nr &&
RR_SIZECODE(request+(*nr)-1) == REC.sizecode &&
compactify->head == REC.head &&
compactify->ptr + 1 == ptr &&
compactify->sector +1 == REC.sector) {
RR_SETSIZECODE(request+(*nr)-1, REC.sizecode);
} else {
if(*nr)
RR_SETCONT(request+(*nr)-1);
RR_INIT(request+(*nr));
RR_SETDRIVE(request+(*nr), This->drive);
RR_SETRATE(request+(*nr), This->rate);
RR_SETTRACK(request+(*nr), This->current_track);
RR_SETPTRACK(request+(*nr),
This->current_track << This->stretch);
RR_SETHEAD(request+(*nr), REC.head);
RR_SETSECTOR(request+(*nr), REC.sector);
RR_SETSIZECODE(request+(*nr), REC.sizecode);
RR_SETDIRECTION(request+(*nr), direction);
RR_SETDATA(request+(*nr),
(caddr_t) This->buffer + ptr * This->sector_size);
(*nr)++;
}
compactify->ptr = ptr;
compactify->head = REC.head;
compactify->sector = REC.sector;
return 0;
}
static void add_to_request_if_invalid(Xdf_t *This, int ptr,
RawRequest_t *request, int *nr,
Compactify_t *compactify)
{
if(!REC.valid)
add_to_request(This, ptr, request, nr, MT_READ, compactify);
}
static void adjust_bounds(Xdf_t *This, off_t *begin, off_t *end)
{
/* translates begin and end from byte to sectors */
*begin = *begin / This->sector_size;
*end = (*end + This->sector_size - 1) / This->sector_size;
}
static inline int try_flush_dirty(Xdf_t *This)
{
int ptr, nr, bytes;
RawRequest_t requests[100];
Compactify_t compactify;
if(This->current_track < 0)
return 0;
nr = 0;
for(ptr=0; ptr < This->last_sector; ptr=REC.end)
if(REC.dirty)
add_to_request(This, ptr,
requests, &nr,
MT_WRITE, &compactify);
#if 1
bytes = send_cmd(This->fd,requests, nr, "writing", 4);
if(bytes < 0)
return bytes;
#else
bytes = 0xffffff;
#endif
for(ptr=0; ptr < This->last_sector; ptr=REC.end)
if(REC.dirty) {
if(bytes >= REC.end - REC.begin) {
bytes -= REC.end - REC.begin;
REC.dirty = 0;
} else
return 1;
}
return 0;
}
static int flush_dirty(Xdf_t *This)
{
int ret;
while((ret = try_flush_dirty(This))) {
if(ret < 0)
return ret;
}
return 0;
}
static int load_data(Xdf_t *This, off_t begin, off_t end, int retries)
{
int ptr, nr, bytes;
RawRequest_t requests[100];
Compactify_t compactify;
adjust_bounds(This, &begin, &end);
ptr = begin;
nr = 0;
for(ptr=REC.begin; ptr < end ; ptr = REC.end)
add_to_request_if_invalid(This, ptr, requests, &nr,
&compactify);
bytes = send_cmd(This->fd,requests, nr, "reading", retries);
if(bytes < 0)
return bytes;
ptr = begin;
for(ptr=REC.begin; ptr < end ; ptr = REC.end) {
if(!REC.valid) {
if(bytes >= REC.end - REC.begin) {
bytes -= REC.end - REC.begin;
REC.valid = 1;
} else if(ptr > begin)
return ptr * This->sector_size;
else
return -1;
}
}
return end * This->sector_size;
}
static void mark_dirty(Xdf_t *This, off_t begin, off_t end)
{
int ptr;
adjust_bounds(This, &begin, &end);
ptr = begin;
for(ptr=REC.begin; ptr < end ; ptr = REC.end) {
REC.valid = 1;
if(!REC.phantom)
REC.dirty = 1;
}
}
static int load_bounds(Xdf_t *This, off_t begin, off_t end)
{
off_t lbegin, lend;
int endp1, endp2;
lbegin = begin;
lend = end;
adjust_bounds(This, &lbegin, &lend);
if(begin != BEGIN(lbegin) * This->sector_size &&
end != BEGIN(lend) * This->sector_size &&
lend < END(END(lbegin)))
/* contiguous end & begin, load them in one go */
return load_data(This, begin, end, 4);
if(begin != BEGIN(lbegin) * This->sector_size) {
endp1 = load_data(This, begin, begin, 4);
if(endp1 < 0)
return endp1;
}
if(end != BEGIN(lend) * This->sector_size) {
endp2 = load_data(This, end, end, 4);
if(endp2 < 0)
return BEGIN(lend) * This->sector_size;
}
return lend * This->sector_size;
}
static int fill_t0(Xdf_t *This, int ptr, int size, int *sector, int *head)
{
int n;
for(n = 0; n < size; ptr++,n++) {
REC.head = *head;
REC.sector = *sector + 129;
REC.phantom = 0;
(*sector)++;
if(!*head && *sector >= This->track0_size - 8) {
*sector = 0;
*head = 1;
}
}
return ptr;
}
static int fill_phantoms(Xdf_t *This, int ptr, int size)
{
int n;
for(n = 0; n < size; ptr++,n++)
REC.phantom = 1;
return ptr;
}
static void decompose(Xdf_t *This, int where, int len, off_t *begin,
off_t *end, int boot)
{
int ptr, track;
sector_map_t *map;
int lbegin, lend;
track = where / This->track_size / 1024;
*begin = where - track * This->track_size * 1024;
*end = where + len - track * This->track_size * 1024;
maximize(*end, This->track_size * 1024);
if(This->current_track == track && !boot)
/* already OK, return immediately */
return;
if(!boot)
flush_dirty(This);
This->current_track = track;
if(track) {
for(ptr=0, map=This->map; map->size; map++) {
/* iterate through all sectors */
lbegin = ptr;
lend = ptr + (128 << map->size) / This->sector_size;
for( ; ptr < lend ; ptr++) {
REC.begin = lbegin;
REC.end = lend;
REC.head = map->head;
REC.sector = map->size + 128;
REC.sizecode = map->size;
REC.valid = 0;
REC.dirty = 0;
REC.phantom = 0;
}
}
REC.begin = REC.end = ptr;
} else {
int sector, head;
head = 0;
sector = 0;
for(ptr=boot; ptr < 2 * This->track_size; ptr++) {
REC.begin = ptr;
REC.end = ptr+1;
REC.sizecode = 2;
REC.valid = 0;
REC.dirty = 0;
}
/* boot & 1st fat */
ptr=fill_t0(This, 0, 1 + This->FatSize, &sector, &head);
/* second fat */
ptr=fill_phantoms(This, ptr, This->FatSize);
/* root dir */
ptr=fill_t0(This, ptr, This->RootDirSize, &sector, &head);
/* "bad sectors" at the beginning of the fs */
ptr=fill_phantoms(This, ptr, 5);
if(This->rootskip)
sector++;
/* beginning of the file system */
ptr = fill_t0(This, ptr,
(This->track_size - This->FatSize) * 2 -
This->RootDirSize - 6,
&sector, &head);
}
This->last_sector = ptr;
}
static int xdf_read(Stream_t *Stream, char *buf, mt_off_t where, size_t len)
{
off_t begin, end;
size_t len2;
DeclareThis(Xdf_t);
decompose(This, truncBytes32(where), len, &begin, &end, 0);
len2 = load_data(This, begin, end, 4);
if(len2 < 0)
return len2;
len2 -= begin;
maximize(len, len2);
memcpy(buf, This->buffer + begin, len);
return end - begin;
}
static int xdf_write(Stream_t *Stream, char *buf, mt_off_t where, size_t len)
{
off_t begin, end;
size_t len2;
DeclareThis(Xdf_t);
decompose(This, truncBytes32(where), len, &begin, &end, 0);
len2 = load_bounds(This, begin, end);
if(len2 < 0)
return len2;
maximize(end, len2);
len2 -= begin;
maximize(len, len2);
memcpy(This->buffer + begin, buf, len);
mark_dirty(This, begin, end);
return end - begin;
}
static int xdf_flush(Stream_t *Stream)
{
DeclareThis(Xdf_t);
return flush_dirty(This);
}
static int xdf_free(Stream_t *Stream)
{
DeclareThis(Xdf_t);
Free(This->track_map);
Free(This->buffer);
return close(This->fd);
}
static int check_geom(struct device *dev, int media, struct bootsector *boot)
{
int sect;
if(media >= 0xfc && media <= 0xff)
return 1; /* old DOS */
if (!IS_MFORMAT_ONLY(dev)) {
if(compare(dev->sectors, 19) &&
compare(dev->sectors, 23) &&
compare(dev->sectors, 24) &&
compare(dev->sectors, 46) &&
compare(dev->sectors, 48))
return 1;
/* check against contradictory info from configuration file */
if(compare(dev->heads, 2))
return 1;
}
/* check against info from boot */
if(boot) {
sect = WORD(nsect);
if((sect != 19 && sect != 23 && sect != 24 &&
sect != 46 && sect != 48) ||
(!IS_MFORMAT_ONLY(dev) && compare(dev->sectors, sect)) ||
WORD(nheads) !=2)
return 1;
}
return 0;
}
static void set_geom(struct bootsector *boot, struct device *dev)
{
/* fill in config info to be returned to user */
dev->heads = 2;
dev->use_2m = 0xff;
if(boot) {
dev->sectors = WORD(nsect);
if(WORD(psect))
dev->tracks = WORD(psect) / dev->sectors / 2;
}
}
static int config_geom(Stream_t *Stream, struct device *dev,
struct device *orig_dev, int media,
struct bootsector *boot)
{
if(check_geom(dev, media, boot))
return 1;
set_geom(boot,dev);
return 0;
}
static Class_t XdfClass = {
xdf_read,
xdf_write,
xdf_flush,
xdf_free,
config_geom,
0, /* get_data */
0 /* pre-allocate */
};
Stream_t *XdfOpen(struct device *dev, char *name,
int mode, char *errmsg, struct xdf_info *info)
{
Xdf_t *This;
off_t begin, end;
struct bootsector *boot;
int type;
if(dev && (!SHOULD_USE_XDF(dev) || check_geom(dev, 0, 0)))
return NULL;
This = New(Xdf_t);
if (!This)
return NULL;
This->Class = &XdfClass;
This->sector_size = 512;
This->stretch = 0;
precmd(dev);
This->fd = open(name, mode | dev->mode | O_EXCL | O_NDELAY);
if(This->fd < 0) {
#ifdef HAVE_SNPRINTF
snprintf(errmsg,199,"xdf floppy: open: \"%s\"", strerror(errno));
#else
sprintf(errmsg,"xdf floppy: open: \"%s\"", strerror(errno));
#endif
goto exit_0;
}
closeExec(This->fd);
This->drive = GET_DRIVE(This->fd);
if(This->drive < 0)
goto exit_1;
/* allocate buffer */
This->buffer = (char *) malloc(96 * 512);
if (!This->buffer)
goto exit_1;
This->current_track = -1;
This->track_map = (TrackMap_t *)
calloc(96, sizeof(TrackMap_t));
if(!This->track_map)
goto exit_2;
/* lock the device on writes */
if (lock_dev(This->fd, mode == O_RDWR, dev)) {
#ifdef HAVE_SNPRINTF
snprintf(errmsg,199,"xdf floppy: device \"%s\" busy:",
dev->name);
#else
sprintf(errmsg,"xdf floppy: device \"%s\" busy:",
dev->name);
#endif
goto exit_3;
}
/* Before reading the boot sector, assume dummy values suitable
* for reading at least the boot sector */
This->track_size = 11;
This->track0_size = 6;
This->rate = 0;
This->FatSize = 9;
This->RootDirSize = 1;
decompose(This, 0, 512, &begin, &end, 0);
if (load_data(This, 0, 1, 1) < 0 ) {
This->rate = 0x43;
if(load_data(This, 0, 1, 1) < 0)
goto exit_3;
}
boot = (struct bootsector *) This->buffer;
This->FatSize = WORD(fatlen);
This->RootDirSize = WORD(dirents)/16;
This->track_size = WORD(nsect);
for(type=0; type < NUMBER(xdf_table); type++) {
if(xdf_table[type].track_size == This->track_size) {
This->map = xdf_table[type].map;
This->track0_size = xdf_table[type].track0_size;
This->rootskip = xdf_table[type].rootskip;
break;
}
}
if(type == NUMBER(xdf_table))
goto exit_3;
if(info) {
info->RootDirSize = This->RootDirSize;
info->FatSize = This->FatSize;
info->BadSectors = 5;
}
decompose(This, 0, 512, &begin, &end, 1);
This->refs = 1;
This->Next = 0;
This->Buffer = 0;
if(dev)
set_geom(boot, dev);
return (Stream_t *) This;
exit_3:
Free(This->track_map);
exit_2:
Free(This->buffer);
exit_1:
close(This->fd);
exit_0:
Free(This);
return NULL;
}
#endif
/* Algorithms can't be patented */