VirtualBox

source: vbox/trunk/src/VBox/VMM/testcase/tstPDMAsyncCompletion.cpp@ 77807

Last change on this file since 77807 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 9.1 KB
Line 
1/* $Id: tstPDMAsyncCompletion.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * PDM Asynchronous Completion Testcase.
4 *
5 * This testcase is for testing the async completion interface.
6 * It implements a file copy program which uses the interface to copy the data.
7 *
8 * Use: ./tstPDMAsyncCompletion <source> <destination>
9 */
10
11/*
12 * Copyright (C) 2008-2019 Oracle Corporation
13 *
14 * This file is part of VirtualBox Open Source Edition (OSE), as
15 * available from http://www.virtualbox.org. This file is free software;
16 * you can redistribute it and/or modify it under the terms of the GNU
17 * General Public License (GPL) as published by the Free Software
18 * Foundation, in version 2 as it comes in the "COPYING" file of the
19 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
20 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
21 */
22
23
24/*********************************************************************************************************************************
25* Header Files *
26*********************************************************************************************************************************/
27#define LOG_GROUP LOG_GROUP_PDM_ASYNC_COMPLETION
28
29#include "VMInternal.h" /* UVM */
30#include <VBox/vmm/vm.h>
31#include <VBox/vmm/uvm.h>
32#include <VBox/vmm/pdmasynccompletion.h>
33#include <VBox/vmm/vmm.h>
34#include <VBox/vmm/cpum.h>
35#include <iprt/errcore.h>
36#include <VBox/log.h>
37#include <VBox/vmm/pdmapi.h>
38#include <iprt/alloc.h>
39#include <iprt/asm.h>
40#include <iprt/assert.h>
41#include <iprt/file.h>
42#include <iprt/initterm.h>
43#include <iprt/semaphore.h>
44#include <iprt/stream.h>
45#include <iprt/string.h>
46#include <iprt/thread.h>
47
48#define TESTCASE "tstPDMAsyncCompletion"
49
50/*
51 * Number of simultaneous active tasks.
52 */
53#define NR_TASKS 80
54#define BUFFER_SIZE (64*_1K)
55
56/* Buffers to store data in .*/
57uint8_t *g_AsyncCompletionTasksBuffer[NR_TASKS];
58PPDMASYNCCOMPLETIONTASK g_AsyncCompletionTasks[NR_TASKS];
59volatile uint32_t g_cTasksLeft;
60RTSEMEVENT g_FinishedEventSem;
61
62static DECLCALLBACK(void) AsyncTaskCompleted(PVM pVM, void *pvUser, void *pvUser2, int rc)
63{
64 RT_NOREF4(pVM, pvUser, pvUser2, rc);
65 LogFlow((TESTCASE ": %s: pVM=%p pvUser=%p pvUser2=%p\n", __FUNCTION__, pVM, pvUser, pvUser2));
66
67 uint32_t cTasksStillLeft = ASMAtomicDecU32(&g_cTasksLeft);
68
69 if (!cTasksStillLeft)
70 {
71 /* All tasks processed. Wakeup main. */
72 RTSemEventSignal(g_FinishedEventSem);
73 }
74}
75
76/**
77 * Entry point.
78 */
79extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
80{
81 RT_NOREF1(envp);
82 int rcRet = 0; /* error count */
83 PPDMASYNCCOMPLETIONENDPOINT pEndpointSrc, pEndpointDst;
84
85 RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
86
87 if (argc != 3)
88 {
89 RTPrintf(TESTCASE ": Usage is ./tstPDMAsyncCompletion <source> <dest>\n");
90 return 1;
91 }
92
93 PVM pVM;
94 PUVM pUVM;
95 int rc = VMR3Create(1, NULL, NULL, NULL, NULL, NULL, &pVM, &pUVM);
96 if (RT_SUCCESS(rc))
97 {
98 /*
99 * Little hack to avoid the VM_ASSERT_EMT assertion.
100 */
101 RTTlsSet(pVM->pUVM->vm.s.idxTLS, &pVM->pUVM->aCpus[0]);
102 pVM->pUVM->aCpus[0].pUVM = pVM->pUVM;
103 pVM->pUVM->aCpus[0].vm.s.NativeThreadEMT = RTThreadNativeSelf();
104
105 /*
106 * Create the template.
107 */
108 PPDMASYNCCOMPLETIONTEMPLATE pTemplate;
109 rc = PDMR3AsyncCompletionTemplateCreateInternal(pVM, &pTemplate, AsyncTaskCompleted, NULL, "Test");
110 if (RT_FAILURE(rc))
111 {
112 RTPrintf(TESTCASE ": Error while creating the template!! rc=%d\n", rc);
113 return 1;
114 }
115
116 /*
117 * Create event semaphore.
118 */
119 rc = RTSemEventCreate(&g_FinishedEventSem);
120 AssertRC(rc);
121
122 /*
123 * Create the temporary buffers.
124 */
125 for (unsigned i=0; i < NR_TASKS; i++)
126 {
127 g_AsyncCompletionTasksBuffer[i] = (uint8_t *)RTMemAllocZ(BUFFER_SIZE);
128 if (!g_AsyncCompletionTasksBuffer[i])
129 {
130 RTPrintf(TESTCASE ": out of memory!\n");
131 return ++rcRet;
132 }
133 }
134
135 /* Create the destination as the async completion API can't do this. */
136 RTFILE FileTmp;
137 rc = RTFileOpen(&FileTmp, argv[2], RTFILE_O_READWRITE | RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_NONE);
138 if (RT_FAILURE(rc))
139 {
140 RTPrintf(TESTCASE ": Error while creating the destination!! rc=%d\n", rc);
141 return ++rcRet;
142 }
143 RTFileClose(FileTmp);
144
145 /* Create our file endpoint */
146 rc = PDMR3AsyncCompletionEpCreateForFile(&pEndpointSrc, argv[1], 0, pTemplate);
147 if (RT_SUCCESS(rc))
148 {
149 rc = PDMR3AsyncCompletionEpCreateForFile(&pEndpointDst, argv[2], 0, pTemplate);
150 if (RT_SUCCESS(rc))
151 {
152 PDMR3PowerOn(pVM);
153
154 /* Wait for all threads to finish initialization. */
155 RTThreadSleep(100);
156
157 int fReadPass = true;
158 uint64_t cbSrc;
159 size_t offSrc = 0;
160 size_t offDst = 0;
161 uint32_t cTasksUsed = 0;
162
163 rc = PDMR3AsyncCompletionEpGetSize(pEndpointSrc, &cbSrc);
164 if (RT_SUCCESS(rc))
165 {
166 /* Copy the data. */
167 for (;;)
168 {
169 if (fReadPass)
170 {
171 cTasksUsed = (BUFFER_SIZE * NR_TASKS) <= (cbSrc - offSrc)
172 ? NR_TASKS
173 : ((cbSrc - offSrc) / BUFFER_SIZE)
174 + ((cbSrc - offSrc) % BUFFER_SIZE) > 0
175 ? 1
176 : 0;
177
178 g_cTasksLeft = cTasksUsed;
179
180 for (uint32_t i = 0; i < cTasksUsed; i++)
181 {
182 size_t cbRead = ((size_t)offSrc + BUFFER_SIZE) <= cbSrc ? BUFFER_SIZE : cbSrc - offSrc;
183 RTSGSEG DataSeg;
184
185 DataSeg.pvSeg = g_AsyncCompletionTasksBuffer[i];
186 DataSeg.cbSeg = cbRead;
187
188 rc = PDMR3AsyncCompletionEpRead(pEndpointSrc, offSrc, &DataSeg, 1, cbRead, NULL,
189 &g_AsyncCompletionTasks[i]);
190 AssertRC(rc);
191 offSrc += cbRead;
192 if (offSrc == cbSrc)
193 break;
194 }
195 }
196 else
197 {
198 g_cTasksLeft = cTasksUsed;
199
200 for (uint32_t i = 0; i < cTasksUsed; i++)
201 {
202 size_t cbWrite = (offDst + BUFFER_SIZE) <= cbSrc ? BUFFER_SIZE : cbSrc - offDst;
203 RTSGSEG DataSeg;
204
205 DataSeg.pvSeg = g_AsyncCompletionTasksBuffer[i];
206 DataSeg.cbSeg = cbWrite;
207
208 rc = PDMR3AsyncCompletionEpWrite(pEndpointDst, offDst, &DataSeg, 1, cbWrite, NULL,
209 &g_AsyncCompletionTasks[i]);
210 AssertRC(rc);
211 offDst += cbWrite;
212 if (offDst == cbSrc)
213 break;
214 }
215 }
216
217 rc = RTSemEventWait(g_FinishedEventSem, RT_INDEFINITE_WAIT);
218 AssertRC(rc);
219
220 if (!fReadPass && (offDst == cbSrc))
221 break;
222 else if (fReadPass)
223 fReadPass = false;
224 else
225 {
226 cTasksUsed = 0;
227 fReadPass = true;
228 }
229 }
230 }
231 else
232 {
233 RTPrintf(TESTCASE ": Error querying size of the endpoint!! rc=%d\n", rc);
234 rcRet++;
235 }
236
237 PDMR3PowerOff(pVM);
238 PDMR3AsyncCompletionEpClose(pEndpointDst);
239 }
240 PDMR3AsyncCompletionEpClose(pEndpointSrc);
241 }
242
243 rc = VMR3Destroy(pUVM);
244 AssertMsg(rc == VINF_SUCCESS, ("%s: Destroying VM failed rc=%Rrc!!\n", __FUNCTION__, rc));
245 VMR3ReleaseUVM(pUVM);
246
247 /*
248 * Clean up.
249 */
250 for (uint32_t i = 0; i < NR_TASKS; i++)
251 {
252 RTMemFree(g_AsyncCompletionTasksBuffer[i]);
253 }
254 }
255 else
256 {
257 RTPrintf(TESTCASE ": failed to create VM!! rc=%Rrc\n", rc);
258 rcRet++;
259 }
260
261 return rcRet;
262}
263
264
265#if !defined(VBOX_WITH_HARDENING) || !defined(RT_OS_WINDOWS)
266/**
267 * Main entry point.
268 */
269int main(int argc, char **argv, char **envp)
270{
271 return TrustedMain(argc, argv, envp);
272}
273#endif
274
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