net_tmr.c

ucos的tcpip协议占

    if (fnct == (CPU_FNCT_PTR)0) {
        NET_CTR_ERR_INC(NetTmr_ErrNullFnctCtr);
       *perr =   NET_TMR_ERR_NULL_FNCT;
        return ((NET_TMR *)0);
    }
#endif

                                                                /* --------------------- GET TMR ---------------------- */
    if (NetTmr_PoolPtr != (NET_TMR *)0) {                       /* If tmr pool NOT empty, get tmr from pool.            */
        ptmr            = (NET_TMR *)NetTmr_PoolPtr;
        NetTmr_PoolPtr  = (NET_TMR *)ptmr->NextPtr;

    } else {                                                    /* If none avail, rtn err.                              */
        NET_CTR_ERR_INC(NetTmr_ErrNoneAvailCtr);
       *perr =   NET_TMR_ERR_NONE_AVAIL;
        return ((NET_TMR *)0);
    }


#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
                                                                /* ------------------- VALIDATE TMR ------------------- */
    if (ptmr->Type != NET_TMR_TYPE_TMR) {
        NetTmr_Discard(ptmr);
        NET_CTR_ERR_INC(NetTmr_ErrInvalidTypeCtr);
       *perr =   NET_TMR_ERR_INVALID_TYPE;
        return ((NET_TMR *)0);
    }
#endif

                                                                /* --------------------- INIT TMR --------------------- */
    ptmr->PrevPtr = (void *)0;
    ptmr->NextPtr = (void *)NetTmr_TaskListHead;
    ptmr->Obj     =  obj;
    ptmr->Fnct    =  fnct;
    ptmr->TmrVal  =  time;                                      /* Set tmr val (in ticks/seconds).                      */
    ptmr->Flags   =  NET_TMR_FLAG_NONE;
    DEF_BIT_SET(ptmr->Flags, NET_TMR_FLAG_USED);                /* Set tmr as used.                                     */

                                                                /* ---------- INSERT TMR INTO TMR TASK LIST ----------- */
    if (NetTmr_TaskListHead != (NET_TMR *)0) {                  /* If list NOT empty, insert before head.               */
        NetTmr_TaskListHead->PrevPtr = (void *)ptmr;
    }
    NetTmr_TaskListHead = ptmr;                                 /* Insert tmr @ list head.                              */

                                                                /* --------------- UPDATE TMR POOL STATS -------------- */
    NetStat_PoolEntryUsedInc(&NetTmr_PoolStat, &stat_err);

   *perr =  NET_TMR_ERR_NONE;

    return (ptmr);                                              /* --------------------- RTN TMR ---------------------- */
}


/*$PAGE*/
/*
*********************************************************************************************************
*                                            NetTmr_Free()
*
* Description : (1) Free a network timer :
*
*                   (a) Remove timer from Timer Task List
*                   (b) Clear  timer controls
*                   (c) Free   timer back to timer pool
*                   (d) Update timer pool statistics
*
*
* Argument(s) : ptmr        Pointer to a network timer.
*
* Return(s)   : none.
*
* Caller(s)   : various.
*
*               This function is an INTERNAL network protocol suite function & SHOULD NOT be called by 
*               application function(s).
*
* Note(s)     : (2) #### To prevent freeing a timer already freed via previous timer free, NetTmr_Free()
*                   checks the timer's 'USED' flag BEFORE freeing the timer.
*
*                   This prevention is only best-effort since any invalid duplicate timer frees MAY be
*                   asynchronous to potentially valid timer gets.  Thus the invalid timer free(s) MAY
*                   corrupt the timer's valid operation(s).
*
*                   However, since the primary tasks of the network protocol suite are prevented from
*                   running concurrently (see 'net.h  Note #2'), it is NOT necessary to protect network
*                   timer resources from possible corruption since no asynchronous access from other
*                   network tasks is possible.
*
*               (3) Since NetTmr_TaskHandler() is asynchronous to NetTmr_Free() [via execution of certain
*                   timer expiration functions], the Timer Task List timer ('NetTmr_TaskListPtr') MUST be
*                   coordinated with NetTmr_Free() to avoid Timer Task List corruption :
*
*                   (a) Whenever the Timer Task List timer is freed, the Timer Task List timer MUST be
*                       advanced to the next valid & available timer in the Timer Task List.
*
*                       See also 'NetTmr_TaskHandler()  Note #5a2'.
*********************************************************************************************************
*/
/*$PAGE*/
void  NetTmr_Free (NET_TMR  *ptmr)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)                    && \
     (NET_CTR_CFG_ERR_EN         == DEF_ENABLED)                    && \
     (CPU_CFG_CRITICAL_METHOD    == CPU_CRITICAL_METHOD_STATUS_LOCAL))
    CPU_SR        cpu_sr;
#endif
#if  (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
    CPU_BOOLEAN   used;
#endif
    NET_TMR      *pprev;
    NET_TMR      *pnext;
    NET_ERR       stat_err;


                                                                /* ------------------- VALIDATE PTR ------------------- */
    if (ptmr == (NET_TMR *)0) {
        return;
    }

#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
                                                                /* ------------------- VALIDATE TYPE ------------------ */
    if (ptmr->Type != NET_TMR_TYPE_TMR) {
        NetTmr_Discard(ptmr);
        NET_CTR_ERR_INC(NetTmr_ErrInvalidTypeCtr);
        return;
    }
                                                                /* ----------------- VALIDATE TMR USED ---------------- */
    used = DEF_BIT_IS_SET(ptmr->Flags, NET_TMR_FLAG_USED);
    if (used != DEF_YES) {                                      /* If tmr NOT used, ...                                 */
        NET_CTR_ERR_INC(NetTmr_ErrNotUsedCtr);
        return;                                                 /* ... rtn but do NOT free (see Note #2).               */
    }
#endif

                                                                /* ----------- REMOVE TMR FROM TMR TASK LIST ---------- */
    if (ptmr == NetTmr_TaskListPtr) {                           /* If tmr is next Tmr Task tmr to update, ...           */
        pnext              = (NET_TMR *)NetTmr_TaskListPtr->NextPtr;
        NetTmr_TaskListPtr = (NET_TMR *)pnext;                  /* ... adv Tmr Task ptr to skip this tmr (see Note #3a).*/
    }

    pprev = (NET_TMR *)ptmr->PrevPtr;
    pnext = (NET_TMR *)ptmr->NextPtr;
    if (pprev != (NET_TMR *)0) {                                /* If ptmr is NOT   the head of Tmr Task List, ...      */
        pprev->NextPtr      = (void    *)pnext;                 /* ... set pprev's NextPtr to skip ptmr.                */
    } else {                                                    /* Else set pnext as head of Tmr Task List.             */
        NetTmr_TaskListHead = (NET_TMR *)pnext;
    }
    if (pnext != (NET_TMR *)0) {                                /* If ptmr is NOT @ the tail of Tmr Task List, ...      */
        pnext->PrevPtr      = (void    *)pprev;                 /* ... set pnext's PrevPtr to skip ptmr.                */
    }

                                                                /* ---------------------- CLR TMR --------------------- */
    DEF_BIT_CLR(ptmr->Flags, NET_TMR_FLAG_USED);                /* Set tmr as NOT used.                                 */
#if (NET_DBG_CFG_MEM_CLR_EN == DEF_ENABLED)
    NetTmr_Clr(ptmr);
#endif

                                                                /* --------------------- FREE TMR --------------------- */
    ptmr->NextPtr  = (void    *)NetTmr_PoolPtr;
    NetTmr_PoolPtr = (NET_TMR *)ptmr;

                                                                /* -------------- UPDATE TMR POOL STATS --------------- */
    NetStat_PoolEntryUsedDec(&NetTmr_PoolStat, &stat_err);
}


/*$PAGE*/
/*
*********************************************************************************************************
*                                            NetTmr_Set()
*
* Description : Update a network timer with a new expiration function & timer value.
*
* Argument(s) : ptmr        Pointer to a network timer.
*
*               fnct        Pointer to object function to execute when timer expires (see Note #2).
*
*               time        Update timer value (in seconds expressed in 'NET_TMR_TICK' ticks)
*                               [see also Note #3].
*
*               perr        Pointer to variable that will receive the return error code from this function :
*
*                               NET_TMR_ERR_NONE                Network timer time successfully updated.
*                               NET_TMR_ERR_NULL_PTR            Argument 'ptmr' passed a NULL pointer.
*                               NET_TMR_ERR_NULL_FNCT           Argument 'fnct' passed a NULL pointer.
*                               NET_TMR_ERR_INVALID_TYPE        Argument 'ptmr's TYPE is invalid or unknown.
*
* Return(s)   : none.
*
* Caller(s)   : various.
*
*               This function is an INTERNAL network protocol suite function & SHOULD NOT be called by 
*               application function(s).
*
* Note(s)     : (1) Assumes network timer is ALREADY owned by a valid network object.
*
*               (2) Ideally, network timer expiration functions could be defined as '[(void) (OBJECT *)]' 
*                   type functions -- even though network timer API functions cast expiration functions 
*                   to generic 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]').
*
*                   (a) (1) Unfortunately, ISO-IEC 9899-1999 ANSI-C, Section 6.3.2.3.7 states that "a 
*                           pointer to an object ... may be converted to a pointer to a different object 
*                           ... [but] if the resulting pointer is not correctly aligned ... the behavior
*                           is undefined".
*
*                           And since compilers may NOT correctly convert 'void' pointers to non-'void' 
*                           pointer arguments, network timer expiration functions MUST avoid incorrect
*                           pointer conversion behavior between 'void' pointer parameters & non-'void' 
*                           pointer arguments & therefore CANNOT be defined as '[(void) (OBJECT *)]'.
*
*                       (2) However, Section 6.3.2.3.1 states that "a pointer to void may be converted 
*                           to or from a pointer to any ... object ... A pointer to any ... object ... 
*                           may be converted to a pointer to void and back again; the result shall 
*                           compare equal to the original pointer".
*                   
*                   (b) Therefore, to correctly convert 'void' pointer objects back to appropriate
*                       network object pointer objects, network timer expiration functions MUST :
*
*                       (1) Be defined as 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]'); & ...
*                       (2) Explicitly cast 'void' pointer arguments to specific object pointers.
*
*                   See also 'NetTmr_Get()  Note #3'.
*
*               (3) Timer value of 0 ticks/seconds allowed; next tick will expire timer.
*
*                   See also 'NetTmr_TaskHandler()  Note #6'.
*********************************************************************************************************
*/
/*$PAGE*/
void  NetTmr_Set (NET_TMR       *ptmr,
                  CPU_FNCT_PTR   fnct,
                  NET_TMR_TICK   time,
                  NET_ERR       *perr)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)                    && \
     (NET_CTR_CFG_ERR_EN         == DEF_ENABLED)                    && \
     (CPU_CFG_CRITICAL_METHOD    == CPU_CRITICAL_METHOD_STATUS_LOCAL))
    CPU_SR  cpu_sr;
#endif


#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
                                                                /* ------------------- VALIDATE PTRS ------------------ */
    if (ptmr == (NET_TMR *)0) {
        NET_CTR_ERR_INC(NetTmr_ErrNullPtrCtr);
       *perr = NET_TMR_ERR_NULL_PTR;
        return;
    }

    if (fnct == (CPU_FNCT_PTR)0) {
        NET_CTR_ERR_INC(NetTmr_ErrNullFnctCtr);
       *perr = NET_TMR_ERR_NULL_FNCT;
        return;
    }