-/* $Id: kill.c,v 1.89 2004/12/04 16:56:20 blight 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 *****************************************************************/
/* GLOBALS *******************************************************************/
-extern KSPIN_LOCK PiThreadLock;
-
VOID PsTerminateCurrentThread(NTSTATUS ExitStatus);
NTSTATUS STDCALL NtCallTerminatePorts(PETHREAD Thread);
LIST_ENTRY ThreadsToReapHead;
+#define TERMINATE_PROC 0x1
+#define TERMINATE_APC 0x2
+
/* FUNCTIONS *****************************************************************/
VOID
PETHREAD Thread;
PLIST_ENTRY ListEntry;
- KeAcquireSpinLock(&PiThreadLock, &oldlvl);
+ oldlvl = KeAcquireDispatcherDatabaseLock();
while((ListEntry = RemoveHeadList(&ThreadsToReapHead)) != &ThreadsToReapHead)
{
PiNrThreadsAwaitingReaping--;
- KeReleaseSpinLock(&PiThreadLock, oldlvl);
-
+ KeReleaseDispatcherDatabaseLock(oldlvl);
Thread = CONTAINING_RECORD(ListEntry, ETHREAD, TerminationPortList);
ObDereferenceObject(Thread);
-
- KeAcquireSpinLock(&PiThreadLock, &oldlvl);
+ oldlvl = KeAcquireDispatcherDatabaseLock();
}
- KeReleaseSpinLock(&PiThreadLock, oldlvl);
+ KeReleaseDispatcherDatabaseLock(oldlvl);
}
VOID
DPRINT("PiTerminateProcessThreads(Process %x, ExitStatus %x)\n",
Process, ExitStatus);
+
+ oldlvl = KeAcquireDispatcherDatabaseLock();
- KeAcquireSpinLock(&PiThreadLock, &oldlvl);
-
current_entry = Process->ThreadListHead.Flink;
while (current_entry != &Process->ThreadListHead)
{
DPRINT("Terminating %x, current thread: %x, "
"thread's process: %x\n", current, PsGetCurrentThread(),
current->ThreadsProcess);
- KeReleaseSpinLock(&PiThreadLock, oldlvl);
+ KeReleaseDispatcherDatabaseLock(oldlvl);
PsTerminateOtherThread(current, ExitStatus);
- KeAcquireSpinLock(&PiThreadLock, &oldlvl);
+ oldlvl = KeAcquireDispatcherDatabaseLock();
current_entry = Process->ThreadListHead.Flink;
}
else
current_entry = current_entry->Flink;
}
}
- KeReleaseSpinLock(&PiThreadLock, oldlvl);
+ KeReleaseDispatcherDatabaseLock(oldlvl);
DPRINT("Finished PiTerminateProcessThreads()\n");
}
SIZE_T Length = PAGE_SIZE;
PVOID TebBlock;
- KeLowerIrql(PASSIVE_LEVEL);
+ 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 */
KeCancelTimer(&CurrentThread->Tcb.Timer);
- KeAcquireSpinLock(&PiThreadLock, &oldIrql);
+ oldIrql = KeAcquireDispatcherDatabaseLock();
DPRINT("terminating %x\n",CurrentThread);
- CurrentThread->HasTerminated = TRUE;
CurrentThread->ExitStatus = ExitStatus;
KeQuerySystemTime((PLARGE_INTEGER)&CurrentThread->ExitTime);
InterlockedCompareExchangePointer(&KeGetCurrentKPCR()->PrcbData.NpxThread,
NULL, ETHREAD_TO_KTHREAD(CurrentThread));
- KeReleaseSpinLock(&PiThreadLock, oldIrql);
+ KeReleaseDispatcherDatabaseLock(oldIrql);
PsLockProcess(CurrentProcess, FALSE);
oldIrql = KeAcquireDispatcherDatabaseLock();
CurrentThread->Tcb.DispatcherHeader.SignalState = TRUE;
- KiDispatcherObjectWake(&CurrentThread->Tcb.DispatcherHeader);
+ KiDispatcherObjectWake(&CurrentThread->Tcb.DispatcherHeader, IO_NO_INCREMENT);
KeReleaseDispatcherDatabaseLock (oldIrql);
/* The last thread shall close the door on exit */
PiTerminateProcess(CurrentProcess, ExitStatus);
}
- KeAcquireSpinLock(&PiThreadLock, &oldIrql);
+ oldIrql = KeAcquireDispatcherDatabaseLock();
#ifdef _ENABLE_THRDEVTPAIR
ExpSwapThreadEventPair(CurrentThread, NULL); /* Release the associated eventpair object, if there was one */
PVOID SystemArgument1,
PVOID SystemArgument2)
{
- PsTerminateCurrentThread(PsGetCurrentThread()->ExitStatus);
+ PsTerminateCurrentThread((NTSTATUS)SystemArgument1);
}
VOID
DPRINT("PsTerminateOtherThread(Thread %x, ExitStatus %x)\n",
Thread, ExitStatus);
- KeAcquireSpinLock(&PiThreadLock, &OldIrql);
- if (Thread->HasTerminated)
+ OldIrql = KeAcquireDispatcherDatabaseLock();
+ if (Thread->HasTerminated & TERMINATE_APC)
{
- KeReleaseSpinLock(&PiThreadLock, OldIrql);
+ KeReleaseDispatcherDatabaseLock (OldIrql);
return;
}
- Thread->HasTerminated = TRUE;
- KeReleaseSpinLock(&PiThreadLock, OldIrql);
- Thread->ExitStatus = ExitStatus;
+ Thread->HasTerminated |= TERMINATE_APC;
+ KeReleaseDispatcherDatabaseLock (OldIrql);
Apc = ExAllocatePoolWithTag(NonPagedPool, sizeof(KAPC), TAG_TERMINATE_APC);
KeInitializeApc(Apc,
&Thread->Tcb,
KernelMode,
NULL);
KeInsertQueueApc(Apc,
- NULL,
+ (PVOID)ExitStatus,
NULL,
IO_NO_INCREMENT);
ObGetObjectHandleCount(Process));
ObReferenceObject(Process);
- if (InterlockedExchange((PLONG)&Process->Pcb.State,
- PROCESS_STATE_TERMINATED) ==
+ if (InterlockedExchangeUL(&Process->Pcb.State,
+ PROCESS_STATE_TERMINATED) ==
PROCESS_STATE_TERMINATED)
{
ObDereferenceObject(Process);
}
OldIrql = KeAcquireDispatcherDatabaseLock ();
Process->Pcb.DispatcherHeader.SignalState = TRUE;
- KiDispatcherObjectWake(&Process->Pcb.DispatcherHeader);
+ KiDispatcherObjectWake(&Process->Pcb.DispatcherHeader, IO_NO_INCREMENT);
KeReleaseDispatcherDatabaseLock (OldIrql);
ObDereferenceObject(Process);
return(STATUS_SUCCESS);
NTSTATUS Status;
PEPROCESS Process;
+ PAGED_CODE();
+
DPRINT("NtTerminateProcess(ProcessHandle %x, ExitStatus %x)\n",
ProcessHandle, ExitStatus);
PETHREAD Thread;
NTSTATUS Status;
+ PAGED_CODE();
+
Status = ObReferenceObjectByHandle(ThreadHandle,
THREAD_TERMINATE,
PsThreadType,
PLIST_ENTRY current_entry;
PEPORT_TERMINATION_REQUEST current;
+ PAGED_CODE();
+
KeAcquireSpinLock(&Thread->ActiveTimerListLock, &oldIrql);
while ((current_entry = RemoveHeadList(&Thread->TerminationPortList)) !=
&Thread->TerminationPortList);
KIRQL oldIrql;
PETHREAD Thread;
+ PAGED_CODE();
+
Status = ObReferenceObjectByHandle(PortHandle,
PORT_ALL_ACCESS,
- ExPortType,
+ LpcPortObjectType,
KeGetCurrentThread()->PreviousMode,
(PVOID*)&TerminationPort,
NULL);