thread.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <sys/syscall.h>
#include <sys/kassert.h>
#include <sys/kconfig.h>
#include <sys/kdebug.h>
#include <sys/kmem.h>
#include <sys/ktime.h>
#include <sys/mp.h>
#include <sys/spinlock.h>
#include <sys/thread.h>
#include <machine/trap.h>
#include <machine/pmap.h>

Include dependency graph for thread.c:

Go to the source code of this file.

Functions
void	Handle_GlobalInit ()
void	Thread_Init ()
void	Thread_InitAP ()
Thread *	Thread_Create (Process *proc)
Thread *	Thread_KThreadCreate (void(*f)(void *), void *arg)
Thread *	Thread_UThreadCreate (Thread *oldThr, uint64_t rip, uint64_t arg)
static void	Thread_Destroy (Thread *thr)
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)
void	ThreadKThreadEntry (TrapFrame *tf) __NO_LOCK_ANALYSIS
void	Thread_Dump (Thread *thr)
static void	Debug_Threads (int argc, const char *argv[])
	REGISTER_DBGCMD (threads, "Display list of threads", Debug_Threads)
static void	Debug_ThreadInfo (int argc, const char *argv[])
	REGISTER_DBGCMD (threadinfo, "Display current thread state", Debug_ThreadInfo)

Variables
Spinlock	schedLock
ThreadQueue	waitQueue
ThreadQueue	runnableQueue
Thread *	curProc [MAX_CPUS]
Spinlock	procLock
uint64_t	nextProcessID
ProcessQueue	processList
Slab	processSlab
Process *	kernelProcess
Slab	threadSlab
TaskStateSegment64	TSS [MAX_CPUS]

Function Documentation

Debug_ThreadInfo()

static void Debug_ThreadInfo ( int  argc, const char *  argv[]  )

static

Definition at line 384 of file thread.c.

{
    Thread *thr = curProc[CPU()];
 
    kprintf("Current Thread State:\n");
    Thread_Dump(thr);
}

Here is the call graph for this function:

Debug_Threads()

static void Debug_Threads ( int  argc, const char *  argv[]  )

static

Definition at line 354 of file thread.c.

{
    Thread *thr;
 
    //Spinlock_Lock(&threadLock);
 
    for (int i = 0; i < MAX_CPUS; i++) {
        thr = curProc[i];
        if (thr) {
            kprintf("Running Thread CPU %d: %d(%016llx) %d\n", i, thr->tid, thr, thr->ctxSwitches);
            Thread_Dump(thr);
        }
    }
    TAILQ_FOREACH(thr, &runnableQueue, schedQueue)
    {
        kprintf("Runnable Thread: %d(%016llx) %d\n", thr->tid, thr, thr->ctxSwitches);
        Thread_Dump(thr);
    }
    TAILQ_FOREACH(thr, &waitQueue, schedQueue)
    {
        kprintf("Waiting Thread: %d(%016llx) %d\n", thr->tid, thr, thr->ctxSwitches);
        Thread_Dump(thr);
    }
 
    //Spinlock_Unlock(&threadLock);
}

Here is the call graph for this function:

Handle_GlobalInit()

void Handle_GlobalInit

(

)

Definition at line 15 of file handle.c.

{
    Slab_Init(&handleSlab, "Handle Objects", sizeof(Handle), 16);
}

Here is the call graph for this function:

Here is the caller graph for this function:

REGISTER_DBGCMD() [1/2]

REGISTER_DBGCMD	(	threadinfo	,
		"Display current thread state"	,
		Debug_ThreadInfo
	)

REGISTER_DBGCMD() [2/2]

REGISTER_DBGCMD	(	threads	,
		"Display list of threads"	,
		Debug_Threads
	)

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_Destroy()

static void Thread_Destroy ( Thread *  thr )

static

Definition at line 195 of file thread.c.

{
    Process *proc = thr->proc;
 
    // Don't free kernel threads
    ASSERT(proc->pid != 1);
 
    // Free userspace stack
 
    Spinlock_Lock(&proc->lock);
    proc->threads--;
    TAILQ_REMOVE(&proc->threadList, thr, threadList);
    Spinlock_Unlock(&proc->lock);
 
    // Free AS
    PAlloc_Release((void *)thr->kstack);
 
    // Release process handle
    Process_Release(thr->proc);
 
    Slab_Free(&threadSlab, 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_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_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:

ThreadKThreadEntry()

void ThreadKThreadEntry

(

TrapFrame *

tf

)

Definition at line 314 of file thread.c.

{
    TSS[CPU()].rsp0 = curProc[CPU()]->kstack + 4096;
 
    Spinlock_Unlock(&schedLock);
 
    Trap_Pop(tf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

curProc

Thread* curProc[MAX_CPUS]

extern

Current thread executing on a given CPU.

Definition at line 41 of file sched.c.

kernelProcess

Process* kernelProcess

Definition at line 45 of file thread.c.

nextProcessID

uint64_t nextProcessID

extern

Definition at line 29 of file process.c.

processList

ProcessQueue processList

extern

Definition at line 30 of file process.c.

processSlab

Slab processSlab

extern

Definition at line 33 of file process.c.

procLock

Spinlock procLock

extern

Definition at line 28 of file process.c.

runnableQueue

ThreadQueue runnableQueue

extern

All runnable threads.

Definition at line 37 of file sched.c.

schedLock

Spinlock schedLock

extern

Scheduler lock that protects all queues.

Definition at line 29 of file sched.c.

threadSlab

Slab threadSlab

Definition at line 48 of file thread.c.

TSS

TaskStateSegment64 TSS[MAX_CPUS]

extern

Definition at line 40 of file machine.c.

waitQueue

ThreadQueue waitQueue

extern

All threads currently waiting.

Definition at line 33 of file sched.c.