git.oblomov.eu Git - wine/blob - 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/winbase16.h"
  39 #include "wine/exception.h"
  40 #include "wine/library.h"
  41 #include "wine/server.h"
  42 #include "wine/debug.h"
  43
  44 #include "kernel_private.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(thread);
  47
  48
  49 /***********************************************************************
  50  *           CreateThread   (KERNEL32.@)
  51  */
  52 HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, SIZE_T stack,
  53                             LPTHREAD_START_ROUTINE start, LPVOID param,
  54                             DWORD flags, LPDWORD id )
  55 {
  56      return CreateRemoteThread( GetCurrentProcess(),
  57                                 sa, stack, start, param, flags, id );
  58 }
  59
  60
  61 /***************************************************************************
  62  *                  CreateRemoteThread   (KERNEL32.@)
  63  *
  64  * Creates a thread that runs in the address space of another process
  65  *
  66  * PARAMS
  67  *
  68  * RETURNS
  69  *   Success: Handle to the new thread.
  70  *   Failure: NULL. Use GetLastError() to find the error cause.
  71  *
  72  * BUGS
  73  *   Improper memory allocation: there's no ability to free new_thread_info
  74  *   in other process.
  75  *   Bad start address for RtlCreateUserThread because the library
  76  *   may be loaded at different address in other process.
  77  */
  78 HANDLE WINAPI CreateRemoteThread( HANDLE hProcess, SECURITY_ATTRIBUTES *sa, SIZE_T stack,
  79                                   LPTHREAD_START_ROUTINE start, LPVOID param,
  80                                   DWORD flags, LPDWORD id )
  81 {
  82     HANDLE handle;
  83     CLIENT_ID client_id;
  84     NTSTATUS status;
  85     SIZE_T stack_reserve = 0, stack_commit = 0;
  86
  87     if (flags & STACK_SIZE_PARAM_IS_A_RESERVATION) stack_reserve = stack;
  88     else stack_commit = stack;
  89
  90     status = RtlCreateUserThread( hProcess, NULL, TRUE,
  91                                   NULL, stack_reserve, stack_commit,
  92                                   (PRTL_THREAD_START_ROUTINE)start, param, &handle, &client_id );
  93     if (status == STATUS_SUCCESS)
  94     {
  95         if (id) *id = HandleToULong(client_id.UniqueThread);
  96         if (sa && (sa->nLength >= sizeof(*sa)) && sa->bInheritHandle)
  97             SetHandleInformation( handle, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT );
  98         if (!(flags & CREATE_SUSPENDED))
  99         {
 100             ULONG ret;
 101             if (NtResumeThread( handle, &ret ))
 102             {
 103                 NtClose( handle );
 104                 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 105                 handle = 0;
 106             }
 107         }
 108     }
 109     else
 110     {
 111         SetLastError( RtlNtStatusToDosError(status) );
 112         handle = 0;
 113     }
 114     return handle;
 115 }
 116
 117
 118 /***********************************************************************
 119  * OpenThread  [KERNEL32.@]   Retrieves a handle to a thread from its thread id
 120  */
 121 HANDLE WINAPI OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId )
 122 {
 123     NTSTATUS status;
 124     HANDLE handle;
 125     OBJECT_ATTRIBUTES attr;
 126     CLIENT_ID cid;
 127
 128     attr.Length = sizeof(attr);
 129     attr.RootDirectory = 0;
 130     attr.Attributes = bInheritHandle ? OBJ_INHERIT : 0;
 131     attr.ObjectName = NULL;
 132     attr.SecurityDescriptor = NULL;
 133     attr.SecurityQualityOfService = NULL;
 134
 135     cid.UniqueProcess = 0; /* FIXME */
 136     cid.UniqueThread = ULongToHandle(dwThreadId);
 137     status = NtOpenThread( &handle, dwDesiredAccess, &attr, &cid );
 138     if (status)
 139     {
 140         SetLastError( RtlNtStatusToDosError(status) );
 141         handle = 0;
 142     }
 143     return handle;
 144 }
 145
 146
 147 /***********************************************************************
 148  * ExitThread [KERNEL32.@]  Ends a thread
 149  *
 150  * RETURNS
 151  *    None
 152  */
 153 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
 154 {
 155     RtlFreeThreadActivationContextStack();
 156     RtlExitUserThread( code );
 157 }
 158
 159
 160 /**********************************************************************
 161  * TerminateThread [KERNEL32.@]  Terminates a thread
 162  *
 163  * RETURNS
 164  *    Success: TRUE
 165  *    Failure: FALSE
 166  */
 167 BOOL WINAPI TerminateThread( HANDLE handle,    /* [in] Handle to thread */
 168                              DWORD exit_code)  /* [in] Exit code for thread */
 169 {
 170     NTSTATUS status = NtTerminateThread( handle, exit_code );
 171     if (status) SetLastError( RtlNtStatusToDosError(status) );
 172     return !status;
 173 }
 174
 175
 176 /***********************************************************************
 177  *           FreeLibraryAndExitThread (KERNEL32.@)
 178  */
 179 void WINAPI FreeLibraryAndExitThread(HINSTANCE hLibModule, DWORD dwExitCode)
 180 {
 181     FreeLibrary(hLibModule);
 182     ExitThread(dwExitCode);
 183 }
 184
 185
 186 /**********************************************************************
 187  *              GetExitCodeThread (KERNEL32.@)
 188  *
 189  * Gets termination status of thread.
 190  *
 191  * RETURNS
 192  *    Success: TRUE
 193  *    Failure: FALSE
 194  */
 195 BOOL WINAPI GetExitCodeThread(
 196     HANDLE hthread, /* [in]  Handle to thread */
 197     LPDWORD exitcode) /* [out] Address to receive termination status */
 198 {
 199     THREAD_BASIC_INFORMATION info;
 200     NTSTATUS status = NtQueryInformationThread( hthread, ThreadBasicInformation,
 201                                                 &info, sizeof(info), NULL );
 202
 203     if (status)
 204     {
 205         SetLastError( RtlNtStatusToDosError(status) );
 206         return FALSE;
 207     }
 208     if (exitcode) *exitcode = info.ExitStatus;
 209     return TRUE;
 210 }
 211
 212
 213 /***********************************************************************
 214  * SetThreadContext [KERNEL32.@]  Sets context of thread.
 215  *
 216  * RETURNS
 217  *    Success: TRUE
 218  *    Failure: FALSE
 219  */
 220 BOOL WINAPI SetThreadContext( HANDLE handle,           /* [in]  Handle to thread with context */
 221                               const CONTEXT *context ) /* [in] Address of context structure */
 222 {
 223     NTSTATUS status = NtSetContextThread( handle, context );
 224     if (status) SetLastError( RtlNtStatusToDosError(status) );
 225     return !status;
 226 }
 227
 228
 229 /***********************************************************************
 230  * GetThreadContext [KERNEL32.@]  Retrieves context of thread.
 231  *
 232  * RETURNS
 233  *    Success: TRUE
 234  *    Failure: FALSE
 235  */
 236 BOOL WINAPI GetThreadContext( HANDLE handle,     /* [in]  Handle to thread with context */
 237                               CONTEXT *context ) /* [out] Address of context structure */
 238 {
 239     NTSTATUS status = NtGetContextThread( handle, context );
 240     if (status) SetLastError( RtlNtStatusToDosError(status) );
 241     return !status;
 242 }
 243
 244
 245 /**********************************************************************
 246  * SuspendThread [KERNEL32.@]  Suspends a thread.
 247  *
 248  * RETURNS
 249  *    Success: Previous suspend count
 250  *    Failure: 0xFFFFFFFF
 251  */
 252 DWORD WINAPI SuspendThread( HANDLE hthread ) /* [in] Handle to the thread */
 253 {
 254     DWORD ret;
 255     NTSTATUS status = NtSuspendThread( hthread, &ret );
 256
 257     if (status)
 258     {
 259         ret = ~0U;
 260         SetLastError( RtlNtStatusToDosError(status) );
 261     }
 262     return ret;
 263 }
 264
 265
 266 /**********************************************************************
 267  * ResumeThread [KERNEL32.@]  Resumes a thread.
 268  *
 269  * Decrements a thread's suspend count.  When count is zero, the
 270  * execution of the thread is resumed.
 271  *
 272  * RETURNS
 273  *    Success: Previous suspend count
 274  *    Failure: 0xFFFFFFFF
 275  *    Already running: 0
 276  */
 277 DWORD WINAPI ResumeThread( HANDLE hthread ) /* [in] Identifies thread to restart */
 278 {
 279     DWORD ret;
 280     NTSTATUS status = NtResumeThread( hthread, &ret );
 281
 282     if (status)
 283     {
 284         ret = ~0U;
 285         SetLastError( RtlNtStatusToDosError(status) );
 286     }
 287     return ret;
 288 }
 289
 290
 291 /**********************************************************************
 292  * GetThreadPriority [KERNEL32.@]  Returns priority for thread.
 293  *
 294  * RETURNS
 295  *    Success: Thread's priority level.
 296  *    Failure: THREAD_PRIORITY_ERROR_RETURN
 297  */
 298 INT WINAPI GetThreadPriority(
 299     HANDLE hthread) /* [in] Handle to thread */
 300 {
 301     THREAD_BASIC_INFORMATION info;
 302     NTSTATUS status = NtQueryInformationThread( hthread, ThreadBasicInformation,
 303                                                 &info, sizeof(info), NULL );
 304
 305     if (status)
 306     {
 307         SetLastError( RtlNtStatusToDosError(status) );
 308         return THREAD_PRIORITY_ERROR_RETURN;
 309     }
 310     return info.Priority;
 311 }
 312
 313
 314 /**********************************************************************
 315  * SetThreadPriority [KERNEL32.@]  Sets priority for thread.
 316  *
 317  * RETURNS
 318  *    Success: TRUE
 319  *    Failure: FALSE
 320  */
 321 BOOL WINAPI SetThreadPriority(
 322     HANDLE hthread, /* [in] Handle to thread */
 323     INT priority)   /* [in] Thread priority level */
 324 {
 325     DWORD       prio = priority;
 326     NTSTATUS    status;
 327
 328     status = NtSetInformationThread(hthread, ThreadBasePriority,
 329                                     &prio, sizeof(prio));
 330
 331     if (status)
 332     {
 333         SetLastError( RtlNtStatusToDosError(status) );
 334         return FALSE;
 335     }
 336
 337     return TRUE;
 338 }
 339
 340
 341 /**********************************************************************
 342  * GetThreadPriorityBoost [KERNEL32.@]  Returns priority boost for thread.
 343  *
 344  * Always reports that priority boost is disabled.
 345  *
 346  * RETURNS
 347  *    Success: TRUE.
 348  *    Failure: FALSE
 349  */
 350 BOOL WINAPI GetThreadPriorityBoost(
 351     HANDLE hthread, /* [in] Handle to thread */
 352     PBOOL pstate)   /* [out] pointer to var that receives the boost state */
 353 {
 354     if (pstate) *pstate = FALSE;
 355     return TRUE;
 356 }
 357
 358
 359 /**********************************************************************
 360  * SetThreadPriorityBoost [KERNEL32.@]  Sets priority boost for thread.
 361  *
 362  * Priority boost is not implemented. This function always returns
 363  * FALSE and sets last error to ERROR_CALL_NOT_IMPLEMENTED
 364  *
 365  * RETURNS
 366  *    Always returns FALSE to indicate a failure
 367  */
 368 BOOL WINAPI SetThreadPriorityBoost(
 369     HANDLE hthread, /* [in] Handle to thread */
 370     BOOL disable)   /* [in] TRUE to disable priority boost */
 371 {
 372     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 373     return FALSE;
 374 }
 375
 376
 377 /**********************************************************************
 378  *           SetThreadAffinityMask   (KERNEL32.@)
 379  */
 380 DWORD_PTR WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD_PTR dwThreadAffinityMask )
 381 {
 382     NTSTATUS                    status;
 383     THREAD_BASIC_INFORMATION    tbi;
 384
 385     status = NtQueryInformationThread( hThread, ThreadBasicInformation,
 386                                        &tbi, sizeof(tbi), NULL );
 387     if (status)
 388     {
 389         SetLastError( RtlNtStatusToDosError(status) );
 390         return 0;
 391     }
 392     status = NtSetInformationThread( hThread, ThreadAffinityMask,
 393                                      &dwThreadAffinityMask,
 394                                      sizeof(dwThreadAffinityMask));
 395     if (status)
 396     {
 397         SetLastError( RtlNtStatusToDosError(status) );
 398         return 0;
 399     }
 400     return tbi.AffinityMask;
 401 }
 402
 403
 404 /**********************************************************************
 405  * SetThreadIdealProcessor [KERNEL32.@]  Sets preferred processor for thread.
 406  *
 407  * RETURNS
 408  *    Success: Value of last call to SetThreadIdealProcessor
 409  *    Failure: -1
 410  */
 411 DWORD WINAPI SetThreadIdealProcessor(
 412     HANDLE hThread,          /* [in] Specifies the thread of interest */
 413     DWORD dwIdealProcessor)  /* [in] Specifies the new preferred processor */
 414 {
 415     FIXME("(%p): stub\n",hThread);
 416     if (dwIdealProcessor > MAXIMUM_PROCESSORS)
 417     {
 418         SetLastError(ERROR_INVALID_PARAMETER);
 419         return ~0u;
 420     }
 421     return 0;
 422 }
 423
 424
 425 /* callback for QueueUserAPC */
 426 static void CALLBACK call_user_apc( ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3 )
 427 {
 428     PAPCFUNC func = (PAPCFUNC)arg1;
 429     func( arg2 );
 430 }
 431
 432 /***********************************************************************
 433  *              QueueUserAPC  (KERNEL32.@)
 434  */
 435 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
 436 {
 437     NTSTATUS status = NtQueueApcThread( hthread, call_user_apc, (ULONG_PTR)func, data, 0 );
 438
 439     if (status) SetLastError( RtlNtStatusToDosError(status) );
 440     return !status;
 441 }
 442
 443 /***********************************************************************
 444  *              QueueUserWorkItem  (KERNEL32.@)
 445  */
 446 BOOL WINAPI QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags )
 447 {
 448     NTSTATUS status;
 449
 450     TRACE("(%p,%p,0x%08x)\n", Function, Context, Flags);
 451
 452     status = RtlQueueWorkItem( Function, Context, Flags );
 453
 454     if (status) SetLastError( RtlNtStatusToDosError(status) );
 455     return !status;
 456 }
 457
 458 /**********************************************************************
 459  * GetThreadTimes [KERNEL32.@]  Obtains timing information.
 460  *
 461  * RETURNS
 462  *    Success: TRUE
 463  *    Failure: FALSE
 464  */
 465 BOOL WINAPI GetThreadTimes(
 466     HANDLE thread,         /* [in]  Specifies the thread of interest */
 467     LPFILETIME creationtime, /* [out] When the thread was created */
 468     LPFILETIME exittime,     /* [out] When the thread was destroyed */
 469     LPFILETIME kerneltime,   /* [out] Time thread spent in kernel mode */
 470     LPFILETIME usertime)     /* [out] Time thread spent in user mode */
 471 {
 472     KERNEL_USER_TIMES   kusrt;
 473     NTSTATUS            status;
 474
 475     status = NtQueryInformationThread(thread, ThreadTimes, &kusrt,
 476                                       sizeof(kusrt), NULL);
 477     if (status)
 478     {
 479         SetLastError( RtlNtStatusToDosError(status) );
 480         return FALSE;
 481     }
 482     if (creationtime)
 483     {
 484         creationtime->dwLowDateTime = kusrt.CreateTime.u.LowPart;
 485         creationtime->dwHighDateTime = kusrt.CreateTime.u.HighPart;
 486     }
 487     if (exittime)
 488     {
 489         exittime->dwLowDateTime = kusrt.ExitTime.u.LowPart;
 490         exittime->dwHighDateTime = kusrt.ExitTime.u.HighPart;
 491     }
 492     if (kerneltime)
 493     {
 494         kerneltime->dwLowDateTime = kusrt.KernelTime.u.LowPart;
 495         kerneltime->dwHighDateTime = kusrt.KernelTime.u.HighPart;
 496     }
 497     if (usertime)
 498     {
 499         usertime->dwLowDateTime = kusrt.UserTime.u.LowPart;
 500         usertime->dwHighDateTime = kusrt.UserTime.u.HighPart;
 501     }
 502
 503     return TRUE;
 504 }
 505
 506 /**********************************************************************
 507  * GetThreadId [KERNEL32.@]
 508  *
 509  * Retrieve the identifier of a thread.
 510  *
 511  * PARAMS
 512  *  Thread [I] The thread to retrieve the identifier of.
 513  *
 514  * RETURNS
 515  *    Success: Identifier of the target thread.
 516  *    Failure: 0
 517  */
 518 DWORD WINAPI GetThreadId(HANDLE Thread)
 519 {
 520     THREAD_BASIC_INFORMATION tbi;
 521     NTSTATUS status;
 522
 523     TRACE("(%p)\n", Thread);
 524
 525     status = NtQueryInformationThread(Thread, ThreadBasicInformation, &tbi,
 526                                       sizeof(tbi), NULL);
 527     if (status)
 528     {
 529         SetLastError( RtlNtStatusToDosError(status) );
 530         return 0;
 531     }
 532
 533     return HandleToULong(tbi.ClientId.UniqueThread);
 534 }
 535
 536
 537 /**********************************************************************
 538  * VWin32_BoostThreadGroup [KERNEL.535]
 539  */
 540 VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
 541 {
 542     FIXME("(0x%08x,%d): stub\n", threadId, boost);
 543 }
 544
 545
 546 /**********************************************************************
 547  * VWin32_BoostThreadStatic [KERNEL.536]
 548  */
 549 VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT boost )
 550 {
 551     FIXME("(0x%08x,%d): stub\n", threadId, boost);
 552 }
 553
 554
 555 /***********************************************************************
 556  * GetCurrentThread [KERNEL32.@]  Gets pseudohandle for current thread
 557  *
 558  * RETURNS
 559  *    Pseudohandle for the current thread
 560  */
 561 #undef GetCurrentThread
 562 HANDLE WINAPI GetCurrentThread(void)
 563 {
 564     return (HANDLE)~(ULONG_PTR)1;
 565 }
 566
 567
 568 #ifdef __i386__
 569
 570 /***********************************************************************
 571  *              SetLastError (KERNEL.147)
 572  *              SetLastError (KERNEL32.@)
 573  */
 574 /* void WINAPI SetLastError( DWORD error ); */
 575 __ASM_STDCALL_FUNC( SetLastError, 4,
 576                    "movl 4(%esp),%eax\n\t"
 577                    ".byte 0x64\n\t"
 578                    "movl %eax,0x34\n\t"
 579                    "ret $4" )
 580
 581 /***********************************************************************
 582  *              GetLastError (KERNEL.148)
 583  *              GetLastError (KERNEL32.@)
 584  */
 585 /* DWORD WINAPI GetLastError(void); */
 586 __ASM_STDCALL_FUNC( GetLastError, 0, ".byte 0x64\n\tmovl 0x34,%eax\n\tret" )
 587
 588 /***********************************************************************
 589  *              GetCurrentProcessId (KERNEL.471)
 590  *              GetCurrentProcessId (KERNEL32.@)
 591  */
 592 /* DWORD WINAPI GetCurrentProcessId(void) */
 593 __ASM_STDCALL_FUNC( GetCurrentProcessId, 0, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" )
 594
 595 /***********************************************************************
 596  *              GetCurrentThreadId (KERNEL.462)
 597  *              GetCurrentThreadId (KERNEL32.@)
 598  */
 599 /* DWORD WINAPI GetCurrentThreadId(void) */
 600 __ASM_STDCALL_FUNC( GetCurrentThreadId, 0, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" )
 601
 602 #else  /* __i386__ */
 603
 604 /**********************************************************************
 605  *              SetLastError (KERNEL.147)
 606  *              SetLastError (KERNEL32.@)
 607  *
 608  * Sets the last-error code.
 609  *
 610  * RETURNS
 611  * Nothing.
 612  */
 613 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
 614 {
 615     NtCurrentTeb()->LastErrorValue = error;
 616 }
 617
 618 /**********************************************************************
 619  *              GetLastError (KERNEL.148)
 620  *              GetLastError (KERNEL32.@)
 621  *
 622  * Get the last-error code.
 623  *
 624  * RETURNS
 625  *  last-error code.
 626  */
 627 DWORD WINAPI GetLastError(void)
 628 {
 629     return NtCurrentTeb()->LastErrorValue;
 630 }
 631
 632 /***********************************************************************
 633  *              GetCurrentProcessId (KERNEL.471)
 634  *              GetCurrentProcessId (KERNEL32.@)
 635  *
 636  * Get the current process identifier.
 637  *
 638  * RETURNS
 639  *  current process identifier
 640  */
 641 DWORD WINAPI GetCurrentProcessId(void)
 642 {
 643     return HandleToULong(NtCurrentTeb()->ClientId.UniqueProcess);
 644 }
 645
 646 /***********************************************************************
 647  *              GetCurrentThreadId (KERNEL.462)
 648  *              GetCurrentThreadId (KERNEL32.@)
 649  *
 650  * Get the current thread identifier.
 651  *
 652  * RETURNS
 653  *  current thread identifier
 654  */
 655 DWORD WINAPI GetCurrentThreadId(void)
 656 {
 657     return HandleToULong(NtCurrentTeb()->ClientId.UniqueThread);
 658 }
 659
 660 #endif  /* __i386__ */