Phase 4: keyboard driver, shell

#include "keyboard.h"

#include <stddef.h>
#include <stdint.h>

#define KBD_DATA   0x60
#define KBD_STATUS 0x64

#define SC_LSHIFT 0x2A
#define SC_RSHIFT 0x36

static inline uint8_t inb(uint16_t port) {
    uint8_t ret;
    __asm__ volatile ("inb %1, %0" : "=a"(ret) : "Nd"(port));
    return ret;
}

/* Scancode set 1, indexed by make code. 0 = unmapped/non-printable. */
static const char lower_table[] = {
    0,    27,  '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', '\b',
    '\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n',
    0 /*ctrl*/, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '`',
    0 /*lshift*/, '\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/',
    0 /*rshift*/, '*', 0 /*alt*/, ' ',
};

static const char upper_table[] = {
    0,    27,  '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '\b',
    '\t', 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n',
    0, 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', '"', '~',
    0, '|', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?',
    0, '*', 0, ' ',
};

#define TABLE_LEN (sizeof(lower_table) / sizeof(lower_table[0]))

static int shift_down = 0;

static int scancode_ready(void) {
    return inb(KBD_STATUS) & 1;
}

char keyboard_getchar(void) {
    for (;;) {
        while (!scancode_ready()) {}
        uint8_t sc = inb(KBD_DATA);

        int release = sc & 0x80;
        uint8_t code = sc & 0x7F;

        if (code == SC_LSHIFT || code == SC_RSHIFT) {
            shift_down = !release;
            continue;
        }
        if (release || code >= TABLE_LEN) {
            continue;
        }

        char c = shift_down ? upper_table[code] : lower_table[code];
        if (c == 0) {
            continue;
        }
        return c;
    }
}

#include "shell.h"

#include <stdint.h>

#include "console.h"
#include "fs/tinyfs.h"
#include "keyboard.h"
#include "serial.h"
#include "string.h"

#define LINE_MAX 128

static inline void outb(uint16_t port, uint8_t val) {
    __asm__ volatile ("outb %0, %1" : : "a"(val), "Nd"(port));
}

static inline uint8_t inb(uint16_t port) {
    uint8_t ret;
    __asm__ volatile ("inb %1, %0" : "=a"(ret) : "Nd"(port));
    return ret;
}

static void echo_char(char c) {
    console_putc(c);
    serial_putc(c);
}

static void print_line(const char *s) {
    console_write(s);
    console_write("\n");
    serial_write(s);
    serial_write("\n");
}

static int read_line(char *buf, int max_len) {
    int len = 0;
    for (;;) {
        char c = keyboard_getchar();
        if (c == '\n') {
            echo_char('\n');
            buf[len] = '\0';
            return len;
        } else if (c == '\b') {
            if (len > 0) {
                len--;
                echo_char('\b');
                echo_char(' ');
                echo_char('\b');
            }
        } else if (c >= 32 && c < 127 && len < max_len - 1) {
            buf[len++] = c;
            echo_char(c);
        }
    }
}

static void skip_spaces(const char **p) {
    while (**p == ' ') {
        (*p)++;
    }
}

static int next_word(const char **p, char *out, int max_len) {
    skip_spaces(p);
    int n = 0;
    while (**p && **p != ' ' && n < max_len - 1) {
        out[n++] = *(*p)++;
    }
    out[n] = '\0';
    return n;
}

static void cmd_help(void) {
    print_line("commands: ls, cat <file>, write <file> <text>, rm <file>, help, clear, reboot");
}

static void cmd_ls(void) {
    tinyfs_dirent_t entries[TINYFS_NUM_INODES];
    int n = tinyfs_list(entries, TINYFS_NUM_INODES);
    char numbuf[16];
    for (int i = 0; i < n; i++) {
        console_write(entries[i].name);
        console_write("  ");
        console_write(itoa((int)entries[i].size, numbuf, 10));
        console_write("\n");
        serial_write(entries[i].name);
        serial_write("  ");
        serial_write(itoa((int)entries[i].size, numbuf, 10));
        serial_write("\n");
    }
}

static void cmd_cat(const char *name) {
    static char buf[TINYFS_MAX_FILE_SIZE + 1];
    uint32_t len = 0;
    if (tinyfs_read(name, buf, sizeof(buf) - 1, &len) != 0) {
        print_line("cat: no such file");
        return;
    }
    buf[len] = '\0';
    console_write(buf);
    serial_write(buf);
    if (len == 0 || buf[len - 1] != '\n') {
        console_write("\n");
        serial_write("\n");
    }
}

static void cmd_write(const char *name, const char *contents) {
    tinyfs_create(name); /* ignored if it already exists - write() below overwrites it */
    uint32_t len = (uint32_t)strlen(contents);
    if (len > TINYFS_MAX_FILE_SIZE) {
        print_line("write: content too long");
        return;
    }
    if (tinyfs_write(name, contents, len) != 0) {
        print_line("write: failed (no space or bad name)");
        return;
    }
    print_line("write: ok");
}

static void cmd_rm(const char *name) {
    if (tinyfs_delete(name) != 0) {
        print_line("rm: no such file");
    } else {
        print_line("rm: ok");
    }
}

static void cmd_reboot(void) {
    print_line("rebooting...");
    uint8_t status;
    do {
        status = inb(0x64);
    } while (status & 0x02);
    outb(0x64, 0xFE); /* pulse the keyboard controller's reset line */
    for (;;) {
        __asm__ volatile ("hlt");
    }
}

void shell_run(void) {
    static char line[LINE_MAX];

    print_line("tiny-os shell. type 'help' for commands.");

    for (;;) {
        console_write("> ");
        serial_write("> ");
        read_line(line, sizeof(line));

        const char *p = line;
        char cmd[32];
        if (next_word(&p, cmd, sizeof(cmd)) == 0) {
            continue;
        }

        if (strcmp(cmd, "help") == 0) {
            cmd_help();
        } else if (strcmp(cmd, "ls") == 0) {
            cmd_ls();
        } else if (strcmp(cmd, "clear") == 0) {
            console_clear();
        } else if (strcmp(cmd, "reboot") == 0) {
            cmd_reboot();
        } else if (strcmp(cmd, "cat") == 0) {
            char name[TINYFS_NAME_MAX];
            if (next_word(&p, name, sizeof(name)) == 0) {
                print_line("usage: cat <file>");
            } else {
                cmd_cat(name);
            }
        } else if (strcmp(cmd, "rm") == 0) {
            char name[TINYFS_NAME_MAX];
            if (next_word(&p, name, sizeof(name)) == 0) {
                print_line("usage: rm <file>");
            } else {
                cmd_rm(name);
            }
        } else if (strcmp(cmd, "write") == 0) {
            char name[TINYFS_NAME_MAX];
            if (next_word(&p, name, sizeof(name)) == 0) {
                print_line("usage: write <file> <text>");
            } else {
                skip_spaces(&p);
                cmd_write(name, p);
            }
        } else {
            print_line("unknown command (type 'help')");
        }
    }
}

#!/usr/bin/env python3
"""Types text into a running QEMU guest via its HMP monitor's `sendkey`
command, over a unix socket (-monitor unix:PATH,server,nowait). Used by
tools/run_tests.sh to drive the kernel shell headlessly - there is no
other way to feed the polled PS/2 keyboard driver without real hardware
or a display.
"""
import socket
import sys
import time

KEYMAP = {
    " ": "spc",
    ".": "dot",
    "\n": "ret",
    "-": "minus",
    "_": "shift-minus",
    ",": "comma",
    "/": "slash",
}


def key_name(c):
    if c in KEYMAP:
        return KEYMAP[c]
    if c.isalpha():
        return c.lower()
    if c.isdigit():
        return c
    raise ValueError(f"qemu_type: no key mapping for {c!r}")


def main():
    if len(sys.argv) != 3:
        print(f"usage: {sys.argv[0]} <monitor-socket> <text>", file=sys.stderr)
        sys.exit(1)

    sock_path, text = sys.argv[1], sys.argv[2]

    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    s.connect(sock_path)
    time.sleep(0.2)
    s.recv(4096)  # monitor banner

    for c in text:
        s.sendall(f"sendkey {key_name(c)}\n".encode())
        time.sleep(0.05)
        s.recv(4096)

    s.close()


if __name__ == "__main__":
    main()

#!/usr/bin/env bash
# Boots the kernel headlessly in QEMU, checks the kernel self-test result,
# then drives the interactive shell via QEMU's monitor `sendkey` (see
# tools/qemu_type.py - there's no other way to feed the polled PS/2
# keyboard driver without real hardware) and asserts on serial output.
set -euo pipefail

cd "$(dirname "$0")/.."
make >/dev/null

BUILD=build
LOG="$BUILD/serial.log"
MON="$BUILD/qemu-monitor.sock"
rm -f "$LOG" "$MON"

qemu-system-i386 \
    -drive file="$BUILD/disk.img",format=raw \
    -display none \
    -serial file:"$LOG" \
    -monitor unix:"$MON",server,nowait \
    -no-reboot &
QEMU_PID=$!

cleanup() {
    kill "$QEMU_PID" 2>/dev/null || true
    wait "$QEMU_PID" 2>/dev/null || true
}
trap cleanup EXIT

fail() {
    echo "run_tests: FAIL - $1"
    echo "--- serial log ---"
    cat "$LOG" 2>/dev/null || true
    exit 1
}

wait_for() {
    local pattern="$1"
    local max_tries="${2:-50}" # 50 * 0.2s = 10s
    local i=0
    while ! grep -qF "$pattern" "$LOG" 2>/dev/null; do
        i=$((i + 1))
        if [ "$i" -ge "$max_tries" ]; then
            fail "timed out waiting for '$pattern'"
        fi
        sleep 0.2
    done
}

type_line() {
    python3 tools/qemu_type.py "$MON" "$1"$'\n'
}

for i in $(seq 1 25); do
    [ -S "$MON" ] && break
    sleep 0.2
done
[ -S "$MON" ] || fail "qemu monitor socket never appeared"

wait_for "SELFTEST PASS"
wait_for "type 'help'"

type_line "ls"
wait_for "hello.txt"

type_line "cat hello.txt"
wait_for "Hello, tinyfs!"

type_line "write greet.txt hi there"
wait_for "write: ok"

type_line "cat greet.txt"
wait_for "hi there"

type_line "rm greet.txt"
wait_for "rm: ok"

type_line "cat greet.txt"
wait_for "cat: no such file"

type_line "help"
wait_for "commands:"

echo "run_tests: PASS"