Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-04 02:21:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

Implemented SetThreadAffinityMask().

Browse source 
Fixed some *nix line breaks.

svn path=/trunk/; revision=3817
This commit is contained in:
Eric Kohl 2002-12-02 21:28:40 +00:00
parent a378416e55
commit c00bebf1f2
1 changed files with 276 additions and 216 deletions
Download patch file Download diff file Expand all files Collapse all files

310
reactos/lib/kernel32/thread/thread.c
View file

@ -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
EXCEPTION_DISPOSITION
__cdecl
_except_handler(
struct _EXCEPTION_RECORD *ExceptionRecord,
static EXCEPTION_DISPOSITION __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);
return FALSE;
SetLastErrorByStatus(Status);
return(FALSE);
}
return TRUE;
}
WINBOOL STDCALL SetThreadContext(HANDLE hThread,
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;
return(TRUE);
}
WINBOOL STDCALL
TerminateThread (HANDLE hThread,
DWORD dwExitCode)
SetThreadContext(HANDLE hThread,
CONST CONTEXT *lpContext)
{
if (0 == hThread)
{
SetLastError (ERROR_INVALID_HANDLE);
}
else
{
NTSTATUS Status = NtTerminateThread (hThread, dwExitCode);
NTSTATUS Status;
if (NT_SUCCESS(Status))
Status = NtSetContextThread(hThread,
(void *)lpContext);
if (!NT_SUCCESS(Status))
{
return TRUE;
SetLastErrorByStatus(Status);
return(FALSE);
}
SetLastErrorByStatus (Status);
}
return FALSE;
return(TRUE);
}
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);
return FALSE;
SetLastErrorByStatus(Status);
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);
return FALSE;
SetLastErrorByStatus(Status);
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);
return THREAD_PRIORITY_ERROR_RETURN;
SetLastErrorByStatus(Status);
return(THREAD_PRIORITY_ERROR_RETURN);
}
return ThreadBasic.BasePriority;
return(ThreadBasic.BasePriority);
}
/* EOF */