harvey/sys/src/cmd/aux/disksim.c

#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 */
	LOGNPTR = LOGBLKSZ-2,	/* assume sizeof(void*) == 4 */
	NPTR = 1<<LOGNPTR,
};

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];

char *sdname = "sdXX";
ulong ctlmode = 0666;
char *inquiry = "aux/disksim hard drive";
vlong nsect, sectsize, c, h, s;
ulong time0;

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(void)
{
	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);
	return op;
}

uchar*
getblock(vlong addr, int alloc)
{
	static uchar zero[BLKSZ];
 	Dbl *p2;
	Ind *p1;
	uchar *p0;
	uint i0, i1, i2;

	addr >>= LOGBLKSZ;
	i0 = addr & (NPTR-1);
	addr >>= LOGNPTR;
	i1 = addr & (NPTR-1);
	addr >>= LOGNPTR;
	i2 = addr & (NPTR-1);
	addr >>= LOGNPTR;
	assert(addr == 0);

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

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

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

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
rdwrpart(Req *r)
{
	int q;
	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;
	if(r->ifcall.type == Tread)
		dat = (uchar*)r->ofcall.data;
	else
		dat = (uchar*)r->ifcall.data;
	o = offset & (BLKSZ-1);

	/* left fringe block */
	if(o && count){	
		blk = getblock(offset, r->ifcall.type==Twrite);
		if(blk == nil)
			abort();
		n = BLKSZ - o;
		if(n > count)
			n = count;
		(*move)(dat, blk+o, n);
		tot += n;
	}
	/* full and right fringe blocks */
	while(tot < count){
		blk = getblock(offset+tot, r->ifcall.type==Twrite);
		if(blk == nil)
			abort();
		n = BLKSZ;
		if(n > count)
			n = count;
		(*move)(dat+tot, blk, n);
		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] [-s srvname] [-m mtpt] [sdXX]\n");
	fprint(2, "\tdefault mtpt is /dev\n");
	exits("usage");
}

void
main(int argc, char **argv)
{
	quotefmtinstall();
	time0 = time(0);
	if(NPTR != BLKSZ/sizeof(void*))
		sysfatal("unexpected pointer size");

	ARGBEGIN{
	case 'D':
		chatty9p++;
		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];

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

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