#include <ntoskrnl.h>
#define NDEBUG
-#include <internal/debug.h>
+#include <debug.h>
/* GLOBALS ******************************************************************/
PETHREAD Thread;
PTEB Teb;
BOOLEAN DeadThread = FALSE;
+ KIRQL OldIrql;
PAGED_CODE();
PSTRACE(PS_THREAD_DEBUG,
"StartRoutine: %p StartContext: %p\n", StartRoutine, StartContext);
Teb->IdealProcessor = Thread->Tcb.IdealProcessor;
}
- /* Check if this is a system thread, or if we're hiding */
- PSREFTRACE(Thread);
- if (!(Thread->SystemThread) && !(Thread->HideFromDebugger))
+ /* Check if this is a dead thread, or if we're hiding */
+ if (!(Thread->DeadThread) && !(Thread->HideFromDebugger))
{
/* We're not, so notify the debugger */
- DbgkCreateThread(StartContext);
+ DbgkCreateThread(Thread, StartContext);
}
/* Make sure we're not already dead */
}
/* Raise to APC */
- KfRaiseIrql(APC_LEVEL);
+ KeRaiseIrql(APC_LEVEL, &OldIrql);
/* Queue the User APC */
- KiInitializeUserApc(NULL,
- (PVOID)((ULONG_PTR)Thread->Tcb.InitialStack -
- sizeof(KTRAP_FRAME) -
- sizeof(FX_SAVE_AREA)),
+ KiInitializeUserApc(KeGetExceptionFrame(&Thread->Tcb),
+ KeGetTrapFrame(&Thread->Tcb),
PspSystemDllEntryPoint,
NULL,
PspSystemDllBase,
Prcb = KeGetCurrentPrcb();
NewCookie = Prcb->MmPageFaultCount ^ Prcb->InterruptTime ^
SystemTime.u.LowPart ^ SystemTime.u.HighPart ^
- (ULONG)&SystemTime;
+ (ULONG_PTR)&SystemTime;
/* Set the new cookie*/
InterlockedCompareExchange((LONG*)&SharedUserData->Cookie,
}
}
+LONG
+PspUnhandledExceptionInSystemThread(PEXCEPTION_POINTERS ExceptionPointers)
+{
+ /* Print debugging information */
+ DPRINT1("PS: Unhandled Kernel Mode Exception Pointers = 0x%p\n",
+ ExceptionPointers);
+ DPRINT1("Code %x Addr %p Info0 %p Info1 %p Info2 %p Info3 %p\n",
+ ExceptionPointers->ExceptionRecord->ExceptionCode,
+ ExceptionPointers->ExceptionRecord->ExceptionAddress,
+ ExceptionPointers->ExceptionRecord->ExceptionInformation[0],
+ ExceptionPointers->ExceptionRecord->ExceptionInformation[1],
+ ExceptionPointers->ExceptionRecord->ExceptionInformation[2],
+ ExceptionPointers->ExceptionRecord->ExceptionInformation[3]);
+
+ /* Bugcheck the system */
+ KeBugCheckEx(SYSTEM_THREAD_EXCEPTION_NOT_HANDLED,
+ ExceptionPointers->ExceptionRecord->ExceptionCode,
+ (ULONG_PTR)ExceptionPointers->ExceptionRecord->ExceptionAddress,
+ (ULONG_PTR)ExceptionPointers->ExceptionRecord,
+ (ULONG_PTR)ExceptionPointers->ContextRecord);
+ return 0;
+}
+
VOID
NTAPI
PspSystemThreadStartup(IN PKSTART_ROUTINE StartRoutine,
Thread = PsGetCurrentThread();
/* Make sure the thread isn't gone */
- PSREFTRACE(Thread);
- if (!(Thread->Terminated) && !(Thread->DeadThread))
+ _SEH2_TRY
+ {
+ if (!(Thread->Terminated) && !(Thread->DeadThread))
+ {
+ /* Call the Start Routine */
+ StartRoutine(StartContext);
+ }
+ }
+ _SEH2_EXCEPT(PspUnhandledExceptionInSystemThread(_SEH2_GetExceptionInformation()))
{
- /* Call it the Start Routine */
- StartRoutine(StartContext);
+ /* Bugcheck if we got here */
+ KeBugCheck(KMODE_EXCEPTION_NOT_HANDLED);
}
+ _SEH2_END;
/* Exit the thread */
PspTerminateThreadByPointer(Thread, STATUS_SUCCESS, TRUE);
HANDLE_TABLE_ENTRY CidEntry;
ACCESS_STATE LocalAccessState;
PACCESS_STATE AccessState = &LocalAccessState;
- AUX_DATA AuxData;
+ AUX_ACCESS_DATA AuxData;
BOOLEAN Result, SdAllocated;
PSECURITY_DESCRIPTOR SecurityDescriptor;
SECURITY_SUBJECT_CONTEXT SubjectContext;
{
/* Reference the Process by Pointer */
ObReferenceObject(TargetProcess);
- PSREFTRACE(TargetProcess);
Process = TargetProcess;
Status = STATUS_SUCCESS;
}
}
/* Zero the Object entirely */
- PSREFTRACE(Thread);
RtlZeroMemory(Thread, sizeof(ETHREAD));
/* Initialize rundown protection */
KeInitializeSpinLock(&Thread->ActiveTimerListLock);
/* Acquire rundown protection */
- ExAcquireRundownProtection(&Process->RundownProtect);
+ if (!ExAcquireRundownProtection (&Process->RundownProtect))
+ {
+ /* Fail */
+ ObDereferenceObject(Thread);
+ return STATUS_PROCESS_IS_TERMINATING;
+ }
/* Now let the kernel initialize the context */
if (ThreadContext)
{
/* User-mode Thread, create Teb */
- TebBase = MmCreateTeb(Process, &Thread->Cid, InitialTeb);
- if (!TebBase)
+ Status = MmCreateTeb(Process, &Thread->Cid, InitialTeb, &TebBase);
+ if (!NT_SUCCESS(Status))
{
/* Failed to create the TEB. Release rundown and dereference */
ExReleaseRundownProtection(&Process->RundownProtect);
ObDereferenceObject(Thread);
- return STATUS_INSUFFICIENT_RESOURCES;
+ return Status;
}
/* Set the Start Addresses */
- Thread->StartAddress = (PVOID)ThreadContext->Eip;
- Thread->Win32StartAddress = (PVOID)ThreadContext->Eax;
+ Thread->StartAddress = (PVOID)KeGetContextPc(ThreadContext);
+ Thread->Win32StartAddress = (PVOID)KeGetContextReturnRegister(ThreadContext);
/* Let the kernel intialize the Thread */
Status = KeInitThread(&Thread->Tcb,
}
/* Check if we failed */
- PSREFTRACE(Thread);
if (!NT_SUCCESS(Status))
{
/* Delete the TEB if we had done */
/* Dereference completely to kill it */
ObDereferenceObjectEx(Thread, 2);
+ return Status;
}
/* Insert the Thread into the Object Manager */
&hThread);
/* Delete the access state if we had one */
- PSREFTRACE(Thread);
if (AccessState) SeDeleteAccessState(AccessState);
/* Check for success */
if (NT_SUCCESS(Status))
{
/* Wrap in SEH to protect against bad user-mode pointers */
- _SEH_TRY
+ _SEH2_TRY
{
/* Return Cid and Handle */
if (ClientId) *ClientId = Thread->Cid;
*ThreadHandle = hThread;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
-
/* Thread insertion failed, thread is dead */
PspSetCrossThreadFlag(Thread, CT_DEAD_THREAD_BIT);
/* Close its handle, killing it */
ObCloseHandle(ThreadHandle, PreviousMode);
+
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
else
{
ASSERT(!(Thread->CreateTime.HighPart & 0xF0000000));
/* Make sure the thread isn't dead */
- PSREFTRACE(Thread);
if (!Thread->DeadThread)
{
/* Get the thread's SD */
SubjectContext.ClientToken = NULL;
/* Do the access check */
- if (!SecurityDescriptor) DPRINT1("FIX PS SDs!!\n");
Result = SeAccessCheck(SecurityDescriptor,
&SubjectContext,
FALSE,
}
/* Dispatch thread */
- PSREFTRACE(Thread);
KeReadyThread(&Thread->Tcb);
/* Dereference it, leaving only the keep-alive */
ObDereferenceObject(Thread);
/* Return */
- PSREFTRACE(Thread);
return Status;
/* Most annoying failure case ever, where we undo almost all manually */
Quickie:
/* When we get here, the process is locked, unlock it */
ExReleasePushLockExclusive(&Process->ProcessLock);
+ KeLeaveCriticalRegion();
/* Uninitailize it */
- PSREFTRACE(Thread);
KeUninitThread(&Thread->Tcb);
/* If we had a TEB, delete it */
/* Dereference the thread and return failure */
ObDereferenceObject(Thread);
- PSREFTRACE(Thread);
return STATUS_PROCESS_IS_TERMINATING;
}
NTAPI
PsGetThreadHardErrorsAreDisabled(IN PETHREAD Thread)
{
- return Thread->HardErrorsAreDisabled;
+ return Thread->HardErrorsAreDisabled ? TRUE : FALSE;
}
/*
NTAPI
PsIsThreadImpersonating(IN PETHREAD Thread)
{
- return Thread->ActiveImpersonationInfo;
+ return Thread->ActiveImpersonationInfo ? TRUE : FALSE;
}
/*
/*
* @implemented
*/
-struct _W32THREAD*
+PVOID
NTAPI
PsGetCurrentThreadWin32Thread(VOID)
{
IN BOOLEAN CreateSuspended)
{
INITIAL_TEB SafeInitialTeb;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
PSTRACE(PS_THREAD_DEBUG,
"ProcessHandle: %p Context: %p\n", ProcessHandle, ThreadContext);
/* Check if this was from user-mode */
- if(KeGetPreviousMode() != KernelMode)
+ if (KeGetPreviousMode() != KernelMode)
{
/* Make sure that we got a context */
if (!ThreadContext) return STATUS_INVALID_PARAMETER;
/* Protect checks */
- _SEH_TRY
+ _SEH2_TRY
{
/* Make sure the handle pointer we got is valid */
ProbeForWriteHandle(ThreadHandle);
/* Check if the caller wants a client id */
- if(ClientId)
+ if (ClientId)
{
/* Make sure we can write to it */
ProbeForWrite(ClientId, sizeof(CLIENT_ID), sizeof(ULONG));
/* Check the Initial TEB */
ProbeForRead(InitialTeb, sizeof(INITIAL_TEB), sizeof(ULONG));
SafeInitialTeb = *InitialTeb;
- }
- _SEH_HANDLE
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
-
- /* Handle any failures in our SEH checks */
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
else
{
CLIENT_ID SafeClientId;
ULONG Attributes = 0;
HANDLE hThread = NULL;
- NTSTATUS Status = STATUS_SUCCESS;
+ NTSTATUS Status;
PETHREAD Thread;
BOOLEAN HasObjectName = FALSE;
ACCESS_STATE AccessState;
- AUX_DATA AuxData;
+ AUX_ACCESS_DATA AuxData;
PAGED_CODE();
PSTRACE(PS_THREAD_DEBUG,
"ClientId: %p ObjectAttributes: %p\n", ClientId, ObjectAttributes);
if (PreviousMode != KernelMode)
{
/* Enter SEH for probing */
- _SEH_TRY
+ _SEH2_TRY
{
/* Probe the thread handle */
ProbeForWriteHandle(ThreadHandle);
HasObjectName = (ObjectAttributes->ObjectName != NULL);
Attributes = ObjectAttributes->Attributes;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
- _SEH_END;
- if (!NT_SUCCESS(Status)) return Status;
+ _SEH2_END;
}
else
{
if (NT_SUCCESS(Status))
{
/* Protect against bad user-mode pointers */
- _SEH_TRY
+ _SEH2_TRY
{
/* Write back the handle */
*ThreadHandle = hThread;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Get the exception code */
- Status = _SEH_GetExceptionCode();
+ Status = _SEH2_GetExceptionCode();
}
- _SEH_END;
+ _SEH2_END;
}
/* Return status */
projects / reactos.git / blobdiff