From 924d90c0665c38d417a1f71792086657bc8b489c Mon Sep 17 00:00:00 2001 From: iDunnoDev Date: Wed, 14 Dec 2022 01:04:42 +0000 Subject: [PATCH] Added code to get the consoles to be split into their own 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 --- .vscode/settings.json | 3 +- Makefile | 5 +- console.c | 594 ++++++++++++++++++++++++++---------------- defs.h | 7 +- maze.c | 66 +++++ proc.c | 13 +- proc.h | 2 +- sysproc.c | 12 +- 8 files changed, 454 insertions(+), 248 deletions(-) create mode 100644 maze.c diff --git a/.vscode/settings.json b/.vscode/settings.json index 929365a..13ad06d 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,6 +1,7 @@ { "files.associations": { "new": "c", - "*.tcc": "c" + "*.tcc": "c", + "cstdlib": "c" } } \ No newline at end of file diff --git a/Makefile b/Makefile index 8df2736..5285406 100644 --- a/Makefile +++ b/Makefile @@ -200,6 +200,7 @@ UPROGS=\ _argtest\ _screen\ _cls\ + _maze\ fs.img: mkfs $(UPROGS) ./mkfs fs.img $(UPROGS) @@ -223,8 +224,8 @@ QEMUGDB = $(shell if $(QEMU) -help | grep -q '^-gdb'; \ then echo "-gdb tcp::$(GDBPORT)"; \ else echo "-s -p $(GDBPORT)"; fi) ifndef CPUS -CPUS := 2 -#CPUS := 1 +#CPUS := 2 +CPUS := 1 # For debugging endif QEMUOPTS = -drive file=fs.img,index=1,media=disk,format=raw -drive file=xv6.img,index=0,media=disk,format=raw -smp $(CPUS) -m 512 $(QEMUEXTRA) diff --git a/console.c b/console.c index 18b4476..d56bbba 100644 --- a/console.c +++ b/console.c @@ -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(¤tconsole->lock, "vconsole0"); + currentconsole->inuse = 1; input = ¤tconsole->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(¤tconsole->lock); - //sleep(&(currentconsole), ¤tconsole->lock); + // acquire(¤tconsole->lock); + // sleep(&(currentconsole), ¤tconsole->lock); acquire(&cons.lock); - currentconsoleindex = consoleindex; - currentconsole = &consoles[currentconsoleindex]; + releaseallconsoles(); + currentconsole = consoleptr; + currentconsole->inuse = 1; input = ¤tconsole->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; } \ No newline at end of file diff --git a/defs.h b/defs.h index ba65fa5..09c349a 100644 --- a/defs.h +++ b/defs.h @@ -22,11 +22,12 @@ void cprintf(char*, ...); void consoleintr(int (*)(void)); int consoleget(void); void panic(char*) __attribute__((noreturn)); -int newconsole(void); -int switchtoconsole(int consoleindex); -int closeconsole(int consoleindex); +struct vconsole* newconsole(void); +int switchtoconsole(struct vconsole*); +int closeconsole(void); int getcurrentconsoleindex(void); void clearscreen(void); +struct vconsole* getbaseconsoleptr(void); // exec.c int exec(char*, char**); diff --git a/maze.c b/maze.c new file mode 100644 index 0000000..8e9db0e --- /dev/null +++ b/maze.c @@ -0,0 +1,66 @@ +#include "types.h" +#include "user.h" + +uint rngnumber(void) +{ + // Take from http://stackoverflow.com/questions/1167253/implementation-of-rand + static unsigned int z1 = 12345, z2 = 12345, z3 = 12345, z4 = 12345; + unsigned int b; + b = ((z1 << 6) ^ z1) >> 13; + z1 = ((z1 & 4294967294U) << 18) ^ b; + b = ((z2 << 2) ^ z2) >> 27; + z2 = ((z2 & 4294967288U) << 2) ^ b; + b = ((z3 << 13) ^ z3) >> 21; + z3 = ((z3 & 4294967280U) << 7) ^ b; + b = ((z4 << 3) ^ z4) >> 12; + z4 = ((z4 & 4294967168U) << 13) ^ b; + + return (z1 ^ z2 ^ z3 ^ z4) / 2; +} + +int rngrange(int start, int end) +{ + if (end < start) + { + int swtmp = start; + start = end; + end = swtmp; + } + + int range = end - start + 1; + return rngnumber() % (range) + start; +} + +int main(int argc, char *argv[]) { + int lines = 1000; + + for (int i = 1; i < argc; i++) { + if (strcmp(argv[i], "-l") == 0) { + lines = atoi(argv[i + 1]); + } + } + + cls(); + printf(1, "Start Maze\n"); + for (int y = 0; y < lines; y++) + { + for (int x = 0; x < 79; x++) + { + int rndnum = rngrange(189, 197); + switch (rndnum) + { + case 189: + rndnum = 179; + break; + case 190: + rndnum = 180; + break; + } + printf(1, "%c", rndnum); + + } + printf(1, "\n"); + sleep(10); + } + exit(); +} \ No newline at end of file diff --git a/proc.c b/proc.c index 2da2158..f8203aa 100644 --- a/proc.c +++ b/proc.c @@ -112,7 +112,7 @@ static struct proc* allocproc(void) { p->context = (struct context*)sp; memset(p->context, 0, sizeof *p->context); p->context->eip = (uint)forkret; - p->consoleIndex = 0; + p->consoleptr = getbaseconsoleptr(); return p; } @@ -142,7 +142,7 @@ void userinit(void) { safestrcpy(p->name, "initcode", sizeof(p->name)); p->cwd = namei("/"); - p->consoleIndex = 0; + p->consoleptr = getbaseconsoleptr(); safestrcpy(p->title, "Shell (Root)", sizeof(p->title)); // this assignment to p->state lets other cores @@ -219,7 +219,7 @@ int fork(void) { acquire(&ptable.lock); np->state = RUNNABLE; - np->consoleIndex = curproc->consoleIndex; + np->consoleptr = curproc->consoleptr; release(&ptable.lock); @@ -260,16 +260,16 @@ void exit(void) { for (p = ptable.proc; p < &ptable.proc[NPROC]; p++) { if (p->parent == curproc) { p->parent = initproc; - p->consoleIndex = 0; + p->consoleptr = getbaseconsoleptr(); if (p->state == ZOMBIE) { wakeup1(initproc); } } } - if (curproc->consoleIndex != 0 && curproc->consoleIndex == getcurrentconsoleindex()) + if (curproc->consoleptr != getbaseconsoleptr()) { - closeconsole(curproc->consoleIndex); + closeconsole(); } // Jump into the scheduler, never to return. @@ -305,6 +305,7 @@ int wait(void) { p->name[0] = 0; p->killed = 0; p->state = UNUSED; + p->consoleptr = 0; release(&ptable.lock); return pid; } diff --git a/proc.h b/proc.h index ab10b54..10b5ce0 100644 --- a/proc.h +++ b/proc.h @@ -48,7 +48,7 @@ struct proc { struct file *ofile[NOFILE]; // Open files struct inode *cwd; // Current directory char name[16]; // Process name (debugging) - uint consoleIndex; + struct vconsole* consoleptr; char title[20]; }; diff --git a/sysproc.c b/sysproc.c index 4cb5937..f0b3396 100644 --- a/sysproc.c +++ b/sysproc.c @@ -93,12 +93,12 @@ int sys_uptime(void) } int sys_greeting(void) -{ +{ cprintf("Hello again\n"); cprintf("Using Console: %d\n", getcurrentconsoleindex()); cprintf("Current PID: %d\n", myproc()->pid); cprintf("Current Parent PID: %d\n", myproc()->parent->pid); - cprintf("Process Console: %d\n", myproc()->consoleIndex); + //cprintf("Process Console: %d\n", myproc()->consoleptr->consoleindex); return 0; } @@ -129,11 +129,11 @@ int sys_screen(void) { struct proc *curproc = myproc(); int result = 0; - int consoleindex = -1; - if ((consoleindex = newconsole()) != 0) + struct vconsole* consoleptr = 0; + if ((consoleptr = newconsole()) != 0) { - curproc->consoleIndex = consoleindex; - switchtoconsole(consoleindex); + curproc->consoleptr = consoleptr; + switchtoconsole(consoleptr); result = 1; } return result;