?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vbscript: Compile tests with -D__WINESRC__.
[wine.git] / dlls / ntdll / thread.c
blob9c34c0c260399dba4e7e840be0b742e6dbd1c7cc
1 /*
2 * NT threads support
3 *
4 * Copyright 1996, 2003 Alexandre Julliard
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <stdarg.h>
26 #include <sys/types.h>
27 #ifdef HAVE_SYS_MMAN_H
28 #include <sys/mman.h>
29 #endif
30 #ifdef HAVE_SYS_TIMES_H
31 #include <sys/times.h>
32 #endif
33 #ifdef HAVE_SYS_SYSCALL_H
34 #include <sys/syscall.h>
35 #endif
36
37 #define NONAMELESSUNION
38 #include "ntstatus.h"
39 #define WIN32_NO_STATUS
40 #include "winternl.h"
41 #include "wine/library.h"
42 #include "wine/server.h"
43 #include "wine/debug.h"
44 #include "ntdll_misc.h"
45 #include "ddk/wdm.h"
46 #include "wine/exception.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(thread);
49 WINE_DECLARE_DEBUG_CHANNEL(relay);
50
51 struct _KUSER_SHARED_DATA *user_shared_data = NULL;
52
53 PUNHANDLED_EXCEPTION_FILTER unhandled_exception_filter = NULL;
54
55 /* info passed to a starting thread */
56 struct startup_info
57 {
58 TEB *teb;
59 PRTL_THREAD_START_ROUTINE entry_point;
60 void *entry_arg;
61 };
62
63 static PEB *peb;
64 static PEB_LDR_DATA ldr;
65 static RTL_USER_PROCESS_PARAMETERS params; /* default parameters if no parent */
66 static WCHAR current_dir[MAX_NT_PATH_LENGTH];
67 static RTL_BITMAP tls_bitmap;
68 static RTL_BITMAP tls_expansion_bitmap;
69 static RTL_BITMAP fls_bitmap;
70 static LIST_ENTRY tls_links;
71 static int nb_threads = 1;
72
73 /***********************************************************************
74 * get_unicode_string
75 *
76 * Copy a unicode string from the startup info.
77 */
78 static inline void get_unicode_string( UNICODE_STRING *str, WCHAR **src, WCHAR **dst, UINT len )
79 {
80 str->Buffer = *dst;
81 str->Length = len;
82 str->MaximumLength = len + sizeof(WCHAR);
83 memcpy( str->Buffer, *src, len );
84 str->Buffer[len / sizeof(WCHAR)] = 0;
85 *src += len / sizeof(WCHAR);
86 *dst += len / sizeof(WCHAR) + 1;
87 }
88
89 /***********************************************************************
90 * init_user_process_params
91 *
92 * Fill the RTL_USER_PROCESS_PARAMETERS structure from the server.
93 */
94 static NTSTATUS init_user_process_params( SIZE_T data_size, HANDLE *exe_file )
95 {
96 void *ptr;
97 WCHAR *src, *dst;
98 SIZE_T info_size, env_size, size, alloc_size;
99 NTSTATUS status;
100 startup_info_t *info;
101 RTL_USER_PROCESS_PARAMETERS *params = NULL;
102
103 if (!(info = RtlAllocateHeap( GetProcessHeap(), 0, data_size )))
104 return STATUS_NO_MEMORY;
105
106 SERVER_START_REQ( get_startup_info )
107 {
108 wine_server_set_reply( req, info, data_size );
109 if (!(status = wine_server_call( req )))
110 {
111 data_size = wine_server_reply_size( reply );
112 info_size = reply->info_size;
113 env_size = data_size - info_size;
114 *exe_file = wine_server_ptr_handle( reply->exe_file );
115 }
116 }
117 SERVER_END_REQ;
118 if (status != STATUS_SUCCESS) goto done;
119
120 size = sizeof(*params);
121 size += MAX_NT_PATH_LENGTH * sizeof(WCHAR);
122 size += info->dllpath_len + sizeof(WCHAR);
123 size += info->imagepath_len + sizeof(WCHAR);
124 size += info->cmdline_len + sizeof(WCHAR);
125 size += info->title_len + sizeof(WCHAR);
126 size += info->desktop_len + sizeof(WCHAR);
127 size += info->shellinfo_len + sizeof(WCHAR);
128 size += info->runtime_len + sizeof(WCHAR);
129
130 alloc_size = size;
131 status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)&params, 0, &alloc_size,
132 MEM_COMMIT, PAGE_READWRITE );
133 if (status != STATUS_SUCCESS) goto done;
134
135 NtCurrentTeb()->Peb->ProcessParameters = params;
136 params->AllocationSize = alloc_size;
137 params->Size = size;
138 params->Flags = PROCESS_PARAMS_FLAG_NORMALIZED;
139 params->DebugFlags = info->debug_flags;
140 params->ConsoleHandle = wine_server_ptr_handle( info->console );
141 params->ConsoleFlags = info->console_flags;
142 params->hStdInput = wine_server_ptr_handle( info->hstdin );
143 params->hStdOutput = wine_server_ptr_handle( info->hstdout );
144 params->hStdError = wine_server_ptr_handle( info->hstderr );
145 params->dwX = info->x;
146 params->dwY = info->y;
147 params->dwXSize = info->xsize;
148 params->dwYSize = info->ysize;
149 params->dwXCountChars = info->xchars;
150 params->dwYCountChars = info->ychars;
151 params->dwFillAttribute = info->attribute;
152 params->dwFlags = info->flags;
153 params->wShowWindow = info->show;
154
155 src = (WCHAR *)(info + 1);
156 dst = (WCHAR *)(params + 1);
157
158 /* current directory needs more space */
159 get_unicode_string( &params->CurrentDirectory.DosPath, &src, &dst, info->curdir_len );
160 params->CurrentDirectory.DosPath.MaximumLength = MAX_NT_PATH_LENGTH * sizeof(WCHAR);
161 dst = (WCHAR *)(params + 1) + MAX_NT_PATH_LENGTH;
162
163 get_unicode_string( &params->DllPath, &src, &dst, info->dllpath_len );
164 get_unicode_string( &params->ImagePathName, &src, &dst, info->imagepath_len );
165 get_unicode_string( &params->CommandLine, &src, &dst, info->cmdline_len );
166 get_unicode_string( &params->WindowTitle, &src, &dst, info->title_len );
167 get_unicode_string( &params->Desktop, &src, &dst, info->desktop_len );
168 get_unicode_string( &params->ShellInfo, &src, &dst, info->shellinfo_len );
169
170 /* runtime info isn't a real string */
171 params->RuntimeInfo.Buffer = dst;
172 params->RuntimeInfo.Length = params->RuntimeInfo.MaximumLength = info->runtime_len;
173 memcpy( dst, src, info->runtime_len );
174
175 /* environment needs to be a separate memory block */
176 ptr = NULL;
177 alloc_size = max( 1, env_size );
178 status = NtAllocateVirtualMemory( NtCurrentProcess(), &ptr, 0, &alloc_size,
179 MEM_COMMIT, PAGE_READWRITE );
180 if (status != STATUS_SUCCESS) goto done;
181 memcpy( ptr, (char *)info + info_size, env_size );
182 params->Environment = ptr;
183
184 done:
185 RtlFreeHeap( GetProcessHeap(), 0, info );
186 return status;
187 }
188
189 /***********************************************************************
190 * thread_init
191 *
192 * Setup the initial thread.
193 *
194 * NOTES: The first allocated TEB on NT is at 0x7ffde000.
195 */
196 HANDLE thread_init(void)
197 {
198 TEB *teb;
199 void *addr;
200 SIZE_T size, info_size;
201 HANDLE exe_file = 0;
202 LARGE_INTEGER now;
203 NTSTATUS status;
204 struct ntdll_thread_data *thread_data;
205 static struct debug_info debug_info; /* debug info for initial thread */
206
207 virtual_init();
208
209 /* reserve space for shared user data */
210
211 addr = (void *)0x7ffe0000;
212 size = 0x10000;
213 status = NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 0, &size,
214 MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE );
215 if (status)
216 {
217 MESSAGE( "wine: failed to map the shared user data: %08x\n", status );
218 exit(1);
219 }
220 user_shared_data = addr;
221
222 /* allocate and initialize the PEB */
223
224 addr = NULL;
225 size = sizeof(*peb);
226 NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 1, &size,
227 MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE );
228 peb = addr;
229
230 peb->ProcessParameters = &params;
231 peb->TlsBitmap = &tls_bitmap;
232 peb->TlsExpansionBitmap = &tls_expansion_bitmap;
233 peb->FlsBitmap = &fls_bitmap;
234 peb->LdrData = &ldr;
235 params.CurrentDirectory.DosPath.Buffer = current_dir;
236 params.CurrentDirectory.DosPath.MaximumLength = sizeof(current_dir);
237 params.wShowWindow = 1; /* SW_SHOWNORMAL */
238 ldr.Length = sizeof(ldr);
239 RtlInitializeBitMap( &tls_bitmap, peb->TlsBitmapBits, sizeof(peb->TlsBitmapBits) * 8 );
240 RtlInitializeBitMap( &tls_expansion_bitmap, peb->TlsExpansionBitmapBits,
241 sizeof(peb->TlsExpansionBitmapBits) * 8 );
242 RtlInitializeBitMap( &fls_bitmap, peb->FlsBitmapBits, sizeof(peb->FlsBitmapBits) * 8 );
243 InitializeListHead( &peb->FlsListHead );
244 InitializeListHead( &ldr.InLoadOrderModuleList );
245 InitializeListHead( &ldr.InMemoryOrderModuleList );
246 InitializeListHead( &ldr.InInitializationOrderModuleList );
247 InitializeListHead( &tls_links );
248
249 /* allocate and initialize the initial TEB */
250
251 signal_alloc_thread( &teb );
252 teb->Peb = peb;
253 teb->Tib.StackBase = (void *)~0UL;
254 teb->StaticUnicodeString.Buffer = teb->StaticUnicodeBuffer;
255 teb->StaticUnicodeString.MaximumLength = sizeof(teb->StaticUnicodeBuffer);
256
257 thread_data = (struct ntdll_thread_data *)teb->SpareBytes1;
258 thread_data->request_fd = -1;
259 thread_data->reply_fd = -1;
260 thread_data->wait_fd[0] = -1;
261 thread_data->wait_fd[1] = -1;
262 thread_data->debug_info = &debug_info;
263 InsertHeadList( &tls_links, &teb->TlsLinks );
264
265 signal_init_thread( teb );
266 virtual_init_threading();
267
268 debug_info.str_pos = debug_info.strings;
269 debug_info.out_pos = debug_info.output;
270 debug_init();
271
272 /* setup the server connection */
273 server_init_process();
274 info_size = server_init_thread( peb );
275
276 /* create the process heap */
277 if (!(peb->ProcessHeap = RtlCreateHeap( HEAP_GROWABLE, NULL, 0, 0, NULL, NULL )))
278 {
279 MESSAGE( "wine: failed to create the process heap\n" );
280 exit(1);
281 }
282
283 /* allocate user parameters */
284 if (info_size)
285 {
286 init_user_process_params( info_size, &exe_file );
287 }
288 else
289 {
290 if (isatty(0) || isatty(1) || isatty(2))
291 params.ConsoleHandle = (HANDLE)2; /* see kernel32/kernel_private.h */
292 if (!isatty(0))
293 wine_server_fd_to_handle( 0, GENERIC_READ|SYNCHRONIZE, OBJ_INHERIT, &params.hStdInput );
294 if (!isatty(1))
295 wine_server_fd_to_handle( 1, GENERIC_WRITE|SYNCHRONIZE, OBJ_INHERIT, &params.hStdOutput );
296 if (!isatty(2))
297 wine_server_fd_to_handle( 2, GENERIC_WRITE|SYNCHRONIZE, OBJ_INHERIT, &params.hStdError );
298 }
299
300 /* initialize time values in user_shared_data */
301 NtQuerySystemTime( &now );
302 user_shared_data->SystemTime.LowPart = now.u.LowPart;
303 user_shared_data->SystemTime.High1Time = user_shared_data->SystemTime.High2Time = now.u.HighPart;
304 user_shared_data->u.TickCountQuad = (now.QuadPart - server_start_time) / 10000;
305 user_shared_data->u.TickCount.High2Time = user_shared_data->u.TickCount.High1Time;
306 user_shared_data->TickCountLowDeprecated = user_shared_data->u.TickCount.LowPart;
307 user_shared_data->TickCountMultiplier = 1 << 24;
308
309 fill_cpu_info();
310
311 NtCreateKeyedEvent( &keyed_event, GENERIC_READ | GENERIC_WRITE, NULL, 0 );
312
313 return exe_file;
314 }
315
316
317 /***********************************************************************
318 * terminate_thread
319 */
320 void terminate_thread( int status )
321 {
322 pthread_sigmask( SIG_BLOCK, &server_block_set, NULL );
323 if (interlocked_xchg_add( &nb_threads, -1 ) <= 1) _exit( status );
324
325 close( ntdll_get_thread_data()->wait_fd[0] );
326 close( ntdll_get_thread_data()->wait_fd[1] );
327 close( ntdll_get_thread_data()->reply_fd );
328 close( ntdll_get_thread_data()->request_fd );
329 pthread_exit( UIntToPtr(status) );
330 }
331
332
333 /***********************************************************************
334 * exit_thread
335 */
336 void exit_thread( int status )
337 {
338 static void *prev_teb;
339 TEB *teb;
340
341 if (status) /* send the exit code to the server (0 is already the default) */
342 {
343 SERVER_START_REQ( terminate_thread )
344 {
345 req->handle = wine_server_obj_handle( GetCurrentThread() );
346 req->exit_code = status;
347 wine_server_call( req );
348 }
349 SERVER_END_REQ;
350 }
351
352 if (interlocked_xchg_add( &nb_threads, -1 ) <= 1)
353 {
354 LdrShutdownProcess();
355 exit( status );
356 }
357
358 LdrShutdownThread();
359 RtlAcquirePebLock();
360 RemoveEntryList( &NtCurrentTeb()->TlsLinks );
361 RtlReleasePebLock();
362 RtlFreeHeap( GetProcessHeap(), 0, NtCurrentTeb()->FlsSlots );
363 RtlFreeHeap( GetProcessHeap(), 0, NtCurrentTeb()->TlsExpansionSlots );
364
365 pthread_sigmask( SIG_BLOCK, &server_block_set, NULL );
366
367 if ((teb = interlocked_xchg_ptr( &prev_teb, NtCurrentTeb() )))
368 {
369 struct ntdll_thread_data *thread_data = (struct ntdll_thread_data *)teb->SpareBytes1;
370
371 if (thread_data->pthread_id)
372 {
373 pthread_join( thread_data->pthread_id, NULL );
374 signal_free_thread( teb );
375 }
376 }
377
378 close( ntdll_get_thread_data()->wait_fd[0] );
379 close( ntdll_get_thread_data()->wait_fd[1] );
380 close( ntdll_get_thread_data()->reply_fd );
381 close( ntdll_get_thread_data()->request_fd );
382 pthread_exit( UIntToPtr(status) );
383 }
384
385
386 /***********************************************************************
387 * start_thread
388 *
389 * Startup routine for a newly created thread.
390 */
391 static void start_thread( struct startup_info *info )
392 {
393 TEB *teb = info->teb;
394 struct ntdll_thread_data *thread_data = (struct ntdll_thread_data *)teb->SpareBytes1;
395 PRTL_THREAD_START_ROUTINE func = info->entry_point;
396 void *arg = info->entry_arg;
397 struct debug_info debug_info;
398
399 debug_info.str_pos = debug_info.strings;
400 debug_info.out_pos = debug_info.output;
401 thread_data->debug_info = &debug_info;
402 thread_data->pthread_id = pthread_self();
403
404 signal_init_thread( teb );
405 server_init_thread( func );
406 pthread_sigmask( SIG_UNBLOCK, &server_block_set, NULL );
407
408 RtlAcquirePebLock();
409 InsertHeadList( &tls_links, &teb->TlsLinks );
410 RtlReleasePebLock();
411
412 MODULE_DllThreadAttach( NULL );
413
414 if (TRACE_ON(relay))
415 DPRINTF( "%04x:Starting thread proc %p (arg=%p)\n", GetCurrentThreadId(), func, arg );
416
417 call_thread_entry_point( (LPTHREAD_START_ROUTINE)func, arg );
418 }
419
420
421 /***********************************************************************
422 * RtlCreateUserThread (NTDLL.@)
423 */
424 NTSTATUS WINAPI RtlCreateUserThread( HANDLE process, const SECURITY_DESCRIPTOR *descr,
425 BOOLEAN suspended, PVOID stack_addr,
426 SIZE_T stack_reserve, SIZE_T stack_commit,
427 PRTL_THREAD_START_ROUTINE start, void *param,
428 HANDLE *handle_ptr, CLIENT_ID *id )
429 {
430 sigset_t sigset;
431 pthread_t pthread_id;
432 pthread_attr_t attr;
433 struct ntdll_thread_data *thread_data;
434 struct startup_info *info = NULL;
435 HANDLE handle = 0, actctx = 0;
436 TEB *teb = NULL;
437 DWORD tid = 0;
438 int request_pipe[2];
439 NTSTATUS status;
440
441 if (process != NtCurrentProcess())
442 {
443 apc_call_t call;
444 apc_result_t result;
445
446 memset( &call, 0, sizeof(call) );
447
448 call.create_thread.type = APC_CREATE_THREAD;
449 call.create_thread.func = wine_server_client_ptr( start );
450 call.create_thread.arg = wine_server_client_ptr( param );
451 call.create_thread.reserve = stack_reserve;
452 call.create_thread.commit = stack_commit;
453 call.create_thread.suspend = suspended;
454 status = server_queue_process_apc( process, &call, &result );
455 if (status != STATUS_SUCCESS) return status;
456
457 if (result.create_thread.status == STATUS_SUCCESS)
458 {
459 if (id) id->UniqueThread = ULongToHandle(result.create_thread.tid);
460 if (handle_ptr) *handle_ptr = wine_server_ptr_handle( result.create_thread.handle );
461 else NtClose( wine_server_ptr_handle( result.create_thread.handle ));
462 }
463 return result.create_thread.status;
464 }
465
466 if (server_pipe( request_pipe ) == -1) return STATUS_TOO_MANY_OPENED_FILES;
467 wine_server_send_fd( request_pipe[0] );
468
469 SERVER_START_REQ( new_thread )
470 {
471 req->access = THREAD_ALL_ACCESS;
472 req->attributes = 0; /* FIXME */
473 req->suspend = suspended;
474 req->request_fd = request_pipe[0];
475 if (!(status = wine_server_call( req )))
476 {
477 handle = wine_server_ptr_handle( reply->handle );
478 tid = reply->tid;
479 }
480 close( request_pipe[0] );
481 }
482 SERVER_END_REQ;
483
484 if (status)
485 {
486 close( request_pipe[1] );
487 return status;
488 }
489
490 pthread_sigmask( SIG_BLOCK, &server_block_set, &sigset );
491
492 if ((status = signal_alloc_thread( &teb ))) goto error;
493
494 teb->Peb = NtCurrentTeb()->Peb;
495 teb->ClientId.UniqueProcess = ULongToHandle(GetCurrentProcessId());
496 teb->ClientId.UniqueThread = ULongToHandle(tid);
497 teb->StaticUnicodeString.Buffer = teb->StaticUnicodeBuffer;
498 teb->StaticUnicodeString.MaximumLength = sizeof(teb->StaticUnicodeBuffer);
499
500 /* create default activation context frame for new thread */
501 RtlGetActiveActivationContext(&actctx);
502 if (actctx)
503 {
504 RTL_ACTIVATION_CONTEXT_STACK_FRAME *frame;
505
506 frame = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(*frame));
507 frame->Previous = NULL;
508 frame->ActivationContext = actctx;
509 frame->Flags = 0;
510 teb->ActivationContextStack.ActiveFrame = frame;
511
512 RtlAddRefActivationContext(actctx);
513 }
514
515 info = (struct startup_info *)(teb + 1);
516 info->teb = teb;
517 info->entry_point = start;
518 info->entry_arg = param;
519
520 thread_data = (struct ntdll_thread_data *)teb->SpareBytes1;
521 thread_data->request_fd = request_pipe[1];
522 thread_data->reply_fd = -1;
523 thread_data->wait_fd[0] = -1;
524 thread_data->wait_fd[1] = -1;
525
526 if ((status = virtual_alloc_thread_stack( teb, stack_reserve, stack_commit ))) goto error;
527
528 pthread_attr_init( &attr );
529 pthread_attr_setstack( &attr, teb->DeallocationStack,
530 (char *)teb->Tib.StackBase - (char *)teb->DeallocationStack );
531 pthread_attr_setscope( &attr, PTHREAD_SCOPE_SYSTEM ); /* force creating a kernel thread */
532 interlocked_xchg_add( &nb_threads, 1 );
533 if (pthread_create( &pthread_id, &attr, (void * (*)(void *))start_thread, info ))
534 {
535 interlocked_xchg_add( &nb_threads, -1 );
536 pthread_attr_destroy( &attr );
537 status = STATUS_NO_MEMORY;
538 goto error;
539 }
540 pthread_attr_destroy( &attr );
541 pthread_sigmask( SIG_SETMASK, &sigset, NULL );
542
543 if (id) id->UniqueThread = ULongToHandle(tid);
544 if (handle_ptr) *handle_ptr = handle;
545 else NtClose( handle );
546
547 return STATUS_SUCCESS;
548
549 error:
550 if (teb) signal_free_thread( teb );
551 if (handle) NtClose( handle );
552 pthread_sigmask( SIG_SETMASK, &sigset, NULL );
553 close( request_pipe[1] );
554 return status;
555 }
556
557
558 /******************************************************************************
559 * RtlGetNtGlobalFlags (NTDLL.@)
560 */
561 ULONG WINAPI RtlGetNtGlobalFlags(void)
562 {
563 if (!peb) return 0; /* init not done yet */
564 return peb->NtGlobalFlag;
565 }
566
567
568 /***********************************************************************
569 * NtOpenThread (NTDLL.@)
570 * ZwOpenThread (NTDLL.@)
571 */
572 NTSTATUS WINAPI NtOpenThread( HANDLE *handle, ACCESS_MASK access,
573 const OBJECT_ATTRIBUTES *attr, const CLIENT_ID *id )
574 {
575 NTSTATUS ret;
576
577 SERVER_START_REQ( open_thread )
578 {
579 req->tid = HandleToULong(id->UniqueThread);
580 req->access = access;
581 req->attributes = attr ? attr->Attributes : 0;
582 ret = wine_server_call( req );
583 *handle = wine_server_ptr_handle( reply->handle );
584 }
585 SERVER_END_REQ;
586 return ret;
587 }
588
589
590 /******************************************************************************
591 * NtSuspendThread (NTDLL.@)
592 * ZwSuspendThread (NTDLL.@)
593 */
594 NTSTATUS WINAPI NtSuspendThread( HANDLE handle, PULONG count )
595 {
596 NTSTATUS ret;
597
598 SERVER_START_REQ( suspend_thread )
599 {
600 req->handle = wine_server_obj_handle( handle );
601 if (!(ret = wine_server_call( req ))) *count = reply->count;
602 }
603 SERVER_END_REQ;
604 return ret;
605 }
606
607
608 /******************************************************************************
609 * NtResumeThread (NTDLL.@)
610 * ZwResumeThread (NTDLL.@)
611 */
612 NTSTATUS WINAPI NtResumeThread( HANDLE handle, PULONG count )
613 {
614 NTSTATUS ret;
615
616 SERVER_START_REQ( resume_thread )
617 {
618 req->handle = wine_server_obj_handle( handle );
619 if (!(ret = wine_server_call( req ))) *count = reply->count;
620 }
621 SERVER_END_REQ;
622 return ret;
623 }
624
625
626 /******************************************************************************
627 * NtAlertResumeThread (NTDLL.@)
628 * ZwAlertResumeThread (NTDLL.@)
629 */
630 NTSTATUS WINAPI NtAlertResumeThread( HANDLE handle, PULONG count )
631 {
632 FIXME( "stub: should alert thread %p\n", handle );
633 return NtResumeThread( handle, count );
634 }
635
636
637 /******************************************************************************
638 * NtAlertThread (NTDLL.@)
639 * ZwAlertThread (NTDLL.@)
640 */
641 NTSTATUS WINAPI NtAlertThread( HANDLE handle )
642 {
643 FIXME( "stub: %p\n", handle );
644 return STATUS_NOT_IMPLEMENTED;
645 }
646
647
648 /******************************************************************************
649 * NtTerminateThread (NTDLL.@)
650 * ZwTerminateThread (NTDLL.@)
651 */
652 NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code )
653 {
654 NTSTATUS ret;
655 BOOL self;
656
657 SERVER_START_REQ( terminate_thread )
658 {
659 req->handle = wine_server_obj_handle( handle );
660 req->exit_code = exit_code;
661 ret = wine_server_call( req );
662 self = !ret && reply->self;
663 }
664 SERVER_END_REQ;
665
666 if (self) abort_thread( exit_code );
667 return ret;
668 }
669
670
671 /******************************************************************************
672 * NtQueueApcThread (NTDLL.@)
673 */
674 NTSTATUS WINAPI NtQueueApcThread( HANDLE handle, PNTAPCFUNC func, ULONG_PTR arg1,
675 ULONG_PTR arg2, ULONG_PTR arg3 )
676 {
677 NTSTATUS ret;
678 SERVER_START_REQ( queue_apc )
679 {
680 req->handle = wine_server_obj_handle( handle );
681 if (func)
682 {
683 req->call.type = APC_USER;
684 req->call.user.func = wine_server_client_ptr( func );
685 req->call.user.args[0] = arg1;
686 req->call.user.args[1] = arg2;
687 req->call.user.args[2] = arg3;
688 }
689 else req->call.type = APC_NONE; /* wake up only */
690 ret = wine_server_call( req );
691 }
692 SERVER_END_REQ;
693 return ret;
694 }
695
696
697 /***********************************************************************
698 * NtSetContextThread (NTDLL.@)
699 * ZwSetContextThread (NTDLL.@)
700 */
701 NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context )
702 {
703 NTSTATUS ret;
704 DWORD dummy, i;
705 BOOL self = FALSE;
706
707 #ifdef __i386__
708 /* on i386 debug registers always require a server call */
709 self = (handle == GetCurrentThread());
710 if (self && (context->ContextFlags & (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386)))
711 {
712 self = (ntdll_get_thread_data()->dr0 == context->Dr0 &&
713 ntdll_get_thread_data()->dr1 == context->Dr1 &&
714 ntdll_get_thread_data()->dr2 == context->Dr2 &&
715 ntdll_get_thread_data()->dr3 == context->Dr3 &&
716 ntdll_get_thread_data()->dr6 == context->Dr6 &&
717 ntdll_get_thread_data()->dr7 == context->Dr7);
718 }
719 #endif
720
721 if (!self)
722 {
723 context_t server_context;
724
725 context_to_server( &server_context, context );
726
727 SERVER_START_REQ( set_thread_context )
728 {
729 req->handle = wine_server_obj_handle( handle );
730 req->suspend = 1;
731 wine_server_add_data( req, &server_context, sizeof(server_context) );
732 ret = wine_server_call( req );
733 self = reply->self;
734 }
735 SERVER_END_REQ;
736
737 if (ret == STATUS_PENDING)
738 {
739 for (i = 0; i < 100; i++)
740 {
741 SERVER_START_REQ( set_thread_context )
742 {
743 req->handle = wine_server_obj_handle( handle );
744 req->suspend = 0;
745 wine_server_add_data( req, &server_context, sizeof(server_context) );
746 ret = wine_server_call( req );
747 }
748 SERVER_END_REQ;
749 if (ret == STATUS_PENDING)
750 {
751 LARGE_INTEGER timeout;
752 timeout.QuadPart = -10000;
753 NtDelayExecution( FALSE, &timeout );
754 }
755 else break;
756 }
757 NtResumeThread( handle, &dummy );
758 if (ret == STATUS_PENDING) ret = STATUS_ACCESS_DENIED;
759 }
760
761 if (ret) return ret;
762 }
763
764 if (self) set_cpu_context( context );
765 return STATUS_SUCCESS;
766 }
767
768
769 /* convert CPU-specific flags to generic server flags */
770 static inline unsigned int get_server_context_flags( DWORD flags )
771 {
772 unsigned int ret = 0;
773
774 flags &= 0x3f; /* mask CPU id flags */
775 if (flags & CONTEXT_CONTROL) ret |= SERVER_CTX_CONTROL;
776 if (flags & CONTEXT_INTEGER) ret |= SERVER_CTX_INTEGER;
777 #ifdef CONTEXT_SEGMENTS
778 if (flags & CONTEXT_SEGMENTS) ret |= SERVER_CTX_SEGMENTS;
779 #endif
780 #ifdef CONTEXT_FLOATING_POINT
781 if (flags & CONTEXT_FLOATING_POINT) ret |= SERVER_CTX_FLOATING_POINT;
782 #endif
783 #ifdef CONTEXT_DEBUG_REGISTERS
784 if (flags & CONTEXT_DEBUG_REGISTERS) ret |= SERVER_CTX_DEBUG_REGISTERS;
785 #endif
786 #ifdef CONTEXT_EXTENDED_REGISTERS
787 if (flags & CONTEXT_EXTENDED_REGISTERS) ret |= SERVER_CTX_EXTENDED_REGISTERS;
788 #endif
789 return ret;
790 }
791
792 /***********************************************************************
793 * NtGetContextThread (NTDLL.@)
794 * ZwGetContextThread (NTDLL.@)
795 */
796 NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context )
797 {
798 NTSTATUS ret;
799 DWORD dummy, i;
800 DWORD needed_flags = context->ContextFlags;
801 BOOL self = (handle == GetCurrentThread());
802
803 #ifdef __i386__
804 /* on i386 debug registers always require a server call */
805 if (context->ContextFlags & (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386)) self = FALSE;
806 #endif
807
808 if (!self)
809 {
810 unsigned int server_flags = get_server_context_flags( context->ContextFlags );
811 context_t server_context;
812
813 SERVER_START_REQ( get_thread_context )
814 {
815 req->handle = wine_server_obj_handle( handle );
816 req->flags = server_flags;
817 req->suspend = 1;
818 wine_server_set_reply( req, &server_context, sizeof(server_context) );
819 ret = wine_server_call( req );
820 self = reply->self;
821 }
822 SERVER_END_REQ;
823
824 if (ret == STATUS_PENDING)
825 {
826 for (i = 0; i < 100; i++)
827 {
828 SERVER_START_REQ( get_thread_context )
829 {
830 req->handle = wine_server_obj_handle( handle );
831 req->flags = server_flags;
832 req->suspend = 0;
833 wine_server_set_reply( req, &server_context, sizeof(server_context) );
834 ret = wine_server_call( req );
835 }
836 SERVER_END_REQ;
837 if (ret == STATUS_PENDING)
838 {
839 LARGE_INTEGER timeout;
840 timeout.QuadPart = -10000;
841 NtDelayExecution( FALSE, &timeout );
842 }
843 else break;
844 }
845 NtResumeThread( handle, &dummy );
846 if (ret == STATUS_PENDING) ret = STATUS_ACCESS_DENIED;
847 }
848 if (!ret) ret = context_from_server( context, &server_context );
849 if (ret) return ret;
850 needed_flags &= ~context->ContextFlags;
851 }
852
853 if (self)
854 {
855 if (needed_flags)
856 {
857 CONTEXT ctx;
858 RtlCaptureContext( &ctx );
859 copy_context( context, &ctx, ctx.ContextFlags & needed_flags );
860 context->ContextFlags |= ctx.ContextFlags & needed_flags;
861 }
862 #ifdef __i386__
863 /* update the cached version of the debug registers */
864 if (context->ContextFlags & (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386))
865 {
866 ntdll_get_thread_data()->dr0 = context->Dr0;
867 ntdll_get_thread_data()->dr1 = context->Dr1;
868 ntdll_get_thread_data()->dr2 = context->Dr2;
869 ntdll_get_thread_data()->dr3 = context->Dr3;
870 ntdll_get_thread_data()->dr6 = context->Dr6;
871 ntdll_get_thread_data()->dr7 = context->Dr7;
872 }
873 #endif
874 }
875 return STATUS_SUCCESS;
876 }
877
878
879 /******************************************************************************
880 * NtQueryInformationThread (NTDLL.@)
881 * ZwQueryInformationThread (NTDLL.@)
882 */
883 NTSTATUS WINAPI NtQueryInformationThread( HANDLE handle, THREADINFOCLASS class,
884 void *data, ULONG length, ULONG *ret_len )
885 {
886 NTSTATUS status;
887
888 switch(class)
889 {
890 case ThreadBasicInformation:
891 {
892 THREAD_BASIC_INFORMATION info;
893 const ULONG_PTR affinity_mask = ((ULONG_PTR)1 << NtCurrentTeb()->Peb->NumberOfProcessors) - 1;
894
895 SERVER_START_REQ( get_thread_info )
896 {
897 req->handle = wine_server_obj_handle( handle );
898 req->tid_in = 0;
899 if (!(status = wine_server_call( req )))
900 {
901 info.ExitStatus = reply->exit_code;
902 info.TebBaseAddress = wine_server_get_ptr( reply->teb );
903 info.ClientId.UniqueProcess = ULongToHandle(reply->pid);
904 info.ClientId.UniqueThread = ULongToHandle(reply->tid);
905 info.AffinityMask = reply->affinity & affinity_mask;
906 info.Priority = reply->priority;
907 info.BasePriority = reply->priority; /* FIXME */
908 }
909 }
910 SERVER_END_REQ;
911 if (status == STATUS_SUCCESS)
912 {
913 if (data) memcpy( data, &info, min( length, sizeof(info) ));
914 if (ret_len) *ret_len = min( length, sizeof(info) );
915 }
916 }
917 return status;
918 case ThreadAffinityMask:
919 {
920 const ULONG_PTR affinity_mask = ((ULONG_PTR)1 << NtCurrentTeb()->Peb->NumberOfProcessors) - 1;
921 ULONG_PTR affinity = 0;
922
923 SERVER_START_REQ( get_thread_info )
924 {
925 req->handle = wine_server_obj_handle( handle );
926 req->tid_in = 0;
927 if (!(status = wine_server_call( req )))
928 affinity = reply->affinity & affinity_mask;
929 }
930 SERVER_END_REQ;
931 if (status == STATUS_SUCCESS)
932 {
933 if (data) memcpy( data, &affinity, min( length, sizeof(affinity) ));
934 if (ret_len) *ret_len = min( length, sizeof(affinity) );
935 }
936 }
937 return status;
938 case ThreadTimes:
939 {
940 KERNEL_USER_TIMES kusrt;
941 /* We need to do a server call to get the creation time or exit time */
942 /* This works on any thread */
943 SERVER_START_REQ( get_thread_info )
944 {
945 req->handle = wine_server_obj_handle( handle );
946 req->tid_in = 0;
947 status = wine_server_call( req );
948 if (status == STATUS_SUCCESS)
949 {
950 kusrt.CreateTime.QuadPart = reply->creation_time;
951 kusrt.ExitTime.QuadPart = reply->exit_time;
952 }
953 }
954 SERVER_END_REQ;
955 if (status == STATUS_SUCCESS)
956 {
957 /* We call times(2) for kernel time or user time */
958 /* We can only (portably) do this for the current thread */
959 if (handle == GetCurrentThread())
960 {
961 struct tms time_buf;
962 long clocks_per_sec = sysconf(_SC_CLK_TCK);
963
964 times(&time_buf);
965 kusrt.KernelTime.QuadPart = (ULONGLONG)time_buf.tms_stime * 10000000 / clocks_per_sec;
966 kusrt.UserTime.QuadPart = (ULONGLONG)time_buf.tms_utime * 10000000 / clocks_per_sec;
967 }
968 else
969 {
970 static BOOL reported = FALSE;
971
972 kusrt.KernelTime.QuadPart = 0;
973 kusrt.UserTime.QuadPart = 0;
974 if (reported)
975 TRACE("Cannot get kerneltime or usertime of other threads\n");
976 else
977 {
978 FIXME("Cannot get kerneltime or usertime of other threads\n");
979 reported = TRUE;
980 }
981 }
982 if (data) memcpy( data, &kusrt, min( length, sizeof(kusrt) ));
983 if (ret_len) *ret_len = min( length, sizeof(kusrt) );
984 }
985 }
986 return status;
987 case ThreadDescriptorTableEntry:
988 {
989 #ifdef __i386__
990 THREAD_DESCRIPTOR_INFORMATION* tdi = data;
991 if (length < sizeof(*tdi))
992 status = STATUS_INFO_LENGTH_MISMATCH;
993 else if (!(tdi->Selector & 4)) /* GDT selector */
994 {
995 unsigned sel = tdi->Selector & ~3; /* ignore RPL */
996 status = STATUS_SUCCESS;
997 if (!sel) /* null selector */
998 memset( &tdi->Entry, 0, sizeof(tdi->Entry) );
999 else
1000 {
1001 tdi->Entry.BaseLow = 0;
1002 tdi->Entry.HighWord.Bits.BaseMid = 0;
1003 tdi->Entry.HighWord.Bits.BaseHi = 0;
1004 tdi->Entry.LimitLow = 0xffff;
1005 tdi->Entry.HighWord.Bits.LimitHi = 0xf;
1006 tdi->Entry.HighWord.Bits.Dpl = 3;
1007 tdi->Entry.HighWord.Bits.Sys = 0;
1008 tdi->Entry.HighWord.Bits.Pres = 1;
1009 tdi->Entry.HighWord.Bits.Granularity = 1;
1010 tdi->Entry.HighWord.Bits.Default_Big = 1;
1011 tdi->Entry.HighWord.Bits.Type = 0x12;
1012 /* it has to be one of the system GDT selectors */
1013 if (sel != (wine_get_ds() & ~3) && sel != (wine_get_ss() & ~3))
1014 {
1015 if (sel == (wine_get_cs() & ~3))
1016 tdi->Entry.HighWord.Bits.Type |= 8; /* code segment */
1017 else status = STATUS_ACCESS_DENIED;
1018 }
1019 }
1020 }
1021 else
1022 {
1023 SERVER_START_REQ( get_selector_entry )
1024 {
1025 req->handle = wine_server_obj_handle( handle );
1026 req->entry = tdi->Selector >> 3;
1027 status = wine_server_call( req );
1028 if (!status)
1029 {
1030 if (!(reply->flags & WINE_LDT_FLAGS_ALLOCATED))
1031 status = STATUS_ACCESS_VIOLATION;
1032 else
1033 {
1034 wine_ldt_set_base ( &tdi->Entry, (void *)reply->base );
1035 wine_ldt_set_limit( &tdi->Entry, reply->limit );
1036 wine_ldt_set_flags( &tdi->Entry, reply->flags );
1037 }
1038 }
1039 }
1040 SERVER_END_REQ;
1041 }
1042 if (status == STATUS_SUCCESS && ret_len)
1043 /* yes, that's a bit strange, but it's the way it is */
1044 *ret_len = sizeof(LDT_ENTRY);
1045 #else
1046 status = STATUS_NOT_IMPLEMENTED;
1047 #endif
1048 return status;
1049 }
1050 case ThreadAmILastThread:
1051 {
1052 SERVER_START_REQ(get_thread_info)
1053 {
1054 req->handle = wine_server_obj_handle( handle );
1055 req->tid_in = 0;
1056 status = wine_server_call( req );
1057 if (status == STATUS_SUCCESS)
1058 {
1059 BOOLEAN last = reply->last;
1060 if (data) memcpy( data, &last, min( length, sizeof(last) ));
1061 if (ret_len) *ret_len = min( length, sizeof(last) );
1062 }
1063 }
1064 SERVER_END_REQ;
1065 return status;
1066 }
1067 case ThreadPriority:
1068 case ThreadBasePriority:
1069 case ThreadImpersonationToken:
1070 case ThreadEnableAlignmentFaultFixup:
1071 case ThreadEventPair_Reusable:
1072 case ThreadQuerySetWin32StartAddress:
1073 case ThreadZeroTlsCell:
1074 case ThreadPerformanceCount:
1075 case ThreadIdealProcessor:
1076 case ThreadPriorityBoost:
1077 case ThreadSetTlsArrayAddress:
1078 case ThreadIsIoPending:
1079 default:
1080 FIXME( "info class %d not supported yet\n", class );
1081 return STATUS_NOT_IMPLEMENTED;
1082 }
1083 }
1084
1085
1086 /******************************************************************************
1087 * NtSetInformationThread (NTDLL.@)
1088 * ZwSetInformationThread (NTDLL.@)
1089 */
1090 NTSTATUS WINAPI NtSetInformationThread( HANDLE handle, THREADINFOCLASS class,
1091 LPCVOID data, ULONG length )
1092 {
1093 NTSTATUS status;
1094 switch(class)
1095 {
1096 case ThreadZeroTlsCell:
1097 if (handle == GetCurrentThread())
1098 {
1099 LIST_ENTRY *entry;
1100 DWORD index;
1101
1102 if (length != sizeof(DWORD)) return STATUS_INVALID_PARAMETER;
1103 index = *(const DWORD *)data;
1104 if (index < TLS_MINIMUM_AVAILABLE)
1105 {
1106 RtlAcquirePebLock();
1107 for (entry = tls_links.Flink; entry != &tls_links; entry = entry->Flink)
1108 {
1109 TEB *teb = CONTAINING_RECORD(entry, TEB, TlsLinks);
1110 teb->TlsSlots[index] = 0;
1111 }
1112 RtlReleasePebLock();
1113 }
1114 else
1115 {
1116 index -= TLS_MINIMUM_AVAILABLE;
1117 if (index >= 8 * sizeof(NtCurrentTeb()->Peb->TlsExpansionBitmapBits))
1118 return STATUS_INVALID_PARAMETER;
1119 RtlAcquirePebLock();
1120 for (entry = tls_links.Flink; entry != &tls_links; entry = entry->Flink)
1121 {
1122 TEB *teb = CONTAINING_RECORD(entry, TEB, TlsLinks);
1123 if (teb->TlsExpansionSlots) teb->TlsExpansionSlots[index] = 0;
1124 }
1125 RtlReleasePebLock();
1126 }
1127 return STATUS_SUCCESS;
1128 }
1129 FIXME( "ZeroTlsCell not supported on other threads\n" );
1130 return STATUS_NOT_IMPLEMENTED;
1131
1132 case ThreadImpersonationToken:
1133 {
1134 const HANDLE *phToken = data;
1135 if (length != sizeof(HANDLE)) return STATUS_INVALID_PARAMETER;
1136 TRACE("Setting ThreadImpersonationToken handle to %p\n", *phToken );
1137 SERVER_START_REQ( set_thread_info )
1138 {
1139 req->handle = wine_server_obj_handle( handle );
1140 req->token = wine_server_obj_handle( *phToken );
1141 req->mask = SET_THREAD_INFO_TOKEN;
1142 status = wine_server_call( req );
1143 }
1144 SERVER_END_REQ;
1145 }
1146 return status;
1147 case ThreadBasePriority:
1148 {
1149 const DWORD *pprio = data;
1150 if (length != sizeof(DWORD)) return STATUS_INVALID_PARAMETER;
1151 SERVER_START_REQ( set_thread_info )
1152 {
1153 req->handle = wine_server_obj_handle( handle );
1154 req->priority = *pprio;
1155 req->mask = SET_THREAD_INFO_PRIORITY;
1156 status = wine_server_call( req );
1157 }
1158 SERVER_END_REQ;
1159 }
1160 return status;
1161 case ThreadAffinityMask:
1162 {
1163 const ULONG_PTR affinity_mask = ((ULONG_PTR)1 << NtCurrentTeb()->Peb->NumberOfProcessors) - 1;
1164 ULONG_PTR req_aff;
1165
1166 if (length != sizeof(ULONG_PTR)) return STATUS_INVALID_PARAMETER;
1167 req_aff = *(const ULONG_PTR *)data;
1168 if ((ULONG)req_aff == ~0u) req_aff = affinity_mask;
1169 else if (req_aff & ~affinity_mask) return STATUS_INVALID_PARAMETER;
1170 else if (!req_aff) return STATUS_INVALID_PARAMETER;
1171 SERVER_START_REQ( set_thread_info )
1172 {
1173 req->handle = wine_server_obj_handle( handle );
1174 req->affinity = req_aff;
1175 req->mask = SET_THREAD_INFO_AFFINITY;
1176 status = wine_server_call( req );
1177 }
1178 SERVER_END_REQ;
1179 }
1180 return status;
1181 case ThreadHideFromDebugger:
1182 /* pretend the call succeeded to satisfy some code protectors */
1183 return STATUS_SUCCESS;
1184
1185 case ThreadBasicInformation:
1186 case ThreadTimes:
1187 case ThreadPriority:
1188 case ThreadDescriptorTableEntry:
1189 case ThreadEnableAlignmentFaultFixup:
1190 case ThreadEventPair_Reusable:
1191 case ThreadQuerySetWin32StartAddress:
1192 case ThreadPerformanceCount:
1193 case ThreadAmILastThread:
1194 case ThreadIdealProcessor:
1195 case ThreadPriorityBoost:
1196 case ThreadSetTlsArrayAddress:
1197 case ThreadIsIoPending:
1198 default:
1199 FIXME( "info class %d not supported yet\n", class );
1200 return STATUS_NOT_IMPLEMENTED;
1201 }
1202 }
1203
1204 /******************************************************************************
1205 * NtGetCurrentProcessorNumber (NTDLL.@)
1206 *
1207 * Return the processor, on which the thread is running
1208 *
1209 */
1210 ULONG WINAPI NtGetCurrentProcessorNumber(void)
1211 {
1212 ULONG processor;
1213
1214 #if defined(__linux__) && defined(__NR_getcpu)
1215 int res = syscall(__NR_getcpu, &processor, NULL, NULL);
1216 if (res != -1) return processor;
1217 #endif
1218
1219 if (NtCurrentTeb()->Peb->NumberOfProcessors > 1)
1220 {
1221 ULONG_PTR thread_mask, processor_mask;
1222 NTSTATUS status;
1223
1224 status = NtQueryInformationThread(GetCurrentThread(), ThreadAffinityMask,
1225 &thread_mask, sizeof(thread_mask), NULL);
1226 if (status == STATUS_SUCCESS)
1227 {
1228 for (processor = 0; processor < NtCurrentTeb()->Peb->NumberOfProcessors; processor++)
1229 {
1230 processor_mask = (1 << processor);
1231 if (thread_mask & processor_mask)
1232 {
1233 if (thread_mask != processor_mask)
1234 FIXME("need multicore support (%d processors)\n",
1235 NtCurrentTeb()->Peb->NumberOfProcessors);
1236 return processor;
1237 }
1238 }
1239 }
1240 }
1241
1242 /* fallback to the first processor */
1243 return 0;
1244 }
Windows API implementation