klish/lub/partition/vxworks/vxworks_partition.c

/*
 * vxworks_partition.c
 */
#include <stdlib.h>
#include <assert.h>

#include <taskLib.h>
#include <taskHookLib.h>

#include "private.h"

static lub_vxworks_partition_t *first_partition;

/*-------------------------------------------------------- */
static void
lub_vxworks_partition_task_delete_hook(WIND_TCB *pTcb)
{
    lub_vxworks_partition_t **ptr;
    int                       tid = (int)pTcb;
    
    /* iterate the list of partitions */
    taskLock();
    for(ptr = &first_partition;
        *ptr;
         ptr = &(*ptr)->m_next_partition)
    {
        int val = taskVarGet(tid,(int*)&(*ptr)->m_local_heap);
        if(ERROR != val)
        {
            /* destroy this local heap */
            lub_partition_destroy_local_heap(&(*ptr)->m_base,(void*)val);

            /* and remove the task variable */
            taskVarDelete(tid,(int*)&(*ptr)->m_local_heap);
        }
    }
    taskUnlock();
}
/*-------------------------------------------------------- */
lub_partition_t *
lub_partition_create(const lub_partition_spec_t *spec)
{
    lub_vxworks_partition_t *this;
    this = calloc(sizeof(lub_vxworks_partition_t),1);
    if(this)
    {
        /* initialise the global mutex */
        if(ERROR == semMInit(&this->m_sem,SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE))
        {
            assert(NULL == "semMInit() failed!");
        }
        
        lub_partition_lock(&this->m_base);
        /* initialise the local task variable system */
        taskVarInit();
        
        /* initialise the base class */
        lub_partition_init(&this->m_base,spec);
        
        /* add to the list of partitions */
        this->m_next_partition = first_partition;
        first_partition        = this;

        if(this == first_partition)
        {
            /* register a task deletion hook */
            taskDeleteHookAdd((FUNCPTR)lub_vxworks_partition_task_delete_hook);
        }
        lub_partition_unlock(&this->m_base);
    }
    return this ? &this->m_base : 0;
}
/*-------------------------------------------------------- */
void
lub_partition_destroy(lub_partition_t *instance)
{
    lub_vxworks_partition_t  *this = (void*)instance;
    lub_vxworks_partition_t **ptr;

    /* finalise the base class */
    lub_partition_fini(&this->m_base);
    
    lub_partition_lock(&this->m_base);
    /* remove from the list of partitions */
    for(ptr = &first_partition;
        *ptr;
        ptr = &(*ptr)->m_next_partition)
    {
        if(&(*ptr)->m_base == instance)
        {
            /* remove from list */
            *ptr = (*ptr)->m_next_partition;
            break;
        }
    }
    if(!first_partition)
    {
        /* deregister delete hook */
        taskDeleteHookDelete((FUNCPTR)lub_vxworks_partition_task_delete_hook);
    }
    lub_partition_unlock(&this->m_base);
    free(this);
}
/*-------------------------------------------------------- */
lub_heap_t *
lub_partition__get_local_heap(lub_partition_t *instance) 
{
    lub_vxworks_partition_t *this = (void*)instance;

    return this->m_local_heap;
}
/*-------------------------------------------------------- */
void
lub_partition__set_local_heap(lub_partition_t *instance,
                              lub_heap_t      *heap) 
{
    lub_vxworks_partition_t *this = (void*)instance;

    if(this->m_local_heap)
    {
        assert(NULL == "Local heap already exists!");
    }
    /* add this memory to the local task */
    taskVarAdd(0,(int*)&this->m_local_heap);

    /* add set the value */
    this->m_local_heap = heap;
}
/*-------------------------------------------------------- */
void
lub_partition_lock(lub_partition_t *instance) 
{
    lub_vxworks_partition_t *this = (void*)instance;
    
    if(ERROR == semTake(&this->m_sem,WAIT_FOREVER))
    {
        assert(NULL == "semTake() failed!");
    }
}
/*-------------------------------------------------------- */
void
lub_partition_unlock(lub_partition_t *instance) 
{
    lub_vxworks_partition_t *this = (void*)instance;
    
    if(ERROR == semGive(&this->m_sem))
    {
        assert(NULL == "semGive() failed!");
    }
}
/*-------------------------------------------------------- */