kernel.cc

#include "kernel.hh"
#include "k-ahci.hh"
#include "k-nic.hh"
#include "k-apic.hh"
#include "k-chkfs.hh"
#include "k-chkfsiter.hh"
#include "k-devices.hh"
#include "k-vmiter.hh"
#include "k-fs.hh"
#include "k-net.hh"
#include "obj/k-firstprocess.h"

// kernel.cc
//
//    This is the kernel.

// # timer interrupts so far on CPU 0
std::atomic<unsigned long> ticks;

static void tick();
static void start_initial_process(pid_t pid, const char* program_name);
void run_init_task();

// kernel_start(command)
//    Initialize the hardware and processes and start running. The `command`
//    string is an optional string passed from the boot loader.

void kernel_start(const char* command) {
    init_hardware();
    consoletype = CONSOLE_NORMAL;
    console_clear();

    // set up process descriptors
    for (pid_t i = 0; i < NTHREAD; i++) {
        ptable[i] = nullptr;
    }
    for (pid_t i = 0; i < NPROC; i++) {
        gtable[i] = nullptr;
    }

    // start `init` kernel process (pid 1)
    proc* init = knew<proc>();
    init->group_ = knew<thread_group>();
    init->group_->threads_.push_front(init);
    init->init_kernel(run_init_task);
    init->id_ = 1;
    init->group_->pid_ = 1;
    init->group_->parent_id_ = 1;
    ptable[init->id_] = init;
    gtable[init->group_->pid_] = init->group_;
    cpus[0].enqueue(init);

    // Create network daemon kernel thread on the init process
    if (eth_nic) {
        proc* netd = knew<proc>();
        netd->group_ = init->group_;
        init->group_->threads_.push_back(netd);
        netd->id_ = 2;
        netd->init_kernel(run_packet_handler_task);
        ptable[netd->id_] = netd;
        cpus[ncpu-1].enqueue(netd);
    }

    // start first process
    start_initial_process(2, CHICKADEE_FIRST_PROCESS);

    // start running processes
    cpus[0].schedule();
}


// start_initial_process(pid, name)
//    Load application program `name` as process number `pid`.
//    This loads the application's code and data into memory, sets its
//    %rip and %rsp, gives it a stack page, and marks it as runnable.
//    Only called at initial boot time.

void start_initial_process(pid_t pid, const char* name) {
    // look up process image in initfs
    spinlock_guard initfs_guard(memfile::initfs_lock);
    int mindex = memfile::initfs_lookup(name, memfile::required);
    x86_64_pagetable* pt = knew_pagetable();
    assert(mindex >= 0 && pt);

    // load code and data into pagetable
    memfile_loader ld(mindex, pt);
    int r = proc::load(ld);
    assert(r >= 0);
    initfs_guard.unlock();

    pid_t tid = 1;
    for (; tid < NTHREAD; ++tid) {
        if (!ptable[tid]) {
            break;
        }
    }
    assert(tid < NTHREAD);

    // allocate process, initialize registers
    proc* p = knew<proc>();
    p->group_ = knew<thread_group>();
    p->group_->threads_.push_front(p);
    p->id_ = tid;
    p->group_->pid_ = pid;
    p->group_->parent_id_ = 1; // Force init process ID as parent
    p->init_user(pt);
    p->regs_->reg_rip = ld.entry_rip_;

    // initialize stack
    void* stkpg = kalloc(PAGESIZE);
    assert(stkpg);
    vmiter(p, MEMSIZE_VIRTUAL - PAGESIZE).map(stkpg, PTE_PWU);
    p->regs_->reg_rsp = MEMSIZE_VIRTUAL;

    // map console
    vmiter(p, ktext2pa(console)).map(console, PTE_PWU);

    // create standard i/o file descriptors
    file* stdio = knew<file>();
    stdio->vnode_ = knew<stdio_vnode>();
    stdio->vnode_->refcount_ = 1;
    stdio->mode_ = OF_READ | OF_WRITE;
    assert(!file_table[0]);
    file_table[0] = stdio;
    
    p->group_->file_descriptors_[0] = 0;
    p->group_->file_descriptors_[1] = 0;
    p->group_->file_descriptors_[2] = 0;
    stdio->refcount_ += 3;
    for (int i = 3; i < NFILE_PROC; ++i) {
        p->group_->file_descriptors_[i] = -1;
    }

    // add to process table (requires lock in case another CPU is already
    // running processes)
    {
        spinlock_guard guard(ptable_lock);
        spinlock_guard hguard(gtable[1]->lock_);
        assert(gtable[1]); // `init` process must exist
        gtable[1]->children_.push_back(p->group_);
        assert(!gtable[pid] && !ptable[tid]);
        ptable[tid] = p;
        gtable[pid] = p->group_;
        hguard.unlock();
    }

    // add to run queue
    cpus[pid % ncpu].enqueue(p);
}


// run_init_task()
//    Function that runs the kernel task for the `init` process (pid 1)
void run_init_task() {
    proc* init = ptable[1];
    assert(init);

    while (true) {
        init->waitpid(0, W_NOHANG);

        if (init->group_->children_.empty()) {
            process_halt();
            assert(false);
            return;
        }

        init->yield();
    }
}


// proc::exception(reg)
//    Exception handler (for interrupts, traps, and faults).
//
//    The register values from exception time are stored in `reg`.
//    The processor responds to an exception by saving application state on
//    the current CPU stack, then jumping to kernel assembly code (in
//    k-exception.S). That code transfers the state to the current kernel
//    task's stack, then calls proc::exception().

void proc::exception(regstate* regs) {
    // It can be useful to log events using `log_printf`.
    // Events logged this way are stored in the host's `log.txt` file.
    //log_printf("proc %d: exception %d @%p\n", id_, regs->reg_intno, regs->reg_rip);

    // Set stack canary
    Canary stack_guard(stack_canary_);

    // Record most recent user-mode %rip.
    if ((regs->reg_cs & 3) != 0) {
        recent_user_rip_ = regs->reg_rip;
    }

    // Show the current cursor location.
    consolestate::get().cursor();


    // Actually handle the exception.
    switch (regs->reg_intno) {

    case INT_IRQ + IRQ_TIMER: {
        cpustate* cpu = this_cpu();
        if (cpu->cpuindex_ == 0) {
            tick();
        }
        lapicstate::get().ack();
        regs_ = regs;
        yield_noreturn();
        break;                  /* will not be reached */
    }

    case INT_PF: {              // pagefault exception
        // Analyze faulting address and access type.
        uintptr_t addr = rdcr2();
        const char* operation = regs->reg_errcode & PFERR_WRITE
                ? "write" : "read";
        const char* problem = regs->reg_errcode & PFERR_PRESENT
                ? "protection problem" : "missing page";

        if ((regs->reg_cs & 3) == 0) {
            panic_at(*regs, "Kernel page fault for %p (%s %s)!\n",
                     addr, operation, problem);
        }

        error_printf(CS_ERROR "Process %d page fault for %p (%s %s, rip=%p)!\n",
                     id_, addr, operation, problem, regs->reg_rip);
        pstate_ = proc::ps_faulted;
        yield();
        break;
    }

    case INT_IRQ + IRQ_KEYBOARD:
        keyboardstate::get().handle_interrupt();
        break;

    default:
        if (sata_disk && regs->reg_intno == INT_IRQ + sata_disk->irq_) {
            sata_disk->handle_interrupt();
        } else if (eth_nic && regs->reg_intno == INT_IRQ + eth_nic->irq_) {
            eth_nic->handle_interrupt();
        } else {
            panic_at(*regs, "Unexpected exception %d!\n", regs->reg_intno);
        }
        break;                  /* will not be reached */

    }

    // return to interrupted context
}


// proc::syscall(regs)
//    System call handler.
//
//    The register values from system call time are stored in `regs`.
//    The return value from `proc::syscall()` is returned to the user
//    process in `%rax`.

uintptr_t proc::syscall(regstate* regs) {
    //log_printf("proc %d: syscall %ld @%p\n", id_, regs->reg_rax, regs->reg_rip);

    // Record most recent user-mode %rip.
    recent_user_rip_ = regs->reg_rip;

    // Set stack canary
    Canary stack_guard(stack_canary_);

    switch (regs->reg_rax) {

    case SYSCALL_CONSOLETYPE:
        if (consoletype != (int) regs->reg_rdi) {
            console_clear();
        }
        consoletype = regs->reg_rdi;
        return 0;

    case SYSCALL_PANIC:
        panic_at(*regs, "process %d called sys_panic()", id_);
        break;                  // will not be reached

    case SYSCALL_EXIT:
        syscall_exit(regs);
        assert(false);
        break;                  // will not be reached

    case SYSCALL_TEXIT: {
        thread_exit();
        assert(false);
    }

    case SYSCALL_KTEST:
        if (regs->reg_rdi == 1) {
            return ktest_wait_queues();
        }
        return -1;

    case SYSCALL_GETPID:
        assert(group_);
        return group_->pid_;
    
    case SYSCALL_GETTID:
        return id_;

    case SYSCALL_YIELD:
        yield();
        return 0;

    case SYSCALL_PAGE_ALLOC: {
        uintptr_t addr = regs->reg_rdi;
        if (addr >= VA_LOWEND || addr & 0xFFF) {
            return -1;
        }
        void* pg = kalloc(PAGESIZE);
        if (!pg) {
            return -1;
        }
        spinlock_guard guard(group_->pt_lock_);
        if (vmiter(this, addr).try_map(ka2pa(pg), PTE_PWU) < 0) {
            guard.unlock();
            kfree(pg);
            return -1;
        }
        return 0;
    }

    case SYSCALL_PAUSE: {
        sti();
        for (uintptr_t delay = 0; delay < 1000000; ++delay) {
            pause();
        }
        return 0;
    }

    case SYSCALL_FORK:
        return syscall_fork(regs);
    
    case SYSCALL_EXECV:
        return syscall_execv(regs);

    case SYSCALL_CLONE:
        return syscall_clone(regs);

    case SYSCALL_READ:
        return syscall_read(regs);

    case SYSCALL_WRITE:
        return syscall_write(regs);
    
    case SYSCALL_LSEEK:
        return syscall_lseek(regs);

    case SYSCALL_READDISKFILE:
        return syscall_readdiskfile(regs);

    case SYSCALL_SYNC: {
        int drop = regs->reg_rdi;
        // `drop > 1` asserts that no data blocks are referenced (except
        // possibly superblock and FBB blocks). This can only be ensured on
        // tests that run as the first process.
        if (drop > 1 && strncmp(CHICKADEE_FIRST_PROCESS, "test", 4) != 0) {
            drop = 1;
        }
        return bufcache::get().sync(drop);
    }

    case SYSCALL_GETUSAGE: {
        if (!regs->reg_rdi ||
             regs->reg_rdi % alignof(usage) != 0 || 
             !vmiter(this, regs->reg_rdi).user()) {
            return E_FAULT;
        }
        usage* u = reinterpret_cast<usage*>(regs->reg_rdi);
        u->time = ticks;
        u->allocated_pages = allocated_pages;
        u->free_pages = total_pages - allocated_pages;
        return 0;
    }

    case SYSCALL_CORRUPT: {
        syscall_corrupt();
        return 0;
    }

    case SYSCALL_KALLOC: {
        return reinterpret_cast<uintptr_t>(kalloc(regs->reg_rdi));
    }

    case SYSCALL_KFREE: {
        kfree(reinterpret_cast<void*>(regs->reg_rdi));
        return 0;
    }

    case SYSCALL_PAGE_FREE: {
        if (regs->reg_rdi == CONSOLE_ADDR || regs->reg_rdi >= HIGHMEM_BASE) {
            return E_PERM;
        }
        vmiter it(pagetable_, regs->reg_rdi);
        it.kfree_page();
        it.invalidate();
        return 0;
    }

    case SYSCALL_MSLEEP: {
        unsigned msecs = round_up(regs->reg_rdi, 10)/10;
        wake_timestamp_ = ticks + msecs;

        assert(!runq_links_.is_linked());

        spinlock_guard guard(group_->lock_);
        group_->child_exited_ = false;
        waiter().wait_until(sleep_queue, [&] () {
            return group_->child_exited_ || (long(ticks - wake_timestamp_) >= 0);
        }, guard);

        if (group_->child_exited_) {
            group_->child_exited_ = false;
            return E_INTR;
        }

        return 0;
    }

    case SYSCALL_GETPPID: {
        assert(group_);
        return group_->parent_id_;
    }

    case SYSCALL_WAITPID: {
        sti();
        return waitpid(regs->reg_rdi, regs->reg_rsi);
    }

    case SYSCALL_DUP2: {
        return syscall_dup2(regs);
    }

    case SYSCALL_OPEN: {
        return syscall_open(regs);
    }

    case SYSCALL_CLOSE: {
        return syscall_close(regs);
    }

    case SYSCALL_UNLINK: {
        return syscall_unlink(regs);
    }

    case SYSCALL_PIPE: {
        return syscall_pipe();
    }

    case SYSCALL_SETIPADDR: {
        set_local_ipaddr(regs->reg_rdi & 0xffffffff);
        return 0;
    }

    case SYSCALL_BIND: {
        return syscall_bind(regs);
    }

    // For demo purposes only... and fun
    case SYSCALL_TX_RAW_ETH: {
        spinlock_guard guard(eth_nic->tx_lock_);
        while (!eth_nic->transmit_raw(reinterpret_cast<void*>(regs->reg_rdi), regs->reg_rsi & 0xffffffff)) {
            guard.unlock();
            yield();
            guard.lock();
        }
        return 0;
    }

    default:
        // no such system call
        log_printf("%d: no such system call %u\n", id_, regs->reg_rax);
        return E_NOSYS;

    }
}

[[noreturn]] void proc::thread_exit() {
    cli();
    ptable_lock.lock_noirq(); // Must hold this throughout most of the exit or else memviewer might try to lock something that doesn't exist
    {
        spinlock_guard guard(group_->lock_);
        group_links_.erase();
    }
    // Once the group becomes empty, it should stay empty, so this check doesn't need to hold the group lock
    if (group_->threads_.empty()) {
        group_->pt_lock_.lock_noirq(); // Still necessary to stop conflicts with the memviewer
        x86_64_pagetable* pt = pagetable_;
        pagetable_ = early_pagetable;
        group_->pt_lock_.unlock_noirq();
        set_pagetable(early_pagetable);

        // Freeing the pagetable can take time--enable interrupts for responsiveness
        ptable_lock.unlock_noirq();
        sti();
        kfree_user_pagetable(pt);
        cli();

        // Need children lock because other processes might try to reparent to us or send an exit signal
        group_->children_lock_.lock_noirq();
        while (!group_->children_.empty()) {
            // orphans become owned by the `init` process
            assert(gtable[1]);
            thread_group* c = group_->children_.pop_front();
            c->parent_id_ = 1;
            spinlock_guard init_guard(gtable[1]->children_lock_);
            gtable[1]->children_.push_back(c);
        }
        assert(group_->children_.empty());
        group_->children_lock_.unlock_noirq();

        // Don't need to hold the group's fd lock because no other threads should be left to access it
        file_table_lock.lock_noirq();
        for (int i = 0; i < NFILE_PROC; ++i) {
            int global_fd = group_->file_descriptors_[i];
            if (global_fd == -1) continue;
            assert(global_fd < NFILE_GLOBAL);
            file* f = file_table[global_fd];
            assert(f);
            assert(f->refcount_ > 0);
            --f->refcount_;
            if (f->refcount_ == 0) {
                delete f;
                file_table[global_fd] = nullptr;
            }
        }
        file_table_lock.unlock_noirq();

        // Get the ptable lock again for the gtable and ptable operations
        ptable_lock.lock_noirq();
        assert(gtable[group_->parent_id_] && !gtable[group_->parent_id_]->exited_);
        gtable[group_->parent_id_]->child_exited_ = true;

        group_->exited_ = true;
        waitpid_queue.notify_all();
    }

    // Release this tid for reuse and indicate that this thread's struct proc can be freed once back on the cpustack
    pstate_ = ps_exited;
    ptable[id_] = nullptr;

    ptable_lock.unlock_noirq();
    yield_noreturn();
}

// proc::syscall_exit()
//    Handle exit system call
void proc::syscall_exit(regstate* regs) {
    // Indicate that the other threads in this group should exit themselves as soon as possible
    spinlock_guard guard(group_->lock_);
    for (proc* t = group_->threads_.front(); t != nullptr; t = group_->threads_.next(t)) {
        t->should_exit_ = true;
        t->unblock();
    }
    // Set the exit code so that it can be retrieved once the rest of the threads finish exiting
    group_->exit_code_ = regs->reg_rdi;
    guard.unlock();

    // Exit this thread--including cleanup tasks if this happens to be the last thread
    thread_exit();
    assert(false); // should never get here
}

// proc::syscall_corrupt()
//    Handle corrupt system call

void proc::syscall_corrupt() {
    char evil_array[PAGESIZE * 2];
    memset(evil_array, -1, PAGESIZE*2);
}

// proc::syscall_fork(regs)
//    Handle fork system call.

int proc::syscall_fork(regstate* regs) {
    // This is a slow system call, so allow interrupts by default
    sti();

    // Allocate a new pagetable for the child and start crawling
    // the parent's virtual address space to copy its mappings
    x86_64_pagetable* pt = knew_pagetable();
    if (!pt) {
        return E_NOSYS;
    }
    {
        spinlock_guard guard(group_->pt_lock_); // Prevent changes to current pagetable while copying
        vmiter parent_it(this, 0);
        vmiter child_it(pt, 0);
        while (!parent_it.done() && parent_it.va() < HIGHMEM_BASE) {
            if (parent_it.pa() != uintptr_t(-1) && parent_it.pa() != CONSOLE_ADDR) {
                // If the parent has a mapping here that isn't the console, allocate
                // a new page for it, then copy its data and mapping
                void* new_page = kalloc(PAGESIZE);
                if (!new_page) {
                    // Couldn't allocate enough space for the child
                    guard.unlock();
                    kfree_user_pagetable(pt);
                    return E_NOSYS;
                }
                memcpy(new_page, parent_it.kptr(), PAGESIZE);
                if (child_it.find(parent_it.va()).try_map(new_page, parent_it.perm()) < 0) {
                    // Couldn't replicate the parent's mapping for this page
                    guard.unlock();
                    kfree(new_page);
                    kfree_user_pagetable(pt);
                    return E_NOSYS;
                }
            } else if (parent_it.pa() == CONSOLE_ADDR) {
                if (child_it.find(CONSOLE_ADDR).try_map(CONSOLE_ADDR, parent_it.perm()) < 0) {
                    // Failed to map the console in the child's page table
                    guard.unlock();
                    kfree_user_pagetable(pt);
                    return E_NOSYS;
                }
            }
            
            parent_it.next();
        }
    }

    // Lock the process list and search for a free pid and tid >= 1
    // cli(); // Holding a spinlock requires that interrupts are disabled
    pid_t pid = 1;
    pid_t tid = 1;
    spinlock_guard guard(ptable_lock);
    while (ptable[tid] && ptable[tid]->pstate_ != ps_blank) {
        if (++tid >= NTHREAD) {
            // No pids available
            guard.unlock();
            kfree_user_pagetable(pt);
            return E_NOSYS;
        }
    }
    while (gtable[pid]) {
        if (++pid >= NPROC) {
            guard.unlock();
            kfree_user_pagetable(pt);
            return E_NOSYS;
        }
    }
    // There shouldn't be a proc in our slot
    assert(!ptable[tid] || ptable[tid]->pstate_ == ps_blank);
    assert(!gtable[pid]);

    // Allocate a new proc and install its pagetable
    proc* p = knew<proc>();
    if (!p) {
        // Failed to allocate a new proc
        guard.unlock();
        kfree_user_pagetable(pt);
        return E_NOSYS;
    }
    thread_group* g = knew<thread_group>();
    if (!g) {
        // Failed to allocate a new thread group
        guard.unlock();
        kfree(p);
        kfree_user_pagetable(pt);
        return E_NOSYS;
    }
    p->id_ = tid;
    p->group_ = g;
    g->threads_.push_front(p);
    g->pid_ = pid;
    g->parent_id_ = group_->pid_;
    p->init_user(pt);
    // Copy parent's file descriptors to the child
    spinlock_guard fd_guard(group_->fd_lock_);
    for (int i = 0; i < NFILE_PROC; ++i) {
        int global_fd = group_->file_descriptors_[i];
        g->file_descriptors_[i] = global_fd;
        if (global_fd != -1 && file_table[global_fd]) {
            assert(file_table[global_fd]->refcount_ > 0);
            ++file_table[global_fd]->refcount_;
        }
    }
    fd_guard.unlock();

    {
        spinlock_guard c_guard(group_->children_lock_);
        group_->children_.push_back(p->group_);
    }

    // Copy the parent's current registers into the child's regstate
    // and override the return value of this syscall to be 0
    memcpy(p->regs_, regs, sizeof(regstate));
    p->regs_->reg_rax = 0;

    // Add the child to the process table and a run queue
    ptable[tid] = p;
    gtable[pid] = g;
    cpus[pid % ncpu].enqueue(p);

    return pid;
}

// validate_user_string(buf, page_table)
//    Checks if a user-provided nul-terminated buffer is within accessible memory
//    and returns its size (including the null termination)
int validate_user_string(const char* buf, x86_64_pagetable* pt) {
    uint64_t wanted_perms = PTE_P | PTE_U;
    int n = 0;
    do {
        uint64_t has_perms = vmiter(pt, reinterpret_cast<uintptr_t>(&buf[n])).perm();
        if ((has_perms == uint64_t(-1)) || (has_perms & wanted_perms) != wanted_perms) {
            return E_FAULT;
        }
    } while (buf[n++] != 0);
    return n;
}

// proc::syscall_execv(regs)
//    Handle execv system call
int proc::syscall_execv(regstate* regs) {
    sti();
    const char* pathname = reinterpret_cast<const char*>(regs->reg_rdi);
    const char** argv = reinterpret_cast<const char**>(regs->reg_rsi);
    int argc = regs->reg_rdx;

    // Validate pathname
    if (!pathname || !argv) {
        return E_FAULT;
    }
    if (validate_user_string(pathname, pagetable_) < 0) {
        return E_FAULT;
    }

    // Validate each argv element (including null termination)
    size_t total_argv_size = 0;
    int count = 0;
    while (true) {
        if (count > argc) {
            return E_FAULT;
        }
        // Ensure valid location of argv[i]
        uint64_t wanted_perms = PTE_P | PTE_U;
        uint64_t has_perms = vmiter(pagetable_, reinterpret_cast<uintptr_t>(&argv[count])).perm();
        if ((has_perms == uint64_t(-1)) || (has_perms & wanted_perms) != wanted_perms) {
            return E_FAULT;
        }
        if (argv[count++] == nullptr) {
            break;
        }
        // Ensure argv[i] is a valid string and keep track of total args length
        int sz = validate_user_string(argv[count-1], pagetable_);
        if (sz < 0) {
            return E_FAULT;
        }
        // Includes null termination
        total_argv_size += sz;
    };
    if (count <= argc) {
        return E_FAULT;
    }
    assert(count == argc + 1);

    // Locate program inode, allocate pagetable, and start loading program segments
    chkfs_iref inode = chkfsstate::get().lookup_inode(pathname);
    if (!inode) {
        return E_NOENT;
    }
    x86_64_pagetable* pt = knew_pagetable();
    if (!pt) {
        return E_NOMEM;
    }
    inode->lock_read();
    chkfs_fileiter it(inode.get());
    chkfs_loader ld(&it, pt);
    int r = load(ld);
    inode->unlock_read();
    if (r < 0) {
        kfree_user_pagetable(pt);
        return r;
    }

    // create and map stack + arguments list
    // no one should let me write anything ever again
    size_t argv_sz = (argc + 1) * 8;
    if (argv_sz > PAGESIZE) {
        kfree_user_pagetable(pt);
        return E_NOSPC;
    }
    uintptr_t argv_va = 0;
    void* current_argpg = kalloc(PAGESIZE);
    uintptr_t current_argpg_va = MEMSIZE_VIRTUAL - PAGESIZE;
    if (!current_argpg) {
        kfree_user_pagetable(pt);
        return E_NOSPC;
    }
    size_t current_argpg_sz = 0;
    // Add 2 extra iterations to loop to handle allocating+mapping space for the argv
    // array if necessary and allocating the stack page
    // spinlock_guard guard(group_->lock_); // Not necessary--should only ever be called by single-threaded processes
    for (int i = 0; i < argc + 2; ++i) {
        size_t n = (i >= argc) ? argv_sz : strlen(argv[i]) + 1;
        if ((i == argc + 1) || (current_argpg_sz + n > PAGESIZE)) {
            if (vmiter(pt, current_argpg_va).try_map(kptr2pa(current_argpg), PTE_PWU) != 0) {
                kfree_user_pagetable(pt);
                return E_NOSPC;
            }
            current_argpg_sz = 0;
            current_argpg = kalloc(PAGESIZE);
            current_argpg_va -= PAGESIZE;
            if (!current_argpg) {
                kfree_user_pagetable(pt);
                return E_NOSPC;
            }
            if (i == argc + 1) {
                // should exit loop with all arg pages filled + mapped, the stack page in current_argpg, and the
                // base va of the stack page in current_argpg_va
                break;
            }
        }
        assert(i <= argc);
        const void* src = argv[i];
        if (i == argc) {
            src = argv;
        }
        memcpy(&reinterpret_cast<char*>(current_argpg)[current_argpg_sz], src, n);
        if (i == argc) {
            // current_argpg_sz should be offset of argv array
            argv_va = current_argpg_va + current_argpg_sz;
            continue;
        }
        argv[i] = reinterpret_cast<const char*>(current_argpg_va + current_argpg_sz);
        current_argpg_sz += n;
    }
    assert(argv_va != 0);
    void* stkpg = current_argpg;
    if (vmiter(pt, current_argpg_va).try_map(kptr2pa(stkpg), PTE_PWU) != 0) {
        kfree(stkpg);
        kfree_user_pagetable(pt);
        return E_NOSPC;
    }

    // map console
    vmiter(pt, ktext2pa(console)).map(console, PTE_PWU);

    spinlock_guard ptable_guard(ptable_lock);
    // Save current pagetable now because init_user() updates pagetable_
    x86_64_pagetable* old_pt = pagetable_;
    init_user(pt);
    // Set up registers to point to program entry, stack top, and main function arguments
    regs_->reg_rip = ld.entry_rip_;
    regs_->reg_rsp = current_argpg_va + PAGESIZE;
    regs_->reg_rdi = argc;
    regs_->reg_rsi = argv_va;
    // Finally switch to new pagetable and free old one
    set_pagetable(pt);
    kfree_user_pagetable(old_pt);
    ptable_guard.unlock();

    // Disable interrupts and yield to scheduler
    cli();
    yield_noreturn();
}

// proc::syscall_clone(regs)
//    Handle clone system call.

int proc::syscall_clone(regstate* regs) {
    // This is a slow system call, so allow interrupts by default
    sti();

    // Lock the process list and search for a free tid >= 1
    // cli(); // Holding a spinlock requires that interrupts are disabled
    pid_t tid = 1;
    spinlock_guard guard(ptable_lock);
    while (ptable[tid] && ptable[tid]->pstate_ != ps_blank) {
        if (++tid >= NTHREAD) {
            // No pids available
            return E_NOSYS;
        }
    }
    // There shouldn't be a proc in our slot
    assert(!ptable[tid] || ptable[tid]->pstate_ == ps_blank);

    // Allocate a new proc and install its pagetable
    proc* p = knew<proc>();
    if (!p) {
        // Failed to allocate a new proc
        return E_NOSYS;
    }
    p->id_ = tid;
    p->init_user(pagetable_);
    
    // Add the thread to our group
    {
        spinlock_guard group_guard(group_->lock_);
        p->group_ = group_;
        group_->threads_.push_back(p);
        p->should_exit_ = should_exit_; // In case the process is exited by another thread during the clone
    }

    // Copy the parent's current registers into the child's regstate
    // and override the return value of this syscall to be 0
    memcpy(p->regs_, regs, sizeof(regstate));
    p->regs_->reg_rax = 0;

    // Add the child to the process table and a run queue
    ptable[tid] = p;
    cpus[tid % ncpu].enqueue(p);

    return tid;
}

// proc::waitpid()
//    Internal waitpid implementation
uint64_t proc::waitpid(pid_t pid, int options) {
    spinlock_guard guard(group_->children_lock_);
    Canary stack_guard(stack_canary_);
    if (group_->children_.empty()) {
        return E_CHILD;
    }

    thread_group* child = group_->children_.front();
    while (child) {
        // Find the process we are looking for (or the first exited process if pid == 0)
        assert(child->parent_id_ == group_->pid_);
        if (child->pid_ == pid || (pid == 0 && child->exited_)) {
            break;
        }
        child = group_->children_.next(child);
    }

    // If we were looking for a specific process but couldn't find it
    if (!child && pid != 0) {
        return E_CHILD;
    }

    // We need to return some result right away if called with NOHANG
    if (options == W_NOHANG) {
        if (!child) {
            if (pid == 0) {
                // When pid is wildcard, E_CHILD is only for having no children
                return E_AGAIN;
            }
            return E_CHILD;
        }
        if (!child->exited_) {
            return E_AGAIN;
        }
        // Finish destroying the child's proc and return the pid in the lower
        // half of the return value and the exit code in the upper half
        stack_guard.check();
        int exit_status = reap_child(child);
        guard.unlock();
        return child->pid_ | (uint64_t(exit_status) << 32);
    }

    assert(options != W_NOHANG);
    waiter().wait_until(waitpid_queue, [&]() {
        stack_guard.check();
        if (!child) {
            // Still looking for an exited process (pid is wildcard)
            assert(pid == 0);
            child = this->group_->children_.front();
            while (child && !child->exited_) {
                child = this->group_->children_.next(child);
            }
        }
        if (!child) {
            // No exited children found
            return false;
        }
        // Waiting on a specific child
        return child->exited_;
    }, guard);
    
    // Finish destroying the child's proc and return the pid in the lower
    // half of the return value and the exit code in the upper half
    assert(child && child->threads_.empty());
    stack_guard.check();
    int exit_status = reap_child(child);
    guard.unlock();
    return child->pid_ | (uint64_t(exit_status) << 32);
}

// proc::reap_child(child)
//    Finishes freeing the child's group struct and releases its PID for
//    reuse before returning the child's exit status. The reaped process
//    must be a child of the calling process and have actually exited.
//    The parent's children_lock must be held before calling
int proc::reap_child(thread_group* p) {
    spinlock_guard guard(p->lock_);
    spinlock_guard c_guard(p->children_lock_);
    assert(p->threads_.empty());
    assert(p->children_.empty());
    assert(p->parent_id_ == group_->pid_);

    // This is okay because p->parent_links_ is part of the parent's
    // children_ list, which we should be holding the lock for
    assert(p->parent_links_.is_linked());
    group_->children_.erase(p);

    int exit_code = p->exit_code_;

    assert(p->children_.empty());
    ptable_lock.lock_noirq();
    gtable[p->pid_] = nullptr;
    ptable_lock.unlock_noirq();

    guard.unlock();
    kfree(p);
    return exit_code;
}

// proc::syscall_read(regs), proc::syscall_write(regs),
// proc::syscall_readdiskfile(regs)
//    Handle read and write system calls.

uintptr_t proc::syscall_read(regstate* regs) {
    // This is a slow system call, so allow interrupts by default
    sti();

    uint64_t fd = regs->reg_rdi;
    uintptr_t addr = regs->reg_rsi;
    size_t sz = regs->reg_rdx;

    // Validate target file descriptor and locate file
    if (fd >= NFILE_PROC) {
        return E_BADF;
    }
    int global_fd = -1;
    {
        spinlock_guard guard(group_->fd_lock_);
        global_fd = group_->file_descriptors_[fd];
    }
    if (global_fd == -1) {
        return E_BADF;
    }
    assert(global_fd < NFILE_GLOBAL);

    // Ensure file is readable
    file* f;
    {
        spinlock_guard guard(file_table_lock);
        f = file_table[global_fd];
    }
    assert(f);
    if ((f->mode_ & OF_READ) != OF_READ) {
        return E_BADF;
    }

    // Validate buffer
    if (size_t(addr) + sz < addr) {
        return E_FAULT;
    }
    if (addr <= VA_LOWEND && sz == 0) {
        return 0;
    }
    uint64_t wanted_perms = PTE_P | PTE_U | PTE_W;
    uint64_t has_perms = vmiter(pagetable_, addr).range_perm(sz);
    if ((has_perms == uint64_t(-1)) || (has_perms & wanted_perms) != wanted_perms) {
        return E_FAULT;
    }

    size_t n = f->vnode_->read(f->seek_head_, sz, reinterpret_cast<void*>(addr));
    if (n > 0) {
        // Don't update head if read returned error
        f->seek_head_ += n;
    }
    return n;
}

uintptr_t proc::syscall_write(regstate* regs) {
    // This is a slow system call, so allow interrupts by default
    sti();

    unsigned int fd = regs->reg_rdi;
    uintptr_t addr = regs->reg_rsi;
    size_t sz = regs->reg_rdx;

    // Validate target file descriptor and locate file
    if (fd >= NFILE_PROC) {
        return E_BADF;
    }
    int global_fd = -1;
    {
        spinlock_guard guard(group_->fd_lock_);
        global_fd = group_->file_descriptors_[fd];
    }
    if (global_fd == -1) {
        return E_BADF;
    }
    assert(global_fd < NFILE_GLOBAL);

    // Ensure file is writable
    file* f;
    {
        spinlock_guard guard(file_table_lock);
        f = file_table[global_fd];
    }
    assert(f);
    if ((f->mode_ & OF_WRITE) != OF_WRITE) {
        return E_BADF;
    }

    // Validate buffer
    if (addr + sz < addr) {
        return E_FAULT;
    }
    if (addr <= VA_LOWEND && sz == 0) {
        return 0;
    }
    uint64_t wanted_perms = PTE_P | PTE_U;
    uint64_t has_perms = vmiter(pagetable_, addr).range_perm(sz);
    if ((has_perms == uint64_t(-1)) || (has_perms & wanted_perms) != wanted_perms) {
        return E_FAULT;
    }

    size_t n = f->vnode_->write(f->seek_head_, sz, reinterpret_cast<void*>(addr));
    if (sz > 0) {
        // Don't update head if write returned error
        f->seek_head_ += n;
    }
    return n;
}

off_t proc::syscall_lseek(regstate* regs) {


    unsigned int fd = regs->reg_rdi;
    off_t off = regs->reg_rsi;
    int whence = regs->reg_rdx;

    // Validate target file descriptor and locate file
    if (fd >= NFILE_PROC) {
        return E_BADF;
    }
    int global_fd = -1;
    {
        spinlock_guard guard(group_->fd_lock_);
        global_fd = group_->file_descriptors_[fd];
    }
    if (global_fd == -1) {
        return E_BADF;
    }
    assert(global_fd < NFILE_GLOBAL);

    file* f;
    {
        spinlock_guard guard(file_table_lock);
        f = file_table[global_fd];
    }
    assert(f);
    if (!f->vnode_->seekable_) {
        return E_SPIPE;
    }

    switch (whence) {
        case LSEEK_SET:
            if (size_t(off) > f->vnode_->get_size()) {
                // Don't support seeking past end of the file
                return E_INVAL;
            }
            f->seek_head_ = off;
            return f->seek_head_;

        case LSEEK_CUR:
            if (size_t(f->seek_head_ + off) > f->vnode_->get_size()) {
                // Don't support seeking past end of the file
                return E_INVAL;
            }
            f->seek_head_ += off;
            return f->seek_head_;
        
        case LSEEK_END:
            if (off > 0) {
                // Don't support seeking past end of the file
                return E_INVAL;
            }
            f->seek_head_ = f->vnode_->get_size() + off;
            return f->seek_head_;
        
        case LSEEK_SIZE:
            return f->vnode_->get_size();
    }

    return E_INVAL;
}

int proc::syscall_dup2(regstate* regs) {
    uint64_t old_fd = regs->reg_rdi;
    uint64_t new_fd = regs->reg_rsi;

    // Validate arguments
    if (old_fd >= NFILE_PROC || new_fd >= NFILE_PROC) {
        return E_BADF;
    }
    spinlock_guard guard(group_->fd_lock_);
    int global_old_fd = group_->file_descriptors_[old_fd];
    if (global_old_fd == -1) {
        return E_BADF;
    }
    int global_new_fd = group_->file_descriptors_[new_fd];
    if (global_new_fd == global_old_fd) {
        return new_fd;
    }
    
    // Locate target file
    file* f;
    {
        spinlock_guard table_guard(file_table_lock);
        if (global_new_fd != -1) {
            // Must delete existing file in new_fd--decrement refcount and delete if necessary
            spinlock_guard file_guard(file_table[global_new_fd]->lock_);
            --file_table[global_new_fd]->refcount_;
            if (file_table[global_new_fd]->refcount_ == 0) {
                delete file_table[global_new_fd];
                file_table[global_new_fd] = nullptr;
            }
        }
        group_->file_descriptors_[new_fd] = global_old_fd;
        f = file_table[global_old_fd];
    }
    // Update refcount for duplicated file
    assert(f);
    spinlock_guard file_guard(f->lock_);
    assert(f->refcount_ > 0);
    ++f->refcount_;
    return new_fd;
}

int proc::syscall_open(regstate* regs) {
    uintptr_t path_addr = regs->reg_rdi;
    int flags = regs->reg_rsi;

    // Validate path argument
    if (!path_addr) {
        return E_FAULT;
    }
    uint64_t wanted_perms = PTE_P | PTE_U;
    size_t sz = 0;
    do {
        uint64_t has_perms = vmiter(pagetable_, path_addr + sz).perm();
        if ((has_perms == uint64_t(-1)) || (has_perms & wanted_perms) != wanted_perms) {
            return E_FAULT;
        }
    } while (*reinterpret_cast<char*>(path_addr + (sz++)) != 0);
    --sz;
    // Only support files in the root directory for now
    if (sz > chkfs::maxnamelen) {
        return E_NAMETOOLONG;
    }
    
    // Find or create inode for path
    chkfs_iref inode = chkfsstate::get().lookup_inode(reinterpret_cast<const char*>(path_addr));
    if (!inode) {
        if ((flags & (OF_CREAT | OF_WRITE)) == (OF_CREAT | OF_WRITE)) {
            // Find empty direntry in parent directory (only root for now)
            chkfs_iref root_inode = chkfsstate::get().inode(1);
            assert(root_inode->type == chkfs::type_directory);
            root_inode->lock_write();
            chkfs_fileiter it(root_inode.get(), 0);
            bcref dir_data;
            chkfs::dirent* entry = nullptr; // Potentially dangerous unwrapped reference. Okay as long as `dir_data` is in scope
            while (it.active()) {
                dir_data = it.load();
                assert(dir_data);
                chkfs::dirent* en = reinterpret_cast<chkfs::dirent*>(&dir_data->buf_[it.block_relative_offset()]);
                if (en->inum == 0) {
                    // Found free directory entry
                    entry = en;
                    break;
                }
                it += sizeof(chkfs::dirent);
            }
            if (!entry) {
                // TODO: Support adding directory extents
                return E_NOSPC;
            }

            // Alocate new inode
            int inode_num;
            {
                bcref sb_slot = bufcache::get().load(0);
                assert(sb_slot);
                chkfs::superblock* sb = reinterpret_cast<chkfs::superblock*>(&sb_slot->buf_[chkfs::superblock_offset]);
                for (inode_num = 1; inode_num < sb->ninodes; ++inode_num) {
                    inode = chkfsstate::get().inode(inode_num);
                    if (inode && inode->type == 0) {
                        // Found unused inode number
                        break;
                    }
                }
            }
            if (!inode) {
                return E_NOSPC;
            }

            // Initialize inode
            inode->lock_write();
            inode->slot()->lock_buffer();
            inode->type = chkfs::type_regular;
            inode->nlink = 1;
            inode->size = 0;
            inode->direct[0].count = 0;
            inode->direct[0].first = 0;
            inode->slot()->unlock_buffer();
            inode->unlock_write();

            // Add inode to directory
            dir_data->lock_buffer();
            entry->inum = inode_num;
            memcpy(entry->name, reinterpret_cast<char*>(path_addr), sz);
            entry->name[sz] = 0;
            dir_data->unlock_buffer();
            root_inode->unlock_write();
        }
        if (!inode) {
            return E_NOENT;
        }
    }
    assert(inode->type == chkfs::type_regular);

    if ((flags & (OF_WRITE | OF_TRUNC)) == (OF_WRITE | OF_TRUNC)) {
        // Reduce file's size to 0. Do not change allocated extents (chickadee
        // doesn't support seeking past the end of a file, so any time a file
        // grows a write must have passed through all data leading up to the
        // new size, so any old data in the block will be overwritten).
        // Must lock the inode slot's buffer to add it to the dirty list
        inode->lock_write();
        inode->slot()->lock_buffer();
        inode->size = 0;
        inode->slot()->unlock_buffer();
        inode->unlock_write();
    }

    // Allocate new file descriptor and file ID
    int new_fd = -1;
    spinlock_guard local_guard(group_->fd_lock_);
    for (int i = 0; i < NFILE_PROC; ++i) {
        if (group_->file_descriptors_[i] == -1) {
            new_fd = i;
            break;
        }
    }
    if (new_fd == -1) {
        return E_MFILE;
    }

    int new_fd_global = -1;
    spinlock_guard global_guard(file_table_lock);
    for (int i = 0; i < NFILE_GLOBAL; ++i) {
        if (!file_table[i]) {
            new_fd_global = i;
            break;
        }
    }
    if (new_fd_global == -1) {
        return E_NFILE;
    }

    // Create new file and vnode
    file* f = knew<file>();
    if (!f) {
        return E_NOSPC;
    }
    f->refcount_ = 1;
    if ((flags & OF_READ) == OF_READ) {
        f->mode_ |= OF_READ;
    }
    if ((flags & OF_WRITE) == OF_WRITE) {
        f->mode_ |= OF_WRITE;
    }
    // memfs_vnode* vn = knew<memfs_vnode>(mf);
    chkfs_vnode* vn = knew<chkfs_vnode>(std::move(inode));
    if (!vn) {
        delete f;
        return E_NOSPC;
    }
    ++vn->refcount_;
    f->vnode_ = vn;

    file_table[new_fd_global] = f;
    group_->file_descriptors_[new_fd] = new_fd_global;
    return new_fd;
}

int proc::syscall_close(regstate* regs) {
    uint64_t fd = regs->reg_rdi;

    // Validate file descriptor
    if (fd >= NFILE_PROC) {
        return E_BADF;
    }
    int global_fd;
    {
        spinlock_guard guard(group_->fd_lock_);
        global_fd = group_->file_descriptors_[fd];
    }
    if (global_fd == -1) {
        return E_BADF;
    }
    assert(global_fd < NFILE_GLOBAL);

    // Lock file, trigger destructor (which updates the refcount for its vnode), and free memory
    file* f;
    {
        spinlock_guard guard(file_table_lock);
        f = file_table[global_fd];
    }
    assert(f);
    {
        spinlock_guard guard(f->lock_);
        assert(f->refcount_ > 0);
        --f->refcount_;
        if (f->refcount_ == 0) {
            spinlock_guard table_guard(file_table_lock);
            delete f;
            file_table[global_fd] = nullptr;
        }
        group_->file_descriptors_[fd] = -1;
    }
    return 0;
}

int proc::syscall_unlink(regstate* regs) {
    uintptr_t path_addr = regs->reg_rdi;

    // Validate path argument
    if (!path_addr) {
        return E_FAULT;
    }
    uint64_t wanted_perms = PTE_P | PTE_U;
    size_t sz = 0;
    do {
        uint64_t has_perms = vmiter(pagetable_, path_addr + sz).perm();
        if ((has_perms == uint64_t(-1)) || (has_perms & wanted_perms) != wanted_perms) {
            return E_FAULT;
        }
    } while (*reinterpret_cast<char*>(path_addr + (sz++)) != 0);
    --sz;
    // Only support files in the root directory for now
    if (sz > chkfs::maxnamelen) {
        return E_NAMETOOLONG;
    }

    // Find directory entry
    chkfs_iref root_inode = chkfsstate::get().inode(1);
    assert(root_inode->type == chkfs::type_directory);
    root_inode->lock_write();
    chkfs_fileiter it(root_inode.get(), 0);
    bcref dir_data;
    chkfs::dirent* entry = nullptr; // Potentially dangerous unwrapped reference. Okay as long as `dir_data` is in scope
    while (it.active()) {
        dir_data = it.load();
        if (!dir_data) continue;
        chkfs::dirent* en = reinterpret_cast<chkfs::dirent*>(&dir_data->buf_[it.block_relative_offset()]);
        if (en->inum > 0 && memcmp(en->name, reinterpret_cast<char*>(path_addr), sz) == 0) {
            // Found free directory entry
            entry = en;
            break;
        }
        it += sizeof(chkfs::dirent);
    }
    if (!entry) {
        root_inode->unlock_write();
        return E_NOENT;
    }

    chkfs_iref inode = chkfsstate::get().inode(entry->inum);
    assert(inode);
    inode->lock_write();

    root_inode->slot()->lock_buffer();
    entry->inum = 0;
    root_inode->slot()->unlock_buffer();
    root_inode->unlock_write();

    inode->slot()->lock_buffer();
    --inode->nlink;
    inode->slot()->unlock_buffer();
    inode->unlock_write();

    inode->try_free();

    return 0;
}

uint64_t proc::syscall_pipe() {
    sti();
    // Allocate pipe vnode and two file ends
    pipe_vnode* pipe_vn = knew<pipe_vnode>();
    if (!pipe_vn) {
        return E_NOMEM;
    }
    spinlock_guard vn_guard(pipe_vn->lock_);

    file* read_file = knew<file>();
    if (!read_file) {
        delete pipe_vn;
        return E_NOMEM;
    }
    read_file->mode_ = OF_READ;
    read_file->refcount_ = 1;
    read_file->vnode_ = pipe_vn;
    ++pipe_vn->open_reads_;

    file* write_file = knew<file>();
    if (!write_file) {
        delete read_file;
        delete pipe_vn;
        return E_NOMEM;
    }
    write_file->mode_ = OF_WRITE;
    write_file->refcount_ = 1;
    write_file->vnode_ = pipe_vn;
    ++pipe_vn->open_writes_;
    
    // Allocate pair of file descriptors and file IDs
    int read_fd = -1;
    int write_fd = -1;
    spinlock_guard local_guard(group_->fd_lock_);
    for (int i = 0; i < NFILE_PROC; ++i) {
        if (read_fd != -1 && write_fd != -1) {
            break;
        }
        if (group_->file_descriptors_[i] == -1) {
            if (read_fd == -1) {
                read_fd = i;
            } else {
                write_fd = i;
            }
        }
    }
    if (read_fd == -1 || write_fd == -1) {
        delete read_file;
        delete write_file;
        delete pipe_vn;
        return E_MFILE;
    }

    int read_fd_global = -1;
    int write_fd_global = -1;
    spinlock_guard global_guard(file_table_lock);
    for (int i = 0; i < NFILE_GLOBAL; ++i) {
        if (read_fd_global != -1 && write_fd_global != -1) {
            break;
        }
        if (!file_table[i]) {
            if (read_fd_global == -1) {
                read_fd_global = i;
            } else {
                write_fd_global = i;
            }
        }
    }

    if (read_fd_global == -1 || write_fd_global == -1) {
        delete read_file;
        delete write_file;
        delete pipe_vn;
        return E_NFILE;
    }

    file_table[read_fd_global] = read_file;
    group_->file_descriptors_[read_fd] = read_fd_global;
    file_table[write_fd_global] = write_file;
    group_->file_descriptors_[write_fd] = write_fd_global;

    return read_fd | (static_cast<uint64_t>(write_fd) << 32);
}

uintptr_t proc::syscall_readdiskfile(regstate* regs) {
    // This is a slow system call, so allow interrupts by default
    sti();

    const char* filename = reinterpret_cast<const char*>(regs->reg_rdi);
    unsigned char* buf = reinterpret_cast<unsigned char*>(regs->reg_rsi);
    size_t sz = regs->reg_rdx;
    off_t off = regs->reg_r10;

    if (!sata_disk) {
        return E_IO;
    }

    // read root directory to find file inode number
    auto ino = chkfsstate::get().lookup_inode(filename);
    if (!ino) {
        return E_NOENT;
    }

    // read file inode
    ino->lock_read();
    chkfs_fileiter it(ino.get());

    size_t nread = 0;
    while (nread < sz) {
        // copy data from current block
        if (auto e = it.find(off).load()) {
            unsigned b = it.block_relative_offset();
            size_t ncopy = min(
                size_t(ino->size - it.offset()),   // bytes left in file
                chkfs::blocksize - b,              // bytes left in block
                sz - nread                         // bytes left in request
            );
            memcpy(buf + nread, e->buf_ + b, ncopy);

            nread += ncopy;
            off += ncopy;
            if (ncopy == 0) {
                break;
            }
        } else {
            break;
        }
    }

    ino->unlock_read();
    return nread;
}

// WARNING--this is not finished. These descriptors can never be fully closed and
// this interface isn't very robust. This is a hacky repurposing of the pipe vnode
// made specifically to be able to test the network stack as a proof-of-concept.
int proc::syscall_bind(regstate* regs) {
    pipe_vnode* pipe_vn = knew<pipe_vnode>();
    if (!pipe_vn) {
        return E_NOMEM;
    }
    spinlock_guard vn_guard(pipe_vn->lock_);

    file* read_file = knew<file>();
    if (!read_file) {
        delete pipe_vn;
        return E_NOMEM;
    }
    read_file->mode_ = OF_READ;
    read_file->refcount_ = 1;
    read_file->vnode_ = pipe_vn;
    ++pipe_vn->open_reads_;

    file* write_file = knew<file>();
    if (!write_file) {
        delete read_file;
        delete pipe_vn;
        return E_NOMEM;
    }
    write_file->mode_ = OF_WRITE;
    write_file->refcount_ = 1;
    write_file->vnode_ = pipe_vn;
    ++pipe_vn->open_writes_;

    // Get udp_socket slot
    spinlock_guard sock_guard(udp_sockets_lock);
    int sock_idx = -1;
    for (int i = 0; i < MAX_UDP_SOCKETS && (regs->reg_rdi != 0); i++) {
        if (udp_sockets[i].write_fd >= 0 && udp_sockets[i].port == regs->reg_rdi) {
            sock_guard.unlock();
            delete read_file;
            delete write_file;
            delete pipe_vn;
            return E_PERM;
        }
        if (udp_sockets[i].write_fd == -1 && sock_idx == -1) {
            sock_idx = i;
        }
    }
    if (sock_idx == -1 && (regs->reg_rdi != 0)) {
        sock_guard.unlock();
        delete read_file;
        delete write_file;
        delete pipe_vn;
        return E_PERM;
    }
    
    // Allocate pair of file descriptors and file IDs
    int read_fd = -1;
    spinlock_guard local_guard(group_->fd_lock_);
    for (int i = 0; i < NFILE_PROC; ++i) {
        if (read_fd != -1) {
            break;
        }
        if (group_->file_descriptors_[i] == -1) {
            if (read_fd == -1) {
                read_fd = i;
            }
        }
    }
    if (read_fd == -1) {
        delete read_file;
        delete write_file;
        delete pipe_vn;
        return E_MFILE;
    }

    int read_fd_global = -1;
    int write_fd_global = -1;
    spinlock_guard global_guard(file_table_lock);
    for (int i = 0; i < NFILE_GLOBAL; ++i) {
        if (read_fd_global != -1 && write_fd_global != -1) {
            break;
        }
        if (!file_table[i]) {
            if (read_fd_global == -1) {
                read_fd_global = i;
            } else {
                write_fd_global = i;
            }
        }
    }

    if (read_fd_global == -1 || write_fd_global == -1) {
        delete read_file;
        delete write_file;
        delete pipe_vn;
        return E_NFILE;
    }

    file_table[read_fd_global] = read_file;
    group_->file_descriptors_[read_fd] = read_fd_global;
    file_table[write_fd_global] = write_file;
    // group_->file_descriptors_[write_fd] = write_fd_global;
    if (regs->reg_rdi == 0) {
        eth_sniff_fd = write_fd_global;
        return read_fd;
    }
    udp_sockets[sock_idx].port = regs->reg_rdi;
    udp_sockets[sock_idx].write_fd = write_fd_global;

    return read_fd;
}


// memshow()
//    Draw a picture of memory (physical and virtual) on the CGA console.
//    Switches to a new process's virtual memory map every 0.25 sec.
//    Uses `console_memviewer()`, a function defined in `k-memviewer.cc`.

static void memshow() {
    static unsigned long last_redisplay = 0;
    static unsigned long last_switch = 0;
    static int showing = 1;

    // redisplay every 0.04 sec
    if (last_redisplay != 0 && ticks - last_redisplay < HZ / 25) {
        return;
    }
    last_redisplay = ticks;

    // switch to a new process every 0.5 sec
    if (ticks - last_switch >= HZ / 2) {
        showing = (showing + 1) % NPROC;
        last_switch = ticks;
    }

    spinlock_guard guard(ptable_lock);

    int search = 0;
    while ((!ptable[showing]
            || !ptable[showing]->pagetable_
            || ptable[showing]->pagetable_ == early_pagetable)
           && search < NPROC) {
        showing = (showing + 1) % NPROC;
        ++search;
    }

    console_memviewer(ptable[showing]);
    if (!ptable[showing]) {
        console_printf(CPOS(10, 26), CS_WHITE "   VIRTUAL ADDRESS SPACE\n"
            "                          [All processes have exited]\n"
            "\n\n\n\n\n\n\n\n\n\n\n");
    }
}


// tick()
//    Called once every tick (0.01 sec, 1/HZ) by CPU 0. Updates the `ticks`
//    counter and performs other periodic maintenance tasks.

void tick() {
    // Update current time
    ++ticks;

    // Update display
    if (consoletype == CONSOLE_MEMVIEWER) {
        memshow();
    }
}