pcb.h

Go to the documentation of this file.

#ifndef PCB_H
#define PCB_H

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

#define PROCESS_CONTEXT_SIZE (32) //4*32
#define PROCESS_STACK_SIZE (6000) //bytes
#define PCB_QUEUE_MAX_SIZE (128)
#define PROCESS_MAX_NAME_LENGTH (20)

#define  PROCESS_LOWEST_PRIORITY 0
#define PROCESS_HIGHEST_PRIORITY 9

extern linkedList_t readyQueue;
extern linkedList_t blockedQueue;
extern linkedList_t suspendedReadyQueue;
extern linkedList_t suspendedBlockedQueue;


typedef enum {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}
             e_PCB_ERROR_CODE_t;
extern e_PCB_ERROR_CODE_t prevPCBError;

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

typedef enum {SUSPENDED, NOT_SUSPENDED, SUSPENSION_UNKNOWN} e_PROCESS_SUSPENSION_STATE_t;

typedef enum {SYSTEM, USER_APP, CLASS_UNKNOWN} e_PROCESS_CLASS_t;

typedef struct s_pcb_stuct pcb_t;




extern pcb_t* currentOperatingProcess;





typedef struct s_pcb_list pcbQueue_t;

typedef size_t PID_t;

typedef size_t processPriority_t;

typedef uint8_t programPtr_t;

typedef uint32_t programDataPtr_t;

typedef uint8_t processStack_t;

struct s_pcb_stuct
{
    char name[PROCESS_MAX_NAME_LENGTH];
    PID_t PID;
    size_t priority;

    e_PROCESS_STATE_t processState;
    e_PROCESS_SUSPENSION_STATE_t processSuspensionState;

    e_PROCESS_CLASS_t processClass;

    processContext_t* context;
    processStack_t stack[PROCESS_STACK_SIZE];

    //pcb_queue_t children;

    programPtr_t* programStart;
    size_t programSize;

    programDataPtr_t* dataStart;
    size_t dataSize;

    processStack_t* stackBase;
    processStack_t* stackTop;

    node_t* representingNode;

};

pcb_t* allocatePCB(void);

e_PCB_ERROR_CODE_t freePCB(pcb_t* pcbToFree);

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

pcb_t* findPCB(const char* processName);

void insertPCB(pcb_t* pcbToInsert);

e_PCB_ERROR_CODE_t removePCB(pcb_t* pcbToRemove);

e_PROCESS_STATE_t getState(const char* name);
int pcbSearchFunc(void* pcb,  void* nameToFind);

int priorityInsertFunc(void* pcb1, void* pcb2);

int fifoInsertFunc(void* pcb1, void* pcb2);

void initPCBQueues(void);

void pcbTest(void);

e_PCB_ERROR_CODE_t changeProcessState(const char* processName, e_PROCESS_STATE_t state);

e_PCB_ERROR_CODE_t changeProcessSuspensionState(const char* processName, e_PROCESS_SUSPENSION_STATE_t suspensionState);

const char* errorToString(e_PCB_ERROR_CODE_t error);

const char* classToString(e_PROCESS_CLASS_t processClass);

const char* stateToString(e_PROCESS_STATE_t state);

e_PROCESS_CLASS_t stringToClass(const char * stringifiedClass);

e_PCB_ERROR_CODE_t changeProcessPriority(const char * procName, processPriority_t newPriority);

void printPCBFunc(void* pcb);

#endif // PCB_H