kern/drivers/dev/misc.c - upstream - Git at Google

 #include <vfs.h>
 #include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
 #include <string.h>
 #include <stdio.h>
 #include <assert.h>
 #include <error.h>
 #include <cpio.h>
 #include <pmap.h>
 #include <smp.h>

 enum {
 	Qdir,
 	Qbintime,
 	Qcons,
 	Qconsctl,
 	Qcputime,
 	Qdrivers,
 	Qkmesg,
 	Qkprint,
 	Qhostdomain,
 	Qhostowner,
 	Qnull,
 	Qosversion,
 	Qpgrpid,
 	Qpid,
 	Qppid,
 	Qrandom,
 	Qreboot,
 	Qswap,
 	Qsysname,
 	Qsysstat,
 	Qtime,
 	Quser,
 	Qzero,
 	Qdebug,
 };

 enum {
 	VLNUMSIZE = 22,
 };

 static struct dirtab consdir[] = {
 	{".", {Qdir, 0, QTDIR}, 0, DMDIR | 0555},
 	{"bintime", {Qbintime}, 24, 0664},
 	{"cputime", {Qcputime}, 6 * NUMSIZE, 0444},
 	{"drivers", {Qdrivers}, 0, 0444},
 	//  {"hostdomain",  {Qhostdomain},  DOMLEN,     0664},
 	{"hostowner", {Qhostowner}, 0, 0664},
 	{"kmesg",	{Qkmesg},	0,		0444,},
 	{"null", {Qnull}, 0, 0666},
 	{"osversion", {Qosversion}, 0, 0444},
 	{"pgrpid", {Qpgrpid}, NUMSIZE, 0444},
 	{"pid", {Qpid}, NUMSIZE, 0444},
 	{"ppid", {Qppid}, NUMSIZE, 0444},
 	{"random", {Qrandom}, 0, 0444},
 	{"reboot", {Qreboot}, 0, 0664},
 	{"swap", {Qswap}, 0, 0664},
 	{"sysname", {Qsysname}, 0, 0664},
 	{"sysstat", {Qsysstat}, 0, 0666},
 	{"time", {Qtime}, NUMSIZE + 3 * VLNUMSIZE, 0664},
 	{"user", {Quser}, 0, 0666},
 	{"zero", {Qzero}, 0, 0444},
 	{"debug", {Qdebug}, 0, 0666},
 };

 static void consinit(void)
 {
 	void randominit(void);
 	printk("consinit\n");
 	randominit();
 }

 static uint32_t randn;

 static void
 seedrand(void)
 {
 	ERRSTACK(1);
 	if(!waserror()){
 		randomread((void*)&randn, sizeof(randn));
 		poperror();
 	}
 }

 int
 nrand(int n)
 {
 	if(randn == 0)
 		seedrand();
 	randn = randn*1103515245 + 12345 + tsc2msec(read_tsc_serialized());
 	return (randn>>16) % n;
 }

 int
 rand(void)
 {
 	nrand(1);
 	return randn;
 }

 static struct chan *consattach(char *spec)
 {
 	return devattach('c', spec);
 }

 static struct walkqid *conswalk(struct chan *c, struct chan *nc, char **name,
 								int nname)
 {
 	return devwalk(c, nc, name, nname, consdir, ARRAY_SIZE(consdir), devgen);
 }

 static long
 consstat(struct chan *c, uint8_t * dp, long n)
 {
 	return devstat(c, dp, n, consdir, ARRAY_SIZE(consdir), devgen);
 }

 static struct chan *consopen(struct chan *c, int omode)
 {
 	c->aux = NULL;
 	c = devopen(c, omode, consdir, ARRAY_SIZE(consdir), devgen);
 	return c;
 }

 static void consclose(struct chan *c)
 {
 }

 /* we do it this way to avoid the many fun deadlock opportunities
  * we keep hitting. And, if you don't suck it
  * out soon enough, you lost it. No real effort to ensure goodness
  * here as it can get called anywhere. Barret will fix it.
  */
 static uint8_t logbuffer[1<<20];
 static int index = 0;
 static struct queue *logqueue = NULL;
 static int reading_kmesg = 0;
 void logbuf(int c)
 {
 	if (reading_kmesg)
 		return;
 	if (index > 1<<20)
 		return;
 	logbuffer[index++] = c;
 }

 static long
 consread(struct chan *c, void *buf, long n, int64_t off)
 {
 	uint32_t l;
 	char *b, *bp, ch, *s, *e;
 	char tmp[512];				/* Qswap is 381 bytes at clu */
 	int i, k, id, send;
 	long offset, nread;

 	if (n <= 0)
 		return n;

 	nread = n;
 	offset = off;
 	switch ((uint32_t) c->qid.path) {
 		case Qdir:
 			return devdirread(c, buf, n, consdir, ARRAY_SIZE(consdir), devgen);

 		case Qcputime:
 			error("not now");
 #if 0
 			k = offset;
 			if (k >= 6 * NUMSIZE)
 				return 0;
 			if (k + n > 6 * NUMSIZE)
 				n = 6 * NUMSIZE - k;
 			/* easiest to format in a separate buffer and copy out */
 			for (i = 0; i < 6 && NUMSIZE * i < k + n; i++) {
 				l = current->time[i];
 				if (i == TReal)
 					l = sys->ticks - l;
 				l = TK2MS(l);
 				readnum(0, tmp + NUMSIZE * i, NUMSIZE, l, NUMSIZE);
 			}
 			memmove(buf, tmp + k, n);
 #endif
 			return n;

 		case Qkmesg:
 			/* the queue gives us some elasticity for log reading. */
 			if (! logqueue)
 				logqueue = qopen(1<<20, 0, 0, 0);
 			if (logqueue){
 				int ret;
 				/* atomic sets/gets are not that important in this case. */
 				reading_kmesg = 1;
 				qwrite(logqueue, logbuffer, index);
 				index = 0;
 				ret = qread(logqueue, buf, n);
 				reading_kmesg = 0;
 				return ret;
 			}
 			break;
 #if 0
 		case Qkprint:
 			return qread(kprintoq, buf, n);
 #endif
 		case Qpgrpid:
 			return readnum(offset, buf, n, current->pgrp->pgrpid, NUMSIZE);

 		case Qpid:
 			return readnum(offset, buf, n, current->pid, NUMSIZE);
 #if 0
 		case Qppid:
 			return readnum(offset, buf, n, current->parentpid, NUMSIZE);

 		case Qtime:
 			return readtime(offset, buf, n);

 		case Qbintime:
 			return readbintime(buf, n);

 		case Qhostowner:
 			return readstr(offset, buf, n, eve);

 		case Qhostdomain:
 			return readstr(offset, buf, n, hostdomain);

 		case Quser:
 			return readstr(offset, buf, n, current->user);
 #endif
 		case Qnull:
 			return 0;
 #if 0
 		case Qsysname:
 			if (sysname == NULL)
 				return 0;
 			return readstr(offset, buf, n, sysname);
 #endif
 		case Qrandom:
 			return randomread(buf, n);
 		case Qdrivers:
 			return devtabread(c, buf, n, off);

 		case Qzero:
 			memset(buf, 0, n);
 			return n;

 		case Qosversion:
 			snprintf(tmp, sizeof tmp, "2000");
 			n = readstr(offset, buf, n, tmp);
 			return n;

 		case Qdebug:
 #if 0
 			s = seprint(tmp, tmp + sizeof tmp, "locks %uld\n", lockstats.locks);
 			s = seprint(s, tmp + sizeof tmp, "glare %uld\n", lockstats.glare);
 			s = seprint(s, tmp + sizeof tmp, "inglare %uld\n",
 						lockstats.inglare);
 			s = seprint(s, tmp + sizeof tmp, "qlock %uld\n", qlockstats.qlock);
 			seprint(s, tmp + sizeof tmp, "qlockq %uld\n", qlockstats.qlockq);
 			return readstr(offset, buf, n, tmp);
 #endif
 			return 0;
 		default:
 			printd("consread %#llux\n", c->qid.path);
 			error(Egreg);
 	}
 	return -1;	/* never reached */
 }

 static long
 conswrite(struct chan *c, void *va, long n, int64_t off)
 {
 	char buf[256], ch;
 	long l, bp;
 	char *a;
 	int i;
 	uint32_t offset;
 	struct cmdbuf *cb;
 	struct cmdtab *ct;
 	a = va;
 	offset = off;

 	switch ((uint32_t) c->qid.path) {
 #if 0
 		case Qtime:
 			if (!iseve())
 				error(Eperm);
 			return writetime(a, n);

 		case Qbintime:
 			if (!iseve())
 				error(Eperm);
 			return writebintime(a, n);

 		case Qhostowner:
 			return hostownerwrite(a, n);

 		case Qhostdomain:
 			return hostdomainwrite(a, n);

 		case Quser:
 			return userwrite(a, n);
 #endif
 		case Qnull:
 			break;
 #if 0
 		case Qreboot:

 			if (!iseve())
 				error(Eperm);
 			cb = parsecmd(a, n);

 			if (waserror()) {
 				free(cb);
 				nexterror();
 			}
 			ct = lookupcmd(cb, rebootmsg, ARRAY_SIZE(rebootmsg));
 			switch (ct->index) {
 				case CMhalt:
 					reboot(NULL, 0, 0);
 					break;
 				case CMreboot:
 					rebootcmd(cb->nf - 1, cb->f + 1);
 					break;
 				case CMpanic:
 					panic("/dev/reboot");
 			}
 			poperror();
 			free(cb);
 			break;

 		case Qsysname:
 			if (offset != 0)
 				error(Ebadarg);
 			if (n <= 0 || n >= sizeof buf)
 				error(Ebadarg);
 			strncpy(buf, a, n);
 			buf[n] = 0;
 			if (buf[n - 1] == '\n')
 				buf[n - 1] = 0;
 			kstrdup(&sysname, buf);
 			break;

 		case Qdebug:
 			if (n >= sizeof(buf))
 				n = sizeof(buf) - 1;
 			strncpy(buf, a, n);
 			buf[n] = 0;
 			if (n > 0 && buf[n - 1] == '\n')
 				buf[n - 1] = 0;
 			error(Ebadctl);
 			break;
 #endif
 		default:
 			printd("conswrite: %#llux\n", c->qid.path);
 			error(Egreg);
 	}
 	return n;
 }

 struct dev miscdevtab = {
 	'c',
 	"misc",

 	devreset,
 	consinit,
 	devshutdown,
 	consattach,
 	conswalk,
 	consstat,
 	consopen,
 	devcreate,
 	consclose,
 	consread,
 	devbread,
 	conswrite,
 	devbwrite,
 	devremove,
 	devwstat,
 	devpower,
 	devconfig,
 	devchaninfo,
 };
	#include <vfs.h>
	#include <kfs.h>
	#include <slab.h>
	#include <kmalloc.h>
	#include <kref.h>
	#include <string.h>
	#include <stdio.h>
	#include <assert.h>
	#include <error.h>
	#include <cpio.h>
	#include <pmap.h>
	#include <smp.h>

	enum {
	Qdir,
	Qbintime,
	Qcons,
	Qconsctl,
	Qcputime,
	Qdrivers,
	Qkmesg,
	Qkprint,
	Qhostdomain,
	Qhostowner,
	Qnull,
	Qosversion,
	Qpgrpid,
	Qpid,
	Qppid,
	Qrandom,
	Qreboot,
	Qswap,
	Qsysname,
	Qsysstat,
	Qtime,
	Quser,
	Qzero,
	Qdebug,
	};

	enum {
	VLNUMSIZE = 22,
	};

	static struct dirtab consdir[] = {
	{".", {Qdir, 0, QTDIR}, 0, DMDIR \| 0555},
	{"bintime", {Qbintime}, 24, 0664},
	{"cputime", {Qcputime}, 6 * NUMSIZE, 0444},
	{"drivers", {Qdrivers}, 0, 0444},
	// {"hostdomain", {Qhostdomain}, DOMLEN, 0664},
	{"hostowner", {Qhostowner}, 0, 0664},
	{"kmesg", {Qkmesg}, 0, 0444,},
	{"null", {Qnull}, 0, 0666},
	{"osversion", {Qosversion}, 0, 0444},
	{"pgrpid", {Qpgrpid}, NUMSIZE, 0444},
	{"pid", {Qpid}, NUMSIZE, 0444},
	{"ppid", {Qppid}, NUMSIZE, 0444},
	{"random", {Qrandom}, 0, 0444},
	{"reboot", {Qreboot}, 0, 0664},
	{"swap", {Qswap}, 0, 0664},
	{"sysname", {Qsysname}, 0, 0664},
	{"sysstat", {Qsysstat}, 0, 0666},
	{"time", {Qtime}, NUMSIZE + 3 * VLNUMSIZE, 0664},
	{"user", {Quser}, 0, 0666},
	{"zero", {Qzero}, 0, 0444},
	{"debug", {Qdebug}, 0, 0666},
	};

	static void consinit(void)
	{
	void randominit(void);
	printk("consinit\n");
	randominit();
	}

	static uint32_t randn;

	static void
	seedrand(void)
	{
	ERRSTACK(1);
	if(!waserror()){
	randomread((void*)&randn, sizeof(randn));
	poperror();
	}
	}

	int
	nrand(int n)
	{
	if(randn == 0)
	seedrand();
	randn = randn*1103515245 + 12345 + tsc2msec(read_tsc_serialized());
	return (randn>>16) % n;
	}

	int
	rand(void)
	{
	nrand(1);
	return randn;
	}

	static struct chan consattach(char spec)
	{
	return devattach('c', spec);
	}

	static struct walkqid conswalk(struct chan c, struct chan nc, char *name,
	int nname)
	{
	return devwalk(c, nc, name, nname, consdir, ARRAY_SIZE(consdir), devgen);
	}

	static long
	consstat(struct chan c, uint8_t dp, long n)
	{
	return devstat(c, dp, n, consdir, ARRAY_SIZE(consdir), devgen);
	}

	static struct chan consopen(struct chan c, int omode)
	{
	c->aux = NULL;
	c = devopen(c, omode, consdir, ARRAY_SIZE(consdir), devgen);
	return c;
	}

	static void consclose(struct chan *c)
	{
	}

	/* we do it this way to avoid the many fun deadlock opportunities
	* we keep hitting. And, if you don't suck it
	* out soon enough, you lost it. No real effort to ensure goodness
	* here as it can get called anywhere. Barret will fix it.
	*/
	static uint8_t logbuffer[1<<20];
	static int index = 0;
	static struct queue *logqueue = NULL;
	static int reading_kmesg = 0;
	void logbuf(int c)
	{
	if (reading_kmesg)
	return;
	if (index > 1<<20)
	return;
	logbuffer[index++] = c;
	}

	static long
	consread(struct chan c, void buf, long n, int64_t off)
	{
	uint32_t l;
	char b, bp, ch, s, e;
	char tmp[512]; /* Qswap is 381 bytes at clu */
	int i, k, id, send;
	long offset, nread;

	if (n <= 0)
	return n;

	nread = n;
	offset = off;
	switch ((uint32_t) c->qid.path) {
	case Qdir:
	return devdirread(c, buf, n, consdir, ARRAY_SIZE(consdir), devgen);

	case Qcputime:
	error("not now");
	#if 0
	k = offset;
	if (k >= 6 * NUMSIZE)
	return 0;
	if (k + n > 6 * NUMSIZE)
	n = 6 * NUMSIZE - k;
	/* easiest to format in a separate buffer and copy out */
	for (i = 0; i < 6 && NUMSIZE * i < k + n; i++) {
	l = current->time[i];
	if (i == TReal)
	l = sys->ticks - l;
	l = TK2MS(l);
	readnum(0, tmp + NUMSIZE * i, NUMSIZE, l, NUMSIZE);
	}
	memmove(buf, tmp + k, n);
	#endif
	return n;

	case Qkmesg:
	/* the queue gives us some elasticity for log reading. */
	if (! logqueue)
	logqueue = qopen(1<<20, 0, 0, 0);
	if (logqueue){
	int ret;
	/* atomic sets/gets are not that important in this case. */
	reading_kmesg = 1;
	qwrite(logqueue, logbuffer, index);
	index = 0;
	ret = qread(logqueue, buf, n);
	reading_kmesg = 0;
	return ret;
	}
	break;
	#if 0
	case Qkprint:
	return qread(kprintoq, buf, n);
	#endif
	case Qpgrpid:
	return readnum(offset, buf, n, current->pgrp->pgrpid, NUMSIZE);

	case Qpid:
	return readnum(offset, buf, n, current->pid, NUMSIZE);
	#if 0
	case Qppid:
	return readnum(offset, buf, n, current->parentpid, NUMSIZE);

	case Qtime:
	return readtime(offset, buf, n);

	case Qbintime:
	return readbintime(buf, n);

	case Qhostowner:
	return readstr(offset, buf, n, eve);

	case Qhostdomain:
	return readstr(offset, buf, n, hostdomain);

	case Quser:
	return readstr(offset, buf, n, current->user);
	#endif
	case Qnull:
	return 0;
	#if 0
	case Qsysname:
	if (sysname == NULL)
	return 0;
	return readstr(offset, buf, n, sysname);
	#endif
	case Qrandom:
	return randomread(buf, n);
	case Qdrivers:
	return devtabread(c, buf, n, off);

	case Qzero:
	memset(buf, 0, n);
	return n;

	case Qosversion:
	snprintf(tmp, sizeof tmp, "2000");
	n = readstr(offset, buf, n, tmp);
	return n;

	case Qdebug:
	#if 0
	s = seprint(tmp, tmp + sizeof tmp, "locks %uld\n", lockstats.locks);
	s = seprint(s, tmp + sizeof tmp, "glare %uld\n", lockstats.glare);
	s = seprint(s, tmp + sizeof tmp, "inglare %uld\n",
	lockstats.inglare);
	s = seprint(s, tmp + sizeof tmp, "qlock %uld\n", qlockstats.qlock);
	seprint(s, tmp + sizeof tmp, "qlockq %uld\n", qlockstats.qlockq);
	return readstr(offset, buf, n, tmp);
	#endif
	return 0;
	default:
	printd("consread %#llux\n", c->qid.path);
	error(Egreg);
	}
	return -1; /* never reached */
	}

	static long
	conswrite(struct chan c, void va, long n, int64_t off)
	{
	char buf[256], ch;
	long l, bp;
	char *a;
	int i;
	uint32_t offset;
	struct cmdbuf *cb;
	struct cmdtab *ct;
	a = va;
	offset = off;

	switch ((uint32_t) c->qid.path) {
	#if 0
	case Qtime:
	if (!iseve())
	error(Eperm);
	return writetime(a, n);

	case Qbintime:
	if (!iseve())
	error(Eperm);
	return writebintime(a, n);

	case Qhostowner:
	return hostownerwrite(a, n);

	case Qhostdomain:
	return hostdomainwrite(a, n);

	case Quser:
	return userwrite(a, n);
	#endif
	case Qnull:
	break;
	#if 0
	case Qreboot:

	if (!iseve())
	error(Eperm);
	cb = parsecmd(a, n);

	if (waserror()) {
	free(cb);
	nexterror();
	}
	ct = lookupcmd(cb, rebootmsg, ARRAY_SIZE(rebootmsg));
	switch (ct->index) {
	case CMhalt:
	reboot(NULL, 0, 0);
	break;
	case CMreboot:
	rebootcmd(cb->nf - 1, cb->f + 1);
	break;
	case CMpanic:
	panic("/dev/reboot");
	}
	poperror();
	free(cb);
	break;

	case Qsysname:
	if (offset != 0)
	error(Ebadarg);
	if (n <= 0 \|\| n >= sizeof buf)
	error(Ebadarg);
	strncpy(buf, a, n);
	buf[n] = 0;
	if (buf[n - 1] == '\n')
	buf[n - 1] = 0;
	kstrdup(&sysname, buf);
	break;

	case Qdebug:
	if (n >= sizeof(buf))
	n = sizeof(buf) - 1;
	strncpy(buf, a, n);
	buf[n] = 0;
	if (n > 0 && buf[n - 1] == '\n')
	buf[n - 1] = 0;
	error(Ebadctl);
	break;
	#endif
	default:
	printd("conswrite: %#llux\n", c->qid.path);
	error(Egreg);
	}
	return n;
	}

	struct dev miscdevtab = {
	'c',
	"misc",

	devreset,
	consinit,
	devshutdown,
	consattach,
	conswalk,
	consstat,
	consopen,
	devcreate,
	consclose,
	consread,
	devbread,
	conswrite,
	devbwrite,
	devremove,
	devwstat,
	devpower,
	devconfig,
	devchaninfo,
	};