ER
ena_int(INTNO intno)
{
bool_t locked;
ER ercd;
LOG_ENA_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_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
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);
CHECK_MACV_WRITE(p_tskpri, PRI);
p_tcb = get_tcb_self(tskid);
CHECK_ACPTN(p_tcb->p_tinib->acvct.acptn4);
t_lock_cpu();
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);
}
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);
CHECK_ACPTN(p_tcb->p_tinib->acvct.acptn1);
t_lock_cpu();
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);
}
ER
ter_tsk(ID tskid)
{
TCB *p_tcb;
bool_t dspreq = false;
ER ercd;
LOG_TER_TSK_ENTER(tskid);
CHECK_TSKCTX_UNL();
CHECK_TSKID(tskid);
p_tcb = get_tcb(tskid);
CHECK_NONSELF(p_tcb);
CHECK_ACPTN(p_tcb->p_tinib->acvct.acptn2);
t_lock_cpu();
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)) {
if (wait_dequeue_wobj(p_tcb)) {
dspreq = true;
}
wait_dequeue_tmevtb(p_tcb);
}
if (!queue_empty(&(p_tcb->mutex_queue))) {
if ((*mtxhook_release_all)(p_tcb)) {
dspreq = true;
}
}
make_dormant(p_tcb);
if (p_tcb->actque) {
p_tcb->actque = false;
if (make_active(p_tcb)) {
dspreq = true;
}
}
if (dspreq) {
dispatch();
}
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_TER_TSK_LEAVE(ercd);
return(ercd);
}
ER_UINT
acre_isr(const T_CISR *pk_cisr)
{
ISRCB *p_isrcb;
ISRINIB *p_isrinib;
QUEUE *p_isr_queue;
ER ercd;
LOG_ACRE_ISR_ENTER(pk_cisr);
CHECK_TSKCTX_UNL();
CHECK_MACV_READ(pk_cisr, T_CISR);
CHECK_RSATR(pk_cisr->isratr, TARGET_ISRATR|TA_DOMMASK);
CHECK_ATRDOMID_KERNEL(get_atrdomid(pk_cisr->isratr));
CHECK_INTNO_CREISR(pk_cisr->intno);
CHECK_ALIGN_FUNC(pk_cisr->isr);
CHECK_NONNULL_FUNC(pk_cisr->isr);
CHECK_ISRPRI(pk_cisr->isrpri);
CHECK_ACPTN(sysstat_acvct.acptn3);
p_isr_queue = search_isr_queue(pk_cisr->intno);
CHECK_OBJ(p_isr_queue != NULL);
t_lock_cpu();
if (tnum_isr == 0 || queue_empty(&free_isrcb)) {
ercd = E_NOID;
}
else {
p_isrcb = ((ISRCB *) queue_delete_next(&free_isrcb));
p_isrinib = (ISRINIB *)(p_isrcb->p_isrinib);
p_isrinib->isratr = pk_cisr->isratr;
p_isrinib->exinf = pk_cisr->exinf;
p_isrinib->intno = pk_cisr->intno;
p_isrinib->p_isr_queue = p_isr_queue;
p_isrinib->isr = pk_cisr->isr;
p_isrinib->isrpri = pk_cisr->isrpri;
p_isrinib->acvct.acptn1 = TACP_KERNEL;
p_isrinib->acvct.acptn2 = TACP_KERNEL;
p_isrinib->acvct.acptn3 = TACP_KERNEL | rundom;
p_isrinib->acvct.acptn4 = TACP_KERNEL;
enqueue_isr(p_isr_queue, p_isrcb);
ercd = ISRID(p_isrcb);
}
t_unlock_cpu();
error_exit:
LOG_ACRE_ISR_LEAVE(ercd);
return(ercd);
}
ER_UINT
acre_sem(const T_CSEM *pk_csem)
{
ID domid;
SEMCB *p_semcb;
SEMINIB *p_seminib;
ACPTN acptn;
ER ercd;
LOG_ACRE_SEM_ENTER(pk_csem);
CHECK_TSKCTX_UNL();
CHECK_MACV_READ(pk_csem, T_CSEM);
CHECK_RSATR(pk_csem->sematr, TA_TPRI|TA_DOMMASK);
domid = get_atrdomid(pk_csem->sematr);
CHECK_ATRDOMID_INACTIVE(domid);
CHECK_PAR(0 <= pk_csem->isemcnt && pk_csem->isemcnt <= pk_csem->maxsem);
CHECK_PAR(1 <= pk_csem->maxsem && pk_csem->maxsem <= TMAX_MAXSEM);
CHECK_ACPTN(sysstat_acvct.acptn3);
t_lock_cpu();
if (tnum_sem == 0 || queue_empty(&free_semcb)) {
ercd = E_NOID;
}
else {
p_semcb = ((SEMCB *) queue_delete_next(&free_semcb));
p_seminib = (SEMINIB *)(p_semcb->p_seminib);
p_seminib->sematr = pk_csem->sematr;
p_seminib->isemcnt = pk_csem->isemcnt;
p_seminib->maxsem = pk_csem->maxsem;
acptn = default_acptn(domid);
p_seminib->acvct.acptn1 = acptn;
p_seminib->acvct.acptn2 = acptn;
p_seminib->acvct.acptn3 = acptn | rundom;
p_seminib->acvct.acptn4 = acptn;
queue_initialize(&(p_semcb->wait_queue));
p_semcb->semcnt = p_semcb->p_seminib->isemcnt;
ercd = SEMID(p_semcb);
}
t_unlock_cpu();
error_exit:
LOG_ACRE_SEM_LEAVE(ercd);
return(ercd);
}
ER
loc_cpu(void)
{
ER ercd;
LOG_LOC_CPU_ENTER();
CHECK_TSKCTX();
CHECK_ACPTN(sysstat_acvct.acptn2);
if (!t_sense_lock()) {
t_lock_cpu();
}
ercd = E_OK;
error_exit:
LOG_LOC_CPU_LEAVE(ercd);
return(ercd);
}
ER
chg_pri(ID tskid, PRI tskpri)
{
TCB *p_tcb;
uint_t newbpri;
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);
CHECK_ACPTN(p_tcb->p_tinib->acvct.acptn2);
newbpri = (tskpri == TPRI_INI) ? p_tcb->p_tinib->ipriority
: INT_PRIORITY(tskpri);
if (rundom != TACP_KERNEL) {
CHECK_ILUSE(newbpri >= p_runtsk->p_tinib->p_dominib->minpriority);
}
t_lock_cpu();
if (TSTAT_DORMANT(p_tcb->tstat)) {
ercd = E_OBJ;
}
else if ((!queue_empty(&(p_tcb->mutex_queue))
|| TSTAT_WAIT_MTX(p_tcb->tstat))
&& !((*mtxhook_check_ceilpri)(p_tcb, newbpri))) {
ercd = E_ILUSE;
}
else {
p_tcb->bpriority = newbpri;
if (queue_empty(&(p_tcb->mutex_queue))
|| !((*mtxhook_scan_ceilmtx)(p_tcb))) {
if (change_priority(p_tcb, newbpri, false)) {
dispatch();
}
}
ercd = E_OK;
}
t_unlock_cpu();
error_exit:
LOG_CHG_PRI_LEAVE(ercd);
return(ercd);
}
ER
get_ipm(PRI *p_intpri)
{
ER ercd;
LOG_GET_IPM_ENTER(p_intpri);
CHECK_TSKCTX_UNL();
CHECK_MACV_WRITE(p_intpri, PRI);
CHECK_ACPTN(sysstat_acvct.acptn4);
t_lock_cpu();
*p_intpri = t_get_ipm();
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_GET_IPM_LEAVE(ercd, *p_intpri);
return(ercd);
}
ER
dis_dsp(void)
{
ER ercd;
LOG_DIS_DSP_ENTER();
CHECK_TSKCTX_UNL();
CHECK_ACPTN(sysstat_acvct.acptn1);
t_lock_cpu();
disdsp = true;
dspflg = false;
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_DIS_DSP_LEAVE(ercd);
return(ercd);
}
ER_UINT
acre_flg(const T_CFLG *pk_cflg)
{
ID domid;
FLGCB *p_flgcb;
FLGINIB *p_flginib;
ACPTN acptn;
ER ercd;
LOG_ACRE_FLG_ENTER(pk_cflg);
CHECK_TSKCTX_UNL();
CHECK_MACV_READ(pk_cflg, T_CFLG);
CHECK_RSATR(pk_cflg->flgatr, TA_TPRI|TA_WMUL|TA_CLR|TA_DOMMASK);
domid = get_atrdomid(pk_cflg->flgatr);
CHECK_ATRDOMID_INACTIVE(domid);
CHECK_ACPTN(sysstat_acvct.acptn3);
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;
acptn = default_acptn(domid);
p_flginib->acvct.acptn1 = acptn;
p_flginib->acvct.acptn2 = acptn;
p_flginib->acvct.acptn3 = acptn | rundom;
p_flginib->acvct.acptn4 = acptn;
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_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);
CHECK_ACPTN(p_tcb->p_tinib->acvct.acptn1);
t_lock_cpu();
ercd = p_tcb->actque ? 1 : 0;
p_tcb->actque = false;
t_unlock_cpu();
error_exit:
LOG_CAN_ACT_LEAVE(ercd);
return(ercd);
}
ER
unl_cpu(void)
{
ER ercd;
LOG_UNL_CPU_ENTER();
CHECK_TSKCTX();
CHECK_ACPTN(sysstat_acvct.acptn2);
if (t_sense_lock()) {
if (p_runtsk->enatex && p_runtsk->texptn != 0U && ipmflg
&& rundom == TACP_KERNEL && p_runtsk->svclevel == 0U) {
call_texrtn_stask();
}
t_unlock_cpu();
}
ercd = E_OK;
error_exit:
LOG_UNL_CPU_LEAVE(ercd);
return(ercd);
}
ER
rot_rdq(PRI tskpri)
{
uint_t pri;
ER ercd;
LOG_ROT_RDQ_ENTER(tskpri);
CHECK_TSKCTX_UNL();
CHECK_TPRI_SELF(tskpri);
CHECK_ACPTN(sysstat_acvct.acptn1);
t_lock_cpu();
pri = (tskpri == TPRI_SELF) ? p_runtsk->bpriority : INT_PRIORITY(tskpri);
if (rotate_ready_queue(pri)) {
dispatch();
}
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_ROT_RDQ_LEAVE(ercd);
return(ercd);
}
ER
chg_ipm(PRI intpri)
{
ER ercd;
LOG_CHG_IPM_ENTER(intpri);
CHECK_TSKCTX_UNL();
CHECK_INTPRI_CHGIPM(intpri);
CHECK_ACPTN(sysstat_acvct.acptn2);
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
&& rundom == TACP_KERNEL && p_runtsk->svclevel == 0U) {
call_texrtn_stask();
}
}
else {
ipmflg = false;
dspflg = false;
}
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_CHG_IPM_LEAVE(ercd);
return(ercd);
}
ER
ena_dsp(void)
{
ER ercd;
LOG_ENA_DSP_ENTER();
CHECK_TSKCTX_UNL();
CHECK_ACPTN(sysstat_acvct.acptn1);
t_lock_cpu();
disdsp = false;
if (ipmflg) {
dspflg = true;
if (p_runtsk != p_schedtsk) {
dispatch();
}
}
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_ENA_DSP_LEAVE(ercd);
return(ercd);
}
ER_UINT
acre_mbf(const T_CMBF *pk_cmbf)
{
MBFCB *p_mbfcb;
MBFINIB *p_mbfinib;
ATR mbfatr;
uint_t maxmsz;
size_t mbfsz;
void *mbfmb;
ID domid;
const DOMINIB *p_dominib;
ACPTN acptn;
ER ercd;
LOG_ACRE_MBF_ENTER(pk_cmbf);
CHECK_TSKCTX_UNL();
CHECK_MACV_READ(pk_cmbf, T_CMBF);
mbfatr = pk_cmbf->mbfatr;
maxmsz = pk_cmbf->maxmsz;
mbfsz = pk_cmbf->mbfsz;
mbfmb = pk_cmbf->mbfmb;
CHECK_VALIDATR(mbfatr, TA_TPRI|TA_DOMMASK);
if (mbfmb != NULL) {
CHECK_PAR(MB_ALIGN(mbfmb));
CHECK_OBJ(valid_memobj_kernel(mbfmb, mbfsz));
}
domid = get_atrdomid(mbfatr);
if (domid == TDOM_SELF) {
if (rundom == TACP_KERNEL) {
domid = TDOM_KERNEL;
}
else {
domid = p_runtsk->p_tinib->domid;
}
mbfatr = set_atrdomid(mbfatr, domid);
}
switch (domid) {
case TDOM_KERNEL:
p_dominib = &dominib_kernel;
break;
case TDOM_NONE:
p_dominib = &dominib_none;
break;
default:
CHECK_RSATR(VALID_DOMID(domid));
p_dominib = get_dominib(domid);
break;
}
CHECK_ACPTN(p_dominib->acvct.acptn1);
lock_cpu();
if (tnum_mbf == 0 || queue_empty(&(p_dominib->p_domcb->free_mbfcb))) {
ercd = E_NOID;
}
else {
if (mbfsz != 0 && mbfmb == NULL) {
mbfmb = malloc_mpk(mbfsz, p_dominib);
mbfatr |= TA_MBALLOC;
}
if (mbfsz != 0 && mbfmb == NULL) {
ercd = E_NOMEM;
}
else {
p_mbfcb = (MBFCB *)
queue_delete_next(&(p_dominib->p_domcb->free_mbfcb));
p_mbfinib = (MBFINIB *)(p_mbfcb->p_mbfinib);
p_mbfinib->mbfatr = mbfatr;
p_mbfinib->maxmsz = maxmsz;
p_mbfinib->mbfsz = mbfsz;
p_mbfinib->mbfmb = mbfmb;
acptn = default_acptn(domid);
p_mbfinib->acvct.acptn1 = acptn;
p_mbfinib->acvct.acptn2 = acptn;
p_mbfinib->acvct.acptn3 = p_dominib->acvct.acptn1;
p_mbfinib->acvct.acptn4 = acptn;
queue_initialize(&(p_mbfcb->swait_queue));
queue_initialize(&(p_mbfcb->rwait_queue));
p_mbfcb->fmbfsz = mbfsz;
p_mbfcb->head = 0U;
p_mbfcb->tail = 0U;
p_mbfcb->smbfcnt = 0U;
ercd = MBFID(p_mbfcb);
}
}
unlock_cpu();
error_exit:
LOG_ACRE_MBF_LEAVE(ercd);
return(ercd);
}
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_pdq(const T_CPDQ *pk_cpdq)
{
ID domid;
PDQCB *p_pdqcb;
PDQINIB *p_pdqinib;
ATR pdqatr;
PDQMB *p_pdqmb;
ACPTN acptn;
ER ercd;
LOG_ACRE_PDQ_ENTER(pk_cpdq);
CHECK_TSKCTX_UNL();
CHECK_MACV_READ(pk_cpdq, T_CPDQ);
CHECK_RSATR(pk_cpdq->pdqatr, TA_TPRI|TA_DOMMASK);
domid = get_atrdomid(pk_cpdq->pdqatr);
CHECK_ATRDOMID_INACTIVE(domid);
CHECK_DPRI(pk_cpdq->maxdpri);
if (pk_cpdq->pdqmb != NULL) {
CHECK_ALIGN_MB(pk_cpdq->pdqmb);
CHECK_OBJ(valid_memobj_kernel(pk_cpdq->pdqmb,
sizeof(PDQMB) * pk_cpdq->pdqcnt));
}
CHECK_ACPTN(sysstat_acvct.acptn3);
pdqatr = pk_cpdq->pdqatr;
p_pdqmb = pk_cpdq->pdqmb;
t_lock_cpu();
if (tnum_pdq == 0 || queue_empty(&free_pdqcb)) {
ercd = E_NOID;
}
else {
if (pk_cpdq->pdqcnt != 0 && p_pdqmb == NULL) {
p_pdqmb = kernel_malloc(sizeof(PDQMB) * pk_cpdq->pdqcnt);
pdqatr |= TA_MBALLOC;
}
if (pk_cpdq->pdqcnt != 0 && p_pdqmb == NULL) {
ercd = E_NOMEM;
}
else {
p_pdqcb = ((PDQCB *) queue_delete_next(&free_pdqcb));
p_pdqinib = (PDQINIB *)(p_pdqcb->p_pdqinib);
p_pdqinib->pdqatr = pdqatr;
p_pdqinib->pdqcnt = pk_cpdq->pdqcnt;
p_pdqinib->maxdpri = pk_cpdq->maxdpri;
p_pdqinib->p_pdqmb = p_pdqmb;
acptn = default_acptn(domid);
p_pdqinib->acvct.acptn1 = acptn;
p_pdqinib->acvct.acptn2 = acptn;
p_pdqinib->acvct.acptn3 = acptn | rundom;
p_pdqinib->acvct.acptn4 = acptn;
queue_initialize(&(p_pdqcb->swait_queue));
queue_initialize(&(p_pdqcb->rwait_queue));
p_pdqcb->count = 0U;
p_pdqcb->p_head = NULL;
p_pdqcb->unused = 0U;
p_pdqcb->p_freelist = NULL;
ercd = PDQID(p_pdqcb);
}
}
t_unlock_cpu();
error_exit:
LOG_ACRE_PDQ_LEAVE(ercd);
return(ercd);
}
ER_UINT
acre_mtx(const T_CMTX *pk_cmtx)
{
MTXCB *p_mtxcb;
MTXINIB *p_mtxinib;
ATR mtxatr;
PRI ceilpri;
ID domid;
const DOMINIB *p_dominib;
ACPTN acptn;
ER ercd;
LOG_ACRE_MTX_ENTER(pk_cmtx);
CHECK_TSKCTX_UNL();
CHECK_MACV_READ(pk_cmtx, T_CMTX);
mtxatr = pk_cmtx->mtxatr;
ceilpri = pk_cmtx->ceilpri;
if ((mtxatr & MTXPROTO_MASK) == TA_CEILING) {
CHECK_VALIDATR(mtxatr, TA_CEILING|TA_DOMMASK);
CHECK_PAR(VALID_TPRI(ceilpri));
}
else {
CHECK_VALIDATR(pk_cmtx->mtxatr, TA_TPRI|TA_DOMMASK);
}
domid = get_atrdomid(mtxatr);
if (domid == TDOM_SELF) {
if (rundom == TACP_KERNEL) {
domid = TDOM_KERNEL;
}
else {
domid = p_runtsk->p_tinib->domid;
}
mtxatr = set_atrdomid(mtxatr, domid);
}
switch (domid) {
case TDOM_KERNEL:
p_dominib = &dominib_kernel;
break;
case TDOM_NONE:
p_dominib = &dominib_none;
break;
default:
CHECK_RSATR(VALID_DOMID(domid));
p_dominib = get_dominib(domid);
break;
}
CHECK_ACPTN(p_dominib->acvct.acptn1);
lock_cpu();
if (tnum_mtx == 0 || queue_empty(&(p_dominib->p_domcb->free_mtxcb))) {
ercd = E_NOID;
}
else {
p_mtxcb = (MTXCB *)
queue_delete_next(&(p_dominib->p_domcb->free_mtxcb));
p_mtxinib = (MTXINIB *)(p_mtxcb->p_mtxinib);
p_mtxinib->mtxatr = mtxatr;
p_mtxinib->ceilpri = INT_PRIORITY(ceilpri);
acptn = default_acptn(domid);
p_mtxinib->acvct.acptn1 = acptn;
p_mtxinib->acvct.acptn2 = acptn;
p_mtxinib->acvct.acptn3 = p_dominib->acvct.acptn1;
p_mtxinib->acvct.acptn4 = acptn;
queue_initialize(&(p_mtxcb->wait_queue));
p_mtxcb->p_loctsk = NULL;
ercd = MTXID(p_mtxcb);
}
unlock_cpu();
error_exit:
LOG_ACRE_MTX_LEAVE(ercd);
return(ercd);
}
ER
ref_tsk(ID tskid, T_RTSK *pk_rtsk)
{
TCB *p_tcb;
uint_t tstat;
ER ercd;
LOG_REF_TSK_ENTER(tskid, pk_rtsk);
CHECK_TSKCTX_UNL();
CHECK_TSKID_SELF(tskid);
CHECK_MACV_WRITE(pk_rtsk, T_RTSK);
p_tcb = get_tcb_self(tskid);
CHECK_ACPTN(p_tcb->p_tinib->acvct.acptn4);
t_lock_cpu();
tstat = p_tcb->tstat;
if (TSTAT_DORMANT(tstat)) {
/*
* 対象タスクが休止状態の場合
*/
pk_rtsk->tskstat = TTS_DMT;
}
else {
/*
* タスク状態の取出し
*/
if (TSTAT_SUSPENDED(tstat)) {
if (TSTAT_WAITING(tstat)) {
pk_rtsk->tskstat = TTS_WAS;
}
else {
pk_rtsk->tskstat = TTS_SUS;
}
}
else if (TSTAT_WAITING(tstat)) {
pk_rtsk->tskstat = TTS_WAI;
}
else if (p_tcb == p_runtsk) {
pk_rtsk->tskstat = TTS_RUN;
}
else {
pk_rtsk->tskstat = TTS_RDY;
}
/*
* 現在優先度とベース優先度の取出し
*/
pk_rtsk->tskpri = EXT_TSKPRI(p_tcb->priority);
pk_rtsk->tskbpri = EXT_TSKPRI(p_tcb->bpriority);
if (TSTAT_WAITING(tstat)) {
/*
* 待ち要因と待ち対象のオブジェクトのIDの取出し
*/
switch (tstat & TS_WAIT_MASK) {
case TS_WAIT_SLP:
pk_rtsk->tskwait = TTW_SLP;
break;
case TS_WAIT_DLY:
pk_rtsk->tskwait = TTW_DLY;
break;
case TS_WAIT_SEM:
pk_rtsk->tskwait = TTW_SEM;
pk_rtsk->wobjid = SEMID(((WINFO_SEM *)(p_tcb->p_winfo))
->p_semcb);
break;
case TS_WAIT_FLG:
pk_rtsk->tskwait = TTW_FLG;
pk_rtsk->wobjid = FLGID(((WINFO_FLG *)(p_tcb->p_winfo))
->p_flgcb);
break;
case TS_WAIT_SDTQ:
pk_rtsk->tskwait = TTW_SDTQ;
pk_rtsk->wobjid = DTQID(((WINFO_DTQ *)(p_tcb->p_winfo))
->p_dtqcb);
break;
case TS_WAIT_RDTQ:
pk_rtsk->tskwait = TTW_RDTQ;
pk_rtsk->wobjid = DTQID(((WINFO_DTQ *)(p_tcb->p_winfo))
->p_dtqcb);
break;
case TS_WAIT_SPDQ:
pk_rtsk->tskwait = TTW_SPDQ;
pk_rtsk->wobjid = PDQID(((WINFO_PDQ *)(p_tcb->p_winfo))
->p_pdqcb);
break;
case TS_WAIT_RPDQ:
pk_rtsk->tskwait = TTW_RPDQ;
pk_rtsk->wobjid = PDQID(((WINFO_PDQ *)(p_tcb->p_winfo))
->p_pdqcb);
break;
case TS_WAIT_MTX:
pk_rtsk->tskwait = TTW_MTX;
pk_rtsk->wobjid = MTXID(((WINFO_MTX *)(p_tcb->p_winfo))
->p_mtxcb);
break;
case TS_WAIT_SMBF:
pk_rtsk->tskwait = TTW_SMBF;
pk_rtsk->wobjid = MBFID(((WINFO_MBF *)(p_tcb->p_winfo))
->p_mbfcb);
break;
case TS_WAIT_RMBF:
pk_rtsk->tskwait = TTW_RMBF;
pk_rtsk->wobjid = MBFID(((WINFO_MBF *)(p_tcb->p_winfo))
->p_mbfcb);
break;
case TS_WAIT_MPF:
pk_rtsk->tskwait = TTW_MPF;
pk_rtsk->wobjid = MPFID(((WINFO_MPF *)(p_tcb->p_winfo))
->p_mpfcb);
break;
}
/*
* タイムアウトするまでの時間の取出し
*/
if (p_tcb->p_winfo->p_tmevtb != NULL) {
pk_rtsk->lefttmo
= (TMO) tmevt_lefttim(p_tcb->p_winfo->p_tmevtb);
}
else {
pk_rtsk->lefttmo = TMO_FEVR;
}
}
/*
* 起床要求キューイング数の取出し
*/
pk_rtsk->wupcnt = p_tcb->wupque ? 1U : 0U;
/*
* タスク例外マスク状態か否かの取出し
*/
pk_rtsk->texmsk = t_sense_texmask(p_tcb);
/*
* 待ち禁止状態か否かの取出し
*/
pk_rtsk->waifbd = p_tcb->waifbd;
/*
* 拡張サービスコールのネストレベルの取出し
*/
pk_rtsk->svclevel = p_tcb->svclevel;
}
/*
* 起動要求キューイング数の取出し
*/
pk_rtsk->actcnt = p_tcb->actque ? 1U : 0U;
ercd = E_OK;
t_unlock_cpu();
error_exit:
LOG_REF_TSK_LEAVE(ercd, pk_rtsk);
return(ercd);
}
ER_UINT
acre_sem(const T_CSEM *pk_csem)
{
SEMCB *p_semcb;
SEMINIB *p_seminib;
ATR sematr;
uint_t isemcnt, maxsem;
ID domid;
const DOMINIB *p_dominib;
ACPTN acptn;
ER ercd;
LOG_ACRE_SEM_ENTER(pk_csem);
CHECK_TSKCTX_UNL();
CHECK_MACV_READ(pk_csem, T_CSEM);
sematr = pk_csem->sematr;
isemcnt = pk_csem->isemcnt;
maxsem = pk_csem->maxsem;
CHECK_VALIDATR(sematr, TA_TPRI|TA_DOMMASK);
CHECK_PAR(0 <= isemcnt && isemcnt <= maxsem);
CHECK_PAR(1 <= maxsem && maxsem <= TMAX_MAXSEM);
domid = get_atrdomid(sematr);
if (domid == TDOM_SELF) {
if (rundom == TACP_KERNEL) {
domid = TDOM_KERNEL;
}
else {
domid = p_runtsk->p_tinib->domid;
}
sematr = set_atrdomid(sematr, domid);
}
switch (domid) {
case TDOM_KERNEL:
p_dominib = &dominib_kernel;
break;
case TDOM_NONE:
p_dominib = &dominib_none;
break;
default:
CHECK_RSATR(VALID_DOMID(domid));
p_dominib = get_dominib(domid);
break;
}
CHECK_ACPTN(p_dominib->acvct.acptn1);
lock_cpu();
if (tnum_sem == 0 || queue_empty(&(p_dominib->p_domcb->free_semcb))) {
ercd = E_NOID;
}
else {
p_semcb = (SEMCB *)
queue_delete_next(&(p_dominib->p_domcb->free_semcb));
p_seminib = (SEMINIB *)(p_semcb->p_seminib);
p_seminib->sematr = sematr;
p_seminib->isemcnt = isemcnt;
p_seminib->maxsem = maxsem;
acptn = default_acptn(domid);
p_seminib->acvct.acptn1 = acptn;
p_seminib->acvct.acptn2 = acptn;
p_seminib->acvct.acptn3 = p_dominib->acvct.acptn1;
p_seminib->acvct.acptn4 = acptn;
queue_initialize(&(p_semcb->wait_queue));
p_semcb->semcnt = isemcnt;
ercd = SEMID(p_semcb);
}
unlock_cpu();
error_exit:
LOG_ACRE_SEM_LEAVE(ercd);
return(ercd);
}
