feat: implement readlink(2) readlinkat(2)

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

diff --git a/lunaix-os/kernel/lxconsole.c b/lunaix-os/kernel/lxconsole.c
index 25c4faa1af9ff4314f5314b909f741c6847a462c..894a1b8e9837d636bbca6bf1a65355000b5316c4 100644 (file)
--- a/lunaix-os/kernel/lxconsole.c
+++ b/lunaix-os/kernel/lxconsole.c
@@ -1,4 +1,5 @@
 #include <klibc/string.h>
+#include <lunaix/device.h>
 #include <lunaix/lxconsole.h>
 #include <lunaix/mm/pmm.h>
 #include <lunaix/mm/vmm.h>
@@ -7,7 +8,11 @@
 
 static struct console lx_console;
 
-volatile int can_flush = 0;
+int
+__tty_write(struct device* dev,
+            void* buf,
+            unsigned int offset,
+            unsigned int len);
 
 void
 lxconsole_init()
@@ -30,6 +35,19 @@ lxconsole_init()
     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");
+    tty_dev->write = __tty_write;
+}
+
+int
+__tty_write(struct device* dev,
+            void* buf,
+            unsigned int offset,
+            unsigned int len)
+{
+    struct console* console = (struct console*)dev->underlay;
+    console_write(console, buf, len);
 }
 
 void
@@ -39,39 +57,50 @@ 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_buffer* buffer = &lx_console.buffer;
+    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.buffer.wr_pos &&
+           ((char*)lx_console.buffer.data)[p] != '\n') {
+        p = (p + 1) % lx_console.buffer.size;
     }
+    return p + 1;
+}
 
-    buffer->rd_pos = p + 1;
-    // mutex_unlock(&buffer->lock);
+void
+console_view_down()
+{
+    struct fifo_buffer* buffer = &lx_console.buffer;
+    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)) {
         return;
@@ -80,18 +109,11 @@ __flush_cb(void* arg)
         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.buffer.data,
+                     lx_console.erd_pos,
+                     lx_console.buffer.wr_pos,
+                     lx_console.buffer.size);
+    lx_console.buffer.flags &= ~FIFO_DIRTY;
 }
 
 void
@@ -102,15 +124,28 @@ console_write(struct console* console, uint8_t* data, size_t size)
     uintptr_t ptr = console->buffer.wr_pos;
     uintptr_t rd_ptr = console->buffer.rd_pos;
 
+    char c;
+    int lines = 0;
     for (size_t i = 0; i < size; i++) {
-        buffer[(ptr + i) % console->buffer.size] = data[i];
+        c = data[i];
+        buffer[(ptr + i) % console->buffer.size] = c;
+        lines += (c == '\n');
     }
 
     uintptr_t new_ptr = (ptr + size) % console->buffer.size;
     console->buffer.wr_pos = new_ptr;
+
+    if (console->lines > TTY_HEIGHT && lines > 0) {
+        console->buffer.rd_pos =
+          __find_next_line((size + rd_ptr) % console->buffer.size);
+    }
+
     if (new_ptr < ptr + size && new_ptr > rd_ptr) {
         console->buffer.rd_pos = new_ptr;
     }
+
+    console->lines += lines;
+    console->erd_pos = console->buffer.rd_pos;
     console->buffer.flags |= FIFO_DIRTY;
     mutex_unlock(&console->buffer.lock);
 }
@@ -131,6 +166,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