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
  23 #include <osl/diagnose.h>
  24 #include <osl/thread.h>
  25 #include <rtl/alloc.h>
  26 #include <osl/time.h>
  27 #include <osl/interlck.h>
  28 #include <rtl/tencinfo.h>
  29 #include <errno.h>
  30
  31 /**
  32     Thread-data structure hidden behind oslThread:
  33  */
  34 typedef struct
  35 {
  36     HANDLE              m_hThread;      /* OS-handle used for all thread-functions */
  37     unsigned            m_ThreadId;     /* identifier for this thread */
  38     sal_Int32           m_nTerminationRequested;
  39     oslWorkerFunction   m_WorkerFunction;
  40     void*               m_pData;
  41
  42 } osl_TThreadImpl;
  43
  44 static unsigned __stdcall oslWorkerWrapperFunction(void* pData);
  45 static oslThread oslCreateThread(oslWorkerFunction pWorker, void* pThreadData, sal_uInt32 nFlags);
  46
  47 static unsigned __stdcall oslWorkerWrapperFunction(void* pData)
  48 {
  49     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(pData);
  50
  51     /* Initialize COM - Multi Threaded Apartment (MTA) for all threads */
  52     CoInitializeEx(nullptr, COINIT_MULTITHREADED); /* spawned by oslCreateThread */
  53
  54     /* call worker-function with data */
  55
  56     pThreadImpl->m_WorkerFunction(pThreadImpl->m_pData);
  57
  58     CoUninitialize();
  59
  60     return 0;
  61 }
  62
  63 static oslThread oslCreateThread(oslWorkerFunction pWorker,
  64                                  void* pThreadData,
  65                                  sal_uInt32 nFlags)
  66 {
  67     osl_TThreadImpl* pThreadImpl;
  68
  69     /* alloc mem. for our internal data structure */
  70     pThreadImpl= static_cast<osl_TThreadImpl *>(malloc(sizeof(osl_TThreadImpl)));
  71
  72     OSL_ASSERT(pThreadImpl);
  73
  74     if ( pThreadImpl == nullptr )
  75     {
  76         return nullptr;
  77     }
  78
  79     pThreadImpl->m_WorkerFunction= pWorker;
  80     pThreadImpl->m_pData= pThreadData;
  81     pThreadImpl->m_nTerminationRequested= 0;
  82
  83     pThreadImpl->m_hThread=
  84         reinterpret_cast<HANDLE>(_beginthreadex(nullptr,                        /* no security */
  85                                0,                           /* default stack-size */
  86                                oslWorkerWrapperFunction,    /* worker-function */
  87                                pThreadImpl,                 /* provide worker-function with data */
  88                                nFlags,                      /* start thread immediately or suspended */
  89                                &pThreadImpl->m_ThreadId));
  90
  91     if(pThreadImpl->m_hThread == nullptr)
  92     {
  93         switch (errno)
  94         {
  95             case EAGAIN:
  96                 fprintf(stderr, "_beginthreadex errno EAGAIN\n");
  97             break;
  98             case EINVAL:
  99                 fprintf(stderr, "_beginthreadex errno EINVAL\n");
 100             break;
 101             case EACCES:
 102                 fprintf(stderr, "_beginthreadex errno EACCES\n");
 103             break;
 104             case ENOMEM:
 105                 fprintf(stderr, "_beginthreadex undocumented errno ENOMEM - this means not enough VM for stack\n");
 106             break;
 107             default:
 108                 fprintf(stderr, "_beginthreadex unexpected errno %d\n", errno);
 109             break;
 110         }
 111
 112         /* create failed */
 113         free(pThreadImpl);
 114         return nullptr;
 115     }
 116
 117     return pThreadImpl;
 118 }
 119
 120 oslThread SAL_CALL osl_createThread(oslWorkerFunction pWorker,
 121                                     void* pThreadData)
 122 {
 123     return oslCreateThread(pWorker, pThreadData, 0);
 124 }
 125
 126 oslThread SAL_CALL osl_createSuspendedThread(oslWorkerFunction pWorker,
 127                                              void* pThreadData)
 128 {
 129     return oslCreateThread(pWorker, pThreadData, CREATE_SUSPENDED);
 130 }
 131
 132 oslThreadIdentifier SAL_CALL osl_getThreadIdentifier(oslThread Thread)
 133 {
 134     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 135
 136     if (pThreadImpl != nullptr)
 137         return static_cast<oslThreadIdentifier>(pThreadImpl->m_ThreadId);
 138     else
 139         return static_cast<oslThreadIdentifier>(GetCurrentThreadId());
 140 }
 141
 142 void SAL_CALL osl_destroyThread(oslThread Thread)
 143 {
 144     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 145
 146     if (Thread == nullptr) /* valid ptr? */
 147     {
 148         /* thread already destroyed or not created */
 149         return;
 150     }
 151
 152     /* !!!! _exitthreadex does _not_ call CloseHandle !!! */
 153     CloseHandle( pThreadImpl->m_hThread );
 154
 155     /* free memory */
 156     free(Thread);
 157 }
 158
 159 void SAL_CALL osl_resumeThread(oslThread Thread)
 160 {
 161     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 162
 163     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 164
 165     ResumeThread(pThreadImpl->m_hThread);
 166 }
 167
 168 void SAL_CALL osl_suspendThread(oslThread Thread)
 169 {
 170     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 171
 172     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 173
 174     SuspendThread(pThreadImpl->m_hThread);
 175 }
 176
 177 void SAL_CALL osl_setThreadPriority(oslThread Thread,
 178                            oslThreadPriority Priority)
 179 {
 180     int winPriority;
 181     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 182
 183     OSL_ASSERT(pThreadImpl);        /* valid ptr? */
 184
 185     /*  map enum to WIN32 levels
 186         it would be faster and more elegant to preset
 187         the enums, but that would require an #ifdef in
 188         the exported header, which is not desired.
 189     */
 190     switch(Priority) {
 191
 192     case osl_Thread_PriorityHighest:
 193         winPriority= THREAD_PRIORITY_HIGHEST;
 194         break;
 195
 196     case osl_Thread_PriorityAboveNormal:
 197         winPriority= THREAD_PRIORITY_ABOVE_NORMAL;
 198         break;
 199
 200     case osl_Thread_PriorityNormal:
 201         winPriority= THREAD_PRIORITY_NORMAL;
 202         break;
 203
 204     case osl_Thread_PriorityBelowNormal:
 205         winPriority= THREAD_PRIORITY_BELOW_NORMAL;
 206         break;
 207
 208     case osl_Thread_PriorityLowest:
 209         winPriority= THREAD_PRIORITY_LOWEST;
 210         break;
 211
 212     case osl_Thread_PriorityUnknown:
 213         OSL_ASSERT(FALSE);      /* only fools try this...*/
 214
 215         /* let release-version behave friendly */
 216         return;
 217
 218     default:
 219         OSL_ASSERT(FALSE);      /* enum expanded, but forgotten here...*/
 220
 221         /* let release-version behave friendly */
 222         return;
 223     }
 224
 225     SetThreadPriority(pThreadImpl->m_hThread, winPriority);
 226 }
 227
 228 oslThreadPriority SAL_CALL osl_getThreadPriority(const oslThread Thread)
 229 {
 230     int winPriority;
 231     oslThreadPriority Priority;
 232
 233     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 234
 235     /* invalid arguments ?*/
 236     if(pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 237     {
 238         return osl_Thread_PriorityUnknown;
 239     }
 240
 241     winPriority=
 242         GetThreadPriority(pThreadImpl->m_hThread);
 243
 244     if(winPriority == THREAD_PRIORITY_ERROR_RETURN)
 245     {
 246         return osl_Thread_PriorityUnknown;
 247     }
 248
 249     /* map WIN32 priority to enum */
 250     switch(winPriority)
 251     {
 252     case THREAD_PRIORITY_TIME_CRITICAL:
 253     case THREAD_PRIORITY_HIGHEST:
 254         Priority= osl_Thread_PriorityHighest;
 255         break;
 256
 257     case THREAD_PRIORITY_ABOVE_NORMAL:
 258         Priority= osl_Thread_PriorityAboveNormal;
 259         break;
 260
 261     case THREAD_PRIORITY_NORMAL:
 262         Priority= osl_Thread_PriorityNormal;
 263         break;
 264
 265     case THREAD_PRIORITY_BELOW_NORMAL:
 266         Priority= osl_Thread_PriorityBelowNormal;
 267         break;
 268
 269     case THREAD_PRIORITY_IDLE:
 270     case THREAD_PRIORITY_LOWEST:
 271         Priority= osl_Thread_PriorityLowest;
 272         break;
 273
 274     default:
 275         OSL_ASSERT(FALSE); /* WIN32 API changed, incorporate new prio-level! */
 276
 277         /* release-version behaves friendly */
 278         Priority= osl_Thread_PriorityUnknown;
 279     }
 280
 281     return Priority;
 282 }
 283
 284 sal_Bool SAL_CALL osl_isThreadRunning(const oslThread Thread)
 285 {
 286     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 287
 288     /* invalid arguments ?*/
 289     if(pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 290     {
 291         return false;
 292     }
 293
 294     return WaitForSingleObject(pThreadImpl->m_hThread, 0) != WAIT_OBJECT_0;
 295 }
 296
 297 void SAL_CALL osl_joinWithThread(oslThread Thread)
 298 {
 299     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 300
 301     /* invalid arguments?*/
 302     if(pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 303     {
 304         /* assume thread is not running */
 305         return;
 306     }
 307
 308     WaitForSingleObject(pThreadImpl->m_hThread, INFINITE);
 309 }
 310
 311 void SAL_CALL osl_waitThread(const TimeValue* pDelay)
 312 {
 313     if (pDelay)
 314     {
 315         DWORD millisecs = pDelay->Seconds * 1000L + pDelay->Nanosec / 1000000L;
 316
 317         Sleep(millisecs);
 318     }
 319 }
 320
 321 void SAL_CALL osl_terminateThread(oslThread Thread)
 322 {
 323     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 324
 325     /* invalid arguments?*/
 326     if (pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 327     {
 328         /* assume thread is not running */
 329         return;
 330     }
 331
 332     osl_atomic_increment(&(pThreadImpl->m_nTerminationRequested));
 333 }
 334
 335 sal_Bool SAL_CALL osl_scheduleThread(oslThread Thread)
 336 {
 337     osl_TThreadImpl* pThreadImpl= static_cast<osl_TThreadImpl*>(Thread);
 338
 339     osl_yieldThread();
 340
 341     /* invalid arguments?*/
 342     if (pThreadImpl==nullptr || pThreadImpl->m_hThread==nullptr)
 343     {
 344         /* assume thread is not running */
 345         return false;
 346     }
 347
 348     return 0 == pThreadImpl->m_nTerminationRequested;
 349 }
 350
 351 void SAL_CALL osl_yieldThread(void)
 352 {
 353     Sleep(0);
 354 }
 355
 356 void SAL_CALL osl_setThreadName(char const * name) {
 357 #ifdef _MSC_VER
 358     /* See <http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx>: */
 359 #pragma pack(push, 8)
 360     struct {
 361         DWORD dwType;
 362         LPCSTR szName;
 363         DWORD dwThreadID;
 364         DWORD dwFlags;
 365     } info;
 366 #pragma pack(pop)
 367     info.dwType = 0x1000;
 368     info.szName = name;
 369     info.dwThreadID = DWORD(-1);
 370     info.dwFlags = 0;
 371     __try {
 372         RaiseException(
 373             0x406D1388, 0, sizeof info / sizeof (ULONG_PTR),
 374             reinterpret_cast<ULONG_PTR *>(&info));
 375     } __except (EXCEPTION_EXECUTE_HANDLER) {}
 376 #else
 377     (void) name;
 378 #endif
 379 }
 380
 381 typedef struct TLS_
 382 {
 383     DWORD                           dwIndex;
 384     oslThreadKeyCallbackFunction    pfnCallback;
 385     struct TLS_                     *pNext, *pPrev;
 386 } TLS, *PTLS;
 387
 388 static  PTLS        g_pThreadKeyList = nullptr;
 389 CRITICAL_SECTION    g_ThreadKeyListCS;
 390
 391 static void AddKeyToList( PTLS pTls )
 392 {
 393     if ( pTls )
 394     {
 395         EnterCriticalSection( &g_ThreadKeyListCS );
 396
 397         pTls->pNext = g_pThreadKeyList;
 398         pTls->pPrev = nullptr;
 399
 400         if ( g_pThreadKeyList )
 401             g_pThreadKeyList->pPrev = pTls;
 402
 403         g_pThreadKeyList = pTls;
 404
 405         LeaveCriticalSection( &g_ThreadKeyListCS );
 406     }
 407 }
 408
 409 static void RemoveKeyFromList( PTLS pTls )
 410 {
 411     if ( pTls )
 412     {
 413         EnterCriticalSection( &g_ThreadKeyListCS );
 414         if ( pTls->pPrev )
 415             pTls->pPrev->pNext = pTls->pNext;
 416         else
 417         {
 418             OSL_ASSERT( pTls == g_pThreadKeyList );
 419             g_pThreadKeyList = pTls->pNext;
 420         }
 421
 422         if ( pTls->pNext )
 423             pTls->pNext->pPrev = pTls->pPrev;
 424         LeaveCriticalSection( &g_ThreadKeyListCS );
 425     }
 426 }
 427
 428 void osl_callThreadKeyCallbackOnThreadDetach(void)
 429 {
 430     PTLS    pTls;
 431
 432     EnterCriticalSection( &g_ThreadKeyListCS );
 433     pTls = g_pThreadKeyList;
 434     while ( pTls )
 435     {
 436         if ( pTls->pfnCallback )
 437         {
 438             void    *pValue = TlsGetValue( pTls->dwIndex );
 439
 440             if ( pValue )
 441                 pTls->pfnCallback( pValue );
 442         }
 443
 444         pTls = pTls->pNext;
 445     }
 446     LeaveCriticalSection( &g_ThreadKeyListCS );
 447 }
 448
 449 oslThreadKey SAL_CALL osl_createThreadKey(oslThreadKeyCallbackFunction pCallback)
 450 {
 451     PTLS    pTls = static_cast<PTLS>(malloc( sizeof(TLS) ));
 452
 453     if ( pTls )
 454     {
 455         pTls->pfnCallback = pCallback;
 456         if ( DWORD(-1) == (pTls->dwIndex = TlsAlloc()) )
 457         {
 458             free( pTls );
 459             pTls = nullptr;
 460         }
 461         else
 462             AddKeyToList( pTls );
 463     }
 464
 465     return pTls;
 466 }
 467
 468 void SAL_CALL osl_destroyThreadKey(oslThreadKey Key)
 469 {
 470     if (Key != nullptr)
 471     {
 472         PTLS    pTls = static_cast<PTLS>(Key);
 473
 474         RemoveKeyFromList( pTls );
 475         TlsFree( pTls->dwIndex );
 476         free( pTls );
 477     }
 478 }
 479
 480 void* SAL_CALL osl_getThreadKeyData(oslThreadKey Key)
 481 {
 482     if (Key != nullptr)
 483     {
 484         PTLS    pTls = static_cast<PTLS>(Key);
 485
 486         return TlsGetValue( pTls->dwIndex );
 487     }
 488
 489     return nullptr;
 490 }
 491
 492 sal_Bool SAL_CALL osl_setThreadKeyData(oslThreadKey Key, void *pData)
 493 {
 494     if (Key != nullptr)
 495     {
 496         PTLS    pTls = static_cast<PTLS>(Key);
 497         void*   pOldData = nullptr;
 498         BOOL    fSuccess;
 499
 500         if ( pTls->pfnCallback )
 501             pOldData = TlsGetValue( pTls->dwIndex );
 502
 503         fSuccess = TlsSetValue( pTls->dwIndex, pData );
 504
 505         if ( fSuccess && pTls->pfnCallback && pOldData )
 506             pTls->pfnCallback( pOldData );
 507
 508         return fSuccess != FALSE;
 509     }
 510
 511     return false;
 512 }
 513
 514 DWORD   g_dwTLSTextEncodingIndex = DWORD(-1);
 515
 516 rtl_TextEncoding SAL_CALL osl_getThreadTextEncoding(void)
 517 {
 518     DWORD_PTR           dwEncoding;
 519     rtl_TextEncoding    _encoding;
 520     BOOL                gotACP;
 521
 522     if ( DWORD(-1) == g_dwTLSTextEncodingIndex )
 523         g_dwTLSTextEncodingIndex = TlsAlloc();
 524
 525     dwEncoding = reinterpret_cast<DWORD_PTR>(TlsGetValue( g_dwTLSTextEncodingIndex ));
 526     _encoding = LOWORD(dwEncoding);
 527     gotACP = HIWORD(dwEncoding);
 528
 529     if ( !gotACP )
 530     {
 531         _encoding = rtl_getTextEncodingFromWindowsCodePage( GetACP() );
 532         TlsSetValue( g_dwTLSTextEncodingIndex, reinterpret_cast<LPVOID>(static_cast<DWORD_PTR>(MAKELONG( _encoding, TRUE ))) );
 533     }
 534
 535     return _encoding;
 536 }
 537
 538 rtl_TextEncoding SAL_CALL osl_setThreadTextEncoding( rtl_TextEncoding Encoding )
 539 {
 540     rtl_TextEncoding oldEncoding = osl_getThreadTextEncoding();
 541
 542     TlsSetValue( g_dwTLSTextEncodingIndex, reinterpret_cast<LPVOID>(static_cast<DWORD_PTR>(MAKELONG( Encoding, TRUE))) );
 543
 544     return oldEncoding;
 545 }
 546
 547 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */