platform.c

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

    {
        msgctl(msgQid, IPC_RMID, NULL);/*删除队列*/
        return NULL;
    }
    
    /*根据入参调整消息队列的属性*/
    msg_info.msg_qbytes = maxMsgLength*maxMsgs;/*消息队列的最大长度*/
    if (msgctl(msgQid, IPC_SET, &msg_info) == ERROR)/*调整队列属性失败*/
    {
        msgctl(msgQid, IPC_RMID, NULL);/*删除队列*/
        return NULL;
    }
    
    return msgQid;
}


/****************************************************************************
                                向linux消息队列发送消息
函数名   ： msgQSend()
  
功能     ： 向linux消息队列发送消息
  
参数     ： msgQId      消息队列的id.

            buffer      存有消息的缓冲区.
            
            nBytes      发送缓冲中数据的长度.
            
            timeout     发送的超时选项，可选值有二:
                            NO_WAIT     :队列满时，不等待，立即返回错误.
                            WAIT_FOREVER:队列满时将阻塞，直到队列有空间.
                        注:如果传入值不在上面选项中，则认为是WAIT_FOREVER.
                        
            option      未使用
            
返回值   ： OK(0)       成功发送
            ERROR(-1)   调用失败
******************************************************************************/
 int msgQSend
    ( 
      USE  MSG_Q_ID msgQId,  /* 队列id */
      USE  char *   buffer,  /* 发送缓冲 */
      USE  unsigned int     nBytes,  /* 缓冲区长度 */
      USE  int      timeout, /* NO_WAIT(队列满时立即返回)，
                               WAIT_FOREVER(队列满时将阻塞，直到队列有空间) */
      NO int      option /* 对于linux，该项无效*/
    )
{
    struct msgbuf 
    {
        int mtype;
        char mtext[nBytes];
    }buf;
    
    memcpy(buf.mtext,buffer,nBytes);
    buf.mtype = 10;
    
    if (timeout == NO_WAIT)
    {
        return msgsnd(msgQId, &buf, nBytes, IPC_NOWAIT);
    }
    else if (timeout == WAIT_FOREVER)
    {
        return msgsnd(msgQId, &buf, nBytes, 0);
    }
    else
    {
        return msgsnd(msgQId, &buf, nBytes, 0);
    }
}

/****************************************************************************
                                从linux消息队列接收消息
函数名   ： msgQReceive()
  
功能     ： 从linux消息队列接收消息
  
参数     ： msgQId      消息队列的id.

            buffer      存有消息的缓冲区.
            
            nBytes      发送缓冲中数据的长度.
            
            timeout     发送的超时选项，可选值有二:
                            NO_WAIT     :队列满时，不等待，立即返回错误.
                            WAIT_FOREVER:队列满时将阻塞，直到队列有空间.
                        注:如果传入值不在上面选项中，则认为是WAIT_FOREVER.
                        
            option      未使用
            
返回值   ： 接收到消息的大小(>0)       成功接收
            ERROR(-1)                  调用失败
******************************************************************************/

int msgQReceive
    (
     USE MSG_Q_ID msgQId,     /* 队列id */
     USE char *   buffer,    /* 接收缓冲 */
     USE unsigned int     maxNBytes, /* 缓冲区长度 */
     USE int      timeout    /* NO_WAIT(队列空时立即返回),WAIT_FOREVER(队列空时将阻塞，直到队列不为空) */
    )
{
    int rcvLen;
    struct msgbuf 
    {
        int mtype;
        char mtext[maxNBytes];
    }buf;

    if (timeout == NO_WAIT)
    {
        rcvLen = msgrcv(msgQId, &buf, maxNBytes, 0, IPC_NOWAIT);
    }
    else if (timeout == WAIT_FOREVER)
    {
        rcvLen = msgrcv(msgQId, &buf, maxNBytes, 0, 0);
    }
    else 
    {
        rcvLen = msgrcv(msgQId, &buf, maxNBytes, 0, 0);
    }
    
    if(rcvLen == ERROR)
    {
        return ERROR;
    }
    
    memcpy(buffer, buf.mtext, rcvLen);
    return rcvLen;
}

/****************************************************************************
                        获取linux消息队列中当前消息个数
                        
函数名   ： msgQNumMsgs()
  
功能     ： 获取linux消息队列中当前消息个数
  
参数     ： msgQId      消息队列的id.

返回值   ： 消息个数(>=0)       查询成功
            ERROR(-1)           调用失败
******************************************************************************/
int msgQNumMsgs
    (
    USE MSG_Q_ID msgQId /* message queue to examine */
    )
{
    struct msqid_ds msg_info;
        
    if (msgctl(msgQId,IPC_STAT,&msg_info) == ERROR)
    {
        return ERROR;
    }
    else
    {
        return msg_info.msg_qnum;
    }
}
#endif


#ifndef __SEM__



/*管理计数信号量、二进制信号量、互斥信号量的全局变量*/
semInfo semInfoList[MAX_SEM];
semInfo* semInfoFreeList;


/*初始化全局变量结构*/
void initSemList()
{
    int i=0;

    semInfo* pSem1;
    semInfo* pSem2;

    (void)memset(semInfoList, 0, sizeof(semInfoList));

    pSem1 = &semInfoList[0];
    pSem2 = &semInfoList[1];

    for(i=0; i< (MAX_SEM - 1); i++)
    {
        pSem1->semType = SEM_TYPE_UNUSED;
        pSem1->semInfoPtr = pSem2;
  
        pSem1++;
        pSem2++;
    }
    semInfoFreeList = &semInfoList[0];
}


/****************************************************************************
                                删除一个信号量
                        
函数名   ： semDelete()
  
功能     ： 删除一个信号量
  
参数     ： semId      信号量的id.

返回值   ： OK(0)       删除成功
            ERROR(-1)   调用失败
******************************************************************************/
int semDelete
    (
    SEM_ID semId /* semaphore ID to delete */
    )
{
    semInfo* pSem;
    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;
    }
        
    if (semId == 0)
    {
        pl(); fprintf(stderr, "error,semId = 0\n");
        return ERROR;
    }
    
    pSem = (semInfo*)semId;

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

    if (pSem->semType == SEM_TYPE_MUTEX)
    {
        if (pthread_mutex_destroy(&pSem->mutex) != OK)
        {
            perror(NULL); print("%s %d  ",__FILE__, __LINE__);print("__pthread_mutex_destroy error\n");
            return ERROR;
        }
    }
    else
    {
        if (semctl(pSem->semId, 0, IPC_RMID, 0) == ERROR)
        {
            perror(NULL); print("%s %d  ",__FILE__, __LINE__);print("semDelete error\n");
            return ERROR;
        }
    }
      

    pSem->semType = SEM_TYPE_UNUSED;

    pSem->semInfoPtr = semInfoFreeList;
    semInfoFreeList = pSem;
    
    return OK;
}


/****************************************************************************
                                等待一个信号量
                        
函数名   ： semTake()
  
功能     ： 等待一个信号量
  
参数     ： semId       信号量的id.

            timeout     等待超时选项，可选值有二:
                            NO_WAIT     :没有信号量时不等待，立即返回错误.
                            WAIT_FOREVER:没有信号量时时将阻塞，直到取得信号量.
                        注:如果传入值不在上面选项中，则认为是WAIT_FOREVER.    

返回值   ： OK(0)       删除成功
            ERROR(-1)   调用失败
******************************************************************************/

int semTake
    (
    SEM_ID semId,  /* semaphore ID to take */
    int    timeout /* timeout in ticks */
    )
{
    semInfo* pSem;
    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, "error:pSem->semType == SEM_TYPE_UNUSED\n");
        return ERROR;
    }

    if (timeout == NO_WAIT)
    {
        if (pSem->semType == SEM_TYPE_MUTEX)
        {
            if (pthread_mutex_trylock(&pSem->mutex) != OK)
            {
                return ERROR;
            }
        }
        else 
        {
            struct sembuf sops={0,-1,IPC_NOWAIT};
            
            sops.sem_flg = IPC_NOWAIT;
            sops.sem_num = 0;
            sops.sem_op = -1;
            
            if (semop(pSem->semId, &sops, 1) == ERROR)
            {
                perror(NULL); print("%s %d  ",__FILE__, __LINE__);print("semop\n");
                return ERROR;
            }
        }
    }
    else //if (timeout == WAIT_FOREVER)
    {
        if (pSem->semType == SEM_TYPE_MUTEX)
        {
            if (pthread_mutex_lock(&pSem->mutex) != OK)
            {
                perror(NULL); print("%s %d  ",__FILE__, __LINE__);print("__pthread_mutex_trylock error\n");
                return ERROR;
            }
        }
        else
        {
            struct sembuf sops={0,-1,0};
            
            sops.sem_flg = 0;//如果信号量取不到则等待
            sops.sem_num = 0;
            sops.sem_op = -1;
            
            if (semop(pSem->semId, &sops, 1) == ERROR)