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
chg_ipm(PRI intpri)
{
ER ercd;
LOG_CHG_IPM_ENTER(intpri);
CHECK_TSKCTX_UNL();
CHECK_INTPRI_CHGIPM(intpri);
t_lock_cpu();
t_set_ipm(intpri);
if (intpri == TIPM_ENAALL) {
ipmflg = true;
if (!disdsp) {
dspflg = true;
if (p_runtsk != p_schedtsk) {
dispatch();
}
}
if (p_runtsk->enatex && p_runtsk->texptn != 0U) {
call_texrtn();
}
}
else {
ipmflg = false;
dspflg = false;
}
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_CHG_IPM_LEAVE(ercd);
return(ercd);
}
ER
prcv_pdq(ID pdqid, intptr_t *p_data, PRI *p_datapri)
{
PDQCB *p_pdqcb;
bool_t reqdsp;
ER ercd;
LOG_PRCV_PDQ_ENTER(pdqid, p_data, p_datapri);
CHECK_TSKCTX_UNL();
CHECK_PDQID(pdqid);
p_pdqcb = get_pdqcb(pdqid);
t_lock_cpu();
if (p_pdqcb->p_pdqinib->pdqatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (receive_pridata(p_pdqcb, p_data, p_datapri, &reqdsp)) {
if (reqdsp) {
dispatch();
}
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
error_exit:
LOG_PRCV_PDQ_LEAVE(ercd, *p_data, *p_datapri);
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_NOEXS) {
ercd = E_NOEXS;
}
else 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);
}
ER
ref_flg(ID flgid, T_RFLG *pk_rflg)
{
FLGCB *p_flgcb;
ER ercd;
LOG_REF_FLG_ENTER(flgid, pk_rflg);
CHECK_TSKCTX_UNL();
CHECK_FLGID(flgid);
p_flgcb = get_flgcb(flgid);
t_lock_cpu();
if (p_flgcb->p_flginib->flgatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
pk_rflg->wtskid = wait_tskid(&(p_flgcb->wait_queue));
pk_rflg->flgptn = p_flgcb->flgptn;
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_REF_FLG_LEAVE(ercd, pk_rflg);
return(ercd);
}
ER
pget_mpf(ID mpfid, void **p_blk)
{
MPFCB *p_mpfcb;
ER ercd;
LOG_PGET_MPF_ENTER(mpfid, p_blk);
CHECK_TSKCTX_UNL();
CHECK_MPFID(mpfid);
p_mpfcb = get_mpfcb(mpfid);
t_lock_cpu();
if (p_mpfcb->fblkcnt > 0) {
get_mpf_block(p_mpfcb, p_blk);
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
error_exit:
LOG_PGET_MPF_LEAVE(ercd, *p_blk);
return(ercd);
}
ER_UINT
acre_flg(const T_CFLG *pk_cflg)
{
FLGCB *p_flgcb;
FLGINIB *p_flginib;
ER ercd;
LOG_ACRE_FLG_ENTER(pk_cflg);
CHECK_TSKCTX_UNL();
CHECK_RSATR(pk_cflg->flgatr, TA_TPRI|TA_WMUL|TA_CLR);
t_lock_cpu();
if (tnum_flg == 0 || queue_empty(&free_flgcb)) {
ercd = E_NOID;
}
else {
p_flgcb = ((FLGCB *) queue_delete_next(&free_flgcb));
p_flginib = (FLGINIB *)(p_flgcb->p_flginib);
p_flginib->flgatr = pk_cflg->flgatr;
p_flginib->iflgptn = pk_cflg->iflgptn;
queue_initialize(&(p_flgcb->wait_queue));
p_flgcb->flgptn = p_flgcb->p_flginib->iflgptn;
ercd = FLGID(p_flgcb);
}
t_unlock_cpu();
error_exit:
LOG_ACRE_FLG_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
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
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);
}
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
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);
}
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);
}
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
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
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);
}
ER
get_mpf(ID mpfid, void **p_blk)
{
MPFCB *p_mpfcb;
WINFO_MPF winfo_mpf;
ER ercd;
LOG_GET_MPF_ENTER(mpfid, p_blk);
CHECK_DISPATCH();
CHECK_MPFID(mpfid);
p_mpfcb = get_mpfcb(mpfid);
t_lock_cpu();
if (p_mpfcb->fblkcnt > 0) {
get_mpf_block(p_mpfcb, p_blk);
ercd = E_OK;
}
else {
p_runtsk->tstat = (TS_WAITING | TS_WAIT_MPF);
wobj_make_wait((WOBJCB *) p_mpfcb, (WINFO_WOBJ *) &winfo_mpf);
dispatch();
ercd = winfo_mpf.winfo.wercd;
if (ercd == E_OK) {
*p_blk = winfo_mpf.blk;
}
}
t_unlock_cpu();
error_exit:
LOG_GET_MPF_LEAVE(ercd, *p_blk);
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_mpf(ID mpfid)
{
MPFCB *p_mpfcb;
bool_t dspreq;
ER ercd;
LOG_INI_MPF_ENTER(mpfid);
CHECK_TSKCTX_UNL();
CHECK_MPFID(mpfid);
p_mpfcb = get_mpfcb(mpfid);
t_lock_cpu();
dspreq = init_wait_queue(&(p_mpfcb->wait_queue));
p_mpfcb->fblkcnt = p_mpfcb->p_mpfinib->blkcnt;
p_mpfcb->unused = 0U;
p_mpfcb->freelist = INDEX_NULL;
if (dspreq) {
dispatch();
}
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_INI_MPF_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);
}
ER
clr_flg(ID flgid, FLGPTN clrptn)
{
FLGCB *p_flgcb;
ER ercd;
LOG_CLR_FLG_ENTER(flgid, clrptn);
CHECK_TSKCTX_UNL();
CHECK_FLGID(flgid);
p_flgcb = get_flgcb(flgid);
t_lock_cpu();
if (p_flgcb->p_flginib->flgatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
p_flgcb->flgptn &= clrptn;
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_CLR_FLG_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
ini_flg(ID flgid)
{
FLGCB *p_flgcb;
bool_t dspreq;
ER ercd;
LOG_INI_FLG_ENTER(flgid);
CHECK_TSKCTX_UNL();
CHECK_FLGID(flgid);
p_flgcb = get_flgcb(flgid);
t_lock_cpu();
if (p_flgcb->p_flginib->flgatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
dspreq = init_wait_queue(&(p_flgcb->wait_queue));
p_flgcb->flgptn = p_flgcb->p_flginib->iflgptn;
if (dspreq) {
dispatch();
}
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_INI_FLG_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);
}
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
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
psnd_pdq(ID pdqid, intptr_t data, PRI datapri)
{
PDQCB *p_pdqcb;
bool_t reqdsp;
ER ercd;
LOG_PSND_PDQ_ENTER(pdqid, data, datapri);
CHECK_TSKCTX_UNL();
CHECK_PDQID(pdqid);
p_pdqcb = get_pdqcb(pdqid);
CHECK_PAR(TMIN_DPRI <= datapri && datapri <= p_pdqcb->p_pdqinib->maxdpri);
t_lock_cpu();
if (p_pdqcb->p_pdqinib->pdqatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (send_pridata(p_pdqcb, data, datapri, &reqdsp)) {
if (reqdsp) {
dispatch();
}
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
t_unlock_cpu();
error_exit:
LOG_PSND_PDQ_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);
}
ER
ref_pdq(ID pdqid, T_RPDQ *pk_rpdq)
{
PDQCB *p_pdqcb;
ER ercd;
LOG_REF_PDQ_ENTER(pdqid, pk_rpdq);
CHECK_TSKCTX_UNL();
CHECK_PDQID(pdqid);
p_pdqcb = get_pdqcb(pdqid);
t_lock_cpu();
if (p_pdqcb->p_pdqinib->pdqatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
pk_rpdq->stskid = wait_tskid(&(p_pdqcb->swait_queue));
pk_rpdq->rtskid = wait_tskid(&(p_pdqcb->rwait_queue));
pk_rpdq->spdqcnt = p_pdqcb->count;
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_REF_PDQ_LEAVE(ercd, pk_rpdq);
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);
}
