VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/win/thread-win.cpp@ 58029

Last change on this file since 58029 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: 11.9 KB
Line 
1/* $Id: thread-win.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2/** @file
3 * IPRT - Threads, Windows.
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#include <Windows.h>
33
34#include <errno.h>
35#include <process.h>
36
37#include <iprt/thread.h>
38#include "internal/iprt.h"
39
40#include <iprt/asm-amd64-x86.h>
41#include <iprt/assert.h>
42#include <iprt/cpuset.h>
43#include <iprt/err.h>
44#include <iprt/log.h>
45#include <iprt/mem.h>
46#include "internal/thread.h"
47
48
49/*********************************************************************************************************************************
50* Defined Constants And Macros *
51*********************************************************************************************************************************/
52/** The TLS index allocated for storing the RTTHREADINT pointer. */
53static DWORD g_dwSelfTLS = TLS_OUT_OF_INDEXES;
54
55
56/*********************************************************************************************************************************
57* Internal Functions *
58*********************************************************************************************************************************/
59static unsigned __stdcall rtThreadNativeMain(void *pvArgs);
60static void rtThreadWinTellDebuggerThreadName(uint32_t idThread, const char *pszName);
61
62
63DECLHIDDEN(int) rtThreadNativeInit(void)
64{
65 g_dwSelfTLS = TlsAlloc();
66 if (g_dwSelfTLS == TLS_OUT_OF_INDEXES)
67 return VERR_NO_TLS_FOR_SELF;
68 return VINF_SUCCESS;
69}
70
71
72DECLHIDDEN(void) rtThreadNativeReInitObtrusive(void)
73{
74 /* nothing to do here. */
75}
76
77
78DECLHIDDEN(void) rtThreadNativeDetach(void)
79{
80 /*
81 * Deal with alien threads.
82 */
83 PRTTHREADINT pThread = (PRTTHREADINT)TlsGetValue(g_dwSelfTLS);
84 if ( pThread
85 && (pThread->fIntFlags & RTTHREADINT_FLAGS_ALIEN))
86 {
87 rtThreadTerminate(pThread, 0);
88 TlsSetValue(g_dwSelfTLS, NULL);
89 }
90}
91
92
93DECLHIDDEN(void) rtThreadNativeDestroy(PRTTHREADINT pThread)
94{
95 if (pThread == (PRTTHREADINT)TlsGetValue(g_dwSelfTLS))
96 TlsSetValue(g_dwSelfTLS, NULL);
97
98 if ((HANDLE)pThread->hThread != INVALID_HANDLE_VALUE)
99 {
100 CloseHandle((HANDLE)pThread->hThread);
101 pThread->hThread = (uintptr_t)INVALID_HANDLE_VALUE;
102 }
103}
104
105
106DECLHIDDEN(int) rtThreadNativeAdopt(PRTTHREADINT pThread)
107{
108 if (!TlsSetValue(g_dwSelfTLS, pThread))
109 return VERR_FAILED_TO_SET_SELF_TLS;
110 if (IsDebuggerPresent())
111 rtThreadWinTellDebuggerThreadName(GetCurrentThreadId(), pThread->szName);
112 return VINF_SUCCESS;
113}
114
115
116DECLHIDDEN(void) rtThreadNativeInformDebugger(PRTTHREADINT pThread)
117{
118 rtThreadWinTellDebuggerThreadName((uint32_t)(uintptr_t)pThread->Core.Key, pThread->szName);
119}
120
121
122/**
123 * Communicates the thread name to the debugger, if we're begin debugged that
124 * is.
125 *
126 * See http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx for debugger
127 * interface details.
128 *
129 * @param idThread The thread ID. UINT32_MAX for current thread.
130 * @param pszName The name.
131 */
132static void rtThreadWinTellDebuggerThreadName(uint32_t idThread, const char *pszName)
133{
134 struct
135 {
136 uint32_t uType;
137 const char *pszName;
138 uint32_t idThread;
139 uint32_t fFlags;
140 } Pkg = { 0x1000, pszName, idThread, 0 };
141 __try
142 {
143 RaiseException(0x406d1388, 0, sizeof(Pkg)/sizeof(ULONG_PTR), (ULONG_PTR *)&Pkg);
144 }
145 __except(EXCEPTION_CONTINUE_EXECUTION)
146 {
147
148 }
149}
150
151
152/**
153 * Bitch about dangling COM and OLE references, dispose of them
154 * afterwards so we don't end up deadlocked somewhere below
155 * OLE32!DllMain.
156 */
157static void rtThreadNativeUninitComAndOle(void)
158{
159#if 1 /* experimental code */
160 /*
161 * Read the counters.
162 */
163 struct MySOleTlsData
164 {
165 void *apvReserved0[2]; /**< x86=0x00 W7/64=0x00 */
166 DWORD adwReserved0[3]; /**< x86=0x08 W7/64=0x10 */
167 void *apvReserved1[1]; /**< x86=0x14 W7/64=0x20 */
168 DWORD cComInits; /**< x86=0x18 W7/64=0x28 */
169 DWORD cOleInits; /**< x86=0x1c W7/64=0x2c */
170 DWORD dwReserved1; /**< x86=0x20 W7/64=0x30 */
171 void *apvReserved2[4]; /**< x86=0x24 W7/64=0x38 */
172 DWORD adwReserved2[1]; /**< x86=0x34 W7/64=0x58 */
173 void *pvCurrentCtx; /**< x86=0x38 W7/64=0x60 */
174 IUnknown *pCallState; /**< x86=0x3c W7/64=0x68 */
175 } *pOleTlsData = NULL; /* outside the try/except for debugging */
176 DWORD cComInits = 0;
177 DWORD cOleInits = 0;
178 __try
179 {
180 void *pvTeb = NtCurrentTeb();
181# ifdef RT_ARCH_AMD64
182 pOleTlsData = *(struct MySOleTlsData **)((uintptr_t)pvTeb + 0x1758); /*TEB.ReservedForOle*/
183# elif RT_ARCH_X86
184 pOleTlsData = *(struct MySOleTlsData **)((uintptr_t)pvTeb + 0x0f80); /*TEB.ReservedForOle*/
185# else
186# error "Port me!"
187# endif
188 if (pOleTlsData)
189 {
190 cComInits = pOleTlsData->cComInits;
191 cOleInits = pOleTlsData->cOleInits;
192 }
193 }
194 __except(EXCEPTION_EXECUTE_HANDLER)
195 {
196 AssertFailedReturnVoid();
197 }
198
199 /*
200 * Assert sanity. If any of these breaks, the structure layout above is
201 * probably not correct any longer.
202 */
203 AssertMsgReturnVoid(cComInits < 1000, ("%u (%#x)\n", cComInits, cComInits));
204 AssertMsgReturnVoid(cOleInits < 1000, ("%u (%#x)\n", cOleInits, cOleInits));
205 AssertMsgReturnVoid(cComInits >= cOleInits, ("cComInits=%#x cOleInits=%#x\n", cComInits, cOleInits));
206
207 /*
208 * Do the uninitializing.
209 */
210 if (cComInits)
211 {
212 AssertMsgFailed(("cComInits=%u (%#x) cOleInits=%u (%#x) - dangling COM/OLE inits!\n",
213 cComInits, cComInits, cOleInits, cOleInits));
214
215 HMODULE hOle32 = GetModuleHandle("ole32.dll");
216 AssertReturnVoid(hOle32 != NULL);
217
218 typedef void (WINAPI *PFNOLEUNINITIALIZE)(void);
219 PFNOLEUNINITIALIZE pfnOleUninitialize = (PFNOLEUNINITIALIZE)GetProcAddress(hOle32, "OleUninitialize");
220 AssertReturnVoid(pfnOleUninitialize);
221
222 typedef void (WINAPI *PFNCOUNINITIALIZE)(void);
223 PFNCOUNINITIALIZE pfnCoUninitialize = (PFNCOUNINITIALIZE)GetProcAddress(hOle32, "CoUninitialize");
224 AssertReturnVoid(pfnCoUninitialize);
225
226 while (cOleInits-- > 0)
227 {
228 pfnOleUninitialize();
229 cComInits--;
230 }
231
232 while (cComInits-- > 0)
233 pfnCoUninitialize();
234 }
235#endif
236}
237
238
239/**
240 * Wrapper which unpacks the param stuff and calls thread function.
241 */
242static unsigned __stdcall rtThreadNativeMain(void *pvArgs)
243{
244 DWORD dwThreadId = GetCurrentThreadId();
245 PRTTHREADINT pThread = (PRTTHREADINT)pvArgs;
246
247 if (!TlsSetValue(g_dwSelfTLS, pThread))
248 AssertReleaseMsgFailed(("failed to set self TLS. lasterr=%d thread '%s'\n", GetLastError(), pThread->szName));
249 if (IsDebuggerPresent())
250 rtThreadWinTellDebuggerThreadName(dwThreadId, &pThread->szName[0]);
251
252 int rc = rtThreadMain(pThread, dwThreadId, &pThread->szName[0]);
253
254 TlsSetValue(g_dwSelfTLS, NULL);
255 rtThreadNativeUninitComAndOle();
256 _endthreadex(rc);
257 return rc;
258}
259
260
261DECLHIDDEN(int) rtThreadNativeCreate(PRTTHREADINT pThread, PRTNATIVETHREAD pNativeThread)
262{
263 AssertReturn(pThread->cbStack < ~(unsigned)0, VERR_INVALID_PARAMETER);
264
265 /*
266 * Create the thread.
267 */
268 pThread->hThread = (uintptr_t)INVALID_HANDLE_VALUE;
269 unsigned uThreadId = 0;
270 uintptr_t hThread = _beginthreadex(NULL, (unsigned)pThread->cbStack, rtThreadNativeMain, pThread, 0, &uThreadId);
271 if (hThread != 0 && hThread != ~0U)
272 {
273 pThread->hThread = hThread;
274 *pNativeThread = uThreadId;
275 return VINF_SUCCESS;
276 }
277 return RTErrConvertFromErrno(errno);
278}
279
280
281RTDECL(RTTHREAD) RTThreadSelf(void)
282{
283 PRTTHREADINT pThread = (PRTTHREADINT)TlsGetValue(g_dwSelfTLS);
284 /** @todo import alien threads ? */
285 return pThread;
286}
287
288
289#if 0 /* noone is using this ... */
290/**
291 * Returns the processor number the current thread was running on during this call
292 *
293 * @returns processor nr
294 */
295static int rtThreadGetCurrentProcessorNumber(void)
296{
297 static bool fInitialized = false;
298 static DWORD (WINAPI *pfnGetCurrentProcessorNumber)(void) = NULL;
299 if (!fInitialized)
300 {
301 HMODULE hmodKernel32 = GetModuleHandle("kernel32.dll");
302 if (hmodKernel32)
303 pfnGetCurrentProcessorNumber = (DWORD (WINAPI*)(void))GetProcAddress(hmodKernel32, "GetCurrentProcessorNumber");
304 fInitialized = true;
305 }
306 if (pfnGetCurrentProcessorNumber)
307 return pfnGetCurrentProcessorNumber();
308 return -1;
309}
310#endif
311
312
313RTR3DECL(int) RTThreadSetAffinity(PCRTCPUSET pCpuSet)
314{
315 DWORD_PTR fNewMask = pCpuSet ? RTCpuSetToU64(pCpuSet) : ~(DWORD_PTR)0;
316 DWORD_PTR dwRet = SetThreadAffinityMask(GetCurrentThread(), fNewMask);
317 if (dwRet)
318 return VINF_SUCCESS;
319
320 int iLastError = GetLastError();
321 AssertMsgFailed(("SetThreadAffinityMask failed, LastError=%d\n", iLastError));
322 return RTErrConvertFromWin32(iLastError);
323}
324
325
326RTR3DECL(int) RTThreadGetAffinity(PRTCPUSET pCpuSet)
327{
328 /*
329 * Haven't found no query api, but the set api returns the old mask, so let's use that.
330 */
331 DWORD_PTR dwIgnored;
332 DWORD_PTR dwProcAff = 0;
333 if (GetProcessAffinityMask(GetCurrentProcess(), &dwProcAff, &dwIgnored))
334 {
335 HANDLE hThread = GetCurrentThread();
336 DWORD_PTR dwRet = SetThreadAffinityMask(hThread, dwProcAff);
337 if (dwRet)
338 {
339 DWORD_PTR dwSet = SetThreadAffinityMask(hThread, dwRet);
340 Assert(dwSet == dwProcAff); NOREF(dwRet);
341
342 RTCpuSetFromU64(pCpuSet, (uint64_t)dwSet);
343 return VINF_SUCCESS;
344 }
345 }
346
347 int iLastError = GetLastError();
348 AssertMsgFailed(("SetThreadAffinityMask or GetProcessAffinityMask failed, LastError=%d\n", iLastError));
349 return RTErrConvertFromWin32(iLastError);
350}
351
352
353RTR3DECL(int) RTThreadGetExecutionTimeMilli(uint64_t *pKernelTime, uint64_t *pUserTime)
354{
355 uint64_t u64CreationTime, u64ExitTime, u64KernelTime, u64UserTime;
356
357 if (GetThreadTimes(GetCurrentThread(), (LPFILETIME)&u64CreationTime, (LPFILETIME)&u64ExitTime, (LPFILETIME)&u64KernelTime, (LPFILETIME)&u64UserTime))
358 {
359 *pKernelTime = u64KernelTime / 10000; /* GetThreadTimes returns time in 100 ns units */
360 *pUserTime = u64UserTime / 10000; /* GetThreadTimes returns time in 100 ns units */
361 return VINF_SUCCESS;
362 }
363
364 int iLastError = GetLastError();
365 AssertMsgFailed(("GetThreadTimes failed, LastError=%d\n", iLastError));
366 return RTErrConvertFromWin32(iLastError);
367}
368
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