?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Use syscalls for the server functions.
[wine.git] / dlls / ntdll / unix / thread.c
blob1b0a68bf6968e6c1a94405b1f0a4c912c50422c4
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 #if 0
22 #pragma makedep unix
23 #endif
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <assert.h>
29 #include <errno.h>
30 #include <limits.h>
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <pthread.h>
35 #include <signal.h>
36 #include <sys/types.h>
37 #ifdef HAVE_SYS_MMAN_H
38 #include <sys/mman.h>
39 #endif
40 #ifdef HAVE_SYS_TIMES_H
41 #include <sys/times.h>
42 #endif
43 #ifdef HAVE_SYS_SYSCALL_H
44 #include <sys/syscall.h>
45 #endif
46
47 #define NONAMELESSUNION
48 #include "ntstatus.h"
49 #define WIN32_NO_STATUS
50 #include "winternl.h"
51 #include "ddk/wdm.h"
52 #include "wine/server.h"
53 #include "wine/debug.h"
54 #include "wine/exception.h"
55 #include "unix_private.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(seh);
58
59 #ifndef PTHREAD_STACK_MIN
60 #define PTHREAD_STACK_MIN 16384
61 #endif
62
63 static int nb_threads = 1;
64
65 static inline int get_unix_exit_code( NTSTATUS status )
66 {
67 /* prevent a nonzero exit code to end up truncated to zero in unix */
68 if (status && !(status & 0xff)) return 1;
69 return status;
70 }
71
72
73 /***********************************************************************
74 * pthread_exit_wrapper
75 */
76 static void pthread_exit_wrapper( int status )
77 {
78 close( ntdll_get_thread_data()->wait_fd[0] );
79 close( ntdll_get_thread_data()->wait_fd[1] );
80 close( ntdll_get_thread_data()->reply_fd );
81 close( ntdll_get_thread_data()->request_fd );
82 pthread_exit( UIntToPtr(status) );
83 }
84
85
86 /***********************************************************************
87 * start_thread
88 *
89 * Startup routine for a newly created thread.
90 */
91 static void start_thread( TEB *teb )
92 {
93 struct ntdll_thread_data *thread_data = (struct ntdll_thread_data *)&teb->GdiTebBatch;
94 struct debug_info debug_info;
95 BOOL suspend;
96
97 debug_info.str_pos = debug_info.out_pos = 0;
98 thread_data->debug_info = &debug_info;
99 thread_data->pthread_id = pthread_self();
100 signal_init_thread( teb );
101 server_init_thread( thread_data->start, &suspend );
102 signal_start_thread( thread_data->start, thread_data->param, suspend,
103 pRtlUserThreadStart, pLdrInitializeThunk, teb );
104 }
105
106
107 /***********************************************************************
108 * update_attr_list
109 *
110 * Update the output attributes.
111 */
112 static void update_attr_list( PS_ATTRIBUTE_LIST *attr, const CLIENT_ID *id, TEB *teb )
113 {
114 SIZE_T i, count = (attr->TotalLength - sizeof(attr->TotalLength)) / sizeof(PS_ATTRIBUTE);
115
116 for (i = 0; i < count; i++)
117 {
118 if (attr->Attributes[i].Attribute == PS_ATTRIBUTE_CLIENT_ID)
119 {
120 SIZE_T size = min( attr->Attributes[i].Size, sizeof(*id) );
121 memcpy( attr->Attributes[i].ValuePtr, id, size );
122 if (attr->Attributes[i].ReturnLength) *attr->Attributes[i].ReturnLength = size;
123 }
124 else if (attr->Attributes[i].Attribute == PS_ATTRIBUTE_TEB_ADDRESS)
125 {
126 SIZE_T size = min( attr->Attributes[i].Size, sizeof(teb) );
127 memcpy( attr->Attributes[i].ValuePtr, &teb, size );
128 if (attr->Attributes[i].ReturnLength) *attr->Attributes[i].ReturnLength = size;
129 }
130 }
131 }
132
133
134 /***********************************************************************
135 * NtCreateThreadEx (NTDLL.@)
136 */
137 NTSTATUS WINAPI NtCreateThreadEx( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
138 HANDLE process, PRTL_THREAD_START_ROUTINE start, void *param,
139 ULONG flags, SIZE_T zero_bits, SIZE_T stack_commit,
140 SIZE_T stack_reserve, PS_ATTRIBUTE_LIST *attr_list )
141 {
142 sigset_t sigset;
143 pthread_t pthread_id;
144 pthread_attr_t pthread_attr;
145 data_size_t len;
146 struct object_attributes *objattr;
147 struct ntdll_thread_data *thread_data;
148 DWORD tid = 0;
149 int request_pipe[2];
150 SIZE_T extra_stack = PTHREAD_STACK_MIN;
151 CLIENT_ID client_id;
152 TEB *teb;
153 INITIAL_TEB stack;
154 NTSTATUS status;
155
156 if (process != NtCurrentProcess())
157 {
158 apc_call_t call;
159 apc_result_t result;
160
161 memset( &call, 0, sizeof(call) );
162
163 call.create_thread.type = APC_CREATE_THREAD;
164 call.create_thread.flags = flags;
165 call.create_thread.func = wine_server_client_ptr( start );
166 call.create_thread.arg = wine_server_client_ptr( param );
167 call.create_thread.reserve = stack_reserve;
168 call.create_thread.commit = stack_commit;
169 status = server_queue_process_apc( process, &call, &result );
170 if (status != STATUS_SUCCESS) return status;
171
172 if (result.create_thread.status == STATUS_SUCCESS)
173 {
174 TEB *teb = wine_server_get_ptr( result.create_thread.teb );
175 *handle = wine_server_ptr_handle( result.create_thread.handle );
176 client_id.UniqueProcess = ULongToHandle( result.create_thread.pid );
177 client_id.UniqueThread = ULongToHandle( result.create_thread.tid );
178 if (attr_list) update_attr_list( attr_list, &client_id, teb );
179 }
180 return result.create_thread.status;
181 }
182
183 if ((status = alloc_object_attributes( attr, &objattr, &len ))) return status;
184
185 if (server_pipe( request_pipe ) == -1)
186 {
187 free( objattr );
188 return STATUS_TOO_MANY_OPENED_FILES;
189 }
190 wine_server_send_fd( request_pipe[0] );
191
192 if (!access) access = THREAD_ALL_ACCESS;
193
194 SERVER_START_REQ( new_thread )
195 {
196 req->process = wine_server_obj_handle( process );
197 req->access = access;
198 req->suspend = flags & THREAD_CREATE_FLAGS_CREATE_SUSPENDED;
199 req->request_fd = request_pipe[0];
200 wine_server_add_data( req, objattr, len );
201 if (!(status = wine_server_call( req )))
202 {
203 *handle = wine_server_ptr_handle( reply->handle );
204 tid = reply->tid;
205 }
206 close( request_pipe[0] );
207 }
208 SERVER_END_REQ;
209
210 free( objattr );
211 if (status)
212 {
213 close( request_pipe[1] );
214 return status;
215 }
216
217 pthread_sigmask( SIG_BLOCK, &server_block_set, &sigset );
218
219 if ((status = virtual_alloc_teb( &teb ))) goto done;
220
221 if ((status = virtual_alloc_thread_stack( &stack, stack_reserve, stack_commit, &extra_stack )))
222 {
223 virtual_free_teb( teb );
224 goto done;
225 }
226
227 client_id.UniqueProcess = ULongToHandle( GetCurrentProcessId() );
228 client_id.UniqueThread = ULongToHandle( tid );
229 teb->ClientId = client_id;
230
231 teb->Tib.StackBase = stack.StackBase;
232 teb->Tib.StackLimit = stack.StackLimit;
233 teb->DeallocationStack = stack.DeallocationStack;
234
235 thread_data = (struct ntdll_thread_data *)&teb->GdiTebBatch;
236 thread_data->request_fd = request_pipe[1];
237 thread_data->start_stack = (char *)teb->Tib.StackBase;
238 thread_data->start = start;
239 thread_data->param = param;
240
241 pthread_attr_init( &pthread_attr );
242 pthread_attr_setstack( &pthread_attr, teb->DeallocationStack,
243 (char *)teb->Tib.StackBase + extra_stack - (char *)teb->DeallocationStack );
244 pthread_attr_setguardsize( &pthread_attr, 0 );
245 pthread_attr_setscope( &pthread_attr, PTHREAD_SCOPE_SYSTEM ); /* force creating a kernel thread */
246 InterlockedIncrement( &nb_threads );
247 if (pthread_create( &pthread_id, &pthread_attr, (void * (*)(void *))start_thread, teb ))
248 {
249 InterlockedDecrement( &nb_threads );
250 virtual_free_teb( teb );
251 status = STATUS_NO_MEMORY;
252 }
253 pthread_attr_destroy( &pthread_attr );
254
255 done:
256 pthread_sigmask( SIG_SETMASK, &sigset, NULL );
257 if (status)
258 {
259 NtClose( *handle );
260 close( request_pipe[1] );
261 return status;
262 }
263 if (attr_list) update_attr_list( attr_list, &client_id, teb );
264 return STATUS_SUCCESS;
265 }
266
267
268 /***********************************************************************
269 * abort_thread
270 */
271 void abort_thread( int status )
272 {
273 pthread_sigmask( SIG_BLOCK, &server_block_set, NULL );
274 if (InterlockedDecrement( &nb_threads ) <= 0) abort_process( status );
275 signal_exit_thread( status, pthread_exit_wrapper );
276 }
277
278
279 /***********************************************************************
280 * abort_process
281 */
282 void abort_process( int status )
283 {
284 _exit( get_unix_exit_code( status ));
285 }
286
287
288 /***********************************************************************
289 * exit_thread
290 */
291 static void exit_thread( int status )
292 {
293 static void *prev_teb;
294 TEB *teb;
295
296 pthread_sigmask( SIG_BLOCK, &server_block_set, NULL );
297
298 if ((teb = InterlockedExchangePointer( &prev_teb, NtCurrentTeb() )))
299 {
300 struct ntdll_thread_data *thread_data = (struct ntdll_thread_data *)&teb->GdiTebBatch;
301
302 if (thread_data->pthread_id)
303 {
304 pthread_join( thread_data->pthread_id, NULL );
305 virtual_free_teb( teb );
306 }
307 }
308 signal_exit_thread( status, pthread_exit_wrapper );
309 }
310
311
312 /***********************************************************************
313 * exit_process
314 */
315 void exit_process( int status )
316 {
317 pthread_sigmask( SIG_BLOCK, &server_block_set, NULL );
318 signal_exit_thread( get_unix_exit_code( status ), exit );
319 }
320
321
322 /**********************************************************************
323 * wait_suspend
324 *
325 * Wait until the thread is no longer suspended.
326 */
327 void wait_suspend( CONTEXT *context )
328 {
329 int saved_errno = errno;
330
331 /* wait with 0 timeout, will only return once the thread is no longer suspended */
332 server_select( NULL, 0, SELECT_INTERRUPTIBLE, 0, context, NULL, NULL );
333 errno = saved_errno;
334 }
335
336
337 /**********************************************************************
338 * send_debug_event
339 *
340 * Send an EXCEPTION_DEBUG_EVENT event to the debugger.
341 */
342 NTSTATUS send_debug_event( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
343 {
344 NTSTATUS ret;
345 DWORD i;
346 obj_handle_t handle = 0;
347 client_ptr_t params[EXCEPTION_MAXIMUM_PARAMETERS];
348 CONTEXT exception_context = *context;
349 select_op_t select_op;
350 sigset_t old_set;
351
352 if (!NtCurrentTeb()->Peb->BeingDebugged) return 0; /* no debugger present */
353
354 pthread_sigmask( SIG_BLOCK, &server_block_set, &old_set );
355
356 for (i = 0; i < min( rec->NumberParameters, EXCEPTION_MAXIMUM_PARAMETERS ); i++)
357 params[i] = rec->ExceptionInformation[i];
358
359 SERVER_START_REQ( queue_exception_event )
360 {
361 req->first = first_chance;
362 req->code = rec->ExceptionCode;
363 req->flags = rec->ExceptionFlags;
364 req->record = wine_server_client_ptr( rec->ExceptionRecord );
365 req->address = wine_server_client_ptr( rec->ExceptionAddress );
366 req->len = i * sizeof(params[0]);
367 wine_server_add_data( req, params, req->len );
368 if (!(ret = wine_server_call( req ))) handle = reply->handle;
369 }
370 SERVER_END_REQ;
371
372 if (handle)
373 {
374 select_op.wait.op = SELECT_WAIT;
375 select_op.wait.handles[0] = handle;
376 server_select( &select_op, offsetof( select_op_t, wait.handles[1] ), SELECT_INTERRUPTIBLE,
377 TIMEOUT_INFINITE, &exception_context, NULL, NULL );
378
379 SERVER_START_REQ( get_exception_status )
380 {
381 req->handle = handle;
382 ret = wine_server_call( req );
383 }
384 SERVER_END_REQ;
385 if (ret >= 0) *context = exception_context;
386 }
387
388 pthread_sigmask( SIG_SETMASK, &old_set, NULL );
389 return ret;
390 }
391
392
393 /*******************************************************************
394 * NtRaiseException (NTDLL.@)
395 */
396 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
397 {
398 NTSTATUS status = send_debug_event( rec, context, first_chance );
399
400 if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
401 NtSetContextThread( GetCurrentThread(), context );
402
403 if (first_chance) call_user_exception_dispatcher( rec, context, pKiUserExceptionDispatcher );
404
405 if (rec->ExceptionFlags & EH_STACK_INVALID)
406 ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
407 else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
408 ERR("Process attempted to continue execution after noncontinuable exception.\n");
409 else
410 ERR("Unhandled exception code %x flags %x addr %p\n",
411 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
412
413 NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
414 return STATUS_SUCCESS;
415 }
416
417
418 /***********************************************************************
419 * NtOpenThread (NTDLL.@)
420 */
421 NTSTATUS WINAPI NtOpenThread( HANDLE *handle, ACCESS_MASK access,
422 const OBJECT_ATTRIBUTES *attr, const CLIENT_ID *id )
423 {
424 NTSTATUS ret;
425
426 SERVER_START_REQ( open_thread )
427 {
428 req->tid = HandleToULong(id->UniqueThread);
429 req->access = access;
430 req->attributes = attr ? attr->Attributes : 0;
431 ret = wine_server_call( req );
432 *handle = wine_server_ptr_handle( reply->handle );
433 }
434 SERVER_END_REQ;
435 return ret;
436 }
437
438
439 /******************************************************************************
440 * NtSuspendThread (NTDLL.@)
441 */
442 NTSTATUS WINAPI NtSuspendThread( HANDLE handle, ULONG *count )
443 {
444 NTSTATUS ret;
445
446 SERVER_START_REQ( suspend_thread )
447 {
448 req->handle = wine_server_obj_handle( handle );
449 if (!(ret = wine_server_call( req )))
450 {
451 if (count) *count = reply->count;
452 }
453 }
454 SERVER_END_REQ;
455 return ret;
456 }
457
458
459 /******************************************************************************
460 * NtResumeThread (NTDLL.@)
461 */
462 NTSTATUS WINAPI NtResumeThread( HANDLE handle, ULONG *count )
463 {
464 NTSTATUS ret;
465
466 SERVER_START_REQ( resume_thread )
467 {
468 req->handle = wine_server_obj_handle( handle );
469 if (!(ret = wine_server_call( req )))
470 {
471 if (count) *count = reply->count;
472 }
473 }
474 SERVER_END_REQ;
475 return ret;
476 }
477
478
479 /******************************************************************************
480 * NtAlertResumeThread (NTDLL.@)
481 */
482 NTSTATUS WINAPI NtAlertResumeThread( HANDLE handle, ULONG *count )
483 {
484 FIXME( "stub: should alert thread %p\n", handle );
485 return NtResumeThread( handle, count );
486 }
487
488
489 /******************************************************************************
490 * NtAlertThread (NTDLL.@)
491 */
492 NTSTATUS WINAPI NtAlertThread( HANDLE handle )
493 {
494 FIXME( "stub: %p\n", handle );
495 return STATUS_NOT_IMPLEMENTED;
496 }
497
498
499 /******************************************************************************
500 * NtTerminateThread (NTDLL.@)
501 */
502 NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code )
503 {
504 NTSTATUS ret;
505 BOOL self = (handle == GetCurrentThread());
506
507 if (!self || exit_code)
508 {
509 SERVER_START_REQ( terminate_thread )
510 {
511 req->handle = wine_server_obj_handle( handle );
512 req->exit_code = exit_code;
513 ret = wine_server_call( req );
514 self = !ret && reply->self;
515 }
516 SERVER_END_REQ;
517 }
518 if (self) exit_thread( exit_code );
519 return ret;
520 }
521
522
523 /******************************************************************************
524 * NtQueueApcThread (NTDLL.@)
525 */
526 NTSTATUS WINAPI NtQueueApcThread( HANDLE handle, PNTAPCFUNC func, ULONG_PTR arg1,
527 ULONG_PTR arg2, ULONG_PTR arg3 )
528 {
529 NTSTATUS ret;
530
531 SERVER_START_REQ( queue_apc )
532 {
533 req->handle = wine_server_obj_handle( handle );
534 if (func)
535 {
536 req->call.type = APC_USER;
537 req->call.user.user.func = wine_server_client_ptr( func );
538 req->call.user.user.args[0] = arg1;
539 req->call.user.user.args[1] = arg2;
540 req->call.user.user.args[2] = arg3;
541 }
542 else req->call.type = APC_NONE; /* wake up only */
543 ret = wine_server_call( req );
544 }
545 SERVER_END_REQ;
546 return ret;
547 }
548
549
550 /***********************************************************************
551 * set_thread_context
552 */
553 NTSTATUS set_thread_context( HANDLE handle, const context_t *context, BOOL *self )
554 {
555 NTSTATUS ret;
556
557 SERVER_START_REQ( set_thread_context )
558 {
559 req->handle = wine_server_obj_handle( handle );
560 wine_server_add_data( req, context, sizeof(*context) );
561 ret = wine_server_call( req );
562 *self = reply->self;
563 }
564 SERVER_END_REQ;
565
566 return ret;
567 }
568
569
570 /***********************************************************************
571 * get_thread_context
572 */
573 NTSTATUS get_thread_context( HANDLE handle, context_t *context, unsigned int flags, BOOL *self )
574 {
575 NTSTATUS ret;
576
577 SERVER_START_REQ( get_thread_context )
578 {
579 req->handle = wine_server_obj_handle( handle );
580 req->flags = flags;
581 wine_server_set_reply( req, context, sizeof(*context) );
582 ret = wine_server_call( req );
583 *self = reply->self;
584 handle = wine_server_ptr_handle( reply->handle );
585 }
586 SERVER_END_REQ;
587
588 if (ret == STATUS_PENDING)
589 {
590 LARGE_INTEGER timeout;
591 timeout.QuadPart = -1000000;
592 if (NtWaitForSingleObject( handle, FALSE, &timeout ))
593 {
594 NtClose( handle );
595 return STATUS_ACCESS_DENIED;
596 }
597 SERVER_START_REQ( get_thread_context )
598 {
599 req->handle = wine_server_obj_handle( handle );
600 req->flags = flags;
601 wine_server_set_reply( req, context, sizeof(*context) );
602 ret = wine_server_call( req );
603 }
604 SERVER_END_REQ;
605 }
606 return ret;
607 }
608
609
610 #ifdef __x86_64__
611
612 /***********************************************************************
613 * wow64_get_server_context_flags
614 */
615 static unsigned int wow64_get_server_context_flags( DWORD flags )
616 {
617 unsigned int ret = 0;
618
619 flags &= ~WOW64_CONTEXT_i386; /* get rid of CPU id */
620 if (flags & WOW64_CONTEXT_CONTROL) ret |= SERVER_CTX_CONTROL;
621 if (flags & WOW64_CONTEXT_INTEGER) ret |= SERVER_CTX_INTEGER;
622 if (flags & WOW64_CONTEXT_SEGMENTS) ret |= SERVER_CTX_SEGMENTS;
623 if (flags & WOW64_CONTEXT_FLOATING_POINT) ret |= SERVER_CTX_FLOATING_POINT;
624 if (flags & WOW64_CONTEXT_DEBUG_REGISTERS) ret |= SERVER_CTX_DEBUG_REGISTERS;
625 if (flags & WOW64_CONTEXT_EXTENDED_REGISTERS) ret |= SERVER_CTX_EXTENDED_REGISTERS;
626 return ret;
627 }
628
629 /***********************************************************************
630 * wow64_context_from_server
631 */
632 static NTSTATUS wow64_context_from_server( WOW64_CONTEXT *to, const context_t *from )
633 {
634 if (from->cpu != CPU_x86) return STATUS_INVALID_PARAMETER;
635
636 to->ContextFlags = WOW64_CONTEXT_i386;
637 if (from->flags & SERVER_CTX_CONTROL)
638 {
639 to->ContextFlags |= WOW64_CONTEXT_CONTROL;
640 to->Ebp = from->ctl.i386_regs.ebp;
641 to->Esp = from->ctl.i386_regs.esp;
642 to->Eip = from->ctl.i386_regs.eip;
643 to->SegCs = from->ctl.i386_regs.cs;
644 to->SegSs = from->ctl.i386_regs.ss;
645 to->EFlags = from->ctl.i386_regs.eflags;
646 }
647 if (from->flags & SERVER_CTX_INTEGER)
648 {
649 to->ContextFlags |= WOW64_CONTEXT_INTEGER;
650 to->Eax = from->integer.i386_regs.eax;
651 to->Ebx = from->integer.i386_regs.ebx;
652 to->Ecx = from->integer.i386_regs.ecx;
653 to->Edx = from->integer.i386_regs.edx;
654 to->Esi = from->integer.i386_regs.esi;
655 to->Edi = from->integer.i386_regs.edi;
656 }
657 if (from->flags & SERVER_CTX_SEGMENTS)
658 {
659 to->ContextFlags |= WOW64_CONTEXT_SEGMENTS;
660 to->SegDs = from->seg.i386_regs.ds;
661 to->SegEs = from->seg.i386_regs.es;
662 to->SegFs = from->seg.i386_regs.fs;
663 to->SegGs = from->seg.i386_regs.gs;
664 }
665 if (from->flags & SERVER_CTX_FLOATING_POINT)
666 {
667 to->ContextFlags |= WOW64_CONTEXT_FLOATING_POINT;
668 to->FloatSave.ControlWord = from->fp.i386_regs.ctrl;
669 to->FloatSave.StatusWord = from->fp.i386_regs.status;
670 to->FloatSave.TagWord = from->fp.i386_regs.tag;
671 to->FloatSave.ErrorOffset = from->fp.i386_regs.err_off;
672 to->FloatSave.ErrorSelector = from->fp.i386_regs.err_sel;
673 to->FloatSave.DataOffset = from->fp.i386_regs.data_off;
674 to->FloatSave.DataSelector = from->fp.i386_regs.data_sel;
675 to->FloatSave.Cr0NpxState = from->fp.i386_regs.cr0npx;
676 memcpy( to->FloatSave.RegisterArea, from->fp.i386_regs.regs, sizeof(to->FloatSave.RegisterArea) );
677 }
678 if (from->flags & SERVER_CTX_DEBUG_REGISTERS)
679 {
680 to->ContextFlags |= WOW64_CONTEXT_DEBUG_REGISTERS;
681 to->Dr0 = from->debug.i386_regs.dr0;
682 to->Dr1 = from->debug.i386_regs.dr1;
683 to->Dr2 = from->debug.i386_regs.dr2;
684 to->Dr3 = from->debug.i386_regs.dr3;
685 to->Dr6 = from->debug.i386_regs.dr6;
686 to->Dr7 = from->debug.i386_regs.dr7;
687 }
688 if (from->flags & SERVER_CTX_EXTENDED_REGISTERS)
689 {
690 to->ContextFlags |= WOW64_CONTEXT_EXTENDED_REGISTERS;
691 memcpy( to->ExtendedRegisters, from->ext.i386_regs, sizeof(to->ExtendedRegisters) );
692 }
693 return STATUS_SUCCESS;
694 }
695
696 /***********************************************************************
697 * wow64_context_to_server
698 */
699 static void wow64_context_to_server( context_t *to, const WOW64_CONTEXT *from )
700 {
701 DWORD flags = from->ContextFlags & ~WOW64_CONTEXT_i386; /* get rid of CPU id */
702
703 memset( to, 0, sizeof(*to) );
704 to->cpu = CPU_x86;
705
706 if (flags & WOW64_CONTEXT_CONTROL)
707 {
708 to->flags |= SERVER_CTX_CONTROL;
709 to->ctl.i386_regs.ebp = from->Ebp;
710 to->ctl.i386_regs.esp = from->Esp;
711 to->ctl.i386_regs.eip = from->Eip;
712 to->ctl.i386_regs.cs = from->SegCs;
713 to->ctl.i386_regs.ss = from->SegSs;
714 to->ctl.i386_regs.eflags = from->EFlags;
715 }
716 if (flags & WOW64_CONTEXT_INTEGER)
717 {
718 to->flags |= SERVER_CTX_INTEGER;
719 to->integer.i386_regs.eax = from->Eax;
720 to->integer.i386_regs.ebx = from->Ebx;
721 to->integer.i386_regs.ecx = from->Ecx;
722 to->integer.i386_regs.edx = from->Edx;
723 to->integer.i386_regs.esi = from->Esi;
724 to->integer.i386_regs.edi = from->Edi;
725 }
726 if (flags & WOW64_CONTEXT_SEGMENTS)
727 {
728 to->flags |= SERVER_CTX_SEGMENTS;
729 to->seg.i386_regs.ds = from->SegDs;
730 to->seg.i386_regs.es = from->SegEs;
731 to->seg.i386_regs.fs = from->SegFs;
732 to->seg.i386_regs.gs = from->SegGs;
733 }
734 if (flags & WOW64_CONTEXT_FLOATING_POINT)
735 {
736 to->flags |= SERVER_CTX_FLOATING_POINT;
737 to->fp.i386_regs.ctrl = from->FloatSave.ControlWord;
738 to->fp.i386_regs.status = from->FloatSave.StatusWord;
739 to->fp.i386_regs.tag = from->FloatSave.TagWord;
740 to->fp.i386_regs.err_off = from->FloatSave.ErrorOffset;
741 to->fp.i386_regs.err_sel = from->FloatSave.ErrorSelector;
742 to->fp.i386_regs.data_off = from->FloatSave.DataOffset;
743 to->fp.i386_regs.data_sel = from->FloatSave.DataSelector;
744 to->fp.i386_regs.cr0npx = from->FloatSave.Cr0NpxState;
745 memcpy( to->fp.i386_regs.regs, from->FloatSave.RegisterArea, sizeof(to->fp.i386_regs.regs) );
746 }
747 if (flags & WOW64_CONTEXT_DEBUG_REGISTERS)
748 {
749 to->flags |= SERVER_CTX_DEBUG_REGISTERS;
750 to->debug.i386_regs.dr0 = from->Dr0;
751 to->debug.i386_regs.dr1 = from->Dr1;
752 to->debug.i386_regs.dr2 = from->Dr2;
753 to->debug.i386_regs.dr3 = from->Dr3;
754 to->debug.i386_regs.dr6 = from->Dr6;
755 to->debug.i386_regs.dr7 = from->Dr7;
756 }
757 if (flags & WOW64_CONTEXT_EXTENDED_REGISTERS)
758 {
759 to->flags |= SERVER_CTX_EXTENDED_REGISTERS;
760 memcpy( to->ext.i386_regs, from->ExtendedRegisters, sizeof(to->ext.i386_regs) );
761 }
762 }
763
764 #endif /* __x86_64__ */
765
766 #ifdef linux
767 BOOL get_thread_times(int unix_pid, int unix_tid, LARGE_INTEGER *kernel_time, LARGE_INTEGER *user_time)
768 {
769 unsigned long clocks_per_sec = sysconf( _SC_CLK_TCK );
770 unsigned long usr, sys;
771 const char *pos;
772 char buf[512];
773 FILE *f;
774 int i;
775
776 if (unix_tid == -1)
777 sprintf( buf, "/proc/%u/stat", unix_pid );
778 else
779 sprintf( buf, "/proc/%u/task/%u/stat", unix_pid, unix_tid );
780 if (!(f = fopen( buf, "r" )))
781 {
782 WARN("Failed to open %s: %s\n", buf, strerror(errno));
783 return FALSE;
784 }
785
786 pos = fgets( buf, sizeof(buf), f );
787 fclose( f );
788
789 /* the process name is printed unescaped, so we have to skip to the last ')'
790 * to avoid misinterpreting the string */
791 if (pos) pos = strrchr( pos, ')' );
792 if (pos) pos = strchr( pos + 1, ' ' );
793 if (pos) pos++;
794
795 /* skip over the following fields: state, ppid, pgid, sid, tty_nr, tty_pgrp,
796 * task->flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
797 for (i = 0; i < 11 && pos; i++)
798 {
799 pos = strchr( pos + 1, ' ' );
800 if (pos) pos++;
801 }
802
803 /* the next two values are user and system time */
804 if (pos && (sscanf( pos, "%lu %lu", &usr, &sys ) == 2))
805 {
806 kernel_time->QuadPart = (ULONGLONG)sys * 10000000 / clocks_per_sec;
807 user_time->QuadPart = (ULONGLONG)usr * 10000000 / clocks_per_sec;
808 return TRUE;
809 }
810
811 ERR("Failed to parse %s\n", debugstr_a(buf));
812 return FALSE;
813 }
814 #else
815 BOOL get_thread_times(int unix_pid, int unix_tid, LARGE_INTEGER *kernel_time, LARGE_INTEGER *user_time)
816 {
817 static int once;
818 if (!once++) FIXME("not implemented on this platform\n");
819 return FALSE;
820 }
821 #endif
822
823 /******************************************************************************
824 * NtQueryInformationThread (NTDLL.@)
825 */
826 NTSTATUS WINAPI NtQueryInformationThread( HANDLE handle, THREADINFOCLASS class,
827 void *data, ULONG length, ULONG *ret_len )
828 {
829 NTSTATUS status;
830
831 TRACE("(%p,%d,%p,%x,%p)\n", handle, class, data, length, ret_len);
832
833 switch (class)
834 {
835 case ThreadBasicInformation:
836 {
837 THREAD_BASIC_INFORMATION info;
838 const ULONG_PTR affinity_mask = get_system_affinity_mask();
839
840 SERVER_START_REQ( get_thread_info )
841 {
842 req->handle = wine_server_obj_handle( handle );
843 if (!(status = wine_server_call( req )))
844 {
845 info.ExitStatus = reply->exit_code;
846 info.TebBaseAddress = wine_server_get_ptr( reply->teb );
847 info.ClientId.UniqueProcess = ULongToHandle(reply->pid);
848 info.ClientId.UniqueThread = ULongToHandle(reply->tid);
849 info.AffinityMask = reply->affinity & affinity_mask;
850 info.Priority = reply->priority;
851 info.BasePriority = reply->priority; /* FIXME */
852 }
853 }
854 SERVER_END_REQ;
855 if (status == STATUS_SUCCESS)
856 {
857 if (data) memcpy( data, &info, min( length, sizeof(info) ));
858 if (ret_len) *ret_len = min( length, sizeof(info) );
859 }
860 return status;
861 }
862
863 case ThreadAffinityMask:
864 {
865 const ULONG_PTR affinity_mask = get_system_affinity_mask();
866 ULONG_PTR affinity = 0;
867
868 SERVER_START_REQ( get_thread_info )
869 {
870 req->handle = wine_server_obj_handle( handle );
871 req->access = THREAD_QUERY_INFORMATION;
872 if (!(status = wine_server_call( req ))) affinity = reply->affinity & affinity_mask;
873 }
874 SERVER_END_REQ;
875 if (status == STATUS_SUCCESS)
876 {
877 if (data) memcpy( data, &affinity, min( length, sizeof(affinity) ));
878 if (ret_len) *ret_len = min( length, sizeof(affinity) );
879 }
880 return status;
881 }
882
883 case ThreadTimes:
884 {
885 KERNEL_USER_TIMES kusrt;
886 int unix_pid, unix_tid;
887
888 SERVER_START_REQ( get_thread_times )
889 {
890 req->handle = wine_server_obj_handle( handle );
891 status = wine_server_call( req );
892 if (status == STATUS_SUCCESS)
893 {
894 kusrt.CreateTime.QuadPart = reply->creation_time;
895 kusrt.ExitTime.QuadPart = reply->exit_time;
896 unix_pid = reply->unix_pid;
897 unix_tid = reply->unix_tid;
898 }
899 }
900 SERVER_END_REQ;
901 if (status == STATUS_SUCCESS)
902 {
903 BOOL ret = FALSE;
904
905 kusrt.KernelTime.QuadPart = kusrt.UserTime.QuadPart = 0;
906 if (unix_pid != -1 && unix_tid != -1)
907 ret = get_thread_times( unix_pid, unix_tid, &kusrt.KernelTime, &kusrt.UserTime );
908 if (!ret && handle == GetCurrentThread())
909 {
910 /* fall back to process times */
911 struct tms time_buf;
912 long clocks_per_sec = sysconf(_SC_CLK_TCK);
913
914 times(&time_buf);
915 kusrt.KernelTime.QuadPart = (ULONGLONG)time_buf.tms_stime * 10000000 / clocks_per_sec;
916 kusrt.UserTime.QuadPart = (ULONGLONG)time_buf.tms_utime * 10000000 / clocks_per_sec;
917 }
918 if (data) memcpy( data, &kusrt, min( length, sizeof(kusrt) ));
919 if (ret_len) *ret_len = min( length, sizeof(kusrt) );
920 }
921 return status;
922 }
923
924 case ThreadDescriptorTableEntry:
925 return get_thread_ldt_entry( handle, data, length, ret_len );
926
927 case ThreadAmILastThread:
928 {
929 if (length != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
930 SERVER_START_REQ( get_thread_info )
931 {
932 req->handle = wine_server_obj_handle( handle );
933 status = wine_server_call( req );
934 if (status == STATUS_SUCCESS)
935 {
936 ULONG last = reply->last;
937 if (data) memcpy( data, &last, sizeof(last) );
938 if (ret_len) *ret_len = sizeof(last);
939 }
940 }
941 SERVER_END_REQ;
942 return status;
943 }
944
945 case ThreadQuerySetWin32StartAddress:
946 {
947 SERVER_START_REQ( get_thread_info )
948 {
949 req->handle = wine_server_obj_handle( handle );
950 req->access = THREAD_QUERY_INFORMATION;
951 status = wine_server_call( req );
952 if (status == STATUS_SUCCESS)
953 {
954 PRTL_THREAD_START_ROUTINE entry = wine_server_get_ptr( reply->entry_point );
955 if (data) memcpy( data, &entry, min( length, sizeof(entry) ) );
956 if (ret_len) *ret_len = min( length, sizeof(entry) );
957 }
958 }
959 SERVER_END_REQ;
960 return status;
961 }
962
963 case ThreadGroupInformation:
964 {
965 const ULONG_PTR affinity_mask = get_system_affinity_mask();
966 GROUP_AFFINITY affinity;
967
968 memset( &affinity, 0, sizeof(affinity) );
969 affinity.Group = 0; /* Wine only supports max 64 processors */
970
971 SERVER_START_REQ( get_thread_info )
972 {
973 req->handle = wine_server_obj_handle( handle );
974 if (!(status = wine_server_call( req ))) affinity.Mask = reply->affinity & affinity_mask;
975 }
976 SERVER_END_REQ;
977 if (status == STATUS_SUCCESS)
978 {
979 if (data) memcpy( data, &affinity, min( length, sizeof(affinity) ));
980 if (ret_len) *ret_len = min( length, sizeof(affinity) );
981 }
982 return status;
983 }
984
985 case ThreadIsIoPending:
986 FIXME( "ThreadIsIoPending info class not supported yet\n" );
987 if (length != sizeof(BOOL)) return STATUS_INFO_LENGTH_MISMATCH;
988 if (!data) return STATUS_ACCESS_DENIED;
989 *(BOOL*)data = FALSE;
990 if (ret_len) *ret_len = sizeof(BOOL);
991 return STATUS_SUCCESS;
992
993 case ThreadSuspendCount:
994 if (length != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
995 if (!data) return STATUS_ACCESS_VIOLATION;
996
997 SERVER_START_REQ( get_thread_info )
998 {
999 req->handle = wine_server_obj_handle( handle );
1000 if (!(status = wine_server_call( req ))) *(ULONG *)data = reply->suspend_count;
1001 }
1002 SERVER_END_REQ;
1003 return status;
1004
1005 case ThreadDescription:
1006 {
1007 THREAD_DESCRIPTION_INFORMATION *info = data;
1008 data_size_t len, desc_len = 0;
1009 WCHAR *ptr;
1010
1011 len = length >= sizeof(*info) ? length - sizeof(*info) : 0;
1012 ptr = info ? (WCHAR *)(info + 1) : NULL;
1013
1014 SERVER_START_REQ( get_thread_info )
1015 {
1016 req->handle = wine_server_obj_handle( handle );
1017 if (ptr) wine_server_set_reply( req, ptr, len );
1018 status = wine_server_call( req );
1019 desc_len = reply->desc_len;
1020 }
1021 SERVER_END_REQ;
1022
1023 if (!info) status = STATUS_BUFFER_TOO_SMALL;
1024 else if (status == STATUS_SUCCESS)
1025 {
1026 info->Description.Length = info->Description.MaximumLength = desc_len;
1027 info->Description.Buffer = ptr;
1028 }
1029
1030 if (ret_len && (status == STATUS_SUCCESS || status == STATUS_BUFFER_TOO_SMALL))
1031 *ret_len = sizeof(*info) + desc_len;
1032 return status;
1033 }
1034
1035 case ThreadWow64Context:
1036 {
1037 #ifdef __x86_64__
1038 BOOL self;
1039 WOW64_CONTEXT *context = data;
1040 context_t server_context;
1041 unsigned int server_flags;
1042
1043 if (length != sizeof(*context)) return STATUS_INFO_LENGTH_MISMATCH;
1044 server_flags = wow64_get_server_context_flags( context->ContextFlags );
1045 if ((status = get_thread_context( handle, &server_context, server_flags, &self ))) return status;
1046 if (self) return STATUS_INVALID_PARAMETER;
1047 status = wow64_context_from_server( context, &server_context );
1048 if (ret_len && !status) *ret_len = sizeof(*context);
1049 return status;
1050 #else
1051 return STATUS_INVALID_INFO_CLASS;
1052 #endif
1053 }
1054
1055 case ThreadHideFromDebugger:
1056 if (length != sizeof(BOOLEAN)) return STATUS_INFO_LENGTH_MISMATCH;
1057 if (!data) return STATUS_ACCESS_VIOLATION;
1058 SERVER_START_REQ( get_thread_info )
1059 {
1060 req->handle = wine_server_obj_handle( handle );
1061 req->access = THREAD_QUERY_INFORMATION;
1062 if ((status = wine_server_call( req ))) return status;
1063 *(BOOLEAN*)data = reply->dbg_hidden;
1064 }
1065 SERVER_END_REQ;
1066 if (ret_len) *ret_len = sizeof(BOOLEAN);
1067 return STATUS_SUCCESS;
1068
1069 case ThreadPriority:
1070 case ThreadBasePriority:
1071 case ThreadImpersonationToken:
1072 case ThreadEnableAlignmentFaultFixup:
1073 case ThreadEventPair_Reusable:
1074 case ThreadZeroTlsCell:
1075 case ThreadPerformanceCount:
1076 case ThreadIdealProcessor:
1077 case ThreadPriorityBoost:
1078 case ThreadSetTlsArrayAddress:
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 */
1089 NTSTATUS WINAPI NtSetInformationThread( HANDLE handle, THREADINFOCLASS class,
1090 const void *data, ULONG length )
1091 {
1092 NTSTATUS status;
1093
1094 TRACE("(%p,%d,%p,%x)\n", handle, class, data, length);
1095
1096 switch (class)
1097 {
1098 case ThreadZeroTlsCell:
1099 if (handle == GetCurrentThread())
1100 {
1101 if (length != sizeof(DWORD)) return STATUS_INVALID_PARAMETER;
1102 return virtual_clear_tls_index( *(const ULONG *)data );
1103 }
1104 FIXME( "ZeroTlsCell not supported on other threads\n" );
1105 return STATUS_NOT_IMPLEMENTED;
1106
1107 case ThreadImpersonationToken:
1108 {
1109 const HANDLE *token = data;
1110
1111 if (length != sizeof(HANDLE)) return STATUS_INVALID_PARAMETER;
1112 TRACE("Setting ThreadImpersonationToken handle to %p\n", *token );
1113 SERVER_START_REQ( set_thread_info )
1114 {
1115 req->handle = wine_server_obj_handle( handle );
1116 req->token = wine_server_obj_handle( *token );
1117 req->mask = SET_THREAD_INFO_TOKEN;
1118 status = wine_server_call( req );
1119 }
1120 SERVER_END_REQ;
1121 return status;
1122 }
1123
1124 case ThreadBasePriority:
1125 {
1126 const DWORD *pprio = data;
1127 if (length != sizeof(DWORD)) return STATUS_INVALID_PARAMETER;
1128 SERVER_START_REQ( set_thread_info )
1129 {
1130 req->handle = wine_server_obj_handle( handle );
1131 req->priority = *pprio;
1132 req->mask = SET_THREAD_INFO_PRIORITY;
1133 status = wine_server_call( req );
1134 }
1135 SERVER_END_REQ;
1136 return status;
1137 }
1138
1139 case ThreadAffinityMask:
1140 {
1141 const ULONG_PTR affinity_mask = get_system_affinity_mask();
1142 ULONG_PTR req_aff;
1143
1144 if (length != sizeof(ULONG_PTR)) return STATUS_INVALID_PARAMETER;
1145 req_aff = *(const ULONG_PTR *)data & affinity_mask;
1146 if (!req_aff) return STATUS_INVALID_PARAMETER;
1147
1148 SERVER_START_REQ( set_thread_info )
1149 {
1150 req->handle = wine_server_obj_handle( handle );
1151 req->affinity = req_aff;
1152 req->mask = SET_THREAD_INFO_AFFINITY;
1153 status = wine_server_call( req );
1154 }
1155 SERVER_END_REQ;
1156 return status;
1157 }
1158
1159 case ThreadHideFromDebugger:
1160 if (length) return STATUS_INFO_LENGTH_MISMATCH;
1161 SERVER_START_REQ( set_thread_info )
1162 {
1163 req->handle = wine_server_obj_handle( handle );
1164 req->mask = SET_THREAD_INFO_DBG_HIDDEN;
1165 status = wine_server_call( req );
1166 }
1167 SERVER_END_REQ;
1168 return status;
1169
1170 case ThreadQuerySetWin32StartAddress:
1171 {
1172 const PRTL_THREAD_START_ROUTINE *entry = data;
1173 if (length != sizeof(PRTL_THREAD_START_ROUTINE)) return STATUS_INVALID_PARAMETER;
1174 SERVER_START_REQ( set_thread_info )
1175 {
1176 req->handle = wine_server_obj_handle( handle );
1177 req->mask = SET_THREAD_INFO_ENTRYPOINT;
1178 req->entry_point = wine_server_client_ptr( *entry );
1179 status = wine_server_call( req );
1180 }
1181 SERVER_END_REQ;
1182 return status;
1183 }
1184
1185 case ThreadGroupInformation:
1186 {
1187 const ULONG_PTR affinity_mask = get_system_affinity_mask();
1188 const GROUP_AFFINITY *req_aff;
1189
1190 if (length != sizeof(*req_aff)) return STATUS_INVALID_PARAMETER;
1191 if (!data) return STATUS_ACCESS_VIOLATION;
1192 req_aff = data;
1193
1194 /* On Windows the request fails if the reserved fields are set */
1195 if (req_aff->Reserved[0] || req_aff->Reserved[1] || req_aff->Reserved[2])
1196 return STATUS_INVALID_PARAMETER;
1197
1198 /* Wine only supports max 64 processors */
1199 if (req_aff->Group) return STATUS_INVALID_PARAMETER;
1200 if (req_aff->Mask & ~affinity_mask) return STATUS_INVALID_PARAMETER;
1201 if (!req_aff->Mask) return STATUS_INVALID_PARAMETER;
1202 SERVER_START_REQ( set_thread_info )
1203 {
1204 req->handle = wine_server_obj_handle( handle );
1205 req->affinity = req_aff->Mask;
1206 req->mask = SET_THREAD_INFO_AFFINITY;
1207 status = wine_server_call( req );
1208 }
1209 SERVER_END_REQ;
1210 return status;
1211 }
1212
1213 case ThreadDescription:
1214 {
1215 const THREAD_DESCRIPTION_INFORMATION *info = data;
1216
1217 if (length != sizeof(*info)) return STATUS_INFO_LENGTH_MISMATCH;
1218 if (!info) return STATUS_ACCESS_VIOLATION;
1219 if (info->Description.Length != info->Description.MaximumLength) return STATUS_INVALID_PARAMETER;
1220 if (info->Description.Length && !info->Description.Buffer) return STATUS_ACCESS_VIOLATION;
1221
1222 SERVER_START_REQ( set_thread_info )
1223 {
1224 req->handle = wine_server_obj_handle( handle );
1225 req->mask = SET_THREAD_INFO_DESCRIPTION;
1226 wine_server_add_data( req, info->Description.Buffer, info->Description.Length );
1227 status = wine_server_call( req );
1228 }
1229 SERVER_END_REQ;
1230 return status;
1231 }
1232
1233 case ThreadWow64Context:
1234 {
1235 #ifdef __x86_64__
1236 BOOL self;
1237 const WOW64_CONTEXT *context = data;
1238 context_t server_context;
1239
1240 if (length != sizeof(*context)) return STATUS_INFO_LENGTH_MISMATCH;
1241 wow64_context_to_server( &server_context, context );
1242 return set_thread_context( handle, &server_context, &self );
1243 #else
1244 return STATUS_INVALID_INFO_CLASS;
1245 #endif
1246 }
1247
1248 case ThreadBasicInformation:
1249 case ThreadTimes:
1250 case ThreadPriority:
1251 case ThreadDescriptorTableEntry:
1252 case ThreadEnableAlignmentFaultFixup:
1253 case ThreadEventPair_Reusable:
1254 case ThreadPerformanceCount:
1255 case ThreadAmILastThread:
1256 case ThreadIdealProcessor:
1257 case ThreadPriorityBoost:
1258 case ThreadSetTlsArrayAddress:
1259 case ThreadIsIoPending:
1260 default:
1261 FIXME( "info class %d not supported yet\n", class );
1262 return STATUS_NOT_IMPLEMENTED;
1263 }
1264 }
1265
1266
1267 /******************************************************************************
1268 * NtGetCurrentProcessorNumber (NTDLL.@)
1269 */
1270 ULONG WINAPI NtGetCurrentProcessorNumber(void)
1271 {
1272 ULONG processor;
1273
1274 #if defined(__linux__) && defined(__NR_getcpu)
1275 int res = syscall(__NR_getcpu, &processor, NULL, NULL);
1276 if (res != -1) return processor;
1277 #endif
1278
1279 if (NtCurrentTeb()->Peb->NumberOfProcessors > 1)
1280 {
1281 ULONG_PTR thread_mask, processor_mask;
1282
1283 if (!NtQueryInformationThread( GetCurrentThread(), ThreadAffinityMask,
1284 &thread_mask, sizeof(thread_mask), NULL ))
1285 {
1286 for (processor = 0; processor < NtCurrentTeb()->Peb->NumberOfProcessors; processor++)
1287 {
1288 processor_mask = (1 << processor);
1289 if (thread_mask & processor_mask)
1290 {
1291 if (thread_mask != processor_mask)
1292 FIXME( "need multicore support (%d processors)\n",
1293 NtCurrentTeb()->Peb->NumberOfProcessors );
1294 return processor;
1295 }
1296 }
1297 }
1298 }
1299 /* fallback to the first processor */
1300 return 0;
1301 }
Windows API implementation