4 * Copyright 1996 Alexandre Julliard
11 #include <sys/types.h>
12 #ifdef HAVE_SYS_MMAN_H
16 #include "wine/winbase16.h"
17 #include "wine/port.h"
23 #include "selectors.h"
27 #include "stackframe.h"
28 #include "builtin16.h"
29 #include "debugtools.h"
32 DEFAULT_DEBUG_CHANNEL(thread);
34 /* TEB of the initial thread */
35 static TEB initial_teb;
37 extern struct _PDB current_process;
39 /***********************************************************************
42 BOOL THREAD_IsWin16( TEB *teb )
44 return !teb || !(teb->tibflags & TEBF_WIN32);
47 /***********************************************************************
50 * Convert a thread id to a TEB, making sure it is valid.
52 TEB *THREAD_IdToTEB( DWORD id )
56 if (!id || id == GetCurrentThreadId()) return NtCurrentTeb();
60 struct get_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
62 req->tid_in = (void *)id;
63 if (!server_call_noerr( REQ_GET_THREAD_INFO )) ret = req->teb;
69 /* Allow task handles to be used; convert to main thread */
72 TDB *pTask = (TDB *)GlobalLock16( id );
73 if (pTask) return pTask->teb;
75 SetLastError( ERROR_INVALID_PARAMETER );
81 /***********************************************************************
84 * Initialization of a newly created TEB.
86 static BOOL THREAD_InitTEB( TEB *teb )
88 teb->except = (void *)~0UL;
90 teb->tibflags = TEBF_WIN32;
91 teb->tls_ptr = teb->tls_array;
92 teb->exit_code = STILL_ACTIVE;
96 teb->stack_top = (void *)~0UL;
97 teb->StaticUnicodeString.MaximumLength = sizeof(teb->StaticUnicodeBuffer);
98 teb->StaticUnicodeString.Buffer = (PWSTR)teb->StaticUnicodeBuffer;
99 teb->teb_sel = SELECTOR_AllocBlock( teb, 0x1000, WINE_LDT_FLAGS_DATA|WINE_LDT_FLAGS_32BIT );
100 return (teb->teb_sel != 0);
104 /***********************************************************************
107 * Free data structures associated with a thread.
108 * Must be called from the context of another thread.
110 static void CALLBACK THREAD_FreeTEB( TEB *teb )
112 TRACE("(%p) called\n", teb );
113 if (teb->cleanup) SERVICE_Delete( teb->cleanup );
115 /* Free the associated memory */
117 if (teb->socket != -1) close( teb->socket );
118 close( teb->request_fd );
119 close( teb->reply_fd );
120 if (teb->stack_sel) FreeSelector16( teb->stack_sel );
121 FreeSelector16( teb->teb_sel );
122 if (teb->buffer) munmap( (void *)teb->buffer,
123 (char *)(teb->buffer_info+1) - (char *)teb->buffer );
124 if (teb->debug_info) HeapFree( GetProcessHeap(), 0, teb->debug_info );
125 VirtualFree( teb->stack_base, 0, MEM_RELEASE );
129 /***********************************************************************
132 * Allocate the stack of a thread.
134 TEB *THREAD_InitStack( TEB *teb, DWORD stack_size, BOOL alloc_stack16 )
136 DWORD old_prot, total_size;
137 DWORD page_size = getpagesize();
140 /* Allocate the stack */
142 if (stack_size >= 16*1024*1024)
143 WARN("Thread stack size is %ld MB.\n",stack_size/1024/1024);
145 /* if size is smaller than default, get stack size from parent */
146 if (stack_size < 1024 * 1024)
149 stack_size = 1024 * 1024; /* no parent */
151 stack_size = ((char *)NtCurrentTeb()->stack_top - (char *)NtCurrentTeb()->stack_base
152 - SIGNAL_STACK_SIZE - 3 * page_size);
155 /* FIXME: some Wine functions use a lot of stack, so we add 64Kb here */
156 stack_size += 64 * 1024;
158 /* Memory layout in allocated block:
161 * 1 page NOACCESS guard page
162 * SIGNAL_STACK_SIZE signal stack
163 * 1 page NOACCESS guard page
164 * 1 page PAGE_GUARD guard page
165 * stack_size normal stack
166 * 64Kb 16-bit stack (optional)
167 * 1 page TEB (except for initial thread)
170 stack_size = (stack_size + (page_size - 1)) & ~(page_size - 1);
171 total_size = stack_size + SIGNAL_STACK_SIZE + 3 * page_size;
172 if (alloc_stack16) total_size += 0x10000;
173 if (!teb) total_size += page_size;
175 if (!(base = VirtualAlloc( NULL, total_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE )))
180 teb = (TEB *)((char *)base + total_size - page_size);
181 if (!THREAD_InitTEB( teb ))
183 VirtualFree( base, 0, MEM_RELEASE );
188 teb->stack_low = base;
189 teb->stack_base = base;
190 teb->signal_stack = (char *)base + page_size;
191 teb->stack_top = (char *)base + 3 * page_size + SIGNAL_STACK_SIZE + stack_size;
193 /* Setup guard pages */
195 VirtualProtect( base, 1, PAGE_NOACCESS, &old_prot );
196 VirtualProtect( (char *)teb->signal_stack + SIGNAL_STACK_SIZE, 1, PAGE_NOACCESS, &old_prot );
197 VirtualProtect( (char *)teb->signal_stack + SIGNAL_STACK_SIZE + page_size, 1,
198 PAGE_EXECUTE_READWRITE | PAGE_GUARD, &old_prot );
200 /* Allocate the 16-bit stack selector */
204 teb->stack_sel = SELECTOR_AllocBlock( teb->stack_top, 0x10000, WINE_LDT_FLAGS_DATA );
205 if (!teb->stack_sel) goto error;
206 teb->cur_stack = MAKESEGPTR( teb->stack_sel, 0x10000 - sizeof(STACK16FRAME) );
211 THREAD_FreeTEB( teb );
216 /***********************************************************************
217 * thread_errno_location
219 * Get the per-thread errno location.
221 static int *thread_errno_location(void)
223 return &NtCurrentTeb()->thread_errno;
226 /***********************************************************************
227 * thread_h_errno_location
229 * Get the per-thread h_errno location.
231 static int *thread_h_errno_location(void)
233 return &NtCurrentTeb()->thread_h_errno;
236 /***********************************************************************
239 * Setup the initial thread.
241 * NOTES: The first allocated TEB on NT is at 0x7ffde000.
243 void THREAD_Init(void)
245 if (!initial_teb.self) /* do it only once */
247 THREAD_InitTEB( &initial_teb );
248 assert( initial_teb.teb_sel );
249 initial_teb.process = ¤t_process;
250 SYSDEPS_SetCurThread( &initial_teb );
251 wine_errno_location = thread_errno_location;
252 wine_h_errno_location = thread_h_errno_location;
256 DECL_GLOBAL_CONSTRUCTOR(thread_init) { THREAD_Init(); }
258 /***********************************************************************
262 TEB *THREAD_Create( int fd, DWORD stack_size, BOOL alloc_stack16 )
266 if ((teb = THREAD_InitStack( NULL, stack_size, alloc_stack16 )))
268 teb->tibflags = TEBF_WIN32;
269 teb->process = NtCurrentTeb()->process;
271 fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
272 TRACE("(%p) succeeded\n", teb);
278 /***********************************************************************
281 * Start execution of a newly created thread. Does not return.
283 static void THREAD_Start(void)
285 HANDLE cleanup_object;
286 LPTHREAD_START_ROUTINE func = (LPTHREAD_START_ROUTINE)NtCurrentTeb()->entry_point;
288 /* install cleanup handler */
289 if (DuplicateHandle( GetCurrentProcess(), GetCurrentThread(),
290 GetCurrentProcess(), &cleanup_object,
291 0, FALSE, DUPLICATE_SAME_ACCESS ))
292 NtCurrentTeb()->cleanup = SERVICE_AddObject( cleanup_object, (PAPCFUNC)THREAD_FreeTEB,
293 (ULONG_PTR)NtCurrentTeb() );
295 PROCESS_CallUserSignalProc( USIG_THREAD_INIT, 0 );
297 MODULE_DllThreadAttach( NULL );
298 ExitThread( func( NtCurrentTeb()->entry_arg ) );
302 /***********************************************************************
303 * CreateThread (KERNEL32.63)
305 HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
306 LPTHREAD_START_ROUTINE start, LPVOID param,
307 DWORD flags, LPDWORD id )
316 struct new_thread_request *req = server_alloc_req( sizeof(*req), 0 );
318 req->suspend = ((flags & CREATE_SUSPENDED) != 0);
319 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
320 if (!server_call( REQ_NEW_THREAD ))
322 handle = req->handle;
324 socket = wine_server_recv_fd( handle, 0 );
328 if (!handle) return 0;
330 if (!(teb = THREAD_Create( socket, stack, TRUE )))
335 teb->entry_point = start;
336 teb->entry_arg = param;
337 teb->startup = THREAD_Start;
338 teb->htask16 = GetCurrentTask();
339 if (id) *id = (DWORD)tid;
340 if (SYSDEPS_SpawnThread( teb ) == -1)
342 CloseHandle( handle );
343 THREAD_FreeTEB( teb );
349 /***********************************************************************
350 * CreateThread16 (KERNEL.441)
352 static DWORD CALLBACK THREAD_StartThread16( LPVOID threadArgs )
354 FARPROC16 start = ((FARPROC16 *)threadArgs)[0];
355 DWORD param = ((DWORD *)threadArgs)[1];
356 HeapFree( GetProcessHeap(), 0, threadArgs );
358 ((LPDWORD)CURRENT_STACK16)[-1] = param;
359 return wine_call_to_16_long( start, sizeof(DWORD) );
361 HANDLE WINAPI CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
362 FARPROC16 start, SEGPTR param,
363 DWORD flags, LPDWORD id )
365 DWORD *threadArgs = HeapAlloc( GetProcessHeap(), 0, 2*sizeof(DWORD) );
366 if (!threadArgs) return INVALID_HANDLE_VALUE;
367 threadArgs[0] = (DWORD)start;
368 threadArgs[1] = (DWORD)param;
370 return CreateThread( sa, stack, THREAD_StartThread16, threadArgs, flags, id );
374 /***********************************************************************
375 * ExitThread [KERNEL32.215] Ends a thread
380 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
385 struct terminate_thread_request *req = server_alloc_req( sizeof(*req), 0 );
387 /* send the exit code to the server */
388 req->handle = GetCurrentThread();
389 req->exit_code = code;
390 server_call( REQ_TERMINATE_THREAD );
397 MODULE_DllProcessDetach( TRUE, (LPVOID)1 );
402 MODULE_DllThreadDetach( NULL );
403 if (!(NtCurrentTeb()->tibflags & TEBF_WIN32)) TASK_ExitTask();
404 SYSDEPS_ExitThread( code );
409 /***********************************************************************
410 * SetThreadContext [KERNEL32.670] Sets context of thread.
416 BOOL WINAPI SetThreadContext( HANDLE handle, /* [in] Handle to thread with context */
417 const CONTEXT *context ) /* [in] Address of context structure */
422 struct set_thread_context_request *req = server_alloc_req( sizeof(*req),
424 req->handle = handle;
425 req->flags = context->ContextFlags;
426 memcpy( server_data_ptr(req), context, sizeof(*context) );
427 ret = !server_call( REQ_SET_THREAD_CONTEXT );
434 /***********************************************************************
435 * GetThreadContext [KERNEL32.294] Retrieves context of thread.
441 BOOL WINAPI GetThreadContext( HANDLE handle, /* [in] Handle to thread with context */
442 CONTEXT *context ) /* [out] Address of context structure */
447 struct get_thread_context_request *req = server_alloc_req( sizeof(*req),
449 req->handle = handle;
450 req->flags = context->ContextFlags;
451 memcpy( server_data_ptr(req), context, sizeof(*context) );
452 if ((ret = !server_call( REQ_GET_THREAD_CONTEXT )))
453 memcpy( context, server_data_ptr(req), sizeof(*context) );
460 /**********************************************************************
461 * GetThreadPriority [KERNEL32.296] Returns priority for thread.
464 * Success: Thread's priority level.
465 * Failure: THREAD_PRIORITY_ERROR_RETURN
467 INT WINAPI GetThreadPriority(
468 HANDLE hthread) /* [in] Handle to thread */
470 INT ret = THREAD_PRIORITY_ERROR_RETURN;
473 struct get_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
474 req->handle = hthread;
476 if (!server_call( REQ_GET_THREAD_INFO )) ret = req->priority;
483 /**********************************************************************
484 * SetThreadPriority [KERNEL32.514] Sets priority for thread.
490 BOOL WINAPI SetThreadPriority(
491 HANDLE hthread, /* [in] Handle to thread */
492 INT priority) /* [in] Thread priority level */
497 struct set_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
498 req->handle = hthread;
499 req->priority = priority;
500 req->mask = SET_THREAD_INFO_PRIORITY;
501 ret = !server_call( REQ_SET_THREAD_INFO );
508 /**********************************************************************
509 * GetThreadPriorityBoost [KERNEL32.877] Returns priority boost for thread.
511 * Always reports that priority boost is disabled.
517 BOOL WINAPI GetThreadPriorityBoost(
518 HANDLE hthread, /* [in] Handle to thread */
519 PBOOL pstate) /* [out] pointer to var that receives the boost state */
521 if (pstate) *pstate = FALSE;
526 /**********************************************************************
527 * SetThreadPriorityBoost [KERNEL32.893] Sets priority boost for thread.
529 * Priority boost is not implemented. Thsi function always returns
530 * FALSE and sets last error to ERROR_CALL_NOT_IMPLEMENTED
533 * Always returns FALSE to indicate a failure
535 BOOL WINAPI SetThreadPriorityBoost(
536 HANDLE hthread, /* [in] Handle to thread */
537 BOOL disable) /* [in] TRUE to disable priority boost */
539 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
544 /**********************************************************************
545 * SetThreadAffinityMask (KERNEL32.669)
547 DWORD WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD dwThreadAffinityMask )
552 struct set_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
553 req->handle = hThread;
554 req->affinity = dwThreadAffinityMask;
555 req->mask = SET_THREAD_INFO_AFFINITY;
556 ret = !server_call( REQ_SET_THREAD_INFO );
557 /* FIXME: should return previous value */
564 /**********************************************************************
565 * TerminateThread [KERNEL32.685] Terminates a thread
571 BOOL WINAPI TerminateThread( HANDLE handle, /* [in] Handle to thread */
572 DWORD exit_code) /* [in] Exit code for thread */
574 NTSTATUS status = NtTerminateThread( handle, exit_code );
575 if (status) SetLastError( RtlNtStatusToDosError(status) );
580 /**********************************************************************
581 * GetExitCodeThread [KERNEL32.???] Gets termination status of thread.
587 BOOL WINAPI GetExitCodeThread(
588 HANDLE hthread, /* [in] Handle to thread */
589 LPDWORD exitcode) /* [out] Address to receive termination status */
594 struct get_thread_info_request *req = server_alloc_req( sizeof(*req), 0 );
595 req->handle = hthread;
597 ret = !server_call( REQ_GET_THREAD_INFO );
598 if (ret && exitcode) *exitcode = req->exit_code;
605 /**********************************************************************
606 * ResumeThread [KERNEL32.587] Resumes a thread.
608 * Decrements a thread's suspend count. When count is zero, the
609 * execution of the thread is resumed.
612 * Success: Previous suspend count
613 * Failure: 0xFFFFFFFF
616 DWORD WINAPI ResumeThread(
617 HANDLE hthread) /* [in] Identifies thread to restart */
619 DWORD ret = 0xffffffff;
622 struct resume_thread_request *req = server_alloc_req( sizeof(*req), 0 );
623 req->handle = hthread;
624 if (!server_call( REQ_RESUME_THREAD )) ret = req->count;
631 /**********************************************************************
632 * SuspendThread [KERNEL32.681] Suspends a thread.
635 * Success: Previous suspend count
636 * Failure: 0xFFFFFFFF
638 DWORD WINAPI SuspendThread(
639 HANDLE hthread) /* [in] Handle to the thread */
641 DWORD ret = 0xffffffff;
644 struct suspend_thread_request *req = server_alloc_req( sizeof(*req), 0 );
645 req->handle = hthread;
646 if (!server_call( REQ_SUSPEND_THREAD )) ret = req->count;
653 /***********************************************************************
654 * QueueUserAPC (KERNEL32.566)
656 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
661 struct queue_apc_request *req = server_alloc_req( sizeof(*req), 0 );
662 req->handle = hthread;
665 req->param = (void *)data;
666 ret = !server_call( REQ_QUEUE_APC );
673 /**********************************************************************
674 * GetThreadTimes [KERNEL32.???] Obtains timing information.
677 * What are the fields where these values are stored?
683 BOOL WINAPI GetThreadTimes(
684 HANDLE thread, /* [in] Specifies the thread of interest */
685 LPFILETIME creationtime, /* [out] When the thread was created */
686 LPFILETIME exittime, /* [out] When the thread was destroyed */
687 LPFILETIME kerneltime, /* [out] Time thread spent in kernel mode */
688 LPFILETIME usertime) /* [out] Time thread spent in user mode */
690 FIXME("(0x%08x): stub\n",thread);
691 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
696 /**********************************************************************
697 * VWin32_BoostThreadGroup [KERNEL.535]
699 VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
701 FIXME("(0x%08lx,%d): stub\n", threadId, boost);
704 /**********************************************************************
705 * VWin32_BoostThreadStatic [KERNEL.536]
707 VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT boost )
709 FIXME("(0x%08lx,%d): stub\n", threadId, boost);
713 /***********************************************************************
714 * GetThreadLocale (KERNEL32.295)
716 LCID WINAPI GetThreadLocale(void)
718 LCID ret = NtCurrentTeb()->CurrentLocale;
719 if (!ret) NtCurrentTeb()->CurrentLocale = ret = GetUserDefaultLCID();
724 /**********************************************************************
725 * SetThreadLocale [KERNEL32.671] Sets the calling threads current locale.
732 * check if lcid is a valid cp
734 BOOL WINAPI SetThreadLocale(
735 LCID lcid) /* [in] Locale identifier */
739 case LOCALE_SYSTEM_DEFAULT:
740 lcid = GetSystemDefaultLCID();
742 case LOCALE_USER_DEFAULT:
744 lcid = GetUserDefaultLCID();
747 NtCurrentTeb()->CurrentLocale = lcid;
752 /***********************************************************************
753 * GetCurrentThread [KERNEL32.200] Gets pseudohandle for current thread
756 * Pseudohandle for the current thread
758 #undef GetCurrentThread
759 HANDLE WINAPI GetCurrentThread(void)
765 /***********************************************************************
766 * ProcessIdToSessionId (KERNEL32)
767 * This function is available on Terminal Server 4SP4 and Windows 2000
769 BOOL WINAPI ProcessIdToSessionId( DWORD procid, DWORD *sessionid_ptr )
771 /* According to MSDN, if the calling process is not in a terminal
772 * services environment, then the sessionid returned is zero.
781 /* void WINAPI SetLastError( DWORD error ); */
782 __ASM_GLOBAL_FUNC( SetLastError,
783 "movl 4(%esp),%eax\n\t"
788 /* DWORD WINAPI GetLastError(void); */
789 __ASM_GLOBAL_FUNC( GetLastError, ".byte 0x64\n\tmovl 0x60,%eax\n\tret" );
791 /* DWORD WINAPI GetCurrentProcessId(void) */
792 __ASM_GLOBAL_FUNC( GetCurrentProcessId, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" );
794 /* DWORD WINAPI GetCurrentThreadId(void) */
795 __ASM_GLOBAL_FUNC( GetCurrentThreadId, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" );
799 /**********************************************************************
800 * SetLastError [KERNEL.147] [KERNEL32.497] Sets the last-error code.
802 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
804 NtCurrentTeb()->last_error = error;
807 /**********************************************************************
808 * GetLastError [KERNEL.148] [KERNEL32.227] Returns last-error code.
810 DWORD WINAPI GetLastError(void)
812 return NtCurrentTeb()->last_error;
815 /***********************************************************************
816 * GetCurrentProcessId [KERNEL32.199] Returns process identifier.
818 DWORD WINAPI GetCurrentProcessId(void)
820 return (DWORD)NtCurrentTeb()->pid;
823 /***********************************************************************
824 * GetCurrentThreadId [KERNEL32.201] Returns thread identifier.
826 DWORD WINAPI GetCurrentThreadId(void)
828 return (DWORD)NtCurrentTeb()->tid;
831 #endif /* __i386__ */