xdf_io.c

Go to the documentation of this 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 */

---