feat: mount point flags check

[lunaix-os.git] / lunaix-os / kernel / lxconsole.c

diff --git a/lunaix-os/kernel/lxconsole.c b/lunaix-os/kernel/lxconsole.c
index 0a2d449a1ad291df6a22fbeda1528a316ec1fa27..785330a4aa4b5d78b4ea9e06421281b55b48ea2f 100644 (file)
--- a/lunaix-os/kernel/lxconsole.c
+++ b/lunaix-os/kernel/lxconsole.c
@@ -1,33 +1,97 @@
 #include <klibc/string.h>
 #include <klibc/string.h>

+#include <lunaix/device.h>
+#include <lunaix/keyboard.h>

 #include <lunaix/lxconsole.h>
 #include <lunaix/mm/pmm.h>
 #include <lunaix/lxconsole.h>
 #include <lunaix/mm/pmm.h>

+#include <lunaix/mm/valloc.h>

 #include <lunaix/mm/vmm.h>
 #include <lunaix/mm/vmm.h>

+#include <lunaix/sched.h>

 #include <lunaix/tty/console.h>
 #include <lunaix/tty/tty.h>
 
 static struct console lx_console;
 
 #include <lunaix/tty/console.h>
 #include <lunaix/tty/tty.h>
 
 static struct console lx_console;
 

+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));
 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 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);
     }
 
                         pa,
                         PG_PREM_URW,
                         0);
     }
 

-    memset(lx_console.buffer.data, 0, lx_console.buffer.size);
-

     lx_console.flush_timer = NULL;
     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
 }
 
 void


@@ -39,7 +103,7 @@ console_schedule_flush()
 void
 console_view_up()
 {
 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 &&
     mutex_lock(&buffer->lock);
     size_t p = lx_console.erd_pos - 2;
     while (p < lx_console.erd_pos && p != buffer->wr_pos &&


@@ -61,9 +125,9 @@ size_t
 __find_next_line(size_t start)
 {
     size_t p = start;
 __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;
 }
     }
     return p + 1;
 }


@@ -71,7 +135,7 @@ __find_next_line(size_t start)
 void
 console_view_down()
 {
 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);
     mutex_lock(&buffer->lock);
 
     lx_console.erd_pos = __find_next_line(lx_console.erd_pos);


@@ -80,54 +144,61 @@ console_view_down()
 }
 
 void
 }
 
 void

-console_flush(void* arg)
+console_flush()

 {
 {

-    if (mutex_on_hold(&lx_console.buffer.lock)) {
+    if (mutex_on_hold(&lx_console.output.lock)) {

         return;
     }
         return;
     }

-    if (!(lx_console.buffer.flags & FIFO_DIRTY)) {
+    if (!(lx_console.output.flags & FIFO_DIRTY)) {

         return;
     }
 
         return;
     }
 

-    tty_flush_buffer(lx_console.buffer.data,
+    tty_flush_buffer(lx_console.output.data,

                      lx_console.erd_pos,
                      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)
 {
 }
 
 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;
 
     char c;
     int lines = 0;

+    int j = 0;

     for (size_t i = 0; i < size; i++) {
         c = data[i];
     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');
         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) {
 
     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) {
     }
 
     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->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
 }
 
 void