自学教程：C++ t_unlock_cpu函数代码示例

SYSCALL ERrel_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);}

ERchg_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);}

ERprcv_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);}

ERpol_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);}

ERref_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);}

ERpget_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_UINTacre_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);}

ERini_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);}

ERrcv_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);}

ERprcv_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 ERtslp_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 ERslp_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 ERdly_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);}

ERref_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);}

ERsnd_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);}

ERget_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);}

ERpsnd_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);}

ERini_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);}

ERprcv_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);}

ERclr_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);}

ERini_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);}

ERini_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_UINTacre_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);}

ERena_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);}

ERsta_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);}

ERpsnd_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);}

ERstp_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);}

ERref_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_UINTcan_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);}