The Atari Compendium/The Atari Compendium (Toad Computers) (1994).iso/files/prgtools/mint/filesy~1/mfs610s.zoo/fsck/io.c

C/C++ Source or Header | 1994-05-13 | 4.7 KB | 185 lines

/* The functions read_blocks(start,count,buff) and write_blocks(), read/write
 * 'count' 1K blocks from disk starting at block 'start' into the buffer
 * pointed to by 'buff' . The function init_device(name,rw) initialises the
 * device 'name' so that read_blocks() and write_blocks() use it. Since this
 * is called once initially, any other machine dependent initialisation can be
 * put here, if it returns non-zero then the operation failed. If 'rw' is not
 * zero, write access is sought also for this device. The function set_size is
 * used to tell the I/O routines the size of the filesystems being accessed,
 * so any special arrangements can be made. If this function returns non-zero
 * then the operation failed and the filesystem cannot be accessed.
 */

#ifdef atarist

#include <stdio.h>
#include <mintbind.h>
#include "fs.h"
#include "global.h"
#include "proto.h"

int _device,_write_ok,shift;

void read_blocks(start,count,buff)
long start;
unsigned count;
void *buff;
{

    long ret;
    ret=block_rwabs(0,buff,count,start,&hdinf);
    if(ret) printf("Rwabs read returned %ld\n",ret);
}

void write_blocks(start,count,buff)
long start;
unsigned count;
void *buff;
{
    long ret;
if(start==0){
 printf("Illegal Write\n");
return;
}
    if(!_write_ok)
    {
        printf("Internal error : Illegal write\n");
        printf("Start %ld Count %d\n",(long)start,count);
        return;
    }
    modified=1;
    ret=block_rwabs(1,buff,count,start,&hdinf);
    if(ret) printf("Rwabs write returned %ld\n",ret);
}

/* Constants for fscntl */

#define MFS_BASE    0x100
#define MFS_VERIFY    (MFS_BASE)    /* Return minixfs magic number */
#define MFS_SYNC    (MFS_BASE|0x01)    /* Sync the filesystem */
#define MFS_CINVALID    (MFS_BASE|0x02)    /* Invalidate cache entries */
#define MFS_FINVALID    (MFS_BASE|0x03)    /* Invalidate Fileptrs */
#define MFS_INFO    (MFS_BASE|0x04)    /* Get info about filesystem */
#define MFS_USAGE    (MFS_BASE|0x05)    /* Get block allocation of a file */
#define MFS_IMODE    (MFS_BASE|0x06)    /* Change all bits in an inode mode */
#define MFS_GTRANS    (MFS_BASE|0x07) /* Get filename translation mode */
#define MFS_STRANS    (MFS_BASE|0x08) /* Set filename translation mode */
#define MFS_PHYS    (MFS_BASE|0x09) /* Get physical partition info */
#define MFS_IADDR    (MFS_BASE|0x0a) /* Get start address of minixfs */
#define MFS_UPDATE    (MFS_BASE|0x0b) /* Update daemon controls */
#define MFS_MOUNT    (MFS_BASE|0x0c) /* Mount a filesystem */
#define MFS_UMOUNT    (MFS_BASE|0x0d) /* Umount a filesystem */

#define MFS_MAGIC    0x18970431    /* Magic number from MFS_VERIFY */


int init_device(name,rw)
char *name;
int rw;
{
    long err;
    struct
    {
        long start;
        long finish;
        char shadow;
        char scsiz;
    } pp;
    _device=(name[0]-'A') & ~32;
    if( (_device < 0) || (_device > 32) || name[1]!=':' )
    {
        fprintf(stderr,"Invalid drive name %s\n",name);
        return 1;
    }

    if( Dcntl(MFS_VERIFY,name,&err) || err!=MFS_MAGIC )
    {
        fprintf(stderr,"Not recognised Minixfs partition or Minixfs not running\n");
        if(!ask("Continue?","Ignored")) return 1;
    }

    if( !Dcntl(MFS_PHYS,name,&pp) && pp.start!=-1)
    /* Is this a physical partition ? */
    {
        long tstack;
        hdinf.start=pp.start;
        hdinf.size=pp.finish-hdinf.start+1;
        hdinf.scsiz=pp.scsiz;
        hdinf.drive=_device;
        hdinf.major = pp.shadow;
        (void)Getbpb(_device);     /* Satisfy disk changes */
        hdinf.rwmode = RW_PHYS;
        tstack=Super(0l);
        if(init_icd()==2)
        {
            Super(tstack);
            fprintf(stderr,"Can't patch ICD bug\n");
            return 1;
        }
        Super(tstack);

        if(hdinf.start > 0xfff0)
        {
            if(no_plrecno(hdinf.major)) return 1;
            hdinf.rwmode |= RW_LRECNO;
        }
    }
    else if( (err=get_hddinf(_device,&hdinf,0)) )
    {
        fprintf(stderr,"Drive %s %s\n",name,hdd_err[err]);
        return 1;
    }

    if(rw) _write_ok=1;

    Dcntl(MFS_UPDATE,name,1);    /* Suspend update */
    /* Sync the filesytem and lock the device */
    if( Dcntl(MFS_SYNC,name,0) || Dlock(1,_device) )
    {
        fprintf(stderr,"Couldn't sync or lock device %s.\n",name);
        if(ask("Continue?","Ignored"))
            fprintf(stderr,"Warning: reboot after running.\n");
        else
        {
            close_device();
            return 1;
        }
    }
    return 0;
}

void close_device()
{
    extern char *drvnam;
    (void) Dlock(0,_device);    /* Unlock drive */
    Dcntl(MFS_UPDATE,drvnam,2);        /* Restart update */
}

int set_size(nblocks)
long nblocks;
{
    long err,tsize;

    tsize=hdinf.size;
    err = set_lrecno(&hdinf,nblocks);

    if(err)
    {
        fprintf(stderr,"set_size %s\n",hdd_err[err]);
        return err;
    }

    if( !tsize && no_size)
    {
        if( (err=get_size(hdinf.drive,&tsize)) )
            fprintf(stderr,"get_size: warning %s\n",size_err[err]);
        else if( tsize!=nblocks ) fprintf(stderr,"Warning filesystem "
                 "size %ldK, Expected %ldK\n",nblocks,tsize);
    }

    return 0;

}

#endif