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
sac_tsk(ID tskid, const ACVCT *p_acvct)
{
TCB *p_tcb;
TINIB *p_tinib;
ER ercd;
LOG_SAC_TSK_ENTER(tskid, p_acvct);
CHECK_TSKCTX_UNL();
CHECK_TSKID(tskid);
CHECK_MACV_READ(p_acvct, ACVCT);
p_tcb = get_tcb(tskid);
t_lock_cpu();
if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
ercd = E_NOEXS;
}
else if (VIOLATE_ACPTN(p_tcb->p_tinib->acvct.acptn3)) {
ercd = E_OACV;
}
else if (TSKID(p_tcb) > tmax_stskid) {
p_tinib = (TINIB *)(p_tcb->p_tinib);
p_tinib->acvct = *p_acvct;
ercd = E_OK;
}
else {
ercd = E_OBJ;
}
t_unlock_cpu();
error_exit:
LOG_SAC_TSK_LEAVE(ercd);
return(ercd);
}
/*
* get information about kernel
*/
static intptr_t
get_tskid(intptr_t info)
{
TCB *p_tcb;
ID tskid;
p_tcb = (TCB *) info;
if (p_tcb == NULL) {
tskid = 0;
}
else {
tskid = TSKID(p_tcb);
}
return((intptr_t) tskid);
}
ER
iget_tid(ID *p_tskid)
{
ER ercd;
LOG_IGET_TID_ENTER(p_tskid);
CHECK_INTCTX_UNL();
i_lock_cpu();
*p_tskid = (p_runtsk == NULL) ? TSK_NONE : TSKID(p_runtsk);
ercd = E_OK;
i_unlock_cpu();
error_exit:
LOG_IGET_TID_LEAVE(ercd, *p_tskid);
return(ercd);
}
ER
get_tid(ID *p_tskid)
{
ER ercd;
LOG_GET_TID_ENTER(p_tskid);
CHECK_TSKCTX_UNL();
t_lock_cpu();
*p_tskid = TSKID(p_runtsk);
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_GET_TID_LEAVE(ercd, *p_tskid);
return(ercd);
}
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 (VIOLATE_ACPTN(p_tcb->p_tinib->acvct.acptn3)) {
ercd = E_OACV;
}
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->sstk);
}
#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);
}
void
call_ovrhdr(void)
{
PRI saved_ipm;
assert(sense_context());
assert(!i_sense_lock());
assert(ovrinib.ovrhdr != NULL);
p_runtsk->leftotm = 0U;
saved_ipm = i_get_ipm();
LOG_OVR_ENTER(p_runtsk);
(*((OVRHDR)(ovrinib.ovrhdr)))(TSKID(p_runtsk), p_runtsk->p_tinib->exinf);
LOG_OVR_LEAVE(p_runtsk);
if (i_sense_lock()) {
i_unlock_cpu();
}
i_set_ipm(saved_ipm);
}
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_MTXID(mtxid);
p_mtxcb = get_mtxcb(mtxid);
t_lock_cpu();
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;
t_unlock_cpu();
error_exit:
LOG_REF_MTX_LEAVE(ercd, pk_rmtx);
return(ercd);
}
void
call_ovrhdr(void)
{
assert(sense_context());
assert(!i_sense_lock());
assert(ovrinib.ovrhdr != NULL);
i_lock_cpu();
if (p_runtsk!= NULL && p_runtsk->leftotm == 1U) {
p_runtsk->leftotm = 0U;
i_unlock_cpu();
LOG_OVR_ENTER(p_runtsk);
((OVRHDR)(ovrinib.ovrhdr))(TSKID(p_runtsk), p_runtsk->p_tinib->exinf);
LOG_OVR_LEAVE(p_runtsk);
}
else {
/*
* このルーチンが呼び出される前に，オーバランハンドラの起動が
* キャンセルされた場合
*/
i_unlock_cpu();
}
}
ER_UINT
acre_tsk(const T_CTSK *pk_ctsk)
{
ID domid;
const DOMINIB *p_dominib;
TCB *p_tcb;
TINIB *p_tinib;
ATR tskatr;
SIZE sstksz, ustksz;
void *sstk, *ustk;
ACPTN acptn;
ER ercd;
LOG_ACRE_TSK_ENTER(pk_ctsk);
CHECK_TSKCTX_UNL();
CHECK_MACV_READ(pk_ctsk, T_CTSK);
CHECK_RSATR(pk_ctsk->tskatr, TA_ACT|TARGET_TSKATR|TA_DOMMASK);
domid = get_atrdomid(pk_ctsk->tskatr);
CHECK_ATRDOMID_ACTIVE(domid);
CHECK_ALIGN_FUNC(pk_ctsk->task);
CHECK_NONNULL_FUNC(pk_ctsk->task);
CHECK_TPRI(pk_ctsk->itskpri);
p_dominib = (domid == TDOM_SELF) ? p_runtsk->p_tinib->p_dominib
: (domid == TDOM_KERNEL) ? &dominib_kernel : get_dominib(domid);
if (p_dominib == &dominib_kernel) {
/*
* システムタスクの場合
*/
ustksz = 0U;
ustk = NULL;
CHECK_PAR(pk_ctsk->sstk == NULL);
CHECK_PAR(pk_ctsk->stksz > 0U);
sstksz = pk_ctsk->stksz;
sstk = pk_ctsk->stk;
if (sstk != NULL) {
CHECK_PAR(pk_ctsk->sstksz == 0U);
}
else {
sstksz += pk_ctsk->sstksz;
}
}
else {
/*
* ユーザタスクの場合
*/
ustksz = pk_ctsk->stksz;
ustk = pk_ctsk->stk;
CHECK_PAR(ustksz >= TARGET_MIN_USTKSZ);
CHECK_NOSPT(ustk != NULL);
CHECK_TARGET_USTACK(ustksz, ustk, p_dominib);
sstksz = pk_ctsk->sstksz;
sstk = pk_ctsk->sstk;
}
CHECK_PAR(sstksz >= TARGET_MIN_SSTKSZ);
if (sstk != NULL) {
CHECK_ALIGN_STKSZ(sstksz);
CHECK_ALIGN_STACK(sstk);
}
CHECK_ACPTN(sysstat_acvct.acptn3);
tskatr = pk_ctsk->tskatr;
t_lock_cpu();
if (queue_empty(&free_tcb)) {
ercd = E_NOID;
}
else {
if (sstk == NULL) {
sstk = kernel_malloc(ROUND_STK_T(sstksz));
tskatr |= TA_MEMALLOC;
}
if (sstk == NULL) {
ercd = E_NOMEM;
}
else {
p_tcb = ((TCB *) queue_delete_next(&free_tcb));
p_tinib = (TINIB *)(p_tcb->p_tinib);
p_tinib->p_dominib = p_dominib;
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), p_dominib,
sstksz, sstk, utsksz, ustk, pk_ctsk);
#else /* USE_TSKINICTXB */
p_tinib->sstksz = sstksz;
p_tinib->sstk = sstk;
p_tinib->ustksz = ustksz;
p_tinib->ustk = ustk;
#endif /* USE_TSKINICTXB */
p_tinib->texatr = TA_NULL;
p_tinib->texrtn = NULL;
acptn = default_acptn(domid);
p_tinib->acvct.acptn1 = acptn;
p_tinib->acvct.acptn2 = acptn;
p_tinib->acvct.acptn3 = acptn | rundom;
p_tinib->acvct.acptn4 = acptn;
p_tcb->actque = false;
make_dormant(p_tcb);
queue_initialize(&(p_tcb->mutex_queue));
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);
}
ER_UINT
acre_tsk(const T_CTSK *pk_ctsk)
{
TCB *p_tcb;
TINIB *p_tinib;
ATR tskatr;
TASK task;
PRI itskpri;
size_t stksz;
STK_T *stk;
ER ercd;
LOG_ACRE_TSK_ENTER(pk_ctsk);
CHECK_TSKCTX_UNL();
tskatr = pk_ctsk->tskatr;
task = pk_ctsk->task;
itskpri = pk_ctsk->itskpri;
stksz = pk_ctsk->stksz;
stk = pk_ctsk->stk;
CHECK_RSATR(tskatr, TA_ACT|TA_NOACTQUE|TARGET_TSKATR);
CHECK_PAR(FUNC_ALIGN(task));
CHECK_PAR(FUNC_NONNULL(task));
CHECK_PAR(VALID_TPRI(itskpri));
CHECK_PAR(stksz >= TARGET_MIN_STKSZ);
if (stk != NULL) {
CHECK_PAR(STKSZ_ALIGN(stksz));
CHECK_PAR(STACK_ALIGN(stk));
}
lock_cpu();
if (queue_empty(&free_tcb)) {
ercd = E_NOID;
}
else {
if (stk == NULL) {
stk = kernel_malloc(ROUND_STK_T(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 = task;
p_tinib->ipriority = INT_PRIORITY(itskpri);
#ifdef USE_TSKINICTXB
init_tskinictxb(&(p_tinib->tskinictxb), stksz, stk);
#else /* USE_TSKINICTXB */
p_tinib->stksz = stksz;
p_tinib->stk = stk;
#endif /* USE_TSKINICTXB */
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);
}
}
unlock_cpu();
error_exit:
LOG_ACRE_TSK_LEAVE(ercd);
return(ercd);
}
