platform.c

uclinux线程的创建、消息队列的创建、信号量、互斥信号量、信号等的创建

            {
                perror(NULL); print("%s %d  ",__FILE__, __LINE__);print("semop\n");
                return ERROR;
            } 
        }
    }

    return OK;
}


/****************************************************************************
                                释放一个信号量
                        
函数名   ： semGive()
  
功能     ： 释放一个信号量
  
参数     ： semId       信号量的id.

返回值   ： OK(0)       删除成功
            ERROR(-1)   调用失败
******************************************************************************/
int semGive
    (
    SEM_ID semId /* semaphore ID to give */
    )

{
    semInfo* pSem;
    struct sembuf sops={0,+1,IPC_NOWAIT};
    int t1;

    if (semId <= 0)
    {
        pl(); fprintf(stderr, "error,semId = 0\n");
        return ERROR;
    }
    
    t1 = ((int)semId - (int)semInfoList)/sizeof(semInfo);
    if ((int)semId != (int)&semInfoList[t1])
    {
        pl(); fprintf(stderr, "error,semId = %d\n", semId);
        return ERROR;
    }
    
    pSem = (semInfo*)semId;

    if (pSem->semType == SEM_TYPE_UNUSED)
    {
        pl(); fprintf(stderr, "semGive error:pSem->semType == SEM_TYPE_UNUSED\n");
        return ERROR;
    }

    if (pSem->semType == SEM_TYPE_MUTEX)
    {
        if (pthread_mutex_unlock(&pSem->mutex) != OK)
        {
            print("%s %d  ",__FILE__, __LINE__);print( "__pthread_mutex_unlock error\n");perror(0);
            return ERROR;
        }

        return OK;//返回
    }
    else if (pSem->semType == SEM_TYPE_BINARY)
    {
        int value;

        value = semctl(pSem->semId, 0, GETVAL, 0);
        if (value == ERROR)
        {
            perror(NULL); print("%s %d  ",__FILE__, __LINE__);print("sem_getvalue\n");
            return ERROR;
        }
        
        pl(); fprintf(stderr, "value is %d\n", value);
        if (value == 1)
        {
            return OK;
        }
        else if (value > 1)
        {
            pl(); fprintf(stderr, "binary sem value %d >1\n", value);
            return OK;
        }
    }

    
    if (semop(pSem->semId, &sops, 1) == ERROR)
    {
        perror(NULL); print("%s %d  ",__FILE__, __LINE__);print("semop\n");
        return ERROR;
    }

    return OK;
}




/****************************************************************************
                                创建一个计数信号量
                        
函数名   ： semCCreate()
  
功能     ： 创建一个计数信号量
  
参数     ： options       未使用.

            initialCount  信号量的初始值

返回值   ： 信号量id(>0)       创建成功
            NULL(0)           调用失败
******************************************************************************/
SEM_ID semCCreate//创建一个计数信号量
    (
    NO   int options,     /* 不使用 */
    USE int initialCount /* 信号量的初始值 */
    )
{
    semInfo* pSem;
    SEM_ID semCId;
    union semun sem;
    
    semCId = semget(IPC_PRIVATE, 1, IPC_CREAT|IPC_EXCL|0666);
    if (semCId == ERROR)
    {
        perror("semget");
        print("%s %d  ",__FILE__, __LINE__);print("semget\n");
        return NULL;
    }

    sem.val = initialCount;
    if (semctl(semCId, 0, SETVAL, sem) == ERROR)
    {
        perror("semctl");
        pl();print("semctl\n");
        return NULL;
    }
    
    /*进入临界段*/
    pSem = semInfoFreeList;
    if (semInfoFreeList != (semInfo*)0)
    {
        semInfoFreeList = semInfoFreeList->semInfoPtr;
    }

    if (pSem != (semInfo*)0)
    {
        pSem->semType = SEM_TYPE_COUNT;
        pSem->semId = semCId;
    }

    return (int)pSem;
}


/****************************************************************************
                                创建一个互斥型信号量
                        
函数名   ： semMCreate()
  
功能     ： 创建一个互斥型信号量
  
参数     ： options       未使用.

            initialCount  信号量的初始值

返回值   ： 信号量id(>0)       创建成功
            NULL(0)            调用失败
******************************************************************************/
SEM_ID semMCreate//创建一个互斥型信号量
    (
    NO int options /* 未使用 */
    )
{
    /*创建优先级锁*/
    semInfo* pSem;

    /***********************************************************************
    PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，
    其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁
    策略保证了资源分配的公平性。 
    PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得
    多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重
    新竞争。 
    PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则
    返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当
    不允许多次加锁时不会出现最简单情况下的死锁。 
    PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后
    重新竞争。 
    ***********************************************************************/
    //pthread_mutex_t  mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
    //pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;
    
    mutex.__m_kind = PTHREAD_MUTEX_TIMED_NP;/*创建优先级锁*/
    
    /*进入临界段*/
    pSem = semInfoFreeList;
    if (semInfoFreeList != (semInfo*)0)
    {
        semInfoFreeList = semInfoFreeList->semInfoPtr;
    }

    if (pSem != (semInfo*)0)
    {
        pSem->semType = SEM_TYPE_MUTEX;
        pSem->mutex = mutex;
    }

    return (int)pSem;//如果失败则返回空值
    
 }

/****************************************************************************
                                创建一个二进制型信号量
                        
函数名   ： semBCreate()
  
功能     ： 创建一个互斥型信号量
  
参数     ： options       未使用.

            initialCount  信号量的初始值

返回值   ： 信号量id(>0)       创建成功
            NULL(0)            调用失败
******************************************************************************/
/*linux信号量都是按照先后顺序来的，没有按照优先级来排队*/
SEM_ID semBCreate//创建一个二进制型信号量
    (
    NO     int   options,     /* 未使用 */
    USE int  initialState /* 初始值 */
    )
{
    semInfo* pSem = NULL;
    SEM_ID semBId;
    union semun sem;

    if (initialState <0 ||initialState >1)
    {
        pl();print("initialState must be 1 or 0\n");
        return NULL;
    }
    
    semBId = semget(IPC_PRIVATE, 1, IPC_CREAT|IPC_EXCL|0666);
    if (semBId == ERROR)
    {
        perror("semget");
        pl();print("semget\n");
        return NULL;
    }

    
    sem.val = initialState;
    if (semctl(semBId, 0, SETVAL, sem) == ERROR)
    {
        perror("semctl");
        pl();print("semctl\n");
        return NULL;
    }
    
    
    /*进入临界段*/
    pSem = semInfoFreeList;
    if (semInfoFreeList != (semInfo*)0)
    {
        semInfoFreeList = semInfoFreeList->semInfoPtr;
    }

    if (pSem != (semInfo*)0)
    {
        pSem->semType = SEM_TYPE_BINARY;
        pSem->semId = semBId;
    }

    return (int)pSem;
}
 
#endif

#ifndef __TIMER__



static void taskTimer();
static struct _appTimer appClock;

int sysClkConnect
    (
    void (*routine) (void*), /* routine called at each system clock interrupt */
    int     arg      /* argument with which to call routine */
    )
{ 
    appClock.act.sa_handler = routine; 
    appClock.act.sa_flags = 0;
    
    appClock.clkConnect = 1;

    return OK;
}


/*********************************************************************
linux主机上只能提供最小10ms的定时，不足10ms的定时系统自动调整为10ms
uclinux上可以通过调整内核来达到更精确的定时
**********************************************************************/
int sysClkRateSet
    (
    int ticksPerSecond /* number of clock interrupts per second */
    )
{
    appClock.value.it_value.tv_sec = 0; 

    appClock.value.it_value.tv_usec = 1000000/ticksPerSecond; /*1us为百万分之一秒*/
    appClock.value.it_interval = appClock.value.it_value; 

    appClock.rateSetFlag = 1;

    return OK;
}


void sysAuxClkEnable(void)
{
    if ((appClock.rateSetFlag & appClock.clkConnect) != 1)
    {
        pl(); fprintf(stderr, "please sysClkRateSet\n");
        return;
    }
    
    /*新开一个优先级较高的实时线程作为定时器任务，因为main进程实际上是一个
    非实时进程，不具有抢占性。*/
    appClock.th_timer = taskSpawn("taskTimer", 1, 0, 20000, (void*)taskTimer, 0,SCHED_FIFO,0,0,0,0,0,0,0,0);
    pl(); print("th_timer = %ld\n", appClock.th_timer);
}

static void taskTimer()
{
    setitimer(0,&appClock.value,NULL);/*调用软中断*/

    sigemptyset(&appClock.act.sa_mask); 
    
    sigaction(SIGALRM,&appClock.act,NULL); 

    for(;;)
    {
        sleep(100);
    }
    /*init_timer(&timer);
    timer.function = (void *)funcTimer;
    timer.expires = 100;
    timer.data = 5;
    add_timer(&timer);//这是内核使用的定时器，只有内核才能使用*/
}

#endif