VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR0/VMMR0.cpp@ 45684

Last change on this file since 45684 was 44528, checked in by vboxsync, 12 years ago

header (C) fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 56.0 KB
Line 
1/* $Id: VMMR0.cpp 44528 2013-02-04 14:27:54Z vboxsync $ */
2/** @file
3 * VMM - Host Context Ring 0.
4 */
5
6/*
7 * Copyright (C) 2006-2012 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* Header Files *
20*******************************************************************************/
21#define LOG_GROUP LOG_GROUP_VMM
22#include <VBox/vmm/vmm.h>
23#include <VBox/sup.h>
24#include <VBox/vmm/trpm.h>
25#include <VBox/vmm/cpum.h>
26#include <VBox/vmm/pdmapi.h>
27#include <VBox/vmm/pgm.h>
28#include <VBox/vmm/stam.h>
29#include <VBox/vmm/tm.h>
30#include "VMMInternal.h"
31#include <VBox/vmm/vm.h>
32#ifdef VBOX_WITH_PCI_PASSTHROUGH
33# include <VBox/vmm/pdmpci.h>
34#endif
35
36#include <VBox/vmm/gvmm.h>
37#include <VBox/vmm/gmm.h>
38#include <VBox/intnet.h>
39#include <VBox/vmm/hm.h>
40#include <VBox/param.h>
41#include <VBox/err.h>
42#include <VBox/version.h>
43#include <VBox/log.h>
44
45#include <iprt/asm-amd64-x86.h>
46#include <iprt/assert.h>
47#include <iprt/crc.h>
48#include <iprt/mp.h>
49#include <iprt/once.h>
50#include <iprt/stdarg.h>
51#include <iprt/string.h>
52#include <iprt/thread.h>
53#include <iprt/timer.h>
54
55#include "dtrace/VBoxVMM.h"
56
57
58#if defined(_MSC_VER) && defined(RT_ARCH_AMD64) /** @todo check this with with VC7! */
59# pragma intrinsic(_AddressOfReturnAddress)
60#endif
61
62
63/*******************************************************************************
64* Internal Functions *
65*******************************************************************************/
66RT_C_DECLS_BEGIN
67#if defined(RT_ARCH_X86) && (defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD))
68extern uint64_t __udivdi3(uint64_t, uint64_t);
69extern uint64_t __umoddi3(uint64_t, uint64_t);
70#endif
71RT_C_DECLS_END
72
73
74/*******************************************************************************
75* Global Variables *
76*******************************************************************************/
77/** Drag in necessary library bits.
78 * The runtime lives here (in VMMR0.r0) and VBoxDD*R0.r0 links against us. */
79PFNRT g_VMMGCDeps[] =
80{
81 (PFNRT)RTCrc32,
82 (PFNRT)RTOnce,
83#if defined(RT_ARCH_X86) && (defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD))
84 (PFNRT)__udivdi3,
85 (PFNRT)__umoddi3,
86#endif
87 NULL
88};
89
90#ifdef RT_OS_SOLARIS
91/* Dependency information for the native solaris loader. */
92extern "C" { char _depends_on[] = "vboxdrv"; }
93#endif
94
95
96
97/**
98 * Initialize the module.
99 * This is called when we're first loaded.
100 *
101 * @returns 0 on success.
102 * @returns VBox status on failure.
103 * @param hMod Image handle for use in APIs.
104 */
105DECLEXPORT(int) ModuleInit(void *hMod)
106{
107#ifdef VBOX_WITH_DTRACE_R0
108 /*
109 * The first thing to do is register the static tracepoints.
110 * (Deregistration is automatic.)
111 */
112 int rc2 = SUPR0TracerRegisterModule(hMod, &g_VTGObjHeader);
113 if (RT_FAILURE(rc2))
114 return rc2;
115#endif
116 LogFlow(("ModuleInit:\n"));
117
118 /*
119 * Initialize the VMM, GVMM, GMM, HM, PGM (Darwin) and INTNET.
120 */
121 int rc = vmmInitFormatTypes();
122 if (RT_SUCCESS(rc))
123 {
124 rc = GVMMR0Init();
125 if (RT_SUCCESS(rc))
126 {
127 rc = GMMR0Init();
128 if (RT_SUCCESS(rc))
129 {
130 rc = HMR0Init();
131 if (RT_SUCCESS(rc))
132 {
133 rc = PGMRegisterStringFormatTypes();
134 if (RT_SUCCESS(rc))
135 {
136#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
137 rc = PGMR0DynMapInit();
138#endif
139 if (RT_SUCCESS(rc))
140 {
141 rc = IntNetR0Init();
142 if (RT_SUCCESS(rc))
143 {
144#ifdef VBOX_WITH_PCI_PASSTHROUGH
145 rc = PciRawR0Init();
146#endif
147 if (RT_SUCCESS(rc))
148 {
149 rc = CPUMR0ModuleInit();
150 if (RT_SUCCESS(rc))
151 {
152#ifdef VBOX_WITH_TRIPLE_FAULT_HACK
153 rc = vmmR0TripleFaultHackInit();
154 if (RT_SUCCESS(rc))
155#endif
156 {
157 LogFlow(("ModuleInit: returns success.\n"));
158 return VINF_SUCCESS;
159 }
160
161 /*
162 * Bail out.
163 */
164#ifdef VBOX_WITH_TRIPLE_FAULT_HACK
165 vmmR0TripleFaultHackTerm();
166#endif
167 }
168 else
169 LogRel(("ModuleInit: CPUMR0ModuleInit -> %Rrc\n", rc));
170#ifdef VBOX_WITH_PCI_PASSTHROUGH
171 PciRawR0Term();
172#endif
173 }
174 else
175 LogRel(("ModuleInit: PciRawR0Init -> %Rrc\n", rc));
176 IntNetR0Term();
177 }
178 else
179 LogRel(("ModuleInit: IntNetR0Init -> %Rrc\n", rc));
180#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
181 PGMR0DynMapTerm();
182#endif
183 }
184 else
185 LogRel(("ModuleInit: PGMR0DynMapInit -> %Rrc\n", rc));
186 PGMDeregisterStringFormatTypes();
187 }
188 else
189 LogRel(("ModuleInit: PGMRegisterStringFormatTypes -> %Rrc\n", rc));
190 HMR0Term();
191 }
192 else
193 LogRel(("ModuleInit: HMR0Init -> %Rrc\n", rc));
194 GMMR0Term();
195 }
196 else
197 LogRel(("ModuleInit: GMMR0Init -> %Rrc\n", rc));
198 GVMMR0Term();
199 }
200 else
201 LogRel(("ModuleInit: GVMMR0Init -> %Rrc\n", rc));
202 vmmTermFormatTypes();
203 }
204 else
205 LogRel(("ModuleInit: vmmInitFormatTypes -> %Rrc\n", rc));
206
207 LogFlow(("ModuleInit: failed %Rrc\n", rc));
208 return rc;
209}
210
211
212/**
213 * Terminate the module.
214 * This is called when we're finally unloaded.
215 *
216 * @param hMod Image handle for use in APIs.
217 */
218DECLEXPORT(void) ModuleTerm(void *hMod)
219{
220 LogFlow(("ModuleTerm:\n"));
221
222 /*
223 * Terminate the CPUM module (Local APIC cleanup).
224 */
225 CPUMR0ModuleTerm();
226
227 /*
228 * Terminate the internal network service.
229 */
230 IntNetR0Term();
231
232 /*
233 * PGM (Darwin), HM and PciRaw global cleanup.
234 */
235#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
236 PGMR0DynMapTerm();
237#endif
238#ifdef VBOX_WITH_PCI_PASSTHROUGH
239 PciRawR0Term();
240#endif
241 PGMDeregisterStringFormatTypes();
242 HMR0Term();
243#ifdef VBOX_WITH_TRIPLE_FAULT_HACK
244 vmmR0TripleFaultHackTerm();
245#endif
246
247 /*
248 * Destroy the GMM and GVMM instances.
249 */
250 GMMR0Term();
251 GVMMR0Term();
252
253 vmmTermFormatTypes();
254
255 LogFlow(("ModuleTerm: returns\n"));
256}
257
258
259/**
260 * Initiates the R0 driver for a particular VM instance.
261 *
262 * @returns VBox status code.
263 *
264 * @param pVM Pointer to the VM.
265 * @param uSvnRev The SVN revision of the ring-3 part.
266 * @thread EMT.
267 */
268static int vmmR0InitVM(PVM pVM, uint32_t uSvnRev)
269{
270 /*
271 * Match the SVN revisions.
272 */
273 if (uSvnRev != VMMGetSvnRev())
274 {
275 LogRel(("VMMR0InitVM: Revision mismatch, r3=%d r0=%d\n", uSvnRev, VMMGetSvnRev()));
276 SUPR0Printf("VMMR0InitVM: Revision mismatch, r3=%d r0=%d\n", uSvnRev, VMMGetSvnRev());
277 return VERR_VMM_R0_VERSION_MISMATCH;
278 }
279 if ( !VALID_PTR(pVM)
280 || pVM->pVMR0 != pVM)
281 return VERR_INVALID_PARAMETER;
282
283#ifdef LOG_ENABLED
284 /*
285 * Register the EMT R0 logger instance for VCPU 0.
286 */
287 PVMCPU pVCpu = &pVM->aCpus[0];
288
289 PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
290 if (pR0Logger)
291 {
292# if 0 /* testing of the logger. */
293 LogCom(("vmmR0InitVM: before %p\n", RTLogDefaultInstance()));
294 LogCom(("vmmR0InitVM: pfnFlush=%p actual=%p\n", pR0Logger->Logger.pfnFlush, vmmR0LoggerFlush));
295 LogCom(("vmmR0InitVM: pfnLogger=%p actual=%p\n", pR0Logger->Logger.pfnLogger, vmmR0LoggerWrapper));
296 LogCom(("vmmR0InitVM: offScratch=%d fFlags=%#x fDestFlags=%#x\n", pR0Logger->Logger.offScratch, pR0Logger->Logger.fFlags, pR0Logger->Logger.fDestFlags));
297
298 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
299 LogCom(("vmmR0InitVM: after %p reg\n", RTLogDefaultInstance()));
300 RTLogSetDefaultInstanceThread(NULL, pVM->pSession);
301 LogCom(("vmmR0InitVM: after %p dereg\n", RTLogDefaultInstance()));
302
303 pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
304 LogCom(("vmmR0InitVM: returned successfully from direct logger call.\n"));
305 pR0Logger->Logger.pfnFlush(&pR0Logger->Logger);
306 LogCom(("vmmR0InitVM: returned successfully from direct flush call.\n"));
307
308 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
309 LogCom(("vmmR0InitVM: after %p reg2\n", RTLogDefaultInstance()));
310 pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
311 LogCom(("vmmR0InitVM: returned successfully from direct logger call (2). offScratch=%d\n", pR0Logger->Logger.offScratch));
312 RTLogSetDefaultInstanceThread(NULL, pVM->pSession);
313 LogCom(("vmmR0InitVM: after %p dereg2\n", RTLogDefaultInstance()));
314
315 RTLogLoggerEx(&pR0Logger->Logger, 0, ~0U, "hello ring-0 logger (RTLogLoggerEx)\n");
316 LogCom(("vmmR0InitVM: RTLogLoggerEx returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
317
318 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
319 RTLogPrintf("hello ring-0 logger (RTLogPrintf)\n");
320 LogCom(("vmmR0InitVM: RTLogPrintf returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
321# endif
322 Log(("Switching to per-thread logging instance %p (key=%p)\n", &pR0Logger->Logger, pVM->pSession));
323 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
324 pR0Logger->fRegistered = true;
325 }
326#endif /* LOG_ENABLED */
327
328 /*
329 * Check if the host supports high resolution timers or not.
330 */
331 if ( pVM->vmm.s.fUsePeriodicPreemptionTimers
332 && !RTTimerCanDoHighResolution())
333 pVM->vmm.s.fUsePeriodicPreemptionTimers = false;
334
335 /*
336 * Initialize the per VM data for GVMM and GMM.
337 */
338 int rc = GVMMR0InitVM(pVM);
339// if (RT_SUCCESS(rc))
340// rc = GMMR0InitPerVMData(pVM);
341 if (RT_SUCCESS(rc))
342 {
343 /*
344 * Init HM, CPUM and PGM (Darwin only).
345 */
346 rc = HMR0InitVM(pVM);
347 if (RT_SUCCESS(rc))
348 {
349 rc = CPUMR0Init(pVM); /** @todo rename to CPUMR0InitVM */
350 if (RT_SUCCESS(rc))
351 {
352#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
353 rc = PGMR0DynMapInitVM(pVM);
354#endif
355 if (RT_SUCCESS(rc))
356 {
357#ifdef VBOX_WITH_PCI_PASSTHROUGH
358 rc = PciRawR0InitVM(pVM);
359#endif
360 if (RT_SUCCESS(rc))
361 {
362 GVMMR0DoneInitVM(pVM);
363 return rc;
364 }
365 }
366
367 /* bail out */
368 }
369#ifdef VBOX_WITH_PCI_PASSTHROUGH
370 PciRawR0TermVM(pVM);
371#endif
372 HMR0TermVM(pVM);
373 }
374 }
375
376
377 RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pVM->pSession);
378 return rc;
379}
380
381
382/**
383 * Terminates the R0 bits for a particular VM instance.
384 *
385 * This is normally called by ring-3 as part of the VM termination process, but
386 * may alternatively be called during the support driver session cleanup when
387 * the VM object is destroyed (see GVMM).
388 *
389 * @returns VBox status code.
390 *
391 * @param pVM Pointer to the VM.
392 * @param pGVM Pointer to the global VM structure. Optional.
393 * @thread EMT or session clean up thread.
394 */
395VMMR0DECL(int) VMMR0TermVM(PVM pVM, PGVM pGVM)
396{
397#ifdef VBOX_WITH_PCI_PASSTHROUGH
398 PciRawR0TermVM(pVM);
399#endif
400
401
402 /*
403 * Tell GVMM what we're up to and check that we only do this once.
404 */
405 if (GVMMR0DoingTermVM(pVM, pGVM))
406 {
407 /** @todo I wish to call PGMR0PhysFlushHandyPages(pVM, &pVM->aCpus[idCpu])
408 * here to make sure we don't leak any shared pages if we crash... */
409#ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
410 PGMR0DynMapTermVM(pVM);
411#endif
412 HMR0TermVM(pVM);
413 }
414
415 /*
416 * Deregister the logger.
417 */
418 RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pVM->pSession);
419 return VINF_SUCCESS;
420}
421
422
423#ifdef VBOX_WITH_STATISTICS
424/**
425 * Record return code statistics
426 * @param pVM Pointer to the VM.
427 * @param pVCpu Pointer to the VMCPU.
428 * @param rc The status code.
429 */
430static void vmmR0RecordRC(PVM pVM, PVMCPU pVCpu, int rc)
431{
432 /*
433 * Collect statistics.
434 */
435 switch (rc)
436 {
437 case VINF_SUCCESS:
438 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetNormal);
439 break;
440 case VINF_EM_RAW_INTERRUPT:
441 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterrupt);
442 break;
443 case VINF_EM_RAW_INTERRUPT_HYPER:
444 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterruptHyper);
445 break;
446 case VINF_EM_RAW_GUEST_TRAP:
447 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetGuestTrap);
448 break;
449 case VINF_EM_RAW_RING_SWITCH:
450 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRingSwitch);
451 break;
452 case VINF_EM_RAW_RING_SWITCH_INT:
453 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRingSwitchInt);
454 break;
455 case VINF_EM_RAW_STALE_SELECTOR:
456 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetStaleSelector);
457 break;
458 case VINF_EM_RAW_IRET_TRAP:
459 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIRETTrap);
460 break;
461 case VINF_IOM_R3_IOPORT_READ:
462 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIORead);
463 break;
464 case VINF_IOM_R3_IOPORT_WRITE:
465 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIOWrite);
466 break;
467 case VINF_IOM_R3_MMIO_READ:
468 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIORead);
469 break;
470 case VINF_IOM_R3_MMIO_WRITE:
471 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOWrite);
472 break;
473 case VINF_IOM_R3_MMIO_READ_WRITE:
474 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOReadWrite);
475 break;
476 case VINF_PATM_HC_MMIO_PATCH_READ:
477 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOPatchRead);
478 break;
479 case VINF_PATM_HC_MMIO_PATCH_WRITE:
480 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMMIOPatchWrite);
481 break;
482 case VINF_EM_RAW_EMULATE_INSTR:
483 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetEmulate);
484 break;
485 case VINF_EM_RAW_EMULATE_IO_BLOCK:
486 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIOBlockEmulate);
487 break;
488 case VINF_PATCH_EMULATE_INSTR:
489 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchEmulate);
490 break;
491 case VINF_EM_RAW_EMULATE_INSTR_LDT_FAULT:
492 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetLDTFault);
493 break;
494 case VINF_EM_RAW_EMULATE_INSTR_GDT_FAULT:
495 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetGDTFault);
496 break;
497 case VINF_EM_RAW_EMULATE_INSTR_IDT_FAULT:
498 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetIDTFault);
499 break;
500 case VINF_EM_RAW_EMULATE_INSTR_TSS_FAULT:
501 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetTSSFault);
502 break;
503 case VINF_EM_RAW_EMULATE_INSTR_PD_FAULT:
504 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPDFault);
505 break;
506 case VINF_CSAM_PENDING_ACTION:
507 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCSAMTask);
508 break;
509 case VINF_PGM_SYNC_CR3:
510 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetSyncCR3);
511 break;
512 case VINF_PATM_PATCH_INT3:
513 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchInt3);
514 break;
515 case VINF_PATM_PATCH_TRAP_PF:
516 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchPF);
517 break;
518 case VINF_PATM_PATCH_TRAP_GP:
519 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchGP);
520 break;
521 case VINF_PATM_PENDING_IRQ_AFTER_IRET:
522 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchIretIRQ);
523 break;
524 case VINF_EM_RESCHEDULE_REM:
525 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetRescheduleREM);
526 break;
527 case VINF_EM_RAW_TO_R3:
528 if (VM_FF_ISPENDING(pVM, VM_FF_TM_VIRTUAL_SYNC))
529 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3TMVirt);
530 else if (VM_FF_ISPENDING(pVM, VM_FF_PGM_NEED_HANDY_PAGES))
531 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3HandyPages);
532 else if (VM_FF_ISPENDING(pVM, VM_FF_PDM_QUEUES))
533 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3PDMQueues);
534 else if (VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS))
535 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Rendezvous);
536 else if (VM_FF_ISPENDING(pVM, VM_FF_PDM_DMA))
537 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3DMA);
538 else if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_TIMER))
539 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Timer);
540 else if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_PDM_CRITSECT))
541 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3CritSect);
542 else if (VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_TO_R3))
543 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3);
544 else
545 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Unknown);
546 break;
547
548 case VINF_EM_RAW_TIMER_PENDING:
549 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetTimerPending);
550 break;
551 case VINF_EM_RAW_INTERRUPT_PENDING:
552 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetInterruptPending);
553 break;
554 case VINF_VMM_CALL_HOST:
555 switch (pVCpu->vmm.s.enmCallRing3Operation)
556 {
557 case VMMCALLRING3_PDM_CRIT_SECT_ENTER:
558 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMCritSectEnter);
559 break;
560 case VMMCALLRING3_PDM_LOCK:
561 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPDMLock);
562 break;
563 case VMMCALLRING3_PGM_POOL_GROW:
564 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMPoolGrow);
565 break;
566 case VMMCALLRING3_PGM_LOCK:
567 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMLock);
568 break;
569 case VMMCALLRING3_PGM_MAP_CHUNK:
570 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMMapChunk);
571 break;
572 case VMMCALLRING3_PGM_ALLOCATE_HANDY_PAGES:
573 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMAllocHandy);
574 break;
575 case VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS:
576 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallRemReplay);
577 break;
578 case VMMCALLRING3_VMM_LOGGER_FLUSH:
579 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallLogFlush);
580 break;
581 case VMMCALLRING3_VM_SET_ERROR:
582 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetError);
583 break;
584 case VMMCALLRING3_VM_SET_RUNTIME_ERROR:
585 STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallVMSetRuntimeError);
586 break;
587 case VMMCALLRING3_VM_R0_ASSERTION:
588 default:
589 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetCallRing3);
590 break;
591 }
592 break;
593 case VINF_PATM_DUPLICATE_FUNCTION:
594 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPATMDuplicateFn);
595 break;
596 case VINF_PGM_CHANGE_MODE:
597 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPGMChangeMode);
598 break;
599 case VINF_PGM_POOL_FLUSH_PENDING:
600 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPGMFlushPending);
601 break;
602 case VINF_EM_PENDING_REQUEST:
603 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPendingRequest);
604 break;
605 case VINF_EM_HM_PATCH_TPR_INSTR:
606 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetPatchTPR);
607 break;
608 default:
609 STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetMisc);
610 break;
611 }
612}
613#endif /* VBOX_WITH_STATISTICS */
614
615
616/**
617 * Unused ring-0 entry point that used to be called from the interrupt gate.
618 *
619 * Will be removed one of the next times we do a major SUPDrv version bump.
620 *
621 * @returns VBox status code.
622 * @param pVM Pointer to the VM.
623 * @param enmOperation Which operation to execute.
624 * @param pvArg Argument to the operation.
625 * @remarks Assume called with interrupts disabled.
626 */
627VMMR0DECL(int) VMMR0EntryInt(PVM pVM, VMMR0OPERATION enmOperation, void *pvArg)
628{
629 /*
630 * We're returning VERR_NOT_SUPPORT here so we've got something else
631 * than -1 which the interrupt gate glue code might return.
632 */
633 Log(("operation %#x is not supported\n", enmOperation));
634 NOREF(enmOperation); NOREF(pvArg); NOREF(pVM);
635 return VERR_NOT_SUPPORTED;
636}
637
638
639/**
640 * The Ring 0 entry point, called by the fast-ioctl path.
641 *
642 * @param pVM Pointer to the VM.
643 * The return code is stored in pVM->vmm.s.iLastGZRc.
644 * @param idCpu The Virtual CPU ID of the calling EMT.
645 * @param enmOperation Which operation to execute.
646 * @remarks Assume called with interrupts _enabled_.
647 */
648VMMR0DECL(void) VMMR0EntryFast(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation)
649{
650 if (RT_UNLIKELY(idCpu >= pVM->cCpus))
651 return;
652 PVMCPU pVCpu = &pVM->aCpus[idCpu];
653
654 switch (enmOperation)
655 {
656 /*
657 * Switch to GC and run guest raw mode code.
658 * Disable interrupts before doing the world switch.
659 */
660 case VMMR0_DO_RAW_RUN:
661 {
662 /* Some safety precautions first. */
663#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
664 if (RT_LIKELY( !pVM->vmm.s.fSwitcherDisabled /* hm */
665 && pVM->cCpus == 1 /* !smp */
666 && PGMGetHyperCR3(pVCpu)))
667#else
668 if (RT_LIKELY( !pVM->vmm.s.fSwitcherDisabled
669 && pVM->cCpus == 1))
670#endif
671 {
672 /* Disable preemption and update the periodic preemption timer. */
673 RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
674 RTThreadPreemptDisable(&PreemptState);
675 RTCPUID idHostCpu = RTMpCpuId();
676#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
677 CPUMR0SetLApic(pVM, idHostCpu);
678#endif
679 ASMAtomicWriteU32(&pVCpu->idHostCpu, idHostCpu);
680 if (pVM->vmm.s.fUsePeriodicPreemptionTimers)
681 GVMMR0SchedUpdatePeriodicPreemptionTimer(pVM, pVCpu->idHostCpu, TMCalcHostTimerFrequency(pVM, pVCpu));
682
683 /* We might need to disable VT-x if the active switcher turns off paging. */
684 bool fVTxDisabled;
685 int rc = HMR0EnterSwitcher(pVM, pVM->vmm.s.enmSwitcher, &fVTxDisabled);
686 if (RT_SUCCESS(rc))
687 {
688 RTCCUINTREG uFlags = ASMIntDisableFlags();
689
690 for (;;)
691 {
692 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC);
693 TMNotifyStartOfExecution(pVCpu);
694
695 rc = pVM->vmm.s.pfnR0ToRawMode(pVM);
696 pVCpu->vmm.s.iLastGZRc = rc;
697
698 TMNotifyEndOfExecution(pVCpu);
699 VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
700
701 if (rc != VINF_VMM_CALL_TRACER)
702 break;
703 SUPR0TracerUmodProbeFire(pVM->pSession, &pVCpu->vmm.s.TracerCtx);
704 }
705
706 /* Re-enable VT-x if previously turned off. */
707 HMR0LeaveSwitcher(pVM, fVTxDisabled);
708
709 if ( rc == VINF_EM_RAW_INTERRUPT
710 || rc == VINF_EM_RAW_INTERRUPT_HYPER)
711 TRPMR0DispatchHostInterrupt(pVM);
712
713 ASMSetFlags(uFlags);
714
715#ifdef VBOX_WITH_STATISTICS
716 STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
717 vmmR0RecordRC(pVM, pVCpu, rc);
718#endif
719 }
720 else
721 pVCpu->vmm.s.iLastGZRc = rc;
722 ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
723 RTThreadPreemptRestore(&PreemptState);
724 }
725 else
726 {
727 Assert(!pVM->vmm.s.fSwitcherDisabled);
728 pVCpu->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
729 if (pVM->cCpus != 1)
730 pVCpu->vmm.s.iLastGZRc = VERR_RAW_MODE_INVALID_SMP;
731#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
732 if (!PGMGetHyperCR3(pVCpu))
733 pVCpu->vmm.s.iLastGZRc = VERR_PGM_NO_CR3_SHADOW_ROOT;
734#endif
735 }
736 break;
737 }
738
739 /*
740 * Run guest code using the available hardware acceleration technology.
741 *
742 * Disable interrupts before we do anything interesting. On Windows we avoid
743 * this by having the support driver raise the IRQL before calling us, this way
744 * we hope to get away with page faults and later calling into the kernel.
745 */
746 case VMMR0_DO_HM_RUN:
747 {
748#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
749 RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
750 RTThreadPreemptDisable(&PreemptState);
751#elif !defined(RT_OS_WINDOWS)
752 RTCCUINTREG uFlags = ASMIntDisableFlags();
753#endif
754 ASMAtomicWriteU32(&pVCpu->idHostCpu, RTMpCpuId());
755 if (pVM->vmm.s.fUsePeriodicPreemptionTimers)
756 GVMMR0SchedUpdatePeriodicPreemptionTimer(pVM, pVCpu->idHostCpu, TMCalcHostTimerFrequency(pVM, pVCpu));
757
758#ifdef LOG_ENABLED
759 if (pVCpu->idCpu > 0)
760 {
761 /* Lazy registration of ring 0 loggers. */
762 PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
763 if ( pR0Logger
764 && !pR0Logger->fRegistered)
765 {
766 RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
767 pR0Logger->fRegistered = true;
768 }
769 }
770#endif
771 int rc;
772 if (!HMR0SuspendPending())
773 {
774 rc = HMR0Enter(pVM, pVCpu);
775 if (RT_SUCCESS(rc))
776 {
777 rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, HMR0RunGuestCode, pVM, pVCpu); /* this may resume code. */
778 int rc2 = HMR0Leave(pVM, pVCpu);
779 AssertRC(rc2);
780 }
781 STAM_COUNTER_INC(&pVM->vmm.s.StatRunRC);
782 }
783 else
784 {
785 /* System is about to go into suspend mode; go back to ring 3. */
786 rc = VINF_EM_RAW_INTERRUPT;
787 }
788 pVCpu->vmm.s.iLastGZRc = rc;
789
790 ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
791#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
792 RTThreadPreemptRestore(&PreemptState);
793#elif !defined(RT_OS_WINDOWS)
794 ASMSetFlags(uFlags);
795#endif
796
797#ifdef VBOX_WITH_STATISTICS
798 vmmR0RecordRC(pVM, pVCpu, rc);
799#endif
800 /* No special action required for external interrupts, just return. */
801 break;
802 }
803
804 /*
805 * For profiling.
806 */
807 case VMMR0_DO_NOP:
808 pVCpu->vmm.s.iLastGZRc = VINF_SUCCESS;
809 break;
810
811 /*
812 * Impossible.
813 */
814 default:
815 AssertMsgFailed(("%#x\n", enmOperation));
816 pVCpu->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
817 break;
818 }
819}
820
821
822/**
823 * Validates a session or VM session argument.
824 *
825 * @returns true / false accordingly.
826 * @param pVM Pointer to the VM.
827 * @param pSession The session argument.
828 */
829DECLINLINE(bool) vmmR0IsValidSession(PVM pVM, PSUPDRVSESSION pClaimedSession, PSUPDRVSESSION pSession)
830{
831 /* This must be set! */
832 if (!pSession)
833 return false;
834
835 /* Only one out of the two. */
836 if (pVM && pClaimedSession)
837 return false;
838 if (pVM)
839 pClaimedSession = pVM->pSession;
840 return pClaimedSession == pSession;
841}
842
843
844/**
845 * VMMR0EntryEx worker function, either called directly or when ever possible
846 * called thru a longjmp so we can exit safely on failure.
847 *
848 * @returns VBox status code.
849 * @param pVM Pointer to the VM.
850 * @param idCpu Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
851 * is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
852 * @param enmOperation Which operation to execute.
853 * @param pReqHdr This points to a SUPVMMR0REQHDR packet. Optional.
854 * The support driver validates this if it's present.
855 * @param u64Arg Some simple constant argument.
856 * @param pSession The session of the caller.
857 * @remarks Assume called with interrupts _enabled_.
858 */
859static int vmmR0EntryExWorker(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReqHdr, uint64_t u64Arg, PSUPDRVSESSION pSession)
860{
861 /*
862 * Common VM pointer validation.
863 */
864 if (pVM)
865 {
866 if (RT_UNLIKELY( !VALID_PTR(pVM)
867 || ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
868 {
869 SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p! (op=%d)\n", pVM, enmOperation);
870 return VERR_INVALID_POINTER;
871 }
872 if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
873 || pVM->enmVMState > VMSTATE_TERMINATED
874 || pVM->pVMR0 != pVM))
875 {
876 SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{enmVMState=%d, .pVMR0=%p}! (op=%d)\n",
877 pVM, pVM->enmVMState, pVM->pVMR0, enmOperation);
878 return VERR_INVALID_POINTER;
879 }
880
881 if (RT_UNLIKELY(idCpu >= pVM->cCpus && idCpu != NIL_VMCPUID))
882 {
883 SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu (%u vs cCpus=%u)\n", idCpu, pVM->cCpus);
884 return VERR_INVALID_PARAMETER;
885 }
886 }
887 else if (RT_UNLIKELY(idCpu != NIL_VMCPUID))
888 {
889 SUPR0Printf("vmmR0EntryExWorker: Invalid idCpu=%u\n", idCpu);
890 return VERR_INVALID_PARAMETER;
891 }
892
893
894 switch (enmOperation)
895 {
896 /*
897 * GVM requests
898 */
899 case VMMR0_DO_GVMM_CREATE_VM:
900 if (pVM || u64Arg || idCpu != NIL_VMCPUID)
901 return VERR_INVALID_PARAMETER;
902 return GVMMR0CreateVMReq((PGVMMCREATEVMREQ)pReqHdr);
903
904 case VMMR0_DO_GVMM_DESTROY_VM:
905 if (pReqHdr || u64Arg)
906 return VERR_INVALID_PARAMETER;
907 return GVMMR0DestroyVM(pVM);
908
909 case VMMR0_DO_GVMM_REGISTER_VMCPU:
910 {
911 if (!pVM)
912 return VERR_INVALID_PARAMETER;
913 return GVMMR0RegisterVCpu(pVM, idCpu);
914 }
915
916 case VMMR0_DO_GVMM_SCHED_HALT:
917 if (pReqHdr)
918 return VERR_INVALID_PARAMETER;
919 return GVMMR0SchedHalt(pVM, idCpu, u64Arg);
920
921 case VMMR0_DO_GVMM_SCHED_WAKE_UP:
922 if (pReqHdr || u64Arg)
923 return VERR_INVALID_PARAMETER;
924 return GVMMR0SchedWakeUp(pVM, idCpu);
925
926 case VMMR0_DO_GVMM_SCHED_POKE:
927 if (pReqHdr || u64Arg)
928 return VERR_INVALID_PARAMETER;
929 return GVMMR0SchedPoke(pVM, idCpu);
930
931 case VMMR0_DO_GVMM_SCHED_WAKE_UP_AND_POKE_CPUS:
932 if (u64Arg)
933 return VERR_INVALID_PARAMETER;
934 return GVMMR0SchedWakeUpAndPokeCpusReq(pVM, (PGVMMSCHEDWAKEUPANDPOKECPUSREQ)pReqHdr);
935
936 case VMMR0_DO_GVMM_SCHED_POLL:
937 if (pReqHdr || u64Arg > 1)
938 return VERR_INVALID_PARAMETER;
939 return GVMMR0SchedPoll(pVM, idCpu, !!u64Arg);
940
941 case VMMR0_DO_GVMM_QUERY_STATISTICS:
942 if (u64Arg)
943 return VERR_INVALID_PARAMETER;
944 return GVMMR0QueryStatisticsReq(pVM, (PGVMMQUERYSTATISTICSSREQ)pReqHdr);
945
946 case VMMR0_DO_GVMM_RESET_STATISTICS:
947 if (u64Arg)
948 return VERR_INVALID_PARAMETER;
949 return GVMMR0ResetStatisticsReq(pVM, (PGVMMRESETSTATISTICSSREQ)pReqHdr);
950
951 /*
952 * Initialize the R0 part of a VM instance.
953 */
954 case VMMR0_DO_VMMR0_INIT:
955 return vmmR0InitVM(pVM, (uint32_t)u64Arg);
956
957 /*
958 * Terminate the R0 part of a VM instance.
959 */
960 case VMMR0_DO_VMMR0_TERM:
961 return VMMR0TermVM(pVM, NULL);
962
963 /*
964 * Attempt to enable hm mode and check the current setting.
965 */
966 case VMMR0_DO_HM_ENABLE:
967 return HMR0EnableAllCpus(pVM);
968
969 /*
970 * Setup the hardware accelerated session.
971 */
972 case VMMR0_DO_HM_SETUP_VM:
973 return HMR0SetupVM(pVM);
974
975 /*
976 * Switch to RC to execute Hypervisor function.
977 */
978 case VMMR0_DO_CALL_HYPERVISOR:
979 {
980 int rc;
981 bool fVTxDisabled;
982
983 /* Safety precaution as HM can disable the switcher. */
984 Assert(!pVM->vmm.s.fSwitcherDisabled);
985 if (RT_UNLIKELY(pVM->vmm.s.fSwitcherDisabled))
986 return VERR_NOT_SUPPORTED;
987
988#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
989 if (RT_UNLIKELY(!PGMGetHyperCR3(VMMGetCpu0(pVM))))
990 return VERR_PGM_NO_CR3_SHADOW_ROOT;
991#endif
992
993 RTCCUINTREG fFlags = ASMIntDisableFlags();
994
995#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
996 RTCPUID idHostCpu = RTMpCpuId();
997 CPUMR0SetLApic(pVM, idHostCpu);
998#endif
999
1000 /* We might need to disable VT-x if the active switcher turns off paging. */
1001 rc = HMR0EnterSwitcher(pVM, pVM->vmm.s.enmSwitcher, &fVTxDisabled);
1002 if (RT_FAILURE(rc))
1003 return rc;
1004
1005 rc = pVM->vmm.s.pfnR0ToRawMode(pVM);
1006
1007 /* Re-enable VT-x if previously turned off. */
1008 HMR0LeaveSwitcher(pVM, fVTxDisabled);
1009
1010 /** @todo dispatch interrupts? */
1011 ASMSetFlags(fFlags);
1012 return rc;
1013 }
1014
1015 /*
1016 * PGM wrappers.
1017 */
1018 case VMMR0_DO_PGM_ALLOCATE_HANDY_PAGES:
1019 if (idCpu == NIL_VMCPUID)
1020 return VERR_INVALID_CPU_ID;
1021 return PGMR0PhysAllocateHandyPages(pVM, &pVM->aCpus[idCpu]);
1022
1023 case VMMR0_DO_PGM_FLUSH_HANDY_PAGES:
1024 if (idCpu == NIL_VMCPUID)
1025 return VERR_INVALID_CPU_ID;
1026 return PGMR0PhysFlushHandyPages(pVM, &pVM->aCpus[idCpu]);
1027
1028 case VMMR0_DO_PGM_ALLOCATE_LARGE_HANDY_PAGE:
1029 if (idCpu == NIL_VMCPUID)
1030 return VERR_INVALID_CPU_ID;
1031 return PGMR0PhysAllocateLargeHandyPage(pVM, &pVM->aCpus[idCpu]);
1032
1033 case VMMR0_DO_PGM_PHYS_SETUP_IOMMU:
1034 if (idCpu != 0)
1035 return VERR_INVALID_CPU_ID;
1036 return PGMR0PhysSetupIommu(pVM);
1037
1038 /*
1039 * GMM wrappers.
1040 */
1041 case VMMR0_DO_GMM_INITIAL_RESERVATION:
1042 if (u64Arg)
1043 return VERR_INVALID_PARAMETER;
1044 return GMMR0InitialReservationReq(pVM, idCpu, (PGMMINITIALRESERVATIONREQ)pReqHdr);
1045
1046 case VMMR0_DO_GMM_UPDATE_RESERVATION:
1047 if (u64Arg)
1048 return VERR_INVALID_PARAMETER;
1049 return GMMR0UpdateReservationReq(pVM, idCpu, (PGMMUPDATERESERVATIONREQ)pReqHdr);
1050
1051 case VMMR0_DO_GMM_ALLOCATE_PAGES:
1052 if (u64Arg)
1053 return VERR_INVALID_PARAMETER;
1054 return GMMR0AllocatePagesReq(pVM, idCpu, (PGMMALLOCATEPAGESREQ)pReqHdr);
1055
1056 case VMMR0_DO_GMM_FREE_PAGES:
1057 if (u64Arg)
1058 return VERR_INVALID_PARAMETER;
1059 return GMMR0FreePagesReq(pVM, idCpu, (PGMMFREEPAGESREQ)pReqHdr);
1060
1061 case VMMR0_DO_GMM_FREE_LARGE_PAGE:
1062 if (u64Arg)
1063 return VERR_INVALID_PARAMETER;
1064 return GMMR0FreeLargePageReq(pVM, idCpu, (PGMMFREELARGEPAGEREQ)pReqHdr);
1065
1066 case VMMR0_DO_GMM_QUERY_HYPERVISOR_MEM_STATS:
1067 if (u64Arg)
1068 return VERR_INVALID_PARAMETER;
1069 return GMMR0QueryHypervisorMemoryStatsReq(pVM, (PGMMMEMSTATSREQ)pReqHdr);
1070
1071 case VMMR0_DO_GMM_QUERY_MEM_STATS:
1072 if (idCpu == NIL_VMCPUID)
1073 return VERR_INVALID_CPU_ID;
1074 if (u64Arg)
1075 return VERR_INVALID_PARAMETER;
1076 return GMMR0QueryMemoryStatsReq(pVM, idCpu, (PGMMMEMSTATSREQ)pReqHdr);
1077
1078 case VMMR0_DO_GMM_BALLOONED_PAGES:
1079 if (u64Arg)
1080 return VERR_INVALID_PARAMETER;
1081 return GMMR0BalloonedPagesReq(pVM, idCpu, (PGMMBALLOONEDPAGESREQ)pReqHdr);
1082
1083 case VMMR0_DO_GMM_MAP_UNMAP_CHUNK:
1084 if (u64Arg)
1085 return VERR_INVALID_PARAMETER;
1086 return GMMR0MapUnmapChunkReq(pVM, (PGMMMAPUNMAPCHUNKREQ)pReqHdr);
1087
1088 case VMMR0_DO_GMM_SEED_CHUNK:
1089 if (pReqHdr)
1090 return VERR_INVALID_PARAMETER;
1091 return GMMR0SeedChunk(pVM, idCpu, (RTR3PTR)u64Arg);
1092
1093 case VMMR0_DO_GMM_REGISTER_SHARED_MODULE:
1094 if (idCpu == NIL_VMCPUID)
1095 return VERR_INVALID_CPU_ID;
1096 if (u64Arg)
1097 return VERR_INVALID_PARAMETER;
1098 return GMMR0RegisterSharedModuleReq(pVM, idCpu, (PGMMREGISTERSHAREDMODULEREQ)pReqHdr);
1099
1100 case VMMR0_DO_GMM_UNREGISTER_SHARED_MODULE:
1101 if (idCpu == NIL_VMCPUID)
1102 return VERR_INVALID_CPU_ID;
1103 if (u64Arg)
1104 return VERR_INVALID_PARAMETER;
1105 return GMMR0UnregisterSharedModuleReq(pVM, idCpu, (PGMMUNREGISTERSHAREDMODULEREQ)pReqHdr);
1106
1107 case VMMR0_DO_GMM_RESET_SHARED_MODULES:
1108 if (idCpu == NIL_VMCPUID)
1109 return VERR_INVALID_CPU_ID;
1110 if ( u64Arg
1111 || pReqHdr)
1112 return VERR_INVALID_PARAMETER;
1113 return GMMR0ResetSharedModules(pVM, idCpu);
1114
1115#ifdef VBOX_WITH_PAGE_SHARING
1116 case VMMR0_DO_GMM_CHECK_SHARED_MODULES:
1117 {
1118 if (idCpu == NIL_VMCPUID)
1119 return VERR_INVALID_CPU_ID;
1120 if ( u64Arg
1121 || pReqHdr)
1122 return VERR_INVALID_PARAMETER;
1123
1124 PVMCPU pVCpu = &pVM->aCpus[idCpu];
1125 Assert(pVCpu->hNativeThreadR0 == RTThreadNativeSelf());
1126
1127# ifdef DEBUG_sandervl
1128 /* Make sure that log flushes can jump back to ring-3; annoying to get an incomplete log (this is risky though as the code doesn't take this into account). */
1129 /* Todo: this can have bad side effects for unexpected jumps back to r3. */
1130 int rc = GMMR0CheckSharedModulesStart(pVM);
1131 if (rc == VINF_SUCCESS)
1132 {
1133 rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, GMMR0CheckSharedModules, pVM, pVCpu); /* this may resume code. */
1134 Assert( rc == VINF_SUCCESS
1135 || (rc == VINF_VMM_CALL_HOST && pVCpu->vmm.s.enmCallRing3Operation == VMMCALLRING3_VMM_LOGGER_FLUSH));
1136 GMMR0CheckSharedModulesEnd(pVM);
1137 }
1138# else
1139 int rc = GMMR0CheckSharedModules(pVM, pVCpu);
1140# endif
1141 return rc;
1142 }
1143#endif
1144
1145#if defined(VBOX_STRICT) && HC_ARCH_BITS == 64
1146 case VMMR0_DO_GMM_FIND_DUPLICATE_PAGE:
1147 if (u64Arg)
1148 return VERR_INVALID_PARAMETER;
1149 return GMMR0FindDuplicatePageReq(pVM, (PGMMFINDDUPLICATEPAGEREQ)pReqHdr);
1150#endif
1151
1152 case VMMR0_DO_GMM_QUERY_STATISTICS:
1153 if (u64Arg)
1154 return VERR_INVALID_PARAMETER;
1155 return GMMR0QueryStatisticsReq(pVM, (PGMMQUERYSTATISTICSSREQ)pReqHdr);
1156
1157 case VMMR0_DO_GMM_RESET_STATISTICS:
1158 if (u64Arg)
1159 return VERR_INVALID_PARAMETER;
1160 return GMMR0ResetStatisticsReq(pVM, (PGMMRESETSTATISTICSSREQ)pReqHdr);
1161
1162 /*
1163 * A quick GCFGM mock-up.
1164 */
1165 /** @todo GCFGM with proper access control, ring-3 management interface and all that. */
1166 case VMMR0_DO_GCFGM_SET_VALUE:
1167 case VMMR0_DO_GCFGM_QUERY_VALUE:
1168 {
1169 if (pVM || !pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
1170 return VERR_INVALID_PARAMETER;
1171 PGCFGMVALUEREQ pReq = (PGCFGMVALUEREQ)pReqHdr;
1172 if (pReq->Hdr.cbReq != sizeof(*pReq))
1173 return VERR_INVALID_PARAMETER;
1174 int rc;
1175 if (enmOperation == VMMR0_DO_GCFGM_SET_VALUE)
1176 {
1177 rc = GVMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
1178 //if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1179 // rc = GMMR0SetConfig(pReq->pSession, &pReq->szName[0], pReq->u64Value);
1180 }
1181 else
1182 {
1183 rc = GVMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
1184 //if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1185 // rc = GMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
1186 }
1187 return rc;
1188 }
1189
1190 /*
1191 * PDM Wrappers.
1192 */
1193 case VMMR0_DO_PDM_DRIVER_CALL_REQ_HANDLER:
1194 {
1195 if (!pVM || !pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
1196 return VERR_INVALID_PARAMETER;
1197 return PDMR0DriverCallReqHandler(pVM, (PPDMDRIVERCALLREQHANDLERREQ)pReqHdr);
1198 }
1199
1200 case VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER:
1201 {
1202 if (!pVM || !pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
1203 return VERR_INVALID_PARAMETER;
1204 return PDMR0DeviceCallReqHandler(pVM, (PPDMDEVICECALLREQHANDLERREQ)pReqHdr);
1205 }
1206
1207 /*
1208 * Requests to the internal networking service.
1209 */
1210 case VMMR0_DO_INTNET_OPEN:
1211 {
1212 PINTNETOPENREQ pReq = (PINTNETOPENREQ)pReqHdr;
1213 if (u64Arg || !pReq || !vmmR0IsValidSession(pVM, pReq->pSession, pSession) || idCpu != NIL_VMCPUID)
1214 return VERR_INVALID_PARAMETER;
1215 return IntNetR0OpenReq(pSession, pReq);
1216 }
1217
1218 case VMMR0_DO_INTNET_IF_CLOSE:
1219 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFCLOSEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1220 return VERR_INVALID_PARAMETER;
1221 return IntNetR0IfCloseReq(pSession, (PINTNETIFCLOSEREQ)pReqHdr);
1222
1223 case VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS:
1224 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFGETBUFFERPTRSREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1225 return VERR_INVALID_PARAMETER;
1226 return IntNetR0IfGetBufferPtrsReq(pSession, (PINTNETIFGETBUFFERPTRSREQ)pReqHdr);
1227
1228 case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE:
1229 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1230 return VERR_INVALID_PARAMETER;
1231 return IntNetR0IfSetPromiscuousModeReq(pSession, (PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr);
1232
1233 case VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS:
1234 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETMACADDRESSREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1235 return VERR_INVALID_PARAMETER;
1236 return IntNetR0IfSetMacAddressReq(pSession, (PINTNETIFSETMACADDRESSREQ)pReqHdr);
1237
1238 case VMMR0_DO_INTNET_IF_SET_ACTIVE:
1239 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETACTIVEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1240 return VERR_INVALID_PARAMETER;
1241 return IntNetR0IfSetActiveReq(pSession, (PINTNETIFSETACTIVEREQ)pReqHdr);
1242
1243 case VMMR0_DO_INTNET_IF_SEND:
1244 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSENDREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1245 return VERR_INVALID_PARAMETER;
1246 return IntNetR0IfSendReq(pSession, (PINTNETIFSENDREQ)pReqHdr);
1247
1248 case VMMR0_DO_INTNET_IF_WAIT:
1249 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1250 return VERR_INVALID_PARAMETER;
1251 return IntNetR0IfWaitReq(pSession, (PINTNETIFWAITREQ)pReqHdr);
1252
1253 case VMMR0_DO_INTNET_IF_ABORT_WAIT:
1254 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1255 return VERR_INVALID_PARAMETER;
1256 return IntNetR0IfAbortWaitReq(pSession, (PINTNETIFABORTWAITREQ)pReqHdr);
1257
1258#ifdef VBOX_WITH_PCI_PASSTHROUGH
1259 /*
1260 * Requests to host PCI driver service.
1261 */
1262 case VMMR0_DO_PCIRAW_REQ:
1263 if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PPCIRAWSENDREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
1264 return VERR_INVALID_PARAMETER;
1265 return PciRawR0ProcessReq(pSession, pVM, (PPCIRAWSENDREQ)pReqHdr);
1266#endif
1267 /*
1268 * For profiling.
1269 */
1270 case VMMR0_DO_NOP:
1271 case VMMR0_DO_SLOW_NOP:
1272 return VINF_SUCCESS;
1273
1274 /*
1275 * For testing Ring-0 APIs invoked in this environment.
1276 */
1277 case VMMR0_DO_TESTS:
1278 /** @todo make new test */
1279 return VINF_SUCCESS;
1280
1281
1282#if HC_ARCH_BITS == 32 && defined(VBOX_WITH_64_BITS_GUESTS) && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL)
1283 case VMMR0_DO_TEST_SWITCHER3264:
1284 if (idCpu == NIL_VMCPUID)
1285 return VERR_INVALID_CPU_ID;
1286 return HMR0TestSwitcher3264(pVM);
1287#endif
1288 default:
1289 /*
1290 * We're returning VERR_NOT_SUPPORT here so we've got something else
1291 * than -1 which the interrupt gate glue code might return.
1292 */
1293 Log(("operation %#x is not supported\n", enmOperation));
1294 return VERR_NOT_SUPPORTED;
1295 }
1296}
1297
1298
1299/**
1300 * Argument for vmmR0EntryExWrapper containing the arguments for VMMR0EntryEx.
1301 */
1302typedef struct VMMR0ENTRYEXARGS
1303{
1304 PVM pVM;
1305 VMCPUID idCpu;
1306 VMMR0OPERATION enmOperation;
1307 PSUPVMMR0REQHDR pReq;
1308 uint64_t u64Arg;
1309 PSUPDRVSESSION pSession;
1310} VMMR0ENTRYEXARGS;
1311/** Pointer to a vmmR0EntryExWrapper argument package. */
1312typedef VMMR0ENTRYEXARGS *PVMMR0ENTRYEXARGS;
1313
1314/**
1315 * This is just a longjmp wrapper function for VMMR0EntryEx calls.
1316 *
1317 * @returns VBox status code.
1318 * @param pvArgs The argument package
1319 */
1320static DECLCALLBACK(int) vmmR0EntryExWrapper(void *pvArgs)
1321{
1322 return vmmR0EntryExWorker(((PVMMR0ENTRYEXARGS)pvArgs)->pVM,
1323 ((PVMMR0ENTRYEXARGS)pvArgs)->idCpu,
1324 ((PVMMR0ENTRYEXARGS)pvArgs)->enmOperation,
1325 ((PVMMR0ENTRYEXARGS)pvArgs)->pReq,
1326 ((PVMMR0ENTRYEXARGS)pvArgs)->u64Arg,
1327 ((PVMMR0ENTRYEXARGS)pvArgs)->pSession);
1328}
1329
1330
1331/**
1332 * The Ring 0 entry point, called by the support library (SUP).
1333 *
1334 * @returns VBox status code.
1335 * @param pVM Pointer to the VM.
1336 * @param idCpu Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
1337 * is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
1338 * @param enmOperation Which operation to execute.
1339 * @param pReq Pointer to the SUPVMMR0REQHDR packet. Optional.
1340 * @param u64Arg Some simple constant argument.
1341 * @param pSession The session of the caller.
1342 * @remarks Assume called with interrupts _enabled_.
1343 */
1344VMMR0DECL(int) VMMR0EntryEx(PVM pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation, PSUPVMMR0REQHDR pReq, uint64_t u64Arg, PSUPDRVSESSION pSession)
1345{
1346 /*
1347 * Requests that should only happen on the EMT thread will be
1348 * wrapped in a setjmp so we can assert without causing trouble.
1349 */
1350 if ( VALID_PTR(pVM)
1351 && pVM->pVMR0
1352 && idCpu < pVM->cCpus)
1353 {
1354 switch (enmOperation)
1355 {
1356 /* These might/will be called before VMMR3Init. */
1357 case VMMR0_DO_GMM_INITIAL_RESERVATION:
1358 case VMMR0_DO_GMM_UPDATE_RESERVATION:
1359 case VMMR0_DO_GMM_ALLOCATE_PAGES:
1360 case VMMR0_DO_GMM_FREE_PAGES:
1361 case VMMR0_DO_GMM_BALLOONED_PAGES:
1362 /* On the mac we might not have a valid jmp buf, so check these as well. */
1363 case VMMR0_DO_VMMR0_INIT:
1364 case VMMR0_DO_VMMR0_TERM:
1365 {
1366 PVMCPU pVCpu = &pVM->aCpus[idCpu];
1367
1368 if (!pVCpu->vmm.s.CallRing3JmpBufR0.pvSavedStack)
1369 break;
1370
1371 /** @todo validate this EMT claim... GVM knows. */
1372 VMMR0ENTRYEXARGS Args;
1373 Args.pVM = pVM;
1374 Args.idCpu = idCpu;
1375 Args.enmOperation = enmOperation;
1376 Args.pReq = pReq;
1377 Args.u64Arg = u64Arg;
1378 Args.pSession = pSession;
1379 return vmmR0CallRing3SetJmpEx(&pVCpu->vmm.s.CallRing3JmpBufR0, vmmR0EntryExWrapper, &Args);
1380 }
1381
1382 default:
1383 break;
1384 }
1385 }
1386 return vmmR0EntryExWorker(pVM, idCpu, enmOperation, pReq, u64Arg, pSession);
1387}
1388
1389/**
1390 * Internal R0 logger worker: Flush logger.
1391 *
1392 * @param pLogger The logger instance to flush.
1393 * @remark This function must be exported!
1394 */
1395VMMR0DECL(void) vmmR0LoggerFlush(PRTLOGGER pLogger)
1396{
1397#ifdef LOG_ENABLED
1398 /*
1399 * Convert the pLogger into a VM handle and 'call' back to Ring-3.
1400 * (This is a bit paranoid code.)
1401 */
1402 PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1403 if ( !VALID_PTR(pR0Logger)
1404 || !VALID_PTR(pR0Logger + 1)
1405 || pLogger->u32Magic != RTLOGGER_MAGIC)
1406 {
1407# ifdef DEBUG
1408 SUPR0Printf("vmmR0LoggerFlush: pLogger=%p!\n", pLogger);
1409# endif
1410 return;
1411 }
1412 if (pR0Logger->fFlushingDisabled)
1413 return; /* quietly */
1414
1415 PVM pVM = pR0Logger->pVM;
1416 if ( !VALID_PTR(pVM)
1417 || pVM->pVMR0 != pVM)
1418 {
1419# ifdef DEBUG
1420 SUPR0Printf("vmmR0LoggerFlush: pVM=%p! pVMR0=%p! pLogger=%p\n", pVM, pVM->pVMR0, pLogger);
1421# endif
1422 return;
1423 }
1424
1425 PVMCPU pVCpu = VMMGetCpu(pVM);
1426 if (pVCpu)
1427 {
1428 /*
1429 * Check that the jump buffer is armed.
1430 */
1431# ifdef RT_ARCH_X86
1432 if ( !pVCpu->vmm.s.CallRing3JmpBufR0.eip
1433 || pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1434# else
1435 if ( !pVCpu->vmm.s.CallRing3JmpBufR0.rip
1436 || pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1437# endif
1438 {
1439# ifdef DEBUG
1440 SUPR0Printf("vmmR0LoggerFlush: Jump buffer isn't armed!\n");
1441# endif
1442 return;
1443 }
1444 VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VMM_LOGGER_FLUSH, 0);
1445 }
1446# ifdef DEBUG
1447 else
1448 SUPR0Printf("vmmR0LoggerFlush: invalid VCPU context!\n");
1449# endif
1450#endif
1451}
1452
1453/**
1454 * Internal R0 logger worker: Custom prefix.
1455 *
1456 * @returns Number of chars written.
1457 *
1458 * @param pLogger The logger instance.
1459 * @param pchBuf The output buffer.
1460 * @param cchBuf The size of the buffer.
1461 * @param pvUser User argument (ignored).
1462 */
1463VMMR0DECL(size_t) vmmR0LoggerPrefix(PRTLOGGER pLogger, char *pchBuf, size_t cchBuf, void *pvUser)
1464{
1465 NOREF(pvUser);
1466#ifdef LOG_ENABLED
1467 PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
1468 if ( !VALID_PTR(pR0Logger)
1469 || !VALID_PTR(pR0Logger + 1)
1470 || pLogger->u32Magic != RTLOGGER_MAGIC
1471 || cchBuf < 2)
1472 return 0;
1473
1474 static const char s_szHex[17] = "0123456789abcdef";
1475 VMCPUID const idCpu = pR0Logger->idCpu;
1476 pchBuf[1] = s_szHex[ idCpu & 15];
1477 pchBuf[0] = s_szHex[(idCpu >> 4) & 15];
1478
1479 return 2;
1480#else
1481 return 0;
1482#endif
1483}
1484
1485#ifdef LOG_ENABLED
1486
1487/**
1488 * Disables flushing of the ring-0 debug log.
1489 *
1490 * @param pVCpu Pointer to the VMCPU.
1491 */
1492VMMR0DECL(void) VMMR0LogFlushDisable(PVMCPU pVCpu)
1493{
1494 if (pVCpu->vmm.s.pR0LoggerR0)
1495 pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = true;
1496}
1497
1498
1499/**
1500 * Enables flushing of the ring-0 debug log.
1501 *
1502 * @param pVCpu Pointer to the VMCPU.
1503 */
1504VMMR0DECL(void) VMMR0LogFlushEnable(PVMCPU pVCpu)
1505{
1506 if (pVCpu->vmm.s.pR0LoggerR0)
1507 pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = false;
1508}
1509
1510
1511/**
1512 * Checks if log flushing is disabled or not.
1513 *
1514 * @param pVCpu Pointer to the VMCPU.
1515 */
1516VMMR0DECL(bool) VMMR0IsLogFlushDisabled(PVMCPU pVCpu)
1517{
1518 if (pVCpu->vmm.s.pR0LoggerR0)
1519 return pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled;
1520 return true;
1521}
1522#endif /* LOG_ENABLED */
1523
1524/**
1525 * Jump back to ring-3 if we're the EMT and the longjmp is armed.
1526 *
1527 * @returns true if the breakpoint should be hit, false if it should be ignored.
1528 */
1529DECLEXPORT(bool) RTCALL RTAssertShouldPanic(void)
1530{
1531#if 0
1532 return true;
1533#else
1534 PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1535 if (pVM)
1536 {
1537 PVMCPU pVCpu = VMMGetCpu(pVM);
1538
1539 if (pVCpu)
1540 {
1541#ifdef RT_ARCH_X86
1542 if ( pVCpu->vmm.s.CallRing3JmpBufR0.eip
1543 && !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1544#else
1545 if ( pVCpu->vmm.s.CallRing3JmpBufR0.rip
1546 && !pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
1547#endif
1548 {
1549 int rc = VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VM_R0_ASSERTION, 0);
1550 return RT_FAILURE_NP(rc);
1551 }
1552 }
1553 }
1554#ifdef RT_OS_LINUX
1555 return true;
1556#else
1557 return false;
1558#endif
1559#endif
1560}
1561
1562
1563/**
1564 * Override this so we can push it up to ring-3.
1565 *
1566 * @param pszExpr Expression. Can be NULL.
1567 * @param uLine Location line number.
1568 * @param pszFile Location file name.
1569 * @param pszFunction Location function name.
1570 */
1571DECLEXPORT(void) RTCALL RTAssertMsg1Weak(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction)
1572{
1573 /*
1574 * To the log.
1575 */
1576 LogAlways(("\n!!R0-Assertion Failed!!\n"
1577 "Expression: %s\n"
1578 "Location : %s(%d) %s\n",
1579 pszExpr, pszFile, uLine, pszFunction));
1580
1581 /*
1582 * To the global VMM buffer.
1583 */
1584 PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1585 if (pVM)
1586 RTStrPrintf(pVM->vmm.s.szRing0AssertMsg1, sizeof(pVM->vmm.s.szRing0AssertMsg1),
1587 "\n!!R0-Assertion Failed!!\n"
1588 "Expression: %s\n"
1589 "Location : %s(%d) %s\n",
1590 pszExpr, pszFile, uLine, pszFunction);
1591
1592 /*
1593 * Continue the normal way.
1594 */
1595 RTAssertMsg1(pszExpr, uLine, pszFile, pszFunction);
1596}
1597
1598
1599/**
1600 * Callback for RTLogFormatV which writes to the ring-3 log port.
1601 * See PFNLOGOUTPUT() for details.
1602 */
1603static DECLCALLBACK(size_t) rtLogOutput(void *pv, const char *pachChars, size_t cbChars)
1604{
1605 for (size_t i = 0; i < cbChars; i++)
1606 LogAlways(("%c", pachChars[i]));
1607
1608 NOREF(pv);
1609 return cbChars;
1610}
1611
1612
1613/**
1614 * Override this so we can push it up to ring-3.
1615 *
1616 * @param pszFormat The format string.
1617 * @param va Arguments.
1618 */
1619DECLEXPORT(void) RTCALL RTAssertMsg2WeakV(const char *pszFormat, va_list va)
1620{
1621 va_list vaCopy;
1622
1623 /*
1624 * Push the message to the logger.
1625 */
1626 PRTLOGGER pLog = RTLogDefaultInstance(); /** @todo we want this for release as well! */
1627 if (pLog)
1628 {
1629 va_copy(vaCopy, va);
1630 RTLogFormatV(rtLogOutput, pLog, pszFormat, vaCopy);
1631 va_end(vaCopy);
1632 }
1633
1634 /*
1635 * Push it to the global VMM buffer.
1636 */
1637 PVM pVM = GVMMR0GetVMByEMT(NIL_RTNATIVETHREAD);
1638 if (pVM)
1639 {
1640 va_copy(vaCopy, va);
1641 RTStrPrintfV(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2), pszFormat, vaCopy);
1642 va_end(vaCopy);
1643 }
1644
1645 /*
1646 * Continue the normal way.
1647 */
1648 RTAssertMsg2V(pszFormat, va);
1649}
1650
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