sal/osl/w32/thread.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: thread.c,v $
  10  * $Revision: 1.20 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "system.h"
  32
  33 #include <osl/diagnose.h>
  34 #include <osl/thread.h>
  35 #include <rtl/alloc.h>
  36 #include <osl/time.h>
  37 #include <osl/interlck.h>
  38 #include <rtl/tencinfo.h>
  39
  40 /*
  41     Thread-data structure hidden behind oslThread:
  42 */
  43 typedef struct _osl_TThreadImpl
  44 {
  45     HANDLE                              m_hThread;              /* OS-handle used for all thread-functions */
  46     unsigned                    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 #define THREADIMPL_FLAGS_TERMINATE      0x0001
  54
  55 static unsigned __stdcall oslWorkerWrapperFunction(void* pData);
  56 static oslThread oslCreateThread(oslWorkerFunction pWorker, void* pThreadData, sal_uInt32 nFlags);
  57
  58 /*****************************************************************************/
  59 /* oslWorkerWrapperFunction */
  60 /*****************************************************************************/
  61 static unsigned __stdcall oslWorkerWrapperFunction(void* pData)
  62 {
  63     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)pData;
  64
  65     /* Initialize COM */
  66
  67     CoInitializeEx(NULL, COINIT_MULTITHREADED);
  68
  69     /* call worker-function with data */
  70
  71     pThreadImpl->m_WorkerFunction(pThreadImpl->m_pData);
  72
  73     CoUninitialize();
  74
  75     return (0);
  76 }
  77
  78 /*****************************************************************************/
  79 /* oslCreateThread */
  80 /*****************************************************************************/
  81 static oslThread oslCreateThread(oslWorkerFunction pWorker,
  82                                  void* pThreadData,
  83                                  sal_uInt32 nFlags)
  84 {
  85     osl_TThreadImpl* pThreadImpl;
  86
  87     /* alloc mem. for our internal data structure */
  88     pThreadImpl= malloc(sizeof(osl_TThreadImpl));
  89
  90     OSL_ASSERT(pThreadImpl);
  91
  92     if ( pThreadImpl == 0 )
  93     {
  94         return 0;
  95     }
  96
  97     pThreadImpl->m_WorkerFunction= pWorker;
  98     pThreadImpl->m_pData= pThreadData;
  99     pThreadImpl->m_nTerminationRequested= 0;
 100
 101     pThreadImpl->m_hThread=
 102         (HANDLE)_beginthreadex(NULL,                                            /* no security */
 103                                0,                                                       /* default stack-size */
 104                                oslWorkerWrapperFunction,        /* worker-function */
 105                                pThreadImpl,                                     /* provide worker-function with data */
 106                                nFlags,                                          /* start thread immediately or suspended */
 107                                &pThreadImpl->m_ThreadId);
 108
 109     if(pThreadImpl->m_hThread == 0)
 110     {
 111         /* create failed */
 112         free(pThreadImpl);
 113         return 0;
 114     }
 115
 116     return (oslThread)pThreadImpl;
 117 }
 118
 119 /*****************************************************************************/
 120 /* osl_createThread */
 121 /*****************************************************************************/
 122 oslThread SAL_CALL osl_createThread(oslWorkerFunction pWorker,
 123                                     void* pThreadData)
 124 {
 125     return oslCreateThread(pWorker, pThreadData, 0);
 126 }
 127
 128 /*****************************************************************************/
 129 /* osl_createSuspendedThread */
 130 /*****************************************************************************/
 131 oslThread SAL_CALL osl_createSuspendedThread(oslWorkerFunction pWorker,
 132                                              void* pThreadData)
 133 {
 134     return oslCreateThread(pWorker, pThreadData, CREATE_SUSPENDED);
 135 }
 136
 137 /*****************************************************************************/
 138 /* osl_getThreadIdentifier */
 139 /*****************************************************************************/
 140 oslThreadIdentifier SAL_CALL osl_getThreadIdentifier(oslThread Thread)
 141 {
 142     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 143
 144     if (pThreadImpl != NULL)
 145         return ((oslThreadIdentifier)pThreadImpl->m_ThreadId);
 146     else
 147         return ((oslThreadIdentifier)GetCurrentThreadId());
 148 }
 149
 150 /*****************************************************************************/
 151 /* osl_destroyThread */
 152 /*****************************************************************************/
 153 void SAL_CALL osl_destroyThread(oslThread Thread)
 154 {
 155     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 156
 157     if (Thread == 0) /* valid ptr? */
 158     {
 159         /* thread already destroyed or not created */
 160         return;
 161     }
 162
 163     /* !!!! _exitthreadex does _not_ call CloseHandle !!! */
 164     CloseHandle( pThreadImpl->m_hThread );
 165
 166     /* free memory */
 167     free(Thread);
 168 }
 169
 170 /*****************************************************************************/
 171 /* osl_resumeThread */
 172 /*****************************************************************************/
 173 void SAL_CALL osl_resumeThread(oslThread Thread)
 174 {
 175     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 176
 177     OSL_ASSERT(pThreadImpl);            /* valid ptr? */
 178
 179     ResumeThread(pThreadImpl->m_hThread);
 180 }
 181
 182 /*****************************************************************************/
 183 /* osl_suspendThread */
 184 /*****************************************************************************/
 185 void SAL_CALL osl_suspendThread(oslThread Thread)
 186 {
 187     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 188
 189     OSL_ASSERT(pThreadImpl);            /* valid ptr? */
 190
 191     SuspendThread(pThreadImpl->m_hThread);
 192 }
 193
 194 /*****************************************************************************/
 195 /* osl_setThreadPriority */
 196 /*****************************************************************************/
 197 void SAL_CALL osl_setThreadPriority(oslThread Thread,
 198                            oslThreadPriority Priority)
 199 {
 200     int winPriority;
 201     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 202
 203     OSL_ASSERT(pThreadImpl);            /* valid ptr? */
 204
 205
 206     /*  map enum to WIN32 levels
 207         it would be faster and more elegant to preset
 208         the enums, but that would require an #ifdef in
 209         the exported header, which is not desired.
 210     */
 211     switch(Priority) {
 212
 213     case osl_Thread_PriorityHighest:
 214         winPriority= THREAD_PRIORITY_HIGHEST;
 215         break;
 216
 217     case osl_Thread_PriorityAboveNormal:
 218         winPriority= THREAD_PRIORITY_ABOVE_NORMAL;
 219         break;
 220
 221     case osl_Thread_PriorityNormal:
 222         winPriority= THREAD_PRIORITY_NORMAL;
 223         break;
 224
 225     case osl_Thread_PriorityBelowNormal:
 226         winPriority= THREAD_PRIORITY_BELOW_NORMAL;
 227         break;
 228
 229     case osl_Thread_PriorityLowest:
 230         winPriority= THREAD_PRIORITY_LOWEST;
 231         break;
 232
 233     case osl_Thread_PriorityUnknown:
 234         OSL_ASSERT(FALSE);              /* only fools try this...*/
 235
 236         /* let release-version behave friendly */
 237         return;
 238
 239     default:
 240         OSL_ASSERT(FALSE);              /* enum expanded, but forgotten here...*/
 241
 242         /* let release-version behave friendly */
 243         return;
 244     }
 245
 246     SetThreadPriority(pThreadImpl->m_hThread, winPriority);
 247 }
 248
 249 /*****************************************************************************/
 250 /* osl_getThreadPriority  */
 251 /*****************************************************************************/
 252 oslThreadPriority SAL_CALL osl_getThreadPriority(const oslThread Thread)
 253 {
 254     int winPriority;
 255     oslThreadPriority Priority;
 256
 257     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 258
 259     /* invalid arguments ?*/
 260     if(pThreadImpl==0 || pThreadImpl->m_hThread==0)
 261     {
 262         return osl_Thread_PriorityUnknown;
 263     }
 264
 265     winPriority=
 266         GetThreadPriority(pThreadImpl->m_hThread);
 267
 268
 269     if(winPriority == THREAD_PRIORITY_ERROR_RETURN)
 270     {
 271         return osl_Thread_PriorityUnknown;
 272     }
 273
 274     /* map WIN32 priority to enum */
 275     switch(winPriority)
 276     {
 277     case THREAD_PRIORITY_TIME_CRITICAL:
 278     case THREAD_PRIORITY_HIGHEST:
 279         Priority= osl_Thread_PriorityHighest;
 280         break;
 281
 282     case THREAD_PRIORITY_ABOVE_NORMAL:
 283         Priority= osl_Thread_PriorityAboveNormal;
 284         break;
 285
 286     case THREAD_PRIORITY_NORMAL:
 287         Priority= osl_Thread_PriorityNormal;
 288         break;
 289
 290     case THREAD_PRIORITY_BELOW_NORMAL:
 291         Priority= osl_Thread_PriorityBelowNormal;
 292         break;
 293
 294     case THREAD_PRIORITY_IDLE:
 295     case THREAD_PRIORITY_LOWEST:
 296         Priority= osl_Thread_PriorityLowest;
 297         break;
 298
 299     default:
 300         OSL_ASSERT(FALSE);              /* WIN32 API changed, incorporate new prio-level! */
 301
 302         /* release-version behaves friendly */
 303         Priority= osl_Thread_PriorityUnknown;
 304     }
 305
 306     return Priority;
 307 }
 308
 309 /*****************************************************************************/
 310 /* osl_isThreadRunning */
 311 /*****************************************************************************/
 312 sal_Bool SAL_CALL osl_isThreadRunning(const oslThread Thread)
 313 {
 314     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 315
 316     /* invalid arguments ?*/
 317     if(pThreadImpl==0 || pThreadImpl->m_hThread==0)
 318     {
 319         return sal_False;
 320     }
 321
 322     return (sal_Bool)(WaitForSingleObject(pThreadImpl->m_hThread, 0) != WAIT_OBJECT_0);
 323 }
 324
 325 /*****************************************************************************/
 326 /* osl_joinWithThread */
 327 /*****************************************************************************/
 328 void SAL_CALL osl_joinWithThread(oslThread Thread)
 329 {
 330     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 331
 332     /* invalid arguments?*/
 333     if(pThreadImpl==0 || pThreadImpl->m_hThread==0)
 334     {
 335         /* assume thread is not running */
 336         return;
 337     }
 338
 339     WaitForSingleObject(pThreadImpl->m_hThread, INFINITE);
 340 }
 341
 342 /*****************************************************************************/
 343 /* osl_waitThread */
 344 /*****************************************************************************/
 345 void SAL_CALL osl_waitThread(const TimeValue* pDelay)
 346 {
 347     if (pDelay)
 348     {
 349         DWORD millisecs = pDelay->Seconds * 1000L + pDelay->Nanosec / 1000000L;
 350
 351         Sleep(millisecs);
 352     }
 353 }
 354
 355 /*****************************************************************************/
 356 /* osl_terminateThread */
 357 /*****************************************************************************/
 358 void SAL_CALL osl_terminateThread(oslThread Thread)
 359 {
 360     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 361
 362     /* invalid arguments?*/
 363     if (pThreadImpl==0 || pThreadImpl->m_hThread==0)
 364     {
 365         /* assume thread is not running */
 366         return;
 367     }
 368
 369     osl_incrementInterlockedCount(&(pThreadImpl->m_nTerminationRequested));
 370 }
 371
 372
 373 /*****************************************************************************/
 374 /* osl_scheduleThread */
 375 /*****************************************************************************/
 376 sal_Bool SAL_CALL osl_scheduleThread(oslThread Thread)
 377 {
 378     osl_TThreadImpl* pThreadImpl= (osl_TThreadImpl*)Thread;
 379
 380     osl_yieldThread();
 381
 382     /* invalid arguments?*/
 383     if (pThreadImpl==0 || pThreadImpl->m_hThread==0)
 384     {
 385         /* assume thread is not running */
 386         return sal_False;
 387     }
 388
 389     return (sal_Bool)(0 == pThreadImpl->m_nTerminationRequested);
 390 }
 391
 392 /*****************************************************************************/
 393 /* osl_yieldThread */
 394 /*****************************************************************************/
 395 void SAL_CALL osl_yieldThread(void)
 396 {
 397     Sleep(0);
 398 }
 399
 400 typedef struct _TLS
 401 {
 402     DWORD                                                       dwIndex;
 403     oslThreadKeyCallbackFunction        pfnCallback;
 404     struct _TLS                                         *pNext, *pPrev;
 405 } TLS, *PTLS;
 406
 407 static  PTLS            g_pThreadKeyList = NULL;
 408 CRITICAL_SECTION        g_ThreadKeyListCS;
 409
 410 static void AddKeyToList( PTLS pTls )
 411 {
 412     if ( pTls )
 413     {
 414         EnterCriticalSection( &g_ThreadKeyListCS );
 415
 416         pTls->pNext = g_pThreadKeyList;
 417         pTls->pPrev = 0;
 418
 419         if ( g_pThreadKeyList )
 420             g_pThreadKeyList->pPrev = pTls;
 421
 422         g_pThreadKeyList = pTls;
 423
 424         LeaveCriticalSection( &g_ThreadKeyListCS );
 425     }
 426 }
 427
 428 static void RemoveKeyFromList( PTLS pTls )
 429 {
 430     if ( pTls )
 431     {
 432         EnterCriticalSection( &g_ThreadKeyListCS );
 433         if ( pTls->pPrev )
 434             pTls->pPrev->pNext = pTls->pNext;
 435         else
 436         {
 437             OSL_ASSERT( pTls == g_pThreadKeyList );
 438             g_pThreadKeyList = pTls->pNext;
 439         }
 440
 441         if ( pTls->pNext )
 442             pTls->pNext->pPrev = pTls->pPrev;
 443         LeaveCriticalSection( &g_ThreadKeyListCS );
 444     }
 445 }
 446
 447 void SAL_CALL _osl_callThreadKeyCallbackOnThreadDetach(void)
 448 {
 449     PTLS        pTls;
 450
 451
 452     EnterCriticalSection( &g_ThreadKeyListCS );
 453     pTls = g_pThreadKeyList;
 454     while ( pTls )
 455     {
 456         if ( pTls->pfnCallback )
 457         {
 458             void        *pValue = TlsGetValue( pTls->dwIndex );
 459
 460             if ( pValue )
 461                 pTls->pfnCallback( pValue );
 462         }
 463
 464         pTls = pTls->pNext;
 465     }
 466     LeaveCriticalSection( &g_ThreadKeyListCS );
 467 }
 468
 469 /*****************************************************************************/
 470 /* osl_createThreadKey */
 471 /*****************************************************************************/
 472 oslThreadKey SAL_CALL osl_createThreadKey(oslThreadKeyCallbackFunction pCallback)
 473 {
 474     PTLS        pTls = rtl_allocateMemory( sizeof(TLS) );
 475
 476     if ( pTls )
 477     {
 478         pTls->pfnCallback = pCallback;
 479         if ( (DWORD)-1 == (pTls->dwIndex = TlsAlloc()) )
 480         {
 481             rtl_freeMemory( pTls );
 482             pTls = 0;
 483         }
 484         else
 485             AddKeyToList( pTls );
 486     }
 487
 488     return ((oslThreadKey)pTls);
 489 }
 490
 491 /*****************************************************************************/
 492 /* osl_destroyThreadKey */
 493 /*****************************************************************************/
 494 void SAL_CALL osl_destroyThreadKey(oslThreadKey Key)
 495 {
 496     if (Key != 0)
 497     {
 498         PTLS    pTls = (PTLS)Key;
 499
 500         RemoveKeyFromList( pTls );
 501         TlsFree( pTls->dwIndex );
 502         rtl_freeMemory( pTls );
 503     }
 504 }
 505
 506 /*****************************************************************************/
 507 /* osl_getThreadKeyData */
 508 /*****************************************************************************/
 509 void* SAL_CALL osl_getThreadKeyData(oslThreadKey Key)
 510 {
 511     if (Key != 0)
 512     {
 513         PTLS    pTls = (PTLS)Key;
 514
 515         return (TlsGetValue( pTls->dwIndex ));
 516     }
 517
 518     return (NULL);
 519 }
 520
 521 /*****************************************************************************/
 522 /* osl_setThreadKeyData */
 523 /*****************************************************************************/
 524 sal_Bool SAL_CALL osl_setThreadKeyData(oslThreadKey Key, void *pData)
 525 {
 526     if (Key != 0)
 527     {
 528         PTLS    pTls = (PTLS)Key;
 529         void*   pOldData = NULL;
 530         BOOL    fSuccess;
 531
 532         if ( pTls->pfnCallback )
 533             pOldData = TlsGetValue( pTls->dwIndex );
 534
 535         fSuccess = TlsSetValue( pTls->dwIndex, pData );
 536
 537         if ( fSuccess && pTls->pfnCallback && pOldData )
 538             pTls->pfnCallback( pOldData );
 539
 540         return (sal_Bool)(fSuccess != FALSE);
 541     }
 542
 543     return (sal_False);
 544 }
 545
 546
 547 /*****************************************************************************/
 548 /* osl_getThreadTextEncoding */
 549 /*****************************************************************************/
 550
 551 DWORD   g_dwTLSTextEncodingIndex = (DWORD)-1;
 552
 553
 554 rtl_TextEncoding SAL_CALL osl_getThreadTextEncoding(void)
 555 {
 556     DWORD                               dwEncoding;
 557     rtl_TextEncoding    _encoding;
 558     BOOL                                gotACP;
 559
 560     if ( (DWORD)-1 == g_dwTLSTextEncodingIndex )
 561         g_dwTLSTextEncodingIndex = TlsAlloc();
 562
 563     dwEncoding = (DWORD)TlsGetValue( g_dwTLSTextEncodingIndex );
 564     _encoding = LOWORD(dwEncoding);
 565     gotACP = HIWORD(dwEncoding);
 566
 567
 568     if ( !gotACP )
 569     {
 570         char    *pszEncoding;
 571
 572         if ( NULL != (pszEncoding = getenv( "SOLAR_USER_RTL_TEXTENCODING" )) )
 573             _encoding = (rtl_TextEncoding)atoi(pszEncoding);
 574         else
 575             _encoding = rtl_getTextEncodingFromWindowsCodePage( GetACP() );
 576
 577         TlsSetValue( g_dwTLSTextEncodingIndex, (LPVOID)MAKELONG( _encoding, TRUE ) );
 578     }
 579
 580     return _encoding;
 581 }
 582
 583 /*****************************************************************************/
 584 /* osl_getThreadTextEncoding */
 585 /*****************************************************************************/
 586 rtl_TextEncoding SAL_CALL osl_setThreadTextEncoding( rtl_TextEncoding Encoding )
 587 {
 588     rtl_TextEncoding oldEncoding = osl_getThreadTextEncoding();
 589
 590     TlsSetValue( g_dwTLSTextEncodingIndex, (LPVOID)MAKELONG( Encoding, TRUE) );
 591
 592     return oldEncoding;
 593 }
 594
 595
 596