source: extension/dcre/kernel/task_manage.c

/*
 *  TOPPERS/ASP Kernel
 *      Toyohashi Open Platform for Embedded Real-Time Systems/
 *      Advanced Standard Profile Kernel
 * 
 *  Copyright (C) 2000-2003 by Embedded and Real-Time Systems Laboratory
 *                              Toyohashi Univ. of Technology, JAPAN
 *  Copyright (C) 2005-2014 by Embedded and Real-Time Systems Laboratory
 *              Graduate School of Information Science, Nagoya Univ., JAPAN
 * 
 *  Ÿåµ­Ãøºîž¢ŒÔ€Ï¡€°Ê²Œ€Î(1)¡Á(4)€ÎŸò·ï€òËþ€¿€¹Ÿì¹ç€ËžÂ€ê¡€ËÜ¥œ¥Õ¥È¥Š¥§
 *  ¥¢¡ÊËÜ¥œ¥Õ¥È¥Š¥§¥¢€ò²þÊÑ€·€¿€â€Î€òŽÞ€à¡¥°Ê²ŒÆ±€ž¡Ë€ò»ÈÍÑ¡ŠÊ£Àœ¡Š²þ
 *  ÊÑ¡ŠºÆÇÛÉۡʰʲŒ¡€ÍøÍрȞƀ֡ˀ¹€ë€³€È€ò̵œþ€ÇµöÂú€¹€ë¡¥
 *  (1) ËÜ¥œ¥Õ¥È¥Š¥§¥¢€ò¥œ¡Œ¥¹¥³¡Œ¥É€Î·Á€ÇÍøÍÑ€¹€ëŸì¹ç€Ë€Ï¡€Ÿåµ­€ÎÃøºî
 *      ž¢ÉœŒš¡€€³€ÎÍøÍÑŸò·ï€ª€è€Ó²Œµ­€Î̵ÊÝŸÚµ¬Äꀬ¡€€œ€Î€Þ€Þ€Î·Á€Ç¥œ¡Œ
 *      ¥¹¥³¡Œ¥ÉÃæ€ËŽÞ€Þ€ì€Æ€€€ë€³€È¡¥
 *  (2) ËÜ¥œ¥Õ¥È¥Š¥§¥¢€ò¡€¥é¥€¥Ö¥é¥ê·ÁŒ°€Ê€É¡€ÂŸ€Î¥œ¥Õ¥È¥Š¥§¥¢³«È¯€Ë»È
 *      Íрǀ­€ë·Á€ÇºÆÇÛÉÛ€¹€ëŸì¹ç€Ë€Ï¡€ºÆÇÛÉÛ€ËÈŒ€Š¥É¥­¥å¥á¥ó¥È¡ÊÍøÍÑ
 *      ŒÔ¥Þ¥Ë¥å¥¢¥ë€Ê€É¡Ë€Ë¡€Ÿåµ­€ÎÃøºîž¢ÉœŒš¡€€³€ÎÍøÍÑŸò·ï€ª€è€Ó²Œµ­
 *      €Î̵ÊÝŸÚµ¬Äê€ò·ÇºÜ€¹€ë€³€È¡¥
 *  (3) ËÜ¥œ¥Õ¥È¥Š¥§¥¢€ò¡€µ¡Žï€ËÁȀ߹þ€à€Ê€É¡€ÂŸ€Î¥œ¥Õ¥È¥Š¥§¥¢³«È¯€Ë»È
 *      Íрǀ­€Ê€€·Á€ÇºÆÇÛÉÛ€¹€ëŸì¹ç€Ë€Ï¡€Œ¡€Î€€€º€ì€«€ÎŸò·ï€òËþ€¿€¹€³
 *      €È¡¥
 *    (a) ºÆÇÛÉÛ€ËÈŒ€Š¥É¥­¥å¥á¥ó¥È¡ÊÍøÍьԥޥ˥奢¥ë€Ê€É¡Ë€Ë¡€Ÿåµ­€ÎÃø
 *        ºîž¢ÉœŒš¡€€³€ÎÍøÍÑŸò·ï€ª€è€Ó²Œµ­€Î̵ÊÝŸÚµ¬Äê€ò·ÇºÜ€¹€ë€³€È¡¥
 *    (b) ºÆÇÛÉۀηÁÂÖ€ò¡€ÊÌ€ËÄê€á€ëÊýË¡€Ë€è€Ã€Æ¡€TOPPERS¥×¥í¥ž¥§¥¯¥È€Ë
 *        Êó¹ð€¹€ë€³€È¡¥
 *  (4) ËÜ¥œ¥Õ¥È¥Š¥§¥¢€ÎÍøÍрˀè€êÄŸÀÜŪ€Þ€¿€ÏŽÖÀÜŪ€ËÀž€ž€ë€€€«€Ê€ë»
 *      ³²€«€é€â¡€Ÿåµ­Ãøºîž¢ŒÔ€ª€è€ÓTOPPERS¥×¥í¥ž¥§¥¯¥È€òÌÈÀÕ€¹€ë€³€È¡¥
 *      €Þ€¿¡€ËÜ¥œ¥Õ¥È¥Š¥§¥¢€Î¥æ¡Œ¥¶€Þ€¿€Ï¥š¥ó¥É¥æ¡Œ¥¶€«€é€Î€€€«€Ê€ëÍý
 *      ͳ€ËŽð€Å€¯ÀÁµá€«€é€â¡€Ÿåµ­Ãøºîž¢ŒÔ€ª€è€ÓTOPPERS¥×¥í¥ž¥§¥¯¥È€ò
 *      ÌÈÀÕ€¹€ë€³€È¡¥
 * 
 *  ËÜ¥œ¥Õ¥È¥Š¥§¥¢€Ï¡€ÌµÊÝŸÚ€ÇÄ󶡀µ€ì€Æ€€€ë€â€Î€Ç€¢€ë¡¥Ÿåµ­Ãøºîž¢ŒÔ€ª
 *  €è€ÓTOPPERS¥×¥í¥ž¥§¥¯¥È€Ï¡€ËÜ¥œ¥Õ¥È¥Š¥§¥¢€ËŽØ€·€Æ¡€ÆÃÄê€Î»ÈÍÑÌÜŪ
 *  €ËÂЀ¹€ëŬ¹çÀ­€âŽÞ€á€Æ¡€€€€«€Ê€ëÊÝŸÚ€â¹Ô€ï€Ê€€¡¥€Þ€¿¡€ËÜ¥œ¥Õ¥È¥Š¥§
 *  ¥¢€ÎÍøÍрˀè€êÄŸÀÜŪ€Þ€¿€ÏŽÖÀÜŪ€ËÀž€ž€¿€€€«€Ê€ë»³²€ËŽØ€·€Æ€â¡€€œ
 *  €ÎÀÕÇ€€òÉé€ï€Ê€€¡¥
 * 
 *  $Id$
 */

/*
 *              ¥¿¥¹¥¯ŽÉÍýµ¡Çœ
 */

#include "kernel_impl.h"
#include "check.h"
#include "task.h"
#include "wait.h"

/*
 *  ¥È¥ì¡Œ¥¹¥í¥°¥Þ¥¯¥í€Î¥Ç¥Õ¥©¥ë¥ÈÄêµÁ
 */
#ifndef LOG_ACRE_TSK_ENTER
#define LOG_ACRE_TSK_ENTER(pk_ctsk)
#endif /* LOG_ACRE_TSK_ENTER */

#ifndef LOG_ACRE_TSK_LEAVE
#define LOG_ACRE_TSK_LEAVE(ercd)
#endif /* LOG_ACRE_TSK_LEAVE */

#ifndef LOG_DEL_TSK_ENTER
#define LOG_DEL_TSK_ENTER(tskid)
#endif /* LOG_DEL_TSK_ENTER */

#ifndef LOG_DEL_TSK_LEAVE
#define LOG_DEL_TSK_LEAVE(ercd)
#endif /* LOG_DEL_TSK_LEAVE */

#ifndef LOG_ACT_TSK_ENTER
#define LOG_ACT_TSK_ENTER(tskid)
#endif /* LOG_ACT_TSK_ENTER */

#ifndef LOG_ACT_TSK_LEAVE
#define LOG_ACT_TSK_LEAVE(ercd)
#endif /* LOG_ACT_TSK_LEAVE */

#ifndef LOG_IACT_TSK_ENTER
#define LOG_IACT_TSK_ENTER(tskid)
#endif /* LOG_IACT_TSK_ENTER */

#ifndef LOG_IACT_TSK_LEAVE
#define LOG_IACT_TSK_LEAVE(ercd)
#endif /* LOG_IACT_TSK_LEAVE */

#ifndef LOG_CAN_ACT_ENTER
#define LOG_CAN_ACT_ENTER(tskid)
#endif /* LOG_CAN_ACT_ENTER */

#ifndef LOG_CAN_ACT_LEAVE
#define LOG_CAN_ACT_LEAVE(ercd)
#endif /* LOG_CAN_ACT_LEAVE */

#ifndef LOG_EXT_TSK_ENTER
#define LOG_EXT_TSK_ENTER()
#endif /* LOG_EXT_TSK_ENTER */

#ifndef LOG_EXT_TSK_LEAVE
#define LOG_EXT_TSK_LEAVE(ercd)
#endif /* LOG_EXT_TSK_LEAVE */

#ifndef LOG_TER_TSK_ENTER
#define LOG_TER_TSK_ENTER(tskid)
#endif /* LOG_TER_TSK_ENTER */

#ifndef LOG_TER_TSK_LEAVE
#define LOG_TER_TSK_LEAVE(ercd)
#endif /* LOG_TER_TSK_LEAVE */

#ifndef LOG_CHG_PRI_ENTER
#define LOG_CHG_PRI_ENTER(tskid, tskpri)
#endif /* LOG_CHG_PRI_ENTER */

#ifndef LOG_CHG_PRI_LEAVE
#define LOG_CHG_PRI_LEAVE(ercd)
#endif /* LOG_CHG_PRI_LEAVE */

#ifndef LOG_GET_PRI_ENTER
#define LOG_GET_PRI_ENTER(tskid, p_tskpri)
#endif /* LOG_GET_PRI_ENTER */

#ifndef LOG_GET_PRI_LEAVE
#define LOG_GET_PRI_LEAVE(ercd, tskpri)
#endif /* LOG_GET_PRI_LEAVE */

#ifndef LOG_GET_INF_ENTER
#define LOG_GET_INF_ENTER(p_exinf)
#endif /* LOG_GET_INF_ENTER */

#ifndef LOG_GET_INF_LEAVE
#define LOG_GET_INF_LEAVE(ercd, exinf)
#endif /* LOG_GET_INF_LEAVE */

/*
 *  ¥¿¥¹¥¯€ÎÀžÀ®
 */
#ifdef TOPPERS_acre_tsk

#ifndef TARGET_MIN_STKSZ
#define TARGET_MIN_STKSZ        1U              /* Ì€ÄêµÁ€ÎŸì¹ç€Ï0€Ç€Ê€€€³€È€ò¥Á¥§¥Ã¥¯ */
#endif /* TARGET_MIN_STKSZ */

ER_UINT
acre_tsk(const T_CTSK *pk_ctsk)
{
        TCB             *p_tcb;
        TINIB   *p_tinib;
        ATR             tskatr;
        void    *stk;
        ER              ercd;

        LOG_ACRE_TSK_ENTER(pk_ctsk);
        CHECK_TSKCTX_UNL();
        CHECK_RSATR(pk_ctsk->tskatr, TA_ACT|TARGET_TSKATR);
        CHECK_ALIGN_FUNC(pk_ctsk->task);
        CHECK_NONNULL_FUNC(pk_ctsk->task);
        CHECK_TPRI(pk_ctsk->itskpri);
        CHECK_PAR(pk_ctsk->stksz >= TARGET_MIN_STKSZ);
        if (pk_ctsk->stk != NULL) {
                CHECK_ALIGN_STKSZ(pk_ctsk->stksz);
                CHECK_ALIGN_STACK(pk_ctsk->stk);
        }
        tskatr = pk_ctsk->tskatr;
        stk = pk_ctsk->stk;

        t_lock_cpu();
        if (queue_empty(&free_tcb)) {
                ercd = E_NOID;
        }
        else {
                if (stk == NULL) {
                        stk = kernel_malloc(ROUND_STK_T(pk_ctsk->stksz));
                        tskatr |= TA_MEMALLOC;
                }
                if (stk == NULL) {
                        ercd = E_NOMEM;
                }
                else {
                        p_tcb = ((TCB *) queue_delete_next(&free_tcb));
                        p_tinib = (TINIB *)(p_tcb->p_tinib);
                        p_tinib->tskatr = tskatr;
                        p_tinib->exinf = pk_ctsk->exinf;
                        p_tinib->task = pk_ctsk->task;
                        p_tinib->ipriority = INT_PRIORITY(pk_ctsk->itskpri);
#ifdef USE_TSKINICTXB
                        init_tskinictxb(&(p_tinib->tskinictxb), stk, pk_ctsk);
#else /* USE_TSKINICTXB */
                        p_tinib->stksz = pk_ctsk->stksz;
                        p_tinib->stk = stk;
#endif /* USE_TSKINICTXB */
                        p_tinib->texatr = TA_NULL;
                        p_tinib->texrtn = NULL;

                        p_tcb->actque = false;
                        make_dormant(p_tcb);
                        if ((p_tcb->p_tinib->tskatr & TA_ACT) != 0U) {
                                make_active(p_tcb);
                        }
                        ercd = TSKID(p_tcb);
                }
        }
        t_unlock_cpu();

  error_exit:
        LOG_ACRE_TSK_LEAVE(ercd);
        return(ercd);
}

#endif /* TOPPERS_acre_tsk */

/*
 *  ¥¿¥¹¥¯€Îºïœü
 */
#ifdef TOPPERS_del_tsk

ER
del_tsk(ID tskid)
{
        TCB             *p_tcb;
        TINIB   *p_tinib;
        ER              ercd;

        LOG_DEL_TSK_ENTER(tskid);
        CHECK_TSKCTX_UNL();
        CHECK_TSKID(tskid);
        p_tcb = get_tcb(tskid);

        t_lock_cpu();
        if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
                ercd = E_NOEXS;
        }
        else if (TSKID(p_tcb) > tmax_stskid && TSTAT_DORMANT(p_tcb->tstat)) {
                p_tinib = (TINIB *)(p_tcb->p_tinib);
#ifdef USE_TSKINICTXB
                term_tskinictxb(&(p_tinib->tskinictxb));
#else /* USE_TSKINICTXB */
                if ((p_tinib->tskatr & TA_MEMALLOC) != 0U) {
                        kernel_free(p_tinib->stk);
                }
#endif /* USE_TSKINICTXB */
                p_tinib->tskatr = TA_NOEXS;
                queue_insert_prev(&free_tcb, &(p_tcb->task_queue));
                ercd = E_OK;
        }
        else {
                ercd = E_OBJ;
        }
        t_unlock_cpu();

  error_exit:
        LOG_DEL_TSK_LEAVE(ercd);
        return(ercd);
}

#endif /* TOPPERS_del_tsk */

/*
 *  ¥¿¥¹¥¯€Îµ¯Æ°
 */
#ifdef TOPPERS_act_tsk

ER
act_tsk(ID tskid)
{
        TCB             *p_tcb;
        ER              ercd;

        LOG_ACT_TSK_ENTER(tskid);
        CHECK_TSKCTX_UNL();
        CHECK_TSKID_SELF(tskid);
        p_tcb = get_tcb_self(tskid);

        t_lock_cpu();
        if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
                ercd = E_NOEXS;
        }
        else if (TSTAT_DORMANT(p_tcb->tstat)) {
                if (make_active(p_tcb)) {
                        dispatch();
                }
                ercd = E_OK;
        }
        else if (!(p_tcb->actque)) {
                p_tcb->actque = true;
                ercd = E_OK;
        }
        else {
                ercd = E_QOVR;
        }
        t_unlock_cpu();

  error_exit:
        LOG_ACT_TSK_LEAVE(ercd);
        return(ercd);
}

#endif /* TOPPERS_act_tsk */

/*
 *  ¥¿¥¹¥¯€Îµ¯Æ°¡ÊÈ󥿥¹¥¯¥³¥ó¥Æ¥­¥¹¥ÈÍÑ¡Ë
 */
#ifdef TOPPERS_iact_tsk

ER
iact_tsk(ID tskid)
{
        TCB             *p_tcb;
        ER              ercd;

        LOG_IACT_TSK_ENTER(tskid);
        CHECK_INTCTX_UNL();
        CHECK_TSKID(tskid);
        p_tcb = get_tcb(tskid);

        i_lock_cpu();
        if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
                ercd = E_NOEXS;
        }
        else if (TSTAT_DORMANT(p_tcb->tstat)) {
                if (make_active(p_tcb)) {
                        reqflg = true;
                }
                ercd = E_OK;
        }
        else if (!(p_tcb->actque)) {
                p_tcb->actque = true;
                ercd = E_OK;
        }
        else {
                ercd = E_QOVR;
        }
        i_unlock_cpu();

  error_exit:
        LOG_IACT_TSK_LEAVE(ercd);
        return(ercd);
}

#endif /* TOPPERS_iact_tsk */

/*
 *  ¥¿¥¹¥¯µ¯Æ°Í×µá€Î¥­¥ã¥ó¥»¥ë
 */
#ifdef TOPPERS_can_act

ER_UINT
can_act(ID tskid)
{
        TCB             *p_tcb;
        ER_UINT ercd;

        LOG_CAN_ACT_ENTER(tskid);
        CHECK_TSKCTX_UNL();
        CHECK_TSKID_SELF(tskid);
        p_tcb = get_tcb_self(tskid);

        t_lock_cpu();
        if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
                ercd = E_NOEXS;
        }
        else {
                ercd = p_tcb->actque ? 1 : 0;
                p_tcb->actque = false;
        }
        t_unlock_cpu();

  error_exit:
        LOG_CAN_ACT_LEAVE(ercd);
        return(ercd);
}

#endif /* TOPPERS_can_act */

/*
 *  Œ«¥¿¥¹¥¯€ÎœªÎ»
 */
#ifdef TOPPERS_ext_tsk

ER
ext_tsk(void)
{
        ER              ercd;

        LOG_EXT_TSK_ENTER();
        CHECK_TSKCTX();

        if (t_sense_lock()) {
                /*
                 *  CPU¥í¥Ã¥¯ŸõÂÖ€Çext_tsk€¬žÆ€Ð€ì€¿Ÿì¹ç€Ï¡€CPU¥í¥Ã¥¯€ò²òœü€·
                 *  €Æ€«€é¥¿¥¹¥¯€òœªÎ»€¹€ë¡¥ŒÂÁõŸå€Ï¡€¥µ¡Œ¥Ó¥¹¥³¡Œ¥ëÆâ€Ç€ÎCPU
                 *  ¥í¥Ã¥¯€òŸÊά€¹€ì€Ð€è€€€À€±¡¥
                 */
        }
        else {
                t_lock_cpu();
        }
        if (disdsp) {
                /*
                 *  ¥Ç¥£¥¹¥Ñ¥Ã¥Á¶Ø»ßŸõÂÖ€Çext_tsk€¬žÆ€Ð€ì€¿Ÿì¹ç€Ï¡€¥Ç¥£¥¹¥Ñ¥Ã
                 *  ¥Áµö²ÄŸõÂրˀ·€Æ€«€é¥¿¥¹¥¯€òœªÎ»€¹€ë¡¥
                 */
                disdsp = false;
        }
        if (!ipmflg) {
                /*
                 *  ³ä¹þ€ßÍ¥ÀèÅÙ¥Þ¥¹¥¯¡ÊIPM¡Ë€¬TIPM_ENAALL°Ê³°€ÎŸõÂÖ€Çext_tsk
                 *  €¬žÆ€Ð€ì€¿Ÿì¹ç€Ï¡€IPM€òTIPM_ENAALL€Ë€·€Æ€«€é¥¿¥¹¥¯€òœªÎ»€¹
                 *  €ë¡¥
                 */
                t_set_ipm(TIPM_ENAALL);
                ipmflg = true;
        }
        dspflg = true;

        (void) make_non_runnable(p_runtsk);
        make_dormant(p_runtsk);
        if (p_runtsk->actque) {
                p_runtsk->actque = false;
                (void) make_active(p_runtsk);
        }
        exit_and_dispatch();
        ercd = E_SYS;

  error_exit:
        LOG_EXT_TSK_LEAVE(ercd);
        return(ercd);
}

#endif /* TOPPERS_ext_tsk */

/*
 *  ¥¿¥¹¥¯€Î¶¯À©œªÎ»
 */
#ifdef TOPPERS_ter_tsk

ER
ter_tsk(ID tskid)
{
        TCB             *p_tcb;
        ER              ercd;

        LOG_TER_TSK_ENTER(tskid);
        CHECK_TSKCTX_UNL();
        CHECK_TSKID(tskid);
        p_tcb = get_tcb(tskid);
        CHECK_NONSELF(p_tcb);

        t_lock_cpu();
        if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
                ercd = E_NOEXS;
        }
        else if (TSTAT_DORMANT(p_tcb->tstat)) {
                ercd = E_OBJ;
        }
        else {
                if (TSTAT_RUNNABLE(p_tcb->tstat)) {
                        /*
                         *  p_tcb€ÏŒ«¥¿¥¹¥¯€Ç€Ê€€€¿€á¡€¡Ê¥·¥ó¥°¥ë¥×¥í¥»¥Ã¥µ€Ç€Ï¡ËŒÂ
                         *  ¹ÔŸõÂրǀʀ¯¡€make_non_runnable(p_tcb)€Ç¥¿¥¹¥¯¥Ç¥£¥¹¥Ñ¥Ã
                         *  ¥Á€¬É¬Í׀ˀʀ뀳€È€Ï€Ê€€¡¥
                         */
                        (void) make_non_runnable(p_tcb);
                }
                else if (TSTAT_WAITING(p_tcb->tstat)) {
                        wait_dequeue_wobj(p_tcb);
                        wait_dequeue_tmevtb(p_tcb);
                }
                make_dormant(p_tcb);
                if (p_tcb->actque) {
                        p_tcb->actque = false;
                        if (make_active(p_tcb)) {
                                dispatch();
                        }
                }
                ercd = E_OK;
        }
        t_unlock_cpu();

  error_exit:
        LOG_TER_TSK_LEAVE(ercd);
        return(ercd);
}

#endif /* TOPPERS_ter_tsk */

/*
 *  ¥¿¥¹¥¯€Î¥Ù¡Œ¥¹Í¥ÀèÅÙ€ÎÊѹ¹
 */
#ifdef TOPPERS_chg_pri

ER
chg_pri(ID tskid, PRI tskpri)
{
        TCB             *p_tcb;
        uint_t  newpri;
        ER              ercd;

        LOG_CHG_PRI_ENTER(tskid, tskpri);
        CHECK_TSKCTX_UNL();
        CHECK_TSKID_SELF(tskid);
        CHECK_TPRI_INI(tskpri);
        p_tcb = get_tcb_self(tskid);

        t_lock_cpu();
        if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
                ercd = E_NOEXS;
        }
        else if (TSTAT_DORMANT(p_tcb->tstat)) {
                ercd = E_OBJ;
        }
        else {
                newpri = (tskpri == TPRI_INI) ? p_tcb->p_tinib->ipriority
                                                                                        : INT_PRIORITY(tskpri);
                if (change_priority(p_tcb, newpri)) {
                        dispatch();
                }
                ercd = E_OK;
        }
        t_unlock_cpu();

  error_exit:
        LOG_CHG_PRI_LEAVE(ercd);
        return(ercd);
}

#endif /* TOPPERS_chg_pri */

/*
 *  ¥¿¥¹¥¯Í¥ÀèÅـλ²ŸÈ
 */
#ifdef TOPPERS_get_pri

ER
get_pri(ID tskid, PRI *p_tskpri)
{
        TCB             *p_tcb;
        ER              ercd;

        LOG_GET_PRI_ENTER(tskid, p_tskpri);
        CHECK_TSKCTX_UNL();
        CHECK_TSKID_SELF(tskid);
        p_tcb = get_tcb_self(tskid);

        t_lock_cpu();
        if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
                ercd = E_NOEXS;
        }
        else if (TSTAT_DORMANT(p_tcb->tstat)) {
                ercd = E_OBJ;
        }
        else {
                *p_tskpri = EXT_TSKPRI(p_tcb->priority);
                ercd = E_OK;
        }
        t_unlock_cpu();

  error_exit:
        LOG_GET_PRI_LEAVE(ercd, *p_tskpri);
        return(ercd);
}

#endif /* TOPPERS_get_pri */

/*
 *  Œ«¥¿¥¹¥¯€Î³ÈÄ¥ŸðÊó€Î»²ŸÈ
 */
#ifdef TOPPERS_get_inf

ER
get_inf(intptr_t *p_exinf)
{
        ER              ercd;

        LOG_GET_INF_ENTER(p_exinf);
        CHECK_TSKCTX_UNL();

        t_lock_cpu();
        *p_exinf = p_runtsk->p_tinib->exinf;
        ercd = E_OK;
        t_unlock_cpu();

  error_exit:
        LOG_GET_INF_LEAVE(ercd, *p_exinf);
        return(ercd);
}

#endif /* TOPPERS_get_inf */