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
);
59 /***************************************************************************
60 * CreateRemoteThread (KERNEL32.@)
62 * Creates a thread that runs in the address space of another process
67 * Success: Handle to the new thread.
68 * Failure: NULL. Use GetLastError() to find the error cause.
71 * Improper memory allocation: there's no ability to free new_thread_info
73 * Bad start address for RtlCreateUserThread because the library
74 * may be loaded at different address in other process.
76 HANDLE WINAPI
CreateRemoteThread( HANDLE hProcess
, SECURITY_ATTRIBUTES
*sa
, SIZE_T stack
,
77 LPTHREAD_START_ROUTINE start
, LPVOID param
,
78 DWORD flags
, LPDWORD id
)
83 SIZE_T stack_reserve
= 0, stack_commit
= 0;
85 if (flags
& STACK_SIZE_PARAM_IS_A_RESERVATION
) stack_reserve
= stack
;
86 else stack_commit
= stack
;
88 status
= RtlCreateUserThread( hProcess
, NULL
, TRUE
,
89 NULL
, stack_reserve
, stack_commit
,
90 (PRTL_THREAD_START_ROUTINE
)start
, param
, &handle
, &client_id
);
91 if (status
== STATUS_SUCCESS
)
93 if (id
) *id
= HandleToULong(client_id
.UniqueThread
);
94 if (sa
&& (sa
->nLength
>= sizeof(*sa
)) && sa
->bInheritHandle
)
95 SetHandleInformation( handle
, HANDLE_FLAG_INHERIT
, HANDLE_FLAG_INHERIT
);
96 if (!(flags
& CREATE_SUSPENDED
))
99 if (NtResumeThread( handle
, &ret
))
102 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
109 SetLastError( RtlNtStatusToDosError(status
) );
116 /***********************************************************************
117 * OpenThread [KERNEL32.@] Retrieves a handle to a thread from its thread id
119 HANDLE WINAPI
OpenThread( DWORD dwDesiredAccess
, BOOL bInheritHandle
, DWORD dwThreadId
)
123 OBJECT_ATTRIBUTES attr
;
126 attr
.Length
= sizeof(attr
);
127 attr
.RootDirectory
= 0;
128 attr
.Attributes
= bInheritHandle
? OBJ_INHERIT
: 0;
129 attr
.ObjectName
= NULL
;
130 attr
.SecurityDescriptor
= NULL
;
131 attr
.SecurityQualityOfService
= NULL
;
133 cid
.UniqueProcess
= 0; /* FIXME */
134 cid
.UniqueThread
= ULongToHandle(dwThreadId
);
135 status
= NtOpenThread( &handle
, dwDesiredAccess
, &attr
, &cid
);
138 SetLastError( RtlNtStatusToDosError(status
) );
145 /***********************************************************************
146 * ExitThread [KERNEL32.@] Ends a thread
151 void WINAPI
ExitThread( DWORD code
) /* [in] Exit code for this thread */
153 RtlExitUserThread( code
);
157 /**********************************************************************
158 * TerminateThread [KERNEL32.@] Terminates a thread
164 BOOL WINAPI
TerminateThread( HANDLE handle
, /* [in] Handle to thread */
165 DWORD exit_code
) /* [in] Exit code for thread */
167 NTSTATUS status
= NtTerminateThread( handle
, exit_code
);
168 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
173 /***********************************************************************
174 * FreeLibraryAndExitThread (KERNEL32.@)
176 void WINAPI
FreeLibraryAndExitThread(HINSTANCE hLibModule
, DWORD dwExitCode
)
178 FreeLibrary(hLibModule
);
179 ExitThread(dwExitCode
);
183 /**********************************************************************
184 * GetExitCodeThread (KERNEL32.@)
186 * Gets termination status of thread.
192 BOOL WINAPI
GetExitCodeThread(
193 HANDLE hthread
, /* [in] Handle to thread */
194 LPDWORD exitcode
) /* [out] Address to receive termination status */
196 THREAD_BASIC_INFORMATION info
;
197 NTSTATUS status
= NtQueryInformationThread( hthread
, ThreadBasicInformation
,
198 &info
, sizeof(info
), NULL
);
202 SetLastError( RtlNtStatusToDosError(status
) );
205 if (exitcode
) *exitcode
= info
.ExitStatus
;
210 /***********************************************************************
211 * SetThreadContext [KERNEL32.@] Sets context of thread.
217 BOOL WINAPI
SetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
218 const CONTEXT
*context
) /* [in] Address of context structure */
220 NTSTATUS status
= NtSetContextThread( handle
, context
);
221 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
226 /***********************************************************************
227 * GetThreadContext [KERNEL32.@] Retrieves context of thread.
233 BOOL WINAPI
GetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
234 CONTEXT
*context
) /* [out] Address of context structure */
236 NTSTATUS status
= NtGetContextThread( handle
, context
);
237 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
242 /**********************************************************************
243 * SuspendThread [KERNEL32.@] Suspends a thread.
246 * Success: Previous suspend count
247 * Failure: 0xFFFFFFFF
249 DWORD WINAPI
SuspendThread( HANDLE hthread
) /* [in] Handle to the thread */
252 NTSTATUS status
= NtSuspendThread( hthread
, &ret
);
257 SetLastError( RtlNtStatusToDosError(status
) );
263 /**********************************************************************
264 * ResumeThread [KERNEL32.@] Resumes a thread.
266 * Decrements a thread's suspend count. When count is zero, the
267 * execution of the thread is resumed.
270 * Success: Previous suspend count
271 * Failure: 0xFFFFFFFF
274 DWORD WINAPI
ResumeThread( HANDLE hthread
) /* [in] Identifies thread to restart */
277 NTSTATUS status
= NtResumeThread( hthread
, &ret
);
282 SetLastError( RtlNtStatusToDosError(status
) );
288 /**********************************************************************
289 * GetThreadPriority [KERNEL32.@] Returns priority for thread.
292 * Success: Thread's priority level.
293 * Failure: THREAD_PRIORITY_ERROR_RETURN
295 INT WINAPI
GetThreadPriority(
296 HANDLE hthread
) /* [in] Handle to thread */
298 THREAD_BASIC_INFORMATION info
;
299 NTSTATUS status
= NtQueryInformationThread( hthread
, ThreadBasicInformation
,
300 &info
, sizeof(info
), NULL
);
304 SetLastError( RtlNtStatusToDosError(status
) );
305 return THREAD_PRIORITY_ERROR_RETURN
;
307 return info
.Priority
;
311 /**********************************************************************
312 * SetThreadPriority [KERNEL32.@] Sets priority for thread.
318 BOOL WINAPI
SetThreadPriority(
319 HANDLE hthread
, /* [in] Handle to thread */
320 INT priority
) /* [in] Thread priority level */
322 DWORD prio
= priority
;
325 status
= NtSetInformationThread(hthread
, ThreadBasePriority
,
326 &prio
, sizeof(prio
));
330 SetLastError( RtlNtStatusToDosError(status
) );
338 /**********************************************************************
339 * GetThreadPriorityBoost [KERNEL32.@] Returns priority boost for thread.
341 * Always reports that priority boost is disabled.
347 BOOL WINAPI
GetThreadPriorityBoost(
348 HANDLE hthread
, /* [in] Handle to thread */
349 PBOOL pstate
) /* [out] pointer to var that receives the boost state */
351 if (pstate
) *pstate
= FALSE
;
356 /**********************************************************************
357 * SetThreadPriorityBoost [KERNEL32.@] Sets priority boost for thread.
359 * Priority boost is not implemented, but we return TRUE
360 * anyway because some games crash otherwise.
362 BOOL WINAPI
SetThreadPriorityBoost(
363 HANDLE hthread
, /* [in] Handle to thread */
364 BOOL disable
) /* [in] TRUE to disable priority boost */
370 /**********************************************************************
371 * SetThreadStackGuarantee (KERNEL32.@)
373 BOOL WINAPI
SetThreadStackGuarantee(PULONG stacksize
)
377 FIXME("(%p): stub\n", stacksize
);
381 /***********************************************************************
382 * GetThreadGroupAffinity (KERNEL32.@)
384 BOOL WINAPI
GetThreadGroupAffinity( HANDLE thread
, GROUP_AFFINITY
*affinity
)
390 SetLastError( ERROR_INVALID_PARAMETER
);
394 status
= NtQueryInformationThread( thread
, ThreadGroupInformation
,
395 affinity
, sizeof(*affinity
), NULL
);
398 SetLastError( RtlNtStatusToDosError(status
) );
405 /***********************************************************************
406 * SetThreadGroupAffinity (KERNEL32.@)
408 BOOL WINAPI
SetThreadGroupAffinity( HANDLE thread
, const GROUP_AFFINITY
*affinity_new
,
409 GROUP_AFFINITY
*affinity_old
)
413 if (affinity_old
&& !GetThreadGroupAffinity( thread
, affinity_old
))
416 status
= NtSetInformationThread( thread
, ThreadGroupInformation
,
417 affinity_new
, sizeof(*affinity_new
) );
420 SetLastError( RtlNtStatusToDosError(status
) );
427 /**********************************************************************
428 * SetThreadAffinityMask (KERNEL32.@)
430 DWORD_PTR WINAPI
SetThreadAffinityMask( HANDLE hThread
, DWORD_PTR dwThreadAffinityMask
)
433 THREAD_BASIC_INFORMATION tbi
;
435 status
= NtQueryInformationThread( hThread
, ThreadBasicInformation
,
436 &tbi
, sizeof(tbi
), NULL
);
439 SetLastError( RtlNtStatusToDosError(status
) );
442 status
= NtSetInformationThread( hThread
, ThreadAffinityMask
,
443 &dwThreadAffinityMask
,
444 sizeof(dwThreadAffinityMask
));
447 SetLastError( RtlNtStatusToDosError(status
) );
450 return tbi
.AffinityMask
;
454 /**********************************************************************
455 * SetThreadIdealProcessor [KERNEL32.@] Sets preferred processor for thread.
458 * Success: Value of last call to SetThreadIdealProcessor
461 DWORD WINAPI
SetThreadIdealProcessor(
462 HANDLE hThread
, /* [in] Specifies the thread of interest */
463 DWORD dwIdealProcessor
) /* [in] Specifies the new preferred processor */
465 FIXME("(%p): stub\n",hThread
);
466 if (dwIdealProcessor
> MAXIMUM_PROCESSORS
)
468 SetLastError(ERROR_INVALID_PARAMETER
);
475 /***********************************************************************
476 * GetThreadSelectorEntry (KERNEL32.@)
478 BOOL WINAPI
GetThreadSelectorEntry( HANDLE hthread
, DWORD sel
, LPLDT_ENTRY ldtent
)
480 THREAD_DESCRIPTOR_INFORMATION tdi
;
484 status
= NtQueryInformationThread( hthread
, ThreadDescriptorTableEntry
, &tdi
, sizeof(tdi
), NULL
);
487 SetLastError( RtlNtStatusToDosError(status
) );
495 /* callback for QueueUserAPC */
496 static void CALLBACK
call_user_apc( ULONG_PTR arg1
, ULONG_PTR arg2
, ULONG_PTR arg3
)
498 PAPCFUNC func
= (PAPCFUNC
)arg1
;
502 /***********************************************************************
503 * QueueUserAPC (KERNEL32.@)
505 DWORD WINAPI
QueueUserAPC( PAPCFUNC func
, HANDLE hthread
, ULONG_PTR data
)
507 NTSTATUS status
= NtQueueApcThread( hthread
, call_user_apc
, (ULONG_PTR
)func
, data
, 0 );
509 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
513 /***********************************************************************
514 * QueueUserWorkItem (KERNEL32.@)
516 BOOL WINAPI
QueueUserWorkItem( LPTHREAD_START_ROUTINE Function
, PVOID Context
, ULONG Flags
)
520 TRACE("(%p,%p,0x%08x)\n", Function
, Context
, Flags
);
522 status
= RtlQueueWorkItem( Function
, Context
, Flags
);
524 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
528 /**********************************************************************
529 * GetThreadTimes [KERNEL32.@] Obtains timing information.
535 BOOL WINAPI
GetThreadTimes(
536 HANDLE thread
, /* [in] Specifies the thread of interest */
537 LPFILETIME creationtime
, /* [out] When the thread was created */
538 LPFILETIME exittime
, /* [out] When the thread was destroyed */
539 LPFILETIME kerneltime
, /* [out] Time thread spent in kernel mode */
540 LPFILETIME usertime
) /* [out] Time thread spent in user mode */
542 KERNEL_USER_TIMES kusrt
;
545 status
= NtQueryInformationThread(thread
, ThreadTimes
, &kusrt
,
546 sizeof(kusrt
), NULL
);
549 SetLastError( RtlNtStatusToDosError(status
) );
554 creationtime
->dwLowDateTime
= kusrt
.CreateTime
.u
.LowPart
;
555 creationtime
->dwHighDateTime
= kusrt
.CreateTime
.u
.HighPart
;
559 exittime
->dwLowDateTime
= kusrt
.ExitTime
.u
.LowPart
;
560 exittime
->dwHighDateTime
= kusrt
.ExitTime
.u
.HighPart
;
564 kerneltime
->dwLowDateTime
= kusrt
.KernelTime
.u
.LowPart
;
565 kerneltime
->dwHighDateTime
= kusrt
.KernelTime
.u
.HighPart
;
569 usertime
->dwLowDateTime
= kusrt
.UserTime
.u
.LowPart
;
570 usertime
->dwHighDateTime
= kusrt
.UserTime
.u
.HighPart
;
576 /**********************************************************************
577 * GetThreadId [KERNEL32.@]
579 * Retrieve the identifier of a thread.
582 * Thread [I] The thread to retrieve the identifier of.
585 * Success: Identifier of the target thread.
588 DWORD WINAPI
GetThreadId(HANDLE Thread
)
590 THREAD_BASIC_INFORMATION tbi
;
593 TRACE("(%p)\n", Thread
);
595 status
= NtQueryInformationThread(Thread
, ThreadBasicInformation
, &tbi
,
599 SetLastError( RtlNtStatusToDosError(status
) );
603 return HandleToULong(tbi
.ClientId
.UniqueThread
);
606 /**********************************************************************
607 * GetProcessIdOfThread [KERNEL32.@]
609 * Retrieve process identifier given thread belongs to.
612 * Thread [I] The thread identifier.
615 * Success: Process identifier
618 DWORD WINAPI
GetProcessIdOfThread(HANDLE Thread
)
620 THREAD_BASIC_INFORMATION tbi
;
623 TRACE("(%p)\n", Thread
);
625 status
= NtQueryInformationThread(Thread
, ThreadBasicInformation
, &tbi
,
629 SetLastError( RtlNtStatusToDosError(status
) );
633 return HandleToULong(tbi
.ClientId
.UniqueProcess
);
636 /***********************************************************************
637 * GetCurrentThread [KERNEL32.@] Gets pseudohandle for current thread
640 * Pseudohandle for the current thread
642 #undef GetCurrentThread
643 HANDLE WINAPI
GetCurrentThread(void)
645 return (HANDLE
)~(ULONG_PTR
)1;
651 /***********************************************************************
652 * SetLastError (KERNEL32.@)
654 /* void WINAPI SetLastError( DWORD error ); */
655 __ASM_STDCALL_FUNC( SetLastError
, 4,
656 "movl 4(%esp),%eax\n\t"
661 /***********************************************************************
662 * GetLastError (KERNEL32.@)
664 /* DWORD WINAPI GetLastError(void); */
665 __ASM_STDCALL_FUNC( GetLastError
, 0, ".byte 0x64\n\tmovl 0x34,%eax\n\tret" )
667 /***********************************************************************
668 * GetCurrentProcessId (KERNEL32.@)
670 /* DWORD WINAPI GetCurrentProcessId(void) */
671 __ASM_STDCALL_FUNC( GetCurrentProcessId
, 0, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" )
673 /***********************************************************************
674 * GetCurrentThreadId (KERNEL32.@)
676 /* DWORD WINAPI GetCurrentThreadId(void) */
677 __ASM_STDCALL_FUNC( GetCurrentThreadId
, 0, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" )
679 /***********************************************************************
680 * GetProcessHeap (KERNEL32.@)
682 /* HANDLE WINAPI GetProcessHeap(void) */
683 __ASM_STDCALL_FUNC( GetProcessHeap
, 0, ".byte 0x64\n\tmovl 0x30,%eax\n\tmovl 0x18(%eax),%eax\n\tret");
685 #elif defined(__x86_64__) && !defined(__APPLE__)
687 /***********************************************************************
688 * SetLastError (KERNEL32.@)
690 /* void WINAPI SetLastError( DWORD error ); */
691 __ASM_STDCALL_FUNC( SetLastError
, 8, ".byte 0x65\n\tmovl %ecx,0x68\n\tret" );
693 /***********************************************************************
694 * GetLastError (KERNEL32.@)
696 /* DWORD WINAPI GetLastError(void); */
697 __ASM_STDCALL_FUNC( GetLastError
, 0, ".byte 0x65\n\tmovl 0x68,%eax\n\tret" );
699 /***********************************************************************
700 * GetCurrentProcessId (KERNEL32.@)
702 /* DWORD WINAPI GetCurrentProcessId(void) */
703 __ASM_STDCALL_FUNC( GetCurrentProcessId
, 0, ".byte 0x65\n\tmovl 0x40,%eax\n\tret" );
705 /***********************************************************************
706 * GetCurrentThreadId (KERNEL32.@)
708 /* DWORD WINAPI GetCurrentThreadId(void) */
709 __ASM_STDCALL_FUNC( GetCurrentThreadId
, 0, ".byte 0x65\n\tmovl 0x48,%eax\n\tret" );
711 /***********************************************************************
712 * GetProcessHeap (KERNEL32.@)
714 /* HANDLE WINAPI GetProcessHeap(void) */
715 __ASM_STDCALL_FUNC( GetProcessHeap
, 0, ".byte 0x65\n\tmovq 0x60,%rax\n\tmovq 0x30(%rax),%rax\n\tret");
717 #else /* __x86_64__ */
719 /**********************************************************************
720 * SetLastError (KERNEL32.@)
722 * Sets the last-error code.
727 void WINAPI
SetLastError( DWORD error
) /* [in] Per-thread error code */
729 NtCurrentTeb()->LastErrorValue
= error
;
732 /**********************************************************************
733 * GetLastError (KERNEL32.@)
735 * Get the last-error code.
740 DWORD WINAPI
GetLastError(void)
742 return NtCurrentTeb()->LastErrorValue
;
745 /***********************************************************************
746 * GetCurrentProcessId (KERNEL32.@)
748 * Get the current process identifier.
751 * current process identifier
753 DWORD WINAPI
GetCurrentProcessId(void)
755 return HandleToULong(NtCurrentTeb()->ClientId
.UniqueProcess
);
758 /***********************************************************************
759 * GetCurrentThreadId (KERNEL32.@)
761 * Get the current thread identifier.
764 * current thread identifier
766 DWORD WINAPI
GetCurrentThreadId(void)
768 return HandleToULong(NtCurrentTeb()->ClientId
.UniqueThread
);
771 /***********************************************************************
772 * GetProcessHeap (KERNEL32.@)
774 HANDLE WINAPI
GetProcessHeap(void)
776 return NtCurrentTeb()->Peb
->ProcessHeap
;
779 #endif /* __i386__ */
781 /*************************************************************************
782 * rtlmode_to_win32mode
784 static DWORD
rtlmode_to_win32mode( DWORD rtlmode
)
789 win32mode
|= SEM_FAILCRITICALERRORS
;
791 win32mode
|= SEM_NOGPFAULTERRORBOX
;
793 win32mode
|= SEM_NOOPENFILEERRORBOX
;
798 /***********************************************************************
799 * SetThreadErrorMode (KERNEL32.@)
801 * Set the thread local error mode.
804 * mode [I] The new error mode, a bitwise or of SEM_FAILCRITICALERRORS,
805 * SEM_NOGPFAULTERRORBOX and SEM_NOOPENFILEERRORBOX.
806 * oldmode [O] Destination of the old error mode (may be NULL)
810 * Failure: FALSE, check GetLastError
812 BOOL WINAPI
SetThreadErrorMode( DWORD mode
, LPDWORD oldmode
)
817 if (mode
& ~(SEM_FAILCRITICALERRORS
|
818 SEM_NOGPFAULTERRORBOX
|
819 SEM_NOOPENFILEERRORBOX
))
821 SetLastError( ERROR_INVALID_PARAMETER
);
825 if (mode
& SEM_FAILCRITICALERRORS
)
827 if (mode
& SEM_NOGPFAULTERRORBOX
)
829 if (mode
& SEM_NOOPENFILEERRORBOX
)
832 status
= RtlSetThreadErrorMode( tmp
, oldmode
);
835 SetLastError( RtlNtStatusToDosError(status
) );
840 *oldmode
= rtlmode_to_win32mode(*oldmode
);
845 /***********************************************************************
846 * GetThreadErrorMode (KERNEL32.@)
848 * Get the thread local error mode.
854 * The current thread local error mode.
856 DWORD WINAPI
GetThreadErrorMode( void )
858 return rtlmode_to_win32mode( RtlGetThreadErrorMode() );
861 /***********************************************************************
862 * GetThreadUILanguage (KERNEL32.@)
864 * Get the current thread's language identifier.
870 * The current thread's language identifier.
872 LANGID WINAPI
GetThreadUILanguage( void )
875 NtQueryDefaultUILanguage( &lang
);
876 FIXME(": stub, returning default language.\n");
880 /***********************************************************************
881 * GetThreadIOPendingFlag (KERNEL32.@)
883 BOOL WINAPI
GetThreadIOPendingFlag( HANDLE thread
, PBOOL io_pending
)
885 FIXME("%p, %p\n", thread
, io_pending
);
890 /***********************************************************************
891 * CallbackMayRunLong (KERNEL32.@)
893 BOOL WINAPI
CallbackMayRunLong( TP_CALLBACK_INSTANCE
*instance
)
897 TRACE( "%p\n", instance
);
899 status
= TpCallbackMayRunLong( instance
);
902 SetLastError( RtlNtStatusToDosError(status
) );
909 /***********************************************************************
910 * CreateThreadpool (KERNEL32.@)
912 PTP_POOL WINAPI
CreateThreadpool( PVOID reserved
)
917 TRACE( "%p\n", reserved
);
919 status
= TpAllocPool( &pool
, reserved
);
922 SetLastError( RtlNtStatusToDosError(status
) );
929 /***********************************************************************
930 * CreateThreadpoolCleanupGroup (KERNEL32.@)
932 PTP_CLEANUP_GROUP WINAPI
CreateThreadpoolCleanupGroup( void )
934 TP_CLEANUP_GROUP
*group
;
939 status
= TpAllocCleanupGroup( &group
);
942 SetLastError( RtlNtStatusToDosError(status
) );
949 /***********************************************************************
950 * CreateThreadpoolTimer (KERNEL32.@)
952 PTP_TIMER WINAPI
CreateThreadpoolTimer( PTP_TIMER_CALLBACK callback
, PVOID userdata
,
953 TP_CALLBACK_ENVIRON
*environment
)
958 TRACE( "%p, %p, %p\n", callback
, userdata
, environment
);
960 status
= TpAllocTimer( &timer
, callback
, userdata
, environment
);
963 SetLastError( RtlNtStatusToDosError(status
) );
970 /***********************************************************************
971 * CreateThreadpoolWait (KERNEL32.@)
973 PTP_WAIT WINAPI
CreateThreadpoolWait( PTP_WAIT_CALLBACK callback
, PVOID userdata
,
974 TP_CALLBACK_ENVIRON
*environment
)
979 TRACE( "%p, %p, %p\n", callback
, userdata
, environment
);
981 status
= TpAllocWait( &wait
, callback
, userdata
, environment
);
984 SetLastError( RtlNtStatusToDosError(status
) );
991 /***********************************************************************
992 * CreateThreadpoolWork (KERNEL32.@)
994 PTP_WORK WINAPI
CreateThreadpoolWork( PTP_WORK_CALLBACK callback
, PVOID userdata
,
995 TP_CALLBACK_ENVIRON
*environment
)
1000 TRACE( "%p, %p, %p\n", callback
, userdata
, environment
);
1002 status
= TpAllocWork( &work
, callback
, userdata
, environment
);
1005 SetLastError( RtlNtStatusToDosError(status
) );
1012 /***********************************************************************
1013 * SetThreadpoolTimer (KERNEL32.@)
1015 VOID WINAPI
SetThreadpoolTimer( TP_TIMER
*timer
, FILETIME
*due_time
,
1016 DWORD period
, DWORD window_length
)
1018 LARGE_INTEGER timeout
;
1020 TRACE( "%p, %p, %u, %u\n", timer
, due_time
, period
, window_length
);
1024 timeout
.u
.LowPart
= due_time
->dwLowDateTime
;
1025 timeout
.u
.HighPart
= due_time
->dwHighDateTime
;
1028 TpSetTimer( timer
, due_time
? &timeout
: NULL
, period
, window_length
);
1031 /***********************************************************************
1032 * SetThreadpoolWait (KERNEL32.@)
1034 VOID WINAPI
SetThreadpoolWait( TP_WAIT
*wait
, HANDLE handle
, FILETIME
*due_time
)
1036 LARGE_INTEGER timeout
;
1038 TRACE( "%p, %p, %p\n", wait
, handle
, due_time
);
1046 timeout
.u
.LowPart
= due_time
->dwLowDateTime
;
1047 timeout
.u
.HighPart
= due_time
->dwHighDateTime
;
1050 TpSetWait( wait
, handle
, due_time
? &timeout
: NULL
);
1053 /***********************************************************************
1054 * TrySubmitThreadpoolCallback (KERNEL32.@)
1056 BOOL WINAPI
TrySubmitThreadpoolCallback( PTP_SIMPLE_CALLBACK callback
, PVOID userdata
,
1057 TP_CALLBACK_ENVIRON
*environment
)
1061 TRACE( "%p, %p, %p\n", callback
, userdata
, environment
);
1063 status
= TpSimpleTryPost( callback
, userdata
, environment
);
1066 SetLastError( RtlNtStatusToDosError(status
) );