oc_process.c

Go to the documentation of this file.

#include <oc_process.h>
#include <oc_memman.h>
#include <oc_user.h>
#include <oc_object.h>
#include <oc_list.h>
#include <oc_system_cfg.h>
#include <oc_threadman.h>
#include <oc_intman.h>
#include <oc_stdtypes.h>
#include <oc_system.h>
#include <oc_ktime.h>
#include <oc_processman.h>
#include <string.h>
#include <oc_vfs.h>
#include <oc_mutex.h>
#include <oc_udp.h>
#include <oc_icmp.h>
#include <oc_tcp.h>
#include <oc_exchan.h>

#define _________________________________________TYPES_SECTION______________________________________________________________________________

struct Process_t
{
    oC_ObjectControl_t          ObjectControl;
    oC_Process_Priority_t       Priority;
    const char *                Name;
    oC_User_t                   User;
    oC_Stream_t                 InputStream;
    oC_Stream_t                 OutputStream;
    oC_Stream_t                 ErrorStream;
    oC_Allocator_t              Allocator;
    bool                        Killed;
    oC_HeapMap_t                HeapMap;
    oC_IoFlags_t                IoFlags;
    char *                      Pwd;
    oC_UInt_t                   Pid;
    void *                      StdioBuffer;
    oC_Mutex_t                  StdioMutex;
};

#undef  _________________________________________TYPES_SECTION______________________________________________________________________________

#define _________________________________________PROTOTYPES_SECTION_________________________________________________________________________

static void MemoryFaultHandler( void * Address , MemoryEventFlags_t Event , const char * Function, uint32_t LineNumber );

#undef  _________________________________________PROTOTYPES_SECTION_________________________________________________________________________


#define _________________________________________VARIABLES_SECTION__________________________________________________________________________

static const oC_Allocator_t Allocator = {
                .Name           = "process" ,
                .EventHandler   = MemoryFaultHandler ,
                .EventFlags     = MemoryEventFlags_BufferOverflow       |
                                  MemoryEventFlags_DataSectionOverflow  |
                                  MemoryEventFlags_MemoryExhausted      |
                                  MemoryEventFlags_PanicMemoryExhausted |
                                  MemoryEventFlags_PossibleMemoryLeak
};

#undef  _________________________________________VARIABLES_SECTION__________________________________________________________________________


#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_Process_t oC_Process_New( oC_Process_Priority_t Priority , const char * Name , oC_User_t User , oC_UInt_t HeapMapSize, oC_Stream_t InputStream , oC_Stream_t OutputStream , oC_Stream_t ErrorStream )
{
    oC_Process_t process = NULL;

    if(
        oC_MemMan_IsAddressCorrect(Name) &&
        oC_User_IsCorrect(User)
        )
    {
        if(InputStream != NULL && !oC_Stream_IsType(InputStream , oC_Stream_Type_Input))
        {
            oC_SaveError(Name,oC_ErrorCode_StreamTypeNotCorrect);
        }
        if(OutputStream != NULL && !oC_Stream_IsType(OutputStream , oC_Stream_Type_Output))
        {
            oC_SaveError(Name,oC_ErrorCode_StreamTypeNotCorrect);
        }
        if(ErrorStream != NULL && !oC_Stream_IsType(ErrorStream , oC_Stream_Type_Output))
        {
            oC_SaveError(Name,oC_ErrorCode_StreamTypeNotCorrect);
        }

        process = kmalloc(sizeof(struct Process_t) , &Allocator , AllocationFlags_CanWait1Second);

        if(process)
        {
            oC_Process_t currentProcess     = oC_ProcessMan_GetCurrentProcess();
            process->ObjectControl          = oC_CountObjectControl(process,oC_ObjectId_Process);
            process->ErrorStream            = ErrorStream;
            process->InputStream            = InputStream;
            process->Name                   = Name;
            process->OutputStream           = OutputStream;
            process->Priority               = Priority;
            process->User                   = User;
            process->Allocator.Name         = Name;
            process->Allocator.EventHandler = MemoryFaultHandler;
            process->Allocator.EventFlags   = MemoryEventFlags_AllErrors;
            process->Killed                 = false;
            process->IoFlags                = oC_IoFlags_Default;
            process->HeapMap                = oC_MemMan_AllocateHeapMap(HeapMapSize,&process->Allocator,oC_FUNCTION,__LINE__,AllocationFlags_CanWait1Second);
            process->Pwd                    = oC_Process_GetPwd(currentProcess);
            process->Pid                    = oC_ProcessMan_GetNextPid();
            process->StdioBuffer            = kmalloc(CFG_BYTES_STDIO_BUFFER_SIZE * sizeof(char) , &process->Allocator , AllocationFlags_CanWait1Second);
            process->StdioMutex             = oC_Mutex_New(oC_Mutex_Type_Normal,&process->Allocator,AllocationFlags_CanWait1Second);
        }
    }

    return process;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Process_Delete( oC_Process_t * Process )
{
    bool deleted = false;

    if(oC_Process_IsCorrect(*Process) && oC_Process_Kill(*Process))
    {
        (*Process)->ObjectControl = 0;
        deleted                   = true;

        oC_ErrorCode_t errorCode = oC_VirtualFileSystem_fcloseFromProcess(*Process);

        if(oC_ErrorOccur(errorCode))
        {
            oC_SaveError("Process delete - VFS error" , errorCode );
            deleted = false;
        }

        errorCode = oC_Udp_ReleaseAllPortsReservedBy(*Process,s(2));

        if(oC_ErrorOccur(errorCode))
        {
            oC_SaveError("Process delete - UDP error - " , errorCode );
            deleted = false;
        }

        errorCode = oC_Icmp_ReleaseAllTypesReservedBy(*Process,s(2));

        if(oC_ErrorOccur(errorCode))
        {
            oC_SaveError("Process delete - ICMP error - " , errorCode );
            deleted = false;
        }

        errorCode = oC_Tcp_CloseProcess(*Process,s(2));

        if(oC_ErrorOccur(errorCode))
        {
            oC_SaveError("Process delete - TCP error - " , errorCode );
            deleted = false;
        }

        if(!oC_Mutex_Delete(&((*Process)->StdioMutex),AllocationFlags_CanWait1Second))
        {
            oC_SaveError("Process: Cannot delete StdioMutex",oC_ErrorCode_CannotDeleteObject);
            deleted = false;
        }

        if(oC_MemMan_FreeAllMemoryOfAllocator(&(*Process)->Allocator)==false)
        {
            oC_SaveError("Process delete - Error when releasing memory of allocator: " , oC_ErrorCode_ReleaseError);
            deleted = false;
        }

        if(kfree(*Process,AllocationFlags_CanWaitForever)==false)
        {
            oC_SaveError("Process delete - cannot release process memory" , oC_ErrorCode_ReleaseError);
            deleted  = false;
        }
        else
        {
            *Process = NULL;
        }

    }

    return deleted;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Process_IsCorrect( oC_Process_t Process )
{
    return isram(Process) && oC_CheckObjectControl(Process,oC_ObjectId_Process,Process->ObjectControl);
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Process_IsKilled( oC_Process_t Process )
{
    return oC_Process_IsCorrect(Process) && Process->Killed;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Process_ContainsThread( oC_Process_t Process , oC_Thread_t Thread )
{
    bool contains = false;

    if(oC_Process_IsCorrect(Process) && oC_Thread_IsCorrect(Thread))
    {
        contains = oC_MemMan_GetAllocatorOfAddress(Thread) == &Process->Allocator;
    }

    return contains;
}

//==========================================================================================================================================
//==========================================================================================================================================
const char * oC_Process_GetName( oC_Process_t Process )
{
    const char * name = "unknown";

    if(oC_Process_IsCorrect(Process))
    {
        name = Process->Name;
    }

    return name;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Process_State_t oC_Process_GetState( oC_Process_t Process )
{
    oC_Process_State_t state = oC_Process_State_Invalid;

    if(oC_Process_IsCorrect(Process))
    {
        oC_IntMan_EnterCriticalSection();
        oC_List(oC_Thread_t) threads = oC_ThreadMan_GetList();

        if(threads)
        {
            if(Process->Killed)
            {
                state = oC_Process_State_Killed;
            }
            else
            {
                state = oC_Process_State_Initialized;
            }

            uint32_t numberOfthreads = 0;

            oC_List_Foreach(threads,thread)
            {
                if(oC_Process_ContainsThread(Process,thread))
                {
                    numberOfthreads++;

                    if(Process->Killed)
                    {
                        state = oC_Process_State_Zombie;
                    }
                    else if(oC_Thread_IsBlocked(thread))
                    {
                        state = oC_Process_State_Asleep;
                    }
                    else
                    {
                        state = oC_Process_State_Run;
                        break;
                    }
                }
            }

            if(numberOfthreads == 0)
            {
                state = oC_Process_State_Zombie;
            }
        }
        oC_IntMan_ExitCriticalSection();
    }

    return state;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_User_t oC_Process_GetUser( oC_Process_t Process )
{
    oC_User_t user = NULL;

    if(oC_Process_IsCorrect(Process))
    {
        user = Process->User;
    }

    return user;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Stream_t oC_Process_GetInputStream( oC_Process_t Process )
{
    oC_Stream_t stream = NULL;

    if(oC_Process_IsCorrect(Process))
    {
        stream = Process->InputStream;
    }

    return stream;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Stream_t oC_Process_GetOutputStream( oC_Process_t Process )
{
    oC_Stream_t stream = NULL;

    if(oC_Process_IsCorrect(Process))
    {
        stream = Process->OutputStream;
    }

    return stream;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Stream_t oC_Process_GetErrorStream( oC_Process_t Process )
{
    oC_Stream_t stream = NULL;

    if(oC_Process_IsCorrect(Process))
    {
        stream = Process->ErrorStream;
    }

    return stream;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_SetInputStream( oC_Process_t Process , oC_Stream_t Stream )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process) ,                  oC_ErrorCode_ProcessNotCorrect) &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Stream_IsCorrect(Stream) ,                    oC_ErrorCode_StreamNotCorrect) &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Stream_IsType(Stream,oC_Stream_Type_Input) ,  oC_ErrorCode_StreamTypeNotCorrect)
        )
    {
        errorCode            = oC_ErrorCode_None;
        Process->InputStream = Stream;
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_SetOutputStream( oC_Process_t Process , oC_Stream_t Stream )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process) ,                  oC_ErrorCode_ProcessNotCorrect) &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Stream_IsCorrect(Stream) ,                    oC_ErrorCode_StreamNotCorrect) &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Stream_IsType(Stream,oC_Stream_Type_Output) , oC_ErrorCode_StreamTypeNotCorrect)
        )
    {
        errorCode            = oC_ErrorCode_None;
        Process->OutputStream= Stream;
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_SetErrorStream( oC_Process_t Process , oC_Stream_t Stream )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process) ,                  oC_ErrorCode_ProcessNotCorrect) &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Stream_IsCorrect(Stream) ,                    oC_ErrorCode_StreamNotCorrect) &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Stream_IsType(Stream,oC_Stream_Type_Output) , oC_ErrorCode_StreamTypeNotCorrect)
        )
    {
        errorCode            = oC_ErrorCode_None;
        Process->ErrorStream = Stream;
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_SetPriority( oC_Process_t Process , oC_Process_Priority_t Priority )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(ErrorCondition( oC_Process_IsCorrect(Process) , oC_ErrorCode_ProcessNotCorrect    ))
    {
        Process->Priority   = Priority;
        errorCode           = oC_ErrorCode_None;
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Process_Priority_t oC_Process_GetPriority( oC_Process_t Process )
{
    return oC_Process_IsCorrect(Process) ? Process->Priority : 0;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_LockStdioBuffer( oC_Process_t Process , char ** outStdioBuffer , oC_Time_t Timeout )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        ErrorCondition(oC_Process_IsCorrect(Process)            ,oC_ErrorCode_ProcessNotCorrect) &&
        ErrorCondition(oC_MemMan_IsRamAddress(outStdioBuffer)   ,oC_ErrorCode_OutputAddressNotInRAM)
        )
    {
        if(oC_Mutex_Take(Process->StdioMutex,Timeout))
        {
            *outStdioBuffer = Process->StdioBuffer;
            errorCode       = oC_ErrorCode_None;

            memset(Process->StdioBuffer,0,CFG_BYTES_STDIO_BUFFER_SIZE * sizeof(char));
        }
        else
        {
            errorCode = oC_ErrorCode_TimeoutError;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_UnlockStdioBuffer( oC_Process_t Process )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(ErrorCondition(oC_Process_IsCorrect(Process) ,oC_ErrorCode_ProcessNotCorrect))
    {
        if(oC_Mutex_Give(Process->StdioMutex))
        {
            errorCode = oC_ErrorCode_None;
        }
        else
        {
            errorCode = oC_ErrorCode_ReleasingMutexError;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Process_IsActive( oC_Process_t Process )
{
    bool active = false;

    if(oC_Process_IsCorrect(Process))
    {
        oC_IntMan_EnterCriticalSection();
        oC_List(oC_Thread_t) threads = oC_ThreadMan_GetList();

        foreach(threads,thread)
        {
            if(oC_Process_ContainsThread(Process,thread))
            {
                active = true;
                break;
            }
        }
        oC_IntMan_ExitCriticalSection();
    }

    return active;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Process_Kill( oC_Process_t Process )
{
    bool allKilled = false;

    if(oC_Process_IsCorrect(Process))
    {
        oC_IntMan_EnterCriticalSection();
        Process->Killed = true;
        allKilled       = true;

        oC_ProcessMan_ActivateDeleteDeamon();

        oC_List(oC_Thread_t) threads = oC_ThreadMan_GetList();

        if(threads)
        {
            oC_List_Foreach(threads,thread)
            {
                if(oC_Process_ContainsThread(Process,thread))
                {
                    if(oC_Thread_Cancel(&thread)==false)
                    {
                        allKilled = false;
                    }
                }
            }

            oC_List_Foreach(threads,thread)
            {
                if(oC_Process_ContainsThread(Process,thread))
                {
                    if(oC_Thread_IsCorrect(thread))
                    {
                        oC_List_RemoveAll(threads,thread);
                    }
                }
            }
        }
        oC_IntMan_ExitCriticalSection();

    }

    return allKilled;
}

//==========================================================================================================================================
//==========================================================================================================================================
Allocator_t oC_Process_GetAllocator( oC_Process_t Process )
{
    Allocator_t allocator = NULL;

    if(oC_Process_IsCorrect(Process))
    {
        allocator = &Process->Allocator;
    }

    return allocator;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_HeapMap_t oC_Process_GetHeapMap( oC_Process_t Process )
{
    oC_HeapMap_t heapMap = NULL;

    if(oC_Process_IsCorrect(Process))
    {
        heapMap = Process->HeapMap;
    }

    return heapMap;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_Sleep( oC_Process_t Process , oC_Time_t Timeout )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process) , oC_ErrorCode_ObjectNotCorrect))
    {
        errorCode = oC_ErrorCode_None;

        oC_List(oC_Thread_t) threads = oC_ThreadMan_GetList();

        if(threads)
        {
            oC_List_Foreach(threads,thread)
            {
                oC_IntMan_EnterCriticalSection();
                if(oC_Process_ContainsThread(Process,thread))
                {
                    if(oC_Thread_IsBlocked(thread) == false)
                    {
                        oC_Thread_Sleep(thread,Timeout);
                    }
                }
                oC_IntMan_ExitCriticalSection();
            }
        }

    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_UInt_t oC_Process_GetHeapMapSize( oC_Process_t Process )
{
    oC_UInt_t size = 0;

    if(oC_Process_IsCorrect(Process))
    {
        size = oC_MemMan_GetHeapMapSize(Process->HeapMap);
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_UInt_t oC_Process_GetFreeHeapMapSize(oC_Process_t Process )
{
    oC_UInt_t size = 0;

    if(oC_Process_IsCorrect(Process))
    {
        size = oC_MemMan_GetFreeHeapMapSize(Process->HeapMap);
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_UInt_t oC_Process_GetThreadsStackSize(oC_Process_t Process )
{
    oC_UInt_t size = 0;

    if(oC_Process_IsCorrect(Process))
    {
        oC_List(oC_Thread_t) threads = oC_ThreadMan_GetList();

        if(threads)
        {
            oC_List_Foreach(threads,thread)
            {
                if(oC_Process_ContainsThread(Process,thread))
                {
                    size += oC_Thread_GetStackSize(thread);
                }
            }
        }
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Int_t oC_Process_GetFreeThreadsStackSize(oC_Process_t Process , bool Current )
{
    oC_Int_t size = 0;

    if(oC_Process_IsCorrect(Process))
    {
        oC_List(oC_Thread_t) threads = oC_ThreadMan_GetList();

        if(threads)
        {
            oC_List_Foreach(threads,thread)
            {
                if(oC_Process_ContainsThread(Process,thread))
                {
                    oC_Int_t threadFreeSize = oC_Thread_GetFreeStackSize(thread,Current);

                    if(threadFreeSize > 0 && size >= 0)
                    {
                        size += threadFreeSize;
                    }
                    else if(threadFreeSize < size)
                    {
                        size = threadFreeSize;
                    }
                }
            }
        }
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Time_t oC_Process_GetExecutionTime( oC_Process_t Process )
{
    oC_Time_t executionTime = 0;

    if(oC_Process_IsCorrect(Process))
    {
        oC_List(oC_Thread_t) threads = oC_ThreadMan_GetList();

        if(threads)
        {
            oC_List_Foreach(threads,thread)
            {
                if(oC_Process_ContainsThread(Process,thread))
                {
                    executionTime += oC_Thread_GetExecutionTime(thread);
                }
            }
        }
    }

    return executionTime;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_UInt_t oC_Process_GetUsedRamSize( oC_Process_t Process )
{
    oC_UInt_t size = 0;

    if(oC_Process_IsCorrect(Process))
    {
        size = oC_MemMan_GetMemoryOfAllocatorSize(&Process->Allocator) + sizeof(struct Process_t);
    }

    return size;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_IoFlags_t oC_Process_GetIoFlags( oC_Process_t Process )
{
    oC_IoFlags_t flags = oC_IoFlags_Default;

    if(oC_Process_IsCorrect(Process))
    {
        flags = Process->IoFlags;
    }

    return flags;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_SetIoFlags( oC_Process_t Process , oC_IoFlags_t IoFlags )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process),oC_ErrorCode_ProcessNotCorrect))
    {
        Process->IoFlags = IoFlags;
        errorCode        = oC_ErrorCode_None;
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_WaitForFinish( oC_Process_t Process , oC_Time_t CheckPeriod , oC_Time_t Timeout )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process),oC_ErrorCode_ProcessNotCorrect))
    {
        errorCode                = oC_ErrorCode_None;
        oC_Process_State_t state = oC_Process_State_Run;
        oC_Time_t timeoutTime    = oC_KTime_GetTimestamp() + Timeout;
        while( state == oC_Process_State_Run || state == oC_Process_State_Asleep || state == oC_Process_State_Initialized )
        {
            sleep(CheckPeriod);

            state = oC_Process_GetState(Process);

            if(oC_KTime_GetTimestamp() >= timeoutTime)
            {
                errorCode = oC_ErrorCode_Timeout;
                break;
            }
        }

    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
char * oC_Process_GetPwd( oC_Process_t Process )
{
    char * pwd = "/";

    if(oC_Process_IsCorrect(Process))
    {
        pwd = Process->Pwd;
    }

    return pwd;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Process_SetPwd( oC_Process_t Process , const char * Pwd )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process) , oC_ErrorCode_ProcessNotCorrect) &&
        oC_AssignErrorCodeIfFalse(&errorCode , isaddresscorrect(Pwd) ,         oC_ErrorCode_WrongAddress)
        )
    {
        uint32_t requiredSize   = 0;
        char *   newRelativePwd = NULL;

        errorCode = oC_VirtualFileSystem_ConvertRelativeToAbsolute(Pwd,NULL,&requiredSize,true);

        if(!oC_ErrorOccur(errorCode))
        {
            newRelativePwd = smartalloc(requiredSize,AllocationFlags_CanWait1Second);

            if(newRelativePwd)
            {
                errorCode = oC_VirtualFileSystem_ConvertRelativeToAbsolute(Pwd,newRelativePwd,&requiredSize,true);

                if(!oC_ErrorOccur(errorCode))
                {
                    errorCode = oC_ErrorCode_None;

                    if(oC_VirtualFileSystem_DirExists(newRelativePwd))
                    {
                        if(oC_MemMan_IsDynamicAllocatedAddress(Process->Pwd))
                        {
                            if(smartfree(Process->Pwd,strlen(Process->Pwd)+1,AllocationFlags_CanWaitForever)==false)
                            {
                                errorCode = oC_ErrorCode_ReleaseError;
                            }
                        }
                        Process->Pwd                 = newRelativePwd;
                    }
                    else
                    {
                        if(smartfree(newRelativePwd,requiredSize,AllocationFlags_CanWait1Second) == false)
                        {
                            oC_SaveError("Process: Set pwd, cannot release newRelativePwd: " , oC_ErrorCode_ReleaseError);
                        }

                        errorCode = oC_ErrorCode_DirectoryNotExists;
                    }

                }
                else
                {
                    if(smartfree(newRelativePwd,requiredSize,AllocationFlags_CanWait1Second) == false)
                    {
                        oC_SaveError("Process: Set pwd, cannot release newRelativePwd: " , oC_ErrorCode_ReleaseError);
                    }
                }
            }
            else
            {
                errorCode = oC_ErrorCode_AllocationError;
            }
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_UInt_t oC_Process_GetPid( oC_Process_t Process )
{
    oC_UInt_t pid = 0;

    if(oC_Process_IsCorrect(Process))
    {
        pid = Process->Pid;
    }

    return pid;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Process_SetAllocationLimit( oC_Process_t Process , oC_MemorySize_t Limit )
{
    bool success = false;

    if(oC_Process_IsCorrect(Process))
    {
        Process->Allocator.Limit = Limit;
        success                  = true;
    }

    return success;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Process_SetAllocationTracking( oC_Process_t Process, bool Enabled )
{
    bool success = false;

    if(oC_Process_IsCorrect(Process))
    {
        if(Enabled)
        {
            Process->Allocator.EventFlags |= MemoryEventFlags_MemoryAllocated | MemoryEventFlags_MemoryReleased;
        }
        else
        {
            Process->Allocator.EventFlags &= ~(MemoryEventFlags_MemoryAllocated | MemoryEventFlags_MemoryReleased);
        }
        success = true;
    }

    return success;
}

#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

#define _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________

static void MemoryFaultHandler( void * Address , MemoryEventFlags_t Event , const char * Function, uint32_t LineNumber )
{
    char tempString[150] = {0};

    sprintf(tempString, "Error in allocation of address '%p' allocated in function %s at line %d (%d bytes)\n", Address, Function, LineNumber, oC_MemMan_GetSizeOfAllocation(Address));

    if(Event & MemoryEventFlags_MemoryFault                  ) oC_ExcHan_LogEvent( "Memory fault flag. Reason is unknown                                                            " , tempString, NULL, NULL, oC_ExcHan_ExceptionType_MemoryAllocationError );
    if(Event & MemoryEventFlags_BusFault                     ) oC_ExcHan_LogEvent( "Bus fault flag.                                                                                 " , tempString, NULL, NULL, oC_ExcHan_ExceptionType_MemoryAllocationError );
    if(Event & MemoryEventFlags_AllocationError              ) oC_ExcHan_LogEvent( "Error while allocation of memory                                                                " , tempString, NULL, NULL, oC_ExcHan_ExceptionType_MemoryAllocationError );
    if(Event & MemoryEventFlags_ReleaseError                 ) oC_ExcHan_LogEvent( "Error while releasing memory (address and allocation line number given in the event arguments)  " , tempString, NULL, NULL, oC_ExcHan_ExceptionType_MemoryAllocationError );
    if(Event & MemoryEventFlags_PossibleMemoryLeak           ) oC_ExcHan_LogEvent( "There is a possibility of memory leak                                                           " , tempString, NULL, NULL, oC_ExcHan_ExceptionType_MemoryAllocationError );
    if(Event & MemoryEventFlags_BufferOverflow               ) oC_ExcHan_LogEvent( "Allocated memory at the given address achieved 'red-zone'                                       " , tempString, NULL, NULL, oC_ExcHan_ExceptionType_MemoryAllocationError );

    if(Event & MemoryEventFlags_MemoryAllocated              ) kdebuglog(oC_LogType_Track, "allocation - %s:%d (%d bytes)", Function,LineNumber, oC_MemMan_GetSizeOfAllocation(Address));
    if(Event & MemoryEventFlags_MemoryReleased               ) kdebuglog(oC_LogType_Track, "release    - %s:%d (%d bytes)", Function,LineNumber, oC_MemMan_GetSizeOfAllocation(Address));
    if(Event & MemoryEventFlags_RawMemoryAllocated           ) kdebuglog(oC_LogType_Track, "allocation - %s:%d (%d bytes)", Function,LineNumber, oC_MemMan_GetSizeOfAllocation(Address));
    if(Event & MemoryEventFlags_RawMemoryReleased            ) kdebuglog(oC_LogType_Track, "release    - %s:%d (%d bytes)", Function,LineNumber, oC_MemMan_GetSizeOfAllocation(Address));

    if(Event & MemoryEventFlags_ModuleTurningOff             ) oC_ExcHan_LogEvent( "The MemMan module is turning off                                                                " , tempString, NULL, NULL, oC_ExcHan_ExceptionType_MemoryAllocationError );
    if(Event & MemoryEventFlags_DataSectionOverflow          ) oC_ExcHan_LogEvent( "Some buffer, that is in the data section was overwritten.                                       " , tempString, NULL, NULL, oC_ExcHan_ExceptionType_MemoryAllocationError );

}

#undef  _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________