pcb.c File Reference

#include <core/pcb.h>

Include dependency graph for pcb.c:

Go to the source code of this file.

Functions
pcb_t *	allocatePCB (void)
	allocatePCB allocate new memory for a pcb_t More...
e_PCB_ERROR_CODE_t	freePCB (pcb_t *pcbToFree)
	freePCB free all associated memory with the PCB, including the stack and other pointers More...
pcb_t *	setupPCB (const char *processName, e_PROCESS_CLASS_t processClass, processPriority_t processPriority)
	setupPCB calls allocatePCB, initializes the PCB with the arguments and sets it state to ready More...
pcb_t *	findPCB (const char *processName)
	findPCB will search all queues for the PCB with the input name More...
void	insertPCB (pcb_t *pcbToInsert)
	insertPCB insert the PCB into the queue represented by the process state, following each queue's rules More...
e_PCB_ERROR_CODE_t	removePCB (pcb_t *pcbToRemove)
	removePCB remove the input PCB from its associated queue More...
e_PCB_ERROR_CODE_t	changeProcessState (const char *processName, e_PROCESS_STATE_t newState)
	changeProcessState changes the state of the process being called More...
e_PCB_ERROR_CODE_t	changeProcessSuspensionState (const char *processName, e_PROCESS_SUSPENSION_STATE_t suspensionState)
	changeProcessSuspensionState More...
e_PROCESS_STATE_t	getState (const char *name)
	getState gets the current state of the process More...
int	fifoInsertFunc (void *pcb1, void *pcb2)
	priorityInsertFunc function that inserts pcbs into new pcb queues ordered by the sequence of arrival. See Linked List documentation for a better description of a list insert function. More...
int	priorityInsertFunc (void *pcb1, void *pcb2)
	priorityInsertFunc function that inserts pcbs into new pcb queues ordered by the pcbs' priority. See Linked List documentation for a better description of a list insert function. More...
int	pcbSearchFunc (void *pcb, void *nameToFind)
	pcbSearchFunc pcb search function for linked list. All pcb linkedLists use this function for searching See Linked List documentation for a description of a list search function More...
void	initPCBQueues (void)
	initPCBQueues initlize the queues for each process queue. This function calls the list init function and sets the function pointers for each list More...
void	pcbTest (void)
	pcbTest a simple test case function to show pcb queue functionality More...
const char *	errorToString (e_PCB_ERROR_CODE_t error)
	errorToString creates a string form of the error passed in More...
const char *	classToString (e_PROCESS_CLASS_t processClass)
	classToString creates a string form of the class passed in More...
const char *	stateToString (e_PROCESS_STATE_t state)
	stateToString creates a string form of the state passed in More...
const char *	suspensionToString (e_PROCESS_SUSPENSION_STATE_t state)
e_PROCESS_CLASS_t	stringToClass (const char *stringifiedClass)
	stringToClass returns the enum representation of a string More...
void	printPCBFunc (void *pcb)
	printPCBFunc prints the status of a process More...
e_PCB_ERROR_CODE_t	changeProcessPriority (const char *procName, processPriority_t newPriority)
	changeProcessPriority More...

Variables
linkedList_t	readyQueue
linkedList_t	blockedQueue
linkedList_t	suspendedReadyQueue
linkedList_t	suspendedBlockedQueue
pcb_t *	currentOperatingProcess = 0
e_PCB_ERROR_CODE_t	prevPCBError

Function Documentation

pcb_t* allocatePCB

(

void

)

allocatePCB allocate new memory for a pcb_t

Returns

null if error, else pointer to pcb_t

Definition at line 15 of file pcb.c.

References ERROR_ALLOCATING_NODE, makeNewNode(), prevPCBError, SUCCESS, and sys_alloc_mem().

Referenced by setupPCB().

{
#ifndef LL_IS_ARRAY_BACKED
    prevPCBError=SUCCESS;

    pcb_t* temp = (pcb_t*)sys_alloc_mem(sizeof(pcb_t));
    temp->representingNode = makeNewNode(0, (void*)temp);

    if(!temp || !temp->representingNode) { prevPCBError = ERROR_ALLOCATING_NODE; return 0; }

    return temp;
#endif
}

e_PCB_ERROR_CODE_t changeProcessPriority	(	const char *	procName,
		processPriority_t	newPriority
	)

changeProcessPriority

Parameters

procName
newPriority

Returns

Todo:

comment this

Definition at line 342 of file pcb.c.

References ERROR_PCB_NOT_FOUND, ERROR_PRIORITY_INVALID, findPCB(), prevPCBError, PROCESS_HIGHEST_PRIORITY, and SUCCESS.

Referenced by setPriority().

{
    prevPCBError=SUCCESS;
    if(newPriority > PROCESS_HIGHEST_PRIORITY)
    {
        return ERROR_PRIORITY_INVALID;
    }
    pcb_t* foundProcess = findPCB(procName);
    if(!foundProcess)
    {
        return ERROR_PCB_NOT_FOUND;
    }

    foundProcess->priority = newPriority;
    return SUCCESS;
}

e_PCB_ERROR_CODE_t changeProcessSuspensionState	(	const char *	processName,
		e_PROCESS_SUSPENSION_STATE_t	suspensionState
	)

changeProcessSuspensionState

Parameters

name
suspensionState

Returns

Todo:

comment this

Definition at line 190 of file pcb.c.

References ERROR_PCB_NOT_FOUND, ERROR_STATE_INVALID, findPCB(), insertPCB(), NOT_SUSPENDED, prevPCBError, removePCB(), SUCCESS, and SUSPENDED.

Referenced by kmain(), resumePCB(), and suspendPCB().

{
    prevPCBError=SUCCESS;
    if((suspensionState != SUSPENDED) &&
            (suspensionState != NOT_SUSPENDED))
    {
        return prevPCBError=ERROR_STATE_INVALID;
    }

    pcb_t* process = findPCB(processName);
    if(!process){ return prevPCBError = ERROR_PCB_NOT_FOUND; }

    process->processSuspensionState = suspensionState;

    removePCB(process);
    insertPCB(process);

    return prevPCBError;
}

int fifoInsertFunc	(	void *	pcb1,
		void *	pcb2
	)

priorityInsertFunc function that inserts pcbs into new pcb queues ordered by the sequence of arrival. See Linked List documentation for a better description of a list insert function.

Parameters

pcb1	void* to a pcb to compare with
pcb2	void* to the pcb to insert

Returns

see Linked List documentation for a description on the returned value

Definition at line 217 of file pcb.c.

{
    (void)pcb1; (void)pcb2;
    return -1;
}

pcb_t* findPCB

(

const char *

processName

)

findPCB will search all queues for the PCB with the input name

Parameters

processName

the name of the PCB searching for

Returns

null if PCB not found, otherwise returns pointer to pcb_t represented by name

Definition at line 100 of file pcb.c.

References ERROR_PCB_NOT_FOUND, prevPCBError, searchList(), and SUCCESS.

Referenced by changeProcessPriority(), changeProcessState(), changeProcessSuspensionState(), deletePCB(), getState(), setPriority(), setupPCB(), and showPCB().

{
    prevPCBError=SUCCESS;
    node_t* temp;
    temp = searchList(&readyQueue,(void*) processName);
    if(temp)
    {
        return (pcb_t*)(temp->data);
    }

    temp = searchList(&blockedQueue,(void*) processName);
    if(temp)
    {
        return (pcb_t*)(temp->data);
    }

    temp = searchList(&suspendedReadyQueue,(void*) processName);
    if(temp)
    {
        return (pcb_t*)(temp->data);
    }

    temp = searchList(&suspendedBlockedQueue,(void*) processName);
    if(temp)
    {
        return (pcb_t*)(temp->data);
    }

    prevPCBError=ERROR_PCB_NOT_FOUND;
    return 0;
}

e_PCB_ERROR_CODE_t freePCB

(

pcb_t *

pcbToFree

)

freePCB free all associated memory with the PCB, including the stack and other pointers

Todo:

line 45 needs to call linkedList_t node free functions

Definition at line 32 of file pcb.c.

References ERROR_FREEING_NODE, ERROR_FREEING_PCB, ERROR_FREEING_STACK, ERROR_REMOVING_PCB, prevPCBError, removePCB(), and SUCCESS.

Referenced by deletePCB(), and sys_call().

{
    prevPCBError=SUCCESS;
    if(pcbToFree)
    {
        prevPCBError = removePCB(pcbToFree);
        if(prevPCBError != SUCCESS)
        {
            return prevPCBError = ERROR_REMOVING_PCB;
        }
        if(pcbToFree->representingNode)
        {

            //prevPCBError = sys_free_mem(pcbToFree->representingNode);
            if(prevPCBError != SUCCESS)
            {
                return prevPCBError = ERROR_FREEING_NODE;
            }
        }
        if(pcbToFree->stackBase)
        {
            //prevPCBError = sys_free_mem(pcbToFree->stackBottom);
            if(prevPCBError != SUCCESS)
            {
                return prevPCBError = ERROR_FREEING_STACK;
            }
        }

        //prevPCBError = sys_free_mem(pcbToFree);
    }

    if(prevPCBError != SUCCESS)
    {
        return prevPCBError = ERROR_FREEING_PCB;
    }

    return prevPCBError = SUCCESS;
}

void initPCBQueues

(

void

)

initPCBQueues initlize the queues for each process queue. This function calls the list init function and sets the function pointers for each list

Definition at line 233 of file pcb.c.

References initLinkedList(), pcbSearchFunc(), printPCBFunc(), setPrintFunction(), and setSearchComparisonFunction().

Referenced by kmain().

{
    initLinkedList(&readyQueue);
    initLinkedList(&blockedQueue);
    initLinkedList(&suspendedReadyQueue);
    initLinkedList(&suspendedBlockedQueue);

    setSearchComparisonFunction(&readyQueue, &pcbSearchFunc);
    setSearchComparisonFunction(&blockedQueue, &pcbSearchFunc);
    setSearchComparisonFunction(&suspendedReadyQueue, &pcbSearchFunc);
    setSearchComparisonFunction(&suspendedBlockedQueue, &pcbSearchFunc);

    setPrintFunction(&readyQueue, &printPCBFunc);
    setPrintFunction(&blockedQueue, &printPCBFunc);
    setPrintFunction(&suspendedReadyQueue, &printPCBFunc);
    setPrintFunction(&suspendedBlockedQueue, &printPCBFunc);

//    setInsertComparisonFunction(&readyQueue, &priorityInsertFunc);
}

void insertPCB

(

pcb_t *

pcbToInsert

)

insertPCB insert the PCB into the queue represented by the process state, following each queue's rules

Parameters

pcbToInsert

pointer to pcb_t to insert

Definition at line 132 of file pcb.c.

References BLOCKED, ERROR_INSERTING_PCB, insertNode(), NOT_SUSPENDED, prevPCBError, READY, SUCCESS, and SUSPENDED.

Referenced by changeProcessState(), changeProcessSuspensionState(), setupPCB(), and sys_call().

{
    prevPCBError=SUCCESS;
    if((pcbToInsert->processState == READY) &&
            (pcbToInsert->processSuspensionState == NOT_SUSPENDED))
    {
        (void)insertNode(&readyQueue,pcbToInsert->representingNode);
        return;
    }
    if((pcbToInsert->processState == BLOCKED) &&
            (pcbToInsert->processSuspensionState == NOT_SUSPENDED))
    {
        (void)insertNode(&blockedQueue,pcbToInsert->representingNode);
        return;
    }
    if((pcbToInsert->processState == READY) &&
            (pcbToInsert->processSuspensionState == SUSPENDED))
    {
        (void)insertNode(&suspendedReadyQueue,pcbToInsert->representingNode);
        return;
    }
    if((pcbToInsert->processState == BLOCKED) &&
            (pcbToInsert->processSuspensionState == SUSPENDED))
    {
        (void)insertNode(&suspendedBlockedQueue,pcbToInsert->representingNode);
        return;
    }
    prevPCBError=ERROR_INSERTING_PCB;
}

int pcbSearchFunc	(	void *	pcb,
		void *	nameToFind
	)

pcbSearchFunc pcb search function for linked list. All pcb linkedLists use this function for searching See Linked List documentation for a description of a list search function

Parameters

pcb	void* to pcb structure
nameToFind	void* to (const char*)

Returns

0 if the name of the pcb matches nameToFind

Definition at line 228 of file pcb.c.

References strcmp().

Referenced by initPCBQueues().

{
    return strcmp(((pcb_t*)pcb)->name, (char*)nameToFind);
}

void pcbTest

(

void

)

pcbTest a simple test case function to show pcb queue functionality

Definition at line 253 of file pcb.c.

References printf, printList(), setupPCB(), sprintf(), and SYSTEM.

{
    printf("%s","PCB Queue Test\r\n\r\n");
    int i;
    for( i = 0; i < 30; i++)
    {
        char name[20];
        sprintf(name, 20, "Proc %d", i);
        setupPCB(name, SYSTEM, i/3);
    }
    printf("Ready Queue Contents%s","\r\n");
    printList(&readyQueue);
}

int priorityInsertFunc	(	void *	pcb1,
		void *	pcb2
	)

priorityInsertFunc function that inserts pcbs into new pcb queues ordered by the pcbs' priority. See Linked List documentation for a better description of a list insert function.

Parameters

pcb1	void* to a pcb to compare with
pcb2	void* to the pcb to insert

Returns

see Linked List documentation for a description on the returned value

Definition at line 223 of file pcb.c.

{
    return ((pcb_t*)pcb2)->priority - ((pcb_t*)pcb1)->priority;
}

e_PCB_ERROR_CODE_t removePCB

(

pcb_t *

pcbToRemove

)

removePCB remove the input PCB from its associated queue

Parameters

pcbToRemove

pointer to pcb_t

Returns

PCB_ERROR_CODE_t value that describes result

Definition at line 162 of file pcb.c.

References prevPCBError, removeNode(), and SUCCESS.

Referenced by changeProcessState(), changeProcessSuspensionState(), freePCB(), and sys_call().

{
    (void)removeNode(pcbToRemove->representingNode);
    return prevPCBError=SUCCESS;
}

pcb_t* setupPCB	(	const char *	processName,
		e_PROCESS_CLASS_t	processClass,
		processPriority_t	processPriority
	)

setupPCB calls allocatePCB, initializes the PCB with the arguments and sets it state to ready

Parameters

processName	the name of the new process
processClass	the class of the new process
processPriority	the priority of the new process, must be between 0-9

Returns

null if error, pointer to new PCB otherwise

Definition at line 71 of file pcb.c.

References allocatePCB(), ERROR_ALLOCATING_NODE, ERROR_CLASS_INVALID, ERROR_NAME_COLLISION, ERROR_NAME_INVALID, ERROR_PRIORITY_INVALID, findPCB(), insertPCB(), prevPCBError, PROCESS_MAX_NAME_LENGTH, PROCESS_STACK_SIZE, READY, strcpy(), strlen(), SUCCESS, SUSPENDED, SYSTEM, and USER_APP.

Referenced by createPCB(), kmain(), loadr3(), and pcbTest().

{
    prevPCBError=SUCCESS;
    int lengthOfName = strlen(processName);
    if(lengthOfName >= PROCESS_MAX_NAME_LENGTH || lengthOfName <= 0 ) { prevPCBError = ERROR_NAME_INVALID; return 0; }
    if(processPriority > 9) { prevPCBError = ERROR_PRIORITY_INVALID; return 0; }
    if((processClass != SYSTEM) && (processClass != USER_APP)) { prevPCBError = ERROR_CLASS_INVALID; return 0; }

    pcb_t* newPCB = findPCB(processName);
    if(newPCB){ prevPCBError = ERROR_NAME_COLLISION; return 0; }

    newPCB = allocatePCB();

    if(!newPCB) { prevPCBError = ERROR_ALLOCATING_NODE; return 0; }

    strcpy(newPCB->name, processName);
    newPCB->processClass = processClass;
    newPCB->priority = processPriority;
    newPCB->processState = READY;
    newPCB->processSuspensionState = SUSPENDED;
    newPCB->stackBase= &newPCB->stack[0];
    newPCB->stackTop = newPCB->stackBase+PROCESS_STACK_SIZE-sizeof(processContext_t);
    newPCB->context = (processContext_t*)newPCB->stackTop;

    insertPCB(newPCB);

    return newPCB;
}

const char* suspensionToString

(

e_PROCESS_SUSPENSION_STATE_t

state

)

Definition at line 317 of file pcb.c.

References NOT_SUSPENDED, SUSPENDED, and SUSPENSION_UNKNOWN.

Referenced by printPCBFunc().

{
    switch(state)
    {
        case SUSPENDED: return "Suspended";
        case NOT_SUSPENDED: return "Not-Suspended";
        default:
        case SUSPENSION_UNKNOWN: return "Suspension-State-Unknown";
    }
}

Variable Documentation

linkedList_t blockedQueue

Definition at line 4 of file pcb.c.

Referenced by showAllProcesses(), and showBlockedProcesses().

pcb_t* currentOperatingProcess = 0

Definition at line 9 of file pcb.c.

Referenced by allocateMemFromHeap(), freeHeapMem(), and sys_call().

e_PCB_ERROR_CODE_t prevPCBError

Definition at line 13 of file pcb.c.

Referenced by allocatePCB(), changeProcessPriority(), changeProcessState(), changeProcessSuspensionState(), createPCB(), deletePCB(), findPCB(), freePCB(), getState(), insertPCB(), removePCB(), setupPCB(), and showPCB().

linkedList_t readyQueue

Definition at line 3 of file pcb.c.

Referenced by idle(), showAllProcesses(), showReadyProcesses(), and sys_call().

linkedList_t suspendedBlockedQueue

Definition at line 6 of file pcb.c.

Referenced by showAllProcesses().

linkedList_t suspendedReadyQueue

Definition at line 5 of file pcb.c.

Referenced by showAllProcesses().