sal/osl/w32/thread.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "system.h"
  21 #include "thread.hxx"
  22 #include <thread_internal.hxx>
  23
  24 #include <comphelper/windowserrorstring.hxx>
  25 #include <osl/diagnose.h>
  26 #include <osl/mutex.hxx>
  27 #include <osl/thread.h>
  28 #include <rtl/alloc.h>
  29 #include <osl/time.h>
  30 #include <osl/interlck.h>
  31 #include <rtl/tencinfo.h>
  32 #include <sal/log.hxx>
  33 #include <systools/win32/comtools.hxx>
  34
  35 #include <errno.h>
  36 #include <mutex>
  37
  38 namespace {
  39
  40 /**
  41     Thread-data structure hidden behind oslThread:
  42  */
  43 typedef struct
  44 {
  45     HANDLE              m_hThread;      /* OS-handle used for all thread-functions */
  46     DWORD               m_ThreadId;     /* identifier for this thread */
  47     sal_Int32           m_nTerminationRequested;
  48     oslWorkerFunction   m_WorkerFunction;
  49     void*               m_pData;
  50
  51 } osl_TThreadImpl;
  52
  53 }
  54
  55 static oslThread oslCreateThread(oslWorkerFunction pWorker, void* pThreadData, sal_uInt32 nFlags);
  56
  57 static DWORD WINAPI oslWorkerWrapperFunction(_In_ LPVOID pData)
  58 {
  59     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(pData);
  60
  61     /* Initialize COM - Multi Threaded Apartment (MTA) for all threads */
  62     sal::systools::CoInitializeGuard aGuard(COINIT_MULTITHREADED, false,
  63                                             sal::systools::CoInitializeGuard::WhenFailed::NoThrow);
  64
  65     /* call worker-function with data */
  66
  67     pThreadImpl->m_WorkerFunction(pThreadImpl->m_pData);
  68
  69     return 0;
  70 }
  71
  72 static oslThread oslCreateThread(oslWorkerFunction pWorker,
  73                                  void* pThreadData,
  74                                  sal_uInt32 nFlags)
  75 {
  76     osl_TThreadImpl* pThreadImpl;
  77
  78     /* alloc mem. for our internal data structure */
  79     pThreadImpl= static_cast<osl_TThreadImpl *>(malloc(sizeof(osl_TThreadImpl)));
  80
  81     OSL_ASSERT(pThreadImpl);
  82
  83     if ( pThreadImpl == nullptr )
  84     {
  85         return nullptr;
  86     }
  87
  88     pThreadImpl->m_WorkerFunction= pWorker;
  89     pThreadImpl->m_pData= pThreadData;
  90     pThreadImpl->m_nTerminationRequested= 0;
  91
  92     pThreadImpl->m_hThread= CreateThread(
  93                                nullptr,                     /* no security */
  94                                0,                           /* default stack-size */
  95                                oslWorkerWrapperFunction,    /* worker-function */
  96                                pThreadImpl,                 /* provide worker-function with data */
  97                                nFlags,                      /* start thread immediately or suspended */
  98                                &pThreadImpl->m_ThreadId);
  99
 100     if(pThreadImpl->m_hThread == nullptr)
 101     {
 102         SAL_WARN("sal.osl", "CreateThread failed:" << WindowsErrorString(GetLastError()));
 103
 104         /* create failed */
 105         free(pThreadImpl);
 106         return nullptr;
 107     }
 108
 109     return pThreadImpl;
 110 }
 111
 112 oslThread SAL_CALL osl_createThread(oslWorkerFunction pWorker,
 113                                     void* pThreadData)
 114 {
 115     return oslCreateThread(pWorker, pThreadData, 0);
 116 }
 117
 118 oslThread SAL_CALL osl_createSuspendedThread(oslWorkerFunction pWorker,
 119                                              void* pThreadData)
 120 {
 121     return oslCreateThread(pWorker, pThreadData, CREATE_SUSPENDED);
 122 }
 123
 124 oslThreadIdentifier SAL_CALL osl_getThreadIdentifier(oslThread Thread)
 125 {
 126     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 127
 128     if (pThreadImpl != nullptr)
 129         return static_cast<oslThreadIdentifier>(pThreadImpl->m_ThreadId);
 130     else
 131         return static_cast<oslThreadIdentifier>(GetCurrentThreadId());
 132 }
 133
 134 void SAL_CALL osl_destroyThread(oslThread Thread)
 135 {
 136     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 137
 138     if (Thread == nullptr) /* valid ptr? */
 139     {
 140         /* thread already destroyed or not created */
 141         return;
 142     }
 143
 144     /* !!!! _exitthreadex does _not_ call CloseHandle !!! */
 145     CloseHandle( pThreadImpl->m_hThread );
 146
 147     /* free memory */
 148     free(Thread);
 149 }
 150
 151 void SAL_CALL osl_resumeThread(oslThread Thread)
 152 {
 153     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 154
 155     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 156
 157     ResumeThread(pThreadImpl->m_hThread);
 158 }
 159
 160 void SAL_CALL osl_suspendThread(oslThread Thread)
 161 {
 162     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 163
 164     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 165
 166     SuspendThread(pThreadImpl->m_hThread);
 167 }
 168
 169 void SAL_CALL osl_setThreadPriority(oslThread Thread,
 170                            oslThreadPriority Priority)
 171 {
 172     int winPriority;
 173     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 174
 175     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 176
 177     /*  map enum to WIN32 levels
 178         it would be faster and more elegant to preset
 179         the enums, but that would require an #ifdef in
 180         the exported header, which is not desired.
 181     */
 182     switch(Priority) {
 183
 184     case osl_Thread_PriorityHighest:
 185         winPriority= THREAD_PRIORITY_HIGHEST;
 186         break;
 187
 188     case osl_Thread_PriorityAboveNormal:
 189         winPriority= THREAD_PRIORITY_ABOVE_NORMAL;
 190         break;
 191
 192     case osl_Thread_PriorityNormal:
 193         winPriority= THREAD_PRIORITY_NORMAL;
 194         break;
 195
 196     case osl_Thread_PriorityBelowNormal:
 197         winPriority= THREAD_PRIORITY_BELOW_NORMAL;
 198         break;
 199
 200     case osl_Thread_PriorityLowest:
 201         winPriority= THREAD_PRIORITY_LOWEST;
 202         break;
 203
 204     case osl_Thread_PriorityUnknown:
 205         OSL_ASSERT(FALSE);      /* only fools try this...*/
 206
 207         /* let release-version behave friendly */
 208         return;
 209
 210     default:
 211         OSL_ASSERT(FALSE);      /* enum expanded, but forgotten here...*/
 212
 213         /* let release-version behave friendly */
 214         return;
 215     }
 216
 217     SetThreadPriority(pThreadImpl->m_hThread, winPriority);
 218 }
 219
 220 oslThreadPriority SAL_CALL osl_getThreadPriority(const oslThread Thread)
 221 {
 222     int winPriority;
 223     oslThreadPriority Priority;
 224
 225     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 226
 227     /* invalid arguments ?*/
 228     if(pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 229     {
 230         return osl_Thread_PriorityUnknown;
 231     }
 232
 233     winPriority=
 234         GetThreadPriority(pThreadImpl->m_hThread);
 235
 236     if(winPriority == THREAD_PRIORITY_ERROR_RETURN)
 237     {
 238         return osl_Thread_PriorityUnknown;
 239     }
 240
 241     /* map WIN32 priority to enum */
 242     switch(winPriority)
 243     {
 244     case THREAD_PRIORITY_TIME_CRITICAL:
 245     case THREAD_PRIORITY_HIGHEST:
 246         Priority= osl_Thread_PriorityHighest;
 247         break;
 248
 249     case THREAD_PRIORITY_ABOVE_NORMAL:
 250         Priority= osl_Thread_PriorityAboveNormal;
 251         break;
 252
 253     case THREAD_PRIORITY_NORMAL:
 254         Priority= osl_Thread_PriorityNormal;
 255         break;
 256
 257     case THREAD_PRIORITY_BELOW_NORMAL:
 258         Priority= osl_Thread_PriorityBelowNormal;
 259         break;
 260
 261     case THREAD_PRIORITY_IDLE:
 262     case THREAD_PRIORITY_LOWEST:
 263         Priority= osl_Thread_PriorityLowest;
 264         break;
 265
 266     default:
 267         OSL_ASSERT(FALSE); /* WIN32 API changed, incorporate new prio-level! */
 268
 269         /* release-version behaves friendly */
 270         Priority= osl_Thread_PriorityUnknown;
 271     }
 272
 273     return Priority;
 274 }
 275
 276 sal_Bool SAL_CALL osl_isThreadRunning(const oslThread Thread)
 277 {
 278     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 279
 280     /* invalid arguments ?*/
 281     if(pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 282     {
 283         return false;
 284     }
 285
 286     return WaitForSingleObject(pThreadImpl->m_hThread, 0) != WAIT_OBJECT_0;
 287 }
 288
 289 void SAL_CALL osl_joinWithThread(oslThread Thread)
 290 {
 291     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 292
 293     /* invalid arguments?*/
 294     if(pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 295     {
 296         /* assume thread is not running */
 297         return;
 298     }
 299
 300     WaitForSingleObject(pThreadImpl->m_hThread, INFINITE);
 301 }
 302
 303 void SAL_CALL osl_waitThread(const TimeValue* pDelay)
 304 {
 305     if (pDelay)
 306     {
 307         DWORD millisecs = pDelay->Seconds * 1000L + pDelay->Nanosec / 1000000L;
 308
 309         Sleep(millisecs);
 310     }
 311 }
 312
 313 void SAL_CALL osl_terminateThread(oslThread Thread)
 314 {
 315     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 316
 317     /* invalid arguments?*/
 318     if (pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 319     {
 320         /* assume thread is not running */
 321         return;
 322     }
 323
 324     osl_atomic_increment(&(pThreadImpl->m_nTerminationRequested));
 325 }
 326
 327 sal_Bool SAL_CALL osl_scheduleThread(oslThread Thread)
 328 {
 329     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 330
 331     osl_yieldThread();
 332
 333     /* invalid arguments?*/
 334     if (pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 335     {
 336         /* assume thread is not running */
 337         return false;
 338     }
 339
 340     return 0 == pThreadImpl->m_nTerminationRequested;
 341 }
 342
 343 void SAL_CALL osl_yieldThread(void)
 344 {
 345     Sleep(0);
 346 }
 347
 348 static void impSetThreadDescription(char const * name) {
 349     // SetThreadDescription is only available since Windows 10 version 1607
 350     typedef HRESULT(WINAPI * TSetThreadDescription)(HANDLE, PCWSTR);
 351     static const auto pSetThreadDescription = reinterpret_cast<TSetThreadDescription>(
 352         GetProcAddress(GetModuleHandleA("KernelBase.dll"), "SetThreadDescription"));
 353     if (pSetThreadDescription)
 354     {
 355         if (const int nReqCCh = MultiByteToWideChar(CP_ACP, 0, name, -1, nullptr, 0))
 356         {
 357             if (PWSTR wStr = static_cast<PWSTR>(malloc(nReqCCh * sizeof(WCHAR))))
 358             {
 359                 if (MultiByteToWideChar(CP_ACP, 0, name, -1, wStr, nReqCCh))
 360                     pSetThreadDescription(GetCurrentThread(), wStr);
 361                 free(wStr);
 362             }
 363         }
 364     }
 365 }
 366
 367 void SAL_CALL osl_setThreadName(char const * name) {
 368     /* See < https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-set-a-thread-name-in-native-code >: */
 369 #pragma pack(push, 8)
 370     struct {
 371         DWORD dwType = 0x1000;
 372         LPCSTR szName;
 373         DWORD dwThreadID = DWORD(-1);
 374         DWORD dwFlags = 0;
 375     } info;
 376 #pragma pack(pop)
 377     info.szName = name;
 378     __try {
 379         RaiseException(
 380             0x406D1388, 0, sizeof info / sizeof (ULONG_PTR),
 381             reinterpret_cast<ULONG_PTR *>(&info));
 382     } __except (EXCEPTION_EXECUTE_HANDLER) {}
 383
 384     impSetThreadDescription(name);
 385 }
 386
 387 namespace {
 388
 389 typedef struct TLS_
 390 {
 391     DWORD                           dwIndex;
 392     oslThreadKeyCallbackFunction    pfnCallback;
 393     struct TLS_                     *pNext, *pPrev;
 394 } TLS, *PTLS;
 395
 396 PTLS g_pThreadKeyList = nullptr;
 397 std::mutex& getThreadKeyListMutex()
 398 {
 399     static std::mutex g_ThreadKeyListMutex;
 400     return g_ThreadKeyListMutex;
 401 }
 402
 403 }
 404
 405 static void AddKeyToList( PTLS pTls )
 406 {
 407     if ( pTls )
 408     {
 409         std::lock_guard aGuard(getThreadKeyListMutex());
 410
 411         pTls->pNext = g_pThreadKeyList;
 412         pTls->pPrev = nullptr;
 413
 414         if ( g_pThreadKeyList )
 415             g_pThreadKeyList->pPrev = pTls;
 416
 417         g_pThreadKeyList = pTls;
 418     }
 419 }
 420
 421 static void RemoveKeyFromList( PTLS pTls )
 422 {
 423     if ( pTls )
 424     {
 425         std::lock_guard aGuard(getThreadKeyListMutex());
 426         if ( pTls->pPrev )
 427             pTls->pPrev->pNext = pTls->pNext;
 428         else
 429         {
 430             OSL_ASSERT( pTls == g_pThreadKeyList );
 431             g_pThreadKeyList = pTls->pNext;
 432         }
 433
 434         if ( pTls->pNext )
 435             pTls->pNext->pPrev = pTls->pPrev;
 436     }
 437 }
 438
 439 void osl_callThreadKeyCallbackOnThreadDetach(void)
 440 {
 441     PTLS    pTls;
 442
 443     std::lock_guard aGuard(getThreadKeyListMutex());
 444     pTls = g_pThreadKeyList;
 445     while ( pTls )
 446     {
 447         if ( pTls->pfnCallback )
 448         {
 449             void    *pValue = TlsGetValue( pTls->dwIndex );
 450
 451             if ( pValue )
 452                 pTls->pfnCallback( pValue );
 453         }
 454
 455         pTls = pTls->pNext;
 456     }
 457 }
 458
 459 oslThreadKey SAL_CALL osl_createThreadKey(oslThreadKeyCallbackFunction pCallback)
 460 {
 461     PTLS    pTls = static_cast<PTLS>(malloc( sizeof(TLS) ));
 462
 463     if ( pTls )
 464     {
 465         pTls->pfnCallback = pCallback;
 466         if ( DWORD(-1) == (pTls->dwIndex = TlsAlloc()) )
 467         {
 468             free( pTls );
 469             pTls = nullptr;
 470         }
 471         else
 472             AddKeyToList( pTls );
 473     }
 474
 475     return pTls;
 476 }
 477
 478 void SAL_CALL osl_destroyThreadKey(oslThreadKey Key)
 479 {
 480     if (Key != nullptr)
 481     {
 482         PTLS    pTls = static_cast<PTLS>(Key);
 483
 484         RemoveKeyFromList( pTls );
 485         TlsFree( pTls->dwIndex );
 486         free( pTls );
 487     }
 488 }
 489
 490 void* SAL_CALL osl_getThreadKeyData(oslThreadKey Key)
 491 {
 492     if (Key != nullptr)
 493     {
 494         PTLS    pTls = static_cast<PTLS>(Key);
 495
 496         return TlsGetValue( pTls->dwIndex );
 497     }
 498
 499     return nullptr;
 500 }
 501
 502 sal_Bool SAL_CALL osl_setThreadKeyData(oslThreadKey Key, void *pData)
 503 {
 504     if (Key != nullptr)
 505     {
 506         PTLS    pTls = static_cast<PTLS>(Key);
 507         void*   pOldData = nullptr;
 508         bool    fSuccess;
 509
 510         if ( pTls->pfnCallback )
 511             pOldData = TlsGetValue( pTls->dwIndex );
 512
 513         fSuccess = TlsSetValue( pTls->dwIndex, pData );
 514
 515         if ( fSuccess && pTls->pfnCallback && pOldData )
 516             pTls->pfnCallback( pOldData );
 517
 518         return fSuccess;
 519     }
 520
 521     return false;
 522 }
 523
 524 rtl_TextEncoding getThreadTextEncodingForInitialization()
 525 {
 526     return rtl_getTextEncodingFromWindowsCodePage(GetACP());
 527 }
 528
 529 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */