[ros-diffs] [royce] 14546: use tags for pool allocations, and reformat code

use tags for pool allocations, and reformat code
Modified: trunk/reactos/ntoskrnl/ps/create.c
  _____  

Modified: trunk/reactos/ntoskrnl/ps/create.c
--- trunk/reactos/ntoskrnl/ps/create.c	2005-04-08 12:54:37 UTC (rev
14545)
+++ trunk/reactos/ntoskrnl/ps/create.c	2005-04-08 13:02:23 UTC (rev
14546)
@@ -4,7 +4,7 @@

  * PROJECT:         ReactOS kernel
  * FILE:            ntoskrnl/ps/create.c
  * PURPOSE:         Thread managment
- * 
+ *
  * PROGRAMMERS:     David Welch (welch(a)mcmail.com)
  *                  Phillip Susi
  *                  Skywing
@@ -12,10 +12,10 @@
 
 /*
  * NOTE:
- * 
+ *
  * All of the routines that manipulate the thread queue synchronize on
  * a single spinlock
- * 
+ *
  */
 
 /* INCLUDES
****************************************************************/
@@ -27,6 +27,7 @@
 /* GLOBAL
*******************************************************************/
 
 #define MAX_THREAD_NOTIFY_ROUTINE_COUNT    8
+#define TAG_KAPC TAG('k','p','a','p') /* kpap - kernel ps
apc */
 
 static ULONG PiThreadNotifyRoutineCount = 0;
 static PCREATE_THREAD_NOTIFY_ROUTINE
@@ -40,462 +41,475 @@
 VOID
 PiBeforeBeginThread(CONTEXT c)
 {
-   KeLowerIrql(PASSIVE_LEVEL);
+    KeLowerIrql(PASSIVE_LEVEL);
 }
 
 NTSTATUS
-PsInitializeThread(PEPROCESS Process,
-		   PETHREAD* ThreadPtr,
-		   POBJECT_ATTRIBUTES ObjectAttributes,
-		   KPROCESSOR_MODE AccessMode,
-		   BOOLEAN First)
+PsInitializeThread (
+    PEPROCESS Process,
+    PETHREAD* ThreadPtr,
+    POBJECT_ATTRIBUTES ObjectAttributes,
+    KPROCESSOR_MODE AccessMode,
+    BOOLEAN First )
 {
-   PETHREAD Thread;
-   NTSTATUS Status;
-   KIRQL oldIrql;
-   
-   PAGED_CODE();
-   
-   if (Process == NULL)
-     {
-	Process = PsInitialSystemProcess;
-     }
-   
-   /*
+    PETHREAD Thread;
+    NTSTATUS Status;
+    KIRQL oldIrql;
+
+    PAGED_CODE();
+
+    if (Process == NULL)
+    {
+        Process = PsInitialSystemProcess;
+    }
+
+    /*
     * Create and initialize thread
     */
-   Status = ObCreateObject(AccessMode,
-			   PsThreadType,
-			   ObjectAttributes,
-			   KernelMode,
-			   NULL,
-			   sizeof(ETHREAD),
-			   0,
-			   0,
-			   (PVOID*)&Thread);
-   if (!NT_SUCCESS(Status))
-     {
+    Status = ObCreateObject(AccessMode,
+        PsThreadType,
+        ObjectAttributes,
+        KernelMode,
+        NULL,
+        sizeof(ETHREAD),
+        0,
+        0,
+        (PVOID*)&Thread);
+    if (!NT_SUCCESS(Status))
+    {
         return(Status);
-     }
+    }
 
-   /*
+    /*
     * Reference process
     */
-   ObReferenceObjectByPointer(Process,
-                              PROCESS_CREATE_THREAD,
-                              PsProcessType,
-                              KernelMode);
+    ObReferenceObjectByPointer(Process,
+        PROCESS_CREATE_THREAD,
+        PsProcessType,
+        KernelMode);
 
-   Thread->ThreadsProcess = Process;
-   Thread->Cid.UniqueThread = NULL;
-   Thread->Cid.UniqueProcess =
(HANDLE)Thread->ThreadsProcess->UniqueProcessId;
+    Thread->ThreadsProcess = Process;
+    Thread->Cid.UniqueThread = NULL;
+    Thread->Cid.UniqueProcess =
(HANDLE)Thread->ThreadsProcess->UniqueProcessId;
 
-   DPRINT("Thread = %x\n",Thread);
+    DPRINT("Thread = %x\n",Thread);
 
-   KeInitializeThread(&Process->Pcb, &Thread->Tcb, First);
-   InitializeListHead(&Thread->ActiveTimerListHead);
-   KeInitializeSpinLock(&Thread->ActiveTimerListLock);
-   InitializeListHead(&Thread->IrpList);
-   Thread->DeadThread = FALSE;
-   Thread->HasTerminated = FALSE;
-   Thread->Tcb.Win32Thread = NULL;
-   DPRINT("Thread->Cid.UniqueThread %d\n",Thread->Cid.UniqueThread);
-   
+    KeInitializeThread(&Process->Pcb, &Thread->Tcb, First);
+    InitializeListHead(&Thread->ActiveTimerListHead);
+    KeInitializeSpinLock(&Thread->ActiveTimerListLock);
+    InitializeListHead(&Thread->IrpList);
+    Thread->DeadThread = FALSE;
+    Thread->HasTerminated = FALSE;
+    Thread->Tcb.Win32Thread = NULL;
+    DPRINT("Thread->Cid.UniqueThread %d\n",Thread->Cid.UniqueThread);
 
-   Thread->Tcb.BasePriority = (CHAR)Process->Pcb.BasePriority;
-   Thread->Tcb.Priority = Thread->Tcb.BasePriority;
 
-   /*
+    Thread->Tcb.BasePriority = (CHAR)Process->Pcb.BasePriority;
+    Thread->Tcb.Priority = Thread->Tcb.BasePriority;
+
+    /*
     * Local Procedure Call facility (LPC)
     */
-   KeInitializeSemaphore  (& Thread->LpcReplySemaphore, 0, LONG_MAX);
-   Thread->LpcReplyMessage = NULL;
-   Thread->LpcReplyMessageId = 0; /* not valid */
-   /* Thread->LpcReceiveMessageId = 0; */
-   Thread->LpcExitThreadCalled = FALSE;
-   Thread->LpcReceivedMsgIdValid = FALSE;
+    KeInitializeSemaphore  (& Thread->LpcReplySemaphore, 0, LONG_MAX);
+    Thread->LpcReplyMessage = NULL;
+    Thread->LpcReplyMessageId = 0; /* not valid */
+    /* Thread->LpcReceiveMessageId = 0; */
+    Thread->LpcExitThreadCalled = FALSE;
+    Thread->LpcReceivedMsgIdValid = FALSE;
 
-   oldIrql = KeAcquireDispatcherDatabaseLock();
-   InsertTailList(&Process->ThreadListHead,
-		  &Thread->ThreadListEntry);
-   KeReleaseDispatcherDatabaseLock(oldIrql);
+    oldIrql = KeAcquireDispatcherDatabaseLock();
+    InsertTailList(&Process->ThreadListHead,
+        &Thread->ThreadListEntry);
+    KeReleaseDispatcherDatabaseLock(oldIrql);
 
-   *ThreadPtr = Thread;
+    *ThreadPtr = Thread;
 
-   return STATUS_SUCCESS;
+    return STATUS_SUCCESS;
 }
 
 
 static NTSTATUS
-PsCreateTeb(HANDLE ProcessHandle,
-	    PTEB *TebPtr,
-	    PETHREAD Thread,
-	    PINITIAL_TEB InitialTeb)
+PsCreateTeb (
+    HANDLE ProcessHandle,
+    PTEB *TebPtr,
+    PETHREAD Thread,
+    PINITIAL_TEB InitialTeb )
 {
-   PEPROCESS Process;
-   NTSTATUS Status;
-   ULONG ByteCount;
-   ULONG RegionSize;
-   ULONG TebSize;
-   PVOID TebBase;
-   TEB Teb;
-   
-   PAGED_CODE();
+    PEPROCESS Process;
+    NTSTATUS Status;
+    ULONG ByteCount;
+    ULONG RegionSize;
+    ULONG TebSize;
+    PVOID TebBase;
+    TEB Teb;
 
-   TebSize = PAGE_SIZE;
+    PAGED_CODE();
 
-   if (NULL == Thread->ThreadsProcess)
-     {
-       /* We'll be allocating a 64k block here and only use 4k of it,
but this
-          path should almost never be taken. Actually, I never saw it
was taken,
-          so maybe we should just ASSERT(NULL !=
Thread->ThreadsProcess) and
-          move on */
-       TebBase = NULL;
-       Status = ZwAllocateVirtualMemory(ProcessHandle,
-                                        &TebBase,
-                                        0,
-                                        &TebSize,
-                                        MEM_RESERVE | MEM_COMMIT |
MEM_TOP_DOWN,
-                                        PAGE_READWRITE);
-       if (! NT_SUCCESS(Status))
-         {
-           DPRINT1("Failed to allocate virtual memory for TEB\n");
-           return Status;
-         }
-     }
-   else
-     {
-       Process = Thread->ThreadsProcess;
-       PsLockProcess(Process, FALSE);
-       if (NULL == Process->TebBlock ||
-           Process->TebBlock == Process->TebLastAllocated)
-         {
-           Process->TebBlock = NULL;
-           RegionSize = MM_VIRTMEM_GRANULARITY;
-           Status = ZwAllocateVirtualMemory(ProcessHandle,
-                                            &Process->TebBlock,
-                                            0,
-                                            &RegionSize,
-                                            MEM_RESERVE | MEM_TOP_DOWN,
-                                            PAGE_READWRITE);
-           if (! NT_SUCCESS(Status))
-             {
-               PsUnlockProcess(Process);
-               DPRINT1("Failed to reserve virtual memory for TEB\n");
-               return Status;
-             }
-           Process->TebLastAllocated = (PVOID) ((char *)
Process->TebBlock + RegionSize);
-         }
-       TebBase = (PVOID) ((char *) Process->TebLastAllocated -
PAGE_SIZE);
-       Status = ZwAllocateVirtualMemory(ProcessHandle,
-                                        &TebBase,
-                                        0,
-                                        &TebSize,
-                                        MEM_COMMIT,
-                                        PAGE_READWRITE);
-       if (! NT_SUCCESS(Status))
-         {
-           DPRINT1("Failed to commit virtual memory for TEB\n");
-           return Status;
-         }
-       Process->TebLastAllocated = TebBase;
-       PsUnlockProcess(Process);
-     }
+    TebSize = PAGE_SIZE;
 
-   DPRINT ("TebBase %p TebSize %lu\n", TebBase, TebSize);
-   ASSERT(NULL != TebBase && PAGE_SIZE <= TebSize);
-
-   RtlZeroMemory(&Teb, sizeof(TEB));
-   /* set all pointers to and from the TEB */
-   Teb.Tib.Self = TebBase;
-   if (Thread->ThreadsProcess)
-     {
-        Teb.Peb = Thread->ThreadsProcess->Peb; /* No PEB yet!! */
-     }
-   DPRINT("Teb.Peb %x\n", Teb.Peb);
-   
-   /* store stack information from InitialTeb */
-   if(InitialTeb != NULL)
-   {
-    /* fixed-size stack */
-    if(InitialTeb->StackBase && InitialTeb->StackLimit)
+    if (NULL == Thread->ThreadsProcess)
     {
-     Teb.Tib.StackBase = InitialTeb->StackBase;
-     Teb.Tib.StackLimit = InitialTeb->StackLimit;
-     Teb.DeallocationStack = InitialTeb->StackLimit;
+    /* We'll be allocating a 64k block here and only use 4k of it, but
this
+    path should almost never be taken. Actually, I never saw it was
taken,
+    so maybe we should just ASSERT(NULL != Thread->ThreadsProcess) and
+        move on */
+        TebBase = NULL;
+        Status = ZwAllocateVirtualMemory(ProcessHandle,
+            &TebBase,
+            0,
+            &TebSize,
+            MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
+            PAGE_READWRITE);
+        if (! NT_SUCCESS(Status))
+        {
+            DPRINT1("Failed to allocate virtual memory for TEB\n");
+            return Status;
+        }
     }
-    /* expandable stack */
     else
     {
-     Teb.Tib.StackBase = InitialTeb->StackCommit;
-     Teb.Tib.StackLimit = InitialTeb->StackCommitMax;
-     Teb.DeallocationStack = InitialTeb->StackReserved;
+        Process = Thread->ThreadsProcess;
+        PsLockProcess(Process, FALSE);
+        if (NULL == Process->TebBlock ||
+            Process->TebBlock == Process->TebLastAllocated)
+        {
+            Process->TebBlock = NULL;
+            RegionSize = MM_VIRTMEM_GRANULARITY;
+            Status = ZwAllocateVirtualMemory(ProcessHandle,
+                &Process->TebBlock,
+                0,
+                &RegionSize,
+                MEM_RESERVE | MEM_TOP_DOWN,
+                PAGE_READWRITE);
+            if (! NT_SUCCESS(Status))
+            {
+                PsUnlockProcess(Process);
+                DPRINT1("Failed to reserve virtual memory for TEB\n");
+                return Status;
+            }
+            Process->TebLastAllocated = (PVOID) ((char *)
Process->TebBlock + RegionSize);
+        }
+        TebBase = (PVOID) ((char *) Process->TebLastAllocated -
PAGE_SIZE);
+        Status = ZwAllocateVirtualMemory(ProcessHandle,
+            &TebBase,
+            0,
+            &TebSize,
+            MEM_COMMIT,
+            PAGE_READWRITE);
+        if (! NT_SUCCESS(Status))
+        {
+            DPRINT1("Failed to commit virtual memory for TEB\n");
+            return Status;
+        }
+        Process->TebLastAllocated = TebBase;
+        PsUnlockProcess(Process);
     }
-   }
 
-   /* more initialization */
-   Teb.Cid.UniqueThread = Thread->Cid.UniqueThread;
-   Teb.Cid.UniqueProcess = Thread->Cid.UniqueProcess;
-   Teb.CurrentLocale = PsDefaultThreadLocaleId;
+    DPRINT ("TebBase %p TebSize %lu\n", TebBase, TebSize);
+    ASSERT(NULL != TebBase && PAGE_SIZE <= TebSize);
 
-   /* Terminate the exception handler list */
-   Teb.Tib.ExceptionList = (PVOID)-1;
-   
-   DPRINT("sizeof(TEB) %x\n", sizeof(TEB));
-   
-   /* write TEB data into teb page */
-   Status = NtWriteVirtualMemory(ProcessHandle,
-                                 TebBase,
-                                 &Teb,
-                                 sizeof(TEB),
-                                 &ByteCount);
+    RtlZeroMemory(&Teb, sizeof(TEB));
+    /* set all pointers to and from the TEB */
+    Teb.Tib.Self = TebBase;
+    if (Thread->ThreadsProcess)
+    {
+        Teb.Peb = Thread->ThreadsProcess->Peb; /* No PEB yet!! */
+    }
+    DPRINT("Teb.Peb %x\n", Teb.Peb);
 
-   if (!NT_SUCCESS(Status))
-     {
+    /* store stack information from InitialTeb */
+    if(InitialTeb != NULL)
+    {
+        /* fixed-size stack */
+        if(InitialTeb->StackBase && InitialTeb->StackLimit)
+        {
+            Teb.Tib.StackBase = InitialTeb->StackBase;
+            Teb.Tib.StackLimit = InitialTeb->StackLimit;
+            Teb.DeallocationStack = InitialTeb->StackLimit;
+        }
+        /* expandable stack */
+        else
+        {
+            Teb.Tib.StackBase = InitialTeb->StackCommit;
+            Teb.Tib.StackLimit = InitialTeb->StackCommitMax;
+            Teb.DeallocationStack = InitialTeb->StackReserved;
+        }
+    }
+
+    /* more initialization */
+    Teb.Cid.UniqueThread = Thread->Cid.UniqueThread;
+    Teb.Cid.UniqueProcess = Thread->Cid.UniqueProcess;
+    Teb.CurrentLocale = PsDefaultThreadLocaleId;
+
+    /* Terminate the exception handler list */
+    Teb.Tib.ExceptionList = (PVOID)-1;
+
+    DPRINT("sizeof(TEB) %x\n", sizeof(TEB));
+
+    /* write TEB data into teb page */
+    Status = NtWriteVirtualMemory(ProcessHandle,
+        TebBase,
+        &Teb,
+        sizeof(TEB),
+        &ByteCount);
+
+    if (!NT_SUCCESS(Status))
+    {
         /* free TEB */
         DPRINT1 ("Writing TEB failed!\n");
 
         RegionSize = 0;
         NtFreeVirtualMemory(ProcessHandle,
-                            TebBase,
-                            &RegionSize,
-                            MEM_RELEASE);
+            TebBase,
+            &RegionSize,
+            MEM_RELEASE);
 
         return Status;
-     }
+    }
 
-   if (TebPtr != NULL)
-     {
+    if (TebPtr != NULL)
+    {
         *TebPtr = (PTEB)TebBase;
-     }
+    }
 
-   DPRINT("TEB allocated at %p\n", TebBase);
+    DPRINT("TEB allocated at %p\n", TebBase);
 
-   return Status;
+    return Status;
 }
 
 
 VOID STDCALL
-LdrInitApcRundownRoutine(PKAPC Apc)
+LdrInitApcRundownRoutine ( PKAPC Apc )
 {
-   ExFreePool(Apc);
+    ExFreePool(Apc);
 }
 
 
 VOID STDCALL
-LdrInitApcKernelRoutine(PKAPC Apc,
-			PKNORMAL_ROUTINE* NormalRoutine,
-			PVOID* NormalContext,
-			PVOID* SystemArgument1,
-			PVOID* SystemArgument2)
+LdrInitApcKernelRoutine (
+    PKAPC Apc,
+    PKNORMAL_ROUTINE* NormalRoutine,
+    PVOID* NormalContext,
+    PVOID* SystemArgument1,
+    PVOID* SystemArgument2)
 {
-  ExFreePool(Apc);
+    ExFreePool(Apc);
 }
 
 
 NTSTATUS STDCALL
-NtCreateThread(OUT PHANDLE ThreadHandle,
-	       IN ACCESS_MASK DesiredAccess,
-	       IN POBJECT_ATTRIBUTES ObjectAttributes  OPTIONAL,
-	       IN HANDLE ProcessHandle,
-	       OUT PCLIENT_ID ClientId,
-	       IN PCONTEXT ThreadContext,
-	       IN PINITIAL_TEB InitialTeb,
-	       IN BOOLEAN CreateSuspended)
+NtCreateThread (
+    OUT PHANDLE ThreadHandle,
+    IN ACCESS_MASK DesiredAccess,
+    IN POBJECT_ATTRIBUTES ObjectAttributes  OPTIONAL,
+    IN HANDLE ProcessHandle,
+    OUT PCLIENT_ID ClientId,
+    IN PCONTEXT ThreadContext,
+    IN PINITIAL_TEB InitialTeb,
+    IN BOOLEAN CreateSuspended )
 {
-  HANDLE hThread;
-  CONTEXT SafeContext;
-  INITIAL_TEB SafeInitialTeb;
-  PEPROCESS Process;
-  PETHREAD Thread;
-  PTEB TebBase;
-  PKAPC LdrInitApc;
-  KIRQL oldIrql;
-  KPROCESSOR_MODE PreviousMode;
-  NTSTATUS Status = STATUS_SUCCESS;
-  
-  PAGED_CODE();
-  
-  if(ThreadContext == NULL)
-  {
-    return STATUS_INVALID_PARAMETER;
-  }
-  
-  PreviousMode = ExGetPreviousMode();
+    HANDLE hThread;
+    CONTEXT SafeContext;
+    INITIAL_TEB SafeInitialTeb;
+    PEPROCESS Process;
+    PETHREAD Thread;
+    PTEB TebBase;
+    PKAPC LdrInitApc;
+    KIRQL oldIrql;
+    KPROCESSOR_MODE PreviousMode;
+    NTSTATUS Status = STATUS_SUCCESS;
 
-  if(PreviousMode != KernelMode)
-  {
-    _SEH_TRY
+    PAGED_CODE();
+
+    if(ThreadContext == NULL)
     {
-      ProbeForWrite(ThreadHandle,
-                    sizeof(HANDLE),
-                    sizeof(ULONG));
-      if(ClientId != NULL)
-      {
-        ProbeForWrite(ClientId,
-                      sizeof(CLIENT_ID),
-                      sizeof(ULONG));
-      }
-      ProbeForRead(ThreadContext,
-                   sizeof(CONTEXT),
-                   sizeof(ULONG));
-      SafeContext = *ThreadContext;
-      ThreadContext = &SafeContext;
-      ProbeForRead(InitialTeb,
-                   sizeof(INITIAL_TEB),
-                   sizeof(ULONG));
-      SafeInitialTeb = *InitialTeb;
-      InitialTeb = &SafeInitialTeb;
+        return STATUS_INVALID_PARAMETER;
     }
-    _SEH_HANDLE
+
+    PreviousMode = ExGetPreviousMode();
+
+    if(PreviousMode != KernelMode)
     {
-      Status = _SEH_GetExceptionCode();
+        _SEH_TRY
+        {
+            ProbeForWrite(ThreadHandle,
+                sizeof(HANDLE),
+                sizeof(ULONG));
+            if(ClientId != NULL)
+            {
+                ProbeForWrite(ClientId,
+                    sizeof(CLIENT_ID),
+                    sizeof(ULONG));
+            }
+            ProbeForRead(ThreadContext,
+                sizeof(CONTEXT),
+                sizeof(ULONG));
+            SafeContext = *ThreadContext;
+            ThreadContext = &SafeContext;
+            ProbeForRead(InitialTeb,
+                sizeof(INITIAL_TEB),
+                sizeof(ULONG));
+            SafeInitialTeb = *InitialTeb;
+            InitialTeb = &SafeInitialTeb;
+        }
+        _SEH_HANDLE
+        {
+            Status = _SEH_GetExceptionCode();
+        }
+        _SEH_END;
+
+        if(!NT_SUCCESS(Status))
+        {
+            return Status;
+        }
     }
-    _SEH_END;
 
+    DPRINT("NtCreateThread(ThreadHandle %x, PCONTEXT %x)\n",
+        ThreadHandle,ThreadContext);
+
+    Status = ObReferenceObjectByHandle(
+        ProcessHandle,
+        PROCESS_CREATE_THREAD,
+        PsProcessType,
+        PreviousMode,
+        (PVOID*)&Process,
+        NULL);
     if(!NT_SUCCESS(Status))
     {
-      return Status;
+        return(Status);
     }
-  }
 
-  DPRINT("NtCreateThread(ThreadHandle %x, PCONTEXT %x)\n",
-	 ThreadHandle,ThreadContext);
-
-  Status = ObReferenceObjectByHandle(ProcessHandle,
-                                     PROCESS_CREATE_THREAD,
-                                     PsProcessType,
-                                     PreviousMode,
-                                     (PVOID*)&Process,
-                                     NULL);
-  if(!NT_SUCCESS(Status))
-  {
-    return(Status);
-  }
-  
-  Status = PsLockProcess(Process, FALSE);
-  if (!NT_SUCCESS(Status))
+    Status = PsLockProcess(Process, FALSE);
+    if (!NT_SUCCESS(Status))
     {
-       ObDereferenceObject(Process);
-       return(Status);
+        ObDereferenceObject(Process);
+        return(Status);
     }
 
-  if(Process->ExitTime.QuadPart != 0)
+    if(Process->ExitTime.QuadPart != 0)
     {
-       PsUnlockProcess(Process);
-       return STATUS_PROCESS_IS_TERMINATING;
+        PsUnlockProcess(Process);
+        return STATUS_PROCESS_IS_TERMINATING;
     }
 
-  PsUnlockProcess(Process);
+    PsUnlockProcess(Process);
 
-  Status = PsInitializeThread(Process,
-			      &Thread,
-			      ObjectAttributes,
-			      PreviousMode,
-			      FALSE);
+    Status = PsInitializeThread(Process,
+        &Thread,
+        ObjectAttributes,
+        PreviousMode,
+        FALSE);
 
-  ObDereferenceObject(Process);
-  
-  if (!NT_SUCCESS(Status))
+    ObDereferenceObject(Process);
+
+    if (!NT_SUCCESS(Status))
     {
-      return(Status);
+        return(Status);
     }
-  
-  /* create a client id handle */
-  Status = PsCreateCidHandle(Thread, PsThreadType,
&Thread->Cid.UniqueThread);
-  if (!NT_SUCCESS(Status))
+
+    /* create a client id handle */
+    Status = PsCreateCidHandle (
+        Thread, PsThreadType, &Thread->Cid.UniqueThread);
+    if (!NT_SUCCESS(Status))
     {
-      ObDereferenceObject(Thread);
-      return Status;
+        ObDereferenceObject(Thread);
+        return Status;
     }
 
-  Status = KiArchInitThreadWithContext(&Thread->Tcb, ThreadContext);
-  if (!NT_SUCCESS(Status))
+    Status = KiArchInitThreadWithContext(&Thread->Tcb, ThreadContext);
+    if (!NT_SUCCESS(Status))
     {
-      PsDeleteCidHandle(Thread->Cid.UniqueThread, PsThreadType);
-      ObDereferenceObject(Thread);
-      return(Status);
+        PsDeleteCidHandle(Thread->Cid.UniqueThread, PsThreadType);
+        ObDereferenceObject(Thread);
+        return(Status);
     }
 
-  Status = PsCreateTeb(ProcessHandle,
-		       &TebBase,
-		       Thread,
-		       InitialTeb);
-  if (!NT_SUCCESS(Status))
+    Status = PsCreateTeb(ProcessHandle,
+        &TebBase,
+        Thread,
+        InitialTeb);
+    if (!NT_SUCCESS(Status))
     {
-      PsDeleteCidHandle(Thread->Cid.UniqueThread, PsThreadType);
-      ObDereferenceObject(Thread);
-      return(Status);
+        PsDeleteCidHandle(Thread->Cid.UniqueThread, PsThreadType);
+        ObDereferenceObject(Thread);
+        return(Status);
     }
-  Thread->Tcb.Teb = TebBase;
+    Thread->Tcb.Teb = TebBase;
 
-  Thread->StartAddress = NULL;
+    Thread->StartAddress = NULL;
 
-  /*
-   * Maybe send a message to the process's debugger
-   */
-  DbgkCreateThread((PVOID)ThreadContext->Eip);
+    /*
+    * Maybe send a message to the process's debugger
+    */
+    DbgkCreateThread((PVOID)ThreadContext->Eip);
 
-  /*
-   * First, force the thread to be non-alertable for user-mode alerts.
-   */
-  Thread->Tcb.Alertable = FALSE;
+    /*
+    * First, force the thread to be non-alertable for user-mode alerts.
+    */
+    Thread->Tcb.Alertable = FALSE;
 
-  /*
-   * If the thread is to be created suspended then queue an APC to
-   * do the suspend before we run any userspace code.
-   */
-  if (CreateSuspended)
+    /*
+    * If the thread is to be created suspended then queue an APC to
+    * do the suspend before we run any userspace code.
+    */
+    if (CreateSuspended)
     {
-      KeSuspendThread(&Thread->Tcb);
+        KeSuspendThread(&Thread->Tcb);
     }
 
-  /*
-   * Queue an APC to the thread that will execute the ntdll startup
-   * routine.
-   */
-  LdrInitApc = ExAllocatePool(NonPagedPool, sizeof(KAPC));
-  KeInitializeApc(LdrInitApc, &Thread->Tcb, OriginalApcEnvironment,
LdrInitApcKernelRoutine,
-		  LdrInitApcRundownRoutine,
LdrpGetSystemDllEntryPoint(), 
-		  UserMode, NULL);
-  KeInsertQueueApc(LdrInitApc, NULL, NULL, IO_NO_INCREMENT);
-  
-  /* 
-   * The thread is non-alertable, so the APC we added did not set
UserApcPending to TRUE. 
-   * We must do this manually. Do NOT attempt to set the Thread to
Alertable before the call,
-   * doing so is a blatant and erronous hack.
-   */
-  Thread->Tcb.ApcState.UserApcPending = TRUE;
-  Thread->Tcb.Alerted[KernelMode] = TRUE;
+    /*
+    * Queue an APC to the thread that will execute the ntdll startup
+    * routine.
+    */
+    LdrInitApc = ExAllocatePoolWithTag (
+        NonPagedPool, sizeof(KAPC), TAG_KAPC );
+    KeInitializeApc (
+        LdrInitApc,
+        &Thread->Tcb,
+        OriginalApcEnvironment,
+        LdrInitApcKernelRoutine,
+        LdrInitApcRundownRoutine,
+        LdrpGetSystemDllEntryPoint(),
+        UserMode,
+        NULL );
+    KeInsertQueueApc(LdrInitApc, NULL, NULL, IO_NO_INCREMENT);
 
-  oldIrql = KeAcquireDispatcherDatabaseLock ();
-  KiUnblockThread(&Thread->Tcb, NULL, 0);
-  KeReleaseDispatcherDatabaseLock(oldIrql);
+    /*
+    * The thread is non-alertable, so the APC we added did not set
UserApcPending to TRUE.
+    * We must do this manually. Do NOT attempt to set the Thread to
Alertable before the call,
+    * doing so is a blatant and erronous hack.
+    */
+    Thread->Tcb.ApcState.UserApcPending = TRUE;
+    Thread->Tcb.Alerted[KernelMode] = TRUE;
 
-  Status = ObInsertObject((PVOID)Thread,
-			  NULL,
-			  DesiredAccess,
-			  0,
-			  NULL,
-			  &hThread);
-  if(NT_SUCCESS(Status))
-  {
-    _SEH_TRY
+    oldIrql = KeAcquireDispatcherDatabaseLock ();
+    KiUnblockThread(&Thread->Tcb, NULL, 0);
+    KeReleaseDispatcherDatabaseLock(oldIrql);
+
+    Status = ObInsertObject((PVOID)Thread,
+        NULL,
+        DesiredAccess,
+        0,
+        NULL,
+        &hThread);
+    if(NT_SUCCESS(Status))
     {
-      if(ClientId != NULL)
-      {
-        *ClientId = Thread->Cid;
-      }
-      *ThreadHandle = hThread;
+        _SEH_TRY
+        {
+            if(ClientId != NULL)
+            {
+                *ClientId = Thread->Cid;
+            }
+            *ThreadHandle = hThread;
+        }
+        _SEH_HANDLE
+        {
+            Status = _SEH_GetExceptionCode();
+        }
+        _SEH_END;
     }
-    _SEH_HANDLE
-    {
-      Status = _SEH_GetExceptionCode();
-    }
-    _SEH_END;
-  }
-  
-  return Status;
+
+    return Status;
 }
 
 
@@ -503,17 +517,18 @@
  * @implemented
  */
 NTSTATUS STDCALL
-PsCreateSystemThread(PHANDLE ThreadHandle,
-		     ACCESS_MASK DesiredAccess,
-		     POBJECT_ATTRIBUTES ObjectAttributes,
-		     HANDLE ProcessHandle,
-		     PCLIENT_ID ClientId,
-		     PKSTART_ROUTINE StartRoutine,
-		     PVOID StartContext)
+PsCreateSystemThread (
+    PHANDLE ThreadHandle,
+    ACCESS_MASK DesiredAccess,
+    POBJECT_ATTRIBUTES ObjectAttributes,
+    HANDLE ProcessHandle,
+    PCLIENT_ID ClientId,
+    PKSTART_ROUTINE StartRoutine,
+    PVOID StartContext )
 /*
  * FUNCTION: Creates a thread which executes in kernel mode
  * ARGUMENTS:
- *       ThreadHandle (OUT) = Caller supplied storage for the returned
thread 
+ *       ThreadHandle (OUT) = Caller supplied storage for the returned
thread
  *                            handle
  *       DesiredAccess = Requested access to the thread
  *       ObjectAttributes = Object attributes (optional)
@@ -527,78 +542,82 @@
  * RETURNS: Success or failure status
  */
 {
-   PETHREAD Thread;
-   NTSTATUS Status;
-   KIRQL oldIrql;
-   
-   PAGED_CODE();
-   
-   DPRINT("PsCreateSystemThread(ThreadHandle %x, ProcessHandle %x)\n",
-	    ThreadHandle,ProcessHandle);
-   
-   Status = PsInitializeThread(NULL,
-			       &Thread,
-			       ObjectAttributes,
-			       KernelMode,
-			       FALSE);
-   if (!NT_SUCCESS(Status))
-     {
-	return(Status);
-     }
+    PETHREAD Thread;
+    NTSTATUS Status;
+    KIRQL oldIrql;
 
+    PAGED_CODE();
+
+    DPRINT("PsCreateSystemThread(ThreadHandle %x, ProcessHandle %x)\n",
+        ThreadHandle,ProcessHandle);
+
+    Status = PsInitializeThread(
+        NULL,
+        &Thread,
+        ObjectAttributes,
+        KernelMode,
+        FALSE);
+    if (!NT_SUCCESS(Status))
+    {
+        return(Status);
+    }
+
     /* Set the thread as a system thread */
     Thread->SystemThread = TRUE;
-     
-   Status = PsCreateCidHandle(Thread,
-                              PsThreadType,
-                              &Thread->Cid.UniqueThread);
-   if(!NT_SUCCESS(Status))
-   {
-     ObDereferenceObject(Thread);
-     return Status;
-   }
-   
-   Thread->StartAddress = StartRoutine;
-   Status = KiArchInitThread(&Thread->Tcb, StartRoutine, StartContext);
-   if (!NT_SUCCESS(Status))
-     {
+
+    Status = PsCreateCidHandle(Thread,
+        PsThreadType,
+        &Thread->Cid.UniqueThread);
+    if(!NT_SUCCESS(Status))
+    {
         ObDereferenceObject(Thread);
+        return Status;
+    }
+
+    Thread->StartAddress = StartRoutine;
+    Status = KiArchInitThread (
+        &Thread->Tcb, StartRoutine, StartContext);
+    if (!NT_SUCCESS(Status))
+    {
+        ObDereferenceObject(Thread);
         return(Status);
-     }
+    }
 
-   if (ClientId != NULL)
-     {
-	*ClientId=Thread->Cid;
-     }
+    if (ClientId != NULL)
+    {
+        *ClientId=Thread->Cid;
+    }
 
-   oldIrql = KeAcquireDispatcherDatabaseLock ();
-   KiUnblockThread(&Thread->Tcb, NULL, 0);
-   KeReleaseDispatcherDatabaseLock(oldIrql);
-   
-   Status = ObInsertObject((PVOID)Thread,
-			   NULL,
-			   DesiredAccess,
-			   0,
-			   NULL,
-			   ThreadHandle);
-   
-   /* don't dereference the thread, the initial reference serves as the
keep-alive
-      reference which will be removed by the thread reaper */
-   
-   return Status;
+    oldIrql = KeAcquireDispatcherDatabaseLock ();
+    KiUnblockThread(&Thread->Tcb, NULL, 0);
+    KeReleaseDispatcherDatabaseLock(oldIrql);
+
+    Status = ObInsertObject(
+        (PVOID)Thread,
[truncated at 1000 lines; 58 more skipped]