iDunnoDev/xv6-custom-os
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added code to get the consoles to be split into their own

Browse Source 
Fixed issue where exiting a shell would not close the parent console properly
Changed the way the consoles are linked to the processes by making it a pointer to the console
Added all the console changes for the above
Added a slow maze drawing program similar to the c64 version
This commit is contained in:
iDunnoDev
2022-12-14 01:04:42 +00:00
committed by iDunnoDev
parent 5b21654261
commit 924d90c066
8 changed files with 454 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

594
console.c
View File

@ -17,31 +17,35 @@
#define INPUT_BUF 128
struct kbdbuffer {
struct kbdbuffer
{
char buf[INPUT_BUF];
uint r; // Read index
uint w; // Write index
uint e; // Edit index
uint r; // Read index
uint w; // Write index
uint e; // Edit index
};
struct kbdbuffer inputBuffer;
struct kbdbuffer * input = 0;
struct kbdbuffer *input = 0;
struct vconsole {
struct vconsole
{
uint consoleindex;
struct spinlock lock;
struct proc* processowner;
struct proc *processowner;
ushort screenbuffer[SCRWIDTH * SCRHEIGHT];
struct kbdbuffer keybuffer;
int pos;
int active;
int inuse;
};
struct vconsole consoles[MAXVCONSOLES];
struct vconsole* currentconsole = 0;
static uint currentconsoleindex = 0;
struct vconsole *currentconsole = 0;
//static uint currentconsoleindex = 0;
#define C(x) ((x) - '@') // Control-x
#define C(x) ((x) - '@') // Control-x
void clearconsole(ushort *bufferin);
void loadscreenbuffer(ushort *bufferin);
@ -52,97 +56,114 @@ static void consputc(int);
static int panicked = 0;
static struct {
static struct
{
struct spinlock lock;
int locking;
} cons;
static void printint(int xx, int base, int sign) {
static void printint(int xx, int base, int sign)
{
static char digits[] = "0123456789abcdef";
char buf[16];
int i;
uint x;
if (sign && (sign = xx < 0)) {
if (sign && (sign = xx < 0))
{
x = -xx;
}
else {
else
{
x = xx;
}
i = 0;
do {
do
{
buf[i++] = digits[x % base];
}
while ((x /= base) != 0);
} while ((x /= base) != 0);
if (sign) {
if (sign)
{
buf[i++] = '-';
}
while (--i >= 0) {
while (--i >= 0)
{
consputc(buf[i]);
}
}
// Print to the console. only understands %d, %x, %p, %s.
void cprintf(char *fmt, ...) {
void cprintf(char *fmt, ...)
{
int i, c, locking;
uint *argp;
char *s;
locking = cons.locking;
if (locking) {
if (locking)
{
acquire(&cons.lock);
}
if (fmt == 0) {
if (fmt == 0)
{
panic("null fmt");
}
argp = (uint*)(void*)(&fmt + 1);
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
if (c != '%') {
argp = (uint *)(void *)(&fmt + 1);
for (i = 0; (c = fmt[i] & 0xff) != 0; i++)
{
if (c != '%')
{
consputc(c);
continue;
}
c = fmt[++i] & 0xff;
if (c == 0) {
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);
}
break;
case '%':
consputc('%');
break;
default:
// Print unknown % sequence to draw attention.
consputc('%');
consputc(c);
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);
}
break;
case '%':
consputc('%');
break;
default:
// Print unknown % sequence to draw attention.
consputc('%');
consputc(c);
break;
}
}
if (locking) {
if (locking)
{
release(&cons.lock);
}
}
void panic(char *s) {
void panic(char *s)
{
int i;
uint pcs[10];
@ -153,32 +174,64 @@ void panic(char *s) {
cprintf(s);
cprintf("\n");
getcallerpcs(&s, pcs);
for (i = 0; i < 10; i++) {
for (i = 0; i < 10; i++)
{
cprintf(" %p", pcs[i]);
}
panicked = 1; // freeze other CPU
for (;;) {
for (;;)
{
;
}
}
// function that checks and returns a valid vconsole pointer, since i was repeating the same checks i moved it
// into its own function to keep things looking clean
struct vconsole* getvalidprocessconsoleptr(void)
{
struct vconsole* inconsoleptr = 0;
// Check if a process has actually been created otherwise use the base console
if (myproc() == 0x0)
{
inconsoleptr = currentconsole;
if (inconsoleptr == 0)
{
// fall back to the base console if the process and currentconsole has no console assigned for some reason
inconsoleptr = &consoles[0];
}
}
else
{
inconsoleptr = myproc()->consoleptr;
if (inconsoleptr == 0)
{
// fall back to the console set in currentconsole
inconsoleptr = currentconsole;
if (inconsoleptr == 0)
{
// fall back to the base console if the process and currentconsole has no console assigned for some reason
inconsoleptr = &consoles[0];
}
}
}
return inconsoleptr;
}
#define BACKSPACE 0x100
#define CRTPORT 0x3d4
#define TITLEOFF (SCRWIDTH * 1) // Size of the offset we need for the title bar
#define TITLEOFF (SCRWIDTH * 1) // Size of the offset we need for the title bar
static ushort *crt = (ushort*)P2V(0xb8000); // CGA memory
static ushort *crt = (ushort *)P2V(0xb8000); // CGA memory
static void cgaputc(int c) {
static void cgaputc(int c)
{
int pos;
int consoleindex = 0;
// Check if a process has actually been created otherwise use the base console
if (myproc() != 0x0)
{
consoleindex = myproc()->consoleIndex;
}
ushort* currentbuffer = consoles[consoleindex].screenbuffer;
struct vconsole* inconsoleptr = getvalidprocessconsoleptr();
ushort *currentbuffer = inconsoleptr->screenbuffer;
if (consoleindex == currentconsoleindex)
if (inconsoleptr->inuse)
{
// Cursor position: col + 80*row.
outb(CRTPORT, 14);
@ -188,45 +241,50 @@ static void cgaputc(int c) {
}
else
{
pos = consoles[consoleindex].pos;
pos = inconsoleptr->pos;
}
if (c == '\n') {
if (c == '\n')
{
pos += SCRWIDTH - pos % SCRWIDTH;
}
else if (c == BACKSPACE) {
if (pos > (TITLEOFF)) {
else if (c == BACKSPACE)
{
if (pos > (TITLEOFF))
{
currentbuffer[pos] = 0; // Clear the character from the buffer
--pos;
}
}
else {
//int posp = pos;
if (consoleindex == currentconsoleindex)
else
{
// int posp = pos;
if (inconsoleptr->inuse)
{
crt[pos] = (c & 0xff) | 0x0700; // black on white
crt[pos] = (c & 0xff) | 0x0700; // black on white
}
currentbuffer[pos] = (c & 0xff) | 0x0700; // black on white
currentbuffer[pos] = (c & 0xff) | 0x0700; // black on white
pos++;
}
if (pos < TITLEOFF || pos > SCRHEIGHT * SCRWIDTH) {
if (pos < TITLEOFF || pos > SCRHEIGHT * SCRWIDTH)
{
panic("pos under/overflow");
}
if ((pos / 80) >= 24) { // Scroll up.
memmove(currentbuffer + TITLEOFF, currentbuffer + (SCRWIDTH + TITLEOFF), sizeof(crt[0]) * (SCRHEIGHT - 1) * SCRWIDTH);
if ((pos / 80) >= 24)
{ // Scroll up.
memmove(currentbuffer + TITLEOFF, currentbuffer + (SCRWIDTH + TITLEOFF), sizeof(crt[0]) * (SCRHEIGHT - 1) * SCRWIDTH);
pos -= 80;
memset(currentbuffer + pos, 0, sizeof(crt[0]) * (SCRHEIGHT * SCRWIDTH - pos));
if (consoleindex == currentconsoleindex)
if (inconsoleptr->inuse)
{
memmove(crt + TITLEOFF, crt + (SCRWIDTH + TITLEOFF), sizeof(crt[0]) * (SCRHEIGHT - 1) * SCRWIDTH);
memset(crt + pos, 0, sizeof(crt[0]) * (SCRHEIGHT * SCRWIDTH - pos));
}
}
consoles[consoleindex].pos = pos;
inconsoleptr->pos = pos;
if (consoleindex == currentconsoleindex)
if (inconsoleptr->inuse)
{
outb(CRTPORT, 14);
outb(CRTPORT + 1, pos >> 8);
@ -236,32 +294,40 @@ static void cgaputc(int c) {
}
}
void consputc(int c) {
if (panicked) {
void consputc(int c)
{
if (panicked)
{
cli();
for (;;) {
for (;;)
{
;
}
}
if (c == BACKSPACE) {
if (c == BACKSPACE)
{
uartputc('\b');
uartputc(' ');
uartputc('\b');
}
else {
else
{
uartputc(c);
}
cgaputc(c);
}
int consoleget(void) {
int consoleget(void)
{
int c;
acquire(&cons.lock);
while ((c = kbdgetc()) <= 0) {
if (c == 0) {
while ((c = kbdgetc()) <= 0)
{
if (c == 0)
{
c = kbdgetc();
}
}
@ -271,108 +337,132 @@ int consoleget(void) {
return c;
}
void consoleintr(int (*getc)(void)) {
void consoleintr(int (*getc)(void))
{
int c, doprocdump = 0, doconsoleswitch = 0, doconsolehome = 0;
acquire(&cons.lock);
while ((c = getc()) >= 0) {
switch (c) {
case C('P'): // Process listing.
// procdump() locks cons.lock indirectly; invoke later
doprocdump = 1;
break;
case C('U'): // Kill line.
while (input->e != input->w &&
input->buf[(input->e - 1) % INPUT_BUF] != '\n') {
input->e--;
consputc(BACKSPACE);
acquire(&cons.lock);
while ((c = getc()) >= 0)
{
switch (c)
{
case C('P'): // Process listing.
// procdump() locks cons.lock indirectly; invoke later
doprocdump = 1;
break;
case C('U'): // Kill line.
while (input->e != input->w &&
input->buf[(input->e - 1) % INPUT_BUF] != '\n')
{
input->e--;
consputc(BACKSPACE);
}
break;
case C('H'):
case '\x7f': // Backspace
if (input->e != input->w)
{
input->e--;
consputc(BACKSPACE);
}
break;
case C('T'):
doconsoleswitch = 1;
break;
case C('K'):
doconsolehome = 1;
break;
default:
if (c != 0 && input->e - input->r < INPUT_BUF)
{
c = (c == '\r') ? '\n' : c;
input->buf[input->e++ % INPUT_BUF] = c;
consputc(c);
if (c == '\n' || c == C('D') || input->e == input->r + INPUT_BUF)
{
input->w = input->e;
wakeup(&(input->r));
}
break;
case C('H'):
case '\x7f': // Backspace
if (input->e != input->w) {
input->e--;
consputc(BACKSPACE);
}
break;
case C('T'):
doconsoleswitch = 1;
break;
case C('K'):
doconsolehome = 1;
break;
default:
if (c != 0 && input->e - input->r < INPUT_BUF) {
c = (c == '\r') ? '\n' : c;
input->buf[input->e++ % INPUT_BUF] = c;
consputc(c);
if (c == '\n' || c == C('D') || input->e == input->r + INPUT_BUF) {
input->w = input->e;
wakeup(&(input->r));
}
}
break;
}
break;
}
}
release(&cons.lock);
if (doprocdump) {
procdump(); // now call procdump() wo. cons.lock held
if (doprocdump)
{
procdump(); // now call procdump() wo. cons.lock held
}
if (doconsolehome) {
if (currentconsoleindex != 0)
if (doconsolehome)
{
if (currentconsole->consoleindex != 0)
{
switchtoconsole(0);
switchtoconsole(0);
}
}
if (doconsoleswitch)
if (doconsoleswitch)
{
int toconsole = 0;
for (int i = (currentconsoleindex + 1); i < MAXVCONSOLES; i++)
struct vconsole* toconsole = 0;
acquire(&cons.lock);
for (int i = (currentconsole->consoleindex + 1); i < MAXVCONSOLES; i++)
{
if (consoles[i].active)
{
toconsole = i;
toconsole = &consoles[i];
break;
}
}
if (toconsole != currentconsoleindex)
}
if (toconsole == 0)
{
toconsole = getbaseconsoleptr();
}
release(&cons.lock);
if (!toconsole->inuse)
{
switchtoconsole(toconsole);
}
}
}
int consoleread(struct inode *ip, char *dst, int n) {
int consoleread(struct inode *ip, char *dst, int n)
{
uint target;
int c;
struct vconsole* inconsoleptr = getvalidprocessconsoleptr();
struct kbdbuffer* consolekbdbuffer = &inconsoleptr->keybuffer;
iunlock(ip);
target = n;
target = n;
acquire(&cons.lock);
while (n > 0) {
while (input->r == input->w) {
if (myproc()->killed) {
release(&cons.lock);
ilock(ip);
return -1;
while (n > 0)
{
while (consolekbdbuffer->r == consolekbdbuffer->w)
{
if (myproc()->killed)
{
release(&cons.lock);
ilock(ip);
return -1;
}
sleep(&(consolekbdbuffer->r), &cons.lock);
}
sleep(&(input->r), &cons.lock);
}
c = input->buf[input->r++ % INPUT_BUF];
if (c == C('D')) { // EOF
if (n < target) {
// Save ^D for next time, to make sure
// caller gets a 0-byte result.
input->r--;
c = consolekbdbuffer->buf[consolekbdbuffer->r++ % INPUT_BUF];
if (c == C('D'))
{ // EOF
if (n < target)
{
// Save ^D for next time, to make sure
// caller gets a 0-byte result.
consolekbdbuffer->r--;
}
break;
}
break;
}
*dst++ = c;
--n;
if (c == '\n') {
break;
}
*dst++ = c;
--n;
if (c == '\n')
{
break;
}
}
release(&cons.lock);
ilock(ip);
@ -380,14 +470,17 @@ int consoleread(struct inode *ip, char *dst, int n) {
return target - n;
}
int consolewrite(struct inode *ip, char *buf, int n) {
int consolewrite(struct inode *ip, char *buf, int n)
{
int i;
//struct vconsole* inconsoleptr = getvalidprocessconsoleptr();
iunlock(ip);
acquire(&cons.lock);
for (i = 0; i < n; i++) {
consputc(buf[i] & 0xff);
}
acquire(&cons.lock);
for (i = 0; i < n; i++)
{
consputc(buf[i] & 0xff);
}
release(&cons.lock);
ilock(ip);
@ -413,8 +506,13 @@ void testfillbuffer(ushort *bufferin)
}
}
struct vconsole* getbaseconsoleptr(void)
{
return &consoles[0];
}
void clearconsole(ushort *bufferin)
{
{
// Flood the screen buffer with blank spaces
memset(bufferin, 0, sizeof(bufferin[0]) * SCRHEIGHT * SCRWIDTH);
}
@ -427,53 +525,59 @@ void loadscreenbuffer(ushort *bufferin)
void savescreenbuffer(ushort *bufferin)
{
// Copy the memory from the console buffer to the crt buffer
memmove(bufferin, crt, sizeof(crt[0]) * SCRHEIGHT * SCRWIDTH);
// Copy the memory from the console buffer to the crt buffer
memmove(bufferin, crt, sizeof(crt[0]) * SCRHEIGHT * SCRWIDTH);
}
void clearscreen(void)
void clearscreen(void)
{
//cprintf("process id: %d", myproc()->consoleIndex);
//return;
//cprintf("size of buffer item: %d\n", sizeof(consoles[currentconsoleindex].screenbuffer[0]) * (SCRHEIGHT * SCRWIDTH));
//cprintf("size of crt item: %d\n", sizeof(crt[0]) * (SCRHEIGHT * SCRWIDTH));
//return;
int consoleindex = 0;
// Check if a process has actually been created otherwise use the base console
if (myproc() != 0x0)
{
consoleindex = myproc()->consoleIndex;
}
if (consoleindex == currentconsoleindex)
{
acquire(&cons.lock);
int pos = TITLEOFF;
//testfillbuffer(consoles[currentconsoleindex].screenbuffer);
clearconsole(crt);
//loadscreenbuffer(consoles[currentconsoleindex].screenbuffer);
release(&cons.lock);
// cprintf("process id: %d", myproc()->consoleIndex);
// return;
// cprintf("size of buffer item: %d\n", sizeof(consoles[currentconsoleindex].screenbuffer[0]) * (SCRHEIGHT * SCRWIDTH));
// cprintf("size of crt item: %d\n", sizeof(crt[0]) * (SCRHEIGHT * SCRWIDTH));
// return;
// Check if a process has actually been created otherwise use the base console
struct vconsole* inconsoleptr = getvalidprocessconsoleptr();
currentconsole->pos = pos;
acquire(&cons.lock);
int pos = TITLEOFF;
clearconsole(inconsoleptr->screenbuffer);
inconsoleptr->pos = pos;
release(&cons.lock);
if (inconsoleptr->inuse)
{
acquire(&cons.lock);
loadscreenbuffer(inconsoleptr->screenbuffer);
release(&cons.lock);
outb(CRTPORT, 14);
outb(CRTPORT + 1, pos >> 8);
outb(CRTPORT, 15);
outb(CRTPORT + 1, pos);
}
else
{
}
}
}
void consoleinit(void) {
initlock(&cons.lock, "console");
// Initialise pointer to point to our console input buffer
currentconsole = &consoles[currentconsoleindex];
void consoleinit(void)
{
initlock(&cons.lock, "console");
for (int i = 0; i < MAXVCONSOLES; i++)
{
consoles[i].consoleindex = i;
consoles[i].processowner = 0;
consoles[i].pos = 0;
consoles[i].active = 0;
consoles[i].inuse = 0;
//initlock(&consoles[i].lock, "vconsole" + i);
}
// Initialise pointer to point to our console input buffer
currentconsole = &consoles[0];
currentconsole->active = 1;
initlock(&currentconsole->lock, "vconsole0");
currentconsole->inuse = 1;
input = &currentconsole->keybuffer;
devsw[CONSOLE].write = consolewrite;
@ -486,23 +590,34 @@ void consoleinit(void) {
ioapicenable(IRQ_KBD, 0);
}
int newconsole(void)
{
int result = 0;
struct vconsole* newconsole(void)
{
struct vconsole* result = 0;
acquire(&cons.lock);
for (int i = 1; i < MAXVCONSOLES; i++)
{
if (!consoles[i].active)
{
result = i;
consoles[i].processowner = myproc();
result = &consoles[i];
break;
}
}
release(&cons.lock);
return result;
}
int switchtoconsole(int consoleindex)
void releaseallconsoles(void)
{
for (int i = 0; i < MAXVCONSOLES; i++)
{
consoles[i].inuse = 0;
}
}
int switchtoconsole(struct vconsole* consoleptr)
{
int pos;
@ -511,25 +626,26 @@ int switchtoconsole(int consoleindex)
outb(CRTPORT, 15);
pos |= inb(CRTPORT + 1);*/
//consoles[currentconsoleindex].pos = pos;
// consoles[currentconsoleindex].pos = pos;
//savescreenbuffer(consoles[currentconsoleindex].screenbuffer);
// savescreenbuffer(consoles[currentconsoleindex].screenbuffer);
//acquire(&currentconsole->lock);
//sleep(&(currentconsole), &currentconsole->lock);
// acquire(&currentconsole->lock);
// sleep(&(currentconsole), &currentconsole->lock);
acquire(&cons.lock);
currentconsoleindex = consoleindex;
currentconsole = &consoles[currentconsoleindex];
releaseallconsoles();
currentconsole = consoleptr;
currentconsole->inuse = 1;
input = &currentconsole->keybuffer;
//ioapicenable(IRQ_KBD, 0);
loadscreenbuffer(currentconsole->screenbuffer);
// ioapicenable(IRQ_KBD, 0);
loadscreenbuffer(currentconsole->screenbuffer);
release(&cons.lock);
if (!currentconsole->active)
{
{
clearscreen();
cprintf("Welcome to Console: %d\n", currentconsoleindex);
cprintf("Welcome to Console: %d\n", currentconsole->consoleindex);
currentconsole->active = 1;
}
else
@ -540,21 +656,41 @@ int switchtoconsole(int consoleindex)
outb(CRTPORT + 1, pos >> 8);
outb(CRTPORT, 15);
outb(CRTPORT + 1, pos);
}
//wakeup(myproc()->chan);
}
// wakeup(myproc()->chan);
return 0;
}
int closeconsole(int consoleindex)
{
clearconsole(currentconsole->screenbuffer);
currentconsole->active = 0;
switchtoconsole(0);
int closeconsole(void)
{
struct vconsole* consoleptr = myproc()->consoleptr;
cprintf("Console Owner PID: %d\n", consoleptr->processowner->pid);
if (myproc() == consoleptr->processowner)
{
clearconsole(consoleptr->screenbuffer);
consoleptr->active = 0;
if (consoleptr->inuse)
{
consoleptr->inuse = 0;
switchtoconsole(&consoles[0]);
}
}
return 0;
}
int getcurrentconsoleindex(void)
{
return currentconsoleindex;
for (int i = 0; i < MAXVCONSOLES; i++)
{
if (consoles[i].inuse)
{
return consoles[i].consoleindex;
}
}
return -1;
}