VMAll.cpp@ 850

Last change on this file since 850 was 322, checked in by vboxsync, 18 years ago
r=bird: some comments on the runtime error stuff.
Property svn:keywords set to `Id`
File size: 11.3 KB

Line
1	/* $Id: VMAll.cpp 322 2007-01-25 17:20:26Z vboxsync $ */
2	/** @file
3	* VM - Virtual Machine All Contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
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
33	#include <iprt/assert.h>
34	#include <iprt/string.h>
35
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 VM handle. Must be non-NULL.
45	* @param rc VBox status code.
46	* @param RT_SRC_POS_DECL Use RT_SRC_POS.
47	* @param pszFormat Error message format string.
48	* @param ... Error message arguments.
49	* @thread Any
50	*/
51	VMDECL(int) VMSetError(PVM 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 VM handle. Must be non-NULL.
69	* @param rc VBox status code.
70	* @param RT_SRC_POS_DECL Use RT_SRC_POS.
71	* @param pszFormat Error message format string.
72	* @param args Error message arguments.
73	* @thread Any
74	*/
75	VMDECL(int) VMSetErrorV(PVM 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	PVMREQ pReq;
82	VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3SetErrorV, 7, /* ASSUMES 3 source pos args! */
83	pVM, rc, RT_SRC_POS_ARGS, pszFormat, &args);
84	VMR3ReqFree(pReq);
85
86	#else
87	/*
88	* We're already on the EMT thread and can safely create a VMERROR chunk.
89	*/
90	vmSetErrorCopy(pVM, rc, RT_SRC_POS_ARGS, pszFormat, args);
91
92	# ifdef IN_GC
93	VMMGCCallHost(pVM, VMMCALLHOST_VM_SET_ERROR, 0);
94	# elif defined(IN_RING0)
95	VMMR0CallHost(pVM, VMMCALLHOST_VM_SET_ERROR, 0);
96	# else
97	# endif
98	#endif
99	return rc;
100	}
101
102
103	/**
104	* Copies the error to a VMERROR structure.
105	*
106	* This is mainly intended for Ring-0 and GC where the error must be copied to
107	* memory accessible from ring-3. But it's just possible that we might add
108	* APIs for retrieving the VMERROR copy later.
109	*
110	* @param pVM VM handle. Must be non-NULL.
111	* @param rc VBox status code.
112	* @param RT_SRC_POS_DECL Use RT_SRC_POS.
113	* @param pszFormat Error message format string.
114	* @param args Error message arguments.
115	* @thread EMT
116	*/
117	void vmSetErrorCopy(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args)
118	{
119	#if 0 /// @todo implement Ring-0 and GC VMSetError
120	/*
121	* Create the untranslated message copy.
122	*/
123	/* free any old message. */
124	MMHyperFree(pVM, MMHyperR32Ctx(pVM, pVM->vm.s.pError));
125	pVM->vm.s.pError = NULL;
126
127	/* calc reasonable start size. */
128	size_t cchFile = pszFile ? strlen(pszFile) : 0;
129	size_t cchFunction = pszFunction ? strlen(pszFunction) : 0;
130	size_t cchFormat = strlen(pszFormat);
131	size_t cb = sizeof(VMERROR)
132	+ cchFile + 1
133	+ cchFunction + 1
134	+ cchFormat + 32;
135
136	/* allocate it */
137	void *pv;
138	int rc2 = MMHyperAlloc(pVM, cb, 0, MM_TAG_VM, &pv);
139	if (VBOX_SUCCESS(rc2))
140	{
141	/* initialize it. */
142	PVMERROR pErr = (PVMERROR)pv;
143	pErr->cbAllocated = cb;
144	pErr->iLine = iLine;
145	pErr->off = sizeof(VMERROR);
146	pErr->offFile = pErr->offFunction = 0;
147
148	if (cchFile)
149	{
150	pErr->offFile = pErr->off;
151	memcpy((uint8_t *)pErr + pErr->off, pszFile, cchFile + 1);
152	pErr->off += cchFile + 1;
153	}
154
155	if (cchFunction)
156	{
157	pErr->offFunction = pErr->off;
158	memcpy((uint8_t *)pErr + pErr->off, pszFunction, cchFunction + 1);
159	pErr->off += cchFunction + 1;
160	}
161
162	pErr->offMessage = pErr->off;
163
164	/* format the message (pErr might be reallocated) */
165	VMSETERRORFMTARGS Args;
166	Args.pVM = pVM;
167	Args.pErr = pErr;
168
169	va_list va2;
170	va_copy(va2, args);
171	RTStrFormatV(vmSetErrorFmtOut, &pErr, NULL, NULL, &pszFormatTmp, args);
172	va_end(va2);
173
174	/* done. */
175	pVM->vm.s.pErrorR3 = MMHyper2HC(pVM, (uintptr_t)pArgs.pErr);
176	}
177	#endif
178	}
179
180
181	/**
182	* Sets the runtime error message.
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	* The @a fFatal parameter defines whether the error is fatal or not. If it is
188	* true, then it is expected that the caller has already paused the VM execution
189	* before calling this method. The VM user is supposed to power off the VM
190	* immediately after it has received the runtime error notification via the
191	* FNVMATRUNTIMEERROR callback.
192	*
193	* If @a fFatal is false, then the paused state of the VM defines the kind of
194	* the error. If the VM is paused before calling this method, it means that
195	* the VM user may try to fix the error condition (i.e. free more host memory)
196	* and then resume the VM execution. If the VM is not paused before calling
197	* this method, it means that the given error is a warning about an error
198	* condition that may happen soon but that doesn't directly affect the
199	* VM execution by the time of the call.
200	*
201	* The @a pszErrorID parameter defines an unique error identificator.
202	* It is used by the front-ends to show a proper message to the end user
203	* containig possible actions (for example, Retry/Ignore). For this reason,
204	* an error ID assigned once to some particular error condition should not
205	* change in the future. The format of this parameter is "someErrorCondition".
206	*
207	* @param pVM VM handle. Must be non-NULL.
208	* @param fFatal Whether it is a fatal error or not.
209	* @param pszErrorID Error ID string.
210	* @param pszFormat Error message format string.
211	* @param ... Error message arguments.
212	*
213	* @return VBox status code (whether the error has been successfully set
214	* and delivered to callbacks or not).
215	*
216	* @thread Any
217	* @todo r=bird: The pausing/suspending of the VM should be done here, we'll just end
218	* up duplicating code all over the place otherwise. In the case of
219	* devices/drivers/etc they might not be trusted to pause/suspend the
220	* vm even. Change fFatal to fFlags and define action flags and a fatal flag.
221	*
222	* Also, why a string ID and not an enum?
223	*/
224	VMDECL(int) VMSetRuntimeError(PVM pVM, bool fFatal, const char *pszErrorID,
225	const char *pszFormat, ...)
226	{
227	va_list args;
228	va_start(args, pszFormat);
229	int rc = VMSetRuntimeErrorV(pVM, fFatal, pszErrorID, pszFormat, args);
230	va_end(args);
231	return rc;
232	}
233
234
235	/**
236	* va_list version of VMSetRuntimeError.
237	*
238	* @param pVM VM handle. Must be non-NULL.
239	* @param fFatal Whether it is a fatal error or not.
240	* @param pszErrorID Error ID string.
241	* @param pszFormat Error message format string.
242	* @param args Error message arguments.
243	*
244	* @return VBox status code (whether the error has been successfully set
245	* and delivered to callbacks or not).
246	*
247	* @thread Any
248	*/
249	VMDECL(int) VMSetRuntimeErrorV(PVM pVM, bool fFatal, const char *pszErrorID,
250	const char *pszFormat, va_list args)
251	{
252	#ifdef IN_RING3
253	/*
254	* Switch to EMT.
255	*/
256	PVMREQ pReq;
257	VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3SetRuntimeErrorV, 5,
258	pVM, fFatal, pszErrorID, pszFormat, &args);
259	VMR3ReqFree(pReq);
260
261	#else
262	/*
263	* We're already on the EMT thread and can safely create a VMRUNTIMEERROR chunk.
264	*/
265	vmSetRuntimeErrorCopy(pVM, fFatal, pszErrorID, pszFormat, args);
266
267	# ifdef IN_GC
268	VMMGCCallHost(pVM, VMMCALLHOST_VM_SET_RUNTIME_ERROR, 0);
269	# elif defined(IN_RING0)
270	VMMR0CallHost(pVM, VMMCALLHOST_VM_SET_RUNTIME_ERROR, 0);
271	# else
272	# endif
273	#endif
274	return VINF_SUCCESS;
275	}
276
277
278	/**
279	* Copies the error to a VMRUNTIMEERROR structure.
280	*
281	* This is mainly intended for Ring-0 and GC where the error must be copied to
282	* memory accessible from ring-3. But it's just possible that we might add
283	* APIs for retrieving the VMRUNTIMEERROR copy later.
284	*
285	* @param pVM VM handle. Must be non-NULL.
286	* @param fFatal Whether it is a fatal error or not.
287	* @param pszErrorID Error ID string.
288	* @param pszFormat Error message format string.
289	* @param args Error message arguments.
290	* @thread EMT
291	*/
292	void vmSetRuntimeErrorCopy(PVM pVM, bool fFatal, const char *pszErrorID,
293	const char *pszFormat, va_list args)
294	{
295	#if 0 /// @todo implement Ring-0 and GC VMSetError
296	/*
297	* Create the untranslated message copy.
298	*/
299	/* free any old message. */
300	MMHyperFree(pVM, MMHyperR32Ctx(pVM, pVM->vm.s.pRuntimeErrorR3));
301	pVM->vm.s.pRuntimeErrorR3 = NULL;
302
303	/* calc reasonable start size. */
304	size_t cchErrorID = pszErrorID ? strlen(pszErrorID) : 0;
305	size_t cchFormat = strlen(pszFormat);
306	size_t cb = sizeof(VMRUNTIMEERROR)
307	+ cchErrorID + 1
308	+ cchFormat + 32;
309
310	/* allocate it */
311	void *pv;
312	int rc2 = MMHyperAlloc(pVM, cb, 0, MM_TAG_VM, &pv);
313	if (VBOX_SUCCESS(rc2))
314	{
315	/* initialize it. */
316	PVMRUNTIMEERROR pErr = (PVMRUNTIMEERROR)pv;
317	pErr->cbAllocated = cb;
318	pErr->off = sizeof(PVMRUNTIMEERROR);
319	pErr->offErrorID = = 0;
320
321	if (cchErrorID)
322	{
323	pErr->offErrorID = pErr->off;
324	memcpy((uint8_t *)pErr + pErr->off, pszErrorID, cchErrorID + 1);
325	pErr->off += cchErrorID + 1;
326	}
327
328	pErr->offMessage = pErr->off;
329
330	/* format the message (pErr might be reallocated) */
331	VMSETRUNTIMEERRORFMTARGS Args;
332	Args.pVM = pVM;
333	Args.pErr = pErr;
334
335	va_list va2;
336	va_copy(va2, args);
337	RTStrFormatV(vmSetRuntimeErrorFmtOut, &pErr, NULL, NULL, &pszFormatTmp, args);
338	va_end(va2);
339
340	/* done. */
341	pVM->vm.s.pErrorRuntimeR3 = MMHyper2HC(pVM, (uintptr_t)pArgs.pErr);
342	}
343	#endif
344	}
345

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

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

Download in other formats: