1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski #include "system.h"
25*b1cdbd2cSJim Jagielski #include <string.h>
26*b1cdbd2cSJim Jagielski #include <osl/diagnose.h>
27*b1cdbd2cSJim Jagielski #include <osl/thread.h>
28*b1cdbd2cSJim Jagielski #include <osl/nlsupport.h>
29*b1cdbd2cSJim Jagielski #ifndef _RTL_TEXTENC_H_
30*b1cdbd2cSJim Jagielski #include <rtl/textenc.h>
31*b1cdbd2cSJim Jagielski #endif
32*b1cdbd2cSJim Jagielski
33*b1cdbd2cSJim Jagielski #if defined LINUX
34*b1cdbd2cSJim Jagielski #include <sys/prctl.h>
35*b1cdbd2cSJim Jagielski #endif
36*b1cdbd2cSJim Jagielski
37*b1cdbd2cSJim Jagielski /****************************************************************************
38*b1cdbd2cSJim Jagielski * @@@ TODO @@@
39*b1cdbd2cSJim Jagielski *
40*b1cdbd2cSJim Jagielski * (1) 'osl_thread_priority_init_Impl()'
41*b1cdbd2cSJim Jagielski * - insane assumption that initializing caller is main thread
42*b1cdbd2cSJim Jagielski * - use _POSIX_THREAD_PRIORITY_SCHEDULING, not NO_PTHREAD_PRIORITY (?)
43*b1cdbd2cSJim Jagielski * - POSIX doesn't require defined prio's for SCHED_OTHER (!)
44*b1cdbd2cSJim Jagielski * - use SCHED_RR instead of SCHED_OTHER for defined behaviour (?)
45*b1cdbd2cSJim Jagielski * (2) 'oslThreadIdentifier' and '{insert|remove|lookup}ThreadId()'
46*b1cdbd2cSJim Jagielski * - cannot reliably be applied to 'alien' threads;
47*b1cdbd2cSJim Jagielski * - memory leak for 'alien' thread 'HashEntry's;
48*b1cdbd2cSJim Jagielski * - use 'PTHREAD_VALUE(pthread_t)' as identifier instead (?)
49*b1cdbd2cSJim Jagielski * - if yes, change 'oslThreadIdentifier' to 'intptr_t' or similar
50*b1cdbd2cSJim Jagielski * (3) 'oslSigAlarmHandler()' (#71232#)
51*b1cdbd2cSJim Jagielski * - [Under Solaris we get SIGALRM in e.g. pthread_join which terminates
52*b1cdbd2cSJim Jagielski * the process. So we initialize our signal handling module and do
53*b1cdbd2cSJim Jagielski * register a SIGALRM Handler which catches and ignores it]
54*b1cdbd2cSJim Jagielski * - should this still happen, 'signal.c' needs to be fixed instead.
55*b1cdbd2cSJim Jagielski *
56*b1cdbd2cSJim Jagielski ****************************************************************************/
57*b1cdbd2cSJim Jagielski
58*b1cdbd2cSJim Jagielski /*****************************************************************************/
59*b1cdbd2cSJim Jagielski /* Internal data structures and functions */
60*b1cdbd2cSJim Jagielski /*****************************************************************************/
61*b1cdbd2cSJim Jagielski
62*b1cdbd2cSJim Jagielski #define THREADIMPL_FLAGS_TERMINATE 0x00001
63*b1cdbd2cSJim Jagielski #define THREADIMPL_FLAGS_STARTUP 0x00002
64*b1cdbd2cSJim Jagielski #define THREADIMPL_FLAGS_SUSPENDED 0x00004
65*b1cdbd2cSJim Jagielski #define THREADIMPL_FLAGS_ACTIVE 0x00008
66*b1cdbd2cSJim Jagielski #define THREADIMPL_FLAGS_ATTACHED 0x00010
67*b1cdbd2cSJim Jagielski #define THREADIMPL_FLAGS_DESTROYED 0x00020
68*b1cdbd2cSJim Jagielski
69*b1cdbd2cSJim Jagielski typedef struct osl_thread_impl_st
70*b1cdbd2cSJim Jagielski {
71*b1cdbd2cSJim Jagielski pthread_t m_hThread;
72*b1cdbd2cSJim Jagielski sal_uInt16 m_Ident; /* @@@ see TODO @@@ */
73*b1cdbd2cSJim Jagielski short m_Flags;
74*b1cdbd2cSJim Jagielski oslWorkerFunction m_WorkerFunction;
75*b1cdbd2cSJim Jagielski void* m_pData;
76*b1cdbd2cSJim Jagielski pthread_mutex_t m_Lock;
77*b1cdbd2cSJim Jagielski pthread_cond_t m_Cond;
78*b1cdbd2cSJim Jagielski } Thread_Impl;
79*b1cdbd2cSJim Jagielski
80*b1cdbd2cSJim Jagielski struct osl_thread_priority_st
81*b1cdbd2cSJim Jagielski {
82*b1cdbd2cSJim Jagielski int m_Highest;
83*b1cdbd2cSJim Jagielski int m_Above_Normal;
84*b1cdbd2cSJim Jagielski int m_Normal;
85*b1cdbd2cSJim Jagielski int m_Below_Normal;
86*b1cdbd2cSJim Jagielski int m_Lowest;
87*b1cdbd2cSJim Jagielski };
88*b1cdbd2cSJim Jagielski
89*b1cdbd2cSJim Jagielski #define OSL_THREAD_PRIORITY_INITIALIZER { 127, 96, 64, 32, 0 }
90*b1cdbd2cSJim Jagielski static void osl_thread_priority_init_Impl (void);
91*b1cdbd2cSJim Jagielski
92*b1cdbd2cSJim Jagielski struct osl_thread_textencoding_st
93*b1cdbd2cSJim Jagielski {
94*b1cdbd2cSJim Jagielski pthread_key_t m_key; /* key to store thread local text encoding */
95*b1cdbd2cSJim Jagielski rtl_TextEncoding m_default; /* the default text encoding */
96*b1cdbd2cSJim Jagielski };
97*b1cdbd2cSJim Jagielski
98*b1cdbd2cSJim Jagielski #define OSL_THREAD_TEXTENCODING_INITIALIZER { 0, RTL_TEXTENCODING_DONTKNOW }
99*b1cdbd2cSJim Jagielski static void osl_thread_textencoding_init_Impl (void);
100*b1cdbd2cSJim Jagielski
101*b1cdbd2cSJim Jagielski struct osl_thread_global_st
102*b1cdbd2cSJim Jagielski {
103*b1cdbd2cSJim Jagielski pthread_once_t m_once;
104*b1cdbd2cSJim Jagielski struct osl_thread_priority_st m_priority;
105*b1cdbd2cSJim Jagielski struct osl_thread_textencoding_st m_textencoding;
106*b1cdbd2cSJim Jagielski };
107*b1cdbd2cSJim Jagielski
108*b1cdbd2cSJim Jagielski static struct osl_thread_global_st g_thread =
109*b1cdbd2cSJim Jagielski {
110*b1cdbd2cSJim Jagielski PTHREAD_ONCE_INIT,
111*b1cdbd2cSJim Jagielski OSL_THREAD_PRIORITY_INITIALIZER,
112*b1cdbd2cSJim Jagielski OSL_THREAD_TEXTENCODING_INITIALIZER
113*b1cdbd2cSJim Jagielski };
114*b1cdbd2cSJim Jagielski
115*b1cdbd2cSJim Jagielski static void osl_thread_init_Impl (void);
116*b1cdbd2cSJim Jagielski
117*b1cdbd2cSJim Jagielski static Thread_Impl* osl_thread_construct_Impl (void);
118*b1cdbd2cSJim Jagielski static void osl_thread_destruct_Impl (Thread_Impl ** ppImpl);
119*b1cdbd2cSJim Jagielski
120*b1cdbd2cSJim Jagielski static void* osl_thread_start_Impl (void * pData);
121*b1cdbd2cSJim Jagielski static void osl_thread_cleanup_Impl (void * pData);
122*b1cdbd2cSJim Jagielski
123*b1cdbd2cSJim Jagielski static oslThread osl_thread_create_Impl (
124*b1cdbd2cSJim Jagielski oslWorkerFunction pWorker, void * pThreadData, short nFlags);
125*b1cdbd2cSJim Jagielski
126*b1cdbd2cSJim Jagielski static void osl_thread_join_cleanup_Impl (void * opaque);
127*b1cdbd2cSJim Jagielski static void osl_thread_wait_cleanup_Impl (void * opaque);
128*b1cdbd2cSJim Jagielski
129*b1cdbd2cSJim Jagielski /* @@@ see TODO @@@ */
130*b1cdbd2cSJim Jagielski static sal_uInt16 insertThreadId (pthread_t hThread);
131*b1cdbd2cSJim Jagielski static sal_uInt16 lookupThreadId (pthread_t hThread);
132*b1cdbd2cSJim Jagielski static void removeThreadId (pthread_t hThread);
133*b1cdbd2cSJim Jagielski
134*b1cdbd2cSJim Jagielski /*****************************************************************************/
135*b1cdbd2cSJim Jagielski /* osl_thread_init_Impl */
136*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_init_Impl(void)137*b1cdbd2cSJim Jagielski static void osl_thread_init_Impl (void)
138*b1cdbd2cSJim Jagielski {
139*b1cdbd2cSJim Jagielski osl_thread_priority_init_Impl();
140*b1cdbd2cSJim Jagielski osl_thread_textencoding_init_Impl();
141*b1cdbd2cSJim Jagielski }
142*b1cdbd2cSJim Jagielski
143*b1cdbd2cSJim Jagielski /*****************************************************************************/
144*b1cdbd2cSJim Jagielski /* osl_thread_join_cleanup_Impl */
145*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_join_cleanup_Impl(void * opaque)146*b1cdbd2cSJim Jagielski static void osl_thread_join_cleanup_Impl (void * opaque)
147*b1cdbd2cSJim Jagielski {
148*b1cdbd2cSJim Jagielski pthread_t hThread = (pthread_t)(opaque);
149*b1cdbd2cSJim Jagielski pthread_detach (hThread);
150*b1cdbd2cSJim Jagielski }
151*b1cdbd2cSJim Jagielski
152*b1cdbd2cSJim Jagielski /*****************************************************************************/
153*b1cdbd2cSJim Jagielski /* osl_thread_wait_cleanup_Impl */
154*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_wait_cleanup_Impl(void * opaque)155*b1cdbd2cSJim Jagielski static void osl_thread_wait_cleanup_Impl (void * opaque)
156*b1cdbd2cSJim Jagielski {
157*b1cdbd2cSJim Jagielski pthread_mutex_t * pMutex = (pthread_mutex_t*)(opaque);
158*b1cdbd2cSJim Jagielski pthread_mutex_unlock (pMutex);
159*b1cdbd2cSJim Jagielski }
160*b1cdbd2cSJim Jagielski
161*b1cdbd2cSJim Jagielski /*****************************************************************************/
162*b1cdbd2cSJim Jagielski /* osl_thread_construct_Impl */
163*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_construct_Impl(void)164*b1cdbd2cSJim Jagielski Thread_Impl* osl_thread_construct_Impl (void)
165*b1cdbd2cSJim Jagielski {
166*b1cdbd2cSJim Jagielski Thread_Impl* pImpl = malloc (sizeof(Thread_Impl));
167*b1cdbd2cSJim Jagielski if (pImpl)
168*b1cdbd2cSJim Jagielski {
169*b1cdbd2cSJim Jagielski memset (pImpl, 0, sizeof(Thread_Impl));
170*b1cdbd2cSJim Jagielski
171*b1cdbd2cSJim Jagielski pthread_mutex_init (&(pImpl->m_Lock), PTHREAD_MUTEXATTR_DEFAULT);
172*b1cdbd2cSJim Jagielski pthread_cond_init (&(pImpl->m_Cond), PTHREAD_CONDATTR_DEFAULT);
173*b1cdbd2cSJim Jagielski }
174*b1cdbd2cSJim Jagielski return (pImpl);
175*b1cdbd2cSJim Jagielski }
176*b1cdbd2cSJim Jagielski
177*b1cdbd2cSJim Jagielski /*****************************************************************************/
178*b1cdbd2cSJim Jagielski /* osl_thread_destruct_Impl */
179*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_destruct_Impl(Thread_Impl ** ppImpl)180*b1cdbd2cSJim Jagielski static void osl_thread_destruct_Impl (Thread_Impl ** ppImpl)
181*b1cdbd2cSJim Jagielski {
182*b1cdbd2cSJim Jagielski OSL_ASSERT(ppImpl);
183*b1cdbd2cSJim Jagielski if (*ppImpl)
184*b1cdbd2cSJim Jagielski {
185*b1cdbd2cSJim Jagielski pthread_cond_destroy (&((*ppImpl)->m_Cond));
186*b1cdbd2cSJim Jagielski pthread_mutex_destroy (&((*ppImpl)->m_Lock));
187*b1cdbd2cSJim Jagielski
188*b1cdbd2cSJim Jagielski free (*ppImpl);
189*b1cdbd2cSJim Jagielski (*ppImpl) = 0;
190*b1cdbd2cSJim Jagielski }
191*b1cdbd2cSJim Jagielski }
192*b1cdbd2cSJim Jagielski
193*b1cdbd2cSJim Jagielski /*****************************************************************************/
194*b1cdbd2cSJim Jagielski /* osl_thread_cleanup_Impl */
195*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_cleanup_Impl(void * pData)196*b1cdbd2cSJim Jagielski static void osl_thread_cleanup_Impl (void* pData)
197*b1cdbd2cSJim Jagielski {
198*b1cdbd2cSJim Jagielski pthread_t thread;
199*b1cdbd2cSJim Jagielski int attached;
200*b1cdbd2cSJim Jagielski int destroyed;
201*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)pData;
202*b1cdbd2cSJim Jagielski
203*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
204*b1cdbd2cSJim Jagielski
205*b1cdbd2cSJim Jagielski thread = pImpl->m_hThread;
206*b1cdbd2cSJim Jagielski attached = (pImpl->m_Flags & THREADIMPL_FLAGS_ATTACHED) != 0;
207*b1cdbd2cSJim Jagielski destroyed = (pImpl->m_Flags & THREADIMPL_FLAGS_DESTROYED) != 0;
208*b1cdbd2cSJim Jagielski pImpl->m_Flags &= ~(THREADIMPL_FLAGS_ACTIVE | THREADIMPL_FLAGS_ATTACHED);
209*b1cdbd2cSJim Jagielski
210*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
211*b1cdbd2cSJim Jagielski
212*b1cdbd2cSJim Jagielski /* release oslThreadIdentifier @@@ see TODO @@@ */
213*b1cdbd2cSJim Jagielski removeThreadId (thread);
214*b1cdbd2cSJim Jagielski
215*b1cdbd2cSJim Jagielski if (attached)
216*b1cdbd2cSJim Jagielski {
217*b1cdbd2cSJim Jagielski pthread_detach (thread);
218*b1cdbd2cSJim Jagielski }
219*b1cdbd2cSJim Jagielski
220*b1cdbd2cSJim Jagielski if (destroyed)
221*b1cdbd2cSJim Jagielski {
222*b1cdbd2cSJim Jagielski osl_thread_destruct_Impl (&pImpl);
223*b1cdbd2cSJim Jagielski }
224*b1cdbd2cSJim Jagielski }
225*b1cdbd2cSJim Jagielski
226*b1cdbd2cSJim Jagielski /*****************************************************************************/
227*b1cdbd2cSJim Jagielski /* osl_thread_start_Impl */
228*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_start_Impl(void * pData)229*b1cdbd2cSJim Jagielski static void* osl_thread_start_Impl (void* pData)
230*b1cdbd2cSJim Jagielski {
231*b1cdbd2cSJim Jagielski int terminate;
232*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)pData;
233*b1cdbd2cSJim Jagielski
234*b1cdbd2cSJim Jagielski OSL_ASSERT(pImpl);
235*b1cdbd2cSJim Jagielski
236*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
237*b1cdbd2cSJim Jagielski
238*b1cdbd2cSJim Jagielski /* install cleanup handler */
239*b1cdbd2cSJim Jagielski pthread_cleanup_push (osl_thread_cleanup_Impl, pData);
240*b1cdbd2cSJim Jagielski
241*b1cdbd2cSJim Jagielski /* request oslThreadIdentifier @@@ see TODO @@@ */
242*b1cdbd2cSJim Jagielski pImpl->m_Ident = insertThreadId (pImpl->m_hThread);
243*b1cdbd2cSJim Jagielski
244*b1cdbd2cSJim Jagielski /* signal change from STARTUP to ACTIVE state */
245*b1cdbd2cSJim Jagielski pImpl->m_Flags &= ~THREADIMPL_FLAGS_STARTUP;
246*b1cdbd2cSJim Jagielski pImpl->m_Flags |= THREADIMPL_FLAGS_ACTIVE;
247*b1cdbd2cSJim Jagielski pthread_cond_signal (&(pImpl->m_Cond));
248*b1cdbd2cSJim Jagielski
249*b1cdbd2cSJim Jagielski /* Check if thread is started in SUSPENDED state */
250*b1cdbd2cSJim Jagielski while (pImpl->m_Flags & THREADIMPL_FLAGS_SUSPENDED)
251*b1cdbd2cSJim Jagielski {
252*b1cdbd2cSJim Jagielski /* wait until SUSPENDED flag is cleared */
253*b1cdbd2cSJim Jagielski pthread_cleanup_push (osl_thread_wait_cleanup_Impl, &(pImpl->m_Lock));
254*b1cdbd2cSJim Jagielski pthread_cond_wait (&(pImpl->m_Cond), &(pImpl->m_Lock));
255*b1cdbd2cSJim Jagielski pthread_cleanup_pop (0);
256*b1cdbd2cSJim Jagielski }
257*b1cdbd2cSJim Jagielski
258*b1cdbd2cSJim Jagielski /* check for SUSPENDED to TERMINATE state change */
259*b1cdbd2cSJim Jagielski terminate = ((pImpl->m_Flags & THREADIMPL_FLAGS_TERMINATE) > 0);
260*b1cdbd2cSJim Jagielski
261*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
262*b1cdbd2cSJim Jagielski
263*b1cdbd2cSJim Jagielski if (!terminate)
264*b1cdbd2cSJim Jagielski {
265*b1cdbd2cSJim Jagielski /* call worker function */
266*b1cdbd2cSJim Jagielski pImpl->m_WorkerFunction(pImpl->m_pData);
267*b1cdbd2cSJim Jagielski }
268*b1cdbd2cSJim Jagielski
269*b1cdbd2cSJim Jagielski /* call cleanup handler and leave */
270*b1cdbd2cSJim Jagielski pthread_cleanup_pop (1);
271*b1cdbd2cSJim Jagielski return (0);
272*b1cdbd2cSJim Jagielski }
273*b1cdbd2cSJim Jagielski
274*b1cdbd2cSJim Jagielski /*****************************************************************************/
275*b1cdbd2cSJim Jagielski /* osl_thread_create_Impl */
276*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_create_Impl(oslWorkerFunction pWorker,void * pThreadData,short nFlags)277*b1cdbd2cSJim Jagielski static oslThread osl_thread_create_Impl (
278*b1cdbd2cSJim Jagielski oslWorkerFunction pWorker,
279*b1cdbd2cSJim Jagielski void* pThreadData,
280*b1cdbd2cSJim Jagielski short nFlags)
281*b1cdbd2cSJim Jagielski {
282*b1cdbd2cSJim Jagielski Thread_Impl* pImpl;
283*b1cdbd2cSJim Jagielski int nRet=0;
284*b1cdbd2cSJim Jagielski
285*b1cdbd2cSJim Jagielski pImpl = osl_thread_construct_Impl();
286*b1cdbd2cSJim Jagielski if (!pImpl)
287*b1cdbd2cSJim Jagielski return (0); /* ENOMEM */
288*b1cdbd2cSJim Jagielski
289*b1cdbd2cSJim Jagielski pImpl->m_WorkerFunction = pWorker;
290*b1cdbd2cSJim Jagielski pImpl->m_pData = pThreadData;
291*b1cdbd2cSJim Jagielski pImpl->m_Flags = nFlags | THREADIMPL_FLAGS_STARTUP;
292*b1cdbd2cSJim Jagielski
293*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
294*b1cdbd2cSJim Jagielski
295*b1cdbd2cSJim Jagielski if ((nRet = pthread_create (
296*b1cdbd2cSJim Jagielski &(pImpl->m_hThread),
297*b1cdbd2cSJim Jagielski PTHREAD_ATTR_DEFAULT,
298*b1cdbd2cSJim Jagielski osl_thread_start_Impl,
299*b1cdbd2cSJim Jagielski (void*)(pImpl))) != 0)
300*b1cdbd2cSJim Jagielski {
301*b1cdbd2cSJim Jagielski OSL_TRACE("osl_thread_create_Impl(): errno: %d, %s\n",
302*b1cdbd2cSJim Jagielski nRet, strerror(nRet));
303*b1cdbd2cSJim Jagielski
304*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
305*b1cdbd2cSJim Jagielski osl_thread_destruct_Impl (&pImpl);
306*b1cdbd2cSJim Jagielski
307*b1cdbd2cSJim Jagielski return (0);
308*b1cdbd2cSJim Jagielski }
309*b1cdbd2cSJim Jagielski
310*b1cdbd2cSJim Jagielski /* wait for change from STARTUP to ACTIVE state */
311*b1cdbd2cSJim Jagielski while (pImpl->m_Flags & THREADIMPL_FLAGS_STARTUP)
312*b1cdbd2cSJim Jagielski {
313*b1cdbd2cSJim Jagielski /* wait until STARTUP flag is cleared */
314*b1cdbd2cSJim Jagielski pthread_cleanup_push (osl_thread_wait_cleanup_Impl, &(pImpl->m_Lock));
315*b1cdbd2cSJim Jagielski pthread_cond_wait (&(pImpl->m_Cond), &(pImpl->m_Lock));
316*b1cdbd2cSJim Jagielski pthread_cleanup_pop (0);
317*b1cdbd2cSJim Jagielski }
318*b1cdbd2cSJim Jagielski
319*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
320*b1cdbd2cSJim Jagielski
321*b1cdbd2cSJim Jagielski return ((oslThread)(pImpl));
322*b1cdbd2cSJim Jagielski }
323*b1cdbd2cSJim Jagielski
324*b1cdbd2cSJim Jagielski /*****************************************************************************/
325*b1cdbd2cSJim Jagielski /* osl_createThread */
326*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_createThread(oslWorkerFunction pWorker,void * pThreadData)327*b1cdbd2cSJim Jagielski oslThread osl_createThread (
328*b1cdbd2cSJim Jagielski oslWorkerFunction pWorker,
329*b1cdbd2cSJim Jagielski void * pThreadData)
330*b1cdbd2cSJim Jagielski {
331*b1cdbd2cSJim Jagielski return osl_thread_create_Impl (
332*b1cdbd2cSJim Jagielski pWorker,
333*b1cdbd2cSJim Jagielski pThreadData,
334*b1cdbd2cSJim Jagielski THREADIMPL_FLAGS_ATTACHED);
335*b1cdbd2cSJim Jagielski }
336*b1cdbd2cSJim Jagielski
337*b1cdbd2cSJim Jagielski /*****************************************************************************/
338*b1cdbd2cSJim Jagielski /* osl_createSuspendedThread */
339*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_createSuspendedThread(oslWorkerFunction pWorker,void * pThreadData)340*b1cdbd2cSJim Jagielski oslThread osl_createSuspendedThread (
341*b1cdbd2cSJim Jagielski oslWorkerFunction pWorker,
342*b1cdbd2cSJim Jagielski void * pThreadData)
343*b1cdbd2cSJim Jagielski {
344*b1cdbd2cSJim Jagielski return osl_thread_create_Impl (
345*b1cdbd2cSJim Jagielski pWorker,
346*b1cdbd2cSJim Jagielski pThreadData,
347*b1cdbd2cSJim Jagielski THREADIMPL_FLAGS_ATTACHED |
348*b1cdbd2cSJim Jagielski THREADIMPL_FLAGS_SUSPENDED );
349*b1cdbd2cSJim Jagielski }
350*b1cdbd2cSJim Jagielski
351*b1cdbd2cSJim Jagielski /*****************************************************************************/
352*b1cdbd2cSJim Jagielski /* osl_destroyThread */
353*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_destroyThread(oslThread Thread)354*b1cdbd2cSJim Jagielski void SAL_CALL osl_destroyThread(oslThread Thread)
355*b1cdbd2cSJim Jagielski {
356*b1cdbd2cSJim Jagielski if (Thread != NULL) {
357*b1cdbd2cSJim Jagielski Thread_Impl * impl = (Thread_Impl *) Thread;
358*b1cdbd2cSJim Jagielski int active;
359*b1cdbd2cSJim Jagielski pthread_mutex_lock(&impl->m_Lock);
360*b1cdbd2cSJim Jagielski active = (impl->m_Flags & THREADIMPL_FLAGS_ACTIVE) != 0;
361*b1cdbd2cSJim Jagielski impl->m_Flags |= THREADIMPL_FLAGS_DESTROYED;
362*b1cdbd2cSJim Jagielski pthread_mutex_unlock(&impl->m_Lock);
363*b1cdbd2cSJim Jagielski if (!active) {
364*b1cdbd2cSJim Jagielski osl_thread_destruct_Impl(&impl);
365*b1cdbd2cSJim Jagielski }
366*b1cdbd2cSJim Jagielski }
367*b1cdbd2cSJim Jagielski }
368*b1cdbd2cSJim Jagielski
369*b1cdbd2cSJim Jagielski /*****************************************************************************/
370*b1cdbd2cSJim Jagielski /* osl_resumeThread */
371*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_resumeThread(oslThread Thread)372*b1cdbd2cSJim Jagielski void SAL_CALL osl_resumeThread(oslThread Thread)
373*b1cdbd2cSJim Jagielski {
374*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
375*b1cdbd2cSJim Jagielski
376*b1cdbd2cSJim Jagielski OSL_ASSERT(pImpl);
377*b1cdbd2cSJim Jagielski if (!pImpl)
378*b1cdbd2cSJim Jagielski return; /* EINVAL */
379*b1cdbd2cSJim Jagielski
380*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
381*b1cdbd2cSJim Jagielski
382*b1cdbd2cSJim Jagielski if (pImpl->m_Flags & THREADIMPL_FLAGS_SUSPENDED)
383*b1cdbd2cSJim Jagielski {
384*b1cdbd2cSJim Jagielski /* clear SUSPENDED flag */
385*b1cdbd2cSJim Jagielski pImpl->m_Flags &= ~THREADIMPL_FLAGS_SUSPENDED;
386*b1cdbd2cSJim Jagielski pthread_cond_signal (&(pImpl->m_Cond));
387*b1cdbd2cSJim Jagielski }
388*b1cdbd2cSJim Jagielski
389*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
390*b1cdbd2cSJim Jagielski }
391*b1cdbd2cSJim Jagielski
392*b1cdbd2cSJim Jagielski /*****************************************************************************/
393*b1cdbd2cSJim Jagielski /* osl_suspendThread */
394*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_suspendThread(oslThread Thread)395*b1cdbd2cSJim Jagielski void SAL_CALL osl_suspendThread(oslThread Thread)
396*b1cdbd2cSJim Jagielski {
397*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
398*b1cdbd2cSJim Jagielski
399*b1cdbd2cSJim Jagielski OSL_ASSERT(pImpl);
400*b1cdbd2cSJim Jagielski if (!pImpl)
401*b1cdbd2cSJim Jagielski return; /* EINVAL */
402*b1cdbd2cSJim Jagielski
403*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
404*b1cdbd2cSJim Jagielski
405*b1cdbd2cSJim Jagielski pImpl->m_Flags |= THREADIMPL_FLAGS_SUSPENDED;
406*b1cdbd2cSJim Jagielski
407*b1cdbd2cSJim Jagielski if (pthread_equal (pthread_self(), pImpl->m_hThread))
408*b1cdbd2cSJim Jagielski {
409*b1cdbd2cSJim Jagielski /* self suspend */
410*b1cdbd2cSJim Jagielski while (pImpl->m_Flags & THREADIMPL_FLAGS_SUSPENDED)
411*b1cdbd2cSJim Jagielski {
412*b1cdbd2cSJim Jagielski /* wait until SUSPENDED flag is cleared */
413*b1cdbd2cSJim Jagielski pthread_cleanup_push (osl_thread_wait_cleanup_Impl, &(pImpl->m_Lock));
414*b1cdbd2cSJim Jagielski pthread_cond_wait (&(pImpl->m_Cond), &(pImpl->m_Lock));
415*b1cdbd2cSJim Jagielski pthread_cleanup_pop (0);
416*b1cdbd2cSJim Jagielski }
417*b1cdbd2cSJim Jagielski }
418*b1cdbd2cSJim Jagielski
419*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
420*b1cdbd2cSJim Jagielski }
421*b1cdbd2cSJim Jagielski
422*b1cdbd2cSJim Jagielski /*****************************************************************************/
423*b1cdbd2cSJim Jagielski /* osl_isThreadRunning */
424*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_isThreadRunning(const oslThread Thread)425*b1cdbd2cSJim Jagielski sal_Bool SAL_CALL osl_isThreadRunning(const oslThread Thread)
426*b1cdbd2cSJim Jagielski {
427*b1cdbd2cSJim Jagielski sal_Bool active;
428*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
429*b1cdbd2cSJim Jagielski
430*b1cdbd2cSJim Jagielski if (!pImpl)
431*b1cdbd2cSJim Jagielski return sal_False;
432*b1cdbd2cSJim Jagielski
433*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
434*b1cdbd2cSJim Jagielski active = ((pImpl->m_Flags & THREADIMPL_FLAGS_ACTIVE) > 0);
435*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
436*b1cdbd2cSJim Jagielski
437*b1cdbd2cSJim Jagielski return (active);
438*b1cdbd2cSJim Jagielski }
439*b1cdbd2cSJim Jagielski
440*b1cdbd2cSJim Jagielski /*****************************************************************************/
441*b1cdbd2cSJim Jagielski /* osl_joinWithThread */
442*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_joinWithThread(oslThread Thread)443*b1cdbd2cSJim Jagielski void SAL_CALL osl_joinWithThread(oslThread Thread)
444*b1cdbd2cSJim Jagielski {
445*b1cdbd2cSJim Jagielski pthread_t thread;
446*b1cdbd2cSJim Jagielski int attached;
447*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
448*b1cdbd2cSJim Jagielski
449*b1cdbd2cSJim Jagielski if (!pImpl)
450*b1cdbd2cSJim Jagielski return;
451*b1cdbd2cSJim Jagielski
452*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
453*b1cdbd2cSJim Jagielski
454*b1cdbd2cSJim Jagielski if (pthread_equal (pthread_self(), pImpl->m_hThread))
455*b1cdbd2cSJim Jagielski {
456*b1cdbd2cSJim Jagielski /* self join */
457*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
458*b1cdbd2cSJim Jagielski return; /* EDEADLK */
459*b1cdbd2cSJim Jagielski }
460*b1cdbd2cSJim Jagielski
461*b1cdbd2cSJim Jagielski thread = pImpl->m_hThread;
462*b1cdbd2cSJim Jagielski attached = ((pImpl->m_Flags & THREADIMPL_FLAGS_ATTACHED) > 0);
463*b1cdbd2cSJim Jagielski pImpl->m_Flags &= ~THREADIMPL_FLAGS_ATTACHED;
464*b1cdbd2cSJim Jagielski
465*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
466*b1cdbd2cSJim Jagielski
467*b1cdbd2cSJim Jagielski if (attached)
468*b1cdbd2cSJim Jagielski {
469*b1cdbd2cSJim Jagielski /* install cleanup handler to ensure consistent flags and state */
470*b1cdbd2cSJim Jagielski pthread_cleanup_push (
471*b1cdbd2cSJim Jagielski osl_thread_join_cleanup_Impl, (void*)thread);
472*b1cdbd2cSJim Jagielski
473*b1cdbd2cSJim Jagielski /* join */
474*b1cdbd2cSJim Jagielski pthread_join (thread, NULL);
475*b1cdbd2cSJim Jagielski
476*b1cdbd2cSJim Jagielski /* remove cleanup handler */
477*b1cdbd2cSJim Jagielski pthread_cleanup_pop (0);
478*b1cdbd2cSJim Jagielski }
479*b1cdbd2cSJim Jagielski }
480*b1cdbd2cSJim Jagielski
481*b1cdbd2cSJim Jagielski /*****************************************************************************/
482*b1cdbd2cSJim Jagielski /* osl_terminateThread */
483*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_terminateThread(oslThread Thread)484*b1cdbd2cSJim Jagielski void SAL_CALL osl_terminateThread(oslThread Thread)
485*b1cdbd2cSJim Jagielski {
486*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
487*b1cdbd2cSJim Jagielski
488*b1cdbd2cSJim Jagielski OSL_ASSERT(pImpl);
489*b1cdbd2cSJim Jagielski if (!pImpl)
490*b1cdbd2cSJim Jagielski return; /* EINVAL */
491*b1cdbd2cSJim Jagielski
492*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
493*b1cdbd2cSJim Jagielski
494*b1cdbd2cSJim Jagielski if (pImpl->m_Flags & THREADIMPL_FLAGS_SUSPENDED)
495*b1cdbd2cSJim Jagielski {
496*b1cdbd2cSJim Jagielski /* clear SUSPENDED flag */
497*b1cdbd2cSJim Jagielski pImpl->m_Flags &= ~THREADIMPL_FLAGS_SUSPENDED;
498*b1cdbd2cSJim Jagielski pthread_cond_signal (&(pImpl->m_Cond));
499*b1cdbd2cSJim Jagielski }
500*b1cdbd2cSJim Jagielski
501*b1cdbd2cSJim Jagielski pImpl->m_Flags |= THREADIMPL_FLAGS_TERMINATE;
502*b1cdbd2cSJim Jagielski
503*b1cdbd2cSJim Jagielski pthread_mutex_unlock (&(pImpl->m_Lock));
504*b1cdbd2cSJim Jagielski }
505*b1cdbd2cSJim Jagielski
506*b1cdbd2cSJim Jagielski /*****************************************************************************/
507*b1cdbd2cSJim Jagielski /* osl_scheduleThread */
508*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_scheduleThread(oslThread Thread)509*b1cdbd2cSJim Jagielski sal_Bool SAL_CALL osl_scheduleThread(oslThread Thread)
510*b1cdbd2cSJim Jagielski {
511*b1cdbd2cSJim Jagielski int terminate;
512*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
513*b1cdbd2cSJim Jagielski
514*b1cdbd2cSJim Jagielski OSL_ASSERT(pImpl);
515*b1cdbd2cSJim Jagielski if (!pImpl)
516*b1cdbd2cSJim Jagielski return sal_False; /* EINVAL */
517*b1cdbd2cSJim Jagielski
518*b1cdbd2cSJim Jagielski OSL_ASSERT(pthread_equal (pthread_self(), pImpl->m_hThread));
519*b1cdbd2cSJim Jagielski if (!(pthread_equal (pthread_self(), pImpl->m_hThread)))
520*b1cdbd2cSJim Jagielski return sal_False; /* EINVAL */
521*b1cdbd2cSJim Jagielski
522*b1cdbd2cSJim Jagielski pthread_testcancel();
523*b1cdbd2cSJim Jagielski pthread_mutex_lock (&(pImpl->m_Lock));
524*b1cdbd2cSJim Jagielski
525*b1cdbd2cSJim Jagielski while (pImpl->m_Flags & THREADIMPL_FLAGS_SUSPENDED)
526*b1cdbd2cSJim Jagielski {
527*b1cdbd2cSJim Jagielski /* wait until SUSPENDED flag is cleared */
528*b1cdbd2cSJim Jagielski pthread_cleanup_push (osl_thread_wait_cleanup_Impl, &(pImpl->m_Lock));
529*b1cdbd2cSJim Jagielski pthread_cond_wait (&(pImpl->m_Cond), &(pImpl->m_Lock));
530*b1cdbd2cSJim Jagielski pthread_cleanup_pop (0);
531*b1cdbd2cSJim Jagielski }
532*b1cdbd2cSJim Jagielski
533*b1cdbd2cSJim Jagielski terminate = ((pImpl->m_Flags & THREADIMPL_FLAGS_TERMINATE) > 0);
534*b1cdbd2cSJim Jagielski
535*b1cdbd2cSJim Jagielski pthread_mutex_unlock(&(pImpl->m_Lock));
536*b1cdbd2cSJim Jagielski pthread_testcancel();
537*b1cdbd2cSJim Jagielski
538*b1cdbd2cSJim Jagielski return (terminate == 0);
539*b1cdbd2cSJim Jagielski }
540*b1cdbd2cSJim Jagielski
541*b1cdbd2cSJim Jagielski /*****************************************************************************/
542*b1cdbd2cSJim Jagielski /* osl_waitThread */
543*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_waitThread(const TimeValue * pDelay)544*b1cdbd2cSJim Jagielski void SAL_CALL osl_waitThread(const TimeValue* pDelay)
545*b1cdbd2cSJim Jagielski {
546*b1cdbd2cSJim Jagielski if (pDelay)
547*b1cdbd2cSJim Jagielski {
548*b1cdbd2cSJim Jagielski struct timespec delay;
549*b1cdbd2cSJim Jagielski
550*b1cdbd2cSJim Jagielski SET_TIMESPEC(delay, pDelay->Seconds, pDelay->Nanosec);
551*b1cdbd2cSJim Jagielski
552*b1cdbd2cSJim Jagielski SLEEP_TIMESPEC(delay);
553*b1cdbd2cSJim Jagielski }
554*b1cdbd2cSJim Jagielski }
555*b1cdbd2cSJim Jagielski
556*b1cdbd2cSJim Jagielski /*****************************************************************************/
557*b1cdbd2cSJim Jagielski /* osl_yieldThread */
558*b1cdbd2cSJim Jagielski /*
559*b1cdbd2cSJim Jagielski Note that POSIX scheduling _really_ requires threads to call this
560*b1cdbd2cSJim Jagielski functions, since a thread only reschedules to other thread, when
561*b1cdbd2cSJim Jagielski it blocks (sleep, blocking I/O) OR calls sched_yield().
562*b1cdbd2cSJim Jagielski */
563*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_yieldThread()564*b1cdbd2cSJim Jagielski void SAL_CALL osl_yieldThread()
565*b1cdbd2cSJim Jagielski {
566*b1cdbd2cSJim Jagielski sched_yield();
567*b1cdbd2cSJim Jagielski }
568*b1cdbd2cSJim Jagielski
osl_setThreadName(char const * name)569*b1cdbd2cSJim Jagielski void SAL_CALL osl_setThreadName(char const * name) {
570*b1cdbd2cSJim Jagielski #if defined LINUX
571*b1cdbd2cSJim Jagielski if (prctl(PR_SET_NAME, (unsigned long) name, 0, 0, 0) != 0) {
572*b1cdbd2cSJim Jagielski OSL_TRACE(
573*b1cdbd2cSJim Jagielski "%s prctl(PR_SET_NAME) failed with errno %d", OSL_LOG_PREFIX,
574*b1cdbd2cSJim Jagielski errno);
575*b1cdbd2cSJim Jagielski }
576*b1cdbd2cSJim Jagielski #else
577*b1cdbd2cSJim Jagielski (void) name;
578*b1cdbd2cSJim Jagielski #endif
579*b1cdbd2cSJim Jagielski }
580*b1cdbd2cSJim Jagielski
581*b1cdbd2cSJim Jagielski /*****************************************************************************/
582*b1cdbd2cSJim Jagielski /* osl_getThreadIdentifier @@@ see TODO @@@ */
583*b1cdbd2cSJim Jagielski /*****************************************************************************/
584*b1cdbd2cSJim Jagielski
585*b1cdbd2cSJim Jagielski #define HASHID(x) ((unsigned int)PTHREAD_VALUE(x) % HashSize)
586*b1cdbd2cSJim Jagielski
587*b1cdbd2cSJim Jagielski typedef struct _HashEntry
588*b1cdbd2cSJim Jagielski {
589*b1cdbd2cSJim Jagielski pthread_t Handle;
590*b1cdbd2cSJim Jagielski sal_uInt16 Ident;
591*b1cdbd2cSJim Jagielski struct _HashEntry *Next;
592*b1cdbd2cSJim Jagielski } HashEntry;
593*b1cdbd2cSJim Jagielski
594*b1cdbd2cSJim Jagielski static HashEntry* HashTable[31];
595*b1cdbd2cSJim Jagielski static int HashSize = sizeof(HashTable) / sizeof(HashTable[0]);
596*b1cdbd2cSJim Jagielski
597*b1cdbd2cSJim Jagielski static pthread_mutex_t HashLock = PTHREAD_MUTEX_INITIALIZER;
598*b1cdbd2cSJim Jagielski
599*b1cdbd2cSJim Jagielski static sal_uInt16 LastIdent = 0;
600*b1cdbd2cSJim Jagielski
lookupThreadId(pthread_t hThread)601*b1cdbd2cSJim Jagielski static sal_uInt16 lookupThreadId (pthread_t hThread)
602*b1cdbd2cSJim Jagielski {
603*b1cdbd2cSJim Jagielski HashEntry *pEntry;
604*b1cdbd2cSJim Jagielski
605*b1cdbd2cSJim Jagielski pthread_mutex_lock(&HashLock);
606*b1cdbd2cSJim Jagielski
607*b1cdbd2cSJim Jagielski pEntry = HashTable[HASHID(hThread)];
608*b1cdbd2cSJim Jagielski while (pEntry != NULL)
609*b1cdbd2cSJim Jagielski {
610*b1cdbd2cSJim Jagielski if (pthread_equal(pEntry->Handle, hThread))
611*b1cdbd2cSJim Jagielski {
612*b1cdbd2cSJim Jagielski pthread_mutex_unlock(&HashLock);
613*b1cdbd2cSJim Jagielski return (pEntry->Ident);
614*b1cdbd2cSJim Jagielski }
615*b1cdbd2cSJim Jagielski pEntry = pEntry->Next;
616*b1cdbd2cSJim Jagielski }
617*b1cdbd2cSJim Jagielski
618*b1cdbd2cSJim Jagielski pthread_mutex_unlock(&HashLock);
619*b1cdbd2cSJim Jagielski
620*b1cdbd2cSJim Jagielski return (0);
621*b1cdbd2cSJim Jagielski }
622*b1cdbd2cSJim Jagielski
insertThreadId(pthread_t hThread)623*b1cdbd2cSJim Jagielski static sal_uInt16 insertThreadId (pthread_t hThread)
624*b1cdbd2cSJim Jagielski {
625*b1cdbd2cSJim Jagielski HashEntry *pEntry, *pInsert = NULL;
626*b1cdbd2cSJim Jagielski
627*b1cdbd2cSJim Jagielski pthread_mutex_lock(&HashLock);
628*b1cdbd2cSJim Jagielski
629*b1cdbd2cSJim Jagielski pEntry = HashTable[HASHID(hThread)];
630*b1cdbd2cSJim Jagielski
631*b1cdbd2cSJim Jagielski while (pEntry != NULL)
632*b1cdbd2cSJim Jagielski {
633*b1cdbd2cSJim Jagielski if (pthread_equal(pEntry->Handle, hThread))
634*b1cdbd2cSJim Jagielski break;
635*b1cdbd2cSJim Jagielski
636*b1cdbd2cSJim Jagielski pInsert = pEntry;
637*b1cdbd2cSJim Jagielski pEntry = pEntry->Next;
638*b1cdbd2cSJim Jagielski }
639*b1cdbd2cSJim Jagielski
640*b1cdbd2cSJim Jagielski if (pEntry == NULL)
641*b1cdbd2cSJim Jagielski {
642*b1cdbd2cSJim Jagielski pEntry = (HashEntry*) calloc(sizeof(HashEntry), 1);
643*b1cdbd2cSJim Jagielski
644*b1cdbd2cSJim Jagielski pEntry->Handle = hThread;
645*b1cdbd2cSJim Jagielski
646*b1cdbd2cSJim Jagielski ++ LastIdent;
647*b1cdbd2cSJim Jagielski
648*b1cdbd2cSJim Jagielski if ( LastIdent == 0 )
649*b1cdbd2cSJim Jagielski LastIdent = 1;
650*b1cdbd2cSJim Jagielski
651*b1cdbd2cSJim Jagielski pEntry->Ident = LastIdent;
652*b1cdbd2cSJim Jagielski
653*b1cdbd2cSJim Jagielski if (pInsert)
654*b1cdbd2cSJim Jagielski pInsert->Next = pEntry;
655*b1cdbd2cSJim Jagielski else
656*b1cdbd2cSJim Jagielski HashTable[HASHID(hThread)] = pEntry;
657*b1cdbd2cSJim Jagielski }
658*b1cdbd2cSJim Jagielski
659*b1cdbd2cSJim Jagielski pthread_mutex_unlock(&HashLock);
660*b1cdbd2cSJim Jagielski
661*b1cdbd2cSJim Jagielski return (pEntry->Ident);
662*b1cdbd2cSJim Jagielski }
663*b1cdbd2cSJim Jagielski
removeThreadId(pthread_t hThread)664*b1cdbd2cSJim Jagielski static void removeThreadId (pthread_t hThread)
665*b1cdbd2cSJim Jagielski {
666*b1cdbd2cSJim Jagielski HashEntry *pEntry, *pRemove = NULL;
667*b1cdbd2cSJim Jagielski
668*b1cdbd2cSJim Jagielski pthread_mutex_lock(&HashLock);
669*b1cdbd2cSJim Jagielski
670*b1cdbd2cSJim Jagielski pEntry = HashTable[HASHID(hThread)];
671*b1cdbd2cSJim Jagielski while (pEntry != NULL)
672*b1cdbd2cSJim Jagielski {
673*b1cdbd2cSJim Jagielski if (pthread_equal(pEntry->Handle, hThread))
674*b1cdbd2cSJim Jagielski break;
675*b1cdbd2cSJim Jagielski
676*b1cdbd2cSJim Jagielski pRemove = pEntry;
677*b1cdbd2cSJim Jagielski pEntry = pEntry->Next;
678*b1cdbd2cSJim Jagielski }
679*b1cdbd2cSJim Jagielski
680*b1cdbd2cSJim Jagielski if (pEntry != NULL)
681*b1cdbd2cSJim Jagielski {
682*b1cdbd2cSJim Jagielski if (pRemove)
683*b1cdbd2cSJim Jagielski pRemove->Next = pEntry->Next;
684*b1cdbd2cSJim Jagielski else
685*b1cdbd2cSJim Jagielski HashTable[HASHID(hThread)] = pEntry->Next;
686*b1cdbd2cSJim Jagielski
687*b1cdbd2cSJim Jagielski free(pEntry);
688*b1cdbd2cSJim Jagielski }
689*b1cdbd2cSJim Jagielski
690*b1cdbd2cSJim Jagielski pthread_mutex_unlock(&HashLock);
691*b1cdbd2cSJim Jagielski }
692*b1cdbd2cSJim Jagielski
osl_getThreadIdentifier(oslThread Thread)693*b1cdbd2cSJim Jagielski oslThreadIdentifier SAL_CALL osl_getThreadIdentifier(oslThread Thread)
694*b1cdbd2cSJim Jagielski {
695*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
696*b1cdbd2cSJim Jagielski sal_uInt16 Ident;
697*b1cdbd2cSJim Jagielski
698*b1cdbd2cSJim Jagielski if (pImpl)
699*b1cdbd2cSJim Jagielski Ident = pImpl->m_Ident;
700*b1cdbd2cSJim Jagielski else
701*b1cdbd2cSJim Jagielski {
702*b1cdbd2cSJim Jagielski /* current thread */
703*b1cdbd2cSJim Jagielski pthread_t current = pthread_self();
704*b1cdbd2cSJim Jagielski
705*b1cdbd2cSJim Jagielski Ident = lookupThreadId (current);
706*b1cdbd2cSJim Jagielski if (Ident == 0)
707*b1cdbd2cSJim Jagielski /* @@@ see TODO: alien pthread_self() @@@ */
708*b1cdbd2cSJim Jagielski Ident = insertThreadId (current);
709*b1cdbd2cSJim Jagielski }
710*b1cdbd2cSJim Jagielski
711*b1cdbd2cSJim Jagielski return ((oslThreadIdentifier)(Ident));
712*b1cdbd2cSJim Jagielski }
713*b1cdbd2cSJim Jagielski
714*b1cdbd2cSJim Jagielski /*****************************************************************************
715*b1cdbd2cSJim Jagielski @@@ see TODO @@@
716*b1cdbd2cSJim Jagielski osl_thread_priority_init_Impl
717*b1cdbd2cSJim Jagielski
718*b1cdbd2cSJim Jagielski set the base-priority of the main-thread to
719*b1cdbd2cSJim Jagielski oslThreadPriorityNormal (64) since 0 (lowest) is
720*b1cdbd2cSJim Jagielski the system default. This behaviour collides with
721*b1cdbd2cSJim Jagielski our enum-priority definition (highest..normal..lowest).
722*b1cdbd2cSJim Jagielski A normaluser will expect the main-thread of an app.
723*b1cdbd2cSJim Jagielski to have the "normal" priority.
724*b1cdbd2cSJim Jagielski
725*b1cdbd2cSJim Jagielski *****************************************************************************/
osl_thread_priority_init_Impl(void)726*b1cdbd2cSJim Jagielski static void osl_thread_priority_init_Impl (void)
727*b1cdbd2cSJim Jagielski {
728*b1cdbd2cSJim Jagielski #ifndef NO_PTHREAD_PRIORITY
729*b1cdbd2cSJim Jagielski struct sched_param param;
730*b1cdbd2cSJim Jagielski int policy=0;
731*b1cdbd2cSJim Jagielski int nRet=0;
732*b1cdbd2cSJim Jagielski
733*b1cdbd2cSJim Jagielski /* @@@ see TODO: calling thread may not be main thread @@@ */
734*b1cdbd2cSJim Jagielski
735*b1cdbd2cSJim Jagielski if ((nRet = pthread_getschedparam(pthread_self(), &policy, ¶m)) != 0)
736*b1cdbd2cSJim Jagielski {
737*b1cdbd2cSJim Jagielski OSL_TRACE("failed to get priority of thread [%s]\n",strerror(nRet));
738*b1cdbd2cSJim Jagielski return;
739*b1cdbd2cSJim Jagielski }
740*b1cdbd2cSJim Jagielski
741*b1cdbd2cSJim Jagielski #if defined (SOLARIS)
742*b1cdbd2cSJim Jagielski if ( policy >= _SCHED_NEXT)
743*b1cdbd2cSJim Jagielski {
744*b1cdbd2cSJim Jagielski /* mfe: pthread_getschedparam on Solaris has a possible Bug */
745*b1cdbd2cSJim Jagielski /* one gets 959917873 as the policy */
746*b1cdbd2cSJim Jagielski /* so set the policy to a default one */
747*b1cdbd2cSJim Jagielski policy=SCHED_OTHER;
748*b1cdbd2cSJim Jagielski }
749*b1cdbd2cSJim Jagielski #endif /* SOLARIS */
750*b1cdbd2cSJim Jagielski
751*b1cdbd2cSJim Jagielski if ((nRet = sched_get_priority_min(policy) ) != -1)
752*b1cdbd2cSJim Jagielski {
753*b1cdbd2cSJim Jagielski OSL_TRACE("Min Prioriy for policy '%i' == '%i'\n",policy,nRet);
754*b1cdbd2cSJim Jagielski g_thread.m_priority.m_Lowest=nRet;
755*b1cdbd2cSJim Jagielski }
756*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
757*b1cdbd2cSJim Jagielski else
758*b1cdbd2cSJim Jagielski {
759*b1cdbd2cSJim Jagielski fprintf(stderr,"failed to get min sched param [%s]\n",strerror(errno));
760*b1cdbd2cSJim Jagielski }
761*b1cdbd2cSJim Jagielski #endif /* OSL_DEBUG_LEVEL */
762*b1cdbd2cSJim Jagielski
763*b1cdbd2cSJim Jagielski if ((nRet = sched_get_priority_max(policy) ) != -1)
764*b1cdbd2cSJim Jagielski {
765*b1cdbd2cSJim Jagielski OSL_TRACE("Max Prioriy for policy '%i' == '%i'\n",policy,nRet);
766*b1cdbd2cSJim Jagielski g_thread.m_priority.m_Highest=nRet;
767*b1cdbd2cSJim Jagielski }
768*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
769*b1cdbd2cSJim Jagielski else
770*b1cdbd2cSJim Jagielski {
771*b1cdbd2cSJim Jagielski fprintf(stderr,"failed to get max sched param [%s]\n",strerror(errno));
772*b1cdbd2cSJim Jagielski }
773*b1cdbd2cSJim Jagielski #endif /* OSL_DEBUG_LEVEL */
774*b1cdbd2cSJim Jagielski
775*b1cdbd2cSJim Jagielski g_thread.m_priority.m_Normal =
776*b1cdbd2cSJim Jagielski (g_thread.m_priority.m_Lowest + g_thread.m_priority.m_Highest) / 2;
777*b1cdbd2cSJim Jagielski g_thread.m_priority.m_Below_Normal =
778*b1cdbd2cSJim Jagielski (g_thread.m_priority.m_Lowest + g_thread.m_priority.m_Normal) / 2;
779*b1cdbd2cSJim Jagielski g_thread.m_priority.m_Above_Normal =
780*b1cdbd2cSJim Jagielski (g_thread.m_priority.m_Normal + g_thread.m_priority.m_Highest) / 2;
781*b1cdbd2cSJim Jagielski
782*b1cdbd2cSJim Jagielski /* @@@ set prio of calling (not main) thread (?) @@@ */
783*b1cdbd2cSJim Jagielski
784*b1cdbd2cSJim Jagielski param.sched_priority= g_thread.m_priority.m_Normal;
785*b1cdbd2cSJim Jagielski
786*b1cdbd2cSJim Jagielski if ((nRet = pthread_setschedparam(pthread_self(), policy, ¶m)) != 0)
787*b1cdbd2cSJim Jagielski {
788*b1cdbd2cSJim Jagielski OSL_TRACE("failed to change base priority of thread [%s]\n",strerror(nRet));
789*b1cdbd2cSJim Jagielski OSL_TRACE("Thread ID '%i', Policy '%i', Priority '%i'\n",pthread_self(),policy,param.sched_priority);
790*b1cdbd2cSJim Jagielski }
791*b1cdbd2cSJim Jagielski
792*b1cdbd2cSJim Jagielski #endif /* NO_PTHREAD_PRIORITY */
793*b1cdbd2cSJim Jagielski }
794*b1cdbd2cSJim Jagielski
795*b1cdbd2cSJim Jagielski /*****************************************************************************/
796*b1cdbd2cSJim Jagielski /* osl_setThreadPriority */
797*b1cdbd2cSJim Jagielski /*
798*b1cdbd2cSJim Jagielski Impl-Notes: contrary to solaris-docu, which claims
799*b1cdbd2cSJim Jagielski valid priority-levels from 0 .. INT_MAX, only the
800*b1cdbd2cSJim Jagielski range 0..127 is accepted. (0 lowest, 127 highest)
801*b1cdbd2cSJim Jagielski */
802*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_setThreadPriority(oslThread Thread,oslThreadPriority Priority)803*b1cdbd2cSJim Jagielski void SAL_CALL osl_setThreadPriority (
804*b1cdbd2cSJim Jagielski oslThread Thread,
805*b1cdbd2cSJim Jagielski oslThreadPriority Priority)
806*b1cdbd2cSJim Jagielski {
807*b1cdbd2cSJim Jagielski #ifndef NO_PTHREAD_PRIORITY
808*b1cdbd2cSJim Jagielski
809*b1cdbd2cSJim Jagielski struct sched_param Param;
810*b1cdbd2cSJim Jagielski int policy;
811*b1cdbd2cSJim Jagielski int nRet;
812*b1cdbd2cSJim Jagielski
813*b1cdbd2cSJim Jagielski #endif /* NO_PTHREAD_PRIORITY */
814*b1cdbd2cSJim Jagielski
815*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
816*b1cdbd2cSJim Jagielski
817*b1cdbd2cSJim Jagielski OSL_ASSERT(pImpl);
818*b1cdbd2cSJim Jagielski if (!pImpl)
819*b1cdbd2cSJim Jagielski return; /* EINVAL */
820*b1cdbd2cSJim Jagielski
821*b1cdbd2cSJim Jagielski #ifdef NO_PTHREAD_PRIORITY
822*b1cdbd2cSJim Jagielski (void) Priority; /* unused */
823*b1cdbd2cSJim Jagielski #else /* NO_PTHREAD_PRIORITY */
824*b1cdbd2cSJim Jagielski
825*b1cdbd2cSJim Jagielski if (pthread_getschedparam(pImpl->m_hThread, &policy, &Param) != 0)
826*b1cdbd2cSJim Jagielski return; /* ESRCH */
827*b1cdbd2cSJim Jagielski
828*b1cdbd2cSJim Jagielski #if defined (SOLARIS)
829*b1cdbd2cSJim Jagielski if ( policy >= _SCHED_NEXT)
830*b1cdbd2cSJim Jagielski {
831*b1cdbd2cSJim Jagielski /* mfe: pthread_getschedparam on Solaris has a possible Bug */
832*b1cdbd2cSJim Jagielski /* one gets 959917873 as the policy */
833*b1cdbd2cSJim Jagielski /* so set the policy to a default one */
834*b1cdbd2cSJim Jagielski policy=SCHED_OTHER;
835*b1cdbd2cSJim Jagielski }
836*b1cdbd2cSJim Jagielski #endif /* SOLARIS */
837*b1cdbd2cSJim Jagielski
838*b1cdbd2cSJim Jagielski pthread_once (&(g_thread.m_once), osl_thread_init_Impl);
839*b1cdbd2cSJim Jagielski
840*b1cdbd2cSJim Jagielski switch(Priority)
841*b1cdbd2cSJim Jagielski {
842*b1cdbd2cSJim Jagielski case osl_Thread_PriorityHighest:
843*b1cdbd2cSJim Jagielski Param.sched_priority= g_thread.m_priority.m_Highest;
844*b1cdbd2cSJim Jagielski break;
845*b1cdbd2cSJim Jagielski
846*b1cdbd2cSJim Jagielski case osl_Thread_PriorityAboveNormal:
847*b1cdbd2cSJim Jagielski Param.sched_priority= g_thread.m_priority.m_Above_Normal;
848*b1cdbd2cSJim Jagielski break;
849*b1cdbd2cSJim Jagielski
850*b1cdbd2cSJim Jagielski case osl_Thread_PriorityNormal:
851*b1cdbd2cSJim Jagielski Param.sched_priority= g_thread.m_priority.m_Normal;
852*b1cdbd2cSJim Jagielski break;
853*b1cdbd2cSJim Jagielski
854*b1cdbd2cSJim Jagielski case osl_Thread_PriorityBelowNormal:
855*b1cdbd2cSJim Jagielski Param.sched_priority= g_thread.m_priority.m_Below_Normal;
856*b1cdbd2cSJim Jagielski break;
857*b1cdbd2cSJim Jagielski
858*b1cdbd2cSJim Jagielski case osl_Thread_PriorityLowest:
859*b1cdbd2cSJim Jagielski Param.sched_priority= g_thread.m_priority.m_Lowest;
860*b1cdbd2cSJim Jagielski break;
861*b1cdbd2cSJim Jagielski
862*b1cdbd2cSJim Jagielski case osl_Thread_PriorityUnknown:
863*b1cdbd2cSJim Jagielski OSL_ASSERT(sal_False); /* only fools try this...*/
864*b1cdbd2cSJim Jagielski
865*b1cdbd2cSJim Jagielski /* let release-version behave friendly */
866*b1cdbd2cSJim Jagielski return;
867*b1cdbd2cSJim Jagielski
868*b1cdbd2cSJim Jagielski default:
869*b1cdbd2cSJim Jagielski /* enum expanded, but forgotten here...*/
870*b1cdbd2cSJim Jagielski OSL_ENSURE(sal_False,"osl_setThreadPriority : unknown priority\n");
871*b1cdbd2cSJim Jagielski
872*b1cdbd2cSJim Jagielski /* let release-version behave friendly */
873*b1cdbd2cSJim Jagielski return;
874*b1cdbd2cSJim Jagielski }
875*b1cdbd2cSJim Jagielski
876*b1cdbd2cSJim Jagielski if ((nRet = pthread_setschedparam(pImpl->m_hThread, policy, &Param)) != 0)
877*b1cdbd2cSJim Jagielski {
878*b1cdbd2cSJim Jagielski OSL_TRACE("failed to change thread priority [%s]\n",strerror(nRet));
879*b1cdbd2cSJim Jagielski }
880*b1cdbd2cSJim Jagielski
881*b1cdbd2cSJim Jagielski #endif /* NO_PTHREAD_PRIORITY */
882*b1cdbd2cSJim Jagielski }
883*b1cdbd2cSJim Jagielski
884*b1cdbd2cSJim Jagielski /*****************************************************************************/
885*b1cdbd2cSJim Jagielski /* osl_getThreadPriority */
886*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_getThreadPriority(const oslThread Thread)887*b1cdbd2cSJim Jagielski oslThreadPriority SAL_CALL osl_getThreadPriority(const oslThread Thread)
888*b1cdbd2cSJim Jagielski {
889*b1cdbd2cSJim Jagielski #ifndef NO_PTHREAD_PRIORITY
890*b1cdbd2cSJim Jagielski
891*b1cdbd2cSJim Jagielski struct sched_param Param;
892*b1cdbd2cSJim Jagielski int Policy;
893*b1cdbd2cSJim Jagielski
894*b1cdbd2cSJim Jagielski #endif /* NO_PTHREAD_PRIORITY */
895*b1cdbd2cSJim Jagielski
896*b1cdbd2cSJim Jagielski oslThreadPriority Priority = osl_Thread_PriorityNormal;
897*b1cdbd2cSJim Jagielski Thread_Impl* pImpl= (Thread_Impl*)Thread;
898*b1cdbd2cSJim Jagielski
899*b1cdbd2cSJim Jagielski OSL_ASSERT(pImpl);
900*b1cdbd2cSJim Jagielski if (!pImpl)
901*b1cdbd2cSJim Jagielski return osl_Thread_PriorityUnknown; /* EINVAL */
902*b1cdbd2cSJim Jagielski
903*b1cdbd2cSJim Jagielski #ifndef NO_PTHREAD_PRIORITY
904*b1cdbd2cSJim Jagielski
905*b1cdbd2cSJim Jagielski if (pthread_getschedparam(pImpl->m_hThread, &Policy, &Param) != 0)
906*b1cdbd2cSJim Jagielski return osl_Thread_PriorityUnknown; /* ESRCH */
907*b1cdbd2cSJim Jagielski
908*b1cdbd2cSJim Jagielski pthread_once (&(g_thread.m_once), osl_thread_init_Impl);
909*b1cdbd2cSJim Jagielski
910*b1cdbd2cSJim Jagielski /* map pthread priority to enum */
911*b1cdbd2cSJim Jagielski if (Param.sched_priority==g_thread.m_priority.m_Highest)
912*b1cdbd2cSJim Jagielski {
913*b1cdbd2cSJim Jagielski /* 127 - highest */
914*b1cdbd2cSJim Jagielski Priority= osl_Thread_PriorityHighest;
915*b1cdbd2cSJim Jagielski }
916*b1cdbd2cSJim Jagielski else if (Param.sched_priority > g_thread.m_priority.m_Normal)
917*b1cdbd2cSJim Jagielski {
918*b1cdbd2cSJim Jagielski /* 65..126 - above normal */
919*b1cdbd2cSJim Jagielski Priority= osl_Thread_PriorityAboveNormal;
920*b1cdbd2cSJim Jagielski }
921*b1cdbd2cSJim Jagielski else if (Param.sched_priority == g_thread.m_priority.m_Normal)
922*b1cdbd2cSJim Jagielski {
923*b1cdbd2cSJim Jagielski /* normal */
924*b1cdbd2cSJim Jagielski Priority= osl_Thread_PriorityNormal;
925*b1cdbd2cSJim Jagielski }
926*b1cdbd2cSJim Jagielski else if (Param.sched_priority > g_thread.m_priority.m_Lowest)
927*b1cdbd2cSJim Jagielski {
928*b1cdbd2cSJim Jagielski /* 63..1 -below normal */
929*b1cdbd2cSJim Jagielski Priority= osl_Thread_PriorityBelowNormal;
930*b1cdbd2cSJim Jagielski }
931*b1cdbd2cSJim Jagielski else if (Param.sched_priority == g_thread.m_priority.m_Lowest)
932*b1cdbd2cSJim Jagielski {
933*b1cdbd2cSJim Jagielski /* 0 - lowest */
934*b1cdbd2cSJim Jagielski Priority= osl_Thread_PriorityLowest;
935*b1cdbd2cSJim Jagielski }
936*b1cdbd2cSJim Jagielski else
937*b1cdbd2cSJim Jagielski {
938*b1cdbd2cSJim Jagielski /* unknown */
939*b1cdbd2cSJim Jagielski Priority= osl_Thread_PriorityUnknown;
940*b1cdbd2cSJim Jagielski }
941*b1cdbd2cSJim Jagielski
942*b1cdbd2cSJim Jagielski #endif /* NO_PTHREAD_PRIORITY */
943*b1cdbd2cSJim Jagielski
944*b1cdbd2cSJim Jagielski return Priority;
945*b1cdbd2cSJim Jagielski }
946*b1cdbd2cSJim Jagielski
947*b1cdbd2cSJim Jagielski /*****************************************************************************/
948*b1cdbd2cSJim Jagielski /* osl_createThreadKey */
949*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_createThreadKey(oslThreadKeyCallbackFunction pCallback)950*b1cdbd2cSJim Jagielski oslThreadKey SAL_CALL osl_createThreadKey( oslThreadKeyCallbackFunction pCallback )
951*b1cdbd2cSJim Jagielski {
952*b1cdbd2cSJim Jagielski pthread_key_t key;
953*b1cdbd2cSJim Jagielski
954*b1cdbd2cSJim Jagielski if (pthread_key_create(&key, pCallback) != 0)
955*b1cdbd2cSJim Jagielski key = 0;
956*b1cdbd2cSJim Jagielski
957*b1cdbd2cSJim Jagielski return ((oslThreadKey)key);
958*b1cdbd2cSJim Jagielski }
959*b1cdbd2cSJim Jagielski
960*b1cdbd2cSJim Jagielski /*****************************************************************************/
961*b1cdbd2cSJim Jagielski /* osl_destroyThreadKey */
962*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_destroyThreadKey(oslThreadKey Key)963*b1cdbd2cSJim Jagielski void SAL_CALL osl_destroyThreadKey(oslThreadKey Key)
964*b1cdbd2cSJim Jagielski {
965*b1cdbd2cSJim Jagielski pthread_key_delete((pthread_key_t)Key);
966*b1cdbd2cSJim Jagielski }
967*b1cdbd2cSJim Jagielski
968*b1cdbd2cSJim Jagielski /*****************************************************************************/
969*b1cdbd2cSJim Jagielski /* osl_getThreadKeyData */
970*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_getThreadKeyData(oslThreadKey Key)971*b1cdbd2cSJim Jagielski void* SAL_CALL osl_getThreadKeyData(oslThreadKey Key)
972*b1cdbd2cSJim Jagielski {
973*b1cdbd2cSJim Jagielski return (pthread_getspecific((pthread_key_t)Key));
974*b1cdbd2cSJim Jagielski }
975*b1cdbd2cSJim Jagielski
976*b1cdbd2cSJim Jagielski /*****************************************************************************/
977*b1cdbd2cSJim Jagielski /* osl_setThreadKeyData */
978*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_setThreadKeyData(oslThreadKey Key,void * pData)979*b1cdbd2cSJim Jagielski sal_Bool SAL_CALL osl_setThreadKeyData(oslThreadKey Key, void *pData)
980*b1cdbd2cSJim Jagielski {
981*b1cdbd2cSJim Jagielski return (pthread_setspecific((pthread_key_t)Key, pData) == 0);
982*b1cdbd2cSJim Jagielski }
983*b1cdbd2cSJim Jagielski
984*b1cdbd2cSJim Jagielski /*****************************************************************************/
985*b1cdbd2cSJim Jagielski /* Thread Local Text Encoding */
986*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_thread_textencoding_init_Impl(void)987*b1cdbd2cSJim Jagielski static void osl_thread_textencoding_init_Impl (void)
988*b1cdbd2cSJim Jagielski {
989*b1cdbd2cSJim Jagielski rtl_TextEncoding defaultEncoding;
990*b1cdbd2cSJim Jagielski const char * pszEncoding;
991*b1cdbd2cSJim Jagielski
992*b1cdbd2cSJim Jagielski /* create thread specific data key */
993*b1cdbd2cSJim Jagielski pthread_key_create (&(g_thread.m_textencoding.m_key), NULL);
994*b1cdbd2cSJim Jagielski
995*b1cdbd2cSJim Jagielski /* determine default text encoding */
996*b1cdbd2cSJim Jagielski pszEncoding = getenv ("SOLAR_USER_RTL_TEXTENCODING");
997*b1cdbd2cSJim Jagielski if (pszEncoding)
998*b1cdbd2cSJim Jagielski defaultEncoding = atoi(pszEncoding);
999*b1cdbd2cSJim Jagielski else
1000*b1cdbd2cSJim Jagielski defaultEncoding = osl_getTextEncodingFromLocale(NULL);
1001*b1cdbd2cSJim Jagielski
1002*b1cdbd2cSJim Jagielski OSL_ASSERT(defaultEncoding != RTL_TEXTENCODING_DONTKNOW);
1003*b1cdbd2cSJim Jagielski
1004*b1cdbd2cSJim Jagielski /*
1005*b1cdbd2cSJim Jagielski Tools string functions call abort() on an unknown encoding so ASCII
1006*b1cdbd2cSJim Jagielski is a meaningfull fallback regardless wether the assertion makes sense.
1007*b1cdbd2cSJim Jagielski */
1008*b1cdbd2cSJim Jagielski
1009*b1cdbd2cSJim Jagielski if ( RTL_TEXTENCODING_DONTKNOW == defaultEncoding )
1010*b1cdbd2cSJim Jagielski defaultEncoding = RTL_TEXTENCODING_ASCII_US;
1011*b1cdbd2cSJim Jagielski
1012*b1cdbd2cSJim Jagielski g_thread.m_textencoding.m_default = defaultEncoding;
1013*b1cdbd2cSJim Jagielski }
1014*b1cdbd2cSJim Jagielski
1015*b1cdbd2cSJim Jagielski /*****************************************************************************/
1016*b1cdbd2cSJim Jagielski /* osl_getThreadTextEncoding */
1017*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_getThreadTextEncoding()1018*b1cdbd2cSJim Jagielski rtl_TextEncoding SAL_CALL osl_getThreadTextEncoding()
1019*b1cdbd2cSJim Jagielski {
1020*b1cdbd2cSJim Jagielski rtl_TextEncoding threadEncoding;
1021*b1cdbd2cSJim Jagielski
1022*b1cdbd2cSJim Jagielski pthread_once (&(g_thread.m_once), osl_thread_init_Impl);
1023*b1cdbd2cSJim Jagielski
1024*b1cdbd2cSJim Jagielski /* check for thread specific encoding, use default if not set */
1025*b1cdbd2cSJim Jagielski threadEncoding = SAL_INT_CAST(
1026*b1cdbd2cSJim Jagielski rtl_TextEncoding,
1027*b1cdbd2cSJim Jagielski (sal_uIntPtr) pthread_getspecific(g_thread.m_textencoding.m_key));
1028*b1cdbd2cSJim Jagielski if (0 == threadEncoding)
1029*b1cdbd2cSJim Jagielski threadEncoding = g_thread.m_textencoding.m_default;
1030*b1cdbd2cSJim Jagielski
1031*b1cdbd2cSJim Jagielski return threadEncoding;
1032*b1cdbd2cSJim Jagielski }
1033*b1cdbd2cSJim Jagielski
1034*b1cdbd2cSJim Jagielski /*****************************************************************************/
1035*b1cdbd2cSJim Jagielski /* osl_setThreadTextEncoding */
1036*b1cdbd2cSJim Jagielski /*****************************************************************************/
osl_setThreadTextEncoding(rtl_TextEncoding Encoding)1037*b1cdbd2cSJim Jagielski rtl_TextEncoding osl_setThreadTextEncoding(rtl_TextEncoding Encoding)
1038*b1cdbd2cSJim Jagielski {
1039*b1cdbd2cSJim Jagielski rtl_TextEncoding oldThreadEncoding = osl_getThreadTextEncoding();
1040*b1cdbd2cSJim Jagielski
1041*b1cdbd2cSJim Jagielski /* save encoding in thread local storage */
1042*b1cdbd2cSJim Jagielski pthread_setspecific (
1043*b1cdbd2cSJim Jagielski g_thread.m_textencoding.m_key,
1044*b1cdbd2cSJim Jagielski (void*) SAL_INT_CAST(sal_uIntPtr, Encoding));
1045*b1cdbd2cSJim Jagielski
1046*b1cdbd2cSJim Jagielski return oldThreadEncoding;
1047*b1cdbd2cSJim Jagielski }
1048