ShuriZma
/
Cxbx-Reloaded
mirror of https://github.com/Cxbx-Reloaded/Cxbx-Reloaded.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #20 from PatrickvL/master

This commit is contained in:
Luke Usher 2016-11-26 08:56:24 +00:00 committed by GitHub
parent 26c5fb4911 740f1ae8af
commit 7bc449faff
34 changed files with 1426 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
import/OpenXDK/include/xboxkrnl/dbg.h
View File

@ -12,15 +12,33 @@
#ifndef XBOXKRNL_DBG_H
#define XBOXKRNL_DBG_H
XBSYSAPI VOID *DbgBreakPoint;
XBSYSAPI VOID *DbgBreakPointWithStatus;
XBSYSAPI VOID *DbgLoadImageSymbols;
XBSYSAPI EXPORTNUM(5) VOID NTAPI DbgBreakPoint();
XBSYSAPI EXPORTNUM(6) VOID NTAPI DbgBreakPointWithStatus
(
IN ULONG Status
);
XBSYSAPI EXPORTNUM(7) NTSTATUS NTAPI DbgLoadImageSymbols
(
IN PANSI_STRING Name,
IN PVOID Base,
IN ULONG_PTR ProcessId
);
XBSYSAPI EXPORTNUM(8) ULONG _cdecl DbgPrint
(
PCHAR Format, ...
);
XBSYSAPI VOID *DbgPrompt;
XBSYSAPI VOID *DbgUnLoadImageSymbols;
XBSYSAPI EXPORTNUM(10) ULONG NTAPI DbgPrompt
(
IN PCCH Prompt,
OUT PCH Response,
IN ULONG MaximumResponseLength
);
XBSYSAPI EXPORTNUM(11) VOID NTAPI DbgUnLoadImageSymbols
(
IN PANSI_STRING Name,
IN PVOID Base,
IN ULONG_PTR ProcessId
);
#endif

95
import/OpenXDK/include/xboxkrnl/ex.h
View File

@ -12,8 +12,15 @@
#ifndef XBOXKRNL_EX_H
#define XBOXKRNL_EX_H
XBSYSAPI VOID *ExAcquireReadWriteLockExclusive;
XBSYSAPI VOID *ExAcquireReadWriteLockShared;
XBSYSAPI EXPORTNUM(12) NTSTATUS NTAPI ExAcquireReadWriteLockExclusive
(
IN PERWLOCK ReadWriteLock
);
XBSYSAPI EXPORTNUM(13) NTSTATUS NTAPI ExAcquireReadWriteLockShared
(
IN PERWLOCK ReadWriteLock
);
// ******************************************************************
// * ExAllocatePool
@ -24,7 +31,7 @@ XBSYSAPI VOID *ExAcquireReadWriteLockShared;
// ******************************************************************
XBSYSAPI EXPORTNUM(14) PVOID NTAPI ExAllocatePool
(
IN ULONG NumberOfBytes
IN SIZE_T NumberOfBytes
);
// ******************************************************************
@ -54,16 +61,41 @@ XBSYSAPI EXPORTNUM(17) VOID NTAPI ExFreePool
IN PVOID P
);
XBSYSAPI VOID *ExInitializeReadWriteLock;
XBSYSAPI VOID *ExInterlockedAddLargeInteger;
XBSYSAPI VOID *ExInterlockedAddLargeStatistic;
XBSYSAPI VOID *ExInterlockedCompareExchange64;
XBSYSAPI EXPORTNUM(18) NTSTATUS NTAPI ExInitializeReadWriteLock
(
IN PERWLOCK ReadWriteLock
);
// Source:APILogger - Uncertain
XBSYSAPI EXPORTNUM(19) LARGE_INTEGER NTAPI ExInterlockedAddLargeInteger
(
IN OUT PLARGE_INTEGER Addend,
IN LARGE_INTEGER Increment,
IN OUT PKSPIN_LOCK Lock
);
// Source:ReactOS
XBSYSAPI EXPORTNUM(20) VOID __fastcall ExInterlockedAddLargeStatistic
(
IN PLARGE_INTEGER Addend,
IN ULONG Increment
);
// Source:ReactOS
XBSYSAPI EXPORTNUM(21) LONGLONG __fastcall ExInterlockedCompareExchange64
(
IN OUT PLONGLONG Destination,
IN PLONGLONG Exchange,
IN PLONGLONG Comparand,
IN PKSPIN_LOCK Lock
);
XBSYSAPI EXPORTNUM(22) POBJECT_TYPE ExMutantObjectType;
// ******************************************************************
// * ExQueryPoolBlockSize
// ******************************************************************
XBSYSAPI EXPORTNUM(23) ULONG NTAPI ExQueryPoolBlockSize
XBSYSAPI EXPORTNUM(23) ULONG NTAPI ExQueryPoolBlockSize
(
IN PVOID PoolBlock
);
@ -85,14 +117,25 @@ XBSYSAPI EXPORTNUM(24) NTSTATUS NTAPI ExQueryNonVolatileSetting
// ******************************************************************
XBSYSAPI EXPORTNUM(25) NTSTATUS NTAPI ExReadWriteRefurbInfo
(
PVOID Unknown1,
DWORD Unknown2,
DWORD Unknown3
IN OUT PXBOX_REFURB_INFO pRefurbInfo,
IN ULONG dwBufferSize,
IN BOOLEAN bIsWriteMode
);
XBSYSAPI VOID *ExRaiseException;
XBSYSAPI VOID *ExRaiseStatus;
XBSYSAPI VOID *ExReleaseReadWriteLock;
XBSYSAPI EXPORTNUM(26) VOID NTAPI ExRaiseException
(
IN PEXCEPTION_RECORD ExceptionRecord
);
XBSYSAPI EXPORTNUM(27) VOID NTAPI ExRaiseStatus
(
IN NTSTATUS Status
);
XBSYSAPI EXPORTNUM(28) NTSTATUS NTAPI ExReleaseReadWriteLock
(
IN PERWLOCK ReadWriteLock
);
// ******************************************************************
// * ExSaveNonVolatileSetting
@ -107,9 +150,27 @@ XBSYSAPI EXPORTNUM(29) NTSTATUS NTAPI ExSaveNonVolatileSetting
XBSYSAPI EXPORTNUM(30) POBJECT_TYPE ExSemaphoreObjectType;
XBSYSAPI EXPORTNUM(31) POBJECT_TYPE ExTimerObjectType;
XBSYSAPI VOID *ExfInterlockedInsertHeadList;
XBSYSAPI VOID *ExfInterlockedInsertTailList;
XBSYSAPI VOID *ExfInterlockedRemoveHeadList;
XBSYSAPI EXPORTNUM(32) PLIST_ENTRY __fastcall ExfInterlockedInsertHeadList
(
IN PLIST_ENTRY ListHead,
IN PLIST_ENTRY ListEntry,
IN PKSPIN_LOCK Lock
);
XBSYSAPI EXPORTNUM(33) PLIST_ENTRY __fastcall ExfInterlockedInsertTailList
(
IN PLIST_ENTRY ListHead,
IN PLIST_ENTRY ListEntry,
IN PKSPIN_LOCK Lock
);
XBSYSAPI EXPORTNUM(34) PLIST_ENTRY __fastcall ExfInterlockedRemoveHeadList
(
IN PLIST_ENTRY ListHead,
IN PKSPIN_LOCK Lock
);
XBSYSAPI VOID *InterlockedCompareExchange;
XBSYSAPI VOID *InterlockedDecrement;
XBSYSAPI VOID *InterlockedIncrement;

60
import/OpenXDK/include/xboxkrnl/hal.h
View File

@ -21,12 +21,26 @@ XBSYSAPI EXPORTNUM(9) VOID NTAPI HalReadSMCTrayState
DWORD* Count
);
XBSYSAPI VOID *HalClearSoftwareInterrupt;
XBSYSAPI VOID *HalDisableSystemInterrupt;
XBSYSAPI ULONG HalDiskCachePartitionCount;
XBSYSAPI EXPORTNUM(38) VOID __fastcall HalClearSoftwareInterrupt
(
KIRQL Request
);
XBSYSAPI EXPORTNUM(39) VOID NTAPI HalDisableSystemInterrupt
(
ULONG Vector,
KIRQL Irql
);
XBSYSAPI EXPORTNUM(40) ULONG HalDiskCachePartitionCount;
XBSYSAPI EXPORTNUM(41) PANSI_STRING HalDiskModelNumber;
XBSYSAPI EXPORTNUM(42) PANSI_STRING HalDiskSerialNumber;
XBSYSAPI VOID *HalEnableSystemInterrupt;
XBSYSAPI EXPORTNUM(43) BOOLEAN NTAPI HalEnableSystemInterrupt
(
ULONG Vector,
KIRQL Irql,
KINTERRUPT_MODE InterruptMode
);
// ******************************************************************
// * HalGetInterruptVector
@ -71,12 +85,16 @@ typedef struct {
LIST_ENTRY ListEntry;
} HAL_SHUTDOWN_REGISTRATION, *PHAL_SHUTDOWN_REGISTRATION;
// TODO : NTAPI or __fastcall ?
XBSYSAPI EXPORTNUM(47) VOID HalRegisterShutdownNotification(
IN PHAL_SHUTDOWN_REGISTRATION ShutdownRegistration,
IN BOOLEAN Register
);
XBSYSAPI VOID *HalRequestSoftwareInterrupt;
XBSYSAPI EXPORTNUM(46) VOID __fastcall HalRequestSoftwareInterrupt
(
IN KIRQL Request
);
// ******************************************************************
// * HalReturnToFirmware
@ -101,16 +119,6 @@ XBSYSAPI EXPORTNUM(50) NTSTATUS NTAPI HalWriteSMBusValue
ULONG DataValue
);
// ******************************************************************
// * HalBootSMCVideoMode
// ******************************************************************
XBSYSAPI EXPORTNUM(356) DWORD HalBootSMCVideoMode;
XBSYSAPI VOID *HalIsResetOrShutdownPending;
XBSYSAPI VOID *HalInitiateShutdown;
XBSYSAPI VOID *HalEnableSecureTrayEject;
XBSYSAPI VOID *HalWriteSMCScratchRegister;
// ******************************************************************
// * READ_PORT_BUFFER_UCHAR
// ******************************************************************
@ -171,6 +179,28 @@ XBSYSAPI EXPORTNUM(334) VOID NTAPI WRITE_PORT_BUFFER_ULONG
IN ULONG Count
);
// ******************************************************************
// * HalBootSMCVideoMode
// ******************************************************************
XBSYSAPI EXPORTNUM(356) DWORD HalBootSMCVideoMode;
XBSYSAPI EXPORTNUM(358) BOOLEAN NTAPI HalIsResetOrShutdownPending
(
);
XBSYSAPI EXPORTNUM(360) NTSTATUS NTAPI HalInitiateShutdown
(
);
XBSYSAPI EXPORTNUM(365) VOID NTAPI HalEnableSecureTrayEject
(
);
XBSYSAPI EXPORTNUM(366) NTSTATUS NTAPI HalWriteSMCScratchRegister
(
IN DWORD ScratchRegister
);
#endif

27
import/OpenXDK/include/xboxkrnl/kernel.h
View File

@ -12,9 +12,20 @@
#ifndef KERNEL_H
#define KERNEL_H
XBSYSAPI VOID *KeAlertResumeThread;
XBSYSAPI VOID *KeAlertThread;
XBSYSAPI VOID *KeBoostPriorityThread;
XBSYSAPI EXPORTNUM(92) NTSTATUS NTAPI KeAlertResumeThread
(
IN HANDLE ThreadHandle,
IN OUT PULONG PreviousSuspendCount
);
XBSYSAPI EXPORTNUM(93) NTSTATUS NTAPI KeAlertThread
(
IN HANDLE ThreadHandle
);
XBSYSAPI EXPORTNUM(94) NTSTATUS NTAPI KeBoostPriorityThread
(
);
// ******************************************************************
// * KeBugCheck
@ -24,7 +35,15 @@ XBSYSAPI EXPORTNUM(95) VOID NTAPI KeBugCheck
IN ULONG BugCheckMode
);
XBSYSAPI VOID *KeBugCheckEx;
XBSYSAPI EXPORTNUM(96) NTSTATUS NTAPI KeBugCheckEx
(
IN DWORD BugCheckCode,
IN PVOID BugCheckParameter1,
IN PVOID BugCheckParameter2,
IN PVOID BugCheckParameter3,
IN PVOID BugCheckParameter4
);
XBSYSAPI VOID *KeCancelTimer;
// ******************************************************************

3
import/OpenXDK/include/xboxkrnl/ps.h
View File

@ -50,8 +50,7 @@ XBSYSAPI VOID *PsSetCreateThreadNotifyRoutine;
// ******************************************************************
XBSYSAPI EXPORTNUM(258) VOID NTAPI PsTerminateSystemThread(IN NTSTATUS ExitStatus);
//XBSYSAPI VOID *PsThreadObjectType;
XBSYSAPI EXPORTNUM(259) volatile DWORD PsThreadObjectType;
XBSYSAPI EXPORTNUM(259) volatile POBJECT_TYPE PsThreadObjectType;
#endif

15
import/OpenXDK/include/xboxkrnl/rtl.h
View File

@ -27,12 +27,21 @@ XBSYSAPI EXPORTNUM(260) NTSTATUS NTAPI RtlAnsiStringToUnicodeString
// ******************************************************************
XBSYSAPI EXPORTNUM(261) NTSTATUS NTAPI RtlAppendStringToString
(
IN PSTRING Destination,
IN OUT PSTRING Destination,
IN PSTRING Source
);
XBSYSAPI VOID *RtlAppendUnicodeStringToString;
XBSYSAPI VOID *RtlAppendUnicodeToString;
XBSYSAPI EXPORTNUM(262) NTSTATUS NTAPI RtlAppendUnicodeStringToString
(
IN OUT PUNICODE_STRING Destination,
IN PUNICODE_STRING Source
);
XBSYSAPI EXPORTNUM(263) NTSTATUS NTAPI RtlAppendUnicodeToString
(
IN OUT PUNICODE_STRING Destination,
IN LPCWSTR Source
);
// ******************************************************************
// * RtlAssert

2
import/OpenXDK/include/xboxkrnl/xbox.h
View File

@ -54,7 +54,7 @@ XBSYSAPI EXPORTNUM(4) VOID NTAPI AvSetSavedDataAddress
// ******************************************************************
XBSYSAPI EXPORTNUM(35) DWORD NTAPI FscGetCacheSize();
XBSYSAPI VOID *FscInvalidateIdleBlocks;
XBSYSAPI EXPORTNUM(36) VOID NTAPI FscInvalidateIdleBlocks();
// ******************************************************************
// * FscSetCacheSize

67
import/OpenXDK/include/xboxkrnl/xboxkrnl.h
View File

@ -85,7 +85,7 @@ typedef unsigned long PHYSICAL_ADDRESS;
typedef long INT_PTR;
typedef signed __int64 LONGLONG;
typedef unsigned __int64 ULONGLONG;
typedef unsigned short WCHAR;
typedef wchar_t WCHAR;
// ******************************************************************
// * Pointer types
@ -99,13 +99,27 @@ typedef USHORT *PUSHORT;
typedef ULONG *PULONG;
typedef DWORD *PDWORD, *LPDWORD;
typedef ACCESS_MASK *PACCESS_MASK;
typedef LONG *PLONG, *LONG_PTR;
typedef ULONG *ULONG_PTR;
typedef INT_PTR *PINT_PTR;
typedef LONG *PLONG;
typedef long *PINT_PTR;
typedef VOID *PVOID, *LPVOID;
typedef void *HANDLE;
typedef HANDLE *PHANDLE;
// Additional basic and pointer types :
typedef __int32 LONG_PTR; // TODO : Update this declaration for 64 bit
typedef unsigned __int32 ULONG_PTR; // TODO : Update this declaration for 64 bit
typedef LONGLONG *PLONGLONG;
// ******************************************************************
// ANSI (Multi-byte Character) types
// ******************************************************************
typedef CHAR *PCHAR, *LPCH, *PCH;
typedef CONST CHAR *LPCCH, *PCCH;
typedef /*_Null_terminated_*/ CONST WCHAR *LPCWSTR, *PCWSTR;
// ******************************************************************
// * LPSECURITY_ATTRIBUTES
// ******************************************************************
@ -394,6 +408,51 @@ typedef struct _OBJECT_TYPE
}
OBJECT_TYPE, *POBJECT_TYPE;
// Source : DXBX
typedef ULONG_PTR KSPIN_LOCK;
typedef KSPIN_LOCK *PKSPIN_LOCK;
// Source : DXBX
typedef struct _FILETIME
{
DWORD dwLowDateTime;
DWORD dwHighDateTime;
}
FILETIME, *PFILETIME;
typedef struct _ERWLOCK {
LONG LockCount;
ULONG WritersWaitingCount;
ULONG ReadersWaitingCount;
ULONG ReadersEntryCount;
// TODO : Enable once KEVENT and KSEMAPHORE are defined :
// KEVENT WriterEvent;
// KSEMAPHORE ReaderSemaphore;
} ERWLOCK, *PERWLOCK;
// Source : DXBX (Xbox Refurb Info)
typedef struct _XBOX_REFURB_INFO
{
DWORD Signature;
DWORD PowerCycleCount;
FILETIME FirstBootTime;
}
XBOX_REFURB_INFO, *PXBOX_REFURB_INFO;
int const EXCEPTION_MAXIMUM_PARAMETERS = 15; // maximum number of exception parameters
// Source : DXBX
typedef struct _EXCEPTION_RECORD
{
DWORD ExceptionCode;
DWORD ExceptionFlags;
_EXCEPTION_RECORD *ExceptionRecord;
VOID *ExceptionAddress;
DWORD NumberParameters;
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
}
EXCEPTION_RECORD, *PEXCEPTION_RECORD;
// ******************************************************************
// * FSINFOCLASS
// ******************************************************************

22
src/Common/Logging.h
View File

@ -92,11 +92,16 @@ extern thread_local std::string _logPrefix;
msg << ");\n"; \
std::cout << msg.str(); \
} } while (0)
// LOG_FUNC_RESULT logs the function return result
#define LOG_FUNC_RESULT(r) \
std::cout << _logPrefix << " returns " << r;
#else
#define LOG_FUNC_BEGIN ;
#define LOG_FUNC_ARG(arg);
#define LOG_FUNC_ARG_OUT(arg);
#define LOG_FUNC_END ;
#define LOG_FUNC_BEGIN
#define LOG_FUNC_ARG(arg)
#define LOG_FUNC_ARG_OUT(arg)
#define LOG_FUNC_END
#define LOG_FUNC_RESULT(r)
#endif
// Short hand defines :
@ -109,9 +114,16 @@ extern thread_local std::string _logPrefix;
// Log function with one out argument
#define LOG_FUNC_ONE_ARG_OUT(arg) LOG_FUNC_BEGIN LOG_FUNC_ARG_OUT(arg) LOG_FUNC_END
#define UNIMPLEMENTED() \
#define LOG_IGNORED() \
do { if(g_bPrintfOn) { \
std::cout << __func__ << " ignored!\n"; \
} } while (0)
#define LOG_UNIMPLEMENTED() \
do { if(g_bPrintfOn) { \
std::cout << __func__ << " unimplemented!\n"; \
} } while (0)
#define RETURN(r) do { LOG_FUNC_RESULT(r) return r; } while (0)
#endif _LOGGING_H

2
src/CxbxKrnl/CxbxKrnl.cpp
View File

@ -388,7 +388,7 @@ extern "C" CXBXKRNL_API void CxbxKrnlInit
freopen(szDebugFilename, "wt", stdout);
printf("EmuMain (0x%X): Cxbx Version %s\n", GetCurrentThreadId(), _CXBX_VERSION);
printf("EmuMain (0x%X): Cxbx-Reloaded Version %s\n", GetCurrentThreadId(), _CXBX_VERSION);
printf("EmuMain (0x%X): Debug Console Allocated (DM_FILE).\n", GetCurrentThreadId());
}
else

2
src/CxbxKrnl/DbgConsole.cpp
View File

@ -187,7 +187,7 @@ void DbgConsole::ParseCommand()
if(_stricmp(szCmd, "h") == 0 || _stricmp(szCmd, "help") == 0)
{
printf("CxbxDbg: \n");
printf("CxbxDbg: Cxbx Debug Command List:\n");
printf("CxbxDbg: Cxbx-Reloaded Debug Command List:\n");
printf("CxbxDbg: \n");
printf("CxbxDbg: Help [H] : Show Command List\n");
printf("CxbxDbg: Quit/Exit [Q] : Stop Emulation\n");

2
src/CxbxKrnl/EmuDInput.cpp
View File

@ -74,7 +74,7 @@ void XTL::EmuDInputPoll(XTL::PXINPUT_STATE Controller)
g_XBController.ListenPoll(Controller);
if(g_XBController.GetError())
MessageBox(NULL, g_XBController.GetError(), "Cxbx [*UNHANDLED!*]", MB_OK); // TODO: Handle this!
MessageBox(NULL, g_XBController.GetError(), "Cxbx-Reloaded [*UNHANDLED!*]", MB_OK); // TODO: Handle this!
return;
}

4
src/CxbxKrnl/EmuKrnl.cpp
View File

@ -137,7 +137,7 @@ XBSYSAPI EXPORTNUM(160) xboxkrnl::UCHAR* NTAPI xboxkrnl::KfRaiseIrql
LOG_FUNC_ONE_ARG(NewIrql);
// Return addr where old irq level should be stored
return &previousIrqlValue;
RETURN(&previousIrqlValue);
}
// ******************************************************************
@ -150,7 +150,7 @@ XBSYSAPI EXPORTNUM(161) VOID NTAPI xboxkrnl::KfLowerIrql
{
LOG_FUNC_ONE_ARG(NewIrql);
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
}
// Source:ReactOS

42
src/CxbxKrnl/EmuKrnlAv.cpp
View File

@ -97,7 +97,7 @@ XBSYSAPI EXPORTNUM(1) xboxkrnl::PVOID NTAPI xboxkrnl::AvGetSavedDataAddress()
fclose(fp);
}*/
return NULL;//g_pPersistedData;
RETURN (NULL); //g_pPersistedData;
}
// ******************************************************************
@ -118,8 +118,46 @@ XBSYSAPI EXPORTNUM(2) VOID NTAPI xboxkrnl::AvSendTVEncoderOption
LOG_FUNC_ARG_OUT(Result)
LOG_FUNC_END;
// "Run Like Hell" (5233) calls this from a routine at 0x11FCD0 - See XTL_EmuIDirect3DDevice_Unknown1
// TODO: What does this do?
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
}
XBSYSAPI EXPORTNUM(3) xboxkrnl::ULONG NTAPI xboxkrnl::AvSetDisplayMode
(
IN PVOID RegisterBase,
IN ULONG Step,
IN ULONG Mode,
IN ULONG Format,
IN ULONG Pitch,
IN ULONG FrameBuffer
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(RegisterBase)
LOG_FUNC_ARG(Step)
LOG_FUNC_ARG(Mode)
LOG_FUNC_ARG(Format)
LOG_FUNC_ARG(Pitch)
LOG_FUNC_ARG(FrameBuffer)
LOG_FUNC_END;
ULONG result = S_OK;
LOG_UNIMPLEMENTED();
RETURN(result);
}
XBSYSAPI EXPORTNUM(4) VOID NTAPI xboxkrnl::AvSetSavedDataAddress
(
IN PVOID Address
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Address)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}

77
src/CxbxKrnl/EmuKrnlDbg.cpp
View File

@ -46,6 +46,43 @@ namespace xboxkrnl
using namespace xboxkrnl;
XBSYSAPI EXPORTNUM(5) VOID NTAPI xboxkrnl::DbgBreakPoint()
{
LOG_FUNC();
LOG_UNIMPLEMENTED();
}
XBSYSAPI EXPORTNUM(6) VOID NTAPI xboxkrnl::DbgBreakPointWithStatus
(
IN ULONG Status
)
{
LOG_FUNC_ONE_ARG(Status);
LOG_UNIMPLEMENTED();
}
XBSYSAPI EXPORTNUM(7) xboxkrnl::NTSTATUS NTAPI xboxkrnl::DbgLoadImageSymbols
(
IN PANSI_STRING Name,
IN PVOID Base,
IN ULONG_PTR ProcessId
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Name)
LOG_FUNC_ARG(Base)
LOG_FUNC_ARG(ProcessId)
LOG_FUNC_END;
NTSTATUS result = S_OK;
LOG_UNIMPLEMENTED();
RETURN(result);
}
// ******************************************************************
// * 0x0008 DbgPrint
// ******************************************************************
@ -75,5 +112,43 @@ XBSYSAPI EXPORTNUM(8) xboxkrnl::ULONG _cdecl xboxkrnl::DbgPrint
//DbgPrintf(szBuffer);
}
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(10) xboxkrnl::ULONG NTAPI xboxkrnl::DbgPrompt
(
IN PCCH Prompt,
OUT PCH Response,
IN ULONG MaximumResponseLength
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Prompt)
LOG_FUNC_ARG_OUT(Response)
LOG_FUNC_ARG(MaximumResponseLength)
LOG_FUNC_END;
NTSTATUS result = S_OK;
LOG_UNIMPLEMENTED();
RETURN(result);
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(11) VOID NTAPI xboxkrnl::DbgUnLoadImageSymbols
(
IN PANSI_STRING Name,
IN PVOID Base,
IN ULONG_PTR ProcessId
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Name)
LOG_FUNC_ARG(Base)
LOG_FUNC_ARG(ProcessId)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}

298
src/CxbxKrnl/EmuKrnlEx.cpp
View File

@ -49,19 +49,47 @@ namespace xboxkrnl
using namespace xboxkrnl;
// Source:APILogger - Uncertain
XBSYSAPI EXPORTNUM(12) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExAcquireReadWriteLockExclusive
(
IN PERWLOCK ReadWriteLock
)
{
LOG_FUNC_ONE_ARG(ReadWriteLock);
// KeWaitForSingleObject
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// Source:APILogger - Uncertain
XBSYSAPI EXPORTNUM(13) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExAcquireReadWriteLockShared
(
IN PERWLOCK ReadWriteLock
)
{
LOG_FUNC_ONE_ARG(ReadWriteLock);
// KeWaitForSingleObject
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// ******************************************************************
// * 0x000E ExAllocatePool
// ******************************************************************
XBSYSAPI EXPORTNUM(14) xboxkrnl::PVOID NTAPI xboxkrnl::ExAllocatePool
(
IN ULONG NumberOfBytes
IN SIZE_T NumberOfBytes
)
{
LOG_FUNC_ONE_ARG(NumberOfBytes);
PVOID pRet = ExAllocatePoolWithTag(NumberOfBytes, (ULONG)"enoN");
PVOID pRet = ExAllocatePoolWithTag(NumberOfBytes, (ULONG)"enoN"); // "None" in reverse?
return pRet;
RETURN(pRet);
}
// ******************************************************************
@ -84,7 +112,7 @@ XBSYSAPI EXPORTNUM(15) xboxkrnl::PVOID NTAPI xboxkrnl::ExAllocatePoolWithTag
// TODO: Actually implement this
PVOID pRet = CxbxMalloc(NumberOfBytes);
return pRet;
RETURN(pRet);
}
// TODO : What should we initialize this to?
@ -103,6 +131,88 @@ XBSYSAPI EXPORTNUM(17) VOID NTAPI xboxkrnl::ExFreePool
CxbxFree(P);
}
// Source:APILogger - Uncertain
XBSYSAPI EXPORTNUM(18) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExInitializeReadWriteLock
(
IN PERWLOCK ReadWriteLock
)
{
LOG_FUNC_ONE_ARG(ReadWriteLock);
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// Source:ReactOS https://doxygen.reactos.org/d0/d35/ntoskrnl_2ex_2interlocked_8c_source.html#l00062
XBSYSAPI EXPORTNUM(19) xboxkrnl::LARGE_INTEGER NTAPI xboxkrnl::ExInterlockedAddLargeInteger
(
IN OUT PLARGE_INTEGER Addend,
IN LARGE_INTEGER Increment,
IN OUT PKSPIN_LOCK Lock
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Addend)
// TODO : operator<<(LARGE_INTERGER) enables LOG_FUNC_ARG(Increment)
LOG_FUNC_ARG(Lock)
LOG_FUNC_END;
LARGE_INTEGER OldValue;
// TODO : BOOLEAN Enable;
/* Disable interrupts and acquire the spinlock */
// TODO : Enable = _ExiDisableInterruptsAndAcquireSpinlock(Lock);
/* Save the old value */
OldValue.QuadPart = Addend->QuadPart;
/* Do the operation */
Addend->QuadPart += Increment.QuadPart;
/* Release the spinlock and restore interrupts */
// TODO : _ExiReleaseSpinLockAndRestoreInterrupts(Lock, Enable);
/* Return the old value */
return OldValue; // TODO : operator<<(LARGE_INTERGER) enables RETURN(OldValue);
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(20) VOID __fastcall xboxkrnl::ExInterlockedAddLargeStatistic
(
IN PLARGE_INTEGER Addend,
IN ULONG Increment
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Addend)
LOG_FUNC_ARG(Increment)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(21) xboxkrnl::LONGLONG __fastcall xboxkrnl::ExInterlockedCompareExchange64
(
IN OUT PLONGLONG Destination,
IN PLONGLONG Exchange,
IN PLONGLONG Comparand,
IN PKSPIN_LOCK Lock
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG_OUT(Destination)
LOG_FUNC_ARG(Exchange)
LOG_FUNC_ARG(Comparand)
LOG_FUNC_ARG(Lock)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(0);
}
// TODO : What should we initialize this to?
XBSYSAPI EXPORTNUM(22) xboxkrnl::POBJECT_TYPE xboxkrnl::ExMutantObjectType = NULL;
@ -117,7 +227,9 @@ XBSYSAPI EXPORTNUM(23) xboxkrnl::ULONG NTAPI xboxkrnl::ExQueryPoolBlockSize
LOG_FUNC_ONE_ARG(PoolBlock);
// Not strictly correct, but it will do for now
return MmQueryAllocationSize(PoolBlock);
ULONG ret = MmQueryAllocationSize(PoolBlock);
RETURN(ret);
}
// ******************************************************************
@ -236,9 +348,7 @@ XBSYSAPI EXPORTNUM(24) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExQueryNonVolatileSett
break;
}
return ret;
RETURN(ret);
}
// ******************************************************************
@ -246,23 +356,118 @@ XBSYSAPI EXPORTNUM(24) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExQueryNonVolatileSett
// ******************************************************************
XBSYSAPI EXPORTNUM(25) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExReadWriteRefurbInfo
(
PVOID Unknown1,
DWORD Unknown2,
DWORD Unknown3
IN OUT PXBOX_REFURB_INFO pRefurbInfo,
IN ULONG dwBufferSize,
IN BOOLEAN bIsWriteMode
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Unknown1)
LOG_FUNC_ARG(Unknown2)
LOG_FUNC_ARG(Unknown3)
LOG_FUNC_ARG(pRefurbInfo)
LOG_FUNC_ARG(dwBufferSize)
LOG_FUNC_ARG(bIsWriteMode)
LOG_FUNC_END;
// TODO: What does this do?
UNIMPLEMENTED();
NTSTATUS Result = STATUS_SUCCESS;
return STATUS_SUCCESS;
/* TODO: Port this Dxbx code :
if (pRefurbInfo)
{
if dwBufferSize <> SizeOf(XBOX_REFURB_INFO) then
Result = STATUS_INVALID_PARAMETER
else
{
// Open partition 0 directly :
_STRING FileName;
RtlInitAnsiString(&FileName, PCSZ(PAnsiChar(DeviceHarddisk0Partition0)));
OBJECT_ATTRIBUTES ObjectAttributes;
InitializeObjectAttributes(&ObjectAttributes, &FileName, OBJ_CASE_INSENSITIVE, 0, NULL);
Handle ConfigPartitionHandle;
IO_STATUS_BLOCK IoStatusBlock;
Result = xboxkrnl_NtOpenFile(
&ConfigPartitionHandle,
GENERIC_READ or DWORD(iif(aIsWriteMode, GENERIC_WRITE, 0)) or SYNCHRONIZE,
&ObjectAttributes,
&IoStatusBlock,
FILE_SHARE_READ or FILE_SHARE_WRITE,
FILE_SYNCHRONOUS_IO_ALERT);
if (NT_SUCCESS(Result))
{
LARGE_INTEGER ByteOffset;
ByteOffset.QuadPart = XBOX_REFURB_INFO_SECTOR_INDEX * XBOX_HD_SECTOR_SIZE;
XBOX_REFURB_INFO RefurbInfoCopy;
if (bIsWriteMode)
{
RefurbInfoCopy = *pRefurbInfo;
RefurbInfoCopy.Signature_ = XBOX_REFURB_INFO_SIGNATURE;
Result = xboxkrnl_NtWriteFile(ConfigPartitionHandle, 0, NULL, NULL, &IoStatusBlock, &RefurbInfoCopy, XBOX_HD_SECTOR_SIZE, &ByteOffset);
}
else
{
Result = xboxkrnl::NtReadFile(ConfigPartitionHandle, 0, NULL, NULL, &IoStatusBlock, &RefurbInfoCopy, XBOX_HD_SECTOR_SIZE, &ByteOffset);
if (NT_SUCCESS(Result))
{
if (RefurbInfoCopy.Signature_ == XBOX_REFURB_INFO_SIGNATURE)
// No signature - clear output buffer :
ZeroMemory(pRefurbInfo, SizeOf(XBOX_REFURB_INFO))
else
CopyMem(pRefurbInfo, RefurbInfoCopy, SizeOf(XBOX_REFURB_INFO));
}
}
NtClose(ConfigPartitionHandle);
}
}
}
else
Result = STATUS_UNSUCCESSFUL; // This may never happen!
*/
LOG_IGNORED();
RETURN(Result);
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(26) VOID NTAPI xboxkrnl::ExRaiseException
(
IN PEXCEPTION_RECORD ExceptionRecord
)
{
LOG_FUNC_ONE_ARG(ExceptionRecord);
// RtlRaiseException(ExceptionRecord);
LOG_UNIMPLEMENTED();
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(27) VOID NTAPI xboxkrnl::ExRaiseStatus
(
IN NTSTATUS Status
)
{
LOG_FUNC_ONE_ARG(Status);
LOG_UNIMPLEMENTED();
}
// Source:APILogger - Uncertain
XBSYSAPI EXPORTNUM(28) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExReleaseReadWriteLock
(
IN PERWLOCK ReadWriteLock
)
{
LOG_FUNC_ONE_ARG(ReadWriteLock);
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// ******************************************************************
// * 0x001D - ExSaveNonVolatileSetting
// ******************************************************************
@ -282,8 +487,9 @@ XBSYSAPI EXPORTNUM(29) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExSaveNonVolatileSetti
LOG_FUNC_END;
// TODO: Later.
LOG_UNIMPLEMENTED();
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
// TODO : What should we initialize this to?
@ -292,3 +498,59 @@ XBSYSAPI EXPORTNUM(30) xboxkrnl::POBJECT_TYPE xboxkrnl::ExSemaphoreObjectType =
// TODO : What should we initialize this to?
XBSYSAPI EXPORTNUM(31) xboxkrnl::POBJECT_TYPE xboxkrnl::ExTimerObjectType = NULL;
// Source:ReactOS
XBSYSAPI EXPORTNUM(32) xboxkrnl::PLIST_ENTRY __fastcall xboxkrnl::ExfInterlockedInsertHeadList
(
IN PLIST_ENTRY ListHead,
IN PLIST_ENTRY ListEntry,
IN PKSPIN_LOCK Lock
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(ListHead)
LOG_FUNC_ARG(ListEntry)
LOG_FUNC_ARG(Lock)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(ListHead);
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(33) xboxkrnl::PLIST_ENTRY __fastcall xboxkrnl::ExfInterlockedInsertTailList
(
IN PLIST_ENTRY ListHead,
IN PLIST_ENTRY ListEntry,
IN PKSPIN_LOCK Lock
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(ListHead)
LOG_FUNC_ARG(ListEntry)
LOG_FUNC_ARG(Lock)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(ListHead);
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(34) xboxkrnl::PLIST_ENTRY __fastcall xboxkrnl::ExfInterlockedRemoveHeadList
(
IN PLIST_ENTRY ListHead,
IN PKSPIN_LOCK Lock
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(ListHead)
LOG_FUNC_ARG(Lock)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(ListHead);
}

14
src/CxbxKrnl/EmuKrnlFs.cpp
View File

@ -55,9 +55,17 @@ XBSYSAPI EXPORTNUM(35) xboxkrnl::DWORD NTAPI xboxkrnl::FscGetCacheSize()
EmuWarning("FscGetCacheSize returning default 64kb");
return 64 * 1024;
RETURN(64 * 1024);
}
XBSYSAPI EXPORTNUM(36) VOID NTAPI xboxkrnl::FscInvalidateIdleBlocks()
{
LOG_FUNC();
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * 0x0025 - FscSetCacheSize
// ******************************************************************
@ -68,8 +76,8 @@ XBSYSAPI EXPORTNUM(37) xboxkrnl::LONG NTAPI xboxkrnl::FscSetCacheSize
{
LOG_FUNC_ONE_ARG(uCachePages);
UNIMPLEMENTED();
LOG_IGNORED();
return 0;
RETURN(0);
}

273
src/CxbxKrnl/EmuKrnlHal.cpp
View File

@ -72,18 +72,64 @@ XBSYSAPI EXPORTNUM(9) VOID NTAPI xboxkrnl::HalReadSMCTrayState
// TRAY_CLOSED_NO_MEDIA causes Dashboard to call DeviceIoControl, which we do not implement
// TRAY_CLOSED_MEDIA_PRESENT causes Dashboard to attempt to launch media, causing errors.
*State = TRAY_OPEN;
// *Count = 1;
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(38) VOID __fastcall xboxkrnl::HalClearSoftwareInterrupt
(
KIRQL Request
)
{
LOG_FUNC_ONE_ARG(Request);
LOG_UNIMPLEMENTED();
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(39) VOID NTAPI xboxkrnl::HalDisableSystemInterrupt
(
ULONG Vector,
KIRQL Irql
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Vector)
LOG_FUNC_ARG(Irql)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// This enables Partition3..7 Source:OpenXDK TODO : Make this configurable
XBSYSAPI EXPORTNUM(40) xboxkrnl::DWORD xboxkrnl::HalDiskCachePartitionCount = 4; // Was 3
// Source:OpenXDK TODO : Fill this with something sensible
XBSYSAPI EXPORTNUM(40) xboxkrnl::ULONG xboxkrnl::HalDiskCachePartitionCount = 4; // Was 3
// Source:OpenXDK TODO : Fill this with something sensible
XBSYSAPI EXPORTNUM(41) xboxkrnl::PANSI_STRING xboxkrnl::HalDiskModelNumber = 0;
// Source:OpenXDK TODO : Fill this with something sensible
XBSYSAPI EXPORTNUM(42) xboxkrnl::PANSI_STRING xboxkrnl::HalDiskSerialNumber = 0;
XBSYSAPI EXPORTNUM(42) xboxkrnl::PANSI_STRING xboxkrnl::HalDiskSerialNumber = 0;
// Source:ReactOS
XBSYSAPI EXPORTNUM(43) xboxkrnl::BOOLEAN NTAPI xboxkrnl::HalEnableSystemInterrupt
(
ULONG Vector,
KIRQL Irql,
KINTERRUPT_MODE InterruptMode
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Vector)
LOG_FUNC_ARG(Irql)
LOG_FUNC_ARG(InterruptMode)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(FALSE);
}
// ******************************************************************
// * HalGetInterruptVector
@ -103,7 +149,7 @@ XBSYSAPI EXPORTNUM(44) xboxkrnl::ULONG NTAPI xboxkrnl::HalGetInterruptVector
EmuWarning("HalGetInterruptVector(): If this is NOT a Chihiro game, tell blueshogun!");
return 1;
RETURN(1);
}
// ******************************************************************
@ -131,8 +177,30 @@ XBSYSAPI EXPORTNUM(45) xboxkrnl::NTSTATUS NTAPI xboxkrnl::HalReadSMBusValue
// Write BYTE
}
RETURN(STATUS_SUCCESS);
}
return STATUS_SUCCESS;
// Source:OpenXDK
XBSYSAPI EXPORTNUM(46) VOID NTAPI xboxkrnl::HalReadWritePCISpace
(
IN ULONG BusNumber,
IN ULONG SlotNumber,
IN ULONG RegisterNumber,
IN PVOID Buffer,
IN ULONG Length,
IN BOOLEAN WritePCISpace
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(BusNumber)
LOG_FUNC_ARG(SlotNumber)
LOG_FUNC_ARG(RegisterNumber)
LOG_FUNC_ARG(Buffer)
LOG_FUNC_ARG(Length)
LOG_FUNC_ARG(WritePCISpace)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
@ -149,11 +217,19 @@ XBSYSAPI EXPORTNUM(47) VOID xboxkrnl::HalRegisterShutdownNotification
LOG_FUNC_ARG(Register)
LOG_FUNC_END;
UNIMPLEMENTED();
return;
LOG_UNIMPLEMENTED();
}
// Source:ReactOS
XBSYSAPI EXPORTNUM(48) VOID __fastcall xboxkrnl::HalRequestSoftwareInterrupt
(
IN KIRQL Request
)
{
LOG_FUNC_ONE_ARG(Request);
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * 0x0031 - HalReturnToFirmware
@ -170,7 +246,7 @@ XBSYSAPI EXPORTNUM(49) VOID DECLSPEC_NORETURN xboxkrnl::HalReturnToFirmware
CxbxKrnlCleanup("Xbe has rebooted : HalReturnToFirmware(%d)", Routine);
}
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
}
// ******************************************************************
@ -192,8 +268,123 @@ XBSYSAPI EXPORTNUM(50) xboxkrnl::NTSTATUS NTAPI xboxkrnl::HalWriteSMBusValue
LOG_FUNC_END;
// TODO: Later.
LOG_UNIMPLEMENTED();
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
// ******************************************************************
// * READ_PORT_BUFFER_UCHAR
// ******************************************************************
XBSYSAPI EXPORTNUM(329) VOID NTAPI xboxkrnl::READ_PORT_BUFFER_UCHAR
(
IN PUCHAR Port,
IN PUCHAR Buffer,
IN ULONG Count
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Port)
LOG_FUNC_ARG(Buffer)
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * READ_PORT_BUFFER_USHORT
// ******************************************************************
XBSYSAPI EXPORTNUM(330) VOID NTAPI xboxkrnl::READ_PORT_BUFFER_USHORT
(
IN PUSHORT Port,
IN PUSHORT Buffer,
IN ULONG Count
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Port)
LOG_FUNC_ARG(Buffer)
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * READ_PORT_BUFFER_ULONG
// ******************************************************************
XBSYSAPI EXPORTNUM(331) VOID NTAPI xboxkrnl::READ_PORT_BUFFER_ULONG
(
IN PULONG Port,
IN PULONG Buffer,
IN ULONG Count
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Port)
LOG_FUNC_ARG(Buffer)
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * WRITE_PORT_BUFFER_UCHAR
// ******************************************************************
XBSYSAPI EXPORTNUM(332) VOID NTAPI xboxkrnl::WRITE_PORT_BUFFER_UCHAR
(
IN PUCHAR Port,
IN PUCHAR Buffer,
IN ULONG Count
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Port)
LOG_FUNC_ARG(Buffer)
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * WRITE_PORT_BUFFER_USHORT
// ******************************************************************
XBSYSAPI EXPORTNUM(333) VOID NTAPI xboxkrnl::WRITE_PORT_BUFFER_USHORT
(
IN PUSHORT Port,
IN PUSHORT Buffer,
IN ULONG Count
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Port)
LOG_FUNC_ARG(Buffer)
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
// * WRITE_PORT_BUFFER_ULONG
// ******************************************************************
XBSYSAPI EXPORTNUM(334) VOID NTAPI xboxkrnl::WRITE_PORT_BUFFER_ULONG
(
IN PULONG Port,
IN PULONG Buffer,
IN ULONG Count
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Port)
LOG_FUNC_ARG(Buffer)
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
@ -202,3 +393,61 @@ XBSYSAPI EXPORTNUM(50) xboxkrnl::NTSTATUS NTAPI xboxkrnl::HalWriteSMBusValue
// TODO: Verify this!
XBSYSAPI EXPORTNUM(356) xboxkrnl::DWORD xboxkrnl::HalBootSMCVideoMode = 1;
// Source:Dxbx
XBSYSAPI EXPORTNUM(358) xboxkrnl::BOOLEAN NTAPI xboxkrnl::HalIsResetOrShutdownPending
(
)
{
LOG_FUNC();
LOG_UNIMPLEMENTED();
RETURN(FALSE);
}
// Source:Dxbx
XBSYSAPI EXPORTNUM(360) xboxkrnl::NTSTATUS NTAPI xboxkrnl::HalInitiateShutdown
(
)
{
LOG_FUNC();
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// HalEnableSecureTrayEject:
// Notifies the SMBUS that ejecting the DVD-ROM should not reset the system.
// Note that this function can't really be called directly...
//
// New to the XBOX.
// Source:XBMC Undocumented.h
XBSYSAPI EXPORTNUM(365) VOID NTAPI xboxkrnl::HalEnableSecureTrayEject
(
)
{
LOG_FUNC();
LOG_UNIMPLEMENTED();
}
// Source:Dxbx
XBSYSAPI EXPORTNUM(366) xboxkrnl::NTSTATUS NTAPI xboxkrnl::HalWriteSMCScratchRegister
(
IN DWORD ScratchRegister
)
{
LOG_FUNC_ONE_ARG(ScratchRegister);
LOG_UNIMPLEMENTED();
/* TODO
HalpSMCScratchRegister = ScratchRegister;
// TODO : Is this the way we need to set the value?
return HalWriteSMBusValue(SMC_ADDRESS, SMC_COMMAND_SCRATCH, WordFlag: False, ScratchRegister);
*/
RETURN(S_OK);
}

12
src/CxbxKrnl/EmuKrnlIo.cpp
View File

@ -86,9 +86,9 @@ XBSYSAPI EXPORTNUM(66) xboxkrnl::NTSTATUS NTAPI xboxkrnl::IoCreateFile
// TODO: Try redirecting to NtCreateFile if this function ever is run into
CxbxKrnlCleanup("IoCreateFile not implemented");
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
return ret;
RETURN(ret);
}
// ******************************************************************
@ -107,7 +107,7 @@ XBSYSAPI EXPORTNUM(67) xboxkrnl::NTSTATUS NTAPI xboxkrnl::IoCreateSymbolicLink
NTSTATUS ret = CxbxCreateSymbolicLink(std::string(SymbolicLinkName->Buffer, SymbolicLinkName->Length), std::string(DeviceName->Buffer, DeviceName->Length));
return ret;
RETURN(ret);
}
// ******************************************************************
@ -127,7 +127,7 @@ XBSYSAPI EXPORTNUM(69) xboxkrnl::NTSTATUS NTAPI xboxkrnl::IoDeleteSymbolicLink
if ((symbolicLink != NULL))
ret = symbolicLink->NtClose();
return ret;
RETURN(ret);
}
// TODO : What should we initialize this to?
@ -149,8 +149,8 @@ XBSYSAPI EXPORTNUM(91) xboxkrnl::NTSTATUS NTAPI xboxkrnl::IoDismountVolumeByName
NTSTATUS ret = STATUS_SUCCESS;
// TODO: Anything?
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
return ret;
RETURN(ret);
}

107
src/CxbxKrnl/EmuKrnlKe.cpp
View File

@ -60,6 +60,49 @@ std::ostream& operator<<(std::ostream& os, const xboxkrnl::LARGE_INTEGER& value)
return os << value.QuadPart;
}
// Source:Dxbx
XBSYSAPI EXPORTNUM(92) xboxkrnl::NTSTATUS NTAPI xboxkrnl::KeAlertResumeThread
(
IN HANDLE ThreadHandle,
IN OUT PULONG PreviousSuspendCount
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(ThreadHandle)
LOG_FUNC_ARG_OUT(PreviousSuspendCount)
LOG_FUNC_END;
// TODO : Result = NtDll::NtAlertResumeThread(ThreadHandle, PreviousSuspendCount);
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// Source:Dxbx
XBSYSAPI EXPORTNUM(93) xboxkrnl::NTSTATUS NTAPI xboxkrnl::KeAlertThread
(
IN HANDLE ThreadHandle
)
{
LOG_FUNC_ONE_ARG(ThreadHandle);
// TODO : Result = NtDll::NtAlertThread(ThreadHandle);
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// Source:Dxbx
XBSYSAPI EXPORTNUM(94) xboxkrnl::NTSTATUS NTAPI xboxkrnl::KeBoostPriorityThread
(
)
{
LOG_FUNC();
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// ******************************************************************
// * KeBugCheck
@ -71,8 +114,30 @@ XBSYSAPI EXPORTNUM(95) VOID NTAPI xboxkrnl::KeBugCheck
{
LOG_FUNC_ONE_ARG(BugCheckMode);
// TODO: Investigate XapiFiberStartup maybe?
UNIMPLEMENTED();
KeBugCheckEx(BugCheckMode, 0, 0, 0, 0);
}
// Source:Dxbx
XBSYSAPI EXPORTNUM(96) xboxkrnl::NTSTATUS NTAPI xboxkrnl::KeBugCheckEx
(
IN DWORD BugCheckCode,
IN PVOID BugCheckParameter1,
IN PVOID BugCheckParameter2,
IN PVOID BugCheckParameter3,
IN PVOID BugCheckParameter4
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(BugCheckCode)
LOG_FUNC_ARG(BugCheckParameter1)
LOG_FUNC_ARG(BugCheckParameter2)
LOG_FUNC_ARG(BugCheckParameter3)
LOG_FUNC_ARG(BugCheckParameter4)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
RETURN(S_OK);
}
// ******************************************************************
@ -85,9 +150,9 @@ XBSYSAPI EXPORTNUM(98) xboxkrnl::LONG NTAPI xboxkrnl::KeConnectInterrupt
{
LOG_FUNC_ONE_ARG(InterruptObject);
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
return 0;
RETURN(0);
}
// ******************************************************************
@ -108,7 +173,7 @@ XBSYSAPI EXPORTNUM(99) xboxkrnl::NTSTATUS NTAPI xboxkrnl::KeDelayExecutionThread
NTSTATUS ret = NtDll::NtDelayExecution(Alertable, (NtDll::LARGE_INTEGER*)Interval);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -132,8 +197,6 @@ XBSYSAPI EXPORTNUM(107) VOID NTAPI xboxkrnl::KeInitializeDpc
Dpc->Type = DpcObject;
Dpc->DeferredContext = DeferredContext;
Dpc->Inserted = FALSE;
return;
}
// ******************************************************************
@ -160,7 +223,7 @@ XBSYSAPI EXPORTNUM(109) VOID NTAPI xboxkrnl::KeInitializeInterrupt
LOG_FUNC_ARG(ShareVector)
LOG_FUNC_END;
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
}
// ******************************************************************
@ -189,10 +252,6 @@ XBSYSAPI EXPORTNUM(113) VOID NTAPI xboxkrnl::KeInitializeTimerEx
Timer->DueTime.QuadPart = 0;
Timer->Period = 0;
return;
}
// Dxbx note : This was once a value, but instead we now point to
@ -210,7 +269,7 @@ XBSYSAPI EXPORTNUM(126) xboxkrnl::ULONGLONG NTAPI xboxkrnl::KeQueryPerformanceCo
QueryPerformanceCounter(&Counter);
return Counter.QuadPart;
RETURN(Counter.QuadPart);
}
// ******************************************************************
@ -225,7 +284,7 @@ XBSYSAPI EXPORTNUM(127) xboxkrnl::ULONGLONG NTAPI xboxkrnl::KeQueryPerformanceFr
QueryPerformanceFrequency(&Frequency);
return Frequency.QuadPart;
RETURN(Frequency.QuadPart);
}
// ******************************************************************
@ -244,9 +303,7 @@ XBSYSAPI EXPORTNUM(128) VOID NTAPI xboxkrnl::KeQuerySystemTime
GetSystemTime(&SystemTime);
SystemTimeToFileTime(&SystemTime, (FILETIME*)CurrentTime);
return;
SystemTimeToFileTime(&SystemTime, (LPFILETIME)CurrentTime);
}
// ******************************************************************
@ -259,9 +316,9 @@ XBSYSAPI EXPORTNUM(129) xboxkrnl::UCHAR NTAPI xboxkrnl::KeRaiseIrqlToDpcLevel()
// I really tried to avoid adding this...
// __asm int 3;
// CxbxKrnlCleanup("KeRaiseIrqlToDpcLevel not implemented! (Tell blueshogun -_-)");
// UNIMPLEMENTED();
// LOG_UNIMPLEMENTED();
return 0;
RETURN(0);
}
// ******************************************************************
@ -283,7 +340,7 @@ XBSYSAPI EXPORTNUM(149) xboxkrnl::BOOLEAN NTAPI xboxkrnl::KeSetTimer
// Call KeSetTimerEx with a period of zero
BOOLEAN bRet = KeSetTimerEx(Timer, DueTime, 0, Dpc);
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -346,7 +403,7 @@ XBSYSAPI EXPORTNUM(150) xboxkrnl::BOOLEAN NTAPI xboxkrnl::KeSetTimerEx
}
}
return Inserted;
RETURN(Inserted);
}
// Dxbx note : This was once a value, but instead we now point to
@ -389,7 +446,9 @@ XBSYSAPI EXPORTNUM(158) xboxkrnl::NTSTATUS xboxkrnl::KeWaitForMultipleObjects
EmuWarning("EmuKrnl: Redirecting KeWaitForMultipleObjects to NtWaitForMultipleObjectsEx");
return NtWaitForMultipleObjectsEx(Count, Object, WaitType, WaitMode, Alertable, Timeout);
NTSTATUS ret = NtWaitForMultipleObjectsEx(Count, Object, WaitType, WaitMode, Alertable, Timeout);
RETURN(ret);
}
// ******************************************************************
@ -414,6 +473,8 @@ XBSYSAPI EXPORTNUM(159) xboxkrnl::NTSTATUS xboxkrnl::KeWaitForSingleObject
EmuWarning("EmuKrnl: Redirecting KeWaitForSingleObject to NtWaitForSingleObjectEx");
return NtWaitForSingleObjectEx(Object, WaitMode, Alertable, Timeout);
NTSTATUS ret = NtWaitForSingleObjectEx(Object, WaitMode, Alertable, Timeout);
RETURN(ret);
}

32
src/CxbxKrnl/EmuKrnlMm.cpp
View File

@ -110,7 +110,7 @@ XBSYSAPI EXPORTNUM(165) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateContiguousMemo
DbgPrintf("EmuKrnl (0x%X): MmAllocateContiguousMemory returned 0x%.08X\n", GetCurrentThreadId(), pRet);
return pRet;
RETURN(pRet);
}
// ******************************************************************
@ -155,9 +155,7 @@ XBSYSAPI EXPORTNUM(166) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateContiguousMemo
static int count = 0;
DbgPrintf("EmuKrnl (0x%X): MmAllocateContiguousMemoryEx returned 0x%.08X\n", GetCurrentThreadId(), pRet);
return pRet;
RETURN(pRet);
}
// ******************************************************************
@ -177,7 +175,7 @@ XBSYSAPI EXPORTNUM(167) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateSystemMemory
// TODO: should this be aligned?
PVOID pRet = CxbxMalloc(NumberOfBytes);
return pRet;
RETURN(pRet);
}
// ******************************************************************
@ -220,7 +218,7 @@ XBSYSAPI EXPORTNUM(169) xboxkrnl::PVOID NTAPI xboxkrnl::MmCreateKernelStack
else
pRet = (PVOID)((ULONG)pRet + NumberOfBytes);
return pRet;
RETURN(pRet);
}
// ******************************************************************
@ -242,8 +240,6 @@ XBSYSAPI EXPORTNUM(170) VOID NTAPI xboxkrnl::MmDeleteKernelStack
ULONG RegionSize = 0;
if (FAILED(NtDll::NtFreeVirtualMemory(GetCurrentProcess(), &BaseAddress, &RegionSize, MEM_RELEASE)))
EmuWarning("MmDeleteKernelStack failed!\n");
}
// ******************************************************************
@ -273,8 +269,6 @@ XBSYSAPI EXPORTNUM(171) VOID NTAPI xboxkrnl::MmFreeContiguousMemory
{
DbgPrintf("Ignored MmFreeContiguousMemory(&xLaunchDataPage)\n");
}
return;
}
// ******************************************************************
@ -293,7 +287,7 @@ XBSYSAPI EXPORTNUM(172) xboxkrnl::NTSTATUS NTAPI xboxkrnl::MmFreeSystemMemory
CxbxFree(BaseAddress);
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
// ******************************************************************
@ -312,7 +306,7 @@ XBSYSAPI EXPORTNUM(175) void NTAPI xboxkrnl::MmLockUnlockBufferPages
LOG_FUNC_ARG(Protect)
LOG_FUNC_END;
UNIMPLEMENTED();
LOG_IGNORED();
}
// ******************************************************************
@ -334,7 +328,7 @@ XBSYSAPI EXPORTNUM(177) xboxkrnl::PVOID NTAPI xboxkrnl::MmMapIoSpace
// TODO: should this be aligned?
PVOID pRet = CxbxMalloc(NumberOfBytes);
return pRet;
RETURN(pRet);
}
// ******************************************************************
@ -354,7 +348,7 @@ XBSYSAPI EXPORTNUM(178) VOID NTAPI xboxkrnl::MmPersistContiguousMemory
LOG_FUNC_END;
// TODO: Actually set this up to be remember across a "reboot"
UNIMPLEMENTED();
LOG_IGNORED();
}
// ******************************************************************
@ -369,7 +363,7 @@ XBSYSAPI EXPORTNUM(180) xboxkrnl::ULONG NTAPI xboxkrnl::MmQueryAllocationSize
ULONG uiSize = EmuCheckAllocationSize(BaseAddress, false);
return uiSize;
RETURN(uiSize);
}
// ******************************************************************
@ -425,9 +419,7 @@ XBSYSAPI EXPORTNUM(181) xboxkrnl::NTSTATUS NTAPI xboxkrnl::MmQueryStatistics
ret = STATUS_INVALID_PARAMETER;
}
return ret;
RETURN(ret);
}
// ******************************************************************
@ -452,8 +444,6 @@ XBSYSAPI EXPORTNUM(182) VOID NTAPI xboxkrnl::MmSetAddressProtect
EmuWarning("VirtualProtect Failed!");
DbgPrintf("EmuKrnl (0x%X): VirtualProtect was 0x%.08X -> 0x%.08X\n", GetCurrentThreadId(), dwOldProtect, NewProtect & (~PAGE_WRITECOMBINE));
return;
}
// ******************************************************************
@ -472,6 +462,6 @@ XBSYSAPI EXPORTNUM(183) xboxkrnl::NTSTATUS NTAPI xboxkrnl::MmUnmapIoSpace
CxbxFree(BaseAddress);
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}

84
src/CxbxKrnl/EmuKrnlNt.cpp
View File

@ -1009,7 +1009,7 @@ NTSTATUS CxbxObjectAttributesToNT(xboxkrnl::POBJECT_ATTRIBUTES ObjectAttributes,
{
// When the pointer is nil, make sure we pass nil to Windows too :
nativeObjectAttributes.NtObjAttrPtr = NULL;
return result;
RETURN(result);
}
// ObjectAttributes are given, so make sure the pointer we're going to pass to Windows is assigned :
@ -1077,7 +1077,7 @@ NTSTATUS CxbxObjectAttributesToNT(xboxkrnl::POBJECT_ATTRIBUTES ObjectAttributes,
{
result = STATUS_UNRECOGNIZED_VOLUME; // TODO : Is this the correct error?
EmuWarning((("Path not available : ") + OriginalPath).c_str());
return result;
RETURN(result);
}
XboxFullPath = RelativePath;
@ -1112,7 +1112,7 @@ NTSTATUS CxbxObjectAttributesToNT(xboxkrnl::POBJECT_ATTRIBUTES ObjectAttributes,
// Initialize the NT ObjectAttributes :
InitializeObjectAttributes(&nativeObjectAttributes.NtObjAttr, &nativeObjectAttributes.NtUnicodeString, ObjectAttributes->Attributes, ObjectAttributes->RootDirectory, NULL);
return result;
RETURN(result);
}
@ -1154,7 +1154,7 @@ XBSYSAPI EXPORTNUM(184) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtAllocateVirtualMemo
if (ret == 0xC00000F3)
EmuWarning("Invalid Param!");
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1172,7 +1172,7 @@ XBSYSAPI EXPORTNUM(186) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtClearEvent
if (FAILED(ret))
EmuWarning("NtClearEvent Failed!");
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1199,7 +1199,7 @@ XBSYSAPI EXPORTNUM(187) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtClose
ret = NtDll::NtClose(Handle);
}
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1235,7 +1235,7 @@ XBSYSAPI EXPORTNUM(188) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateDirectoryObje
DbgPrintf("EmuKrnl (0x%X): NtCreateDirectoryObject DirectoryHandle = 0x%.08X\n", GetCurrentThreadId(), *DirectoryHandle);
return ret;
RETURN(ret);
}
@ -1278,7 +1278,7 @@ XBSYSAPI EXPORTNUM(189) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateEvent
DbgPrintf("EmuKrnl (0x%X): NtCreateEvent EventHandle = 0x%.08X\n", GetCurrentThreadId(), *EventHandle);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1330,7 +1330,7 @@ XBSYSAPI EXPORTNUM(190) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateFile
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1376,7 +1376,7 @@ XBSYSAPI EXPORTNUM(192) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateMutant
DbgPrintf("EmuKrnl (0x%X): NtCreateMutant MutantHandle = 0x%.08X\n", GetCurrentThreadId(), *MutantHandle);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1412,7 +1412,7 @@ XBSYSAPI EXPORTNUM(193) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateSemaphore
DbgPrintf("EmuKrnl (0x%X): NtCreateSemaphore SemaphoreHandle = 0x%.08X\n", GetCurrentThreadId(), *SemaphoreHandle);
return ret;
RETURN(ret);
}
XBSYSAPI EXPORTNUM(196) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtDeviceIoControlFile
@ -1457,10 +1457,10 @@ XBSYSAPI EXPORTNUM(196) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtDeviceIoControlFile
break;
}
default:
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
}
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
// ******************************************************************
@ -1500,7 +1500,7 @@ XBSYSAPI EXPORTNUM(197) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtDuplicateObject
if (ret != STATUS_SUCCESS)
EmuWarning("Object was not duplicated!");
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1519,7 +1519,7 @@ XBSYSAPI EXPORTNUM(198) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtFlushBuffersFile
NTSTATUS ret = NtDll::NtFlushBuffersFile(FileHandle, (NtDll::IO_STATUS_BLOCK*)IoStatusBlock);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1540,7 +1540,7 @@ XBSYSAPI EXPORTNUM(199) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtFreeVirtualMemory
NTSTATUS ret = NtDll::NtFreeVirtualMemory(GetCurrentProcess(), BaseAddress, FreeSize, FreeType);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1568,7 +1568,9 @@ XBSYSAPI EXPORTNUM(202) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtOpenFile
//*/
return NtCreateFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, NULL, 0, ShareAccess, FILE_OPEN, OpenOptions);
NTSTATUS ret = NtCreateFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, NULL, 0, ShareAccess, FILE_OPEN, OpenOptions);
RETURN(ret);
}
@ -1602,7 +1604,7 @@ XBSYSAPI EXPORTNUM(203) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtOpenSymbolicLinkObj
else
DbgPrintf("EmuKrnl : NtOpenSymbolicLinkObject LinkHandle^ = 0x%.08X", *LinkHandle);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1623,9 +1625,9 @@ XBSYSAPI EXPORTNUM(205) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtProtectVirtualMemor
LOG_FUNC_ARG_OUT(OldProtect)
LOG_FUNC_END;
UNIMPLEMENTED();
LOG_IGNORED();
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
// ******************************************************************
@ -1658,7 +1660,7 @@ XBSYSAPI EXPORTNUM(206) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueueApcThread
if (FAILED(ret))
EmuWarning("NtQueueApcThread failed!");
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1742,7 +1744,7 @@ XBSYSAPI EXPORTNUM(207) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryDirectoryFile
// TODO: Cache the last search result for quicker access with CreateFile (xbox does this internally!)
CxbxFree(FileDirInfo);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1769,7 +1771,7 @@ XBSYSAPI EXPORTNUM(210) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryFullAttributes
if (FAILED(ret))
EmuWarning("NtQueryFullAttributesFile failed! (0x%.08X)\n", ret);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1831,7 +1833,7 @@ XBSYSAPI EXPORTNUM(211) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryInformationFil
if (FAILED(ret))
EmuWarning("NtQueryInformationFile failed! (0x%.08X)", ret);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1879,7 +1881,7 @@ XBSYSAPI EXPORTNUM(215) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQuerySymbolicLinkOb
if (result != STATUS_SUCCESS)
EmuWarning("NtQuerySymbolicLinkObject failed! (%s)", NtStatusToString(result));
return result;
RETURN(result);
}
@ -1931,7 +1933,7 @@ XBSYSAPI EXPORTNUM(217) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryVirtualMemory
}
}
return ret;
RETURN(ret);
}
// ******************************************************************
@ -1981,7 +1983,7 @@ XBSYSAPI EXPORTNUM(218) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryVolumeInformat
EmuWarning("NtQueryVolumeInformationFile failed! (%s)\n", NtStatusToString(ret));
}
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2019,7 +2021,7 @@ XBSYSAPI EXPORTNUM(219) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtReadFile
if (FAILED(ret))
EmuWarning("NtReadFile Failed! (0x%.08X)", ret);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2042,7 +2044,7 @@ XBSYSAPI EXPORTNUM(221) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtReleaseMutant
if (FAILED(ret))
EmuWarning("NtReleaseMutant Failed!");
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS); // TODO : RETURN(ret);
}
// ******************************************************************
@ -2066,7 +2068,7 @@ XBSYSAPI EXPORTNUM(222) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtReleaseSemaphore
if (FAILED(ret))
EmuWarning("NtReleaseSemaphore failed!");
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2087,7 +2089,7 @@ XBSYSAPI EXPORTNUM(224) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtResumeThread
Sleep(10);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2109,7 +2111,7 @@ XBSYSAPI EXPORTNUM(225) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtSetEvent
if (FAILED(ret))
EmuWarning("NtSetEvent Failed!");
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2134,7 +2136,7 @@ XBSYSAPI EXPORTNUM(226) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtSetInformationFile
NTSTATUS ret = NtDll::NtSetInformationFile(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2154,11 +2156,11 @@ XBSYSAPI EXPORTNUM(228) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtSetSystemTime
// Maybe it's not such a good idea to allow Cxbx to change your time
// clock. Might need admin privileges to do this.... dunno.
UNIMPLEMENTED();
LOG_UNIMPLEMENTED();
NTSTATUS ret = STATUS_SUCCESS;
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2177,7 +2179,7 @@ XBSYSAPI EXPORTNUM(231) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtSuspendThread
NTSTATUS ret = NtDll::NtSuspendThread(ThreadHandle, PreviousSuspendCount);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2251,8 +2253,6 @@ XBSYSAPI EXPORTNUM(232) VOID NTAPI xboxkrnl::NtUserIoApcDispatcher
}
DbgPrintf("EmuKrnl (0x%X): NtUserIoApcDispatcher Completed\n", GetCurrentThreadId());
return;
}
// ******************************************************************
@ -2289,7 +2289,7 @@ XBSYSAPI EXPORTNUM(234) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtWaitForSingleObject
if (ret == WAIT_FAILED)
EmuWarning("NtWaitForSingleObjectEx failed! (%s)", NtStatusToString(ret));
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2317,7 +2317,7 @@ XBSYSAPI EXPORTNUM(235) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtWaitForMultipleObje
// TODO: Process EmuHandle
NTSTATUS ret = NtDll::NtWaitForMultipleObjects(Count, Handles, (NtDll::OBJECT_WAIT_TYPE)WaitType, Alertable, (NtDll::PLARGE_INTEGER)Timeout);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2355,7 +2355,7 @@ XBSYSAPI EXPORTNUM(236) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtWriteFile
if (FAILED(ret))
EmuWarning("NtWriteFile Failed! (0x%.08X)", ret);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -2367,7 +2367,5 @@ XBSYSAPI EXPORTNUM(238) VOID NTAPI xboxkrnl::NtYieldExecution()
//LOG_FUNC();
NtDll::NtYieldExecution();
return;
}

6
src/CxbxKrnl/EmuKrnlPs.cpp
View File

@ -257,7 +257,7 @@ XBSYSAPI EXPORTNUM(255) xboxkrnl::NTSTATUS NTAPI xboxkrnl::PsCreateSystemThreadE
*ThreadId = dwThreadId;
}
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
// ******************************************************************
@ -293,7 +293,7 @@ XBSYSAPI EXPORTNUM(258) VOID NTAPI xboxkrnl::PsTerminateSystemThread
_endthreadex(ExitStatus);
//ExitThread(ExitStatus);
return;
}
// TODO : What should we initialize this to?
XBSYSAPI EXPORTNUM(259) volatile xboxkrnl::POBJECT_TYPE xboxkrnl::PsThreadObjectType = NULL;

94
src/CxbxKrnl/EmuKrnlRtl.cpp
View File

@ -46,7 +46,7 @@ namespace xboxkrnl
// prevent name collisions
namespace NtDll
{
#include "EmuNtDll.h"
#include "EmuNtDll.h"
};
#include "CxbxKrnl.h" // For CxbxKrnlCleanup()
@ -93,27 +93,81 @@ int FindCriticalSection(xboxkrnl::PRTL_CRITICAL_SECTION CriticalSection)
return FreeSection;
}
using namespace xboxkrnl;
// ******************************************************************
// * 0x0104 - RtlAnsiStringToUnicodeString
// ******************************************************************
XBSYSAPI EXPORTNUM(260) xboxkrnl::NTSTATUS NTAPI xboxkrnl::RtlAnsiStringToUnicodeString
(
PUNICODE_STRING DestinationString,
PSTRING SourceString,
UCHAR AllocateDestinationString
OUT PUNICODE_STRING DestinationString,
IN PSTRING SourceString,
IN UCHAR AllocateDestinationString
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(DestinationString)
LOG_FUNC_ARG_OUT(DestinationString)
LOG_FUNC_ARG(SourceString)
LOG_FUNC_ARG(AllocateDestinationString)
LOG_FUNC_END;
NTSTATUS ret = NtDll::RtlAnsiStringToUnicodeString((NtDll::UNICODE_STRING*)DestinationString, (NtDll::STRING*)SourceString, AllocateDestinationString);
return ret;
RETURN(ret);
}
XBSYSAPI EXPORTNUM(261) xboxkrnl::NTSTATUS NTAPI xboxkrnl::RtlAppendStringToString
(
IN PSTRING Destination,
IN PSTRING Source
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Destination)
LOG_FUNC_ARG(Source)
LOG_FUNC_END;
NTSTATUS result = NtDll::RtlAppendStringToString((NtDll::PSTRING)Destination, (NtDll::PSTRING)Source);
RETURN(result);
}
XBSYSAPI EXPORTNUM(262) xboxkrnl::NTSTATUS NTAPI xboxkrnl::RtlAppendUnicodeStringToString
(
IN PUNICODE_STRING Destination,
IN PUNICODE_STRING Source
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Destination)
LOG_FUNC_ARG(Source)
LOG_FUNC_END;
NTSTATUS result = NtDll::RtlAppendUnicodeStringToString((NtDll::PUNICODE_STRING)Destination, (NtDll::PUNICODE_STRING)Source);
LOG_UNIMPLEMENTED();
RETURN(result);
}
XBSYSAPI EXPORTNUM(263) xboxkrnl::NTSTATUS NTAPI xboxkrnl::RtlAppendUnicodeToString
(
IN OUT PUNICODE_STRING Destination,
IN LPCWSTR Source
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Destination)
LOG_FUNC_ARG(Source)
LOG_FUNC_END;
NTSTATUS result = NtDll::RtlAppendUnicodeToString((NtDll::PUNICODE_STRING)Destination, (NtDll::PCWSTR)Source);
LOG_UNIMPLEMENTED();
RETURN(result);
}
// ******************************************************************
@ -135,8 +189,6 @@ XBSYSAPI EXPORTNUM(264) VOID NTAPI xboxkrnl::RtlAssert
LOG_FUNC_END;
CxbxKrnlCleanup("RtlAssert() raised by emulated program - consult Debug log");
return;
}
// ******************************************************************
@ -176,8 +228,6 @@ XBSYSAPI EXPORTNUM(277) VOID NTAPI xboxkrnl::RtlEnterCriticalSection
//NtDll::RtlEnterCriticalSection((NtDll::_RTL_CRITICAL_SECTION*)CriticalSection);
}
return;
}
// ******************************************************************
@ -198,7 +248,7 @@ XBSYSAPI EXPORTNUM(279) xboxkrnl::BOOLEAN NTAPI xboxkrnl::RtlEqualString
BOOLEAN bRet = NtDll::RtlEqualString((NtDll::PSTRING)String1, (NtDll::PSTRING)String2, (NtDll::BOOLEAN)CaseSensitive);
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -212,8 +262,6 @@ XBSYSAPI EXPORTNUM(286) VOID NTAPI xboxkrnl::RtlFreeAnsiString
LOG_FUNC_ONE_ARG(AnsiString);
NtDll::RtlFreeAnsiString((NtDll::PANSI_STRING)AnsiString);
return;
}
// ******************************************************************
@ -231,8 +279,6 @@ XBSYSAPI EXPORTNUM(289) VOID NTAPI xboxkrnl::RtlInitAnsiString
LOG_FUNC_END;
NtDll::RtlInitAnsiString((NtDll::PANSI_STRING)DestinationString, (NtDll::PCSZ)SourceString);
return;
}
// ******************************************************************
@ -250,8 +296,6 @@ XBSYSAPI EXPORTNUM(290) VOID NTAPI xboxkrnl::RtlInitUnicodeString
LOG_FUNC_END;
NtDll::RtlInitUnicodeString((NtDll::PUNICODE_STRING)DestinationString, (NtDll::PCWSTR)SourceString);
return;
}
// ******************************************************************
@ -282,8 +326,6 @@ XBSYSAPI EXPORTNUM(291) VOID NTAPI xboxkrnl::RtlInitializeCriticalSection
}
//NtDll::RtlInitializeCriticalSection((NtDll::_RTL_CRITICAL_SECTION*)CriticalSection);
return;
}
// ******************************************************************
@ -315,8 +357,6 @@ XBSYSAPI EXPORTNUM(294) VOID NTAPI xboxkrnl::RtlLeaveCriticalSection
/* sorta pointless
LOG_FUNC_ONE_ARG(CriticalSection);
//*/
return;
}
// ******************************************************************
@ -331,7 +371,7 @@ XBSYSAPI EXPORTNUM(296) xboxkrnl::CHAR NTAPI xboxkrnl::RtlLowerChar
CHAR ret = tolower(Character);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -346,7 +386,7 @@ XBSYSAPI EXPORTNUM(301) xboxkrnl::ULONG NTAPI xboxkrnl::RtlNtStatusToDosError
ULONG ret = NtDll::RtlNtStatusToDosError(Status);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -365,7 +405,7 @@ XBSYSAPI EXPORTNUM(304) xboxkrnl::BOOLEAN NTAPI xboxkrnl::RtlTimeFieldsToTime
BOOLEAN bRet = NtDll::RtlTimeFieldsToTime((NtDll::TIME_FIELDS*)TimeFields, (NtDll::LARGE_INTEGER*)Time);
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -383,8 +423,6 @@ XBSYSAPI EXPORTNUM(305) VOID NTAPI xboxkrnl::RtlTimeToTimeFields
LOG_FUNC_END;
NtDll::RtlTimeToTimeFields((NtDll::LARGE_INTEGER*)Time, (NtDll::TIME_FIELDS*)TimeFields);
return;
}
// ******************************************************************
@ -421,7 +459,7 @@ XBSYSAPI EXPORTNUM(306) xboxkrnl::BOOLEAN NTAPI xboxkrnl::RtlTryEnterCriticalSec
//bRet = NtDll::RtlTryEnterCriticalSection((NtDll::PRTL_CRITICAL_SECTION)CriticalSection);
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -442,6 +480,6 @@ XBSYSAPI EXPORTNUM(308) xboxkrnl::NTSTATUS NTAPI xboxkrnl::RtlUnicodeStringToAns
NTSTATUS ret = NtDll::RtlUnicodeStringToAnsiString((NtDll::STRING*)DestinationString, (NtDll::UNICODE_STRING*)SourceString, AllocateDestinationString);
return ret;
RETURN(ret);
}

10
src/CxbxKrnl/EmuKrnlXc.cpp
View File

@ -56,9 +56,7 @@ XBSYSAPI EXPORTNUM(335) VOID NTAPI xboxkrnl::XcSHAInit
{
LOG_FUNC_ONE_ARG_OUT(pbSHAContext);
UNIMPLEMENTED();
return;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
@ -77,9 +75,7 @@ XBSYSAPI EXPORTNUM(336) VOID NTAPI xboxkrnl::XcSHAUpdate
LOG_FUNC_ARG(dwInputLength)
LOG_FUNC_END;
UNIMPLEMENTED();
return;
LOG_UNIMPLEMENTED();
}
// ******************************************************************
@ -101,7 +97,5 @@ XBSYSAPI EXPORTNUM(337) VOID NTAPI xboxkrnl::XcSHAFinal
{
pbDigest[v] = 0;
}
return;
}

8
src/CxbxKrnl/EmuKrnlXe.cpp
View File

@ -65,12 +65,12 @@ XBSYSAPI EXPORTNUM(327) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XeLoadSection
if (((Xbe::SectionHeader*)section)->dwSectionRefCount > 0) {
((Xbe::SectionHeader*)section)->dwSectionRefCount++;
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
EmuWarning("XeLoadSection lied");
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
XBSYSAPI EXPORTNUM(328) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XeUnloadSection
@ -83,12 +83,12 @@ XBSYSAPI EXPORTNUM(328) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XeUnloadSection
LOG_FUNC_END;
if (((Xbe::SectionHeader*)section)->dwSectionRefCount == 0) {
return STATUS_INVALID_PARAMETER;
RETURN(STATUS_INVALID_PARAMETER);
}
EmuWarning("XeUnloadSection lied");
return STATUS_SUCCESS;
RETURN(STATUS_SUCCESS);
}
// TODO : What should we initialize this to?

104
src/CxbxKrnl/EmuNtDll.cpp
View File

@ -49,52 +49,58 @@ namespace NtDll
// ******************************************************************
static HMODULE hNtDll = GetModuleHandle("ntdll");
NtDll::FPTR_RtlInitAnsiString NtDll::RtlInitAnsiString = (NtDll::FPTR_RtlInitAnsiString)GetProcAddress(hNtDll, "RtlInitAnsiString");
NtDll::FPTR_RtlInitUnicodeString NtDll::RtlInitUnicodeString = (NtDll::FPTR_RtlInitUnicodeString)GetProcAddress(hNtDll, "RtlInitUnicodeString");
NtDll::FPTR_RtlAnsiStringToUnicodeString NtDll::RtlAnsiStringToUnicodeString = (NtDll::FPTR_RtlAnsiStringToUnicodeString)GetProcAddress(hNtDll, "RtlAnsiStringToUnicodeString");
NtDll::FPTR_RtlUnicodeStringToAnsiString NtDll::RtlUnicodeStringToAnsiString = (NtDll::FPTR_RtlUnicodeStringToAnsiString)GetProcAddress(hNtDll, "RtlUnicodeStringToAnsiString");
NtDll::FPTR_RtlFreeAnsiString NtDll::RtlFreeAnsiString = (NtDll::FPTR_RtlFreeAnsiString)GetProcAddress(hNtDll, "RtlFreeAnsiString");
NtDll::FPTR_RtlNtStatusToDosError NtDll::RtlNtStatusToDosError = (NtDll::FPTR_RtlNtStatusToDosError)GetProcAddress(hNtDll, "RtlNtStatusToDosError");
NtDll::FPTR_RtlTimeFieldsToTime NtDll::RtlTimeFieldsToTime = (NtDll::FPTR_RtlTimeFieldsToTime)GetProcAddress(hNtDll, "RtlTimeFieldsToTime");
NtDll::FPTR_RtlTimeToTimeFields NtDll::RtlTimeToTimeFields = (NtDll::FPTR_RtlTimeToTimeFields)GetProcAddress(hNtDll, "RtlTimeToTimeFields");
NtDll::FPTR_RtlTryEnterCriticalSection NtDll::RtlTryEnterCriticalSection = (NtDll::FPTR_RtlTryEnterCriticalSection)GetProcAddress(hNtDll, "RtlTryEnterCriticalSection");
NtDll::FPTR_RtlInitializeCriticalSection NtDll::RtlInitializeCriticalSection = (NtDll::FPTR_RtlInitializeCriticalSection)GetProcAddress(hNtDll, "RtlInitializeCriticalSection");
NtDll::FPTR_RtlEnterCriticalSection NtDll::RtlEnterCriticalSection = (NtDll::FPTR_RtlEnterCriticalSection)GetProcAddress(hNtDll, "RtlEnterCriticalSection");
NtDll::FPTR_RtlLeaveCriticalSection NtDll::RtlLeaveCriticalSection = (NtDll::FPTR_RtlLeaveCriticalSection)GetProcAddress(hNtDll, "RtlLeaveCriticalSection");
NtDll::FPTR_RtlCreateHeap NtDll::RtlCreateHeap = (NtDll::FPTR_RtlCreateHeap)GetProcAddress(hNtDll, "RtlCreateHeap");
NtDll::FPTR_RtlAllocateHeap NtDll::RtlAllocateHeap = (NtDll::FPTR_RtlAllocateHeap)GetProcAddress(hNtDll, "RtlAllocateHeap");
NtDll::FPTR_RtlFreeHeap NtDll::RtlFreeHeap = (NtDll::FPTR_RtlFreeHeap)GetProcAddress(hNtDll, "RtlFreeHeap");
NtDll::FPTR_RtlReAllocateHeap NtDll::RtlReAllocateHeap = (NtDll::FPTR_RtlReAllocateHeap)GetProcAddress(hNtDll, "RtlReAllocateHeap");
NtDll::FPTR_RtlSizeHeap NtDll::RtlSizeHeap = (NtDll::FPTR_RtlSizeHeap)GetProcAddress(hNtDll, "RtlSizeHeap");
NtDll::FPTR_RtlDestroyHeap NtDll::RtlDestroyHeap = (NtDll::FPTR_RtlDestroyHeap)GetProcAddress(hNtDll, "RtlDestroyHeap");
NtDll::FPTR_RtlEqualString NtDll::RtlEqualString = (NtDll::FPTR_RtlEqualString)GetProcAddress(hNtDll, "RtlEqualString");
NtDll::FPTR_NtWaitForSingleObject NtDll::NtWaitForSingleObject = (NtDll::FPTR_NtWaitForSingleObject)GetProcAddress(hNtDll, "NtWaitForSingleObject");
NtDll::FPTR_NtWaitForMultipleObjects NtDll::NtWaitForMultipleObjects = (NtDll::FPTR_NtWaitForMultipleObjects)GetProcAddress(hNtDll, "NtWaitForMultipleObjects");
NtDll::FPTR_NtAllocateVirtualMemory NtDll::NtAllocateVirtualMemory = (NtDll::FPTR_NtAllocateVirtualMemory)GetProcAddress(hNtDll, "NtAllocateVirtualMemory");
NtDll::FPTR_NtFreeVirtualMemory NtDll::NtFreeVirtualMemory = (NtDll::FPTR_NtFreeVirtualMemory)GetProcAddress(hNtDll, "NtFreeVirtualMemory");
NtDll::FPTR_NtQueryVirtualMemory NtDll::NtQueryVirtualMemory = (NtDll::FPTR_NtQueryVirtualMemory)GetProcAddress(hNtDll, "NtQueryVirtualMemory");
NtDll::FPTR_NtClearEvent NtDll::NtClearEvent = (NtDll::FPTR_NtClearEvent)GetProcAddress(hNtDll, "NtClearEvent");
NtDll::FPTR_NtClose NtDll::NtClose = (NtDll::FPTR_NtClose)GetProcAddress(hNtDll, "NtClose");
NtDll::FPTR_NtDelayExecution NtDll::NtDelayExecution = (NtDll::FPTR_NtDelayExecution)GetProcAddress(hNtDll, "NtDelayExecution");
NtDll::FPTR_NtDuplicateObject NtDll::NtDuplicateObject = (NtDll::FPTR_NtDuplicateObject)GetProcAddress(hNtDll, "NtDuplicateObject");
NtDll::FPTR_NtFlushBuffersFile NtDll::NtFlushBuffersFile = (NtDll::FPTR_NtFlushBuffersFile)GetProcAddress(hNtDll, "NtFlushBuffersFile");
NtDll::FPTR_NtQueryInformationFile NtDll::NtQueryInformationFile = (NtDll::FPTR_NtQueryInformationFile)GetProcAddress(hNtDll, "NtQueryInformationFile");
NtDll::FPTR_NtQueryDirectoryFile NtDll::NtQueryDirectoryFile = (NtDll::FPTR_NtQueryDirectoryFile)GetProcAddress(hNtDll, "NtQueryDirectoryFile");
NtDll::FPTR_NtQueryFullAttributesFile NtDll::NtQueryFullAttributesFile = (NtDll::FPTR_NtQueryFullAttributesFile)GetProcAddress(hNtDll, "NtQueryFullAttributesFile");
NtDll::FPTR_NtQueryVolumeInformationFile NtDll::NtQueryVolumeInformationFile = (NtDll::FPTR_NtQueryVolumeInformationFile)GetProcAddress(hNtDll, "NtQueryVolumeInformationFile");
NtDll::FPTR_NtCreateEvent NtDll::NtCreateEvent = (NtDll::FPTR_NtCreateEvent)GetProcAddress(hNtDll, "NtCreateEvent");
NtDll::FPTR_NtCreateMutant NtDll::NtCreateMutant = (NtDll::FPTR_NtCreateMutant)GetProcAddress(hNtDll, "NtCreateMutant");
NtDll::FPTR_NtReleaseMutant NtDll::NtReleaseMutant = (NtDll::FPTR_NtReleaseMutant)GetProcAddress(hNtDll, "NtReleaseMutant");
NtDll::FPTR_NtCreateSemaphore NtDll::NtCreateSemaphore = (NtDll::FPTR_NtCreateSemaphore)GetProcAddress(hNtDll, "NtCreateSemaphore");
NtDll::FPTR_NtReleaseSemaphore NtDll::NtReleaseSemaphore = (NtDll::FPTR_NtReleaseSemaphore)GetProcAddress(hNtDll, "NtReleaseSemaphore");
NtDll::FPTR_NtCreateDirectoryObject NtDll::NtCreateDirectoryObject = (NtDll::FPTR_NtCreateDirectoryObject)GetProcAddress(hNtDll, "NtCreateDirectoryObject");
NtDll::FPTR_NtCreateFile NtDll::NtCreateFile = (NtDll::FPTR_NtCreateFile)GetProcAddress(hNtDll, "NtCreateFile");
NtDll::FPTR_NtReadFile NtDll::NtReadFile = (NtDll::FPTR_NtReadFile)GetProcAddress(hNtDll, "NtReadFile");
NtDll::FPTR_NtWriteFile NtDll::NtWriteFile = (NtDll::FPTR_NtWriteFile)GetProcAddress(hNtDll, "NtWriteFile");
NtDll::FPTR_NtYieldExecution NtDll::NtYieldExecution = (NtDll::FPTR_NtYieldExecution)GetProcAddress(hNtDll, "NtYieldExecution");
NtDll::FPTR_NtSetInformationFile NtDll::NtSetInformationFile = (NtDll::FPTR_NtSetInformationFile)GetProcAddress(hNtDll, "NtSetInformationFile");
NtDll::FPTR_NtSetEvent NtDll::NtSetEvent = (NtDll::FPTR_NtSetEvent)GetProcAddress(hNtDll, "NtSetEvent");
NtDll::FPTR_NtSuspendThread NtDll::NtSuspendThread = (NtDll::FPTR_NtSuspendThread)GetProcAddress(hNtDll, "NtSuspendThread");
NtDll::FPTR_NtResumeThread NtDll::NtResumeThread = (NtDll::FPTR_NtResumeThread)GetProcAddress(hNtDll, "NtResumeThread");
NtDll::FPTR_NtSetLdtEntries NtDll::NtSetLdtEntries = (NtDll::FPTR_NtSetLdtEntries)GetProcAddress(hNtDll, "NtSetLdtEntries");
NtDll::FPTR_NtQueueApcThread NtDll::NtQueueApcThread = (NtDll::FPTR_NtQueueApcThread)GetProcAddress(hNtDll, "NtQueueApcThread");
#define IMPORT(API) \
NtDll::FPTR_##API NtDll::API = (NtDll::FPTR_##API)GetProcAddress(hNtDll, #API)
IMPORT(RtlInitAnsiString);
IMPORT(RtlInitUnicodeString);
IMPORT(RtlAnsiStringToUnicodeString);
IMPORT(RtlAppendStringToString);
IMPORT(RtlAppendUnicodeStringToString);
IMPORT(RtlAppendUnicodeToString);
IMPORT(RtlUnicodeStringToAnsiString);
IMPORT(RtlFreeAnsiString);
IMPORT(RtlNtStatusToDosError);
IMPORT(RtlTimeFieldsToTime);
IMPORT(RtlTimeToTimeFields);
IMPORT(RtlTryEnterCriticalSection);
IMPORT(RtlInitializeCriticalSection);
IMPORT(RtlEnterCriticalSection);
IMPORT(RtlLeaveCriticalSection);
IMPORT(RtlCreateHeap);
IMPORT(RtlAllocateHeap);
IMPORT(RtlFreeHeap);
IMPORT(RtlReAllocateHeap);
IMPORT(RtlSizeHeap);
IMPORT(RtlDestroyHeap);
IMPORT(RtlEqualString);
IMPORT(NtWaitForSingleObject);
IMPORT(NtWaitForMultipleObjects);
IMPORT(NtAllocateVirtualMemory);
IMPORT(NtFreeVirtualMemory);
IMPORT(NtQueryVirtualMemory);
IMPORT(NtClearEvent);
IMPORT(NtClose);
IMPORT(NtDelayExecution);
IMPORT(NtDuplicateObject);
IMPORT(NtFlushBuffersFile);
IMPORT(NtQueryInformationFile);
IMPORT(NtQueryDirectoryFile);
IMPORT(NtQueryFullAttributesFile);
IMPORT(NtQueryVolumeInformationFile);
IMPORT(NtCreateEvent);
IMPORT(NtCreateMutant);
IMPORT(NtReleaseMutant);
IMPORT(NtCreateSemaphore);
IMPORT(NtReleaseSemaphore);
IMPORT(NtCreateDirectoryObject);
IMPORT(NtCreateFile);
IMPORT(NtReadFile);
IMPORT(NtWriteFile);
IMPORT(NtYieldExecution);
IMPORT(NtSetInformationFile);
IMPORT(NtSetEvent);
IMPORT(NtSuspendThread);
IMPORT(NtResumeThread);
IMPORT(NtSetLdtEntries);
IMPORT(NtQueueApcThread);

131
src/CxbxKrnl/EmuNtDll.h
View File

@ -695,6 +695,33 @@ typedef NTSTATUS (NTAPI *FPTR_RtlAnsiStringToUnicodeString)
IN BOOLEAN AllocateDestinationString
);
// ******************************************************************
// * RtlAppendStringToString
// ******************************************************************
typedef NTSTATUS(NTAPI *FPTR_RtlAppendStringToString)
(
IN OUT PSTRING Destination,
IN PSTRING Source
);
// ******************************************************************
// * RtlAppendUnicodeStringToString
// ******************************************************************
typedef NTSTATUS(NTAPI *FPTR_RtlAppendUnicodeStringToString)
(
IN OUT PUNICODE_STRING Destination,
IN PUNICODE_STRING Source
);
// ******************************************************************
// * RtlAppendUnicodeToString
// ******************************************************************
typedef NTSTATUS(NTAPI *FPTR_RtlAppendUnicodeToString)
(
IN OUT PUNICODE_STRING Destination,
IN PCWSTR Source
);
// ******************************************************************
// * RtlUnicodeStringToAnsiString
// ******************************************************************
@ -1134,55 +1161,61 @@ typedef PVOID (NTAPI *FPTR_RtlDestroyHeap)
// ******************************************************************
// * Exported API
// ******************************************************************
extern FPTR_RtlInitAnsiString RtlInitAnsiString;
extern FPTR_RtlInitUnicodeString RtlInitUnicodeString;
extern FPTR_RtlAnsiStringToUnicodeString RtlAnsiStringToUnicodeString;
extern FPTR_RtlUnicodeStringToAnsiString RtlUnicodeStringToAnsiString;
extern FPTR_RtlFreeAnsiString RtlFreeAnsiString;
extern FPTR_RtlNtStatusToDosError RtlNtStatusToDosError;
extern FPTR_RtlTimeFieldsToTime RtlTimeFieldsToTime;
extern FPTR_RtlTimeToTimeFields RtlTimeToTimeFields;
extern FPTR_RtlTryEnterCriticalSection RtlTryEnterCriticalSection;
extern FPTR_RtlInitializeCriticalSection RtlInitializeCriticalSection;
extern FPTR_RtlEnterCriticalSection RtlEnterCriticalSection;
extern FPTR_RtlLeaveCriticalSection RtlLeaveCriticalSection;
extern FPTR_NtWaitForSingleObject NtWaitForSingleObject;
extern FPTR_NtWaitForMultipleObjects NtWaitForMultipleObjects;
extern FPTR_RtlCreateHeap RtlCreateHeap;
extern FPTR_RtlAllocateHeap RtlAllocateHeap;
extern FPTR_RtlFreeHeap RtlFreeHeap;
extern FPTR_RtlReAllocateHeap RtlReAllocateHeap;
extern FPTR_RtlSizeHeap RtlSizeHeap;
extern FPTR_RtlDestroyHeap RtlDestroyHeap;
extern FPTR_RtlEqualString RtlEqualString;
extern FPTR_NtAllocateVirtualMemory NtAllocateVirtualMemory;
extern FPTR_NtFreeVirtualMemory NtFreeVirtualMemory;
extern FPTR_NtQueryVirtualMemory NtQueryVirtualMemory;
extern FPTR_NtClearEvent NtClearEvent;
extern FPTR_NtClose NtClose;
extern FPTR_NtDelayExecution NtDelayExecution;
extern FPTR_NtDuplicateObject NtDuplicateObject;
extern FPTR_NtFlushBuffersFile NtFlushBuffersFile;
extern FPTR_NtQueryInformationFile NtQueryInformationFile;
extern FPTR_NtQueryDirectoryFile NtQueryDirectoryFile;
extern FPTR_NtQueryFullAttributesFile NtQueryFullAttributesFile;
extern FPTR_NtQueryVolumeInformationFile NtQueryVolumeInformationFile;
extern FPTR_NtCreateEvent NtCreateEvent;
extern FPTR_NtCreateMutant NtCreateMutant;
extern FPTR_NtReleaseMutant NtReleaseMutant;
extern FPTR_NtCreateSemaphore NtCreateSemaphore;
extern FPTR_NtReleaseSemaphore NtReleaseSemaphore;
extern FPTR_NtCreateDirectoryObject NtCreateDirectoryObject;
extern FPTR_NtCreateFile NtCreateFile;
extern FPTR_NtReadFile NtReadFile;
extern FPTR_NtWriteFile NtWriteFile;
extern FPTR_NtYieldExecution NtYieldExecution;
extern FPTR_NtSetInformationFile NtSetInformationFile;
extern FPTR_NtSetEvent NtSetEvent;
extern FPTR_NtSuspendThread NtSuspendThread;
extern FPTR_NtResumeThread NtResumeThread;
extern FPTR_NtSetLdtEntries NtSetLdtEntries;
extern FPTR_NtQueueApcThread NtQueueApcThread;
#define EXTERN(API) \
extern FPTR_##API API
EXTERN(RtlInitAnsiString);
EXTERN(RtlInitUnicodeString);
EXTERN(RtlAnsiStringToUnicodeString);
EXTERN(RtlAppendStringToString);
EXTERN(RtlAppendUnicodeStringToString);
EXTERN(RtlAppendUnicodeToString);
EXTERN(RtlUnicodeStringToAnsiString);
EXTERN(RtlFreeAnsiString);
EXTERN(RtlNtStatusToDosError);
EXTERN(RtlTimeFieldsToTime);
EXTERN(RtlTimeToTimeFields);
EXTERN(RtlTryEnterCriticalSection);
EXTERN(RtlInitializeCriticalSection);
EXTERN(RtlEnterCriticalSection);
EXTERN(RtlLeaveCriticalSection);
EXTERN(NtWaitForSingleObject);
EXTERN(NtWaitForMultipleObjects);
EXTERN(RtlCreateHeap);
EXTERN(RtlAllocateHeap);
EXTERN(RtlFreeHeap);
EXTERN(RtlReAllocateHeap);
EXTERN(RtlSizeHeap);
EXTERN(RtlDestroyHeap);
EXTERN(RtlEqualString);
EXTERN(NtAllocateVirtualMemory);
EXTERN(NtFreeVirtualMemory);
EXTERN(NtQueryVirtualMemory);
EXTERN(NtClearEvent);
EXTERN(NtClose);
EXTERN(NtDelayExecution);
EXTERN(NtDuplicateObject);
EXTERN(NtFlushBuffersFile);
EXTERN(NtQueryInformationFile);
EXTERN(NtQueryDirectoryFile);
EXTERN(NtQueryFullAttributesFile);
EXTERN(NtQueryVolumeInformationFile);
EXTERN(NtCreateEvent);
EXTERN(NtCreateMutant);
EXTERN(NtReleaseMutant);
EXTERN(NtCreateSemaphore);
EXTERN(NtReleaseSemaphore);
EXTERN(NtCreateDirectoryObject);
EXTERN(NtCreateFile);
EXTERN(NtReadFile);
EXTERN(NtWriteFile);
EXTERN(NtYieldExecution);
EXTERN(NtSetInformationFile);
EXTERN(NtSetEvent);
EXTERN(NtSuspendThread);
EXTERN(NtResumeThread);
EXTERN(NtSetLdtEntries);
EXTERN(NtQueueApcThread);
#if defined(__cplusplus)
}

17
src/CxbxKrnl/EmuXG.cpp
View File

@ -61,7 +61,7 @@ PVOID WINAPI XTL::EmuXGIsSwizzledFormat
{
LOG_FUNC_ONE_ARG(Format);
return FALSE;
RETURN(FALSE);
}
// ******************************************************************
@ -121,10 +121,6 @@ VOID WINAPI XTL::EmuXGSwizzleRect
pDst += Pitch;
}
}
return;
}
// ******************************************************************
@ -192,10 +188,6 @@ VOID WINAPI XTL::EmuXGSwizzleBox
}
}
}
return;
}
// ******************************************************************
@ -325,10 +317,9 @@ HRESULT WINAPI XTL::EmuXGWriteSurfaceOrTextureToXPR
// and write the surface/texture to a file, or output a generic .xbx
// file and be done with it.
UNIMPLEMENTED();
// (Temporarily) ignoring EmuXGWriteSurfaceOrTextureToXPR. Need file specs.
LOG_IGNORED(); // (Temporarily) ignoring EmuXGWriteSurfaceOrTextureToXPR. Need file specs.
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -431,5 +422,5 @@ VOID WINAPI XTL::EmuXGSetTextureHeader
//
//
//
// return E_FAIL;
// RETURN(E_FAIL);
//}

18
src/CxbxKrnl/EmuXOnline.cpp
View File

@ -64,7 +64,7 @@ int WINAPI XTL::EmuWSAStartup
int ret = WSAStartup(wVersionRequested, lpWSAData);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -80,7 +80,7 @@ INT WINAPI XTL::EmuXNetStartup
// Fake Successfull...hehehe...sucker...hehehehehe
INT ret = 0;
return ret;
RETURN(ret);
}
// ******************************************************************
@ -93,7 +93,7 @@ DWORD WINAPI XTL::EmuXNetGetEthernetLinkStatus()
// for now, no ethernet connection is available
DWORD ret = XNET_ETHERNET_LINK_ACTIVE | XNET_ETHERNET_LINK_100MBPS;
return ret;
RETURN(ret);
}
// ******************************************************************
@ -115,7 +115,7 @@ SOCKET XTL::EmuThis::Emusocket
SOCKET ret = socket(af, type, protocol);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -139,7 +139,7 @@ int XTL::EmuThis::Emubind
int ret = bind(s, name, namelen);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -161,7 +161,7 @@ int XTL::EmuThis::Emulisten
int ret = listen(s, backlog);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -183,7 +183,7 @@ int XTL::EmuThis::Emuioctlsocket
int ret = ioctlsocket(s, cmd, argp);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -204,7 +204,7 @@ HRESULT WINAPI XOnlineLaunchNewImage
HRESULT ret = E_FAIL;
return ret;
RETURN(ret);
}
// ******************************************************************
@ -231,5 +231,5 @@ HRESULT WINAPI XTL::EmuXOnlineLogon
HRESULT ret = HRESULT(0x80151000L); // XONLINE_E_LOGON_NO_NETWORK_CONNECTION
return ret;
RETURN(ret);
}

40
src/CxbxKrnl/EmuXactEng.cpp
View File

@ -80,7 +80,7 @@ HRESULT WINAPI XTL::EmuXACTEngineCreate
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -122,7 +122,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_RegisterWaveBank
*ppWaveBank = (X_XACTWaveBank*) CxbxMalloc( sizeof( X_XACTWaveBank ) );
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -145,7 +145,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_RegisterStreamedWaveBank
*ppWaveBank = (X_XACTWaveBank*) CxbxMalloc( sizeof( X_XACTWaveBank ) );
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -170,7 +170,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_CreateSoundBank
*ppSoundBank = (X_XACTSoundBank*) CxbxMalloc( sizeof( X_XACTSoundBank ) );
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -195,7 +195,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_DownloadEffectsImage
// TODO: Implement
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -216,7 +216,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_CreateSoundSource
*ppSoundSource = (X_XACTSoundSource*) CxbxMalloc( sizeof( X_XACTSoundSource ) );
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -233,7 +233,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_EnableHeadphones
LOG_FUNC_ARG(fEnabled)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -262,7 +262,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_SetListenerOrientation
LOG_FUNC_ARG(dwApply)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -285,7 +285,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_SetListenerPosition
LOG_FUNC_ARG(dwApply)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -308,7 +308,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_SetListenerVelocity
LOG_FUNC_ARG(dwApply)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -327,7 +327,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_SetMasterVolume
LOG_FUNC_ARG(lVolume)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -340,7 +340,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_CommitDeferredSettings
{
LOG_FUNC_ONE_ARG(pThis);
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -359,7 +359,7 @@ HRESULT WINAPI XTL::EmuIXACTSoundBank_GetSoundCueIndexFromFriendlyName
LOG_FUNC_ARG(pdwSoundCueIndex)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -382,7 +382,7 @@ HRESULT WINAPI XTL::EmuIXACTSoundBank_Play
LOG_FUNC_ARG(ppSoundCue)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -403,7 +403,7 @@ HRESULT WINAPI XTL::EmuIXACTSoundBank_Stop
LOG_FUNC_ARG(pSoundCue)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -426,7 +426,7 @@ HRESULT WINAPI XTL::EmuIXACTSoundSource_SetPosition
LOG_FUNC_ARG(dwApply)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -449,7 +449,7 @@ HRESULT WINAPI XTL::EmuIXACTSoundSource_SetVelocity
LOG_FUNC_ARG(dwApply)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -466,7 +466,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_RegisterNotification
LOG_FUNC_ARG(pNotificationDesc)
LOG_FUNC_END;
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -488,7 +488,7 @@ HRESULT WINAPI XTL::EmuIXACTEngine_GetNotification
// TODO: The contents of XACT_NOTIFICATION can vary from one XDK to the next.
// The definition for 4627 is different than 5558.
return S_OK;
RETURN(S_OK);
}
// ******************************************************************
@ -513,5 +513,5 @@ HRESULT WINAPI XTL::EmuIXACTEngine_UnRegisterWaveBank
// if(pWaveBank)
// free(pWaveBank);
return S_OK;
RETURN(S_OK);
}

95
src/CxbxKrnl/EmuXapi.cpp
View File

@ -89,7 +89,7 @@ BOOL WINAPI XTL::EmuXFormatUtilityDrive()
// TODO: yeah... we'll format... riiiiight
return TRUE;
RETURN(TRUE);
}
// ******************************************************************
@ -104,7 +104,7 @@ DWORD WINAPI XTL::EmuGetTimeZoneInformation
DWORD dwRet = GetTimeZoneInformation(lpTimeZoneInformation);
return dwRet;
RETURN(dwRet);
}
// ******************************************************************
@ -122,7 +122,7 @@ BOOL WINAPI XTL::EmuQueryPerformanceCounter
// debug - 4x speed
//lpPerformanceCount->QuadPart *= 4;
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -137,7 +137,7 @@ BOOL WINAPI XTL::EmuQueryPerformanceFrequency
BOOL bRet = QueryPerformanceFrequency(lpFrequency);
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -152,7 +152,7 @@ BOOL WINAPI XTL::EmuXMountUtilityDrive
CxbxMountUtilityDrive(fFormatClean);
return TRUE;
RETURN(TRUE);
}
// ******************************************************************
@ -190,8 +190,6 @@ VOID WINAPI XTL::EmuXInitDevices
{
g_hInputHandle[v] = 0;
}
return;
}
// ******************************************************************
@ -211,7 +209,7 @@ DWORD WINAPI XTL::EmuXGetDevices
else
EmuWarning("Unknown DeviceType (0x%.08X, 0x%.08X, 0x%.08X)\n", DeviceType->Reserved[0], DeviceType->Reserved[1], DeviceType->Reserved[2]);
return ret;
RETURN(ret);
}
// ******************************************************************
@ -255,7 +253,7 @@ BOOL WINAPI XTL::EmuXGetDeviceChanges
*pdwRemovals = 0;
}
return TRUE; //bRet;
RETURN(TRUE); // TODO : RETURN(bRet);
}
// ******************************************************************
@ -326,7 +324,7 @@ HANDLE WINAPI XTL::EmuXInputOpen
g_bXInputOpenCalled = true;
return (HANDLE)pph;
RETURN((HANDLE)pph);
}
// ******************************************************************
@ -365,8 +363,6 @@ VOID WINAPI XTL::EmuXInputClose
delete pph;
}
//*/
return;
}
// ******************************************************************
@ -418,9 +414,7 @@ DWORD WINAPI XTL::EmuXInputPoll
}
}
return ERROR_SUCCESS;
RETURN(ERROR_SUCCESS);
}
// ******************************************************************
@ -455,7 +449,7 @@ DWORD WINAPI XTL::EmuXInputGetCapabilities
}
}
return ret;
RETURN(ret);
}
// ******************************************************************
@ -507,7 +501,7 @@ DWORD WINAPI XTL::EmuXInputGetState
else
EmuWarning( "EmuXInputGetState(): pph == NULL!" );
return ret;
RETURN(ret);
}
// ******************************************************************
@ -583,7 +577,7 @@ DWORD WINAPI XTL::EmuXInputSetState
}
}
return ret;
RETURN(ret);
}
@ -606,7 +600,7 @@ BOOL WINAPI XTL::EmuSetThreadPriorityBoost
if(bRet == FALSE)
EmuWarning("SetThreadPriorityBoost Failed!");
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -628,7 +622,7 @@ BOOL WINAPI XTL::EmuSetThreadPriority
if(bRet == FALSE)
EmuWarning("SetThreadPriority Failed!");
return bRet;
RETURN(bRet);
}
@ -647,7 +641,7 @@ int WINAPI XTL::EmuGetThreadPriority
if(iRet == THREAD_PRIORITY_ERROR_RETURN)
EmuWarning("GetThreadPriority Failed!");
return iRet;
RETURN(iRet);
}
// ******************************************************************
@ -666,7 +660,7 @@ BOOL WINAPI XTL::EmuGetExitCodeThread
BOOL bRet = GetExitCodeThread(hThread, lpExitCode);
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -700,8 +694,6 @@ VOID WINAPI XTL::EmuXapiThreadStartup
*/
//_asm int 3;
return;
}
// ******************************************************************
@ -784,7 +776,7 @@ DWORD WINAPI XTL::EmuQueueUserAPC
if(!dwRet)
EmuWarning("QueueUserAPC failed!");
return dwRet;
RETURN(dwRet);
}
// ******************************************************************
@ -810,7 +802,7 @@ BOOL WINAPI XTL::EmuGetOverlappedResult
// if(bWait)
// bRet = TRUE; // Sucker...
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -889,9 +881,8 @@ DWORD WINAPI XTL::EmuXLaunchNewImage
}
ExitProcess(EXIT_SUCCESS);
return dwRet;
RETURN(dwRet);
}
// ******************************************************************
@ -955,9 +946,7 @@ DWORD WINAPI XTL::EmuXGetLaunchInfo
dwRet = ERROR_SUCCESS;
}
return dwRet;
RETURN(dwRet);
}
// ******************************************************************
@ -971,7 +960,7 @@ VOID WINAPI XTL::EmuXSetProcessQuantumLength
LOG_FUNC_ONE_ARG(dwMilliseconds);
// TODO: Implement?
UNIMPLEMENTED();
LOG_IGNORED();
}
// ******************************************************************
@ -985,7 +974,7 @@ DWORD WINAPI XTL::EmuXGetFileCacheSize()
// TODO: Save the file cache size if/when set.
DWORD dwRet = 64 * 1024;
return dwRet;
RETURN(dwRet);
}
// ******************************************************************
@ -1008,7 +997,7 @@ DWORD WINAPI XTL::EmuSignalObjectAndWait
DWORD dwRet = SignalObjectAndWait( hObjectToSignal, hObjectToWaitOn, dwMilliseconds, bAlertable );
return dwRet;
RETURN(dwRet);
}
// ******************************************************************
@ -1026,7 +1015,7 @@ BOOL WINAPI XTL::EmuPulseEvent
BOOL bRet = PulseEvent( hEvent );
return bRet;
RETURN(bRet);
}
// ******************************************************************
@ -1051,7 +1040,7 @@ MMRESULT WINAPI XTL::EmutimeSetEvent
MMRESULT Ret = timeSetEvent( uDelay, uResolution, fptc, (DWORD_PTR) dwUser, fuEvent );
return Ret;
RETURN(Ret);
}
// ******************************************************************
@ -1066,7 +1055,7 @@ MMRESULT WINAPI XTL::EmutimeKillEvent
MMRESULT Ret = timeKillEvent( uTimerID );
return Ret;
RETURN(Ret);
}
// ******************************************************************
@ -1089,6 +1078,8 @@ VOID WINAPI XTL::EmuRaiseException
// TODO: Implement or not?
// RaiseException(dwExceptionCode, dwExceptionFlags, nNumberOfArguments, (*(ULONG_PTR**) &lpArguments));
LOG_UNIMPLEMENTED();
}
// ******************************************************************
@ -1125,7 +1116,7 @@ DWORD WINAPI XTL::EmuGetFileAttributesA
return dwRet;
RETURN(dwRet);
}
// ******************************************************************
@ -1147,7 +1138,7 @@ DWORD WINAPI XTL::EmuXMountMUA
// TODO: Actually allow memory card emulation? This might make transferring
// game saves a bit easier if the memory card directory was configurable. =]
return E_FAIL;
RETURN(E_FAIL);
}
// ******************************************************************
@ -1172,9 +1163,7 @@ HANDLE WINAPI XTL::EmuCreateWaitableTimerA
HANDLE hRet = CreateWaitableTimerA( NULL, bManualReset, lpTimerName );
return hRet;
RETURN(hRet);
}
// ******************************************************************
@ -1204,7 +1193,7 @@ BOOL WINAPI XTL::EmuSetWaitableTimer
if(!Ret)
EmuWarning("SetWaitableTimer failed!");
return Ret;
RETURN(Ret);
}
// ******************************************************************
@ -1224,8 +1213,9 @@ DWORD WINAPI XTL::EmuXMountAlternateTitle
LOG_FUNC_END;
// TODO: Anything?
LOG_UNIMPLEMENTED();
return ERROR_SUCCESS;
RETURN(ERROR_SUCCESS);
}
// ******************************************************************
@ -1238,7 +1228,9 @@ DWORD WINAPI XTL::EmuXUnmountAlternateTitle
{
LOG_FUNC_ONE_ARG(chDrive);
return ERROR_SUCCESS;
LOG_UNIMPLEMENTED();
RETURN(ERROR_SUCCESS);
}
// ******************************************************************
@ -1248,7 +1240,9 @@ DWORD WINAPI XTL::EmuXGetDeviceEnumerationStatus()
{
LOG_FUNC();
return XDEVICE_ENUMERATION_IDLE;
LOG_UNIMPLEMENTED();
RETURN(XDEVICE_ENUMERATION_IDLE);
}
// ******************************************************************
@ -1266,8 +1260,9 @@ DWORD WINAPI XTL::EmuXInputGetDeviceDescription
LOG_FUNC_END;
// TODO: Lightgun support?
LOG_UNIMPLEMENTED();
return ERROR_NOT_SUPPORTED; // ERROR_DEVICE_NOT_CONNECTED;
RETURN(ERROR_NOT_SUPPORTED); // ERROR_DEVICE_NOT_CONNECTED;
}
// ******************************************************************
@ -1278,8 +1273,9 @@ int WINAPI XTL::EmuXAutoPowerDownResetTimer()
LOG_FUNC();
// Meh, that's what the 'X' is for! =]
LOG_UNIMPLEMENTED();
return TRUE;
RETURN(TRUE);
}
// ******************************************************************
@ -1299,6 +1295,7 @@ DWORD WINAPI XTL::EmuXMountMURootA
LOG_FUNC_END;
// TODO: The params are probably wrong...
LOG_UNIMPLEMENTED();
return ERROR_SUCCESS;
RETURN(ERROR_SUCCESS);
}

2
src/CxbxKrnl/HLEIntercept.cpp
View File

@ -69,7 +69,7 @@ void EmuHLEIntercept(Xbe::LibraryVersion *pLibraryVersion, Xbe::Header *pXbeHead
DbgPrintf("\n");
DbgPrintf("*******************************************************************************\n");
DbgPrintf("* Cxbx High Level Emulation database last modified %s\n", szHLELastCompileTime);
DbgPrintf("* Cxbx-Reloaded High Level Emulation database last modified %s\n", szHLELastCompileTime);
DbgPrintf("*******************************************************************************\n");
DbgPrintf("\n");

108
src/CxbxKrnl/KernelThunk.cpp
View File

@ -57,58 +57,62 @@ namespace xboxkrnl
#define FUNC(f) f
#define VARIABLE(v) v
#define DEVKIT // developer kit only functions
#define PROFILING // private kernel profiling functions
// A.k.a. _XBOX_ENABLE_PROFILING
// kernel thunk table
extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
{
(uint32)PANIC(0x0000), // 0x0000 (0) NULL
(uint32)FUNC(&xboxkrnl::AvGetSavedDataAddress), // 0x0001 (1)
(uint32)FUNC(&xboxkrnl::AvSendTVEncoderOption), // 0x0002 (2)
(uint32)PANIC(0x0003), // 0x0003 (3) AvSetDisplayMode
(uint32)PANIC(0x0004), // 0x0004 (4) AvSetSavedDataAddress
(uint32)PANIC(0x0005), // 0x0005 (5) DbgBreakPoint
(uint32)PANIC(0x0006), // 0x0006 (6) DbgBreakPointWithStatus
(uint32)PANIC(0x0007), // 0x0007 (7) DbgLoadImageSymbols
(uint32)FUNC(&xboxkrnl::AvSetDisplayMode), // 0x0003 (3)
(uint32)FUNC(&xboxkrnl::AvSetSavedDataAddress), // 0x0004 (4)
(uint32)FUNC(&xboxkrnl::DbgBreakPoint), // 0x0005 (5)
(uint32)FUNC(&xboxkrnl::DbgBreakPointWithStatus), // 0x0006 (6)
(uint32)FUNC(&xboxkrnl::DbgLoadImageSymbols), // 0x0007 (7) DEVKIT
(uint32)FUNC(&xboxkrnl::DbgPrint), // 0x0008 (8)
(uint32)FUNC(&xboxkrnl::HalReadSMCTrayState), // 0x0009 (9)
(uint32)PANIC(0x000A), // 0x000A (10) DbgPrompt
(uint32)PANIC(0x000B), // 0x000B (11) DbgUnLoadImageSymbols
(uint32)PANIC(0x000C), // 0x000C (12) ExAcquireReadWriteLockExclusive
(uint32)PANIC(0x000D), // 0x000D (13) ExAcquireReadWriteLockShared
(uint32)FUNC(&xboxkrnl::DbgPrompt), // 0x000A (10)
(uint32)FUNC(&xboxkrnl::DbgUnLoadImageSymbols), // 0x000B (11) DEVKIT
(uint32)FUNC(&xboxkrnl::ExAcquireReadWriteLockExclusive), // 0x000C (12)
(uint32)FUNC(&xboxkrnl::ExAcquireReadWriteLockShared), // 0x000D (13)
(uint32)FUNC(&xboxkrnl::ExAllocatePool), // 0x000E (14)
(uint32)FUNC(&xboxkrnl::ExAllocatePoolWithTag), // 0x000F (15)
(uint32)VARIABLE(&xboxkrnl::ExEventObjectType), // 0x0010 (16)
(uint32)FUNC(&xboxkrnl::ExFreePool), // 0x0011 (17)
(uint32)PANIC(0x0012), // 0x0012 (18) ExInitializeReadWriteLock
(uint32)PANIC(0x0013), // 0x0013 (19) ExInterlockedAddLargeInteger
(uint32)PANIC(0x0014), // 0x0014 (20) ExInterlockedAddLargeStatistic
(uint32)PANIC(0x0015), // 0x0015 (21) ExInterlockedCompareExchange64
(uint32)FUNC(&xboxkrnl::ExInitializeReadWriteLock), // 0x0012 (18)
(uint32)FUNC(&xboxkrnl::ExInterlockedAddLargeInteger), // 0x0013 (19)
(uint32)FUNC(&xboxkrnl::ExInterlockedAddLargeStatistic), // 0x0014 (20)
(uint32)FUNC(&xboxkrnl::ExInterlockedCompareExchange64), // 0x0015 (21)
(uint32)VARIABLE(&xboxkrnl::ExMutantObjectType), // 0x0016 (22)
(uint32)FUNC(&xboxkrnl::ExQueryPoolBlockSize), // 0x0017 (23)
(uint32)FUNC(&xboxkrnl::ExQueryNonVolatileSetting), // 0x0018 (24)
(uint32)FUNC(&xboxkrnl::ExReadWriteRefurbInfo), // 0x0019 (25)
(uint32)PANIC(0x001A), // 0x001A (26) ExQueryPoolBlockSize
(uint32)PANIC(0x001B), // 0x001B (27) ExRaiseStatus
(uint32)PANIC(0x001C), // 0x001C (28) ExReleaseReadWriteLock
(uint32)FUNC(&xboxkrnl::ExRaiseException), // 0x001A (26)
(uint32)FUNC(&xboxkrnl::ExRaiseStatus), // 0x001B (27)
(uint32)FUNC(&xboxkrnl::ExReleaseReadWriteLock), // 0x001C (28)
(uint32)FUNC(&xboxkrnl::ExSaveNonVolatileSetting), // 0x001D (29)
(uint32)VARIABLE(&xboxkrnl::ExSemaphoreObjectType), // 0x001E (30)
(uint32)VARIABLE(&xboxkrnl::ExTimerObjectType), // 0x001F (31)
(uint32)PANIC(0x0020), // 0x0020 (32) ExfInterlockedInsertHeadList
(uint32)PANIC(0x0021), // 0x0021 (33) ExfInterlockedInsertTailList
(uint32)PANIC(0x0022), // 0x0022 (34) ExfInterlockedRemoveHeadList
(uint32)FUNC(&xboxkrnl::ExfInterlockedInsertHeadList), // 0x0020 (32)
(uint32)FUNC(&xboxkrnl::ExfInterlockedInsertTailList), // 0x0021 (33)
(uint32)FUNC(&xboxkrnl::ExfInterlockedRemoveHeadList), // 0x0022 (34)
(uint32)FUNC(&xboxkrnl::FscGetCacheSize), // 0x0023 (35)
(uint32)PANIC(0x0024), // 0x0024 (36) FscInvalidateIdleBlocks
(uint32)FUNC(&xboxkrnl::FscInvalidateIdleBlocks), // 0x0024 (36)
(uint32)FUNC(&xboxkrnl::FscSetCacheSize), // 0x0025 (37)
(uint32)PANIC(0x0026), // 0x0026 (38) HalClearSoftwareInterrupt
(uint32)PANIC(0x0027), // 0x0027 (39) HalDisableSystemInterrupt
(uint32)FUNC(&xboxkrnl::HalClearSoftwareInterrupt), // 0x0026 (38)
(uint32)FUNC(&xboxkrnl::HalDisableSystemInterrupt), // 0x0027 (39)
(uint32)VARIABLE(&xboxkrnl::HalDiskCachePartitionCount), // 0x0028 (40) A.k.a. "IdexDiskPartitionPrefixBuffer"
(uint32)VARIABLE(&xboxkrnl::HalDiskModelNumber), // 0x0029 (41)
(uint32)VARIABLE(&xboxkrnl::HalDiskSerialNumber), // 0x002A (42)
(uint32)PANIC(0x002B), // 0x002B (43) HalEnableSystemInterrupt
(uint32)FUNC(&xboxkrnl::HalEnableSystemInterrupt), // 0x002B (43)
(uint32)FUNC(&xboxkrnl::HalGetInterruptVector), // 0x002C (44)
(uint32)FUNC(&xboxkrnl::HalReadSMBusValue), // 0x002D (45)
(uint32)PANIC(0x002E), // 0x002E (46) HalReadWritePCISpace
(uint32)FUNC(&xboxkrnl::HalReadWritePCISpace), // 0x002E (46)
(uint32)FUNC(&xboxkrnl::HalRegisterShutdownNotification), // 0x002F (47)
(uint32)PANIC(0x0030), // 0x0030 (48) HalRequestSoftwareInterrupt
(uint32)FUNC(&xboxkrnl::HalRequestSoftwareInterrupt), // 0x0030 (48)
(uint32)FUNC(&xboxkrnl::HalReturnToFirmware), // 0x0031 (49)
(uint32)FUNC(&xboxkrnl::HalWriteSMBusValue), // 0x0032 (50)
(uint32)PANIC(0x0033), // 0x0033 (51) InterlockedCompareExchange
@ -152,11 +156,11 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)VARIABLE(&xboxkrnl::KdDebuggerNotPresent), // 0x0059 (89)
(uint32)PANIC(0x005A), // 0x005A (90) IoDismountVolume
(uint32)FUNC(&xboxkrnl::IoDismountVolumeByName), // 0x005B (91)
(uint32)PANIC(0x005C), // 0x005C (92) KeAlertResumeThread
(uint32)PANIC(0x005D), // 0x005D (93) KeAlertThread
(uint32)PANIC(0x005E), // 0x005E (94) KeBoostPriorityThread
(uint32)FUNC(&xboxkrnl::KeAlertResumeThread), // 0x005C (92)
(uint32)FUNC(&xboxkrnl::KeAlertThread), // 0x005D (93)
(uint32)FUNC(&xboxkrnl::KeBoostPriorityThread), // 0x005E (94)
(uint32)FUNC(&xboxkrnl::KeBugCheck), // 0x005F (95)
(uint32)PANIC(0x0060), // 0x0060 (96) KeBugCheckEx
(uint32)FUNC(&xboxkrnl::KeBugCheckEx), // 0x0060 (96)
(uint32)PANIC(0x0061), // 0x0061 (97) KeCancelTimer
(uint32)FUNC(&xboxkrnl::KeConnectInterrupt), // 0x0062 (98)
(uint32)FUNC(&xboxkrnl::KeDelayExecutionThread), // 0x0063 (99)
@ -319,11 +323,11 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)PANIC(0x0100), // 0x0100 (256) PsQueryStatistics
(uint32)PANIC(0x0101), // 0x0101 (257) PsSetCreateThreadNotifyRoutine
(uint32)FUNC(&xboxkrnl::PsTerminateSystemThread), // 0x0102 (258)
(uint32)PANIC(0x0103), // 0x0103 (259) PsThreadObjectType
(uint32)VARIABLE(&xboxkrnl::PsThreadObjectType), // 0x0103 (259)
(uint32)FUNC(&xboxkrnl::RtlAnsiStringToUnicodeString), // 0x0104 (260)
(uint32)PANIC(0x0105), // 0x0105 (261) RtlAppendStringToString
(uint32)PANIC(0x0106), // 0x0106 (262) RtlAppendUnicodeStringToString
(uint32)PANIC(0x0107), // 0x0107 (263) RtlAppendUnicodeToString
(uint32)FUNC(&xboxkrnl::RtlAppendStringToString), // 0x0105 (261)
(uint32)FUNC(&xboxkrnl::RtlAppendUnicodeStringToString), // 0x0106 (262)
(uint32)FUNC(&xboxkrnl::RtlAppendUnicodeToString), // 0x0107 (263)
(uint32)FUNC(&xboxkrnl::RtlAssert), // 0x0108 (264)
(uint32)PANIC(0x0109), // 0x0109 (265) RtlCaptureContext
(uint32)PANIC(0x010A), // 0x010A (266) RtlCaptureStackBackTrace
@ -389,12 +393,12 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)VARIABLE(&xboxkrnl::XeImageFileName), // 0x0146 (326)
(uint32)FUNC(&xboxkrnl::XeLoadSection), // 0x0147 (327)
(uint32)FUNC(&xboxkrnl::XeUnloadSection), // 0x0148 (328)
(uint32)PANIC(0x0149), // 0x0149 (329) READ_PORT_BUFFER_UCHAR
(uint32)PANIC(0x014A), // 0x014A (330) READ_PORT_BUFFER_USHORT
(uint32)PANIC(0x014B), // 0x014B (331) READ_PORT_BUFFER_ULONG
(uint32)PANIC(0x014C), // 0x014C (332) WRITE_PORT_BUFFER_UCHAR
(uint32)PANIC(0x014D), // 0x014D (333) WRITE_PORT_BUFFER_USHORT
(uint32)PANIC(0x014E), // 0x014E (334) WRITE_PORT_BUFFER_ULONG
(uint32)FUNC(&xboxkrnl::READ_PORT_BUFFER_UCHAR), // 0x0149 (329)
(uint32)FUNC(&xboxkrnl::READ_PORT_BUFFER_USHORT), // 0x014A (330)
(uint32)FUNC(&xboxkrnl::READ_PORT_BUFFER_ULONG), // 0x014B (331)
(uint32)FUNC(&xboxkrnl::WRITE_PORT_BUFFER_UCHAR), // 0x014C (332)
(uint32)FUNC(&xboxkrnl::WRITE_PORT_BUFFER_USHORT), // 0x014D (333)
(uint32)FUNC(&xboxkrnl::WRITE_PORT_BUFFER_ULONG), // 0x014E (334)
(uint32)FUNC(&xboxkrnl::XcSHAInit), // 0x014F (335)
(uint32)FUNC(&xboxkrnl::XcSHAUpdate), // 0x0150 (336)
(uint32)FUNC(&xboxkrnl::XcSHAFinal), // 0x0151 (337)
@ -418,27 +422,27 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)VARIABLE(&xboxkrnl::XePublicKeyData), // 0x0163 (355)
(uint32)VARIABLE(&xboxkrnl::HalBootSMCVideoMode), // 0x0164 (356)
(uint32)VARIABLE(&xboxkrnl::IdexChannelObject), // 0x0165 (357)
(uint32)PANIC(0x0166), // 0x0166 (358) HalIsResetOrShutdownPending
(uint32)FUNC(&xboxkrnl::HalIsResetOrShutdownPending), // 0x0166 (358)
(uint32)PANIC(0x0167), // 0x0167 (359) IoMarkIrpMustComplete
(uint32)PANIC(0x0168), // 0x0168 (360) HalInitiateShutdown
(uint32)FUNC(&xboxkrnl::HalInitiateShutdown), // 0x0168 (360)
(uint32)PANIC(0x0169), // 0x0169 (361) RtlSnprintf
(uint32)PANIC(0x016A), // 0x016A (362) RtlSprintf
(uint32)PANIC(0x016B), // 0x016B (363) RtlVsnprintf
(uint32)PANIC(0x016C), // 0x016C (364) RtlVsprintf
(uint32)PANIC(0x016D), // 0x016D (365) HalEnableSecureTrayEject
(uint32)PANIC(0x016E), // 0x016E (366) HalWriteSMCScratchRegister
(uint32)FUNC(&xboxkrnl::HalEnableSecureTrayEject), // 0x016D (365)
(uint32)FUNC(&xboxkrnl::HalWriteSMCScratchRegister), // 0x016E (366)
(uint32)PANIC(0x016F), // 0x016F (367) UnknownAPI367
(uint32)PANIC(0x0170), // 0x0170 (368) UnknownAPI368
(uint32)PANIC(0x0171), // 0x0171 (369) UnknownAPI369
(uint32)PANIC(0x0172), // 0x0172 (370) UnknownAPI370
(uint32)PANIC(0x0173), // 0x0173 (371) UnknownAPI371
(uint32)PANIC(0x0174), // 0x0174 (372) UnknownAPI372
(uint32)PANIC(0x0175), // 0x0175 (373) UnknownAPI373
(uint32)PANIC(0x0176), // 0x0177 (374) MmDbgAllocateMemory
(uint32)PANIC(0x0177), // 0x0178 (375) MmDbgFreeMemory - Returns number of pages released.
(uint32)PANIC(0x0178), // 0x0179 (376) MmDbgQueryAvailablePages
(uint32)PANIC(0x0179), // 0x017A (377) MmDbgReleaseAddress
(uint32)PANIC(0x017A), // 0x017A (378) MmDbgWriteCheck
(uint32)PANIC(0x0172), // 0x0172 (370) PROFILING XProfpControl
(uint32)PANIC(0x0173), // 0x0173 (371) PROFILING XProfpGetData
(uint32)PANIC(0x0174), // 0x0174 (372) PROFILING IrtClientInitFast
(uint32)PANIC(0x0175), // 0x0175 (373) PROFILING IrtSweep
(uint32)PANIC(0x0176), // 0x0177 (374) DEVKIT MmDbgAllocateMemory
(uint32)PANIC(0x0177), // 0x0178 (375) DEVKIT MmDbgFreeMemory - Returns number of pages released.
(uint32)PANIC(0x0178), // 0x0179 (376) DEVKIT MmDbgQueryAvailablePages
(uint32)PANIC(0x0179), // 0x017A (377) DEVKIT MmDbgReleaseAddress
(uint32)PANIC(0x017A), // 0x017A (378) DEVKIT MmDbgWriteCheck
};
/* prevent name collisions */