system.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

// ********************************************************************
// 声明：VOID WINAPI KL_GetSystemInfo( LPSYSTEM_INFO lpsi )
// 参数：
//		IN  lpsi - SYSTEM_INFO结构指针
// 返回值：
//		无
// 功能描述：
//		返回当前系统信息
// 引用：
//		系统API
// ********************************************************************
VOID WINAPI KL_GetSystemInfo( LPSYSTEM_INFO lpsi )
{
#ifdef ARM_CPU
	lpsi->sysID.arch.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_ARM;
	lpsi->dwProcessorType = PROCESSOR_STRONGARM;
	lpsi->wProcessorRevision = 4; //ARMV4
#endif
#ifdef X86_CPU
	lpsi->sysID.arch.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
	lpsi->dwProcessorType = PROCESSOR_INTEL_386;	
	lpsi->wProcessorRevision = 3; //386
#endif
	lpsi->sysID.arch.wReserved = 0;
	lpsi->dwPageSize = PAGE_SIZE;//4 * 1024;
	lpsi->lpMinimumApplicationAddress = (LPVOID)(64 * 1024);
	lpsi->lpMaximumApplicationAddress = (LPVOID)(32 * 1024 * 1024); //32m
	lpsi->dwActiveProcessorMask = 0x00000001;
	lpsi->dwNumberOfProcessors = 1;
	lpsi->dwAllocationGranularity = 64 * 1024;
	lpsi->wProcessorLevel = 1;
}

// ********************************************************************
// 声明：BOOL WINAPI KL_GetVersion( LPOSVERSIONINFO lpvi )
// 参数：
//		IN  lpvi - OSVERSIONINFO结构指针
// 返回值：
//		假如成功，返回TRUE；否则，返回失败
// 功能描述：
//		返回Core版本号
// 引用：
//		系统API	
// ********************************************************************
BOOL WINAPI KL_GetVersion( LPOSVERSIONINFO lpvi )
{
	if( lpvi->dwOSVersionInfoSize == sizeof( OSVERSIONINFO ) )
	{
		memset( lpvi, 0, sizeof( OSVERSIONINFO ) );
		lpvi->dwMajorVersion = MAJOR_VERSION;
		lpvi->dwMinorVersion = MINOR_VERSION;
		lpvi->dwBuildNumber = BUILD_VERSION;
		lpvi->dwPlatformId = 0;
	}
	return TRUE;
}

// ********************************************************************
// 声明：void WINAPI KL_GlobalMemoryStatus( LPMEMORYSTATUS lpms )
// 参数：
//		IN lpms - MEMORYSTATUS结构指针
// 返回值：
//		无
// 功能描述：
//		得到当前系统内存状态
// 引用：
//		系统API
// ********************************************************************
void WINAPI KL_GlobalMemoryStatus( LPMEMORYSTATUS lpms )
{
	extern ULONG ulSysMainMemLength;


	if( lpms && lpms->dwLength == sizeof( MEMORYSTATUS ) )
	{	// 可利用的页文件	
		lpms->dwAvailPageFile = 0;
		// 可利用的物理内存
		lpms->dwAvailPhys = Page_CountFreePages() * PAGE_SIZE;
		// 已使用内存的百分比
		lpms->dwMemoryLoad = (ulSysMainMemLength - lpms->dwAvailPhys) * 100 / ulSysMainMemLength;
		// 总的页文件
		lpms->dwTotalPageFile = 0;
		// 总的物理内存
		lpms->dwTotalPhys = ulSysMainMemLength;

#ifdef VIRTUAL_MEM
		{
			DWORD dwAvailVirtual;
			DWORD dwReserve;
			DWORD dwCommit;
			
			Seg_GetInfo( lpCurThread->lpCurProcess->lpProcessSegments->lpSeg, &dwAvailVirtual, &dwReserve, &dwCommit );
			// 本进程的可利用虚内存	
			lpms->dwAvailVirtual = dwAvailVirtual; //??
			// 本进程的总的虚内存
			lpms->dwTotalVirtual = 32 * 1024;		
		}
#else
		lpms->dwAvailVirtual = 0;
		lpms->dwTotalVirtual = 0;
#endif
	}
#ifdef __DEBUG
	{
        extern void KHeap_Check( void );
		KHeap_Check();
	}
#endif
}

// ********************************************************************
// 声明：static void CheckThread( LPTHREAD lpThread )
// 参数：
//		IN  lpThread - THREAD结构指针
// 返回值：
//		
// 功能描述：
//		调试
// 引用：
//		
// ********************************************************************
static void CheckThread( LPTHREAD lpThread )
{
	extern volatile DWORD dwJiffies;
	LPCRITICAL_SECTION lpcs;
	if( lpThread->dwState == THREAD_UNINTERRUPTIBLE &&
		( lpcs = (LPCRITICAL_SECTION)(lpThread->lpdwTLS[TLS_CRITICAL_SECTION]) ) )
	{
		//CALLSTACK cs;
		CALLSTACK * lpcall = KHeap_Alloc( sizeof( CALLSTACK ) );

		SwitchToProcess( lpThread->lpOwnerProcess, lpcall );
		if( lpcs->uiFlag & 0x1 )//CSF_DEBUG )
			EdbgOutputDebugString( "hThread(0x%x),OwnerProc(%s),CurProc(%s),Locked by CS(0x%x,%s), at file(%s),line(%d),time(0x%x).\r\n", lpThread->hThread, lpThread->lpOwnerProcess->lpszApplicationName, lpThread->lpCurProcess->lpszApplicationName, lpcs, lpcs->lpcsName, lpcs->lpFileName, lpcs->iFileLine, lpThread->dwTimerCount );
		else
			EdbgOutputDebugString( "hThread(0x%x),OwnerProc(%s),CurProc(%s),Locked by CS(0x%x,%s),time(0x%x).\r\n", lpThread->hThread, lpThread->lpOwnerProcess->lpszApplicationName, lpThread->lpCurProcess->lpszApplicationName, lpcs, lpcs->lpcsName, lpThread->dwTimerCount );
		SwitchBackProcess();

		KHeap_Free( lpcall, sizeof( CALLSTACK ) );

	}
	else if( lpThread->dwState == THREAD_RUNNING )
	{
		EdbgOutputDebugString( "Thread running,hThread(0x%x),OwnerProc(%s),CurProc(%s),time(0x%x).\r\n", lpThread->hThread, lpThread->lpOwnerProcess->lpszApplicationName,lpThread->lpCurProcess->lpszApplicationName, lpThread->dwTimerCount );
	}
	else if( lpThread->dwState == THREAD_ZOMBIE )
	{
		EdbgOutputDebugString( "Thread zombie(die),ThreadID(0x%x),OwnerProc(%s),CurProc(%s),time(0x%x).\r\n", lpThread->dwThreadId, lpThread->lpOwnerProcess->lpszApplicationName,lpThread->lpCurProcess->lpszApplicationName, lpThread->dwTimerCount );
	}
	else// if( lpThread->dwState != THREAD_RUNNING )
	{
		EdbgOutputDebugString( "hThread(0x%x),OwnerProc(%s),CurProc(%s),Locked by somthing...,timeout(%d),dwJiffies(%d),diff(%d),lpsemWait(0x%x),time(0x%x).\r\n", lpThread->hThread,lpThread->lpOwnerProcess->lpszApplicationName,lpThread->lpCurProcess->lpszApplicationName,lpThread->dwTimeout, dwJiffies, dwJiffies - lpThread->dwTimeout, lpThread->lppsemWait, lpThread->dwTimerCount );
	}
}

// ********************************************************************
// 声明：void WINAPI KL_ProfileKernel( UINT uiOption, VOID * lpv )
// 参数：
//		IN uiOption - 功能号
//		IN lpv - 功能对应的附加参数
// 返回值：
//		无
// 功能描述：
//		对内核状态进行分析，用于调试
// 引用：
//		
// ********************************************************************
void WINAPI KL_ProfileKernel( UINT uiOption, VOID * lpv )
{
	EdbgOutputDebugString( "ProfileKernel start.\r\n" );
    if( uiOption == 1 )
	{   // profile running thread
		LPTHREAD p;
		//UINT uiSave;

	    //LockIRQSave( &uiSave );
        LOCK_SCHE();
		p = lpInitKernelThread;
		do
		{
			if( p->dwState == THREAD_RUNNING )
			    EdbgOutputDebugString( "ThreadId=0x%x,OwnerProcess=%s,CurProcess=%s,CurPrio=%d,nBoost=%d,time(%d).\r\n", p->dwThreadId, p->lpOwnerProcess->lpszApplicationName, p->lpCurProcess->lpszApplicationName, p->nCurPriority, p->nBoost, p->dwTimerCount );
			p = p->lpNextThread;
		}while( p != lpInitKernelThread );

	    //UnlockIRQRestore( &uiSave );
		UNLOCK_SCHE();
	}
	else if( uiOption == 2 )
	{    //  profile all thread
		LPTHREAD lpThread;
		//UINT uiSave;
		//LockIRQSave( &uiSave );
		LOCK_SCHE();
		for ( lpThread = lpInitKernelThread ; (lpThread = lpThread->lpNextThread) != lpInitKernelThread; )
		{
			CheckThread( lpThread );
		}
		//UnlockIRQRestore( &uiSave );
		UNLOCK_SCHE();
	}
	else if( uiOption == 3 )
	{// get a thread handle, and see it if in wait ... or sleep
		LPTHREAD lpThread = (LPTHREAD)HandleToPtr( (HANDLE)lpv, OBJ_THREAD );
		
		if( lpThread )
		{
//			UINT uiSave;
//			LockIRQSave( &uiSave );
			LOCK_SCHE();
			CheckThread( lpThread );
			UNLOCK_SCHE();
//			UnlockIRQRestore( &uiSave );
		}
	}
	else if( uiOption == 4 )
	{  // percent of cpu consume / 消耗		
		//if( lpv )
		{
			static DWORD dwSaveTimerCount = 0;
			static DWORD dwSaveJiffies = 0;

			DWORD dwDiffTimerCount = lpInitKernelThread->dwTimerCount - dwSaveTimerCount;
			DWORD dwDiffJiffies = dwJiffies - dwSaveJiffies;

			dwSaveTimerCount = lpInitKernelThread->dwTimerCount;
			dwSaveJiffies = dwJiffies;

			LOCK_SCHE();

		    EdbgOutputDebugString( "CPU Idle=(%d).\r\n", dwDiffTimerCount * 100 / dwDiffJiffies );
			UNLOCK_SCHE();
		}
	}
	else if( uiOption == 5 )
	{	// process memory consume
		int i;
		DWORD dwTotalCommitHeapSize  = 0;
		DWORD dwTotalCommitVirtualSize  = 0;
		LOCK_SCHE();

		for( i = 0; i < MAX_PROCESSES; i++ )
		{
			if( lppProcessPtr[i] )
			{
				EdbgOutputDebugString( "ProcessHeap:%s,dwTotalReserveHeapSize=%d,dwTotalCommitHeapSize=%d.\r\n",
										lppProcessPtr[i]->lpszApplicationName,
										lppProcessPtr[i]->lpHeap ? lppProcessPtr[i]->lpHeap->dwTotalReserveSize : 0, 
										lppProcessPtr[i]->lpHeap ? lppProcessPtr[i]->lpHeap->dwTotalCommitSize : 0 );
				dwTotalCommitHeapSize += lppProcessPtr[i]->lpHeap->dwTotalCommitSize;

#ifdef VIRTUAL_MEM
				{
					DWORD dwAvailVirtual = 0;
					DWORD dwReserve = 0;
					DWORD dwCommit = 0;
					
					if( lppProcessPtr[i]->lpProcessSegments )
					{
						Seg_GetInfo( lppProcessPtr[i]->lpProcessSegments->lpSeg, &dwAvailVirtual, &dwReserve, &dwCommit );
						EdbgOutputDebugString( "Processe dwCommitVirtualSize=%d, %dk.\r\n", dwCommit, dwCommit / 1024 );
						dwTotalCommitVirtualSize += dwCommit;
					}
				}
#endif
			}
		}
		EdbgOutputDebugString( "Processes dwTotalCommitHeapSize=%d, %dk.\r\n", dwTotalCommitHeapSize, dwTotalCommitHeapSize / 1024 );
		EdbgOutputDebugString( "Processes dwTotalCommitVirtualSize=%d, %dk.\r\n", dwTotalCommitVirtualSize, dwTotalCommitVirtualSize / 1024 );
		UNLOCK_SCHE();
	}

	EdbgOutputDebugString( "ProfileKernel end.\r\n" );
}