process.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 process.c:

Go to the source code of this file.

Functions
Process *	Process_Create (Process *parent, const char *title)
static void	Process_Destroy (Process *proc)
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)
void	Process_Dump (Process *proc)
static void	Debug_Processes (int argc, const char *argv[])
	REGISTER_DBGCMD (processes, "Display list of processes", Debug_Processes)
static void	Debug_ProcInfo (int argc, const char *argv[])
	REGISTER_DBGCMD (procinfo, "Display current process state", Debug_ProcInfo)

Variables
Thread *	curProc [MAX_CPUS]
Spinlock	procLock
uint64_t	nextProcessID
ProcessQueue	processList
Slab	processSlab

Function Documentation

Debug_Processes()

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

static

Definition at line 269 of file process.c.

{
    Process *proc;
 
    /*
     * We don't hold locks in case you the kernel debugger is entered while 
     * holding this lock.
     */
    //Spinlock_Lock(&threadLock);
 
    TAILQ_FOREACH(proc, &processList, processList)
    {
        kprintf("Process: %d(%016llx)\n", proc->pid, proc);
        Process_Dump(proc);
    }
 
    //Spinlock_Unlock(&threadLock);
}

Here is the call graph for this function:

Debug_ProcInfo()

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

static

Definition at line 291 of file process.c.

{
    Thread *thr = curProc[CPU()];
 
    kprintf("Current Process State:\n");
    Process_Dump(thr->proc);
}

Here is the call graph for this function:

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

static void Process_Destroy ( Process *  proc )

static

Process_Destroy –

Destroy a process. This should not be called direct, but rather by Process_Release.

Parameters

[in]

proc

Process to destroy.

Definition at line 113 of file process.c.

{
    Handle_Destroy(proc);
 
    Spinlock_Destroy(&proc->lock);
    Semaphore_Destroy(&proc->zombieSemaphore);
    CV_Destroy(&proc->zombieProcPCV);
    CV_Destroy(&proc->zombieProcCV);
    Mutex_Destroy(&proc->zombieProcLock);
    PMap_DestroyAS(proc->space);
 
    // XXX: We need to promote zombie processes to our parent
    // XXX: Release the semaphore as well
 
    Spinlock_Lock(&procLock);
    TAILQ_REMOVE(&processList, proc, processList);
    Spinlock_Unlock(&procLock);
 
    Slab_Free(&processSlab, 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:

REGISTER_DBGCMD() [1/2]

REGISTER_DBGCMD	(	processes	,
		"Display list of processes"	,
		Debug_Processes
	)

REGISTER_DBGCMD() [2/2]

REGISTER_DBGCMD	(	procinfo	,
		"Display current process state"	,
		Debug_ProcInfo
	)

Variable Documentation

curProc

Thread* curProc[MAX_CPUS]

extern

Current thread executing on a given CPU.

Definition at line 41 of file sched.c.

nextProcessID

uint64_t nextProcessID

Definition at line 29 of file process.c.

processList

ProcessQueue processList

Definition at line 30 of file process.c.

processSlab

Slab processSlab

Definition at line 33 of file process.c.

procLock

Spinlock procLock

Definition at line 28 of file process.c.