VMAll.cpp@ 91247

Last change on this file since 91247 was 90997, checked in by vboxsync, 3 years ago
VMM,PDM,PGM: Restrict the VMSetError and VMSetRuntimeError APIs to ring-3, these never worked properly in ring-0 or raw-mode. A PAEmode runtime error was the only place any of these were used, but given that the VMSetRuntimeError codepath starts with an assertion, it can't have been used/tested. The PAEmode runtime error shouldn't necessarily be triggered by PGM anyway, but IEM. Removed VMMCALLRING3_VM_SET_ERROR and VMMCALLRING3_VM_SET_RUNTIME_ERROR. bugref:10093
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 13.5 KB

Line
1	/* $Id: VMAll.cpp 90997 2021-08-30 14:04:48Z vboxsync $ */
2	/** @file
3	* VM - Virtual Machine All Contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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_VM
23	#include "VMInternal.h"
24	#include <VBox/vmm/vmm.h>
25	#include <VBox/vmm/mm.h>
26	#include <VBox/vmm/vmcc.h>
27	#include <VBox/err.h>
28	#include <VBox/log.h>
29
30	#include <iprt/assert.h>
31	#include <iprt/string.h>
32	#include <iprt/thread.h>
33
34
35	#ifdef IN_RING3
36
37	/**
38	* Sets the error message.
39	*
40	* @returns rc. Meaning you can do:
41	* @code
42	* return VM_SET_ERROR(pVM, VERR_OF_YOUR_CHOICE, "descriptive message");
43	* @endcode
44	* @param pVM The cross context VM structure.
45	* @param rc VBox status code.
46	* @param SRC_POS Use RT_SRC_POS.
47	* @param pszFormat Error message format string.
48	* @param ... Error message arguments.
49	* @thread Any
50	*/
51	VMMDECL(int) VMSetError(PVMCC pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
52	{
53	va_list args;
54	va_start(args, pszFormat);
55	int rc2 = VMSetErrorV(pVM, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc == rc2); NOREF(rc2);
56	va_end(args);
57	return rc;
58	}
59
60
61	/**
62	* Sets the error message.
63	*
64	* @returns rc. Meaning you can do:
65	* @code
66	* return VM_SET_ERROR(pVM, VERR_OF_YOUR_CHOICE, "descriptive message");
67	* @endcode
68	* @param pVM The cross context VM structure.
69	* @param rc VBox status code.
70	* @param SRC_POS Use RT_SRC_POS.
71	* @param pszFormat Error message format string.
72	* @param args Error message arguments.
73	* @thread Any
74	*/
75	VMMDECL(int) VMSetErrorV(PVMCC pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args)
76	{
77	# ifdef IN_RING3
78	/*
79	* Switch to EMT.
80	*/
81	va_list va2;
82	va_copy(va2, args); /* Have to make a copy here or GCC will break. */
83	VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)vmR3SetErrorUV, 7, /* ASSUMES 3 source pos args! */
84	pVM->pUVM, rc, RT_SRC_POS_ARGS, pszFormat, &va2);
85	va_end(va2);
86
87	# else
88	/*
89	* We're already on the EMT thread and can safely create a VMERROR chunk.
90	*/
91	vmSetErrorCopy(pVM, rc, RT_SRC_POS_ARGS, pszFormat, args);
92	VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VM_SET_ERROR, 0);
93	# endif
94	return rc;
95	}
96
97
98	/**
99	* Copies the error to a VMERROR structure.
100	*
101	* This is mainly intended for Ring-0 and GC where the error must be copied to
102	* memory accessible from ring-3. But it's just possible that we might add
103	* APIs for retrieving the VMERROR copy later.
104	*
105	* @param pVM The cross context VM structure.
106	* @param rc VBox status code.
107	* @param SRC_POS Use RT_SRC_POS.
108	* @param pszFormat Error message format string.
109	* @param args Error message arguments.
110	* @thread EMT
111	*/
112	void vmSetErrorCopy(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args)
113	{
114	NOREF(pVM); NOREF(rc); RT_SRC_POS_NOREF(); NOREF(pszFormat); NOREF(args);
115	# if 0 /// @todo implement Ring-0 and GC VMSetError
116	/*
117	* Create the untranslated message copy.
118	*/
119	/* free any old message. */
120	MMHyperFree(pVM, MMHyperR32Ctx(pVM, pVM->vm.s.pError));
121	pVM->vm.s.pError = NULL;
122
123	/* calc reasonable start size. */
124	size_t cchFile = pszFile ? strlen(pszFile) : 0;
125	size_t cchFunction = pszFunction ? strlen(pszFunction) : 0;
126	size_t cchFormat = strlen(pszFormat);
127	size_t cb = sizeof(VMERROR)
128	+ cchFile + 1
129	+ cchFunction + 1
130	+ cchFormat + 32;
131
132	/* allocate it */
133	void *pv;
134	int rc2 = MMHyperAlloc(pVM, cb, 0, MM_TAG_VM, &pv);
135	if (RT_SUCCESS(rc2))
136	{
137	/* initialize it. */
138	PVMERROR pErr = (PVMERROR)pv;
139	pErr->cbAllocated = cb;
140	pErr->iLine = iLine;
141	pErr->off = sizeof(VMERROR);
142	pErr->offFile = pErr->offFunction = 0;
143
144	if (cchFile)
145	{
146	pErr->offFile = pErr->off;
147	memcpy((uint8_t *)pErr + pErr->off, pszFile, cchFile + 1);
148	pErr->off += cchFile + 1;
149	}
150
151	if (cchFunction)
152	{
153	pErr->offFunction = pErr->off;
154	memcpy((uint8_t *)pErr + pErr->off, pszFunction, cchFunction + 1);
155	pErr->off += cchFunction + 1;
156	}
157
158	pErr->offMessage = pErr->off;
159
160	/* format the message (pErr might be reallocated) */
161	VMSETERRORFMTARGS Args;
162	Args.pVM = pVM;
163	Args.pErr = pErr;
164
165	va_list va2;
166	va_copy(va2, args);
167	RTStrFormatV(vmSetErrorFmtOut, &pErr, NULL, NULL, &pszFormatTmp, args);
168	va_end(va2);
169
170	/* done. */
171	pVM->vm.s.pErrorR3 = MMHyper2HC(pVM, (uintptr_t)pArgs.pErr);
172	}
173	# endif
174	}
175
176	#endif /* IN_RING3 */
177	#ifdef IN_RING3
178
179	/**
180	* Sets the runtime error message.
181	*
182	* As opposed VMSetError(), this method is intended to inform the VM user about
183	* errors and error-like conditions that happen at an arbitrary point during VM
184	* execution (like "host memory low" or "out of host disk space").
185	*
186	* @returns VBox status code. For some flags the status code <b>must</b> be
187	* propagated up the stack.
188	*
189	* @param pVM The cross context VM structure.
190	*
191	* @param fFlags Flags indicating which actions to take.
192	* See VMSETRTERR_FLAGS_* for details on each flag.
193	*
194	* @param pszErrorId Unique error identification string. This is used by
195	* the frontends and maybe other devices or drivers, so
196	* once an ID has been selected it's essentially
197	* unchangable. Employ camelcase when constructing the
198	* string, leave out spaces.
199	*
200	* The registered runtime error callbacks should string
201	* switch on this and handle the ones it knows
202	* specifically and the unknown ones generically.
203	*
204	* @param pszFormat Error message format string.
205	* @param ... Error message arguments.
206	*
207	* @thread Any
208	*/
209	VMMDECL(int) VMSetRuntimeError(PVMCC pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
210	{
211	va_list va;
212	va_start(va, pszFormat);
213	int rc = VMSetRuntimeErrorV(pVM, fFlags, pszErrorId, pszFormat, va);
214	va_end(va);
215	return rc;
216	}
217
218
219	/**
220	* va_list version of VMSetRuntimeError.
221	*
222	* @returns VBox status code. For some flags the status code <b>must</b> be
223	* propagated up the stack.
224	*
225	* @param pVM The cross context VM structure.
226	* @param fFlags Flags indicating which actions to take. See
227	* VMSETRTERR_FLAGS_*.
228	* @param pszErrorId Error ID string.
229	* @param pszFormat Error message format string.
230	* @param va Error message arguments.
231	*
232	* @thread Any
233	*/
234	VMMDECL(int) VMSetRuntimeErrorV(PVMCC pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
235	{
236	Log(("VMSetRuntimeErrorV: fFlags=%#x pszErrorId=%s\n", fFlags, pszErrorId));
237
238	/*
239	* Relaxed parameter validation.
240	*/
241	AssertPtr(pVM);
242	AssertMsg(!(fFlags & ~(VMSETRTERR_FLAGS_NO_WAIT \| VMSETRTERR_FLAGS_SUSPEND \| VMSETRTERR_FLAGS_FATAL)), ("%#x\n", fFlags));
243	Assert(!(fFlags & VMSETRTERR_FLAGS_NO_WAIT) \|\| !VM_IS_EMT(pVM));
244	Assert(!(fFlags & VMSETRTERR_FLAGS_SUSPEND) \|\| !(fFlags & VMSETRTERR_FLAGS_FATAL));
245	AssertPtr(pszErrorId);
246	Assert(*pszErrorId);
247	Assert(RTStrEnd(pszErrorId, 128) != NULL);
248	AssertPtr(pszFormat);
249	Assert(RTStrEnd(pszFormat, 512) != NULL);
250
251	# ifdef IN_RING3
252	/*
253	* Switch to EMT.
254	*
255	* If it's a no-wait request, we have to format the message into a buffer
256	* here since the variable arguments list will become invalid once we call
257	* va_end and return.
258	*/
259	int rc;
260	if ( !(fFlags & VMSETRTERR_FLAGS_NO_WAIT)
261	\|\| VM_IS_EMT(pVM))
262	{
263	fFlags &= ~VMSETRTERR_FLAGS_NO_WAIT;
264
265	va_list va2;
266	va_copy(va2, va); /* Have to make a copy here or GCC will break. */
267	rc = VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY,
268	(PFNRT)vmR3SetRuntimeErrorV, 5, pVM, fFlags, pszErrorId, pszFormat, &va2);
269	va_end(va2);
270	}
271	else
272	{
273	char *pszMessage = MMR3HeapAPrintfV(pVM, MM_TAG_VM, pszFormat, va);
274	rc = VMR3ReqCallNoWait(pVM, VMCPUID_ANY,
275	(PFNRT)vmR3SetRuntimeError, 4, pVM, fFlags, pszErrorId, pszMessage);
276	if (RT_FAILURE(rc))
277	MMR3HeapFree(pszMessage);
278	}
279
280	# else
281	/*
282	* We're already on the EMT and can safely create a VMRUNTIMEERROR chunk.
283	*/
284	AssertReleaseMsgFailed(("Congratulations! You will have the pleasure of debugging the RC/R0 path.\n"));
285	vmSetRuntimeErrorCopy(pVM, fFlags, pszErrorId, pszFormat, va);
286
287	int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VM_SET_RUNTIME_ERROR, 0);
288	# endif
289
290	Log(("VMSetRuntimeErrorV: returns %Rrc (pszErrorId=%s)\n", rc, pszErrorId));
291	return rc;
292	}
293
294
295	/**
296	* Copies the error to a VMRUNTIMEERROR structure.
297	*
298	* This is mainly intended for Ring-0 and RC where the error must be copied to
299	* memory accessible from ring-3. But it's just possible that we might add
300	* APIs for retrieving the VMRUNTIMEERROR copy later.
301	*
302	* @param pVM The cross context VM structure.
303	* @param fFlags The error flags.
304	* @param pszErrorId Error ID string.
305	* @param pszFormat Error message format string.
306	* @param va Error message arguments. This is of course spoiled
307	* by this call.
308	* @thread EMT
309	*/
310	void vmSetRuntimeErrorCopy(PVM pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
311	{
312	NOREF(pVM); NOREF(fFlags); NOREF(pszErrorId); NOREF(pszFormat); NOREF(va);
313	# if 0 /// @todo implement Ring-0 and GC VMSetError
314	/*
315	* Create the untranslated message copy.
316	*/
317	/* free any old message. */
318	MMHyperFree(pVM, MMHyperR32Ctx(pVM, pVM->vm.s.pRuntimeErrorR3));
319	pVM->vm.s.pRuntimeErrorR3 = NULL;
320
321	/* calc reasonable start size. */
322	size_t cchErrorID = pszErrorId ? strlen(pszErrorId) : 0;
323	size_t cchFormat = strlen(pszFormat);
324	size_t cb = sizeof(VMRUNTIMEERROR)
325	+ cchErrorID + 1
326	+ cchFormat + 32;
327
328	/* allocate it */
329	void *pv;
330	int rc2 = MMHyperAlloc(pVM, cb, 0, MM_TAG_VM, &pv);
331	if (RT_SUCCESS(rc2))
332	{
333	/* initialize it. */
334	PVMRUNTIMEERROR pErr = (PVMRUNTIMEERROR)pv;
335	pErr->cbAllocated = cb;
336	pErr->fFlags = fFlags;
337	pErr->off = sizeof(PVMRUNTIMEERROR);
338	pErr->offErrorID = 0;
339
340	if (cchErrorID)
341	{
342	pErr->offErrorID = pErr->off;
343	memcpy((uint8_t *)pErr + pErr->off, pszErrorId, cchErrorID + 1);
344	pErr->off += cchErrorID + 1;
345	}
346
347	pErr->offMessage = pErr->off;
348
349	/* format the message (pErr might be reallocated) */
350	VMSETRUNTIMEERRORFMTARGS Args;
351	Args.pVM = pVM;
352	Args.pErr = pErr;
353
354	va_list va2;
355	va_copy(va2, args);
356	RTStrFormatV(vmSetRuntimeErrorFmtOut, &pErr, NULL, NULL, &pszFormatTmp, args);
357	va_end(va2);
358
359	/* done. */
360	pVM->vm.s.pErrorRuntimeR3 = MMHyper2HC(pVM, (uintptr_t)pArgs.pErr);
361	}
362	# endif
363	}
364
365	#endif /* IN_RING3 */
366
367	/**
368	* Gets the name of VM state.
369	*
370	* @returns Pointer to a read-only string with the state name.
371	* @param enmState The state.
372	*/
373	VMMDECL(const char *) VMGetStateName(VMSTATE enmState)
374	{
375	switch (enmState)
376	{
377	#define MY_CASE(enm) case VMSTATE_##enm: return #enm;
378	MY_CASE(CREATING);
379	MY_CASE(CREATED);
380	MY_CASE(RUNNING);
381	MY_CASE(LOADING);
382	MY_CASE(LOAD_FAILURE);
383	MY_CASE(SAVING);
384	MY_CASE(SUSPENDED);
385	MY_CASE(RESETTING);
386	MY_CASE(GURU_MEDITATION);
387	MY_CASE(OFF);
388	MY_CASE(DESTROYING);
389	MY_CASE(TERMINATED);
390	#undef MY_CASE
391	default:
392	return "Unknown";
393	}
394	}
395
396
397	/**
398	* Gets the total reset count.
399	*
400	* @returns Reset count. UINT32_MAX if @a pVM is invalid.
401	* @param pVM The VM handle.
402	*/
403	VMMDECL(uint32_t) VMGetResetCount(PVMCC pVM)
404	{
405	VM_ASSERT_VALID_EXT_RETURN(pVM, UINT32_MAX);
406	return pVM->vm.s.cResets;
407	}
408
409
410	/**
411	* Gets the soft reset count.
412	*
413	* @returns Soft reset count. UINT32_MAX if @a pVM is invalid.
414	* @param pVM The VM handle.
415	*/
416	VMMDECL(uint32_t) VMGetSoftResetCount(PVMCC pVM)
417	{
418	VM_ASSERT_VALID_EXT_RETURN(pVM, UINT32_MAX);
419	return pVM->vm.s.cSoftResets;
420	}
421
422
423	/**
424	* Gets the hard reset count.
425	*
426	* @returns Hard reset count. UINT32_MAX if @a pVM is invalid.
427	* @param pVM The VM handle.
428	*/
429	VMMDECL(uint32_t) VMGetHardResetCount(PVMCC pVM)
430	{
431	VM_ASSERT_VALID_EXT_RETURN(pVM, UINT32_MAX);
432	return pVM->vm.s.cHardResets;
433	}
434

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

source: vbox/trunk/src/VBox/VMM/VMMAll/VMAll.cpp@ 91247

Download in other formats: