VirtualBox

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

Last change on this file since 2744 was 2297, checked in by vboxsync, 18 years ago

svn:eol-style native
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 11.3 KB
Line 
1/* $Id: VMAll.cpp 2297 2007-04-20 23:51:13Z 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 */
51VMDECL(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 */
75VMDECL(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 */
117void 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 */
224VMDECL(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 */
249VMDECL(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 */
292void 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.

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