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

Added PsCreateSystemThread as forward to PsCreateSystemThreadEx (which had to be corrected) 

Also moved NtStatusToString to EmuFile.cpp.
Forwarded KeBugCheck to KeBugCheckEx, NtWaitForSingleObject,
NtWaitForSingleObjectEx and NtWaitForMultipleObjectsEx to
KeWaitForMultipleObjects (in which all implementation we have thus far,
is now concentrated).
This commit is contained in:
PatrickvL 2016-12-12 16:15:04 +01:00
parent eb46169604
commit a6591ae07c
8 changed files with 1124 additions and 1052 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,13 +16,11 @@
XBSYSAPI EXPORTNUM(254) NTSTATUS NTAPI PsCreateSystemThread
(
PULONG lpThreadAttributes, // SD
DWORD dwStackSize, // initial stack size
PKSTART_ROUTINE lpStartAddress, // thread function
VOID* lpParameter, // thread argument
DWORD dwCreationFlags, // creation option
DWORD* lpThreadId // thread identifier
OUT PHANDLE ThreadHandle,
OUT PHANDLE ThreadId OPTIONAL,
IN PKSTART_ROUTINE StartRoutine,
IN PVOID StartContext,
IN BOOLEAN DebuggerThread
);
// ******************************************************************
@ -30,16 +28,16 @@ XBSYSAPI EXPORTNUM(254) NTSTATUS NTAPI PsCreateSystemThread
// ******************************************************************
XBSYSAPI EXPORTNUM(255) NTSTATUS NTAPI PsCreateSystemThreadEx
(
OUT PHANDLE ThreadHandle,
IN ULONG ThreadExtraSize,
IN ULONG KernelStackSize,
IN ULONG TlsDataSize,
OUT PULONG ThreadId OPTIONAL,
IN PVOID StartContext1,
IN PVOID StartContext2,
IN BOOLEAN CreateSuspended,
IN BOOLEAN DebugStack,
IN PKSTART_ROUTINE StartRoutine
OUT PHANDLE ThreadHandle,
IN ULONG ThreadExtensionSize,
IN ULONG KernelStackSize,
IN ULONG TlsDataSize,
OUT PHANDLE ThreadId OPTIONAL,
IN PKSTART_ROUTINE StartRoutine,
IN PVOID StartContext,
IN BOOLEAN CreateSuspended,
IN BOOLEAN DebuggerThread,
IN PKSYSTEM_ROUTINE SystemRoutine OPTIONAL
);
XBSYSAPI VOID *PsQueryStatistics;

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

@ -879,6 +879,14 @@ KTIMER, *PKTIMER;
// ******************************************************************
// * PKSTART_ROUTINE
// ******************************************************************
typedef VOID (NTAPI *PKSTART_ROUTINE)
(
IN PVOID StartContext
);
// ******************************************************************
// * PKSYSTEM_ROUTINE
// ******************************************************************
// *
// * NOTE: Non-standard call. Similar to stdcall, but first argument
// * must be located at ebp+4 before calling.
@ -887,10 +895,10 @@ KTIMER, *PKTIMER;
// * opposed to 1.
// *
// ******************************************************************
typedef VOID (NTAPI *PKSTART_ROUTINE)
typedef VOID (*PKSYSTEM_ROUTINE)
(
IN PVOID StartContext1,
IN PVOID StartContext2
IN PKSTART_ROUTINE StartRoutine OPTIONAL,
IN PVOID StartContext OPTIONAL
);
struct _KDPC;

934
src/CxbxKrnl/EmuFile.cpp
View File

@ -507,3 +507,937 @@ EmuNtSymbolicLinkObject* FindNtSymbolicLinkObjectByRootHandle(const HANDLE Handl
return NULL;
}
// TODO : Move to a better suited file
// TODO : Create (and use) an Xbox version of this too
CHAR* NtStatusToString(IN NTSTATUS Status)
{
#define _CASE(s) case s: return #s;
switch (Status)
{
// Note : Keep all cases sorted, for easier maintenance
_CASE(DBG_APP_NOT_IDLE);
_CASE(DBG_CONTINUE);
_CASE(DBG_CONTROL_BREAK);
_CASE(DBG_CONTROL_C);
_CASE(DBG_EXCEPTION_HANDLED);
_CASE(DBG_EXCEPTION_NOT_HANDLED);
_CASE(DBG_NO_STATE_CHANGE);
_CASE(DBG_PRINTEXCEPTION_C);
_CASE(DBG_REPLY_LATER);
_CASE(DBG_RIPEXCEPTION);
_CASE(DBG_TERMINATE_PROCESS);
_CASE(DBG_TERMINATE_THREAD);
_CASE(DBG_UNABLE_TO_PROVIDE_HANDLE);
_CASE(EPT_NT_CANT_CREATE);
_CASE(EPT_NT_CANT_PERFORM_OP);
_CASE(EPT_NT_INVALID_ENTRY);
_CASE(EPT_NT_NOT_REGISTERED);
_CASE(RPC_NT_ADDRESS_ERROR);
_CASE(RPC_NT_ALREADY_LISTENING);
_CASE(RPC_NT_ALREADY_REGISTERED);
_CASE(RPC_NT_BAD_STUB_DATA);
_CASE(RPC_NT_BINDING_HAS_NO_AUTH);
_CASE(RPC_NT_BINDING_INCOMPLETE);
_CASE(RPC_NT_BYTE_COUNT_TOO_SMALL);
_CASE(RPC_NT_CALL_CANCELLED);
_CASE(RPC_NT_CALL_FAILED);
_CASE(RPC_NT_CALL_FAILED_DNE);
_CASE(RPC_NT_CALL_IN_PROGRESS);
_CASE(RPC_NT_CANNOT_SUPPORT);
_CASE(RPC_NT_CANT_CREATE_ENDPOINT);
_CASE(RPC_NT_COMM_FAILURE);
_CASE(RPC_NT_DUPLICATE_ENDPOINT);
_CASE(RPC_NT_ENTRY_ALREADY_EXISTS);
_CASE(RPC_NT_ENTRY_NOT_FOUND);
_CASE(RPC_NT_ENUM_VALUE_OUT_OF_RANGE);
_CASE(RPC_NT_FP_DIV_ZERO);
_CASE(RPC_NT_FP_OVERFLOW);
_CASE(RPC_NT_FP_UNDERFLOW);
_CASE(RPC_NT_GROUP_MEMBER_NOT_FOUND);
_CASE(RPC_NT_INCOMPLETE_NAME);
_CASE(RPC_NT_INTERFACE_NOT_FOUND);
_CASE(RPC_NT_INTERNAL_ERROR);
_CASE(RPC_NT_INVALID_ASYNC_CALL);
_CASE(RPC_NT_INVALID_ASYNC_HANDLE);
_CASE(RPC_NT_INVALID_AUTH_IDENTITY);
_CASE(RPC_NT_INVALID_BINDING);
_CASE(RPC_NT_INVALID_BOUND);
_CASE(RPC_NT_INVALID_ENDPOINT_FORMAT);
_CASE(RPC_NT_INVALID_ES_ACTION);
_CASE(RPC_NT_INVALID_NAF_ID);
_CASE(RPC_NT_INVALID_NAME_SYNTAX);
_CASE(RPC_NT_INVALID_NETWORK_OPTIONS);
_CASE(RPC_NT_INVALID_NET_ADDR);
_CASE(RPC_NT_INVALID_OBJECT);
_CASE(RPC_NT_INVALID_PIPE_OBJECT);
_CASE(RPC_NT_INVALID_PIPE_OPERATION);
_CASE(RPC_NT_INVALID_RPC_PROTSEQ);
_CASE(RPC_NT_INVALID_STRING_BINDING);
_CASE(RPC_NT_INVALID_STRING_UUID);
_CASE(RPC_NT_INVALID_TAG);
_CASE(RPC_NT_INVALID_TIMEOUT);
_CASE(RPC_NT_INVALID_VERS_OPTION);
_CASE(RPC_NT_MAX_CALLS_TOO_SMALL);
_CASE(RPC_NT_NAME_SERVICE_UNAVAILABLE);
_CASE(RPC_NT_NOTHING_TO_EXPORT);
_CASE(RPC_NT_NOT_ALL_OBJS_UNEXPORTED);
_CASE(RPC_NT_NOT_CANCELLED);
_CASE(RPC_NT_NOT_LISTENING);
_CASE(RPC_NT_NOT_RPC_ERROR);
_CASE(RPC_NT_NO_BINDINGS);
_CASE(RPC_NT_NO_CALL_ACTIVE);
_CASE(RPC_NT_NO_CONTEXT_AVAILABLE);
_CASE(RPC_NT_NO_ENDPOINT_FOUND);
_CASE(RPC_NT_NO_ENTRY_NAME);
_CASE(RPC_NT_NO_INTERFACES);
_CASE(RPC_NT_NO_MORE_BINDINGS);
_CASE(RPC_NT_NO_MORE_ENTRIES);
_CASE(RPC_NT_NO_MORE_MEMBERS);
_CASE(RPC_NT_NO_PRINC_NAME);
_CASE(RPC_NT_NO_PROTSEQS);
_CASE(RPC_NT_NO_PROTSEQS_REGISTERED);
_CASE(RPC_NT_NULL_REF_POINTER);
_CASE(RPC_NT_OBJECT_NOT_FOUND);
_CASE(RPC_NT_OUT_OF_RESOURCES);
_CASE(RPC_NT_PIPE_CLOSED);
_CASE(RPC_NT_PIPE_DISCIPLINE_ERROR);
_CASE(RPC_NT_PIPE_EMPTY);
_CASE(RPC_NT_PROCNUM_OUT_OF_RANGE);
_CASE(RPC_NT_PROTOCOL_ERROR);
_CASE(RPC_NT_PROTSEQ_NOT_FOUND);
_CASE(RPC_NT_PROTSEQ_NOT_SUPPORTED);
_CASE(RPC_NT_SEC_PKG_ERROR);
_CASE(RPC_NT_SEND_INCOMPLETE);
_CASE(RPC_NT_SERVER_TOO_BUSY);
_CASE(RPC_NT_SERVER_UNAVAILABLE);
_CASE(RPC_NT_SS_CANNOT_GET_CALL_HANDLE);
_CASE(RPC_NT_SS_CHAR_TRANS_OPEN_FAIL);
_CASE(RPC_NT_SS_CHAR_TRANS_SHORT_FILE);
_CASE(RPC_NT_SS_CONTEXT_DAMAGED);
_CASE(RPC_NT_SS_CONTEXT_MISMATCH);
_CASE(RPC_NT_SS_HANDLES_MISMATCH);
_CASE(RPC_NT_SS_IN_NULL_CONTEXT);
_CASE(RPC_NT_STRING_TOO_LONG);
_CASE(RPC_NT_TYPE_ALREADY_REGISTERED);
_CASE(RPC_NT_UNKNOWN_AUTHN_LEVEL);
_CASE(RPC_NT_UNKNOWN_AUTHN_SERVICE);
_CASE(RPC_NT_UNKNOWN_AUTHN_TYPE);
_CASE(RPC_NT_UNKNOWN_AUTHZ_SERVICE);
_CASE(RPC_NT_UNKNOWN_IF);
_CASE(RPC_NT_UNKNOWN_MGR_TYPE);
_CASE(RPC_NT_UNSUPPORTED_AUTHN_LEVEL);
_CASE(RPC_NT_UNSUPPORTED_NAME_SYNTAX);
_CASE(RPC_NT_UNSUPPORTED_TRANS_SYN);
_CASE(RPC_NT_UNSUPPORTED_TYPE);
_CASE(RPC_NT_UUID_LOCAL_ONLY);
_CASE(RPC_NT_UUID_NO_ADDRESS);
_CASE(RPC_NT_WRONG_ES_VERSION);
_CASE(RPC_NT_WRONG_KIND_OF_BINDING);
_CASE(RPC_NT_WRONG_PIPE_VERSION);
_CASE(RPC_NT_WRONG_STUB_VERSION);
_CASE(RPC_NT_ZERO_DIVIDE);
_CASE(STATUS_ABANDONED_WAIT_0);
_CASE(STATUS_ABANDONED_WAIT_63);
_CASE(STATUS_ABIOS_INVALID_COMMAND);
_CASE(STATUS_ABIOS_INVALID_LID);
_CASE(STATUS_ABIOS_INVALID_SELECTOR);
_CASE(STATUS_ABIOS_LID_ALREADY_OWNED);
_CASE(STATUS_ABIOS_LID_NOT_EXIST);
_CASE(STATUS_ABIOS_NOT_LID_OWNER);
_CASE(STATUS_ABIOS_NOT_PRESENT);
_CASE(STATUS_ABIOS_SELECTOR_NOT_AVAILABLE);
_CASE(STATUS_ACCESS_DENIED);
_CASE(STATUS_ACCESS_VIOLATION);
_CASE(STATUS_ACCOUNT_DISABLED);
_CASE(STATUS_ACCOUNT_EXPIRED);
_CASE(STATUS_ACCOUNT_LOCKED_OUT);
_CASE(STATUS_ACCOUNT_RESTRICTION);
_CASE(STATUS_ACPI_ACQUIRE_GLOBAL_LOCK);
_CASE(STATUS_ACPI_ADDRESS_NOT_MAPPED);
_CASE(STATUS_ACPI_ALREADY_INITIALIZED);
_CASE(STATUS_ACPI_ASSERT_FAILED);
_CASE(STATUS_ACPI_FATAL);
_CASE(STATUS_ACPI_HANDLER_COLLISION);
_CASE(STATUS_ACPI_INCORRECT_ARGUMENT_COUNT);
_CASE(STATUS_ACPI_INVALID_ACCESS_SIZE);
_CASE(STATUS_ACPI_INVALID_ARGTYPE);
_CASE(STATUS_ACPI_INVALID_ARGUMENT);
_CASE(STATUS_ACPI_INVALID_DATA);
_CASE(STATUS_ACPI_INVALID_EVENTTYPE);
_CASE(STATUS_ACPI_INVALID_INDEX);
_CASE(STATUS_ACPI_INVALID_MUTEX_LEVEL);
_CASE(STATUS_ACPI_INVALID_OBJTYPE);
_CASE(STATUS_ACPI_INVALID_OPCODE);
_CASE(STATUS_ACPI_INVALID_REGION);
_CASE(STATUS_ACPI_INVALID_SUPERNAME);
_CASE(STATUS_ACPI_INVALID_TABLE);
_CASE(STATUS_ACPI_INVALID_TARGETTYPE);
_CASE(STATUS_ACPI_MUTEX_NOT_OWNED);
_CASE(STATUS_ACPI_MUTEX_NOT_OWNER);
_CASE(STATUS_ACPI_NOT_INITIALIZED);
_CASE(STATUS_ACPI_POWER_REQUEST_FAILED);
_CASE(STATUS_ACPI_REG_HANDLER_FAILED);
_CASE(STATUS_ACPI_RS_ACCESS);
_CASE(STATUS_ACPI_STACK_OVERFLOW);
_CASE(STATUS_ADAPTER_HARDWARE_ERROR);
_CASE(STATUS_ADDRESS_ALREADY_ASSOCIATED);
_CASE(STATUS_ADDRESS_ALREADY_EXISTS);
_CASE(STATUS_ADDRESS_CLOSED);
_CASE(STATUS_ADDRESS_NOT_ASSOCIATED);
_CASE(STATUS_AGENTS_EXHAUSTED);
_CASE(STATUS_ALERTED);
_CASE(STATUS_ALIAS_EXISTS);
_CASE(STATUS_ALLOCATE_BUCKET);
_CASE(STATUS_ALLOTTED_SPACE_EXCEEDED);
_CASE(STATUS_ALREADY_COMMITTED);
_CASE(STATUS_ALREADY_DISCONNECTED);
_CASE(STATUS_ALREADY_WIN32);
_CASE(STATUS_APP_INIT_FAILURE);
_CASE(STATUS_ARBITRATION_UNHANDLED);
_CASE(STATUS_ARRAY_BOUNDS_EXCEEDED);
_CASE(STATUS_AUDIT_FAILED);
_CASE(STATUS_BACKUP_CONTROLLER);
_CASE(STATUS_BAD_COMPRESSION_BUFFER);
_CASE(STATUS_BAD_CURRENT_DIRECTORY);
_CASE(STATUS_BAD_DESCRIPTOR_FORMAT);
_CASE(STATUS_BAD_DEVICE_TYPE);
_CASE(STATUS_BAD_DLL_ENTRYPOINT);
_CASE(STATUS_BAD_FUNCTION_TABLE);
_CASE(STATUS_BAD_IMPERSONATION_LEVEL);
_CASE(STATUS_BAD_INHERITANCE_ACL);
_CASE(STATUS_BAD_INITIAL_PC);
_CASE(STATUS_BAD_INITIAL_STACK);
_CASE(STATUS_BAD_LOGON_SESSION_STATE);
_CASE(STATUS_BAD_MASTER_BOOT_RECORD);
_CASE(STATUS_BAD_NETWORK_NAME);
_CASE(STATUS_BAD_NETWORK_PATH);
_CASE(STATUS_BAD_REMOTE_ADAPTER);
_CASE(STATUS_BAD_SERVICE_ENTRYPOINT);
_CASE(STATUS_BAD_STACK);
_CASE(STATUS_BAD_TOKEN_TYPE);
_CASE(STATUS_BAD_VALIDATION_CLASS);
_CASE(STATUS_BAD_WORKING_SET_LIMIT);
_CASE(STATUS_BEGINNING_OF_MEDIA);
_CASE(STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT);
_CASE(STATUS_BREAKPOINT);
_CASE(STATUS_BUFFER_ALL_ZEROS);
_CASE(STATUS_BUFFER_OVERFLOW);
_CASE(STATUS_BUFFER_TOO_SMALL);
_CASE(STATUS_BUS_RESET);
_CASE(STATUS_CACHE_PAGE_LOCKED);
_CASE(STATUS_CANCELLED);
_CASE(STATUS_CANNOT_DELETE);
_CASE(STATUS_CANNOT_IMPERSONATE);
_CASE(STATUS_CANNOT_LOAD_REGISTRY_FILE);
_CASE(STATUS_CANT_ACCESS_DOMAIN_INFO);
_CASE(STATUS_CANT_DISABLE_MANDATORY);
_CASE(STATUS_CANT_ENABLE_DENY_ONLY);
_CASE(STATUS_CANT_OPEN_ANONYMOUS);
_CASE(STATUS_CANT_TERMINATE_SELF);
_CASE(STATUS_CANT_WAIT);
_CASE(STATUS_CARDBUS_NOT_SUPPORTED);
_CASE(STATUS_CHECKING_FILE_SYSTEM);
_CASE(STATUS_CHILD_MUST_BE_VOLATILE);
_CASE(STATUS_CLIENT_SERVER_PARAMETERS_INVALID);
_CASE(STATUS_COMMITMENT_LIMIT);
_CASE(STATUS_COMMITMENT_MINIMUM);
_CASE(STATUS_CONFLICTING_ADDRESSES);
_CASE(STATUS_CONNECTION_ABORTED);
_CASE(STATUS_CONNECTION_ACTIVE);
_CASE(STATUS_CONNECTION_COUNT_LIMIT);
_CASE(STATUS_CONNECTION_DISCONNECTED);
_CASE(STATUS_CONNECTION_INVALID);
_CASE(STATUS_CONNECTION_IN_USE);
_CASE(STATUS_CONNECTION_REFUSED);
_CASE(STATUS_CONNECTION_RESET);
_CASE(STATUS_CONTROL_C_EXIT);
_CASE(STATUS_CONVERT_TO_LARGE);
_CASE(STATUS_CORRUPT_SYSTEM_FILE);
_CASE(STATUS_COULD_NOT_INTERPRET);
_CASE(STATUS_CRASH_DUMP);
_CASE(STATUS_CRC_ERROR);
_CASE(STATUS_CTL_FILE_NOT_SUPPORTED);
_CASE(STATUS_CTX_BAD_VIDEO_MODE);
_CASE(STATUS_CTX_CDM_CONNECT);
_CASE(STATUS_CTX_CDM_DISCONNECT);
_CASE(STATUS_CTX_CLIENT_LICENSE_IN_USE);
_CASE(STATUS_CTX_CLIENT_LICENSE_NOT_SET);
_CASE(STATUS_CTX_CLIENT_QUERY_TIMEOUT);
_CASE(STATUS_CTX_CLOSE_PENDING);
_CASE(STATUS_CTX_CONSOLE_CONNECT);
_CASE(STATUS_CTX_CONSOLE_DISCONNECT);
_CASE(STATUS_CTX_GRAPHICS_INVALID);
_CASE(STATUS_CTX_INVALID_MODEMNAME);
_CASE(STATUS_CTX_INVALID_PD);
_CASE(STATUS_CTX_INVALID_WD);
_CASE(STATUS_CTX_LICENSE_CLIENT_INVALID);
_CASE(STATUS_CTX_LICENSE_EXPIRED);
_CASE(STATUS_CTX_LICENSE_NOT_AVAILABLE);
_CASE(STATUS_CTX_MODEM_INF_NOT_FOUND);
_CASE(STATUS_CTX_MODEM_RESPONSE_BUSY);
_CASE(STATUS_CTX_MODEM_RESPONSE_NO_CARRIER);
_CASE(STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE);
_CASE(STATUS_CTX_MODEM_RESPONSE_TIMEOUT);
_CASE(STATUS_CTX_MODEM_RESPONSE_VOICE);
_CASE(STATUS_CTX_NOT_CONSOLE);
_CASE(STATUS_CTX_NO_OUTBUF);
_CASE(STATUS_CTX_PD_NOT_FOUND);
_CASE(STATUS_CTX_RESPONSE_ERROR);
_CASE(STATUS_CTX_SHADOW_DENIED);
_CASE(STATUS_CTX_SHADOW_DISABLED);
_CASE(STATUS_CTX_SHADOW_INVALID);
_CASE(STATUS_CTX_TD_ERROR);
_CASE(STATUS_CTX_WD_NOT_FOUND);
_CASE(STATUS_CTX_WINSTATION_ACCESS_DENIED);
_CASE(STATUS_CTX_WINSTATION_BUSY);
_CASE(STATUS_CTX_WINSTATION_NAME_COLLISION);
_CASE(STATUS_CTX_WINSTATION_NAME_INVALID);
_CASE(STATUS_CTX_WINSTATION_NOT_FOUND);
_CASE(STATUS_DATATYPE_MISALIGNMENT);
_CASE(STATUS_DATATYPE_MISALIGNMENT_ERROR);
_CASE(STATUS_DATA_ERROR);
_CASE(STATUS_DATA_LATE_ERROR);
_CASE(STATUS_DATA_NOT_ACCEPTED);
_CASE(STATUS_DATA_OVERRUN);
_CASE(STATUS_DEBUG_ATTACH_FAILED);
_CASE(STATUS_DECRYPTION_FAILED);
_CASE(STATUS_DELETE_PENDING);
_CASE(STATUS_DESTINATION_ELEMENT_FULL);
_CASE(STATUS_DEVICE_ALREADY_ATTACHED);
_CASE(STATUS_DEVICE_BUSY);
_CASE(STATUS_DEVICE_CONFIGURATION_ERROR);
_CASE(STATUS_DEVICE_DATA_ERROR);
_CASE(STATUS_DEVICE_DOES_NOT_EXIST);
_CASE(STATUS_DEVICE_DOOR_OPEN);
_CASE(STATUS_DEVICE_NOT_CONNECTED);
_CASE(STATUS_DEVICE_NOT_PARTITIONED);
_CASE(STATUS_DEVICE_NOT_READY);
_CASE(STATUS_DEVICE_OFF_LINE);
_CASE(STATUS_DEVICE_PAPER_EMPTY);
_CASE(STATUS_DEVICE_POWERED_OFF);
_CASE(STATUS_DEVICE_POWER_FAILURE);
_CASE(STATUS_DEVICE_PROTOCOL_ERROR);
_CASE(STATUS_DEVICE_REMOVED);
_CASE(STATUS_DEVICE_REQUIRES_CLEANING);
_CASE(STATUS_DFS_EXIT_PATH_FOUND);
_CASE(STATUS_DFS_UNAVAILABLE);
_CASE(STATUS_DIRECTORY_IS_A_REPARSE_POINT);
_CASE(STATUS_DIRECTORY_NOT_EMPTY);
_CASE(STATUS_DIRECTORY_SERVICE_REQUIRED);
_CASE(STATUS_DISK_CORRUPT_ERROR);
_CASE(STATUS_DISK_FULL);
_CASE(STATUS_DISK_OPERATION_FAILED);
_CASE(STATUS_DISK_RECALIBRATE_FAILED);
_CASE(STATUS_DISK_RESET_FAILED);
_CASE(STATUS_DLL_INIT_FAILED);
_CASE(STATUS_DLL_INIT_FAILED_LOGOFF);
_CASE(STATUS_DLL_NOT_FOUND);
_CASE(STATUS_DOMAIN_CONTROLLER_NOT_FOUND);
_CASE(STATUS_DOMAIN_CTRLR_CONFIG_ERROR);
_CASE(STATUS_DOMAIN_EXISTS);
_CASE(STATUS_DOMAIN_LIMIT_EXCEEDED);
_CASE(STATUS_DOMAIN_TRUST_INCONSISTENT);
_CASE(STATUS_DRIVER_CANCEL_TIMEOUT);
_CASE(STATUS_DRIVER_ENTRYPOINT_NOT_FOUND);
_CASE(STATUS_DRIVER_FAILED_SLEEP);
_CASE(STATUS_DRIVER_INTERNAL_ERROR);
_CASE(STATUS_DRIVER_ORDINAL_NOT_FOUND);
_CASE(STATUS_DRIVER_UNABLE_TO_LOAD);
_CASE(STATUS_DS_ADMIN_LIMIT_EXCEEDED);
_CASE(STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS);
_CASE(STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED);
_CASE(STATUS_DS_BUSY);
_CASE(STATUS_DS_CANT_MOD_OBJ_CLASS);
_CASE(STATUS_DS_CANT_MOD_PRIMARYGROUPID);
_CASE(STATUS_DS_CANT_ON_NON_LEAF);
_CASE(STATUS_DS_CANT_ON_RDN);
_CASE(STATUS_DS_CANT_START);
_CASE(STATUS_DS_CROSS_DOM_MOVE_FAILED);
_CASE(STATUS_DS_GC_NOT_AVAILABLE);
_CASE(STATUS_DS_GC_REQUIRED);
_CASE(STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER);
_CASE(STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER);
_CASE(STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER);
_CASE(STATUS_DS_HAVE_PRIMARY_MEMBERS);
_CASE(STATUS_DS_INCORRECT_ROLE_OWNER);
_CASE(STATUS_DS_INIT_FAILURE);
_CASE(STATUS_DS_INVALID_ATTRIBUTE_SYNTAX);
_CASE(STATUS_DS_INVALID_GROUP_TYPE);
_CASE(STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER);
_CASE(STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY);
_CASE(STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED);
_CASE(STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY);
_CASE(STATUS_DS_NO_ATTRIBUTE_OR_VALUE);
_CASE(STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS);
_CASE(STATUS_DS_NO_MORE_RIDS);
_CASE(STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN);
_CASE(STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN);
_CASE(STATUS_DS_NO_RIDS_ALLOCATED);
_CASE(STATUS_DS_OBJ_CLASS_VIOLATION);
_CASE(STATUS_DS_RIDMGR_INIT_ERROR);
_CASE(STATUS_DS_SAM_INIT_FAILURE);
_CASE(STATUS_DS_SENSITIVE_GROUP_VIOLATION);
_CASE(STATUS_DS_UNAVAILABLE);
_CASE(STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER);
_CASE(STATUS_DUPLICATE_NAME);
_CASE(STATUS_DUPLICATE_OBJECTID);
_CASE(STATUS_EAS_NOT_SUPPORTED);
_CASE(STATUS_EA_CORRUPT_ERROR);
_CASE(STATUS_EA_LIST_INCONSISTENT);
_CASE(STATUS_EA_TOO_LARGE);
_CASE(STATUS_ENCRYPTION_FAILED);
_CASE(STATUS_END_OF_FILE);
_CASE(STATUS_END_OF_MEDIA);
_CASE(STATUS_ENTRYPOINT_NOT_FOUND);
_CASE(STATUS_EOM_OVERFLOW);
_CASE(STATUS_EVALUATION_EXPIRATION);
_CASE(STATUS_EVENTLOG_CANT_START);
_CASE(STATUS_EVENTLOG_FILE_CHANGED);
_CASE(STATUS_EVENTLOG_FILE_CORRUPT);
_CASE(STATUS_EVENT_DONE);
_CASE(STATUS_EVENT_PENDING);
_CASE(STATUS_EXTRANEOUS_INFORMATION);
_CASE(STATUS_FAIL_CHECK);
_CASE(STATUS_FATAL_APP_EXIT);
_CASE(STATUS_FILEMARK_DETECTED);
_CASE(STATUS_FILES_OPEN);
_CASE(STATUS_FILE_CLOSED);
_CASE(STATUS_FILE_CORRUPT_ERROR);
_CASE(STATUS_FILE_DELETED);
_CASE(STATUS_FILE_ENCRYPTED);
_CASE(STATUS_FILE_FORCED_CLOSED);
_CASE(STATUS_FILE_INVALID);
_CASE(STATUS_FILE_IS_A_DIRECTORY);
_CASE(STATUS_FILE_IS_OFFLINE);
_CASE(STATUS_FILE_LOCK_CONFLICT);
_CASE(STATUS_FILE_NOT_ENCRYPTED);
_CASE(STATUS_FILE_RENAMED);
_CASE(STATUS_FLOAT_DENORMAL_OPERAND);
_CASE(STATUS_FLOAT_DIVIDE_BY_ZERO);
_CASE(STATUS_FLOAT_INEXACT_RESULT);
_CASE(STATUS_FLOAT_INVALID_OPERATION);
_CASE(STATUS_FLOAT_MULTIPLE_FAULTS);
_CASE(STATUS_FLOAT_MULTIPLE_TRAPS);
_CASE(STATUS_FLOAT_OVERFLOW);
_CASE(STATUS_FLOAT_STACK_CHECK);
_CASE(STATUS_FLOAT_UNDERFLOW);
_CASE(STATUS_FLOPPY_BAD_REGISTERS);
_CASE(STATUS_FLOPPY_ID_MARK_NOT_FOUND);
_CASE(STATUS_FLOPPY_UNKNOWN_ERROR);
_CASE(STATUS_FLOPPY_VOLUME);
_CASE(STATUS_FLOPPY_WRONG_CYLINDER);
_CASE(STATUS_FOUND_OUT_OF_SCOPE);
_CASE(STATUS_FREE_VM_NOT_AT_BASE);
_CASE(STATUS_FS_DRIVER_REQUIRED);
_CASE(STATUS_FT_MISSING_MEMBER);
_CASE(STATUS_FT_ORPHANING);
_CASE(STATUS_FT_READ_RECOVERY_FROM_BACKUP);
_CASE(STATUS_FT_WRITE_RECOVERY);
_CASE(STATUS_FULLSCREEN_MODE);
_CASE(STATUS_GENERIC_NOT_MAPPED);
_CASE(STATUS_GRACEFUL_DISCONNECT);
_CASE(STATUS_GROUP_EXISTS);
_CASE(STATUS_GUARD_PAGE_VIOLATION);
_CASE(STATUS_GUIDS_EXHAUSTED);
_CASE(STATUS_GUID_SUBSTITUTION_MADE);
_CASE(STATUS_HANDLES_CLOSED);
_CASE(STATUS_HANDLE_NOT_CLOSABLE);
_CASE(STATUS_HOST_UNREACHABLE);
_CASE(STATUS_ILLEGAL_CHARACTER);
_CASE(STATUS_ILLEGAL_DLL_RELOCATION);
_CASE(STATUS_ILLEGAL_ELEMENT_ADDRESS);
_CASE(STATUS_ILLEGAL_FLOAT_CONTEXT);
_CASE(STATUS_ILLEGAL_FUNCTION);
_CASE(STATUS_ILLEGAL_INSTRUCTION);
_CASE(STATUS_ILL_FORMED_PASSWORD);
_CASE(STATUS_ILL_FORMED_SERVICE_ENTRY);
_CASE(STATUS_IMAGE_ALREADY_LOADED);
_CASE(STATUS_IMAGE_CHECKSUM_MISMATCH);
_CASE(STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
_CASE(STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE);
_CASE(STATUS_IMAGE_MP_UP_MISMATCH);
_CASE(STATUS_IMAGE_NOT_AT_BASE);
_CASE(STATUS_INCOMPATIBLE_FILE_MAP);
_CASE(STATUS_INFO_LENGTH_MISMATCH);
_CASE(STATUS_INSTANCE_NOT_AVAILABLE);
_CASE(STATUS_INSTRUCTION_MISALIGNMENT);
_CASE(STATUS_INSUFFICIENT_LOGON_INFO);
_CASE(STATUS_INSUFFICIENT_POWER);
_CASE(STATUS_INSUFFICIENT_RESOURCES);
_CASE(STATUS_INSUFF_SERVER_RESOURCES);
_CASE(STATUS_INTEGER_DIVIDE_BY_ZERO);
_CASE(STATUS_INTEGER_OVERFLOW);
_CASE(STATUS_INTERNAL_DB_CORRUPTION);
_CASE(STATUS_INTERNAL_DB_ERROR);
_CASE(STATUS_INTERNAL_ERROR);
_CASE(STATUS_INVALID_ACCOUNT_NAME);
_CASE(STATUS_INVALID_ACL);
_CASE(STATUS_INVALID_ADDRESS);
_CASE(STATUS_INVALID_ADDRESS_COMPONENT);
_CASE(STATUS_INVALID_ADDRESS_WILDCARD);
_CASE(STATUS_INVALID_BLOCK_LENGTH);
_CASE(STATUS_INVALID_BUFFER_SIZE);
_CASE(STATUS_INVALID_CID);
_CASE(STATUS_INVALID_COMPUTER_NAME);
_CASE(STATUS_INVALID_CONNECTION);
_CASE(STATUS_INVALID_DEVICE_REQUEST);
_CASE(STATUS_INVALID_DEVICE_STATE);
_CASE(STATUS_INVALID_DISPOSITION);
_CASE(STATUS_INVALID_DOMAIN_ROLE);
_CASE(STATUS_INVALID_DOMAIN_STATE);
_CASE(STATUS_INVALID_EA_FLAG);
_CASE(STATUS_INVALID_EA_NAME);
_CASE(STATUS_INVALID_FILE_FOR_SECTION);
_CASE(STATUS_INVALID_GROUP_ATTRIBUTES);
_CASE(STATUS_INVALID_HANDLE);
_CASE(STATUS_INVALID_HW_PROFILE);
_CASE(STATUS_INVALID_ID_AUTHORITY);
_CASE(STATUS_INVALID_IMAGE_FORMAT);
_CASE(STATUS_INVALID_IMAGE_LE_FORMAT);
_CASE(STATUS_INVALID_IMAGE_NE_FORMAT);
_CASE(STATUS_INVALID_IMAGE_NOT_MZ);
_CASE(STATUS_INVALID_IMAGE_PROTECT);
_CASE(STATUS_INVALID_IMAGE_WIN_16);
_CASE(STATUS_INVALID_INFO_CLASS);
_CASE(STATUS_INVALID_LDT_DESCRIPTOR);
_CASE(STATUS_INVALID_LDT_OFFSET);
_CASE(STATUS_INVALID_LDT_SIZE);
_CASE(STATUS_INVALID_LEVEL);
_CASE(STATUS_INVALID_LOCK_SEQUENCE);
_CASE(STATUS_INVALID_LOGON_HOURS);
_CASE(STATUS_INVALID_LOGON_TYPE);
_CASE(STATUS_INVALID_MEMBER);
_CASE(STATUS_INVALID_NETWORK_RESPONSE);
_CASE(STATUS_INVALID_OPLOCK_PROTOCOL);
_CASE(STATUS_INVALID_OWNER);
_CASE(STATUS_INVALID_PAGE_PROTECTION);
_CASE(STATUS_INVALID_PARAMETER);
_CASE(STATUS_INVALID_PARAMETER_1);
_CASE(STATUS_INVALID_PARAMETER_10);
_CASE(STATUS_INVALID_PARAMETER_11);
_CASE(STATUS_INVALID_PARAMETER_12);
_CASE(STATUS_INVALID_PARAMETER_2);
_CASE(STATUS_INVALID_PARAMETER_3);
_CASE(STATUS_INVALID_PARAMETER_4);
_CASE(STATUS_INVALID_PARAMETER_5);
_CASE(STATUS_INVALID_PARAMETER_6);
_CASE(STATUS_INVALID_PARAMETER_7);
_CASE(STATUS_INVALID_PARAMETER_8);
_CASE(STATUS_INVALID_PARAMETER_9);
_CASE(STATUS_INVALID_PARAMETER_MIX);
_CASE(STATUS_INVALID_PIPE_STATE);
_CASE(STATUS_INVALID_PLUGPLAY_DEVICE_PATH);
_CASE(STATUS_INVALID_PORT_ATTRIBUTES);
_CASE(STATUS_INVALID_PORT_HANDLE);
_CASE(STATUS_INVALID_PRIMARY_GROUP);
_CASE(STATUS_INVALID_QUOTA_LOWER);
_CASE(STATUS_INVALID_READ_MODE);
_CASE(STATUS_INVALID_SECURITY_DESCR);
_CASE(STATUS_INVALID_SERVER_STATE);
_CASE(STATUS_INVALID_SID);
_CASE(STATUS_INVALID_SUB_AUTHORITY);
_CASE(STATUS_INVALID_SYSTEM_SERVICE);
_CASE(STATUS_INVALID_UNWIND_TARGET);
_CASE(STATUS_INVALID_USER_BUFFER);
_CASE(STATUS_INVALID_VARIANT);
_CASE(STATUS_INVALID_VIEW_SIZE);
_CASE(STATUS_INVALID_VOLUME_LABEL);
_CASE(STATUS_INVALID_WORKSTATION);
_CASE(STATUS_IN_PAGE_ERROR);
_CASE(STATUS_IO_DEVICE_ERROR);
_CASE(STATUS_IO_PRIVILEGE_FAILED);
_CASE(STATUS_IO_REPARSE_DATA_INVALID);
_CASE(STATUS_IO_REPARSE_TAG_INVALID);
_CASE(STATUS_IO_REPARSE_TAG_MISMATCH);
_CASE(STATUS_IO_REPARSE_TAG_NOT_HANDLED);
_CASE(STATUS_IO_TIMEOUT);
_CASE(STATUS_IP_ADDRESS_CONFLICT1);
_CASE(STATUS_IP_ADDRESS_CONFLICT2);
_CASE(STATUS_JOURNAL_DELETE_IN_PROGRESS);
_CASE(STATUS_JOURNAL_ENTRY_DELETED);
_CASE(STATUS_JOURNAL_NOT_ACTIVE);
_CASE(STATUS_KERNEL_APC);
_CASE(STATUS_KEY_DELETED);
_CASE(STATUS_KEY_HAS_CHILDREN);
_CASE(STATUS_LAST_ADMIN);
_CASE(STATUS_LICENSE_QUOTA_EXCEEDED);
_CASE(STATUS_LICENSE_VIOLATION);
_CASE(STATUS_LINK_FAILED);
_CASE(STATUS_LINK_TIMEOUT);
_CASE(STATUS_LM_CROSS_ENCRYPTION_REQUIRED);
_CASE(STATUS_LOCAL_DISCONNECT);
_CASE(STATUS_LOCAL_USER_SESSION_KEY);
_CASE(STATUS_LOCK_NOT_GRANTED);
_CASE(STATUS_LOGIN_TIME_RESTRICTION);
_CASE(STATUS_LOGIN_WKSTA_RESTRICTION);
_CASE(STATUS_LOGON_FAILURE);
_CASE(STATUS_LOGON_NOT_GRANTED);
_CASE(STATUS_LOGON_SERVER_CONFLICT);
_CASE(STATUS_LOGON_SESSION_COLLISION);
_CASE(STATUS_LOGON_SESSION_EXISTS);
_CASE(STATUS_LOGON_TYPE_NOT_GRANTED);
_CASE(STATUS_LOG_FILE_FULL);
_CASE(STATUS_LOG_HARD_ERROR);
_CASE(STATUS_LONGJUMP);
_CASE(STATUS_LOST_WRITEBEHIND_DATA);
_CASE(STATUS_LPC_REPLY_LOST);
_CASE(STATUS_LUIDS_EXHAUSTED);
_CASE(STATUS_MAGAZINE_NOT_PRESENT);
_CASE(STATUS_MAPPED_ALIGNMENT);
_CASE(STATUS_MAPPED_FILE_SIZE_ZERO);
_CASE(STATUS_MARSHALL_OVERFLOW);
_CASE(STATUS_MEDIA_CHANGED);
_CASE(STATUS_MEDIA_CHECK);
_CASE(STATUS_MEDIA_WRITE_PROTECTED);
_CASE(STATUS_MEMBERS_PRIMARY_GROUP);
_CASE(STATUS_MEMBER_IN_ALIAS);
_CASE(STATUS_MEMBER_IN_GROUP);
_CASE(STATUS_MEMBER_NOT_IN_ALIAS);
_CASE(STATUS_MEMBER_NOT_IN_GROUP);
_CASE(STATUS_MEMORY_NOT_ALLOCATED);
_CASE(STATUS_MESSAGE_NOT_FOUND);
_CASE(STATUS_MISSING_SYSTEMFILE);
_CASE(STATUS_MORE_ENTRIES);
_CASE(STATUS_MORE_PROCESSING_REQUIRED);
_CASE(STATUS_MP_PROCESSOR_MISMATCH);
_CASE(STATUS_MULTIPLE_FAULT_VIOLATION);
_CASE(STATUS_MUTANT_LIMIT_EXCEEDED);
_CASE(STATUS_MUTANT_NOT_OWNED);
_CASE(STATUS_MUTUAL_AUTHENTICATION_FAILED);
_CASE(STATUS_NAME_TOO_LONG);
_CASE(STATUS_NETLOGON_NOT_STARTED);
_CASE(STATUS_NETWORK_ACCESS_DENIED);
_CASE(STATUS_NETWORK_BUSY);
_CASE(STATUS_NETWORK_CREDENTIAL_CONFLICT);
_CASE(STATUS_NETWORK_NAME_DELETED);
_CASE(STATUS_NETWORK_UNREACHABLE);
_CASE(STATUS_NET_WRITE_FAULT);
_CASE(STATUS_NOINTERFACE);
_CASE(STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT);
_CASE(STATUS_NOLOGON_SERVER_TRUST_ACCOUNT);
_CASE(STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT);
_CASE(STATUS_NONCONTINUABLE_EXCEPTION);
_CASE(STATUS_NONEXISTENT_EA_ENTRY);
_CASE(STATUS_NONEXISTENT_SECTOR);
_CASE(STATUS_NONE_MAPPED);
_CASE(STATUS_NOTIFY_CLEANUP);
_CASE(STATUS_NOTIFY_ENUM_DIR);
_CASE(STATUS_NOT_ALL_ASSIGNED);
_CASE(STATUS_NOT_A_DIRECTORY);
_CASE(STATUS_NOT_A_REPARSE_POINT);
_CASE(STATUS_NOT_CLIENT_SESSION);
_CASE(STATUS_NOT_COMMITTED);
_CASE(STATUS_NOT_EXPORT_FORMAT);
_CASE(STATUS_NOT_FOUND);
_CASE(STATUS_NOT_IMPLEMENTED);
_CASE(STATUS_NOT_LOCKED);
_CASE(STATUS_NOT_LOGON_PROCESS);
_CASE(STATUS_NOT_MAPPED_DATA);
_CASE(STATUS_NOT_MAPPED_VIEW);
_CASE(STATUS_NOT_REGISTRY_FILE);
_CASE(STATUS_NOT_SAME_DEVICE);
_CASE(STATUS_NOT_SERVER_SESSION);
_CASE(STATUS_NOT_SUPPORTED);
_CASE(STATUS_NOT_SUPPORTED_ON_SBS);
_CASE(STATUS_NOT_TINY_STREAM);
_CASE(STATUS_NO_BROWSER_SERVERS_FOUND);
_CASE(STATUS_NO_CALLBACK_ACTIVE);
_CASE(STATUS_NO_DATA_DETECTED);
_CASE(STATUS_NO_EAS_ON_FILE);
_CASE(STATUS_NO_EFS);
_CASE(STATUS_NO_EVENT_PAIR);
_CASE(STATUS_NO_GUID_TRANSLATION);
_CASE(STATUS_NO_IMPERSONATION_TOKEN);
_CASE(STATUS_NO_INHERITANCE);
_CASE(STATUS_NO_LDT);
_CASE(STATUS_NO_LOGON_SERVERS);
_CASE(STATUS_NO_LOG_SPACE);
_CASE(STATUS_NO_MATCH);
_CASE(STATUS_NO_MEDIA);
_CASE(STATUS_NO_MEDIA_IN_DEVICE);
_CASE(STATUS_NO_MEMORY);
_CASE(STATUS_NO_MORE_EAS);
_CASE(STATUS_NO_MORE_ENTRIES);
_CASE(STATUS_NO_MORE_FILES);
_CASE(STATUS_NO_MORE_MATCHES);
_CASE(STATUS_NO_PAGEFILE);
_CASE(STATUS_NO_QUOTAS_FOR_ACCOUNT);
_CASE(STATUS_NO_RECOVERY_POLICY);
_CASE(STATUS_NO_SECURITY_ON_OBJECT);
_CASE(STATUS_NO_SPOOL_SPACE);
_CASE(STATUS_NO_SUCH_ALIAS);
_CASE(STATUS_NO_SUCH_DEVICE);
_CASE(STATUS_NO_SUCH_DOMAIN);
_CASE(STATUS_NO_SUCH_FILE);
_CASE(STATUS_NO_SUCH_GROUP);
_CASE(STATUS_NO_SUCH_LOGON_SESSION);
_CASE(STATUS_NO_SUCH_MEMBER);
_CASE(STATUS_NO_SUCH_PACKAGE);
_CASE(STATUS_NO_SUCH_PRIVILEGE);
_CASE(STATUS_NO_SUCH_USER);
_CASE(STATUS_NO_TOKEN);
_CASE(STATUS_NO_TRACKING_SERVICE);
_CASE(STATUS_NO_TRUST_LSA_SECRET);
_CASE(STATUS_NO_TRUST_SAM_ACCOUNT);
_CASE(STATUS_NO_USER_KEYS);
_CASE(STATUS_NO_USER_SESSION_KEY);
_CASE(STATUS_NO_YIELD_PERFORMED);
_CASE(STATUS_NT_CROSS_ENCRYPTION_REQUIRED);
_CASE(STATUS_NULL_LM_PASSWORD);
_CASE(STATUS_OBJECTID_EXISTS);
_CASE(STATUS_OBJECT_NAME_COLLISION);
_CASE(STATUS_OBJECT_NAME_EXISTS);
_CASE(STATUS_OBJECT_NAME_INVALID);
_CASE(STATUS_OBJECT_NAME_NOT_FOUND);
_CASE(STATUS_OBJECT_PATH_INVALID);
_CASE(STATUS_OBJECT_PATH_NOT_FOUND);
_CASE(STATUS_OBJECT_PATH_SYNTAX_BAD);
_CASE(STATUS_OBJECT_TYPE_MISMATCH);
_CASE(STATUS_ONLY_IF_CONNECTED);
_CASE(STATUS_OPEN_FAILED);
_CASE(STATUS_OPLOCK_BREAK_IN_PROGRESS);
_CASE(STATUS_OPLOCK_NOT_GRANTED);
_CASE(STATUS_ORDINAL_NOT_FOUND);
_CASE(STATUS_PAGEFILE_CREATE_FAILED);
_CASE(STATUS_PAGEFILE_QUOTA);
_CASE(STATUS_PAGEFILE_QUOTA_EXCEEDED);
_CASE(STATUS_PAGE_FAULT_COPY_ON_WRITE);
_CASE(STATUS_PAGE_FAULT_DEMAND_ZERO);
_CASE(STATUS_PAGE_FAULT_GUARD_PAGE);
_CASE(STATUS_PAGE_FAULT_PAGING_FILE);
_CASE(STATUS_PAGE_FAULT_TRANSITION);
_CASE(STATUS_PARITY_ERROR);
_CASE(STATUS_PARTIAL_COPY);
_CASE(STATUS_PARTITION_FAILURE);
_CASE(STATUS_PASSWORD_EXPIRED);
_CASE(STATUS_PASSWORD_MUST_CHANGE);
_CASE(STATUS_PASSWORD_RESTRICTION);
_CASE(STATUS_PATH_NOT_COVERED);
_CASE(STATUS_PENDING);
_CASE(STATUS_PIPE_BROKEN);
_CASE(STATUS_PIPE_BUSY);
_CASE(STATUS_PIPE_CLOSING);
_CASE(STATUS_PIPE_CONNECTED);
_CASE(STATUS_PIPE_DISCONNECTED);
_CASE(STATUS_PIPE_EMPTY);
_CASE(STATUS_PIPE_LISTENING);
_CASE(STATUS_PIPE_NOT_AVAILABLE);
_CASE(STATUS_PLUGPLAY_NO_DEVICE);
_CASE(STATUS_PNP_BAD_MPS_TABLE);
_CASE(STATUS_PNP_IRQ_TRANSLATION_FAILED);
_CASE(STATUS_PNP_REBOOT_REQUIRED);
_CASE(STATUS_PNP_RESTART_ENUMERATION);
_CASE(STATUS_PNP_TRANSLATION_FAILED);
_CASE(STATUS_POLICY_OBJECT_NOT_FOUND);
_CASE(STATUS_POLICY_ONLY_IN_DS);
_CASE(STATUS_PORT_ALREADY_SET);
_CASE(STATUS_PORT_CONNECTION_REFUSED);
_CASE(STATUS_PORT_DISCONNECTED);
_CASE(STATUS_PORT_MESSAGE_TOO_LONG);
_CASE(STATUS_PORT_UNREACHABLE);
_CASE(STATUS_POSSIBLE_DEADLOCK);
_CASE(STATUS_POWER_STATE_INVALID);
_CASE(STATUS_PREDEFINED_HANDLE);
_CASE(STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED);
_CASE(STATUS_PRINT_CANCELLED);
_CASE(STATUS_PRINT_QUEUE_FULL);
_CASE(STATUS_PRIVILEGED_INSTRUCTION);
_CASE(STATUS_PRIVILEGE_NOT_HELD);
_CASE(STATUS_PROCEDURE_NOT_FOUND);
_CASE(STATUS_PROCESS_IS_TERMINATING);
_CASE(STATUS_PROFILING_AT_LIMIT);
_CASE(STATUS_PROFILING_NOT_STARTED);
_CASE(STATUS_PROFILING_NOT_STOPPED);
_CASE(STATUS_PROPSET_NOT_FOUND);
_CASE(STATUS_PROTOCOL_UNREACHABLE);
_CASE(STATUS_PWD_HISTORY_CONFLICT);
_CASE(STATUS_PWD_TOO_RECENT);
_CASE(STATUS_PWD_TOO_SHORT);
_CASE(STATUS_QUOTA_EXCEEDED);
_CASE(STATUS_QUOTA_LIST_INCONSISTENT);
_CASE(STATUS_RANGE_LIST_CONFLICT);
_CASE(STATUS_RANGE_NOT_FOUND);
_CASE(STATUS_RANGE_NOT_LOCKED);
_CASE(STATUS_RDP_PROTOCOL_ERROR);
_CASE(STATUS_RECEIVE_EXPEDITED);
_CASE(STATUS_RECEIVE_PARTIAL);
_CASE(STATUS_RECEIVE_PARTIAL_EXPEDITED);
_CASE(STATUS_RECOVERY_FAILURE);
_CASE(STATUS_REDIRECTOR_HAS_OPEN_HANDLES);
_CASE(STATUS_REDIRECTOR_NOT_STARTED);
_CASE(STATUS_REDIRECTOR_PAUSED);
_CASE(STATUS_REDIRECTOR_STARTED);
_CASE(STATUS_REGISTRY_CORRUPT);
_CASE(STATUS_REGISTRY_IO_FAILED);
_CASE(STATUS_REGISTRY_QUOTA_LIMIT);
_CASE(STATUS_REGISTRY_RECOVERED);
_CASE(STATUS_REG_NAT_CONSUMPTION);
_CASE(STATUS_REINITIALIZATION_NEEDED);
_CASE(STATUS_REMOTE_DISCONNECT);
_CASE(STATUS_REMOTE_NOT_LISTENING);
_CASE(STATUS_REMOTE_RESOURCES);
_CASE(STATUS_REMOTE_SESSION_LIMIT);
_CASE(STATUS_REMOTE_STORAGE_MEDIA_ERROR);
_CASE(STATUS_REMOTE_STORAGE_NOT_ACTIVE);
_CASE(STATUS_REPARSE);
_CASE(STATUS_REPARSE_ATTRIBUTE_CONFLICT);
_CASE(STATUS_REPARSE_OBJECT);
_CASE(STATUS_REPARSE_POINT_NOT_RESOLVED);
_CASE(STATUS_REPLY_MESSAGE_MISMATCH);
_CASE(STATUS_REQUEST_ABORTED);
_CASE(STATUS_REQUEST_NOT_ACCEPTED);
_CASE(STATUS_RESOURCE_DATA_NOT_FOUND);
_CASE(STATUS_RESOURCE_LANG_NOT_FOUND);
_CASE(STATUS_RESOURCE_NAME_NOT_FOUND);
_CASE(STATUS_RESOURCE_NOT_OWNED);
_CASE(STATUS_RESOURCE_REQUIREMENTS_CHANGED);
_CASE(STATUS_RESOURCE_TYPE_NOT_FOUND);
_CASE(STATUS_RETRY);
_CASE(STATUS_REVISION_MISMATCH);
_CASE(STATUS_RXACT_COMMITTED);
_CASE(STATUS_RXACT_COMMIT_FAILURE);
_CASE(STATUS_RXACT_COMMIT_NECESSARY);
_CASE(STATUS_RXACT_INVALID_STATE);
_CASE(STATUS_RXACT_STATE_CREATED);
_CASE(STATUS_SAM_INIT_FAILURE);
_CASE(STATUS_SAM_NEED_BOOTKEY_FLOPPY);
_CASE(STATUS_SAM_NEED_BOOTKEY_PASSWORD);
_CASE(STATUS_SECRET_TOO_LONG);
_CASE(STATUS_SECTION_NOT_EXTENDED);
_CASE(STATUS_SECTION_NOT_IMAGE);
_CASE(STATUS_SECTION_PROTECTION);
_CASE(STATUS_SECTION_TOO_BIG);
_CASE(STATUS_SEGMENT_NOTIFICATION);
_CASE(STATUS_SEMAPHORE_LIMIT_EXCEEDED);
_CASE(STATUS_SERIAL_COUNTER_TIMEOUT);
_CASE(STATUS_SERIAL_MORE_WRITES);
_CASE(STATUS_SERIAL_NO_DEVICE_INITED);
_CASE(STATUS_SERVER_DISABLED);
_CASE(STATUS_SERVER_HAS_OPEN_HANDLES);
_CASE(STATUS_SERVER_NOT_DISABLED);
_CASE(STATUS_SERVER_SID_MISMATCH);
_CASE(STATUS_SERVICE_NOTIFICATION);
_CASE(STATUS_SETMARK_DETECTED);
_CASE(STATUS_SHARED_IRQ_BUSY);
_CASE(STATUS_SHARED_POLICY);
_CASE(STATUS_SHARING_PAUSED);
_CASE(STATUS_SHARING_VIOLATION);
_CASE(STATUS_SINGLE_STEP);
_CASE(STATUS_SOME_NOT_MAPPED);
_CASE(STATUS_SOURCE_ELEMENT_EMPTY);
_CASE(STATUS_SPECIAL_ACCOUNT);
_CASE(STATUS_SPECIAL_GROUP);
_CASE(STATUS_SPECIAL_USER);
_CASE(STATUS_STACK_OVERFLOW);
_CASE(STATUS_STACK_OVERFLOW_READ);
_CASE(STATUS_SUCCESS);
_CASE(STATUS_SUSPEND_COUNT_EXCEEDED);
_CASE(STATUS_SYNCHRONIZATION_REQUIRED);
_CASE(STATUS_SYSTEM_IMAGE_BAD_SIGNATURE);
_CASE(STATUS_SYSTEM_PROCESS_TERMINATED);
_CASE(STATUS_THREAD_IS_TERMINATING);
_CASE(STATUS_THREAD_NOT_IN_PROCESS);
_CASE(STATUS_THREAD_WAS_SUSPENDED);
_CASE(STATUS_TIMEOUT);
_CASE(STATUS_TIMER_NOT_CANCELED);
_CASE(STATUS_TIMER_RESOLUTION_NOT_SET);
_CASE(STATUS_TIMER_RESUME_IGNORED);
_CASE(STATUS_TIME_DIFFERENCE_AT_DC);
_CASE(STATUS_TOKEN_ALREADY_IN_USE);
_CASE(STATUS_TOO_LATE);
_CASE(STATUS_TOO_MANY_ADDRESSES);
_CASE(STATUS_TOO_MANY_COMMANDS);
_CASE(STATUS_TOO_MANY_CONTEXT_IDS);
_CASE(STATUS_TOO_MANY_GUIDS_REQUESTED);
_CASE(STATUS_TOO_MANY_LINKS);
_CASE(STATUS_TOO_MANY_LUIDS_REQUESTED);
_CASE(STATUS_TOO_MANY_NAMES);
_CASE(STATUS_TOO_MANY_NODES);
_CASE(STATUS_TOO_MANY_OPENED_FILES);
_CASE(STATUS_TOO_MANY_PAGING_FILES);
_CASE(STATUS_TOO_MANY_SECRETS);
_CASE(STATUS_TOO_MANY_SESSIONS);
_CASE(STATUS_TOO_MANY_SIDS);
_CASE(STATUS_TOO_MANY_THREADS);
_CASE(STATUS_TRANSACTION_ABORTED);
_CASE(STATUS_TRANSACTION_INVALID_ID);
_CASE(STATUS_TRANSACTION_INVALID_TYPE);
_CASE(STATUS_TRANSACTION_NO_MATCH);
_CASE(STATUS_TRANSACTION_NO_RELEASE);
_CASE(STATUS_TRANSACTION_RESPONDED);
_CASE(STATUS_TRANSACTION_TIMED_OUT);
_CASE(STATUS_TRANSLATION_COMPLETE);
_CASE(STATUS_TRANSPORT_FULL);
_CASE(STATUS_TRUSTED_DOMAIN_FAILURE);
_CASE(STATUS_TRUSTED_RELATIONSHIP_FAILURE);
_CASE(STATUS_TRUST_FAILURE);
_CASE(STATUS_UNABLE_TO_DECOMMIT_VM);
_CASE(STATUS_UNABLE_TO_DELETE_SECTION);
_CASE(STATUS_UNABLE_TO_FREE_VM);
_CASE(STATUS_UNABLE_TO_LOCK_MEDIA);
_CASE(STATUS_UNABLE_TO_UNLOAD_MEDIA);
_CASE(STATUS_UNDEFINED_CHARACTER);
_CASE(STATUS_UNEXPECTED_IO_ERROR);
_CASE(STATUS_UNEXPECTED_MM_CREATE_ERR);
_CASE(STATUS_UNEXPECTED_MM_EXTEND_ERR);
_CASE(STATUS_UNEXPECTED_MM_MAP_ERROR);
_CASE(STATUS_UNEXPECTED_NETWORK_ERROR);
_CASE(STATUS_UNHANDLED_EXCEPTION);
_CASE(STATUS_UNKNOWN_REVISION);
_CASE(STATUS_UNMAPPABLE_CHARACTER);
_CASE(STATUS_UNRECOGNIZED_MEDIA);
_CASE(STATUS_UNRECOGNIZED_VOLUME);
_CASE(STATUS_UNSUCCESSFUL);
_CASE(STATUS_UNSUPPORTED_COMPRESSION);
_CASE(STATUS_UNWIND);
_CASE(STATUS_USER_APC);
_CASE(STATUS_USER_EXISTS);
_CASE(STATUS_USER_MAPPED_FILE);
_CASE(STATUS_USER_SESSION_DELETED);
_CASE(STATUS_VALIDATE_CONTINUE);
_CASE(STATUS_VARIABLE_NOT_FOUND);
_CASE(STATUS_VDM_HARD_ERROR);
_CASE(STATUS_VERIFY_REQUIRED);
_CASE(STATUS_VIRTUAL_CIRCUIT_CLOSED);
_CASE(STATUS_VOLUME_DISMOUNTED);
_CASE(STATUS_VOLUME_MOUNTED);
_CASE(STATUS_VOLUME_NOT_UPGRADED);
_CASE(STATUS_WAIT_1);
_CASE(STATUS_WAIT_2);
_CASE(STATUS_WAIT_3);
_CASE(STATUS_WAIT_63);
_CASE(STATUS_WAKE_SYSTEM);
_CASE(STATUS_WAKE_SYSTEM_DEBUGGER);
_CASE(STATUS_WAS_LOCKED);
_CASE(STATUS_WAS_UNLOCKED);
_CASE(STATUS_WMI_GUID_NOT_FOUND);
_CASE(STATUS_WMI_INSTANCE_NOT_FOUND);
_CASE(STATUS_WMI_ITEMID_NOT_FOUND);
_CASE(STATUS_WMI_NOT_SUPPORTED);
_CASE(STATUS_WMI_READ_ONLY);
_CASE(STATUS_WMI_SET_FAILURE);
_CASE(STATUS_WMI_TRY_AGAIN);
_CASE(STATUS_WORKING_SET_LIMIT_RANGE);
_CASE(STATUS_WORKING_SET_QUOTA);
_CASE(STATUS_WOW_ASSERTION);
_CASE(STATUS_WRONG_EFS);
_CASE(STATUS_WRONG_PASSWORD);
_CASE(STATUS_WRONG_PASSWORD_CORE);
_CASE(STATUS_WRONG_VOLUME);
_CASE(STATUS_WX86_BREAKPOINT);
_CASE(STATUS_WX86_CONTINUE);
_CASE(STATUS_WX86_CREATEWX86TIB);
_CASE(STATUS_WX86_EXCEPTION_CHAIN);
_CASE(STATUS_WX86_EXCEPTION_CONTINUE);
_CASE(STATUS_WX86_EXCEPTION_LASTCHANCE);
_CASE(STATUS_WX86_FLOAT_STACK_CHECK);
_CASE(STATUS_WX86_INTERNAL_ERROR);
_CASE(STATUS_WX86_SINGLE_STEP);
_CASE(STATUS_WX86_UNSIMULATE);
default: return "STATUS_UNKNOWN";
}
#undef _CASE
}

1
src/CxbxKrnl/EmuFile.h
View File

@ -162,6 +162,7 @@ bool IsEmuHandle(HANDLE Handle);
EmuHandle* HandleToEmuHandle(HANDLE Handle);
HANDLE EmuHandleToHandle(EmuHandle* emuHandle);
CHAR* NtStatusToString(IN NTSTATUS Status);
char SymbolicLinkToDriveLetter(std::string aSymbolicLinkName);
EmuNtSymbolicLinkObject* FindNtSymbolicLinkObjectByVolumeLetter(const char VolumeLetter);

39
src/CxbxKrnl/EmuKrnlKe.cpp
View File

@ -51,6 +51,7 @@ namespace NtDll
#include "CxbxKrnl.h" // For CxbxKrnlCleanup
#include "Emu.h" // For EmuWarning()
#include "EmuFile.h" // For IsEmuHandle(), NtStatusToString()
#include <chrono>
#include <thread>
@ -113,7 +114,7 @@ XBSYSAPI EXPORTNUM(95) xboxkrnl::VOID NTAPI xboxkrnl::KeBugCheck
IN ULONG BugCheckMode
)
{
LOG_FUNC_ONE_ARG(BugCheckMode);
LOG_FORWARD("KeBugCheckEx");
KeBugCheckEx(BugCheckMode, 0, 0, 0, 0);
}
@ -182,9 +183,9 @@ XBSYSAPI EXPORTNUM(99) xboxkrnl::NTSTATUS NTAPI xboxkrnl::KeDelayExecutionThread
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG_OUT(WaitMode)
LOG_FUNC_ARG(WaitMode)
LOG_FUNC_ARG(Alertable)
LOG_FUNC_ARG_OUT(Interval)
LOG_FUNC_ARG(Interval)
LOG_FUNC_END;
NTSTATUS ret = NtDll::NtDelayExecution(Alertable, (NtDll::LARGE_INTEGER*)Interval);
@ -557,9 +558,35 @@ XBSYSAPI EXPORTNUM(158) xboxkrnl::NTSTATUS xboxkrnl::KeWaitForMultipleObjects
LOG_FUNC_ARG(WaitBlockArray)
LOG_FUNC_END;
EmuWarning("EmuKrnl: Redirecting KeWaitForMultipleObjects to NtWaitForMultipleObjectsEx");
// Unused arguments : WaitReason, WaitMode, WaitBlockArray
NTSTATUS ret = NtWaitForMultipleObjectsEx(Count, Object, WaitType, WaitMode, Alertable, Timeout);
NTSTATUS ret = STATUS_SUCCESS;
for (uint i = 0; i < Count; i++)
if (IsEmuHandle(Object[i]))
{
ret = WAIT_FAILED;
EmuWarning("WaitFor EmuHandle not supported!");
break;
}
if (ret == STATUS_SUCCESS)
{
// TODO : What should we do with the (currently ignored) WaitMode?
ret = NtDll::NtWaitForMultipleObjects(
Count,
Object,
(NtDll::OBJECT_WAIT_TYPE)WaitType,
Alertable,
(NtDll::PLARGE_INTEGER)Timeout);
if (Count == 1)
DbgPrintf("Finished waiting for 0x%.08X\n", Object[0]);
if (ret == WAIT_FAILED)
EmuWarning("KeWaitForMultipleObjects failed! (%s)", NtStatusToString(ret));
}
RETURN(ret);
}
@ -590,5 +617,3 @@ XBSYSAPI EXPORTNUM(159) xboxkrnl::NTSTATUS xboxkrnl::KeWaitForSingleObject
RETURN(ret);
}

1014
src/CxbxKrnl/EmuKrnlNt.cpp
View File

File diff suppressed because it is too large Load Diff

140
src/CxbxKrnl/EmuKrnlPs.cpp
View File

@ -58,9 +58,9 @@ namespace NtDll
// PsCreateSystemThread proxy parameters
typedef struct _PCSTProxyParam
{
IN PVOID StartContext1;
IN PVOID StartContext2;
IN PVOID StartRoutine;
IN PVOID StartContext;
IN PVOID SystemRoutine;
IN BOOL StartSuspended;
IN HANDLE hStartedEvent;
}
@ -73,17 +73,19 @@ extern int g_iThreadNotificationCount = 0;
// Separate function for logging, otherwise in PCSTProxy __try wont work (Compiler Error C2712)
void PCSTProxy_log
(
uint32 StartContext1,
uint32 StartContext2,
uint32 StartRoutine,
PVOID StartRoutine,
PVOID StartContext,
PVOID SystemRoutine,
BOOL StartSuspended,
HANDLE hStartedEvent
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG(StartContext1)
LOG_FUNC_ARG(StartContext2)
LOG_FUNC_ARG(StartRoutine)
LOG_FUNC_ARG(StartContext)
LOG_FUNC_ARG(SystemRoutine)
LOG_FUNC_ARG(StartSuspended)
LOG_FUNC_ARG(hStartedEvent)
LOG_FUNC_END;
}
@ -98,16 +100,16 @@ static unsigned int WINAPI PCSTProxy
{
PCSTProxyParam *iPCSTProxyParam = (PCSTProxyParam*)Parameter;
uint32 StartContext1 = (uint32)iPCSTProxyParam->StartContext1;
uint32 StartContext2 = (uint32)iPCSTProxyParam->StartContext2;
uint32 StartRoutine = (uint32)iPCSTProxyParam->StartRoutine;
BOOL StartSuspended = (BOOL)iPCSTProxyParam->StartSuspended;
HANDLE hStartedEvent = (HANDLE)iPCSTProxyParam->hStartedEvent;
PVOID StartRoutine = iPCSTProxyParam->StartRoutine;
PVOID StartContext = iPCSTProxyParam->StartContext;
PVOID SystemRoutine = iPCSTProxyParam->SystemRoutine;
BOOL StartSuspended = iPCSTProxyParam->StartSuspended;
HANDLE hStartedEvent = iPCSTProxyParam->hStartedEvent;
// Once deleted, unable to directly access iPCSTProxyParam in remainder of function.
delete iPCSTProxyParam;
PCSTProxy_log(StartContext1, StartContext2, StartRoutine, StartSuspended, hStartedEvent);
PCSTProxy_log(StartRoutine, StartContext, SystemRoutine, StartSuspended, hStartedEvent);
if (StartSuspended == TRUE)
SuspendThread(GetCurrentThread());
@ -127,11 +129,7 @@ static unsigned int WINAPI PCSTProxy
DbgPrintf("EmuKrnl (0x%X): Calling pfnNotificationRoutine[%d] (0x%.08X)\n", GetCurrentThreadId(), g_iThreadNotificationCount, pfnNotificationRoutine);
pfnNotificationRoutine(TRUE);
}
}
@ -140,15 +138,31 @@ static unsigned int WINAPI PCSTProxy
{
SetEvent(hStartedEvent);
__asm
if (SystemRoutine != NULL)
{
mov esi, StartRoutine
push StartContext2
push StartContext1
push offset callComplete
lea ebp, [esp - 4]
jmp near esi
// Given the non-standard calling convention (requiring
// the first argument in ebp+4) we need the below __asm.
//
// Otherwise, this call would have looked something like this :
// ((xboxkrnl::PKSYSTEM_ROUTINE)SystemRoutine)(
// (xboxkrnl::PKSTART_ROUTINE)StartRoutine,
// StartContext);
__asm
{
mov esi, SystemRoutine
push StartContext
push StartRoutine
push offset callComplete
lea ebp, [esp - 4]
jmp near esi
}
}
else
// Handle cases where we have a StartRoutine, not a SystemRoutine :
if (StartRoutine != NULL)
((xboxkrnl::PKSTART_ROUTINE)StartRoutine)(StartContext);
else
EmuWarning("No routines to start!");
}
__except (EmuException(GetExceptionInformation()))
{
@ -157,8 +171,6 @@ static unsigned int WINAPI PCSTProxy
callComplete:
// call thread notification routine(s)
if (g_iThreadNotificationCount != 0)
{
@ -172,11 +184,7 @@ callComplete:
DbgPrintf("EmuKrnl (0x%X): Calling pfnNotificationRoutine[%d] (0x%.08X)\n", GetCurrentThreadId(), g_iThreadNotificationCount, pfnNotificationRoutine);
pfnNotificationRoutine(FALSE);
}
}
@ -186,49 +194,83 @@ callComplete:
}
#pragma warning(pop)
// ******************************************************************
// * 0x00FE - PsCreateSystemThread
// ******************************************************************
XBSYSAPI EXPORTNUM(254) xboxkrnl::NTSTATUS NTAPI xboxkrnl::PsCreateSystemThread
(
OUT PHANDLE ThreadHandle,
OUT PHANDLE ThreadId OPTIONAL,
IN PKSTART_ROUTINE StartRoutine,
IN PVOID StartContext,
IN BOOLEAN DebuggerThread
)
{
LOG_FORWARD("PsCreateSystemThreadEx");
return PsCreateSystemThreadEx(
/*OUT*/ThreadHandle,
/*ThreadExtensionSize=*/0,
/*KernelStackSize=*/0,
/*TlsDataSize=*/0,
/*OUT*/ThreadId,
/*StartRoutine=*/StartRoutine,
StartContext,
/*CreateSuspended=*/FALSE,
/*DebuggerThread=*/DebuggerThread,
/*SystemRoutine=*/NULL // This bypasses XapiThreadStartup - see usage in PCSTProxy
);
}
// ******************************************************************
// * 0x00FF - PsCreateSystemThreadEx
// ******************************************************************
// Creates a system thread.
// ThreadHandle: Receives the thread handle
// ObjectAttributes: Unsure how this works (everything I've seen uses NULL)
// ThreadExtensionSize: Unsure how this works (everything I've seen uses 0)
// KernelStackSize: Size of the allocation for both stack and TLS data
// TlsDataSize: Size within KernelStackSize to use as TLS data
// ThreadId: Receives the thread ID number
// StartContext1: Parameter 1 to StartRoutine
// StartContext2: Parameter 2 to StartRoutine
// StartRoutine: Called when the thread is created (by XapiThreadStartup)
// StartContext: Parameter StartRoutine
// CreateSuspended: TRUE to create the thread as a suspended thread
// DebugStack: TRUE to allocate the stack from Debug Kit memory
// StartRoutine: Called when the thread is created
// DebuggerThread: TRUE to allocate the stack from Debug Kit memory
// SystemRoutine: System function (normally XapiThreadStartup) called when the thread is created
//
// New to the XBOX.
XBSYSAPI EXPORTNUM(255) xboxkrnl::NTSTATUS NTAPI xboxkrnl::PsCreateSystemThreadEx
(
OUT PHANDLE ThreadHandle,
IN ULONG ThreadExtraSize,
IN ULONG ThreadExtensionSize,
IN ULONG KernelStackSize,
IN ULONG TlsDataSize,
OUT PULONG ThreadId OPTIONAL,
IN PVOID StartContext1,
IN PVOID StartContext2,
OUT PHANDLE ThreadId OPTIONAL,
IN PKSTART_ROUTINE StartRoutine,
IN PVOID StartContext,
IN BOOLEAN CreateSuspended,
IN BOOLEAN DebugStack,
IN PKSTART_ROUTINE StartRoutine
IN BOOLEAN DebuggerThread,
IN PKSYSTEM_ROUTINE SystemRoutine OPTIONAL
)
{
LOG_FUNC_BEGIN
LOG_FUNC_ARG_OUT(ThreadHandle)
LOG_FUNC_ARG(ThreadExtraSize)
LOG_FUNC_ARG(ThreadExtensionSize)
LOG_FUNC_ARG(KernelStackSize)
LOG_FUNC_ARG(TlsDataSize)
LOG_FUNC_ARG_OUT(ThreadId)
LOG_FUNC_ARG(StartContext1)
LOG_FUNC_ARG(StartContext2)
LOG_FUNC_ARG(CreateSuspended)
LOG_FUNC_ARG(DebugStack)
LOG_FUNC_ARG(StartRoutine)
LOG_FUNC_ARG(StartContext)
LOG_FUNC_ARG(CreateSuspended)
LOG_FUNC_ARG(DebuggerThread)
LOG_FUNC_ARG(SystemRoutine)
LOG_FUNC_END;
// TODO : Arguments to use : KernelStackSize, TlsDataSize, DebuggerThread
// TODO : Fill KernelStackSize like this :
// if (KernelStackSize == 0)
// KernelStackSize = XeImageHeader()->SizeOfStackCommit;
static bool bFirstTime = false;
// create thread, using our special proxy technique
@ -238,9 +280,9 @@ XBSYSAPI EXPORTNUM(255) xboxkrnl::NTSTATUS NTAPI xboxkrnl::PsCreateSystemThreadE
// PCSTProxy is responsible for cleaning up this pointer
::PCSTProxyParam *iPCSTProxyParam = new ::PCSTProxyParam();
iPCSTProxyParam->StartContext1 = StartContext1;
iPCSTProxyParam->StartContext2 = StartContext2;
iPCSTProxyParam->StartRoutine = StartRoutine;
iPCSTProxyParam->StartContext = StartContext;
iPCSTProxyParam->SystemRoutine = SystemRoutine; // NULL, XapiThreadStartup or unknown?
iPCSTProxyParam->StartSuspended = CreateSuspended;
iPCSTProxyParam->hStartedEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
@ -265,7 +307,7 @@ XBSYSAPI EXPORTNUM(255) xboxkrnl::NTSTATUS NTAPI xboxkrnl::PsCreateSystemThreadE
}
if (ThreadId != NULL)
*ThreadId = dwThreadId;
*ThreadId = (xboxkrnl::HANDLE)dwThreadId;
}
RETURN(STATUS_SUCCESS);

2
src/CxbxKrnl/KernelThunk.cpp
View File

@ -319,7 +319,7 @@ extern "C" CXBXKRNL_API uint32 CxbxKrnl_KernelThunkTable[379] =
(uint32)PANIC(0x00FB), // 0x00FB (251) ObfReferenceObject
(uint32)FUNC(&xboxkrnl::PhyGetLinkState), // 0x00FC (252)
(uint32)FUNC(&xboxkrnl::PhyInitialize), // 0x00FD (253)
(uint32)PANIC(0x00FE), // 0x00FE (254) PsCreateSystemThread
(uint32)FUNC(&xboxkrnl::PsCreateSystemThread), // 0x00FE (254)
(uint32)FUNC(&xboxkrnl::PsCreateSystemThreadEx), // 0x00FF (255)
(uint32)PANIC(0x0100), // 0x0100 (256) PsQueryStatistics
(uint32)PANIC(0x0101), // 0x0101 (257) PsSetCreateThreadNotifyRoutine