oc_processman.c

Go to the documentation of this file.

#include <oc_processman.h>
#include <oc_threadman.h>
#include <string.h>
#include <oc_system_cfg.h>
#include <oc_userman.h>
#include <oc_debug.h>
#include <oc_intman.h>
#include <oc_module.h>

#define _________________________________________VARIABLES_SECTION_________________________________________________________________________

static oC_UInt_t                    NextPid            = 0;
static oC_UInt_t                    SomeProcessToDelete= false;
static oC_Thread_t                  DeleteDeamonThread = NULL;
static oC_Process_t                 DeleteDeamonProcess= NULL;
static oC_List(oC_Process_t)        Processes          = NULL;
static const oC_Allocator_t         Allocator          = {
                .Name           = "Process Manager" ,
                .EventFlags     = 0 ,
                .EventHandler   = NULL
};
const oC_Module_Registration_t ProcessMan = {
                .Name                   = "Process Manager" ,
                .Module                 = oC_Module_ProcessMan ,
                .TurnOnFunction         = oC_ProcessMan_TurnOn ,
                .TurnOffFunction        = oC_ProcessMan_TurnOff ,
                .RequiredModules        = { oC_Module_ThreadMan }
};

#undef  _________________________________________VARIABLES_SECTION_________________________________________________________________________

#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_ProcessMan_TurnOn( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOffVerification(&errorCode, oC_Module_ProcessMan))
    {
        Processes = oC_List_New(&Allocator,AllocationFlags_NoWait);

        if(Processes)
        {
            SomeProcessToDelete = false;
            DeleteDeamonThread  = NULL;
            DeleteDeamonProcess = NULL;
            NextPid             = 0;
            errorCode           = oC_ErrorCode_None;
            oC_Module_TurnOn(oC_Module_ProcessMan);
        }
        else
        {
            errorCode = oC_ErrorCode_AllocationError;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_ProcessMan_TurnOff( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(oC_Module_TurnOnVerification(&errorCode, oC_Module_ProcessMan))
    {
        oC_Module_TurnOff(oC_Module_ProcessMan);
        errorCode = oC_ErrorCode_None;

        oC_List_Foreach(Processes,process)
        {
            if(oC_Process_Delete(&process) == false)
            {
                errorCode = oC_ErrorCode_CannotDeleteProcess;
            }
        }
        if(oC_List_Delete(Processes,AllocationFlags_CanWaitForever) == false)
        {
            errorCode = oC_ErrorCode_ReleaseError;
        }
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_ProcessMan_AddProcess( oC_Process_t Process )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_Module_TurnOnVerification(&errorCode, oC_Module_ProcessMan)
     && oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process) , oC_ErrorCode_ObjectNotCorrect)
        )
    {
        bool added = oC_List_PushBack(Processes,Process,&Allocator);

        if(added)
        {
            errorCode = oC_ErrorCode_None;
        }
        else
        {
            errorCode = oC_ErrorCode_CannotAddObjectToList;
        }
    }

    return errorCode;
}

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

    if(
        oC_Module_TurnOnVerification(&errorCode, oC_Module_ProcessMan)
     && oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(Process) , oC_ErrorCode_ObjectNotCorrect)
        )
    {
        bool contains = oC_List_Contains(Processes,Process);

        if(contains)
        {
            bool removed = oC_List_RemoveAll(Processes,Process);

            if(removed)
            {
                errorCode = oC_ErrorCode_None;
            }
            else
            {
                errorCode = oC_ErrorCode_CannotRemoveObjectFromList;
            }
        }
        else
        {
            errorCode = oC_ErrorCode_ObjectNotFoundOnList;
        }
    }

    return errorCode;
}


//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ProcessMan_ContainsProcess( oC_Process_t Process )
{
    bool contains = false;

    if(
        oC_SaveIfFalse("ProcessMan", oC_Module_IsTurnedOn(oC_Module_ProcessMan) , oC_ErrorCode_ModuleNotStartedYet  )
     && oC_SaveIfFalse("Process"   , oC_Process_IsCorrect(Process)              , oC_ErrorCode_ObjectNotCorrect     )
        )
    {
        contains = oC_List_Contains(Processes,Process);
    }

    return contains;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_ProcessMan_GetList( oC_List(oC_Process_t) List )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_Module_TurnOnVerification(&errorCode, oC_Module_ProcessMan)
        )
    {
        errorCode = oC_ErrorCode_None;

        oC_List_Clear(List);

        oC_List_Foreach(Processes,process)
        {
            bool added = oC_List_PushBack(List,process,&Allocator);

            if(added == false)
            {
                errorCode = oC_ErrorCode_CannotAddObjectToList;
            }
        }
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_ProcessMan_GetUserProcesses( oC_User_t User , oC_List(oC_Process_t) List )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_Module_TurnOnVerification(&errorCode, oC_Module_ProcessMan) &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_List_IsCorrect(List) ,    oC_ErrorCode_ListNotCorrect)
        )
    {
        errorCode = oC_ErrorCode_None;

        oC_List_Clear(List);

        oC_List_Foreach(Processes,process)
        {
            if(oC_Process_GetUser(process) == User)
            {
                bool added = oC_List_PushBack(List,process,&Allocator);

                if(added == false)
                {
                    errorCode = oC_ErrorCode_CannotAddObjectToList;
                }
            }
        }
    }

    return errorCode;
}
//==========================================================================================================================================
//==========================================================================================================================================
oC_Process_t oC_ProcessMan_GetCurrentProcess( void )
{
    oC_Process_t currentProcess = NULL;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        oC_Thread_t currentThread = oC_ThreadMan_GetCurrentThread();

        oC_List_Foreach(Processes,process)
        {
            if(oC_Process_ContainsThread(process,currentThread))
            {
                currentProcess = process;
                break;
            }
        }
    }

    return currentProcess;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Process_t oC_ProcessMan_GetProcess( const char * Name )
{
    oC_Process_t processToReturn = NULL;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        oC_List_Foreach(Processes,process)
        {
            if(strcmp(oC_Process_GetName(process),Name) == 0)
            {
                processToReturn = process;
                break;
            }
        }
    }

    return processToReturn;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Process_t oC_ProcessMan_GetProcessById( oC_UInt_t PID )
{
    oC_Process_t processToReturn = NULL;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        oC_List_Foreach(Processes,process)
        {
            if(oC_Process_GetPid(process) == PID)
            {
                processToReturn = process;
                break;
            }
        }
    }

    return processToReturn;
}

//==========================================================================================================================================
//==========================================================================================================================================
Allocator_t oC_ProcessMan_GetCurrentAllocator( void )
{
    Allocator_t allocator = NULL;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        oC_IntMan_EnterCriticalSection();
        oC_Process_t currentProcess = oC_ProcessMan_GetCurrentProcess();
        oC_IntMan_ExitCriticalSection();

        if(currentProcess)
        {
            oC_IntMan_EnterCriticalSection();
            allocator = oC_Process_GetAllocator(currentProcess);
            oC_IntMan_ExitCriticalSection();
        }
    }

    return allocator;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Process_t oC_ProcessMan_GetProcessOfThread( oC_Thread_t Thread )
{
    oC_Process_t process = NULL;

    if(oC_Thread_IsCorrect(Thread))
    {
        oC_List_Foreach(Processes,proc)
        {
            if(oC_Process_ContainsThread(proc,Thread))
            {
                process = proc;
                break;
            }
        }
    }
    else
    {
        oC_SaveError("Process manager" , oC_ErrorCode_ObjectNotCorrect);
    }

    return process;
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_ProcessMan_RawAllocate( oC_UInt_t Size , const char * Function, uint32_t LineNumber , AllocationFlags_t Flags )
{
    void * address = NULL;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        oC_Process_t currentProcess = oC_ProcessMan_GetCurrentProcess();

        if(currentProcess)
        {
            oC_HeapMap_t heapMap = oC_Process_GetHeapMap(currentProcess);

            if(heapMap)
            {
                address = oC_MemMan_RawAllocate(heapMap,Size,Function,LineNumber,Flags);
            }
        }
    }

    return address;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ProcessMan_RawFree( void * Address , oC_UInt_t Size )
{
    bool released = false;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        oC_Process_t currentProcess = oC_ProcessMan_GetCurrentProcess();

        if(currentProcess)
        {
            oC_HeapMap_t heapMap = oC_Process_GetHeapMap(currentProcess);

            if(heapMap)
            {
                released = oC_MemMan_RawFree(heapMap,Address,Size);
            }
        }
    }

    return released;
}
//==========================================================================================================================================
//==========================================================================================================================================
void * oC_ProcessMan_Allocate( oC_UInt_t Size , const char * Function, uint32_t LineNumber , AllocationFlags_t Flags )
{
    void * address = NULL;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        Allocator_t allocator = oC_ProcessMan_GetCurrentAllocator();

        if(allocator)
        {
            address = oC_MemMan_Allocate(Size,allocator,Function,LineNumber,Flags,0);
        }
    }

    return address;
}
//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ProcessMan_Free( void * Address , AllocationFlags_t Flags )
{
    bool released = false;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        released = oC_MemMan_Free(Address,Flags);
    }

    return released;
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_ProcessMan_SmartAllocate( oC_UInt_t Size, const char * Function, uint32_t LineNumber , AllocationFlags_t Flags )
{
    void * address = NULL;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        oC_UInt_t realRawAllocationSize = Size + (Size/8) + ((Size%8) > 0) ? 1 : 0;
        oC_UInt_t realAllocationSize    = Size + oC_MemMan_GetAllocationBlockSize();

        if(realAllocationSize >= realRawAllocationSize)
        {
            address = oC_ProcessMan_RawAllocate(Size,Function,LineNumber,Flags);
        }
        if(address == NULL)
        {
            address = oC_ProcessMan_Allocate(Size,Function,LineNumber,Flags);
        }
    }

    return address;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ProcessMan_SmartFree( void * Address , oC_UInt_t Size , AllocationFlags_t Flags )
{
    bool released = false;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        released = oC_ProcessMan_RawFree(Address,Size);

        if(!released)
        {
            released = oC_ProcessMan_Free(Address,Flags);
        }
    }

    return released;
}

//==========================================================================================================================================
//==========================================================================================================================================
void * oC_ProcessMan_KernelSmartAllocate( oC_UInt_t Size , Allocator_t Allocator , const char * Function, uint32_t LineNumber , AllocationFlags_t Flags )
{
    void * address = oC_ProcessMan_SmartAllocate(Size,Function,LineNumber,Flags);

    if(address == NULL)
    {
        address = _kmalloc(Size,Allocator,Function,LineNumber,Flags,0);
    }

    return address;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ProcessMan_KernelSmartFree( void * Address , oC_UInt_t Size , AllocationFlags_t Flags )
{
    bool released = oC_ProcessMan_SmartFree(Address,Size,Flags);

    if(released == false)
    {
        released = kfree(Address,Flags);
    }

    return released;
}

//==========================================================================================================================================
//==========================================================================================================================================
void oC_ProcessMan_DeleteDeamon( void * Parameter )
{
    oC_Thread_t currentThread = oC_ThreadMan_GetCurrentThread();
    oC_MEM_LLD_SetMemoryAccessMode(oC_MEM_LLD_MemoryAccessMode_Privileged);
    while(1)
    {
        oC_IntMan_EnterCriticalSection();
        SomeProcessToDelete = false;
        if(oC_Thread_SetBlocked(currentThread,&SomeProcessToDelete,oC_Thread_Unblock_WhenEqual,true,oC_Thread_UnblockMask_All,oC_hour(1))==false)
        {
            kdebuglog(oC_LogType_Error , "DeleteDeamon: cannot block current thread\n");
        }
        oC_IntMan_ExitCriticalSection();

        while(oC_Thread_IsBlocked(currentThread));

        oC_Thread_SetUnblocked(currentThread);

        oC_List_Foreach(Processes,process)
        {
            if(oC_Process_IsKilled(process))
            {
                oC_Process_t    copy      = process;
                oC_ErrorCode_t  errorCode = oC_ProcessMan_RemoveProcess(process);

                if(oC_ErrorOccur(errorCode))
                {
                    oC_SaveError("DeleteDeamon: Cannot delete process from the list: " , errorCode );
                }

                if(oC_Process_Delete(&process)==false)
                {
                    oC_SaveError(oC_Process_GetName(copy),oC_ErrorCode_CannotDeleteProcess);
                }
            }
        }
    }
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_ProcessMan_RunDeleteDaemon( void )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_Module_TurnOnVerification(&errorCode, oC_Module_ProcessMan)      &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Thread_IsCorrect(DeleteDeamonThread)  == false , oC_ErrorCode_DaemonThreadAlreadyExists ) &&
        oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(DeleteDeamonProcess)== false , oC_ErrorCode_DaemonProcessAlreadyExists)
        )
    {
        DeleteDeamonProcess = oC_Process_New(oC_Process_Priority_SystemHandlerDeamon,"delete daemon",oC_UserMan_GetRootUser(),0,NULL,NULL,NULL);

        if(oC_Process_IsCorrect(DeleteDeamonProcess))
        {
            DeleteDeamonThread = oC_Thread_New(oC_Process_Priority_SystemHandlerDeamon,CFG_BYTES_DELETE_DEAMON_STACK_SIZE,DeleteDeamonProcess,"delete daemon",oC_ProcessMan_DeleteDeamon,NULL);

            if(oC_Thread_IsCorrect(DeleteDeamonThread))
            {
                if(oC_Thread_Run(DeleteDeamonThread))
                {
                    errorCode = oC_ProcessMan_AddProcess(DeleteDeamonProcess);
                }
                else
                {
                    if(oC_Process_Delete(&DeleteDeamonProcess)==false)
                    {
                        oC_SaveError("Cannot delete daemon process: ",oC_ErrorCode_ReleaseError);
                    }

                    if(oC_Thread_Delete(&DeleteDeamonThread)==false)
                    {
                        oC_SaveError("Cannot delete daemon thread: ",oC_ErrorCode_ReleaseError);
                    }

                    errorCode = oC_ErrorCode_CannotRunThread;
                }
            }
            else
            {
                if(oC_Process_Delete(&DeleteDeamonProcess)==false)
                {
                    oC_SaveError("Cannot delete daemon process: ",oC_ErrorCode_ReleaseError);
                }
                errorCode = oC_ErrorCode_CannotCreateThread;
            }
        }
        else
        {
            errorCode = oC_ErrorCode_CannotCreateProcess;
        }
    }


    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
void oC_ProcessMan_ActivateDeleteDeamon( void )
{
    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan) && oC_Process_IsCorrect(DeleteDeamonProcess))
    {
        SomeProcessToDelete = true;
    }
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_UInt_t oC_ProcessMan_GetNextPid( void )
{
    oC_UInt_t pid = 0;

    if(oC_Module_IsTurnedOn(oC_Module_ProcessMan))
    {
        do
        {
            pid = ++NextPid;

            oC_List_Foreach(Processes,process)
            {
                if(oC_Process_GetPid(process)==pid)
                {
                    pid = 0;
                    break;
                }
            }
        } while(pid == 0);
    }

    return pid;
}

//==========================================================================================================================================
//==========================================================================================================================================
void oC_ProcessMan_KillAllZombies( void )
{
    oC_List_Foreach(Processes,process)
    {
        if(oC_Process_GetState(process) == oC_Process_State_Zombie)
        {
            oC_Process_Kill(process);
        }
    }
}


#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________