devlib.c

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

typedef BOOL ( WINAPI * PDEV_WRITEFILE )( HANDLE hOpenFile, LPCVOID lpvBuffer, DWORD dwBytesToWrite, LPDWORD lpdwNumBytesWritten, LPOVERLAPPED lpOverlapped );
BOOL WINAPI Dev_WriteFile( HANDLE hOpenFile,
						   LPCVOID lpvBuffer,
						   DWORD dwBytesToWrite,
						   LPDWORD lpdwNumBytesWritten,
						   LPOVERLAPPED lpOverlapped )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_WRITEFILE, 5 );
    cs.arg0 = (DWORD)hOpenFile;
    return (DWORD)CALL_SERVER( &cs, lpvBuffer, dwBytesToWrite, lpdwNumBytesWritten, lpOverlapped );
#else

    PDEV_WRITEFILE pWriteFile;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_WRITEFILE, &pWriteFile, &cs ) )
	{
		lpvBuffer = MapProcessPtr( lpvBuffer, (LPPROCESS)cs.lpvData );
		lpdwNumBytesWritten = MapProcessPtr( lpdwNumBytesWritten, (LPPROCESS)cs.lpvData );
		lpOverlapped = MapProcessPtr( lpOverlapped, (LPPROCESS)cs.lpvData );

		retv = pWriteFile( hOpenFile, lpvBuffer, dwBytesToWrite, lpdwNumBytesWritten, lpOverlapped );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_FLUSHFILEBUFFERS )(HANDLE hOpenFile);
BOOL WINAPI Dev_FlushFileBuffers( HANDLE hOpenFile )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_FLUSHFILEBUFFERS, 1 );
    cs.arg0 = (DWORD)hOpenFile ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PDEV_FLUSHFILEBUFFERS pFlush;
	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_FLUSHFILEBUFFERS, &pFlush, &cs ) )
	{
		retv = pFlush( hOpenFile );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_SETFILETIME )(HANDLE hOpenFile, CONST FILETIME *lpCreation, CONST FILETIME *lpLastAccess, CONST FILETIME *lpLastWrite);
BOOL WINAPI Dev_SetFileTime( HANDLE hOpenFile, 
							 CONST FILETIME *lpCreation, 
							 CONST FILETIME *lpLastAccess,
							 CONST FILETIME *lpLastWrite )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_SETFILETIME, 4 );
    cs.arg0 = (DWORD)hOpenFile;
    return (DWORD)CALL_SERVER( &cs, lpCreation, lpLastAccess, lpLastWrite );
#else

	PDEV_SETFILETIME pSetFileTime;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_SETFILETIME, &pSetFileTime, &cs ) )
	{
		lpCreation = MapProcessPtr( lpCreation, (LPPROCESS)cs.lpvData );
		lpLastAccess = MapProcessPtr( lpLastAccess, (LPPROCESS)cs.lpvData );
		lpLastWrite = MapProcessPtr( lpLastWrite, (LPPROCESS)cs.lpvData );

		retv = pSetFileTime( hOpenFile, lpCreation, lpLastAccess, lpLastWrite );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_GETFILETIME )(HANDLE hOpenFile, LPFILETIME lpftCreation, LPFILETIME lpftLastAccess, LPFILETIME lpftLastWrite);
BOOL WINAPI Dev_GetFileTime( HANDLE hOpenFile, 
							 LPFILETIME lpftCreation,
							 LPFILETIME lpftLastAccess,
							 LPFILETIME lpftLastWrite )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_GETFILETIME, 4 );
    cs.arg0 = (DWORD)hOpenFile;
    return (DWORD)CALL_SERVER( &cs, lpftCreation, lpftLastAccess, lpftLastWrite );
#else

	PDEV_GETFILETIME pGetFileTime;

	CALLSTACK cs;
	BOOL  retv = NULL;

	if( API_Enter( API_DEV_FILE, DEV_GETFILETIME, &pGetFileTime, &cs ) )
	{
		lpftCreation = MapProcessPtr( lpftCreation, (LPPROCESS)cs.lpvData );
		lpftLastAccess = MapProcessPtr( lpftLastAccess, (LPPROCESS)cs.lpvData );
		lpftLastWrite = MapProcessPtr( lpftLastWrite, (LPPROCESS)cs.lpvData );

		retv = pGetFileTime( hOpenFile, lpftCreation, lpftLastAccess, lpftLastWrite );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_GETFILESIZE )( HANDLE hOpenFile, LPDWORD lpdwFileSizeHigh );
DWORD Dev_GetFileSize( HANDLE hOpenFile, LPDWORD lpdwFileSizeHigh )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_GETFILESIZE, 2 );
    cs.arg0 = (DWORD)hOpenFile;
    return (DWORD)CALL_SERVER( &cs, lpdwFileSizeHigh );
#else

	PDEV_GETFILESIZE pGetFileSize;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_GETFILESIZE, &pGetFileSize, &cs ) )
	{
		lpdwFileSizeHigh = MapProcessPtr( lpdwFileSizeHigh, (LPPROCESS)cs.lpvData );

		retv = pGetFileSize( hOpenFile, lpdwFileSizeHigh );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_SETENDOFFILE )(HANDLE);
BOOL WINAPI Dev_SetEndOfFile( HANDLE hOpenFile )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_SETENDOFFILE, 1 );
    cs.arg0 = (DWORD)hOpenFile ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PDEV_SETENDOFFILE pSetEndOfFile;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_SETENDOFFILE, &pSetEndOfFile, &cs ) )
	{
		retv = pSetEndOfFile( hOpenFile );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_SETFILEPOINTER )( HANDLE hOpenFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod );

DWORD WINAPI Dev_SetFilePointer(
						 HANDLE hOpenFile, 
						 LONG lDistanceToMove, 
						 PLONG lpDistanceToMoveHigh,
						 DWORD dwMoveMethod ) 
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_SETFILEPOINTER, 4 );
    cs.arg0 = (DWORD)hOpenFile;
    return (DWORD)CALL_SERVER( &cs, lDistanceToMove, lpDistanceToMoveHigh, dwMoveMethod );
#else

	PDEV_SETFILEPOINTER pSetFilePointer;

	CALLSTACK cs;
	DWORD  retv = 0xffffffff;

	if( API_Enter( API_DEV_FILE, DEV_SETFILEPOINTER, &pSetFilePointer, &cs ) )
	{
		lpDistanceToMoveHigh = MapProcessPtr( lpDistanceToMoveHigh, (LPPROCESS)cs.lpvData );

		retv = pSetFilePointer( hOpenFile, lDistanceToMove, lpDistanceToMoveHigh, dwMoveMethod );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_GETFILEINFORMATIONBYHANDLE )(HANDLE hOpenFile, LPBY_HANDLE_FILE_INFORMATION lpFileInfo);
BOOL WINAPI Dev_GetFileInformationByHandle( HANDLE hOpenFile, LPBY_HANDLE_FILE_INFORMATION lpFileInfo )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_GETFILEINFORMATIONBYHANDLE, 2 );
    cs.arg0 = (DWORD)hOpenFile;
    return (DWORD)CALL_SERVER( &cs, lpFileInfo );
#else

	PDEV_GETFILEINFORMATIONBYHANDLE pGetFileInfo;
	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_GETFILEINFORMATIONBYHANDLE, &pGetFileInfo, &cs ) )
	{
	    lpFileInfo = MapProcessPtr( lpFileInfo, (LPPROCESS)cs.lpvData );

		retv = pGetFileInfo( hOpenFile, lpFileInfo );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_IOCONTROL )(HANDLE hOpenFile, DWORD  dwIoControlCode, LPVOID lpvInBuf, DWORD dwInBufSize, LPVOID lpvOutBuf, DWORD dwOutBufSize, LPDWORD lpdwBytesReturned, LPOVERLAPPED lpOverlapped);
BOOL WINAPI Dev_IoControl( HANDLE hOpenFile,
						   DWORD  dwIoControlCode,
						   LPVOID lpvInBuf,
						   DWORD dwInBufSize,
						   LPVOID lpvOutBuf,
						   DWORD dwOutBufSize,
						   LPDWORD lpdwBytesReturned,
						   LPOVERLAPPED lpOverlapped )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_IOCONTROL, 8 );
    cs.arg0 = (DWORD)hOpenFile;
    return (DWORD)CALL_SERVER( &cs, dwIoControlCode, lpvInBuf, dwInBufSize, lpvOutBuf, dwOutBufSize, lpdwBytesReturned, lpOverlapped );
#else

	PDEV_IOCONTROL pIoControl;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_IOCONTROL, &pIoControl, &cs ) )
	{
		lpvInBuf = MapProcessPtr( lpvInBuf, (LPPROCESS)cs.lpvData );
		lpvOutBuf = MapProcessPtr( lpvOutBuf, (LPPROCESS)cs.lpvData );
		lpdwBytesReturned = MapProcessPtr( lpdwBytesReturned, (LPPROCESS)cs.lpvData );
		lpOverlapped = MapProcessPtr( lpOverlapped, (LPPROCESS)cs.lpvData );
		
		retv = pIoControl( hOpenFile, dwIoControlCode, lpvInBuf, dwInBufSize, lpvOutBuf, dwOutBufSize, lpdwBytesReturned, lpOverlapped );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_GetSystemPowerStatusEx )(PSYSTEM_POWER_STATUS_EX pstatus, BOOL fUpdate);
BOOL WINAPI Dev_GetSystemPowerStatusEx(
				PSYSTEM_POWER_STATUS_EX pstatus, 
				BOOL fUpdate )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV, DEV_GETSYSTEMPOWERSTATUSEX, 2 );
    cs.arg0 = (DWORD)pstatus;
    return (DWORD)CALL_SERVER( &cs, fUpdate );
#else

	PDEV_GetSystemPowerStatusEx pfn;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV, DEV_GETSYSTEMPOWERSTATUSEX, &pfn, &cs ) )
	{
		pstatus = (PSYSTEM_POWER_STATUS_EX)MapProcessPtr( pstatus, (LPPROCESS)cs.lpvData );
	
		retv = pfn( pstatus, fUpdate );
		API_Leave();
	}
	return retv;
#endif
}