#include <u.h>
#include <libc.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>

typedef struct Part Part;
typedef struct Trip Trip;
typedef struct Dbl Dbl;
typedef struct Ind Ind;

/*
* with 8192-byte blocks and 4-byte pointers,
* double-indirect gets us 34 GB.
* triple-indirect gets us 70,368 GB.
*/

enum
{
       LOGBLKSZ = 13,
       BLKSZ = 1<<LOGBLKSZ,    /* 8192 */
       NPTR = BLKSZ/sizeof(void*),
};
static uchar zero[BLKSZ];

struct Trip
{
       Dbl *dbl[NPTR];
};

struct Dbl
{
       Ind *ind[NPTR];
};

struct Ind
{
       uchar *blk[NPTR];
};

Trip trip;

struct Part
{
       int inuse;
       int vers;
       ulong mode;
       char *name;
       vlong offset;   /* in sectors */
       vlong length;   /* in sectors */
};

enum
{
       Qroot = 0,
       Qdir,
       Qctl,
       Qpart,
};

Part tab[64];
int fd = -1;
char *sdname = "sdXX";
ulong ctlmode = 0666;
char *inquiry = "aux/disksim hard drive";
vlong nsect, sectsize, c, h, s;
ulong time0;
int rdonly;

char*
ctlstring(void)
{
       int i;
       Fmt fmt;

       fmtstrinit(&fmt);
       fmtprint(&fmt, "inquiry %s\n", inquiry);
       fmtprint(&fmt, "geometry %lld %lld %lld %lld %lld\n", nsect, sectsize, c, h, s);
       for(i=0; i<nelem(tab); i++)
               if(tab[i].inuse)
                       fmtprint(&fmt, "part %s %lld %lld\n", tab[i].name, tab[i].offset, tab[i].length);
       return fmtstrflush(&fmt);
}

int
addpart(char *name, vlong start, vlong end)
{
       int i;

       if(start < 0 || start > end || end > nsect){
               werrstr("bad partition boundaries");
               return -1;
       }

       for(i=0; i<nelem(tab); i++)
               if(tab[i].inuse == 0)
                       break;
       if(i == nelem(tab)){
               werrstr("no free partition slots");
               return -1;
       }

       free(tab[i].name);
       tab[i].inuse = 1;
       tab[i].name = estrdup9p(name);
       tab[i].offset = start;
       tab[i].length = end - start;
       tab[i].mode = ctlmode;
       tab[i].vers++;

       return 0;
}

int
delpart(char *s)
{
       int i;

       for(i=0; i<nelem(tab); i++)
               if(tab[i].inuse && strcmp(tab[i].name, s) == 0)
                       break;
       if(i==nelem(tab)){
               werrstr("partition not found");
               return -1;
       }

       tab[i].inuse = 0;
       free(tab[i].name);
       tab[i].name = 0;
       return 0;
}

void
ctlwrite(Req *r)
{
       int i;
       Cmdbuf *cb;
       vlong start, end;

       r->ofcall.count = r->ifcall.count;
       cb = parsecmd(r->ifcall.data, r->ifcall.count);
       if(cb->nf < 1){
               respond(r, "empty control message");
               free(cb);
               return;
       }

       if(strcmp(cb->f[0], "part") == 0){
               if(cb->nf != 4){
                       respondcmderror(r, cb, "part takes 3 args");
                       free(cb);
                       return;
               }
               start = strtoll(cb->f[2], 0, 0);
               end = strtoll(cb->f[3], 0, 0);
               if(addpart(cb->f[1], start, end) < 0){
                       respondcmderror(r, cb, "%r");
                       free(cb);
                       return;
               }
       }
       else if(strcmp(cb->f[0], "delpart") == 0){
               if(cb->nf != 2){
                       respondcmderror(r, cb, "delpart takes 1 arg");
                       free(cb);
                       return;
               }
               if(delpart(cb->f[1]) < 0){
                       respondcmderror(r, cb, "%r");
                       free(cb);
                       return;
               }
       }
       else if(strcmp(cb->f[0], "inquiry") == 0){
               if(cb->nf != 2){
                       respondcmderror(r, cb, "inquiry takes 1 arg");
                       free(cb);
                       return;
               }
               free(inquiry);
               inquiry = estrdup9p(cb->f[1]);
       }
       else if(strcmp(cb->f[0], "geometry") == 0){
               if(cb->nf != 6){
                       respondcmderror(r, cb, "geometry takes 5 args");
                       free(cb);
                       return;
               }
               nsect = strtoll(cb->f[1], 0, 0);
               sectsize = strtoll(cb->f[2], 0, 0);
               c = strtoll(cb->f[3], 0, 0);
               h = strtoll(cb->f[4], 0, 0);
               s = strtoll(cb->f[5], 0, 0);
               if(tab[0].inuse && strcmp(tab[0].name, "data") == 0 && tab[0].vers == 0){
                       tab[0].offset = 0;
                       tab[0].length = nsect;
               }
               for(i=0; i<nelem(tab); i++){
                       if(tab[i].inuse && tab[i].offset+tab[i].length > nsect){
                               tab[i].inuse = 0;
                               free(tab[i].name);
                               tab[i].name = 0;
                       }
               }
       }
       else{
               respondcmderror(r, cb, "unknown control message");
               free(cb);
               return;
       }

       free(cb);
       respond(r, nil);
}

void*
allocblk(vlong addr)
{
       uchar *op;
       static uchar *p;
       static ulong n;

       if(n == 0){
               p = malloc(4*1024*1024);
               if(p == 0)
                       sysfatal("out of memory");
               n = 4*1024*1024;
       }
       op = p;
       p += BLKSZ;
       n -= BLKSZ;
       memset(op, 0, BLKSZ);
       if(fd != -1 && addr != -1)
               pread(fd, op, BLKSZ, addr);
       return op;
}

uchar*
getblock(vlong addr, int alloc)
{
       Dbl *p2;
       Ind *p1;
       uchar *p0;
       uint i0, i1, i2;
       vlong oaddr;

       if(fd >= 0)
               alloc = 1;

       addr >>= LOGBLKSZ;
       oaddr = addr<<LOGBLKSZ;
       i0 = addr % NPTR;
       addr /= NPTR;
       i1 = addr % NPTR;
       addr /= NPTR;
       i2 = addr % NPTR;
       addr /= NPTR;
       assert(addr == 0);

       if((p2 = trip.dbl[i2]) == 0){
               if(!alloc)
                       return zero;
               trip.dbl[i2] = p2 = allocblk(-1);
       }

       if((p1 = p2->ind[i1]) == 0){
               if(!alloc)
                       return zero;
               p2->ind[i1] = p1 = allocblk(-1);
       }

       if((p0 = p1->blk[i0]) == 0){
               if(!alloc)
                       return zero;
               p1->blk[i0] = p0 = allocblk(oaddr);
       }
       return p0;
}

void
dirty(vlong addr, uchar *buf)
{
       vlong oaddr;

       if(fd == -1 || rdonly)
               return;
       oaddr = addr&~((vlong)BLKSZ-1);
       if(pwrite(fd, buf, BLKSZ, oaddr) != BLKSZ)
               sysfatal("write: %r");
}

int
rootgen(int off, Dir *d, void*)
{
       memset(d, 0, sizeof *d);
       d->atime = time0;
       d->mtime = time0;
       if(off == 0){
               d->name = estrdup9p(sdname);
               d->mode = DMDIR|0777;
               d->qid.path = Qdir;
               d->qid.type = QTDIR;
               d->uid = estrdup9p("disksim");
               d->gid = estrdup9p("disksim");
               d->muid = estrdup9p("");
               return 0;
       }
       return -1;
}

int
dirgen(int off, Dir *d, void*)
{
       int n, j;

       memset(d, 0, sizeof *d);
       d->atime = time0;
       d->mtime = time0;
       if(off == 0){
               d->name = estrdup9p("ctl");
               d->mode = ctlmode;
               d->qid.path = Qctl;
               goto Have;
       }

       off--;
       n = 0;
       for(j=0; j<nelem(tab); j++){
               if(tab[j].inuse==0)
                       continue;
               if(n == off){
                       d->name = estrdup9p(tab[j].name);
                       d->length = tab[j].length*sectsize;
                       d->mode = tab[j].mode;
                       d->qid.path = Qpart+j;
                       d->qid.vers = tab[j].vers;
                       goto Have;
               }
               n++;
       }
       return -1;

Have:
       d->uid = estrdup9p("disksim");
       d->gid = estrdup9p("disksim");
       d->muid = estrdup9p("");
       return 0;
}

void*
evommem(void *a, void *b, ulong n)
{
       return memmove(b, a, n);
}

int
isnonzero(void *v, ulong n)
{
       uchar *a, *ea;

       a = v;
       ea = a+n;
       for(; a<ea; a++)
               if(*a)
                       return 1;
       return 0;
}

int
rdwrpart(Req *r)
{
       int q, nonzero;
       Part *p;
       vlong offset;
       long count, tot, n, o;
       uchar *blk, *dat;
       void *(*move)(void*, void*, ulong);

       q = r->fid->qid.path-Qpart;
       if(q < 0 || q > nelem(tab) || !tab[q].inuse || tab[q].vers != r->fid->qid.vers){
               respond(r, "unknown partition");
               return -1;
       }

       p = &tab[q];
       offset = r->ifcall.offset;
       count = r->ifcall.count;
       if(offset < 0){
               respond(r, "negative offset");
               return -1;
       }
       if(count < 0){
               respond(r, "negative count");
               return -1;
       }
       if(offset > p->length*sectsize){
               respond(r, "offset past end of partition");
               return -1;
       }
       if(offset+count > p->length*sectsize)
               count = p->length*sectsize - offset;
       offset += p->offset*sectsize;

       if(r->ifcall.type == Tread)
               move = memmove;
       else
               move = evommem;

       tot = 0;
       nonzero = 1;
       if(r->ifcall.type == Tread)
               dat = (uchar*)r->ofcall.data;
       else{
               dat = (uchar*)r->ifcall.data;
               nonzero = isnonzero(dat, r->ifcall.count);
       }
       o = offset & (BLKSZ-1);

       /* left fringe block */
       if(o && count){
               blk = getblock(offset, r->ifcall.type==Twrite && nonzero);
               n = BLKSZ - o;
               if(n > count)
                       n = count;
               if(r->ifcall.type != Twrite || blk != zero)
                       (*move)(dat, blk+o, n);
               if(r->ifcall.type == Twrite)
                       dirty(offset, blk);
               tot += n;
       }
       /* full and right fringe blocks */
       while(tot < count){
               blk = getblock(offset+tot, r->ifcall.type==Twrite && nonzero);
               n = BLKSZ;
               if(n > count-tot)
                       n = count-tot;
               if(r->ifcall.type != Twrite || blk != zero)
                       (*move)(dat+tot, blk, n);
               if(r->ifcall.type == Twrite)
                       dirty(offset+tot, blk);
               tot += n;
       }
       r->ofcall.count = tot;
       respond(r, nil);
       return 0;
}

void
fsread(Req *r)
{
       char *s;

       switch((int)r->fid->qid.path){
       case Qroot:
               dirread9p(r, rootgen, nil);
               respond(r, nil);
               break;

       case Qdir:
               dirread9p(r, dirgen, nil);
               respond(r, nil);
               break;

       case Qctl:
               s = ctlstring();
               readstr(r, s);
               free(s);
               respond(r, nil);
               break;

       default:
               rdwrpart(r);
               break;
       }
}

void
fswrite(Req *r)
{
       switch((int)r->fid->qid.path){
       case Qroot:
       case Qdir:
               respond(r, "write to a directory?");
               break;

       case Qctl:
               ctlwrite(r);
               break;

       default:
               rdwrpart(r);
               break;
       }
}

void
fsopen(Req *r)
{
       if(r->ifcall.mode&ORCLOSE)
               respond(r, "cannot open ORCLOSE");

       switch((int)r->fid->qid.path){
       case Qroot:
       case Qdir:
               if(r->ifcall.mode != OREAD){
                       respond(r, "bad mode for directory open");
                       return;
               }
       }

       respond(r, nil);
}

void
fsstat(Req *r)
{
       int q;
       Dir *d;
       Part *p;

       d = &r->d;
       memset(d, 0, sizeof *d);
       d->qid = r->fid->qid;
       d->atime = d->mtime = time0;
       q = r->fid->qid.path;
       switch(q){
       case Qroot:
               d->name = estrdup9p("/");
               d->mode = DMDIR|0777;
               break;

       case Qdir:
               d->name = estrdup9p(sdname);
               d->mode = DMDIR|0777;
               break;

       default:
               q -= Qpart;
               if(q < 0 || q > nelem(tab) || tab[q].inuse==0 || r->fid->qid.vers != tab[q].vers){
                       respond(r, "partition no longer exists");
                       return;
               }
               p = &tab[q];
               d->name = estrdup9p(p->name);
               d->length = p->length * sectsize;
               d->mode = p->mode;
               break;
       }

       d->uid = estrdup9p("disksim");
       d->gid = estrdup9p("disksim");
       d->muid = estrdup9p("");
       respond(r, nil);
}

void
fsattach(Req *r)
{
       char *spec;

       spec = r->ifcall.aname;
       if(spec && spec[0]){
               respond(r, "invalid attach specifier");
               return;
       }
       r->ofcall.qid = (Qid){Qroot, 0, QTDIR};
       r->fid->qid = r->ofcall.qid;
       respond(r, nil);
}

char*
fswalk1(Fid *fid, char *name, Qid *qid)
{
       int i;
       switch((int)fid->qid.path){
       case Qroot:
               if(strcmp(name, sdname) == 0){
                       fid->qid.path = Qdir;
                       fid->qid.type = QTDIR;
                       *qid = fid->qid;
                       return nil;
               }
               break;
       case Qdir:
               if(strcmp(name, "ctl") == 0){
                       fid->qid.path = Qctl;
                       fid->qid.vers = 0;
                       fid->qid.type = 0;
                       *qid = fid->qid;
                       return nil;
               }
               for(i=0; i<nelem(tab); i++){
                       if(tab[i].inuse && strcmp(tab[i].name, name) == 0){
                               fid->qid.path = i+Qpart;
                               fid->qid.vers = tab[i].vers;
                               fid->qid.type = 0;
                               *qid = fid->qid;
                               return nil;
                       }
               }
               break;
       }
       return "file not found";
}

Srv fs = {
       .attach=        fsattach,
       .open=  fsopen,
       .read=  fsread,
       .write= fswrite,
       .stat=  fsstat,
       .walk1= fswalk1,
};

char *mtpt = "/dev";
char *srvname;

void
usage(void)
{
       fprint(2, "usage: aux/disksim [-D] [-f file] [-s srvname] [-m mtpt] [sdXX]\n");
       fprint(2, "\tdefault mtpt is /dev\n");
       exits("usage");
}

void
main(int argc, char **argv)
{
       char *file;

       file = nil;
       quotefmtinstall();
       time0 = time(0);

       ARGBEGIN{
       case 'D':
               chatty9p++;
               break;
       case 'f':
               file = EARGF(usage());
               break;
       case 'r':
               rdonly = 1;
               break;
       case 's':
               srvname = EARGF(usage());
               break;
       case 'm':
               mtpt = EARGF(usage());
               break;
       default:
               usage();
       }ARGEND

       if(argc > 1)
               usage();
       if(argc == 1)
               sdname = argv[0];

       if(file){
               if((fd = open(file, rdonly ? OREAD : ORDWR)) < 0)
                       sysfatal("open %s: %r", file);
       }

       inquiry = estrdup9p(inquiry);
       tab[0].name = estrdup9p("data");
       tab[0].inuse = 1;
       tab[0].mode = 0666;

       postmountsrv(&fs, srvname, mtpt, MBEFORE);
       exits(nil);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.