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 #178 from PatrickvL/master 

Kernel expansion
This commit is contained in:
PatrickvL 2017-02-19 00:32:13 +01:00 committed by GitHub
parent fb432adfd4 d5bf238cbe
commit 628284eda8
15 changed files with 386 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -61,7 +61,10 @@ XBSYSAPI EXPORTNUM(17) VOID NTAPI ExFreePool
IN PVOID P
);
XBSYSAPI EXPORTNUM(18) NTSTATUS NTAPI ExInitializeReadWriteLock
// ******************************************************************
// * 0x0012 - ExInitializeReadWriteLock()
// ******************************************************************
XBSYSAPI EXPORTNUM(18) VOID NTAPI ExInitializeReadWriteLock
(
IN PERWLOCK ReadWriteLock
);
@ -152,24 +155,30 @@ XBSYSAPI EXPORTNUM(30) OBJECT_TYPE ExSemaphoreObjectType;
XBSYSAPI EXPORTNUM(31) OBJECT_TYPE ExTimerObjectType;
// ******************************************************************
// * 0x0020 - ExfInterlockedInsertHeadList()
// ******************************************************************
XBSYSAPI EXPORTNUM(32) PLIST_ENTRY FASTCALL ExfInterlockedInsertHeadList
(
IN PLIST_ENTRY ListHead,
IN PLIST_ENTRY ListEntry,
IN PKSPIN_LOCK Lock
IN PLIST_ENTRY ListEntry
);
// ******************************************************************
// * 0x0021 - ExfInterlockedInsertTailList()
// ******************************************************************
XBSYSAPI EXPORTNUM(33) PLIST_ENTRY FASTCALL ExfInterlockedInsertTailList
(
IN PLIST_ENTRY ListHead,
IN PLIST_ENTRY ListEntry,
IN PKSPIN_LOCK Lock
IN PLIST_ENTRY ListEntry
);
// ******************************************************************
// * 0x0022 - ExfInterlockedRemoveHeadList()
// ******************************************************************
XBSYSAPI EXPORTNUM(34) PLIST_ENTRY FASTCALL ExfInterlockedRemoveHeadList
(
IN PLIST_ENTRY ListHead,
IN PKSPIN_LOCK Lock
IN PLIST_ENTRY ListHead
);
XBSYSAPI EXPORTNUM(51) LONG FASTCALL KRNL(InterlockedCompareExchange)

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

@ -147,8 +147,25 @@ XBSYSAPI EXPORTNUM(109) VOID NTAPI KeInitializeInterrupt
XBSYSAPI VOID *KeInitializeMutant;
XBSYSAPI VOID *KeInitializeQueue;
XBSYSAPI VOID *KeInitializeSemaphore;
// ******************************************************************
// * 0x006F - KeInitializeQueue()
// ******************************************************************
XBSYSAPI EXPORTNUM(111) VOID NTAPI KeInitializeQueue
(
IN PKQUEUE Queue,
IN ULONG Count OPTIONAL
);
// ******************************************************************
// * 0x0070 - KeInitializeSemaphore()
// ******************************************************************
XBSYSAPI EXPORTNUM(112) VOID NTAPI KeInitializeSemaphore
(
IN PRKSEMAPHORE Semaphore,
IN LONG Count,
IN LONG Limit
);
// ******************************************************************
// * 0x0071 - KeInitializeTimerEx()

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

@ -168,7 +168,13 @@ XBSYSAPI EXPORTNUM(277) VOID NTAPI RtlEnterCriticalSection
IN PRTL_CRITICAL_SECTION CriticalSection
);
XBSYSAPI VOID *RtlEnterCriticalSectionAndRegion;
// ******************************************************************
// * 0x0116 - RtlEnterCriticalSectionAndRegion()
// ******************************************************************
XBSYSAPI EXPORTNUM(278) VOID NTAPI RtlEnterCriticalSectionAndRegion
(
IN PRTL_CRITICAL_SECTION CriticalSection
);
// ******************************************************************
// * 0x0117 - RtlEqualString()
@ -313,7 +319,13 @@ XBSYSAPI EXPORTNUM(294) VOID NTAPI RtlLeaveCriticalSection
IN PRTL_CRITICAL_SECTION CriticalSection
);
XBSYSAPI VOID *RtlLeaveCriticalSectionAndRegion;
// ******************************************************************
// * 0x0127 - RtlLeaveCriticalSectionAndRegion()
// ******************************************************************
XBSYSAPI EXPORTNUM(295) VOID NTAPI RtlLeaveCriticalSectionAndRegion
(
IN PRTL_CRITICAL_SECTION CriticalSection
);
// ******************************************************************
// * RtlLowerChar

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

@ -417,12 +417,13 @@ XBSYSAPI EXPORTNUM(369) NTSTATUS NTAPI UnknownAPI369
XBSYSAPI EXPORTNUM(370) NTSTATUS NTAPI XProfpControl // PROFILING
(
// UNKNOWN ARGUMENTS
ULONG Action,
ULONG Param
);
XBSYSAPI EXPORTNUM(371) NTSTATUS NTAPI XProfpGetData // PROFILING
(
// UNKNOWN ARGUMENTS
// NO ARGUMENTS
);
XBSYSAPI EXPORTNUM(372) NTSTATUS NTAPI IrtClientInitFast // PROFILING

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

@ -1526,6 +1526,8 @@ KDPC, *PKDPC;
// ******************************************************************
typedef enum _KOBJECTS
{
QueueObject = 4,
SemaphoreObject = 5,
TimerNotificationObject = 8,
TimerSynchronizationObject = 9,
DpcObject = 0x13,

6
src/Common/Logging.h
View File

@ -220,6 +220,12 @@ extern thread_local std::string _logPrefix;
std::cout << _logPrefix << __func__ << " unimplemented!\n"; \
} } while (0)
// LOG_INCOMPLETE indicates that Cxbx is missing part of an implementation of an api
#define LOG_INCOMPLETE() \
do { if(g_bPrintfOn) { \
std::cout << _logPrefix << __func__ << " incomplete!\n"; \
} } while (0)
// RETURN logs the given result and then returns it (so this should appear last in functions)
#define RETURN(r) do { LOG_FUNC_RESULT(r) return r; } while (0)

42
src/CxbxKrnl/EmuKrnl.cpp
View File

@ -146,7 +146,9 @@ XBSYSAPI EXPORTNUM(51) xboxkrnl::LONG FASTCALL xboxkrnl::KRNL(InterlockedCompare
LOG_FUNC_ARG(Comparand)
LOG_FUNC_END;
RETURN(InterlockedCompareExchange((NtDll::PLONG)Destination, (NtDll::LONG)Exchange, (NtDll::LONG)Comparand));
LONG res = InterlockedCompareExchange((NtDll::PLONG)Destination, (NtDll::LONG)Exchange, (NtDll::LONG)Comparand);
RETURN(res);
}
// ******************************************************************
@ -160,7 +162,9 @@ XBSYSAPI EXPORTNUM(52) xboxkrnl::LONG FASTCALL xboxkrnl::KRNL(InterlockedDecreme
{
LOG_FUNC_ONE_ARG(Addend);
RETURN(InterlockedDecrement((NtDll::PLONG)Addend));
LONG res = InterlockedDecrement((NtDll::PLONG)Addend);
RETURN(res);
}
// ******************************************************************
@ -174,7 +178,9 @@ XBSYSAPI EXPORTNUM(53) xboxkrnl::LONG FASTCALL xboxkrnl::KRNL(InterlockedIncreme
{
LOG_FUNC_ONE_ARG(Addend);
RETURN(InterlockedIncrement((NtDll::PLONG)Addend));
LONG res = InterlockedIncrement((NtDll::PLONG)Addend);
RETURN(res);
}
// ******************************************************************
@ -192,7 +198,9 @@ XBSYSAPI EXPORTNUM(54) xboxkrnl::LONG FASTCALL xboxkrnl::KRNL(InterlockedExchang
LOG_FUNC_ARG(Value)
LOG_FUNC_END;
RETURN(InterlockedExchange((NtDll::PLONG)Destination, (NtDll::LONG)Value));
LONG res = InterlockedExchange((NtDll::PLONG)Destination, (NtDll::LONG)Value);
RETURN(res);
}
// ******************************************************************
@ -210,7 +218,9 @@ XBSYSAPI EXPORTNUM(55) xboxkrnl::LONG FASTCALL xboxkrnl::KRNL(InterlockedExchang
LOG_FUNC_ARG(Value)
LOG_FUNC_END;
RETURN(InterlockedExchangeAdd((NtDll::PLONG)Addend, (NtDll::LONG)Value));
LONG res = InterlockedExchangeAdd((NtDll::PLONG)Addend, (NtDll::LONG)Value);
RETURN(res);
}
// ******************************************************************
@ -225,7 +235,9 @@ XBSYSAPI EXPORTNUM(56) xboxkrnl::PSINGLE_LIST_ENTRY FASTCALL xboxkrnl::KRNL(Inte
{
LOG_FUNC_ONE_ARG(ListHead);
RETURN((xboxkrnl::PSINGLE_LIST_ENTRY)InterlockedFlushSList((::PSLIST_HEADER)ListHead));
PSINGLE_LIST_ENTRY res = (PSINGLE_LIST_ENTRY)InterlockedFlushSList((::PSLIST_HEADER)ListHead);
RETURN(res);
}
// ******************************************************************
@ -239,7 +251,9 @@ XBSYSAPI EXPORTNUM(57) xboxkrnl::PSLIST_ENTRY FASTCALL xboxkrnl::KRNL(Interlocke
{
LOG_FUNC_ONE_ARG(ListHead);
RETURN((PSLIST_ENTRY)InterlockedPopEntrySList((::PSLIST_HEADER)ListHead));
PSLIST_ENTRY res = (PSLIST_ENTRY)InterlockedPopEntrySList((::PSLIST_HEADER)ListHead);
RETURN(res);
}
// ******************************************************************
@ -257,7 +271,9 @@ XBSYSAPI EXPORTNUM(58) xboxkrnl::PSLIST_ENTRY FASTCALL xboxkrnl::KRNL(Interlocke
LOG_FUNC_ARG(ListEntry)
LOG_FUNC_END;
RETURN((xboxkrnl::PSLIST_ENTRY)InterlockedPushEntrySList((::PSLIST_HEADER)ListHead, (::PSLIST_ENTRY)ListEntry));
PSLIST_ENTRY res = (PSLIST_ENTRY)InterlockedPushEntrySList((::PSLIST_HEADER)ListHead, (::PSLIST_ENTRY)ListEntry);
RETURN(res);
}
// ******************************************************************
@ -415,10 +431,14 @@ XBSYSAPI EXPORTNUM(369) xboxkrnl::NTSTATUS NTAPI xboxkrnl::UnknownAPI369
// ******************************************************************
XBSYSAPI EXPORTNUM(370) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XProfpControl // PROFILING
(
// UNKNOWN ARGUMENTS
ULONG Action,
ULONG Param
)
{
LOG_FUNC();
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Action)
LOG_FUNC_ARG(Param)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
@ -430,7 +450,7 @@ XBSYSAPI EXPORTNUM(370) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XProfpControl // PROF
// ******************************************************************
XBSYSAPI EXPORTNUM(371) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XProfpGetData // PROFILING
(
// UNKNOWN ARGUMENTS
// NO ARGUMENTS
)
{
LOG_FUNC();

94
src/CxbxKrnl/EmuKrnlEx.cpp
View File

@ -55,6 +55,7 @@ namespace NtDll
#include "CxbxKrnl.h" // For CxbxKrnlCleanup
#include "Emu.h" // For EmuWarning()
#include "EmuAlloc.h" // For CxbxFree(), CxbxCalloc(), etc.
#include "EmuKrnl.h" // For InsertHeadList, InsertTailList, RemoveHeadList
#pragma warning(disable:4005) // Ignore redefined status values
#include <ntstatus.h> // For STATUS_BUFFER_TOO_SMALL
@ -161,16 +162,19 @@ XBSYSAPI EXPORTNUM(17) xboxkrnl::VOID NTAPI xboxkrnl::ExFreePool
// * 0x0012 - ExInitializeReadWriteLock()
// ******************************************************************
// Source:APILogger - Uncertain
XBSYSAPI EXPORTNUM(18) xboxkrnl::NTSTATUS NTAPI xboxkrnl::ExInitializeReadWriteLock
XBSYSAPI EXPORTNUM(18) xboxkrnl::VOID NTAPI xboxkrnl::ExInitializeReadWriteLock
(
IN PERWLOCK ReadWriteLock
)
{
LOG_FUNC_ONE_ARG(ReadWriteLock);
LOG_UNIMPLEMENTED();
RETURN(S_OK);
ReadWriteLock->LockCount = -1;
ReadWriteLock->WritersWaitingCount = 0;
ReadWriteLock->ReadersWaitingCount = 0;
ReadWriteLock->ReadersEntryCount = 0;
KeInitializeEvent(&ReadWriteLock->WriterEvent, SynchronizationEvent, FALSE);
KeInitializeSemaphore(&ReadWriteLock->ReaderSemaphore, 0, MAXLONG);
}
// ******************************************************************
@ -597,19 +601,31 @@ XBSYSAPI EXPORTNUM(31) xboxkrnl::OBJECT_TYPE xboxkrnl::ExTimerObjectType =
XBSYSAPI EXPORTNUM(32) xboxkrnl::PLIST_ENTRY FASTCALL xboxkrnl::ExfInterlockedInsertHeadList
(
IN PLIST_ENTRY ListHead,
IN PLIST_ENTRY ListEntry,
IN PKSPIN_LOCK Lock
IN PLIST_ENTRY ListEntry
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(ListHead)
LOG_FUNC_ARG(ListEntry)
LOG_FUNC_ARG(Lock)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
/* Disable interrupts and acquire the spinlock */
// BOOLEAN Enable = _ExiDisableInteruptsAndAcquireSpinlock(Lock);
LOG_INCOMPLETE(); // TODO : Lock
RETURN(ListHead);
/* Save the first entry */
PLIST_ENTRY FirstEntry = ListHead->Flink;
/* Insert the new entry */
InsertHeadList(ListHead, ListEntry);
/* Release the spinlock and restore interrupts */
// _ExiReleaseSpinLockAndRestoreInterupts(Lock, Enable);
/* Return the old first entry or NULL for empty list */
if (FirstEntry == ListHead)
FirstEntry = NULL;
RETURN(FirstEntry);
}
// ******************************************************************
@ -619,19 +635,32 @@ XBSYSAPI EXPORTNUM(32) xboxkrnl::PLIST_ENTRY FASTCALL xboxkrnl::ExfInterlockedIn
XBSYSAPI EXPORTNUM(33) xboxkrnl::PLIST_ENTRY FASTCALL xboxkrnl::ExfInterlockedInsertTailList
(
IN PLIST_ENTRY ListHead,
IN PLIST_ENTRY ListEntry,
IN PKSPIN_LOCK Lock
IN PLIST_ENTRY ListEntry
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(ListHead)
LOG_FUNC_ARG(ListEntry)
LOG_FUNC_ARG(Lock)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
/* Disable interrupts and acquire the spinlock */
// BOOLEAN Enable = _ExiDisableInteruptsAndAcquireSpinlock(Lock);
LOG_INCOMPLETE(); // TODO : Lock
RETURN(ListHead);
/* Save the last entry */
PLIST_ENTRY LastEntry = ListHead->Blink;
/* Insert the new entry */
InsertTailList(ListHead, ListEntry);
/* Release the spinlock and restore interrupts */
// _ExiReleaseSpinLockAndRestoreInterupts(Lock, Enable);
/* Return the old last entry or NULL for empty list */
if (LastEntry == ListHead)
LastEntry = NULL;
RETURN(LastEntry);
}
// ******************************************************************
@ -640,16 +669,37 @@ XBSYSAPI EXPORTNUM(33) xboxkrnl::PLIST_ENTRY FASTCALL xboxkrnl::ExfInterlockedIn
// Source:ReactOS
XBSYSAPI EXPORTNUM(34) xboxkrnl::PLIST_ENTRY FASTCALL xboxkrnl::ExfInterlockedRemoveHeadList
(
IN PLIST_ENTRY ListHead,
IN PKSPIN_LOCK Lock
IN PLIST_ENTRY ListHead
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(ListHead)
LOG_FUNC_ARG(Lock)
LOG_FUNC_END;
LOG_FUNC_ONE_ARG(ListHead);
LOG_UNIMPLEMENTED();
/* Disable interrupts and acquire the spinlock */
// BOOLEAN Enable = _ExiDisableInteruptsAndAcquireSpinlock(Lock);
LOG_INCOMPLETE(); // TODO : Lock
PLIST_ENTRY ListEntry;
/* Check if the list is empty */
if (IsListEmpty(ListHead))
{
/* Return NULL */
ListEntry = NULL;
}
else
{
/* Remove the first entry from the list head */
ListEntry = RemoveHeadList(ListHead);
#if DBG
ListEntry->Flink = (PLIST_ENTRY)0xBADDD0FF;
ListEntry->Blink = (PLIST_ENTRY)0xBADDD0FF;
#endif
}
/* Release the spinlock and restore interrupts */
// _ExiReleaseSpinLockAndRestoreInterupts(Lock, Enable);
/* Return the entry */
RETURN(ListEntry);
RETURN(ListHead);
}

26
src/CxbxKrnl/EmuKrnlHal.cpp
View File

@ -247,15 +247,13 @@ XBSYSAPI EXPORTNUM(45) xboxkrnl::NTSTATUS NTAPI xboxkrnl::HalReadSMBusValue
LOG_FUNC_ARG_OUT(DataValue)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
if (ReadWord) {
// Write UCHAR
LOG_INCOMPLETE(); // TODO : Read UCHAR, possibly as simple as: *((PWORD)DataValue) = value
}
else {
// Write BYTE
// Read BYTE
if (DataValue)
*DataValue = 1;
*DataValue = 1; // TODO : What value?
}
RETURN(STATUS_SUCCESS);
@ -434,7 +432,8 @@ XBSYSAPI EXPORTNUM(329) xboxkrnl::VOID NTAPI xboxkrnl::READ_PORT_BUFFER_UCHAR
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
while (Count-- > 0)
*Buffer++ = EmuX86_IORead8((xbaddr)Port);
}
// ******************************************************************
@ -453,7 +452,8 @@ XBSYSAPI EXPORTNUM(330) xboxkrnl::VOID NTAPI xboxkrnl::READ_PORT_BUFFER_USHORT
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
while (Count-- > 0)
*Buffer++ = EmuX86_IORead16((xbaddr)Port);
}
// ******************************************************************
@ -472,7 +472,8 @@ XBSYSAPI EXPORTNUM(331) xboxkrnl::VOID NTAPI xboxkrnl::READ_PORT_BUFFER_ULONG
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
while (Count-- > 0)
*Buffer++ = EmuX86_IORead32((xbaddr)Port);
}
// ******************************************************************
@ -491,7 +492,8 @@ XBSYSAPI EXPORTNUM(332) xboxkrnl::VOID NTAPI xboxkrnl::WRITE_PORT_BUFFER_UCHAR
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
while (Count-- > 0)
EmuX86_IOWrite8((xbaddr)Port, *Buffer++);
}
// ******************************************************************
@ -510,7 +512,8 @@ XBSYSAPI EXPORTNUM(333) xboxkrnl::VOID NTAPI xboxkrnl::WRITE_PORT_BUFFER_USHORT
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
while (Count-- > 0)
EmuX86_IOWrite16((xbaddr)Port, *Buffer++);
}
// ******************************************************************
@ -529,7 +532,8 @@ XBSYSAPI EXPORTNUM(334) xboxkrnl::VOID NTAPI xboxkrnl::WRITE_PORT_BUFFER_ULONG
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
LOG_UNIMPLEMENTED();
while (Count-- > 0)
EmuX86_IOWrite32((xbaddr)Port, *Buffer++);
}
// ******************************************************************

65
src/CxbxKrnl/EmuKrnlKe.cpp
View File

@ -72,6 +72,13 @@ typedef struct _DpcData {
DpcData g_DpcData = { 0 }; // Note : g_DpcData is initialized in InitDpcAndTimerThread()
xboxkrnl::ULONGLONG LARGE_INTEGER2ULONGLONG(xboxkrnl::LARGE_INTEGER value)
{
// Weird construction because there doesn't seem to exist an implicit
// conversion of LARGE_INTEGER to ULONGLONG :
return *((PULONGLONG)&value);
}
// TODO : Move all Ki* functions to EmuKrnlKi.h/cpp :
#define KiRemoveTreeTimer(Timer) \
@ -620,6 +627,53 @@ XBSYSAPI EXPORTNUM(109) xboxkrnl::VOID NTAPI xboxkrnl::KeInitializeInterrupt
// struct and calls the right dispatch routine (depending on InterruptMode).
}
// ******************************************************************
// * 0x006F - KeInitializeQueue()
// ******************************************************************
XBSYSAPI EXPORTNUM(111) xboxkrnl::VOID NTAPI xboxkrnl::KeInitializeQueue
(
IN PKQUEUE Queue,
IN ULONG Count OPTIONAL
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Queue)
LOG_FUNC_ARG(Count)
LOG_FUNC_END;
Queue->Header.Type = QueueObject;
Queue->Header.Size = sizeof(KQUEUE) / sizeof(LONG);
Queue->Header.SignalState = 0;
InitializeListHead(&Queue->Header.WaitListHead);
InitializeListHead(&Queue->EntryListHead);
InitializeListHead(&Queue->ThreadListHead);
Queue->CurrentCount = 0;
Queue->MaximumCount = (Count > 1) ? Count : 1;
}
// ******************************************************************
// * 0x0070 - KeInitializeSemaphore()
// ******************************************************************
XBSYSAPI EXPORTNUM(112) xboxkrnl::VOID NTAPI xboxkrnl::KeInitializeSemaphore
(
IN PRKSEMAPHORE Semaphore,
IN LONG Count,
IN LONG Limit
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(Semaphore)
LOG_FUNC_ARG(Count)
LOG_FUNC_ARG(Limit)
LOG_FUNC_END;
Semaphore->Header.Type = SemaphoreObject;
Semaphore->Header.Size = sizeof(KSEMAPHORE) / sizeof(LONG);
Semaphore->Header.SignalState = Count;
InitializeListHead(&Semaphore->Header.WaitListHead);
Semaphore->Limit = Limit;
}
// ******************************************************************
// * 0x0071 - KeInitializeTimerEx()
// ******************************************************************
@ -738,6 +792,8 @@ XBSYSAPI EXPORTNUM(125) xboxkrnl::ULONGLONG NTAPI xboxkrnl::KeQueryInterruptTime
// in which case we should not LOG_FUNC nor RETURN (use normal return instead).
LOG_FUNC();
ULONGLONG ret;
LARGE_INTEGER InterruptTime;
while (true)
@ -755,9 +811,8 @@ XBSYSAPI EXPORTNUM(125) xboxkrnl::ULONGLONG NTAPI xboxkrnl::KeQueryInterruptTime
break;
}
// Weird construction because there doesn't seem to exist an implicit
// conversion of LARGE_INTEGER to ULONGLONG :
RETURN(*((PULONGLONG)&InterruptTime));
ret = LARGE_INTEGER2ULONGLONG(InterruptTime);
RETURN(ret);
}
// ******************************************************************
@ -767,6 +822,7 @@ XBSYSAPI EXPORTNUM(126) xboxkrnl::ULONGLONG NTAPI xboxkrnl::KeQueryPerformanceCo
{
LOG_FUNC();
ULONGLONG ret;
::LARGE_INTEGER PerformanceCounter;
// TODO : When Cxbx emulates the RDTSC opcode, use the same handling here.
@ -781,7 +837,8 @@ XBSYSAPI EXPORTNUM(126) xboxkrnl::ULONGLONG NTAPI xboxkrnl::KeQueryPerformanceCo
// We appy a conversion factor here, to fake Xbox1-like increment-speed behaviour :
PerformanceCounter.QuadPart = (ULONGLONG)(NativeToXbox_FactorForPerformanceFrequency * PerformanceCounter.QuadPart);
RETURN(PerformanceCounter.QuadPart);
ret = PerformanceCounter.QuadPart;
RETURN(ret);
}
// ******************************************************************

83
src/CxbxKrnl/EmuKrnlNt.cpp
View File

@ -167,6 +167,8 @@ XBSYSAPI EXPORTNUM(187) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtClose
// delete 'special' handles
EmuHandle *iEmuHandle = HandleToEmuHandle(Handle);
ret = iEmuHandle->NtClose();
LOG_UNIMPLEMENTED(); // TODO : Base this on the Ob* functions
}
else
// close normal handles
@ -231,6 +233,7 @@ XBSYSAPI EXPORTNUM(189) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateEvent
LOG_FUNC_ARG(EventType)
LOG_FUNC_ARG(InitialState)
LOG_FUNC_END;
/*
NTSTATUS Status;
@ -239,8 +242,8 @@ XBSYSAPI EXPORTNUM(189) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateEvent
}
else {
PKEVENT Event;
Status = ObCreateObject(&ExEventObjectType, ObjectAttributes, sizeof(KEVENT), (PVOID *)&Event);
Status = ObCreateObject(&ExEventObjectType, ObjectAttributes, sizeof(KEVENT), (PVOID *)&Event);
if (NT_SUCCESS(Status)) {
KeInitializeEvent(Event, EventType, InitialState);
Status = ObInsertObject(Event, ObjectAttributes, 0, EventHandle);
@ -249,6 +252,8 @@ XBSYSAPI EXPORTNUM(189) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateEvent
RETURN(Status);
*/
LOG_INCOMPLETE(); // TODO : Verify arguments, use ObCreateObject, KeInitializeEvent and ObInsertObject instead of this:
// initialize object attributes
NativeObjectAttributes nativeObjectAttributes;
CxbxObjectAttributesToNT(ObjectAttributes, /*var*/nativeObjectAttributes);
@ -293,6 +298,8 @@ XBSYSAPI EXPORTNUM(190) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateFile
{
LOG_FORWARD("IoCreateFile");
// TODO : How to base this on ObCreateObject, KeInitialize and ObInsertObject ?
return xboxkrnl::IoCreateFile(
FileHandle,
DesiredAccess,
@ -322,6 +329,26 @@ XBSYSAPI EXPORTNUM(192) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateMutant
LOG_FUNC_ARG(InitialOwner)
LOG_FUNC_END;
/*
NTSTATUS Status;
if (!verify arguments) {
Status = STATUS_INVALID_PARAMETER;
}
else {
PKMUTANT Mutant;
Status = ObCreateObject(&ExMutantObjectType, ObjectAttributes, sizeof(KMUTANT), (PVOID *)&Mutant);
if (NT_SUCCESS(Status)) {
KeInitializeMutant(Mutant, InitialOwner);
Status = ObInsertObject(Mutant, ObjectAttributes, 0, /*OUT* /MutantHandle);
}
}
RETURN(Status);
*/
LOG_INCOMPLETE(); // TODO : Verify arguments, use ObCreateObject, KeInitializeMutant and ObInsertObject instead of this:
// initialize object attributes
NativeObjectAttributes nativeObjectAttributes;
CxbxObjectAttributesToNT(ObjectAttributes, /*var*/nativeObjectAttributes);
@ -362,6 +389,26 @@ XBSYSAPI EXPORTNUM(193) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateSemaphore
LOG_FUNC_ARG(MaximumCount)
LOG_FUNC_END;
/*
NTSTATUS Status;
if (!verify arguments) {
Status = STATUS_INVALID_PARAMETER;
}
else {
PKSEMAPHORE Semaphore;
Status = ObCreateObject(&ExSemaphoreObjectType, ObjectAttributes, sizeof(KSEMAPHORE), (PVOID *)&Semaphore);
if (NT_SUCCESS(Status)) {
KeInitializeSemaphore(Semaphore, InitialCount, /*Limit=* /MaximumCount);
Status = ObInsertObject(Semaphore, ObjectAttributes, 0, /*OUT* /SemaphoreHandle);
}
}
RETURN(Status);
*/
LOG_INCOMPLETE(); // TODO : Verify arguments, use ObCreateObject, KeInitializeSemaphore and ObInsertObject instead of this:
// TODO : Is this the correct ACCESS_MASK? :
const ACCESS_MASK DesiredAccess = SEMAPHORE_ALL_ACCESS;
@ -400,6 +447,26 @@ XBSYSAPI EXPORTNUM(194) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateTimer
LOG_FUNC_ARG(TimerType)
LOG_FUNC_END;
/*
NTSTATUS Status;
if (!verify arguments) {
Status = STATUS_INVALID_PARAMETER;
}
else {
PKTIMER Timer;
Status = ObCreateObject(&ExTimerType, ObjectAttributes, sizeof(KTIMER), (PVOID *)&Timer);
if (NT_SUCCESS(Status)) {
KeInitializeTimerEx(Timer, TimerType);
Status = ObInsertObject(Timer, ObjectAttributes, 0, /*OUT* /TimerHandle);
}
}
RETURN(Status);
*/
LOG_INCOMPLETE(); // TODO : Verify arguments, use ObCreateObject, KeInitializeTimerEx and ObInsertObject instead of this:
// TODO : Is this the correct ACCESS_MASK? :
const ACCESS_MASK DesiredAccess = TIMER_ALL_ACCESS;
@ -525,6 +592,20 @@ XBSYSAPI EXPORTNUM(197) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtDuplicateObject
if (IsEmuHandle(SourceHandle)) {
EmuHandle* iEmuHandle = HandleToEmuHandle(SourceHandle);
ret = iEmuHandle->NtDuplicateObject(TargetHandle, Options);
/*
PVOID Object;
ret = ObReferenceObjectByHandle(SourceHandle, /*ObjectType=* /NULL, &Object);
if (NT_SUCCESS(ret)) {
if (ObpIsFlagSet(Options, DUPLICATE_CLOSE_SOURCE))
NtClose(SourceHandle);
status = ObOpenObjectByPointer(Object, OBJECT_TO_OBJECT_HEADER(Object)->Type, /*OUT* /TargetHandle);
ObDereferenceObject(Object);
}
else
*TargetHandle = NULL;
*/
}
else
{

19
src/CxbxKrnl/EmuKrnlOb.cpp
View File

@ -62,6 +62,7 @@ namespace NtDll
#pragma warning(default:4005)
#define OB_FLAG_NAMED_OBJECT 1
#define OB_FLAG_PERMANENT_OBJECT 2
// ******************************************************************
// * 0x00EF - ObCreateObject()
@ -196,7 +197,21 @@ XBSYSAPI EXPORTNUM(242) xboxkrnl::VOID NTAPI xboxkrnl::ObMakeTemporaryObject
{
LOG_FUNC_ONE_ARG(Object);
LOG_UNIMPLEMENTED();
/* Get the header */
POBJECT_HEADER ObjectHeader = OBJECT_TO_OBJECT_HEADER(Object);
/* Acquire object lock */
//ObpAcquireObjectLock(ObjectHeader);
LOG_INCOMPLETE(); // TODO : Lock, etc.
/* Remove the flag */
ObjectHeader->Flags &= ~OB_FLAG_PERMANENT_OBJECT;
/* Release the lock */
// ObpReleaseObjectLock(ObjectHeader);
/* Check if we should delete the object now */
//ObpDeleteNameCheck(ObjectBody);
}
// ******************************************************************
@ -422,5 +437,3 @@ XBSYSAPI EXPORTNUM(251) xboxkrnl::VOID FASTCALL xboxkrnl::ObfReferenceObject
InterlockedIncrement(&ObjectHeader->PointerCount);
}

37
src/CxbxKrnl/EmuKrnlRtl.cpp
View File

@ -436,6 +436,23 @@ XBSYSAPI EXPORTNUM(277) xboxkrnl::VOID NTAPI xboxkrnl::RtlEnterCriticalSection
}
}
// ******************************************************************
// * 0x0116 - RtlEnterCriticalSectionAndRegion()
// ******************************************************************
XBSYSAPI EXPORTNUM(278) xboxkrnl::VOID NTAPI xboxkrnl::RtlEnterCriticalSectionAndRegion
(
IN PRTL_CRITICAL_SECTION CriticalSection
)
{
/** sorta pointless
LOG_FUNC_ONE_ARG(CriticalSection);
//*/
LOG_INCOMPLETE(); // TODO : How to enter region?
RtlEnterCriticalSection(CriticalSection);
}
// ******************************************************************
// * 0x0117 - RtlEqualString()
// ******************************************************************
@ -753,6 +770,10 @@ XBSYSAPI EXPORTNUM(294) xboxkrnl::VOID NTAPI xboxkrnl::RtlLeaveCriticalSection
return;
}
/* sorta pointless
LOG_FUNC_ONE_ARG(CriticalSection);
//*/
int iSection = FindCriticalSection(CriticalSection);
if (iSection >= 0)
@ -764,12 +785,26 @@ XBSYSAPI EXPORTNUM(294) xboxkrnl::VOID NTAPI xboxkrnl::RtlLeaveCriticalSection
CriticalSection->RecursionCount = GlobalCriticalSections[iSection].NativeCriticalSection.RecursionCount;
CriticalSection->OwningThread = GlobalCriticalSections[iSection].NativeCriticalSection.OwningThread;
}
// Note: We need to execute this before debug output to avoid trouble
//NtDll::RtlLeaveCriticalSection((NtDll::_RTL_CRITICAL_SECTION*)CriticalSection);
}
/* sorta pointless
// ******************************************************************
// * 0x0127 - RtlLeaveCriticalSectionAndRegion()
// ******************************************************************
XBSYSAPI EXPORTNUM(295) xboxkrnl::VOID NTAPI xboxkrnl::RtlLeaveCriticalSectionAndRegion
(
IN PRTL_CRITICAL_SECTION CriticalSection
)
{
/** sorta pointless
LOG_FUNC_ONE_ARG(CriticalSection);
//*/
RtlLeaveCriticalSection(CriticalSection);
LOG_INCOMPLETE(); // TODO : How to leave region?
}
// ******************************************************************

20
src/CxbxKrnl/EmuKrnlXe.cpp
View File

@ -78,10 +78,9 @@ XBSYSAPI EXPORTNUM(327) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XeLoadSection
NTSTATUS ret = STATUS_SUCCESS;
if (Section->SectionReferenceCount > 0)
Section->SectionReferenceCount++;
else
LOG_UNIMPLEMENTED();
if (Section->SectionReferenceCount++ == 0) {
LOG_INCOMPLETE(); // TODO : Load section - probably lock this too
}
RETURN(ret);
}
@ -104,14 +103,13 @@ XBSYSAPI EXPORTNUM(328) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XeUnloadSection
NTSTATUS ret = STATUS_SUCCESS;
if (Section->SectionReferenceCount > 0)
Section->SectionReferenceCount--;
else
{
LOG_UNIMPLEMENTED();
ret = STATUS_INVALID_PARAMETER;
if (Section->SectionReferenceCount > 0) {
if (--Section->SectionReferenceCount == 0) {
LOG_INCOMPLETE(); // TODO : Unload section - probably lock this too
}
}
else
ret = STATUS_INVALID_PARAMETER;
RETURN(ret);
}

8
src/CxbxKrnl/KernelThunk.cpp
View File

@ -178,8 +178,8 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)FUNC(&xboxkrnl::KeInitializeEvent), // 0x006C (108)
(uint32)FUNC(&xboxkrnl::KeInitializeInterrupt), // 0x006D (109)
(uint32)PANIC(0x006E), // 0x006E (110) KeInitializeMutant
(uint32)PANIC(0x006F), // 0x006F (111) KeInitializeQueue
(uint32)PANIC(0x0070), // 0x0070 (112) KeInitializeSemaphore
(uint32)FUNC(&xboxkrnl::KeInitializeQueue), // 0x006F (111)
(uint32)FUNC(&xboxkrnl::KeInitializeSemaphore), // 0x0070 (112)
(uint32)FUNC(&xboxkrnl::KeInitializeTimerEx), // 0x0071 (113)
(uint32)PANIC(0x0072), // 0x0072 (114) KeInsertByKeyDeviceQueue
(uint32)PANIC(0x0073), // 0x0073 (115) KeInsertDeviceQueue
@ -345,7 +345,7 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)FUNC(&xboxkrnl::RtlDowncaseUnicodeChar), // 0x0113 (275)
(uint32)FUNC(&xboxkrnl::RtlDowncaseUnicodeString), // 0x0114 (276)
(uint32)FUNC(&xboxkrnl::RtlEnterCriticalSection), // 0x0115 (277)
(uint32)PANIC(0x0116), // 0x0116 (278) RtlEnterCriticalSectionAndRegion
(uint32)FUNC(&xboxkrnl::RtlEnterCriticalSectionAndRegion), // 0x0116 (278)
(uint32)FUNC(&xboxkrnl::RtlEqualString), // 0x0117 (279)
(uint32)FUNC(&xboxkrnl::RtlEqualUnicodeString), // 0x0118 (280)
(uint32)FUNC(&xboxkrnl::RtlExtendedIntegerMultiply), // 0x0119 (281)
@ -362,7 +362,7 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)FUNC(&xboxkrnl::RtlIntegerToChar), // 0x0124 (292)
(uint32)FUNC(&xboxkrnl::RtlIntegerToUnicodeString), // 0x0125 (293)
(uint32)FUNC(&xboxkrnl::RtlLeaveCriticalSection), // 0x0126 (294)
(uint32)PANIC(0x0127), // 0x0127 (295) RtlLeaveCriticalSectionAndRegion
(uint32)FUNC(&xboxkrnl::RtlLeaveCriticalSectionAndRegion), // 0x0127 (295)
(uint32)FUNC(&xboxkrnl::RtlLowerChar), // 0x0128 (296)
(uint32)FUNC(&xboxkrnl::RtlMapGenericMask), // 0x0129 (297)
(uint32)FUNC(&xboxkrnl::RtlMoveMemory), // 0x012A (298)