X-Git-Url: https://scm.lunaixsky.com/lunaix-os.git/blobdiff_plain/db4d7d52fa00cc2fd3f25d971f57b73406d816ba..bc4c6e1218d6903b07c32b11ea7d3c82c463686e:/lunaix-os/kernel/lxconsole.c diff --git a/lunaix-os/kernel/lxconsole.c b/lunaix-os/kernel/lxconsole.c index 25c4faa..785330a 100644 --- a/lunaix-os/kernel/lxconsole.c +++ b/lunaix-os/kernel/lxconsole.c @@ -1,35 +1,97 @@ #include +#include +#include #include #include +#include #include +#include #include #include static struct console lx_console; -volatile int can_flush = 0; +int +__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_addseq(NULL, &lx_console, "tty"); + tty_dev->write = __tty_write; + tty_dev->read = __tty_read; +} + +int +__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_yieldk(); + 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 @@ -39,80 +101,104 @@ console_schedule_flush() } void -console_view_up(struct fifo_buffer* buffer) +console_view_up() { - // mutex_lock(&buffer->lock); - size_t p = buffer->rd_pos - 2; - while (p < buffer->rd_pos && p != buffer->wr_pos && + 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 && ((char*)buffer->data)[p] != '\n') { p--; } p++; - if (p < buffer->rd_pos) { + if (p > lx_console.erd_pos) { p = 0; } - buffer->rd_pos = p; - // mutex_unlock(&buffer->lock); + buffer->flags |= FIFO_DIRTY; + lx_console.erd_pos = p; + mutex_unlock(&buffer->lock); } -void -console_view_down(struct fifo_buffer* buffer) +size_t +__find_next_line(size_t start) { - // mutex_lock(&buffer->lock); - size_t p = buffer->rd_pos; - while (p != buffer->wr_pos && ((char*)buffer->data)[p] != '\n') { - p = (p + 1) % buffer->size; + size_t p = start; + while (p != lx_console.output.wr_pos && + ((char*)lx_console.output.data)[p] != '\n') { + p = (p + 1) % lx_console.output.size; } + return p + 1; +} - buffer->rd_pos = p + 1; - // mutex_unlock(&buffer->lock); +void +console_view_down() +{ + struct fifo_buf* buffer = &lx_console.output; + mutex_lock(&buffer->lock); + + lx_console.erd_pos = __find_next_line(lx_console.erd_pos); + buffer->flags |= FIFO_DIRTY; + mutex_unlock(&buffer->lock); } void -__flush_cb(void* arg) +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; } - size_t pos = tty_flush_buffer(lx_console.buffer.data, - lx_console.buffer.rd_pos, - lx_console.buffer.wr_pos, - lx_console.buffer.size); - lx_console.flush_timer = NULL; - if (pos < lx_console.buffer.wr_pos) { - console_view_down(&lx_console.buffer); - } else { - // clear the dirty bit only if we have flush all the data - // that means: read pointer == write pointer - lx_console.buffer.flags &= ~FIFO_DIRTY; - } + tty_flush_buffer(lx_console.output.data, + lx_console.erd_pos, + 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++) { - buffer[(ptr + i) % console->buffer.size] = data[i]; + c = data[i]; + if (!c) { + continue; + } + buffer[(ptr + j) % console->output.size] = c; + lines += (c == '\n'); + j++; + } + + 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->output.rd_pos = + __find_next_line((size + rd_ptr) % console->output.size); } - uintptr_t new_ptr = (ptr + size) % console->buffer.size; - console->buffer.wr_pos = new_ptr; if (new_ptr < ptr + size && new_ptr > rd_ptr) { - console->buffer.rd_pos = new_ptr; + console->output.rd_pos = new_ptr; } - console->buffer.flags |= FIFO_DIRTY; - mutex_unlock(&console->buffer.lock); + + console->lines += lines; + console->erd_pos = console->output.rd_pos; + console->output.flags |= FIFO_DIRTY; + mutex_unlock(&console->output.lock); } void @@ -131,6 +217,6 @@ void console_start_flushing() { struct lx_timer* timer = - timer_run_ms(20, __flush_cb, NULL, TIMER_MODE_PERIODIC); + timer_run_ms(20, console_flush, NULL, TIMER_MODE_PERIODIC); lx_console.flush_timer = timer; } \ No newline at end of file