-/* $Id: kill.c,v 1.52 2002/04/27 19:25:16 hbirr Exp $
+/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ps/kill.c
* PURPOSE: Terminating a thread
- * PROGRAMMER: David Welch (welch@cwcom.net)
- * UPDATE HISTORY:
- * Created 22/05/98
+ *
+ * PROGRAMMERS: David Welch (welch@cwcom.net)
*/
/* INCLUDES *****************************************************************/
-#include <ddk/ntddk.h>
-#include <internal/ps.h>
-#include <internal/ke.h>
-#include <internal/mm.h>
-#include <internal/ob.h>
-#include <internal/port.h>
-#include <internal/pool.h>
-
+#include <ntoskrnl.h>
#define NDEBUG
#include <internal/debug.h>
/* GLOBALS *******************************************************************/
-extern ULONG PiNrThreads;
-extern ULONG PiNrRunnableThreads;
-extern KSPIN_LOCK PiThreadListLock;
-extern LIST_ENTRY PiThreadListHead;
-extern KSPIN_LOCK PiApcLock;
-
VOID PsTerminateCurrentThread(NTSTATUS ExitStatus);
+NTSTATUS STDCALL NtCallTerminatePorts(PETHREAD Thread);
#define TAG_TERMINATE_APC TAG('T', 'A', 'P', 'C')
+LIST_ENTRY ThreadsToReapHead;
+
+#define TERMINATE_PROC 0x1
+#define TERMINATE_APC 0x2
+
/* FUNCTIONS *****************************************************************/
+VOID
+PsInitializeThreadReaper(VOID)
+{
+ InitializeListHead(&ThreadsToReapHead);
+}
+
+VOID
+PsReapThreads(VOID)
+{
+ KIRQL oldlvl;
+ PETHREAD Thread;
+ PLIST_ENTRY ListEntry;
+
+ oldlvl = KeAcquireDispatcherDatabaseLock();
+ while((ListEntry = RemoveHeadList(&ThreadsToReapHead)) != &ThreadsToReapHead)
+ {
+ PiNrThreadsAwaitingReaping--;
+ KeReleaseDispatcherDatabaseLock(oldlvl);
+ Thread = CONTAINING_RECORD(ListEntry, ETHREAD, TerminationPortList);
+
+ ObDereferenceObject(Thread);
+ oldlvl = KeAcquireDispatcherDatabaseLock();
+ }
+ KeReleaseDispatcherDatabaseLock(oldlvl);
+}
+
+VOID
+PsQueueThreadReap(PETHREAD Thread)
+{
+ InsertTailList(&ThreadsToReapHead, &Thread->TerminationPortList);
+ PiNrThreadsAwaitingReaping++;
+}
+
VOID
PiTerminateProcessThreads(PEPROCESS Process,
NTSTATUS ExitStatus)
{
KIRQL oldlvl;
PLIST_ENTRY current_entry;
- PETHREAD current;
+ PETHREAD current, CurrentThread = PsGetCurrentThread();
DPRINT("PiTerminateProcessThreads(Process %x, ExitStatus %x)\n",
Process, ExitStatus);
+
+ oldlvl = KeAcquireDispatcherDatabaseLock();
- KeAcquireSpinLock(&PiThreadListLock, &oldlvl);
-
current_entry = Process->ThreadListHead.Flink;
while (current_entry != &Process->ThreadListHead)
{
current = CONTAINING_RECORD(current_entry, ETHREAD,
- Tcb.ProcessThreadListEntry);
- if (current != PsGetCurrentThread() &&
- current->DeadThread == 0)
+ ThreadListEntry);
+ if (current != CurrentThread && current->HasTerminated == 0)
{
DPRINT("Terminating %x, current thread: %x, "
"thread's process: %x\n", current, PsGetCurrentThread(),
current->ThreadsProcess);
- KeReleaseSpinLock(&PiThreadListLock, oldlvl);
+ KeReleaseDispatcherDatabaseLock(oldlvl);
PsTerminateOtherThread(current, ExitStatus);
- KeAcquireSpinLock(&PiThreadListLock, &oldlvl);
+ oldlvl = KeAcquireDispatcherDatabaseLock();
current_entry = Process->ThreadListHead.Flink;
}
else
current_entry = current_entry->Flink;
}
}
- KeReleaseSpinLock(&PiThreadListLock, oldlvl);
+ KeReleaseDispatcherDatabaseLock(oldlvl);
DPRINT("Finished PiTerminateProcessThreads()\n");
}
-VOID
-PsReapThreads(VOID)
-{
- PLIST_ENTRY current_entry;
- PETHREAD current;
- KIRQL oldIrql;
-
-// DPRINT1("PsReapThreads()\n");
-
- KeAcquireSpinLock(&PiThreadListLock, &oldIrql);
-
- current_entry = PiThreadListHead.Flink;
-
- while (current_entry != &PiThreadListHead)
- {
- current = CONTAINING_RECORD(current_entry, ETHREAD,
- Tcb.ThreadListEntry);
-
- current_entry = current_entry->Flink;
-
- if (current->Tcb.State == THREAD_STATE_TERMINATED_1)
- {
- PEPROCESS Process = current->ThreadsProcess;
- NTSTATUS Status = current->ExitStatus;
-
- DPRINT("PsProcessType %x\n", PsProcessType);
- DPRINT("Reaping thread %x\n", current);
- DPRINT("Pointer count %d\n", ObGetObjectPointerCount(Process));
- current->Tcb.State = THREAD_STATE_TERMINATED_2;
- RemoveEntryList(¤t->Tcb.ProcessThreadListEntry);
- if (IsListEmpty(&Process->ThreadListHead))
- {
- DPRINT("Last thread terminated, terminating process\n");
- KeReleaseSpinLock( &PiThreadListLock, oldIrql );
- PiTerminateProcess(Process, Status);
- KeAcquireSpinLock( &PiThreadListLock, &oldIrql );
- }
- DPRINT("Pointer count %d\n", ObGetObjectPointerCount(Process));
- KeReleaseSpinLock(&PiThreadListLock, oldIrql);
- ObDereferenceObject(current);
- KeAcquireSpinLock(&PiThreadListLock, &oldIrql);
- current_entry = PiThreadListHead.Flink;
- }
- }
- KeReleaseSpinLock(&PiThreadListLock, oldIrql);
-}
-
VOID
PsTerminateCurrentThread(NTSTATUS ExitStatus)
/*
{
KIRQL oldIrql;
PETHREAD CurrentThread;
- PKTHREAD Thread;
PLIST_ENTRY current_entry;
PKMUTANT Mutant;
-
+ BOOLEAN Last;
+ PEPROCESS CurrentProcess;
+ SIZE_T Length = PAGE_SIZE;
+ PVOID TebBlock;
+
+ DPRINT("PsTerminateCurrentThread(ExitStatus %x)\n", ExitStatus);
+
CurrentThread = PsGetCurrentThread();
-
+
+ oldIrql = KeAcquireDispatcherDatabaseLock();
+ if (CurrentThread->HasTerminated & TERMINATE_PROC)
+ {
+ KeReleaseDispatcherDatabaseLock(oldIrql);
+ return;
+ }
+ CurrentThread->HasTerminated |= TERMINATE_PROC;
+ KeReleaseDispatcherDatabaseLock(oldIrql);
+
+ KeLowerIrql(PASSIVE_LEVEL);
+
+ CurrentProcess = CurrentThread->ThreadsProcess;
+
+ /* Can't terminate a thread if it attached another process */
+ if (AttachedApcEnvironment == CurrentThread->Tcb.ApcStateIndex)
+ {
+ KEBUGCHECKEX(INVALID_PROCESS_ATTACH_ATTEMPT, (ULONG) CurrentProcess,
+ (ULONG) CurrentThread->Tcb.ApcState.Process,
+ (ULONG) CurrentThread->Tcb.ApcStateIndex,
+ (ULONG) CurrentThread);
+ }
+
+ KeCancelTimer(&CurrentThread->Tcb.Timer);
+
+ oldIrql = KeAcquireDispatcherDatabaseLock();
+
DPRINT("terminating %x\n",CurrentThread);
- KeAcquireSpinLock(&PiThreadListLock, &oldIrql);
-
+
CurrentThread->ExitStatus = ExitStatus;
- Thread = KeGetCurrentThread();
- KeCancelTimer(&Thread->Timer);
- KeReleaseSpinLock(&PiThreadListLock, oldIrql);
-
+ KeQuerySystemTime((PLARGE_INTEGER)&CurrentThread->ExitTime);
+
+ /* If the ProcessoR Control Block's NpxThread points to the current thread
+ * unset it.
+ */
+ InterlockedCompareExchangePointer(&KeGetCurrentKPCR()->PrcbData.NpxThread,
+ NULL, ETHREAD_TO_KTHREAD(CurrentThread));
+
+ KeReleaseDispatcherDatabaseLock(oldIrql);
+
+ PsLockProcess(CurrentProcess, FALSE);
+
+ /* Remove the thread from the thread list of its process */
+ RemoveEntryList(&CurrentThread->ThreadListEntry);
+ Last = IsListEmpty(&CurrentProcess->ThreadListHead);
+ PsUnlockProcess(CurrentProcess);
+
+ /* Notify subsystems of the thread termination */
+ PspRunCreateThreadNotifyRoutines(CurrentThread, FALSE);
+ PsTerminateWin32Thread(CurrentThread);
+
+ /* Free the TEB */
+ if(CurrentThread->Tcb.Teb)
+ {
+ DPRINT("Decommit teb at %p\n", CurrentThread->Tcb.Teb);
+ ExAcquireFastMutex(&CurrentProcess->TebLock);
+ TebBlock = MM_ROUND_DOWN(CurrentThread->Tcb.Teb, MM_VIRTMEM_GRANULARITY);
+ ZwFreeVirtualMemory(NtCurrentProcess(),
+ (PVOID *)&CurrentThread->Tcb.Teb,
+ &Length,
+ MEM_DECOMMIT);
+ DPRINT("teb %p, TebBlock %p\n", CurrentThread->Tcb.Teb, TebBlock);
+ if (TebBlock != CurrentProcess->TebBlock ||
+ CurrentProcess->TebBlock == CurrentProcess->TebLastAllocated)
+ {
+ MmLockAddressSpace(&CurrentProcess->AddressSpace);
+ MmReleaseMemoryAreaIfDecommitted(CurrentProcess, &CurrentProcess->AddressSpace, TebBlock);
+ MmUnlockAddressSpace(&CurrentProcess->AddressSpace);
+ }
+ CurrentThread->Tcb.Teb = NULL;
+ ExReleaseFastMutex(&CurrentProcess->TebLock);
+ }
+
/* abandon all owned mutants */
- current_entry = Thread->MutantListHead.Flink;
- while (current_entry != &Thread->MutantListHead)
+ current_entry = CurrentThread->Tcb.MutantListHead.Flink;
+ while (current_entry != &CurrentThread->Tcb.MutantListHead)
{
Mutant = CONTAINING_RECORD(current_entry, KMUTANT,
MutantListEntry);
MUTANT_INCREMENT,
TRUE,
FALSE);
- current_entry = Thread->MutantListHead.Flink;
+ current_entry = CurrentThread->Tcb.MutantListHead.Flink;
}
-
- KeAcquireDispatcherDatabaseLock(FALSE);
+
+ oldIrql = KeAcquireDispatcherDatabaseLock();
CurrentThread->Tcb.DispatcherHeader.SignalState = TRUE;
- KeDispatcherObjectWake(&CurrentThread->Tcb.DispatcherHeader);
- KeReleaseDispatcherDatabaseLock(FALSE);
+ KiDispatcherObjectWake(&CurrentThread->Tcb.DispatcherHeader, IO_NO_INCREMENT);
+ KeReleaseDispatcherDatabaseLock (oldIrql);
+
+ /* The last thread shall close the door on exit */
+ if(Last)
+ {
+ /* save the last thread exit status */
+ CurrentProcess->LastThreadExitStatus = ExitStatus;
+
+ PspRunCreateProcessNotifyRoutines(CurrentProcess, FALSE);
+ PsTerminateWin32Process(CurrentProcess);
+ PiTerminateProcess(CurrentProcess, ExitStatus);
+ }
+
+ oldIrql = KeAcquireDispatcherDatabaseLock();
- KeAcquireSpinLock(&PiThreadListLock, &oldIrql);
+#ifdef _ENABLE_THRDEVTPAIR
+ ExpSwapThreadEventPair(CurrentThread, NULL); /* Release the associated eventpair object, if there was one */
+#endif /* _ENABLE_THRDEVTPAIR */
+
+ ASSERT(CurrentThread->Tcb.WaitBlockList == NULL);
+
PsDispatchThreadNoLock(THREAD_STATE_TERMINATED_1);
- KeBugCheck(0);
+ DPRINT1("Unexpected return, CurrentThread %x PsGetCurrentThread() %x\n", CurrentThread, PsGetCurrentThread());
+ KEBUGCHECK(0);
}
VOID STDCALL
PVOID SystemArgument1,
PVOID SystemArgument2)
{
- PsTerminateCurrentThread(PsGetCurrentThread()->ExitStatus);
+ PsTerminateCurrentThread((NTSTATUS)SystemArgument1);
}
VOID
NTSTATUS ExitStatus)
/*
* FUNCTION: Terminate a thread when calling from another thread's context
- * NOTES: This function must be called with PiThreadListLock held
+ * NOTES: This function must be called with PiThreadLock held
*/
{
PKAPC Apc;
+ KIRQL OldIrql;
DPRINT("PsTerminateOtherThread(Thread %x, ExitStatus %x)\n",
Thread, ExitStatus);
-
- Thread->DeadThread = 1;
- Thread->ExitStatus = ExitStatus;
+
+ OldIrql = KeAcquireDispatcherDatabaseLock();
+ if (Thread->HasTerminated & TERMINATE_APC)
+ {
+ KeReleaseDispatcherDatabaseLock (OldIrql);
+ return;
+ }
+ Thread->HasTerminated |= TERMINATE_APC;
+ KeReleaseDispatcherDatabaseLock (OldIrql);
Apc = ExAllocatePoolWithTag(NonPagedPool, sizeof(KAPC), TAG_TERMINATE_APC);
KeInitializeApc(Apc,
&Thread->Tcb,
- 0,
+ OriginalApcEnvironment,
PiTerminateThreadKernelRoutine,
PiTerminateThreadRundownRoutine,
PiTerminateThreadNormalRoutine,
KernelMode,
NULL);
KeInsertQueueApc(Apc,
+ (PVOID)ExitStatus,
NULL,
- NULL,
- KernelMode);
+ IO_NO_INCREMENT);
+
+ OldIrql = KeAcquireDispatcherDatabaseLock();
+ if (THREAD_STATE_BLOCKED == Thread->Tcb.State && UserMode == Thread->Tcb.WaitMode)
+ {
+ DPRINT("Unblocking thread\n");
+ KiAbortWaitThread((PKTHREAD)Thread, STATUS_THREAD_IS_TERMINATING);
+ }
+ KeReleaseDispatcherDatabaseLock(OldIrql);
}
NTSTATUS STDCALL
PiTerminateProcess(PEPROCESS Process,
NTSTATUS ExitStatus)
{
+ KIRQL OldIrql;
+ PEPROCESS CurrentProcess;
+
DPRINT("PiTerminateProcess(Process %x, ExitStatus %x) PC %d HC %d\n",
Process, ExitStatus, ObGetObjectPointerCount(Process),
ObGetObjectHandleCount(Process));
- if (InterlockedExchange((PLONG)&Process->Pcb.State,
- PROCESS_STATE_TERMINATED) ==
+ ObReferenceObject(Process);
+ if (InterlockedExchangeUL(&Process->Pcb.State,
+ PROCESS_STATE_TERMINATED) ==
PROCESS_STATE_TERMINATED)
{
+ ObDereferenceObject(Process);
return(STATUS_SUCCESS);
}
- KeAttachProcess( Process );
+ CurrentProcess = PsGetCurrentProcess();
+ if (Process != CurrentProcess)
+ {
+ KeAttachProcess(&Process->Pcb);
+ }
ObCloseAllHandles(Process);
- KeDetachProcess();
- KeAcquireDispatcherDatabaseLock(FALSE);
+ if (Process != CurrentProcess)
+ {
+ KeDetachProcess();
+ }
+ OldIrql = KeAcquireDispatcherDatabaseLock ();
Process->Pcb.DispatcherHeader.SignalState = TRUE;
- KeDispatcherObjectWake(&Process->Pcb.DispatcherHeader);
- KeReleaseDispatcherDatabaseLock(FALSE);
+ KiDispatcherObjectWake(&Process->Pcb.DispatcherHeader, IO_NO_INCREMENT);
+ KeReleaseDispatcherDatabaseLock (OldIrql);
+ ObDereferenceObject(Process);
return(STATUS_SUCCESS);
}
NTSTATUS STDCALL
-NtTerminateProcess(IN HANDLE ProcessHandle,
+NtTerminateProcess(IN HANDLE ProcessHandle OPTIONAL,
IN NTSTATUS ExitStatus)
{
NTSTATUS Status;
PEPROCESS Process;
+ PAGED_CODE();
+
DPRINT("NtTerminateProcess(ProcessHandle %x, ExitStatus %x)\n",
ProcessHandle, ExitStatus);
Status = ObReferenceObjectByHandle(ProcessHandle,
PROCESS_TERMINATE,
PsProcessType,
- UserMode,
+ KeGetCurrentThread()->PreviousMode,
(PVOID*)&Process,
NULL);
if (!NT_SUCCESS(Status))
{
ObDereferenceObject(Process);
PsTerminateCurrentThread(ExitStatus);
+ /*
+ * We should never get here!
+ */
+ return(STATUS_SUCCESS);
}
ObDereferenceObject(Process);
return(STATUS_SUCCESS);
PETHREAD Thread;
NTSTATUS Status;
+ PAGED_CODE();
+
Status = ObReferenceObjectByHandle(ThreadHandle,
THREAD_TERMINATE,
PsThreadType,
- UserMode,
+ KeGetCurrentThread()->PreviousMode,
(PVOID*)&Thread,
NULL);
if (Status != STATUS_SUCCESS)
return(Status);
}
- ObDereferenceObject(Thread);
-
if (Thread == PsGetCurrentThread())
{
- PsTerminateCurrentThread(ExitStatus);
+ /* dereference the thread object before we kill our thread */
+ ObDereferenceObject(Thread);
+ PsTerminateCurrentThread(ExitStatus);
+ /*
+ * We should never get here!
+ */
}
else
{
PsTerminateOtherThread(Thread, ExitStatus);
+ ObDereferenceObject(Thread);
}
return(STATUS_SUCCESS);
}
+/*
+ * @implemented
+ */
NTSTATUS STDCALL
PsTerminateSystemThread(NTSTATUS ExitStatus)
/*
PLIST_ENTRY current_entry;
PEPORT_TERMINATION_REQUEST current;
+ PAGED_CODE();
+
KeAcquireSpinLock(&Thread->ActiveTimerListLock, &oldIrql);
while ((current_entry = RemoveHeadList(&Thread->TerminationPortList)) !=
&Thread->TerminationPortList);
KeReleaseSpinLock(&Thread->ActiveTimerListLock, oldIrql);
LpcSendTerminationPort(current->Port,
Thread->CreateTime);
+ ExFreePool(current);
KeAcquireSpinLock(&Thread->ActiveTimerListLock, &oldIrql);
}
KeReleaseSpinLock(&Thread->ActiveTimerListLock, oldIrql);
}
NTSTATUS STDCALL
-NtRegisterThreadTerminatePort(HANDLE TerminationPortHandle)
+NtRegisterThreadTerminatePort(HANDLE PortHandle)
{
NTSTATUS Status;
PEPORT_TERMINATION_REQUEST Request;
KIRQL oldIrql;
PETHREAD Thread;
- Status = ObReferenceObjectByHandle(TerminationPortHandle,
+ PAGED_CODE();
+
+ Status = ObReferenceObjectByHandle(PortHandle,
PORT_ALL_ACCESS,
- ExPortType,
- UserMode,
+ LpcPortObjectType,
+ KeGetCurrentThread()->PreviousMode,
(PVOID*)&TerminationPort,
NULL);
if (!NT_SUCCESS(Status))
return(Status);
}
- Request = ExAllocatePool(NonPagedPool, sizeof(Request));
- Request->Port = TerminationPort;
- Thread = PsGetCurrentThread();
- KeAcquireSpinLock(&Thread->ActiveTimerListLock, &oldIrql);
- InsertTailList(&Thread->TerminationPortList, &Request->ThreadListEntry);
- KeReleaseSpinLock(&Thread->ActiveTimerListLock, oldIrql);
-
- return(STATUS_SUCCESS);
+ Request = ExAllocatePool(NonPagedPool, sizeof(EPORT_TERMINATION_REQUEST));
+ if(Request != NULL)
+ {
+ Request->Port = TerminationPort;
+ Thread = PsGetCurrentThread();
+ KeAcquireSpinLock(&Thread->ActiveTimerListLock, &oldIrql);
+ InsertTailList(&Thread->TerminationPortList, &Request->ThreadListEntry);
+ KeReleaseSpinLock(&Thread->ActiveTimerListLock, oldIrql);
+
+ return(STATUS_SUCCESS);
+ }
+ else
+ {
+ ObDereferenceObject(TerminationPort);
+ return(STATUS_INSUFFICIENT_RESOURCES);
+ }
}