Implemented SetThreadAffinityMask().

Fixed some *nix line breaks.

svn path=/trunk/; revision=3817

reactos/lib/kernel32/thread/thread.c

@@ -1,4 +1,4 @@
-/* $Id: thread.c,v 1.31 2002/10/25 22:59:55 chorns Exp $
+/* $Id: thread.c,v 1.32 2002/12/02 21:28:40 ekohl Exp $
  *
  * COPYRIGHT:       See COPYING in the top level directory
  * PROJECT:         ReactOS system libraries
@@ -27,23 +27,21 @@ static VOID ThreadAttachDlls (VOID);
 
 /* FUNCTIONS *****************************************************************/
 
-static
+static EXCEPTION_DISPOSITION __cdecl
-EXCEPTION_DISPOSITION
+_except_handler(struct _EXCEPTION_RECORD *ExceptionRecord,
-__cdecl
-_except_handler(
-    struct _EXCEPTION_RECORD *ExceptionRecord,
 		void * EstablisherFrame,
 		struct _CONTEXT *ContextRecord,
-    void * DispatcherContext )
+		void * DispatcherContext)
 {
   ExitThread(0);
 
   /* We should not get to here */
-	return ExceptionContinueSearch;
+  return(ExceptionContinueSearch);
 }
 
+
 static VOID STDCALL
-ThreadStartup (LPTHREAD_START_ROUTINE lpStartAddress,
+ThreadStartup(LPTHREAD_START_ROUTINE lpStartAddress,
 	      LPVOID lpParameter)
 {
   UINT uExitCode;
@@ -52,14 +50,17 @@ ThreadStartup (LPTHREAD_START_ROUTINE lpStartAddress,
   {
     /* FIXME: notify csrss of thread creation ?? */
     uExitCode = (lpStartAddress)(lpParameter);
-   } __except1
+  }
+  __except1
   {
   }
 
   ExitThread(uExitCode);
 }
 
-HANDLE STDCALL CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
+
+HANDLE STDCALL
+CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
 	     DWORD dwStackSize,
 	     LPTHREAD_START_ROUTINE lpStartAddress,
 	     LPVOID lpParameter,
@@ -75,7 +76,9 @@ HANDLE STDCALL CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
 			     lpThreadId));
 }
 
-HANDLE STDCALL CreateRemoteThread(HANDLE hProcess,
+
+HANDLE STDCALL
+CreateRemoteThread(HANDLE hProcess,
 		   LPSECURITY_ATTRIBUTES lpThreadAttributes,
 		   DWORD dwStackSize,
 		   LPTHREAD_START_ROUTINE lpStartAddress,
@@ -233,12 +236,14 @@ HANDLE STDCALL CreateRemoteThread(HANDLE hProcess,
   return(ThreadHandle);
 }
 
+
 PTEB
 GetTeb(VOID)
 {
   return(NtCurrentTeb());
 }
 
+
 WINBOOL STDCALL
 SwitchToThread(VOID)
 {
@@ -247,12 +252,14 @@ SwitchToThread(VOID)
   return TRUE;
 }
 
+
 DWORD STDCALL
-GetCurrentThreadId()
+GetCurrentThreadId(VOID)
 {
   return((DWORD)(NtCurrentTeb()->Cid).UniqueThread);
 }
 
+
 VOID STDCALL
 ExitThread(DWORD uExitCode)
 {
@@ -286,7 +293,9 @@ ExitThread(DWORD uExitCode)
      }
 }
 
-WINBOOL STDCALL GetThreadTimes(HANDLE hThread,
+
+WINBOOL STDCALL
+GetThreadTimes(HANDLE hThread,
 	       LPFILETIME lpCreationTime,
 	       LPFILETIME lpExitTime,
 	       LPFILETIME lpKernelTime,
@@ -314,163 +323,214 @@ WINBOOL STDCALL GetThreadTimes(HANDLE hThread,
 }
 
 
-WINBOOL STDCALL GetThreadContext(HANDLE hThread,
+WINBOOL STDCALL
+GetThreadContext(HANDLE hThread,
 		 LPCONTEXT lpContext)
 {
-   NTSTATUS errCode;
+  NTSTATUS Status;
 
-   errCode = NtGetContextThread(hThread,
+  Status = NtGetContextThread(hThread,
 			      lpContext);
-   if (!NT_SUCCESS(errCode))
+  if (!NT_SUCCESS(Status))
     {
-	SetLastErrorByStatus(errCode);
+      SetLastErrorByStatus(Status);
-	return FALSE;
+      return(FALSE);
     }
-   return TRUE;
-}
 
-WINBOOL STDCALL SetThreadContext(HANDLE hThread,
+  return(TRUE);
-				 CONST CONTEXT *lpContext)
-{
-   NTSTATUS errCode;
-   
-   errCode = NtSetContextThread(hThread,
-				(void *)lpContext);
-   if (!NT_SUCCESS(errCode))
-     {
-	SetLastErrorByStatus(errCode);
-	return FALSE;
-     }
-   return TRUE;
-}
-
-WINBOOL STDCALL GetExitCodeThread(HANDLE hThread,
-				  LPDWORD lpExitCode)
-{
-   NTSTATUS errCode;
-   THREAD_BASIC_INFORMATION ThreadBasic;
-   ULONG DataWritten;
-   
-   errCode = NtQueryInformationThread(hThread,
-				      ThreadBasicInformation,
-				      &ThreadBasic,
-				      sizeof(THREAD_BASIC_INFORMATION),
-				      &DataWritten);
-   if (!NT_SUCCESS(errCode))
-     {
-	SetLastErrorByStatus(errCode);
-	return FALSE;
-     }
-   memcpy(lpExitCode, &ThreadBasic.ExitStatus, sizeof(DWORD));
-   return TRUE;
-}
-
-DWORD STDCALL ResumeThread(HANDLE hThread)
-{
-   NTSTATUS errCode;
-   ULONG PreviousResumeCount;
-   
-   errCode = NtResumeThread(hThread,
-			    &PreviousResumeCount);
-   if (!NT_SUCCESS(errCode))
-     {
-	SetLastErrorByStatus(errCode);
-	return  -1;
-     }
-   return PreviousResumeCount;
 }
 
 
 WINBOOL STDCALL
-TerminateThread (HANDLE	hThread,
+SetThreadContext(HANDLE hThread,
-		 DWORD	dwExitCode)
+		 CONST CONTEXT *lpContext)
 {
-    if (0 == hThread)
+  NTSTATUS Status;
-    {
-        SetLastError (ERROR_INVALID_HANDLE);
-    }
-    else
-    {
-        NTSTATUS Status = NtTerminateThread (hThread, dwExitCode);
 
-        if (NT_SUCCESS(Status))
+  Status = NtSetContextThread(hThread,
+			      (void *)lpContext);
+  if (!NT_SUCCESS(Status))
     {
-            return TRUE;
+      SetLastErrorByStatus(Status);
+      return(FALSE);
     }
-        SetLastErrorByStatus (Status);
+
-    }
+  return(TRUE);
-    return FALSE;
 }
 
 
-DWORD STDCALL SuspendThread(HANDLE hThread)
+WINBOOL STDCALL
+GetExitCodeThread(HANDLE hThread,
+		  LPDWORD lpExitCode)
 {
-   NTSTATUS errCode;
-   ULONG PreviousSuspendCount;
-   
-   errCode = NtSuspendThread(hThread,
-			     &PreviousSuspendCount);
-   if (!NT_SUCCESS(errCode))
-     {
-	SetLastErrorByStatus(errCode);
-	return -1;
-     }
-   return PreviousSuspendCount;
-}
-
-DWORD STDCALL SetThreadAffinityMask(HANDLE hThread,
-				    DWORD dwThreadAffinityMask)
-{
-   return 0;
-}
-
-WINBOOL STDCALL SetThreadPriority(HANDLE hThread,
-				  int nPriority)
-{
-   NTSTATUS errCode;
   THREAD_BASIC_INFORMATION ThreadBasic;
   ULONG DataWritten;
+  NTSTATUS Status;
 
-   errCode = NtQueryInformationThread(hThread,
+  Status = NtQueryInformationThread(hThread,
 				    ThreadBasicInformation,
 				    &ThreadBasic,
 				    sizeof(THREAD_BASIC_INFORMATION),
 				    &DataWritten);
-   if (!NT_SUCCESS(errCode))
+  if (!NT_SUCCESS(Status))
     {
-	SetLastErrorByStatus(errCode);
+      SetLastErrorByStatus(Status);
-	return FALSE;
+      return(FALSE);
     }
+
+  memcpy(lpExitCode, &ThreadBasic.ExitStatus, sizeof(DWORD));
+
+  return(TRUE);
+}
+
+
+DWORD STDCALL
+ResumeThread(HANDLE hThread)
+{
+  ULONG PreviousResumeCount;
+  NTSTATUS Status;
+
+  Status = NtResumeThread(hThread,
+			  &PreviousResumeCount);
+  if (!NT_SUCCESS(Status))
+    {
+      SetLastErrorByStatus(Status);
+      return(-1);
+    }
+
+  return(PreviousResumeCount);
+}
+
+
+WINBOOL STDCALL
+TerminateThread(HANDLE hThread,
+		DWORD dwExitCode)
+{
+  NTSTATUS Status;
+
+  if (0 == hThread)
+    {
+      SetLastError(ERROR_INVALID_HANDLE);
+      return(FALSE);
+    }
+
+  Status = NtTerminateThread(hThread,
+			     dwExitCode);
+  if (!NT_SUCCESS(Status))
+    {
+      SetLastErrorByStatus(Status);
+      return(FALSE);
+    }
+
+  return(TRUE);
+}
+
+
+DWORD STDCALL
+SuspendThread(HANDLE hThread)
+{
+  ULONG PreviousSuspendCount;
+  NTSTATUS Status;
+
+  Status = NtSuspendThread(hThread,
+			   &PreviousSuspendCount);
+  if (!NT_SUCCESS(Status))
+    {
+      SetLastErrorByStatus(Status);
+      return(-1);
+    }
+
+  return(PreviousSuspendCount);
+}
+
+
+DWORD STDCALL
+SetThreadAffinityMask(HANDLE hThread,
+		      DWORD dwThreadAffinityMask)
+{
+  THREAD_BASIC_INFORMATION ThreadBasic;
+  KAFFINITY AffinityMask;
+  ULONG DataWritten;
+  NTSTATUS Status;
+
+  AffinityMask = (KAFFINITY)dwThreadAffinityMask;
+
+  Status = NtQueryInformationThread(hThread,
+				    ThreadBasicInformation,
+				    &ThreadBasic,
+				    sizeof(THREAD_BASIC_INFORMATION),
+				    &DataWritten);
+  if (!NT_SUCCESS(Status))
+    {
+      SetLastErrorByStatus(Status);
+      return(0);
+    }
+
+  Status = NtSetInformationThread(hThread,
+				  ThreadAffinityMask,
+				  &AffinityMask,
+				  sizeof(KAFFINITY));
+  if (!NT_SUCCESS(Status))
+    SetLastErrorByStatus(Status);
+
+  return(ThreadBasic.AffinityMask);
+}
+
+
+WINBOOL STDCALL
+SetThreadPriority(HANDLE hThread,
+		  int nPriority)
+{
+  THREAD_BASIC_INFORMATION ThreadBasic;
+  ULONG DataWritten;
+  NTSTATUS Status;
+
+  Status = NtQueryInformationThread(hThread,
+				    ThreadBasicInformation,
+				    &ThreadBasic,
+				    sizeof(THREAD_BASIC_INFORMATION),
+				    &DataWritten);
+  if (!NT_SUCCESS(Status))
+    {
+      SetLastErrorByStatus(Status);
+      return(FALSE);
+    }
+
   ThreadBasic.BasePriority = nPriority;
-   errCode = NtSetInformationThread(hThread,
+
+  Status = NtSetInformationThread(hThread,
 				  ThreadBasicInformation,
 				  &ThreadBasic,
 				  sizeof(THREAD_BASIC_INFORMATION));
-   if (!NT_SUCCESS(errCode))
+  if (!NT_SUCCESS(Status))
     {
-	SetLastErrorByStatus(errCode);
+      SetLastErrorByStatus(Status);
-	return FALSE;
+      return(FALSE);
     }
-   return TRUE;
+
+  return(TRUE);
 }
 
-int STDCALL GetThreadPriority(HANDLE hThread)
+
+int STDCALL
+GetThreadPriority(HANDLE hThread)
 {
-   NTSTATUS errCode;
   THREAD_BASIC_INFORMATION ThreadBasic;
   ULONG DataWritten;
+  NTSTATUS Status;
 
-   errCode = NtQueryInformationThread(hThread,
+  Status = NtQueryInformationThread(hThread,
 				    ThreadBasicInformation,
 				    &ThreadBasic,
 				    sizeof(THREAD_BASIC_INFORMATION),
 				    &DataWritten);
-   if (!NT_SUCCESS(errCode))
+  if (!NT_SUCCESS(Status))
     {
-	SetLastErrorByStatus(errCode);
+      SetLastErrorByStatus(Status);
-	return THREAD_PRIORITY_ERROR_RETURN;
+      return(THREAD_PRIORITY_ERROR_RETURN);
     }
-   return ThreadBasic.BasePriority;
+
+  return(ThreadBasic.BasePriority);
 }
 
 /* EOF */