VirtualBox

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

Last change on this file since 6537 was 5999, checked in by vboxsync, 17 years ago

The Giant CDDL Dual-License Header Change.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 11.3 KB
Line 
1/* $Id: VMAll.cpp 5999 2007-12-07 15:05:06Z vboxsync $ */
2/** @file
3 * VM - Virtual Machine All Contexts.
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek 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 (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.h>
25#include <VBox/mm.h>
26#include <VBox/vm.h>
27#include <VBox/err.h>
28
29#include <iprt/assert.h>
30#include <iprt/string.h>
31
32
33/**
34 * Sets the error message.
35 *
36 * @returns rc. Meaning you can do:
37 * @code
38 * return VM_SET_ERROR(pVM, VERR_OF_YOUR_CHOICE, "descriptive message");
39 * @endcode
40 * @param pVM VM handle. Must be non-NULL.
41 * @param rc VBox status code.
42 * @param RT_SRC_POS_DECL Use RT_SRC_POS.
43 * @param pszFormat Error message format string.
44 * @param ... Error message arguments.
45 * @thread Any
46 */
47VMDECL(int) VMSetError(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
48{
49 va_list args;
50 va_start(args, pszFormat);
51 int rc2 = VMSetErrorV(pVM, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc == rc2); NOREF(rc2);
52 va_end(args);
53 return rc;
54}
55
56
57/**
58 * Sets the error message.
59 *
60 * @returns rc. Meaning you can do:
61 * @code
62 * return VM_SET_ERROR(pVM, VERR_OF_YOUR_CHOICE, "descriptive message");
63 * @endcode
64 * @param pVM VM handle. Must be non-NULL.
65 * @param rc VBox status code.
66 * @param RT_SRC_POS_DECL Use RT_SRC_POS.
67 * @param pszFormat Error message format string.
68 * @param args Error message arguments.
69 * @thread Any
70 */
71VMDECL(int) VMSetErrorV(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args)
72{
73#ifdef IN_RING3
74 /*
75 * Switch to EMT.
76 */
77 va_list va2;
78 va_copy(va2, args); /* Have to make a copy here or GCC will break. */
79 PVMREQ pReq;
80 VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3SetErrorV, 7, /* ASSUMES 3 source pos args! */
81 pVM, rc, RT_SRC_POS_ARGS, pszFormat, &va2);
82 VMR3ReqFree(pReq);
83 va_end(va2);
84
85#else
86 /*
87 * We're already on the EMT thread and can safely create a VMERROR chunk.
88 */
89 vmSetErrorCopy(pVM, rc, RT_SRC_POS_ARGS, pszFormat, args);
90
91# ifdef IN_GC
92 VMMGCCallHost(pVM, VMMCALLHOST_VM_SET_ERROR, 0);
93# elif defined(IN_RING0)
94 VMMR0CallHost(pVM, VMMCALLHOST_VM_SET_ERROR, 0);
95# else
96# endif
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 */
116void 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 (VBOX_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 * 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 * The @a fFatal parameter defines whether the error is fatal or not. If it is
187 * true, then it is expected that the caller has already paused the VM execution
188 * before calling this method. The VM user is supposed to power off the VM
189 * immediately after it has received the runtime error notification via the
190 * FNVMATRUNTIMEERROR callback.
191 *
192 * If @a fFatal is false, then the paused state of the VM defines the kind of
193 * the error. If the VM is paused before calling this method, it means that
194 * the VM user may try to fix the error condition (i.e. free more host memory)
195 * and then resume the VM execution. If the VM is not paused before calling
196 * this method, it means that the given error is a warning about an error
197 * condition that may happen soon but that doesn't directly affect the
198 * VM execution by the time of the call.
199 *
200 * The @a pszErrorID parameter defines an unique error identificator.
201 * It is used by the front-ends to show a proper message to the end user
202 * containig possible actions (for example, Retry/Ignore). For this reason,
203 * an error ID assigned once to some particular error condition should not
204 * change in the future. The format of this parameter is "someErrorCondition".
205 *
206 * @param pVM VM handle. Must be non-NULL.
207 * @param fFatal Whether it is a fatal error or not.
208 * @param pszErrorID Error ID string.
209 * @param pszFormat Error message format string.
210 * @param ... Error message arguments.
211 *
212 * @return VBox status code (whether the error has been successfully set
213 * and delivered to callbacks or not).
214 *
215 * @thread Any
216 * @todo r=bird: The pausing/suspending of the VM should be done here, we'll just end
217 * up duplicating code all over the place otherwise. In the case of
218 * devices/drivers/etc they might not be trusted to pause/suspend the
219 * vm even. Change fFatal to fFlags and define action flags and a fatal flag.
220 *
221 * Also, why a string ID and not an enum?
222 */
223VMDECL(int) VMSetRuntimeError(PVM pVM, bool fFatal, const char *pszErrorID,
224 const char *pszFormat, ...)
225{
226 va_list args;
227 va_start(args, pszFormat);
228 int rc = VMSetRuntimeErrorV(pVM, fFatal, pszErrorID, pszFormat, args);
229 va_end(args);
230 return rc;
231}
232
233
234/**
235 * va_list version of VMSetRuntimeError.
236 *
237 * @param pVM VM handle. Must be non-NULL.
238 * @param fFatal Whether it is a fatal error or not.
239 * @param pszErrorID Error ID string.
240 * @param pszFormat Error message format string.
241 * @param args Error message arguments.
242 *
243 * @return VBox status code (whether the error has been successfully set
244 * and delivered to callbacks or not).
245 *
246 * @thread Any
247 */
248VMDECL(int) VMSetRuntimeErrorV(PVM pVM, bool fFatal, const char *pszErrorID,
249 const char *pszFormat, va_list args)
250{
251#ifdef IN_RING3
252 /*
253 * Switch to EMT.
254 */
255 va_list va2;
256 va_copy(va2, args); /* Have to make a copy here or GCC will break. */
257 PVMREQ pReq;
258 VMR3ReqCall(pVM, &pReq, RT_INDEFINITE_WAIT, (PFNRT)vmR3SetRuntimeErrorV, 5,
259 pVM, fFatal, pszErrorID, pszFormat, &va2);
260 VMR3ReqFree(pReq);
261 va_end(va2);
262
263#else
264 /*
265 * We're already on the EMT thread and can safely create a VMRUNTIMEERROR chunk.
266 */
267 vmSetRuntimeErrorCopy(pVM, fFatal, pszErrorID, pszFormat, args);
268
269# ifdef IN_GC
270 VMMGCCallHost(pVM, VMMCALLHOST_VM_SET_RUNTIME_ERROR, 0);
271# elif defined(IN_RING0)
272 VMMR0CallHost(pVM, VMMCALLHOST_VM_SET_RUNTIME_ERROR, 0);
273# else
274# endif
275#endif
276 return VINF_SUCCESS;
277}
278
279
280/**
281 * Copies the error to a VMRUNTIMEERROR structure.
282 *
283 * This is mainly intended for Ring-0 and GC where the error must be copied to
284 * memory accessible from ring-3. But it's just possible that we might add
285 * APIs for retrieving the VMRUNTIMEERROR copy later.
286 *
287 * @param pVM VM handle. Must be non-NULL.
288 * @param fFatal Whether it is a fatal error or not.
289 * @param pszErrorID Error ID string.
290 * @param pszFormat Error message format string.
291 * @param args Error message arguments.
292 * @thread EMT
293 */
294void vmSetRuntimeErrorCopy(PVM pVM, bool fFatal, const char *pszErrorID,
295 const char *pszFormat, va_list args)
296{
297#if 0 /// @todo implement Ring-0 and GC VMSetError
298 /*
299 * Create the untranslated message copy.
300 */
301 /* free any old message. */
302 MMHyperFree(pVM, MMHyperR32Ctx(pVM, pVM->vm.s.pRuntimeErrorR3));
303 pVM->vm.s.pRuntimeErrorR3 = NULL;
304
305 /* calc reasonable start size. */
306 size_t cchErrorID = pszErrorID ? strlen(pszErrorID) : 0;
307 size_t cchFormat = strlen(pszFormat);
308 size_t cb = sizeof(VMRUNTIMEERROR)
309 + cchErrorID + 1
310 + cchFormat + 32;
311
312 /* allocate it */
313 void *pv;
314 int rc2 = MMHyperAlloc(pVM, cb, 0, MM_TAG_VM, &pv);
315 if (VBOX_SUCCESS(rc2))
316 {
317 /* initialize it. */
318 PVMRUNTIMEERROR pErr = (PVMRUNTIMEERROR)pv;
319 pErr->cbAllocated = cb;
320 pErr->off = sizeof(PVMRUNTIMEERROR);
321 pErr->offErrorID = = 0;
322
323 if (cchErrorID)
324 {
325 pErr->offErrorID = pErr->off;
326 memcpy((uint8_t *)pErr + pErr->off, pszErrorID, cchErrorID + 1);
327 pErr->off += cchErrorID + 1;
328 }
329
330 pErr->offMessage = pErr->off;
331
332 /* format the message (pErr might be reallocated) */
333 VMSETRUNTIMEERRORFMTARGS Args;
334 Args.pVM = pVM;
335 Args.pErr = pErr;
336
337 va_list va2;
338 va_copy(va2, args);
339 RTStrFormatV(vmSetRuntimeErrorFmtOut, &pErr, NULL, NULL, &pszFormatTmp, args);
340 va_end(va2);
341
342 /* done. */
343 pVM->vm.s.pErrorRuntimeR3 = MMHyper2HC(pVM, (uintptr_t)pArgs.pErr);
344 }
345#endif
346}
347
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette