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