VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTR0ThreadPreemptionDriver.cpp@ 58269

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

*: scm cleanup run.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.4 KB
Line 
1/* $Id: tstRTR0ThreadPreemptionDriver.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2/** @file
3 * IPRT R0 Testcase - Thread Preemption, driver program.
4 */
5
6/*
7 * Copyright (C) 2009-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#include <iprt/initterm.h>
32
33#include <iprt/asm.h>
34#include <iprt/cpuset.h>
35#include <iprt/err.h>
36#include <iprt/path.h>
37#include <iprt/param.h>
38#include <iprt/stream.h>
39#include <iprt/string.h>
40#include <iprt/test.h>
41#include <iprt/time.h>
42#include <iprt/thread.h>
43#ifdef VBOX
44# include <VBox/sup.h>
45# include "tstRTR0ThreadPreemption.h"
46#endif
47
48
49/*********************************************************************************************************************************
50* Global Variables *
51*********************************************************************************************************************************/
52static bool volatile g_fTerminate = false;
53
54
55/**
56 * Try make sure all online CPUs will be engaged.
57 */
58static DECLCALLBACK(int) MyThreadProc(RTTHREAD hSelf, void *pvCpuIdx)
59{
60 RTCPUSET Affinity;
61 RTCpuSetEmpty(&Affinity);
62 RTCpuSetAddByIndex(&Affinity, (intptr_t)pvCpuIdx);
63 RTThreadSetAffinity(&Affinity); /* ignore return code as it's not supported on all hosts. */
64
65 while (!g_fTerminate)
66 {
67 uint64_t tsStart = RTTimeMilliTS();
68 do
69 {
70 ASMNopPause();
71 } while (RTTimeMilliTS() - tsStart < 8);
72 RTThreadSleep(4);
73 }
74
75 return VINF_SUCCESS;
76}
77
78
79/**
80 * Entry point.
81 */
82extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
83{
84#ifndef VBOX
85 RTPrintf("tstSup: SKIPPED\n");
86 return 0;
87#else
88 /*
89 * Init.
90 */
91 RTTEST hTest;
92 int rc = RTTestInitAndCreate("tstRTR0ThreadPreemption", &hTest);
93 if (rc)
94 return rc;
95 RTTestBanner(hTest);
96
97 PSUPDRVSESSION pSession;
98 rc = SUPR3Init(&pSession);
99 if (RT_FAILURE(rc))
100 {
101 RTTestFailed(hTest, "SUPR3Init failed with rc=%Rrc\n", rc);
102 return RTTestSummaryAndDestroy(hTest);
103 }
104
105 char szPath[RTPATH_MAX];
106 rc = RTPathExecDir(szPath, sizeof(szPath));
107 if (RT_SUCCESS(rc))
108 rc = RTPathAppend(szPath, sizeof(szPath), "tstRTR0ThreadPreemption.r0");
109 if (RT_FAILURE(rc))
110 {
111 RTTestFailed(hTest, "Failed constructing .r0 filename (rc=%Rrc)", rc);
112 return RTTestSummaryAndDestroy(hTest);
113 }
114
115 void *pvImageBase;
116 rc = SUPR3LoadServiceModule(szPath, "tstRTR0ThreadPreemption",
117 "TSTRTR0ThreadPreemptionSrvReqHandler",
118 &pvImageBase);
119 if (RT_FAILURE(rc))
120 {
121 RTTestFailed(hTest, "SUPR3LoadServiceModule(%s,,,) failed with rc=%Rrc\n", szPath, rc);
122 return RTTestSummaryAndDestroy(hTest);
123 }
124
125 /* test request */
126 struct
127 {
128 SUPR0SERVICEREQHDR Hdr;
129 char szMsg[256];
130 } Req;
131
132 /*
133 * Sanity checks.
134 */
135 RTTestSub(hTest, "Sanity");
136 Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
137 Req.Hdr.cbReq = sizeof(Req);
138 Req.szMsg[0] = '\0';
139 RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0ThreadPreemption", sizeof("tstRTR0ThreadPreemption") - 1,
140 TSTRTR0THREADPREEMPTION_SANITY_OK, 0, &Req.Hdr), VINF_SUCCESS);
141 if (RT_FAILURE(rc))
142 return RTTestSummaryAndDestroy(hTest);
143 RTTESTI_CHECK_MSG(Req.szMsg[0] == '\0', ("%s", Req.szMsg));
144 if (Req.szMsg[0] != '\0')
145 return RTTestSummaryAndDestroy(hTest);
146
147 Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
148 Req.Hdr.cbReq = sizeof(Req);
149 Req.szMsg[0] = '\0';
150 RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0ThreadPreemption", sizeof("tstRTR0ThreadPreemption") - 1,
151 TSTRTR0THREADPREEMPTION_SANITY_FAILURE, 0, &Req.Hdr), VINF_SUCCESS);
152 if (RT_FAILURE(rc))
153 return RTTestSummaryAndDestroy(hTest);
154 RTTESTI_CHECK_MSG(!strncmp(Req.szMsg, RT_STR_TUPLE("!42failure42")), ("%s", Req.szMsg));
155 if (strncmp(Req.szMsg, RT_STR_TUPLE("!42failure42")))
156 return RTTestSummaryAndDestroy(hTest);
157
158 /*
159 * Basic tests, bail out on failure.
160 */
161 RTTestSub(hTest, "Basics");
162 Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
163 Req.Hdr.cbReq = sizeof(Req);
164 Req.szMsg[0] = '\0';
165 RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0ThreadPreemption", sizeof("tstRTR0ThreadPreemption") - 1,
166 TSTRTR0THREADPREEMPTION_BASIC, 0, &Req.Hdr), VINF_SUCCESS);
167 if (RT_FAILURE(rc))
168 return RTTestSummaryAndDestroy(hTest);
169 if (Req.szMsg[0] == '!')
170 {
171 RTTestIFailed("%s", &Req.szMsg[1]);
172 return RTTestSummaryAndDestroy(hTest);
173 }
174 if (Req.szMsg[0])
175 RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
176
177 /*
178 * Is it trusty.
179 */
180 RTTestSub(hTest, "RTThreadPreemptIsPendingTrusty");
181 Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
182 Req.Hdr.cbReq = sizeof(Req);
183 Req.szMsg[0] = '\0';
184 RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0ThreadPreemption", sizeof("tstRTR0ThreadPreemption") - 1,
185 TSTRTR0THREADPREEMPTION_IS_TRUSTY, 0, &Req.Hdr), VINF_SUCCESS);
186 if (RT_FAILURE(rc))
187 return RTTestSummaryAndDestroy(hTest);
188 if (Req.szMsg[0] == '!')
189 RTTestIFailed("%s", &Req.szMsg[1]);
190 else if (Req.szMsg[0])
191 RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
192
193 /*
194 * Stay in ring-0 until preemption is pending.
195 */
196 RTTHREAD ahThreads[RTCPUSET_MAX_CPUS];
197 uint32_t cThreads = RTMpGetCount();
198 RTCPUSET OnlineSet;
199 RTMpGetOnlineSet(&OnlineSet);
200 for (uint32_t i = 0; i < RT_ELEMENTS(ahThreads); i++)
201 {
202 ahThreads[i] = NIL_RTTHREAD;
203 if (RTCpuSetIsMemberByIndex(&OnlineSet, i))
204 RTThreadCreateF(&ahThreads[i], MyThreadProc, (void *)(uintptr_t)i, 0, RTTHREADTYPE_DEFAULT,
205 RTTHREADFLAGS_WAITABLE, "cpu=%u", i);
206 }
207
208
209 RTTestSub(hTest, "Pending Preemption");
210 RTThreadSleep(250); /** @todo fix GIP initialization? */
211 for (int i = 0; ; i++)
212 {
213 Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
214 Req.Hdr.cbReq = sizeof(Req);
215 Req.szMsg[0] = '\0';
216 RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0ThreadPreemption", sizeof("tstRTR0ThreadPreemption") - 1,
217 TSTRTR0THREADPREEMPTION_IS_PENDING, 0, &Req.Hdr), VINF_SUCCESS);
218 if ( strcmp(Req.szMsg, "!cLoops=1\n")
219 || i >= 64)
220 {
221 if (Req.szMsg[0] == '!')
222 RTTestIFailed("%s", &Req.szMsg[1]);
223 else if (Req.szMsg[0])
224 RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
225 break;
226 }
227 if ((i % 3) == 0)
228 RTThreadYield();
229 else if ((i % 16) == 0)
230 RTThreadSleep(8);
231 }
232
233 ASMAtomicWriteBool(&g_fTerminate, true);
234 for (uint32_t i = 0; i < RT_ELEMENTS(ahThreads); i++)
235 if (ahThreads[i] != NIL_RTTHREAD)
236 RTThreadWait(ahThreads[i], 5000, NULL);
237
238 /*
239 * Test nested RTThreadPreemptDisable calls.
240 */
241 RTTestSub(hTest, "Nested");
242 Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
243 Req.Hdr.cbReq = sizeof(Req);
244 Req.szMsg[0] = '\0';
245 RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0ThreadPreemption", sizeof("tstRTR0ThreadPreemption") - 1,
246 TSTRTR0THREADPREEMPTION_NESTED, 0, &Req.Hdr), VINF_SUCCESS);
247 if (Req.szMsg[0] == '!')
248 RTTestIFailed("%s", &Req.szMsg[1]);
249 else if (Req.szMsg[0])
250 RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
251
252
253 /*
254 * Test thread-context hooks.
255 */
256 RTTestSub(hTest, "RTThreadCtxHooks");
257 uint64_t u64StartTS = RTTimeMilliTS();
258 uint64_t cMsMax = 60000; /* ca. 1 minute timeout. */
259 uint64_t cMsElapsed;
260 for (unsigned i = 0; i < 50; i++)
261 {
262 Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
263 Req.Hdr.cbReq = sizeof(Req);
264 Req.szMsg[0] = '\0';
265 RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0ThreadPreemption", sizeof("tstRTR0ThreadPreemption") - 1,
266 TSTRTR0THREADPREEMPTION_CTXHOOKS, 0, &Req.Hdr), VINF_SUCCESS);
267 if (RT_FAILURE(rc))
268 return RTTestSummaryAndDestroy(hTest);
269 if (Req.szMsg[0] == '!')
270 RTTestIFailed("%s", &Req.szMsg[1]);
271 else if (Req.szMsg[0])
272 RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
273 if (!(i % 10))
274 RTTestIPrintf(RTTESTLVL_ALWAYS, "RTThreadCtxHooks passed %u iteration(s)\n", i);
275
276 /* Check timeout and bail. */
277 cMsElapsed = RTTimeMilliTS() - u64StartTS;
278 if (cMsElapsed > cMsMax)
279 {
280 RTTestIPrintf(RTTESTLVL_INFO, "RTThreadCtxHooks Stopping iterations. %RU64 ms. for %u iterations.\n",
281 cMsElapsed, i);
282 break;
283 }
284 }
285
286 /*
287 * Done.
288 */
289 return RTTestSummaryAndDestroy(hTest);
290#endif
291}
292
293
294#if !defined(VBOX_WITH_HARDENING) || !defined(RT_OS_WINDOWS)
295/**
296 * Main entry point.
297 */
298int main(int argc, char **argv, char **envp)
299{
300 return TrustedMain(argc, argv, envp);
301}
302#endif
303
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