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 /***********************************************************************
 426  *           GetThreadSelectorEntry   (KERNEL32.@)
 427  */
 428 BOOL WINAPI GetThreadSelectorEntry( HANDLE hthread, DWORD sel, LPLDT_ENTRY ldtent )
 429 {
 430     THREAD_DESCRIPTOR_INFORMATION tdi;
 431     NTSTATUS status;
 432
 433     tdi.Selector = sel;
 434     status = NtQueryInformationThread( hthread, ThreadDescriptorTableEntry, &tdi, sizeof(tdi), NULL);
 435     if (status)
 436     {
 437         SetLastError( RtlNtStatusToDosError(status) );
 438         return FALSE;
 439     }
 440     *ldtent = tdi.Entry;
 441     return TRUE;
 442 }
 443
 444
 445 /* callback for QueueUserAPC */
 446 static void CALLBACK call_user_apc( ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3 )
 447 {
 448     PAPCFUNC func = (PAPCFUNC)arg1;
 449     func( arg2 );
 450 }
 451
 452 /***********************************************************************
 453  *              QueueUserAPC  (KERNEL32.@)
 454  */
 455 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
 456 {
 457     NTSTATUS status = NtQueueApcThread( hthread, call_user_apc, (ULONG_PTR)func, data, 0 );
 458
 459     if (status) SetLastError( RtlNtStatusToDosError(status) );
 460     return !status;
 461 }
 462
 463 /***********************************************************************
 464  *              QueueUserWorkItem  (KERNEL32.@)
 465  */
 466 BOOL WINAPI QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags )
 467 {
 468     NTSTATUS status;
 469
 470     TRACE("(%p,%p,0x%08x)\n", Function, Context, Flags);
 471
 472     status = RtlQueueWorkItem( Function, Context, Flags );
 473
 474     if (status) SetLastError( RtlNtStatusToDosError(status) );
 475     return !status;
 476 }
 477
 478 /**********************************************************************
 479  * GetThreadTimes [KERNEL32.@]  Obtains timing information.
 480  *
 481  * RETURNS
 482  *    Success: TRUE
 483  *    Failure: FALSE
 484  */
 485 BOOL WINAPI GetThreadTimes(
 486     HANDLE thread,         /* [in]  Specifies the thread of interest */
 487     LPFILETIME creationtime, /* [out] When the thread was created */
 488     LPFILETIME exittime,     /* [out] When the thread was destroyed */
 489     LPFILETIME kerneltime,   /* [out] Time thread spent in kernel mode */
 490     LPFILETIME usertime)     /* [out] Time thread spent in user mode */
 491 {
 492     KERNEL_USER_TIMES   kusrt;
 493     NTSTATUS            status;
 494
 495     status = NtQueryInformationThread(thread, ThreadTimes, &kusrt,
 496                                       sizeof(kusrt), NULL);
 497     if (status)
 498     {
 499         SetLastError( RtlNtStatusToDosError(status) );
 500         return FALSE;
 501     }
 502     if (creationtime)
 503     {
 504         creationtime->dwLowDateTime = kusrt.CreateTime.u.LowPart;
 505         creationtime->dwHighDateTime = kusrt.CreateTime.u.HighPart;
 506     }
 507     if (exittime)
 508     {
 509         exittime->dwLowDateTime = kusrt.ExitTime.u.LowPart;
 510         exittime->dwHighDateTime = kusrt.ExitTime.u.HighPart;
 511     }
 512     if (kerneltime)
 513     {
 514         kerneltime->dwLowDateTime = kusrt.KernelTime.u.LowPart;
 515         kerneltime->dwHighDateTime = kusrt.KernelTime.u.HighPart;
 516     }
 517     if (usertime)
 518     {
 519         usertime->dwLowDateTime = kusrt.UserTime.u.LowPart;
 520         usertime->dwHighDateTime = kusrt.UserTime.u.HighPart;
 521     }
 522
 523     return TRUE;
 524 }
 525
 526 /**********************************************************************
 527  * GetThreadId [KERNEL32.@]
 528  *
 529  * Retrieve the identifier of a thread.
 530  *
 531  * PARAMS
 532  *  Thread [I] The thread to retrieve the identifier of.
 533  *
 534  * RETURNS
 535  *    Success: Identifier of the target thread.
 536  *    Failure: 0
 537  */
 538 DWORD WINAPI GetThreadId(HANDLE Thread)
 539 {
 540     THREAD_BASIC_INFORMATION tbi;
 541     NTSTATUS status;
 542
 543     TRACE("(%p)\n", Thread);
 544
 545     status = NtQueryInformationThread(Thread, ThreadBasicInformation, &tbi,
 546                                       sizeof(tbi), NULL);
 547     if (status)
 548     {
 549         SetLastError( RtlNtStatusToDosError(status) );
 550         return 0;
 551     }
 552
 553     return HandleToULong(tbi.ClientId.UniqueThread);
 554 }
 555
 556
 557 /***********************************************************************
 558  * GetCurrentThread [KERNEL32.@]  Gets pseudohandle for current thread
 559  *
 560  * RETURNS
 561  *    Pseudohandle for the current thread
 562  */
 563 #undef GetCurrentThread
 564 HANDLE WINAPI GetCurrentThread(void)
 565 {
 566     return (HANDLE)~(ULONG_PTR)1;
 567 }
 568
 569
 570 #ifdef __i386__
 571
 572 /***********************************************************************
 573  *              SetLastError (KERNEL32.@)
 574  */
 575 /* void WINAPI SetLastError( DWORD error ); */
 576 __ASM_STDCALL_FUNC( SetLastError, 4,
 577                    "movl 4(%esp),%eax\n\t"
 578                    ".byte 0x64\n\t"
 579                    "movl %eax,0x34\n\t"
 580                    "ret $4" )
 581
 582 /***********************************************************************
 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 (KERNEL32.@)
 590  */
 591 /* DWORD WINAPI GetCurrentProcessId(void) */
 592 __ASM_STDCALL_FUNC( GetCurrentProcessId, 0, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" )
 593
 594 /***********************************************************************
 595  *              GetCurrentThreadId (KERNEL32.@)
 596  */
 597 /* DWORD WINAPI GetCurrentThreadId(void) */
 598 __ASM_STDCALL_FUNC( GetCurrentThreadId, 0, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" )
 599
 600 #else  /* __i386__ */
 601
 602 /**********************************************************************
 603  *              SetLastError (KERNEL32.@)
 604  *
 605  * Sets the last-error code.
 606  *
 607  * RETURNS
 608  * Nothing.
 609  */
 610 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
 611 {
 612     NtCurrentTeb()->LastErrorValue = error;
 613 }
 614
 615 /**********************************************************************
 616  *              GetLastError (KERNEL32.@)
 617  *
 618  * Get the last-error code.
 619  *
 620  * RETURNS
 621  *  last-error code.
 622  */
 623 DWORD WINAPI GetLastError(void)
 624 {
 625     return NtCurrentTeb()->LastErrorValue;
 626 }
 627
 628 /***********************************************************************
 629  *              GetCurrentProcessId (KERNEL32.@)
 630  *
 631  * Get the current process identifier.
 632  *
 633  * RETURNS
 634  *  current process identifier
 635  */
 636 DWORD WINAPI GetCurrentProcessId(void)
 637 {
 638     return HandleToULong(NtCurrentTeb()->ClientId.UniqueProcess);
 639 }
 640
 641 /***********************************************************************
 642  *              GetCurrentThreadId (KERNEL32.@)
 643  *
 644  * Get the current thread identifier.
 645  *
 646  * RETURNS
 647  *  current thread identifier
 648  */
 649 DWORD WINAPI GetCurrentThreadId(void)
 650 {
 651     return HandleToULong(NtCurrentTeb()->ClientId.UniqueThread);
 652 }
 653
 654 #endif  /* __i386__ */