2007-08-28 21:04:36 +02:00
|
|
|
// Console input and output.
|
2009-05-31 02:24:11 +02:00
|
|
|
// Input is from the keyboard or serial port.
|
|
|
|
// Output is written to the screen and serial port.
|
2007-08-28 21:04:36 +02:00
|
|
|
|
2006-07-16 17:40:05 +02:00
|
|
|
#include "types.h"
|
2006-06-12 17:22:12 +02:00
|
|
|
#include "defs.h"
|
2007-08-28 01:26:33 +02:00
|
|
|
#include "param.h"
|
|
|
|
#include "traps.h"
|
2006-07-12 03:48:35 +02:00
|
|
|
#include "spinlock.h"
|
2009-08-08 10:07:30 +02:00
|
|
|
#include "fs.h"
|
|
|
|
#include "file.h"
|
2006-09-07 18:52:13 +02:00
|
|
|
#include "mmu.h"
|
2007-08-08 12:29:42 +02:00
|
|
|
#include "proc.h"
|
2007-08-28 01:26:33 +02:00
|
|
|
#include "x86.h"
|
2006-07-12 03:48:35 +02:00
|
|
|
|
2009-08-08 10:07:30 +02:00
|
|
|
static void consputc(int);
|
2007-08-28 05:28:13 +02:00
|
|
|
|
2009-08-08 10:07:30 +02:00
|
|
|
static int panicked = 0;
|
2007-08-24 22:28:08 +02:00
|
|
|
|
2009-05-31 07:12:21 +02:00
|
|
|
static struct {
|
|
|
|
struct spinlock lock;
|
|
|
|
int locking;
|
|
|
|
} cons;
|
|
|
|
|
2006-07-15 14:03:57 +02:00
|
|
|
static void
|
2006-06-12 17:22:12 +02:00
|
|
|
printint(int xx, int base, int sgn)
|
|
|
|
{
|
2009-05-31 02:24:11 +02:00
|
|
|
static char digits[] = "0123456789abcdef";
|
2006-06-12 17:22:12 +02:00
|
|
|
char buf[16];
|
|
|
|
int i = 0, neg = 0;
|
2006-07-17 03:52:13 +02:00
|
|
|
uint x;
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2006-06-12 17:22:12 +02:00
|
|
|
if(sgn && xx < 0){
|
|
|
|
neg = 1;
|
2009-08-08 10:07:30 +02:00
|
|
|
x = -xx;
|
|
|
|
} else
|
2006-06-12 17:22:12 +02:00
|
|
|
x = xx;
|
|
|
|
|
2007-08-28 20:32:08 +02:00
|
|
|
do{
|
2006-06-12 17:22:12 +02:00
|
|
|
buf[i++] = digits[x % base];
|
2007-08-28 20:32:08 +02:00
|
|
|
}while((x /= base) != 0);
|
2006-06-12 17:22:12 +02:00
|
|
|
if(neg)
|
|
|
|
buf[i++] = '-';
|
|
|
|
|
2006-07-16 03:52:22 +02:00
|
|
|
while(--i >= 0)
|
2009-03-08 23:07:13 +01:00
|
|
|
consputc(buf[i]);
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
|
|
|
|
2009-08-08 10:07:30 +02:00
|
|
|
//PAGEBREAK: 50
|
2007-08-28 20:23:48 +02:00
|
|
|
// Print to the console. only understands %d, %x, %p, %s.
|
2006-06-12 17:22:12 +02:00
|
|
|
void
|
|
|
|
cprintf(char *fmt, ...)
|
|
|
|
{
|
2007-08-14 21:31:16 +02:00
|
|
|
int i, c, state, locking;
|
|
|
|
uint *argp;
|
|
|
|
char *s;
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2009-05-31 07:12:21 +02:00
|
|
|
locking = cons.locking;
|
2007-08-14 21:31:16 +02:00
|
|
|
if(locking)
|
2009-05-31 07:12:21 +02:00
|
|
|
acquire(&cons.lock);
|
2006-07-15 14:03:57 +02:00
|
|
|
|
2009-08-31 08:02:08 +02:00
|
|
|
argp = (uint*)(void*)(&fmt + 1);
|
2007-08-14 21:31:16 +02:00
|
|
|
state = 0;
|
2009-08-08 10:07:30 +02:00
|
|
|
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
|
|
|
|
if(c != '%'){
|
|
|
|
consputc(c);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
c = fmt[++i] & 0xff;
|
|
|
|
if(c == 0)
|
|
|
|
break;
|
|
|
|
switch(c){
|
|
|
|
case 'd':
|
|
|
|
printint(*argp++, 10, 1);
|
|
|
|
break;
|
|
|
|
case 'x':
|
|
|
|
case 'p':
|
|
|
|
printint(*argp++, 16, 0);
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
if((s = (char*)*argp++) == 0)
|
|
|
|
s = "(null)";
|
|
|
|
for(; *s; s++)
|
|
|
|
consputc(*s);
|
2007-08-14 21:31:16 +02:00
|
|
|
break;
|
|
|
|
case '%':
|
2009-08-08 10:07:30 +02:00
|
|
|
consputc('%');
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// Print unknown % sequence to draw attention.
|
|
|
|
consputc('%');
|
|
|
|
consputc(c);
|
2007-08-14 21:31:16 +02:00
|
|
|
break;
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
|
|
|
}
|
2006-07-15 14:03:57 +02:00
|
|
|
|
2006-08-11 00:08:14 +02:00
|
|
|
if(locking)
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&cons.lock);
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
|
|
|
|
2009-08-08 10:07:30 +02:00
|
|
|
void
|
|
|
|
panic(char *s)
|
2006-08-09 18:04:04 +02:00
|
|
|
{
|
|
|
|
int i;
|
2009-08-08 10:07:30 +02:00
|
|
|
uint pcs[10];
|
|
|
|
|
|
|
|
cli();
|
|
|
|
cons.locking = 0;
|
2009-08-31 08:02:08 +02:00
|
|
|
cprintf("cpu%d: panic: ", cpu->id);
|
2009-08-08 10:07:30 +02:00
|
|
|
cprintf(s);
|
|
|
|
cprintf("\n");
|
|
|
|
getcallerpcs(&s, pcs);
|
|
|
|
for(i=0; i<10; i++)
|
|
|
|
cprintf(" %p", pcs[i]);
|
|
|
|
panicked = 1; // freeze other CPU
|
|
|
|
for(;;)
|
|
|
|
;
|
|
|
|
}
|
2006-08-09 18:04:04 +02:00
|
|
|
|
2009-08-08 10:07:30 +02:00
|
|
|
//PAGEBREAK: 50
|
|
|
|
#define BACKSPACE 0x100
|
|
|
|
#define CRTPORT 0x3d4
|
|
|
|
static ushort *crt = (ushort*)0xb8000; // CGA memory
|
2006-08-10 03:28:57 +02:00
|
|
|
|
2009-08-08 10:07:30 +02:00
|
|
|
static void
|
|
|
|
cgaputc(int c)
|
|
|
|
{
|
|
|
|
int pos;
|
|
|
|
|
|
|
|
// Cursor position: col + 80*row.
|
|
|
|
outb(CRTPORT, 14);
|
|
|
|
pos = inb(CRTPORT+1) << 8;
|
|
|
|
outb(CRTPORT, 15);
|
|
|
|
pos |= inb(CRTPORT+1);
|
|
|
|
|
|
|
|
if(c == '\n')
|
|
|
|
pos += 80 - pos%80;
|
|
|
|
else if(c == BACKSPACE){
|
|
|
|
if(pos > 0)
|
|
|
|
crt[--pos] = ' ' | 0x0700;
|
|
|
|
} else
|
|
|
|
crt[pos++] = (c&0xff) | 0x0700; // black on white
|
|
|
|
|
|
|
|
if((pos/80) >= 24){ // Scroll up.
|
|
|
|
memmove(crt, crt+80, sizeof(crt[0])*23*80);
|
|
|
|
pos -= 80;
|
|
|
|
memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos));
|
|
|
|
}
|
|
|
|
|
|
|
|
outb(CRTPORT, 14);
|
|
|
|
outb(CRTPORT+1, pos>>8);
|
|
|
|
outb(CRTPORT, 15);
|
|
|
|
outb(CRTPORT+1, pos);
|
|
|
|
crt[pos] = ' ' | 0x0700;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
consputc(int c)
|
|
|
|
{
|
|
|
|
if(panicked){
|
|
|
|
cli();
|
|
|
|
for(;;)
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
uartputc(c);
|
|
|
|
cgaputc(c);
|
2006-08-09 18:04:04 +02:00
|
|
|
}
|
|
|
|
|
2009-08-08 10:07:30 +02:00
|
|
|
//PAGEBREAK: 50
|
2007-08-28 05:28:13 +02:00
|
|
|
#define INPUT_BUF 128
|
2007-08-14 21:31:16 +02:00
|
|
|
struct {
|
|
|
|
struct spinlock lock;
|
2007-08-28 05:28:13 +02:00
|
|
|
char buf[INPUT_BUF];
|
2008-08-22 02:26:22 +02:00
|
|
|
uint r; // Read index
|
|
|
|
uint w; // Write index
|
|
|
|
uint e; // Edit index
|
2007-08-28 05:28:13 +02:00
|
|
|
} input;
|
2006-08-10 04:07:10 +02:00
|
|
|
|
2007-08-28 06:13:40 +02:00
|
|
|
#define C(x) ((x)-'@') // Control-x
|
|
|
|
|
2006-08-09 18:04:04 +02:00
|
|
|
void
|
2009-03-08 23:07:13 +01:00
|
|
|
consoleintr(int (*getc)(void))
|
2006-08-10 04:07:10 +02:00
|
|
|
{
|
2007-08-28 05:28:13 +02:00
|
|
|
int c;
|
2006-08-23 03:09:24 +02:00
|
|
|
|
2007-08-28 05:28:13 +02:00
|
|
|
acquire(&input.lock);
|
|
|
|
while((c = getc()) >= 0){
|
|
|
|
switch(c){
|
|
|
|
case C('P'): // Process listing.
|
|
|
|
procdump();
|
|
|
|
break;
|
|
|
|
case C('U'): // Kill line.
|
2008-08-22 02:26:22 +02:00
|
|
|
while(input.e != input.w &&
|
2007-08-28 05:28:13 +02:00
|
|
|
input.buf[(input.e-1) % INPUT_BUF] != '\n'){
|
|
|
|
input.e--;
|
2009-03-08 23:07:13 +01:00
|
|
|
consputc(BACKSPACE);
|
2007-08-28 05:28:13 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case C('H'): // Backspace
|
2008-08-22 02:26:22 +02:00
|
|
|
if(input.e != input.w){
|
2007-08-28 05:28:13 +02:00
|
|
|
input.e--;
|
2009-03-08 23:07:13 +01:00
|
|
|
consputc(BACKSPACE);
|
2007-08-28 05:28:13 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2008-08-22 02:26:22 +02:00
|
|
|
if(c != 0 && input.e-input.r < INPUT_BUF){
|
2007-08-30 20:20:53 +02:00
|
|
|
input.buf[input.e++ % INPUT_BUF] = c;
|
2009-03-08 23:07:13 +01:00
|
|
|
consputc(c);
|
2007-08-28 05:28:13 +02:00
|
|
|
if(c == '\n' || c == C('D') || input.e == input.r+INPUT_BUF){
|
|
|
|
input.w = input.e;
|
|
|
|
wakeup(&input.r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2006-09-07 17:45:38 +02:00
|
|
|
}
|
2006-08-10 04:07:10 +02:00
|
|
|
}
|
2007-08-28 05:28:13 +02:00
|
|
|
release(&input.lock);
|
2006-08-10 04:07:10 +02:00
|
|
|
}
|
|
|
|
|
2006-08-11 15:55:18 +02:00
|
|
|
int
|
2009-03-08 23:07:13 +01:00
|
|
|
consoleread(struct inode *ip, char *dst, int n)
|
2006-08-11 15:55:18 +02:00
|
|
|
{
|
2007-08-08 10:04:02 +02:00
|
|
|
uint target;
|
|
|
|
int c;
|
2006-08-11 15:55:18 +02:00
|
|
|
|
2007-08-28 19:49:49 +02:00
|
|
|
iunlock(ip);
|
2007-08-08 10:04:02 +02:00
|
|
|
target = n;
|
2007-08-28 05:28:13 +02:00
|
|
|
acquire(&input.lock);
|
2007-08-08 10:04:02 +02:00
|
|
|
while(n > 0){
|
2007-08-28 05:28:13 +02:00
|
|
|
while(input.r == input.w){
|
2009-08-31 08:02:08 +02:00
|
|
|
if(proc->killed){
|
2007-08-28 05:28:13 +02:00
|
|
|
release(&input.lock);
|
2007-08-28 19:49:49 +02:00
|
|
|
ilock(ip);
|
2007-08-08 12:29:42 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2007-08-28 05:28:13 +02:00
|
|
|
sleep(&input.r, &input.lock);
|
2007-08-08 12:29:42 +02:00
|
|
|
}
|
2007-08-30 20:20:53 +02:00
|
|
|
c = input.buf[input.r++ % INPUT_BUF];
|
2007-08-08 10:04:02 +02:00
|
|
|
if(c == C('D')){ // EOF
|
|
|
|
if(n < target){
|
|
|
|
// Save ^D for next time, to make sure
|
|
|
|
// caller gets a 0-byte result.
|
2007-08-28 05:28:13 +02:00
|
|
|
input.r--;
|
2007-08-08 10:04:02 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
*dst++ = c;
|
2006-08-11 15:55:18 +02:00
|
|
|
--n;
|
2007-08-28 05:28:13 +02:00
|
|
|
if(c == '\n')
|
|
|
|
break;
|
2006-08-11 15:55:18 +02:00
|
|
|
}
|
2007-08-28 05:28:13 +02:00
|
|
|
release(&input.lock);
|
2007-08-28 19:49:49 +02:00
|
|
|
ilock(ip);
|
2006-08-11 15:55:18 +02:00
|
|
|
|
|
|
|
return target - n;
|
|
|
|
}
|
|
|
|
|
2009-08-08 10:07:30 +02:00
|
|
|
int
|
|
|
|
consolewrite(struct inode *ip, char *buf, int n)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
iunlock(ip);
|
|
|
|
acquire(&cons.lock);
|
|
|
|
for(i = 0; i < n; i++)
|
|
|
|
consputc(buf[i] & 0xff);
|
|
|
|
release(&cons.lock);
|
|
|
|
ilock(ip);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2006-08-10 04:07:10 +02:00
|
|
|
void
|
2009-03-08 23:07:13 +01:00
|
|
|
consoleinit(void)
|
2006-08-09 18:04:04 +02:00
|
|
|
{
|
2009-05-31 07:12:21 +02:00
|
|
|
initlock(&cons.lock, "console");
|
|
|
|
initlock(&input.lock, "input");
|
2006-08-11 00:08:14 +02:00
|
|
|
|
2009-03-08 23:07:13 +01:00
|
|
|
devsw[CONSOLE].write = consolewrite;
|
|
|
|
devsw[CONSOLE].read = consoleread;
|
2009-05-31 07:12:21 +02:00
|
|
|
cons.locking = 1;
|
2006-08-10 04:07:10 +02:00
|
|
|
|
2009-03-08 23:07:13 +01:00
|
|
|
picenable(IRQ_KBD);
|
|
|
|
ioapicenable(IRQ_KBD, 0);
|
2006-08-09 18:04:04 +02:00
|
|
|
}
|
2007-08-14 21:31:16 +02:00
|
|
|
|