tkref.c

T-kernel 的extension源代码

EXPORT void DumpMailBox( ID mbxid, UW opt )
{
	T_RMBX	ref;
	ID	id, maxid;
	ER	err;

	maxid = 0;
	tk_get_cfn("TMaxMbxId", &maxid, 1);
	DumpMore(0);

	if ( (opt & 1U) == 0 ) {
		DSP("MBX STATE (MAX:%d):\n", maxid);
		DSP(" ID WID MSG      EXINF\n");
	}

	if ( mbxid > 0 ) {
		maxid = mbxid;
	} else {
		mbxid = 1;
	}

	for ( id = mbxid; id <= maxid; id++ ) {
		err = tk_ref_mbx(id, &ref);
		if ( err < E_OK ) {
			if ( err != E_NOEXS ) {
				DSP("%3d ** %s **\n", id, tkstrerror(err));
			}
			continue;
		}

		DSP("%3d %3d %08x ", id, ref.wtsk, ref.pk_msg);
		dsp_exinf(ref.exinf);

		DSP_LF;
		if ( DumpMore(1) ) {
			break;
		}
	}
}

/* ------------------------------------------------------------------------ */
/*
 *	Message buffer
 */

/*
MBF STATE (MAX:123)
 ID WID SID  MSGSZ   FREE    MAX EXINF
123 123 123 123456 123456 123456 12345678 ABCD
*/

/*
 * Indicate message buffer state
 *	mbfid > 0	Message buffers specified by mbfid only
 *	mbfid = 0	All message buffers
 *	opt		1: Not display header
 */
EXPORT void DumpMessageBuf( ID mbfid, UW opt )
{
	T_RMBF	ref;
	ID	id, maxid;
	ER	err;

	maxid = 0;
	tk_get_cfn("TMaxMbfId", &maxid, 1);
	DumpMore(0);

	if ( (opt & 1U) == 0 ) {
		DSP("MBF STATE (MAX:%d):\n", maxid);
		DSP(" ID WID SID  MSGSZ   FREE    MAX EXINF\n");
	}

	if ( mbfid > 0 ) {
		maxid = mbfid;
	} else {
		mbfid = 1;
	}

	for ( id = mbfid; id <= maxid; id++ ) {
		err = tk_ref_mbf(id, &ref);
		if ( err < E_OK ) {
			if ( err != E_NOEXS ) {
				DSP("%3d ** %s **\n", id, tkstrerror(err));
			}
			continue;
		}

		DSP("%3d %3d %3d %6d %6d %6d ", id, ref.wtsk, ref.stsk,
					ref.msgsz, ref.frbufsz, ref.maxmsz);
		dsp_exinf(ref.exinf);

		DSP_LF;
		if ( DumpMore(1) ) {
			break;
		}
	}
}

/* ------------------------------------------------------------------------ */
/*
 *	Rendezvous port
 */

/*
POR STATE (MAX:123)
 ID WID AID MAXCSZ MAXRSZ EXINF
123 123 123 123456 123456 12345678 ABCD
*/

/*
 * Indicate rendezvous port state
 *	porid > 0	Rendezvous ports specified by porid only
 *	porid = 0	All rendezvous ports
 *	opt		1: Not display header
 */
EXPORT void DumpRdvPort( ID porid, UW opt )
{
	T_RPOR	ref;
	ID	id, maxid;
	ER	err;

	maxid = 0;
	tk_get_cfn("TMaxPorId", &maxid, 1);
	DumpMore(0);

	if ( (opt & 1U) == 0 ) {
		DSP("POR STATE (MAX:%d):\n", maxid);
		DSP(" ID WID AID MAXCSZ MAXRSZ EXINF\n");
	}

	if ( porid > 0 ) {
		maxid = porid;
	} else {
		porid = 1;
	}

	for ( id = porid; id <= maxid; id++ ) {
		err = tk_ref_por(id, &ref);
		if ( err < E_OK ) {
			if ( err != E_NOEXS ) {
				DSP("%3d ** %s **\n", id, tkstrerror(err));
			}
			continue;
		}

		DSP("%3d %3d %3d %6d %6d ", id, ref.wtsk, ref.atsk,
					ref.maxcmsz, ref.maxrmsz);
		dsp_exinf(ref.exinf);

		DSP_LF;
		if ( DumpMore(1) ) {
			break;
		}
	}
}

/* ------------------------------------------------------------------------ */
/*
 *	Variable-length memory pool
 */

/*
MPL STATE (MAX:123)
 ID WID   FREE    MAX EXINF
123 123 123456 123456 12345678 ABCD
*/

/*
 * Indicate variable-length memory pool state
 *	mplid > 0	Variable-length memory pools specified by mplid only
 *	mplid = 0	All variable-length memory pools
 *	opt		1: Not display header
 */
EXPORT void DumpMemoryPool( ID mplid, UW opt )
{
	T_RMPL	ref;
	ID	id, maxid;
	ER	err;

	maxid = 0;
	tk_get_cfn("TMaxMplId", &maxid, 1);
	DumpMore(0);

	if ( (opt & 1U) == 0 ) {
		DSP("MPL STATE (MAX:%d):\n", maxid);
		DSP(" ID WID   FREE    MAX EXINF\n");
	}

	if ( mplid > 0 ) {
		maxid = mplid;
	} else {
		mplid = 1;
	}

	for ( id = mplid; id <= maxid; id++ ) {
		err = tk_ref_mpl(id, &ref);
		if ( err < E_OK ) {
			if ( err != E_NOEXS ) {
				DSP("%3d ** %s **\n", id, tkstrerror(err));
			}
			continue;
		}

		DSP("%3d %3d %6d %6d ", id, ref.wtsk, ref.frsz, ref.maxsz);
		dsp_exinf(ref.exinf);

		DSP_LF;
		if ( DumpMore(1) ) {
			break;
		}
	}
}

/* ------------------------------------------------------------------------ */
/*
 *	Fixed-length memory pool
 */

/*
MPF STATE (MAX:123)
 ID WID FREE EXINF
123 123 1234 12345678 ABCD
*/

/*
 * Indicate fixed-length memory pool state
 *	mpfid > 0	Fixed-length memory pools specified by mpfid only
 *	mpfid = 0	All fixed-length memory pools
 *	opt		1: Not display header
 */
EXPORT void DumpFixMemPool( ID mpfid, UW opt )
{
	T_RMPF	ref;
	ID	id, maxid;
	ER	err;

	maxid = 0;
	tk_get_cfn("TMaxMpfId", &maxid, 1);
	DumpMore(0);

	if ( (opt & 1U) == 0 ) {
		DSP("MPF STATE (MAX:%d):\n", maxid);
		DSP(" ID WID FREE EXINF\n");
	}

	if ( mpfid > 0 ) {
		maxid = mpfid;
	} else {
		mpfid = 1;
	}

	for ( id = mpfid; id <= maxid; id++ ) {
		err = tk_ref_mpf(id, &ref);
		if ( err < E_OK ) {
			if ( err != E_NOEXS ) {
				DSP("%3d ** %s **\n", id, tkstrerror(err));
			}
			continue;
		}

		DSP("%3d %3d %4d ", id, ref.wtsk, ref.frbcnt);
		dsp_exinf(ref.exinf);

		DSP_LF;
		if ( DumpMore(1) ) {
			break;
		}
	}
}

/* ------------------------------------------------------------------------ */
/*
 *	Cyclic start handler
 */

/*
CYC STATE (MAX:123)
 ID STS   TIME EXINF
123 123 123456 12345678 ABCD
*/

/*
 * Indicate cyclic start handler state
 *	cycid > 0	Cyclic start handlers specified by cycid only
 *	cycid = 0	All cyclic start handlers
 *	opt		1: Not display header
 */
EXPORT void DumpCyclicHdr( ID cycid, UW opt )
{
	T_RCYC	ref;
	ID	id, maxid;
	ER	err;

	maxid = 0;
	tk_get_cfn("TMaxCycId", &maxid, 1);
	DumpMore(0);

	if ( (opt & 1U) == 0 ) {
		DSP("CYC STATE (MAX:%d):\n", maxid);
		DSP(" ID STS   TIME EXINF\n");
	}

	if ( cycid > 0 ) {
		maxid = cycid;
	} else {
		cycid = 1;
	}

	for ( id = cycid; id <= maxid; id++ ) {
		err = tk_ref_cyc(id, &ref);
		if ( err < E_OK ) {
			if ( err != E_NOEXS ) {
				DSP("%3d ** %s **\n", id, tkstrerror(err));
			}
			continue;
		}

		DSP("%3d %3s %6d ", id,
			( (ref.cycstat & TCYC_STA) != 0 )? "STA": "",
			ref.lfttim);
		dsp_exinf(ref.exinf);

		DSP_LF;
		if ( DumpMore(1) ) {
			break;
		}
	}
}

/* ------------------------------------------------------------------------ */
/*
 *	Alarm handler
 */

/*
ALM STATE (MAX:123)
 ID STS   TIME EXINF
123 123 123456 12345678 ABCD
*/

/*
 * Indicate alarm handler state
 *	almid > 0	Alarm handlers specified by almid only
 *	almid = 0	All alarm handlers
 *	opt		1: Not display header
 */
EXPORT void DumpAlarmHdr( ID almid, UW opt )
{
	T_RALM	ref;
	ID	id, maxid;
	ER	err;

	maxid = 0;
	tk_get_cfn("TMaxAlmId", &maxid, 1);
	DumpMore(0);

	if ( (opt & 1U) == 0 ) {
		DSP("ALM STATE (MAX:%d):\n", maxid);
		DSP(" ID STS   TIME EXINF\n");
	}

	if ( almid > 0 ) {
		maxid = almid;
	} else {
		almid = 1;
	}

	for ( id = almid; id <= maxid; id++ ) {
		err = tk_ref_alm(id, &ref);
		if ( err < E_OK ) {
			if ( err != E_NOEXS ) {
				DSP("%3d ** %s **\n", id, tkstrerror(err));
			}
			continue;
		}

		DSP("%3d %3s %6d ", id,
			( (ref.almstat & TALM_STA) != 0 )? "STA": "",
			ref.lfttim);
		dsp_exinf(ref.exinf);

		DSP_LF;
		if ( DumpMore(1) ) {
			break;
		}
	}
}

/* ------------------------------------------------------------------------ */
/*
 *	Subsystem
 */

/*
SSY STATE (MAX:123)
 ID PRI  RESSZ
123 123 123456
*/

/*
 * Indicate subsystem state
 *	ssid > 0	Subsystems specified by ssid only
 *	ssid = 0	All subsystems
 *	opt		1: Not display header
 */
EXPORT void DumpSubsystem( ID ssid, UW opt )
{
	T_RSSY	ref;
	ID	id, maxid;
	ER	err;

	maxid = 0;
	tk_get_cfn("TMaxSsyId", &maxid, 1);
	DumpMore(0);

	if ( (opt & 1U) == 0 ) {
		DSP("SSY STATE (MAX:%d):\n", maxid);
		DSP(" ID PRI  RESSZ\n");
	}

	if ( ssid > 0 ) {
		maxid = ssid;
	} else {
		ssid = 1;
	}

	for ( id = ssid; id <= maxid; id++ ) {
		err = tk_ref_ssy(id, &ref);
		if ( err < E_OK ) {
			if ( err != E_NOEXS ) {
				DSP("%3d ** %s **\n", id, tkstrerror(err));
			}
			continue;
		}

		DSP("%3d %3s %6d\n", id, ref.ssypri, ref.resblksz);

		if ( DumpMore(1) ) {
			break;
		}
	}
}

/* ------------------------------------------------------------------------- */
/*
 *	Task register
 */

/*
 * Indicate task register
 *	Indicate task registers specified by tskid
 */
EXPORT void DumpTaskRegister( ID tskid )
{
	T_REGS	gr;
	T_EIT	er;
	T_CREGS	cr;
	ER	err;

	DSP("TASK REGISTER (TID:%d)\n", tskid);

	err = tk_get_reg(tskid, &gr, &er, &cr);
	if ( err < E_OK ) {
		DSP("** %s **\n", tkstrerror(err));
		return;
	}

	PrintTaskRegister(&DSP, &gr, &er, &cr);
}

/* ------------------------------------------------------------------------- */

#endif /* DEBUGFUNC_SUPPORT */