VirtualBox

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

Last change on this file since 91634 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 */
51VMMDECL(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 */
75VMMDECL(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 */
112void 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 */
209VMMDECL(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 */
234VMMDECL(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 */
310void 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 */
373VMMDECL(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 */
403VMMDECL(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 */
416VMMDECL(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 */
429VMMDECL(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.

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