return TRUE;
}
-- return IMAGE_SUBSYSTEM_WINDOWS_CUI == ProcessPeb.ImageSubSystem;
++ return IMAGE_SUBSYSTEM_WINDOWS_CUI == ProcessPeb.ImageSubsystem;
}
HANDLE ThreadHandle;
/* Write common data */
- DebugEvent->dwProcessId = (ULONG_PTR)WaitStateChange->
+ DebugEvent->dwProcessId = (DWORD)WaitStateChange->
AppClientId.UniqueProcess;
- DebugEvent->dwThreadId = (ULONG_PTR)WaitStateChange->AppClientId.UniqueThread;
+ DebugEvent->dwThreadId = (DWORD)WaitStateChange->AppClientId.UniqueThread;
/* Check what kind of even this is */
switch (WaitStateChange->NewState)
/* Save the image name from the TIB */
DebugEvent->u.LoadDll.lpImageName =
((PTEB)ThreadBasicInfo.TebBaseAddress)->
- Tib.ArbitraryUserPointer;
+ NtTib.ArbitraryUserPointer;
}
else
{
ULONG ArgumentLength)
{
/* Return with the result of the callback function */
++ USER_CALL *KernelCallbackTable = NtCurrentPeb()->KernelCallbackTable;
ZwCallbackReturn(NULL,
0,
-- ((USER_CALL)(NtCurrentPeb()->KernelCallbackTable[Index]))
-- (Argument, ArgumentLength));
++ KernelCallbackTable[Index](Argument, ArgumentLength));
}
/* initalize peb lock support */
RtlInitializeCriticalSection(&PebLock);
Peb->FastPebLock = &PebLock;
-- Peb->FastPebLockRoutine = (PPEBLOCKROUTINE)RtlEnterCriticalSection;
-- Peb->FastPebUnlockRoutine = (PPEBLOCKROUTINE)RtlLeaveCriticalSection;
/* initialize tls bitmaps */
RtlInitializeBitMap(&TlsBitMap, Peb->TlsBitmapBits, TLS_MINIMUM_AVAILABLE);
InsertTailList(&Peb->Ldr->InLoadOrderModuleList,
&NtModule->InLoadOrderLinks);
InsertTailList(&Peb->Ldr->InInitializationOrderModuleList,
- &NtModule->InInitializationOrderLinks);
+ &NtModule->InInitializationOrderModuleList);
/* add entry for executable (becomes first list entry) */
ExeModule = (PLDR_DATA_TABLE_ENTRY)
* PURPOSE: Process startup for PE executables
* PROGRAMMERS: Jean Michault
* Rex Jolliff (rex@lvcablemodem.com)
+ * Michael Martin
*/
/*
OUT PVOID *BaseAddress OPTIONAL);
static NTSTATUS LdrpAttachProcess(VOID);
static VOID LdrpDetachProcess(BOOLEAN UnloadAll);
+static NTSTATUS LdrpUnloadModule(PLDR_DATA_TABLE_ENTRY Module, BOOLEAN Unload);
NTSTATUS find_actctx_dll( LPCWSTR libname, WCHAR *fulldosname );
NTSTATUS create_module_activation_context( LDR_DATA_TABLE_ENTRY *module );
ASSERT(Module);
memset(Module, 0, sizeof(LDR_DATA_TABLE_ENTRY));
Module->DllBase = (PVOID)ImageBase;
- Module->EntryPoint = (PVOID)(ULONG_PTR)NTHeaders->OptionalHeader.AddressOfEntryPoint;
+ Module->EntryPoint = (PVOID)NTHeaders->OptionalHeader.AddressOfEntryPoint;
if (Module->EntryPoint != 0)
Module->EntryPoint = (PVOID)((ULONG_PTR)Module->EntryPoint + (ULONG_PTR)Module->DllBase);
Module->SizeOfImage = LdrpGetResidentSize(NTHeaders);
IN BOOLEAN MapAsDataFile,
OUT PHANDLE SectionHandle)
{
- WCHAR SearchPathBuffer[MAX_PATH];
+ WCHAR *SearchPathBuffer = NULL;
+ WCHAR *ImagePathNameBufferPtr = NULL;
WCHAR DosName[MAX_PATH];
UNICODE_STRING FullNtFileName;
+ UNICODE_STRING PathEnvironmentVar_U;
+ UNICODE_STRING PathName_U;
OBJECT_ATTRIBUTES FileObjectAttributes;
HANDLE FileHandle;
char BlockBuffer [1024];
IO_STATUS_BLOCK IoStatusBlock;
NTSTATUS Status;
ULONG len;
+ ULONG ImagePathLen;
DPRINT("LdrpMapDllImageFile() called\n");
if (SearchPath == NULL)
{
/* get application running path */
+ ImagePathNameBufferPtr = NtCurrentPeb()->ProcessParameters->ImagePathName.Buffer;
- wcscpy (SearchPathBuffer, NtCurrentPeb()->ProcessParameters->ImagePathName.Buffer);
+ /* Length of ImagePathName */
+ ImagePathLen = wcslen(ImagePathNameBufferPtr);
- len = wcslen (SearchPathBuffer);
+ /* Subtract application name leaveing only the directory length */
+ while (ImagePathLen && ImagePathNameBufferPtr[ImagePathLen - 1] != L'\\')
+ ImagePathLen--;
- while (len && SearchPathBuffer[len - 1] != L'\\')
- len--;
+ /* Length of directory + semicolon */
+ len = ImagePathLen + 1;
- if (len) SearchPathBuffer[len-1] = L'\0';
+ /* Length of SystemRoot + "//system32" + semicolon*/
+ len += wcslen(SharedUserData->NtSystemRoot) + 10;
+ /* Length of SystemRoot + semicolon */
+ len += wcslen(SharedUserData->NtSystemRoot) + 1;
- wcscat (SearchPathBuffer, L";");
+ RtlInitUnicodeString (&PathName_U, L"PATH");
+ PathEnvironmentVar_U.Length = 0;
+ PathEnvironmentVar_U.MaximumLength = 0;
+ PathEnvironmentVar_U.Buffer = NULL;
+
+ /* Get the path environment variable */
+ Status = RtlQueryEnvironmentVariable_U(NULL, &PathName_U, &PathEnvironmentVar_U);
+
+ /* Check that valid information was returned */
+ if ((Status == STATUS_BUFFER_TOO_SMALL) && (PathEnvironmentVar_U.Length > 0))
+ {
+ /* Allocate memory for the path env var */
+ PathEnvironmentVar_U.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, PathEnvironmentVar_U.Length + sizeof(WCHAR));
+ if (!PathEnvironmentVar_U.Buffer)
+ {
+ DPRINT1("Fatal! Out of Memory!!\n");
+ return STATUS_NO_MEMORY;
+ }
+ PathEnvironmentVar_U.MaximumLength = PathEnvironmentVar_U.Length + sizeof(WCHAR);
+
+ /* Retry */
+ Status = RtlQueryEnvironmentVariable_U(NULL, &PathName_U, &PathEnvironmentVar_U);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Unable to get path environment string!\n");
+ ASSERT(FALSE);
+ }
+ /* Length of path evn var + semicolon */
+ len += (PathEnvironmentVar_U.Length / sizeof(WCHAR)) + 1;
+ }
+ /* Allocate the size needed to hold all the above paths + period */
+ SearchPathBuffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, (len + 2) * sizeof(WCHAR));
+ if (!SearchPathBuffer)
+ {
+ DPRINT1("Fatal! Out of Memory!!\n");
+ return STATUS_NO_MEMORY;
+ }
+
+ wcsncpy(SearchPathBuffer, ImagePathNameBufferPtr, ImagePathLen);
+ wcscat (SearchPathBuffer, L";");
wcscat (SearchPathBuffer, SharedUserData->NtSystemRoot);
wcscat (SearchPathBuffer, L"\\system32;");
wcscat (SearchPathBuffer, SharedUserData->NtSystemRoot);
- wcscat (SearchPathBuffer, L";.");
+ wcscat (SearchPathBuffer, L";");
+
+ if (PathEnvironmentVar_U.Buffer)
+ {
+ wcscat (SearchPathBuffer, PathEnvironmentVar_U.Buffer);
+ wcscat (SearchPathBuffer, L";");
+ RtlFreeHeap(RtlGetProcessHeap(), 0, PathEnvironmentVar_U.Buffer);
+ }
+ wcscat (SearchPathBuffer, L".");
SearchPath = SearchPathBuffer;
}
if(Status == STATUS_SUCCESS)
DPRINT("found %S for %S\n", DosName,DllName->Buffer);
else
- return STATUS_DLL_NOT_FOUND;
+ return STATUS_DLL_NOT_FOUND;
}
if (!RtlDosPathNameToNtPathName_U (DosName,
{
NTSTATUS Status;
PLDR_DATA_TABLE_ENTRY Module;
-
+ ULONG_PTR cookie;
PPEB Peb = NtCurrentPeb();
- TRACE_LDR("LdrLoadDll, loading %wZ%s%S\n",
+ TRACE_LDR("LdrLoadDll loading %wZ%S%S with flags %d\n",
Name,
SearchPath ? L" from " : L"",
- SearchPath ? SearchPath : L"");
+ SearchPath ? SearchPath : L"",
+ LoadFlags ? *LoadFlags : 0);
Status = LdrpLoadModule(SearchPath, LoadFlags ? *LoadFlags : 0, Name, &Module, BaseAddress);
if (NT_SUCCESS(Status) &&
(!LoadFlags || 0 == (*LoadFlags & LOAD_LIBRARY_AS_DATAFILE)))
{
+ if (!create_module_activation_context( Module ))
+ {
+ RtlActivateActivationContext(0, Module->EntryPointActivationContext, &cookie);
+ }
+
if (!(Module->Flags & LDRP_PROCESS_ATTACH_CALLED))
{
RtlEnterCriticalSection(Peb->LoaderLock);
Status = LdrpAttachProcess();
RtlLeaveCriticalSection(Peb->LoaderLock);
}
+ if (Module->EntryPointActivationContext) RtlDeactivateActivationContext(0, cookie);
}
if ((!Module) && (NT_SUCCESS(Status)))
? RVA(BaseAddress, ExFunctions[Ordinal - ExportDir->Base] )
: NULL);
- if (((ULONG_PTR)Function >= (ULONG_PTR)ExportDir) &&
- ((ULONG_PTR)Function < (ULONG_PTR)ExportDir + (ULONG_PTR)ExportDirSize))
+ if (((ULONG)Function >= (ULONG)ExportDir) &&
+ ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
{
DPRINT("Forward: %s\n", (PCHAR)Function);
Function = LdrFixupForward((PCHAR)Function);
{
Ordinal = ExOrdinals[Hint];
Function = RVA(BaseAddress, ExFunctions[Ordinal]);
- if (((ULONG_PTR)Function >= (ULONG_PTR)ExportDir) &&
- ((ULONG_PTR)Function < (ULONG_PTR)ExportDir + (ULONG_PTR)ExportDirSize))
+ if (((ULONG)Function >= (ULONG)ExportDir) &&
+ ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
{
DPRINT("Forward: %s\n", (PCHAR)Function);
Function = LdrFixupForward((PCHAR)Function);
{
Ordinal = ExOrdinals[mid];
Function = RVA(BaseAddress, ExFunctions[Ordinal]);
- if (((ULONG_PTR)Function >= (ULONG_PTR)ExportDir) &&
- ((ULONG_PTR)Function < (ULONG_PTR)ExportDir + (ULONG_PTR)ExportDirSize))
+ if (((ULONG)Function >= (ULONG)ExportDir) &&
+ ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
{
DPRINT("Forward: %s\n", (PCHAR)Function);
Function = LdrFixupForward((PCHAR)Function);
{
PIMAGE_DATA_DIRECTORY RelocationDDir;
PIMAGE_BASE_RELOCATION RelocationDir, RelocationEnd;
- ULONG Count, OldProtect, OldProtect2;
- SIZE_T ProtectSize;
+ ULONG Count, ProtectSize, OldProtect, OldProtect2;
PVOID Page, ProtectPage, ProtectPage2;
PUSHORT TypeOffset;
ULONG_PTR Delta;
if (Load && !NT_SUCCESS(Status))
{
Status = LdrpLoadModule(SearchPath,
- 0,
+ 0,
&DllName,
Module,
- NULL);
+ NULL);
if (NT_SUCCESS(Status))
{
Status = LdrFindEntryForName (&DllName, Module, FALSE);
PVOID IATBase;
ULONG OldProtect;
ULONG Ordinal;
- SIZE_T IATSize;
+ ULONG IATSize;
if (ImportModuleDirectory == NULL || ImportModuleDirectory->Name == 0)
{
IATSize++;
}
+ /* No need to fixup anything if IAT is empty */
+ if (IATSize == 0) return STATUS_SUCCESS;
+
/* Unprotect the region we are about to write into. */
IATBase = (PVOID)ImportAddressList;
IATSize *= sizeof(PVOID*);
PVOID IATBase;
ULONG OldProtect;
ULONG Offset;
- SIZE_T IATSize;
+ ULONG IATSize;
PIMAGE_NT_HEADERS NTHeaders;
PCHAR Name;
ULONG Size;
PIMAGE_BOUND_IMPORT_DESCRIPTOR BoundImportDescriptorCurrent;
PIMAGE_TLS_DIRECTORY TlsDirectory;
ULONG TlsSize = 0;
- NTSTATUS Status;
+ NTSTATUS Status = STATUS_SUCCESS;
PLDR_DATA_TABLE_ENTRY ImportedModule;
PCHAR ImportedName;
PWSTR ModulePath;
if (!NT_SUCCESS(Status))
{
DPRINT1("failed to load %s\n", ImportedName);
- return Status;
+ break;
}
Success:
if (Module == ImportedModule)
if (!NT_SUCCESS(Status))
{
DPRINT1("failed to import %s\n", ImportedName);
- return Status;
+ break;
}
ImportModuleDirectoryCurrent++;
}
+
+ if (!NT_SUCCESS(Status))
+ {
+ NTSTATUS errorStatus = Status;
+
+ while (ImportModuleDirectoryCurrent >= ImportModuleDirectory)
+ {
+ ImportedName = (PCHAR)Module->DllBase + ImportModuleDirectoryCurrent->Name;
+
+ Status = LdrpGetOrLoadModule(NULL, ImportedName, &ImportedModule, FALSE);
+ if (NT_SUCCESS(Status) && Module != ImportedModule)
+ {
+ Status = LdrpUnloadModule(ImportedModule, FALSE);
+ if (!NT_SUCCESS(Status)) DPRINT1("unable to unload %s\n", ImportedName);
+ }
+ ImportModuleDirectoryCurrent--;
+ }
+ return errorStatus;
+ }
}
if (TlsDirectory && TlsSize > 0)
/* Map the dll into the process */
ViewSize = 0;
ImageBase = 0;
- ArbitraryUserPointer = NtCurrentTeb()->Tib.ArbitraryUserPointer;
- NtCurrentTeb()->Tib.ArbitraryUserPointer = FullDosName.Buffer;
+ ArbitraryUserPointer = NtCurrentTeb()->NtTib.ArbitraryUserPointer;
+ NtCurrentTeb()->NtTib.ArbitraryUserPointer = FullDosName.Buffer;
Status = NtMapViewOfSection(SectionHandle,
NtCurrentProcess(),
&ImageBase,
ViewShare,
0,
PAGE_READONLY);
- NtCurrentTeb()->Tib.ArbitraryUserPointer = ArbitraryUserPointer;
+ NtCurrentTeb()->NtTib.ArbitraryUserPointer = ArbitraryUserPointer;
if (!NT_SUCCESS(Status))
{
DPRINT1("map view of section failed (Status 0x%08lx)\n", Status);
if (!NT_SUCCESS(Status))
{
DPRINT1("LdrFixupImports failed for %wZ, status=%x\n", &(*Module)->BaseDllName, Status);
+ NtUnmapViewOfSection (NtCurrentProcess (), ImageBase);
+ NtClose (SectionHandle);
+ RtlFreeUnicodeString (&FullDosName);
+ RtlFreeUnicodeString (&(*Module)->FullDllName);
+ RtlFreeUnicodeString (&(*Module)->BaseDllName);
+ RemoveEntryList (&(*Module)->InLoadOrderLinks);
+ RtlFreeHeap (RtlGetProcessHeap (), 0, Module);
return Status;
}
RtlEnterCriticalSection(NtCurrentPeb()->LoaderLock);
InsertTailList(&NtCurrentPeb()->Ldr->InInitializationOrderModuleList,
- &(*Module)->InInitializationOrderLinks);
+ &(*Module)->InInitializationOrderModuleList);
RtlLeaveCriticalSection (NtCurrentPeb()->LoaderLock);
}
return STATUS_SUCCESS;
PIMAGE_BOUND_IMPORT_DESCRIPTOR BoundImportDescriptorCurrent;
PCHAR ImportedName;
PLDR_DATA_TABLE_ENTRY ImportedModule;
- NTSTATUS Status;
+ NTSTATUS Status = 0;
LONG LoadCount;
ULONG Size;
Entry = ModuleListHead->Blink;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
if (((UnloadAll && Module->LoadCount == LDRP_PROCESS_CREATION_TIME) || Module->LoadCount == 0) &&
Module->Flags & LDRP_ENTRY_PROCESSED &&
!(Module->Flags & LDRP_UNLOAD_IN_PROGRESS))
{
TRACE_LDR("Unload %wZ - Calling entry point at %x\n",
&Module->BaseDllName, Module->EntryPoint);
- LdrpCallDllEntry(Module, DLL_PROCESS_DETACH, (PVOID)(INT_PTR)(Module->LoadCount == LDRP_PROCESS_CREATION_TIME ? 1 : 0));
+ LdrpCallDllEntry(Module, DLL_PROCESS_DETACH, (PVOID)(Module->LoadCount == LDRP_PROCESS_CREATION_TIME ? 1 : 0));
}
else
{
Entry = ModuleListHead->Blink;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
Entry = Entry->Blink;
if (Module->Flags & LDRP_UNLOAD_IN_PROGRESS &&
((UnloadAll && Module->LoadCount != LDRP_PROCESS_CREATION_TIME) || Module->LoadCount == 0))
{
/* remove the module entry from the list */
RemoveEntryList (&Module->InLoadOrderLinks);
- RemoveEntryList (&Module->InInitializationOrderLinks);
+ RemoveEntryList (&Module->InInitializationOrderModuleList);
NtUnmapViewOfSection (NtCurrentProcess (), Module->DllBase);
NtClose (Module->SectionPointer);
Entry = ModuleListHead->Flink;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
if (!(Module->Flags & (LDRP_LOAD_IN_PROGRESS|LDRP_UNLOAD_IN_PROGRESS|LDRP_ENTRY_PROCESSED)))
{
Module->Flags |= LDRP_LOAD_IN_PROGRESS;
TRACE_LDR("%wZ loaded - Calling init routine at %x for process attaching\n",
&Module->BaseDllName, Module->EntryPoint);
- Result = LdrpCallDllEntry(Module, DLL_PROCESS_ATTACH, (PVOID)(INT_PTR)(Module->LoadCount == LDRP_PROCESS_CREATION_TIME ? 1 : 0));
+ Result = LdrpCallDllEntry(Module, DLL_PROCESS_ATTACH, (PVOID)(Module->LoadCount == LDRP_PROCESS_CREATION_TIME ? 1 : 0));
if (!Result)
{
Status = STATUS_DLL_INIT_FAILED;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
if (Module->Flags & LDRP_PROCESS_ATTACH_CALLED &&
!(Module->Flags & LDRP_DONT_CALL_FOR_THREADS) &&
!(Module->Flags & LDRP_UNLOAD_IN_PROGRESS))
Entry = ModuleListHead->Blink;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
if (Module->Flags & LDRP_PROCESS_ATTACH_CALLED &&
!(Module->Flags & LDRP_DONT_CALL_FOR_THREADS) &&
LongPtr = (PULONG)((ULONG_PTR)Address + Offset);
*LongPtr += Delta;
break;
-#ifdef _WIN64
- case IMAGE_REL_BASED_DIR64:
- LongPtr = (PULONG)((ULONG_PTR)Address + Offset);
- *LongPtr += Delta;
- break;
-#endif
case IMAGE_REL_BASED_HIGHADJ:
case IMAGE_REL_BASED_MIPS_JMPADDR:
*Cookie = 0;
CookieSet = TRUE;
if (Disposition) *Disposition = 0;
-}
+ }
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
if (CookieSet)
}
/* FIXME: Cookie is based on part of the thread id */
- *Cookie = (ULONG_PTR)NtCurrentTeb()->RealClientId.UniqueThread;
+ *Cookie = (ULONG)NtCurrentTeb()->RealClientId.UniqueThread;
return Status;
}
if (Flags != 0x01)
return STATUS_INVALID_PARAMETER_1;
- if (Cookie != (ULONG_PTR)NtCurrentTeb()->RealClientId.UniqueThread)
+ if (Cookie != (ULONG)NtCurrentTeb()->RealClientId.UniqueThread)
return STATUS_INVALID_PARAMETER_2;
RtlLeaveCriticalSection(NtCurrentPeb()->LoaderLock);
SIZE_T RtlpAllocDeallocQueryBufferSize = PAGE_SIZE;
PTEB LdrpTopLevelDllBeingLoadedTeb = NULL;
-#define IMAGE_DOS_MAGIC 0x5a4d
-#define IMAGE_PE_MAGIC 0x00004550
/* FUNCTIONS ***************************************************************/
-#ifndef _M_AMD64
-// FIXME: Why "Not implemented"???
/*
* @implemented
*/
/* Not implemented for user-mode */
return 0;
}
-#endif
BOOLEAN
NTAPI
RtlAcquirePebLock(VOID)
{
PPEB Peb = NtCurrentPeb ();
-- Peb->FastPebLockRoutine (Peb->FastPebLock);
++ RtlEnterCriticalSection(Peb->FastPebLock);
}
/*
RtlReleasePebLock(VOID)
{
PPEB Peb = NtCurrentPeb ();
-- Peb->FastPebUnlockRoutine (Peb->FastPebLock);
++ RtlLeaveCriticalSection(Peb->FastPebLock);
}
/*
IN ULONG_PTR *StackEnd)
{
/* FIXME: Verify */
- *StackBegin = (ULONG_PTR)NtCurrentTeb()->Tib.StackLimit;
- *StackEnd = (ULONG_PTR)NtCurrentTeb()->Tib.StackBase;
+ *StackBegin = (ULONG_PTR)NtCurrentTeb()->NtTib.StackLimit;
+ *StackEnd = (ULONG_PTR)NtCurrentTeb()->NtTib.StackBase;
return TRUE;
}
+ #ifdef _AMD64_
+ VOID
+ NTAPI
+ RtlpGetStackLimits(
+ OUT PULONG_PTR LowLimit,
+ OUT PULONG_PTR HighLimit)
+ {
+ *LowLimit = (ULONG_PTR)NtCurrentTeb()->NtTib.StackLimit;
+ *HighLimit = (ULONG_PTR)NtCurrentTeb()->NtTib.StackBase;
+ return;
+ }
+ #endif
+
BOOLEAN
NTAPI
RtlIsThreadWithinLoaderCallout(VOID)
return NULL;
}
+
/*
* Ldr Resource support code
*/
DPRINT1("Converting Fiber to Thread\n");
/* the current thread isn't running a fiber: failure */
- if(!pTeb->HasFiberData)
+ if (!pTeb->HasFiberData)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
pTeb->HasFiberData = FALSE;
/* free the fiber */
- if (pTeb->Tib.FiberData != NULL)
+ if(pTeb->NtTib.FiberData != NULL)
{
- RtlFreeHeap(GetProcessHeap(), 0, pTeb->Tib.FiberData);
+ RtlFreeHeap(GetProcessHeap(), 0, pTeb->NtTib.FiberData);
}
/* success */
DPRINT1("Converting Thread to Fiber\n");
/* the current thread is already a fiber */
- if(pTeb->HasFiberData && pTeb->Tib.FiberData) return pTeb->Tib.FiberData;
+ if(pTeb->HasFiberData && pTeb->NtTib.FiberData) return pTeb->NtTib.FiberData;
/* allocate the fiber */
pfCurFiber = (PFIBER)RtlAllocateHeap(GetProcessHeap(),
sizeof(FIBER));
/* failure */
- if(pfCurFiber == NULL)
+ if (pfCurFiber == NULL)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
/* copy some contextual data from the thread to the fiber */
pfCurFiber->Parameter = lpParameter;
- pfCurFiber->ExceptionList = pTeb->Tib.ExceptionList;
- pfCurFiber->StackBase = pTeb->Tib.StackBase;
- pfCurFiber->StackLimit = pTeb->Tib.StackLimit;
+ pfCurFiber->ExceptionList = pTeb->NtTib.ExceptionList;
+ pfCurFiber->StackBase = pTeb->NtTib.StackBase;
+ pfCurFiber->StackLimit = pTeb->NtTib.StackLimit;
pfCurFiber->DeallocationStack = pTeb->DeallocationStack;
pfCurFiber->FlsData = pTeb->FlsData;
pfCurFiber->GuaranteedStackBytes = pTeb->GuaranteedStackBytes;
pfCurFiber->ActivationContextStack = pTeb->ActivationContextStackPointer;
pfCurFiber->Context.ContextFlags = CONTEXT_FULL;
-
+
/* Save FPU State if requsted */
if (dwFlags & FIBER_FLAG_FLOAT_SWITCH)
{
}
/* associate the fiber to the current thread */
- pTeb->Tib.FiberData = pfCurFiber;
+ pTeb->NtTib.FiberData = pfCurFiber;
pTeb->HasFiberData = TRUE;
/* success */
PVOID ActivationContextStack = NULL;
DPRINT1("Creating Fiber\n");
- #ifdef SXS_SUPPORT_ENABLED
+#ifdef SXS_SUPPORT_ENABLED
/* Allocate the Activation Context Stack */
nErrCode = RtlAllocateActivationContextStack(&ActivationContextStack);
- #endif
-
+#endif
+
/* Allocate the fiber */
pfCurFiber = (PFIBER)RtlAllocateHeap(GetProcessHeap(),
0,
sizeof(FIBER));
/* Failure */
- if(pfCurFiber == NULL)
+ if (pfCurFiber == NULL)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
SetLastErrorByStatus(nErrCode);
return NULL;
}
-
+
/* Clear the context */
RtlZeroMemory(&pfCurFiber->Context, sizeof(CONTEXT));
-
+
/* copy the data into the fiber */
pfCurFiber->StackBase = usFiberInitialTeb.StackBase;
pfCurFiber->StackLimit = usFiberInitialTeb.StackLimit;
pfCurFiber->FlsData = NULL;
pfCurFiber->ActivationContextStack = ActivationContextStack;
pfCurFiber->Context.ContextFlags = CONTEXT_FULL;
-
+
/* Save FPU State if requsted */
if (dwFlags & FIBER_FLAG_FLOAT_SWITCH)
{
pfCurFiber->Context.ContextFlags |= CONTEXT_FLOATING_POINT;
}
-
+
/* initialize the context for the fiber */
BasepInitializeContext(&ctxFiberContext,
lpParameter,
lpStartAddress,
usFiberInitialTeb.StackBase,
2);
-
+
/* Return the Fiber */
return pfCurFiber;
}
RtlFreeHeap(GetProcessHeap(), 0, lpFiber);
/* the fiber is deleting itself: let the system deallocate the stack */
- if(NtCurrentTeb()->Tib.FiberData == lpFiber) ExitThread(1);
+ if(NtCurrentTeb()->NtTib.FiberData == lpFiber) ExitThread(1);
/* deallocate the stack */
NtFreeVirtualMemory(NtCurrentProcess(),
DPRINT1("Starting Fiber\n");
BaseThreadStartup((LPTHREAD_START_ROUTINE)Fiber->Context.Eax,
(LPVOID)Fiber->Context.Ebx);
-#elif defined(__x86_64__)
- PFIBER Fiber = GetFiberData();
-
- /* Call the Thread Startup Routine */
- DPRINT1("Starting Fiber\n");
- BaseThreadStartup((LPTHREAD_START_ROUTINE)Fiber->Context.Rax,
- (LPVOID)Fiber->Context.Rbx);
#else
#warning Unknown architecture
UNIMPLEMENTED;
Init(VOID)
{
USERCONNECT UserCon;
++ PVOID *KernelCallbackTable;
/* Set up the kernel callbacks. */
-- NtCurrentPeb()->KernelCallbackTable[USER32_CALLBACK_WINDOWPROC] =
++ KernelCallbackTable = NtCurrentPeb()->KernelCallbackTable;
++ KernelCallbackTable[USER32_CALLBACK_WINDOWPROC] =
(PVOID)User32CallWindowProcFromKernel;
-- NtCurrentPeb()->KernelCallbackTable[USER32_CALLBACK_SENDASYNCPROC] =
++ KernelCallbackTable[USER32_CALLBACK_SENDASYNCPROC] =
(PVOID)User32CallSendAsyncProcForKernel;
-- NtCurrentPeb()->KernelCallbackTable[USER32_CALLBACK_LOADSYSMENUTEMPLATE] =
++ KernelCallbackTable[USER32_CALLBACK_LOADSYSMENUTEMPLATE] =
(PVOID)User32LoadSysMenuTemplateForKernel;
-- NtCurrentPeb()->KernelCallbackTable[USER32_CALLBACK_LOADDEFAULTCURSORS] =
++ KernelCallbackTable[USER32_CALLBACK_LOADDEFAULTCURSORS] =
(PVOID)User32SetupDefaultCursors;
-- NtCurrentPeb()->KernelCallbackTable[USER32_CALLBACK_HOOKPROC] =
++ KernelCallbackTable[USER32_CALLBACK_HOOKPROC] =
(PVOID)User32CallHookProcFromKernel;
-- NtCurrentPeb()->KernelCallbackTable[USER32_CALLBACK_EVENTPROC] =
++ KernelCallbackTable[USER32_CALLBACK_EVENTPROC] =
(PVOID)User32CallEventProcFromKernel;
-- NtCurrentPeb()->KernelCallbackTable[USER32_CALLBACK_LOADMENU] =
++ KernelCallbackTable[USER32_CALLBACK_LOADMENU] =
(PVOID)User32CallLoadMenuFromKernel;
-- NtCurrentPeb()->KernelCallbackTable[USER32_CALLBACK_CLIENTTHREADSTARTUP] =
++ KernelCallbackTable[USER32_CALLBACK_CLIENTTHREADSTARTUP] =
(PVOID)User32CallClientThreadSetupFromKernel;
NtUserProcessConnect( NtCurrentProcess(),
--- /dev/null
- UCHAR SpareBytes1[0x30 - 3 * sizeof(PTR(PVOID)];
+
+ #define PASTE2(x,y) x##y
+ #define PASTE(x,y) PASTE2(x,y)
+
+ #ifdef EXPLICIT_32BIT
+ #define STRUCT(x) PASTE(x,32)
+ #define PTR(x) ULONG
+ #elif defined(EXPLICIT_64BIT)
+ #define STRUCT(x) PASTE(x,64)
+ #define PTR(x) ULONG64
+ #else
+ #define STRUCT(x) x
+ #define PTR(x) x
+ #endif
+
+ #if defined(_WIN64) && !defined(EXPLICIT_32BIT)
+ #define GDI_HANDLE_BUFFER_SIZE 60
+ #else
+ #define GDI_HANDLE_BUFFER_SIZE 34
+ #endif
+
+ typedef struct STRUCT(_PEB)
+ {
+ BOOLEAN InheritedAddressSpace;
+ BOOLEAN ReadImageFileExecOptions;
+ BOOLEAN BeingDebugged;
+ #if (NTDDI_VERSION >= NTDDI_WS03)
+ union
+ {
+ BOOLEAN BitField;
+ struct
+ {
+ BOOLEAN ImageUsesLargePages:1;
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ BOOLEAN IsProtectedProcess:1;
+ BOOLEAN IsLegacyProcess:1;
+ BOOLEAN IsImageDynamicallyRelocated:1;
+ BOOLEAN SkipPatchingUser32Forwarders:1;
+ BOOLEAN SpareBits:3;
+ #else
+ BOOLEAN SpareBits:7;
+ #endif
+ };
+ };
+ #else
+ BOOLEAN SpareBool;
+ #endif
+ PTR(HANDLE) Mutant;
+ PTR(PVOID) ImageBaseAddress;
+ PTR(PPEB_LDR_DATA) Ldr;
+ PTR(struct _RTL_USER_PROCESS_PARAMETERS*) ProcessParameters;
+ PTR(PVOID) SubSystemData;
+ PTR(PVOID) ProcessHeap;
+ PTR(struct _RTL_CRITICAL_SECTION*) FastPebLock;
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ PTR(PVOID) AltThunkSListPtr;
+ PTR(PVOID) IFEOKey;
+ union
+ {
+ ULONG CrossProcessFlags;
+ struct
+ {
+ ULONG ProcessInJob:1;
+ ULONG ProcessInitializing:1;
+ ULONG ProcessUsingVEH:1;
+ ULONG ProcessUsingVCH:1;
+ ULONG ReservedBits0:28;
+ };
+ };
+ union
+ {
+ PTR(PVOID) KernelCallbackTable;
+ PTR(PVOID) UserSharedInfoPtr;
+ };
+ #elif (NTDDI_VERSION >= NTDDI_WS03)
+ PTR(PVOID) AltThunkSListPtr;
+ PTR(PVOID) SparePtr2;
+ ULONG EnvironmentUpdateCount;
+ PTR(PVOID) KernelCallbackTable;
+ #else
+ PTR(PPEBLOCKROUTINE) FastPebLockRoutine;
+ PTR(PPEBLOCKROUTINE) FastPebUnlockRoutine;
+ ULONG EnvironmentUpdateCount;
+ PTR(PVOID) KernelCallbackTable;
+ #endif
+ ULONG SystemReserved[1];
+ ULONG SpareUlong; // AtlThunkSListPtr32
+ PTR(PPEB_FREE_BLOCK) FreeList;
+ ULONG TlsExpansionCounter;
+ PTR(PVOID) TlsBitmap;
+ ULONG TlsBitmapBits[2];
+ PTR(PVOID) ReadOnlySharedMemoryBase;
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ PTR(PVOID) HotpatchInformation;
+ #else
+ PTR(PVOID) ReadOnlySharedMemoryHeap;
+ #endif
+ PTR(PVOID*) ReadOnlyStaticServerData;
+ PTR(PVOID) AnsiCodePageData;
+ PTR(PVOID) OemCodePageData;
+ PTR(PVOID) UnicodeCaseTableData;
+ ULONG NumberOfProcessors;
+ ULONG NtGlobalFlag;
+ LARGE_INTEGER CriticalSectionTimeout;
+ PTR(ULONG_PTR) HeapSegmentReserve;
+ PTR(ULONG_PTR) HeapSegmentCommit;
+ PTR(ULONG_PTR) HeapDeCommitTotalFreeThreshold;
+ PTR(ULONG_PTR) HeapDeCommitFreeBlockThreshold;
+ ULONG NumberOfHeaps;
+ ULONG MaximumNumberOfHeaps;
+ PTR(PVOID*) ProcessHeaps;
+ PTR(PVOID) GdiSharedHandleTable;
+ PTR(PVOID) ProcessStarterHelper;
+ ULONG GdiDCAttributeList;
+ PTR(struct _RTL_CRITICAL_SECTION*) LoaderLock;
+ ULONG OSMajorVersion;
+ ULONG OSMinorVersion;
+ USHORT OSBuildNumber;
+ USHORT OSCSDVersion;
+ ULONG OSPlatformId;
+ ULONG ImageSubsystem;
+ ULONG ImageSubsystemMajorVersion;
+ ULONG ImageSubsystemMinorVersion;
+ PTR(ULONG_PTR) ImageProcessAffinityMask;
+ ULONG GdiHandleBuffer[GDI_HANDLE_BUFFER_SIZE];
+ PTR(PPOST_PROCESS_INIT_ROUTINE) PostProcessInitRoutine;
+ PTR(PVOID) TlsExpansionBitmap;
+ ULONG TlsExpansionBitmapBits[32];
+ ULONG SessionId;
+ #if (NTDDI_VERSION >= NTDDI_WINXP)
+ ULARGE_INTEGER AppCompatFlags;
+ ULARGE_INTEGER AppCompatFlagsUser;
+ PTR(PVOID) pShimData;
+ PTR(PVOID) AppCompatInfo;
+ STRUCT(UNICODE_STRING) CSDVersion;
+ PTR(struct _ACTIVATION_CONTEXT_DATA*) ActivationContextData;
+ PTR(struct _ASSEMBLY_STORAGE_MAP*) ProcessAssemblyStorageMap;
+ PTR(struct _ACTIVATION_CONTEXT_DATA*) SystemDefaultActivationContextData;
+ PTR(struct _ASSEMBLY_STORAGE_MAP*) SystemAssemblyStorageMap;
+ PTR(ULONG_PTR) MinimumStackCommit;
+ #endif
+ #if (NTDDI_VERSION >= NTDDI_WS03)
+ PTR(PVOID*) FlsCallback;
+ STRUCT(LIST_ENTRY) FlsListHead;
+ PTR(PVOID) FlsBitmap;
+ ULONG FlsBitmapBits[4];
+ ULONG FlsHighIndex;
+ #endif
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ PTR(PVOID) WerRegistrationData;
+ PTR(PVOID) WerShipAssertPtr;
+ #endif
+ } STRUCT(PEB), *STRUCT(PPEB);
+
+
+ #if defined(_WIN64) && !defined(EXPLICIT_32BIT)
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), Mutant) == 0x08);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), Ldr) == 0x18);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), FastPebLock) == 0x038);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), TlsExpansionCounter) == 0x070);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), NtGlobalFlag) == 0x0BC);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), GdiSharedHandleTable) == 0x0F8);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), LoaderLock) == 0x110);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), ImageSubsystem) == 0x128);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), ImageProcessAffinityMask) == 0x138);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), PostProcessInitRoutine) == 0x230);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), SessionId) == 0x2C0);
++#if (NTDDI_VERSION >= NTDDI_WS03)
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), FlsHighIndex) == 0x350);
++#endif
+ #else
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), Mutant) == 0x04);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), Ldr) == 0x0C);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), FastPebLock) == 0x01C);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), TlsExpansionCounter) == 0x03C);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), NtGlobalFlag) == 0x068);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), GdiSharedHandleTable) == 0x094);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), LoaderLock) == 0x0A0);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), ImageSubsystem) == 0x0B4);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), ImageProcessAffinityMask) == 0x0C0);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), PostProcessInitRoutine) == 0x14C);
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), SessionId) == 0x1D4);
++#if (NTDDI_VERSION >= NTDDI_WS03)
+ C_ASSERT(FIELD_OFFSET(STRUCT(PEB), FlsHighIndex) == 0x22C);
+ #endif
++#endif
+
+ //
+ // GDI Batch Descriptor
+ //
+ typedef struct STRUCT(_GDI_TEB_BATCH)
+ {
+ ULONG Offset;
+ PTR(HANDLE) HDC;
+ ULONG Buffer[0x136];
+ } STRUCT(GDI_TEB_BATCH), *STRUCT(PGDI_TEB_BATCH);
+
+ //
+ // Thread Environment Block (TEB)
+ //
+ typedef struct STRUCT(_TEB)
+ {
+ STRUCT(NT_TIB) NtTib;
+ PTR(PVOID) EnvironmentPointer;
+ STRUCT(CLIENT_ID) ClientId;
+ PTR(PVOID) ActiveRpcHandle;
+ PTR(PVOID) ThreadLocalStoragePointer;
+ PTR(STRUCT(PPEB)) ProcessEnvironmentBlock;
+ ULONG LastErrorValue;
+ ULONG CountOfOwnedCriticalSections;
+ PTR(PVOID) CsrClientThread;
+ PTR(PVOID) Win32ThreadInfo;
+ ULONG User32Reserved[26];
+ ULONG UserReserved[5];
+ PTR(PVOID) WOW32Reserved;
+ LCID CurrentLocale;
+ ULONG FpSoftwareStatusRegister;
+ PTR(PVOID) SystemReserved1[54];
+ LONG ExceptionCode;
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ PTR(struct _ACTIVATION_CONTEXT_STACK*) ActivationContextStackPointer;
- PTR(PVOID) Instrumentation[9];
++ UCHAR SpareBytes1[0x30 - 3 * sizeof(PTR(PVOID))];
+ ULONG TxFsContext;
+ #elif (NTDDI_VERSION >= NTDDI_WS03)
+ PTR(struct _ACTIVATION_CONTEXT_STACK*) ActivationContextStackPointer;
+ UCHAR SpareBytes1[0x34 - 3 * sizeof(PTR(PVOID))];
+ #else
+ ACTIVATION_CONTEXT_STACK ActivationContextStack;
+ UCHAR SpareBytes1[24];
+ #endif
+ STRUCT(GDI_TEB_BATCH) GdiTebBatch;
+ STRUCT(CLIENT_ID) RealClientId;
+ PTR(PVOID) GdiCachedProcessHandle;
+ ULONG GdiClientPID;
+ ULONG GdiClientTID;
+ PTR(PVOID) GdiThreadLocalInfo;
+ PTR(SIZE_T) Win32ClientInfo[62];
+ PTR(PVOID) glDispatchTable[233];
+ PTR(SIZE_T) glReserved1[29];
+ PTR(PVOID) glReserved2;
+ PTR(PVOID) glSectionInfo;
+ PTR(PVOID) glSection;
+ PTR(PVOID) glTable;
+ PTR(PVOID) glCurrentRC;
+ PTR(PVOID) glContext;
+ NTSTATUS LastStatusValue;
+ STRUCT(UNICODE_STRING) StaticUnicodeString;
+ WCHAR StaticUnicodeBuffer[261];
+ PTR(PVOID) DeallocationStack;
+ PTR(PVOID) TlsSlots[64];
+ STRUCT(LIST_ENTRY) TlsLinks;
+ PTR(PVOID) Vdm;
+ PTR(PVOID) ReservedForNtRpc;
+ PTR(PVOID) DbgSsReserved[2];
+ #if (NTDDI_VERSION >= NTDDI_WS03)
+ ULONG HardErrorMode;
+ #else
+ ULONG HardErrorsAreDisabled;
+ #endif
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
-C_ASSERT(FIELD_OFFSET(STRUCT(TEB), SubProcessTag) == 0x1728);
++ PTR(PVOID) Instrumentation[13 - sizeof(GUID)/sizeof(PTR(PVOID))];
+ GUID ActivityId;
+ PTR(PVOID) SubProcessTag;
+ PTR(PVOID) EtwLocalData;
++ PTR(PVOID) EtwTraceData;
+ #elif (NTDDI_VERSION >= NTDDI_WS03)
+ PTR(PVOID) Instrumentation[14];
+ PTR(PVOID) SubProcessTag;
+ PTR(PVOID) EtwLocalData;
+ #else
+ PTR(PVOID) Instrumentation[16];
+ #endif
+ PTR(PVOID) WinSockData;
+ ULONG GdiBatchCount;
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ BOOLEAN SpareBool0;
+ BOOLEAN SpareBool1;
+ BOOLEAN SpareBool2;
+ #else
+ BOOLEAN InDbgPrint;
+ BOOLEAN FreeStackOnTermination;
+ BOOLEAN HasFiberData;
+ #endif
+ UCHAR IdealProcessor;
+ #if (NTDDI_VERSION >= NTDDI_WS03)
+ ULONG GuaranteedStackBytes;
+ #else
+ ULONG Spare3;
+ #endif
+ PTR(PVOID) ReservedForPerf;
+ PTR(PVOID) ReservedForOle;
+ ULONG WaitingOnLoaderLock;
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ PTR(PVOID) SavedPriorityState;
+ PTR(ULONG_PTR) SoftPatchPtr1;
+ PTR(ULONG_PTR) ThreadPoolData;
+ #elif (NTDDI_VERSION >= NTDDI_WS03)
+ PTR(ULONG_PTR) SparePointer1;
+ PTR(ULONG_PTR) SoftPatchPtr1;
+ PTR(ULONG_PTR) SoftPatchPtr2;
+ #else
+ Wx86ThreadState Wx86Thread;
+ #endif
+ PTR(PVOID*) TlsExpansionSlots;
+ #if defined(_WIN64) && !defined(EXPLICIT_32BIT)
+ PTR(PVOID) DeallocationBStore;
+ PTR(PVOID) BStoreLimit;
+ #endif
+ ULONG ImpersonationLocale;
+ ULONG IsImpersonating;
+ PTR(PVOID) NlsCache;
+ PTR(PVOID) pShimData;
+ ULONG HeapVirtualAffinity;
+ PTR(HANDLE) CurrentTransactionHandle;
+ PTR(PTEB_ACTIVE_FRAME) ActiveFrame;
+ #if (NTDDI_VERSION >= NTDDI_WS03)
+ PVOID FlsData;
+ #endif
+ #if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ PVOID PreferredLangauges;
+ PVOID UserPrefLanguages;
+ PVOID MergedPrefLanguages;
+ ULONG MuiImpersonation;
+ union
+ {
+ struct
+ {
+ USHORT SpareCrossTebFlags:16;
+ };
+ USHORT CrossTebFlags;
+ };
+ union
+ {
+ struct
+ {
+ USHORT DbgSafeThunkCall:1;
+ USHORT DbgInDebugPrint:1;
+ USHORT DbgHasFiberData:1;
+ USHORT DbgSkipThreadAttach:1;
+ USHORT DbgWerInShipAssertCode:1;
+ USHORT DbgIssuedInitialBp:1;
+ USHORT DbgClonedThread:1;
+ USHORT SpareSameTebBits:9;
+ };
+ USHORT SameTebFlags;
+ };
+ PTR(PVOID) TxnScopeEntercallback;
+ PTR(PVOID) TxnScopeExitCAllback;
+ PTR(PVOID) TxnScopeContext;
+ ULONG LockCount;
+ ULONG ProcessRundown;
+ ULONG64 LastSwitchTime;
+ ULONG64 TotalSwitchOutTime;
+ LARGE_INTEGER WaitReasonBitMap;
+ #else
+ BOOLEAN SafeThunkCall;
+ BOOLEAN BooleanSpare[3];
+ #endif
+ } STRUCT(TEB), *STRUCT(PTEB);
+
+ #if defined(_WIN64) && !defined(EXPLICIT_32BIT)
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), EnvironmentPointer) == 0x038);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), ExceptionCode) == 0x2C0);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), GdiTebBatch) == 0x2F0);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), LastStatusValue) == 0x1250);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), Vdm) == 0x1690);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), HardErrorMode) == 0x16B0);
-C_ASSERT(FIELD_OFFSET(STRUCT(TEB), HardErrorMode) == 0xF28);
-C_ASSERT(FIELD_OFFSET(STRUCT(TEB), SubProcessTag) == 0xF64);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), GdiBatchCount) == 0x1740);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), IdealProcessor) == 0x1747);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), WaitingOnLoaderLock) == 0x1760);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), TlsExpansionSlots) == 0x1780);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), WaitingOnLoaderLock) == 0x1760);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), ActiveFrame) == 0x17C0);
+ #else
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), EnvironmentPointer) == 0x01C);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), ExceptionCode) == 0x1A4);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), GdiTebBatch) == 0x1D4);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), LastStatusValue) == 0xBF4);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), Vdm) == 0xF18);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), GdiBatchCount) == 0xF70);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), TlsExpansionSlots) == 0xF94);
+ C_ASSERT(FIELD_OFFSET(STRUCT(TEB), ActiveFrame) == 0xFB0);
+ #endif
+
+ #undef PTR
+ #undef STRUCT
+ #undef PASTE
+ #undef PASTE2
+ #undef GDI_HANDLE_BUFFER_SIZE
#include <ldrtypes.h>
#include <mmtypes.h>
#include <obtypes.h>
++#include <rtltypes.h>
#ifndef NTOS_MODE_USER
#include <extypes.h>
#include <setypes.h>
HANDLE Mutant;
} INITIAL_PEB, *PINITIAL_PEB;
- //
- // Process Environment Block (PEB)
- //
- typedef struct _PEB
- {
- BOOLEAN InheritedAddressSpace;
- BOOLEAN ReadImageFileExecOptions;
- BOOLEAN BeingDebugged;
- #if (NTDDI_VERSION >= NTDDI_WS03)
- struct
- {
- BOOLEAN ImageUsesLargePages:1;
- #if (NTDDI_VERSION >= NTDDI_LONGHORN)
- BOOLEAN IsProtectedProcess:1;
- BOOLEAN IsLegacyProcess:1;
- BOOLEAN SpareBits:5;
- #else
- BOOLEAN SpareBits:7;
- #endif
- };
- #else
- BOOLEAN SpareBool;
- #endif
- HANDLE Mutant;
- PVOID ImageBaseAddress;
- PPEB_LDR_DATA Ldr;
- struct _RTL_USER_PROCESS_PARAMETERS *ProcessParameters;
- PVOID SubSystemData;
- PVOID ProcessHeap;
- #if (NTDDI_VERSION >= NTDDI_LONGHORN)
- struct _RTL_CRITICAL_SECTION *FastPebLock;
- PVOID AltThunkSListPtr;
- PVOID IFEOKey;
- ULONG Spare;
- union
- {
- PVOID* KernelCallbackTable;
- PVOID UserSharedInfoPtr;
- };
- ULONG SystemReserved[1];
- ULONG SpareUlong;
- #else
- PVOID FastPebLock;
- PPEBLOCKROUTINE FastPebLockRoutine;
- PPEBLOCKROUTINE FastPebUnlockRoutine;
- ULONG EnvironmentUpdateCount;
- PVOID* KernelCallbackTable;
- PVOID EventLogSection;
- PVOID EventLog;
- #endif
- PPEB_FREE_BLOCK FreeList;
- ULONG TlsExpansionCounter;
- PVOID TlsBitmap;
- ULONG TlsBitmapBits[0x2];
- PVOID ReadOnlySharedMemoryBase;
- PVOID ReadOnlySharedMemoryHeap;
- PVOID* ReadOnlyStaticServerData;
- PVOID AnsiCodePageData;
- PVOID OemCodePageData;
- PVOID UnicodeCaseTableData;
- ULONG NumberOfProcessors;
- ULONG NtGlobalFlag;
- LARGE_INTEGER CriticalSectionTimeout;
- ULONG HeapSegmentReserve;
- ULONG HeapSegmentCommit;
- ULONG HeapDeCommitTotalFreeThreshold;
- ULONG HeapDeCommitFreeBlockThreshold;
- ULONG NumberOfHeaps;
- ULONG MaximumNumberOfHeaps;
- PVOID* ProcessHeaps;
- PVOID GdiSharedHandleTable;
- PVOID ProcessStarterHelper;
- ULONG GdiDCAttributeList;
- #if (NTDDI_VERSION >= NTDDI_LONGHORN)
- struct _RTL_CRITICAL_SECTION *LoaderLock;
- #else
- PVOID LoaderLock;
- #endif
- ULONG OSMajorVersion;
- ULONG OSMinorVersion;
- USHORT OSBuildNumber;
- USHORT OSCSDVersion;
- ULONG OSPlatformId;
- ULONG ImageSubSystem;
- ULONG ImageSubSystemMajorVersion;
- ULONG ImageSubSystemMinorVersion;
- ULONG ImageProcessAffinityMask;
- ULONG GdiHandleBuffer[0x22];
- PPOST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;
- struct _RTL_BITMAP *TlsExpansionBitmap;
- ULONG TlsExpansionBitmapBits[0x20];
- ULONG SessionId;
- #if (NTDDI_VERSION >= NTDDI_WINXP)
- ULARGE_INTEGER AppCompatFlags;
- ULARGE_INTEGER AppCompatFlagsUser;
- PVOID pShimData;
- PVOID AppCompatInfo;
- UNICODE_STRING CSDVersion;
- struct _ACTIVATION_CONTEXT_DATA *ActivationContextData;
- struct _ASSEMBLY_STORAGE_MAP *ProcessAssemblyStorageMap;
- struct _ACTIVATION_CONTEXT_DATA *SystemDefaultActivationContextData;
- struct _ASSEMBLY_STORAGE_MAP *SystemAssemblyStorageMap;
- ULONG MinimumStackCommit;
- #endif
- #if (NTDDI_VERSION >= NTDDI_WS03)
- PVOID *FlsCallback;
- LIST_ENTRY FlsListHead;
- struct _RTL_BITMAP *FlsBitmap;
- ULONG FlsBitmapBits[4];
- ULONG FlsHighIndex;
- #endif
- #if (NTDDI_VERSION >= NTDDI_LONGHORN)
- PVOID WerRegistrationData;
- PVOID WerShipAssertPtr;
- #endif
- } PEB, *PPEB;
-
- //
- // GDI Batch Descriptor
- //
- typedef struct _GDI_TEB_BATCH
- {
- ULONG Offset;
- HANDLE HDC;
- ULONG Buffer[0x136];
- } GDI_TEB_BATCH, *PGDI_TEB_BATCH;
-
//
// Initial TEB
//
PTEB_ACTIVE_FRAME_CONTEXT Context;
} TEB_ACTIVE_FRAME, *PTEB_ACTIVE_FRAME;
+ typedef struct _CLIENT_ID32
+ {
+ ULONG UniqueProcess;
+ ULONG UniqueThread;
+ } CLIENT_ID32, *PCLIENT_ID32;
+
+ typedef struct _CLIENT_ID64
+ {
+ ULONG64 UniqueProcess;
+ ULONG64 UniqueThread;
+ } CLIENT_ID64, *PCLIENT_ID64;
+
++#if (NTDDI_VERSION < NTDDI_WS03)
++typedef struct _Wx86ThreadState
++{
++ PULONG CallBx86Eip;
++ PVOID DeallocationCpu;
++ BOOLEAN UseKnownWx86Dll;
++ CHAR OleStubInvoked;
++} Wx86ThreadState, *PWx86ThreadState;
++#endif
++
++
//
+ // Process Environment Block (PEB)
// Thread Environment Block (TEB)
//
- typedef struct _TEB
- {
- NT_TIB Tib;
- PVOID EnvironmentPointer;
- CLIENT_ID ClientId;
- PVOID ActiveRpcHandle;
- PVOID ThreadLocalStoragePointer;
- struct _PEB *ProcessEnvironmentBlock;
- ULONG LastErrorValue;
- ULONG CountOfOwnedCriticalSections;
- PVOID CsrClientThread;
- struct _W32THREAD* Win32ThreadInfo;
- ULONG User32Reserved[0x1A];
- ULONG UserReserved[5];
- PVOID WOW32Reserved;
- LCID CurrentLocale;
- ULONG FpSoftwareStatusRegister;
- PVOID SystemReserved1[0x36];
- LONG ExceptionCode;
- struct _ACTIVATION_CONTEXT_STACK *ActivationContextStackPointer;
- #ifdef _WIN64
- UCHAR SpareBytes1[24];
- #else
- UCHAR SpareBytes1[0x24];
- #endif
- ULONG TxFsContext;
- GDI_TEB_BATCH GdiTebBatch;
- CLIENT_ID RealClientId;
- PVOID GdiCachedProcessHandle;
- ULONG GdiClientPID;
- ULONG GdiClientTID;
- PVOID GdiThreadLocalInfo;
- SIZE_T Win32ClientInfo[62];
- PVOID glDispatchTable[0xE9];
- SIZE_T glReserved1[0x1D];
- PVOID glReserved2;
- PVOID glSectionInfo;
- PVOID glSection;
- PVOID glTable;
- PVOID glCurrentRC;
- PVOID glContext;
- NTSTATUS LastStatusValue;
- UNICODE_STRING StaticUnicodeString;
- WCHAR StaticUnicodeBuffer[0x105];
- PVOID DeallocationStack;
- PVOID TlsSlots[0x40];
- LIST_ENTRY TlsLinks;
- PVOID Vdm;
- PVOID ReservedForNtRpc;
- PVOID DbgSsReserved[0x2];
- ULONG HardErrorDisabled;
+ #include "peb_teb.h"
+
#ifdef _WIN64
- PVOID Instrumentation[11];
- #else
- PVOID Instrumentation[9];
- #endif
- GUID ActivityId;
- PVOID SubProcessTag;
- PVOID EtwTraceData;
- #if (NTDDI_VERSION >= NTDDI_LONGHORN)
- PVOID EtwLocalData;
- #endif
- PVOID WinSockData;
- ULONG GdiBatchCount;
- #if (NTDDI_VERSION >= NTDDI_LONGHORN)
- BOOLEAN SpareBool0;
- BOOLEAN SpareBool1;
- BOOLEAN SpareBool2;
- #else
- BOOLEAN InDbgPrint;
- BOOLEAN FreeStackOnTermination;
- BOOLEAN HasFiberData;
- #endif
- UCHAR IdealProcessor;
- ULONG GuaranteedStackBytes;
- PVOID ReservedForPerf;
- PVOID ReservedForOle;
- ULONG WaitingOnLoaderLock;
- #if (NTDDI_VERSION >= NTDDI_LONGHORN)
- PVOID SavedPriorityState;
- #else
- ULONG SparePointer1;
- #endif
- ULONG SoftPatchPtr1;
- ULONG SoftPatchPtr2;
- PVOID *TlsExpansionSlots;
- ULONG ImpersonationLocale;
- ULONG IsImpersonating;
- PVOID NlsCache;
- PVOID pShimData;
- ULONG HeapVirualAffinity;
- PVOID CurrentTransactionHandle;
- PTEB_ACTIVE_FRAME ActiveFrame;
- #if (NTDDI_VERSION >= NTDDI_WS03)
- PVOID FlsData;
- #endif
- #if (NTDDI_VERSION >= NTDDI_LONGHORN)
- PVOID PreferredLangauges;
- PVOID UserPrefLanguages;
- PVOID MergedPrefLanguages;
- ULONG MuiImpersonation;
- union
- {
- struct
- {
- USHORT SpareCrossTebFlags:16;
- };
- USHORT CrossTebFlags;
- };
- union
- {
- struct
- {
- USHORT DbgSafeThunkCall:1;
- USHORT DbgInDebugPrint:1;
- USHORT DbgHasFiberData:1;
- USHORT DbgSkipThreadAttach:1;
- USHORT DbgWerInShipAssertCode:1;
- USHORT DbgIssuedInitialBp:1;
- USHORT DbgClonedThread:1;
- USHORT SpareSameTebBits:9;
- };
- USHORT SameTebFlags;
- };
- PVOID TxnScopeEntercallback;
- PVOID TxnScopeExitCAllback;
- PVOID TxnScopeContext;
- ULONG LockCount;
- ULONG ProcessRundown;
- ULONGLONG LastSwitchTime;
- ULONGLONG TotalSwitchOutTime;
- LARGE_INTEGER WaitReasonBitMap;
- #else
- UCHAR SafeThunkCall;
- UCHAR BooleanSpare[3];
+ //
+ // Explicit 32 bit PEB/TEB
+ //
+ #define EXPLICIT_32BIT
+ #include "peb_teb.h"
+ #undef EXPLICIT_32BIT
+
+ //
+ // Explicit 64 bit PEB/TEB
+ //
+ #define EXPLICIT_64BIT
+ #include "peb_teb.h"
+ #undef EXPLICIT_64BIT
#endif
- } TEB, *PTEB;
#ifdef NTOS_MODE_USER
HARDWARE_PTE PageDirectoryPte;
ULONGLONG Filler;
};
- PVOID Session;
+ ULONG Session;
CHAR ImageFileName[16];
LIST_ENTRY JobLinks;
PVOID LockedPagesList;
#include <umtypes.h>
#include <ntnls.h>
#include <rtltypes.h>
++#include <pstypes.h>
#include <extypes.h>
#include "in6addr.h"
#include "inaddr.h"
PCHAR OemString,
ULONG OemSize,
PULONG ResultSize,
- PWCHAR UnicodeString,
+ PCWCH UnicodeString,
ULONG UnicodeSize
);
PCHAR OemString,
ULONG OemSize,
PULONG ResultSize,
- PWCHAR UnicodeString,
+ PCWCH UnicodeString,
ULONG UnicodeSize
);
PCHAR MbString,
ULONG MbSize,
PULONG ResultSize,
- PWCHAR UnicodeString,
+ PCWCH UnicodeString,
ULONG UnicodeSize
);
NTAPI
RtlUnicodeToMultiByteSize(
PULONG MbSize,
- PWCHAR UnicodeString,
+ PCWCH UnicodeString,
ULONG UnicodeSize
);
PWSTR UnicodeString,
ULONG MaxBytesInUnicodeString,
PULONG BytesInUnicodeString,
- IN PCHAR OemString,
+ IN PCCH OemString,
ULONG BytesInOemString
);
IN ...
);
+NTSYSAPI
ULONG
NTAPI
DbgPrompt(
// Dependencies
//
#include <umtypes.h>
--#include <pstypes.h>
++#include <mmtypes.h>
++#include <ldrtypes.h>
//
// Maximum Atom Length
} RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED,
*PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED;
++#if (NTDDI_VERSION >= NTDDI_WS03)
typedef struct _ACTIVATION_CONTEXT_STACK
{
PRTL_ACTIVATION_CONTEXT_STACK_FRAME ActiveFrame;
ULONG StackId;
} ACTIVATION_CONTEXT_STACK,
*PACTIVATION_CONTEXT_STACK;
++#else
++typedef struct _ACTIVATION_CONTEXT_STACK
++{
++ ULONG Flags;
++ ULONG NextCookieSequenceNumber;
++ PVOID ActiveFrame;
++ LIST_ENTRY FrameListCache;
++} ACTIVATION_CONTEXT_STACK, *PACTIVATION_CONTEXT_STACK;
++#endif
#endif
CONST CHAR *Buffer;
} CSTRING, *PCSTRING;
++#endif
++
typedef struct _STRING32 {
USHORT Length;
USHORT MaximumLength;
UNICODE_STRING64, *PUNICODE_STRING64,
ANSI_STRING64, *PANSI_STRING64;
--#endif
typedef struct _OBJECT_ATTRIBUTES
{
/* Setup the API Message */
ApiMessage.h.u1.Length = sizeof(DBGKM_MSG) << 16 |
(8 + sizeof(DBGKM_CREATE_PROCESS));
- ApiMessage.h.u2.ZeroInit = LPC_DEBUG_EVENT;
+ ApiMessage.h.u2.ZeroInit = 0;
+ ApiMessage.h.u2.s2.Type = LPC_DEBUG_EVENT;
ApiMessage.ApiNumber = DbgKmCreateProcessApi;
/* Send the message */
wcsncpy(Teb->StaticUnicodeBuffer,
L"ntdll.dll",
sizeof(Teb->StaticUnicodeBuffer) / sizeof(WCHAR));
- Teb->Tib.ArbitraryUserPointer = Teb->StaticUnicodeBuffer;
+ Teb->NtTib.ArbitraryUserPointer = Teb->StaticUnicodeBuffer;
/* Return it in the debug event as well */
- LoadDll->NamePointer = &Teb->Tib.ArbitraryUserPointer;
+ LoadDll->NamePointer = &Teb->NtTib.ArbitraryUserPointer;
}
/* Get a handle */
/* Setup the API Message */
ApiMessage.h.u1.Length = sizeof(DBGKM_MSG) << 16 |
(8 + sizeof(DBGKM_LOAD_DLL));
- ApiMessage.h.u2.ZeroInit = LPC_DEBUG_EVENT;
+ ApiMessage.h.u2.ZeroInit = 0;
+ ApiMessage.h.u2.s2.Type = LPC_DEBUG_EVENT;
ApiMessage.ApiNumber = DbgKmLoadDllApi;
/* Send the message */
/* Setup the API Message */
ApiMessage.h.u1.Length = sizeof(DBGKM_MSG) << 16 |
(8 + sizeof(DBGKM_CREATE_THREAD));
- ApiMessage.h.u2.ZeroInit = LPC_DEBUG_EVENT;
+ ApiMessage.h.u2.ZeroInit = 0;
+ ApiMessage.h.u2.s2.Type = LPC_DEBUG_EVENT;
ApiMessage.ApiNumber = DbgKmCreateThreadApi;
/* Send the message */
/* Setup the API Message */
ApiMessage.h.u1.Length = sizeof(DBGKM_MSG) << 16 |
(8 + sizeof(DBGKM_EXIT_PROCESS));
- ApiMessage.h.u2.ZeroInit = LPC_DEBUG_EVENT;
+ ApiMessage.h.u2.ZeroInit = 0;
+ ApiMessage.h.u2.s2.Type = LPC_DEBUG_EVENT;
ApiMessage.ApiNumber = DbgKmExitProcessApi;
/* Set the current exit time */
/* Setup the API Message */
ApiMessage.h.u1.Length = sizeof(DBGKM_MSG) << 16 |
(8 + sizeof(DBGKM_EXIT_THREAD));
- ApiMessage.h.u2.ZeroInit = LPC_DEBUG_EVENT;
+ ApiMessage.h.u2.ZeroInit = 0;
+ ApiMessage.h.u2.s2.Type = LPC_DEBUG_EVENT;
ApiMessage.ApiNumber = DbgKmExitThreadApi;
/* Suspend the process */
/* Setup the API Message */
ApiMessage.h.u1.Length = sizeof(DBGKM_MSG) << 16 |
(8 + sizeof(DBGKM_LOAD_DLL));
- ApiMessage.h.u2.ZeroInit = LPC_DEBUG_EVENT;
+ ApiMessage.h.u2.ZeroInit = 0;
+ ApiMessage.h.u2.s2.Type = LPC_DEBUG_EVENT;
ApiMessage.ApiNumber = DbgKmLoadDllApi;
/* Send the message */
/* Setup the API Message */
ApiMessage.h.u1.Length = sizeof(DBGKM_MSG) << 16 |
(8 + sizeof(DBGKM_UNLOAD_DLL));
- ApiMessage.h.u2.ZeroInit = LPC_DEBUG_EVENT;
+ ApiMessage.h.u2.ZeroInit = 0;
+ ApiMessage.h.u2.s2.Type = LPC_DEBUG_EVENT;
ApiMessage.ApiNumber = DbgKmUnloadDllApi;
/* Send the message */
/* Save the exception list */
Teb = KeGetCurrentThread()->Teb;
-- ExceptionList = Teb->Tib.ExceptionList;
++ ExceptionList = Teb->NtTib.ExceptionList;
/* Jump to user mode */
*UserEsp = NewStack;
if (CallbackStatus != STATUS_CALLBACK_POP_STACK)
{
/* Only restore the exception list if we didn't crash in ring 3 */
-- Teb->Tib.ExceptionList = ExceptionList;
++ Teb->NtTib.ExceptionList = ExceptionList;
CallbackStatus = STATUS_SUCCESS;
}
else
//
// Setup the template stack PTE
//
- TempPte = HyperTemplatePte;
+ TempPte = ValidKernelPte;
MI_MAKE_LOCAL_PAGE(&TempPte);
MI_MAKE_DIRTY_PAGE(&TempPte);
TempPte.u.Hard.PageFrameNumber = 0;
//
// Get a page
//
- PageFrameIndex = MmAllocPage(MC_NPPOOL, 0);
+ PageFrameIndex = MmAllocPage(MC_NPPOOL);
TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
//
//
*PointerPte = TempPte;
}
-
+
+ // Bug #4835
+ (VOID)InterlockedExchangeAddUL(&MiMemoryConsumers[MC_NPPOOL].PagesUsed, StackPages);
+
//
// Release the PFN lock
//
//
// Setup the template stack PTE
//
- TempPte = HyperTemplatePte;
+ TempPte = ValidKernelPte;
MI_MAKE_LOCAL_PAGE(&TempPte);
MI_MAKE_DIRTY_PAGE(&TempPte);
TempPte.u.Hard.PageFrameNumber = 0;
//
// Get a page
//
- PageFrameIndex = MmAllocPage(MC_NPPOOL, 0);
+ PageFrameIndex = MmAllocPage(MC_NPPOOL);
TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
//
//
// Write subsystem data
//
- Peb->ImageSubSystem = NtHeaders->OptionalHeader.Subsystem;
- Peb->ImageSubSystemMajorVersion = NtHeaders->OptionalHeader.MajorSubsystemVersion;
- Peb->ImageSubSystemMinorVersion = NtHeaders->OptionalHeader.MinorSubsystemVersion;
+ Peb->ImageSubsystem = NtHeaders->OptionalHeader.Subsystem;
+ Peb->ImageSubsystemMajorVersion = NtHeaders->OptionalHeader.MajorSubsystemVersion;
+ Peb->ImageSubsystemMinorVersion = NtHeaders->OptionalHeader.MinorSubsystemVersion;
//
// Check for version data
//
// Set TIB Data
//
- Teb->Tib.ExceptionList = EXCEPTION_CHAIN_END;
- Teb->Tib.Self = (PNT_TIB)Teb;
+ Teb->NtTib.ExceptionList = EXCEPTION_CHAIN_END;
+ Teb->NtTib.Self = (PNT_TIB)Teb;
//
// Identify this as an OS/2 V3.0 ("Cruiser") TIB
//
- Teb->Tib.Version = 30 << 8;
+ Teb->NtTib.Version = 30 << 8;
//
// Set TEB Data
//
// Use initial TEB values
//
- Teb->Tib.StackBase = InitialTeb->StackBase;
- Teb->Tib.StackLimit = InitialTeb->StackLimit;
+ Teb->NtTib.StackBase = InitialTeb->StackBase;
+ Teb->NtTib.StackLimit = InitialTeb->StackLimit;
Teb->DeallocationStack = InitialTeb->AllocatedStackBase;
}
else
//
// Use grandparent TEB values
//
- Teb->Tib.StackBase = InitialTeb->PreviousStackBase;
- Teb->Tib.StackLimit = InitialTeb->PreviousStackLimit;
+ Teb->NtTib.StackBase = InitialTeb->PreviousStackBase;
+ Teb->NtTib.StackLimit = InitialTeb->PreviousStackLimit;
}
//
/* FUNCTIONS *****************************************************************/
-PVOID
-NTAPI
-RtlPcToFileHeader(
- IN PVOID PcValue,
- OUT PVOID *BaseOfImage)
-{
- PLDR_DATA_TABLE_ENTRY LdrEntry;
- BOOLEAN InSystem;
-
- /* Get the base for this file */
- if ((ULONG_PTR)PcValue > (ULONG_PTR)MmHighestUserAddress)
- {
- /* We are in kernel */
- *BaseOfImage = KiPcToFileHeader(PcValue, &LdrEntry, FALSE, &InSystem);
- }
- else
- {
- /* We are in user land */
- *BaseOfImage = KiRosPcToUserFileHeader(PcValue, &LdrEntry);
- }
-
- return *BaseOfImage;
-}
-
VOID
NTAPI
RtlInitializeRangeListPackage(VOID)
return FALSE;
}
-#if !defined(_ARM_) && !defined(_AMD64_)
+#ifndef _ARM_
BOOLEAN
NTAPI
ULONG Eip;
BOOLEAN Result, StopSearch = FALSE;
ULONG i = 0;
- PKTHREAD Thread = KeGetCurrentThread();
+ PETHREAD Thread = PsGetCurrentThread();
PTEB Teb;
PKTRAP_FRAME TrapFrame;
if (Flags == 1)
{
/* Get the trap frame and TEB */
- TrapFrame = Thread->TrapFrame;
- Teb = Thread->Teb;
+ TrapFrame = KeGetTrapFrame(&Thread->Tcb);
+ Teb = Thread->Tcb.Teb;
/* Make sure we can trust the TEB and trap frame */
if (!(Teb) ||
- !((PVOID)((ULONG_PTR)TrapFrame & 0x80000000)) ||
- ((PVOID)TrapFrame <= (PVOID)Thread->StackLimit) ||
- ((PVOID)TrapFrame >= (PVOID)Thread->StackBase) ||
+ !(Thread->SystemThread) ||
(KeIsAttachedProcess()) ||
(KeGetCurrentIrql() >= DISPATCH_LEVEL))
{
}
/* Get the stack limits */
- StackBegin = (ULONG_PTR)Teb->Tib.StackLimit;
- StackEnd = (ULONG_PTR)Teb->Tib.StackBase;
+ StackBegin = (ULONG_PTR)Teb->NtTib.StackLimit;
+ StackEnd = (ULONG_PTR)Teb->NtTib.StackBase;
#ifdef _M_IX86
Stack = TrapFrame->Ebp;
#elif defined(_M_PPC)
if ((StackBegin < Eip) && (Eip < StackEnd)) break;
/* Check if we reached a user-mode address */
- if (!(Flags) && !(Eip & 0x80000000)) break;
+ if (!(Flags) && !(Eip & 0x80000000)) break; // FIXME: 3GB breakage
/* Save this frame */
Callers[i] = (PVOID)Eip;
#endif
-#ifdef _AMD64_
-VOID
-NTAPI
-RtlpGetStackLimits(
- OUT PULONG_PTR LowLimit,
- OUT PULONG_PTR HighLimit)
-{
- PKTHREAD CurrentThread = KeGetCurrentThread();
- *HighLimit = (ULONG_PTR)CurrentThread->InitialStack;
- *LowLimit = (ULONG_PTR)CurrentThread->StackLimit;
-}
-#endif
-
/* RTL Atom Tables ************************************************************/
NTSTATUS