debug.c

T-kernel 的extension源代码

/*
 *----------------------------------------------------------------------
 *    T-Kernel / Standard Extension
 *
 *    Copyright (C) 2006 by Ken Sakamura. All rights reserved.
 *    T-Kernel / Standard Extension is distributed 
 *      under the T-License for T-Kernel / Standard Extension.
 *----------------------------------------------------------------------
 *
 *    Version:   1.00.00
 *    Released by T-Engine Forum(http://www.t-engine.org) at 2006/8/11.
 *
 *----------------------------------------------------------------------
 */

/*
 *	debug.c (proc)
 *
 *	Debug support function
 */

#include "prcmgr.h"
#include <sys/knldbg.h>
#include <tm/tmonitor.h>


#if DEBUGFUNC_SUPPORT
#include <stdio.h>
#include <stdarg.h>
#include <sys/syslog.h>
#endif

#if VIRTUAL_ADDRESS
EXPORT	W	ForceLoadFlag = 0;		/* Forced load flag		*/
#endif
EXPORT	W	DebugMonitorFlag = 1;		/* Debug monitor flag		*/
EXPORT	W	LazyMode;			/* Link mode of shared library	*/

#if DEBUGFUNC_SUPPORT
#include <sys/sysinfo.h>

IMPORT SysCommonInfo	SaveSCInfo;

#define	RunMode		( SCInfo.bm.w )
#define	BootMode	( SaveSCInfo.bm.w )

#define DSP		printf

#define TSD_PLM_BUF_256		256
#define TSD_DBF_MSK_0XFFFF	0xffffU

/*----------------------------------------------------------------------*/
LOCAL	void	proc_break(ID pid)
/*----------------------------------------------------------------------*/
{
#if VIRTUAL_ADDRESS
	PINFO		*pinfo;
	T_TSKSPC	curspc;
	UW		imask;
	ER		err;

	syslog_wait();

	err = PidToPinfo(pid, &pinfo);
	if ( err < E_OK ) {
		DSP("** PID ERROR\n");
		return;
	}

	DI(imask);
	UnlockPinfo();

	ChangeLogicalSpace(&curspc, GetTSKSPC_pinfo(pinfo));
	tm_monitor();
	ChangeLogicalSpace(NULL, curspc);

	EI(imask);
#else
	tm_monitor();
#endif
}
/*----------------------------------------------------------------------*/
LOCAL	UW	_GetRunMode( void )
/*----------------------------------------------------------------------*/
{
	return RunMode;
}
/*----------------------------------------------------------------------*/
LOCAL	UW	_SetBootMode( UW and, UW or )
/*----------------------------------------------------------------------*/
{
	UW	old, imask;

	DI(imask);
	old = BootMode;
	BootMode = (old & and) | or;
	EI(imask);

	return old;
}
/*----------------------------------------------------------------------*/
LOCAL	W	SetDebugMonitorFlag( W val )
/*----------------------------------------------------------------------*/
{
IMPORT	void	RegistSysExcHdr( BOOL regist );
	W	old = DebugMonitorFlag;

	if ( val >= 0 ) {
		RegistSysExcHdr(val == 0);
		DebugMonitorFlag = val;
	}
	return old;
}
/*----------------------------------------------------------------------*/
LOCAL	W	SetLazyMode( W val )
/*----------------------------------------------------------------------*/
{
	W	old = LazyMode;

	if ( val >= 0 ) {
		LazyMode = val;
	}
	return old;
}
/*----------------------------------------------------------------------*/
LOCAL	void	PrLogMsg( int pri, const char *form, va_list *ap )
/*----------------------------------------------------------------------*/
{
extern	int	__logmask;
	B	buf[TSD_PLM_BUF_256];
	W	len;

	if ( (LOG_MASK(pri) & __logmask) != 0 ) {
		len = vsprintf(buf, form, *ap);
		_syslog_send(buf, len);
	}
}
#endif

/*======================================================================*/
EXPORT	W	_DebugFunc(W fn, W p1, W p2, W p3)
/*======================================================================*/
{
#if DEBUGFUNC_SUPPORT
	PINFO	*pi;
IMPORT	W	__MyConsPort;
IMPORT	int	__logmask;
	W	save_port;
	W	n;
	W	ret = E_OK;

#define	SET(item, val)	item; if (val >= 0) { item = val; }

	save_port = __MyConsPort;
	if (fn != KD_Break) {
		pi = GetPinfo(TSK_SELF);
		n = pi->consinf & TSD_DBF_MSK_0XFFFF;
		__MyConsPort = (n <= 0) ? 1 : n;
	}

	switch (fn) {
	  case KD_Break:
		proc_break(p1);
		break;

	  case KD_RefTsk:
		DumpTask(p1, 0);
		break;
	  case KD_RefSem:
		DumpSemaphore(p1, 0);
		break;
	  case KD_RefFlg:
		DumpEventFlag(p1, 0);
		break;
	  case KD_RefMbx:
		DumpMailBox(p1, 0);
		break;
	  case KD_RefMbf:
		DumpMessageBuf(p1, 0);
		break;
	  case KD_RefRdv:
		DumpRdvPort(p1, 0);
		break;
	  case KD_RefMpl:
		DumpMemoryPool(p1, 0);
		break;
	  case KD_RefMpf:
		DumpFixMemPool(p1, 0);
		break;
	  case KD_RefCyc:
		DumpCyclicHdr(p1, 0);
		break;
	  case KD_RefAlm:
		DumpAlarmHdr(p1, 0);
		break;
	  case KD_RefReg:
		DumpTaskRegister(p1);
		break;
	  case KD_RefMtx:
		DumpMutex(p1, 0);
		break;
	  case KD_RefSsy:
		DumpSubsystem(p1, 0);
		break;

#if VIRTUAL_ADDRESS
	  case KD_RefSpc:
		DumpSpace(p1, (VP)p2, (VP)p3);
		break;
	  case KD_RefPgf:
		DumpPageFile();
		break;
	  case KD_RefMtb:
		DumpMemoryTable(p1);
		break;
	  case KD_PreLoad:
		ret = SET(ForceLoadFlag, p1);
		break;
	  case KD_RefDyn:
		DumpDynLoad(p1);
		break;
#else
	  case KD_RefPrc:
		DumpProc(p1, p2);
		break;
#endif
	  case KD_RefPfm:
		DumpPF(p1);
		break;
	  case KD_RefMap:
		DumpMap();
		break;
	  case KD_RefSeg:
		DumpSegInfo();
		break;
	  case KD_RefKex:
		DumpSysProg();
		break;
	  case KD_LogMsg:
		PrLogMsg(p1, (const char*)p2, (va_list*)p3);
		break;
	  case KD_LazyMode:
		ret = SetLazyMode(p1);
		break;
	  case KD_RunMode:
		ret = _GetRunMode();
		break;
	  case KD_BootMode:
		ret = _SetBootMode(p1, p2);
		break;
	  case KD_DebugMode:
		ret = _isDebugMode();
		break;
	  case KD_RomMonitor:
		ret = SetDebugMonitorFlag(p1);
		break;
	  case KD_LogMask:
		ret = SET(__logmask, p1);
		break;
	  case KD_PageSize:
		ret = SET(DumpPageLen, p1);
		break;
	  default:
		DSP("no support\n");
		break;
	}

	if (fn != KD_Break) {
		__MyConsPort = save_port;
	}

	return ret;
#else

	return E_OK;
#endif
}