pcb.h File Reference

#include <system.h>
#include <linked_list.h>

Include dependency graph for pcb.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	s_pcb_stuct
	defines the properties of a process control block More...

Macros
#define	PROCESS_CONTEXT_SIZE   (32)
#define	PROCESS_STACK_SIZE   (6000)
#define	PCB_QUEUE_MAX_SIZE   (128)
#define	PROCESS_MAX_NAME_LENGTH   (20)
#define	PROCESS_LOWEST_PRIORITY   0
#define	PROCESS_HIGHEST_PRIORITY   9

Typedefs
typedef struct s_pcb_stuct	pcb_t
typedef struct s_pcb_list	pcbQueue_t
typedef size_t	PID_t
	PID_t a type that defines a process operating ID. More...
typedef size_t	processPriority_t
	processPriority_t defines a process priority to the system More...
typedef uint8_t	programPtr_t
	programPtr_t a pointer to a process's code More...
typedef uint32_t	programDataPtr_t
	programDataPtr_t a pointer to a process's data More...
typedef uint8_t	processStack_t
	processStack_t a pointer to someplace in a process's stack More...

Enumerations
enum	e_PCB_ERROR_CODE_t {   SUCCESS = 0, ERROR, ERROR_PCB_NOT_FOUND, ERROR_NAME_INVALID,   ERROR_PRIORITY_INVALID, ERROR_FREEING_NODE, ERROR_FREEING_STACK, ERROR_FREEING_PCB,   ERROR_REMOVING_PCB, ERROR_STATE_INVALID, ERROR_CLASS_INVALID, ERROR_ALLOCATING_NODE,   ERROR_NAME_COLLISION, ERROR_INSERTING_PCB }
	The e_PCB_ERROR_CODE_t enum defines the return status of functions working with PCBs. More...
enum	e_PROCESS_STATE_t {   INITIAL, READY, RUNNING, BLOCKED,   TERMINAL, STATE_UNKNOWN }
	The PROCESS_STATE_t enum defines the possible operating states of a process. More...
enum	e_PROCESS_SUSPENSION_STATE_t { SUSPENDED, NOT_SUSPENDED, SUSPENSION_UNKNOWN }
enum	e_PROCESS_CLASS_t { SYSTEM, USER_APP, CLASS_UNKNOWN }
	The PROCESS_CLASS_t enum defines the operating class of the process. More...

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_PROCESS_STATE_t	getState (const char *name)
	getState gets the current state of the process 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...
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	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...
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...
e_PCB_ERROR_CODE_t	changeProcessState (const char *processName, e_PROCESS_STATE_t state)
	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...
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...
e_PROCESS_CLASS_t	stringToClass (const char *stringifiedClass)
	stringToClass returns the enum representation of a string More...
e_PCB_ERROR_CODE_t	changeProcessPriority (const char *procName, processPriority_t newPriority)
	changeProcessPriority More...
void	printPCBFunc (void *pcb)
	printPCBFunc prints the status of a process More...

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

Macro Definition Documentation

#define PCB_QUEUE_MAX_SIZE   (128)

Definition at line 23 of file pcb.h.

#define PROCESS_CONTEXT_SIZE   (32)

Definition at line 21 of file pcb.h.

#define PROCESS_HIGHEST_PRIORITY   9

Definition at line 27 of file pcb.h.

Referenced by changeProcessPriority().

#define PROCESS_LOWEST_PRIORITY   0

Definition at line 26 of file pcb.h.

#define PROCESS_MAX_NAME_LENGTH   (20)

Definition at line 24 of file pcb.h.

Referenced by setupPCB().

#define PROCESS_STACK_SIZE   (6000)

Definition at line 22 of file pcb.h.

Referenced by setupPCB().

Typedef Documentation

typedef struct s_pcb_stuct pcb_t

Definition at line 61 of file pcb.h.

typedef struct s_pcb_list pcbQueue_t

Definition at line 77 of file pcb.h.

typedef size_t PID_t

PID_t a type that defines a process operating ID.

Definition at line 82 of file pcb.h.

typedef size_t processPriority_t

processPriority_t defines a process priority to the system

Definition at line 87 of file pcb.h.

typedef uint8_t processStack_t

processStack_t a pointer to someplace in a process's stack

Definition at line 102 of file pcb.h.

typedef uint32_t programDataPtr_t

programDataPtr_t a pointer to a process's data

Definition at line 97 of file pcb.h.

typedef uint8_t programPtr_t

programPtr_t a pointer to a process's code

Definition at line 92 of file pcb.h.

Enumeration Type Documentation

enum e_PCB_ERROR_CODE_t

The e_PCB_ERROR_CODE_t enum defines the return status of functions working with PCBs.

Enumerator
SUCCESS
ERROR
ERROR_PCB_NOT_FOUND
ERROR_NAME_INVALID
ERROR_PRIORITY_INVALID
ERROR_FREEING_NODE
ERROR_FREEING_STACK
ERROR_FREEING_PCB
ERROR_REMOVING_PCB
ERROR_STATE_INVALID
ERROR_CLASS_INVALID
ERROR_ALLOCATING_NODE
ERROR_NAME_COLLISION
ERROR_INSERTING_PCB

Definition at line 38 of file pcb.h.

             {SUCCESS = 0, ERROR, ERROR_PCB_NOT_FOUND, ERROR_NAME_INVALID, ERROR_PRIORITY_INVALID,
                            ERROR_FREEING_NODE, ERROR_FREEING_STACK, ERROR_FREEING_PCB, ERROR_REMOVING_PCB, ERROR_STATE_INVALID,
                            ERROR_CLASS_INVALID, ERROR_ALLOCATING_NODE, ERROR_NAME_COLLISION, ERROR_INSERTING_PCB}

enum e_PROCESS_CLASS_t

The PROCESS_CLASS_t enum defines the operating class of the process.

Enumerator
SYSTEM
USER_APP
CLASS_UNKNOWN

Definition at line 54 of file pcb.h.

{SYSTEM, USER_APP, CLASS_UNKNOWN} e_PROCESS_CLASS_t;

enum e_PROCESS_STATE_t

The PROCESS_STATE_t enum defines the possible operating states of a process.

Enumerator
INITIAL
READY
RUNNING
BLOCKED
TERMINAL
STATE_UNKNOWN

Definition at line 47 of file pcb.h.

{INITIAL, READY, RUNNING, BLOCKED, TERMINAL, STATE_UNKNOWN} e_PROCESS_STATE_t;

enum e_PROCESS_SUSPENSION_STATE_t

Enumerator
SUSPENDED
NOT_SUSPENDED
SUSPENSION_UNKNOWN

Definition at line 49 of file pcb.h.

{SUSPENDED, NOT_SUSPENDED, SUSPENSION_UNKNOWN} e_PROCESS_SUSPENSION_STATE_t;

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

Parameters

pcbToFree

pointer to PCB to free

Returns

PCB_ERROR_CODE_t describing result

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;
}

Variable Documentation

linkedList_t blockedQueue

Definition at line 4 of file pcb.c.

Referenced by showAllProcesses(), and showBlockedProcesses().

pcb_t* currentOperatingProcess

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