syscall.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <sys/kassert.h>
#include <sys/kmem.h>
#include <sys/ktime.h>
#include <sys/ktimer.h>
#include <sys/thread.h>
#include <sys/loader.h>
#include <sys/syscall.h>
#include <sys/disk.h>
#include <sys/vfs.h>
#include <sys/vfsuio.h>
#include <sys/nic.h>
#include <sys/sysctl.h>

Include dependency graph for syscall.c:

Go to the source code of this file.

Functions
Handle *	Console_OpenHandle ()
uint64_t	Syscall_Time ()
uint64_t	Syscall_GetPID ()
void	Syscall_Exit (uint64_t status)
uint64_t	Syscall_Spawn (uint64_t user_path, uint64_t user_argv)
uint64_t	Syscall_Wait (uint64_t pid)
uint64_t	Syscall_MMap (uint64_t addr, uint64_t len, uint64_t prot)
uint64_t	Syscall_MUnmap (uint64_t addr, uint64_t len)
uint64_t	Syscall_MProtect (uint64_t addr, uint64_t len, uint64_t prot)
uint64_t	Syscall_Read (uint64_t fd, uint64_t addr, uint64_t off, uint64_t length)
uint64_t	Syscall_Write (uint64_t fd, uint64_t addr, uint64_t off, uint64_t length)
uint64_t	Syscall_Flush (uint64_t fd)
uint64_t	Syscall_Open (uint64_t user_path, uint64_t flags)
uint64_t	Syscall_Close (uint64_t fd)
uint64_t	Syscall_Stat (uint64_t user_path, uint64_t user_stat)
uint64_t	Syscall_ReadDir (uint64_t fd, char *user_buf, size_t len, uintptr_t user_off)
uint64_t	Syscall_ThreadCreate (uint64_t rip, uint64_t arg)
uint64_t	Syscall_GetTID ()
void	Syscall_ThreadExit (uint64_t status)
static void	ThreadWakeupHelper (void *arg)
uint64_t	Syscall_ThreadSleep (uint64_t time)
uint64_t	Syscall_ThreadWait (uint64_t tid)
uint64_t	Syscall_NICStat (uint64_t nicNo, uint64_t user_stat)
uint64_t	Syscall_NICSend (uint64_t nicNo, uint64_t user_mbuf)
uint64_t	Syscall_NICRecv (uint64_t nicNo, uint64_t user_mbuf)
uint64_t	Syscall_SysCtl (uint64_t user_node, uint64_t user_oldval, uint64_t user_newval)
uint64_t	Syscall_FSMount (uint64_t user_mntpt, uint64_t user_device, uint64_t flags)
uint64_t	Syscall_FSUnmount (uint64_t user_mntpt)
uint64_t	Syscall_FSInfo (uint64_t user_fsinfo, uint64_t max)
uint64_t	Syscall_Entry (uint64_t syscall, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5)

Function Documentation

Console_OpenHandle()

Handle * Console_OpenHandle

(

)

Definition at line 200 of file console.c.

{
    Handle *handle = Handle_Alloc();
    if (!handle)
        return NULL;
 
    handle->read = &Console_Read;
    handle->write = &Console_Write;
    handle->flush = &Console_Flush;
    handle->close = &Console_Close;
 
    return handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Close()

uint64_t Syscall_Close

(

uint64_t

fd

)

Definition at line 314 of file syscall.c.

{
    uint64_t status;
    Thread *cur = Sched_Current();
    Handle *handle = Handle_Lookup(cur->proc, fd);
 
    if (handle == NULL) {
        status = -EBADF;
    } else {
        status = (handle->close)(handle);
    }
 
    Thread_Release(cur);
 
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Entry()

uint64_t Syscall_Entry	(	uint64_t	syscall,
		uint64_t	a1,
		uint64_t	a2,
		uint64_t	a3,
		uint64_t	a4,
		uint64_t	a5
	)

Definition at line 673 of file syscall.c.

{
    switch (syscall)
    {
        case SYSCALL_NULL:
            return 0;
        case SYSCALL_TIME:
            return Syscall_Time();
        case SYSCALL_GETPID:
            return Syscall_GetPID();
        case SYSCALL_EXIT:
            Syscall_Exit(a1);
            return 0; // To eliminate warning
        case SYSCALL_SPAWN:
            return Syscall_Spawn(a1, a2);
        case SYSCALL_WAIT:
            return Syscall_Wait(a1);
        case SYSCALL_MMAP:
            return Syscall_MMap(a1, a2, a3);
        case SYSCALL_MUNMAP:
            return Syscall_MUnmap(a1, a2);
        case SYSCALL_MPROTECT:
            return Syscall_MProtect(a1, a2, a3);
        case SYSCALL_READ:
            return Syscall_Read(a1, a2, a3, a4);
        case SYSCALL_WRITE:
            return Syscall_Write(a1, a2, a3, a4);
        case SYSCALL_FLUSH:
            return Syscall_Flush(a1);
        case SYSCALL_OPEN:
            return Syscall_Open(a1, a2);
        case SYSCALL_CLOSE:
            return Syscall_Close(a1);
        case SYSCALL_STAT:
            return Syscall_Stat(a1, a2);
        case SYSCALL_READDIR:
            return Syscall_ReadDir(a1, (char *)a2, a3, a4);
        case SYSCALL_THREADCREATE:
            return Syscall_ThreadCreate(a1, a2);
        case SYSCALL_GETTID:
            return Syscall_GetTID();
        case SYSCALL_THREADEXIT:
            Syscall_ThreadExit(a1);
            return 0;
        case SYSCALL_THREADSLEEP:
            return Syscall_ThreadSleep(a1);
        case SYSCALL_THREADWAIT:
            return Syscall_ThreadWait(a1);
        case SYSCALL_NICSTAT:
            return Syscall_NICStat(a1, a2);
        case SYSCALL_NICSEND:
            return Syscall_NICSend(a1, a2);
        case SYSCALL_NICRECV:
            return Syscall_NICRecv(a1, a2);
        case SYSCALL_SYSCTL:
            return Syscall_SysCtl(a1, a2, a3);
        case SYSCALL_FSMOUNT:
            return Syscall_FSMount(a1, a2, a3);
        case SYSCALL_FSUNMOUNT:
            return Syscall_FSUnmount(a1);
        case SYSCALL_FSINFO:
            return Syscall_FSInfo(a1, a2);
        default:
            return SYSCALL_PACK(ENOSYS, 0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Exit()

void Syscall_Exit

(

uint64_t

status

)

Definition at line 45 of file syscall.c.

{
    Thread *cur = Sched_Current();
 
    // Request each thread to exit
 
    // Wait for all threads to exit
 
    // Write exit code
    cur->proc->exitCode = status;
 
    // Exit this thread
    Sched_SetZombie(cur);
    Thread_Release(cur);
    Sched_Scheduler();
 
    // Should not return
    Panic("Returned to exited thread!\n");
 
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Flush()

uint64_t Syscall_Flush

(

uint64_t

fd

)

Definition at line 255 of file syscall.c.

{
    uint64_t status;
    Thread *cur = Sched_Current();
    Handle *handle = Handle_Lookup(cur->proc, fd);
 
    if (handle == NULL) {
        status = -EBADF;
    } else {
        status = (handle->flush)(handle);
    }
 
    Thread_Release(cur);
 
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_FSInfo()

uint64_t Syscall_FSInfo	(	uint64_t	user_fsinfo,
		uint64_t	max
	)

Definition at line 667 of file syscall.c.

{
    return SYSCALL_PACK(ENOSYS, 0);
}

Here is the caller graph for this function:

Syscall_FSMount()

uint64_t Syscall_FSMount	(	uint64_t	user_mntpt,
		uint64_t	user_device,
		uint64_t	flags
	)

Definition at line 655 of file syscall.c.

{
    return SYSCALL_PACK(ENOSYS, 0);
}

Here is the caller graph for this function:

Syscall_FSUnmount()

uint64_t Syscall_FSUnmount

(

uint64_t

user_mntpt

)

Definition at line 661 of file syscall.c.

{
    return SYSCALL_PACK(ENOSYS, 0);
}

Here is the caller graph for this function:

Syscall_GetPID()

uint64_t Syscall_GetPID

(

)

Definition at line 34 of file syscall.c.

{
    Thread *cur = Sched_Current();
    uint64_t pid = cur->proc->pid;
 
    Thread_Release(cur);
 
    return pid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_GetTID()

uint64_t Syscall_GetTID

(

)

Definition at line 417 of file syscall.c.

{
    Thread *cur = Sched_Current();
    uint64_t tid = cur->tid;
 
    Thread_Release(cur);
 
    return tid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_MMap()

uint64_t Syscall_MMap	(	uint64_t	addr,
		uint64_t	len,
		uint64_t	prot
	)

Definition at line 178 of file syscall.c.

{
    Thread *cur = Sched_Current();
    bool status;
 
    status = PMap_AllocMap(cur->space, addr, len, PTE_W);
    Thread_Release(cur);
    if (!status) {
        // XXX: Need to unmap PMap_Unmap(cur->space, addr, pgs);
        return 0;
    } else {
        return addr;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_MProtect()

uint64_t Syscall_MProtect	(	uint64_t	addr,
		uint64_t	len,
		uint64_t	prot
	)

Definition at line 211 of file syscall.c.

{
    //Thread *cur = Sched_Current();
    NOT_IMPLEMENTED();
    return 0;
}

Here is the caller graph for this function:

Syscall_MUnmap()

uint64_t Syscall_MUnmap	(	uint64_t	addr,
		uint64_t	len
	)

Definition at line 194 of file syscall.c.

{
    Thread *cur = Sched_Current();
    uint64_t p;
 
    for (p = 0; p < len; p += PGSIZE)
    {
        // Free page
    }
 
    PMap_Unmap(cur->space, addr, len /= PGSIZE);
    Thread_Release(cur);
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_NICRecv()

uint64_t Syscall_NICRecv	(	uint64_t	nicNo,
		uint64_t	user_mbuf
	)

Definition at line 550 of file syscall.c.

{
    int status;
    NIC *nic;
    MBuf mbuf;
 
    status = Copy_In(user_mbuf, &mbuf, sizeof(mbuf));
    if (status != 0) {
        return SYSCALL_PACK(status, 0);
    }
 
    nic = NIC_GetByID(nicNo);
    if (nic == NULL) {
        return SYSCALL_PACK(ENOENT, 0);
    }
 
    // Pin Memory
    (nic->rx)(nic, &mbuf, NULL, NULL);
    // Unpin Memory
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_NICSend()

uint64_t Syscall_NICSend	(	uint64_t	nicNo,
		uint64_t	user_mbuf
	)

Definition at line 526 of file syscall.c.

{
    int status;
    NIC *nic;
    MBuf mbuf;
 
    status = Copy_In(user_mbuf, &mbuf, sizeof(mbuf));
    if (status != 0) {
        return SYSCALL_PACK(status, 0);
    }
 
    nic = NIC_GetByID(nicNo);
    if (nic == NULL) {
        return SYSCALL_PACK(ENOENT, 0);
    }
 
    // Pin Memory
    (nic->tx)(nic, &mbuf, NULL, NULL);
    // Unpin Memory
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_NICStat()

uint64_t Syscall_NICStat	(	uint64_t	nicNo,
		uint64_t	user_stat
	)

Definition at line 507 of file syscall.c.

{
    int status;
    NIC *nic;
 
    nic = NIC_GetByID(nicNo);
    if (nic == NULL) {
        return ENOENT;
    }
 
    status = Copy_Out(nic, user_stat, sizeof(NIC));
    if (status != 0) {
        return status;
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Open()

uint64_t Syscall_Open	(	uint64_t	user_path,
		uint64_t	flags
	)

Definition at line 276 of file syscall.c.

{
    uint64_t handleNo;
    Thread *cur = Sched_Current();
    int status;
    char path[256];
 
    status = Copy_StrIn(user_path, &path, sizeof(path));
    if (status != 0) {
        Thread_Release(cur);
        return status;
    }
 
    if (strncmp("/dev/", path, 5) == 0) {
        if (strcmp("/dev/console", path) == 0) {
            Handle *handle = Console_OpenHandle();
            handleNo = Handle_Add(cur->proc, handle);
            Thread_Release(cur);
            return handleNo;
        }
 
        Thread_Release(cur);
        return -ENOENT;
    }
 
    Handle *handle;
    status = VFSUIO_Open(path, &handle);
    if (status != 0) {
        Thread_Release(cur);
        return status;
    }
 
    handleNo = Handle_Add(cur->proc, handle);
    Thread_Release(cur);
    return handleNo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Read()

uint64_t Syscall_Read	(	uint64_t	fd,
		uint64_t	addr,
		uint64_t	off,
		uint64_t	length
	)

Definition at line 219 of file syscall.c.

{
    uint64_t status;
    Thread *cur = Sched_Current();
    Handle *handle = Handle_Lookup(cur->proc, fd);
 
    if (handle == NULL) {
        status = -EBADF;
    } else {
        status = (handle->read)(handle, (void *)addr, off, length);
    }
 
    Thread_Release(cur);
 
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_ReadDir()

uint64_t Syscall_ReadDir	(	uint64_t	fd,
		char *	user_buf,
		size_t	len,
		uintptr_t	user_off
	)

Definition at line 358 of file syscall.c.

{
    int status, rstatus;
    Thread *cur = Sched_Current();
    Handle *handle = Handle_Lookup(cur->proc, fd);
    uint64_t offset;
 
    if (handle == NULL) {
        Thread_Release(cur);
        return -EBADF;
    }
 
    status = Copy_In(user_off, &offset, sizeof(offset));
    if (status != 0) {
        Thread_Release(cur);
        return status;
    }
 
    if (handle->type != HANDLE_TYPE_FILE) {
        Thread_Release(cur);
        return -ENOTDIR;
    }
 
    rstatus = VFS_ReadDir(handle->vnode, user_buf, len, &offset);
    if (rstatus < 0) {
        Thread_Release(cur);
        return rstatus;
    }
 
    status = Copy_Out(&offset, user_off, sizeof(offset));
    if (status != 0) {
        Thread_Release(cur);
        return status;
    }
 
    Thread_Release(cur);
 
    return rstatus;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Spawn()

uint64_t Syscall_Spawn	(	uint64_t	user_path,
		uint64_t	user_argv
	)

Definition at line 68 of file syscall.c.

{
    int status;
    char path[512];
    void *pg;
    char *arg;
    VNode *file;
    Process *proc;
    Thread *thr;
    Thread *cur;
 
    status = Copy_StrIn(user_path, &path, sizeof(path));
    if (status != 0)
        return SYSCALL_PACK(status, 0);
 
    Log(syscall, "Spawn(%s)\n", path);
 
    arg = PAlloc_AllocPage();
    if (!arg) {
        return SYSCALL_PACK(ENOMEM, 0);
    }
 
    /* Copy argument pointers */
    for (int i = 0; i < 8; i++) {
        uintptr_t off = sizeof(uintptr_t)*i;
 
        status = Copy_In(user_argv+off, arg+sizeof(uintptr_t)*(1+i), sizeof(uintptr_t));
        if (status != 0) {
            PAlloc_Release(arg);
            return SYSCALL_PACK(status, 0);
        }
 
        if (*(uintptr_t *)(arg+sizeof(uintptr_t)*(1+i)) == 0)
            break;
    }
 
    /* Copy each argument in */
    char *argstart = arg+sizeof(uintptr_t)*8;
    for (int i = 1; i < 8; i++) {
        uintptr_t *str = (uintptr_t *)(arg+sizeof(uintptr_t)*i);
        if (*str == 0)
            break;
 
        status = Copy_StrIn(*str, argstart, 256); // XXX: Make sure there's no overrun
        if (status != 0) {
            PAlloc_Release(arg);
            return SYSCALL_PACK(status, 0);
        }
 
        *str = (uintptr_t)argstart;
        argstart += strlen(argstart)+1;
    }
 
    pg = PAlloc_AllocPage();
    if (!pg) {
        PAlloc_Release(arg);
        return SYSCALL_PACK(ENOMEM, 0);
    }
 
    /* XXXFILLMEIN: Load the ELF headers into the page. */
 
    if (!Loader_CheckHeader(pg)) {
        VFS_Close(file);
        PAlloc_Release(pg);
        PAlloc_Release(arg);
        return SYSCALL_PACK(EINVAL, 0);
    }
 
    cur = Sched_Current();
    proc = Process_Create(cur->proc, path);
    thr = Thread_Create(proc);
    Thread_Release(cur);
    Log(syscall, "SPAWN %lx\n", thr);
 
    Handle *handle = Console_OpenHandle();
    Handle_Add(proc, handle);
    handle = Console_OpenHandle();
    Handle_Add(proc, handle);
    handle = Console_OpenHandle();
    Handle_Add(proc, handle);
 
    Loader_Load(thr, file, pg, 1024);
 
    /* Initialize the trap frame for entering into the process. */
    Thread_SetupUThread(thr, proc->entrypoint, MEM_USERSPACE_STKTOP - PGSIZE);
 
    /* Translate mapping for stack page */
    argstart = (char *)DMPA2VA(PMap_Translate(thr->space, MEM_USERSPACE_STKTOP - PGSIZE));
    uintptr_t offset = sizeof(uintptr_t)*8;
 
    /* XXXFILLMEIN: Export the argument array out to the new application. */
 
    Sched_SetRunnable(thr);
 
    return SYSCALL_PACK(0, proc->pid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Stat()

uint64_t Syscall_Stat	(	uint64_t	user_path,
		uint64_t	user_stat
	)

Definition at line 332 of file syscall.c.

{
    int status;
    char path[256];
    struct stat sb;
 
    status = Copy_StrIn(user_path, &path, sizeof(path));
    if (status != 0) {
        return status;
    }
 
    // VFS_Stat
    status = VFS_Stat(path, &sb);
    if (status != 0) {
        return status;
    }
 
    status = Copy_Out(&sb, user_stat, sizeof(struct stat));
    if (status != 0) {
        return status;
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_SysCtl()

uint64_t Syscall_SysCtl	(	uint64_t	user_node,
		uint64_t	user_oldval,
		uint64_t	user_newval
	)

Definition at line 574 of file syscall.c.

{
    uint64_t status;
    char node[64];
 
    status = Copy_StrIn(user_node, &node, sizeof(node));
    if (status != 0) {
        return SYSCALL_PACK(status, 0);
    }
 
    uint64_t scType = SysCtl_GetType(node);
    if (scType == SYSCTL_TYPE_INVALID) {
        return SYSCALL_PACK(ENOENT, 0);
    }
 
    if (user_oldval != 0) {
        switch (scType) {
            case SYSCTL_TYPE_STR: {
                SysCtlString *scStr = SysCtl_GetObject(node);
                status = Copy_Out(scStr, user_oldval, sizeof(*scStr));
                break;
            }
            case SYSCTL_TYPE_INT: {
                SysCtlInt *scInt = SysCtl_GetObject(node);
                status = Copy_Out(scInt, user_oldval, sizeof(*scInt));
                break;
            }
            case SYSCTL_TYPE_BOOL: {
                SysCtlBool *scBool = SysCtl_GetObject(node);
                status = Copy_Out(scBool, user_oldval, sizeof(scBool));
                break;
            }
            default: {
                status = EINVAL;
            }
        }
 
        if (status != 0) {
            return SYSCALL_PACK(status, 0);
        }
    }
 
    if (user_newval != 0) {
        switch (scType) {
            case SYSCTL_TYPE_STR: {
                SysCtlString scStr;
                status = Copy_In(user_newval, &scStr, sizeof(scStr));
                if (status != 0) {
                    return SYSCALL_PACK(status, 0);
                }
                status = SysCtl_SetObject(node, (void *)&scStr);
                break;
            }
            case SYSCTL_TYPE_INT: {
                SysCtlInt scInt;
                status = Copy_In(user_newval, &scInt, sizeof(scInt));
                if (status != 0) {
                    return SYSCALL_PACK(status, 0);
                }
                status = SysCtl_SetObject(node, (void *)&scInt);
                break;
            }
            case SYSCTL_TYPE_BOOL: {
                SysCtlBool scBool;
                status = Copy_In(user_newval, &scBool, sizeof(scBool));
                if (status != 0) {
                    return SYSCALL_PACK(status, 0);
                }
                status = SysCtl_SetObject(node, (void *)&scBool);
                break;
            }
            default: {
                status = EINVAL;
            }
        }
    }
 
    return SYSCALL_PACK(status, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_ThreadCreate()

uint64_t Syscall_ThreadCreate	(	uint64_t	rip,
		uint64_t	arg
	)

Definition at line 399 of file syscall.c.

{
    uint64_t threadId;
    Thread *curThread = Sched_Current();
    Thread *newThread = Thread_UThreadCreate(curThread, rip, arg);
 
    Thread_Release(curThread);
    if (newThread == NULL) {
        return SYSCALL_PACK(ENOMEM, 0);
    }
 
    threadId = newThread->tid;
    Sched_SetRunnable(newThread);
 
    return SYSCALL_PACK(0, threadId);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_ThreadExit()

void Syscall_ThreadExit

(

uint64_t

status

)

Definition at line 428 of file syscall.c.

{
    Thread *cur = Sched_Current();
 
    // Encode this like POSIX
    cur->exitValue = status;
 
    Sched_SetZombie(cur);
    Semaphore_Release(&cur->proc->zombieSemaphore);
    Thread_Release(cur);
    Sched_Scheduler();
 
    // Should not return
    Panic("Returned to exited thread!\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_ThreadSleep()

uint64_t Syscall_ThreadSleep

(

uint64_t

time

)

Definition at line 456 of file syscall.c.

{
    Thread *cur = Sched_Current();
 
    // If the sleep time is zero just yield
    if (time != 0) {
        Thread_Retain(cur);
        cur->timerEvt = KTimer_Create(time, ThreadWakeupHelper, cur);
        if (cur->timerEvt == NULL) {
            Thread_Release(cur);
            Thread_Release(cur);
            return -ENOMEM;
        }
 
        Sched_SetWaiting(cur);
    }
    Sched_Scheduler();
 
    Thread_Release(cur);
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_ThreadWait()

uint64_t Syscall_ThreadWait

(

uint64_t

tid

)

Definition at line 480 of file syscall.c.

{
    uint64_t status;
    Thread *cur = Sched_Current();
 
    /*
     * Acquire the zombie semaphore see if the specified thread has exited or 
     * any thread if tid == 0.  If the specified thread hasn't exited wait 
     * again on the semaphore.  POSIX does not give any guarentees if multiple 
     * threads wait on the same thread and neither do we.
     *
     * As a precaution we call Sched_Scheduler to prevent looping on the 
     * semaphore acquire-release.
     */
    while (1) {
        Semaphore_Acquire(&cur->proc->zombieSemaphore);
        status = Thread_Wait(cur, tid);
        if (SYSCALL_ERRCODE(status) != EAGAIN) {
            Thread_Release(cur);
            return status;
        }
        Semaphore_Release(&cur->proc->zombieSemaphore);
        Sched_Scheduler();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Time()

uint64_t Syscall_Time

(

)

Definition at line 28 of file syscall.c.

{
    return KTime_GetEpochNS();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Wait()

uint64_t Syscall_Wait

(

uint64_t

pid

)

Definition at line 166 of file syscall.c.

{
    uint64_t status;
    Thread *cur = Sched_Current();
 
    status = Process_Wait(cur->proc, pid);
    Thread_Release(cur);
 
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Syscall_Write()

uint64_t Syscall_Write	(	uint64_t	fd,
		uint64_t	addr,
		uint64_t	off,
		uint64_t	length
	)

Definition at line 237 of file syscall.c.

{
    uint64_t status;
    Thread *cur = Sched_Current();
    Handle *handle = Handle_Lookup(cur->proc, fd);
 
    if (handle == NULL) {
        status = -EBADF;
    } else {
        status = (handle->write)(handle, (void *)addr, off, length);
    }
 
    Thread_Release(cur);
 
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ThreadWakeupHelper()

static void ThreadWakeupHelper ( void *  arg )

static

Definition at line 445 of file syscall.c.

{
    Thread *thr = (Thread *)arg;
 
    Sched_SetRunnable(thr);
    KTimer_Release(thr->timerEvt);
    thr->timerEvt = NULL;
    Thread_Release(thr);
}

Here is the call graph for this function:

Here is the caller graph for this function: