X-Git-Url: https://scm.lunaixsky.com/lunaix-os.git/blobdiff_plain/7515e526342f6ee07cbe92f5a458f1c2c4a1fcaf..0e1309c02f0703c050df09b71346dab60fc6df87:/lunaix-os/kernel/lxconsole.c diff --git a/lunaix-os/kernel/lxconsole.c b/lunaix-os/kernel/lxconsole.c index 894a1b8..e58e3f1 100644 --- a/lunaix-os/kernel/lxconsole.c +++ b/lunaix-os/kernel/lxconsole.c @@ -1,55 +1,99 @@ #include #include +#include #include #include +#include #include +#include #include #include static struct console lx_console; int -__tty_write(struct device* dev, - void* buf, - unsigned int offset, - unsigned int len); +__tty_write(struct device* dev, void* buf, size_t offset, size_t len); + +int +__tty_read(struct device* dev, void* buf, size_t offset, size_t len); void lxconsole_init() { memset(&lx_console, 0, sizeof(lx_console)); - lx_console.buffer.data = VGA_BUFFER_VADDR + 0x1000; - lx_console.buffer.size = 8192; - mutex_init(&lx_console.buffer.lock); + fifo_init(&lx_console.output, VGA_BUFFER_VADDR + 0x1000, 8192, 0); + fifo_init(&lx_console.input, valloc(4096), 4096, 0); + + // FIXME use valloc to allocate console buffer. + // In doing this, the console buffer can only be accessed from kernel mode + // any direct write to this buffer from user land should be purged! // 分配控制台缓存 - for (size_t i = 0; i < PG_ALIGN(lx_console.buffer.size); i += PG_SIZE) { + for (size_t i = 0; i < PG_ALIGN(lx_console.output.size); i += PG_SIZE) { uintptr_t pa = pmm_alloc_page(KERNEL_PID, 0); vmm_set_mapping(PD_REFERENCED, - (uintptr_t)lx_console.buffer.data + i, + (uintptr_t)lx_console.output.data + i, pa, PG_PREM_URW, 0); } - memset(lx_console.buffer.data, 0, lx_console.buffer.size); - lx_console.flush_timer = NULL; - struct device* tty_dev = device_add(NULL, &lx_console, "tty"); + struct device* tty_dev = device_addseq(NULL, &lx_console, "tty"); tty_dev->write = __tty_write; + tty_dev->read = __tty_read; } int -__tty_write(struct device* dev, - void* buf, - unsigned int offset, - unsigned int len) +__tty_write(struct device* dev, void* buf, size_t offset, size_t len) { struct console* console = (struct console*)dev->underlay; console_write(console, buf, len); } +int +__tty_read(struct device* dev, void* buf, size_t offset, size_t len) +{ + struct kdb_keyinfo_pkt keyevent; + struct console* console = (struct console*)dev->underlay; + + size_t count = fifo_read(&console->input, buf, len); + if (count > 0 && ((char*)buf)[count - 1] == '\n') { + return count; + } + + while (count < len) { + // FIXME RACE! + // Consider two process that is polling the input key simultaneously. + // When a key is arrived, one of the processes will win the race and + // swallow it (advancing the key buffer pointer) + if (!kbd_recv_key(&keyevent)) { + sched_yield(); + continue; + } + if (!(keyevent.state & KBD_KEY_FPRESSED)) { + continue; + } + if ((keyevent.keycode & 0xff00) > KEYPAD) { + continue; + } + + char c = (char)(keyevent.keycode & 0x00ff); + if (c == 0x08) { + if (fifo_backone(&console->input)) { + console_write_char(c); + } + continue; + } + console_write_char(c); + if (!fifo_putone(&console->input, c) || c == '\n') { + break; + } + } + return count + fifo_read(&console->input, buf + count, len - count); +} + void console_schedule_flush() { @@ -59,7 +103,7 @@ console_schedule_flush() void console_view_up() { - struct fifo_buffer* buffer = &lx_console.buffer; + struct fifo_buf* buffer = &lx_console.output; mutex_lock(&buffer->lock); size_t p = lx_console.erd_pos - 2; while (p < lx_console.erd_pos && p != buffer->wr_pos && @@ -81,9 +125,9 @@ size_t __find_next_line(size_t start) { size_t p = start; - while (p != lx_console.buffer.wr_pos && - ((char*)lx_console.buffer.data)[p] != '\n') { - p = (p + 1) % lx_console.buffer.size; + while (p != lx_console.output.wr_pos && + ((char*)lx_console.output.data)[p] != '\n') { + p = (p + 1) % lx_console.output.size; } return p + 1; } @@ -91,7 +135,7 @@ __find_next_line(size_t start) void console_view_down() { - struct fifo_buffer* buffer = &lx_console.buffer; + struct fifo_buf* buffer = &lx_console.output; mutex_lock(&buffer->lock); lx_console.erd_pos = __find_next_line(lx_console.erd_pos); @@ -102,52 +146,59 @@ console_view_down() void console_flush() { - if (mutex_on_hold(&lx_console.buffer.lock)) { + if (mutex_on_hold(&lx_console.output.lock)) { return; } - if (!(lx_console.buffer.flags & FIFO_DIRTY)) { + if (!(lx_console.output.flags & FIFO_DIRTY)) { return; } - tty_flush_buffer(lx_console.buffer.data, + tty_flush_buffer(lx_console.output.data, lx_console.erd_pos, - lx_console.buffer.wr_pos, - lx_console.buffer.size); - lx_console.buffer.flags &= ~FIFO_DIRTY; + lx_console.output.wr_pos, + lx_console.output.size); + lx_console.output.flags &= ~FIFO_DIRTY; } void console_write(struct console* console, uint8_t* data, size_t size) { - mutex_lock(&console->buffer.lock); - uint8_t* buffer = console->buffer.data; - uintptr_t ptr = console->buffer.wr_pos; - uintptr_t rd_ptr = console->buffer.rd_pos; + mutex_lock(&console->output.lock); + uint8_t* buffer = console->output.data; + uintptr_t ptr = console->output.wr_pos; + uintptr_t rd_ptr = console->output.rd_pos; char c; int lines = 0; + int j = 0; for (size_t i = 0; i < size; i++) { c = data[i]; - buffer[(ptr + i) % console->buffer.size] = c; + if (!c) { + continue; + } + buffer[(ptr + j) % console->output.size] = c; lines += (c == '\n'); + j++; } - uintptr_t new_ptr = (ptr + size) % console->buffer.size; - console->buffer.wr_pos = new_ptr; + size = j; + + uintptr_t new_ptr = (ptr + size) % console->output.size; + console->output.wr_pos = new_ptr; if (console->lines > TTY_HEIGHT && lines > 0) { - console->buffer.rd_pos = - __find_next_line((size + rd_ptr) % console->buffer.size); + console->output.rd_pos = + __find_next_line((size + rd_ptr) % console->output.size); } if (new_ptr < ptr + size && new_ptr > rd_ptr) { - console->buffer.rd_pos = new_ptr; + console->output.rd_pos = new_ptr; } console->lines += lines; - console->erd_pos = console->buffer.rd_pos; - console->buffer.flags |= FIFO_DIRTY; - mutex_unlock(&console->buffer.lock); + console->erd_pos = console->output.rd_pos; + console->output.flags |= FIFO_DIRTY; + mutex_unlock(&console->output.lock); } void