vx32

devram.c (6712B)

---

 #include	"u.h"
 #include	"lib.h"
 #include	"mem.h"
 #include	"dat.h"
 #include	"fns.h"
 #include	"error.h"
 
 #include	"netif.h"
 
 typedef struct Ram	Ram;
 struct Ram
 {
 	QLock lk;
 	Ram	*next;
 	int	ref;
 	/* simple for now */
 	uchar **pages;
 	int pagecount;
 	int size;
 	int	qref[2];
 	ulong	path;
 };
 
 struct
 {
 	Lock lk;
 	ulong	path;
 } ramalloc;
 
 enum
 {
 	Qdir,
 	Qdata0,
 	Qctl,
 };
 
 Dirtab ramdir[] =
 {
 	".",		{Qdir,0,QTDIR},	0,		DMDIR|0500,
 	"data",		{Qdata0},	0,		0600,
 	"ctl",	{Qctl},	0,		0600,
 };
 #define NPIPEDIR 3
 
 static void
 raminit(void)
 {
 }
 
 /*
  *  create a ram, no streams are created until an open
  */
 static Chan*
 ramattach(char *spec)
 {
 	Ram *p;
 	Chan *c;
 
 	c = devattach('R', spec);
 	p = malloc(sizeof(Ram));
 	if(p == 0)
 		exhausted("memory");
 	p->ref = 1;
 	p->size = 0;
 	p->pagecount = 1;
 	p->pages = mallocz(sizeof(char *), 1);
 	p->pages[0] = mallocz(BY2PG, 1);
 	lock(&ramalloc.lk);
 	p->path = ++ramalloc.path;
 	unlock(&ramalloc.lk);
 
 	mkqid(&c->qid, NETQID(2*p->path, Qdir), 0, QTDIR);
 	c->aux = p;
 	c->dev = 0;
 	return c;
 }
 
 static int
 ramgen(Chan *c, char *name, Dirtab *tab, int ntab, int i, Dir *dp)
 {
 	Qid q;
 	int len;
 	Ram *p;
 
 	if(i == DEVDOTDOT){
 		devdir(c, c->qid, "#R", 0, eve, DMDIR|0555, dp);
 		return 1;
 	}
 	i++;	/* skip . */
 	if(tab==0 || i>=ntab)
 		return -1;
 
 	tab += i;
 	p = c->aux;
 	switch((ulong)tab->qid.path){
 	case Qdata0:
 		len = p->size;
 		break;
 	case Qctl:
 		len = 0;
 		break;
 	default:
 		len = tab->length;
 		break;
 	}
 	mkqid(&q, NETQID(NETID(c->qid.path), tab->qid.path), 0, QTFILE);
 	devdir(c, q, tab->name, len, eve, tab->perm, dp);
 	return 1;
 }
 
 
 static Walkqid*
 ramwalk(Chan *c, Chan *nc, char **name, int nname)
 {
 	Walkqid *wq;
 	Ram *p;
 
 	wq = devwalk(c, nc, name, nname, ramdir, NPIPEDIR, ramgen);
 	if(wq != nil && wq->clone != nil && wq->clone != c){
 		p = c->aux;
 		qlock(&p->lk);
 		p->ref++;
 		if(c->flag & COPEN){
 			print("channel open in ramwalk\n");
 			switch(NETTYPE(c->qid.path)){
 			case Qdata0:
 				p->qref[0]++;
 				break;
 			case Qctl:
 				p->qref[1]++;
 				break;
 			}
 		}
 		qunlock(&p->lk);
 	}
 	return wq;
 }
 
 static int
 ramstat(Chan *c, uchar *db, int n)
 {
 	Ram *p;
 	Dir dir;
 
 	p = c->aux;
 
 	switch(NETTYPE(c->qid.path)){
 	case Qdir:
 		devdir(c, c->qid, ".", 0, eve, DMDIR|0555, &dir);
 		break;
 	case Qdata0:
 		devdir(c, c->qid, "data", p->size, eve, 0600, &dir);
 		break;
 	case Qctl:
 		devdir(c, c->qid, "ctl", 0, eve, 0600, &dir);
 		break;
 	default:
 		panic("ramstat");
 	}
 	n = convD2M(&dir, db, n);
 	if(n < BIT16SZ)
 		error(Eshortstat);
 	return n;
 }
 
 /*
  *  if the stream doesn't exist, create it
  */
 static Chan*
 ramopen(Chan *c, int omode)
 {
 	Ram *p;
 
 	if(c->qid.type & QTDIR){
 		if(omode != OREAD)
 			error(Ebadarg);
 		c->mode = omode;
 		c->flag |= COPEN;
 		c->offset = 0;
 		return c;
 	}
 
 	p = c->aux;
 	qlock(&p->lk);
 	switch(NETTYPE(c->qid.path)){
 	case Qdata0:
 		p->qref[0]++;
 		break;
 	case Qctl:
 		p->qref[1]++;
 		break;
 	}
 	qunlock(&p->lk);
 
 	c->mode = openmode(omode);
 	c->flag |= COPEN;
 	c->offset = 0;
 	c->iounit = qiomaxatomic;
 	return c;
 }
 
 static void
 ramclose(Chan *c)
 {
 	Ram *p;
 
 	p = c->aux;
 	qlock(&p->lk);
 
 	if(c->flag & COPEN){
 		switch(NETTYPE(c->qid.path)){
 		case Qdata0:
 			p->qref[0]--;
 			break;
 		case Qctl:
 			p->qref[1]--;
 			break;
 		}
 	}
 
 	/*
 	 *  free the structure on last close
 	 */
 	p->ref--;
 	if(p->ref == 0){
 		int i;
 		qunlock(&p->lk);
 		for(i = 0; i < p->pagecount; i++)
 			free(p->pages[i]);
 		free(p->pages);
 		free(p);
 	} else
 		qunlock(&p->lk);
 }
 
 static long 
 rampageread(Ram *p, void *va, long n, vlong offset)
 {
 	int i;
 	long total, offinpage, leninpage;
 
 	total = n;
 
 	/* figure out what range we can actually read */
 	if(offset > p->size)
 		return 0;
 	if(offset + n > p->size) 
 		n = p->size - offset;
 	/* granular copy */
 	for(i = offset / BY2PG; n > 0; i++) {
 		/* i is the page */
 		offinpage = offset & (BY2PG - 1);
 		leninpage = BY2PG - offinpage;
 		/* unless there is too little left ... */
 		if(leninpage > n)
 			leninpage = n;
 		memcpy(va, p->pages[i] + offinpage, leninpage);
 		offset += offinpage;
 		n -= leninpage; 
 		va += leninpage;
 	}
 	return total;
 }
 
 static long
 ramread(Chan *c, void *va, long n, vlong offset)
 {
 	Ram *p;
 	char *buf, *s, *e;
 
 	p = c->aux;
 
 	switch(NETTYPE(c->qid.path)){
 	case Qdir:
 		return devdirread(c, va, n, ramdir, NPIPEDIR, ramgen);
 	case Qdata0:
 		return rampageread(p, va, n, offset);
 	case Qctl:
 		buf = smalloc(8192);
 		s = buf;
 		e = buf + 8192;
 		s = seprint(s, e, "pages %p count %d ", p->pages, p->pagecount);
 		seprint(s, e, "size %d\n", p->size);
 		n = readstr(offset, va, n, buf);
 		free(buf);
 		return n;
 	default:
 		panic("ramread");
 	}
 	return -1;	/* not reached */
 }
 
 /* for the range offset .. offset + n, make sure we have pages */
 static 
 void pages(Ram *p, long n, vlong offset)
 {
 	int i;
 	int newpagecount;
 	uchar **newpages;
 
 	newpagecount = (offset + n + BY2PG-1)/BY2PG;
 	if(newpagecount > p->pagecount) {
 		newpages = mallocz(sizeof(char *) * newpagecount, 1);
 		if(!newpages)
 			error("No more pages in devram");
 		memcpy(newpages, p->pages, sizeof(char *) * p->pagecount);
 		free(p->pages);
 		p->pages = newpages;
 		p->pagecount = newpagecount;
 		/* now allocate them */
 		for(i = offset / BY2PG; i < newpagecount; i++) {
 			if(p->pages[i])
 				continue;
 			p->pages[i] = mallocz(BY2PG, 1);
 		}
 	}
 }
 
 static long 
 rampagewrite(Ram *p, void *va, long n, vlong offset)
 {
 	int i;
 	long total, offinpage, leninpage;
 	long newsize;
 
 	total = n;
 	pages(p, n, offset);
 	
 	/* granular copy */
 	newsize = offset + n;
 	for(i = offset / BY2PG; n > 0; i++) {
 		/* i is the page */
 		offinpage = offset & (BY2PG - 1);
 		leninpage = BY2PG - offinpage;
 		/* unless there is too little left ... */
 		if(leninpage > n)
 			leninpage = n;
 		memcpy(p->pages[i] + offinpage, va, leninpage);
 		offset += leninpage;
 		n -= leninpage; 
 		va += leninpage;
 	}
 	p->size = newsize > p->size? newsize : p->size;
 	return total;
 }
 static long
 ramwrite(Chan *c, void *va, long n, vlong offset)
 {
 	Ram *p;
 	int i;
 	uchar **new;
 	uchar *page;
 
 	if(!islo())
 		print("ramwrite hi %lux\n", getcallerpc(&c));
 	p = c->aux;
 	switch(NETTYPE(c->qid.path)){
 	case Qdata0:
 		n = rampagewrite(p, va, n, offset);
 		break;
 
 	case Qctl:
 		if(strcmp(va, "free") == 0) {
 			new = mallocz(sizeof(char *), 1);
 			page = p->pages[0];
 			for(i = 1; i < p->pagecount; i++)
 				free(p->pages[i]);
 			free(p->pages);
 			p->pages = new;
 			p->pages[0] = page;
 			p->size = 0;
 			p->pagecount = 1;
 		} else {
 			error("bad command");
 		}
 		break;
 
 	default:
 		panic("ramwrite");
 	}
 
 	return n;
 }
 
 
 Dev ramdevtab = {
 	'R',
 	"ram",
 
 	devreset,
 	raminit,
 	devshutdown,
 	ramattach,
 	ramwalk,
 	ramstat,
 	ramopen,
 	devcreate,
 	ramclose,
 	ramread,
 	devbread,
 	ramwrite,
 	devbwrite,
 	devremove,
 	devwstat,
 };