thread.h File Reference

#include <sys/queue.h>
#include <sys/handle.h>
#include <sys/ktimer.h>
#include <sys/waitchannel.h>
#include <sys/semaphore.h>
#include <sys/mutex.h>
#include <sys/cv.h>
#include <machine/pmap.h>
#include <machine/thread.h>

Include dependency graph for thread.h:

Go to the source code of this file.

Data Structures
struct	Thread
struct	Process

Macros
#define	SCHED_STATE_NULL   0
#define	SCHED_STATE_RUNNABLE   1
#define	SCHED_STATE_RUNNING   2
#define	SCHED_STATE_WAITING   3
#define	SCHED_STATE_ZOMBIE   4
#define	PROCESS_HANDLE_SLOTS   128
#define	PROCESS_TITLE_LENGTH   128
#define	PROC_STATE_NULL   0
#define	PROC_STATE_READY   1
#define	PROC_STATE_ZOMBIE   2
#define	TID_ANY   0xFFFFFFFF

Typedefs
typedef struct Thread	Thread
typedef struct Process	Process

Functions
typedef	TAILQ_HEAD (ProcessQueue, Process) ProcessQueue
typedef	TAILQ_HEAD (ThreadQueue, Thread) ThreadQueue
void	Thread_Init ()
void	Thread_InitAP ()
Process *	Process_Create (Process *parent, const char *title)
Process *	Process_Lookup (uint64_t pid)
void	Process_Retain (Process *proc)
void	Process_Release (Process *proc)
uint64_t	Process_Wait (Process *proc, uint64_t pid)
Thread *	Thread_Create (Process *proc)
Thread *	Thread_KThreadCreate (void(*f)(void *), void *arg)
Thread *	Thread_UThreadCreate (Thread *oldThr, uint64_t rip, uint64_t arg)
Thread *	Thread_Lookup (Process *proc, uint64_t tid)
void	Thread_Retain (Thread *thr)
void	Thread_Release (Thread *thr)
uint64_t	Thread_Wait (Thread *thr, uint64_t tid)
Thread *	Sched_Current ()
void	Sched_SetRunnable (Thread *thr)
void	Sched_SetWaiting (Thread *thr)
void	Sched_SetZombie (Thread *thr)
void	Sched_Scheduler ()
void	Process_Dump (Process *proc)
void	Thread_Dump (Thread *thr)
void	Thread_InitArch (Thread *thr)
void	Thread_SetupKThread (Thread *thr, void(*f)(), uintptr_t arg1, uintptr_t arg2, uintptr_t arg3)
void	Thread_SetupUThread (Thread *thr, uint64_t rip, uint64_t arg)
void	Thread_SwitchArch (Thread *oldthr, Thread *newthr)
void	Handle_Init (Process *proc)
void	Handle_Destroy (Process *proc)
uint64_t	Handle_Add (Process *proc, Handle *handle)
void	Handle_Remove (Process *proc, Handle *handle)
Handle *	Handle_Lookup (Process *proc, uint64_t fd)
int	Copy_In (uintptr_t fromuser, void *tokernel, uintptr_t len)
int	Copy_Out (void *fromkernel, uintptr_t touser, uintptr_t len)
int	Copy_StrIn (uintptr_t fromuser, void *tokernel, uintptr_t len)
int	Copy_StrOut (void *fromkernel, uintptr_t touser, uintptr_t len)

Macro Definition Documentation

PROC_STATE_NULL

#define PROC_STATE_NULL   0

Definition at line 61 of file thread.h.

PROC_STATE_READY

#define PROC_STATE_READY   1

Definition at line 62 of file thread.h.

PROC_STATE_ZOMBIE

#define PROC_STATE_ZOMBIE   2

Definition at line 63 of file thread.h.

PROCESS_HANDLE_SLOTS

#define PROCESS_HANDLE_SLOTS   128

Definition at line 58 of file thread.h.

PROCESS_TITLE_LENGTH

#define PROCESS_TITLE_LENGTH   128

Definition at line 59 of file thread.h.

SCHED_STATE_NULL

#define SCHED_STATE_NULL   0

Definition at line 25 of file thread.h.

SCHED_STATE_RUNNABLE

#define SCHED_STATE_RUNNABLE   1

Definition at line 26 of file thread.h.

SCHED_STATE_RUNNING

#define SCHED_STATE_RUNNING   2

Definition at line 27 of file thread.h.

SCHED_STATE_WAITING

#define SCHED_STATE_WAITING   3

Definition at line 28 of file thread.h.

SCHED_STATE_ZOMBIE

#define SCHED_STATE_ZOMBIE   4

Definition at line 29 of file thread.h.

TID_ANY

#define TID_ANY   0xFFFFFFFF

Definition at line 106 of file thread.h.

Typedef Documentation

Process

typedef struct Process Process

Definition at line 13 of file thread.h.

Thread

typedef struct Thread Thread

Definition at line 11 of file thread.h.

Function Documentation

Copy_In()

int Copy_In	(	uintptr_t	fromuser,
		void *	tokernel,
		uintptr_t	len
	)

Copy_In –

Safely copy memory from userspace. Prevents userspace pointers from reading kernel memory.

Side effects: Kernel page fault may have occurred.

Parameters

[in]	fromuser	User address to copy from.
[in]	tokernel	Kernel address to copy to.
[in]	len	Length of the data to copy.

Return values

EFAULT

if the address is invalid or causes a fault.

Definition at line 34 of file copy.c.

{
    if (len == 0)
        return 0;
 
    // Kernel space
    if (fromuser >= MEM_USERSPACE_TOP) {
        kprintf("Copy_In: address exceeds userspace top\n");
        return EFAULT;
    }
 
    // Wrap around
    if (len > (MEM_USERSPACE_TOP - fromuser)) {
        kprintf("Copy_In: length exceeds userspace top\n");
        return EFAULT;
    }
 
    return copy_unsafe(tokernel, (void *)fromuser, len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Copy_Out()

int Copy_Out	(	void *	fromkernel,
		uintptr_t	touser,
		uintptr_t	len
	)

Copy_Out –

Safely copy memory to userspace. Prevents userspace pointers from writing kernel memory.

Side effects: Kernel page fault may have occurred.

Parameters

[in]	fromkernel	Kernel address to copy from.
[in]	touser	User address to copy to.
[in]	len	Length of the data to copy.

Return values

EFAULT

if the address is invalid or causes a fault.

Definition at line 70 of file copy.c.

{
    if (len == 0)
        return 0;
 
    // Kernel space
    if (touser >= MEM_USERSPACE_TOP) {
        kprintf("Copy_Out: address exceeds userspace top\n");
        return EFAULT;
    }
 
    // Wrap around
    if (len > (MEM_USERSPACE_TOP - touser)) {
        kprintf("Copy_Out: length exceeds userspace top\n");
        return EFAULT;
    }
 
    return copy_unsafe((void *)touser, fromkernel, len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Copy_StrIn()

int Copy_StrIn	(	uintptr_t	fromuser,
		void *	tokernel,
		uintptr_t	len
	)

Copy_StrIn –

Safely copy a string from userspace. Prevents userspace pointers from reading kernel memory.

Side effects: Kernel page fault may have occurred.

Parameters

[in]	fromuser	User address to copy from.
[in]	tokernel	Kernel address to copy to.
[in]	len	Maximum string length.

Return values

EFAULT

if the address is invalid or causes a fault.

Definition at line 106 of file copy.c.

{
    if (len == 0)
        return 0;
 
    // Kernel space
    if (fromuser >= MEM_USERSPACE_TOP) {
        kprintf("Copy_StrIn: address exceeds userspace top\n");
        return EFAULT;
    }
 
    // Wrap around
    if (len > (MEM_USERSPACE_TOP - fromuser)) {
        kprintf("Copy_StrIn: length exceeds userspace top\n");
        return EFAULT;
    }
 
    return copystr_unsafe(tokernel, (void *)fromuser, len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Copy_StrOut()

int Copy_StrOut	(	void *	fromkernel,
		uintptr_t	touser,
		uintptr_t	len
	)

Copy_StrOut –

Safely copy a string to userspace. Prevents userspace pointers from writing kernel memory.

Side effects: Kernel page fault may have occurred.

Parameters

[in]	fromkernel	Kernel address to copy from.
[in]	touser	User address to copy to.
[in]	len	Maximum string length.

Return values

EFAULT

if the address is invalid or causes a fault.

Definition at line 142 of file copy.c.

{
    if (len == 0)
        return 0;
 
    // Kernel space
    if (touser >= MEM_USERSPACE_TOP) {
        kprintf("Copy_StrOut: address exceeds userspace top\n");
        return EFAULT;
    }
 
    // Wrap around
    if (len > (MEM_USERSPACE_TOP - touser)) {
        kprintf("Copy_StrOut: length exceeds userspace top\n");
        return EFAULT;
    }
 
    return copystr_unsafe((void *)touser, fromkernel, len);
}

Here is the call graph for this function:

Handle_Add()

uint64_t Handle_Add	(	Process *	proc,
		Handle *	handle
	)

Definition at line 47 of file handle.c.

{
    int slot;
 
    handle->fd = proc->nextFD;
    proc->nextFD++;
    handle->processId = proc->pid;
 
    slot = handle->fd % PROCESS_HANDLE_SLOTS;
 
    TAILQ_INSERT_HEAD(&proc->handles[slot], handle, handleList);
 
    return handle->fd;
}

Here is the caller graph for this function:

Handle_Destroy()

void Handle_Destroy

(

Process *

proc

)

Definition at line 33 of file handle.c.

{
    int i;
    Handle *handle, *handle_tmp;
 
    for (i = 0; i < PROCESS_HANDLE_SLOTS; i++) {
        TAILQ_FOREACH_SAFE(handle, &proc->handles[i], handleList, handle_tmp) {
            TAILQ_REMOVE(&proc->handles[i], handle, handleList);
            (handle->close)(handle);
        }
    }
}

Here is the caller graph for this function:

Handle_Init()

void Handle_Init

(

Process *

proc

)

Definition at line 23 of file handle.c.

{
    int i;
 
    for (i = 0; i < PROCESS_HANDLE_SLOTS; i++) {
        TAILQ_INIT(&proc->handles[i]);
    }
}

Here is the caller graph for this function:

Handle_Lookup()

Handle * Handle_Lookup	(	Process *	proc,
		uint64_t	fd
	)

Definition at line 71 of file handle.c.

{
    int slot = fd % PROCESS_HANDLE_SLOTS;
    Handle *handle;
 
    TAILQ_FOREACH(handle, &proc->handles[slot], handleList) {
        if (handle->fd == fd)
            return handle;
    }
 
    return NULL;
}

Here is the caller graph for this function:

Handle_Remove()

void Handle_Remove	(	Process *	proc,
		Handle *	handle
	)

Definition at line 63 of file handle.c.

{
    int slot = handle->fd % PROCESS_HANDLE_SLOTS;
 
    TAILQ_REMOVE(&proc->handles[slot], handle, handleList);
}

Process_Create()

Process * Process_Create	(	Process *	parent,
		const char *	title
	)

Process_Create –

Create a process.

Parameters

[in]	parent	Parent process.
[in]	title	Process title.

Returns

The newly created process.

Definition at line 50 of file process.c.

{
    Process *proc = (Process *)Slab_Alloc(&processSlab);
 
    if (!proc)
        return NULL;
 
    memset(proc, 0, sizeof(*proc));
 
    proc->pid = nextProcessID++;
    proc->threads = 0;
    proc->refCount = 1;
    proc->procState = PROC_STATE_NULL;
    TAILQ_INIT(&proc->threadList);
 
    if (title) {
        strncpy((char *)&proc->title, title, PROCESS_TITLE_LENGTH);
    } else {
        proc->title[0] = '\0';
    }
 
    proc->space = PMap_NewAS();
    if (proc->space == NULL) {
        Slab_Free(&processSlab, proc);
        return NULL;
    }
    proc->ustackNext = MEM_USERSPACE_STKBASE;
 
    Spinlock_Init(&proc->lock, "Process Lock", SPINLOCK_TYPE_NORMAL);
 
    Semaphore_Init(&proc->zombieSemaphore, 0, "Zombie Semaphore");
    TAILQ_INIT(&proc->zombieQueue);
 
    Handle_Init(proc);
 
    proc->parent = parent;
    if (parent) {
        Spinlock_Lock(&parent->lock);
        TAILQ_INSERT_TAIL(&parent->childrenList, proc, siblingList);
        Spinlock_Unlock(&parent->lock);
    }
    TAILQ_INIT(&proc->childrenList);
    TAILQ_INIT(&proc->zombieProc);
    Mutex_Init(&proc->zombieProcLock, "Zombie Process Lock");
    CV_Init(&proc->zombieProcCV, "Zombie Process CV");
    CV_Init(&proc->zombieProcPCV, "Zombie Process PCV");
 
    Spinlock_Lock(&procLock);
    TAILQ_INSERT_TAIL(&processList, proc, processList);
    Spinlock_Unlock(&procLock);
 
    return proc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Process_Dump()

void Process_Dump

(

Process *

proc

)

Definition at line 251 of file process.c.

{
    const char *stateStrings[] = {
        "NULL",
        "READY",
        "ZOMBIE"
    };
 
    kprintf("title      %s\n", proc->title);
    kprintf("pid        %llu\n", proc->pid);
    kprintf("state      %s\n", stateStrings[proc->procState]);
    kprintf("space      %016llx\n", proc->space);
    kprintf("threads    %llu\n", proc->threads);
    kprintf("refCount   %d\n", proc->refCount);
    kprintf("nextFD     %llu\n", proc->nextFD);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Process_Lookup()

Process * Process_Lookup

(

uint64_t

pid

)

Process_Lookup –

Lookup a process by PID and increment its reference count.

Parameters

[in]

pid

Process ID to search for.

Return values

NULL	No such process.

Returns

Process that corresponds to the pid.

Definition at line 145 of file process.c.

{
    Process *p;
    Process *proc = NULL;
 
    Spinlock_Lock(&procLock);
    TAILQ_FOREACH(p, &processList, processList) {
        if (p->pid == pid) {
            Process_Retain(p);
            proc = p;
            break;
        }
    }
    Spinlock_Unlock(&procLock);
 
    return proc;
}

Here is the call graph for this function:

Process_Release()

void Process_Release

(

Process *

proc

)

Process_Release –

Decrement the reference count for a given process.

Parameters

proc	Process to release a reference of.

Definition at line 185 of file process.c.

{
    ASSERT(proc->refCount != 0);
    if (__sync_fetch_and_sub(&proc->refCount, 1) == 1) {
        Process_Destroy(proc);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Process_Retain()

void Process_Retain

(

Process *

proc

)

Process_Retain –

Increment the reference count for a given process.

Parameters

proc	Process to retain a reference to.

Definition at line 171 of file process.c.

{
    ASSERT(proc->refCount != 0);
    __sync_fetch_and_add(&proc->refCount, 1);
}

Here is the caller graph for this function:

Process_Wait()

uint64_t Process_Wait	(	Process *	proc,
		uint64_t	pid
	)

Process_Wait –

Wait for a process to exit and then cleanup it's references. If the pid == 0, we wait for any process, otherwise we wait for a specific process.

Parameters

[in]	proc	Parent process.
[in]	pid	Optionally specify the pid of the process to wait on.

Return values

ENOENT

Process ID doesn't exist.

Returns

Exit status of the process that exited or crashed.

Definition at line 206 of file process.c.

{
    Thread *thr;
    Process *p = NULL;
    uint64_t status;
 
    // XXXFILLMEIN
    /* 
     * Dummy waitpid implementation that pretends the 
     * process has already exited. Remove and replace
     * with the actual implementation from the assignment 
     * description.
     */
    /* XXXREMOVE START */
    ASSERT(pid != 0);
    return (pid << 16);
    /* XXXREMOVE END */
 
    status = (p->pid << 16) | (p->exitCode & 0xff);
 
    // Release threads
    Spinlock_Lock(&proc->lock);
    while (!TAILQ_EMPTY(&p->zombieQueue)) {
        thr = TAILQ_FIRST(&p->zombieQueue);
        TAILQ_REMOVE(&p->zombieQueue, thr, schedQueue);
        Spinlock_Unlock(&proc->lock);
 
        ASSERT(thr->proc->pid != 1);
        Thread_Release(thr);
 
        Spinlock_Lock(&proc->lock);
    }
    Spinlock_Unlock(&proc->lock);
 
    // Release process
    Process_Release(p);
 
    return SYSCALL_PACK(0, status);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sched_Current()

Thread * Sched_Current

(

)

Sched_Current() –

Get the currently executing thread. This function retains a reference count and you must release the reference by calling Thread_Release.

Returns

Returns the current thread.

Definition at line 56 of file sched.c.

{
    Spinlock_Lock(&schedLock);
 
    Thread *thr = curProc[CPU()];
    Thread_Retain(thr);
 
    Spinlock_Unlock(&schedLock);
 
    return thr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sched_Scheduler()

void Sched_Scheduler

(

)

Sched_Scheduler –

Run our round robin scheduler to find the process and switch to it.

Definition at line 189 of file sched.c.

{
    Thread *prev;
    Thread *next;
 
    Spinlock_Lock(&schedLock);
 
    // Select next thread
    next = TAILQ_FIRST(&runnableQueue);
    if (!next) {
        /*
         * There may be no other runnable processes on this core.  This is a 
         * good opportunity to migrate threads.  We should never hit this case 
         * once the OS is up and running because of the idle threads, but just 
         * in case we should assert that we never return to a zombie or waiting 
         * thread.
         */
        ASSERT(curProc[CPU()]->schedState == SCHED_STATE_RUNNING);
        Spinlock_Unlock(&schedLock);
        return;
    }
    ASSERT(next->schedState == SCHED_STATE_RUNNABLE);
    TAILQ_REMOVE(&runnableQueue, next, schedQueue);
 
    prev = curProc[CPU()];
    curProc[CPU()] = next;
    next->schedState = SCHED_STATE_RUNNING;
    next->ctxSwitches++;
 
    if (prev->schedState == SCHED_STATE_RUNNING) {
        prev->schedState = SCHED_STATE_RUNNABLE;
        TAILQ_INSERT_TAIL(&runnableQueue, prev, schedQueue);
    }
 
    Sched_Switch(prev, next);
 
    Spinlock_Unlock(&schedLock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sched_SetRunnable()

void Sched_SetRunnable

(

Thread *

thr

)

Sched_SetRunnable –

Set the thread to the runnable state and move it from the wait queue if necessary to the runnable queue.

Parameters

[in]

thr

Thread to be set as runnable.

Definition at line 77 of file sched.c.

{
    Spinlock_Lock(&schedLock);
 
    if (thr->proc->procState == PROC_STATE_NULL)
        thr->proc->procState = PROC_STATE_READY;
 
    if (thr->schedState == SCHED_STATE_WAITING) {
        thr->waitTime += KTime_GetEpochNS() - thr->waitStart;
        thr->waitStart = 0;
        TAILQ_REMOVE(&waitQueue, thr, schedQueue);
    }
    thr->schedState = SCHED_STATE_RUNNABLE;
    TAILQ_INSERT_TAIL(&runnableQueue, thr, schedQueue);
 
    Spinlock_Unlock(&schedLock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sched_SetWaiting()

void Sched_SetWaiting

(

Thread *

thr

)

Sched_SetWaiting –

Set the thread to the waiting state and move it to the wait queue. The thread should be currently running.

Parameters

[in]

thr

Thread to be set as waiting.

Definition at line 104 of file sched.c.

{
    Spinlock_Lock(&schedLock);
 
    ASSERT(thr->schedState == SCHED_STATE_RUNNING);
 
    thr->schedState = SCHED_STATE_WAITING;
    TAILQ_INSERT_TAIL(&waitQueue, thr, schedQueue);
    thr->waitStart = KTime_GetEpochNS();
 
    Spinlock_Unlock(&schedLock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sched_SetZombie()

void Sched_SetZombie

(

Thread *

thr

)

Sched_SetZombie –

Set the thread to the zombie state and move it to the parent processes's zombie process queue. The thread should be currently running.

Parameters

[in]

thr

Thread to be set as zombie.

Definition at line 126 of file sched.c.

{
    Process *proc = thr->proc;
 
    /*
     * Do not go to sleep holding spinlocks.
     */
    ASSERT(Critical_Level() == 0);
 
    if (proc->threads == 1) {
        // All processes have parents except 'init' and 'kernel'
        ASSERT(proc->parent != NULL);
        Mutex_Lock(&proc->parent->zombieProcLock);
        Spinlock_Lock(&proc->parent->lock); // Guards child list
        proc->procState = PROC_STATE_ZOMBIE;
        TAILQ_REMOVE(&proc->parent->childrenList, proc, siblingList);
        TAILQ_INSERT_TAIL(&proc->parent->zombieProc, proc, siblingList);
        Spinlock_Unlock(&proc->parent->lock);
        CV_Signal(&proc->zombieProcPCV);
        CV_Signal(&proc->parent->zombieProcCV);
    }
 
    /*
     * Set as zombie just before releasing the zombieProcLock in case we had to 
     * sleep to acquire the zombieProcLock.
     */
    Spinlock_Lock(&schedLock);
    thr->schedState = SCHED_STATE_ZOMBIE;
    Spinlock_Unlock(&schedLock);
 
    Spinlock_Lock(&proc->lock);
    TAILQ_INSERT_TAIL(&proc->zombieQueue, thr, schedQueue);
    Spinlock_Unlock(&proc->lock);
 
    if (proc->threads == 1)
        Mutex_Unlock(&proc->parent->zombieProcLock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TAILQ_HEAD() [1/2]

typedef TAILQ_HEAD	(	ProcessQueue	,
		Process
	)

TAILQ_HEAD() [2/2]

typedef TAILQ_HEAD	(	ThreadQueue	,
		Thread
	)

Thread_Create()

Thread * Thread_Create

(

Process *

proc

)

Definition at line 96 of file thread.c.

{
    Thread *thr = (Thread *)Slab_Alloc(&threadSlab);
 
    if (!thr)
        return NULL;
 
    memset(thr, 0, sizeof(*thr));
 
    ASSERT(proc != NULL);
 
    thr->tid = proc->nextThreadID++;
    thr->kstack = (uintptr_t)PAlloc_AllocPage();
    if (thr->kstack == 0) {
        Slab_Free(&threadSlab, thr);
        return NULL;
    }
 
    Process_Retain(proc);
 
    Spinlock_Lock(&proc->lock);
    thr->proc = proc;
    proc->threads++;
    TAILQ_INSERT_TAIL(&proc->threadList, thr, threadList);
    thr->space = proc->space;
    thr->ustack = proc->ustackNext;
    proc->ustackNext += MEM_USERSPACE_STKLEN;
    Spinlock_Unlock(&proc->lock);
 
    thr->schedState = SCHED_STATE_NULL;
    thr->timerEvt = NULL;
    thr->refCount = 1;
 
    Thread_InitArch(thr);
    // Initialize queue
 
    return thr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_Dump()

void Thread_Dump

(

Thread *

thr

)

Definition at line 328 of file thread.c.

{
    const char *states[] = {
        "NULL",
        "RUNNABLE",
        "RUNNING",
        "WAITING",
        "ZOMBIE"
    };
 
    // Thread_DumpArch(thr)
    kprintf("space      %016llx\n", thr->space);
    kprintf("kstack     %016llx\n", thr->kstack);
    kprintf("tid        %llu\n", thr->tid);
    kprintf("refCount   %d\n", thr->refCount);
    kprintf("state      %s\n", states[thr->schedState]);
    kprintf("ctxswtch   %llu\n", thr->ctxSwitches);
    kprintf("utime      %llu\n", thr->userTime);
    kprintf("ktime      %llu\n", thr->kernTime);
    kprintf("wtime      %llu\n", thr->waitTime);
    if (thr->proc) {
        Process_Dump(thr->proc);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_Init()

void Thread_Init

(

)

Definition at line 53 of file thread.c.

{
    nextProcessID = 1;
 
    Slab_Init(&processSlab, "Process Objects", sizeof(Process), 16);
    Slab_Init(&threadSlab, "Thread Objects", sizeof(Thread), 16);
 
    Spinlock_Init(&procLock, "Process List Lock", SPINLOCK_TYPE_NORMAL);
    Spinlock_Init(&schedLock, "Scheduler Lock", SPINLOCK_TYPE_RECURSIVE);
 
    TAILQ_INIT(&waitQueue);
    TAILQ_INIT(&runnableQueue);
    TAILQ_INIT(&processList);
 
    Handle_GlobalInit();
 
    // Kernel Process
    kernelProcess = Process_Create(NULL, "kernel");
 
    // Create an thread object for current context
    Process *proc = Process_Create(NULL, "init");
    curProc[0] = Thread_Create(proc);
    curProc[0]->schedState = SCHED_STATE_RUNNING;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_InitAP()

void Thread_InitAP

(

)

Definition at line 79 of file thread.c.

{
    Thread *apthr = Thread_Create(kernelProcess);
 
    apthr->schedState = SCHED_STATE_RUNNING;
 
    //PAlloc_Release((void *)thr->kstack);
    //thr->kstack = 0;
 
    curProc[CPU()] = apthr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_InitArch()

void Thread_InitArch

(

Thread *

thr

)

Definition at line 20 of file thread.c.

{
    thr->arch.useFP = true;
}

Here is the caller graph for this function:

Thread_KThreadCreate()

Thread * Thread_KThreadCreate	(	void(*)(void *)	f,
		void *	arg
	)

Definition at line 136 of file thread.c.

{
    Thread *thr = Thread_Create(kernelProcess);
    if (!thr)
        return NULL;
 
    Thread_SetupKThread(thr, f, (uintptr_t)arg, 0, 0);
 
    return thr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_Lookup()

Thread * Thread_Lookup	(	Process *	proc,
		uint64_t	tid
	)

Thread_Lookup –

Lookup a thread by TID and increment its reference count.

Parameters

[in]	proc	Process within which to find a specific thread.
[in]	tid	Thread ID of the thread to find.

Return values

NULL	if the thread isn't found.

Definition at line 229 of file thread.c.

{
    Thread *t;
    Thread *thr = NULL;
 
    Spinlock_Lock(&proc->lock);
    TAILQ_FOREACH(t, &proc->threadList, threadList) {
        if (t->tid == tid) {
            Thread_Retain(t);
            thr = t;
            break;
        }
    }
    Spinlock_Unlock(&proc->lock);
 
    return thr;
}

Here is the call graph for this function:

Thread_Release()

void Thread_Release

(

Thread *

thr

)

Thread_Release –

Decrement the reference count for a given thread.

Definition at line 265 of file thread.c.

{
    ASSERT(thr->refCount != 0);
    if (__sync_fetch_and_sub(&thr->refCount, 1) == 1) {
        Thread_Destroy(thr);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_Retain()

void Thread_Retain

(

Thread *

thr

)

Thread_Retain –

Increment the reference count for a given thread.

Definition at line 253 of file thread.c.

{
    ASSERT(thr->refCount != 0);
    __sync_fetch_and_add(&thr->refCount, 1);
}

Here is the caller graph for this function:

Thread_SetupKThread()

void Thread_SetupKThread	(	Thread *	thr,
		void(*)()	f,
		uintptr_t	arg1,
		uintptr_t	arg2,
		uintptr_t	arg3
	)

Definition at line 26 of file thread.c.

{
    // Initialize stack
    uint64_t stacktop = thr->kstack + PGSIZE;
    ThreadArchStackFrame *sf;
    TrapFrame *tf;
 
    tf = (TrapFrame *)(stacktop - sizeof(*tf));
    sf = (ThreadArchStackFrame *)(stacktop - sizeof(*tf) - sizeof(*sf));
    thr->arch.rsp = (uint64_t)sf;
 
    memset(tf, 0, sizeof(*tf));
    memset(sf, 0, sizeof(*sf));
 
    // Setup thread exit function on stack
 
    sf->rip = (uint64_t)&ThreadKThreadEntry;
    sf->rdi = (uint64_t)tf;
 
    tf->ds = 0;
    tf->ss = 0; //SEL_KDS;
    tf->rsp = stacktop;
    tf->cs = SEL_KCS;
    tf->rip = (uint64_t)f;
    tf->rdi = (uint64_t)arg1;
    tf->rsi = (uint64_t)arg2;
    tf->rdx = (uint64_t)arg3;
    tf->rflags = RFLAGS_IF;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_SetupUThread()

void Thread_SetupUThread	(	Thread *	thr,
		uint64_t	rip,
		uint64_t	arg
	)

Definition at line 75 of file thread.c.

{
    Thread_SetupKThread(thr, ThreadEnterUserLevelCB, rip,
                        thr->ustack, arg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_SwitchArch()

void Thread_SwitchArch	(	Thread *	oldthr,
		Thread *	newthr
	)

Definition at line 84 of file thread.c.

{
    /*
     * Save and restore floating point and vector CPU state using the fxsave 
     * and fxrstor instructions.
     */
    if (oldthr->arch.useFP)
    {
        fxsave(&oldthr->arch.xsa);
    }
 
    if (newthr->arch.useFP)
    {
        fxrstor(&newthr->arch.xsa);
    }
 
    clts();
 
    // Jump to trapframe
    switchstack(&oldthr->arch.rsp, newthr->arch.rsp);
 
    // Set new RSP0
    TSS[CPU()].rsp0 = oldthr->kstack + 4096;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_UThreadCreate()

Thread * Thread_UThreadCreate	(	Thread *	oldThr,
		uint64_t	rip,
		uint64_t	arg
	)

Definition at line 148 of file thread.c.

{
    Process *proc = oldThr->proc;
    Thread *thr = (Thread *)Slab_Alloc(&threadSlab);
 
    if (!thr)
        return NULL;
 
    memset(thr, 0, sizeof(*thr));
 
    thr->tid = proc->nextThreadID++;
    thr->kstack = (uintptr_t)PAlloc_AllocPage();
    if (thr->kstack == 0) {
        Slab_Free(&threadSlab, thr);
        return NULL;
    }
 
    thr->space = oldThr->space;
    thr->schedState = SCHED_STATE_NULL;
    thr->refCount = 1;
 
    Spinlock_Lock(&proc->lock);
    thr->ustack = proc->ustackNext;
    proc->ustackNext += MEM_USERSPACE_STKLEN;
    Spinlock_Unlock(&proc->lock);
 
    PMap_AllocMap(thr->space, thr->ustack, MEM_USERSPACE_STKLEN, PTE_W);
    // XXX: Check failure
 
    Thread_InitArch(thr);
    // Initialize queue
 
    Thread_SetupUThread(thr, rip, arg);
 
    Process_Retain(proc);
 
    Spinlock_Lock(&proc->lock);
    thr->proc = proc;
    // XXX: Process lock
    proc->threads++;
    TAILQ_INSERT_TAIL(&proc->threadList, thr, threadList);
    Spinlock_Unlock(&proc->lock);
 
    return thr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Thread_Wait()

uint64_t Thread_Wait	(	Thread *	thr,
		uint64_t	tid
	)

Thread_Wait –

Wait for any thread (tid == TID_ANY) or a specific thread.

Definition at line 279 of file thread.c.

{
    Thread *t;
    uint64_t status;
 
    ASSERT(thr->proc != NULL);
 
    if (tid == TID_ANY) {
        t = TAILQ_FIRST(&thr->proc->zombieQueue);
        if (!t) {
            return SYSCALL_PACK(EAGAIN, 0);
        }
 
        TAILQ_REMOVE(&thr->proc->zombieQueue, t, schedQueue);
        status = t->exitValue;
        Thread_Release(t);
        return SYSCALL_PACK(0, status);
    }
 
    // XXXURGENT
    TAILQ_FOREACH(t, &thr->proc->zombieQueue, schedQueue) {
        if (t->tid == tid) {
            TAILQ_REMOVE(&thr->proc->zombieQueue, t, schedQueue);
            status = t->exitValue;
            Thread_Release(t);
            return SYSCALL_PACK(0, status);
        }
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: