scheduler/thread.c

   1 /*
   2  * Win32 threads
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <signal.h>
   9 #include <unistd.h>
  10 #include "thread.h"
  11 #include "process.h"
  12 #include "task.h"
  13 #include "module.h"
  14 #include "user.h"
  15 #include "winerror.h"
  16 #include "heap.h"
  17 #include "selectors.h"
  18 #include "miscemu.h"
  19 #include "winnt.h"
  20 #include "server.h"
  21 #include "stackframe.h"
  22 #include "debug.h"
  23
  24 #ifndef __i386__
  25 THDB *pCurrentThread;
  26 #endif
  27
  28 static void THREAD_Destroy( K32OBJ *obj );
  29
  30 const K32OBJ_OPS THREAD_Ops =
  31 {
  32     THREAD_Destroy      /* destroy */
  33 };
  34
  35 /* Is threading code initialized? */
  36 BOOL32 THREAD_InitDone = FALSE;
  37
  38 /**********************************************************************
  39  *           THREAD_GetPtr
  40  *
  41  * Return a pointer to a thread object. The object count must be decremented
  42  * when no longer used.
  43  */
  44 THDB *THREAD_GetPtr( HANDLE32 handle, DWORD access, int *server_handle )
  45 {
  46     return (THDB *)HANDLE_GetObjPtr( PROCESS_Current(), handle,
  47                                     K32OBJ_THREAD, access, server_handle );
  48 }
  49
  50
  51 /***********************************************************************
  52  *           THREAD_Current
  53  *
  54  * Return the current thread THDB pointer.
  55  */
  56 THDB *THREAD_Current(void)
  57 {
  58     if (!THREAD_InitDone) return NULL;
  59     return (THDB *)((char *)NtCurrentTeb() - (int)&((THDB *)0)->teb);
  60 }
  61
  62 /***********************************************************************
  63  *           THREAD_IsWin16
  64  */
  65 BOOL32 THREAD_IsWin16( THDB *thdb )
  66 {
  67     if (!thdb || !thdb->process)
  68         return TRUE;
  69     else
  70     {
  71         TDB* pTask = (TDB*)GlobalLock16( thdb->process->task );
  72         return !pTask || pTask->thdb == thdb;
  73     }
  74 }
  75
  76 /***********************************************************************
  77  *           THREAD_IdToTHDB
  78  *
  79  * Convert a thread id to a THDB, making sure it is valid.
  80  */
  81 THDB *THREAD_IdToTHDB( DWORD id )
  82 {
  83     THDB *thdb;
  84
  85     if (!id) return THREAD_Current();
  86     thdb = THREAD_ID_TO_THDB( id );
  87     if (!K32OBJ_IsValid( &thdb->header, K32OBJ_THREAD ))
  88     {
  89         /* Allow task handles to be used; convert to main thread */
  90         if ( IsTask( id ) )
  91         {
  92             TDB *pTask = (TDB *)GlobalLock16( id );
  93             if (pTask) return pTask->thdb;
  94         }
  95
  96         SetLastError( ERROR_INVALID_PARAMETER );
  97         return NULL;
  98     }
  99     return thdb;
 100 }
 101
 102
 103 /***********************************************************************
 104  *           THREAD_AddQueue
 105  *
 106  * Add a thread to a queue.
 107  */
 108 void THREAD_AddQueue( THREAD_QUEUE *queue, THDB *thread )
 109 {
 110     THREAD_ENTRY *entry = HeapAlloc( SystemHeap, HEAP_NO_SERIALIZE,
 111                                      sizeof(*entry) );
 112     assert(entry);
 113     SYSTEM_LOCK();
 114     entry->thread = thread;
 115     if (*queue)
 116     {
 117         entry->next = (*queue)->next;
 118         (*queue)->next = entry;
 119     }
 120     else entry->next = entry;
 121     *queue = entry;
 122     SYSTEM_UNLOCK();
 123 }
 124
 125 /***********************************************************************
 126  *           THREAD_RemoveQueue
 127  *
 128  * Remove a thread from a queue.
 129  */
 130 void THREAD_RemoveQueue( THREAD_QUEUE *queue, THDB *thread )
 131 {
 132     THREAD_ENTRY *entry = *queue;
 133     SYSTEM_LOCK();
 134     if (entry->next == entry)  /* Only one element in the queue */
 135     {
 136         assert( entry->thread == thread );
 137         *queue = NULL;
 138     }
 139     else
 140     {
 141         THREAD_ENTRY *next;
 142         while (entry->next->thread != thread)
 143         {
 144             entry = entry->next;
 145             assert( entry != *queue );  /* Have we come all the way around? */
 146         }
 147         if ((next = entry->next) == *queue) *queue = entry;
 148         entry->next = entry->next->next;
 149         entry = next;  /* This is the one we want to free */
 150     }
 151     HeapFree( SystemHeap, 0, entry );
 152     SYSTEM_UNLOCK();
 153 }
 154
 155
 156 /***********************************************************************
 157  *           THREAD_Create
 158  */
 159 THDB *THREAD_Create( PDB32 *pdb, DWORD stack_size, BOOL32 alloc_stack16,
 160                      int *server_thandle, int *server_phandle,
 161                      LPTHREAD_START_ROUTINE start_addr, LPVOID param )
 162 {
 163     DWORD old_prot;
 164     WORD cs, ds;
 165
 166     THDB *thdb = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(THDB) );
 167     if (!thdb) return NULL;
 168     thdb->header.type     = K32OBJ_THREAD;
 169     thdb->header.refcount = 1;
 170     thdb->process         = pdb;
 171     thdb->teb.except      = (void *)-1;
 172     thdb->teb.htask16     = 0; /* FIXME */
 173     thdb->teb.self        = &thdb->teb;
 174     thdb->teb.flags       = (pdb->flags & PDB32_WIN16_PROC)? 0 : TEBF_WIN32;
 175     thdb->teb.tls_ptr     = thdb->tls_array;
 176     thdb->teb.process     = pdb;
 177     thdb->wait_list       = &thdb->wait_struct;
 178     thdb->exit_code       = 0x103; /* STILL_ACTIVE */
 179     thdb->entry_point     = start_addr;
 180     thdb->entry_arg       = param;
 181     thdb->socket          = -1;
 182
 183     /* Allocate the stack */
 184
 185     /* FIXME:
 186      * If stacksize smaller than 1 MB, allocate 1MB
 187      * (one program wanted only 10 kB, which is recommendable, but some WINE
 188      *  functions, noteably in the files subdir, push HUGE structures and
 189      *  arrays on the stack. They probably shouldn't.)
 190      * If stacksize larger than 16 MB, warn the user. (We could shrink the stack
 191      * but this could give more or less unexplainable crashes.)
 192      */
 193     if (stack_size<1024*1024)
 194         stack_size = 1024 * 1024;
 195     if (stack_size >= 16*1024*1024)
 196         WARN(thread,"Thread stack size is %ld MB.\n",stack_size/1024/1024);
 197     thdb->stack_base = VirtualAlloc(NULL,
 198                                     stack_size + (alloc_stack16 ? 0x10000 : 0),
 199                                     MEM_COMMIT, PAGE_EXECUTE_READWRITE );
 200     if (!thdb->stack_base) goto error;
 201     /* Set a guard page at the bottom of the stack */
 202     VirtualProtect( thdb->stack_base, 1, PAGE_EXECUTE_READWRITE | PAGE_GUARD,
 203                     &old_prot );
 204     thdb->teb.stack_top   = (char *)thdb->stack_base + stack_size;
 205     thdb->teb.stack_low   = thdb->stack_base;
 206     thdb->exit_stack      = thdb->teb.stack_top;
 207
 208     /* Allocate the TEB selector (%fs register) */
 209
 210     thdb->teb_sel = SELECTOR_AllocBlock( &thdb->teb, 0x1000, SEGMENT_DATA,
 211                                          TRUE, FALSE );
 212     if (!thdb->teb_sel) goto error;
 213
 214     /* Allocate the 16-bit stack selector */
 215
 216     if (alloc_stack16)
 217     {
 218         thdb->teb.stack_sel = SELECTOR_AllocBlock( thdb->teb.stack_top,
 219                                                    0x10000, SEGMENT_DATA,
 220                                                    FALSE, FALSE );
 221         if (!thdb->teb.stack_sel) goto error;
 222         thdb->cur_stack = PTR_SEG_OFF_TO_SEGPTR( thdb->teb.stack_sel,
 223                                                  0x10000 - sizeof(STACK16FRAME) );
 224     }
 225
 226     /* Create the thread socket */
 227
 228     if (CLIENT_NewThread( thdb, server_thandle, server_phandle )) goto error;
 229
 230     /* Add thread to process's list of threads */
 231
 232     THREAD_AddQueue( &pdb->thread_list, thdb );
 233
 234     /* Create the thread event */
 235
 236     if (!(thdb->event = CreateEvent32A( NULL, FALSE, FALSE, NULL ))) goto error;
 237     thdb->event = ConvertToGlobalHandle( thdb->event );
 238
 239     /* Initialize the thread context */
 240
 241     GET_CS(cs);
 242     GET_DS(ds);
 243     thdb->pcontext        = &thdb->context;
 244     thdb->context.SegCs   = cs;
 245     thdb->context.SegDs   = ds;
 246     thdb->context.SegEs   = ds;
 247     thdb->context.SegGs   = ds;
 248     thdb->context.SegSs   = ds;
 249     thdb->context.SegFs   = thdb->teb_sel;
 250     thdb->context.Eip     = (DWORD)start_addr;
 251     thdb->context.Esp     = (DWORD)thdb->teb.stack_top;
 252     PE_InitTls( thdb );
 253     return thdb;
 254
 255 error:
 256     if (thdb->socket != -1) close( thdb->socket );
 257     if (thdb->event) CloseHandle( thdb->event );
 258     if (thdb->teb.stack_sel) SELECTOR_FreeBlock( thdb->teb.stack_sel, 1 );
 259     if (thdb->teb_sel) SELECTOR_FreeBlock( thdb->teb_sel, 1 );
 260     if (thdb->stack_base) VirtualFree( thdb->stack_base, 0, MEM_RELEASE );
 261     HeapFree( SystemHeap, 0, thdb );
 262     return NULL;
 263 }
 264
 265
 266 /***********************************************************************
 267  *           THREAD_Destroy
 268  */
 269 static void THREAD_Destroy( K32OBJ *ptr )
 270 {
 271     THDB *thdb = (THDB *)ptr;
 272
 273     assert( ptr->type == K32OBJ_THREAD );
 274     ptr->type = K32OBJ_UNKNOWN;
 275
 276     /* Free the associated memory */
 277
 278 #ifdef __i386__
 279     {
 280         /* Check if we are deleting the current thread */
 281         WORD fs;
 282         GET_FS( fs );
 283         if (fs == thdb->teb_sel)
 284         {
 285             GET_DS( fs );
 286             SET_FS( fs );
 287         }
 288     }
 289 #endif
 290     CloseHandle( thdb->event );
 291     close( thdb->socket );
 292     SELECTOR_FreeBlock( thdb->teb_sel, 1 );
 293     if (thdb->teb.stack_sel) SELECTOR_FreeBlock( thdb->teb.stack_sel, 1 );
 294     HeapFree( SystemHeap, 0, thdb );
 295
 296 }
 297
 298
 299 /***********************************************************************
 300  *           THREAD_Start
 301  *
 302  * Start execution of a newly created thread. Does not return.
 303  */
 304 void THREAD_Start( THDB *thdb )
 305 {
 306     LPTHREAD_START_ROUTINE func = (LPTHREAD_START_ROUTINE)thdb->entry_point;
 307     assert( THREAD_Current() == thdb );
 308     CLIENT_InitThread();
 309     MODULE_InitializeDLLs( thdb->process, 0, DLL_THREAD_ATTACH, NULL );
 310     ExitThread( func( thdb->entry_arg ) );
 311 }
 312
 313
 314 /***********************************************************************
 315  *           CreateThread   (KERNEL32.63)
 316  */
 317 HANDLE32 WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
 318                               LPTHREAD_START_ROUTINE start, LPVOID param,
 319                               DWORD flags, LPDWORD id )
 320 {
 321     int server_handle = -1;
 322     HANDLE32 handle = INVALID_HANDLE_VALUE32;
 323     BOOL32 inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 324
 325     THDB *thread = THREAD_Create( PROCESS_Current(), stack,
 326                                   TRUE, &server_handle, NULL, start, param );
 327     if (!thread) return INVALID_HANDLE_VALUE32;
 328     handle = HANDLE_Alloc( PROCESS_Current(), &thread->header,
 329                            THREAD_ALL_ACCESS, inherit, server_handle );
 330     if (handle == INVALID_HANDLE_VALUE32) goto error;
 331     if (SYSDEPS_SpawnThread( thread ) == -1) goto error;
 332     if (id) *id = THDB_TO_THREAD_ID( thread );
 333     return handle;
 334
 335 error:
 336     if (handle != INVALID_HANDLE_VALUE32) CloseHandle( handle );
 337     K32OBJ_DecCount( &thread->header );
 338     return INVALID_HANDLE_VALUE32;
 339 }
 340
 341
 342 /***********************************************************************
 343  * ExitThread [KERNEL32.215]  Ends a thread
 344  *
 345  * RETURNS
 346  *    None
 347  */
 348 void WINAPI ExitThread(
 349     DWORD code) /* [in] Exit code for this thread */
 350 {
 351     THDB *thdb = THREAD_Current();
 352     LONG count;
 353
 354     /* Remove thread from process's list */
 355     THREAD_RemoveQueue( &thdb->process->thread_list, thdb );
 356
 357     MODULE_InitializeDLLs( thdb->process, 0, DLL_THREAD_DETACH, NULL );
 358
 359     SYSTEM_LOCK();
 360     thdb->exit_code = code;
 361
 362     /* FIXME: should free the stack somehow */
 363 #if 0
 364     /* FIXME: We cannot do this; once the current thread is destroyed,
 365        synchronization primitives do not work properly. */
 366     K32OBJ_DecCount( &thdb->header );
 367 #endif
 368     /* Completely unlock the system lock just in case */
 369     count = SYSTEM_LOCK_COUNT();
 370     while (count--) SYSTEM_UNLOCK();
 371     SYSDEPS_ExitThread();
 372 }
 373
 374
 375 /***********************************************************************
 376  * GetCurrentThread [KERNEL32.200]  Gets pseudohandle for current thread
 377  *
 378  * RETURNS
 379  *    Pseudohandle for the current thread
 380  */
 381 HANDLE32 WINAPI GetCurrentThread(void)
 382 {
 383     return CURRENT_THREAD_PSEUDOHANDLE;
 384 }
 385
 386
 387 /***********************************************************************
 388  * GetCurrentThreadId [KERNEL32.201]  Returns thread identifier.
 389  *
 390  * RETURNS
 391  *    Thread identifier of calling thread
 392  */
 393 DWORD WINAPI GetCurrentThreadId(void)
 394 {
 395     return THDB_TO_THREAD_ID( THREAD_Current() );
 396 }
 397
 398
 399 /**********************************************************************
 400  * GetLastError [KERNEL.148] [KERNEL32.227]  Returns last-error code.
 401  *
 402  * RETURNS
 403  *     Calling thread's last error code value.
 404  */
 405 DWORD WINAPI GetLastError(void)
 406 {
 407     THDB *thread = THREAD_Current();
 408     DWORD ret = thread->last_error;
 409     TRACE(thread,"0x%lx\n",ret);
 410     return ret;
 411 }
 412
 413
 414 /**********************************************************************
 415  * SetLastError [KERNEL.147] [KERNEL32.497]  Sets the last-error code.
 416  *
 417  * RETURNS
 418  *    None.
 419  */
 420 void WINAPI SetLastError(
 421     DWORD error) /* [in] Per-thread error code */
 422 {
 423     THDB *thread = THREAD_Current();
 424     /* This one must work before we have a thread (FIXME) */
 425
 426     TRACE(thread,"%p error=0x%lx\n",thread,error);
 427
 428     if (thread)
 429       thread->last_error = error;
 430 }
 431
 432
 433 /**********************************************************************
 434  * SetLastErrorEx [USER32.485]  Sets the last-error code.
 435  *
 436  * RETURNS
 437  *    None.
 438  */
 439 void WINAPI SetLastErrorEx(
 440     DWORD error, /* [in] Per-thread error code */
 441     DWORD type)  /* [in] Error type */
 442 {
 443     TRACE(thread, "(0x%08lx, 0x%08lx)\n", error,type);
 444     switch(type) {
 445         case 0:
 446             break;
 447         case SLE_ERROR:
 448         case SLE_MINORERROR:
 449         case SLE_WARNING:
 450             /* Fall through for now */
 451         default:
 452             FIXME(thread, "(error=%08lx, type=%08lx): Unhandled type\n", error,type);
 453             break;
 454     }
 455     SetLastError( error );
 456 }
 457
 458
 459 /**********************************************************************
 460  *           THREAD_TlsAlloc
 461  */
 462 DWORD THREAD_TlsAlloc(THDB *thread)
 463 {
 464     DWORD i, mask, ret = 0;
 465     DWORD *bits = thread->process->tls_bits;
 466     EnterCriticalSection( &thread->process->crit_section );
 467     if (*bits == 0xffffffff)
 468     {
 469         bits++;
 470         ret = 32;
 471         if (*bits == 0xffffffff)
 472         {
 473             LeaveCriticalSection( &thread->process->crit_section );
 474             SetLastError( ERROR_NO_MORE_ITEMS );
 475             return 0xffffffff;
 476         }
 477     }
 478     for (i = 0, mask = 1; i < 32; i++, mask <<= 1) if (!(*bits & mask)) break;
 479     *bits |= mask;
 480     LeaveCriticalSection( &thread->process->crit_section );
 481     return ret + i;
 482 }
 483
 484
 485 /**********************************************************************
 486  * TlsAlloc [KERNEL32.530]  Allocates a TLS index.
 487  *
 488  * Allocates a thread local storage index
 489  *
 490  * RETURNS
 491  *    Success: TLS Index
 492  *    Failure: 0xFFFFFFFF
 493  */
 494 DWORD WINAPI TlsAlloc(void)
 495 {
 496     return THREAD_TlsAlloc(THREAD_Current());
 497 }
 498
 499
 500 /**********************************************************************
 501  * TlsFree [KERNEL32.531]  Releases a TLS index.
 502  *
 503  * Releases a thread local storage index, making it available for reuse
 504  *
 505  * RETURNS
 506  *    Success: TRUE
 507  *    Failure: FALSE
 508  */
 509 BOOL32 WINAPI TlsFree(
 510     DWORD index) /* [in] TLS Index to free */
 511 {
 512     DWORD mask;
 513     THDB *thread = THREAD_Current();
 514     DWORD *bits = thread->process->tls_bits;
 515     if (index >= 64)
 516     {
 517         SetLastError( ERROR_INVALID_PARAMETER );
 518         return FALSE;
 519     }
 520     EnterCriticalSection( &thread->process->crit_section );
 521     if (index >= 32) bits++;
 522     mask = (1 << (index & 31));
 523     if (!(*bits & mask))  /* already free? */
 524     {
 525         LeaveCriticalSection( &thread->process->crit_section );
 526         SetLastError( ERROR_INVALID_PARAMETER );
 527         return FALSE;
 528     }
 529     *bits &= ~mask;
 530     thread->tls_array[index] = 0;
 531     /* FIXME: should zero all other thread values */
 532     LeaveCriticalSection( &thread->process->crit_section );
 533     return TRUE;
 534 }
 535
 536
 537 /**********************************************************************
 538  * TlsGetValue [KERNEL32.532]  Gets value in a thread's TLS slot
 539  *
 540  * RETURNS
 541  *    Success: Value stored in calling thread's TLS slot for index
 542  *    Failure: 0 and GetLastError returns NO_ERROR
 543  */
 544 LPVOID WINAPI TlsGetValue(
 545     DWORD index) /* [in] TLS index to retrieve value for */
 546 {
 547     THDB *thread = THREAD_Current();
 548     if (index >= 64)
 549     {
 550         SetLastError( ERROR_INVALID_PARAMETER );
 551         return NULL;
 552     }
 553     SetLastError( ERROR_SUCCESS );
 554     return thread->tls_array[index];
 555 }
 556
 557
 558 /**********************************************************************
 559  * TlsSetValue [KERNEL32.533]  Stores a value in the thread's TLS slot.
 560  *
 561  * RETURNS
 562  *    Success: TRUE
 563  *    Failure: FALSE
 564  */
 565 BOOL32 WINAPI TlsSetValue(
 566     DWORD index,  /* [in] TLS index to set value for */
 567     LPVOID value) /* [in] Value to be stored */
 568 {
 569     THDB *thread = THREAD_Current();
 570     if (index >= 64)
 571     {
 572         SetLastError( ERROR_INVALID_PARAMETER );
 573         return FALSE;
 574     }
 575     thread->tls_array[index] = value;
 576     return TRUE;
 577 }
 578
 579
 580 /***********************************************************************
 581  * SetThreadContext [KERNEL32.670]  Sets context of thread.
 582  *
 583  * RETURNS
 584  *    Success: TRUE
 585  *    Failure: FALSE
 586  */
 587 BOOL32 WINAPI SetThreadContext(
 588     HANDLE32 handle,  /* [in]  Handle to thread with context */
 589     CONTEXT *context) /* [out] Address of context structure */
 590 {
 591     THDB *thread = THREAD_GetPtr( handle, THREAD_GET_CONTEXT, NULL );
 592     if (!thread) return FALSE;
 593     *context = thread->context;
 594     K32OBJ_DecCount( &thread->header );
 595     return TRUE;
 596 }
 597
 598 /***********************************************************************
 599  * GetThreadContext [KERNEL32.294]  Retrieves context of thread.
 600  *
 601  * RETURNS
 602  *    Success: TRUE
 603  *    Failure: FALSE
 604  */
 605 BOOL32 WINAPI GetThreadContext(
 606     HANDLE32 handle,  /* [in]  Handle to thread with context */
 607     CONTEXT *context) /* [out] Address of context structure */
 608 {
 609     THDB *thread = THREAD_GetPtr( handle, THREAD_GET_CONTEXT, NULL );
 610     if (!thread) return FALSE;
 611     *context = thread->context;
 612     K32OBJ_DecCount( &thread->header );
 613     return TRUE;
 614 }
 615
 616
 617 /**********************************************************************
 618  * GetThreadPriority [KERNEL32.296]  Returns priority for thread.
 619  *
 620  * RETURNS
 621  *    Success: Thread's priority level.
 622  *    Failure: THREAD_PRIORITY_ERROR_RETURN
 623  */
 624 INT32 WINAPI GetThreadPriority(
 625     HANDLE32 hthread) /* [in] Handle to thread */
 626 {
 627     THDB *thread;
 628     INT32 ret;
 629
 630     if (!(thread = THREAD_GetPtr( hthread, THREAD_QUERY_INFORMATION, NULL )))
 631         return THREAD_PRIORITY_ERROR_RETURN;
 632     ret = thread->delta_priority;
 633     K32OBJ_DecCount( &thread->header );
 634     return ret;
 635 }
 636
 637
 638 /**********************************************************************
 639  * SetThreadPriority [KERNEL32.514]  Sets priority for thread.
 640  *
 641  * RETURNS
 642  *    Success: TRUE
 643  *    Failure: FALSE
 644  */
 645 BOOL32 WINAPI SetThreadPriority(
 646     HANDLE32 hthread, /* [in] Handle to thread */
 647     INT32 priority)   /* [in] Thread priority level */
 648 {
 649     THDB *thread;
 650
 651     if (!(thread = THREAD_GetPtr( hthread, THREAD_SET_INFORMATION, NULL )))
 652         return FALSE;
 653     thread->delta_priority = priority;
 654     K32OBJ_DecCount( &thread->header );
 655     return TRUE;
 656 }
 657
 658
 659 /**********************************************************************
 660  * TerminateThread [KERNEL32.685]  Terminates a thread
 661  *
 662  * RETURNS
 663  *    Success: TRUE
 664  *    Failure: FALSE
 665  */
 666 BOOL32 WINAPI TerminateThread(
 667     HANDLE32 handle, /* [in] Handle to thread */
 668     DWORD exitcode)  /* [in] Exit code for thread */
 669 {
 670     struct terminate_thread_request req;
 671
 672     req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
 673                                          K32OBJ_THREAD, THREAD_TERMINATE );
 674     req.exit_code = exitcode;
 675     CLIENT_SendRequest( REQ_TERMINATE_THREAD, -1, 1, &req, sizeof(req) );
 676     return !CLIENT_WaitReply( NULL, NULL, 0 );
 677 }
 678
 679
 680 /**********************************************************************
 681  * GetExitCodeThread [KERNEL32.???]  Gets termination status of thread.
 682  *
 683  * RETURNS
 684  *    Success: TRUE
 685  *    Failure: FALSE
 686  */
 687 BOOL32 WINAPI GetExitCodeThread(
 688     HANDLE32 hthread, /* [in]  Handle to thread */
 689     LPDWORD exitcode) /* [out] Address to receive termination status */
 690 {
 691     struct get_thread_info_reply reply;
 692     int handle = HANDLE_GetServerHandle( PROCESS_Current(), hthread,
 693                                          K32OBJ_THREAD, THREAD_QUERY_INFORMATION );
 694     CLIENT_SendRequest( REQ_GET_THREAD_INFO, -1, 1, &handle, sizeof(handle) );
 695     if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return FALSE;
 696     if (exitcode) *exitcode = reply.exit_code;
 697     return TRUE;
 698 }
 699
 700
 701 /**********************************************************************
 702  * ResumeThread [KERNEL32.587]  Resumes a thread.
 703  *
 704  * Decrements a thread's suspend count.  When count is zero, the
 705  * execution of the thread is resumed.
 706  *
 707  * RETURNS
 708  *    Success: Previous suspend count
 709  *    Failure: 0xFFFFFFFF
 710  *    Already running: 0
 711  */
 712 DWORD WINAPI ResumeThread(
 713     HANDLE32 hthread) /* [in] Indentifies thread to restart */
 714 {
 715     THDB *thread;
 716     DWORD oldcount;
 717
 718     SYSTEM_LOCK();
 719     if (!(thread = THREAD_GetPtr( hthread, THREAD_QUERY_INFORMATION, NULL )))
 720     {
 721         SYSTEM_UNLOCK();
 722         WARN(thread, "Invalid thread handle\n");
 723         return 0xFFFFFFFF;
 724     }
 725     if ((oldcount = thread->suspend_count) != 0)
 726     {
 727         if (!--thread->suspend_count)
 728         {
 729             if (kill(thread->unix_pid, SIGCONT))
 730             {
 731                 WARN(thread, "Unable to CONTinue pid: %04x\n",
 732                      thread->unix_pid);
 733                 oldcount = 0xFFFFFFFF;
 734             }
 735         }
 736     }
 737     K32OBJ_DecCount(&thread->header);
 738     SYSTEM_UNLOCK();
 739     return oldcount;
 740 }
 741
 742
 743 /**********************************************************************
 744  * SuspendThread [KERNEL32.681]  Suspends a thread.
 745  *
 746  * RETURNS
 747  *    Success: Previous suspend count
 748  *    Failure: 0xFFFFFFFF
 749  */
 750 DWORD WINAPI SuspendThread(
 751     HANDLE32 hthread) /* [in] Handle to the thread */
 752 {
 753     THDB *thread;
 754     DWORD oldcount;
 755
 756     SYSTEM_LOCK();
 757     if (!(thread = THREAD_GetPtr( hthread, THREAD_QUERY_INFORMATION, NULL )))
 758     {
 759         SYSTEM_UNLOCK();
 760         WARN(thread, "Invalid thread handle\n");
 761         return 0xFFFFFFFF;
 762     }
 763
 764     if (!(oldcount = thread->suspend_count))
 765     {
 766         if (thread->unix_pid == getpid())
 767             WARN(thread, "Attempting to suspend myself\n" );
 768         else
 769         {
 770             if (kill(thread->unix_pid, SIGSTOP))
 771             {
 772                 WARN(thread, "Unable to STOP pid: %04x\n",
 773                      thread->unix_pid);
 774                 oldcount = 0xFFFFFFFF;
 775             }
 776             else thread->suspend_count++;
 777         }
 778     }
 779     else thread->suspend_count++;
 780     K32OBJ_DecCount( &thread->header );
 781     SYSTEM_UNLOCK();
 782     return oldcount;
 783
 784 }
 785
 786
 787 /**********************************************************************
 788  * GetThreadTimes [KERNEL32.???]  Obtains timing information.
 789  *
 790  * NOTES
 791  *    What are the fields where these values are stored?
 792  *
 793  * RETURNS
 794  *    Success: TRUE
 795  *    Failure: FALSE
 796  */
 797 BOOL32 WINAPI GetThreadTimes(
 798     HANDLE32 thread,         /* [in]  Specifies the thread of interest */
 799     LPFILETIME creationtime, /* [out] When the thread was created */
 800     LPFILETIME exittime,     /* [out] When the thread was destroyed */
 801     LPFILETIME kerneltime,   /* [out] Time thread spent in kernel mode */
 802     LPFILETIME usertime)     /* [out] Time thread spent in user mode */
 803 {
 804     FIXME(thread,"(0x%08x): stub\n",thread);
 805     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 806     return FALSE;
 807 }
 808
 809
 810 /**********************************************************************
 811  * AttachThreadInput [KERNEL32.8]  Attaches input of 1 thread to other
 812  *
 813  * Attaches the input processing mechanism of one thread to that of
 814  * another thread.
 815  *
 816  * RETURNS
 817  *    Success: TRUE
 818  *    Failure: FALSE
 819  */
 820 BOOL32 WINAPI AttachThreadInput(
 821     DWORD idAttach,   /* [in] Thread to attach */
 822     DWORD idAttachTo, /* [in] Thread to attach to */
 823     BOOL32 fAttach)   /* [in] Attach or detach */
 824 {
 825     BOOL32 ret;
 826
 827     FIXME(thread, "(0x%08lx,0x%08lx,%d): stub\n",idAttach,idAttachTo,fAttach);
 828     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 829     if (fAttach) {
 830         /* Attach threads */
 831         ret = FALSE;
 832     }
 833     else {
 834         /* Detach threads */
 835         ret = FALSE;
 836     };
 837     return ret;
 838 }
 839
 840 /**********************************************************************
 841  * VWin32_BoostThreadGroup [KERNEL.535]
 842  */
 843 VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT32 boost )
 844 {
 845     FIXME(thread, "(0x%08lx,%d): stub\n", threadId, boost);
 846 }
 847
 848 /**********************************************************************
 849  * VWin32_BoostThreadStatic [KERNEL.536]
 850  */
 851 VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT32 boost )
 852 {
 853     FIXME(thread, "(0x%08lx,%d): stub\n", threadId, boost);
 854 }
 855