task.c

rtai-3.1-test3的源代码(Real-Time Application Interface )

	if (!task)
	    {
	    xnmutex_unlock(&__imutex);
	    return E_NOEXS;
	    }

	if (xnthread_test_flags(&task->threadbase,XNDORMANT))
	    {
	    xnmutex_unlock(&__imutex);
	    return E_OBJ;
	    }
	}

    if (tskpri == TPRI_INI)
	tskpri = xnthread_initial_priority(&task->threadbase);

    /* uITRON specs explicitely states: "If the priority specified is
       the same as the current priority, the task will still be moved
       behind other tasks of the same priority". This allows for
       manual round-robin. Cool! :o) */
    xnpod_renice_thread(&task->threadbase,tskpri);
    xnmutex_unlock(&__imutex);
    xnpod_schedule(NULL);

    return E_OK;
}

ER rot_rdq (PRI tskpri)

{
    if (tskpri != TPRI_RUN)
	{
	/* uITRON uses a (rather widespread) reverse priority scheme: the
	   lower the value, the higher the priority. */
	if (tskpri < uITRON_MAX_PRI || tskpri > uITRON_MIN_PRI)
	    return E_PAR;
	}
    else if (xnpod_asynch_p())
	tskpri = XNPOD_RUNPRI;
    else
	tskpri = xnthread_current_priority(&ui_current_task()->threadbase);

    xnpod_rotate_readyq(tskpri);
    xnpod_schedule(NULL);

    return E_OK;
}

ER rel_wai (ID tskid)

{
    uitask_t *task;
    
    if (xnpod_asynch_p())
	return EN_CTXID;

    if (tskid <= 0 || tskid > uITRON_MAX_TASKID)
	return E_ID;

    if (tskid == ui_current_task()->tskid)
	return E_OBJ;

    xnmutex_lock(&__imutex);

    task = uitaskmap[tskid - 1];

    if (!task)
	{
	xnmutex_unlock(&__imutex);
	return E_NOEXS;
	}

    if (xnthread_test_flags(&task->threadbase,XNDORMANT))
	{
	xnmutex_unlock(&__imutex);
	return E_OBJ;
	}

    xnpod_unblock_thread(&task->threadbase);
    xnmutex_unlock(&__imutex);
    xnpod_schedule(NULL);

    return E_OK;
}

ER get_tid (ID *p_tskid)

{
    if (xnpod_asynch_p())
	*p_tskid = FALSE;
    else
	*p_tskid = ui_current_task()->tskid;

    return E_OK;
}

ER ref_tsk (T_RTSK *pk_rtsk, ID tskid)

{
    UINT tskstat = 0;
    uitask_t *task;

    if (tskid == TSK_SELF)
	{
	if (xnpod_asynch_p())
	    return E_ID;

	task = ui_current_task();
	xnmutex_lock(&__imutex);
	}
    else
	{
	if (tskid <= 0 || tskid > uITRON_MAX_TASKID)
	    return E_ID;

	xnmutex_lock(&__imutex);

	task = uitaskmap[tskid - 1];

	if (!task)
	    {
	    xnmutex_unlock(&__imutex);
	    return E_NOEXS;
	    }
	}

    if (task == ui_current_task())
	setbits(tskstat,TTS_RUN);
    else if (xnthread_test_flags(&task->threadbase,XNDORMANT))
	setbits(tskstat,TTS_DMT);
    else if (xnthread_test_flags(&task->threadbase,XNREADY))
	setbits(tskstat,TTS_RDY);
    else
	{
	if (xnthread_test_flags(&task->threadbase,XNPEND))
	    setbits(tskstat,TTS_WAI);
	if (xnthread_test_flags(&task->threadbase,XNSUSP))
	    setbits(tskstat,TTS_SUS);
	}

    pk_rtsk->exinf = task->exinf;
    pk_rtsk->tskpri = xnthread_current_priority(&task->threadbase);
    pk_rtsk->tskstat = tskstat;
    pk_rtsk->suscnt = task->suspcnt;
    pk_rtsk->wupcnt = task->wkupcnt;
    pk_rtsk->tskwait = testbits(tskstat,TTS_WAI) ? task->waitinfo : 0;
    pk_rtsk->wid = 0;		/* FIXME */
    pk_rtsk->tskatr = task->tskatr;
    pk_rtsk->task = task->entry;
    pk_rtsk->itskpri = xnthread_initial_priority(&task->threadbase);
    pk_rtsk->stksz = (INT)xnthread_stack_size(&task->threadbase);

    xnmutex_unlock(&__imutex);

    return E_OK;
}

ER sus_tsk (ID tskid)

{
    uitask_t *task;
    
    if (xnpod_asynch_p())
	return EN_CTXID;

    if (tskid <= 0 || tskid > uITRON_MAX_TASKID)
	return E_ID;

    if (tskid == ui_current_task()->tskid)
	return E_OBJ;

    xnmutex_lock(&__imutex);

    task = uitaskmap[tskid - 1];

    if (!task)
	{
	xnmutex_unlock(&__imutex);
	return E_NOEXS;
	}

    if (xnthread_test_flags(&task->threadbase,XNDORMANT))
	{
	xnmutex_unlock(&__imutex);
	return E_OBJ;
	}

    if (task->suspcnt >= 0x7fffffff)
	{
	xnmutex_unlock(&__imutex);
	return E_QOVR;
	}

    if (task->suspcnt++ == 0)
	{
	xnpod_suspend_thread(&task->threadbase,
			     XNSUSP,
			     XN_INFINITE,
			     NULL,
			     &__imutex);
	xnpod_schedule(&__imutex);
	}

    xnmutex_unlock(&__imutex);

    return E_OK;
}

static ER rsm_tsk_helper (ID tskid, int force)

{
    uitask_t *task;
    
    if (xnpod_asynch_p())
	return EN_CTXID;

    if (tskid <= 0 || tskid > uITRON_MAX_TASKID)
	return E_ID;

    if (tskid == ui_current_task()->tskid)
	return E_OBJ;

    xnmutex_lock(&__imutex);

    task = uitaskmap[tskid - 1];

    if (!task)
	{
	xnmutex_unlock(&__imutex);
	return E_NOEXS;
	}

    if (task->suspcnt == 0 ||
	xnthread_test_flags(&task->threadbase,XNDORMANT))
	{
	xnmutex_unlock(&__imutex);
	return E_OBJ;
	}

    if (force || --task->suspcnt == 0)
	{
	task->suspcnt = 0;
	xnpod_resume_thread(&task->threadbase,XNSUSP);
	xnpod_schedule(&__imutex);
	}

    xnmutex_unlock(&__imutex);

    return E_OK;
}

ER rsm_tsk (ID tskid) {
    return rsm_tsk_helper(tskid,0);
}

ER frsm_tsk (ID tskid) {
    return rsm_tsk_helper(tskid,1);
}

ER slp_tsk (void)

{
    uitask_t *task;

    if (!xnpod_pendable_p())
	return E_CTX;

    task = ui_current_task();

    xnmutex_lock(&__imutex);

    if (task->wkupcnt > 0)
	{
	task->wkupcnt--;
	xnmutex_unlock(&__imutex);
	return E_OK;
	}

    xnthread_set_flags(&task->threadbase,uITRON_TASK_SLEEP);

    xnpod_suspend_thread(&task->threadbase,
			 XNDELAY,
			 XN_INFINITE,
			 NULL,
			 &__imutex);

    xnthread_clear_flags(&task->threadbase,uITRON_TASK_SLEEP);

    xnmutex_unlock(&__imutex);

    if (xnthread_test_flags(&task->threadbase,XNBREAK))
	return E_RLWAI;

    return E_OK;
}

ER tslp_tsk (TMO tmout)

{
    uitask_t *task;

    if (!xnpod_pendable_p())
	return E_CTX;

    if (tmout == 0)
	return E_TMOUT;

    if (tmout < TMO_FEVR)
	return E_PAR;

    task = ui_current_task();

    xnmutex_lock(&__imutex);

    if (task->wkupcnt > 0)
	{
	task->wkupcnt--;
	xnmutex_unlock(&__imutex);
	return E_OK;
	}

    if (tmout == TMO_FEVR)
	tmout = XN_INFINITE;

    xnthread_set_flags(&task->threadbase,uITRON_TASK_SLEEP);

    xnpod_suspend_thread(&task->threadbase,
			 XNDELAY,
			 tmout,
			 NULL,
			 &__imutex);

    xnthread_clear_flags(&task->threadbase,uITRON_TASK_SLEEP);

    xnmutex_unlock(&__imutex);

    if (xnthread_test_flags(&task->threadbase,XNBREAK))
	return E_RLWAI;

    if (xnthread_test_flags(&task->threadbase,XNTIMEO))
	return E_TMOUT;

    return E_OK;
}

ER wup_tsk (ID tskid)

{
    uitask_t *task;
    
    if (xnpod_asynch_p())
	return EN_CTXID;

    if (tskid <= 0 || tskid > uITRON_MAX_TASKID)
	return E_ID;

    if (tskid == ui_current_task()->tskid)
	return E_OBJ;

    xnmutex_lock(&__imutex);

    task = uitaskmap[tskid - 1];

    if (!task)
	{
	xnmutex_unlock(&__imutex);
	return E_NOEXS;
	}

    if (xnthread_test_flags(&task->threadbase,XNDORMANT))
	{
	xnmutex_unlock(&__imutex);
	return E_OBJ;
	}

    if (!xnthread_test_flags(&task->threadbase,uITRON_TASK_SLEEP))
	{
	if (task->wkupcnt >= 0x7fffffff)
	    {
	    xnmutex_unlock(&__imutex);
	    return E_QOVR;
	    }

	task->wkupcnt++;
	}
    else
	{
	xnpod_resume_thread(&task->threadbase,XNDELAY);
	xnpod_schedule(&__imutex);
	}

    xnmutex_unlock(&__imutex);

    return E_OK;
}

ER can_wup (INT *p_wupcnt, ID tskid)

{
    uitask_t *task;
    
    if (tskid == TSK_SELF)
	{
	if (xnpod_asynch_p())
	    return E_ID;

	task = ui_current_task();
	xnmutex_lock(&__imutex);
	}
    else
	{
	if (tskid <= 0 || tskid > uITRON_MAX_TASKID)
	    return E_ID;

	xnmutex_lock(&__imutex);

	task = uitaskmap[tskid - 1];

	if (!task)
	    {
	    xnmutex_unlock(&__imutex);
	    return E_NOEXS;
	    }

	if (xnthread_test_flags(&task->threadbase,XNDORMANT))
	    {
	    xnmutex_unlock(&__imutex);
	    return E_OBJ;
	    }
	}

    *p_wupcnt = task->wkupcnt;
    task->wkupcnt = 0;

    xnmutex_unlock(&__imutex);

    return E_OK;
}