/*  * This file is part of the UCB release of Plan 9. It is subject to the license * terms in the LICENSE file found in the top-level directory of this * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No * part of the UCB release of Plan 9, including this file, may be copied, * modified, propagated, or distributed except according to the terms contained * in the LICENSE file. */ #include	"u.h"#include	"../port/lib.h"#include	"mem.h"#include	"dat.h"#include	"fns.h"#include	"../port/error.h"#include	"pool.h"#include	<authsrv.h> void	(*consdebug)(void) = nil;void	(*screenputs)(char*, int) = nil; Queue*	kbdq;			/* unprocessed console input */Queue*	lineq;			/* processed console input */Queue*	serialoq;		/* serial console output */Queue*	kprintoq;		/* console output, for /dev/kprint */ulong	kprintinuse;		/* test and set whether /dev/kprint is open */int	iprintscreenputs = 1; int	panicking; static struct{	QLock; 	int	raw;		/* true if we shouldn't process input */	Ref	ctl;		/* number of opens to the control file */	int	x;		/* index into line */	char	line[1024];	/* current input line */ 	int	count;	int	ctlpoff; 	/* a place to save up characters at interrupt time before dumping them in the queue */	Lock	lockputc;	char	istage[1024];	char	*iw;	char	*ir;	char	*ie;} kbd = {	.iw	= kbd.istage,	.ir	= kbd.istage,	.ie	= kbd.istage + sizeof(kbd.istage),}; char	*sysname;vlong	fasthz; static void	seedrand(void);static int	readtime(ulong, char*, int);static int	readbintime(char*, int);static int	writetime(char*, int);static int	writebintime(char*, int); enum{	CMhalt,	CMreboot,	CMpanic,}; Cmdtab rebootmsg[] ={	CMhalt,		"halt",		1,	CMreboot,	"reboot",	0,	CMpanic,	"panic",	0,}; voidprintinit(void){	lineq = qopen(2*1024, 0, nil, nil);	if(lineq == nil)		panic("printinit");	qnoblock(lineq, 1);} intconsactive(void){	if(serialoq)		return qlen(serialoq) > 0;	return 0;} voidprflush(void){	ulong now; 	now = m->ticks;	while(consactive())		if(m->ticks - now >= HZ)			break;} /* * Log console output so it can be retrieved via /dev/kmesg. * This is good for catching boot-time messages after the fact. */struct {	Lock lk;	char buf[KMESGSIZE];	uint n;} kmesg; static voidkmesgputs(char *str, int n){	uint nn, d; 	ilock(&kmesg.lk);	/* take the tail of huge writes */	if(n > sizeof kmesg.buf){		d = n - sizeof kmesg.buf;		str += d;		n -= d;	} 	/* slide the buffer down to make room */	nn = kmesg.n;	if(nn + n >= sizeof kmesg.buf){		d = nn + n - sizeof kmesg.buf;		if(d)			memmove(kmesg.buf, kmesg.buf+d, sizeof kmesg.buf-d);		nn -= d;	} 	/* copy the data in */	memmove(kmesg.buf+nn, str, n);	nn += n;	kmesg.n = nn;	iunlock(&kmesg.lk);} /* *   Print a string on the console.  Convert \n to \r\n for serial *   line consoles.  Locking of the queues is left up to the screen *   or uart code.  Multi-line messages to serial consoles may get *   interspersed with other messages. */static voidputstrn0(char *str, int n, int usewrite){	int m;	char *t; 	if(!islo())		usewrite = 0; 	/*	 *  how many different output devices do we need?	 */	kmesgputs(str, n); 	/*	 *  if someone is reading /dev/kprint,	 *  put the message there.	 *  if not and there's an attached bit mapped display,	 *  put the message there.	 *	 *  if there's a serial line being used as a console,	 *  put the message there.	 */	if(kprintoq != nil && !qisclosed(kprintoq)){		if(usewrite)			qwrite(kprintoq, str, n);		else			qiwrite(kprintoq, str, n);	}else if(screenputs != nil)		screenputs(str, n); 	if(serialoq == nil){		uartputs(str, n);		return;	} 	while(n > 0) {		t = memchr(str, '\n', n);		if(t && !kbd.raw) {			m = t-str;			if(usewrite){				qwrite(serialoq, str, m);				qwrite(serialoq, "\r\n", 2);			} else {				qiwrite(serialoq, str, m);				qiwrite(serialoq, "\r\n", 2);			}			n -= m+1;			str = t+1;		} else {			if(usewrite)				qwrite(serialoq, str, n);			else				qiwrite(serialoq, str, n);			break;		}	}} voidputstrn(char *str, int n){	putstrn0(str, n, 0);} int noprint; intprint(char *fmt, ...){	int n;	va_list arg;	char buf[PRINTSIZE]; 	if(noprint)		return -1; 	va_start(arg, fmt);	n = vseprint(buf, buf+sizeof(buf), fmt, arg) - buf;	va_end(arg); 	if(!normalprint) {		if(0) iprint("\nprint called too early from %#lux\n",			getcallerpc(&fmt));		iprint("%.*s", n, buf);	} else		putstrn(buf, n); 	return n;} /* * Want to interlock iprints to avoid interlaced output on  * multiprocessor, but don't want to deadlock if one processor * dies during print and another has something important to say. * Make a good faith effort. */static Lock iprintlock;static intiprintcanlock(Lock *l){	int i;		for(i=0; i<1000; i++){		if(canlock(l))			return 1;		if(l->m == MACHP(m->machno))			return 0;		microdelay(100);	}	return 0;} intiprint(char *fmt, ...){	int n, s, locked;	va_list arg;	char buf[PRINTSIZE]; 	s = splhi();	va_start(arg, fmt);	n = vseprint(buf, buf+sizeof(buf), fmt, arg) - buf;	va_end(arg);	locked = iprintcanlock(&iprintlock);	if(screenputs != nil && iprintscreenputs)		screenputs(buf, n);	if(consuart == nil || consuart->phys == nil ||	    consuart->phys->putc == nil)		_uartputs(buf, n);	else		uartputs(buf, n);	if(locked)		unlock(&iprintlock);	splx(s); 	return n;} voidpanic(char *fmt, ...){	int n, s;	va_list arg;	char buf[PRINTSIZE]; 	kprintoq = nil;	/* don't try to write to /dev/kprint */ 	if(panicking)		for(;;);	panicking = 1; 	delay(20);	s = splhi();	strcpy(buf, "panic: ");	va_start(arg, fmt);	n = vseprint(buf+strlen(buf), buf+sizeof(buf), fmt, arg) - buf;	va_end(arg);	iprint("%s\n", buf);	if(consdebug)		(*consdebug)();	splx(s);	prflush();	buf[n] = '\n';//	putstrn(buf, n+1);//	dumpstack(); 	exit(1);} /* libmp at least contains a few calls to sysfatal; simulate with panic */voidsysfatal(char *fmt, ...){	char err[256];	va_list arg; 	va_start(arg, fmt);	vseprint(err, err + sizeof err, fmt, arg);	va_end(arg);	panic("sysfatal: %s", err);} void_assert(char *fmt){	panic("assert failed at %#p: %s", getcallerpc(&fmt), fmt);} intpprint(char *fmt, ...){	int n;	Chan *c;	va_list arg;	char buf[2*PRINTSIZE]; 	if(up == nil || up->fgrp == nil)		return 0; 	c = up->fgrp->fd[2];	if(c==0 || (c->mode!=OWRITE && c->mode!=ORDWR))		return 0;	n = snprint(buf, sizeof buf, "%s %lud: ", up->text, up->pid);	va_start(arg, fmt);	n = vseprint(buf+n, buf+sizeof(buf), fmt, arg) - buf;	va_end(arg); 	if(waserror())		return 0;	devtab[c->type]->write(c, buf, n, c->offset);	poperror(); 	lock(c);	c->offset += n;	unlock(c); 	return n;} static voidechoscreen(char *buf, int n){	char *e, *p;	char ebuf[128];	int x; 	p = ebuf;	e = ebuf + sizeof(ebuf) - 4;	while(n-- > 0){		if(p >= e){			screenputs(ebuf, p - ebuf);			p = ebuf;		}		x = *buf++;		if(x == 0x15){			*p++ = '^';			*p++ = 'U';			*p++ = '\n';		} else			*p++ = x;	}	if(p != ebuf)		screenputs(ebuf, p - ebuf);} static voidechoserialoq(char *buf, int n){	int x;	char *e, *p;	char ebuf[128]; 	p = ebuf;	e = ebuf + sizeof(ebuf) - 4;	while(n-- > 0){		if(p >= e){			qiwrite(serialoq, ebuf, p - ebuf);			p = ebuf;		}		x = *buf++;		if(x == '\n'){			*p++ = '\r';			*p++ = '\n';		} else if(x == 0x15){			*p++ = '^';			*p++ = 'U';			*p++ = '\n';		} else			*p++ = x;	}	if(p != ebuf)		qiwrite(serialoq, ebuf, p - ebuf);} static voidecho(char *buf, int n){	static int ctrlt, pid;	int x;	char *e, *p; 	if(n == 0)		return; 	e = buf+n;	for(p = buf; p < e; p++){		switch(*p){		case 0x10:	/* ^P */			if(cpuserver && !kbd.ctlpoff){				active.exiting = 1;				return;			}			break;		case 0x14:	/* ^T */			ctrlt++;			if(ctrlt > 2)				ctrlt = 2;			continue;		} 		if(ctrlt != 2)			continue; 		/* ^T escapes */		ctrlt = 0;		switch(*p){		case 'S':			x = splhi();			dumpstack();			procdump();			splx(x);			return;		case 's':			dumpstack();			return;		case 'x':			xsummary();			ixsummary();			mallocsummary();		//	memorysummary();			pagersummary();			return;		case 'd':			if(consdebug == nil)				consdebug = rdb;			else				consdebug = nil;			print("consdebug now %#p\n", consdebug);			return;		case 'D':			if(consdebug == nil)				consdebug = rdb;			consdebug();			return;		case 'p':			x = spllo();			procdump();			splx(x);			return;		case 'q':			scheddump();			return;		case 'k':			killbig("^t ^t k");			return;		case 'r':			exit(0);			return;		}

Lines 1–500 of 1362. Load more