VMAll.cpp@ 23012

Last change on this file since 23012 was 23012, checked in by vboxsync, 15 years ago
VMM,Devices,Main: VMR3ReqCall w/ RT_INDEFINITE_WAIT -> VMR3ReqCallWait.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 12.4 KB

Line
1	/* $Id: VMAll.cpp 23012 2009-09-14 16:38:13Z vboxsync $ */
2	/** @file
3	* VM - Virtual Machine All Contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_VM
27	#include "VMInternal.h"
28	#include <VBox/vmm.h>
29	#include <VBox/mm.h>
30	#include <VBox/vm.h>
31	#include <VBox/err.h>
32	#include <VBox/log.h>
33
34	#include <iprt/assert.h>
35	#include <iprt/string.h>
36	#ifndef IN_RC
37	# include <iprt/thread.h>
38	#endif
39
40
41	/**
42	* Sets the error message.
43	*
44	* @returns rc. Meaning you can do:
45	* @code
46	* return VM_SET_ERROR(pVM, VERR_OF_YOUR_CHOICE, "descriptive message");
47	* @endcode
48	* @param pVM VM handle. Must be non-NULL.
49	* @param rc VBox status code.
50	* @param RT_SRC_POS_DECL Use RT_SRC_POS.
51	* @param pszFormat Error message format string.
52	* @param ... Error message arguments.
53	* @thread Any
54	*/
55	VMMDECL(int) VMSetError(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
56	{
57	va_list args;
58	va_start(args, pszFormat);
59	int rc2 = VMSetErrorV(pVM, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc == rc2); NOREF(rc2);
60	va_end(args);
61	return rc;
62	}
63
64
65	/**
66	* Sets the error message.
67	*
68	* @returns rc. Meaning you can do:
69	* @code
70	* return VM_SET_ERROR(pVM, VERR_OF_YOUR_CHOICE, "descriptive message");
71	* @endcode
72	* @param pVM VM handle. Must be non-NULL.
73	* @param rc VBox status code.
74	* @param RT_SRC_POS_DECL Use RT_SRC_POS.
75	* @param pszFormat Error message format string.
76	* @param args Error message arguments.
77	* @thread Any
78	*/
79	VMMDECL(int) VMSetErrorV(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args)
80	{
81	#ifdef IN_RING3
82	/*
83	* Switch to EMT.
84	*/
85	va_list va2;
86	va_copy(va2, args); /* Have to make a copy here or GCC will break. */
87	VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)vmR3SetErrorUV, 7, /* ASSUMES 3 source pos args! */
88	pVM->pUVM, rc, RT_SRC_POS_ARGS, pszFormat, &va2);
89	va_end(va2);
90
91	#else
92	/*
93	* We're already on the EMT thread and can safely create a VMERROR chunk.
94	*/
95	vmSetErrorCopy(pVM, rc, RT_SRC_POS_ARGS, pszFormat, args);
96	VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VM_SET_ERROR, 0);
97	#endif
98	return rc;
99	}
100
101
102	/**
103	* Copies the error to a VMERROR structure.
104	*
105	* This is mainly intended for Ring-0 and GC where the error must be copied to
106	* memory accessible from ring-3. But it's just possible that we might add
107	* APIs for retrieving the VMERROR copy later.
108	*
109	* @param pVM VM handle. Must be non-NULL.
110	* @param rc VBox status code.
111	* @param RT_SRC_POS_DECL Use RT_SRC_POS.
112	* @param pszFormat Error message format string.
113	* @param args Error message arguments.
114	* @thread EMT
115	*/
116	void vmSetErrorCopy(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args)
117	{
118	#if 0 /// @todo implement Ring-0 and GC VMSetError
119	/*
120	* Create the untranslated message copy.
121	*/
122	/* free any old message. */
123	MMHyperFree(pVM, MMHyperR32Ctx(pVM, pVM->vm.s.pError));
124	pVM->vm.s.pError = NULL;
125
126	/* calc reasonable start size. */
127	size_t cchFile = pszFile ? strlen(pszFile) : 0;
128	size_t cchFunction = pszFunction ? strlen(pszFunction) : 0;
129	size_t cchFormat = strlen(pszFormat);
130	size_t cb = sizeof(VMERROR)
131	+ cchFile + 1
132	+ cchFunction + 1
133	+ cchFormat + 32;
134
135	/* allocate it */
136	void *pv;
137	int rc2 = MMHyperAlloc(pVM, cb, 0, MM_TAG_VM, &pv);
138	if (RT_SUCCESS(rc2))
139	{
140	/* initialize it. */
141	PVMERROR pErr = (PVMERROR)pv;
142	pErr->cbAllocated = cb;
143	pErr->iLine = iLine;
144	pErr->off = sizeof(VMERROR);
145	pErr->offFile = pErr->offFunction = 0;
146
147	if (cchFile)
148	{
149	pErr->offFile = pErr->off;
150	memcpy((uint8_t *)pErr + pErr->off, pszFile, cchFile + 1);
151	pErr->off += cchFile + 1;
152	}
153
154	if (cchFunction)
155	{
156	pErr->offFunction = pErr->off;
157	memcpy((uint8_t *)pErr + pErr->off, pszFunction, cchFunction + 1);
158	pErr->off += cchFunction + 1;
159	}
160
161	pErr->offMessage = pErr->off;
162
163	/* format the message (pErr might be reallocated) */
164	VMSETERRORFMTARGS Args;
165	Args.pVM = pVM;
166	Args.pErr = pErr;
167
168	va_list va2;
169	va_copy(va2, args);
170	RTStrFormatV(vmSetErrorFmtOut, &pErr, NULL, NULL, &pszFormatTmp, args);
171	va_end(va2);
172
173	/* done. */
174	pVM->vm.s.pErrorR3 = MMHyper2HC(pVM, (uintptr_t)pArgs.pErr);
175	}
176	#endif
177	}
178
179
180	/**
181	* Sets the runtime error message.
182	*
183	* As opposed VMSetError(), this method is intended to inform the VM user about
184	* errors and error-like conditions that happen at an arbitrary point during VM
185	* execution (like "host memory low" or "out of host disk space").
186	*
187	* @returns VBox status code. For some flags the status code <b>must</b> be
188	* propagated up the stack.
189	*
190	* @param pVM The VM handle.
191	*
192	* @param fFlags Flags indicating which actions to take.
193	* See VMSETRTERR_FLAGS_* for details on each flag.
194	*
195	* @param pszErrorId Unique error identificator string. This is used by
196	* the frontends and maybe other devices or drivers, so
197	* once an ID has been selected it's essentially
198	* unchangable. Employ camelcase when constructing the
199	* string, leave out spaces.
200	*
201	* The registered runtime error callbacks should string
202	* switch on this and handle the ones it knows
203	* specifically and the unknown ones generically.
204	*
205	* @param pszFormat Error message format string.
206	* @param ... Error message arguments.
207	*
208	* @thread Any
209	*/
210	VMMDECL(int) VMSetRuntimeError(PVM pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, ...)
211	{
212	va_list va;
213	va_start(va, pszFormat);
214	int rc = VMSetRuntimeErrorV(pVM, fFlags, pszErrorId, pszFormat, va);
215	va_end(va);
216	return rc;
217	}
218
219
220	/**
221	* va_list version of VMSetRuntimeError.
222	*
223	* @returns VBox status code. For some flags the status code <b>must</b> be
224	* propagated up the stack.
225	*
226	* @param pVM The VM handle.
227	* @param fFlags Flags indicating which actions to take. See
228	* VMSETRTERR_FLAGS_*.
229	* @param pszErrorId Error ID string.
230	* @param pszFormat Error message format string.
231	* @param va Error message arguments.
232	*
233	* @thread Any
234	*/
235	VMMDECL(int) VMSetRuntimeErrorV(PVM pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
236	{
237	Log(("VMSetRuntimeErrorV: fFlags=%#x pszErrorId=%s\n", fFlags, pszErrorId));
238
239	/*
240	* Relaxed parameter validation.
241	*/
242	AssertPtr(pVM);
243	AssertMsg(!(fFlags & ~(VMSETRTERR_FLAGS_NO_WAIT \| VMSETRTERR_FLAGS_SUSPEND \| VMSETRTERR_FLAGS_FATAL)), ("%#x\n", fFlags));
244	Assert(!(fFlags & VMSETRTERR_FLAGS_NO_WAIT) \|\| !VM_IS_EMT(pVM));
245	Assert(!(fFlags & VMSETRTERR_FLAGS_SUSPEND) \|\| !(fFlags & VMSETRTERR_FLAGS_FATAL));
246	AssertPtr(pszErrorId);
247	Assert(*pszErrorId);
248	Assert(memchr(pszErrorId, '\0', 128) != NULL);
249	AssertPtr(pszFormat);
250	Assert(memchr(pszFormat, '\0', 512) != NULL);
251
252	#ifdef IN_RING3
253	/*
254	* Switch to EMT.
255	*
256	* If it's a no-wait request, we have to format the message into a buffer
257	* here since the variable arguments list will become invalid once we call
258	* va_end and return.
259	*/
260	int rc;
261	if ( !(fFlags & VMSETRTERR_FLAGS_NO_WAIT)
262	\|\| VM_IS_EMT(pVM))
263	{
264	fFlags &= ~VMSETRTERR_FLAGS_NO_WAIT;
265
266	va_list va2;
267	va_copy(va2, va); /* Have to make a copy here or GCC will break. */
268	rc = VMR3ReqCallWaitU(pVM->pUVM, VMCPUID_ANY,
269	(PFNRT)vmR3SetRuntimeErrorV, 5, pVM, fFlags, pszErrorId, pszFormat, &va2);
270	va_end(va2);
271	}
272	else
273	{
274	char *pszMessage = MMR3HeapAPrintfV(pVM, MM_TAG_VM, pszFormat, va);
275	rc = VMR3ReqCallNoWaitU(pVM->pUVM, VMCPUID_ANY,
276	(PFNRT)vmR3SetRuntimeError, 4, pVM, fFlags, pszErrorId, pszMessage);
277	if (RT_FAILURE(rc))
278	MMR3HeapFree(pszMessage);
279	}
280
281	#else
282	/*
283	* We're already on the EMT and can safely create a VMRUNTIMEERROR chunk.
284	*/
285	AssertReleaseMsgFailed(("Congratulations! You will have the pleasure of debugging the RC/R0 path.\n"));
286	vmSetRuntimeErrorCopy(pVM, fFlags, pszErrorId, pszFormat, va);
287
288	int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_VM_SET_RUNTIME_ERROR, 0);
289	#endif
290
291	Log(("VMSetRuntimeErrorV: returns %Rrc (pszErrorId=%s)\n", rc, pszErrorId));
292	return rc;
293	}
294
295
296	/**
297	* Copies the error to a VMRUNTIMEERROR structure.
298	*
299	* This is mainly intended for Ring-0 and RC where the error must be copied to
300	* memory accessible from ring-3. But it's just possible that we might add
301	* APIs for retrieving the VMRUNTIMEERROR copy later.
302	*
303	* @param pVM VM handle. Must be non-NULL.
304	* @param fFlags The error flags.
305	* @param pszErrorId Error ID string.
306	* @param pszFormat Error message format string.
307	* @param va Error message arguments. This is of course spoiled
308	* by this call.
309	* @thread EMT
310	*/
311	void vmSetRuntimeErrorCopy(PVM pVM, uint32_t fFlags, const char pszErrorId, const char pszFormat, va_list va)
312	{
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
366	/**
367	* Gets the name of VM state.
368	*
369	* @returns Pointer to a read-only string with the state name.
370	* @param enmState The state.
371	*/
372	VMMDECL(const char *) VMGetStateName(VMSTATE enmState)
373	{
374	switch (enmState)
375	{
376	#define MY_CASE(enm) case VMSTATE_##enm: return #enm;
377	MY_CASE(CREATING);
378	MY_CASE(CREATED);
379	MY_CASE(RUNNING);
380	MY_CASE(LOADING);
381	MY_CASE(LOAD_FAILURE);
382	MY_CASE(SAVING);
383	MY_CASE(SUSPENDED);
384	MY_CASE(RESETTING);
385	MY_CASE(GURU_MEDITATION);
386	MY_CASE(OFF);
387	MY_CASE(DESTROYING);
388	MY_CASE(TERMINATED);
389	#undef MY_CASE
390	default:
391	return "Unknown";
392	}
393	}
394

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

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

Download in other formats: