prcmgr.c

T-kernel 的extension源代码

	return pid;
}
#endif /*@ Not used @*/

/*
	Change priority of in-process task
*/
LOCAL	WER	chg_pri_task( W tid, W new_pri, W opt )
{
	PINFO	*pi;
	W	cur_pri;
	W	i;
	ER	err;

	pi = GetPinfo(TSK_SELF);
	if ( pi == NULL ) {
		err = E_CTX;
		goto err_ret;
	}

	if ( tid != 0 ) {
		/* Check if a task is included in current process. */
		for ( i = 0; i < MAX_SUBTASKS; ++i ) {
			if ( pi->tsk[i].tskid == tid ) {
				break;
			}
		}
		if ( i >= MAX_SUBTASKS ) {
			err = E_ID;
			goto err_ret;
		}
	}

	/* Current priority */
	cur_pri = GetPri(tid);
	if ( cur_pri < E_OK ) {
		err = cur_pri;
		goto err_ret;
	}

	/* New priority */
	if ( (opt & P_REL) != 0 ) {
		new_pri += cur_pri;
	}

	if ( new_pri != cur_pri ) {
		/* Check if the changed priority is within a specified range. */
		if ( (opt & P_REL) != 0 ) {
			/* P_REL : Limited to within a priority group of current process */
			err = CheckPri(cur_pri, new_pri);
			if ( err < E_OK ) {
				goto err_ret;
			}
		} else {
			/* P_ABS : No limitation based on priority group */
			if ((new_pri < 0 )||( new_pri > MAX_RRGRP2_PRI)) {
				err = E_PAR;
				goto err_ret;
			}
		}

		/* Change priority */
		err = ChangePri(tid, new_pri);
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	return new_pri;

err_ret:
	return err;
}

/*
	Change priority of all in-process tasks
*/
LOCAL	WER	chg_pri_proc( W pid, W new_pri, W opt )
{
	PINFO	*pi;
	W	cur_pri;
	ID	tid;
	W	i;
	ER	err;

	err = GetPidToPinfo(pid, &pi);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Check if the changed priority is within a specified range. */
	if ( (opt & P_REL) != 0 ) {
		/* P_REL : Limited to within a priority group of current process */
		for ( i = 0; i < MAX_SUBTASKS; ++i ) {
			tid = pi->tsk[i].tskid;
			if ( tid == 0 ) {
				continue;
			}

			cur_pri = GetPri(tid);
			if ( cur_pri < E_OK ) {
				err = cur_pri;
				goto err_ret;
			}

			err = CheckPri(cur_pri, cur_pri + new_pri);
			if ( err < E_OK ) {
				goto err_ret;
			}
		}
	} else {
		/* P_ABS : No limitation based on priority group */
		if ((new_pri < 0 )||( new_pri > MAX_RRGRP2_PRI)) {
			err = E_PAR;
			goto err_ret;
		}
	}

	/* Change priority */
	for ( i = 0; i < MAX_SUBTASKS; ++i ) {
		tid = pi->tsk[i].tskid;
		if ( tid == 0 ) {
			continue;
		}

		err = ChangePri(tid, ( (opt & P_REL) != 0 )?
					(GetPri(tid) + new_pri): new_pri);
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	/* Priority of main task after change */
	new_pri = GetPri(pi->tsk[0].tskid);

	return new_pri;

err_ret:
	return err;
}

/*
	Change priority of process task
*/
LOCAL	WER	 _tkse_chg_pri(ID id, PRI new_pri, W opt)
{
	ER	err;

	if ( ((UW)opt & ~(UW)(P_REL|P_ABS|P_TASK)) != 0 ) {
		return E_PAR;
	}

	Lock(&ProcMgrLock);

	if ( (opt & P_TASK) != 0 ) {
		/* Change priority of task */
		err = chg_pri_task(id, new_pri, opt);
	} else {
		/* Change priority of process */
		err = chg_pri_proc(id, new_pri, opt);
	}

	Unlock(&ProcMgrLock);

	return err;
}

/*
	Fetch process state
*/
LOCAL	WER	_tkse_prc_sts(ID pid, P_STATE *buff, TC *path)
{
	PINFO	*pi;
	ER	er;
	ER	err;
	T_RTSK	rtsk;

	if ((buff &&( CheckSpaceRW((VP)buff, sizeof(P_STATE)))) ||
	   ((path &&( CheckSpaceRW((VP)path, (PNAME_SZ + 1) * sizeof(TC)))))) {
	   	return E_MACV;
	}

	Lock(&ProcMgrLock);

	err = GetPidToPinfo(pid, &pi);
	if (err != 0) {
		goto err_ret;
	}

	if (path != 0) {
		tc_strncpy(path, pi->name, PNAME_SZ);
		if (path[PNAME_SZ - 1] != 0) {
			path[PNAME_SZ] = 0;
		}
	}
	err = RefTask(pi->tsk[0].tskid, &rtsk);
	if ((buff )&&( err == E_OK)) {
		er = (W)rtsk.tskstat;
		buff->state =	((((UW)er & (UW)TTS_RUN)) != 0U) ? P_RUN :
				( (((UW)er & (UW)TTS_RDY) != 0) ? P_READY :
				( (((UW)er & (UW)(TTS_WAI | TTS_SUS)) != 0) ? P_WAIT : 0 ) );
		buff->priority = K_SE_Pri(rtsk.tskpri, (W)rtsk.slicetime);
		buff->parpid = (pi->parent != 0) ? pi->parent->procid : 0;
	}
	if (err == E_OK) {
		err = pi->procid;
	}

err_ret:
	Unlock(&ProcMgrLock);
	return	err;
}

#if _USE_TKSE_CHG_USR
/*
	Set user information
*/
LOCAL	ER	_tkse_chg_usr(P_USER *buff)
{
	PINFO	*pi;
	ER	err;

	if (CheckSpaceR((VP)buff, sizeof(P_USER)) != 0) {
		return E_MACV;
	}

	err = PidToPinfo(0, &pi);
	if (err != 0) {
		return err;
	}
	pi->user->user = *buff;
	UnlockPinfo();

	return E_OK;
}
#endif

#if _USE_TKSE_GET_USR
/*
	Fetch user information
*/
LOCAL	WER	_tkse_get_usr(ID pid, P_USER *buff)
{
	PINFO	*pi;
	ER	err;

	if (buff &&( CheckSpaceRW((VP)buff, sizeof(P_USER)))) {
		return E_MACV;
	}

	err = PidToPinfo(pid, &pi);
	if (err != 0) {
		return err;
	}
	if (buff != 0) {
		*buff = pi->user->user;
	}
	err = pi->procid;
	UnlockPinfo();

	return err;
}
#endif

/*
	Fetch process statistical information
*/
LOCAL	ER	_tkse_get_inf(ID pid, P_INFO *buff)
{
	PINFO	*pi;
	ER	err;
	T_ITSK	inf;
	ID	tid;
	W	subtsks;
	W	i;

	if (CheckSpaceRW((VP)buff, sizeof(P_INFO)) != 0) {
		return E_MACV;
	}

	bzero((VP)buff, (size_t)sizeof(P_INFO));

	err = PidToPinfo(pid, &pi);
	if (err != 0) {
		return err;
	}

	buff->etime = GetSysSec() - pi->ctime;
	subtsks = 0;
	for (i = 0; i < MAX_SUBTASKS; i++) {
		tid = pi->tsk[i].tskid;
		if (tid != 0) {
			tk_inf_tsk(tid, &inf, FALSE);
			buff->utime += inf.utime;
			buff->stime += inf.stime;
			subtsks++;
		}
	}

#if VIRTUAL_ADDRESS
	/* Entire memory */
	i = (W)(pi->ldinfo.dpage + pi->ldinfo.mpage)
	  + GetLocalMemoryUseCount(pi);
	buff->tmem = i * PAGESIZE;

	/* Allocated memory */
	buff->wmem = pi->allocpage * PAGESIZE;

	buff->resv[0] = (W)pi->poutcount;		/* Page out count */
#else
	{ LoadInfo *li = GetLoadInfo(pi->ldinfo.loadno);
	/* Entire memory */
	buff->tmem = (li->textpg + li->datapg + pi->heappg) * PAGESIZE
			+ li->stacksz * subtsks;

	/* Allocated memory */
	buff->wmem = buff->tmem;
	}
#endif

	UnlockPinfo();

	return E_OK;
}

/*
	Generate process to be debugged
*/
LOCAL WER _tkse_cre_dbg(LINK *lnk, ID pri, MESSAGE *msg)
{
	POBJ_HDR	pohdr;

	if (CheckSpaceR((VP)lnk, sizeof(LINK)) != 0) {
		return E_MACV;
	}
	pohdr.type = TPA_LINK;
	pohdr.src.lnk = lnk;
	return CreateProcess(&pohdr, pri, msg, TSD_TCB_VAL_2);
}

/*
	Specify debugger process
*/
LOCAL WER _tkse_set_dbg(ID pid, W mode)
{
	PINFO	*pi;
	W	old;
	ER	err;

	/* Parameter check */
	if ( mode > 1 ) {
		err = E_PAR;
		goto err_ret1;
	}

	Lock(&ProcMgrLock);

	err = GetPidToPinfo(pid, &pi);
	if ( err < E_OK ) {
		goto err_ret2;
	}

	old = pi->dbgmode;
	if ( mode >= 0 ) {
		/* Set debugger process mode */
		pi->dbgmode = mode;
	}

	Unlock(&ProcMgrLock);

	return old;

err_ret2:
	Unlock(&ProcMgrLock);
err_ret1:
	return err;
}

/*
	prc_inf: PI_LINK
	Obtain program file
*/
LOCAL WER pi_link( PINFO *pi, W item, LINK *buf, W len )
{
	if ( item != PI_LINK ) {
		return E_PAR;
	}
	if ( buf == NULL ) {
		return sizeof(LINK);
	}
	if ( len < (W)sizeof(LINK) ) {
		return E_PAR;
	}

#if VIRTUAL_ADDRESS
	*buf = pi->ldinfo.lnk;
#else
	memcpy(buf, &GetLoadInfo(pi->ldinfo.loadno)->lnk,
				offsetof(LINK, atr1));
	memcpy(&buf->atr1, pi->ldinfo.atr, (size_t)sizeof(pi->ldinfo.atr));
#endif

	return sizeof(LINK);
}

/*
	prc_inf: PI_CREINF
	Obtain create information
*/
LOCAL WER pi_cinf( PINFO *pi, W item, P_CREINF *buf, W len )
{
	INT	cinfsize;

	cinfsize = (W)sizeof(P_CREINF) + pi->cinfo.hdrsize - 1;

	if ( item != PI_CREINF ) {
		return E_PAR;
	}
	if ( buf == NULL ) {
		return cinfsize;
	}
	if ( len < cinfsize) {
		return E_PAR;
	}
	buf->pri    = pi->cinfo.cprc.pri;
	buf->prcatr = pi->cinfo.cprc.prcatr;
	memcpy(buf->prchdr, pi->cinfo.cprc.prchdr, (size_t)pi->cinfo.hdrsize);

	return cinfsize;
}

/*
	prc_inf: PI_NTSK, PI_TSKSTAT
	Obtain information on in-process task
*/
LOCAL WER pi_task( PINFO *pi, W item, VP buf, W len )
{
	W	i, n;
	ER	err;

	/* Count the number of tasks */
	n = 0;
	for ( i = 0; i < MAX_SUBTASKS; ++i ) {
		if ( pi->tsk[i].tskid > 0 ) {
			n++;
		}
	}

	if ( item == PI_NTSK ) {
		/* Number of tasks */
		if ( buf == NULL ) {
			return sizeof(W);
		}
		if ( len < (W)sizeof(W) ) {
			return E_PAR;
		}

		*(W*)buf = n;
		return sizeof(W);
	}

	if (( item >= PI_TSKSTAT )&&( item < (PI_TSKSTAT + n ))) {
		/* Task state information */
		P_TSKSTAT	*stat = buf;
		T_RTSK		rtsk;

		if ( buf == NULL ) {
			return sizeof(P_TSKSTAT);
		}
		if ( len < (W)sizeof(P_TSKSTAT) ) {
			return E_PAR;
		}

		n = item - PI_TSKSTAT;
		for ( i = 0;; ++i ) {
			if ( pi->tsk[i].tskid > 0 ) {
				if ( --n < 0 ) {
					break;
				}
			}
		}

		err = RefTask(pi->tsk[i].tskid, &rtsk);
		if ( err < E_OK ) {
			return err;
		}

		stat->tskid = pi->tsk[i].tskid;
		stat->state = (((rtsk.tskstat & (UW)TTS_RUN)) != 0) ? P_RUN:
			      (((rtsk.tskstat & (UW)TTS_RDY) != 0) ? P_READY:
			      (((rtsk.tskstat & (UW)(TTS_WAI|TTS_SUS)) != 0) ? P_WAIT:
			      (((rtsk.tskstat & (UW)TTS_DMT) != 0) ? P_DORMANT:0)));
		stat->priority = K_SE_Pri(rtsk.tskpri, (W)rtsk.slicetime);

		return sizeof(P_TSKSTAT);
	}

	return E_PAR;
}

/*
	Obtain various information on process
*/
LOCAL WER _tkse_prc_inf( ID pid, W item, VP buf, W len )
{
	PINFO	*pi;
	ER	err;

	/* Parameter check */
	if ((buf != NULL) && CheckSpaceRW(buf, len)) {
		return E_MACV;
	}

	Lock(&ProcMgrLock);

	err = GetPidToPinfo(pid, &pi);
	if ( err < E_OK ) {
		goto err_ret;
	}

	switch ( (UW)item & TSD_TPI_MSK_0XFFFF0000 ) {
	  case PI_LINK:
		err = pi_link(pi, item, buf, len);
		break;

	  case PI_NTSK:
	  case PI_TSKSTAT:
		err = pi_task(pi, item, buf, len);
		break;

	  case PI_CREINF:
		err = pi_cinf(pi, item, buf, len);
		break;

	  case PI_PROFIL:
		err = pi_profil(pi, (P_PROFILINF*)buf);
		break;

	  default:
		err = E_PAR;
		break;
	}

err_ret:
	Unlock(&ProcMgrLock);
	return err;
}

/*======================================================================
	Task SVC processing
======================================================================*/
/*
	Generate in-process subtask
*/
LOCAL	WER	_tkse_crs_tsk(FP entry, PRI pri, W arg, VP caller_gp)
{
	PINFO	*pi;
	T_DTEX	dtex;
	ER	err;

	/* Parameter check */
	if (CheckSpaceRE((VP)entry, TSD_CSR_VAL_2) != 0) {
		return E_MACV;
	}
	if ((pri < 0 )||( pri > MAX_RRGRP2_PRI)) {
		return E_PAR;
	}

	Lock(&ProcMgrLock);

	/* Obtain PINFO on current process */
	err = GetPidToPinfo(0, &pi);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Generate task */
	err = CreateTask(pi, entry, pri, caller_gp);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Initialize task register */
	TaskRegisterInitialize(err, entry);

	/* Register forced exception handler */
	dtex.texatr = TA_NULL;
	dtex.texhdr = (FP)pi->fexchdr;
	tk_def_tex(err, &dtex);
	tk_ena_tex(err, 1);

	/* Start task */
	tk_sta_tsk(err, arg);

err_ret:
	Unlock(&ProcMgrLock);

	return err;
}


/*
	Create in-process subtask
*/
LOCAL	WER	_tkse_cre_tsk(FP entry, PRI pri, VP caller_gp)
{
	PINFO	*pi;
	T_DTEX	dtex;
	ER	err;

	/* Parameter check */
	if (CheckSpaceRE((VP)entry, TSD_CSR_VAL_2) != 0) {
		return E_MACV;
	}
	if ((pri < 0 )||( pri > MAX_RRGRP2_PRI)) {
		return E_PAR;
	}

	Lock(&ProcMgrLock);

	/* Obtain PINFO on current process */
	err = GetPidToPinfo(0, &pi);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Generate task */
	err = CreateTask(pi, entry, pri, caller_gp);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Initialize task register */
	TaskRegisterInitialize(err, entry);

	/* Register forced exception handler */
	dtex.texatr = TA_NULL;
	dtex.texhdr = (FP)pi->fexchdr;
	tk_def_tex(err, &dtex);
	tk_ena_tex(err, 1);

err_ret:
	Unlock(&ProcMgrLock);

	return err;