VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/os2/thread-os2.cpp@ 61627

Last change on this file since 61627 was 57358, checked in by vboxsync, 9 years ago

*: scm cleanup run.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 7.9 KB
Line 
1/* $Id: thread-os2.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2/** @file
3 * IPRT - Threads, OS/2.
4 */
5
6/*
7 * Copyright (C) 2006-2015 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#define INCL_BASE
33#include <os2.h>
34#undef RT_MAX
35
36#include <errno.h>
37#include <process.h>
38#include <stdlib.h>
39#include <signal.h>
40#include <InnoTekLIBC/FastInfoBlocks.h>
41#include <InnoTekLIBC/thread.h>
42
43#include <iprt/thread.h>
44#include <iprt/log.h>
45#include <iprt/assert.h>
46#include <iprt/alloc.h>
47#include <iprt/asm-amd64-x86.h>
48#include <iprt/cpuset.h>
49#include <iprt/string.h>
50#include <iprt/err.h>
51#include "internal/thread.h"
52
53
54/*********************************************************************************************************************************
55* Global Variables *
56*********************************************************************************************************************************/
57/** Pointer to thread local memory which points to the current thread. */
58static PRTTHREADINT *g_ppCurThread;
59
60
61/*********************************************************************************************************************************
62* Internal Functions *
63*********************************************************************************************************************************/
64static void rtThreadNativeMain(void *pvArgs);
65
66
67DECLHIDDEN(int) rtThreadNativeInit(void)
68{
69 /*
70 * Allocate thread local memory.
71 */
72 PULONG pul;
73 int rc = DosAllocThreadLocalMemory(1, &pul);
74 if (rc)
75 return VERR_NO_TLS_FOR_SELF;
76 g_ppCurThread = (PRTTHREADINT *)(void *)pul;
77 return VINF_SUCCESS;
78}
79
80
81static void rtThreadOs2BlockSigAlarm(void)
82{
83 /*
84 * Block SIGALRM - required for timer-posix.cpp.
85 * This is done to limit harm done by OSes which doesn't do special SIGALRM scheduling.
86 * It will not help much if someone creates threads directly using pthread_create. :/
87 */
88 sigset_t SigSet;
89 sigemptyset(&SigSet);
90 sigaddset(&SigSet, SIGALRM);
91 sigprocmask(SIG_BLOCK, &SigSet, NULL);
92}
93
94
95DECLHIDDEN(void) rtThreadNativeReInitObtrusive(void)
96{
97 rtThreadOs2BlockSigAlarm();
98}
99
100
101DECLHIDDEN(int) rtThreadNativeAdopt(PRTTHREADINT pThread)
102{
103
104 *g_ppCurThread = pThread;
105 return VINF_SUCCESS;
106}
107
108
109DECLHIDDEN(void) rtThreadNativeDestroy(PRTTHREADINT pThread)
110{
111 if (pThread == *g_ppCurThread)
112 *g_ppCurThread = NULL;
113}
114
115
116/**
117 * Wrapper which unpacks the params and calls thread function.
118 */
119static void rtThreadNativeMain(void *pvArgs)
120{
121 rtThreadOs2BlockSigAlarm();
122
123 /*
124 * Call common main.
125 */
126 PRTTHREADINT pThread = (PRTTHREADINT)pvArgs;
127 *g_ppCurThread = pThread;
128
129#ifdef fibGetTidPid
130 rtThreadMain(pThread, fibGetTidPid(), &pThread->szName[0]);
131#else
132 rtThreadMain(pThread, _gettid(), &pThread->szName[0]);
133#endif
134
135 *g_ppCurThread = NULL;
136 _endthread();
137}
138
139
140DECLHIDDEN(int) rtThreadNativeCreate(PRTTHREADINT pThread, PRTNATIVETHREAD pNativeThread)
141{
142 /*
143 * Default stack size.
144 */
145 if (!pThread->cbStack)
146 pThread->cbStack = 512*1024;
147
148 /*
149 * Create the thread.
150 */
151 int iThreadId = _beginthread(rtThreadNativeMain, NULL, pThread->cbStack, pThread);
152 if (iThreadId > 0)
153 {
154#ifdef fibGetTidPid
155 *pNativeThread = iThreadId | (fibGetPid() << 16);
156#else
157 *pNativeThread = iThreadId;
158#endif
159 return VINF_SUCCESS;
160 }
161 return RTErrConvertFromErrno(errno);
162}
163
164
165RTDECL(RTTHREAD) RTThreadSelf(void)
166{
167 PRTTHREADINT pThread = *g_ppCurThread;
168 if (pThread)
169 return (RTTHREAD)pThread;
170 /** @todo import alien threads? */
171 return NULL;
172}
173
174
175RTDECL(RTNATIVETHREAD) RTThreadNativeSelf(void)
176{
177#ifdef fibGetTidPid
178 return fibGetTidPid();
179#else
180 return _gettid();
181#endif
182}
183
184
185RTDECL(int) RTThreadSleep(RTMSINTERVAL cMillies)
186{
187 LogFlow(("RTThreadSleep: cMillies=%d\n", cMillies));
188 DosSleep(cMillies);
189 LogFlow(("RTThreadSleep: returning (cMillies=%d)\n", cMillies));
190 return VINF_SUCCESS;
191}
192
193
194RTDECL(int) RTThreadSleepNoLog(RTMSINTERVAL cMillies)
195{
196 DosSleep(cMillies);
197 return VINF_SUCCESS;
198}
199
200
201RTDECL(bool) RTThreadYield(void)
202{
203 uint64_t u64TS = ASMReadTSC();
204 DosSleep(0);
205 u64TS = ASMReadTSC() - u64TS;
206 bool fRc = u64TS > 1750;
207 LogFlow(("RTThreadYield: returning %d (%llu ticks)\n", fRc, u64TS));
208 return fRc;
209}
210
211
212RTR3DECL(int) RTThreadGetAffinity(PRTCPUSET pCpuSet)
213{
214 union
215 {
216 uint64_t u64;
217 MPAFFINITY mpaff;
218 } u;
219
220 APIRET rc = DosQueryThreadAffinity(AFNTY_THREAD, &u.mpaff);
221 if (!rc)
222 {
223 RTCpuSetFromU64(pCpuSet, u.u64);
224 return VINF_SUCCESS;
225 }
226 return RTErrConvertFromOS2(rc);
227}
228
229
230RTR3DECL(int) RTThreadSetAffinity(PCRTCPUSET pCpuSet)
231{
232 union
233 {
234 uint64_t u64;
235 MPAFFINITY mpaff;
236 } u;
237 u.u64 = pCpuSet ? RTCpuSetToU64(pCpuSet) : UINT64_MAX;
238 int rc = DosSetThreadAffinity(&u.mpaff);
239 if (!rc)
240 return VINF_SUCCESS;
241 return RTErrConvertFromOS2(rc);
242}
243
244
245RTR3DECL(RTTLS) RTTlsAlloc(void)
246{
247 AssertCompile(NIL_RTTLS == -1);
248 return __libc_TLSAlloc();
249}
250
251
252RTR3DECL(int) RTTlsAllocEx(PRTTLS piTls, PFNRTTLSDTOR pfnDestructor)
253{
254 int rc;
255 int iTls = __libc_TLSAlloc();
256 if (iTls != -1)
257 {
258 if ( !pfnDestructor
259 || __libc_TLSDestructor(iTls, (void (*)(void *, int, unsigned))pfnDestructor, 0) != -1)
260 {
261 *piTls = iTls;
262 return VINF_SUCCESS;
263 }
264
265 rc = RTErrConvertFromErrno(errno);
266 __libc_TLSFree(iTls);
267 }
268 else
269 rc = RTErrConvertFromErrno(errno);
270
271 *piTls = NIL_RTTLS;
272 return rc;
273}
274
275
276RTR3DECL(int) RTTlsFree(RTTLS iTls)
277{
278 if (iTls == NIL_RTTLS)
279 return VINF_SUCCESS;
280 if (__libc_TLSFree(iTls) != -1)
281 return VINF_SUCCESS;
282 return RTErrConvertFromErrno(errno);
283}
284
285
286RTR3DECL(void *) RTTlsGet(RTTLS iTls)
287{
288 return __libc_TLSGet(iTls);
289}
290
291
292RTR3DECL(int) RTTlsGetEx(RTTLS iTls, void **ppvValue)
293{
294 int rc = VINF_SUCCESS;
295 void *pv = __libc_TLSGet(iTls);
296 if (RT_UNLIKELY(!pv))
297 {
298 errno = 0;
299 pv = __libc_TLSGet(iTls);
300 if (!pv && errno)
301 rc = RTErrConvertFromErrno(errno);
302 }
303
304 *ppvValue = pv;
305 return rc;
306}
307
308
309RTR3DECL(int) RTTlsSet(RTTLS iTls, void *pvValue)
310{
311 if (__libc_TLSSet(iTls, pvValue) != -1)
312 return VINF_SUCCESS;
313 return RTErrConvertFromErrno(errno);
314}
315
316
317RTR3DECL(int) RTThreadGetExecutionTimeMilli(uint64_t *pKernelTime, uint64_t *pUserTime)
318{
319 return VERR_NOT_IMPLEMENTED;
320}
Note: See TracBrowser for help on using the repository browser.

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