SYSCALL ER
act_tsk(ID tskid)
{
TCB *tcb;
ER ercd;
LOG_ACT_TSK_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
tcb = get_tcb_self(tskid);
t_lock_cpu();
if (TSTAT_DORMANT(tcb->tstat)) {
if (make_active(tcb)) {
dispatch();
}
ercd = E_OK;
}
else if (!(tcb->actcnt)) {
tcb->actcnt = TRUE;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
t_unlock_cpu();
exit:
LOG_ACT_TSK_LEAVE(ercd);
return(ercd);
}
ER
sta_alm(ID almid, RELTIM almtim)
{
ALMCB *p_almcb;
ER ercd;
LOG_STA_ALM_ENTER(almid, almtim);
CHECK_TSKCTX_UNL();
CHECK_ALMID(almid);
CHECK_PAR(almtim <= TMAX_RELTIM);
p_almcb = get_almcb(almid);
t_lock_cpu();
if (p_almcb->p_alminib->almatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (p_almcb->almsta) {
tmevtb_dequeue(&(p_almcb->tmevtb));
}
else {
p_almcb->almsta = true;
}
tmevtb_enqueue(&(p_almcb->tmevtb), almtim,
(CBACK) call_almhdr, (void *) p_almcb);
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_STA_ALM_LEAVE(ercd);
return(ercd);
}
ER
ref_alm(ID almid, T_RALM *pk_ralm)
{
ALMCB *p_almcb;
ER ercd;
LOG_REF_ALM_ENTER(almid, pk_ralm);
CHECK_TSKCTX_UNL();
CHECK_ALMID(almid);
p_almcb = get_almcb(almid);
t_lock_cpu();
if (p_almcb->p_alminib->almatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
if (p_almcb->almsta) {
pk_ralm->almstat = TALM_STA;
pk_ralm->lefttim = tmevt_lefttim(&(p_almcb->tmevtb));
}
else {
pk_ralm->almstat = TALM_STP;
}
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_REF_ALM_LEAVE(ercd, pk_ralm);
return(ercd);
}
ER
psnd_mbf(ID mbfid, const void *msg, uint_t msgsz)
{
MBFCB *p_mbfcb;
bool_t dspreq;
ER ercd;
LOG_PSND_MBF_ENTER(mbfid, msg, msgsz);
CHECK_TSKCTX_UNL();
CHECK_MBFID(mbfid);
p_mbfcb = get_mbfcb(mbfid);
CHECK_PAR(0 < msgsz && msgsz <= p_mbfcb->p_mbfinib->maxmsz);
t_lock_cpu();
if (send_message(p_mbfcb, msg, msgsz, &dspreq)) {
if (dspreq) {
dispatch();
}
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
error_exit:
LOG_PSND_MBF_LEAVE(ercd);
return(ercd);
}
ER
ini_mbf(ID mbfid)
{
MBFCB *p_mbfcb;
bool_t dspreq;
ER ercd;
LOG_INI_MBF_ENTER(mbfid);
CHECK_TSKCTX_UNL();
CHECK_MBFID(mbfid);
p_mbfcb = get_mbfcb(mbfid);
t_lock_cpu();
dspreq = init_wait_queue(&(p_mbfcb->swait_queue));
if (init_wait_queue(&(p_mbfcb->rwait_queue))) {
dspreq = true;
}
p_mbfcb->fmbfsz = p_mbfcb->p_mbfinib->mbfsz;
p_mbfcb->head = 0U;
p_mbfcb->tail = 0U;
p_mbfcb->smbfcnt = 0U;
if (dspreq) {
dispatch();
}
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_INI_MBF_LEAVE(ercd);
return(ercd);
}
ER
prcv_mbx(ID mbxid, T_MSG **ppk_msg)
{
MBXCB *p_mbxcb;
ER ercd;
LOG_PRCV_MBX_ENTER(mbxid, ppk_msg);
CHECK_TSKCTX_UNL();
CHECK_MBXID(mbxid);
p_mbxcb = get_mbxcb(mbxid);
t_lock_cpu();
if (p_mbxcb->pk_head != NULL) {
*ppk_msg = p_mbxcb->pk_head;
p_mbxcb->pk_head = (*ppk_msg)->pk_next;
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
error_exit:
LOG_PRCV_MBX_LEAVE(ercd, *ppk_msg);
return(ercd);
}
SYSCALL ER
sta_cyc(ID cycid)
{
CYCCB *cyccb;
ER ercd;
LOG_STA_CYC_ENTER(cycid);
CHECK_TSKCTX_UNL();
CHECK_CYCID(cycid);
cyccb = get_cyccb(cycid);
t_lock_cpu();
if (cyccb->cycsta) {
tmevtb_dequeue(&(cyccb->tmevtb));
}
else {
cyccb->cycsta = TRUE;
}
tmevtb_enqueue_cyc(cyccb, base_time + cyccb->cycinib->cyctim);
ercd = E_OK;
t_unlock_cpu();
exit:
LOG_STA_CYC_LEAVE(ercd);
return(ercd);
}
ER
twai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN *p_flgptn, TMO tmout)
{
FLGCB *p_flgcb;
WINFO_FLG *p_winfo_flg;
ER ercd;
PCB *my_p_pcb;
TCB *p_runtsk;
LOG_TWAI_FLG_ENTER(flgid, waiptn, wfmode, p_flgptn, tmout);
CHECK_TSKCTX_UNL();
CHECK_FLGID(flgid);
CHECK_PAR(waiptn != 0U);
CHECK_PAR(wfmode == TWF_ORW || wfmode == TWF_ANDW);
CHECK_TMOUT(tmout);
p_flgcb = get_flgcb(flgid);
t_lock_cpu();
my_p_pcb = get_my_p_pcb();
T_CHECK_DISPATCH(my_p_pcb);
retry:
t_acquire_obj_lock(&GET_OBJLOCK(p_flgcb));
if ((p_flgcb->p_flginib->flgatr & TA_WMUL) == 0U
&& !queue_empty(&(p_flgcb->wait_queue))) {
release_obj_lock(&GET_OBJLOCK(p_flgcb));
ercd = E_ILUSE;
}
else if (check_flg_cond(p_flgcb, waiptn, wfmode, p_flgptn)) {
release_obj_lock(&GET_OBJLOCK(p_flgcb));
ercd = E_OK;
}
else if (tmout == TMO_POL) {
release_obj_lock(&GET_OBJLOCK(p_flgcb));
ercd = E_TMOUT;
}
else {
if ((my_p_pcb = t_acquire_nested_tsk_lock_self(&GET_OBJLOCK(p_flgcb))) == NULL){
goto retry;
}
p_runtsk = my_p_pcb->p_runtsk;
p_winfo_flg = (WINFO_FLG *)(&(p_runtsk->winfo_obj));
p_winfo_flg->waiptn = waiptn;
p_winfo_flg->wfmode = wfmode;
p_runtsk->tstat = (TS_WAITING | TS_WAIT_FLG);
wobj_make_wait_tmout((WOBJCB *) p_flgcb, tmout, p_runtsk);
release_nested_tsk_lock(my_p_pcb);
release_obj_lock(&GET_OBJLOCK(p_flgcb));
dispatch();
ercd = p_runtsk->wercd;
if (ercd == E_OK) {
*p_flgptn = p_winfo_flg->flgptn;
}
}
t_unlock_cpu();
error_exit:
LOG_TWAI_FLG_LEAVE(ercd, *p_flgptn);
return(ercd);
}
ER
ini_flg(ID flgid)
{
FLGCB *p_flgcb;
ER ercd;
bool_t dspreq;
LOG_INI_FLG_ENTER(flgid);
CHECK_TSKCTX_UNL();
CHECK_FLGID(flgid);
p_flgcb = get_flgcb(flgid);
t_lock_cpu();
t_acquire_obj_lock(&GET_OBJLOCK(p_flgcb));
dspreq = init_wait_queue(&(p_flgcb->wait_queue));
p_flgcb->flgptn = p_flgcb->p_flginib->iflgptn;
ercd = E_OK;
release_obj_lock(&GET_OBJLOCK(p_flgcb));
if (dspreq) {
dispatch();
}
t_unlock_cpu();
error_exit:
LOG_INI_FLG_LEAVE(ercd);
return(ercd);
}
ER
ena_int(INTNO intno)
{
bool_t locked;
ER ercd;
LOG_ENA_INT_ENTER(intno);
CHECK_TSKCTX();
CHECK_INTNO_DISINT(intno);
locked = t_sense_lock();
if (!locked) {
t_lock_cpu();
}
if (t_enable_int(intno)) {
ercd = E_OK;
}
else {
ercd = E_OBJ;
}
if (!locked) {
t_unlock_cpu();
}
error_exit:
LOG_ENA_INT_LEAVE(ercd);
return(ercd);
}
ER
chg_ipm(PRI intpri)
{
bool_t locked;
ER ercd;
LOG_CHG_IPM_ENTER(intpri);
CHECK_TSKCTX();
CHECK_INTPRI_CHGIPM(intpri);
locked = t_sense_lock();
if (!locked) {
t_lock_cpu();
}
t_set_ipm(intpri);
if (intpri != TIPM_ENAALL) {
dspflg = false;
}
else if (!disdsp) {
dspflg = true;
if (p_runtsk != p_schedtsk) {
dispatch();
}
}
ercd = E_OK;
if (!locked) {
t_unlock_cpu();
}
error_exit:
LOG_CHG_IPM_LEAVE(ercd);
return(ercd);
}
ER
dis_int(INTNO intno)
{
bool_t locked;
ER ercd;
LOG_DIS_INT_ENTER(intno);
CHECK_TSKCTX();
CHECK_INTNO_DISINT(intno);
CHECK_ACPTN(sysstat_acvct.acptn2);
locked = t_sense_lock();
if (!locked) {
t_lock_cpu();
}
if (t_disable_int(intno)) {
ercd = E_OK;
}
else {
ercd = E_OBJ;
}
if (!locked) {
t_unlock_cpu();
}
error_exit:
LOG_DIS_INT_LEAVE(ercd);
return(ercd);
}
ER
del_isr(ID isrid)
{
ISRCB *p_isrcb;
ISRINIB *p_isrinib;
ER ercd;
LOG_DEL_ISR_ENTER(isrid);
CHECK_TSKCTX_UNL();
CHECK_ISRID(isrid);
p_isrcb = get_isrcb(isrid);
t_lock_cpu();
if (p_isrcb->p_isrinib->isratr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (VIOLATE_ACPTN(p_isrcb->p_isrinib->acvct.acptn3)) {
ercd = E_OACV;
}
else {
queue_delete(&(p_isrcb->isr_queue));
p_isrinib = (ISRINIB *)(p_isrcb->p_isrinib);
p_isrinib->isratr = TA_NOEXS;
queue_insert_prev(&free_isrcb, &(p_isrcb->isr_queue));
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_DEL_ISR_LEAVE(ercd);
return(ercd);
}
ER
sac_isr(ID isrid, const ACVCT *p_acvct)
{
ISRCB *p_isrcb;
ISRINIB *p_isrinib;
ER ercd;
LOG_SAC_ISR_ENTER(isrid, p_acvct);
CHECK_TSKCTX_UNL();
CHECK_ISRID(isrid);
CHECK_MACV_READ(p_acvct, ACVCT);
p_isrcb = get_isrcb(isrid);
t_lock_cpu();
if (p_isrcb->p_isrinib->isratr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (VIOLATE_ACPTN(p_isrcb->p_isrinib->acvct.acptn3)) {
ercd = E_OACV;
}
else {
p_isrinib = (ISRINIB *)(p_isrcb->p_isrinib);
p_isrinib->acvct = *p_acvct;
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_SAC_ISR_LEAVE(ercd);
return(ercd);
}
SYSCALL ER
tslp_tsk(TMO tmout)
{
WINFO winfo;
TMEVTB tmevtb;
ER ercd;
LOG_TSLP_TSK_ENTER(tmout);
CHECK_DISPATCH();
CHECK_TMOUT(tmout);
t_lock_cpu();
if (runtsk->wupcnt) {
runtsk->wupcnt = FALSE;
ercd = E_OK;
}
else if (tmout == TMO_POL) {
ercd = E_TMOUT;
}
else {
runtsk->tstat = (TS_WAITING | TS_WAIT_SLEEP);
make_wait_tmout(&winfo, &tmevtb, tmout);
LOG_TSKSTAT(runtsk);
dispatch();
ercd = winfo.wercd;
}
t_unlock_cpu();
exit:
LOG_TSLP_TSK_LEAVE(ercd);
return(ercd);
}
ER
get_pri(ID tskid, PRI *p_tskpri)
{
TCB *p_tcb;
ER ercd;
PCB *p_pcb;
LOG_GET_PRI_ENTER(tskid, p_tskpri);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
t_lock_cpu();
p_tcb = get_tcb_self(tskid, get_my_p_pcb());
p_pcb = t_acquire_tsk_lock(p_tcb);
if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
}
else {
*p_tskpri = EXT_TSKPRI(p_tcb->priority);
ercd = E_OK;
}
release_tsk_lock(p_pcb);
t_unlock_cpu();
error_exit:
LOG_GET_PRI_LEAVE(ercd, *p_tskpri);
return(ercd);
}
ER
rcv_mbx(ID mbxid, T_MSG **ppk_msg)
{
MBXCB *p_mbxcb;
WINFO_MBX winfo_mbx;
ER ercd;
LOG_RCV_MBX_ENTER(mbxid, ppk_msg);
CHECK_DISPATCH();
CHECK_MBXID(mbxid);
p_mbxcb = get_mbxcb(mbxid);
t_lock_cpu();
if (p_mbxcb->pk_head != NULL) {
*ppk_msg = p_mbxcb->pk_head;
p_mbxcb->pk_head = (*ppk_msg)->pk_next;
ercd = E_OK;
}
else {
p_runtsk->tstat = (TS_WAITING | TS_WAIT_MBX);
wobj_make_wait((WOBJCB *) p_mbxcb, (WINFO_WOBJ *) &winfo_mbx);
dispatch();
ercd = winfo_mbx.winfo.wercd;
if (ercd == E_OK) {
*ppk_msg = winfo_mbx.pk_msg;
}
}
t_unlock_cpu();
error_exit:
LOG_RCV_MBX_LEAVE(ercd, *ppk_msg);
return(ercd);
}
static ER
ipol_sem(ID semid)
{
SEMCB *p_semcb;
ER ercd;
// LOG_POL_SEM_ENTER(semid);
// CHECK_TSKCTX_UNL();
// CHECK_SEMID(semid);
p_semcb = get_semcb(semid);
t_lock_cpu();
/* if (p_semcb->p_seminib->sematr == TA_NOEXS) {
ercd = E_NOEXS;
}
else */if (p_semcb->semcnt >= 1) {
p_semcb->semcnt -= 1;
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
// error_exit:
// LOG_POL_SEM_LEAVE(ercd);
return(ercd);
}
ER
ini_mbx(ID mbxid)
{
MBXCB *p_mbxcb;
bool_t dspreq;
ER ercd;
LOG_INI_MBX_ENTER(mbxid);
CHECK_TSKCTX_UNL();
CHECK_MBXID(mbxid);
p_mbxcb = get_mbxcb(mbxid);
t_lock_cpu();
dspreq = init_wait_queue(&(p_mbxcb->wait_queue));
p_mbxcb->pk_head = NULL;
if (dspreq) {
dispatch();
}
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_INI_MBX_LEAVE(ercd);
return(ercd);
}
SYSCALL ER
wup_tsk(ID tskid)
{
TCB *tcb;
UINT tstat;
ER ercd;
LOG_WUP_TSK_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
tcb = get_tcb_self(tskid);
t_lock_cpu();
if (TSTAT_DORMANT(tstat = tcb->tstat)) {
ercd = E_OBJ;
}
else if ((tstat & TS_WAIT_SLEEP) != 0) {
if (wait_complete(tcb)) {
dispatch();
}
ercd = E_OK;
}
else if (!(tcb->wupcnt)) {
tcb->wupcnt = TRUE;
ercd = E_OK;
}
else {
ercd = E_QOVR;
}
t_unlock_cpu();
exit:
LOG_WUP_TSK_LEAVE(ercd);
return(ercd);
}
ER
snd_mbf(ID mbfid, const void *msg, uint_t msgsz)
{
MBFCB *p_mbfcb;
WINFO_MBF winfo_mbf;
bool_t dspreq;
ER ercd;
LOG_SND_MBF_ENTER(mbfid, msg, msgsz);
CHECK_DISPATCH();
CHECK_MBFID(mbfid);
p_mbfcb = get_mbfcb(mbfid);
CHECK_PAR(0 < msgsz && msgsz <= p_mbfcb->p_mbfinib->maxmsz);
t_lock_cpu();
if (send_message(p_mbfcb, msg, msgsz, &dspreq)) {
if (dspreq) {
dispatch();
}
ercd = E_OK;
}
else {
winfo_mbf.msg = (void *) msg;
winfo_mbf.msgsz = msgsz;
p_runtsk->tstat = (TS_WAITING | TS_WAIT_SMBF);
wobj_make_wait((WOBJCB *) p_mbfcb, (WINFO_WOBJ *) &winfo_mbf);
dispatch();
ercd = winfo_mbf.winfo.wercd;
}
t_unlock_cpu();
error_exit:
LOG_SND_MBF_LEAVE(ercd);
return(ercd);
}
SYSCALL ER_UINT
can_wup(ID tskid)
{
TCB *tcb;
ER_UINT ercd;
LOG_CAN_WUP_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
tcb = get_tcb_self(tskid);
t_lock_cpu();
if (TSTAT_DORMANT(tcb->tstat)) {
ercd = E_OBJ;
}
else {
ercd = tcb->wupcnt ? 1 : 0;
tcb->wupcnt = FALSE;
}
t_unlock_cpu();
exit:
LOG_CAN_WUP_LEAVE(ercd);
return(ercd);
}
ER
prcv_mbf(ID mbfid, void *msg)
{
MBFCB *p_mbfcb;
uint_t msgsz;
bool_t dspreq;
ER_UINT ercd;
LOG_PRCV_MBF_ENTER(mbfid, msg);
CHECK_TSKCTX_UNL();
CHECK_MBFID(mbfid);
p_mbfcb = get_mbfcb(mbfid);
t_lock_cpu();
if ((msgsz = receive_message(p_mbfcb, msg, &dspreq)) > 0U) {
if (dspreq) {
dispatch();
}
ercd = (ER_UINT) msgsz;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
error_exit:
LOG_PRCV_MBF_LEAVE(ercd, msg);
return(ercd);
}
SYSCALL ER
rel_wai(ID tskid)
{
TCB *tcb;
ER ercd;
LOG_REL_WAI_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID(tskid);
tcb = get_tcb(tskid);
t_lock_cpu();
if (!(TSTAT_WAITING(tcb->tstat))) {
ercd = E_OBJ;
}
else {
if (wait_release(tcb)) {
dispatch();
}
ercd = E_OK;
}
t_unlock_cpu();
exit:
LOG_REL_WAI_LEAVE(ercd);
return(ercd);
}
ER_UINT
acre_alm(const T_CALM *pk_calm)
{
ALMCB *p_almcb;
ALMINIB *p_alminib;
ER ercd;
LOG_ACRE_ALM_ENTER(pk_calm);
CHECK_TSKCTX_UNL();
CHECK_RSATR(pk_calm->almatr, TA_NULL);
CHECK_ALIGN_FUNC(pk_calm->almhdr);
CHECK_NONNULL_FUNC(pk_calm->almhdr);
t_lock_cpu();
if (tnum_alm == 0 || queue_empty(&free_almcb)) {
ercd = E_NOID;
}
else {
p_almcb = ((ALMCB *)(((char *) queue_delete_next(&free_almcb))
- offsetof(ALMCB, tmevtb)));
p_alminib = (ALMINIB *)(p_almcb->p_alminib);
p_alminib->almatr = pk_calm->almatr;
p_alminib->exinf = pk_calm->exinf;
p_alminib->almhdr = pk_calm->almhdr;
p_almcb->almsta = false;
ercd = ALMID(p_almcb);
}
t_unlock_cpu();
error_exit:
LOG_ACRE_ALM_LEAVE(ercd);
return(ercd);
}
SYSCALL ER
dly_tsk(RELTIM dlytim)
{
WINFO winfo;
TMEVTB tmevtb;
ER ercd;
LOG_DLY_TSK_ENTER(dlytim);
CHECK_DISPATCH();
CHECK_PAR(dlytim <= TMAX_RELTIM);
t_lock_cpu();
runtsk->tstat = TS_WAITING;
make_non_runnable(runtsk);
runtsk->winfo = &winfo;
winfo.tmevtb = &tmevtb;
tmevtb_enqueue(&tmevtb, dlytim, (CBACK) wait_tmout_ok, (VP) runtsk);
LOG_TSKSTAT(runtsk);
dispatch();
ercd = winfo.wercd;
t_unlock_cpu();
exit:
LOG_DLY_TSK_LEAVE(ercd);
return(ercd);
}
ER
stp_alm(ID almid)
{
ALMCB *p_almcb;
ER ercd;
LOG_STP_ALM_ENTER(almid);
CHECK_TSKCTX_UNL();
CHECK_ALMID(almid);
p_almcb = get_almcb(almid);
t_lock_cpu();
if (p_almcb->p_alminib->almatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (p_almcb->almsta) {
p_almcb->almsta = false;
tmevtb_dequeue(&(p_almcb->tmevtb));
}
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_STP_ALM_LEAVE(ercd);
return(ercd);
}
SYSCALL ER
slp_tsk()
{
WINFO winfo;
ER ercd;
LOG_SLP_TSK_ENTER();
CHECK_DISPATCH();
t_lock_cpu();
if (runtsk->wupcnt) {
runtsk->wupcnt = FALSE;
ercd = E_OK;
}
else {
runtsk->tstat = (TS_WAITING | TS_WAIT_SLEEP);
make_wait(&winfo);
LOG_TSKSTAT(runtsk);
dispatch();
ercd = winfo.wercd;
}
t_unlock_cpu();
exit:
LOG_SLP_TSK_LEAVE(ercd);
return(ercd);
}
ER
pol_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN *p_flgptn)
{
FLGCB *p_flgcb;
ER ercd;
LOG_POL_FLG_ENTER(flgid, waiptn, wfmode, p_flgptn);
CHECK_TSKCTX_UNL();
CHECK_FLGID(flgid);
CHECK_PAR(waiptn != 0U);
CHECK_PAR(wfmode == TWF_ORW || wfmode == TWF_ANDW);
p_flgcb = get_flgcb(flgid);
t_lock_cpu();
if ((p_flgcb->p_flginib->flgatr & TA_WMUL) == 0U
&& !queue_empty(&(p_flgcb->wait_queue))) {
ercd = E_ILUSE;
}
else if (check_flg_cond(p_flgcb, waiptn, wfmode, p_flgptn)) {
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
error_exit:
LOG_POL_FLG_LEAVE(ercd, *p_flgptn);
return(ercd);
}
SYSCALL ER
get_pri(ID tskid, PRI *p_tskpri)
{
TCB *tcb;
ER ercd;
LOG_GET_PRI_ENTER(tskid, p_tskpri);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
tcb = get_tcb_self(tskid);
t_lock_cpu();
if (TSTAT_DORMANT(tcb->tstat)) {
ercd = E_OBJ;
}
else {
*p_tskpri = EXT_TSKPRI(tcb->priority);
ercd = E_OK;
}
t_unlock_cpu();
exit:
LOG_GET_PRI_LEAVE(ercd, *p_tskpri);
return(ercd);
}
