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

Go to the source code of this file.

Functions
Thread *	Sched_Current ()
void	Sched_SetRunnable (Thread *thr)
void	Sched_SetWaiting (Thread *thr)
void	Sched_SetZombie (Thread *thr)
static void	Sched_Switch (Thread *oldthr, Thread *newthr)
void	Sched_Scheduler ()

Variables
Spinlock	schedLock
ThreadQueue	waitQueue
ThreadQueue	runnableQueue
Thread *	curProc [MAX_CPUS]

Function Documentation

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:

Sched_Switch()

static void Sched_Switch ( Thread *  oldthr, Thread *  newthr  )

static

Sched_Switch –

Switch between threads. During the creation of kernel threads (and by proxy user threads) we may not return through this code path and thus the kernel thread initialization function must release the scheduler lock.

Parameters

[in]	oldthr	Current thread we are switching from.
[in]	newthr	Thread to switch to.

Definition at line 175 of file sched.c.

{
    // Load AS
    PMap_LoadAS(newthr->space);
 
    Thread_SwitchArch(oldthr, newthr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

curProc

Thread* curProc[MAX_CPUS]

Current thread executing on a given CPU.

Definition at line 41 of file sched.c.

runnableQueue

ThreadQueue runnableQueue

All runnable threads.

Definition at line 37 of file sched.c.

schedLock

Spinlock schedLock

Scheduler lock that protects all queues.

Definition at line 29 of file sched.c.

waitQueue

ThreadQueue waitQueue

All threads currently waiting.

Definition at line 33 of file sched.c.