scheduler/thread.c

   1 /*
   2  * Win32 threads
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include "wine/port.h"
   8
   9 #include <assert.h>
  10 #include <fcntl.h>
  11 #include <sys/types.h>
  12 #ifdef HAVE_SYS_MMAN_H
  13 #include <sys/mman.h>
  14 #endif
  15 #include <unistd.h>
  16 #include "wine/winbase16.h"
  17 #include "thread.h"
  18 #include "task.h"
  19 #include "module.h"
  20 #include "winerror.h"
  21 #include "selectors.h"
  22 #include "winnt.h"
  23 #include "wine/server.h"
  24 #include "services.h"
  25 #include "stackframe.h"
  26 #include "builtin16.h"
  27 #include "debugtools.h"
  28 #include "winnls.h"
  29
  30 DEFAULT_DEBUG_CHANNEL(thread);
  31 DECLARE_DEBUG_CHANNEL(relay);
  32
  33 /* TEB of the initial thread */
  34 static TEB initial_teb;
  35
  36 extern struct _PDB current_process;
  37
  38 /***********************************************************************
  39  *           THREAD_IdToTEB
  40  *
  41  * Convert a thread id to a TEB, making sure it is valid.
  42  */
  43 TEB *THREAD_IdToTEB( DWORD id )
  44 {
  45     TEB *ret = NULL;
  46
  47     if (!id || id == GetCurrentThreadId()) return NtCurrentTeb();
  48
  49     SERVER_START_REQ( get_thread_info )
  50     {
  51         req->handle = 0;
  52         req->tid_in = (void *)id;
  53         if (!SERVER_CALL()) ret = req->teb;
  54     }
  55     SERVER_END_REQ;
  56
  57     if (!ret)
  58     {
  59         /* Allow task handles to be used; convert to main thread */
  60         if ( IsTask16( id ) )
  61         {
  62             TDB *pTask = TASK_GetPtr( id );
  63             if (pTask) return pTask->teb;
  64         }
  65         SetLastError( ERROR_INVALID_PARAMETER );
  66     }
  67     return ret;
  68 }
  69
  70
  71 /***********************************************************************
  72  *           THREAD_InitTEB
  73  *
  74  * Initialization of a newly created TEB.
  75  */
  76 static BOOL THREAD_InitTEB( TEB *teb )
  77 {
  78     teb->except    = (void *)~0UL;
  79     teb->self      = teb;
  80     teb->tibflags  = TEBF_WIN32;
  81     teb->tls_ptr   = teb->tls_array;
  82     teb->exit_code = STILL_ACTIVE;
  83     teb->request_fd = -1;
  84     teb->reply_fd   = -1;
  85     teb->wait_fd[0] = -1;
  86     teb->wait_fd[1] = -1;
  87     teb->stack_top  = (void *)~0UL;
  88     teb->StaticUnicodeString.MaximumLength = sizeof(teb->StaticUnicodeBuffer);
  89     teb->StaticUnicodeString.Buffer = (PWSTR)teb->StaticUnicodeBuffer;
  90     teb->teb_sel = SELECTOR_AllocBlock( teb, 0x1000, WINE_LDT_FLAGS_DATA|WINE_LDT_FLAGS_32BIT );
  91     return (teb->teb_sel != 0);
  92 }
  93
  94
  95 /***********************************************************************
  96  *           THREAD_FreeTEB
  97  *
  98  * Free data structures associated with a thread.
  99  * Must be called from the context of another thread.
 100  */
 101 static void CALLBACK THREAD_FreeTEB( TEB *teb )
 102 {
 103     TRACE("(%p) called\n", teb );
 104     if (teb->cleanup) SERVICE_Delete( teb->cleanup );
 105
 106     /* Free the associated memory */
 107
 108     close( teb->request_fd );
 109     close( teb->reply_fd );
 110     close( teb->wait_fd[0] );
 111     close( teb->wait_fd[1] );
 112     if (teb->stack_sel) FreeSelector16( teb->stack_sel );
 113     FreeSelector16( teb->teb_sel );
 114     if (teb->buffer) munmap( (void *)teb->buffer, teb->buffer_size );
 115     if (teb->debug_info) HeapFree( GetProcessHeap(), 0, teb->debug_info );
 116     VirtualFree( teb->stack_base, 0, MEM_RELEASE );
 117 }
 118
 119
 120 /***********************************************************************
 121  *           THREAD_InitStack
 122  *
 123  * Allocate the stack of a thread.
 124  */
 125 TEB *THREAD_InitStack( TEB *teb, DWORD stack_size )
 126 {
 127     DWORD old_prot, total_size;
 128     DWORD page_size = getpagesize();
 129     void *base;
 130
 131     /* Allocate the stack */
 132
 133     if (stack_size >= 16*1024*1024)
 134         WARN("Thread stack size is %ld MB.\n",stack_size/1024/1024);
 135
 136     /* if size is smaller than default, get stack size from parent */
 137     if (stack_size < 1024 * 1024)
 138     {
 139         if (teb)
 140             stack_size = 1024 * 1024;  /* no parent */
 141         else
 142             stack_size = ((char *)NtCurrentTeb()->stack_top - (char *)NtCurrentTeb()->stack_base
 143                           - SIGNAL_STACK_SIZE - 3 * page_size);
 144     }
 145
 146     /* FIXME: some Wine functions use a lot of stack, so we add 64Kb here */
 147     stack_size += 64 * 1024;
 148
 149     /* Memory layout in allocated block:
 150      *
 151      *   size                 contents
 152      * 1 page              NOACCESS guard page
 153      * SIGNAL_STACK_SIZE   signal stack
 154      * 1 page              NOACCESS guard page
 155      * 1 page              PAGE_GUARD guard page
 156      * stack_size          normal stack
 157      * 64Kb                16-bit stack (optional)
 158      * 1 page              TEB (except for initial thread)
 159      */
 160
 161     stack_size = (stack_size + (page_size - 1)) & ~(page_size - 1);
 162     total_size = stack_size + SIGNAL_STACK_SIZE + 3 * page_size;
 163     total_size += 0x10000; /* 16-bit stack */
 164     if (!teb) total_size += page_size;
 165
 166     if (!(base = VirtualAlloc( NULL, total_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE )))
 167         return NULL;
 168
 169     if (!teb)
 170     {
 171         teb = (TEB *)((char *)base + total_size - page_size);
 172         if (!THREAD_InitTEB( teb ))
 173         {
 174             VirtualFree( base, 0, MEM_RELEASE );
 175             return NULL;
 176         }
 177     }
 178
 179     teb->stack_low    = base;
 180     teb->stack_base   = base;
 181     teb->signal_stack = (char *)base + page_size;
 182     teb->stack_top    = (char *)base + 3 * page_size + SIGNAL_STACK_SIZE + stack_size;
 183
 184     /* Setup guard pages */
 185
 186     VirtualProtect( base, 1, PAGE_NOACCESS, &old_prot );
 187     VirtualProtect( (char *)teb->signal_stack + SIGNAL_STACK_SIZE, 1, PAGE_NOACCESS, &old_prot );
 188     VirtualProtect( (char *)teb->signal_stack + SIGNAL_STACK_SIZE + page_size, 1,
 189                     PAGE_EXECUTE_READWRITE | PAGE_GUARD, &old_prot );
 190
 191     /* Allocate the 16-bit stack selector */
 192
 193     teb->stack_sel = SELECTOR_AllocBlock( teb->stack_top, 0x10000, WINE_LDT_FLAGS_DATA );
 194     if (!teb->stack_sel) goto error;
 195     teb->cur_stack = MAKESEGPTR( teb->stack_sel, 0x10000 - sizeof(STACK16FRAME) );
 196
 197     return teb;
 198
 199 error:
 200     THREAD_FreeTEB( teb );
 201     return NULL;
 202 }
 203
 204
 205 /***********************************************************************
 206  *           thread_errno_location
 207  *
 208  * Get the per-thread errno location.
 209  */
 210 static int *thread_errno_location(void)
 211 {
 212     return &NtCurrentTeb()->thread_errno;
 213 }
 214
 215 /***********************************************************************
 216  *           thread_h_errno_location
 217  *
 218  * Get the per-thread h_errno location.
 219  */
 220 static int *thread_h_errno_location(void)
 221 {
 222     return &NtCurrentTeb()->thread_h_errno;
 223 }
 224
 225 /***********************************************************************
 226  *           THREAD_Init
 227  *
 228  * Setup the initial thread.
 229  *
 230  * NOTES: The first allocated TEB on NT is at 0x7ffde000.
 231  */
 232 void THREAD_Init(void)
 233 {
 234     if (!initial_teb.self)  /* do it only once */
 235     {
 236         THREAD_InitTEB( &initial_teb );
 237         assert( initial_teb.teb_sel );
 238         initial_teb.process = &current_process;
 239         SYSDEPS_SetCurThread( &initial_teb );
 240         wine_errno_location = thread_errno_location;
 241         wine_h_errno_location = thread_h_errno_location;
 242     }
 243 }
 244
 245 DECL_GLOBAL_CONSTRUCTOR(thread_init) { THREAD_Init(); }
 246
 247
 248 /***********************************************************************
 249  *           THREAD_Start
 250  *
 251  * Start execution of a newly created thread. Does not return.
 252  */
 253 static void THREAD_Start(void)
 254 {
 255     HANDLE cleanup_object;
 256     LPTHREAD_START_ROUTINE func = (LPTHREAD_START_ROUTINE)NtCurrentTeb()->entry_point;
 257
 258     /* install cleanup handler */
 259     if (DuplicateHandle( GetCurrentProcess(), GetCurrentThread(),
 260                          GetCurrentProcess(), &cleanup_object,
 261                          0, FALSE, DUPLICATE_SAME_ACCESS ))
 262         NtCurrentTeb()->cleanup = SERVICE_AddObject( cleanup_object, (PAPCFUNC)THREAD_FreeTEB,
 263                                                      (ULONG_PTR)NtCurrentTeb() );
 264
 265     if (TRACE_ON(relay))
 266         DPRINTF("%08lx:Starting thread (entryproc=%p)\n", GetCurrentThreadId(), func );
 267
 268     PROCESS_CallUserSignalProc( USIG_THREAD_INIT, 0 );
 269     PE_InitTls();
 270     MODULE_DllThreadAttach( NULL );
 271     ExitThread( func( NtCurrentTeb()->entry_arg ) );
 272 }
 273
 274
 275 /***********************************************************************
 276  *           CreateThread   (KERNEL32.@)
 277  */
 278 HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
 279                             LPTHREAD_START_ROUTINE start, LPVOID param,
 280                             DWORD flags, LPDWORD id )
 281 {
 282     HANDLE handle = 0;
 283     TEB *teb;
 284     void *tid = 0;
 285     int request_pipe[2];
 286
 287     if (pipe( request_pipe ) == -1)
 288     {
 289         SetLastError( ERROR_TOO_MANY_OPEN_FILES );
 290         return 0;
 291     }
 292     fcntl( request_pipe[1], F_SETFD, 1 ); /* set close on exec flag */
 293     wine_server_send_fd( request_pipe[0] );
 294
 295     SERVER_START_REQ( new_thread )
 296     {
 297         req->suspend    = ((flags & CREATE_SUSPENDED) != 0);
 298         req->inherit    = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 299         req->request_fd = request_pipe[0];
 300         if (!SERVER_CALL_ERR())
 301         {
 302             handle = req->handle;
 303             tid = req->tid;
 304         }
 305         close( request_pipe[0] );
 306     }
 307     SERVER_END_REQ;
 308
 309     if (!handle || !(teb = THREAD_InitStack( NULL, stack )))
 310     {
 311         close( request_pipe[1] );
 312         return 0;
 313     }
 314
 315     teb->process     = NtCurrentTeb()->process;
 316     teb->tid         = tid;
 317     teb->request_fd  = request_pipe[1];
 318     teb->entry_point = start;
 319     teb->entry_arg   = param;
 320     teb->startup     = THREAD_Start;
 321     teb->htask16     = GetCurrentTask();
 322
 323     if (id) *id = (DWORD)tid;
 324     if (SYSDEPS_SpawnThread( teb ) == -1)
 325     {
 326         CloseHandle( handle );
 327         THREAD_FreeTEB( teb );
 328         return 0;
 329     }
 330     return handle;
 331 }
 332
 333 /***********************************************************************
 334  *           CreateThread16   (KERNEL.441)
 335  */
 336 static DWORD CALLBACK THREAD_StartThread16( LPVOID threadArgs )
 337 {
 338     FARPROC16 start = ((FARPROC16 *)threadArgs)[0];
 339     DWORD     param = ((DWORD *)threadArgs)[1];
 340     HeapFree( GetProcessHeap(), 0, threadArgs );
 341
 342     ((LPDWORD)CURRENT_STACK16)[-1] = param;
 343     return wine_call_to_16_long( start, sizeof(DWORD) );
 344 }
 345 HANDLE WINAPI CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
 346                               FARPROC16 start, SEGPTR param,
 347                               DWORD flags, LPDWORD id )
 348 {
 349     DWORD *threadArgs = HeapAlloc( GetProcessHeap(), 0, 2*sizeof(DWORD) );
 350     if (!threadArgs) return INVALID_HANDLE_VALUE;
 351     threadArgs[0] = (DWORD)start;
 352     threadArgs[1] = (DWORD)param;
 353
 354     return CreateThread( sa, stack, THREAD_StartThread16, threadArgs, flags, id );
 355 }
 356
 357
 358 /***********************************************************************
 359  * ExitThread [KERNEL32.@]  Ends a thread
 360  *
 361  * RETURNS
 362  *    None
 363  */
 364 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
 365 {
 366     BOOL last;
 367     SERVER_START_REQ( terminate_thread )
 368     {
 369         /* send the exit code to the server */
 370         req->handle    = GetCurrentThread();
 371         req->exit_code = code;
 372         SERVER_CALL();
 373         last = req->last;
 374     }
 375     SERVER_END_REQ;
 376
 377     if (last)
 378     {
 379         MODULE_DllProcessDetach( TRUE, (LPVOID)1 );
 380         exit( code );
 381     }
 382     else
 383     {
 384         MODULE_DllThreadDetach( NULL );
 385         if (!(NtCurrentTeb()->tibflags & TEBF_WIN32)) TASK_ExitTask();
 386         SYSDEPS_ExitThread( code );
 387     }
 388 }
 389
 390
 391 /***********************************************************************
 392  * SetThreadContext [KERNEL32.@]  Sets context of thread.
 393  *
 394  * RETURNS
 395  *    Success: TRUE
 396  *    Failure: FALSE
 397  */
 398 BOOL WINAPI SetThreadContext( HANDLE handle,           /* [in]  Handle to thread with context */
 399                               const CONTEXT *context ) /* [in] Address of context structure */
 400 {
 401     BOOL ret;
 402     SERVER_START_VAR_REQ( set_thread_context, sizeof(*context) )
 403     {
 404         req->handle = handle;
 405         req->flags = context->ContextFlags;
 406         memcpy( server_data_ptr(req), context, sizeof(*context) );
 407         ret = !SERVER_CALL_ERR();
 408     }
 409     SERVER_END_VAR_REQ;
 410     return ret;
 411 }
 412
 413
 414 /***********************************************************************
 415  * GetThreadContext [KERNEL32.@]  Retrieves context of thread.
 416  *
 417  * RETURNS
 418  *    Success: TRUE
 419  *    Failure: FALSE
 420  */
 421 BOOL WINAPI GetThreadContext( HANDLE handle,     /* [in]  Handle to thread with context */
 422                               CONTEXT *context ) /* [out] Address of context structure */
 423 {
 424     BOOL ret;
 425     SERVER_START_VAR_REQ( get_thread_context, sizeof(*context) )
 426     {
 427         req->handle = handle;
 428         req->flags = context->ContextFlags;
 429         memcpy( server_data_ptr(req), context, sizeof(*context) );
 430         if ((ret = !SERVER_CALL_ERR()))
 431             memcpy( context, server_data_ptr(req), sizeof(*context) );
 432     }
 433     SERVER_END_VAR_REQ;
 434     return ret;
 435 }
 436
 437
 438 /**********************************************************************
 439  * GetThreadPriority [KERNEL32.@]  Returns priority for thread.
 440  *
 441  * RETURNS
 442  *    Success: Thread's priority level.
 443  *    Failure: THREAD_PRIORITY_ERROR_RETURN
 444  */
 445 INT WINAPI GetThreadPriority(
 446     HANDLE hthread) /* [in] Handle to thread */
 447 {
 448     INT ret = THREAD_PRIORITY_ERROR_RETURN;
 449     SERVER_START_REQ( get_thread_info )
 450     {
 451         req->handle = hthread;
 452         req->tid_in = 0;
 453         if (!SERVER_CALL_ERR()) ret = req->priority;
 454     }
 455     SERVER_END_REQ;
 456     return ret;
 457 }
 458
 459
 460 /**********************************************************************
 461  * SetThreadPriority [KERNEL32.@]  Sets priority for thread.
 462  *
 463  * RETURNS
 464  *    Success: TRUE
 465  *    Failure: FALSE
 466  */
 467 BOOL WINAPI SetThreadPriority(
 468     HANDLE hthread, /* [in] Handle to thread */
 469     INT priority)   /* [in] Thread priority level */
 470 {
 471     BOOL ret;
 472     SERVER_START_REQ( set_thread_info )
 473     {
 474         req->handle   = hthread;
 475         req->priority = priority;
 476         req->mask     = SET_THREAD_INFO_PRIORITY;
 477         ret = !SERVER_CALL_ERR();
 478     }
 479     SERVER_END_REQ;
 480     return ret;
 481 }
 482
 483
 484 /**********************************************************************
 485  * GetThreadPriorityBoost [KERNEL32.@]  Returns priority boost for thread.
 486  *
 487  * Always reports that priority boost is disabled.
 488  *
 489  * RETURNS
 490  *    Success: TRUE.
 491  *    Failure: FALSE
 492  */
 493 BOOL WINAPI GetThreadPriorityBoost(
 494     HANDLE hthread, /* [in] Handle to thread */
 495     PBOOL pstate)   /* [out] pointer to var that receives the boost state */
 496 {
 497     if (pstate) *pstate = FALSE;
 498     return NO_ERROR;
 499 }
 500
 501
 502 /**********************************************************************
 503  * SetThreadPriorityBoost [KERNEL32.@]  Sets priority boost for thread.
 504  *
 505  * Priority boost is not implemented. Thsi function always returns
 506  * FALSE and sets last error to ERROR_CALL_NOT_IMPLEMENTED
 507  *
 508  * RETURNS
 509  *    Always returns FALSE to indicate a failure
 510  */
 511 BOOL WINAPI SetThreadPriorityBoost(
 512     HANDLE hthread, /* [in] Handle to thread */
 513     BOOL disable)   /* [in] TRUE to disable priority boost */
 514 {
 515     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 516     return FALSE;
 517 }
 518
 519
 520 /**********************************************************************
 521  *           SetThreadAffinityMask   (KERNEL32.@)
 522  */
 523 DWORD WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD dwThreadAffinityMask )
 524 {
 525     DWORD ret;
 526     SERVER_START_REQ( set_thread_info )
 527     {
 528         req->handle   = hThread;
 529         req->affinity = dwThreadAffinityMask;
 530         req->mask     = SET_THREAD_INFO_AFFINITY;
 531         ret = !SERVER_CALL_ERR();
 532         /* FIXME: should return previous value */
 533     }
 534     SERVER_END_REQ;
 535     return ret;
 536 }
 537
 538
 539 /**********************************************************************
 540  * TerminateThread [KERNEL32.@]  Terminates a thread
 541  *
 542  * RETURNS
 543  *    Success: TRUE
 544  *    Failure: FALSE
 545  */
 546 BOOL WINAPI TerminateThread( HANDLE handle,    /* [in] Handle to thread */
 547                              DWORD exit_code)  /* [in] Exit code for thread */
 548 {
 549     NTSTATUS status = NtTerminateThread( handle, exit_code );
 550     if (status) SetLastError( RtlNtStatusToDosError(status) );
 551     return !status;
 552 }
 553
 554
 555 /**********************************************************************
 556  *              GetExitCodeThread (KERNEL32.@)
 557  *
 558  * Gets termination status of thread.
 559  *
 560  * RETURNS
 561  *    Success: TRUE
 562  *    Failure: FALSE
 563  */
 564 BOOL WINAPI GetExitCodeThread(
 565     HANDLE hthread, /* [in]  Handle to thread */
 566     LPDWORD exitcode) /* [out] Address to receive termination status */
 567 {
 568     BOOL ret;
 569     SERVER_START_REQ( get_thread_info )
 570     {
 571         req->handle = hthread;
 572         req->tid_in = 0;
 573         ret = !SERVER_CALL_ERR();
 574         if (ret && exitcode) *exitcode = req->exit_code;
 575     }
 576     SERVER_END_REQ;
 577     return ret;
 578 }
 579
 580
 581 /**********************************************************************
 582  * ResumeThread [KERNEL32.@]  Resumes a thread.
 583  *
 584  * Decrements a thread's suspend count.  When count is zero, the
 585  * execution of the thread is resumed.
 586  *
 587  * RETURNS
 588  *    Success: Previous suspend count
 589  *    Failure: 0xFFFFFFFF
 590  *    Already running: 0
 591  */
 592 DWORD WINAPI ResumeThread(
 593     HANDLE hthread) /* [in] Identifies thread to restart */
 594 {
 595     DWORD ret = 0xffffffff;
 596     SERVER_START_REQ( resume_thread )
 597     {
 598         req->handle = hthread;
 599         if (!SERVER_CALL_ERR()) ret = req->count;
 600     }
 601     SERVER_END_REQ;
 602     return ret;
 603 }
 604
 605
 606 /**********************************************************************
 607  * SuspendThread [KERNEL32.@]  Suspends a thread.
 608  *
 609  * RETURNS
 610  *    Success: Previous suspend count
 611  *    Failure: 0xFFFFFFFF
 612  */
 613 DWORD WINAPI SuspendThread(
 614     HANDLE hthread) /* [in] Handle to the thread */
 615 {
 616     DWORD ret = 0xffffffff;
 617     SERVER_START_REQ( suspend_thread )
 618     {
 619         req->handle = hthread;
 620         if (!SERVER_CALL_ERR()) ret = req->count;
 621     }
 622     SERVER_END_REQ;
 623     return ret;
 624 }
 625
 626
 627 /***********************************************************************
 628  *              QueueUserAPC  (KERNEL32.@)
 629  */
 630 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
 631 {
 632     DWORD ret;
 633     SERVER_START_REQ( queue_apc )
 634     {
 635         req->handle = hthread;
 636         req->user   = 1;
 637         req->func   = func;
 638         req->param  = (void *)data;
 639         ret = !SERVER_CALL_ERR();
 640     }
 641     SERVER_END_REQ;
 642     return ret;
 643 }
 644
 645
 646 /**********************************************************************
 647  * GetThreadTimes [KERNEL32.@]  Obtains timing information.
 648  *
 649  * NOTES
 650  *    What are the fields where these values are stored?
 651  *
 652  * RETURNS
 653  *    Success: TRUE
 654  *    Failure: FALSE
 655  */
 656 BOOL WINAPI GetThreadTimes(
 657     HANDLE thread,         /* [in]  Specifies the thread of interest */
 658     LPFILETIME creationtime, /* [out] When the thread was created */
 659     LPFILETIME exittime,     /* [out] When the thread was destroyed */
 660     LPFILETIME kerneltime,   /* [out] Time thread spent in kernel mode */
 661     LPFILETIME usertime)     /* [out] Time thread spent in user mode */
 662 {
 663     FIXME("(0x%08x): stub\n",thread);
 664     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 665     return FALSE;
 666 }
 667
 668
 669 /**********************************************************************
 670  * VWin32_BoostThreadGroup [KERNEL.535]
 671  */
 672 VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
 673 {
 674     FIXME("(0x%08lx,%d): stub\n", threadId, boost);
 675 }
 676
 677 /**********************************************************************
 678  * VWin32_BoostThreadStatic [KERNEL.536]
 679  */
 680 VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT boost )
 681 {
 682     FIXME("(0x%08lx,%d): stub\n", threadId, boost);
 683 }
 684
 685
 686 /***********************************************************************
 687  *           GetThreadLocale    (KERNEL32.@)
 688  */
 689 LCID WINAPI GetThreadLocale(void)
 690 {
 691     LCID ret = NtCurrentTeb()->CurrentLocale;
 692     if (!ret) NtCurrentTeb()->CurrentLocale = ret = GetUserDefaultLCID();
 693     return ret;
 694 }
 695
 696
 697 /**********************************************************************
 698  * SetThreadLocale [KERNEL32.@]  Sets the calling threads current locale.
 699  *
 700  * RETURNS
 701  *    Success: TRUE
 702  *    Failure: FALSE
 703  *
 704  * FIXME
 705  *  check if lcid is a valid cp
 706  */
 707 BOOL WINAPI SetThreadLocale(
 708     LCID lcid)     /* [in] Locale identifier */
 709 {
 710     switch (lcid)
 711     {
 712       case LOCALE_SYSTEM_DEFAULT:
 713         lcid = GetSystemDefaultLCID();
 714         break;
 715       case LOCALE_USER_DEFAULT:
 716       case LOCALE_NEUTRAL:
 717         lcid = GetUserDefaultLCID();
 718         break;
 719     }
 720     NtCurrentTeb()->CurrentLocale = lcid;
 721     return TRUE;
 722 }
 723
 724
 725 /***********************************************************************
 726  * GetCurrentThread [KERNEL32.@]  Gets pseudohandle for current thread
 727  *
 728  * RETURNS
 729  *    Pseudohandle for the current thread
 730  */
 731 #undef GetCurrentThread
 732 HANDLE WINAPI GetCurrentThread(void)
 733 {
 734     return 0xfffffffe;
 735 }
 736
 737
 738 /***********************************************************************
 739  * ProcessIdToSessionId   (KERNEL32.@)
 740  * This function is available on Terminal Server 4SP4 and Windows 2000
 741  */
 742 BOOL WINAPI ProcessIdToSessionId( DWORD procid, DWORD *sessionid_ptr )
 743 {
 744         /* According to MSDN, if the calling process is not in a terminal
 745          * services environment, then the sessionid returned is zero.
 746          */
 747         *sessionid_ptr = 0;
 748         return TRUE;
 749 }
 750
 751 /***********************************************************************
 752  * SetThreadExecutionState (KERNEL32.@)
 753  *
 754  * Informs the system that activity is taking place for
 755  * power management purposes.
 756  */
 757 EXECUTION_STATE WINAPI SetThreadExecutionState(EXECUTION_STATE flags)
 758 {
 759     static EXECUTION_STATE current =
 760             ES_SYSTEM_REQUIRED|ES_DISPLAY_REQUIRED|ES_USER_PRESENT;
 761     EXECUTION_STATE old = current;
 762
 763     if (!(current & ES_CONTINUOUS) || (flags & ES_CONTINUOUS))
 764         current = flags;
 765     FIXME("(0x%lx): stub, harmless (power management).\n", flags);
 766     return old;
 767 }
 768
 769
 770 #ifdef __i386__
 771
 772 /***********************************************************************
 773  *              SetLastError (KERNEL.147)
 774  *              SetLastError (KERNEL32.@)
 775  */
 776 /* void WINAPI SetLastError( DWORD error ); */
 777 __ASM_GLOBAL_FUNC( SetLastError,
 778                    "movl 4(%esp),%eax\n\t"
 779                    ".byte 0x64\n\t"
 780                    "movl %eax,0x60\n\t"
 781                    "ret $4" );
 782
 783 /***********************************************************************
 784  *              GetLastError (KERNEL.148)
 785  *              GetLastError (KERNEL32.@)
 786  */
 787 /* DWORD WINAPI GetLastError(void); */
 788 __ASM_GLOBAL_FUNC( GetLastError, ".byte 0x64\n\tmovl 0x60,%eax\n\tret" );
 789
 790 /***********************************************************************
 791  *              GetCurrentProcessId (KERNEL.471)
 792  *              GetCurrentProcessId (KERNEL32.@)
 793  */
 794 /* DWORD WINAPI GetCurrentProcessId(void) */
 795 __ASM_GLOBAL_FUNC( GetCurrentProcessId, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" );
 796
 797 /***********************************************************************
 798  *              GetCurrentThreadId (KERNEL.462)
 799  *              GetCurrentThreadId (KERNEL32.@)
 800  */
 801 /* DWORD WINAPI GetCurrentThreadId(void) */
 802 __ASM_GLOBAL_FUNC( GetCurrentThreadId, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" );
 803
 804 #else  /* __i386__ */
 805
 806 /**********************************************************************
 807  *              SetLastError (KERNEL.147)
 808  *              SetLastError (KERNEL32.@)
 809  *
 810  * Sets the last-error code.
 811  */
 812 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
 813 {
 814     NtCurrentTeb()->last_error = error;
 815 }
 816
 817 /**********************************************************************
 818  *              GetLastError (KERNEL.148)
 819  *              GetLastError (KERNEL32.@)
 820  *
 821  * Returns last-error code.
 822  */
 823 DWORD WINAPI GetLastError(void)
 824 {
 825     return NtCurrentTeb()->last_error;
 826 }
 827
 828 /***********************************************************************
 829  *              GetCurrentProcessId (KERNEL.471)
 830  *              GetCurrentProcessId (KERNEL32.@)
 831  *
 832  * Returns process identifier.
 833  */
 834 DWORD WINAPI GetCurrentProcessId(void)
 835 {
 836     return (DWORD)NtCurrentTeb()->pid;
 837 }
 838
 839 /***********************************************************************
 840  *              GetCurrentThreadId (KERNEL.462)
 841  *              GetCurrentThreadId (KERNEL32.@)
 842  *
 843  * Returns thread identifier.
 844  */
 845 DWORD WINAPI GetCurrentThreadId(void)
 846 {
 847     return (DWORD)NtCurrentTeb()->tid;
 848 }
 849
 850 #endif  /* __i386__ */