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