4 * Copyright 1996 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
27 #include <sys/types.h>
33 #define WIN32_NO_STATUS
38 #include "wine/exception.h"
39 #include "wine/library.h"
40 #include "wine/server.h"
41 #include "wine/debug.h"
43 #include "kernel_private.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(thread
);
48 /***********************************************************************
49 * CreateThread (KERNEL32.@)
51 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateThread( SECURITY_ATTRIBUTES
*sa
, SIZE_T stack
, LPTHREAD_START_ROUTINE start
,
52 LPVOID param
, DWORD flags
, LPDWORD id
)
54 return CreateRemoteThread( GetCurrentProcess(),
55 sa
, stack
, start
, param
, flags
, id
);
58 /***************************************************************************
59 * CreateRemoteThread (KERNEL32.@)
61 HANDLE WINAPI
CreateRemoteThread( HANDLE hProcess
, SECURITY_ATTRIBUTES
*sa
, SIZE_T stack
,
62 LPTHREAD_START_ROUTINE start
, LPVOID param
,
63 DWORD flags
, DWORD
*id
)
65 return CreateRemoteThreadEx( hProcess
, sa
, stack
, start
, param
, flags
, NULL
, id
);
68 /***************************************************************************
69 * CreateRemoteThreadEx (KERNEL32.@)
71 * Creates a thread that runs in the address space of another process
76 * Success: Handle to the new thread.
77 * Failure: NULL. Use GetLastError() to find the error cause.
80 * Improper memory allocation: there's no ability to free new_thread_info
82 * Bad start address for RtlCreateUserThread because the library
83 * may be loaded at different address in other process.
85 HANDLE WINAPI
CreateRemoteThreadEx( HANDLE hProcess
, SECURITY_ATTRIBUTES
*sa
, SIZE_T stack
,
86 LPTHREAD_START_ROUTINE start
, LPVOID param
, DWORD flags
,
87 LPPROC_THREAD_ATTRIBUTE_LIST attributes
, DWORD
*id
)
92 SIZE_T stack_reserve
= 0, stack_commit
= 0;
95 FIXME("thread attributes ignored\n");
97 if (flags
& STACK_SIZE_PARAM_IS_A_RESERVATION
) stack_reserve
= stack
;
98 else stack_commit
= stack
;
100 status
= RtlCreateUserThread( hProcess
, NULL
, TRUE
,
101 NULL
, stack_reserve
, stack_commit
,
102 (PRTL_THREAD_START_ROUTINE
)start
, param
, &handle
, &client_id
);
103 if (status
== STATUS_SUCCESS
)
105 if (id
) *id
= HandleToULong(client_id
.UniqueThread
);
106 if (sa
&& (sa
->nLength
>= sizeof(*sa
)) && sa
->bInheritHandle
)
107 SetHandleInformation( handle
, HANDLE_FLAG_INHERIT
, HANDLE_FLAG_INHERIT
);
108 if (!(flags
& CREATE_SUSPENDED
))
111 if (NtResumeThread( handle
, &ret
))
114 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
121 SetLastError( RtlNtStatusToDosError(status
) );
128 /***********************************************************************
129 * OpenThread [KERNEL32.@] Retrieves a handle to a thread from its thread id
131 HANDLE WINAPI
OpenThread( DWORD dwDesiredAccess
, BOOL bInheritHandle
, DWORD dwThreadId
)
135 OBJECT_ATTRIBUTES attr
;
138 attr
.Length
= sizeof(attr
);
139 attr
.RootDirectory
= 0;
140 attr
.Attributes
= bInheritHandle
? OBJ_INHERIT
: 0;
141 attr
.ObjectName
= NULL
;
142 attr
.SecurityDescriptor
= NULL
;
143 attr
.SecurityQualityOfService
= NULL
;
145 cid
.UniqueProcess
= 0; /* FIXME */
146 cid
.UniqueThread
= ULongToHandle(dwThreadId
);
147 status
= NtOpenThread( &handle
, dwDesiredAccess
, &attr
, &cid
);
150 SetLastError( RtlNtStatusToDosError(status
) );
157 /***********************************************************************
158 * ExitThread [KERNEL32.@] Ends a thread
163 void WINAPI
ExitThread( DWORD code
) /* [in] Exit code for this thread */
165 RtlExitUserThread( code
);
169 /**********************************************************************
170 * TerminateThread [KERNEL32.@] Terminates a thread
176 BOOL WINAPI
TerminateThread( HANDLE handle
, /* [in] Handle to thread */
177 DWORD exit_code
) /* [in] Exit code for thread */
179 NTSTATUS status
= NtTerminateThread( handle
, exit_code
);
180 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
185 /***********************************************************************
186 * FreeLibraryAndExitThread (KERNEL32.@)
188 void WINAPI
FreeLibraryAndExitThread(HINSTANCE hLibModule
, DWORD dwExitCode
)
190 FreeLibrary(hLibModule
);
191 ExitThread(dwExitCode
);
195 /**********************************************************************
196 * GetExitCodeThread (KERNEL32.@)
198 * Gets termination status of thread.
204 BOOL WINAPI
GetExitCodeThread(
205 HANDLE hthread
, /* [in] Handle to thread */
206 LPDWORD exitcode
) /* [out] Address to receive termination status */
208 THREAD_BASIC_INFORMATION info
;
209 NTSTATUS status
= NtQueryInformationThread( hthread
, ThreadBasicInformation
,
210 &info
, sizeof(info
), NULL
);
214 SetLastError( RtlNtStatusToDosError(status
) );
217 if (exitcode
) *exitcode
= info
.ExitStatus
;
222 /***********************************************************************
223 * SetThreadContext [KERNEL32.@] Sets context of thread.
229 BOOL WINAPI
SetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
230 const CONTEXT
*context
) /* [in] Address of context structure */
232 NTSTATUS status
= NtSetContextThread( handle
, context
);
233 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
238 /***********************************************************************
239 * Wow64SetThreadContext [KERNEL32.@]
241 BOOL WINAPI
Wow64SetThreadContext( HANDLE handle
, const WOW64_CONTEXT
*context
)
244 NTSTATUS status
= NtSetContextThread( handle
, (const CONTEXT
*)context
);
245 #elif defined(__x86_64__)
246 NTSTATUS status
= RtlWow64SetThreadContext( handle
, context
);
248 NTSTATUS status
= STATUS_NOT_IMPLEMENTED
;
249 FIXME("not implemented on this platform\n");
251 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
255 /***********************************************************************
256 * GetThreadContext [KERNEL32.@] Retrieves context of thread.
262 BOOL WINAPI
GetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
263 CONTEXT
*context
) /* [out] Address of context structure */
265 NTSTATUS status
= NtGetContextThread( handle
, context
);
266 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
271 /***********************************************************************
272 * Wow64GetThreadContext [KERNEL32.@]
274 BOOL WINAPI
Wow64GetThreadContext( HANDLE handle
, WOW64_CONTEXT
*context
)
277 NTSTATUS status
= NtGetContextThread( handle
, (CONTEXT
*)context
);
278 #elif defined(__x86_64__)
279 NTSTATUS status
= RtlWow64GetThreadContext( handle
, context
);
281 NTSTATUS status
= STATUS_NOT_IMPLEMENTED
;
282 FIXME("not implemented on this platform\n");
284 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
289 /**********************************************************************
290 * SuspendThread [KERNEL32.@] Suspends a thread.
293 * Success: Previous suspend count
294 * Failure: 0xFFFFFFFF
296 DWORD WINAPI
SuspendThread( HANDLE hthread
) /* [in] Handle to the thread */
299 NTSTATUS status
= NtSuspendThread( hthread
, &ret
);
304 SetLastError( RtlNtStatusToDosError(status
) );
310 /**********************************************************************
311 * ResumeThread [KERNEL32.@] Resumes a thread.
313 * Decrements a thread's suspend count. When count is zero, the
314 * execution of the thread is resumed.
317 * Success: Previous suspend count
318 * Failure: 0xFFFFFFFF
321 DWORD WINAPI
ResumeThread( HANDLE hthread
) /* [in] Identifies thread to restart */
324 NTSTATUS status
= NtResumeThread( hthread
, &ret
);
329 SetLastError( RtlNtStatusToDosError(status
) );
335 /**********************************************************************
336 * GetThreadPriority [KERNEL32.@] Returns priority for thread.
339 * Success: Thread's priority level.
340 * Failure: THREAD_PRIORITY_ERROR_RETURN
342 INT WINAPI
GetThreadPriority(
343 HANDLE hthread
) /* [in] Handle to thread */
345 THREAD_BASIC_INFORMATION info
;
346 NTSTATUS status
= NtQueryInformationThread( hthread
, ThreadBasicInformation
,
347 &info
, sizeof(info
), NULL
);
351 SetLastError( RtlNtStatusToDosError(status
) );
352 return THREAD_PRIORITY_ERROR_RETURN
;
354 return info
.Priority
;
358 /**********************************************************************
359 * SetThreadPriority [KERNEL32.@] Sets priority for thread.
365 BOOL WINAPI
SetThreadPriority(
366 HANDLE hthread
, /* [in] Handle to thread */
367 INT priority
) /* [in] Thread priority level */
369 DWORD prio
= priority
;
372 status
= NtSetInformationThread(hthread
, ThreadBasePriority
,
373 &prio
, sizeof(prio
));
377 SetLastError( RtlNtStatusToDosError(status
) );
385 /**********************************************************************
386 * GetThreadPriorityBoost [KERNEL32.@] Returns priority boost for thread.
388 * Always reports that priority boost is disabled.
394 BOOL WINAPI
GetThreadPriorityBoost(
395 HANDLE hthread
, /* [in] Handle to thread */
396 PBOOL pstate
) /* [out] pointer to var that receives the boost state */
398 if (pstate
) *pstate
= FALSE
;
403 /**********************************************************************
404 * SetThreadPriorityBoost [KERNEL32.@] Sets priority boost for thread.
406 * Priority boost is not implemented, but we return TRUE
407 * anyway because some games crash otherwise.
409 BOOL WINAPI
SetThreadPriorityBoost(
410 HANDLE hthread
, /* [in] Handle to thread */
411 BOOL disable
) /* [in] TRUE to disable priority boost */
417 /**********************************************************************
418 * SetThreadStackGuarantee (KERNEL32.@)
420 BOOL WINAPI
SetThreadStackGuarantee(PULONG stacksize
)
424 FIXME("(%p): stub\n", stacksize
);
428 /***********************************************************************
429 * GetThreadGroupAffinity (KERNEL32.@)
431 BOOL WINAPI
GetThreadGroupAffinity( HANDLE thread
, GROUP_AFFINITY
*affinity
)
437 SetLastError( ERROR_INVALID_PARAMETER
);
441 status
= NtQueryInformationThread( thread
, ThreadGroupInformation
,
442 affinity
, sizeof(*affinity
), NULL
);
445 SetLastError( RtlNtStatusToDosError(status
) );
452 /***********************************************************************
453 * SetThreadGroupAffinity (KERNEL32.@)
455 BOOL WINAPI
SetThreadGroupAffinity( HANDLE thread
, const GROUP_AFFINITY
*affinity_new
,
456 GROUP_AFFINITY
*affinity_old
)
460 if (affinity_old
&& !GetThreadGroupAffinity( thread
, affinity_old
))
463 status
= NtSetInformationThread( thread
, ThreadGroupInformation
,
464 affinity_new
, sizeof(*affinity_new
) );
467 SetLastError( RtlNtStatusToDosError(status
) );
474 /**********************************************************************
475 * SetThreadAffinityMask (KERNEL32.@)
477 DWORD_PTR WINAPI
SetThreadAffinityMask( HANDLE hThread
, DWORD_PTR dwThreadAffinityMask
)
480 THREAD_BASIC_INFORMATION tbi
;
482 status
= NtQueryInformationThread( hThread
, ThreadBasicInformation
,
483 &tbi
, sizeof(tbi
), NULL
);
486 SetLastError( RtlNtStatusToDosError(status
) );
489 status
= NtSetInformationThread( hThread
, ThreadAffinityMask
,
490 &dwThreadAffinityMask
,
491 sizeof(dwThreadAffinityMask
));
494 SetLastError( RtlNtStatusToDosError(status
) );
497 return tbi
.AffinityMask
;
501 /**********************************************************************
502 * SetThreadIdealProcessor [KERNEL32.@] Sets preferred processor for thread.
505 * Success: Value of last call to SetThreadIdealProcessor
508 DWORD WINAPI
SetThreadIdealProcessor(
509 HANDLE hThread
, /* [in] Specifies the thread of interest */
510 DWORD dwIdealProcessor
) /* [in] Specifies the new preferred processor */
512 FIXME("(%p): stub\n",hThread
);
513 if (dwIdealProcessor
> MAXIMUM_PROCESSORS
)
515 SetLastError(ERROR_INVALID_PARAMETER
);
521 /***********************************************************************
522 * SetThreadIdealProcessorEx (KERNEL32.@)
524 BOOL WINAPI
SetThreadIdealProcessorEx( HANDLE thread
, PROCESSOR_NUMBER
*ideal
, PROCESSOR_NUMBER
*previous
)
526 FIXME("(%p %p %p): stub\n", thread
, ideal
, previous
);
527 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
531 /***********************************************************************
532 * GetThreadSelectorEntry (KERNEL32.@)
534 BOOL WINAPI
GetThreadSelectorEntry( HANDLE hthread
, DWORD sel
, LPLDT_ENTRY ldtent
)
536 THREAD_DESCRIPTOR_INFORMATION tdi
;
540 status
= NtQueryInformationThread( hthread
, ThreadDescriptorTableEntry
, &tdi
, sizeof(tdi
), NULL
);
543 SetLastError( RtlNtStatusToDosError(status
) );
551 /* callback for QueueUserAPC */
552 static void CALLBACK
call_user_apc( ULONG_PTR arg1
, ULONG_PTR arg2
, ULONG_PTR arg3
)
554 PAPCFUNC func
= (PAPCFUNC
)arg1
;
558 /***********************************************************************
559 * QueueUserAPC (KERNEL32.@)
561 DWORD WINAPI
QueueUserAPC( PAPCFUNC func
, HANDLE hthread
, ULONG_PTR data
)
563 NTSTATUS status
= NtQueueApcThread( hthread
, call_user_apc
, (ULONG_PTR
)func
, data
, 0 );
565 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
569 /***********************************************************************
570 * QueueUserWorkItem (KERNEL32.@)
572 BOOL WINAPI
QueueUserWorkItem( LPTHREAD_START_ROUTINE Function
, PVOID Context
, ULONG Flags
)
576 TRACE("(%p,%p,0x%08x)\n", Function
, Context
, Flags
);
578 status
= RtlQueueWorkItem( Function
, Context
, Flags
);
580 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
584 /**********************************************************************
585 * GetThreadTimes [KERNEL32.@] Obtains timing information.
591 BOOL WINAPI
GetThreadTimes(
592 HANDLE thread
, /* [in] Specifies the thread of interest */
593 LPFILETIME creationtime
, /* [out] When the thread was created */
594 LPFILETIME exittime
, /* [out] When the thread was destroyed */
595 LPFILETIME kerneltime
, /* [out] Time thread spent in kernel mode */
596 LPFILETIME usertime
) /* [out] Time thread spent in user mode */
598 KERNEL_USER_TIMES kusrt
;
601 status
= NtQueryInformationThread(thread
, ThreadTimes
, &kusrt
,
602 sizeof(kusrt
), NULL
);
605 SetLastError( RtlNtStatusToDosError(status
) );
610 creationtime
->dwLowDateTime
= kusrt
.CreateTime
.u
.LowPart
;
611 creationtime
->dwHighDateTime
= kusrt
.CreateTime
.u
.HighPart
;
615 exittime
->dwLowDateTime
= kusrt
.ExitTime
.u
.LowPart
;
616 exittime
->dwHighDateTime
= kusrt
.ExitTime
.u
.HighPart
;
620 kerneltime
->dwLowDateTime
= kusrt
.KernelTime
.u
.LowPart
;
621 kerneltime
->dwHighDateTime
= kusrt
.KernelTime
.u
.HighPart
;
625 usertime
->dwLowDateTime
= kusrt
.UserTime
.u
.LowPart
;
626 usertime
->dwHighDateTime
= kusrt
.UserTime
.u
.HighPart
;
632 /**********************************************************************
633 * GetThreadId [KERNEL32.@]
635 * Retrieve the identifier of a thread.
638 * Thread [I] The thread to retrieve the identifier of.
641 * Success: Identifier of the target thread.
644 DWORD WINAPI
GetThreadId(HANDLE Thread
)
646 THREAD_BASIC_INFORMATION tbi
;
649 TRACE("(%p)\n", Thread
);
651 status
= NtQueryInformationThread(Thread
, ThreadBasicInformation
, &tbi
,
655 SetLastError( RtlNtStatusToDosError(status
) );
659 return HandleToULong(tbi
.ClientId
.UniqueThread
);
662 /**********************************************************************
663 * GetProcessIdOfThread [KERNEL32.@]
665 * Retrieve process identifier given thread belongs to.
668 * Thread [I] The thread identifier.
671 * Success: Process identifier
674 DWORD WINAPI
GetProcessIdOfThread(HANDLE Thread
)
676 THREAD_BASIC_INFORMATION tbi
;
679 TRACE("(%p)\n", Thread
);
681 status
= NtQueryInformationThread(Thread
, ThreadBasicInformation
, &tbi
,
685 SetLastError( RtlNtStatusToDosError(status
) );
689 return HandleToULong(tbi
.ClientId
.UniqueProcess
);
692 /***********************************************************************
693 * GetCurrentThread [KERNEL32.@] Gets pseudohandle for current thread
696 * Pseudohandle for the current thread
698 #undef GetCurrentThread
699 HANDLE WINAPI
GetCurrentThread(void)
701 return (HANDLE
)~(ULONG_PTR
)1;
707 /***********************************************************************
708 * SetLastError (KERNEL32.@)
710 /* void WINAPI SetLastError( DWORD error ); */
711 __ASM_STDCALL_FUNC( SetLastError
, 4,
712 "movl 4(%esp),%eax\n\t"
717 /***********************************************************************
718 * GetLastError (KERNEL32.@)
720 /* DWORD WINAPI GetLastError(void); */
721 __ASM_STDCALL_FUNC( GetLastError
, 0, ".byte 0x64\n\tmovl 0x34,%eax\n\tret" )
723 /***********************************************************************
724 * GetCurrentProcessId (KERNEL32.@)
726 /* DWORD WINAPI GetCurrentProcessId(void) */
727 __ASM_STDCALL_FUNC( GetCurrentProcessId
, 0, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" )
729 /***********************************************************************
730 * GetCurrentThreadId (KERNEL32.@)
732 /* DWORD WINAPI GetCurrentThreadId(void) */
733 __ASM_STDCALL_FUNC( GetCurrentThreadId
, 0, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" )
735 /***********************************************************************
736 * GetProcessHeap (KERNEL32.@)
738 /* HANDLE WINAPI GetProcessHeap(void) */
739 __ASM_STDCALL_FUNC( GetProcessHeap
, 0, ".byte 0x64\n\tmovl 0x30,%eax\n\tmovl 0x18(%eax),%eax\n\tret");
741 #elif defined(__x86_64__)
745 /***********************************************************************
746 * SetLastError (KERNEL32.@)
748 /* void WINAPI SetLastError( DWORD error ); */
749 __ASM_STDCALL_FUNC( SetLastError
, 8, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovl %ecx,0x68(%rax)\n\tret" );
751 /***********************************************************************
752 * GetLastError (KERNEL32.@)
754 /* DWORD WINAPI GetLastError(void); */
755 __ASM_STDCALL_FUNC( GetLastError
, 0, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovl 0x68(%rax),%eax\n\tret" );
757 /***********************************************************************
758 * GetCurrentProcessId (KERNEL32.@)
760 /* DWORD WINAPI GetCurrentProcessId(void) */
761 __ASM_STDCALL_FUNC( GetCurrentProcessId
, 0, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovl 0x40(%rax),%eax\n\tret" );
763 /***********************************************************************
764 * GetCurrentThreadId (KERNEL32.@)
766 /* DWORD WINAPI GetCurrentThreadId(void) */
767 __ASM_STDCALL_FUNC( GetCurrentThreadId
, 0, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovl 0x48(%rax),%eax\n\tret" );
769 /***********************************************************************
770 * GetProcessHeap (KERNEL32.@)
772 /* HANDLE WINAPI GetProcessHeap(void) */
773 __ASM_STDCALL_FUNC( GetProcessHeap
, 0, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovq 0x60(%rax),%rax\n\tmovq 0x30(%rax),%rax\n\tret");
777 /***********************************************************************
778 * SetLastError (KERNEL32.@)
780 /* void WINAPI SetLastError( DWORD error ); */
781 __ASM_STDCALL_FUNC( SetLastError
, 8, ".byte 0x65\n\tmovl %ecx,0x68\n\tret" );
783 /***********************************************************************
784 * GetLastError (KERNEL32.@)
786 /* DWORD WINAPI GetLastError(void); */
787 __ASM_STDCALL_FUNC( GetLastError
, 0, ".byte 0x65\n\tmovl 0x68,%eax\n\tret" );
789 /***********************************************************************
790 * GetCurrentProcessId (KERNEL32.@)
792 /* DWORD WINAPI GetCurrentProcessId(void) */
793 __ASM_STDCALL_FUNC( GetCurrentProcessId
, 0, ".byte 0x65\n\tmovl 0x40,%eax\n\tret" );
795 /***********************************************************************
796 * GetCurrentThreadId (KERNEL32.@)
798 /* DWORD WINAPI GetCurrentThreadId(void) */
799 __ASM_STDCALL_FUNC( GetCurrentThreadId
, 0, ".byte 0x65\n\tmovl 0x48,%eax\n\tret" );
801 /***********************************************************************
802 * GetProcessHeap (KERNEL32.@)
804 /* HANDLE WINAPI GetProcessHeap(void) */
805 __ASM_STDCALL_FUNC( GetProcessHeap
, 0, ".byte 0x65\n\tmovq 0x60,%rax\n\tmovq 0x30(%rax),%rax\n\tret");
807 #endif /* __APPLE__ */
809 #else /* __x86_64__ */
811 /**********************************************************************
812 * SetLastError (KERNEL32.@)
814 * Sets the last-error code.
819 void WINAPI
SetLastError( DWORD error
) /* [in] Per-thread error code */
821 NtCurrentTeb()->LastErrorValue
= error
;
824 /**********************************************************************
825 * GetLastError (KERNEL32.@)
827 * Get the last-error code.
832 DWORD WINAPI
GetLastError(void)
834 return NtCurrentTeb()->LastErrorValue
;
837 /***********************************************************************
838 * GetCurrentProcessId (KERNEL32.@)
840 * Get the current process identifier.
843 * current process identifier
845 DWORD WINAPI
GetCurrentProcessId(void)
847 return HandleToULong(NtCurrentTeb()->ClientId
.UniqueProcess
);
850 /***********************************************************************
851 * GetCurrentThreadId (KERNEL32.@)
853 * Get the current thread identifier.
856 * current thread identifier
858 DWORD WINAPI
GetCurrentThreadId(void)
860 return HandleToULong(NtCurrentTeb()->ClientId
.UniqueThread
);
863 /***********************************************************************
864 * GetProcessHeap (KERNEL32.@)
866 HANDLE WINAPI
GetProcessHeap(void)
868 return NtCurrentTeb()->Peb
->ProcessHeap
;
871 #endif /* __i386__ */
873 /*************************************************************************
874 * rtlmode_to_win32mode
876 static DWORD
rtlmode_to_win32mode( DWORD rtlmode
)
881 win32mode
|= SEM_FAILCRITICALERRORS
;
883 win32mode
|= SEM_NOGPFAULTERRORBOX
;
885 win32mode
|= SEM_NOOPENFILEERRORBOX
;
890 /***********************************************************************
891 * SetThreadErrorMode (KERNEL32.@)
893 * Set the thread local error mode.
896 * mode [I] The new error mode, a bitwise or of SEM_FAILCRITICALERRORS,
897 * SEM_NOGPFAULTERRORBOX and SEM_NOOPENFILEERRORBOX.
898 * oldmode [O] Destination of the old error mode (may be NULL)
902 * Failure: FALSE, check GetLastError
904 BOOL WINAPI
SetThreadErrorMode( DWORD mode
, LPDWORD oldmode
)
909 if (mode
& ~(SEM_FAILCRITICALERRORS
|
910 SEM_NOGPFAULTERRORBOX
|
911 SEM_NOOPENFILEERRORBOX
))
913 SetLastError( ERROR_INVALID_PARAMETER
);
917 if (mode
& SEM_FAILCRITICALERRORS
)
919 if (mode
& SEM_NOGPFAULTERRORBOX
)
921 if (mode
& SEM_NOOPENFILEERRORBOX
)
924 status
= RtlSetThreadErrorMode( tmp
, oldmode
);
927 SetLastError( RtlNtStatusToDosError(status
) );
932 *oldmode
= rtlmode_to_win32mode(*oldmode
);
937 /***********************************************************************
938 * GetThreadErrorMode (KERNEL32.@)
940 * Get the thread local error mode.
946 * The current thread local error mode.
948 DWORD WINAPI
GetThreadErrorMode( void )
950 return rtlmode_to_win32mode( RtlGetThreadErrorMode() );
953 /***********************************************************************
954 * GetThreadUILanguage (KERNEL32.@)
956 * Get the current thread's language identifier.
962 * The current thread's language identifier.
964 LANGID WINAPI
GetThreadUILanguage( void )
967 NtQueryDefaultUILanguage( &lang
);
968 FIXME(": stub, returning default language.\n");
972 /***********************************************************************
973 * GetThreadIOPendingFlag (KERNEL32.@)
975 BOOL WINAPI
GetThreadIOPendingFlag( HANDLE thread
, PBOOL io_pending
)
979 TRACE("%p, %p\n", thread
, io_pending
);
981 status
= NtQueryInformationThread( thread
, ThreadIsIoPending
,
982 io_pending
, sizeof(*io_pending
), NULL
);
985 SetLastError( RtlNtStatusToDosError(status
) );
991 /***********************************************************************
992 * CallbackMayRunLong (KERNEL32.@)
994 BOOL WINAPI
CallbackMayRunLong( TP_CALLBACK_INSTANCE
*instance
)
998 TRACE( "%p\n", instance
);
1000 status
= TpCallbackMayRunLong( instance
);
1003 SetLastError( RtlNtStatusToDosError(status
) );
1010 /***********************************************************************
1011 * CreateThreadpool (KERNEL32.@)
1013 PTP_POOL WINAPI
CreateThreadpool( PVOID reserved
)
1018 TRACE( "%p\n", reserved
);
1020 status
= TpAllocPool( &pool
, reserved
);
1023 SetLastError( RtlNtStatusToDosError(status
) );
1030 /***********************************************************************
1031 * CreateThreadpoolCleanupGroup (KERNEL32.@)
1033 PTP_CLEANUP_GROUP WINAPI
CreateThreadpoolCleanupGroup( void )
1035 TP_CLEANUP_GROUP
*group
;
1040 status
= TpAllocCleanupGroup( &group
);
1043 SetLastError( RtlNtStatusToDosError(status
) );
1050 /***********************************************************************
1051 * CreateThreadpoolIo (KERNEL32.@)
1053 PTP_IO WINAPI
CreateThreadpoolIo( HANDLE handle
, PTP_WIN32_IO_CALLBACK callback
,
1054 PVOID userdata
, TP_CALLBACK_ENVIRON
*environment
)
1056 FIXME("(%p, %p, %p, %p): stub\n", handle
, callback
, userdata
, environment
);
1060 /***********************************************************************
1061 * CreateThreadpoolTimer (KERNEL32.@)
1063 PTP_TIMER WINAPI
CreateThreadpoolTimer( PTP_TIMER_CALLBACK callback
, PVOID userdata
,
1064 TP_CALLBACK_ENVIRON
*environment
)
1069 TRACE( "%p, %p, %p\n", callback
, userdata
, environment
);
1071 status
= TpAllocTimer( &timer
, callback
, userdata
, environment
);
1074 SetLastError( RtlNtStatusToDosError(status
) );
1081 /***********************************************************************
1082 * CreateThreadpoolWait (KERNEL32.@)
1084 PTP_WAIT WINAPI
CreateThreadpoolWait( PTP_WAIT_CALLBACK callback
, PVOID userdata
,
1085 TP_CALLBACK_ENVIRON
*environment
)
1090 TRACE( "%p, %p, %p\n", callback
, userdata
, environment
);
1092 status
= TpAllocWait( &wait
, callback
, userdata
, environment
);
1095 SetLastError( RtlNtStatusToDosError(status
) );
1102 /***********************************************************************
1103 * CreateThreadpoolWork (KERNEL32.@)
1105 PTP_WORK WINAPI
CreateThreadpoolWork( PTP_WORK_CALLBACK callback
, PVOID userdata
,
1106 TP_CALLBACK_ENVIRON
*environment
)
1111 TRACE( "%p, %p, %p\n", callback
, userdata
, environment
);
1113 status
= TpAllocWork( &work
, callback
, userdata
, environment
);
1116 SetLastError( RtlNtStatusToDosError(status
) );
1123 /***********************************************************************
1124 * SetThreadpoolTimer (KERNEL32.@)
1126 VOID WINAPI
SetThreadpoolTimer( TP_TIMER
*timer
, FILETIME
*due_time
,
1127 DWORD period
, DWORD window_length
)
1129 LARGE_INTEGER timeout
;
1131 TRACE( "%p, %p, %u, %u\n", timer
, due_time
, period
, window_length
);
1135 timeout
.u
.LowPart
= due_time
->dwLowDateTime
;
1136 timeout
.u
.HighPart
= due_time
->dwHighDateTime
;
1139 TpSetTimer( timer
, due_time
? &timeout
: NULL
, period
, window_length
);
1142 /***********************************************************************
1143 * SetThreadpoolWait (KERNEL32.@)
1145 VOID WINAPI
SetThreadpoolWait( TP_WAIT
*wait
, HANDLE handle
, FILETIME
*due_time
)
1147 LARGE_INTEGER timeout
;
1149 TRACE( "%p, %p, %p\n", wait
, handle
, due_time
);
1157 timeout
.u
.LowPart
= due_time
->dwLowDateTime
;
1158 timeout
.u
.HighPart
= due_time
->dwHighDateTime
;
1161 TpSetWait( wait
, handle
, due_time
? &timeout
: NULL
);
1164 /***********************************************************************
1165 * TrySubmitThreadpoolCallback (KERNEL32.@)
1167 BOOL WINAPI
TrySubmitThreadpoolCallback( PTP_SIMPLE_CALLBACK callback
, PVOID userdata
,
1168 TP_CALLBACK_ENVIRON
*environment
)
1172 TRACE( "%p, %p, %p\n", callback
, userdata
, environment
);
1174 status
= TpSimpleTryPost( callback
, userdata
, environment
);
1177 SetLastError( RtlNtStatusToDosError(status
) );