lunaix-os/kernel/tty/lxconsole.c

   1 #include <klibc/string.h>
   2 #include <lunaix/device.h>
   3 #include <lunaix/input.h>
   4 #include <lunaix/ioctl.h>
   5 #include <lunaix/keyboard.h>
   6 #include <lunaix/lxconsole.h>
   7 #include <lunaix/mm/pmm.h>
   8 #include <lunaix/mm/valloc.h>
   9 #include <lunaix/mm/vmm.h>
  10 #include <lunaix/sched.h>
  11 #include <lunaix/tty/console.h>
  12 #include <lunaix/tty/tty.h>
  13
  14 #include <lunaix/lxsignal.h>
  15
  16 static struct console lx_console;
  17
  18 int
  19 __tty_write(struct device* dev, void* buf, size_t offset, size_t len);
  20
  21 int
  22 __tty_read(struct device* dev, void* buf, size_t offset, size_t len);
  23
  24 void
  25 console_flush();
  26
  27 static waitq_t lx_reader;
  28 static volatile char ttychr;
  29
  30 static volatile pid_t fg_pgid = 0;
  31
  32 static inline void
  33 print_control_code(const char cntrl)
  34 {
  35     console_write_char('^');
  36     console_write_char(cntrl + 64);
  37 }
  38
  39 int
  40 __lxconsole_listener(struct input_device* dev)
  41 {
  42     uint32_t key = dev->current_pkt.sys_code;
  43     uint32_t type = dev->current_pkt.pkt_type;
  44     kbd_kstate_t state = key >> 16;
  45     ttychr = key & 0xff;
  46     key = key & 0xffff;
  47
  48     if (type == PKT_RELEASE) {
  49         goto done;
  50     }
  51
  52     if ((state & KBD_KEY_FLCTRL_HELD)) {
  53         char cntrl = (char)(ttychr | 0x20);
  54         if ('a' > cntrl || cntrl > 'z') {
  55             goto done;
  56         }
  57         ttychr = cntrl - 'a' + 1;
  58         switch (ttychr) {
  59             case TCINTR:
  60                 signal_send(-fg_pgid, _SIGINT);
  61                 print_control_code(ttychr);
  62                 break;
  63             case TCSTOP:
  64                 signal_send(-fg_pgid, _SIGSTOP);
  65                 print_control_code(ttychr);
  66                 break;
  67             default:
  68                 break;
  69         }
  70     } else if (key == KEY_PG_UP) {
  71         console_view_up();
  72         goto done;
  73     } else if (key == KEY_PG_DOWN) {
  74         console_view_down();
  75         goto done;
  76     } else if ((key & 0xff00) <= KEYPAD) {
  77         ttychr = key;
  78     } else {
  79         goto done;
  80     }
  81
  82     pwake_all(&lx_reader);
  83
  84 done:
  85     return INPUT_EVT_NEXT;
  86 }
  87
  88 int
  89 __tty_exec_cmd(struct device* dev, uint32_t req, va_list args)
  90 {
  91     switch (req) {
  92         case TIOCGPGRP:
  93             return fg_pgid;
  94         case TIOCSPGRP:
  95             fg_pgid = va_arg(args, pid_t);
  96             break;
  97         case TIOCCLSBUF:
  98             fifo_clear(&lx_console.output);
  99             fifo_clear(&lx_console.input);
 100             lx_console.wnd_start = 0;
 101             lx_console.lines = 0;
 102             lx_console.output.flags |= FIFO_DIRTY;
 103             break;
 104         case TIOCFLUSH:
 105             lx_console.output.flags |= FIFO_DIRTY;
 106             console_flush();
 107             break;
 108         default:
 109             return EINVAL;
 110     }
 111     return 0;
 112 }
 113
 114 void
 115 lxconsole_init()
 116 {
 117     memset(&lx_console, 0, sizeof(lx_console));
 118     fifo_init(&lx_console.output, valloc(8192), 8192, 0);
 119     fifo_init(&lx_console.input, valloc(4096), 4096, 0);
 120
 121     lx_console.flush_timer = NULL;
 122 }
 123
 124 int
 125 __tty_write_pg(struct device* dev, void* buf, size_t offset)
 126 {
 127     return __tty_write(dev, buf, offset, PG_SIZE);
 128 }
 129
 130 int
 131 __tty_read_pg(struct device* dev, void* buf, size_t offset)
 132 {
 133     return __tty_read(dev, buf, offset, PG_SIZE);
 134 }
 135
 136 void
 137 lxconsole_spawn_ttydev()
 138 {
 139     struct device* tty_dev = device_addseq(NULL, &lx_console, "tty");
 140     tty_dev->write = __tty_write;
 141     tty_dev->write_page = __tty_write_pg;
 142     tty_dev->read = __tty_read;
 143     tty_dev->read_page = __tty_read_pg;
 144     tty_dev->exec_cmd = __tty_exec_cmd;
 145
 146     waitq_init(&lx_reader);
 147     input_add_listener(__lxconsole_listener);
 148 }
 149
 150 int
 151 __tty_write(struct device* dev, void* buf, size_t offset, size_t len)
 152 {
 153     struct console* console = (struct console*)dev->underlay;
 154     console_write(console, buf, len);
 155 }
 156
 157 int
 158 __tty_read(struct device* dev, void* buf, size_t offset, size_t len)
 159 {
 160     struct console* console = (struct console*)dev->underlay;
 161
 162     size_t count = fifo_read(&console->input, buf, len);
 163     if (count > 0 && ((char*)buf)[count - 1] == '\n') {
 164         return count;
 165     }
 166
 167     while (count < len) {
 168         pwait(&lx_reader);
 169
 170         if (ttychr < 0x1B) {
 171             // ASCII control codes
 172             switch (ttychr) {
 173                 case TCINTR:
 174                     fifo_clear(&console->input);
 175                     return 0;
 176                 case TCBS:
 177                     if (fifo_backone(&console->input)) {
 178                         console_write_char(ttychr);
 179                     }
 180                     continue;
 181                 case TCLF:
 182                 case TCCR:
 183                     goto proceed;
 184                 default:
 185                     break;
 186             }
 187             print_control_code(ttychr);
 188             continue;
 189         }
 190
 191     proceed:
 192         console_write_char(ttychr);
 193         if (!fifo_putone(&console->input, ttychr) || ttychr == '\n') {
 194             break;
 195         }
 196     }
 197     return count + fifo_read(&console->input, buf + count, len - count);
 198 }
 199
 200 void
 201 console_schedule_flush()
 202 {
 203     // TODO make the flush on-demand rather than periodic
 204 }
 205
 206 size_t
 207 __find_next_line(size_t start)
 208 {
 209     size_t p = start - 1;
 210     struct fifo_buf* buffer = &lx_console.output;
 211     do {
 212         p = (p + 1) % buffer->size;
 213     } while (p != buffer->wr_pos && ((char*)buffer->data)[p] != '\n');
 214     return p + (((char*)buffer->data)[p] == '\n');
 215 }
 216
 217 size_t
 218 __find_prev_line(size_t start)
 219 {
 220     size_t p = start - 1;
 221     struct fifo_buf* buffer = &lx_console.output;
 222     do {
 223         p--;
 224     } while (p < lx_console.wnd_start && p != buffer->wr_pos &&
 225              ((char*)buffer->data)[p] != '\n');
 226
 227     if (p > lx_console.wnd_start) {
 228         return 0;
 229     }
 230     return p + 1;
 231 }
 232
 233 void
 234 console_view_up()
 235 {
 236     struct fifo_buf* buffer = &lx_console.output;
 237     mutex_lock(&buffer->lock);
 238     fifo_set_rdptr(buffer, __find_prev_line(buffer->rd_pos));
 239     buffer->flags |= FIFO_DIRTY;
 240     mutex_unlock(&buffer->lock);
 241
 242     console_flush();
 243 }
 244
 245 void
 246 console_view_down()
 247 {
 248     struct fifo_buf* buffer = &lx_console.output;
 249     mutex_lock(&buffer->lock);
 250
 251     size_t wnd = lx_console.wnd_start;
 252     size_t p = __find_next_line(buffer->rd_pos);
 253     fifo_set_rdptr(buffer, p > wnd ? wnd : p);
 254     buffer->flags |= FIFO_DIRTY;
 255     mutex_unlock(&buffer->lock);
 256
 257     console_flush();
 258 }
 259
 260 void
 261 console_flush()
 262 {
 263     if (mutex_on_hold(&lx_console.output.lock)) {
 264         return;
 265     }
 266     if (!(lx_console.output.flags & FIFO_DIRTY)) {
 267         return;
 268     }
 269
 270     size_t rdpos_save = lx_console.output.rd_pos;
 271     tty_flush_buffer(&lx_console.output);
 272     fifo_set_rdptr(&lx_console.output, rdpos_save);
 273
 274     lx_console.output.flags &= ~FIFO_DIRTY;
 275 }
 276
 277 void
 278 console_write(struct console* console, uint8_t* data, size_t size)
 279 {
 280     struct fifo_buf* fbuf = &console->output;
 281     mutex_lock(&console->output.lock);
 282     fifo_set_rdptr(fbuf, console->wnd_start);
 283
 284     uint8_t* buffer = fbuf->data;
 285     uintptr_t ptr = fbuf->wr_pos;
 286     uintptr_t rd_ptr = fbuf->rd_pos;
 287
 288     char c;
 289     for (size_t i = 0; i < size; i++) {
 290         c = data[i];
 291         if (!c) {
 292             continue;
 293         }
 294         if (c == '\n') {
 295             console->lines++;
 296         } else if (c == '\x08') {
 297             ptr = ptr ? ptr - 1 : fbuf->size - 1;
 298             continue;
 299         }
 300         buffer[ptr] = c;
 301         ptr = (ptr + 1) % fbuf->size;
 302     }
 303
 304     fifo_set_wrptr(fbuf, ptr);
 305
 306     while (console->lines >= TTY_HEIGHT) {
 307         rd_ptr = __find_next_line(rd_ptr);
 308         console->lines--;
 309     }
 310
 311     fifo_set_rdptr(&lx_console.output, rd_ptr);
 312     console->wnd_start = rd_ptr;
 313     fbuf->flags |= FIFO_DIRTY;
 314     mutex_unlock(&fbuf->lock);
 315
 316     if (!lx_console.flush_timer) {
 317         console_flush();
 318     }
 319 }
 320
 321 void
 322 console_write_str(char* str)
 323 {
 324     console_write(&lx_console, str, strlen(str));
 325 }
 326
 327 void
 328 console_write_char(char str)
 329 {
 330     console_write(&lx_console, &str, 1);
 331 }
 332
 333 void
 334 console_start_flushing()
 335 {
 336     struct lx_timer* timer =
 337       timer_run_ms(20, console_flush, NULL, TIMER_MODE_PERIODIC);
 338     lx_console.flush_timer = timer;
 339 }