VMMDevTesting.cpp@ 40280

Last change on this file since 40280 was 40280, checked in by vboxsync, 13 years ago
Corrected a bunch of HC and GC uses in status codes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 12.7 KB

Line
1	/* $Id: VMMDevTesting.cpp 40280 2012-02-28 19:47:00Z vboxsync $ */
2	/** @file
3	* VMMDev - Testing Extensions.
4	*/
5
6	/*
7	* Copyright (C) 2010 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
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DEV_VMM
23	#include <VBox/VMMDev.h>
24	#include <VBox/log.h>
25	#include <VBox/err.h>
26
27	#include <iprt/asm.h>
28	#include <iprt/assert.h>
29	#include <iprt/string.h>
30	#include <iprt/time.h>
31	#ifdef IN_RING3
32	# include <iprt/stream.h>
33	#endif
34
35	#include "VMMDevState.h"
36	#include "VMMDevTesting.h"
37
38
39	#ifndef VBOX_WITHOUT_TESTING_FEATURES
40
41	/**
42	* @callback_method_impl{FNIOMMMIOWRITE}
43	*/
44	PDMBOTHCBDECL(int) vmmdevTestingMmioWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void const pv, unsigned cb)
45	{
46	switch (GCPhysAddr)
47	{
48	case VMMDEV_TESTING_MMIO_NOP:
49	switch (cb)
50	{
51	case 8:
52	case 4:
53	case 2:
54	case 1:
55	break;
56	default:
57	AssertFailed();
58	return VERR_INTERNAL_ERROR_5;
59	}
60	return VINF_SUCCESS;
61
62	default:
63	break;
64	}
65	return VINF_SUCCESS;
66	}
67
68
69	/**
70	* @callback_method_impl{FNIOMMMIOREAD}
71	*/
72	PDMBOTHCBDECL(int) vmmdevTestingMmioRead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
73	{
74	switch (GCPhysAddr)
75	{
76	case VMMDEV_TESTING_MMIO_NOP:
77	switch (cb)
78	{
79	case 8:
80	(uint64_t )pv = VMMDEV_TESTING_NOP_RET \| ((uint64_t)VMMDEV_TESTING_NOP_RET << 32);
81	break;
82	case 4:
83	(uint32_t )pv = VMMDEV_TESTING_NOP_RET;
84	break;
85	case 2:
86	(uint16_t )pv = (uint16_t)VMMDEV_TESTING_NOP_RET;
87	break;
88	case 1:
89	(uint8_t )pv = (uint8_t)VMMDEV_TESTING_NOP_RET;
90	break;
91	default:
92	AssertFailed();
93	return VERR_INTERNAL_ERROR_5;
94	}
95	return VINF_SUCCESS;
96
97
98	default:
99	break;
100	}
101
102	return VINF_IOM_MMIO_UNUSED_FF;
103	}
104
105
106	/**
107	* @callback_method_impl{FNIOMIOPORTOUT}
108	*/
109	PDMBOTHCBDECL(int) vmmdevTestingIoWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
110	{
111	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
112
113	switch (Port)
114	{
115	case VMMDEV_TESTING_IOPORT_NOP:
116	switch (cb)
117	{
118	case 4:
119	case 2:
120	case 1:
121	break;
122	default:
123	AssertFailed();
124	return VERR_INTERNAL_ERROR_2;
125	}
126	return VINF_SUCCESS;
127
128	case VMMDEV_TESTING_IOPORT_TS_LOW:
129	break;
130
131	case VMMDEV_TESTING_IOPORT_TS_HIGH:
132	break;
133
134	case VMMDEV_TESTING_IOPORT_CMD:
135	if (cb == 4)
136	{
137	pThis->u32TestingCmd = u32;
138	pThis->offTestingData = 0;
139	RT_ZERO(pThis->TestingData);
140	return VINF_SUCCESS;
141	}
142	break;
143
144	case VMMDEV_TESTING_IOPORT_DATA:
145	{
146	uint32_t uCmd = pThis->u32TestingCmd;
147	uint32_t off = pThis->offTestingData;
148	switch (uCmd)
149	{
150	case VMMDEV_TESTING_CMD_INIT:
151	case VMMDEV_TESTING_CMD_SUB_NEW:
152	case VMMDEV_TESTING_CMD_FAILED:
153	if ( off < sizeof(pThis->TestingData.String.sz) - 1
154	&& cb == 1)
155	{
156	if (u32)
157	{
158	pThis->TestingData.String.sz[off] = u32;
159	pThis->offTestingData = off + 1;
160	}
161	else
162	{
163	#ifdef IN_RING3
164	switch (uCmd)
165	{
166	case VMMDEV_TESTING_CMD_INIT:
167	RTPrintf("testing: INIT '%.*s'\n", sizeof(pThis->TestingData.String.sz) - 1, pThis->TestingData.String.sz);
168	break;
169	case VMMDEV_TESTING_CMD_SUB_NEW:
170	RTPrintf("testing: SUB_NEW '%.*s'\n", sizeof(pThis->TestingData.String.sz) - 1, pThis->TestingData.String.sz);
171	break;
172	case VMMDEV_TESTING_CMD_FAILED:
173	RTPrintf("testing: FAILED '%.*s'\n", sizeof(pThis->TestingData.String.sz) - 1, pThis->TestingData.String.sz);
174	break;
175	}
176	#else
177	return VINF_IOM_R3_IOPORT_WRITE;
178	#endif
179	}
180	return VINF_SUCCESS;
181	}
182	break;
183
184	case VMMDEV_TESTING_CMD_TERM:
185	case VMMDEV_TESTING_CMD_SUB_DONE:
186	if ( off == 0
187	&& cb == 4)
188	{
189	#ifdef IN_RING3
190	pThis->TestingData.Error.c = u32;
191	if (uCmd == VMMDEV_TESTING_CMD_TERM)
192	RTPrintf("testing: TERM - %u errors\n", u32);
193	else
194	RTPrintf("testing: SUB_DONE - %u errors\n", u32);
195	return VINF_SUCCESS;
196	#else
197	return VINF_IOM_R3_IOPORT_WRITE;
198	#endif
199	}
200	break;
201
202	case VMMDEV_TESTING_CMD_VALUE:
203	if (cb == 4)
204	{
205	if (off == 0)
206	pThis->TestingData.Value.u64Value.s.Lo = u32;
207	else if (off == 4)
208	pThis->TestingData.Value.u64Value.s.Hi = u32;
209	else if (off == 8)
210	pThis->TestingData.Value.u32Unit = u32;
211	else
212	break;
213	pThis->offTestingData = off + 4;
214	return VINF_SUCCESS;
215	}
216	if ( off >= 12
217	&& cb == 1
218	&& off < sizeof(pThis->TestingData.Value.szName) - 1 - 12)
219	{
220	if (u32)
221	{
222	pThis->TestingData.Value.szName[off - 12] = u32;
223	pThis->offTestingData = off + 1;
224	}
225	else
226	{
227	#ifdef IN_RING3
228	RTPrintf("testing: VALUE '%.s'%s: %'9llu (%#llx) [%u]\n",
229	sizeof(pThis->TestingData.Value.szName) - 1, pThis->TestingData.Value.szName,
230	off - 12 > 48 ? 0 : 48 - (off - 12), "",
231	pThis->TestingData.Value.u64Value.u, pThis->TestingData.Value.u64Value.u,
232	pThis->TestingData.Value.u32Unit);
233	#else
234	return VINF_IOM_R3_IOPORT_WRITE;
235	#endif
236	}
237	return VINF_SUCCESS;
238
239	#ifdef IN_RING3
240	pThis->TestingData.Error.c = u32;
241	if (uCmd == VMMDEV_TESTING_CMD_TERM)
242	RTPrintf("testing: TERM - %u errors\n", u32);
243	else
244	RTPrintf("testing: SUB_DONE - %u errors\n", u32);
245	return VINF_SUCCESS;
246	#else
247	return VINF_IOM_R3_IOPORT_WRITE;
248	#endif
249	}
250	break;
251
252	default:
253	break;
254	}
255	Log(("VMMDEV_TESTING_IOPORT_CMD: bad access; cmd=%#x off=%#x cb=%#x u32=%#x\n", uCmd, off, cb, u32));
256	return VINF_SUCCESS;
257	}
258
259	default:
260	break;
261	}
262
263	return VERR_IOM_IOPORT_UNUSED;
264	}
265
266
267	/**
268	* @callback_method_impl{FNIOMIOPORTIN}
269	*/
270	PDMBOTHCBDECL(int) vmmdevTestingIoRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
271	{
272	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
273
274	switch (Port)
275	{
276	case VMMDEV_TESTING_IOPORT_NOP:
277	switch (cb)
278	{
279	case 4:
280	case 2:
281	case 1:
282	break;
283	default:
284	AssertFailed();
285	return VERR_INTERNAL_ERROR_2;
286	}
287	*pu32 = VMMDEV_TESTING_NOP_RET;
288	return VINF_SUCCESS;
289
290	case VMMDEV_TESTING_IOPORT_TS_LOW:
291	if (cb == 4)
292	{
293	uint64_t NowTS = RTTimeNanoTS();
294	*pu32 = (uint32_t)NowTS;
295	pThis->u32TestingHighTimestamp = (uint32_t)(NowTS >> 32);
296	return VINF_SUCCESS;
297	}
298	break;
299
300	case VMMDEV_TESTING_IOPORT_TS_HIGH:
301	if (cb == 4)
302	{
303	*pu32 = pThis->u32TestingHighTimestamp;
304	return VINF_SUCCESS;
305	}
306	break;
307
308	case VMMDEV_TESTING_IOPORT_CMD:
309	case VMMDEV_TESTING_IOPORT_DATA:
310	break;
311
312	default:
313	break;
314	}
315
316	return VERR_IOM_IOPORT_UNUSED;
317	}
318
319
320	#ifdef IN_RING3
321
322	/**
323	* Initializes the testing part of the VMMDev if enabled.
324	*
325	* @returns VBox status code.
326	* @param pDevIns The VMMDev device instance.
327	*/
328	int vmmdevTestingInitialize(PPDMDEVINS pDevIns)
329	{
330	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
331	if (!pThis->fTestingEnabled)
332	return VINF_SUCCESS;
333
334	/*
335	* Register a chunk of MMIO memory that we'll use for various
336	* tests interfaces.
337	*/
338	int rc = PDMDevHlpMMIORegister(pDevIns, VMMDEV_TESTING_MMIO_BASE, VMMDEV_TESTING_MMIO_SIZE, NULL /pvUser/,
339	IOMMMIO_FLAGS_READ_PASSTHRU \| IOMMMIO_FLAGS_WRITE_PASSTHRU,
340	vmmdevTestingMmioWrite, vmmdevTestingMmioRead, "VMMDev Testing");
341	AssertRCReturn(rc, rc);
342	if (pThis->fRZEnabled)
343	{
344	rc = PDMDevHlpMMIORegisterR0(pDevIns, VMMDEV_TESTING_MMIO_BASE, VMMDEV_TESTING_MMIO_SIZE, NIL_RTR0PTR /pvUser/,
345	"vmmdevTestingMmioWrite", "vmmdevTestingMmioRead");
346	AssertRCReturn(rc, rc);
347	rc = PDMDevHlpMMIORegisterRC(pDevIns, VMMDEV_TESTING_MMIO_BASE, VMMDEV_TESTING_MMIO_SIZE, NIL_RTRCPTR /pvUser/,
348	"vmmdevTestingMmioWrite", "vmmdevTestingMmioRead");
349	AssertRCReturn(rc, rc);
350	}
351
352
353	/*
354	* Register the I/O ports used for testing.
355	*/
356	rc = PDMDevHlpIOPortRegister(pDevIns, VMMDEV_TESTING_IOPORT_BASE, VMMDEV_TESTING_IOPORT_COUNT, NULL,
357	vmmdevTestingIoWrite,
358	vmmdevTestingIoRead,
359	NULL /pfnOutStr/,
360	NULL /pfnInStr/,
361	"VMMDev Testing");
362	AssertRCReturn(rc, rc);
363	if (pThis->fRZEnabled)
364	{
365	rc = PDMDevHlpIOPortRegisterR0(pDevIns, VMMDEV_TESTING_IOPORT_BASE, VMMDEV_TESTING_IOPORT_COUNT, NIL_RTR0PTR /pvUser/,
366	"vmmdevTestingIoWrite",
367	"vmmdevTestingIoRead",
368	NULL /pszOutStr/,
369	NULL /pszInStr/,
370	"VMMDev Testing");
371	AssertRCReturn(rc, rc);
372	rc = PDMDevHlpIOPortRegisterRC(pDevIns, VMMDEV_TESTING_IOPORT_BASE, VMMDEV_TESTING_IOPORT_COUNT, NIL_RTRCPTR /pvUser/,
373	"vmmdevTestingIoWrite",
374	"vmmdevTestingIoRead",
375	NULL /pszOutStr/,
376	NULL /pszInStr/,
377	"VMMDev Testing");
378	AssertRCReturn(rc, rc);
379	}
380
381	return VINF_SUCCESS;
382	}
383
384	#endif /* IN_RING3 */
385	#endif /* !VBOX_WITHOUT_TESTING_FEATURES */
386

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/VMMDev/VMMDevTesting.cpp@ 40280

Download in other formats: