dlls/kernel32/thread.c

   1 /*
   2  * Win32 threads
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <fcntl.h>
  26 #include <stdarg.h>
  27 #include <sys/types.h>
  28 #ifdef HAVE_UNISTD_H
  29 # include <unistd.h>
  30 #endif
  31
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winerror.h"
  37 #include "winternl.h"
  38 #include "wine/exception.h"
  39 #include "wine/library.h"
  40 #include "wine/server.h"
  41 #include "wine/debug.h"
  42
  43 #include "kernel_private.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(thread);
  46
  47
  48 /***********************************************************************
  49  *           CreateThread   (KERNEL32.@)
  50  */
  51 HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread( SECURITY_ATTRIBUTES *sa, SIZE_T stack, LPTHREAD_START_ROUTINE start,
  52                                               LPVOID param, DWORD flags, LPDWORD id )
  53 {
  54      return CreateRemoteThread( GetCurrentProcess(),
  55                                 sa, stack, start, param, flags, id );
  56 }
  57
  58
  59 /***************************************************************************
  60  *                  CreateRemoteThread   (KERNEL32.@)
  61  *
  62  * Creates a thread that runs in the address space of another process
  63  *
  64  * PARAMS
  65  *
  66  * RETURNS
  67  *   Success: Handle to the new thread.
  68  *   Failure: NULL. Use GetLastError() to find the error cause.
  69  *
  70  * BUGS
  71  *   Improper memory allocation: there's no ability to free new_thread_info
  72  *   in other process.
  73  *   Bad start address for RtlCreateUserThread because the library
  74  *   may be loaded at different address in other process.
  75  */
  76 HANDLE WINAPI CreateRemoteThread( HANDLE hProcess, SECURITY_ATTRIBUTES *sa, SIZE_T stack,
  77                                   LPTHREAD_START_ROUTINE start, LPVOID param,
  78                                   DWORD flags, LPDWORD id )
  79 {
  80     HANDLE handle;
  81     CLIENT_ID client_id;
  82     NTSTATUS status;
  83     SIZE_T stack_reserve = 0, stack_commit = 0;
  84
  85     if (flags & STACK_SIZE_PARAM_IS_A_RESERVATION) stack_reserve = stack;
  86     else stack_commit = stack;
  87
  88     status = RtlCreateUserThread( hProcess, NULL, TRUE,
  89                                   NULL, stack_reserve, stack_commit,
  90                                   (PRTL_THREAD_START_ROUTINE)start, param, &handle, &client_id );
  91     if (status == STATUS_SUCCESS)
  92     {
  93         if (id) *id = HandleToULong(client_id.UniqueThread);
  94         if (sa && (sa->nLength >= sizeof(*sa)) && sa->bInheritHandle)
  95             SetHandleInformation( handle, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT );
  96         if (!(flags & CREATE_SUSPENDED))
  97         {
  98             ULONG ret;
  99             if (NtResumeThread( handle, &ret ))
 100             {
 101                 NtClose( handle );
 102                 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 103                 handle = 0;
 104             }
 105         }
 106     }
 107     else
 108     {
 109         SetLastError( RtlNtStatusToDosError(status) );
 110         handle = 0;
 111     }
 112     return handle;
 113 }
 114
 115
 116 /***********************************************************************
 117  * OpenThread  [KERNEL32.@]   Retrieves a handle to a thread from its thread id
 118  */
 119 HANDLE WINAPI OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId )
 120 {
 121     NTSTATUS status;
 122     HANDLE handle;
 123     OBJECT_ATTRIBUTES attr;
 124     CLIENT_ID cid;
 125
 126     attr.Length = sizeof(attr);
 127     attr.RootDirectory = 0;
 128     attr.Attributes = bInheritHandle ? OBJ_INHERIT : 0;
 129     attr.ObjectName = NULL;
 130     attr.SecurityDescriptor = NULL;
 131     attr.SecurityQualityOfService = NULL;
 132
 133     cid.UniqueProcess = 0; /* FIXME */
 134     cid.UniqueThread = ULongToHandle(dwThreadId);
 135     status = NtOpenThread( &handle, dwDesiredAccess, &attr, &cid );
 136     if (status)
 137     {
 138         SetLastError( RtlNtStatusToDosError(status) );
 139         handle = 0;
 140     }
 141     return handle;
 142 }
 143
 144
 145 /***********************************************************************
 146  * ExitThread [KERNEL32.@]  Ends a thread
 147  *
 148  * RETURNS
 149  *    None
 150  */
 151 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
 152 {
 153     RtlExitUserThread( code );
 154 }
 155
 156
 157 /**********************************************************************
 158  * TerminateThread [KERNEL32.@]  Terminates a thread
 159  *
 160  * RETURNS
 161  *    Success: TRUE
 162  *    Failure: FALSE
 163  */
 164 BOOL WINAPI TerminateThread( HANDLE handle,    /* [in] Handle to thread */
 165                              DWORD exit_code)  /* [in] Exit code for thread */
 166 {
 167     NTSTATUS status = NtTerminateThread( handle, exit_code );
 168     if (status) SetLastError( RtlNtStatusToDosError(status) );
 169     return !status;
 170 }
 171
 172
 173 /***********************************************************************
 174  *           FreeLibraryAndExitThread (KERNEL32.@)
 175  */
 176 void WINAPI FreeLibraryAndExitThread(HINSTANCE hLibModule, DWORD dwExitCode)
 177 {
 178     FreeLibrary(hLibModule);
 179     ExitThread(dwExitCode);
 180 }
 181
 182
 183 /**********************************************************************
 184  *              GetExitCodeThread (KERNEL32.@)
 185  *
 186  * Gets termination status of thread.
 187  *
 188  * RETURNS
 189  *    Success: TRUE
 190  *    Failure: FALSE
 191  */
 192 BOOL WINAPI GetExitCodeThread(
 193     HANDLE hthread, /* [in]  Handle to thread */
 194     LPDWORD exitcode) /* [out] Address to receive termination status */
 195 {
 196     THREAD_BASIC_INFORMATION info;
 197     NTSTATUS status = NtQueryInformationThread( hthread, ThreadBasicInformation,
 198                                                 &info, sizeof(info), NULL );
 199
 200     if (status)
 201     {
 202         SetLastError( RtlNtStatusToDosError(status) );
 203         return FALSE;
 204     }
 205     if (exitcode) *exitcode = info.ExitStatus;
 206     return TRUE;
 207 }
 208
 209
 210 /***********************************************************************
 211  * SetThreadContext [KERNEL32.@]  Sets context of thread.
 212  *
 213  * RETURNS
 214  *    Success: TRUE
 215  *    Failure: FALSE
 216  */
 217 BOOL WINAPI SetThreadContext( HANDLE handle,           /* [in]  Handle to thread with context */
 218                               const CONTEXT *context ) /* [in] Address of context structure */
 219 {
 220     NTSTATUS status = NtSetContextThread( handle, context );
 221     if (status) SetLastError( RtlNtStatusToDosError(status) );
 222     return !status;
 223 }
 224
 225
 226 /***********************************************************************
 227  * GetThreadContext [KERNEL32.@]  Retrieves context of thread.
 228  *
 229  * RETURNS
 230  *    Success: TRUE
 231  *    Failure: FALSE
 232  */
 233 BOOL WINAPI GetThreadContext( HANDLE handle,     /* [in]  Handle to thread with context */
 234                               CONTEXT *context ) /* [out] Address of context structure */
 235 {
 236     NTSTATUS status = NtGetContextThread( handle, context );
 237     if (status) SetLastError( RtlNtStatusToDosError(status) );
 238     return !status;
 239 }
 240
 241
 242 /**********************************************************************
 243  * SuspendThread [KERNEL32.@]  Suspends a thread.
 244  *
 245  * RETURNS
 246  *    Success: Previous suspend count
 247  *    Failure: 0xFFFFFFFF
 248  */
 249 DWORD WINAPI SuspendThread( HANDLE hthread ) /* [in] Handle to the thread */
 250 {
 251     DWORD ret;
 252     NTSTATUS status = NtSuspendThread( hthread, &ret );
 253
 254     if (status)
 255     {
 256         ret = ~0U;
 257         SetLastError( RtlNtStatusToDosError(status) );
 258     }
 259     return ret;
 260 }
 261
 262
 263 /**********************************************************************
 264  * ResumeThread [KERNEL32.@]  Resumes a thread.
 265  *
 266  * Decrements a thread's suspend count.  When count is zero, the
 267  * execution of the thread is resumed.
 268  *
 269  * RETURNS
 270  *    Success: Previous suspend count
 271  *    Failure: 0xFFFFFFFF
 272  *    Already running: 0
 273  */
 274 DWORD WINAPI ResumeThread( HANDLE hthread ) /* [in] Identifies thread to restart */
 275 {
 276     DWORD ret;
 277     NTSTATUS status = NtResumeThread( hthread, &ret );
 278
 279     if (status)
 280     {
 281         ret = ~0U;
 282         SetLastError( RtlNtStatusToDosError(status) );
 283     }
 284     return ret;
 285 }
 286
 287
 288 /**********************************************************************
 289  * GetThreadPriority [KERNEL32.@]  Returns priority for thread.
 290  *
 291  * RETURNS
 292  *    Success: Thread's priority level.
 293  *    Failure: THREAD_PRIORITY_ERROR_RETURN
 294  */
 295 INT WINAPI GetThreadPriority(
 296     HANDLE hthread) /* [in] Handle to thread */
 297 {
 298     THREAD_BASIC_INFORMATION info;
 299     NTSTATUS status = NtQueryInformationThread( hthread, ThreadBasicInformation,
 300                                                 &info, sizeof(info), NULL );
 301
 302     if (status)
 303     {
 304         SetLastError( RtlNtStatusToDosError(status) );
 305         return THREAD_PRIORITY_ERROR_RETURN;
 306     }
 307     return info.Priority;
 308 }
 309
 310
 311 /**********************************************************************
 312  * SetThreadPriority [KERNEL32.@]  Sets priority for thread.
 313  *
 314  * RETURNS
 315  *    Success: TRUE
 316  *    Failure: FALSE
 317  */
 318 BOOL WINAPI SetThreadPriority(
 319     HANDLE hthread, /* [in] Handle to thread */
 320     INT priority)   /* [in] Thread priority level */
 321 {
 322     DWORD       prio = priority;
 323     NTSTATUS    status;
 324
 325     status = NtSetInformationThread(hthread, ThreadBasePriority,
 326                                     &prio, sizeof(prio));
 327
 328     if (status)
 329     {
 330         SetLastError( RtlNtStatusToDosError(status) );
 331         return FALSE;
 332     }
 333
 334     return TRUE;
 335 }
 336
 337
 338 /**********************************************************************
 339  * GetThreadPriorityBoost [KERNEL32.@]  Returns priority boost for thread.
 340  *
 341  * Always reports that priority boost is disabled.
 342  *
 343  * RETURNS
 344  *    Success: TRUE.
 345  *    Failure: FALSE
 346  */
 347 BOOL WINAPI GetThreadPriorityBoost(
 348     HANDLE hthread, /* [in] Handle to thread */
 349     PBOOL pstate)   /* [out] pointer to var that receives the boost state */
 350 {
 351     if (pstate) *pstate = FALSE;
 352     return TRUE;
 353 }
 354
 355
 356 /**********************************************************************
 357  * SetThreadPriorityBoost [KERNEL32.@]  Sets priority boost for thread.
 358  *
 359  * Priority boost is not implemented, but we return TRUE
 360  * anyway because some games crash otherwise.
 361  */
 362 BOOL WINAPI SetThreadPriorityBoost(
 363     HANDLE hthread, /* [in] Handle to thread */
 364     BOOL disable)   /* [in] TRUE to disable priority boost */
 365 {
 366     return TRUE;
 367 }
 368
 369
 370 /**********************************************************************
 371  *           SetThreadStackGuarantee   (KERNEL32.@)
 372  */
 373 BOOL WINAPI SetThreadStackGuarantee(PULONG stacksize)
 374 {
 375     static int once;
 376     if (once++ == 0)
 377         FIXME("(%p): stub\n", stacksize);
 378     return TRUE;
 379 }
 380
 381 /***********************************************************************
 382  *              GetThreadGroupAffinity (KERNEL32.@)
 383  */
 384 BOOL WINAPI GetThreadGroupAffinity( HANDLE thread, GROUP_AFFINITY *affinity )
 385 {
 386     NTSTATUS status;
 387
 388     if (!affinity)
 389     {
 390         SetLastError( ERROR_INVALID_PARAMETER );
 391         return FALSE;
 392     }
 393
 394     status = NtQueryInformationThread( thread, ThreadGroupInformation,
 395                                        affinity, sizeof(*affinity), NULL );
 396     if (status)
 397     {
 398         SetLastError( RtlNtStatusToDosError(status) );
 399         return FALSE;
 400     }
 401
 402     return TRUE;
 403 }
 404
 405 /***********************************************************************
 406  *              SetThreadGroupAffinity (KERNEL32.@)
 407  */
 408 BOOL WINAPI SetThreadGroupAffinity( HANDLE thread, const GROUP_AFFINITY *affinity_new,
 409                                     GROUP_AFFINITY *affinity_old )
 410 {
 411     NTSTATUS status;
 412
 413     if (affinity_old && !GetThreadGroupAffinity( thread, affinity_old ))
 414         return FALSE;
 415
 416     status = NtSetInformationThread( thread, ThreadGroupInformation,
 417                                      affinity_new, sizeof(*affinity_new) );
 418     if (status)
 419     {
 420         SetLastError( RtlNtStatusToDosError(status) );
 421         return FALSE;
 422     }
 423
 424     return TRUE;
 425 }
 426
 427 /**********************************************************************
 428  *           SetThreadAffinityMask   (KERNEL32.@)
 429  */
 430 DWORD_PTR WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD_PTR dwThreadAffinityMask )
 431 {
 432     NTSTATUS                    status;
 433     THREAD_BASIC_INFORMATION    tbi;
 434
 435     status = NtQueryInformationThread( hThread, ThreadBasicInformation,
 436                                        &tbi, sizeof(tbi), NULL );
 437     if (status)
 438     {
 439         SetLastError( RtlNtStatusToDosError(status) );
 440         return 0;
 441     }
 442     status = NtSetInformationThread( hThread, ThreadAffinityMask,
 443                                      &dwThreadAffinityMask,
 444                                      sizeof(dwThreadAffinityMask));
 445     if (status)
 446     {
 447         SetLastError( RtlNtStatusToDosError(status) );
 448         return 0;
 449     }
 450     return tbi.AffinityMask;
 451 }
 452
 453
 454 /**********************************************************************
 455  * SetThreadIdealProcessor [KERNEL32.@]  Sets preferred processor for thread.
 456  *
 457  * RETURNS
 458  *    Success: Value of last call to SetThreadIdealProcessor
 459  *    Failure: -1
 460  */
 461 DWORD WINAPI SetThreadIdealProcessor(
 462     HANDLE hThread,          /* [in] Specifies the thread of interest */
 463     DWORD dwIdealProcessor)  /* [in] Specifies the new preferred processor */
 464 {
 465     FIXME("(%p): stub\n",hThread);
 466     if (dwIdealProcessor > MAXIMUM_PROCESSORS)
 467     {
 468         SetLastError(ERROR_INVALID_PARAMETER);
 469         return ~0u;
 470     }
 471     return 0;
 472 }
 473
 474 /***********************************************************************
 475  *              SetThreadIdealProcessorEx (KERNEL32.@)
 476  */
 477 BOOL WINAPI SetThreadIdealProcessorEx( HANDLE thread, PROCESSOR_NUMBER *ideal, PROCESSOR_NUMBER *previous )
 478 {
 479     FIXME("(%p %p %p): stub\n", thread, ideal, previous);
 480     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 481     return FALSE;
 482 }
 483
 484 /***********************************************************************
 485  *           GetThreadSelectorEntry   (KERNEL32.@)
 486  */
 487 BOOL WINAPI GetThreadSelectorEntry( HANDLE hthread, DWORD sel, LPLDT_ENTRY ldtent )
 488 {
 489     THREAD_DESCRIPTOR_INFORMATION tdi;
 490     NTSTATUS status;
 491
 492     tdi.Selector = sel;
 493     status = NtQueryInformationThread( hthread, ThreadDescriptorTableEntry, &tdi, sizeof(tdi), NULL);
 494     if (status)
 495     {
 496         SetLastError( RtlNtStatusToDosError(status) );
 497         return FALSE;
 498     }
 499     *ldtent = tdi.Entry;
 500     return TRUE;
 501 }
 502
 503
 504 /* callback for QueueUserAPC */
 505 static void CALLBACK call_user_apc( ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3 )
 506 {
 507     PAPCFUNC func = (PAPCFUNC)arg1;
 508     func( arg2 );
 509 }
 510
 511 /***********************************************************************
 512  *              QueueUserAPC  (KERNEL32.@)
 513  */
 514 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
 515 {
 516     NTSTATUS status = NtQueueApcThread( hthread, call_user_apc, (ULONG_PTR)func, data, 0 );
 517
 518     if (status) SetLastError( RtlNtStatusToDosError(status) );
 519     return !status;
 520 }
 521
 522 /***********************************************************************
 523  *              QueueUserWorkItem  (KERNEL32.@)
 524  */
 525 BOOL WINAPI QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags )
 526 {
 527     NTSTATUS status;
 528
 529     TRACE("(%p,%p,0x%08x)\n", Function, Context, Flags);
 530
 531     status = RtlQueueWorkItem( Function, Context, Flags );
 532
 533     if (status) SetLastError( RtlNtStatusToDosError(status) );
 534     return !status;
 535 }
 536
 537 /**********************************************************************
 538  * GetThreadTimes [KERNEL32.@]  Obtains timing information.
 539  *
 540  * RETURNS
 541  *    Success: TRUE
 542  *    Failure: FALSE
 543  */
 544 BOOL WINAPI GetThreadTimes(
 545     HANDLE thread,         /* [in]  Specifies the thread of interest */
 546     LPFILETIME creationtime, /* [out] When the thread was created */
 547     LPFILETIME exittime,     /* [out] When the thread was destroyed */
 548     LPFILETIME kerneltime,   /* [out] Time thread spent in kernel mode */
 549     LPFILETIME usertime)     /* [out] Time thread spent in user mode */
 550 {
 551     KERNEL_USER_TIMES   kusrt;
 552     NTSTATUS            status;
 553
 554     status = NtQueryInformationThread(thread, ThreadTimes, &kusrt,
 555                                       sizeof(kusrt), NULL);
 556     if (status)
 557     {
 558         SetLastError( RtlNtStatusToDosError(status) );
 559         return FALSE;
 560     }
 561     if (creationtime)
 562     {
 563         creationtime->dwLowDateTime = kusrt.CreateTime.u.LowPart;
 564         creationtime->dwHighDateTime = kusrt.CreateTime.u.HighPart;
 565     }
 566     if (exittime)
 567     {
 568         exittime->dwLowDateTime = kusrt.ExitTime.u.LowPart;
 569         exittime->dwHighDateTime = kusrt.ExitTime.u.HighPart;
 570     }
 571     if (kerneltime)
 572     {
 573         kerneltime->dwLowDateTime = kusrt.KernelTime.u.LowPart;
 574         kerneltime->dwHighDateTime = kusrt.KernelTime.u.HighPart;
 575     }
 576     if (usertime)
 577     {
 578         usertime->dwLowDateTime = kusrt.UserTime.u.LowPart;
 579         usertime->dwHighDateTime = kusrt.UserTime.u.HighPart;
 580     }
 581
 582     return TRUE;
 583 }
 584
 585 /**********************************************************************
 586  * GetThreadId [KERNEL32.@]
 587  *
 588  * Retrieve the identifier of a thread.
 589  *
 590  * PARAMS
 591  *  Thread [I] The thread to retrieve the identifier of.
 592  *
 593  * RETURNS
 594  *    Success: Identifier of the target thread.
 595  *    Failure: 0
 596  */
 597 DWORD WINAPI GetThreadId(HANDLE Thread)
 598 {
 599     THREAD_BASIC_INFORMATION tbi;
 600     NTSTATUS status;
 601
 602     TRACE("(%p)\n", Thread);
 603
 604     status = NtQueryInformationThread(Thread, ThreadBasicInformation, &tbi,
 605                                       sizeof(tbi), NULL);
 606     if (status)
 607     {
 608         SetLastError( RtlNtStatusToDosError(status) );
 609         return 0;
 610     }
 611
 612     return HandleToULong(tbi.ClientId.UniqueThread);
 613 }
 614
 615 /**********************************************************************
 616  * GetProcessIdOfThread [KERNEL32.@]
 617  *
 618  * Retrieve process identifier given thread belongs to.
 619  *
 620  * PARAMS
 621  *  Thread [I] The thread identifier.
 622  *
 623  * RETURNS
 624  *    Success: Process identifier
 625  *    Failure: 0
 626  */
 627 DWORD WINAPI GetProcessIdOfThread(HANDLE Thread)
 628 {
 629     THREAD_BASIC_INFORMATION tbi;
 630     NTSTATUS status;
 631
 632     TRACE("(%p)\n", Thread);
 633
 634     status = NtQueryInformationThread(Thread, ThreadBasicInformation, &tbi,
 635                                       sizeof(tbi), NULL);
 636     if (status)
 637     {
 638         SetLastError( RtlNtStatusToDosError(status) );
 639         return 0;
 640     }
 641
 642     return HandleToULong(tbi.ClientId.UniqueProcess);
 643 }
 644
 645 /***********************************************************************
 646  * GetCurrentThread [KERNEL32.@]  Gets pseudohandle for current thread
 647  *
 648  * RETURNS
 649  *    Pseudohandle for the current thread
 650  */
 651 #undef GetCurrentThread
 652 HANDLE WINAPI GetCurrentThread(void)
 653 {
 654     return (HANDLE)~(ULONG_PTR)1;
 655 }
 656
 657
 658 #ifdef __i386__
 659
 660 /***********************************************************************
 661  *              SetLastError (KERNEL32.@)
 662  */
 663 /* void WINAPI SetLastError( DWORD error ); */
 664 __ASM_STDCALL_FUNC( SetLastError, 4,
 665                    "movl 4(%esp),%eax\n\t"
 666                    ".byte 0x64\n\t"
 667                    "movl %eax,0x34\n\t"
 668                    "ret $4" )
 669
 670 /***********************************************************************
 671  *              GetLastError (KERNEL32.@)
 672  */
 673 /* DWORD WINAPI GetLastError(void); */
 674 __ASM_STDCALL_FUNC( GetLastError, 0, ".byte 0x64\n\tmovl 0x34,%eax\n\tret" )
 675
 676 /***********************************************************************
 677  *              GetCurrentProcessId (KERNEL32.@)
 678  */
 679 /* DWORD WINAPI GetCurrentProcessId(void) */
 680 __ASM_STDCALL_FUNC( GetCurrentProcessId, 0, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" )
 681
 682 /***********************************************************************
 683  *              GetCurrentThreadId (KERNEL32.@)
 684  */
 685 /* DWORD WINAPI GetCurrentThreadId(void) */
 686 __ASM_STDCALL_FUNC( GetCurrentThreadId, 0, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" )
 687
 688 /***********************************************************************
 689  *              GetProcessHeap (KERNEL32.@)
 690  */
 691 /* HANDLE WINAPI GetProcessHeap(void) */
 692 __ASM_STDCALL_FUNC( GetProcessHeap, 0, ".byte 0x64\n\tmovl 0x30,%eax\n\tmovl 0x18(%eax),%eax\n\tret");
 693
 694 #elif defined(__x86_64__)
 695
 696 #ifdef __APPLE__
 697
 698 /***********************************************************************
 699  *              SetLastError (KERNEL32.@)
 700  */
 701 /* void WINAPI SetLastError( DWORD error ); */
 702 __ASM_STDCALL_FUNC( SetLastError, 8, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovl %ecx,0x68(%rax)\n\tret" );
 703
 704 /***********************************************************************
 705  *              GetLastError (KERNEL32.@)
 706  */
 707 /* DWORD WINAPI GetLastError(void); */
 708 __ASM_STDCALL_FUNC( GetLastError, 0, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovl 0x68(%rax),%eax\n\tret" );
 709
 710 /***********************************************************************
 711  *              GetCurrentProcessId (KERNEL32.@)
 712  */
 713 /* DWORD WINAPI GetCurrentProcessId(void) */
 714 __ASM_STDCALL_FUNC( GetCurrentProcessId, 0, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovl 0x40(%rax),%eax\n\tret" );
 715
 716 /***********************************************************************
 717  *              GetCurrentThreadId (KERNEL32.@)
 718  */
 719 /* DWORD WINAPI GetCurrentThreadId(void) */
 720 __ASM_STDCALL_FUNC( GetCurrentThreadId, 0, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovl 0x48(%rax),%eax\n\tret" );
 721
 722 /***********************************************************************
 723  *              GetProcessHeap (KERNEL32.@)
 724  */
 725 /* HANDLE WINAPI GetProcessHeap(void) */
 726 __ASM_STDCALL_FUNC( GetProcessHeap, 0, ".byte 0x65\n\tmovq 0x30,%rax\n\tmovq 0x60(%rax),%rax\n\tmovq 0x30(%rax),%rax\n\tret");
 727
 728 #else
 729
 730 /***********************************************************************
 731  *              SetLastError (KERNEL32.@)
 732  */
 733 /* void WINAPI SetLastError( DWORD error ); */
 734 __ASM_STDCALL_FUNC( SetLastError, 8, ".byte 0x65\n\tmovl %ecx,0x68\n\tret" );
 735
 736 /***********************************************************************
 737  *              GetLastError (KERNEL32.@)
 738  */
 739 /* DWORD WINAPI GetLastError(void); */
 740 __ASM_STDCALL_FUNC( GetLastError, 0, ".byte 0x65\n\tmovl 0x68,%eax\n\tret" );
 741
 742 /***********************************************************************
 743  *              GetCurrentProcessId (KERNEL32.@)
 744  */
 745 /* DWORD WINAPI GetCurrentProcessId(void) */
 746 __ASM_STDCALL_FUNC( GetCurrentProcessId, 0, ".byte 0x65\n\tmovl 0x40,%eax\n\tret" );
 747
 748 /***********************************************************************
 749  *              GetCurrentThreadId (KERNEL32.@)
 750  */
 751 /* DWORD WINAPI GetCurrentThreadId(void) */
 752 __ASM_STDCALL_FUNC( GetCurrentThreadId, 0, ".byte 0x65\n\tmovl 0x48,%eax\n\tret" );
 753
 754 /***********************************************************************
 755  *              GetProcessHeap (KERNEL32.@)
 756  */
 757 /* HANDLE WINAPI GetProcessHeap(void) */
 758 __ASM_STDCALL_FUNC( GetProcessHeap, 0, ".byte 0x65\n\tmovq 0x60,%rax\n\tmovq 0x30(%rax),%rax\n\tret");
 759
 760 #endif /* __APPLE__ */
 761
 762 #else  /* __x86_64__ */
 763
 764 /**********************************************************************
 765  *              SetLastError (KERNEL32.@)
 766  *
 767  * Sets the last-error code.
 768  *
 769  * RETURNS
 770  * Nothing.
 771  */
 772 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
 773 {
 774     NtCurrentTeb()->LastErrorValue = error;
 775 }
 776
 777 /**********************************************************************
 778  *              GetLastError (KERNEL32.@)
 779  *
 780  * Get the last-error code.
 781  *
 782  * RETURNS
 783  *  last-error code.
 784  */
 785 DWORD WINAPI GetLastError(void)
 786 {
 787     return NtCurrentTeb()->LastErrorValue;
 788 }
 789
 790 /***********************************************************************
 791  *              GetCurrentProcessId (KERNEL32.@)
 792  *
 793  * Get the current process identifier.
 794  *
 795  * RETURNS
 796  *  current process identifier
 797  */
 798 DWORD WINAPI GetCurrentProcessId(void)
 799 {
 800     return HandleToULong(NtCurrentTeb()->ClientId.UniqueProcess);
 801 }
 802
 803 /***********************************************************************
 804  *              GetCurrentThreadId (KERNEL32.@)
 805  *
 806  * Get the current thread identifier.
 807  *
 808  * RETURNS
 809  *  current thread identifier
 810  */
 811 DWORD WINAPI GetCurrentThreadId(void)
 812 {
 813     return HandleToULong(NtCurrentTeb()->ClientId.UniqueThread);
 814 }
 815
 816 /***********************************************************************
 817  *           GetProcessHeap    (KERNEL32.@)
 818  */
 819 HANDLE WINAPI GetProcessHeap(void)
 820 {
 821     return NtCurrentTeb()->Peb->ProcessHeap;
 822 }
 823
 824 #endif  /* __i386__ */
 825
 826 /*************************************************************************
 827  *              rtlmode_to_win32mode
 828  */
 829 static DWORD rtlmode_to_win32mode( DWORD rtlmode )
 830 {
 831     DWORD win32mode = 0;
 832
 833     if (rtlmode & 0x10)
 834         win32mode |= SEM_FAILCRITICALERRORS;
 835     if (rtlmode & 0x20)
 836         win32mode |= SEM_NOGPFAULTERRORBOX;
 837     if (rtlmode & 0x40)
 838         win32mode |= SEM_NOOPENFILEERRORBOX;
 839
 840     return win32mode;
 841 }
 842
 843 /***********************************************************************
 844  *              SetThreadErrorMode (KERNEL32.@)
 845  *
 846  * Set the thread local error mode.
 847  *
 848  * PARAMS
 849  *  mode    [I] The new error mode, a bitwise or of SEM_FAILCRITICALERRORS,
 850  *              SEM_NOGPFAULTERRORBOX and SEM_NOOPENFILEERRORBOX.
 851  *  oldmode [O] Destination of the old error mode (may be NULL)
 852  *
 853  * RETURNS
 854  *  Success: TRUE
 855  *  Failure: FALSE, check GetLastError
 856  */
 857 BOOL WINAPI SetThreadErrorMode( DWORD mode, LPDWORD oldmode )
 858 {
 859     NTSTATUS status;
 860     DWORD tmp = 0;
 861
 862     if (mode & ~(SEM_FAILCRITICALERRORS |
 863                  SEM_NOGPFAULTERRORBOX |
 864                  SEM_NOOPENFILEERRORBOX))
 865     {
 866         SetLastError( ERROR_INVALID_PARAMETER );
 867         return FALSE;
 868     }
 869
 870     if (mode & SEM_FAILCRITICALERRORS)
 871         tmp |= 0x10;
 872     if (mode & SEM_NOGPFAULTERRORBOX)
 873         tmp |= 0x20;
 874     if (mode & SEM_NOOPENFILEERRORBOX)
 875         tmp |= 0x40;
 876
 877     status = RtlSetThreadErrorMode( tmp, oldmode );
 878     if (status)
 879     {
 880         SetLastError( RtlNtStatusToDosError(status) );
 881         return FALSE;
 882     }
 883
 884     if (oldmode)
 885         *oldmode = rtlmode_to_win32mode(*oldmode);
 886
 887     return TRUE;
 888 }
 889
 890 /***********************************************************************
 891  *              GetThreadErrorMode (KERNEL32.@)
 892  *
 893  * Get the thread local error mode.
 894  *
 895  * PARAMS
 896  *  None.
 897  *
 898  * RETURNS
 899  *  The current thread local error mode.
 900  */
 901 DWORD WINAPI GetThreadErrorMode( void )
 902 {
 903     return rtlmode_to_win32mode( RtlGetThreadErrorMode() );
 904 }
 905
 906 /***********************************************************************
 907  *              GetThreadUILanguage (KERNEL32.@)
 908  *
 909  * Get the current thread's language identifier.
 910  *
 911  * PARAMS
 912  *  None.
 913  *
 914  * RETURNS
 915  *  The current thread's language identifier.
 916  */
 917 LANGID WINAPI GetThreadUILanguage( void )
 918 {
 919     LANGID lang;
 920     NtQueryDefaultUILanguage( &lang );
 921     FIXME(": stub, returning default language.\n");
 922     return lang;
 923 }
 924
 925 /***********************************************************************
 926  *              GetThreadIOPendingFlag (KERNEL32.@)
 927  */
 928 BOOL WINAPI GetThreadIOPendingFlag( HANDLE thread, PBOOL io_pending )
 929 {
 930     NTSTATUS status;
 931
 932     TRACE("%p, %p\n", thread, io_pending);
 933
 934     status = NtQueryInformationThread( thread, ThreadIsIoPending,
 935                                        io_pending, sizeof(*io_pending), NULL );
 936     if (status)
 937     {
 938         SetLastError( RtlNtStatusToDosError(status) );
 939         return FALSE;
 940     }
 941     return TRUE;
 942 }
 943
 944 /***********************************************************************
 945  *              CallbackMayRunLong (KERNEL32.@)
 946  */
 947 BOOL WINAPI CallbackMayRunLong( TP_CALLBACK_INSTANCE *instance )
 948 {
 949     NTSTATUS status;
 950
 951     TRACE( "%p\n", instance );
 952
 953     status = TpCallbackMayRunLong( instance );
 954     if (status)
 955     {
 956         SetLastError( RtlNtStatusToDosError(status) );
 957         return FALSE;
 958     }
 959
 960     return TRUE;
 961 }
 962
 963 /***********************************************************************
 964  *              CreateThreadpool (KERNEL32.@)
 965  */
 966 PTP_POOL WINAPI CreateThreadpool( PVOID reserved )
 967 {
 968     TP_POOL *pool;
 969     NTSTATUS status;
 970
 971     TRACE( "%p\n", reserved );
 972
 973     status = TpAllocPool( &pool, reserved );
 974     if (status)
 975     {
 976         SetLastError( RtlNtStatusToDosError(status) );
 977         return NULL;
 978     }
 979
 980     return pool;
 981 }
 982
 983 /***********************************************************************
 984  *              CreateThreadpoolCleanupGroup (KERNEL32.@)
 985  */
 986 PTP_CLEANUP_GROUP WINAPI CreateThreadpoolCleanupGroup( void )
 987 {
 988     TP_CLEANUP_GROUP *group;
 989     NTSTATUS status;
 990
 991     TRACE( "\n" );
 992
 993     status = TpAllocCleanupGroup( &group );
 994     if (status)
 995     {
 996         SetLastError( RtlNtStatusToDosError(status) );
 997         return NULL;
 998     }
 999
1000     return group;
1001 }
1002
1003 /***********************************************************************
1004  *              CreateThreadpoolIo (KERNEL32.@)
1005  */
1006 PTP_IO WINAPI CreateThreadpoolIo( HANDLE handle, PTP_WIN32_IO_CALLBACK callback,
1007                                   PVOID userdata, TP_CALLBACK_ENVIRON *environment )
1008 {
1009     FIXME("(%p, %p, %p, %p): stub\n", handle, callback, userdata, environment);
1010     return FALSE;
1011 }
1012
1013 /***********************************************************************
1014  *              CreateThreadpoolTimer (KERNEL32.@)
1015  */
1016 PTP_TIMER WINAPI CreateThreadpoolTimer( PTP_TIMER_CALLBACK callback, PVOID userdata,
1017                                         TP_CALLBACK_ENVIRON *environment )
1018 {
1019     TP_TIMER *timer;
1020     NTSTATUS status;
1021
1022     TRACE( "%p, %p, %p\n", callback, userdata, environment );
1023
1024     status = TpAllocTimer( &timer, callback, userdata, environment );
1025     if (status)
1026     {
1027         SetLastError( RtlNtStatusToDosError(status) );
1028         return NULL;
1029     }
1030
1031     return timer;
1032 }
1033
1034 /***********************************************************************
1035  *              CreateThreadpoolWait (KERNEL32.@)
1036  */
1037 PTP_WAIT WINAPI CreateThreadpoolWait( PTP_WAIT_CALLBACK callback, PVOID userdata,
1038                                       TP_CALLBACK_ENVIRON *environment )
1039 {
1040     TP_WAIT *wait;
1041     NTSTATUS status;
1042
1043     TRACE( "%p, %p, %p\n", callback, userdata, environment );
1044
1045     status = TpAllocWait( &wait, callback, userdata, environment );
1046     if (status)
1047     {
1048         SetLastError( RtlNtStatusToDosError(status) );
1049         return NULL;
1050     }
1051
1052     return wait;
1053 }
1054
1055 /***********************************************************************
1056  *              CreateThreadpoolWork (KERNEL32.@)
1057  */
1058 PTP_WORK WINAPI CreateThreadpoolWork( PTP_WORK_CALLBACK callback, PVOID userdata,
1059                                       TP_CALLBACK_ENVIRON *environment )
1060 {
1061     TP_WORK *work;
1062     NTSTATUS status;
1063
1064     TRACE( "%p, %p, %p\n", callback, userdata, environment );
1065
1066     status = TpAllocWork( &work, callback, userdata, environment );
1067     if (status)
1068     {
1069         SetLastError( RtlNtStatusToDosError(status) );
1070         return NULL;
1071     }
1072
1073     return work;
1074 }
1075
1076 /***********************************************************************
1077  *              SetThreadpoolTimer (KERNEL32.@)
1078  */
1079 VOID WINAPI SetThreadpoolTimer( TP_TIMER *timer, FILETIME *due_time,
1080                                 DWORD period, DWORD window_length )
1081 {
1082     LARGE_INTEGER timeout;
1083
1084     TRACE( "%p, %p, %u, %u\n", timer, due_time, period, window_length );
1085
1086     if (due_time)
1087     {
1088         timeout.u.LowPart = due_time->dwLowDateTime;
1089         timeout.u.HighPart = due_time->dwHighDateTime;
1090     }
1091
1092     TpSetTimer( timer, due_time ? &timeout : NULL, period, window_length );
1093 }
1094
1095 /***********************************************************************
1096  *              SetThreadpoolWait (KERNEL32.@)
1097  */
1098 VOID WINAPI SetThreadpoolWait( TP_WAIT *wait, HANDLE handle, FILETIME *due_time )
1099 {
1100     LARGE_INTEGER timeout;
1101
1102     TRACE( "%p, %p, %p\n", wait, handle, due_time );
1103
1104     if (!handle)
1105     {
1106         due_time = NULL;
1107     }
1108     else if (due_time)
1109     {
1110         timeout.u.LowPart = due_time->dwLowDateTime;
1111         timeout.u.HighPart = due_time->dwHighDateTime;
1112     }
1113
1114     TpSetWait( wait, handle, due_time ? &timeout : NULL );
1115 }
1116
1117 /***********************************************************************
1118  *              TrySubmitThreadpoolCallback (KERNEL32.@)
1119  */
1120 BOOL WINAPI TrySubmitThreadpoolCallback( PTP_SIMPLE_CALLBACK callback, PVOID userdata,
1121                                          TP_CALLBACK_ENVIRON *environment )
1122 {
1123     NTSTATUS status;
1124
1125     TRACE( "%p, %p, %p\n", callback, userdata, environment );
1126
1127     status = TpSimpleTryPost( callback, userdata, environment );
1128     if (status)
1129     {
1130         SetLastError( RtlNtStatusToDosError(status) );
1131         return FALSE;
1132     }
1133
1134     return TRUE;
1135 }