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 RtlFreeThreadActivationContextStack();
154 RtlExitUserThread( code
);
158 /**********************************************************************
159 * TerminateThread [KERNEL32.@] Terminates a thread
165 BOOL WINAPI
TerminateThread( HANDLE handle
, /* [in] Handle to thread */
166 DWORD exit_code
) /* [in] Exit code for thread */
168 NTSTATUS status
= NtTerminateThread( handle
, exit_code
);
169 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
174 /***********************************************************************
175 * FreeLibraryAndExitThread (KERNEL32.@)
177 void WINAPI
FreeLibraryAndExitThread(HINSTANCE hLibModule
, DWORD dwExitCode
)
179 FreeLibrary(hLibModule
);
180 ExitThread(dwExitCode
);
184 /**********************************************************************
185 * GetExitCodeThread (KERNEL32.@)
187 * Gets termination status of thread.
193 BOOL WINAPI
GetExitCodeThread(
194 HANDLE hthread
, /* [in] Handle to thread */
195 LPDWORD exitcode
) /* [out] Address to receive termination status */
197 THREAD_BASIC_INFORMATION info
;
198 NTSTATUS status
= NtQueryInformationThread( hthread
, ThreadBasicInformation
,
199 &info
, sizeof(info
), NULL
);
203 SetLastError( RtlNtStatusToDosError(status
) );
206 if (exitcode
) *exitcode
= info
.ExitStatus
;
211 /***********************************************************************
212 * SetThreadContext [KERNEL32.@] Sets context of thread.
218 BOOL WINAPI
SetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
219 const CONTEXT
*context
) /* [in] Address of context structure */
221 NTSTATUS status
= NtSetContextThread( handle
, context
);
222 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
227 /***********************************************************************
228 * GetThreadContext [KERNEL32.@] Retrieves context of thread.
234 BOOL WINAPI
GetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
235 CONTEXT
*context
) /* [out] Address of context structure */
237 NTSTATUS status
= NtGetContextThread( handle
, context
);
238 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
243 /**********************************************************************
244 * SuspendThread [KERNEL32.@] Suspends a thread.
247 * Success: Previous suspend count
248 * Failure: 0xFFFFFFFF
250 DWORD WINAPI
SuspendThread( HANDLE hthread
) /* [in] Handle to the thread */
253 NTSTATUS status
= NtSuspendThread( hthread
, &ret
);
258 SetLastError( RtlNtStatusToDosError(status
) );
264 /**********************************************************************
265 * ResumeThread [KERNEL32.@] Resumes a thread.
267 * Decrements a thread's suspend count. When count is zero, the
268 * execution of the thread is resumed.
271 * Success: Previous suspend count
272 * Failure: 0xFFFFFFFF
275 DWORD WINAPI
ResumeThread( HANDLE hthread
) /* [in] Identifies thread to restart */
278 NTSTATUS status
= NtResumeThread( hthread
, &ret
);
283 SetLastError( RtlNtStatusToDosError(status
) );
289 /**********************************************************************
290 * GetThreadPriority [KERNEL32.@] Returns priority for thread.
293 * Success: Thread's priority level.
294 * Failure: THREAD_PRIORITY_ERROR_RETURN
296 INT WINAPI
GetThreadPriority(
297 HANDLE hthread
) /* [in] Handle to thread */
299 THREAD_BASIC_INFORMATION info
;
300 NTSTATUS status
= NtQueryInformationThread( hthread
, ThreadBasicInformation
,
301 &info
, sizeof(info
), NULL
);
305 SetLastError( RtlNtStatusToDosError(status
) );
306 return THREAD_PRIORITY_ERROR_RETURN
;
308 return info
.Priority
;
312 /**********************************************************************
313 * SetThreadPriority [KERNEL32.@] Sets priority for thread.
319 BOOL WINAPI
SetThreadPriority(
320 HANDLE hthread
, /* [in] Handle to thread */
321 INT priority
) /* [in] Thread priority level */
323 DWORD prio
= priority
;
326 status
= NtSetInformationThread(hthread
, ThreadBasePriority
,
327 &prio
, sizeof(prio
));
331 SetLastError( RtlNtStatusToDosError(status
) );
339 /**********************************************************************
340 * GetThreadPriorityBoost [KERNEL32.@] Returns priority boost for thread.
342 * Always reports that priority boost is disabled.
348 BOOL WINAPI
GetThreadPriorityBoost(
349 HANDLE hthread
, /* [in] Handle to thread */
350 PBOOL pstate
) /* [out] pointer to var that receives the boost state */
352 if (pstate
) *pstate
= FALSE
;
357 /**********************************************************************
358 * SetThreadPriorityBoost [KERNEL32.@] Sets priority boost for thread.
360 * Priority boost is not implemented, but we return TRUE
361 * anyway because some games crash otherwise.
363 BOOL WINAPI
SetThreadPriorityBoost(
364 HANDLE hthread
, /* [in] Handle to thread */
365 BOOL disable
) /* [in] TRUE to disable priority boost */
371 /**********************************************************************
372 * SetThreadStackGuarantee (KERNEL32.@)
374 BOOL WINAPI
SetThreadStackGuarantee(PULONG stacksize
)
378 FIXME("(%p): stub\n", stacksize
);
382 /**********************************************************************
383 * SetThreadAffinityMask (KERNEL32.@)
385 DWORD_PTR WINAPI
SetThreadAffinityMask( HANDLE hThread
, DWORD_PTR dwThreadAffinityMask
)
388 THREAD_BASIC_INFORMATION tbi
;
390 status
= NtQueryInformationThread( hThread
, ThreadBasicInformation
,
391 &tbi
, sizeof(tbi
), NULL
);
394 SetLastError( RtlNtStatusToDosError(status
) );
397 status
= NtSetInformationThread( hThread
, ThreadAffinityMask
,
398 &dwThreadAffinityMask
,
399 sizeof(dwThreadAffinityMask
));
402 SetLastError( RtlNtStatusToDosError(status
) );
405 return tbi
.AffinityMask
;
409 /**********************************************************************
410 * SetThreadIdealProcessor [KERNEL32.@] Sets preferred processor for thread.
413 * Success: Value of last call to SetThreadIdealProcessor
416 DWORD WINAPI
SetThreadIdealProcessor(
417 HANDLE hThread
, /* [in] Specifies the thread of interest */
418 DWORD dwIdealProcessor
) /* [in] Specifies the new preferred processor */
420 FIXME("(%p): stub\n",hThread
);
421 if (dwIdealProcessor
> MAXIMUM_PROCESSORS
)
423 SetLastError(ERROR_INVALID_PARAMETER
);
430 /***********************************************************************
431 * GetThreadSelectorEntry (KERNEL32.@)
433 BOOL WINAPI
GetThreadSelectorEntry( HANDLE hthread
, DWORD sel
, LPLDT_ENTRY ldtent
)
435 THREAD_DESCRIPTOR_INFORMATION tdi
;
439 status
= NtQueryInformationThread( hthread
, ThreadDescriptorTableEntry
, &tdi
, sizeof(tdi
), NULL
);
442 SetLastError( RtlNtStatusToDosError(status
) );
450 /* callback for QueueUserAPC */
451 static void CALLBACK
call_user_apc( ULONG_PTR arg1
, ULONG_PTR arg2
, ULONG_PTR arg3
)
453 PAPCFUNC func
= (PAPCFUNC
)arg1
;
457 /***********************************************************************
458 * QueueUserAPC (KERNEL32.@)
460 DWORD WINAPI
QueueUserAPC( PAPCFUNC func
, HANDLE hthread
, ULONG_PTR data
)
462 NTSTATUS status
= NtQueueApcThread( hthread
, call_user_apc
, (ULONG_PTR
)func
, data
, 0 );
464 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
468 /***********************************************************************
469 * QueueUserWorkItem (KERNEL32.@)
471 BOOL WINAPI
QueueUserWorkItem( LPTHREAD_START_ROUTINE Function
, PVOID Context
, ULONG Flags
)
475 TRACE("(%p,%p,0x%08x)\n", Function
, Context
, Flags
);
477 status
= RtlQueueWorkItem( Function
, Context
, Flags
);
479 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
483 /**********************************************************************
484 * GetThreadTimes [KERNEL32.@] Obtains timing information.
490 BOOL WINAPI
GetThreadTimes(
491 HANDLE thread
, /* [in] Specifies the thread of interest */
492 LPFILETIME creationtime
, /* [out] When the thread was created */
493 LPFILETIME exittime
, /* [out] When the thread was destroyed */
494 LPFILETIME kerneltime
, /* [out] Time thread spent in kernel mode */
495 LPFILETIME usertime
) /* [out] Time thread spent in user mode */
497 KERNEL_USER_TIMES kusrt
;
500 status
= NtQueryInformationThread(thread
, ThreadTimes
, &kusrt
,
501 sizeof(kusrt
), NULL
);
504 SetLastError( RtlNtStatusToDosError(status
) );
509 creationtime
->dwLowDateTime
= kusrt
.CreateTime
.u
.LowPart
;
510 creationtime
->dwHighDateTime
= kusrt
.CreateTime
.u
.HighPart
;
514 exittime
->dwLowDateTime
= kusrt
.ExitTime
.u
.LowPart
;
515 exittime
->dwHighDateTime
= kusrt
.ExitTime
.u
.HighPart
;
519 kerneltime
->dwLowDateTime
= kusrt
.KernelTime
.u
.LowPart
;
520 kerneltime
->dwHighDateTime
= kusrt
.KernelTime
.u
.HighPart
;
524 usertime
->dwLowDateTime
= kusrt
.UserTime
.u
.LowPart
;
525 usertime
->dwHighDateTime
= kusrt
.UserTime
.u
.HighPart
;
531 /**********************************************************************
532 * GetThreadId [KERNEL32.@]
534 * Retrieve the identifier of a thread.
537 * Thread [I] The thread to retrieve the identifier of.
540 * Success: Identifier of the target thread.
543 DWORD WINAPI
GetThreadId(HANDLE Thread
)
545 THREAD_BASIC_INFORMATION tbi
;
548 TRACE("(%p)\n", Thread
);
550 status
= NtQueryInformationThread(Thread
, ThreadBasicInformation
, &tbi
,
554 SetLastError( RtlNtStatusToDosError(status
) );
558 return HandleToULong(tbi
.ClientId
.UniqueThread
);
562 /***********************************************************************
563 * GetCurrentThread [KERNEL32.@] Gets pseudohandle for current thread
566 * Pseudohandle for the current thread
568 #undef GetCurrentThread
569 HANDLE WINAPI
GetCurrentThread(void)
571 return (HANDLE
)~(ULONG_PTR
)1;
577 /***********************************************************************
578 * SetLastError (KERNEL32.@)
580 /* void WINAPI SetLastError( DWORD error ); */
581 __ASM_STDCALL_FUNC( SetLastError
, 4,
582 "movl 4(%esp),%eax\n\t"
587 /***********************************************************************
588 * GetLastError (KERNEL32.@)
590 /* DWORD WINAPI GetLastError(void); */
591 __ASM_STDCALL_FUNC( GetLastError
, 0, ".byte 0x64\n\tmovl 0x34,%eax\n\tret" )
593 /***********************************************************************
594 * GetCurrentProcessId (KERNEL32.@)
596 /* DWORD WINAPI GetCurrentProcessId(void) */
597 __ASM_STDCALL_FUNC( GetCurrentProcessId
, 0, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" )
599 /***********************************************************************
600 * GetCurrentThreadId (KERNEL32.@)
602 /* DWORD WINAPI GetCurrentThreadId(void) */
603 __ASM_STDCALL_FUNC( GetCurrentThreadId
, 0, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" )
605 /***********************************************************************
606 * GetProcessHeap (KERNEL32.@)
608 /* HANDLE WINAPI GetProcessHeap(void) */
609 __ASM_STDCALL_FUNC( GetProcessHeap
, 0, ".byte 0x64\n\tmovl 0x30,%eax\n\tmovl 0x18(%eax),%eax\n\tret");
611 #elif defined(__x86_64__)
613 /***********************************************************************
614 * SetLastError (KERNEL32.@)
616 /* void WINAPI SetLastError( DWORD error ); */
617 __ASM_STDCALL_FUNC( SetLastError
, 8, ".byte 0x65\n\tmovl %ecx,0x68\n\tret" );
619 /***********************************************************************
620 * GetLastError (KERNEL32.@)
622 /* DWORD WINAPI GetLastError(void); */
623 __ASM_STDCALL_FUNC( GetLastError
, 0, ".byte 0x65\n\tmovl 0x68,%eax\n\tret" );
625 /***********************************************************************
626 * GetCurrentProcessId (KERNEL32.@)
628 /* DWORD WINAPI GetCurrentProcessId(void) */
629 __ASM_STDCALL_FUNC( GetCurrentProcessId
, 0, ".byte 0x65\n\tmovl 0x40,%eax\n\tret" );
631 /***********************************************************************
632 * GetCurrentThreadId (KERNEL32.@)
634 /* DWORD WINAPI GetCurrentThreadId(void) */
635 __ASM_STDCALL_FUNC( GetCurrentThreadId
, 0, ".byte 0x65\n\tmovl 0x48,%eax\n\tret" );
637 /***********************************************************************
638 * GetProcessHeap (KERNEL32.@)
640 /* HANDLE WINAPI GetProcessHeap(void) */
641 __ASM_STDCALL_FUNC( GetProcessHeap
, 0, ".byte 0x65\n\tmovq 0x60,%rax\n\tmovq 0x30(%rax),%rax\n\tret");
643 #else /* __x86_64__ */
645 /**********************************************************************
646 * SetLastError (KERNEL32.@)
648 * Sets the last-error code.
653 void WINAPI
SetLastError( DWORD error
) /* [in] Per-thread error code */
655 NtCurrentTeb()->LastErrorValue
= error
;
658 /**********************************************************************
659 * GetLastError (KERNEL32.@)
661 * Get the last-error code.
666 DWORD WINAPI
GetLastError(void)
668 return NtCurrentTeb()->LastErrorValue
;
671 /***********************************************************************
672 * GetCurrentProcessId (KERNEL32.@)
674 * Get the current process identifier.
677 * current process identifier
679 DWORD WINAPI
GetCurrentProcessId(void)
681 return HandleToULong(NtCurrentTeb()->ClientId
.UniqueProcess
);
684 /***********************************************************************
685 * GetCurrentThreadId (KERNEL32.@)
687 * Get the current thread identifier.
690 * current thread identifier
692 DWORD WINAPI
GetCurrentThreadId(void)
694 return HandleToULong(NtCurrentTeb()->ClientId
.UniqueThread
);
697 /***********************************************************************
698 * GetProcessHeap (KERNEL32.@)
700 HANDLE WINAPI
GetProcessHeap(void)
702 return NtCurrentTeb()->Peb
->ProcessHeap
;
705 #endif /* __i386__ */
707 /*************************************************************************
708 * rtlmode_to_win32mode
710 static DWORD
rtlmode_to_win32mode( DWORD rtlmode
)
715 win32mode
|= SEM_FAILCRITICALERRORS
;
717 win32mode
|= SEM_NOGPFAULTERRORBOX
;
719 win32mode
|= SEM_NOOPENFILEERRORBOX
;
724 /***********************************************************************
725 * SetThreadErrorMode (KERNEL32.@)
727 * Set the thread local error mode.
730 * mode [I] The new error mode, a bitwise or of SEM_FAILCRITICALERRORS,
731 * SEM_NOGPFAULTERRORBOX and SEM_NOOPENFILEERRORBOX.
732 * oldmode [O] Destination of the old error mode (may be NULL)
736 * Failure: FALSE, check GetLastError
738 BOOL WINAPI
SetThreadErrorMode( DWORD mode
, LPDWORD oldmode
)
743 if (mode
& ~(SEM_FAILCRITICALERRORS
|
744 SEM_NOGPFAULTERRORBOX
|
745 SEM_NOOPENFILEERRORBOX
))
747 SetLastError( ERROR_INVALID_PARAMETER
);
751 if (mode
& SEM_FAILCRITICALERRORS
)
753 if (mode
& SEM_NOGPFAULTERRORBOX
)
755 if (mode
& SEM_NOOPENFILEERRORBOX
)
758 status
= RtlSetThreadErrorMode( tmp
, oldmode
);
761 SetLastError( RtlNtStatusToDosError(status
) );
766 *oldmode
= rtlmode_to_win32mode(*oldmode
);
771 /***********************************************************************
772 * GetThreadErrorMode (KERNEL32.@)
774 * Get the thread local error mode.
780 * The current thread local error mode.
782 DWORD WINAPI
GetThreadErrorMode( void )
784 return rtlmode_to_win32mode( RtlGetThreadErrorMode() );
787 /***********************************************************************
788 * GetThreadUILanguage (KERNEL32.@)
790 * Get the current thread's language identifier.
796 * The current thread's language identifier.
798 LANGID WINAPI
GetThreadUILanguage( void )
801 NtQueryDefaultUILanguage( &lang
);
802 FIXME(": stub, returning default language.\n");
806 /***********************************************************************
807 * GetThreadIOPendingFlag (KERNEL32.@)
809 BOOL WINAPI
GetThreadIOPendingFlag( HANDLE thread
, PBOOL io_pending
)
811 FIXME("%p, %p\n", thread
, io_pending
);
816 /***********************************************************************
817 * SetThreadPreferredUILanguages (KERNEL32.@)
819 BOOL WINAPI
SetThreadPreferredUILanguages( DWORD flags
, PCZZWSTR buffer
, PULONG count
)
821 FIXME( "%u, %p, %p\n", flags
, buffer
, count
);
825 /***********************************************************************
826 * GetThreadPreferredUILanguages (KERNEL32.@)
828 BOOL WINAPI
GetThreadPreferredUILanguages( DWORD flags
, PULONG count
, PCZZWSTR buffer
, PULONG buffersize
)
830 FIXME( "%u, %p, %p %p\n", flags
, count
, buffer
, buffersize
);