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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
26 #include <sys/types.h>
27 #ifdef HAVE_SYS_MMAN_H
31 #include "wine/winbase16.h"
36 #include "selectors.h"
38 #include "wine/server.h"
39 #include "stackframe.h"
40 #include "wine/debug.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(thread
);
44 WINE_DECLARE_DEBUG_CHANNEL(relay
);
46 /* TEB of the initial thread */
47 static TEB initial_teb
;
49 extern struct _PDB current_process
;
51 /***********************************************************************
54 * Convert a thread id to a TEB, making sure it is valid.
56 TEB
*THREAD_IdToTEB( DWORD id
)
60 if (!id
|| id
== GetCurrentThreadId()) return NtCurrentTeb();
62 SERVER_START_REQ( get_thread_info
)
65 req
->tid_in
= (void *)id
;
66 if (!wine_server_call( req
)) ret
= reply
->teb
;
72 /* Allow task handles to be used; convert to main thread */
75 TDB
*pTask
= TASK_GetPtr( id
);
76 if (pTask
) return pTask
->teb
;
78 SetLastError( ERROR_INVALID_PARAMETER
);
84 /***********************************************************************
87 * Initialization of a newly created TEB.
89 static BOOL
THREAD_InitTEB( TEB
*teb
)
91 teb
->except
= (void *)~0UL;
93 teb
->tibflags
= TEBF_WIN32
;
94 teb
->tls_ptr
= teb
->tls_array
;
95 teb
->exit_code
= STILL_ACTIVE
;
100 teb
->stack_top
= (void *)~0UL;
101 teb
->StaticUnicodeString
.MaximumLength
= sizeof(teb
->StaticUnicodeBuffer
);
102 teb
->StaticUnicodeString
.Buffer
= (PWSTR
)teb
->StaticUnicodeBuffer
;
103 teb
->teb_sel
= SELECTOR_AllocBlock( teb
, 0x1000, WINE_LDT_FLAGS_DATA
|WINE_LDT_FLAGS_32BIT
);
104 return (teb
->teb_sel
!= 0);
108 /***********************************************************************
111 * Free data structures associated with a thread.
112 * Must be called from the context of another thread.
114 static void THREAD_FreeTEB( TEB
*teb
)
116 TRACE("(%p) called\n", teb
);
117 /* Free the associated memory */
118 FreeSelector16( teb
->stack_sel
);
119 FreeSelector16( teb
->teb_sel
);
120 VirtualFree( teb
->stack_base
, 0, MEM_RELEASE
);
124 /***********************************************************************
127 * Allocate the stack of a thread.
129 TEB
*THREAD_InitStack( TEB
*teb
, DWORD stack_size
)
131 DWORD old_prot
, total_size
;
132 DWORD page_size
= getpagesize();
135 /* Allocate the stack */
137 if (stack_size
>= 16*1024*1024)
138 WARN("Thread stack size is %ld MB.\n",stack_size
/1024/1024);
140 /* if size is smaller than default, get stack size from parent */
141 if (stack_size
< 1024 * 1024)
144 stack_size
= 1024 * 1024; /* no parent */
146 stack_size
= ((char *)NtCurrentTeb()->stack_top
- (char *)NtCurrentTeb()->stack_base
147 - SIGNAL_STACK_SIZE
- 3 * page_size
);
150 /* FIXME: some Wine functions use a lot of stack, so we add 64Kb here */
151 stack_size
+= 64 * 1024;
153 /* Memory layout in allocated block:
156 * 1 page NOACCESS guard page
157 * SIGNAL_STACK_SIZE signal stack
158 * 1 page NOACCESS guard page
159 * 1 page PAGE_GUARD guard page
160 * stack_size normal stack
161 * 64Kb 16-bit stack (optional)
162 * 1 page TEB (except for initial thread)
163 * 1 page debug info (except for initial thread)
166 stack_size
= (stack_size
+ (page_size
- 1)) & ~(page_size
- 1);
167 total_size
= stack_size
+ SIGNAL_STACK_SIZE
+ 3 * page_size
;
168 total_size
+= 0x10000; /* 16-bit stack */
169 if (!teb
) total_size
+= 2 * page_size
;
171 if (!(base
= VirtualAlloc( NULL
, total_size
, MEM_COMMIT
, PAGE_EXECUTE_READWRITE
)))
176 teb
= (TEB
*)((char *)base
+ total_size
- 2 * page_size
);
177 if (!THREAD_InitTEB( teb
)) goto error
;
178 teb
->debug_info
= (char *)teb
+ page_size
;
181 teb
->stack_low
= base
;
182 teb
->stack_base
= base
;
183 teb
->signal_stack
= (char *)base
+ page_size
;
184 teb
->stack_top
= (char *)base
+ 3 * page_size
+ SIGNAL_STACK_SIZE
+ stack_size
;
186 /* Setup guard pages */
188 VirtualProtect( base
, 1, PAGE_NOACCESS
, &old_prot
);
189 VirtualProtect( (char *)teb
->signal_stack
+ SIGNAL_STACK_SIZE
, 1, PAGE_NOACCESS
, &old_prot
);
190 VirtualProtect( (char *)teb
->signal_stack
+ SIGNAL_STACK_SIZE
+ page_size
, 1,
191 PAGE_EXECUTE_READWRITE
| PAGE_GUARD
, &old_prot
);
193 /* Allocate the 16-bit stack selector */
195 teb
->stack_sel
= SELECTOR_AllocBlock( teb
->stack_top
, 0x10000, WINE_LDT_FLAGS_DATA
);
196 if (!teb
->stack_sel
) goto error
;
197 teb
->cur_stack
= MAKESEGPTR( teb
->stack_sel
, 0x10000 - sizeof(STACK16FRAME
) );
202 FreeSelector16( teb
->teb_sel
);
203 VirtualFree( base
, 0, MEM_RELEASE
);
208 /***********************************************************************
209 * thread_errno_location
211 * Get the per-thread errno location.
213 static int *thread_errno_location(void)
215 return &NtCurrentTeb()->thread_errno
;
218 /***********************************************************************
219 * thread_h_errno_location
221 * Get the per-thread h_errno location.
223 static int *thread_h_errno_location(void)
225 return &NtCurrentTeb()->thread_h_errno
;
228 /***********************************************************************
231 * Setup the initial thread.
233 * NOTES: The first allocated TEB on NT is at 0x7ffde000.
235 void THREAD_Init(void)
237 if (!initial_teb
.self
) /* do it only once */
239 THREAD_InitTEB( &initial_teb
);
240 assert( initial_teb
.teb_sel
);
241 initial_teb
.process
= ¤t_process
;
242 SYSDEPS_SetCurThread( &initial_teb
);
243 wine_errno_location
= thread_errno_location
;
244 wine_h_errno_location
= thread_h_errno_location
;
248 DECL_GLOBAL_CONSTRUCTOR(thread_init
) { THREAD_Init(); }
251 /***********************************************************************
254 * Start execution of a newly created thread. Does not return.
256 static void THREAD_Start(void)
258 LPTHREAD_START_ROUTINE func
= (LPTHREAD_START_ROUTINE
)NtCurrentTeb()->entry_point
;
261 DPRINTF("%08lx:Starting thread (entryproc=%p)\n", GetCurrentThreadId(), func
);
263 PROCESS_CallUserSignalProc( USIG_THREAD_INIT
, 0 );
264 MODULE_DllThreadAttach( NULL
);
265 ExitThread( func( NtCurrentTeb()->entry_arg
) );
269 /***********************************************************************
270 * CreateThread (KERNEL32.@)
272 HANDLE WINAPI
CreateThread( SECURITY_ATTRIBUTES
*sa
, DWORD stack
,
273 LPTHREAD_START_ROUTINE start
, LPVOID param
,
274 DWORD flags
, LPDWORD id
)
281 if (pipe( request_pipe
) == -1)
283 SetLastError( ERROR_TOO_MANY_OPEN_FILES
);
286 fcntl( request_pipe
[1], F_SETFD
, 1 ); /* set close on exec flag */
287 wine_server_send_fd( request_pipe
[0] );
289 SERVER_START_REQ( new_thread
)
291 req
->suspend
= ((flags
& CREATE_SUSPENDED
) != 0);
292 req
->inherit
= (sa
&& (sa
->nLength
>=sizeof(*sa
)) && sa
->bInheritHandle
);
293 req
->request_fd
= request_pipe
[0];
294 if (!wine_server_call_err( req
))
296 handle
= reply
->handle
;
299 close( request_pipe
[0] );
303 if (!handle
|| !(teb
= THREAD_InitStack( NULL
, stack
)))
305 close( request_pipe
[1] );
309 teb
->process
= NtCurrentTeb()->process
;
311 teb
->request_fd
= request_pipe
[1];
312 teb
->entry_point
= start
;
313 teb
->entry_arg
= param
;
314 teb
->startup
= THREAD_Start
;
315 teb
->htask16
= GetCurrentTask();
317 if (id
) *id
= (DWORD
)tid
;
318 if (SYSDEPS_SpawnThread( teb
) == -1)
320 CloseHandle( handle
);
321 close( request_pipe
[1] );
322 THREAD_FreeTEB( teb
);
328 /***********************************************************************
329 * CreateThread16 (KERNEL.441)
331 static DWORD CALLBACK
THREAD_StartThread16( LPVOID threadArgs
)
333 FARPROC16 start
= ((FARPROC16
*)threadArgs
)[0];
334 DWORD param
= ((DWORD
*)threadArgs
)[1];
335 HeapFree( GetProcessHeap(), 0, threadArgs
);
337 ((LPDWORD
)CURRENT_STACK16
)[-1] = param
;
338 return wine_call_to_16_long( start
, sizeof(DWORD
) );
340 HANDLE WINAPI
CreateThread16( SECURITY_ATTRIBUTES
*sa
, DWORD stack
,
341 FARPROC16 start
, SEGPTR param
,
342 DWORD flags
, LPDWORD id
)
344 DWORD
*threadArgs
= HeapAlloc( GetProcessHeap(), 0, 2*sizeof(DWORD
) );
345 if (!threadArgs
) return INVALID_HANDLE_VALUE
;
346 threadArgs
[0] = (DWORD
)start
;
347 threadArgs
[1] = (DWORD
)param
;
349 return CreateThread( sa
, stack
, THREAD_StartThread16
, threadArgs
, flags
, id
);
353 /***********************************************************************
354 * ExitThread [KERNEL32.@] Ends a thread
359 void WINAPI
ExitThread( DWORD code
) /* [in] Exit code for this thread */
362 SERVER_START_REQ( terminate_thread
)
364 /* send the exit code to the server */
365 req
->handle
= GetCurrentThread();
366 req
->exit_code
= code
;
367 wine_server_call( req
);
374 MODULE_DllProcessDetach( TRUE
, (LPVOID
)1 );
379 MODULE_DllThreadDetach( NULL
);
380 if (!(NtCurrentTeb()->tibflags
& TEBF_WIN32
)) TASK_ExitTask();
381 SYSDEPS_ExitThread( code
);
386 /***********************************************************************
387 * SetThreadContext [KERNEL32.@] Sets context of thread.
393 BOOL WINAPI
SetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
394 const CONTEXT
*context
) /* [in] Address of context structure */
397 SERVER_START_REQ( set_thread_context
)
399 req
->handle
= handle
;
400 req
->flags
= context
->ContextFlags
;
401 wine_server_add_data( req
, context
, sizeof(*context
) );
402 ret
= !wine_server_call_err( req
);
409 /***********************************************************************
410 * GetThreadContext [KERNEL32.@] Retrieves context of thread.
416 BOOL WINAPI
GetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
417 CONTEXT
*context
) /* [out] Address of context structure */
420 SERVER_START_REQ( get_thread_context
)
422 req
->handle
= handle
;
423 req
->flags
= context
->ContextFlags
;
424 wine_server_add_data( req
, context
, sizeof(*context
) );
425 wine_server_set_reply( req
, context
, sizeof(*context
) );
426 ret
= !wine_server_call_err( req
);
433 /**********************************************************************
434 * GetThreadPriority [KERNEL32.@] Returns priority for thread.
437 * Success: Thread's priority level.
438 * Failure: THREAD_PRIORITY_ERROR_RETURN
440 INT WINAPI
GetThreadPriority(
441 HANDLE hthread
) /* [in] Handle to thread */
443 INT ret
= THREAD_PRIORITY_ERROR_RETURN
;
444 SERVER_START_REQ( get_thread_info
)
446 req
->handle
= hthread
;
448 if (!wine_server_call_err( req
)) ret
= reply
->priority
;
455 /**********************************************************************
456 * SetThreadPriority [KERNEL32.@] Sets priority for thread.
462 BOOL WINAPI
SetThreadPriority(
463 HANDLE hthread
, /* [in] Handle to thread */
464 INT priority
) /* [in] Thread priority level */
467 SERVER_START_REQ( set_thread_info
)
469 req
->handle
= hthread
;
470 req
->priority
= priority
;
471 req
->mask
= SET_THREAD_INFO_PRIORITY
;
472 ret
= !wine_server_call_err( req
);
479 /**********************************************************************
480 * GetThreadPriorityBoost [KERNEL32.@] Returns priority boost for thread.
482 * Always reports that priority boost is disabled.
488 BOOL WINAPI
GetThreadPriorityBoost(
489 HANDLE hthread
, /* [in] Handle to thread */
490 PBOOL pstate
) /* [out] pointer to var that receives the boost state */
492 if (pstate
) *pstate
= FALSE
;
497 /**********************************************************************
498 * SetThreadPriorityBoost [KERNEL32.@] Sets priority boost for thread.
500 * Priority boost is not implemented. Thsi function always returns
501 * FALSE and sets last error to ERROR_CALL_NOT_IMPLEMENTED
504 * Always returns FALSE to indicate a failure
506 BOOL WINAPI
SetThreadPriorityBoost(
507 HANDLE hthread
, /* [in] Handle to thread */
508 BOOL disable
) /* [in] TRUE to disable priority boost */
510 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
515 /**********************************************************************
516 * SetThreadAffinityMask (KERNEL32.@)
518 DWORD WINAPI
SetThreadAffinityMask( HANDLE hThread
, DWORD dwThreadAffinityMask
)
521 SERVER_START_REQ( set_thread_info
)
523 req
->handle
= hThread
;
524 req
->affinity
= dwThreadAffinityMask
;
525 req
->mask
= SET_THREAD_INFO_AFFINITY
;
526 ret
= !wine_server_call_err( req
);
527 /* FIXME: should return previous value */
534 /**********************************************************************
535 * TerminateThread [KERNEL32.@] Terminates a thread
541 BOOL WINAPI
TerminateThread( HANDLE handle
, /* [in] Handle to thread */
542 DWORD exit_code
) /* [in] Exit code for thread */
544 NTSTATUS status
= NtTerminateThread( handle
, exit_code
);
545 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
550 /**********************************************************************
551 * GetExitCodeThread (KERNEL32.@)
553 * Gets termination status of thread.
559 BOOL WINAPI
GetExitCodeThread(
560 HANDLE hthread
, /* [in] Handle to thread */
561 LPDWORD exitcode
) /* [out] Address to receive termination status */
564 SERVER_START_REQ( get_thread_info
)
566 req
->handle
= hthread
;
568 ret
= !wine_server_call_err( req
);
569 if (ret
&& exitcode
) *exitcode
= reply
->exit_code
;
576 /**********************************************************************
577 * ResumeThread [KERNEL32.@] Resumes a thread.
579 * Decrements a thread's suspend count. When count is zero, the
580 * execution of the thread is resumed.
583 * Success: Previous suspend count
584 * Failure: 0xFFFFFFFF
587 DWORD WINAPI
ResumeThread(
588 HANDLE hthread
) /* [in] Identifies thread to restart */
590 DWORD ret
= 0xffffffff;
591 SERVER_START_REQ( resume_thread
)
593 req
->handle
= hthread
;
594 if (!wine_server_call_err( req
)) ret
= reply
->count
;
601 /**********************************************************************
602 * SuspendThread [KERNEL32.@] Suspends a thread.
605 * Success: Previous suspend count
606 * Failure: 0xFFFFFFFF
608 DWORD WINAPI
SuspendThread(
609 HANDLE hthread
) /* [in] Handle to the thread */
611 DWORD ret
= 0xffffffff;
612 SERVER_START_REQ( suspend_thread
)
614 req
->handle
= hthread
;
615 if (!wine_server_call_err( req
)) ret
= reply
->count
;
622 /***********************************************************************
623 * QueueUserAPC (KERNEL32.@)
625 DWORD WINAPI
QueueUserAPC( PAPCFUNC func
, HANDLE hthread
, ULONG_PTR data
)
628 SERVER_START_REQ( queue_apc
)
630 req
->handle
= hthread
;
633 req
->param
= (void *)data
;
634 ret
= !wine_server_call_err( req
);
641 /**********************************************************************
642 * GetThreadTimes [KERNEL32.@] Obtains timing information.
645 * What are the fields where these values are stored?
651 BOOL WINAPI
GetThreadTimes(
652 HANDLE thread
, /* [in] Specifies the thread of interest */
653 LPFILETIME creationtime
, /* [out] When the thread was created */
654 LPFILETIME exittime
, /* [out] When the thread was destroyed */
655 LPFILETIME kerneltime
, /* [out] Time thread spent in kernel mode */
656 LPFILETIME usertime
) /* [out] Time thread spent in user mode */
658 FIXME("(0x%08x): stub\n",thread
);
659 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
664 /**********************************************************************
665 * VWin32_BoostThreadGroup [KERNEL.535]
667 VOID WINAPI
VWin32_BoostThreadGroup( DWORD threadId
, INT boost
)
669 FIXME("(0x%08lx,%d): stub\n", threadId
, boost
);
672 /**********************************************************************
673 * VWin32_BoostThreadStatic [KERNEL.536]
675 VOID WINAPI
VWin32_BoostThreadStatic( DWORD threadId
, INT boost
)
677 FIXME("(0x%08lx,%d): stub\n", threadId
, boost
);
681 /***********************************************************************
682 * GetThreadLocale (KERNEL32.@)
684 LCID WINAPI
GetThreadLocale(void)
686 LCID ret
= NtCurrentTeb()->CurrentLocale
;
687 if (!ret
) NtCurrentTeb()->CurrentLocale
= ret
= GetUserDefaultLCID();
692 /**********************************************************************
693 * SetThreadLocale [KERNEL32.@] Sets the calling threads current locale.
700 * check if lcid is a valid cp
702 BOOL WINAPI
SetThreadLocale(
703 LCID lcid
) /* [in] Locale identifier */
707 case LOCALE_SYSTEM_DEFAULT
:
708 lcid
= GetSystemDefaultLCID();
710 case LOCALE_USER_DEFAULT
:
712 lcid
= GetUserDefaultLCID();
715 NtCurrentTeb()->CurrentLocale
= lcid
;
720 /***********************************************************************
721 * GetCurrentThread [KERNEL32.@] Gets pseudohandle for current thread
724 * Pseudohandle for the current thread
726 #undef GetCurrentThread
727 HANDLE WINAPI
GetCurrentThread(void)
733 /***********************************************************************
734 * ProcessIdToSessionId (KERNEL32.@)
735 * This function is available on Terminal Server 4SP4 and Windows 2000
737 BOOL WINAPI
ProcessIdToSessionId( DWORD procid
, DWORD
*sessionid_ptr
)
739 /* According to MSDN, if the calling process is not in a terminal
740 * services environment, then the sessionid returned is zero.
746 /***********************************************************************
747 * SetThreadExecutionState (KERNEL32.@)
749 * Informs the system that activity is taking place for
750 * power management purposes.
752 EXECUTION_STATE WINAPI
SetThreadExecutionState(EXECUTION_STATE flags
)
754 static EXECUTION_STATE current
=
755 ES_SYSTEM_REQUIRED
|ES_DISPLAY_REQUIRED
|ES_USER_PRESENT
;
756 EXECUTION_STATE old
= current
;
758 if (!(current
& ES_CONTINUOUS
) || (flags
& ES_CONTINUOUS
))
760 FIXME("(0x%lx): stub, harmless (power management).\n", flags
);
767 /***********************************************************************
768 * SetLastError (KERNEL.147)
769 * SetLastError (KERNEL32.@)
771 /* void WINAPI SetLastError( DWORD error ); */
772 __ASM_GLOBAL_FUNC( SetLastError
,
773 "movl 4(%esp),%eax\n\t"
778 /***********************************************************************
779 * GetLastError (KERNEL.148)
780 * GetLastError (KERNEL32.@)
782 /* DWORD WINAPI GetLastError(void); */
783 __ASM_GLOBAL_FUNC( GetLastError
, ".byte 0x64\n\tmovl 0x60,%eax\n\tret" );
785 /***********************************************************************
786 * GetCurrentProcessId (KERNEL.471)
787 * GetCurrentProcessId (KERNEL32.@)
789 /* DWORD WINAPI GetCurrentProcessId(void) */
790 __ASM_GLOBAL_FUNC( GetCurrentProcessId
, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" );
792 /***********************************************************************
793 * GetCurrentThreadId (KERNEL.462)
794 * GetCurrentThreadId (KERNEL32.@)
796 /* DWORD WINAPI GetCurrentThreadId(void) */
797 __ASM_GLOBAL_FUNC( GetCurrentThreadId
, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" );
801 /**********************************************************************
802 * SetLastError (KERNEL.147)
803 * SetLastError (KERNEL32.@)
805 * Sets the last-error code.
807 void WINAPI
SetLastError( DWORD error
) /* [in] Per-thread error code */
809 NtCurrentTeb()->last_error
= error
;
812 /**********************************************************************
813 * GetLastError (KERNEL.148)
814 * GetLastError (KERNEL32.@)
816 * Returns last-error code.
818 DWORD WINAPI
GetLastError(void)
820 return NtCurrentTeb()->last_error
;
823 /***********************************************************************
824 * GetCurrentProcessId (KERNEL.471)
825 * GetCurrentProcessId (KERNEL32.@)
827 * Returns process identifier.
829 DWORD WINAPI
GetCurrentProcessId(void)
831 return (DWORD
)NtCurrentTeb()->pid
;
834 /***********************************************************************
835 * GetCurrentThreadId (KERNEL.462)
836 * GetCurrentThreadId (KERNEL32.@)
838 * Returns thread identifier.
840 DWORD WINAPI
GetCurrentThreadId(void)
842 return (DWORD
)NtCurrentTeb()->tid
;
845 #endif /* __i386__ */