R2

Files
file	pcb.h
file	linked_list.h

Functions
e_PROCESS_STATE_t	getState (const char *name)
	getState gets the current state of the process 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...
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...
void	printPCBFunc (void *pcb)
	printPCBFunc prints the status of a process More...
void	setPrintFunction (linkedList_t *list, void(*newPrintFunc)(void *))
	sets the function whose job it is to print the list to the screen. More...

Detailed Description

This grouping provides a quick access to all development that occured during module R2. Each function or file that was added during this module can be found here.

Function Documentation

e_PCB_ERROR_CODE_t changeProcessState	(	const char *	processName,
		e_PROCESS_STATE_t	state
	)

changeProcessState changes the state of the process being called

Parameters

name	the name of the process to change the state of
state	the state to change the process to

Returns

e_PCB_ERROR_CODE_t value that describes the result

Definition at line 168 of file pcb.c.

References BLOCKED, ERROR_PCB_NOT_FOUND, ERROR_STATE_INVALID, findPCB(), INITIAL, insertPCB(), prevPCBError, READY, removePCB(), RUNNING, SUCCESS, and TERMINAL.

Referenced by blockPCB(), and unblockPCB().

{
    prevPCBError=SUCCESS;

    if (newState != INITIAL && newState != READY && newState != RUNNING &&
            newState != BLOCKED && newState != TERMINAL)
    {
        prevPCBError=ERROR_STATE_INVALID;
        return ERROR_STATE_INVALID;
    }

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

    process->processState = newState;

    removePCB(process);
    insertPCB(process);

    return prevPCBError;
}

const char* classToString

(

e_PROCESS_CLASS_t

processClass

)

classToString creates a string form of the class passed in

Parameters

class

the class to parse to a string

Returns

the const char* of the class

Definition at line 289 of file pcb.c.

References CLASS_UNKNOWN, SYSTEM, and USER_APP.

Referenced by printPCBFunc().

{
    switch(processClass)
    {
        case SYSTEM: return "System";
        case USER_APP: return "User-App";
        case CLASS_UNKNOWN: return "Class Unknown";
        default: return "Error parsing class code";
    }
    return "Error parsing class code";
}

const char* errorToString

(

e_PCB_ERROR_CODE_t

error

)

errorToString creates a string form of the error passed in

Parameters

error

the error to parse to a string

Returns

the const char* of the error

Definition at line 267 of file pcb.c.

References ERROR, ERROR_ALLOCATING_NODE, ERROR_CLASS_INVALID, ERROR_FREEING_NODE, ERROR_FREEING_PCB, ERROR_FREEING_STACK, ERROR_INSERTING_PCB, ERROR_NAME_COLLISION, ERROR_NAME_INVALID, ERROR_PCB_NOT_FOUND, ERROR_PRIORITY_INVALID, ERROR_REMOVING_PCB, ERROR_STATE_INVALID, and SUCCESS.

Referenced by blockPCB(), createPCB(), deletePCB(), resumePCB(), setPriority(), showPCB(), suspendPCB(), and unblockPCB().

{
    switch(error)
    {
        case SUCCESS: return "Success";
        case ERROR: return "Error";
        case ERROR_PCB_NOT_FOUND: return "Error: PCB not found";
        case ERROR_NAME_INVALID: return "Error: name invalid";
        case ERROR_PRIORITY_INVALID: return "Error: priority invalid";
        case ERROR_FREEING_NODE: return "Error freeing node";
        case ERROR_FREEING_STACK: return "Error freeing stack";
        case ERROR_FREEING_PCB: return "Error freeing PCB";
        case ERROR_REMOVING_PCB: return "Error removing PCB";
        case ERROR_STATE_INVALID: return "Error: State Invalid";
        case ERROR_CLASS_INVALID: return "Error: Class Invalid";
        case ERROR_ALLOCATING_NODE: return "Error Allocating Node";
        case ERROR_NAME_COLLISION: return "Error: PCB Name Already in Use";
        case ERROR_INSERTING_PCB: return "Error: PCB States have resulted in invalid transition";
        default: return "Error parsing error code";
    }
}

e_PROCESS_STATE_t getState

(

const char *

name

)

getState gets the current state of the process

Parameters

name	the name of the process

Returns

e_PROCESS_STATE_t the state of the process

Definition at line 210 of file pcb.c.

References findPCB(), prevPCBError, and SUCCESS.

{
    prevPCBError=SUCCESS;
    pcb_t* process = findPCB(name);
    return process->processState;
}

void printPCBFunc

(

void *

pcb

)

printPCBFunc prints the status of a process

Parameters

pcb	void pointer to a process

Definition at line 335 of file pcb.c.

References classToString(), printf, stateToString(), and suspensionToString().

Referenced by initPCBQueues(), setPriority(), and showPCB().

{
    printf("PCB: %s | Priority: %d | Class: %s | State: %s | Suspension Status: %s\r\n",
              ((pcb_t*)pcb)->name, ((pcb_t*)pcb)->priority, classToString(((pcb_t*)pcb)->processClass),
              stateToString(((pcb_t*)pcb)->processState), suspensionToString(((pcb_t*)pcb)->processSuspensionState));
}

void setPrintFunction	(	linkedList_t *	list,
		void(*)(void *)	newPrintFunc
	)

sets the function whose job it is to print the list to the screen.

Parameters

list	to set the search funtion for
newPrintFunc	pointer to function whose job is to print the data contained in the node. The argument of this function is the data conatined in the node. Traversal of the list starts one after the head and goes to the node before the tail.

Definition at line 207 of file linked_list.c.

Referenced by initHeap(), initPCBQueues(), and listTest().

{
    list->printNodeFunc = newPrintFunc;
}

const char* stateToString

(

e_PROCESS_STATE_t

state

)

stateToString creates a string form of the state passed in

Parameters

state

the state to parse to a string

Returns

the const char* of the state

Definition at line 301 of file pcb.c.

References BLOCKED, INITIAL, READY, RUNNING, STATE_UNKNOWN, and TERMINAL.

Referenced by printPCBFunc().

{
    switch(state)
    {
        case INITIAL: return "Initial";
        case READY: return "Ready";
        case RUNNING: return "Running";
        case BLOCKED: return "Blocked";
        //case SUSPENDED_READY: return "Suspended-ready";
        //case SUSPENDED_BLOCKED: return "Suspened-blocked";
        case TERMINAL: return "Terminal";
        case STATE_UNKNOWN: return "State unknown";
        default: return "Error parsing state code";
    }
}

e_PROCESS_CLASS_t stringToClass

(

const char *

stringifiedClass

)

stringToClass returns the enum representation of a string

Parameters

stringifiedClass

the string that represents a process class enum

Returns

string represenation of the e_PROCESS_STATE_t enum, returns value CLASS_UNKNOWN if error in processing occurs;

Definition at line 328 of file pcb.c.

References CLASS_UNKNOWN, strcmp(), SYSTEM, and USER_APP.

Referenced by createPCB().

{
    if(!strcmp("System", stringifiedClass)){ return SYSTEM; }
    if(!strcmp("User-App", stringifiedClass)){ return USER_APP; }
    return CLASS_UNKNOWN;
}