15. System Calls API Setup - josehu07/hux-kernel GitHub Wiki

/** Helpers for getting something from user memory address. */
bool
sysarg_addr_int(uint32_t addr, int32_t *ret)
{
    process_t *proc = running_proc();

    if (addr < proc->stack_low || addr + 4 > USER_MAX) {
        warn("sysarg_addr_int: invalid arg addr %p for %s", addr, proc->name);
        return false;
    }

    *ret = *((int32_t *) addr);
    return true;
}

bool
sysarg_addr_uint(uint32_t addr, uint32_t *ret)
{
    process_t *proc = running_proc();

    if (addr < proc->stack_low || addr + 4 > USER_MAX) {
        warn("sysarg_addr_uint: invalid arg addr %p for %s", addr, proc->name);
        return false;
    }

    *ret = *((uint32_t *) addr);
    return true;
}

bool
sysarg_addr_mem(uint32_t addr, char **mem, size_t len)
{
    process_t *proc = running_proc();

    if (addr >= USER_MAX || addr + len > USER_MAX || addr < USER_BASE
        || (addr >= proc->heap_high && addr < proc->stack_low)
        || (addr + len > proc->heap_high && addr + len <= proc->stack_low)
        || (addr < proc->heap_high && addr + len > proc->heap_high)) {
        warn("sysarg_addr_mem: invalid mem %p w/ len %d for %s",
             addr, len, proc->name);
        return false;
    }

    *mem = (char *) addr;
    return true;
}

int32_t
sysarg_addr_str(uint32_t addr, char **str)
{
    process_t *proc = running_proc();

    if (addr >= USER_MAX || addr < USER_BASE
        || (addr >= proc->heap_high && addr < proc->stack_low)) {
        warn("sysarg_get_str: invalid str %p for %s",
             addr, proc->name);
        return -1;
    }

    char *bound = addr < proc->heap_high ? (char *) proc->heap_high
                                         : (char *) USER_MAX;
    for (char *c = (char *) addr; c < bound; ++c) {
        if (*c == '\0') {
            *str = (char *) addr;
            return c - (char *) addr;
        }
    }
    return -1;
}


/**
 * Get syscall arguments on the user stack.
 *   - state->esp is the current user ESP;
 *   - 0(state->esp) is the return address, so skip;
 *   - starting from 4(state->esp) are the arguments, from stack
 *     bottom -> top are user lib arguments from left -> right.
 */

/**
 * Fetch the n-th (starting from 0-th) 32bit integer. Returns true on
 * success and false if address not in user stack.
 */
bool
sysarg_get_int(int8_t n, int32_t *ret)
{
    process_t *proc = running_proc();
    uint32_t addr = (proc->trap_state->esp) + 4 + (4 * n);
    return sysarg_addr_int(addr, ret);
}

/** Same but for uint32_t. */
bool
sysarg_get_uint(int8_t n, uint32_t *ret)
{
    process_t *proc = running_proc();
    uint32_t addr = (proc->trap_state->esp) + 4 + (4 * n);
    return sysarg_addr_uint(addr, ret);
}

/**
 * Fetch the n-th (starting from 0-th) 32-bit argument and interpret as
 * a pointer to a bytes array of length `len`. Returns true on success
 * and false if address invalid.
 */
bool
sysarg_get_mem(int8_t n, char **mem, size_t len)
{
    uint32_t ptr;
    if (!sysarg_get_int(n, (int32_t *) &ptr)) {
        warn("sysarg_get_mem: inner sysarg_get_int failed");
        return false;
    }
    return sysarg_addr_mem(ptr, mem, len);
}

/**
 * Fetch the n-th (starting from 0-th) 32-bit argument and interpret as
 * a pointer to a string. Returns the length of string actually parsed
 * on success, and -1 if address invalid or the string is not correctly
 * null-terminated.
 */
int32_t
sysarg_get_str(int8_t n, char **str)
{
    uint32_t ptr;
    if (!sysarg_get_int(n, (int32_t *) &ptr)) {
        warn("sysarg_get_str: inner sysarg_get_int failed");
        return -1;
    }
    return sysarg_addr_str(ptr, str);
}


// src/interrupt/syscall.h

bool sysarg_addr_int(uint32_t addr, int32_t *ret);
bool sysarg_addr_uint(uint32_t addr, uint32_t *ret);
bool sysarg_addr_mem(uint32_t addr, char **mem, size_t len);
int32_t sysarg_addr_str(uint32_t addr, char **str);

bool sysarg_get_int(int8_t n, int32_t *ret);
bool sysarg_get_uint(int8_t n, uint32_t *ret);
bool sysarg_get_mem(int8_t n, char **mem, size_t len);
int32_t sysarg_get_str(int8_t n, char **str);

/** Individual syscall handler type: void -> int32_t. */
typedef int32_t (*syscall_t)(void);

/** Syscall unsuccessful return code. */
#define SYS_FAIL_RC (-1)

void syscall(interrupt_state_t *state);


/** List of known syscall numbers. */
#define SYSCALL_HELLO 1

/**
 * Centralized syscall handler entry.
 *   - The trap state holds the syscall number in register EAX
 *     and the arguments on user stack;
 *   - Returns a return code back to register EAX.
 *
 * User syscall library should do syscalls following this rule.
 */
void
syscall(interrupt_state_t *state)
{
    int32_t syscall_no = state->eax;

    if (syscall_no <= 0 || syscall_no >= NUM_SYSCALLS) {
        warn("syscall: unknwon syscall number %d", syscall_no);
        state->eax = SYS_FAIL_RC;
    } else if (syscall_handlers[syscall_no] == NULL) {
        warn("syscall: null handler for syscall # %d", syscall_no);
        state->eax = SYS_FAIL_RC;
    } else {
        syscall_t handler = syscall_handlers[syscall_no];
        state->eax = handler();
    }
}

/** int32_t hello(int32_t num, char *mem, int32_t len, char *str); */
int32_t
syscall_hello(void)
{
    int32_t num, len;
    char *mem, *str;

    if (!sysarg_get_int(0, &num))
        return SYS_FAIL_RC;
    if (!sysarg_get_int(2, &len))
        return SYS_FAIL_RC;
    if (len <= 0)
        return SYS_FAIL_RC;
    if (!sysarg_get_mem(1, &mem, len))
        return SYS_FAIL_RC;
    if (sysarg_get_str(3, &str) < 0)
        return SYS_FAIL_RC;

    process_t *proc = running_proc();
    printf("From sysall_hello handler: Hello, %s!\n", proc->name);
    printf("  num: %d, mem[0]: %c, str: %s\n", num, mem[0], str);

    return 0;
}


// src/process/sysproc.h
int32_t syscall_hello(void);

/** Array of individual handlers: void -> int32_t functions. */
static syscall_t syscall_handlers[] = {
    [SYSCALL_HELLO]     syscall_hello
};

#define NUM_SYSCALLS ((int32_t) (sizeof(syscall_handlers) / sizeof(syscall_t)))

/** Print interrupt state information. */
static void
_print_interrupt_state(interrupt_state_t *state)
{
    info("interrupt state:");
    process_t *proc = running_proc();
    printf("  Current process: %d - %s\n", proc->pid, proc->name);
    printf("  INT#: %d  ERR_CODE: %#010X\n",
           state->int_no, state->err_code);
    printf("  EAX: %#010X  EIP: %#010X  ESP: %#010X\n",
           state->eax, state->eip, state->esp);
    printf("   DS: %#010X   CS: %#010X   SS: %#010X\n",
           state->ds, state->cs, state->ss);
    printf("  EFLAGS: %#010X\n", state->eflags);
}

/**
 * ISR handler written in C.
 *
 * Receives a pointer to a structure of interrupt state. Handles the
 * interrupt and simply returns. Can modify interrupt state through
 * this pointer if necesary.
 */
void
isr_handler(interrupt_state_t *state)
{
    uint8_t int_no = state->int_no;

    /** An exception interrupt. */
    if (int_no <= 31) {

        /** Panic if no actual ISR is registered. */
        if (isr_table[int_no] == NULL) {
            _print_interrupt_state(state);
            error("isr: missing handler for exception (fault) # %#x", int_no);
        } else
            isr_table[int_no](state);

    /** An IRQ-translated interrupt from external device. */
    } else if (int_no <= 47) {
        uint8_t irq_no = state->int_no - 32;

        /** Call actual ISR if registered. */
        if (isr_table[int_no] == NULL) {
            _print_interrupt_state(state);
            error("isr: missing handler for device interrupt # %#x", int_no);
        } else
            isr_table[int_no](state);

        _pic_send_eoi(irq_no);      /** Send back EOI signal to PIC. */

    /** Syscall trap. */
    } else if (int_no == INT_NO_SYSCALL) {

        /** Point proc->trap_state to this trap. */
        running_proc()->trap_state = state;

        /**
         * Call the syscall handler in `syscall.c`.
         *
         * Interrupt state contains the syscall number in EAX and the
         * arguments on the user stack. Returns an integer return code
         * back to EAX.
         */
        syscall(state);

    /** Unknown interrupt number. */
    } else {
        _print_interrupt_state(state);
        error("isr: caught unknown interrupt # %#x", int_no);
    }
}

/** Syscall trap gate number. */
INT_NO_SYSCALL = 64


/** List of known syscall. */
SYSCALL_HELLO = 1

.include "syslist.s"


/**
 * Using an auto-generation macro, since every syscall expect the same
 * thing of putting arguments on stack, setting EAX to the number, etc.
 */
.macro SYSCALL_LIBGEN name, no
    .global \name
    .type \name, @function
    \name:
        movl $\no, %eax
        int $INT_NO_SYSCALL
        ret
.endm


SYSCALL_LIBGEN hello, SYSCALL_HELLO

// user/lib/syscall.h

#ifndef SYSCALL_H
#define SYSCALL_H


#include <stdint.h>


/**
 * Externed from ASM `syscall.s`.
 *
 * Be sure that all arguments & returns values are 32-bit values, since
 * Hux parses syscall arguments by simply getting 32-bit values on stack.
 */
extern int32_t hello(int32_t num, char *mem, int32_t len, char *str);


#endif

void
main(void)
{
    int32_t num = 7913;

    char mem[8] = "ABCDEFG";
    int32_t len = 7;

    char *str = "This is init!";

    hello(num, mem, len, str);

    asm volatile ( "hlt" );
}