tstDeviceVMMStubs.cpp@ 76520

Last change on this file since 76520 was 73097, checked in by vboxsync, 6 years ago
*: Made RT_UOFFSETOF, RT_OFFSETOF, RT_UOFFSETOF_ADD and RT_OFFSETOF_ADD work like builtin_offsetof() and require compile time resolvable requests, adding RT_UOFFSETOF_DYN for the dynamic questions that can only be answered at runtime.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.2 KB

Line
1	/* $Id: tstDeviceVMMStubs.cpp 73097 2018-07-12 21:06:33Z vboxsync $ */
2	/** @file
3	* tstDevice - Test framework for PDM devices/drivers, shim library exporting methods
4	* originally for VBoxVMM for intercepting (we don't want to use the PDM module
5	* to use the originals from VBoxVMM).
6	*/
7
8	/*
9	* Copyright (C) 2017 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*/
19	/* Methods imported from VBoxVMM by VBoxDD are extracted with:
20	* objdump -T VBoxDD.so \| grep "UND" \| awk -F ' ' '{print $5}' \| grep -E "^TM\|^PGM\|^PDM\|^CFGM\|^IOM\|^MM\|^VM\|^PDM\|^SUP" \| sort
21	*/
22
23
24	/*********************************************************************************************************************************
25	* Header Files *
26	*********************************************************************************************************************************/
27	#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
28	#include <iprt/assert.h>
29	#include <iprt/mem.h>
30
31	#include <VBox/err.h>
32	#include <VBox/cdefs.h>
33
34	#include "tstDeviceVMMInternal.h"
35
36
37	/*********************************************************************************************************************************
38	* Defined Constants And Macros *
39	*********************************************************************************************************************************/
40
41
42	/*********************************************************************************************************************************
43	* Structures and Typedefs *
44	*********************************************************************************************************************************/
45
46
47	/*********************************************************************************************************************************
48	* Global Variables *
49	*********************************************************************************************************************************/
50
51
52	/*********************************************************************************************************************************
53	* Internal Functions *
54	*********************************************************************************************************************************/
55
56
57	/**
58	* @copydoc CFGMR3AreValuesValid
59	*/
60	VMMR3DECL(bool) CFGMR3AreValuesValid(PCFGMNODE pNode, const char *pszzValid)
61	{
62	return pNode->pVmmCallbacks->pfnCFGMR3AreValuesValid(pNode, pszzValid);
63	}
64
65
66	/**
67	* @copydoc CFGMR3Dump
68	*/
69	VMMR3DECL(void) CFGMR3Dump(PCFGMNODE pRoot)
70	{
71	pRoot->pVmmCallbacks->pfnCFGMR3Dump(pRoot);
72	}
73
74
75	/**
76	* @copydoc CFGMR3GetChild
77	*/
78	VMMR3DECL(PCFGMNODE) CFGMR3GetChild(PCFGMNODE pNode, const char *pszPath)
79	{
80	return pNode->pVmmCallbacks->pfnCFGMR3GetChild(pNode, pszPath);
81	}
82
83
84	/**
85	* @copydoc CFGMR3GetChildF
86	*/
87	VMMR3DECL(PCFGMNODE) CFGMR3GetChildF(PCFGMNODE pNode, const char *pszPathFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3)
88	{
89	va_list Args;
90	va_start(Args, pszPathFormat);
91	PCFGMNODE pChild = pNode->pVmmCallbacks->pfnCFGMR3GetChildFV(pNode, pszPathFormat, Args);
92	va_end(Args);
93
94	return pChild;
95	}
96
97
98	/**
99	* @copydoc CFGMR3GetFirstChild
100	*/
101	VMMR3DECL(PCFGMNODE) CFGMR3GetFirstChild(PCFGMNODE pNode)
102	{
103	return pNode->pVmmCallbacks->pfnCFGMR3GetFirstChild(pNode);
104	}
105
106
107	/**
108	* @copydoc CFGMR3GetName
109	*/
110	VMMR3DECL(int) CFGMR3GetName(PCFGMNODE pCur, char *pszName, size_t cchName)
111	{
112	return pCur->pVmmCallbacks->pfnCFGMR3GetName(pCur, pszName, cchName);
113	}
114
115
116	/**
117	* @copydoc CFGMR3GetFirstChild
118	*/
119	VMMR3DECL(PCFGMNODE) CFGMR3GetNextChild(PCFGMNODE pNode)
120	{
121	return pNode->pVmmCallbacks->pfnCFGMR3GetNextChild(pNode);
122	}
123
124
125	/**
126	* @copydoc CFGMR3GetParent
127	*/
128	VMMR3DECL(PCFGMNODE) CFGMR3GetParent(PCFGMNODE pNode)
129	{
130	return pNode->pVmmCallbacks->pfnCFGMR3GetParent(pNode);
131	}
132
133
134	/**
135	* @copydoc CFGMR3GetRoot
136	*/
137	VMMR3DECL(PCFGMNODE) CFGMR3GetRoot(PVM pVM)
138	{
139	return pVM->vm.s.pVmmCallbacks->pfnCFGMR3GetRoot(pVM);
140	}
141
142
143	/**
144	* @copydoc CFGMR3InsertNode
145	*/
146	VMMR3DECL(int) CFGMR3InsertNode(PCFGMNODE pNode, const char pszName, PCFGMNODE ppChild)
147	{
148	return pNode->pVmmCallbacks->pfnCFGMR3InsertNode(pNode, pszName, ppChild);
149	}
150
151
152	/**
153	* @copydoc CFGMR3InsertNodeF
154	*/
155	VMMR3DECL(int) CFGMR3InsertNodeF(PCFGMNODE pNode, PCFGMNODE *ppChild,
156	const char *pszNameFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4)
157	{
158	va_list Args;
159	va_start(Args, pszNameFormat);
160	int rc = pNode->pVmmCallbacks->pfnCFGMR3InsertNodeFV(pNode, ppChild, pszNameFormat, Args);
161	va_end(Args);
162
163	return rc;
164	}
165
166
167	/**
168	* @copydoc CFGMR3InsertString
169	*/
170	VMMR3DECL(int) CFGMR3InsertString(PCFGMNODE pNode, const char pszName, const char pszString)
171	{
172	return pNode->pVmmCallbacks->pfnCFGMR3InsertString(pNode, pszName, pszString);
173	}
174
175
176	/**
177	* @copydoc CFGMR3QueryBool
178	*/
179	VMMR3DECL(int) CFGMR3QueryBool(PCFGMNODE pNode, const char pszName, bool pf)
180	{
181	uint64_t u64;
182	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
183	if (RT_SUCCESS(rc))
184	*pf = u64 ? true : false;
185	return rc;
186	}
187
188
189	/**
190	* @copydoc CFGMR3QueryBoolDef
191	*/
192	VMMR3DECL(int) CFGMR3QueryBoolDef(PCFGMNODE pNode, const char pszName, bool pf, bool fDef)
193	{
194	uint64_t u64;
195	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, fDef);
196	*pf = u64 ? true : false;
197	return rc;
198	}
199
200
201	/**
202	* @copydoc CFGMR3QueryBytes
203	*/
204	VMMR3DECL(int) CFGMR3QueryBytes(PCFGMNODE pNode, const char pszName, void pvData, size_t cbData)
205	{
206	return pNode->pVmmCallbacks->pfnCFGMR3QueryBytes(pNode, pszName, pvData, cbData);
207	}
208
209
210	/**
211	* @copydoc CFGMR3QueryInteger
212	*/
213	VMMR3DECL(int) CFGMR3QueryInteger(PCFGMNODE pNode, const char pszName, uint64_t pu64)
214	{
215	return pNode->pVmmCallbacks->pfnCFGMR3QueryInteger(pNode, pszName, pu64);
216	}
217
218
219	/**
220	* @copydoc CFGMR3QueryIntegerDef
221	*/
222	VMMR3DECL(int) CFGMR3QueryIntegerDef(PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def)
223	{
224	int rc = CFGMR3QueryInteger(pNode, pszName, pu64);
225	if (RT_FAILURE(rc))
226	{
227	*pu64 = u64Def;
228	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
229	rc = VINF_SUCCESS;
230	}
231
232	return rc;
233	}
234
235
236	/**
237	* @copydoc CFGMR3QueryPortDef
238	*/
239	VMMR3DECL(int) CFGMR3QueryPortDef(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef)
240	{
241	AssertCompileSize(RTIOPORT, 2);
242	return CFGMR3QueryU16Def(pNode, pszName, pPort, PortDef);
243	}
244
245
246	/**
247	* @copydoc CFGMR3QueryPtr
248	*/
249	VMMR3DECL(int) CFGMR3QueryPtr(PCFGMNODE pNode, const char pszName, void *ppv)
250	{
251	uint64_t u64;
252	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
253	if (RT_SUCCESS(rc))
254	{
255	uintptr_t u = (uintptr_t)u64;
256	if (u64 == u)
257	ppv = (void )u;
258	else
259	rc = VERR_CFGM_INTEGER_TOO_BIG;
260	}
261	return rc;
262	}
263
264
265	/**
266	* @copydoc CFGMR3QueryS32
267	*/
268	VMMR3DECL(int) CFGMR3QueryS32(PCFGMNODE pNode, const char pszName, int32_t pi32)
269	{
270	uint64_t u64;
271	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
272	if (RT_SUCCESS(rc))
273	{
274	if ( !(u64 & UINT64_C(0xffffffff80000000))
275	\|\| (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
276	*pi32 = (int32_t)u64;
277	else
278	rc = VERR_CFGM_INTEGER_TOO_BIG;
279	}
280	return rc;
281	}
282
283
284	/**
285	* @copydoc CFGMR3QueryS32Def
286	*/
287	VMMR3DECL(int) CFGMR3QueryS32Def(PCFGMNODE pNode, const char pszName, int32_t pi32, int32_t i32Def)
288	{
289	uint64_t u64;
290	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, i32Def);
291	if (RT_SUCCESS(rc))
292	{
293	if ( !(u64 & UINT64_C(0xffffffff80000000))
294	\|\| (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
295	*pi32 = (int32_t)u64;
296	else
297	rc = VERR_CFGM_INTEGER_TOO_BIG;
298	}
299	if (RT_FAILURE(rc))
300	*pi32 = i32Def;
301	return rc;
302	}
303
304
305	/**
306	* @copydoc CFGMR3QuerySIntDef
307	*/
308	VMMR3DECL(int) CFGMR3QuerySIntDef(PCFGMNODE pNode, const char pszName, signed int pi, signed int iDef)
309	{
310	AssertCompileSize(signed int, 4);
311	return CFGMR3QueryS32Def(pNode, pszName, (int32_t *)pi, iDef);
312	}
313
314
315	/**
316	* @copydoc CFGMR3QuerySize
317	*/
318	VMMDECL(int) CFGMR3QuerySize(PCFGMNODE pNode, const char pszName, size_t pcb)
319	{
320	return pNode->pVmmCallbacks->pfnCFGMR3QuerySize(pNode, pszName, pcb);
321	}
322
323
324	/**
325	* @copydoc CFGMR3QueryString
326	*/
327	VMMR3DECL(int) CFGMR3QueryString(PCFGMNODE pNode, const char pszName, char pszString, size_t cchString)
328	{
329	return pNode->pVmmCallbacks->pfnCFGMR3QueryString(pNode, pszName, pszString, cchString);
330	}
331
332
333	/**
334	* @copydoc CFGMR3QueryStringDef
335	*/
336	VMMR3DECL(int) CFGMR3QueryStringDef(PCFGMNODE pNode, const char pszName, char pszString, size_t cchString, const char *pszDef)
337	{
338	int rc = CFGMR3QueryString(pNode, pszName, pszString, cchString);
339	if (RT_FAILURE(rc) && rc != VERR_CFGM_NOT_ENOUGH_SPACE)
340	{
341	size_t cchDef = strlen(pszDef);
342	if (cchString > cchDef)
343	{
344	memcpy(pszString, pszDef, cchDef);
345	memset(pszString + cchDef, 0, cchString - cchDef);
346	if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
347	rc = VINF_SUCCESS;
348	}
349	else if (rc == VERR_CFGM_VALUE_NOT_FOUND \|\| rc == VERR_CFGM_NO_PARENT)
350	rc = VERR_CFGM_NOT_ENOUGH_SPACE;
351	}
352
353	return rc;
354	}
355
356
357	/**
358	* @copydoc CFGMR3QueryStringAlloc
359	*/
360	VMMR3DECL(int) CFGMR3QueryStringAlloc(PCFGMNODE pNode, const char pszName, char *ppszString)
361	{
362	#if 0
363	size_t cbString;
364	int rc = CFGMR3QuerySize(pNode, pszName, &cbString);
365	if (RT_SUCCESS(rc))
366	{
367	char *pszString = cfgmR3StrAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
368	if (pszString)
369	{
370	rc = CFGMR3QueryString(pNode, pszName, pszString, cbString);
371	if (RT_SUCCESS(rc))
372	*ppszString = pszString;
373	else
374	cfgmR3StrFree(pNode->pVM, pszString);
375	}
376	else
377	rc = VERR_NO_MEMORY;
378	}
379	return rc;
380	#endif
381	RT_NOREF(pNode, pszName, ppszString);
382	AssertFailed();
383	return VERR_NOT_IMPLEMENTED;
384	}
385
386
387	/**
388	* @copydoc CFGMR3QueryStringAllocDef
389	*/
390	VMMR3DECL(int) CFGMR3QueryStringAllocDef(PCFGMNODE pNode, const char pszName, char ppszString, const char pszDef)
391	{
392	RT_NOREF(pNode, pszName, ppszString, pszDef);
393	AssertFailed();
394	return VERR_NOT_IMPLEMENTED;
395	}
396
397
398	/**
399	* @copydoc CFGMR3QueryU16
400	*/
401	VMMR3DECL(int) CFGMR3QueryU16(PCFGMNODE pNode, const char pszName, uint16_t pu16)
402	{
403	uint64_t u64;
404	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
405	if (RT_SUCCESS(rc))
406	{
407	if (!(u64 & UINT64_C(0xffffffffffff0000)))
408	*pu16 = (int16_t)u64;
409	else
410	rc = VERR_CFGM_INTEGER_TOO_BIG;
411	}
412	return rc;
413	}
414
415
416	/**
417	* @copydoc CFGMR3QueryU16Def
418	*/
419	VMMR3DECL(int) CFGMR3QueryU16Def(PCFGMNODE pNode, const char pszName, uint16_t pu16, uint16_t u16Def)
420	{
421	uint64_t u64;
422	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u16Def);
423	if (RT_SUCCESS(rc))
424	{
425	if (!(u64 & UINT64_C(0xffffffffffff0000)))
426	*pu16 = (int16_t)u64;
427	else
428	rc = VERR_CFGM_INTEGER_TOO_BIG;
429	}
430	if (RT_FAILURE(rc))
431	*pu16 = u16Def;
432	return rc;
433	}
434
435
436	/**
437	* @copydoc CFGMR3QueryU32
438	*/
439	VMMR3DECL(int) CFGMR3QueryU32(PCFGMNODE pNode, const char pszName, uint32_t pu32)
440	{
441	uint64_t u64;
442	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
443	if (RT_SUCCESS(rc))
444	{
445	if (!(u64 & UINT64_C(0xffffffff00000000)))
446	*pu32 = (uint32_t)u64;
447	else
448	rc = VERR_CFGM_INTEGER_TOO_BIG;
449	}
450	return rc;
451	}
452
453
454	/**
455	* @copydoc CFGMR3QueryU32Def
456	*/
457	VMMR3DECL(int) CFGMR3QueryU32Def(PCFGMNODE pNode, const char pszName, uint32_t pu32, uint32_t u32Def)
458	{
459	uint64_t u64;
460	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u32Def);
461	if (RT_SUCCESS(rc))
462	{
463	if (!(u64 & UINT64_C(0xffffffff00000000)))
464	*pu32 = (uint32_t)u64;
465	else
466	rc = VERR_CFGM_INTEGER_TOO_BIG;
467	}
468	if (RT_FAILURE(rc))
469	*pu32 = u32Def;
470	return rc;
471	}
472
473
474	/**
475	* @copydoc CFGMR3QueryU64
476	*/
477	VMMR3DECL(int) CFGMR3QueryU64(PCFGMNODE pNode, const char pszName, uint64_t pu64)
478	{
479	return CFGMR3QueryInteger(pNode, pszName, pu64);
480	}
481
482
483	/**
484	* @copydoc CFGMR3QueryU64Def
485	*/
486	VMMR3DECL(int) CFGMR3QueryU64Def(PCFGMNODE pNode, const char pszName, uint64_t pu64, uint64_t u64Def)
487	{
488	return CFGMR3QueryIntegerDef(pNode, pszName, pu64, u64Def);
489	}
490
491
492	/**
493	* @copydoc CFGMR3QueryU8
494	*/
495	VMMR3DECL(int) CFGMR3QueryU8(PCFGMNODE pNode, const char pszName, uint8_t pu8)
496	{
497	uint64_t u64;
498	int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
499	if (RT_SUCCESS(rc))
500	{
501	if (!(u64 & UINT64_C(0xffffffffffffff00)))
502	*pu8 = (uint8_t)u64;
503	else
504	rc = VERR_CFGM_INTEGER_TOO_BIG;
505	}
506	return rc;
507	}
508
509
510	/**
511	* @copydoc CFGMR3QueryU8Def
512	*/
513	VMMR3DECL(int) CFGMR3QueryU8Def(PCFGMNODE pNode, const char pszName, uint8_t pu8, uint8_t u8Def)
514	{
515	uint64_t u64;
516	int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, u8Def);
517	if (RT_SUCCESS(rc))
518	{
519	if (!(u64 & UINT64_C(0xffffffffffffff00)))
520	*pu8 = (uint8_t)u64;
521	else
522	rc = VERR_CFGM_INTEGER_TOO_BIG;
523	}
524	if (RT_FAILURE(rc))
525	*pu8 = u8Def;
526	return rc;
527	}
528
529
530	/**
531	* @copydoc CFGMR3RemoveNode
532	*/
533	VMMR3DECL(void) CFGMR3RemoveNode(PCFGMNODE pNode)
534	{
535	pNode->pVmmCallbacks->pfnCFGMR3RemoveNode(pNode);
536	}
537
538
539	/**
540	* @copydoc CFGMR3ValidateConfig
541	*/
542	VMMR3DECL(int) CFGMR3ValidateConfig(PCFGMNODE pNode, const char *pszNode,
543	const char pszValidValues, const char pszValidNodes,
544	const char *pszWho, uint32_t uInstance)
545	{
546	return pNode->pVmmCallbacks->pfnCFGMR3ValidateConfig(pNode, pszNode, pszValidValues, pszValidNodes, pszWho, uInstance);
547	}
548
549
550	/**
551	* @copydoc IOMIOPortWrite
552	*/
553	VMMDECL(VBOXSTRICTRC) IOMIOPortWrite(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
554	{
555	return pVM->vm.s.pVmmCallbacks->pfnIOMIOPortWrite(pVM, pVCpu, Port, u32Value, cbValue);
556	}
557
558
559	/**
560	* @copydoc IOMMMIOMapMMIO2Page
561	*/
562	VMMDECL(int) IOMMMIOMapMMIO2Page(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysRemapped, uint64_t fPageFlags)
563	{
564	return pVM->vm.s.pVmmCallbacks->pfnIOMMMIOMapMMIO2Page(pVM, GCPhys, GCPhysRemapped, fPageFlags);
565	}
566
567
568	/**
569	* @copydoc IOMMMIOResetRegion
570	*/
571	VMMDECL(int) IOMMMIOResetRegion(PVM pVM, RTGCPHYS GCPhys)
572	{
573	return pVM->vm.s.pVmmCallbacks->pfnIOMMMIOResetRegion(pVM, GCPhys);
574	}
575
576
577	/**
578	* @copydoc MMHyperAlloc
579	*/
580	VMMDECL(int) MMHyperAlloc(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv)
581	{
582	return pVM->vm.s.pVmmCallbacks->pfnMMHyperAlloc(pVM, cb, uAlignment, enmTag, ppv);
583	}
584
585
586	/**
587	* @copydoc MMHyperFree
588	*/
589	VMMDECL(int) MMHyperFree(PVM pVM, void *pv)
590	{
591	return pVM->vm.s.pVmmCallbacks->pfnMMHyperFree(pVM, pv);
592	}
593
594
595	/**
596	* @copydoc MMHyperR3ToR0
597	*/
598	VMMDECL(RTR0PTR) MMHyperR3ToR0(PVM pVM, RTR3PTR R3Ptr)
599	{
600	return pVM->vm.s.pVmmCallbacks->pfnMMHyperR3ToR0(pVM, R3Ptr);
601	}
602
603
604	/**
605	* @copydoc MMHyperR3ToRC
606	*/
607	VMMDECL(RTRCPTR) MMHyperR3ToRC(PVM pVM, RTR3PTR R3Ptr)
608	{
609	return pVM->vm.s.pVmmCallbacks->pfnMMHyperR3ToRC(pVM, R3Ptr);
610	}
611
612
613	/**
614	* @copydoc MMR3HeapFree
615	*/
616	VMMR3DECL(void) MMR3HeapFree(void *pv)
617	{
618	PTSTDEVMMHEAPALLOC pHeapAlloc = (PTSTDEVMMHEAPALLOC)((uint8_t *)pv - RT_UOFFSETOF(TSTDEVMMHEAPALLOC, abAlloc[0]));
619	pHeapAlloc->pVmmCallbacks->pfnMMR3HeapFree(pv);
620	}
621
622
623	/**
624	* @copydoc MMR3HyperAllocOnceNoRel
625	*/
626	VMMR3DECL(int) MMR3HyperAllocOnceNoRel(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv)
627	{
628	return pVM->vm.s.pVmmCallbacks->pfnMMR3HyperAllocOnceNoRel(pVM, cb, uAlignment, enmTag, ppv);
629	}
630
631
632	/**
633	* @copydoc MMR3PhysGetRamSize
634	*/
635	VMMR3DECL(uint64_t) MMR3PhysGetRamSize(PVM pVM)
636	{
637	return pVM->vm.s.pVmmCallbacks->pfnMMR3PhysGetRamSize(pVM);
638	}
639
640
641	/**
642	* @copydoc MMR3PhysGetRamSizeBelow4GB
643	*/
644	VMMR3DECL(uint32_t) MMR3PhysGetRamSizeBelow4GB(PVM pVM)
645	{
646	return pVM->vm.s.pVmmCallbacks->pfnMMR3PhysGetRamSizeBelow4GB(pVM);
647	}
648
649
650	/**
651	* @copydoc MMR3PhysGetRamSizeAbove4GB
652	*/
653	VMMR3DECL(uint64_t) MMR3PhysGetRamSizeAbove4GB(PVM pVM)
654	{
655	return pVM->vm.s.pVmmCallbacks->pfnMMR3PhysGetRamSizeAbove4GB(pVM);
656	}
657
658
659	/**
660	* @copydoc PDMCritSectEnterDebug
661	*/
662	VMMDECL(int) PDMCritSectEnterDebug(PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
663	{
664	return pCritSect->s.pVmmCallbacks->pfnPDMCritSectEnterDebug(pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
665	}
666
667
668	/**
669	* @copydoc PDMCritSectIsInitialized
670	*/
671	VMMDECL(bool) PDMCritSectIsInitialized(PCPDMCRITSECT pCritSect)
672	{
673	return pCritSect->s.pVmmCallbacks->pfnPDMCritSectIsInitialized(pCritSect);
674	}
675
676
677	/**
678	* @copydoc PDMCritSectIsOwner
679	*/
680	VMMDECL(bool) PDMCritSectIsOwner(PCPDMCRITSECT pCritSect)
681	{
682	return pCritSect->s.pVmmCallbacks->pfnPDMCritSectIsOwner(pCritSect);
683	}
684
685
686	/**
687	* @copydoc PDMCritSectLeave
688	*/
689	VMMDECL(int) PDMCritSectLeave(PPDMCRITSECT pCritSect)
690	{
691	return pCritSect->s.pVmmCallbacks->pfnPDMCritSectLeave(pCritSect);
692	}
693
694
695	/**
696	* @copydoc PDMCritSectTryEnterDebug
697	*/
698	VMMDECL(int) PDMCritSectTryEnterDebug(PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
699	{
700	return pCritSect->s.pVmmCallbacks->pfnPDMCritSectTryEnterDebug(pCritSect, uId, RT_SRC_POS_ARGS);
701	}
702
703
704	/**
705	* @copydoc PDMHCCritSectScheduleExitEvent
706	*/
707	VMMDECL(int) PDMHCCritSectScheduleExitEvent(PPDMCRITSECT pCritSect, SUPSEMEVENT hEventToSignal)
708	{
709	return pCritSect->s.pVmmCallbacks->pfnPDMHCCritSectScheduleExitEvent(pCritSect, hEventToSignal);
710	}
711
712
713	/**
714	* @copydoc PDMNsAllocateBandwidth
715	*/
716	VMMDECL(bool) PDMNsAllocateBandwidth(PPDMNSFILTER pFilter, size_t cbTransfer)
717	{
718	#if 0
719	return pFilter->pVmmCallbacks->pfnPDMNsAllocateBandwidth(pFilter, cbTransfer);
720	#endif
721	RT_NOREF(pFilter, cbTransfer);
722	AssertFailed();
723	return false;
724	}
725
726
727	/**
728	* @copydoc PDMQueueAlloc
729	*/
730	VMMDECL(PPDMQUEUEITEMCORE) PDMQueueAlloc(PPDMQUEUE pQueue)
731	{
732	return pQueue->pVmmCallbacks->pfnPDMQueueAlloc(pQueue);
733	}
734
735
736	/**
737	* @copydoc PDMQueueFlushIfNecessary
738	*/
739	VMMDECL(bool) PDMQueueFlushIfNecessary(PPDMQUEUE pQueue)
740	{
741	return pQueue->pVmmCallbacks->pfnPDMQueueFlushIfNecessary(pQueue);
742	}
743
744
745	/**
746	* @copydoc PDMQueueInsert
747	*/
748	VMMDECL(void) PDMQueueInsert(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem)
749	{
750	pQueue->pVmmCallbacks->pfnPDMQueueInsert(pQueue, pItem);
751	}
752
753
754	/**
755	* @copydoc PDMQueueR0Ptr
756	*/
757	VMMDECL(R0PTRTYPE(PPDMQUEUE)) PDMQueueR0Ptr(PPDMQUEUE pQueue)
758	{
759	return pQueue->pVmmCallbacks->pfnPDMQueueR0Ptr(pQueue);
760	}
761
762
763	/**
764	* @copydoc PDMQueueRCPtr
765	*/
766	VMMDECL(RCPTRTYPE(PPDMQUEUE)) PDMQueueRCPtr(PPDMQUEUE pQueue)
767	{
768	return pQueue->pVmmCallbacks->pfnPDMQueueRCPtr(pQueue);
769	}
770
771
772	/**
773	* @copydoc PGMHandlerPhysicalPageTempOff
774	*/
775	VMMDECL(int) PGMHandlerPhysicalPageTempOff(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
776	{
777	RT_NOREF(pVM, GCPhys, GCPhysPage);
778	AssertFailed();
779	return VERR_NOT_IMPLEMENTED;
780	}
781
782
783	/**
784	* @copydoc PGMShwMakePageWritable
785	*/
786	VMMDECL(int) PGMShwMakePageWritable(PVMCPU pVCpu, RTGCPTR GCPtr, uint32_t fFlags)
787	{
788	RT_NOREF(pVCpu, GCPtr, fFlags);
789	AssertFailed();
790	return VERR_NOT_IMPLEMENTED;
791	}
792
793	/** @todo PDMR3AsyncCompletion + BlkCache + CritSect + QueryLun + Thread. */
794
795	/**
796	* @copydoc TMCpuTicksPerSecond
797	*/
798	VMMDECL(uint64_t) TMCpuTicksPerSecond(PVM pVM)
799	{
800	return pVM->vm.s.pVmmCallbacks->pfnTMCpuTicksPerSecond(pVM);
801	}
802
803
804	/**
805	* @copydoc TMR3TimerDestroy
806	*/
807	VMMR3DECL(int) TMR3TimerDestroy(PTMTIMER pTimer)
808	{
809	return pTimer->pVmmCallbacks->pfnTMR3TimerDestroy(pTimer);
810	}
811
812
813	/**
814	* @copydoc TMR3TimerSave
815	*/
816	VMMR3DECL(int) TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
817	{
818	return pTimer->pVmmCallbacks->pfnTMR3TimerSave(pTimer, pSSM);
819	}
820
821
822	/**
823	* @copydoc TMR3TimerLoad
824	*/
825	VMMR3DECL(int) TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
826	{
827	return pTimer->pVmmCallbacks->pfnTMR3TimerLoad(pTimer, pSSM);
828	}
829
830
831	/**
832	* @copydoc TMR3TimerSetCritSect
833	*/
834	VMMR3DECL(int) TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect)
835	{
836	return pTimer->pVmmCallbacks->pfnTMR3TimerSetCritSect(pTimer, pCritSect);
837	}
838
839
840	/**
841	* @copydoc TMTimerFromMilli
842	*/
843	VMMDECL(uint64_t) TMTimerFromMilli(PTMTIMER pTimer, uint64_t cMilliSecs)
844	{
845	return pTimer->pVmmCallbacks->pfnTMTimerFromMilli(pTimer, cMilliSecs);
846	}
847
848
849	/**
850	* @copydoc TMTimerFromNano
851	*/
852	VMMDECL(uint64_t) TMTimerFromNano(PTMTIMER pTimer, uint64_t cNanoSecs)
853	{
854	return pTimer->pVmmCallbacks->pfnTMTimerFromNano(pTimer, cNanoSecs);
855	}
856
857
858	/**
859	* @copydoc TMTimerGet
860	*/
861	VMMDECL(uint64_t) TMTimerGet(PTMTIMER pTimer)
862	{
863	return pTimer->pVmmCallbacks->pfnTMTimerGet(pTimer);
864	}
865
866
867	/**
868	* @copydoc TMTimerGetFreq
869	*/
870	VMMDECL(uint64_t) TMTimerGetFreq(PTMTIMER pTimer)
871	{
872	return pTimer->pVmmCallbacks->pfnTMTimerGetFreq(pTimer);
873	}
874
875
876	/**
877	* @copydoc TMTimerGetNano
878	*/
879	VMMDECL(uint64_t) TMTimerGetNano(PTMTIMER pTimer)
880	{
881	return pTimer->pVmmCallbacks->pfnTMTimerGetNano(pTimer);
882	}
883
884
885	/**
886	* @copydoc TMTimerIsActive
887	*/
888	VMMDECL(bool) TMTimerIsActive(PTMTIMER pTimer)
889	{
890	return pTimer->pVmmCallbacks->pfnTMTimerIsActive(pTimer);
891	}
892
893
894	/**
895	* @copydoc TMTimerIsLockOwner
896	*/
897	VMMDECL(bool) TMTimerIsLockOwner(PTMTIMER pTimer)
898	{
899	return pTimer->pVmmCallbacks->pfnTMTimerIsLockOwner(pTimer);
900	}
901
902
903	/**
904	* @copydoc TMTimerLock
905	*/
906	VMMDECL(int) TMTimerLock(PTMTIMER pTimer, int rcBusy)
907	{
908	return pTimer->pVmmCallbacks->pfnTMTimerLock(pTimer, rcBusy);
909	}
910
911
912	/**
913	* @copydoc TMTimerR0Ptr
914	*/
915	VMMDECL(PTMTIMERR0) TMTimerR0Ptr(PTMTIMER pTimer)
916	{
917	return pTimer->pVmmCallbacks->pfnTMTimerR0Ptr(pTimer);
918	}
919
920
921	/**
922	* @copydoc TMTimerRCPtr
923	*/
924	VMMDECL(PTMTIMERRC) TMTimerRCPtr(PTMTIMER pTimer)
925	{
926	return pTimer->pVmmCallbacks->pfnTMTimerRCPtr(pTimer);
927	}
928
929
930	/**
931	* @copydoc TMTimerSet
932	*/
933	VMMDECL(int) TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire)
934	{
935	return pTimer->pVmmCallbacks->pfnTMTimerSet(pTimer, u64Expire);
936	}
937
938
939	/**
940	* @copydoc TMTimerSetFrequencyHint
941	*/
942	VMMDECL(int) TMTimerSetFrequencyHint(PTMTIMER pTimer, uint32_t uHz)
943	{
944	return pTimer->pVmmCallbacks->pfnTMTimerSetFrequencyHint(pTimer, uHz);
945	}
946
947
948	/**
949	* @copydoc TMTimerSetMicro
950	*/
951	VMMDECL(int) TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext)
952	{
953	return pTimer->pVmmCallbacks->pfnTMTimerSetMicro(pTimer, cMicrosToNext);
954	}
955
956
957	/**
958	* @copydoc TMTimerSetMillies
959	*/
960	VMMDECL(int) TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext)
961	{
962	return pTimer->pVmmCallbacks->pfnTMTimerSetMillies(pTimer, cMilliesToNext);
963	}
964
965
966	/**
967	* @copydoc TMTimerSetNano
968	*/
969	VMMDECL(int) TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext)
970	{
971	return pTimer->pVmmCallbacks->pfnTMTimerSetNano(pTimer, cNanosToNext);
972	}
973
974
975	/**
976	* @copydoc TMTimerStop
977	*/
978	VMMDECL(int) TMTimerStop(PTMTIMER pTimer)
979	{
980	return pTimer->pVmmCallbacks->pfnTMTimerStop(pTimer);
981	}
982
983
984	/**
985	* @copydoc TMTimerUnlock
986	*/
987	VMMDECL(void) TMTimerUnlock(PTMTIMER pTimer)
988	{
989	return pTimer->pVmmCallbacks->pfnTMTimerUnlock(pTimer);
990	}
991

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

source: vbox/trunk/src/VBox/Devices/testcase/tstDeviceVMMStubs.cpp@ 76520

Download in other formats: