/*
* イベント待ち
*/
StatusType
WaitEvent(EventMaskType mask)
{
StatusType ercd = E_OK;
LOG_WAIEVT_ENTER(mask);
CHECK_CALLEVEL(TCL_TASK);
CHECK_ACCESS(runtsk < tnum_exttask);
CHECK_RESOURCE(tcb_lastres[runtsk] == RESID_NULL);
lock_cpu();
if ((tcb_curevt[runtsk] & mask) == EVTMASK_NONE) {
tcb_curpri[runtsk] = tinib_inipri[runtsk];
tcb_tstat[runtsk] = TS_WAITING;
tcb_waievt[runtsk] = mask;
search_schedtsk();
dispatch();
tcb_curpri[runtsk] = tinib_exepri[runtsk];
}
exit:
unlock_cpu();
LOG_WAIEVT_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
_errorhook_par1.mask = mask;
call_errorhook(ercd, OSServiceId_WaitEvent);
goto exit;
}
/*
* cancle the alarm
*
*/
StatusType
CancelAlarm(AlarmType almid)
{
StatusType ercd = E_OK;
LOG_CANALM_ENTER(almid);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2);
CHECK_ALMID(almid);
lock_cpu();
if (almcb_next[almid] == almid) {
ercd = E_OS_NOFUNC;
goto d_error_exit;
}
dequeue_alarm(almid, alminib_cntid[almid]);
/*
* set alarm cycle to zero
* if something wrong with dequeue_alarm() not really cancel
* this alarm, the Zero value of alarm cycle will make sure
* it will be auto-cancled at the next expiry value when SignalCounter()
*/
almcb_cycle[almid] = 0u;
exit:
unlock_cpu();
LOG_CANALM_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
d_error_exit:
_errorhook_par1.almid = almid;
call_errorhook(ercd, OSServiceId_CancelAlarm);
goto exit;
}
/*
* イベントの状態参照
*/
StatusType
GetEvent(TaskType tskid, EventMaskRefType p_mask)
{
StatusType ercd = E_OK;
LOG_GETEVT_ENTER(tskid, p_mask);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2 | TCL_ERROR | TCL_PREPOST);
CHECK_TSKID(tskid);
CHECK_ACCESS(tskid < tnum_exttask);
lock_cpu();
D_CHECK_STATE(tcb_tstat[tskid] != TS_DORMANT);
*p_mask = tcb_curevt[tskid];
exit:
unlock_cpu();
LOG_GETEVT_LEAVE(ercd, *p_mask);
return(ercd);
error_exit:
lock_cpu();
d_error_exit:
_errorhook_par1.tskid = tskid;
_errorhook_par2.p_mask = p_mask;
call_errorhook(ercd, OSServiceId_GetEvent);
goto exit;
}
/*
* スケジューラの呼び出し
*/
StatusType
Schedule(void)
{
/*
* ここでの ercd の初期化は本来は不要であるが，コンパイラの警
* 告メッセージを避けるために初期化している．
*/
StatusType ercd = E_OK;
LOG_SCHED_ENTER();
CHECK_CALLEVEL(TCL_TASK);
CHECK_RESOURCE(tcb_lastres[runtsk] == RESID_NULL);
lock_cpu();
if (tinib_inipri[runtsk] < nextpri) {
tcb_curpri[runtsk] = tinib_inipri[runtsk];
preempt();
dispatch();
tcb_curpri[runtsk] = tinib_exepri[runtsk];
}
exit:
unlock_cpu();
LOG_SCHED_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
call_errorhook(ercd, OSServiceId_Schedule);
goto exit;
}
/*
* 実行状態のタスクIDの参照
*/
StatusType
GetTaskID(TaskRefType p_tskid)
{
StatusType ercd = E_OK;
LOG_GETTID_ENTER(p_tskid);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2 | TCL_ERROR | TCL_PREPOST);
lock_cpu();
*p_tskid = runtsk;
/*
* 本来は runtsk ではなく以下の式になるべきだが，TSKID_NULL
* と INVALID_TASK は等しいので，単に runtsk でよい．
* (runtsk == TSKID_NULL) ? INVALID_TASK : runtsk
*/
exit:
unlock_cpu();
LOG_GETTID_LEAVE(ercd, *p_tskid);
return(ercd);
error_exit:
lock_cpu();
call_errorhook(ercd, OSServiceId_GetTaskID);
goto exit;
}
/*
* タスクの起動
*/
StatusType
ActivateTask(TaskType tskid)
{
StatusType ercd = E_OK;
LOG_ACTTSK_ENTER(tskid);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2);
CHECK_TSKID(tskid);
lock_cpu();
if (tcb_tstat[tskid] == TS_DORMANT) {
if ((make_active(tskid)) && (callevel == TCL_TASK)) {
dispatch();
}
}
else if (tcb_actcnt[tskid] < tinib_maxact[tskid]) {
tcb_actcnt[tskid] += 1;
}
else {
ercd = E_OS_LIMIT;
goto d_error_exit;
}
exit:
unlock_cpu();
LOG_ACTTSK_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
d_error_exit:
_errorhook_par1.tskid = tskid;
call_errorhook(ercd, OSServiceId_ActivateTask);
goto exit;
}
/*
* イベントのセット
*/
StatusType
SetEvent(TaskType tskid, EventMaskType mask)
{
StatusType ercd = E_OK;
LOG_SETEVT_ENTER(tskid, mask);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2);
CHECK_TSKID(tskid);
CHECK_ACCESS(tskid < tnum_exttask);
lock_cpu();
D_CHECK_STATE(tcb_tstat[tskid] != TS_DORMANT);
tcb_curevt[tskid] |= mask;
if ((tcb_curevt[tskid] & tcb_waievt[tskid]) != EVTMASK_NONE) {
tcb_waievt[tskid] = EVTMASK_NONE;
if ((make_runnable(tskid)) && (callevel == TCL_TASK)) {
dispatch();
}
}
exit:
unlock_cpu();
LOG_SETEVT_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
d_error_exit:
_errorhook_par1.tskid = tskid;
_errorhook_par2.mask = mask;
call_errorhook(ercd, OSServiceId_SetEvent);
goto exit;
}
/*
* 自タスクの終了
*/
StatusType
TerminateTask(void)
{
StatusType ercd = E_OK;
LOG_TERTSK_ENTER();
CHECK_CALLEVEL(TCL_TASK);
CHECK_RESOURCE(tcb_lastres[runtsk] == RESID_NULL);
lock_cpu();
/*
* 内部リソースの解放は優先度を下げるだけなので，ここでは
* 何もしなくてよい．
*/
tcb_tstat[runtsk] = TS_DORMANT;
search_schedtsk();
if (tcb_actcnt[runtsk] > 0) {
tcb_actcnt[runtsk] -= 1;
(void)make_active(runtsk);
}
exit_and_dispatch();
/* ここには戻ってこない */
error_exit:
lock_cpu();
call_errorhook(ercd, OSServiceId_TerminateTask);
unlock_cpu();
LOG_TERTSK_LEAVE(ercd);
return(ercd);
}
/*
* アラームの設定（絶対値）
*/
StatusType
SetAbsAlarm(AlarmType almid, TickType start, TickType cycle)
{
StatusType ercd = E_OK;
CounterType cntid;
TickType maxval, start2;
LOG_SETABS_ENTER(almid, start, cycle);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2);
CHECK_ALMID(almid);
cntid = alminib_cntid[almid];
maxval = cntinib_maxval[cntid];
CHECK_VALUE(start <= maxval);
CHECK_VALUE((cycle == 0u)
|| ((cntinib_mincyc[cntid] <= cycle) && (cycle <= maxval)));
lock_cpu();
if (almcb_next[almid] != almid) {
ercd = E_OS_STATE;
goto d_error_exit;
}
start2 = start + maxval + 1;
if (cntcb_curval[cntid] <= maxval) {
if (start <= cntcb_curval[cntid]) {
almcb_almval[almid] = start2;
}
else {
almcb_almval[almid] = start;
}
}
else {
if (start2 <= cntcb_curval[cntid]) {
almcb_almval[almid] = start;
}
else {
almcb_almval[almid] = start2;
}
}
almcb_cycle[almid] = cycle;
enqueue_alarm(almid, cntid);
exit:
unlock_cpu();
LOG_SETABS_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
d_error_exit:
_errorhook_par1.almid = almid;
_errorhook_par2.start = start;
_errorhook_par3.cycle = cycle;
call_errorhook(ercd, OSServiceId_SetAbsAlarm);
goto exit;
}
/*
* 自タスクの終了とタスクの起動
*/
StatusType
ChainTask(TaskType tskid)
{
/*
* ここでの ercd の初期化は本来は不要であるが，コンパイラの警
* 告メッセージを避けるために初期化している．
*/
StatusType ercd = E_OK;
LOG_CHNTSK_ENTER(tskid);
CHECK_CALLEVEL(TCL_TASK);
CHECK_RESOURCE(tcb_lastres[runtsk] == RESID_NULL);
CHECK_TSKID(tskid);
lock_cpu();
if (tskid == runtsk) {
// tcb_tstat[runtsk] = TS_DORMANT;
search_schedtsk();
(void)make_active(runtsk);
}
else {
/*
* エラー時に副作用が残らないように，エラーチェックは
* タスク終了処理の前に行う必要がある．
*/
if ((tcb_tstat[tskid] != TS_DORMANT)
&& (tcb_actcnt[tskid] >= tinib_maxact[tskid])) {
ercd = E_OS_LIMIT;
goto d_error_exit;
}
tcb_tstat[runtsk] = TS_DORMANT;
search_schedtsk();
if (tcb_actcnt[runtsk] > 0) {
tcb_actcnt[runtsk] -= 1;
(void)make_active(runtsk);
}
if (tcb_tstat[tskid] == TS_DORMANT) {
(void)make_active(tskid);
}
else {
tcb_actcnt[tskid] += 1;
}
}
exit_and_dispatch();
/* ここには戻ってこない */
error_exit:
lock_cpu();
d_error_exit:
_errorhook_par1.tskid = tskid;
call_errorhook(ercd, OSServiceId_ChainTask);
unlock_cpu();
LOG_CHNTSK_LEAVE(ercd);
return(ercd);
}
/*
* リソースの獲得
*/
StatusType
GetResource(ResourceType resid)
{
StatusType ercd = E_OK;
Priority ceilpri, curpri;
LOG_GETRES_ENTER(resid);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2);
CHECK_RESID(resid);
ceilpri = resinib_ceilpri[resid];
if (callevel == TCL_TASK) {
CHECK_ACCESS(tinib_inipri[runtsk] <= ceilpri);
lock_cpu();
D_CHECK_ACCESS(rescb_prevpri[resid] == TPRI_NULL);
curpri = tcb_curpri[runtsk];
rescb_prevpri[resid] = curpri;
rescb_prevres[resid] = tcb_lastres[runtsk];
tcb_lastres[runtsk] = resid;
if (ceilpri > curpri) {
tcb_curpri[runtsk] = ceilpri;
if (ceilpri >= TPRI_MINISR) {
set_ipl(ceilpri - TPRI_MINISR);
}
}
}
else {
CHECK_ACCESS(isrinib_intpri[runisr] <= ceilpri);
lock_cpu();
D_CHECK_ACCESS(rescb_prevpri[resid] == TPRI_NULL);
curpri = current_ipl() + TPRI_MINISR;
rescb_prevpri[resid] = curpri;
rescb_prevres[resid] = isrcb_lastres[runisr];
isrcb_lastres[runisr] = resid;
if (ceilpri > curpri) {
set_ipl(ceilpri - TPRI_MINISR);
}
}
exit:
unlock_cpu();
LOG_GETRES_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
d_error_exit:
_errorhook_par1.resid = resid;
call_errorhook(ercd, OSServiceId_GetResource);
goto exit;
}
/*
* リソースの返却
*/
StatusType
ReleaseResource(ResourceType resid)
{
StatusType ercd = E_OK;
LOG_RELRES_ENTER(resid);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2);
CHECK_RESID(resid);
if (callevel == TCL_TASK) {
CHECK_ACCESS(tinib_inipri[runtsk] <= resinib_ceilpri[resid]);
CHECK_NOFUNC(tcb_lastres[runtsk] == resid);
lock_cpu();
if (rescb_prevpri[resid] >= TPRI_MINISR) {
set_ipl(rescb_prevpri[resid] - TPRI_MINISR);
}
else{
if (tcb_curpri[runtsk] >= TPRI_MINISR) {
set_ipl(IPL_ENA_ALL);
}
}
tcb_curpri[runtsk] = rescb_prevpri[resid];
tcb_lastres[runtsk] = rescb_prevres[resid];
rescb_prevpri[resid] = TPRI_NULL;
if (tcb_curpri[runtsk] < nextpri) {
preempt();
dispatch();
}
}
else {
CHECK_ACCESS(isrinib_intpri[runisr] <= resinib_ceilpri[resid]);
CHECK_NOFUNC(isrcb_lastres[runisr] == resid);
lock_cpu();
set_ipl(rescb_prevpri[resid] - TPRI_MINISR);
isrcb_lastres[runisr] = rescb_prevres[resid];
rescb_prevpri[resid] = TPRI_NULL;
}
exit:
unlock_cpu();
LOG_RELRES_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
_errorhook_par1.resid = resid;
call_errorhook(ercd, OSServiceId_ReleaseResource);
goto exit;
}
ER_UINT
can_wup(ID tskid)
{
TCB *p_tcb;
ER_UINT ercd;
LOG_CAN_WUP_ENTER(tskid);
CHECK_TSKCTX_UNL();
if (tskid == TSK_SELF) {
p_tcb = p_runtsk;
}
else {
CHECK_ID(VALID_TSKID(tskid));
p_tcb = get_tcb(tskid);
}
lock_cpu();
if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
}
else {
ercd = p_tcb->wupque ? 1 : 0;
p_tcb->wupque = false;
}
unlock_cpu();
error_exit:
LOG_CAN_WUP_LEAVE(ercd);
return(ercd);
}
ER
pol_sem(ID semid)
{
SEMCB *p_semcb;
ER ercd;
LOG_POL_SEM_ENTER(semid);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_SEMID(semid));
p_semcb = get_semcb(semid);
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;
}
unlock_cpu();
error_exit:
LOG_POL_SEM_LEAVE(ercd);
return(ercd);
}
ER
ref_mtx(ID mtxid, T_RMTX *pk_rmtx)
{
MTXCB *p_mtxcb;
ER ercd;
LOG_REF_MTX_ENTER(mtxid, pk_rmtx);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_MTXID(mtxid));
CHECK_MACV_WRITE(pk_rmtx, T_RMTX);
p_mtxcb = get_mtxcb(mtxid);
lock_cpu();
if (p_mtxcb->p_mtxinib->mtxatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (VIOLATE_ACPTN(p_mtxcb->p_mtxinib->acvct.acptn4)) {
ercd = E_OACV;
}
else {
pk_rmtx->htskid = (p_mtxcb->p_loctsk != NULL) ?
TSKID(p_mtxcb->p_loctsk) : TSK_NONE;
pk_rmtx->wtskid = wait_tskid(&(p_mtxcb->wait_queue));
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_REF_MTX_LEAVE(ercd, pk_rmtx);
return(ercd);
}
ER
sta_alm(ID almid, RELTIM almtim)
{
ALMCB *p_almcb;
ER ercd;
LOG_STA_ALM_ENTER(almid, almtim);
CHECK_UNL();
CHECK_ID(VALID_ALMID(almid));
CHECK_PAR(VALID_RELTIM(almtim));
p_almcb = get_almcb(almid);
lock_cpu();
if (p_almcb->almsta) {
tmevtb_dequeue(&(p_almcb->tmevtb));
}
else {
p_almcb->almsta = true;
}
tmevtb_enqueue(&(p_almcb->tmevtb), almtim);
ercd = E_OK;
unlock_cpu();
error_exit:
LOG_STA_ALM_LEAVE(ercd);
return(ercd);
}
ER
get_pri(ID tskid, PRI *p_tskpri)
{
TCB *p_tcb;
ER ercd;
LOG_GET_PRI_ENTER(tskid, p_tskpri);
CHECK_TSKCTX_UNL(); /*［NGKI1203］［NGKI1204］*/
if (tskid == TSK_SELF) {
p_tcb = p_runtsk; /*［NGKI1211］*/
}
else {
CHECK_ID(VALID_TSKID(tskid)); /*［NGKI1205］*/
p_tcb = get_tcb(tskid);
}
lock_cpu();
if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ; /*［NGKI1209］*/
}
else {
*p_tskpri = EXT_TSKPRI(p_tcb->priority); /*［NGKI1210］*/
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_GET_PRI_LEAVE(ercd, p_tskpri);
return(ercd);
}
/*
* アラームベースの参照
*/
StatusType
GetAlarmBase(AlarmType almid, AlarmBaseRefType p_info)
{
StatusType ercd = E_OK;
CounterType cntid;
LOG_GETALB_ENTER(almid, p_info);
CHECK_CALLEVEL(TCL_TASK | TCL_ISR2 | TCL_ERROR | TCL_PREPOST);
CHECK_ALMID(almid);
cntid = alminib_cntid[almid];
p_info->maxallowedvalue = cntinib_maxval[cntid];
p_info->ticksperbase = cntinib_tickbase[cntid];
p_info->mincycle = cntinib_mincyc[cntid];
exit:
LOG_GETALB_LEAVE(ercd);
return(ercd);
error_exit:
lock_cpu();
_errorhook_par1.almid = almid;
_errorhook_par2.p_info = p_info;
call_errorhook(ercd, OSServiceId_GetAlarmBase);
unlock_cpu();
goto exit;
}
ER_UINT
can_act(ID tskid)
{
TCB *p_tcb;
ER_UINT ercd;
LOG_CAN_ACT_ENTER(tskid);
CHECK_TSKCTX_UNL(); /*［NGKI1139］［NGKI1140］*/
if (tskid == TSK_SELF) {
p_tcb = p_runtsk; /*［NGKI1146］*/
}
else {
CHECK_ID(VALID_TSKID(tskid)); /*［NGKI1141］*/
p_tcb = get_tcb(tskid);
}
lock_cpu();
ercd = p_tcb->actque ? 1 : 0; /*［NGKI1144］*/
p_tcb->actque = false; /*［NGKI1144］*/
unlock_cpu();
error_exit:
LOG_CAN_ACT_LEAVE(ercd);
return(ercd);
}
ER
ref_mpf(ID mpfid, T_RMPF *pk_rmpf)
{
MPFCB *p_mpfcb;
ER ercd;
LOG_REF_MPF_ENTER(mpfid, pk_rmpf);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_MPFID(mpfid));
p_mpfcb = get_mpfcb(mpfid);
lock_cpu();
if (p_mpfcb->p_mpfinib->mpfatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
pk_rmpf->wtskid = wait_tskid(&(p_mpfcb->wait_queue));
pk_rmpf->fblkcnt = p_mpfcb->fblkcnt;
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_REF_MPF_LEAVE(ercd, pk_rmpf);
return(ercd);
}
ER
ref_sem(ID semid, T_RSEM *pk_rsem)
{
SEMCB *p_semcb;
ER ercd;
LOG_REF_SEM_ENTER(semid, pk_rsem);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_SEMID(semid));
p_semcb = get_semcb(semid);
lock_cpu();
if (p_semcb->p_seminib->sematr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
pk_rsem->wtskid = wait_tskid(&(p_semcb->wait_queue));
pk_rsem->semcnt = p_semcb->semcnt;
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_REF_SEM_LEAVE(ercd, pk_rsem);
return(ercd);
}
ER
ini_sem(ID semid)
{
SEMCB *p_semcb;
ER ercd;
LOG_INI_SEM_ENTER(semid);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_SEMID(semid));
p_semcb = get_semcb(semid);
lock_cpu();
if (p_semcb->p_seminib->sematr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
init_wait_queue(&(p_semcb->wait_queue));
p_semcb->semcnt = p_semcb->p_seminib->isemcnt;
if (p_runtsk != p_schedtsk) {
dispatch();
}
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_INI_SEM_LEAVE(ercd);
return(ercd);
}
ER
ini_mpf(ID mpfid)
{
MPFCB *p_mpfcb;
ER ercd;
LOG_INI_MPF_ENTER(mpfid);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_MPFID(mpfid));
p_mpfcb = get_mpfcb(mpfid);
lock_cpu();
if (p_mpfcb->p_mpfinib->mpfatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else {
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 (p_runtsk != p_schedtsk) {
dispatch();
}
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_INI_MPF_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_ID(VALID_ALMID(almid));
p_almcb = get_almcb(almid);
lock_cpu();
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;
unlock_cpu();
error_exit:
LOG_REF_ALM_LEAVE(ercd, pk_ralm);
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_ID(VALID_MPFID(mpfid));
p_mpfcb = get_mpfcb(mpfid);
lock_cpu();
if (p_mpfcb->p_mpfinib->mpfatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (p_mpfcb->fblkcnt > 0) {
get_mpf_block(p_mpfcb, p_blk);
ercd = E_OK;
}
else {
ercd = E_TMOUT;
}
unlock_cpu();
error_exit:
LOG_PGET_MPF_LEAVE(ercd, p_blk);
return(ercd);
}
ER
sac_mtx(ID mtxid, const ACVCT *p_acvct)
{
MTXCB *p_mtxcb;
MTXINIB *p_mtxinib;
ER ercd;
LOG_SAC_MTX_ENTER(mtxid, p_acvct);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_MTXID(mtxid));
CHECK_MACV_READ(p_acvct, ACVCT);
p_mtxcb = get_mtxcb(mtxid);
lock_cpu();
if (p_mtxcb->p_mtxinib->mtxatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (VIOLATE_ACPTN(p_mtxcb->p_mtxinib->acvct.acptn3)) {
ercd = E_OACV;
}
else if (MTXID(p_mtxcb) <= tmax_smtxid) {
ercd = E_OBJ;
}
else {
p_mtxinib = (MTXINIB *)(p_mtxcb->p_mtxinib);
p_mtxinib->acvct = *p_acvct;
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_SAC_MTX_LEAVE(ercd);
return(ercd);
}
ER
ref_mbf(ID mbfid, T_RMBF *pk_rmbf)
{
MBFCB *p_mbfcb;
ER ercd;
LOG_REF_MBF_ENTER(mbfid, pk_rmbf);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_MBFID(mbfid));
CHECK_MACV_WRITE(pk_rmbf, T_RMBF);
p_mbfcb = get_mbfcb(mbfid);
lock_cpu();
if (p_mbfcb->p_mbfinib->mbfatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (VIOLATE_ACPTN(p_mbfcb->p_mbfinib->acvct.acptn4)) {
ercd = E_OACV;
}
else {
pk_rmbf->stskid = wait_tskid(&(p_mbfcb->swait_queue));
pk_rmbf->rtskid = wait_tskid(&(p_mbfcb->rwait_queue));
pk_rmbf->smbfcnt = p_mbfcb->smbfcnt;
pk_rmbf->fmbfsz = p_mbfcb->fmbfsz;
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_REF_MBF_LEAVE(ercd, pk_rmbf);
return(ercd);
}
ER
del_sem(ID semid)
{
SEMCB *p_semcb;
SEMINIB *p_seminib;
ER ercd;
LOG_DEL_SEM_ENTER(semid);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_SEMID(semid));
p_semcb = get_semcb(semid);
lock_cpu();
if (p_semcb->p_seminib->sematr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (semid <= tmax_ssemid) {
ercd = E_OBJ;
}
else {
init_wait_queue(&(p_semcb->wait_queue));
p_seminib = (SEMINIB *)(p_semcb->p_seminib);
p_seminib->sematr = TA_NOEXS;
queue_insert_prev(&free_semcb, &(p_semcb->wait_queue));
if (p_runtsk != p_schedtsk) {
dispatch();
}
ercd = E_OK;
}
unlock_cpu();
error_exit:
LOG_DEL_SEM_LEAVE(ercd);
return(ercd);
}
ER
set_dft(int32_t drift)
{
ER ercd;
LOG_SET_DFT_ENTER(drift);
CHECK_UNL(); /*［NGKI3598］*/
CHECK_PAR(TMIN_DRIFT <= drift && drift <= TMAX_DRIFT);
/*［NGKI3599］*/
lock_cpu();
update_current_evttim();
drift_rate = (uint32_t)(1000000U + drift); /*［NGKI3601］*/
evttim_step = (TSTEP_HRTCNT * drift_rate + 999999U) / 1000000U;
evttim_step_frac = (TSTEP_HRTCNT * drift_rate + 999999U) % 1000000U;
set_hrt_event();
ercd = E_OK;
unlock_cpu();
error_exit:
LOG_SET_DFT_LEAVE(ercd);
return(ercd);
}
ER
ini_pdq(ID pdqid)
{
PDQCB *p_pdqcb;
ER ercd;
LOG_INI_PDQ_ENTER(pdqid);
CHECK_TSKCTX_UNL();
CHECK_ID(VALID_PDQID(pdqid));
p_pdqcb = get_pdqcb(pdqid);
lock_cpu();
init_wait_queue(&(p_pdqcb->swait_queue));
init_wait_queue(&(p_pdqcb->rwait_queue));
p_pdqcb->count = 0U;
p_pdqcb->p_head = NULL;
p_pdqcb->unused = 0U;
p_pdqcb->p_freelist = NULL;
if (p_runtsk != p_schedtsk) {
dispatch();
}
ercd = E_OK;
unlock_cpu();
error_exit:
LOG_INI_PDQ_LEAVE(ercd);
return(ercd);
}
