VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/posix/thread-posix.cpp@ 40532

Last change on this file since 40532 was 37733, checked in by vboxsync, 14 years ago

gcc 4.4.4 build fix for VBOX_WITH_EF_WRAPS=1.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 11.0 KB
Line 
1/* $Id: thread-posix.cpp 37733 2011-07-01 15:41:37Z vboxsync $ */
2/** @file
3 * IPRT - Threads, POSIX.
4 */
5
6/*
7 * Copyright (C) 2006-2011 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*******************************************************************************
29* Header Files *
30*******************************************************************************/
31#define LOG_GROUP RTLOGGROUP_THREAD
32#include <errno.h>
33#include <pthread.h>
34#include <signal.h>
35#if defined(RT_OS_LINUX)
36# include <unistd.h>
37# include <sys/syscall.h>
38#endif
39#if defined(RT_OS_SOLARIS)
40# include <sched.h>
41# include <sys/resource.h>
42#endif
43#if defined(RT_OS_DARWIN)
44# include <mach/thread_act.h>
45# include <mach/thread_info.h>
46# include <mach/host_info.h>
47# include <mach/mach_init.h>
48# include <mach/mach_host.h>
49#endif
50
51#include <iprt/thread.h>
52#include <iprt/log.h>
53#include <iprt/assert.h>
54#include <iprt/asm.h>
55#include <iprt/err.h>
56#include <iprt/string.h>
57#include "internal/thread.h"
58
59
60/*******************************************************************************
61* Defined Constants And Macros *
62*******************************************************************************/
63#ifndef IN_GUEST
64/** Includes RTThreadPoke. */
65# define RTTHREAD_POSIX_WITH_POKE
66#endif
67
68
69/*******************************************************************************
70* Global Variables *
71*******************************************************************************/
72/** The pthread key in which we store the pointer to our own PRTTHREAD structure. */
73static pthread_key_t g_SelfKey;
74#ifdef RTTHREAD_POSIX_WITH_POKE
75/** The signal we use for poking threads.
76 * This is set to -1 if no available signal was found. */
77static int g_iSigPokeThread = -1;
78#endif
79
80
81/*******************************************************************************
82* Internal Functions *
83*******************************************************************************/
84static void *rtThreadNativeMain(void *pvArgs);
85static void rtThreadKeyDestruct(void *pvValue);
86static void rtThreadPosixPokeSignal(int iSignal);
87
88
89DECLHIDDEN(int) rtThreadNativeInit(void)
90{
91 /*
92 * Allocate the TLS (key in posix terms) where we store the pointer to
93 * a threads RTTHREADINT structure.
94 */
95 int rc = pthread_key_create(&g_SelfKey, rtThreadKeyDestruct);
96 if (rc)
97 return VERR_NO_TLS_FOR_SELF;
98
99#ifdef RTTHREAD_POSIX_WITH_POKE
100 /*
101 * Try register the dummy signal handler for RTThreadPoke.
102 * Avoid SIGRTMIN thru SIGRTMIN+2 because of LinuxThreads.
103 */
104 static const int s_aiSigCandidates[] =
105 {
106# ifdef SIGRTMAX
107 SIGRTMAX-3,
108 SIGRTMAX-2,
109 SIGRTMAX-1,
110# endif
111# ifndef RT_OS_SOLARIS
112 SIGUSR2,
113# endif
114 SIGWINCH
115 };
116
117 g_iSigPokeThread = -1;
118 for (unsigned iSig = 0; iSig < RT_ELEMENTS(s_aiSigCandidates); iSig++)
119 {
120 struct sigaction SigActOld;
121 if (!sigaction(s_aiSigCandidates[iSig], NULL, &SigActOld))
122 {
123 if ( SigActOld.sa_handler == SIG_DFL
124 || SigActOld.sa_handler == rtThreadPosixPokeSignal)
125 {
126 struct sigaction SigAct;
127 RT_ZERO(SigAct);
128 SigAct.sa_handler = rtThreadPosixPokeSignal;
129 SigAct.sa_flags = 0;
130 sigfillset(&SigAct.sa_mask);
131
132 /* ASSUMES no sigaction race... (lazy bird) */
133 if (!sigaction(s_aiSigCandidates[iSig], &SigAct, NULL))
134 {
135 g_iSigPokeThread = s_aiSigCandidates[iSig];
136 break;
137 }
138 AssertMsgFailed(("rc=%Rrc errno=%d\n", RTErrConvertFromErrno(errno), errno));
139 }
140 }
141 else
142 AssertMsgFailed(("rc=%Rrc errno=%d\n", RTErrConvertFromErrno(errno), errno));
143 }
144#endif /* RTTHREAD_POSIX_WITH_POKE */
145 return rc;
146}
147
148
149/**
150 * Destructor called when a thread terminates.
151 * @param pvValue The key value. PRTTHREAD in our case.
152 */
153static void rtThreadKeyDestruct(void *pvValue)
154{
155 /*
156 * Deal with alien threads.
157 */
158 PRTTHREADINT pThread = (PRTTHREADINT)pvValue;
159 if (pThread->fIntFlags & RTTHREADINT_FLAGS_ALIEN)
160 {
161 pthread_setspecific(g_SelfKey, pThread);
162 rtThreadTerminate(pThread, 0);
163 pthread_setspecific(g_SelfKey, NULL);
164 }
165}
166
167
168#ifdef RTTHREAD_POSIX_WITH_POKE
169/**
170 * Dummy signal handler for the poke signal.
171 *
172 * @param iSignal The signal number.
173 */
174static void rtThreadPosixPokeSignal(int iSignal)
175{
176 Assert(iSignal == g_iSigPokeThread);
177 NOREF(iSignal);
178}
179#endif
180
181
182/**
183 * Adopts a thread, this is called immediately after allocating the
184 * thread structure.
185 *
186 * @param pThread Pointer to the thread structure.
187 */
188DECLHIDDEN(int) rtThreadNativeAdopt(PRTTHREADINT pThread)
189{
190 /*
191 * Block SIGALRM - required for timer-posix.cpp.
192 * This is done to limit harm done by OSes which doesn't do special SIGALRM scheduling.
193 * It will not help much if someone creates threads directly using pthread_create. :/
194 */
195 sigset_t SigSet;
196 sigemptyset(&SigSet);
197 sigaddset(&SigSet, SIGALRM);
198 sigprocmask(SIG_BLOCK, &SigSet, NULL);
199#ifdef RTTHREAD_POSIX_WITH_POKE
200 if (g_iSigPokeThread != -1)
201 siginterrupt(g_iSigPokeThread, 1);
202#endif
203
204 int rc = pthread_setspecific(g_SelfKey, pThread);
205 if (!rc)
206 return VINF_SUCCESS;
207 return VERR_FAILED_TO_SET_SELF_TLS;
208}
209
210
211DECLHIDDEN(void) rtThreadNativeDestroy(PRTTHREADINT pThread)
212{
213 if (pThread == (PRTTHREADINT)pthread_getspecific(g_SelfKey))
214 pthread_setspecific(g_SelfKey, NULL);
215}
216
217
218/**
219 * Wrapper which unpacks the params and calls thread function.
220 */
221static void *rtThreadNativeMain(void *pvArgs)
222{
223 PRTTHREADINT pThread = (PRTTHREADINT)pvArgs;
224
225#if defined(RT_OS_LINUX)
226 /*
227 * Set the TID.
228 */
229 pThread->tid = syscall(__NR_gettid);
230 ASMMemoryFence();
231#endif
232
233 /*
234 * Block SIGALRM - required for timer-posix.cpp.
235 * This is done to limit harm done by OSes which doesn't do special SIGALRM scheduling.
236 * It will not help much if someone creates threads directly using pthread_create. :/
237 */
238 sigset_t SigSet;
239 sigemptyset(&SigSet);
240 sigaddset(&SigSet, SIGALRM);
241 sigprocmask(SIG_BLOCK, &SigSet, NULL);
242#ifdef RTTHREAD_POSIX_WITH_POKE
243 if (g_iSigPokeThread != -1)
244 siginterrupt(g_iSigPokeThread, 1);
245#endif
246
247 int rc = pthread_setspecific(g_SelfKey, pThread);
248 AssertReleaseMsg(!rc, ("failed to set self TLS. rc=%d thread '%s'\n", rc, pThread->szName));
249
250 /*
251 * Call common main.
252 */
253 pthread_t Self = pthread_self();
254 Assert((uintptr_t)Self == (RTNATIVETHREAD)Self && (uintptr_t)Self != NIL_RTNATIVETHREAD);
255 rc = rtThreadMain(pThread, (uintptr_t)Self, &pThread->szName[0]);
256
257 pthread_setspecific(g_SelfKey, NULL);
258 pthread_exit((void *)(intptr_t)rc);
259 return (void *)(intptr_t)rc;
260}
261
262
263DECLHIDDEN(int) rtThreadNativeCreate(PRTTHREADINT pThread, PRTNATIVETHREAD pNativeThread)
264{
265 /*
266 * Set the default stack size.
267 */
268 if (!pThread->cbStack)
269 pThread->cbStack = 512*1024;
270
271#ifdef RT_OS_LINUX
272 pThread->tid = -1;
273#endif
274
275 /*
276 * Setup thread attributes.
277 */
278 pthread_attr_t ThreadAttr;
279 int rc = pthread_attr_init(&ThreadAttr);
280 if (!rc)
281 {
282 rc = pthread_attr_setdetachstate(&ThreadAttr, PTHREAD_CREATE_DETACHED);
283 if (!rc)
284 {
285 rc = pthread_attr_setstacksize(&ThreadAttr, pThread->cbStack);
286 if (!rc)
287 {
288 /*
289 * Create the thread.
290 */
291 pthread_t ThreadId;
292 rc = pthread_create(&ThreadId, &ThreadAttr, rtThreadNativeMain, pThread);
293 if (!rc)
294 {
295 *pNativeThread = (uintptr_t)ThreadId;
296 return VINF_SUCCESS;
297 }
298 }
299 }
300 pthread_attr_destroy(&ThreadAttr);
301 }
302 return RTErrConvertFromErrno(rc);
303}
304
305
306RTDECL(RTTHREAD) RTThreadSelf(void)
307{
308 PRTTHREADINT pThread = (PRTTHREADINT)pthread_getspecific(g_SelfKey);
309 /** @todo import alien threads? */
310 return pThread;
311}
312
313
314#ifdef RTTHREAD_POSIX_WITH_POKE
315RTDECL(int) RTThreadPoke(RTTHREAD hThread)
316{
317 AssertReturn(hThread != RTThreadSelf(), VERR_INVALID_PARAMETER);
318 PRTTHREADINT pThread = rtThreadGet(hThread);
319 AssertReturn(pThread, VERR_INVALID_HANDLE);
320
321 int rc;
322 if (g_iSigPokeThread != -1)
323 {
324 rc = pthread_kill((pthread_t)(uintptr_t)pThread->Core.Key, g_iSigPokeThread);
325 rc = RTErrConvertFromErrno(rc);
326 }
327 else
328 rc = VERR_NOT_SUPPORTED;
329
330 rtThreadRelease(pThread);
331 return rc;
332}
333#endif
334
335/** @todo move this into platform specific files. */
336RTR3DECL(int) RTThreadGetExecutionTimeMilli(uint64_t *pKernelTime, uint64_t *pUserTime)
337{
338#if defined(RT_OS_SOLARIS)
339 struct rusage ts;
340 int rc = getrusage(RUSAGE_LWP, &ts);
341 if (rc)
342 return RTErrConvertFromErrno(rc);
343
344 *pKernelTime = ts.ru_stime.tv_sec * 1000 + ts.ru_stime.tv_usec / 1000;
345 *pUserTime = ts.ru_utime.tv_sec * 1000 + ts.ru_utime.tv_usec / 1000;
346 return VINF_SUCCESS;
347
348#elif defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
349 /* on Linux, getrusage(RUSAGE_THREAD, ...) is available since 2.6.26 */
350 struct timespec ts;
351 int rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
352 if (rc)
353 return RTErrConvertFromErrno(rc);
354
355 *pKernelTime = 0;
356 *pUserTime = (uint64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
357 return VINF_SUCCESS;
358
359#elif defined(RT_OS_DARWIN)
360 thread_basic_info ThreadInfo;
361 mach_msg_type_number_t Count = THREAD_BASIC_INFO_COUNT;
362 kern_return_t krc = thread_info(mach_thread_self(), THREAD_BASIC_INFO, (thread_info_t)&ThreadInfo, &Count);
363 AssertReturn(krc == KERN_SUCCESS, RTErrConvertFromDarwinKern(krc));
364
365 *pKernelTime = ThreadInfo.system_time.seconds * 1000 + ThreadInfo.system_time.microseconds / 1000;
366 *pUserTime = ThreadInfo.user_time.seconds * 1000 + ThreadInfo.user_time.microseconds / 1000;
367
368 return VINF_SUCCESS;
369#else
370 return VERR_NOT_IMPLEMENTED;
371#endif
372}
373
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette