scheduler/thread.c

   1 /*
   2  * Win32 threads
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <fcntl.h>
   9 #include <sys/types.h>
  10 #include <sys/socket.h>
  11 #include <sys/mman.h>
  12 #include <unistd.h>
  13 #include "wine/winbase16.h"
  14 #include "thread.h"
  15 #include "process.h"
  16 #include "task.h"
  17 #include "module.h"
  18 #include "user.h"
  19 #include "winerror.h"
  20 #include "heap.h"
  21 #include "selectors.h"
  22 #include "winnt.h"
  23 #include "server.h"
  24 #include "services.h"
  25 #include "stackframe.h"
  26 #include "debugtools.h"
  27 #include "queue.h"
  28 #include "hook.h"
  29
  30 DEFAULT_DEBUG_CHANNEL(thread)
  31
  32 /* TEB of the initial thread */
  33 static TEB initial_teb;
  34
  35 /* Global thread list (FIXME: not thread-safe) */
  36 TEB *THREAD_First = &initial_teb;
  37
  38 /***********************************************************************
  39  *           THREAD_IsWin16
  40  */
  41 BOOL THREAD_IsWin16( TEB *teb )
  42 {
  43     return !teb || !(teb->flags & TEBF_WIN32);
  44 }
  45
  46 /***********************************************************************
  47  *           THREAD_IdToTEB
  48  *
  49  * Convert a thread id to a TEB, making sure it is valid.
  50  */
  51 TEB *THREAD_IdToTEB( DWORD id )
  52 {
  53     TEB *teb = THREAD_First;
  54
  55     if (!id) return NtCurrentTeb();
  56     while (teb)
  57     {
  58         if ((DWORD)teb->tid == id) return teb;
  59         teb = teb->next;
  60     }
  61     /* Allow task handles to be used; convert to main thread */
  62     if ( IsTask16( id ) )
  63     {
  64         TDB *pTask = (TDB *)GlobalLock16( id );
  65         if (pTask) return pTask->teb;
  66     }
  67     SetLastError( ERROR_INVALID_PARAMETER );
  68     return NULL;
  69 }
  70
  71
  72 /***********************************************************************
  73  *           THREAD_InitTEB
  74  *
  75  * Initialization of a newly created TEB.
  76  */
  77 static BOOL THREAD_InitTEB( TEB *teb, DWORD stack_size, BOOL alloc_stack16,
  78                             LPSECURITY_ATTRIBUTES sa )
  79 {
  80     DWORD old_prot;
  81
  82     /* Allocate the stack */
  83
  84     /* FIXME:
  85      * If stacksize smaller than 1 MB, allocate 1MB
  86      * (one program wanted only 10 kB, which is recommendable, but some WINE
  87      *  functions, noteably in the files subdir, push HUGE structures and
  88      *  arrays on the stack. They probably shouldn't.)
  89      * If stacksize larger than 16 MB, warn the user. (We could shrink the stack
  90      * but this could give more or less unexplainable crashes.)
  91      */
  92     if (stack_size<1024*1024)
  93         stack_size = 1024 * 1024;
  94     if (stack_size >= 16*1024*1024)
  95         WARN("Thread stack size is %ld MB.\n",stack_size/1024/1024);
  96     teb->stack_base = VirtualAlloc(NULL, stack_size + SIGNAL_STACK_SIZE +
  97                                    (alloc_stack16 ? 0x10000 : 0),
  98                                    MEM_COMMIT, PAGE_EXECUTE_READWRITE );
  99     if (!teb->stack_base) goto error;
 100     /* Set a guard page at the bottom of the stack */
 101     VirtualProtect( teb->stack_base, 1, PAGE_EXECUTE_READWRITE | PAGE_GUARD, &old_prot );
 102     teb->stack_top    = (char *)teb->stack_base + stack_size;
 103     teb->stack_low    = teb->stack_base;
 104     teb->signal_stack = teb->stack_top;  /* start of signal stack */
 105
 106     /* Allocate the 16-bit stack selector */
 107
 108     if (alloc_stack16)
 109     {
 110         teb->stack_sel = SELECTOR_AllocBlock( teb->stack_top, 0x10000, SEGMENT_DATA,
 111                                               FALSE, FALSE );
 112         if (!teb->stack_sel) goto error;
 113         teb->cur_stack = PTR_SEG_OFF_TO_SEGPTR( teb->stack_sel,
 114                                                 0x10000 - sizeof(STACK16FRAME) );
 115         teb->signal_stack = (char *)teb->signal_stack + 0x10000;
 116     }
 117
 118     /* Create the thread event */
 119
 120     if (!(teb->event = CreateEventA( NULL, FALSE, FALSE, NULL ))) goto error;
 121     teb->event = ConvertToGlobalHandle( teb->event );
 122     return TRUE;
 123
 124 error:
 125     if (teb->event) CloseHandle( teb->event );
 126     if (teb->stack_sel) SELECTOR_FreeBlock( teb->stack_sel, 1 );
 127     if (teb->stack_base) VirtualFree( teb->stack_base, 0, MEM_RELEASE );
 128     return FALSE;
 129 }
 130
 131
 132 /***********************************************************************
 133  *           THREAD_FreeTEB
 134  *
 135  * Free data structures associated with a thread.
 136  * Must be called from the context of another thread.
 137  */
 138 void CALLBACK THREAD_FreeTEB( ULONG_PTR arg )
 139 {
 140     TEB *teb = (TEB *)arg;
 141     TEB **pptr = &THREAD_First;
 142
 143     TRACE("(%p) called\n", teb );
 144     SERVICE_Delete( teb->cleanup );
 145
 146     PROCESS_CallUserSignalProc( USIG_THREAD_EXIT, 0 );
 147
 148     CloseHandle( teb->event );
 149     while (*pptr && (*pptr != teb)) pptr = &(*pptr)->next;
 150     if (*pptr) *pptr = teb->next;
 151
 152     /* Free the associated memory */
 153
 154     if (teb->stack_sel) SELECTOR_FreeBlock( teb->stack_sel, 1 );
 155     SELECTOR_FreeBlock( teb->teb_sel, 1 );
 156     close( teb->socket );
 157     if (teb->buffer) munmap( teb->buffer, teb->buffer_size );
 158     VirtualFree( teb->stack_base, 0, MEM_RELEASE );
 159     HeapFree( SystemHeap, 0, teb );
 160 }
 161
 162
 163 /***********************************************************************
 164  *           THREAD_CreateInitialThread
 165  *
 166  * Create the initial thread.
 167  */
 168 TEB *THREAD_CreateInitialThread( PDB *pdb, int server_fd )
 169 {
 170     initial_teb.except      = (void *)-1;
 171     initial_teb.self        = &initial_teb;
 172     initial_teb.flags       = /* TEBF_WIN32 */ 0;
 173     initial_teb.tls_ptr     = initial_teb.tls_array;
 174     initial_teb.process     = pdb;
 175     initial_teb.exit_code   = 0x103; /* STILL_ACTIVE */
 176     initial_teb.socket      = server_fd;
 177
 178     /* Allocate the TEB selector (%fs register) */
 179
 180     if (!(initial_teb.teb_sel = SELECTOR_AllocBlock( &initial_teb, 0x1000,
 181                                                      SEGMENT_DATA, TRUE, FALSE )))
 182     {
 183         MESSAGE("Could not allocate fs register for initial thread\n" );
 184         return NULL;
 185     }
 186     SYSDEPS_SetCurThread( &initial_teb );
 187
 188     /* Now proceed with normal initialization */
 189
 190     if (CLIENT_InitThread()) return NULL;
 191     if (!THREAD_InitTEB( &initial_teb, 0, TRUE, NULL )) return NULL;
 192     return &initial_teb;
 193 }
 194
 195
 196 /***********************************************************************
 197  *           THREAD_Create
 198  */
 199 TEB *THREAD_Create( PDB *pdb, DWORD flags, DWORD stack_size, BOOL alloc_stack16,
 200                      LPSECURITY_ATTRIBUTES sa, int *server_handle )
 201 {
 202     struct new_thread_request *req = get_req_buffer();
 203     int fd[2];
 204     HANDLE cleanup_object;
 205
 206     TEB *teb = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(TEB) );
 207     if (!teb) return NULL;
 208     teb->except      = (void *)-1;
 209     teb->htask16     = pdb->task;
 210     teb->self        = teb;
 211     teb->flags       = (pdb->flags & PDB32_WIN16_PROC)? 0 : TEBF_WIN32;
 212     teb->tls_ptr     = teb->tls_array;
 213     teb->process     = pdb;
 214     teb->exit_code   = 0x103; /* STILL_ACTIVE */
 215     teb->socket      = -1;
 216
 217     /* Allocate the TEB selector (%fs register) */
 218
 219     *server_handle = -1;
 220     teb->teb_sel = SELECTOR_AllocBlock( teb, 0x1000, SEGMENT_DATA, TRUE, FALSE );
 221     if (!teb->teb_sel) goto error;
 222
 223     /* Create the socket pair for server communication */
 224
 225     if (socketpair( AF_UNIX, SOCK_STREAM, 0, fd ) == -1)
 226     {
 227         SetLastError( ERROR_TOO_MANY_OPEN_FILES );  /* FIXME */
 228         goto error;
 229     }
 230     teb->socket = fd[0];
 231     fcntl( fd[0], F_SETFD, 1 ); /* set close on exec flag */
 232
 233     /* Create the thread on the server side */
 234
 235     req->pid     = teb->process->server_pid;
 236     req->suspend = ((flags & CREATE_SUSPENDED) != 0);
 237     req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 238     if (server_call_fd( REQ_NEW_THREAD, fd[1], NULL )) goto error;
 239     teb->tid = req->tid;
 240     *server_handle = req->handle;
 241
 242     /* Do the rest of the initialization */
 243
 244     if (!THREAD_InitTEB( teb, stack_size, alloc_stack16, sa )) goto error;
 245     teb->next = THREAD_First;
 246     THREAD_First = teb;
 247
 248     /* Install cleanup handler */
 249     if ( !DuplicateHandle( GetCurrentProcess(), *server_handle,
 250                            GetCurrentProcess(), &cleanup_object,
 251                            0, FALSE, DUPLICATE_SAME_ACCESS ) ) goto error;
 252     teb->cleanup = SERVICE_AddObject( cleanup_object, THREAD_FreeTEB, (ULONG_PTR)teb );
 253
 254     return teb;
 255
 256 error:
 257     if (*server_handle != -1) CloseHandle( *server_handle );
 258     if (teb->teb_sel) SELECTOR_FreeBlock( teb->teb_sel, 1 );
 259     if (teb->socket != -1) close( teb->socket );
 260     HeapFree( SystemHeap, 0, teb );
 261     return NULL;
 262 }
 263
 264
 265 /***********************************************************************
 266  *           THREAD_Start
 267  *
 268  * Start execution of a newly created thread. Does not return.
 269  */
 270 static void THREAD_Start(void)
 271 {
 272     LPTHREAD_START_ROUTINE func = (LPTHREAD_START_ROUTINE)NtCurrentTeb()->entry_point;
 273     PROCESS_CallUserSignalProc( USIG_THREAD_INIT, 0 );
 274     PE_InitTls();
 275     MODULE_DllThreadAttach( NULL );
 276
 277     if (NtCurrentTeb()->process->flags & PDB32_DEBUGGED) DEBUG_SendCreateThreadEvent( func );
 278
 279     ExitThread( func( NtCurrentTeb()->entry_arg ) );
 280 }
 281
 282
 283 /***********************************************************************
 284  *           CreateThread   (KERNEL32.63)
 285  */
 286 HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
 287                             LPTHREAD_START_ROUTINE start, LPVOID param,
 288                             DWORD flags, LPDWORD id )
 289 {
 290     int handle = -1;
 291     TEB *teb = THREAD_Create( PROCESS_Current(), flags, stack, TRUE, sa, &handle );
 292     if (!teb) return 0;
 293     teb->flags      |= TEBF_WIN32;
 294     teb->entry_point = start;
 295     teb->entry_arg   = param;
 296     teb->startup     = THREAD_Start;
 297     if (SYSDEPS_SpawnThread( teb ) == -1)
 298     {
 299         CloseHandle( handle );
 300         return 0;
 301     }
 302     if (id) *id = (DWORD)teb->tid;
 303     return handle;
 304 }
 305
 306
 307 /***********************************************************************
 308  * ExitThread [KERNEL32.215]  Ends a thread
 309  *
 310  * RETURNS
 311  *    None
 312  */
 313 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
 314 {
 315     MODULE_DllThreadDetach( NULL );
 316     TerminateThread( GetCurrentThread(), code );
 317 }
 318
 319
 320 /***********************************************************************
 321  * GetCurrentThread [KERNEL32.200]  Gets pseudohandle for current thread
 322  *
 323  * RETURNS
 324  *    Pseudohandle for the current thread
 325  */
 326 HANDLE WINAPI GetCurrentThread(void)
 327 {
 328     return CURRENT_THREAD_PSEUDOHANDLE;
 329 }
 330
 331
 332 /**********************************************************************
 333  * GetLastError [KERNEL.148] [KERNEL32.227]  Returns last-error code.
 334  *
 335  * RETURNS
 336  *     Calling thread's last error code value.
 337  */
 338 DWORD WINAPI GetLastError(void)
 339 {
 340     return NtCurrentTeb()->last_error;
 341 }
 342
 343
 344 /**********************************************************************
 345  * SetLastErrorEx [USER32.485]  Sets the last-error code.
 346  *
 347  * RETURNS
 348  *    None.
 349  */
 350 void WINAPI SetLastErrorEx(
 351     DWORD error, /* [in] Per-thread error code */
 352     DWORD type)  /* [in] Error type */
 353 {
 354     TRACE("(0x%08lx, 0x%08lx)\n", error,type);
 355     switch(type) {
 356         case 0:
 357             break;
 358         case SLE_ERROR:
 359         case SLE_MINORERROR:
 360         case SLE_WARNING:
 361             /* Fall through for now */
 362         default:
 363             FIXME("(error=%08lx, type=%08lx): Unhandled type\n", error,type);
 364             break;
 365     }
 366     SetLastError( error );
 367 }
 368
 369
 370 /**********************************************************************
 371  * TlsAlloc [KERNEL32.530]  Allocates a TLS index.
 372  *
 373  * Allocates a thread local storage index
 374  *
 375  * RETURNS
 376  *    Success: TLS Index
 377  *    Failure: 0xFFFFFFFF
 378  */
 379 DWORD WINAPI TlsAlloc( void )
 380 {
 381     PDB *process = PROCESS_Current();
 382     DWORD i, mask, ret = 0;
 383     DWORD *bits = process->tls_bits;
 384     EnterCriticalSection( &process->crit_section );
 385     if (*bits == 0xffffffff)
 386     {
 387         bits++;
 388         ret = 32;
 389         if (*bits == 0xffffffff)
 390         {
 391             LeaveCriticalSection( &process->crit_section );
 392             SetLastError( ERROR_NO_MORE_ITEMS );
 393             return 0xffffffff;
 394         }
 395     }
 396     for (i = 0, mask = 1; i < 32; i++, mask <<= 1) if (!(*bits & mask)) break;
 397     *bits |= mask;
 398     LeaveCriticalSection( &process->crit_section );
 399     return ret + i;
 400 }
 401
 402
 403 /**********************************************************************
 404  * TlsFree [KERNEL32.531]  Releases a TLS index.
 405  *
 406  * Releases a thread local storage index, making it available for reuse
 407  *
 408  * RETURNS
 409  *    Success: TRUE
 410  *    Failure: FALSE
 411  */
 412 BOOL WINAPI TlsFree(
 413     DWORD index) /* [in] TLS Index to free */
 414 {
 415     PDB *process = PROCESS_Current();
 416     DWORD mask;
 417     DWORD *bits = process->tls_bits;
 418     if (index >= 64)
 419     {
 420         SetLastError( ERROR_INVALID_PARAMETER );
 421         return FALSE;
 422     }
 423     EnterCriticalSection( &process->crit_section );
 424     if (index >= 32) bits++;
 425     mask = (1 << (index & 31));
 426     if (!(*bits & mask))  /* already free? */
 427     {
 428         LeaveCriticalSection( &process->crit_section );
 429         SetLastError( ERROR_INVALID_PARAMETER );
 430         return FALSE;
 431     }
 432     *bits &= ~mask;
 433     NtCurrentTeb()->tls_array[index] = 0;
 434     /* FIXME: should zero all other thread values */
 435     LeaveCriticalSection( &process->crit_section );
 436     return TRUE;
 437 }
 438
 439
 440 /**********************************************************************
 441  * TlsGetValue [KERNEL32.532]  Gets value in a thread's TLS slot
 442  *
 443  * RETURNS
 444  *    Success: Value stored in calling thread's TLS slot for index
 445  *    Failure: 0 and GetLastError returns NO_ERROR
 446  */
 447 LPVOID WINAPI TlsGetValue(
 448     DWORD index) /* [in] TLS index to retrieve value for */
 449 {
 450     if (index >= 64)
 451     {
 452         SetLastError( ERROR_INVALID_PARAMETER );
 453         return NULL;
 454     }
 455     SetLastError( ERROR_SUCCESS );
 456     return NtCurrentTeb()->tls_array[index];
 457 }
 458
 459
 460 /**********************************************************************
 461  * TlsSetValue [KERNEL32.533]  Stores a value in the thread's TLS slot.
 462  *
 463  * RETURNS
 464  *    Success: TRUE
 465  *    Failure: FALSE
 466  */
 467 BOOL WINAPI TlsSetValue(
 468     DWORD index,  /* [in] TLS index to set value for */
 469     LPVOID value) /* [in] Value to be stored */
 470 {
 471     if (index >= 64)
 472     {
 473         SetLastError( ERROR_INVALID_PARAMETER );
 474         return FALSE;
 475     }
 476     NtCurrentTeb()->tls_array[index] = value;
 477     return TRUE;
 478 }
 479
 480
 481 /***********************************************************************
 482  * SetThreadContext [KERNEL32.670]  Sets context of thread.
 483  *
 484  * RETURNS
 485  *    Success: TRUE
 486  *    Failure: FALSE
 487  */
 488 BOOL WINAPI SetThreadContext(
 489     HANDLE handle,  /* [in]  Handle to thread with context */
 490     CONTEXT *context) /* [out] Address of context structure */
 491 {
 492     FIXME("not implemented\n" );
 493     return TRUE;
 494 }
 495
 496 /***********************************************************************
 497  * GetThreadContext [KERNEL32.294]  Retrieves context of thread.
 498  *
 499  * RETURNS
 500  *    Success: TRUE
 501  *    Failure: FALSE
 502  */
 503 BOOL WINAPI GetThreadContext(
 504     HANDLE handle,  /* [in]  Handle to thread with context */
 505     CONTEXT *context) /* [out] Address of context structure */
 506 {
 507 #ifdef __i386__
 508     WORD cs, ds;
 509
 510     FIXME("returning dummy info\n" );
 511
 512     /* make up some plausible values for segment registers */
 513     GET_CS(cs);
 514     GET_DS(ds);
 515     context->SegCs   = cs;
 516     context->SegDs   = ds;
 517     context->SegEs   = ds;
 518     context->SegGs   = ds;
 519     context->SegSs   = ds;
 520     context->SegFs   = ds;
 521 #endif
 522     return TRUE;
 523 }
 524
 525
 526 /**********************************************************************
 527  * GetThreadPriority [KERNEL32.296]  Returns priority for thread.
 528  *
 529  * RETURNS
 530  *    Success: Thread's priority level.
 531  *    Failure: THREAD_PRIORITY_ERROR_RETURN
 532  */
 533 INT WINAPI GetThreadPriority(
 534     HANDLE hthread) /* [in] Handle to thread */
 535 {
 536     INT ret = THREAD_PRIORITY_ERROR_RETURN;
 537     struct get_thread_info_request *req = get_req_buffer();
 538     req->handle = hthread;
 539     if (!server_call( REQ_GET_THREAD_INFO )) ret = req->priority;
 540     return ret;
 541 }
 542
 543
 544 /**********************************************************************
 545  * SetThreadPriority [KERNEL32.514]  Sets priority for thread.
 546  *
 547  * RETURNS
 548  *    Success: TRUE
 549  *    Failure: FALSE
 550  */
 551 BOOL WINAPI SetThreadPriority(
 552     HANDLE hthread, /* [in] Handle to thread */
 553     INT priority)   /* [in] Thread priority level */
 554 {
 555     struct set_thread_info_request *req = get_req_buffer();
 556     req->handle   = hthread;
 557     req->priority = priority;
 558     req->mask     = SET_THREAD_INFO_PRIORITY;
 559     return !server_call( REQ_SET_THREAD_INFO );
 560 }
 561
 562
 563 /**********************************************************************
 564  *           SetThreadAffinityMask   (KERNEL32.669)
 565  */
 566 DWORD WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD dwThreadAffinityMask )
 567 {
 568     struct set_thread_info_request *req = get_req_buffer();
 569     req->handle   = hThread;
 570     req->affinity = dwThreadAffinityMask;
 571     req->mask     = SET_THREAD_INFO_AFFINITY;
 572     if (server_call( REQ_SET_THREAD_INFO )) return 0;
 573     return 1;  /* FIXME: should return previous value */
 574 }
 575
 576
 577 /**********************************************************************
 578  * TerminateThread [KERNEL32.685]  Terminates a thread
 579  *
 580  * RETURNS
 581  *    Success: TRUE
 582  *    Failure: FALSE
 583  */
 584 BOOL WINAPI TerminateThread(
 585     HANDLE handle, /* [in] Handle to thread */
 586     DWORD exitcode)  /* [in] Exit code for thread */
 587 {
 588     struct terminate_thread_request *req = get_req_buffer();
 589     req->handle    = handle;
 590     req->exit_code = exitcode;
 591     return !server_call( REQ_TERMINATE_THREAD );
 592 }
 593
 594
 595 /**********************************************************************
 596  * GetExitCodeThread [KERNEL32.???]  Gets termination status of thread.
 597  *
 598  * RETURNS
 599  *    Success: TRUE
 600  *    Failure: FALSE
 601  */
 602 BOOL WINAPI GetExitCodeThread(
 603     HANDLE hthread, /* [in]  Handle to thread */
 604     LPDWORD exitcode) /* [out] Address to receive termination status */
 605 {
 606     BOOL ret = FALSE;
 607     struct get_thread_info_request *req = get_req_buffer();
 608     req->handle = hthread;
 609     if (!server_call( REQ_GET_THREAD_INFO ))
 610     {
 611         if (exitcode) *exitcode = req->exit_code;
 612         ret = TRUE;
 613     }
 614     return ret;
 615 }
 616
 617
 618 /**********************************************************************
 619  * ResumeThread [KERNEL32.587]  Resumes a thread.
 620  *
 621  * Decrements a thread's suspend count.  When count is zero, the
 622  * execution of the thread is resumed.
 623  *
 624  * RETURNS
 625  *    Success: Previous suspend count
 626  *    Failure: 0xFFFFFFFF
 627  *    Already running: 0
 628  */
 629 DWORD WINAPI ResumeThread(
 630     HANDLE hthread) /* [in] Identifies thread to restart */
 631 {
 632     DWORD ret = 0xffffffff;
 633     struct resume_thread_request *req = get_req_buffer();
 634     req->handle = hthread;
 635     if (!server_call( REQ_RESUME_THREAD )) ret = req->count;
 636     return ret;
 637 }
 638
 639
 640 /**********************************************************************
 641  * SuspendThread [KERNEL32.681]  Suspends a thread.
 642  *
 643  * RETURNS
 644  *    Success: Previous suspend count
 645  *    Failure: 0xFFFFFFFF
 646  */
 647 DWORD WINAPI SuspendThread(
 648     HANDLE hthread) /* [in] Handle to the thread */
 649 {
 650     DWORD ret = 0xffffffff;
 651     struct suspend_thread_request *req = get_req_buffer();
 652     req->handle = hthread;
 653     if (!server_call( REQ_SUSPEND_THREAD )) ret = req->count;
 654     return ret;
 655 }
 656
 657
 658 /***********************************************************************
 659  *              QueueUserAPC  (KERNEL32.566)
 660  */
 661 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
 662 {
 663     struct queue_apc_request *req = get_req_buffer();
 664     req->handle = hthread;
 665     req->func   = func;
 666     req->param  = (void *)data;
 667     return !server_call( REQ_QUEUE_APC );
 668 }
 669
 670
 671 /**********************************************************************
 672  * GetThreadTimes [KERNEL32.???]  Obtains timing information.
 673  *
 674  * NOTES
 675  *    What are the fields where these values are stored?
 676  *
 677  * RETURNS
 678  *    Success: TRUE
 679  *    Failure: FALSE
 680  */
 681 BOOL WINAPI GetThreadTimes(
 682     HANDLE thread,         /* [in]  Specifies the thread of interest */
 683     LPFILETIME creationtime, /* [out] When the thread was created */
 684     LPFILETIME exittime,     /* [out] When the thread was destroyed */
 685     LPFILETIME kerneltime,   /* [out] Time thread spent in kernel mode */
 686     LPFILETIME usertime)     /* [out] Time thread spent in user mode */
 687 {
 688     FIXME("(0x%08x): stub\n",thread);
 689     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 690     return FALSE;
 691 }
 692
 693
 694 /**********************************************************************
 695  * AttachThreadInput [KERNEL32.8]  Attaches input of 1 thread to other
 696  *
 697  * Attaches the input processing mechanism of one thread to that of
 698  * another thread.
 699  *
 700  * RETURNS
 701  *    Success: TRUE
 702  *    Failure: FALSE
 703  *
 704  * TODO:
 705  *    1. Reset the Key State (currenly per thread key state is not maintained)
 706  */
 707 BOOL WINAPI AttachThreadInput(
 708     DWORD idAttach,   /* [in] Thread to attach */
 709     DWORD idAttachTo, /* [in] Thread to attach to */
 710     BOOL fAttach)   /* [in] Attach or detach */
 711 {
 712     MESSAGEQUEUE *pSrcMsgQ = 0, *pTgtMsgQ = 0;
 713     BOOL16 bRet = 0;
 714
 715     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 716
 717     /* A thread cannot attach to itself */
 718     if ( idAttach == idAttachTo )
 719         goto CLEANUP;
 720
 721     /* According to the docs this method should fail if a
 722      * "Journal record" hook is installed. (attaches all input queues together)
 723      */
 724     if ( HOOK_IsHooked( WH_JOURNALRECORD ) )
 725         goto CLEANUP;
 726
 727     /* Retrieve message queues corresponding to the thread id's */
 728     pTgtMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( GetThreadQueue16( idAttach ) );
 729     pSrcMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( GetThreadQueue16( idAttachTo ) );
 730
 731     /* Ensure we have message queues and that Src and Tgt threads
 732      * are not system threads.
 733      */
 734     if ( !pSrcMsgQ || !pTgtMsgQ || !pSrcMsgQ->pQData || !pTgtMsgQ->pQData )
 735         goto CLEANUP;
 736
 737     if (fAttach)   /* Attach threads */
 738     {
 739         /* Only attach if currently detached  */
 740         if ( pTgtMsgQ->pQData != pSrcMsgQ->pQData )
 741         {
 742             /* First release the target threads perQData */
 743             PERQDATA_Release( pTgtMsgQ->pQData );
 744
 745             /* Share a reference to the source threads perQDATA */
 746             PERQDATA_Addref( pSrcMsgQ->pQData );
 747             pTgtMsgQ->pQData = pSrcMsgQ->pQData;
 748         }
 749     }
 750     else    /* Detach threads */
 751     {
 752         /* Only detach if currently attached */
 753         if ( pTgtMsgQ->pQData == pSrcMsgQ->pQData )
 754         {
 755             /* First release the target threads perQData */
 756             PERQDATA_Release( pTgtMsgQ->pQData );
 757
 758             /* Give the target thread its own private perQDATA once more */
 759             pTgtMsgQ->pQData = PERQDATA_CreateInstance();
 760         }
 761     }
 762
 763     /* TODO: Reset the Key State */
 764
 765     bRet = 1;      /* Success */
 766
 767 CLEANUP:
 768
 769     /* Unlock the queues before returning */
 770     if ( pSrcMsgQ )
 771         QUEUE_Unlock( pSrcMsgQ );
 772     if ( pTgtMsgQ )
 773         QUEUE_Unlock( pTgtMsgQ );
 774
 775     return bRet;
 776 }
 777
 778 /**********************************************************************
 779  * VWin32_BoostThreadGroup [KERNEL.535]
 780  */
 781 VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
 782 {
 783     FIXME("(0x%08lx,%d): stub\n", threadId, boost);
 784 }
 785
 786 /**********************************************************************
 787  * VWin32_BoostThreadStatic [KERNEL.536]
 788  */
 789 VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT boost )
 790 {
 791     FIXME("(0x%08lx,%d): stub\n", threadId, boost);
 792 }
 793
 794 /**********************************************************************
 795  * SetThreadLocale [KERNEL32.671]  Sets the calling threads current locale.
 796  *
 797  * RETURNS
 798  *    Success: TRUE
 799  *    Failure: FALSE
 800  *
 801  * NOTES
 802  *  Implemented in NT only (3.1 and above according to MS
 803  */
 804 BOOL WINAPI SetThreadLocale(
 805     LCID lcid)     /* [in] Locale identifier */
 806 {
 807     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 808     return FALSE;
 809 }
 810
 811
 812 /**********************************************************************
 813  * SetLastError [KERNEL.147] [KERNEL32.497]  Sets the last-error code.
 814  *
 815  * RETURNS
 816  *    None.
 817  */
 818 #undef SetLastError
 819 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
 820 {
 821     NtCurrentTeb()->last_error = error;
 822 }
 823
 824
 825 /***********************************************************************
 826  * GetCurrentThreadId [KERNEL32.201]  Returns thread identifier.
 827  *
 828  * RETURNS
 829  *    Thread identifier of calling thread
 830  */
 831 #undef GetCurrentThreadId
 832 DWORD WINAPI GetCurrentThreadId(void)
 833 {
 834     return (DWORD)NtCurrentTeb()->tid;
 835 }