/* INCLUDES ******************************************************************/
-#include <windows.h>
-#include <kernel32/thread.h>
-#include <ntdll/ldr.h>
-#include <string.h>
-#include <napi/i386/segment.h>
+#include <k32.h>
#define NDEBUG
#include <kernel32/kernel32.h>
-#include <kernel32/error.h>
-static VOID ThreadAttachDlls (VOID);
+//static VOID ThreadAttachDlls (VOID);
/* FUNCTIONS *****************************************************************/
-static\r
-EXCEPTION_DISPOSITION\r
-__cdecl\r
-_except_handler(\r
- struct _EXCEPTION_RECORD *ExceptionRecord,\r
- void * EstablisherFrame,\r
- struct _CONTEXT *ContextRecord,\r
- void * DispatcherContext )\r
-{\r
- ExitThread(0);
-
- /* We should not get to here */
- return ExceptionContinueSearch;
-}\r
-
-static VOID STDCALL
-ThreadStartup (LPTHREAD_START_ROUTINE lpStartAddress,
- LPVOID lpParameter)
+static EXCEPTION_DISPOSITION __cdecl
+_except_handler(struct _EXCEPTION_RECORD *ExceptionRecord,
+ void * EstablisherFrame,
+ struct _CONTEXT *ContextRecord,
+ void * DispatcherContext)
{
- UINT uExitCode;
+ ExitThread(0);
- __try1(_except_handler)
- {
- /* FIXME: notify csrss of thread creation ?? */
- uExitCode = (lpStartAddress)(lpParameter);
- } __except1
- {
- }
+ /* We should not get to here */
+ return(ExceptionContinueSearch);
+}
- ExitThread(uExitCode);
+
+static VOID STDCALL
+ThreadStartup(LPTHREAD_START_ROUTINE lpStartAddress,
+ LPVOID lpParameter)
+{
+ UINT uExitCode;
+
+ __try1(_except_handler)
+ {
+ /* FIXME: notify csrss of thread creation ?? */
+ uExitCode = (lpStartAddress)(lpParameter);
+ }
+ __except1
+ {
+ }
+
+ ExitThread(uExitCode);
}
-HANDLE STDCALL CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
- DWORD dwStackSize,
- LPTHREAD_START_ROUTINE lpStartAddress,
- LPVOID lpParameter,
- DWORD dwCreationFlags,
- LPDWORD lpThreadId)
+
+HANDLE STDCALL
+CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
+ DWORD dwStackSize,
+ LPTHREAD_START_ROUTINE lpStartAddress,
+ LPVOID lpParameter,
+ DWORD dwCreationFlags,
+ LPDWORD lpThreadId)
{
- return(CreateRemoteThread(NtCurrentProcess(),
- lpThreadAttributes,
- dwStackSize,
- lpStartAddress,
- lpParameter,
- dwCreationFlags,
- lpThreadId));
+ return(CreateRemoteThread(NtCurrentProcess(),
+ lpThreadAttributes,
+ dwStackSize,
+ lpStartAddress,
+ lpParameter,
+ dwCreationFlags,
+ lpThreadId));
}
-HANDLE STDCALL CreateRemoteThread(HANDLE hProcess,
- LPSECURITY_ATTRIBUTES lpThreadAttributes,
- DWORD dwStackSize,
- LPTHREAD_START_ROUTINE lpStartAddress,
- LPVOID lpParameter,
- DWORD dwCreationFlags,
- LPDWORD lpThreadId)
+
+HANDLE STDCALL
+CreateRemoteThread(HANDLE hProcess,
+ LPSECURITY_ATTRIBUTES lpThreadAttributes,
+ DWORD dwStackSize,
+ LPTHREAD_START_ROUTINE lpStartAddress,
+ LPVOID lpParameter,
+ DWORD dwCreationFlags,
+ LPDWORD lpThreadId)
{
- HANDLE ThreadHandle;
- OBJECT_ATTRIBUTES ObjectAttributes;
- CLIENT_ID ClientId;
- CONTEXT ThreadContext;
- INITIAL_TEB InitialTeb;
- BOOLEAN CreateSuspended = FALSE;
- PVOID BaseAddress;
- ULONG OldPageProtection;
- NTSTATUS Status;
-
- ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
- ObjectAttributes.RootDirectory = NULL;
- ObjectAttributes.ObjectName = NULL;
- ObjectAttributes.Attributes = 0;
- if (lpThreadAttributes != NULL)
- {
- if (lpThreadAttributes->bInheritHandle)
- ObjectAttributes.Attributes = OBJ_INHERIT;
- ObjectAttributes.SecurityDescriptor =
- lpThreadAttributes->lpSecurityDescriptor;
- }
- ObjectAttributes.SecurityQualityOfService = NULL;
-
- if ((dwCreationFlags & CREATE_SUSPENDED) == CREATE_SUSPENDED)
- CreateSuspended = TRUE;
- else
- CreateSuspended = FALSE;
+ HANDLE ThreadHandle;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ CLIENT_ID ClientId;
+ CONTEXT ThreadContext;
+ INITIAL_TEB InitialTeb;
+ BOOLEAN CreateSuspended = FALSE;
+ PVOID BaseAddress;
+ ULONG OldPageProtection;
+ NTSTATUS Status;
+
+ ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
+ ObjectAttributes.RootDirectory = NULL;
+ ObjectAttributes.ObjectName = NULL;
+ ObjectAttributes.Attributes = 0;
+ if (lpThreadAttributes != NULL)
+ {
+ if (lpThreadAttributes->bInheritHandle)
+ ObjectAttributes.Attributes = OBJ_INHERIT;
+ ObjectAttributes.SecurityDescriptor =
+ lpThreadAttributes->lpSecurityDescriptor;
+ }
+ ObjectAttributes.SecurityQualityOfService = NULL;
+
+ if ((dwCreationFlags & CREATE_SUSPENDED) == CREATE_SUSPENDED)
+ CreateSuspended = TRUE;
+ else
+ CreateSuspended = FALSE;
InitialTeb.StackReserve = 0x100000; /* 1MByte */
/* FIXME: use correct commit size */
return(ThreadHandle);
}
+
PTEB
GetTeb(VOID)
{
return(NtCurrentTeb());
}
+
WINBOOL STDCALL
SwitchToThread(VOID)
{
- NTSTATUS errCode;
- errCode = NtYieldExecution();
- return TRUE;
+ NTSTATUS errCode;
+ errCode = NtYieldExecution();
+ return TRUE;
}
+
DWORD STDCALL
-GetCurrentThreadId()
+GetCurrentThreadId(VOID)
{
- return((DWORD)(NtCurrentTeb()->Cid).UniqueThread);
+ return((DWORD)(NtCurrentTeb()->Cid).UniqueThread);
}
+
VOID STDCALL
ExitThread(DWORD uExitCode)
{
- NTSTATUS errCode;
- BOOLEAN LastThread;
- NTSTATUS Status;
-
- /*
- * Terminate process if this is the last thread
- * of the current process
- */
- Status = NtQueryInformationThread(NtCurrentThread(),
- ThreadAmILastThread,
- &LastThread,
- sizeof(BOOLEAN),
- NULL);
- if (NT_SUCCESS(Status) && LastThread == TRUE)
- {
- ExitProcess (uExitCode);
- }
-
- /* FIXME: notify csrss of thread termination */
-
- LdrShutdownThread();
-
- errCode = NtTerminateThread(NtCurrentThread(),
- uExitCode);
- if (!NT_SUCCESS(errCode))
- {
- SetLastErrorByStatus(errCode);
- }
+ BOOLEAN LastThread;
+ NTSTATUS Status;
+
+ /*
+ * Terminate process if this is the last thread
+ * of the current process
+ */
+ Status = NtQueryInformationThread(NtCurrentThread(),
+ ThreadAmILastThread,
+ &LastThread,
+ sizeof(BOOLEAN),
+ NULL);
+ if (NT_SUCCESS(Status) && LastThread == TRUE)
+ {
+ ExitProcess(uExitCode);
+ }
+
+ /* FIXME: notify csrss of thread termination */
+
+ LdrShutdownThread();
+
+ Status = NtTerminateThread(NtCurrentThread(),
+ uExitCode);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ }
}
-WINBOOL STDCALL GetThreadTimes(HANDLE hThread,
- LPFILETIME lpCreationTime,
- LPFILETIME lpExitTime,
- LPFILETIME lpKernelTime,
- LPFILETIME lpUserTime)
+
+WINBOOL STDCALL
+GetThreadTimes(HANDLE hThread,
+ LPFILETIME lpCreationTime,
+ LPFILETIME lpExitTime,
+ LPFILETIME lpKernelTime,
+ LPFILETIME lpUserTime)
{
- NTSTATUS errCode;
- KERNEL_USER_TIMES KernelUserTimes;
- ULONG ReturnLength;
-
- errCode = NtQueryInformationThread(hThread,
- ThreadTimes,
- &KernelUserTimes,
- sizeof(KERNEL_USER_TIMES),
- &ReturnLength);
- if (!NT_SUCCESS(errCode))
- {
- SetLastErrorByStatus(errCode);
- return FALSE;
- }
- memcpy(lpCreationTime, &KernelUserTimes.CreateTime, sizeof(FILETIME));
- memcpy(lpExitTime, &KernelUserTimes.ExitTime, sizeof(FILETIME));
- memcpy(lpKernelTime, &KernelUserTimes.KernelTime, sizeof(FILETIME));
- memcpy(lpUserTime, &KernelUserTimes.UserTime, sizeof(FILETIME));
- return TRUE;
+ KERNEL_USER_TIMES KernelUserTimes;
+ ULONG ReturnLength;
+ NTSTATUS Status;
+
+ Status = NtQueryInformationThread(hThread,
+ ThreadTimes,
+ &KernelUserTimes,
+ sizeof(KERNEL_USER_TIMES),
+ &ReturnLength);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ memcpy(lpCreationTime, &KernelUserTimes.CreateTime, sizeof(FILETIME));
+ memcpy(lpExitTime, &KernelUserTimes.ExitTime, sizeof(FILETIME));
+ memcpy(lpKernelTime, &KernelUserTimes.KernelTime, sizeof(FILETIME));
+ memcpy(lpUserTime, &KernelUserTimes.UserTime, sizeof(FILETIME));
+
+ return(TRUE);
}
-WINBOOL STDCALL GetThreadContext(HANDLE hThread,
- LPCONTEXT lpContext)
+WINBOOL STDCALL
+GetThreadContext(HANDLE hThread,
+ LPCONTEXT lpContext)
{
- NTSTATUS errCode;
-
- errCode = NtGetContextThread(hThread,
- lpContext);
- if (!NT_SUCCESS(errCode))
- {
- SetLastErrorByStatus(errCode);
- return FALSE;
- }
- return TRUE;
+ NTSTATUS Status;
+
+ Status = NtGetContextThread(hThread,
+ lpContext);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ return(TRUE);
}
-WINBOOL STDCALL SetThreadContext(HANDLE hThread,
- CONST CONTEXT *lpContext)
+
+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;
+ NTSTATUS Status;
+
+ Status = NtSetContextThread(hThread,
+ (void *)lpContext);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ return(TRUE);
}
-WINBOOL STDCALL GetExitCodeThread(HANDLE hThread,
- LPDWORD lpExitCode)
+
+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;
+ 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);
+ }
+
+ memcpy(lpExitCode, &ThreadBasic.ExitStatus, sizeof(DWORD));
+
+ return(TRUE);
}
-DWORD STDCALL ResumeThread(HANDLE hThread)
+
+DWORD STDCALL
+ResumeThread(HANDLE hThread)
{
- NTSTATUS errCode;
- ULONG PreviousResumeCount;
-
- errCode = NtResumeThread(hThread,
- &PreviousResumeCount);
- if (!NT_SUCCESS(errCode))
- {
- SetLastErrorByStatus(errCode);
- return -1;
- }
- return PreviousResumeCount;
+ 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)
+TerminateThread(HANDLE hThread,
+ DWORD dwExitCode)
{
- if (0 == hThread)
+ NTSTATUS Status;
+
+ if (0 == hThread)
{
- SetLastError (ERROR_INVALID_HANDLE);
+ SetLastError(ERROR_INVALID_HANDLE);
+ return(FALSE);
}
- else
+
+ 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))
{
- NTSTATUS Status = NtTerminateThread (hThread, dwExitCode);
-
- if (NT_SUCCESS(Status))
- {
- return TRUE;
- }
- SetLastErrorByStatus (Status);
+ SetLastErrorByStatus(Status);
+ return(-1);
}
- return FALSE;
+
+ return(PreviousSuspendCount);
}
-DWORD STDCALL SuspendThread(HANDLE hThread)
+DWORD STDCALL
+SetThreadAffinityMask(HANDLE hThread,
+ DWORD dwThreadAffinityMask)
{
- NTSTATUS errCode;
- ULONG PreviousSuspendCount;
-
- errCode = NtSuspendThread(hThread,
- &PreviousSuspendCount);
- if (!NT_SUCCESS(errCode))
- {
- SetLastErrorByStatus(errCode);
- return -1;
- }
- return PreviousSuspendCount;
+ 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);
}
-DWORD STDCALL SetThreadAffinityMask(HANDLE hThread,
- DWORD dwThreadAffinityMask)
+
+WINBOOL STDCALL
+SetThreadPriority(HANDLE hThread,
+ int nPriority)
{
- return 0;
+ 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;
+
+ Status = NtSetInformationThread(hThread,
+ ThreadBasicInformation,
+ &ThreadBasic,
+ sizeof(THREAD_BASIC_INFORMATION));
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ return(TRUE);
}
-WINBOOL STDCALL SetThreadPriority(HANDLE hThread,
- int nPriority)
+
+int STDCALL
+GetThreadPriority(HANDLE hThread)
{
- 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;
- }
- ThreadBasic.BasePriority = nPriority;
- errCode = NtSetInformationThread(hThread,
+ THREAD_BASIC_INFORMATION ThreadBasic;
+ ULONG DataWritten;
+ NTSTATUS Status;
+
+ Status = NtQueryInformationThread(hThread,
ThreadBasicInformation,
&ThreadBasic,
- sizeof(THREAD_BASIC_INFORMATION));
- if (!NT_SUCCESS(errCode))
- {
- SetLastErrorByStatus(errCode);
- return FALSE;
- }
- return TRUE;
+ sizeof(THREAD_BASIC_INFORMATION),
+ &DataWritten);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(THREAD_PRIORITY_ERROR_RETURN);
+ }
+
+ return(ThreadBasic.BasePriority);
+}
+
+
+WINBOOL STDCALL
+GetThreadPriorityBoost(IN HANDLE hThread,
+ OUT PBOOL pDisablePriorityBoost)
+{
+ ULONG PriorityBoost;
+ ULONG DataWritten;
+ NTSTATUS Status;
+
+ Status = NtQueryInformationThread(hThread,
+ ThreadPriorityBoost,
+ &PriorityBoost,
+ sizeof(ULONG),
+ &DataWritten);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ *pDisablePriorityBoost = !((WINBOOL)PriorityBoost);
+
+ return(TRUE);
+}
+
+
+WINBOOL STDCALL
+SetThreadPriorityBoost(IN HANDLE hThread,
+ IN WINBOOL bDisablePriorityBoost)
+{
+ ULONG PriorityBoost;
+ NTSTATUS Status;
+
+ PriorityBoost = (ULONG)!bDisablePriorityBoost;
+
+ Status = NtSetInformationThread(hThread,
+ ThreadPriorityBoost,
+ &PriorityBoost,
+ sizeof(ULONG));
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ return(TRUE);
}
-int STDCALL GetThreadPriority(HANDLE hThread)
+
+WINBOOL STDCALL
+GetThreadSelectorEntry(IN HANDLE hThread,
+ IN DWORD dwSelector,
+ OUT LPLDT_ENTRY lpSelectorEntry)
{
- 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 THREAD_PRIORITY_ERROR_RETURN;
- }
- return ThreadBasic.BasePriority;
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return(FALSE);
+}
+
+
+WINBOOL STDCALL
+SetThreadIdealProcessor(HANDLE hThread,
+ DWORD dwIdealProcessor)
+{
+ ULONG IdealProcessor;
+ NTSTATUS Status;
+
+ IdealProcessor = (ULONG)dwIdealProcessor;
+
+ Status = NtSetInformationThread(hThread,
+ ThreadIdealProcessor,
+ &IdealProcessor,
+ sizeof(ULONG));
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return(FALSE);
+ }
+
+ return(TRUE);
}
/* EOF */
git://git.jankratochvil.net / reactos.git / blobdiff