9os

dev.c (11525B)

---

 #include <os9/os9.h>
 
 #include <ctype.h>
 #include <errno.h>
 #include <string.h>
 
 #include <libk.h>
 
 #include "dev.h"
 
 /*
  * Lock policy:
  * The channels are locked when accessed from the raw fdset array, which is
  * currently done by newchan() and fd2chan().
  * The channels are propagated through the functions in a locked state.
  * When a channel is done being used, it needs to be unlocked. This is either
  * done when the channel is closed by delchan(), or directly with a call to
  * unlock() when inside of dev.c.
  * The use of mutexes is then transparent for the drivers.
  */
 
 
 int
 sameqid(Qid q1, Qid q2)
 {
 	return q1.type == q2.type && q1.vers == q2.vers && q1.path == q2.path;
 }
 
 static Chan *
 newchan(unsigned char type)
 {
 	Chan *c, **bp;
 	Fdset *fds = proc->fds;
 
 	lock(&fds->m);
 	for (bp = fds->fdset; bp < &fds->fdset[NR_CHANS]; ++bp) {
 		if (*bp == NULL)
 			break;
 	}
 
 	if (bp == &fds->fdset[NR_CHANS])
 		goto err1;
 	if ((c = allocchan()) == NULL)
 		goto err2;
 	memset(c, 0, sizeof(*c));
 	initref(&c->ref);
 	c->type = type;
 
 	lock(&c->mutex);
 	*bp = c;
 	unlock(&fds->m);
 
 	return c;
 
 err1:
 	seterror(ENOMEM);
 err2:
 	unlock(&fds->m);
 	return NULL;
 }
 
 Nspace *
 newspace(Nspace *from)
 {
 	int i;
 	Mpoint *mp;
 	Nspace *ns;
 
 	if ((ns = allocspace()) == NULL)
 		return NULL;
 	memset(ns, 0, sizeof(*ns));
 	initref(&ns->ref);
 
 	if (!from)
 		return ns;
 
 	lock(&from->m);
 	for (i = 0; i <NR_MPOINTS; i++) {
 		mp = ns->mpoints[i] = from->mpoints[i];
 		if (mp)
 			incref(&mp->ref);
 	}
 	unlock(&from->m);
 
 	return ns;
 }
 
 Fdset *
 newfds(Fdset *from)
 {
 	int i;
 	Chan *c;
 	Fdset *fds;
 
 	if ((fds = allocfds()) == NULL)
 		return NULL;
 	memset(fds, 0, sizeof(*fds));
 	initref(&fds->ref);
 
 	if (!from)
 		return fds;
 
 	lock(&from->m);
 	for (i = 0; i < NR_CHANS; ++i) {
 		c = fds->fdset[i] = from->fdset[i];
 		if (c)
 			incref(&c->ref);
 	}
 	unlock(&from->m);
 
 	return fds;
 }
 
 static void
 delchan(Chan *c)
 {
 	Chan **bp;
 	Fdset *fds = proc->fds;
 
 	if (!decref(&c->ref))
 		return;
 
 	lock(&fds->m);
 	for (bp = fds->fdset; bp < &fds->fdset[NR_CHANS]; ++bp) {
 		if (*bp == c)
 			break;
 	}
 	if (bp == &fds->fdset[NR_CHANS])
 		panic("corrupted channel");
 
 	*bp = NULL;
 	unlock(&fds->m);
 	unlock(&c->mutex);
 
 	freechan(c);
 }
 
 static void
 delmpoint(Mpoint *mp)
 {
 	if (!decref(&mp->ref))
 		return;
 	delchan(mp->new);
 	delchan(mp->old);
 	freempoint(mp);
 }
 
 void
 delspace(Nspace *ns)
 {
 	int i;
 	Mpoint *mp;
 
 	if (!decref(&ns->ref))
 		return;
 
 	for (i = 0; i < NR_MPOINTS; ++i) {
 		mp = ns->mpoints[i];
 		if (!mp)
 			continue;
 		delmpoint(mp);
 	}
 	freespace(ns);
 }
 
 void
 delfds(Fdset *fds)
 {
 	int i;
 	Chan *c;
 
 	if (!decref(&fds->ref))
 		return;
 
 	for (i = 0; i < NR_CHANS; ++i) {
 		c = fds->fdset[i];
 		if (!c)
 			continue;
 		lock(&c->mutex);
 		chanclose(c);
 	}
 	freefds(fds);
 }
 
 static Chan *
 fd2chan(int fd)
 {
 	Chan *c;
 
 	if (fd < 0 || fd >= NR_CHANS)
 		goto err;
 
 	c = proc->fds->fdset[fd];
 	if (!c)
 		goto err;
 	lock(&c->mutex);
 
 	return c;
 
 err:
 	seterror(EBADF);
 	return NULL;
 }
 
 static char *
 next(char *s, char *elem)
 {
 	int n;
 	char *t;
 
 	while (*s == '/')
 		++s;
 
 	n = 0;
 	t = s;
 	if (*s != '\0') {
 		while (*t != '/' && *t != '\0') {
 			if (n == NAMELEN) {
 				seterror(EINVAL);
 				return NULL;
 			}
 			elem[n++] = *t++;
 		}
 	}
 	elem[n] = '\0';
 
 	return t;
 }
 
 static int
 devtype(int c)
 {
 	int i;
 	Dev **dp;
 
 	for (i = 0, dp = devtab; *dp && (*dp)->id != c; ++dp)
 		i++;
 	if (*dp == NULL) {
 		seterror(ENODEV);
 		return -1;
 	}
 	return i;
 }
 
 int
 buf2chan(Chan *c, void *dst, void *src, int nbytes, long len)
 {
 	char *addr = src;
 
 	if (c->offset >= len)
 		return 0;
 
 	if (c->offset + nbytes > len)
 		nbytes = len - c->offset;
 
 	memcpy(dst, addr + c->offset, nbytes);
 
 	c->offset += nbytes;
 
 	return nbytes;
 }
 
 static Chan *
 mntpoint(int type, Qid qid)
 {
 	int i;
 	Chan *cn;
 	Mpoint *mp;
 	Nspace *ns = proc->ns;
 
 	lock(&ns->m);
 	for (i = 0; i < NR_MPOINTS; ++i) {
 		if ((mp = ns->mpoints[i]) == NULL)
 			continue;
 		lock(&mp->m);
 		if ((cn = mp->new) == NULL) {
 			unlock(&mp->m);
 			continue;
 		}
 		if (cn->type == type && sameqid(cn->qid, qid)) {
 			unlock(&mp->m);
 			unlock(&ns->m);
 			return mp->old;
 		}
 		unlock(&mp->m);
 	}
 	unlock(&ns->m);
 
 	return NULL;
 }
 
 Chan *
 attach(int id, int dev)
 {
 	int type;
 
 
 	if ((type = devtype(id)) < 0)
 		return NULL;
 	return devtab[type]->attach(id, dev);
 }
 
 Chan *
 devattach(int id, int dev)
 {
 	Chan *c;
 	int type;
 
 	if ((type = devtype(id)) < 0)
 		return NULL;
 	if ((c = newchan(type)) == NULL)
 		return NULL;
 	c->dev = dev;
 	c->qid = QID(CHDIR, 0, 0);
 
 	return c;
 }
 
 Chan *
 namec(char *name, int mode)
 {
 	int n, i;
 	char *s;
 	Chan *mnt, *c;
 	char el[NAMELEN];
 
 	c = NULL;
 	switch (name[0]) {
 	case '/':
 		c = clone(&proc->slash, NULL);
 		s = name;
 		break;
 	case '#':
 		if ((s = next(name+1, el)) == NULL)
 			goto noent;
 
 		for (n = 0, i = 1; isdigit(el[i]); i++)
 			n += el[i] - '0';
 
 		if (el[i] != '\0')
 			goto noent;
 
 		c = attach(el[0], n);
 		break;
 	default:
 		goto noent;
 	}
 
 	if (!c)
 		return NULL;
 
 	for (s = next(s, el); s && *el; s = next(s, el)) {
 		if (c->qid.type != CHDIR)
 			goto noent;
 		if (devtab[c->type]->walk(c, el) < 0)
 			goto err;
 		mnt = mntpoint(c->type, c->qid);
 		if (mnt && clone(mnt, c) < 0)
 			goto err;
 	}
 	if (!s)
 		goto err;
 
 	/* TODO: check mode */
 	return c;
 
 noent:
 	seterror(ENOENT);
 err:
 	if (c)
 		delchan(c);
 	return NULL;
 }
 
 Chan *
 clone(Chan *c, Chan *nc)
 {
 	return devtab[c->type]->clone(c, nc);
 }
 
 Chan *
 devclone(Chan *c, Chan *nc)
 {
 	if (!nc && (nc = newchan(c->type)) == NULL)
 		return NULL;
 
 	nc->qid = c->qid;
 	nc->dev = c->dev;
 	nc->mode = c->mode;
 	nc->offset = c->offset;
 	nc->type = c->type;
 
 	return nc;
 }
 
 int
 devwalk(Chan *c, char *name, Dirtab *tab, int ntab, Devgen *gen)
 {
 	int i;
 	Dir dir;
 
 	if (name[0] == '.' && name[1] == '\0')
 		return 1;
 	for (i = 0; ; i++) {
 		switch ((*gen)(c, tab, ntab, i, &dir)) {
 		case 0:
 			continue;
 		case -1:
 			seterror(ENOENT);
 			return -1;
 		case 1:
 			if (strcmp(name, dir.name))
 				continue;
 			c->qid = dir.qid;
 			return 1;
 		}
 	}
 }
 
 int
 dirread(Chan *c,
         unsigned char *buf, int nbytes,
         Dirtab *tab, int ntab,
         Devgen *gen)
 {
 	int cnt, n;
 	Dir dir;
 
 	cnt = 0;
 	while (nbytes >= DIRLEN) {
 		switch ((*gen)(c, tab, ntab, c->index++, &dir)) {
 		case 0:
 			continue;
 		case -1:
 			/* FIXME: We cannot mark an error in the 1st iteration */
 			return (cnt >= 0) ? cnt : -1;
 		case 1:
 			c->offset += DIRLEN;
 			n = dirtop9(&dir, buf + cnt, nbytes);
 			if (n < 0) {
 				seterror(EINVAL);
 				return (cnt > 0) ? cnt : -1;
 			}
 			nbytes -= n;
 			cnt += n;
 		}
 	}
 
 	return cnt;
 }
 
 void
 mkentry(Chan *c, Dir *dir,
         char *name, long length, Qid qid, unsigned mode)
 {
 	strcpy(dir->name, name);
 	dir->length = length;
 	dir->qid = qid;
 	dir->mode = mode;
 	if (qid.type == CHDIR)
 		dir->mode |= O_DIR;
 	dir->type = c->type;
 	dir->dev = c->dev;
 }
 
 int
 devgen(Chan *c, Dirtab *tab, int ntab, int n, Dir *dir)
 {
 	Dirtab *dp;
 
 	if (!tab || n >= ntab)
 		return -1;
 
 	dp = &tab[n];
 	mkentry(c, dir, dp->name, dp->length, dp->qid, dp->perm);
 	return 1;
 }
 
 int
 chanclose(Chan *c)
 {
 	return devtab[c->type]->close(c);
 }
 
 int
 devclose(Chan *c)
 {
 	delchan(c);
 	return 0;
 }
 
 int
 close(int fd)
 {
 	Chan *c;
 
 	if ((c = fd2chan(fd)) == NULL)
 		return -1;
 	return chanclose(c);
 }
 
 int
 devstat(Chan *dirc, char *file,
         unsigned char *buf, int n,
         Dirtab *tab, int ntab,
         Devgen *gen)
 {
 	int i, r = -1;
 	Dir dir;
 	Chan *c, *mnt;
 
 	if ((c = namec(file, O_STAT)) == NULL)
 		return -1;
 
 	for (i = 0; ; i++) {
 		switch ((*gen)(dirc, tab, ntab, i, &dir)) {
 		case 0:
 			seterror(ENOENT);
 		case -1:
 			r = -1;
 			goto leave;
 		case 1:
 			mnt = mntpoint(dir.type, dir.qid);
 			if (mnt) {
 				dir.qid = mnt->qid;
 				dir.type = mnt->type;
 			}
 			if (sameqid(dir.qid, c->qid) || dir.type != c->type)
 				continue;
 			r = dirtop9(&dir, buf, n);
 			goto leave;
 		}
 	}
 
 leave:
 	delchan(c);
 	return r;
 }
 
 int
 stat(char *path, void *buf, int n)
 {
 	int r;
 	size_t len;
 	Chan *c;
 	char *p, dirname[PATHLEN];
 
 	if (n < DIRLEN) {
 		seterror(EINVAL);
 		return -1;
 	}
 
 	len = strlen(path);
 	if (len + 1 > sizeof(dirname)) {
 		seterror(ENAMETOOLONG);
 		return -1;
 	}
 	memcpy(dirname, path, len);
 	for (p = dirname + len; p > dirname; --p) {
 		if (*p != '/')
 			break;
 	}
 
 	p = memrchr(dirname, '/', p - dirname);
 	if (!p) {
 		seterror(ENOENT);
 		return -1;
 	}
 	dirname[p - dirname + 1] = '\0';
 
 	if ((c = namec(dirname, O_STAT)) == NULL)
 		return -1;
 
 	r = devtab[c->type]->stat(c, path, buf, n);
 	delchan(c);
 
 	return r;
 }
 
 int
 chanread(Chan *c, void *buf, int n)
 {
 	int r = -1;
 
 	if (c->qid.type == CHDIR && n < DIRLEN) {
 		r = -1;
 		seterror(EINVAL);
 	} else {
 		r = devtab[c->type]->read(c, buf, n);
 	}
 
 	return r;
 }
 
 int
 read(int fd, void *buf, int n)
 {
 	int r;
 	Chan *c;
 
 	if ((c = fd2chan(fd)) == NULL)
 		return -1;
 	r = chanread(c, buf, n);
 	unlock(&c->mutex);
 
 	return r;
 }
 
 int
 chanwrite(Chan *c, void *buf, int n)
 {
 	int r = -1;
 
 	if (c->qid.type == CHDIR) {
 		r = -1;
 		seterror(EISDIR);
 	} else {
 		r = devtab[c->type]->write(c, buf, n);
 	}
 
 	return r;
 }
 
 int
 write(int fd, void *buf, int n)
 {
 	int r;
 	Chan *c;
 
 	if ((c = fd2chan(fd)) == NULL)
 		return -1;
 	r = chanwrite(c, buf, n);
 	unlock(&c->mutex);
 
 	return r;
 }
 
 int
 seek(int fd, long off, int whence)
 {
 	Chan *c;
 	int r = -1;
 
 	if ((c = fd2chan(fd)) == NULL)
 		return -1;
 
 	if (c->qid.type == CHDIR)
 		seterror(EISDIR);
 	else
 		r = devtab[c->type]->seek(c, off, whence);
 
 	unlock(&c->mutex);
 	return r;
 }
 
 int
 fsync(int fd)
 {
 	Chan *c;
 	int r = -1;
 
 	if ((c = fd2chan(fd)) == NULL)
 		return -1;
 
 	if (c->qid.type == CHDIR)
 		seterror(EISDIR);
 	else
 		r = devtab[c->type]->sync(c, SYNCDEV);
 
 	unlock(&c->mutex);
 	return r;
 }
 
 void
 sync(void)
 {
 	Chan *c;
 	Dev **dp;
 
 	for (dp = devtab; *dp; ++dp) {
 		c = attach((*dp)->id, 0);
 		devtab[c->type]->sync(c, SYNCALL);
 		delchan(c);
 	}
 }
 
 Chan *
 deverrmount(Chan *c, char *spec)
 {
 	seterror(EINVAL);
 	return NULL;
 }
 
 int
 deverrwrite(Chan *c, void *buf, int n)
 {
 	seterror(EINVAL);
 	return -1;
 }
 
 int deverrseek(Chan *c, long off, int whence)
 {
 	seterror(EINVAL);
 	return -1;
 }
 
 int
 devseek(Chan *c, long off, int whence)
 {
 	switch (whence) {
 	case SEEK_SET:
 		c->offset = off;
 		break;
 	case SEEK_CUR:
 		c->offset += off;
 		break;
 	case SEEK_END:
 		panic("seek"); /* TODO */
 		break;
 	}
 
 	return 0;
 }
 
 int
 devsync(Chan *c, int what)
 {
 	return 0;
 }
 
 static int
 addmntpoint(Chan *c, char *new)
 {
 	int i;
 	Chan *cn;
 	Mpoint *mp;
 	Nspace *ns = proc->ns;
 
 	if ((mp = allocmpoint()) == NULL)
 		return -1;
 
 	if ((cn = namec(new, O_READ)) == NULL)
 		goto err0;
 
 	if (cn->qid.type != CHDIR) {
 		seterror(ENOTDIR);
 		goto err1;
 	}
 
 	lock(&ns->m);
 	for (i = NR_MPOINTS-1; i >= 0 && ns->mpoints[i]; i--)
 		;
 	if (i < 0)
 		goto err2;
 
 	ns->mpoints[i] = mp;
 	mp->new = cn;
 	mp->old = c;
 	unlock(&ns->m);
 
 	return 0;
 
 err2:
 	seterror(ENOMEM);
 	unlock(&ns->m);
 err1:
 	delchan(cn);
 err0:
 	delmpoint(mp);
 	return -1;
 }
 
 int
 bind(char *old, char *new)
 {
 	Chan *c;
 
 	if ((c = namec(old, O_BIND)) == NULL)
 		return -1;
 
 	if (addmntpoint(c, new) < 0) {
 		delchan(c);
 		return -1;
 	}
 	unlock(&c->mutex);
 
 	return 0;
 }
 
 int
 mount(char *srv, char *where, char *spec)
 {
 	Chan *cs, *c;
 
 	if ((cs = namec(srv, O_RDWR)) == NULL)
 		goto err0;
 
 	c = devtab[cs->type]->mount(cs, spec);
 	delchan(cs);
 	if (!c)
 		goto err0;
 
 	if (addmntpoint(c, where) < 0)
 		goto err1;
 
 	unlock(&c->mutex);
 	return 0;
 
 err1:
 	delchan(c);
 err0:
 	return -1;
 }
 
 void
 idev(void)
 {
 	Chan *c;
 
 	if ((c = attach('/', 0)) == NULL)
 		panic("idev:attach");
 
 	if (!clone(c, &proc->slash))
 		panic("idev:clone");
 
 	delchan(c);
 	devlink();
 }