VirtualBox

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

Last change on this file since 31407 was 31407, checked in by vboxsync, 14 years ago

VMMR0: Set VMCPU::hNativeThreadR0 in GVMMR0CreateVM and GVMMR0RegisterVCpu.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 68.7 KB
Line 
1/* $Id: GVMMR0.cpp 31407 2010-08-05 13:36:39Z vboxsync $ */
2/** @file
3 * GVMM - Global VM Manager.
4 */
5
6/*
7 * Copyright (C) 2007 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/** @page pg_gvmm GVMM - The Global VM Manager
20 *
21 * The Global VM Manager lives in ring-0. It's main function at the moment
22 * is to manage a list of all running VMs, keep a ring-0 only structure (GVM)
23 * for each of them, and assign them unique identifiers (so GMM can track
24 * page owners). The idea for the future is to add an idle priority kernel
25 * thread that can take care of tasks like page sharing.
26 *
27 * The GVMM will create a ring-0 object for each VM when it's registered,
28 * this is both for session cleanup purposes and for having a point where
29 * it's possible to implement usage polices later (in SUPR0ObjRegister).
30 */
31
32
33/*******************************************************************************
34* Header Files *
35*******************************************************************************/
36#define LOG_GROUP LOG_GROUP_GVMM
37#include <VBox/gvmm.h>
38#include <VBox/gmm.h>
39#include "GVMMR0Internal.h"
40#include <VBox/gvm.h>
41#include <VBox/vm.h>
42#include <VBox/vmm.h>
43#include <VBox/param.h>
44#include <VBox/err.h>
45#include <iprt/asm.h>
46#include <iprt/asm-amd64-x86.h>
47#include <iprt/mem.h>
48#include <iprt/semaphore.h>
49#include <iprt/time.h>
50#include <VBox/log.h>
51#include <iprt/thread.h>
52#include <iprt/process.h>
53#include <iprt/param.h>
54#include <iprt/string.h>
55#include <iprt/assert.h>
56#include <iprt/mem.h>
57#include <iprt/memobj.h>
58#include <iprt/mp.h>
59
60
61/*******************************************************************************
62* Structures and Typedefs *
63*******************************************************************************/
64
65/**
66 * Global VM handle.
67 */
68typedef struct GVMHANDLE
69{
70 /** The index of the next handle in the list (free or used). (0 is nil.) */
71 uint16_t volatile iNext;
72 /** Our own index / handle value. */
73 uint16_t iSelf;
74 /** The pointer to the ring-0 only (aka global) VM structure. */
75 PGVM pGVM;
76 /** The ring-0 mapping of the shared VM instance data. */
77 PVM pVM;
78 /** The virtual machine object. */
79 void *pvObj;
80 /** The session this VM is associated with. */
81 PSUPDRVSESSION pSession;
82 /** The ring-0 handle of the EMT0 thread.
83 * This is used for ownership checks as well as looking up a VM handle by thread
84 * at times like assertions. */
85 RTNATIVETHREAD hEMT0;
86 /** The process ID of the handle owner.
87 * This is used for access checks. */
88 RTPROCESS ProcId;
89} GVMHANDLE;
90/** Pointer to a global VM handle. */
91typedef GVMHANDLE *PGVMHANDLE;
92
93/** Number of GVM handles (including the NIL handle). */
94#if HC_ARCH_BITS == 64
95# define GVMM_MAX_HANDLES 1024
96#else
97# define GVMM_MAX_HANDLES 128
98#endif
99
100/**
101 * The GVMM instance data.
102 */
103typedef struct GVMM
104{
105 /** Eyecatcher / magic. */
106 uint32_t u32Magic;
107 /** The index of the head of the free handle chain. (0 is nil.) */
108 uint16_t volatile iFreeHead;
109 /** The index of the head of the active handle chain. (0 is nil.) */
110 uint16_t volatile iUsedHead;
111 /** The number of VMs. */
112 uint16_t volatile cVMs;
113// /** The number of halted EMT threads. */
114// uint16_t volatile cHaltedEMTs;
115 /** The number of EMTs. */
116 uint32_t volatile cEMTs;
117 /** The lock used to serialize VM creation, destruction and associated events that
118 * isn't performance critical. Owners may acquire the list lock. */
119 RTSEMFASTMUTEX CreateDestroyLock;
120 /** The lock used to serialize used list updates and accesses.
121 * This indirectly includes scheduling since the scheduler will have to walk the
122 * used list to examin running VMs. Owners may not acquire any other locks. */
123 RTSEMFASTMUTEX UsedLock;
124 /** The handle array.
125 * The size of this array defines the maximum number of currently running VMs.
126 * The first entry is unused as it represents the NIL handle. */
127 GVMHANDLE aHandles[GVMM_MAX_HANDLES];
128
129 /** @gcfgm{/GVMM/cEMTsMeansCompany, 32-bit, 0, UINT32_MAX, 1}
130 * The number of EMTs that means we no longer consider ourselves alone on a
131 * CPU/Core.
132 */
133 uint32_t cEMTsMeansCompany;
134 /** @gcfgm{/GVMM/MinSleepAlone,32-bit, 0, 100000000, 750000, ns}
135 * The minimum sleep time for when we're alone, in nano seconds.
136 */
137 uint32_t nsMinSleepAlone;
138 /** @gcfgm{/GVMM/MinSleepCompany,32-bit,0, 100000000, 15000, ns}
139 * The minimum sleep time for when we've got company, in nano seconds.
140 */
141 uint32_t nsMinSleepCompany;
142 /** @gcfgm{/GVMM/EarlyWakeUp1, 32-bit, 0, 100000000, 25000, ns}
143 * The limit for the first round of early wakeups, given in nano seconds.
144 */
145 uint32_t nsEarlyWakeUp1;
146 /** @gcfgm{/GVMM/EarlyWakeUp2, 32-bit, 0, 100000000, 50000, ns}
147 * The limit for the second round of early wakeups, given in nano seconds.
148 */
149 uint32_t nsEarlyWakeUp2;
150} GVMM;
151/** Pointer to the GVMM instance data. */
152typedef GVMM *PGVMM;
153
154/** The GVMM::u32Magic value (Charlie Haden). */
155#define GVMM_MAGIC 0x19370806
156
157
158
159/*******************************************************************************
160* Global Variables *
161*******************************************************************************/
162/** Pointer to the GVMM instance data.
163 * (Just my general dislike for global variables.) */
164static PGVMM g_pGVMM = NULL;
165
166/** Macro for obtaining and validating the g_pGVMM pointer.
167 * On failure it will return from the invoking function with the specified return value.
168 *
169 * @param pGVMM The name of the pGVMM variable.
170 * @param rc The return value on failure. Use VERR_INTERNAL_ERROR for
171 * VBox status codes.
172 */
173#define GVMM_GET_VALID_INSTANCE(pGVMM, rc) \
174 do { \
175 (pGVMM) = g_pGVMM;\
176 AssertPtrReturn((pGVMM), (rc)); \
177 AssertMsgReturn((pGVMM)->u32Magic == GVMM_MAGIC, ("%p - %#x\n", (pGVMM), (pGVMM)->u32Magic), (rc)); \
178 } while (0)
179
180/** Macro for obtaining and validating the g_pGVMM pointer, void function variant.
181 * On failure it will return from the invoking function.
182 *
183 * @param pGVMM The name of the pGVMM variable.
184 */
185#define GVMM_GET_VALID_INSTANCE_VOID(pGVMM) \
186 do { \
187 (pGVMM) = g_pGVMM;\
188 AssertPtrReturnVoid((pGVMM)); \
189 AssertMsgReturnVoid((pGVMM)->u32Magic == GVMM_MAGIC, ("%p - %#x\n", (pGVMM), (pGVMM)->u32Magic)); \
190 } while (0)
191
192
193/*******************************************************************************
194* Internal Functions *
195*******************************************************************************/
196static void gvmmR0InitPerVMData(PGVM pGVM);
197static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void *pvObj, void *pvGVMM, void *pvHandle);
198static int gvmmR0ByVM(PVM pVM, PGVM *ppGVM, PGVMM *ppGVMM, bool fTakeUsedLock);
199static int gvmmR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM *ppGVM, PGVMM *ppGVMM);
200
201
202/**
203 * Initializes the GVMM.
204 *
205 * This is called while owninng the loader sempahore (see supdrvIOCtl_LdrLoad()).
206 *
207 * @returns VBox status code.
208 */
209GVMMR0DECL(int) GVMMR0Init(void)
210{
211 LogFlow(("GVMMR0Init:\n"));
212
213 /*
214 * Allocate and initialize the instance data.
215 */
216 PGVMM pGVMM = (PGVMM)RTMemAllocZ(sizeof(*pGVMM));
217 if (!pGVMM)
218 return VERR_NO_MEMORY;
219 int rc = RTSemFastMutexCreate(&pGVMM->CreateDestroyLock);
220 if (RT_SUCCESS(rc))
221 {
222 rc = RTSemFastMutexCreate(&pGVMM->UsedLock);
223 if (RT_SUCCESS(rc))
224 {
225 pGVMM->u32Magic = GVMM_MAGIC;
226 pGVMM->iUsedHead = 0;
227 pGVMM->iFreeHead = 1;
228
229 /* the nil handle */
230 pGVMM->aHandles[0].iSelf = 0;
231 pGVMM->aHandles[0].iNext = 0;
232
233 /* the tail */
234 unsigned i = RT_ELEMENTS(pGVMM->aHandles) - 1;
235 pGVMM->aHandles[i].iSelf = i;
236 pGVMM->aHandles[i].iNext = 0; /* nil */
237
238 /* the rest */
239 while (i-- > 1)
240 {
241 pGVMM->aHandles[i].iSelf = i;
242 pGVMM->aHandles[i].iNext = i + 1;
243 }
244
245 /* The default configuration values. */
246 pGVMM->cEMTsMeansCompany = 1; /** @todo should be adjusted to relative to the cpu count or something... */
247 pGVMM->nsMinSleepAlone = 750000 /* ns (0.750 ms) */; /** @todo this should be adjusted to be 75% (or something) of the scheduler granularity... */
248 pGVMM->nsMinSleepCompany = 15000 /* ns (0.015 ms) */;
249 pGVMM->nsEarlyWakeUp1 = 25000 /* ns (0.025 ms) */;
250 pGVMM->nsEarlyWakeUp2 = 50000 /* ns (0.050 ms) */;
251
252 g_pGVMM = pGVMM;
253 LogFlow(("GVMMR0Init: pGVMM=%p\n", pGVMM));
254 return VINF_SUCCESS;
255 }
256
257 RTSemFastMutexDestroy(pGVMM->CreateDestroyLock);
258 }
259
260 RTMemFree(pGVMM);
261 return rc;
262}
263
264
265/**
266 * Terminates the GVM.
267 *
268 * This is called while owning the loader semaphore (see supdrvLdrFree()).
269 * And unless something is wrong, there should be absolutely no VMs
270 * registered at this point.
271 */
272GVMMR0DECL(void) GVMMR0Term(void)
273{
274 LogFlow(("GVMMR0Term:\n"));
275
276 PGVMM pGVMM = g_pGVMM;
277 g_pGVMM = NULL;
278 if (RT_UNLIKELY(!VALID_PTR(pGVMM)))
279 {
280 SUPR0Printf("GVMMR0Term: pGVMM=%p\n", pGVMM);
281 return;
282 }
283
284 pGVMM->u32Magic++;
285
286 RTSemFastMutexDestroy(pGVMM->UsedLock);
287 pGVMM->UsedLock = NIL_RTSEMFASTMUTEX;
288 RTSemFastMutexDestroy(pGVMM->CreateDestroyLock);
289 pGVMM->CreateDestroyLock = NIL_RTSEMFASTMUTEX;
290
291 pGVMM->iFreeHead = 0;
292 if (pGVMM->iUsedHead)
293 {
294 SUPR0Printf("GVMMR0Term: iUsedHead=%#x! (cVMs=%#x cEMTs=%#x)\n", pGVMM->iUsedHead, pGVMM->cVMs, pGVMM->cEMTs);
295 pGVMM->iUsedHead = 0;
296 }
297
298 RTMemFree(pGVMM);
299}
300
301
302/**
303 * A quick hack for setting global config values.
304 *
305 * @returns VBox status code.
306 *
307 * @param pSession The session handle. Used for authentication.
308 * @param pszName The variable name.
309 * @param u64Value The new value.
310 */
311GVMMR0DECL(int) GVMMR0SetConfig(PSUPDRVSESSION pSession, const char *pszName, uint64_t u64Value)
312{
313 /*
314 * Validate input.
315 */
316 PGVMM pGVMM;
317 GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
318 AssertPtrReturn(pSession, VERR_INVALID_HANDLE);
319 AssertPtrReturn(pszName, VERR_INVALID_POINTER);
320
321 /*
322 * String switch time!
323 */
324 if (strncmp(pszName, "/GVMM/", sizeof("/GVMM/") - 1))
325 return VERR_CFGM_VALUE_NOT_FOUND; /* borrow status codes from CFGM... */
326 int rc = VINF_SUCCESS;
327 pszName += sizeof("/GVMM/") - 1;
328 if (!strcmp(pszName, "cEMTsMeansCompany"))
329 {
330 if (u64Value <= UINT32_MAX)
331 pGVMM->cEMTsMeansCompany = u64Value;
332 else
333 rc = VERR_OUT_OF_RANGE;
334 }
335 else if (!strcmp(pszName, "MinSleepAlone"))
336 {
337 if (u64Value <= 100000000)
338 pGVMM->nsMinSleepAlone = u64Value;
339 else
340 rc = VERR_OUT_OF_RANGE;
341 }
342 else if (!strcmp(pszName, "MinSleepCompany"))
343 {
344 if (u64Value <= 100000000)
345 pGVMM->nsMinSleepCompany = u64Value;
346 else
347 rc = VERR_OUT_OF_RANGE;
348 }
349 else if (!strcmp(pszName, "EarlyWakeUp1"))
350 {
351 if (u64Value <= 100000000)
352 pGVMM->nsEarlyWakeUp1 = u64Value;
353 else
354 rc = VERR_OUT_OF_RANGE;
355 }
356 else if (!strcmp(pszName, "EarlyWakeUp2"))
357 {
358 if (u64Value <= 100000000)
359 pGVMM->nsEarlyWakeUp2 = u64Value;
360 else
361 rc = VERR_OUT_OF_RANGE;
362 }
363 else
364 rc = VERR_CFGM_VALUE_NOT_FOUND;
365 return rc;
366}
367
368
369/**
370 * A quick hack for getting global config values.
371 *
372 * @returns VBox status code.
373 *
374 * @param pSession The session handle. Used for authentication.
375 * @param pszName The variable name.
376 * @param u64Value The new value.
377 */
378GVMMR0DECL(int) GVMMR0QueryConfig(PSUPDRVSESSION pSession, const char *pszName, uint64_t *pu64Value)
379{
380 /*
381 * Validate input.
382 */
383 PGVMM pGVMM;
384 GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
385 AssertPtrReturn(pSession, VERR_INVALID_HANDLE);
386 AssertPtrReturn(pszName, VERR_INVALID_POINTER);
387 AssertPtrReturn(pu64Value, VERR_INVALID_POINTER);
388
389 /*
390 * String switch time!
391 */
392 if (strncmp(pszName, "/GVMM/", sizeof("/GVMM/") - 1))
393 return VERR_CFGM_VALUE_NOT_FOUND; /* borrow status codes from CFGM... */
394 int rc = VINF_SUCCESS;
395 pszName += sizeof("/GVMM/") - 1;
396 if (!strcmp(pszName, "cEMTsMeansCompany"))
397 *pu64Value = pGVMM->cEMTsMeansCompany;
398 else if (!strcmp(pszName, "MinSleepAlone"))
399 *pu64Value = pGVMM->nsMinSleepAlone;
400 else if (!strcmp(pszName, "MinSleepCompany"))
401 *pu64Value = pGVMM->nsMinSleepCompany;
402 else if (!strcmp(pszName, "EarlyWakeUp1"))
403 *pu64Value = pGVMM->nsEarlyWakeUp1;
404 else if (!strcmp(pszName, "EarlyWakeUp2"))
405 *pu64Value = pGVMM->nsEarlyWakeUp2;
406 else
407 rc = VERR_CFGM_VALUE_NOT_FOUND;
408 return rc;
409}
410
411
412/**
413 * Try acquire the 'used' lock.
414 *
415 * @returns IPRT status code, see RTSemFastMutexRequest.
416 * @param pGVMM The GVMM instance data.
417 */
418DECLINLINE(int) gvmmR0UsedLock(PGVMM pGVMM)
419{
420 LogFlow(("++gvmmR0UsedLock(%p)\n", pGVMM));
421 int rc = RTSemFastMutexRequest(pGVMM->UsedLock);
422 LogFlow(("gvmmR0UsedLock(%p)->%Rrc\n", pGVMM, rc));
423 return rc;
424}
425
426
427/**
428 * Release the 'used' lock.
429 *
430 * @returns IPRT status code, see RTSemFastMutexRelease.
431 * @param pGVMM The GVMM instance data.
432 */
433DECLINLINE(int) gvmmR0UsedUnlock(PGVMM pGVMM)
434{
435 LogFlow(("--gvmmR0UsedUnlock(%p)\n", pGVMM));
436 int rc = RTSemFastMutexRelease(pGVMM->UsedLock);
437 AssertRC(rc);
438 return rc;
439}
440
441
442/**
443 * Try acquire the 'create & destroy' lock.
444 *
445 * @returns IPRT status code, see RTSemFastMutexRequest.
446 * @param pGVMM The GVMM instance data.
447 */
448DECLINLINE(int) gvmmR0CreateDestroyLock(PGVMM pGVMM)
449{
450 LogFlow(("++gvmmR0CreateDestroyLock(%p)\n", pGVMM));
451 int rc = RTSemFastMutexRequest(pGVMM->CreateDestroyLock);
452 LogFlow(("gvmmR0CreateDestroyLock(%p)->%Rrc\n", pGVMM, rc));
453 return rc;
454}
455
456
457/**
458 * Release the 'create & destroy' lock.
459 *
460 * @returns IPRT status code, see RTSemFastMutexRequest.
461 * @param pGVMM The GVMM instance data.
462 */
463DECLINLINE(int) gvmmR0CreateDestroyUnlock(PGVMM pGVMM)
464{
465 LogFlow(("--gvmmR0CreateDestroyUnlock(%p)\n", pGVMM));
466 int rc = RTSemFastMutexRelease(pGVMM->CreateDestroyLock);
467 AssertRC(rc);
468 return rc;
469}
470
471
472/**
473 * Request wrapper for the GVMMR0CreateVM API.
474 *
475 * @returns VBox status code.
476 * @param pReq The request buffer.
477 */
478GVMMR0DECL(int) GVMMR0CreateVMReq(PGVMMCREATEVMREQ pReq)
479{
480 /*
481 * Validate the request.
482 */
483 if (!VALID_PTR(pReq))
484 return VERR_INVALID_POINTER;
485 if (pReq->Hdr.cbReq != sizeof(*pReq))
486 return VERR_INVALID_PARAMETER;
487 if (!VALID_PTR(pReq->pSession))
488 return VERR_INVALID_POINTER;
489
490 /*
491 * Execute it.
492 */
493 PVM pVM;
494 pReq->pVMR0 = NULL;
495 pReq->pVMR3 = NIL_RTR3PTR;
496 int rc = GVMMR0CreateVM(pReq->pSession, pReq->cCpus, &pVM);
497 if (RT_SUCCESS(rc))
498 {
499 pReq->pVMR0 = pVM;
500 pReq->pVMR3 = pVM->pVMR3;
501 }
502 return rc;
503}
504
505
506/**
507 * Allocates the VM structure and registers it with GVM.
508 *
509 * The caller will become the VM owner and there by the EMT.
510 *
511 * @returns VBox status code.
512 * @param pSession The support driver session.
513 * @param cCpus Number of virtual CPUs for the new VM.
514 * @param ppVM Where to store the pointer to the VM structure.
515 *
516 * @thread EMT.
517 */
518GVMMR0DECL(int) GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCpus, PVM *ppVM)
519{
520 LogFlow(("GVMMR0CreateVM: pSession=%p\n", pSession));
521 PGVMM pGVMM;
522 GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
523
524 AssertPtrReturn(ppVM, VERR_INVALID_POINTER);
525 *ppVM = NULL;
526
527 if ( cCpus == 0
528 || cCpus > VMM_MAX_CPU_COUNT)
529 return VERR_INVALID_PARAMETER;
530
531 RTNATIVETHREAD hEMT0 = RTThreadNativeSelf();
532 AssertReturn(hEMT0 != NIL_RTNATIVETHREAD, VERR_INTERNAL_ERROR);
533 RTNATIVETHREAD ProcId = RTProcSelf();
534 AssertReturn(ProcId != NIL_RTPROCESS, VERR_INTERNAL_ERROR);
535
536 /*
537 * The whole allocation process is protected by the lock.
538 */
539 int rc = gvmmR0CreateDestroyLock(pGVMM);
540 AssertRCReturn(rc, rc);
541
542 /*
543 * Allocate a handle first so we don't waste resources unnecessarily.
544 */
545 uint16_t iHandle = pGVMM->iFreeHead;
546 if (iHandle)
547 {
548 PGVMHANDLE pHandle = &pGVMM->aHandles[iHandle];
549
550 /* consistency checks, a bit paranoid as always. */
551 if ( !pHandle->pVM
552 && !pHandle->pGVM
553 && !pHandle->pvObj
554 && pHandle->iSelf == iHandle)
555 {
556 pHandle->pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_VM, gvmmR0HandleObjDestructor, pGVMM, pHandle);
557 if (pHandle->pvObj)
558 {
559 /*
560 * Move the handle from the free to used list and perform permission checks.
561 */
562 rc = gvmmR0UsedLock(pGVMM);
563 AssertRC(rc);
564
565 pGVMM->iFreeHead = pHandle->iNext;
566 pHandle->iNext = pGVMM->iUsedHead;
567 pGVMM->iUsedHead = iHandle;
568 pGVMM->cVMs++;
569
570 pHandle->pVM = NULL;
571 pHandle->pGVM = NULL;
572 pHandle->pSession = pSession;
573 pHandle->hEMT0 = NIL_RTNATIVETHREAD;
574 pHandle->ProcId = NIL_RTPROCESS;
575
576 gvmmR0UsedUnlock(pGVMM);
577
578 rc = SUPR0ObjVerifyAccess(pHandle->pvObj, pSession, NULL);
579 if (RT_SUCCESS(rc))
580 {
581 /*
582 * Allocate the global VM structure (GVM) and initialize it.
583 */
584 PGVM pGVM = (PGVM)RTMemAllocZ(RT_UOFFSETOF(GVM, aCpus[cCpus]));
585 if (pGVM)
586 {
587 pGVM->u32Magic = GVM_MAGIC;
588 pGVM->hSelf = iHandle;
589 pGVM->pVM = NULL;
590 pGVM->cCpus = cCpus;
591
592 gvmmR0InitPerVMData(pGVM);
593 GMMR0InitPerVMData(pGVM);
594
595 /*
596 * Allocate the shared VM structure and associated page array.
597 */
598 const uint32_t cbVM = RT_UOFFSETOF(VM, aCpus[cCpus]);
599 const uint32_t cPages = RT_ALIGN_32(cbVM, PAGE_SIZE) >> PAGE_SHIFT;
600#ifdef RT_OS_DARWIN /** @todo Figure out why this is broken. Is it only on snow leopard? */
601 rc = RTR0MemObjAllocLow(&pGVM->gvmm.s.VMMemObj, (cPages + 1) << PAGE_SHIFT, false /* fExecutable */);
602#else
603 rc = RTR0MemObjAllocLow(&pGVM->gvmm.s.VMMemObj, cPages << PAGE_SHIFT, false /* fExecutable */);
604#endif
605 if (RT_SUCCESS(rc))
606 {
607 PVM pVM = (PVM)RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj); AssertPtr(pVM);
608 memset(pVM, 0, cPages << PAGE_SHIFT);
609 pVM->enmVMState = VMSTATE_CREATING;
610 pVM->pVMR0 = pVM;
611 pVM->pSession = pSession;
612 pVM->hSelf = iHandle;
613 pVM->cbSelf = cbVM;
614 pVM->cCpus = cCpus;
615 pVM->uCpuPriority = 100; /* default is maximum priority. */
616 pVM->offVMCPU = RT_UOFFSETOF(VM, aCpus);
617
618 rc = RTR0MemObjAllocPage(&pGVM->gvmm.s.VMPagesMemObj, cPages * sizeof(SUPPAGE), false /* fExecutable */);
619 if (RT_SUCCESS(rc))
620 {
621 PSUPPAGE paPages = (PSUPPAGE)RTR0MemObjAddress(pGVM->gvmm.s.VMPagesMemObj); AssertPtr(paPages);
622 for (uint32_t iPage = 0; iPage < cPages; iPage++)
623 {
624 paPages[iPage].uReserved = 0;
625 paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(pGVM->gvmm.s.VMMemObj, iPage);
626 Assert(paPages[iPage].Phys != NIL_RTHCPHYS);
627 }
628
629 /*
630 * Map them into ring-3.
631 */
632 rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMMapObj, pGVM->gvmm.s.VMMemObj, (RTR3PTR)-1, 0,
633 RTMEM_PROT_READ | RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
634 if (RT_SUCCESS(rc))
635 {
636 pVM->pVMR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMMapObj);
637 AssertPtr((void *)pVM->pVMR3);
638
639 /* Initialize all the VM pointers. */
640 for (uint32_t i = 0; i < cCpus; i++)
641 {
642 pVM->aCpus[i].pVMR0 = pVM;
643 pVM->aCpus[i].pVMR3 = pVM->pVMR3;
644 pVM->aCpus[i].idHostCpu = NIL_RTCPUID;
645 pVM->aCpus[i].hNativeThreadR0 = NIL_RTNATIVETHREAD;
646 }
647
648 rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMPagesMapObj, pGVM->gvmm.s.VMPagesMemObj, (RTR3PTR)-1, 0,
649 RTMEM_PROT_READ | RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
650 if (RT_SUCCESS(rc))
651 {
652 pVM->paVMPagesR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMPagesMapObj);
653 AssertPtr((void *)pVM->paVMPagesR3);
654
655 /* complete the handle - take the UsedLock sem just to be careful. */
656 rc = gvmmR0UsedLock(pGVMM);
657 AssertRC(rc);
658
659 pHandle->pVM = pVM;
660 pHandle->pGVM = pGVM;
661 pHandle->hEMT0 = hEMT0;
662 pHandle->ProcId = ProcId;
663 pGVM->pVM = pVM;
664 pGVM->aCpus[0].hEMT = hEMT0;
665 pVM->aCpus[0].hNativeThreadR0 = hEMT0;
666 pGVMM->cEMTs += cCpus;
667
668 gvmmR0UsedUnlock(pGVMM);
669 gvmmR0CreateDestroyUnlock(pGVMM);
670
671 *ppVM = pVM;
672 Log(("GVMMR0CreateVM: pVM=%p pVMR3=%p pGVM=%p hGVM=%d\n", pVM, pVM->pVMR3, pGVM, iHandle));
673 return VINF_SUCCESS;
674 }
675
676 RTR0MemObjFree(pGVM->gvmm.s.VMMapObj, false /* fFreeMappings */);
677 pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
678 }
679 RTR0MemObjFree(pGVM->gvmm.s.VMPagesMemObj, false /* fFreeMappings */);
680 pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
681 }
682 RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, false /* fFreeMappings */);
683 pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
684 }
685 }
686 }
687 /* else: The user wasn't permitted to create this VM. */
688
689 /*
690 * The handle will be freed by gvmmR0HandleObjDestructor as we release the
691 * object reference here. A little extra mess because of non-recursive lock.
692 */
693 void *pvObj = pHandle->pvObj;
694 pHandle->pvObj = NULL;
695 gvmmR0CreateDestroyUnlock(pGVMM);
696
697 SUPR0ObjRelease(pvObj, pSession);
698
699 SUPR0Printf("GVMMR0CreateVM: failed, rc=%d\n", rc);
700 return rc;
701 }
702
703 rc = VERR_NO_MEMORY;
704 }
705 else
706 rc = VERR_INTERNAL_ERROR;
707 }
708 else
709 rc = VERR_GVM_TOO_MANY_VMS;
710
711 gvmmR0CreateDestroyUnlock(pGVMM);
712 return rc;
713}
714
715
716/**
717 * Initializes the per VM data belonging to GVMM.
718 *
719 * @param pGVM Pointer to the global VM structure.
720 */
721static void gvmmR0InitPerVMData(PGVM pGVM)
722{
723 AssertCompile(RT_SIZEOFMEMB(GVM,gvmm.s) <= RT_SIZEOFMEMB(GVM,gvmm.padding));
724 AssertCompile(RT_SIZEOFMEMB(GVMCPU,gvmm.s) <= RT_SIZEOFMEMB(GVMCPU,gvmm.padding));
725 pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
726 pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
727 pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
728 pGVM->gvmm.s.VMPagesMapObj = NIL_RTR0MEMOBJ;
729 pGVM->gvmm.s.fDoneVMMR0Init = false;
730 pGVM->gvmm.s.fDoneVMMR0Term = false;
731
732 for (VMCPUID i = 0; i < pGVM->cCpus; i++)
733 {
734 pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
735 pGVM->aCpus[i].hEMT = NIL_RTNATIVETHREAD;
736 }
737}
738
739
740/**
741 * Does the VM initialization.
742 *
743 * @returns VBox status code.
744 * @param pVM Pointer to the shared VM structure.
745 */
746GVMMR0DECL(int) GVMMR0InitVM(PVM pVM)
747{
748 LogFlow(("GVMMR0InitVM: pVM=%p\n", pVM));
749
750 /*
751 * Validate the VM structure, state and handle.
752 */
753 PGVM pGVM;
754 PGVMM pGVMM;
755 int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
756 if (RT_SUCCESS(rc))
757 {
758 if ( !pGVM->gvmm.s.fDoneVMMR0Init
759 && pGVM->aCpus[0].gvmm.s.HaltEventMulti == NIL_RTSEMEVENTMULTI)
760 {
761 for (VMCPUID i = 0; i < pGVM->cCpus; i++)
762 {
763 rc = RTSemEventMultiCreate(&pGVM->aCpus[i].gvmm.s.HaltEventMulti);
764 if (RT_FAILURE(rc))
765 {
766 pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
767 break;
768 }
769 }
770 }
771 else
772 rc = VERR_WRONG_ORDER;
773 }
774
775 LogFlow(("GVMMR0InitVM: returns %Rrc\n", rc));
776 return rc;
777}
778
779
780/**
781 * Indicates that we're done with the ring-0 initialization
782 * of the VM.
783 *
784 * @param pVM Pointer to the shared VM structure.
785 * @thread EMT(0)
786 */
787GVMMR0DECL(void) GVMMR0DoneInitVM(PVM pVM)
788{
789 /* Validate the VM structure, state and handle. */
790 PGVM pGVM;
791 PGVMM pGVMM;
792 int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
793 AssertRCReturnVoid(rc);
794
795 /* Set the indicator. */
796 pGVM->gvmm.s.fDoneVMMR0Init = true;
797}
798
799
800/**
801 * Indicates that we're doing the ring-0 termination of the VM.
802 *
803 * @returns true if termination hasn't been done already, false if it has.
804 * @param pVM Pointer to the shared VM structure.
805 * @param pGVM Pointer to the global VM structure. Optional.
806 * @thread EMT(0)
807 */
808GVMMR0DECL(bool) GVMMR0DoingTermVM(PVM pVM, PGVM pGVM)
809{
810 /* Validate the VM structure, state and handle. */
811 AssertPtrNullReturn(pGVM, false);
812 AssertReturn(!pGVM || pGVM->u32Magic == GVM_MAGIC, false);
813 if (!pGVM)
814 {
815 PGVMM pGVMM;
816 int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
817 AssertRCReturn(rc, false);
818 }
819
820 /* Set the indicator. */
821 if (pGVM->gvmm.s.fDoneVMMR0Term)
822 return false;
823 pGVM->gvmm.s.fDoneVMMR0Term = true;
824 return true;
825}
826
827
828/**
829 * Destroys the VM, freeing all associated resources (the ring-0 ones anyway).
830 *
831 * This is call from the vmR3DestroyFinalBit and from a error path in VMR3Create,
832 * and the caller is not the EMT thread, unfortunately. For security reasons, it
833 * would've been nice if the caller was actually the EMT thread or that we somehow
834 * could've associated the calling thread with the VM up front.
835 *
836 * @returns VBox status code.
837 * @param pVM Where to store the pointer to the VM structure.
838 *
839 * @thread EMT(0) if it's associated with the VM, otherwise any thread.
840 */
841GVMMR0DECL(int) GVMMR0DestroyVM(PVM pVM)
842{
843 LogFlow(("GVMMR0DestroyVM: pVM=%p\n", pVM));
844 PGVMM pGVMM;
845 GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
846
847
848 /*
849 * Validate the VM structure, state and caller.
850 */
851 AssertPtrReturn(pVM, VERR_INVALID_POINTER);
852 AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
853 AssertMsgReturn(pVM->enmVMState >= VMSTATE_CREATING && pVM->enmVMState <= VMSTATE_TERMINATED, ("%d\n", pVM->enmVMState), VERR_WRONG_ORDER);
854
855 uint32_t hGVM = pVM->hSelf;
856 AssertReturn(hGVM != NIL_GVM_HANDLE, VERR_INVALID_HANDLE);
857 AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), VERR_INVALID_HANDLE);
858
859 PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
860 AssertReturn(pHandle->pVM == pVM, VERR_NOT_OWNER);
861
862 RTPROCESS ProcId = RTProcSelf();
863 RTNATIVETHREAD hSelf = RTThreadNativeSelf();
864 AssertReturn( ( pHandle->hEMT0 == hSelf
865 && pHandle->ProcId == ProcId)
866 || pHandle->hEMT0 == NIL_RTNATIVETHREAD, VERR_NOT_OWNER);
867
868 /*
869 * Lookup the handle and destroy the object.
870 * Since the lock isn't recursive and we'll have to leave it before dereferencing the
871 * object, we take some precautions against racing callers just in case...
872 */
873 int rc = gvmmR0CreateDestroyLock(pGVMM);
874 AssertRC(rc);
875
876 /* be careful here because we might theoretically be racing someone else cleaning up. */
877 if ( pHandle->pVM == pVM
878 && ( ( pHandle->hEMT0 == hSelf
879 && pHandle->ProcId == ProcId)
880 || pHandle->hEMT0 == NIL_RTNATIVETHREAD)
881 && VALID_PTR(pHandle->pvObj)
882 && VALID_PTR(pHandle->pSession)
883 && VALID_PTR(pHandle->pGVM)
884 && pHandle->pGVM->u32Magic == GVM_MAGIC)
885 {
886 void *pvObj = pHandle->pvObj;
887 pHandle->pvObj = NULL;
888 gvmmR0CreateDestroyUnlock(pGVMM);
889
890 SUPR0ObjRelease(pvObj, pHandle->pSession);
891 }
892 else
893 {
894 SUPR0Printf("GVMMR0DestroyVM: pHandle=%p:{.pVM=%p, .hEMT0=%p, .ProcId=%u, .pvObj=%p} pVM=%p hSelf=%p\n",
895 pHandle, pHandle->pVM, pHandle->hEMT0, pHandle->ProcId, pHandle->pvObj, pVM, hSelf);
896 gvmmR0CreateDestroyUnlock(pGVMM);
897 rc = VERR_INTERNAL_ERROR;
898 }
899
900 return rc;
901}
902
903
904/**
905 * Performs VM cleanup task as part of object destruction.
906 *
907 * @param pGVM The GVM pointer.
908 */
909static void gvmmR0CleanupVM(PGVM pGVM)
910{
911 if ( pGVM->gvmm.s.fDoneVMMR0Init
912 && !pGVM->gvmm.s.fDoneVMMR0Term)
913 {
914 if ( pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ
915 && RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM->pVM)
916 {
917 LogFlow(("gvmmR0CleanupVM: Calling VMMR0TermVM\n"));
918 VMMR0TermVM(pGVM->pVM, pGVM);
919 }
920 else
921 AssertMsgFailed(("gvmmR0CleanupVM: VMMemObj=%p pVM=%p\n", pGVM->gvmm.s.VMMemObj, pGVM->pVM));
922 }
923
924 GMMR0CleanupVM(pGVM);
925}
926
927
928/**
929 * Handle destructor.
930 *
931 * @param pvGVMM The GVM instance pointer.
932 * @param pvHandle The handle pointer.
933 */
934static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void *pvObj, void *pvGVMM, void *pvHandle)
935{
936 LogFlow(("gvmmR0HandleObjDestructor: %p %p %p\n", pvObj, pvGVMM, pvHandle));
937
938 /*
939 * Some quick, paranoid, input validation.
940 */
941 PGVMHANDLE pHandle = (PGVMHANDLE)pvHandle;
942 AssertPtr(pHandle);
943 PGVMM pGVMM = (PGVMM)pvGVMM;
944 Assert(pGVMM == g_pGVMM);
945 const uint16_t iHandle = pHandle - &pGVMM->aHandles[0];
946 if ( !iHandle
947 || iHandle >= RT_ELEMENTS(pGVMM->aHandles)
948 || iHandle != pHandle->iSelf)
949 {
950 SUPR0Printf("GVM: handle %d is out of range or corrupt (iSelf=%d)!\n", iHandle, pHandle->iSelf);
951 return;
952 }
953
954 int rc = gvmmR0CreateDestroyLock(pGVMM);
955 AssertRC(rc);
956 rc = gvmmR0UsedLock(pGVMM);
957 AssertRC(rc);
958
959 /*
960 * This is a tad slow but a doubly linked list is too much hazzle.
961 */
962 if (RT_UNLIKELY(pHandle->iNext >= RT_ELEMENTS(pGVMM->aHandles)))
963 {
964 SUPR0Printf("GVM: used list index %d is out of range!\n", pHandle->iNext);
965 gvmmR0UsedUnlock(pGVMM);
966 gvmmR0CreateDestroyUnlock(pGVMM);
967 return;
968 }
969
970 if (pGVMM->iUsedHead == iHandle)
971 pGVMM->iUsedHead = pHandle->iNext;
972 else
973 {
974 uint16_t iPrev = pGVMM->iUsedHead;
975 int c = RT_ELEMENTS(pGVMM->aHandles) + 2;
976 while (iPrev)
977 {
978 if (RT_UNLIKELY(iPrev >= RT_ELEMENTS(pGVMM->aHandles)))
979 {
980 SUPR0Printf("GVM: used list index %d is out of range!\n", iPrev);
981 gvmmR0UsedUnlock(pGVMM);
982 gvmmR0CreateDestroyUnlock(pGVMM);
983 return;
984 }
985 if (RT_UNLIKELY(c-- <= 0))
986 {
987 iPrev = 0;
988 break;
989 }
990
991 if (pGVMM->aHandles[iPrev].iNext == iHandle)
992 break;
993 iPrev = pGVMM->aHandles[iPrev].iNext;
994 }
995 if (!iPrev)
996 {
997 SUPR0Printf("GVM: can't find the handle previous previous of %d!\n", pHandle->iSelf);
998 gvmmR0UsedUnlock(pGVMM);
999 gvmmR0CreateDestroyUnlock(pGVMM);
1000 return;
1001 }
1002
1003 Assert(pGVMM->aHandles[iPrev].iNext == iHandle);
1004 pGVMM->aHandles[iPrev].iNext = pHandle->iNext;
1005 }
1006 pHandle->iNext = 0;
1007 pGVMM->cVMs--;
1008
1009 /*
1010 * Do the global cleanup round.
1011 */
1012 PGVM pGVM = pHandle->pGVM;
1013 if ( VALID_PTR(pGVM)
1014 && pGVM->u32Magic == GVM_MAGIC)
1015 {
1016 pGVMM->cEMTs -= pGVM->cCpus;
1017 gvmmR0UsedUnlock(pGVMM);
1018
1019 gvmmR0CleanupVM(pGVM);
1020
1021 /*
1022 * Do the GVMM cleanup - must be done last.
1023 */
1024 /* The VM and VM pages mappings/allocations. */
1025 if (pGVM->gvmm.s.VMPagesMapObj != NIL_RTR0MEMOBJ)
1026 {
1027 rc = RTR0MemObjFree(pGVM->gvmm.s.VMPagesMapObj, false /* fFreeMappings */); AssertRC(rc);
1028 pGVM->gvmm.s.VMPagesMapObj = NIL_RTR0MEMOBJ;
1029 }
1030
1031 if (pGVM->gvmm.s.VMMapObj != NIL_RTR0MEMOBJ)
1032 {
1033 rc = RTR0MemObjFree(pGVM->gvmm.s.VMMapObj, false /* fFreeMappings */); AssertRC(rc);
1034 pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
1035 }
1036
1037 if (pGVM->gvmm.s.VMPagesMemObj != NIL_RTR0MEMOBJ)
1038 {
1039 rc = RTR0MemObjFree(pGVM->gvmm.s.VMPagesMemObj, false /* fFreeMappings */); AssertRC(rc);
1040 pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
1041 }
1042
1043 if (pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ)
1044 {
1045 rc = RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, false /* fFreeMappings */); AssertRC(rc);
1046 pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
1047 }
1048
1049 for (VMCPUID i = 0; i < pGVM->cCpus; i++)
1050 {
1051 if (pGVM->aCpus[i].gvmm.s.HaltEventMulti != NIL_RTSEMEVENTMULTI)
1052 {
1053 rc = RTSemEventMultiDestroy(pGVM->aCpus[i].gvmm.s.HaltEventMulti); AssertRC(rc);
1054 pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
1055 }
1056 }
1057
1058 /* the GVM structure itself. */
1059 pGVM->u32Magic |= UINT32_C(0x80000000);
1060 RTMemFree(pGVM);
1061
1062 /* Re-acquire the UsedLock before freeing the handle since we're updating handle fields. */
1063 rc = gvmmR0UsedLock(pGVMM);
1064 AssertRC(rc);
1065 }
1066 /* else: GVMMR0CreateVM cleanup. */
1067
1068 /*
1069 * Free the handle.
1070 */
1071 pHandle->iNext = pGVMM->iFreeHead;
1072 pGVMM->iFreeHead = iHandle;
1073 ASMAtomicWriteNullPtr(&pHandle->pGVM);
1074 ASMAtomicWriteNullPtr(&pHandle->pVM);
1075 ASMAtomicWriteNullPtr(&pHandle->pvObj);
1076 ASMAtomicWriteNullPtr(&pHandle->pSession);
1077 ASMAtomicWriteSize(&pHandle->hEMT0, NIL_RTNATIVETHREAD);
1078 ASMAtomicWriteSize(&pHandle->ProcId, NIL_RTPROCESS);
1079
1080 gvmmR0UsedUnlock(pGVMM);
1081 gvmmR0CreateDestroyUnlock(pGVMM);
1082 LogFlow(("gvmmR0HandleObjDestructor: returns\n"));
1083}
1084
1085
1086/**
1087 * Registers the calling thread as the EMT of a Virtual CPU.
1088 *
1089 * Note that VCPU 0 is automatically registered during VM creation.
1090 *
1091 * @returns VBox status code
1092 * @param pVM The shared VM structure (the ring-0 mapping).
1093 * @param idCpu VCPU id.
1094 */
1095GVMMR0DECL(int) GVMMR0RegisterVCpu(PVM pVM, VMCPUID idCpu)
1096{
1097 AssertReturn(idCpu != 0, VERR_NOT_OWNER);
1098
1099 /*
1100 * Validate the VM structure, state and handle.
1101 */
1102 PGVM pGVM;
1103 PGVMM pGVMM;
1104 int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, false /* fTakeUsedLock */);
1105 if (RT_FAILURE(rc))
1106 return rc;
1107
1108 AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID);
1109 AssertReturn(pGVM->aCpus[idCpu].hEMT == NIL_RTNATIVETHREAD, VERR_ACCESS_DENIED);
1110 Assert(pGVM->cCpus == pVM->cCpus);
1111 Assert(pVM->aCpus[idCpu].hNativeThreadR0 == NIL_RTNATIVETHREAD);
1112
1113 pVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = RTThreadNativeSelf();
1114
1115 return VINF_SUCCESS;
1116}
1117
1118
1119/**
1120 * Lookup a GVM structure by its handle.
1121 *
1122 * @returns The GVM pointer on success, NULL on failure.
1123 * @param hGVM The global VM handle. Asserts on bad handle.
1124 */
1125GVMMR0DECL(PGVM) GVMMR0ByHandle(uint32_t hGVM)
1126{
1127 PGVMM pGVMM;
1128 GVMM_GET_VALID_INSTANCE(pGVMM, NULL);
1129
1130 /*
1131 * Validate.
1132 */
1133 AssertReturn(hGVM != NIL_GVM_HANDLE, NULL);
1134 AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), NULL);
1135
1136 /*
1137 * Look it up.
1138 */
1139 PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1140 AssertPtrReturn(pHandle->pVM, NULL);
1141 AssertPtrReturn(pHandle->pvObj, NULL);
1142 PGVM pGVM = pHandle->pGVM;
1143 AssertPtrReturn(pGVM, NULL);
1144 AssertReturn(pGVM->pVM == pHandle->pVM, NULL);
1145
1146 return pHandle->pGVM;
1147}
1148
1149
1150/**
1151 * Lookup a GVM structure by the shared VM structure.
1152 *
1153 * The calling thread must be in the same process as the VM. All current lookups
1154 * are by threads inside the same process, so this will not be an issue.
1155 *
1156 * @returns VBox status code.
1157 * @param pVM The shared VM structure (the ring-0 mapping).
1158 * @param ppGVM Where to store the GVM pointer.
1159 * @param ppGVMM Where to store the pointer to the GVMM instance data.
1160 * @param fTakeUsedLock Whether to take the used lock or not.
1161 * Be very careful if not taking the lock as it's possible that
1162 * the VM will disappear then.
1163 *
1164 * @remark This will not assert on an invalid pVM but try return sliently.
1165 */
1166static int gvmmR0ByVM(PVM pVM, PGVM *ppGVM, PGVMM *ppGVMM, bool fTakeUsedLock)
1167{
1168 RTPROCESS ProcId = RTProcSelf();
1169 PGVMM pGVMM;
1170 GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
1171
1172 /*
1173 * Validate.
1174 */
1175 if (RT_UNLIKELY( !VALID_PTR(pVM)
1176 || ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
1177 return VERR_INVALID_POINTER;
1178 if (RT_UNLIKELY( pVM->enmVMState < VMSTATE_CREATING
1179 || pVM->enmVMState >= VMSTATE_TERMINATED))
1180 return VERR_INVALID_POINTER;
1181
1182 uint16_t hGVM = pVM->hSelf;
1183 if (RT_UNLIKELY( hGVM == NIL_GVM_HANDLE
1184 || hGVM >= RT_ELEMENTS(pGVMM->aHandles)))
1185 return VERR_INVALID_HANDLE;
1186
1187 /*
1188 * Look it up.
1189 */
1190 PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1191 PGVM pGVM;
1192 if (fTakeUsedLock)
1193 {
1194 int rc = gvmmR0UsedLock(pGVMM);
1195 AssertRCReturn(rc, rc);
1196
1197 pGVM = pHandle->pGVM;
1198 if (RT_UNLIKELY( pHandle->pVM != pVM
1199 || pHandle->ProcId != ProcId
1200 || !VALID_PTR(pHandle->pvObj)
1201 || !VALID_PTR(pGVM)
1202 || pGVM->pVM != pVM))
1203 {
1204 gvmmR0UsedUnlock(pGVMM);
1205 return VERR_INVALID_HANDLE;
1206 }
1207 }
1208 else
1209 {
1210 if (RT_UNLIKELY(pHandle->pVM != pVM))
1211 return VERR_INVALID_HANDLE;
1212 if (RT_UNLIKELY(pHandle->ProcId != ProcId))
1213 return VERR_INVALID_HANDLE;
1214 if (RT_UNLIKELY(!VALID_PTR(pHandle->pvObj)))
1215 return VERR_INVALID_HANDLE;
1216
1217 pGVM = pHandle->pGVM;
1218 if (RT_UNLIKELY(!VALID_PTR(pGVM)))
1219 return VERR_INVALID_HANDLE;
1220 if (RT_UNLIKELY(pGVM->pVM != pVM))
1221 return VERR_INVALID_HANDLE;
1222 }
1223
1224 *ppGVM = pGVM;
1225 *ppGVMM = pGVMM;
1226 return VINF_SUCCESS;
1227}
1228
1229
1230/**
1231 * Lookup a GVM structure by the shared VM structure.
1232 *
1233 * @returns VBox status code.
1234 * @param pVM The shared VM structure (the ring-0 mapping).
1235 * @param ppGVM Where to store the GVM pointer.
1236 *
1237 * @remark This will not take the 'used'-lock because it doesn't do
1238 * nesting and this function will be used from under the lock.
1239 */
1240GVMMR0DECL(int) GVMMR0ByVM(PVM pVM, PGVM *ppGVM)
1241{
1242 PGVMM pGVMM;
1243 return gvmmR0ByVM(pVM, ppGVM, &pGVMM, false /* fTakeUsedLock */);
1244}
1245
1246
1247/**
1248 * Lookup a GVM structure by the shared VM structure and ensuring that the
1249 * caller is an EMT thread.
1250 *
1251 * @returns VBox status code.
1252 * @param pVM The shared VM structure (the ring-0 mapping).
1253 * @param idCpu The Virtual CPU ID of the calling EMT.
1254 * @param ppGVM Where to store the GVM pointer.
1255 * @param ppGVMM Where to store the pointer to the GVMM instance data.
1256 * @thread EMT
1257 *
1258 * @remark This will assert in all failure paths.
1259 */
1260static int gvmmR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM *ppGVM, PGVMM *ppGVMM)
1261{
1262 PGVMM pGVMM;
1263 GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
1264
1265 /*
1266 * Validate.
1267 */
1268 AssertPtrReturn(pVM, VERR_INVALID_POINTER);
1269 AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
1270
1271 uint16_t hGVM = pVM->hSelf;
1272 AssertReturn(hGVM != NIL_GVM_HANDLE, VERR_INVALID_HANDLE);
1273 AssertReturn(hGVM < RT_ELEMENTS(pGVMM->aHandles), VERR_INVALID_HANDLE);
1274
1275 /*
1276 * Look it up.
1277 */
1278 PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
1279 AssertReturn(pHandle->pVM == pVM, VERR_NOT_OWNER);
1280 RTPROCESS ProcId = RTProcSelf();
1281 AssertReturn(pHandle->ProcId == ProcId, VERR_NOT_OWNER);
1282 AssertPtrReturn(pHandle->pvObj, VERR_INTERNAL_ERROR);
1283
1284 PGVM pGVM = pHandle->pGVM;
1285 AssertPtrReturn(pGVM, VERR_INTERNAL_ERROR);
1286 AssertReturn(pGVM->pVM == pVM, VERR_INTERNAL_ERROR);
1287 RTNATIVETHREAD hAllegedEMT = RTThreadNativeSelf();
1288 AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID);
1289 AssertReturn(pGVM->aCpus[idCpu].hEMT == hAllegedEMT, VERR_INTERNAL_ERROR);
1290
1291 *ppGVM = pGVM;
1292 *ppGVMM = pGVMM;
1293 return VINF_SUCCESS;
1294}
1295
1296
1297/**
1298 * Lookup a GVM structure by the shared VM structure
1299 * and ensuring that the caller is the EMT thread.
1300 *
1301 * @returns VBox status code.
1302 * @param pVM The shared VM structure (the ring-0 mapping).
1303 * @param idCpu The Virtual CPU ID of the calling EMT.
1304 * @param ppGVM Where to store the GVM pointer.
1305 * @thread EMT
1306 */
1307GVMMR0DECL(int) GVMMR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM *ppGVM)
1308{
1309 AssertPtrReturn(ppGVM, VERR_INVALID_POINTER);
1310 PGVMM pGVMM;
1311 return gvmmR0ByVMAndEMT(pVM, idCpu, ppGVM, &pGVMM);
1312}
1313
1314
1315/**
1316 * Lookup a VM by its global handle.
1317 *
1318 * @returns The VM handle on success, NULL on failure.
1319 * @param hGVM The global VM handle. Asserts on bad handle.
1320 */
1321GVMMR0DECL(PVM) GVMMR0GetVMByHandle(uint32_t hGVM)
1322{
1323 PGVM pGVM = GVMMR0ByHandle(hGVM);
1324 return pGVM ? pGVM->pVM : NULL;
1325}
1326
1327
1328/**
1329 * Looks up the VM belonging to the specified EMT thread.
1330 *
1331 * This is used by the assertion machinery in VMMR0.cpp to avoid causing
1332 * unnecessary kernel panics when the EMT thread hits an assertion. The
1333 * call may or not be an EMT thread.
1334 *
1335 * @returns The VM handle on success, NULL on failure.
1336 * @param hEMT The native thread handle of the EMT.
1337 * NIL_RTNATIVETHREAD means the current thread
1338 */
1339GVMMR0DECL(PVM) GVMMR0GetVMByEMT(RTNATIVETHREAD hEMT)
1340{
1341 /*
1342 * No Assertions here as we're usually called in a AssertMsgN or
1343 * RTAssert* context.
1344 */
1345 PGVMM pGVMM = g_pGVMM;
1346 if ( !VALID_PTR(pGVMM)
1347 || pGVMM->u32Magic != GVMM_MAGIC)
1348 return NULL;
1349
1350 if (hEMT == NIL_RTNATIVETHREAD)
1351 hEMT = RTThreadNativeSelf();
1352 RTPROCESS ProcId = RTProcSelf();
1353
1354 /*
1355 * Search the handles in a linear fashion as we don't dare to take the lock (assert).
1356 */
1357 for (unsigned i = 1; i < RT_ELEMENTS(pGVMM->aHandles); i++)
1358 {
1359 if ( pGVMM->aHandles[i].iSelf == i
1360 && pGVMM->aHandles[i].ProcId == ProcId
1361 && VALID_PTR(pGVMM->aHandles[i].pvObj)
1362 && VALID_PTR(pGVMM->aHandles[i].pVM)
1363 && VALID_PTR(pGVMM->aHandles[i].pGVM))
1364 {
1365 if (pGVMM->aHandles[i].hEMT0 == hEMT)
1366 return pGVMM->aHandles[i].pVM;
1367
1368 /* This is fearly safe with the current process per VM approach. */
1369 PGVM pGVM = pGVMM->aHandles[i].pGVM;
1370 VMCPUID const cCpus = pGVM->cCpus;
1371 if ( cCpus < 1
1372 || cCpus > VMM_MAX_CPU_COUNT)
1373 continue;
1374 for (VMCPUID idCpu = 1; idCpu < cCpus; idCpu++)
1375 if (pGVM->aCpus[idCpu].hEMT == hEMT)
1376 return pGVMM->aHandles[i].pVM;
1377 }
1378 }
1379 return NULL;
1380}
1381
1382
1383/**
1384 * This is will wake up expired and soon-to-be expired VMs.
1385 *
1386 * @returns Number of VMs that has been woken up.
1387 * @param pGVMM Pointer to the GVMM instance data.
1388 * @param u64Now The current time.
1389 */
1390static unsigned gvmmR0SchedDoWakeUps(PGVMM pGVMM, uint64_t u64Now)
1391{
1392/** @todo Rewrite this algorithm. See performance defect XYZ. */
1393
1394 /*
1395 * The first pass will wake up VMs which have actually expired
1396 * and look for VMs that should be woken up in the 2nd and 3rd passes.
1397 */
1398 unsigned cWoken = 0;
1399 unsigned cHalted = 0;
1400 unsigned cTodo2nd = 0;
1401 unsigned cTodo3rd = 0;
1402 for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1403 i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1404 i = pGVMM->aHandles[i].iNext)
1405 {
1406 PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1407 if ( VALID_PTR(pCurGVM)
1408 && pCurGVM->u32Magic == GVM_MAGIC)
1409 {
1410 for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
1411 {
1412 PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1413
1414 uint64_t u64 = pCurGVCpu->gvmm.s.u64HaltExpire;
1415 if (u64)
1416 {
1417 if (u64 <= u64Now)
1418 {
1419 if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1420 {
1421 int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1422 AssertRC(rc);
1423 cWoken++;
1424 }
1425 }
1426 else
1427 {
1428 cHalted++;
1429 if (u64 <= u64Now + pGVMM->nsEarlyWakeUp1)
1430 cTodo2nd++;
1431 else if (u64 <= u64Now + pGVMM->nsEarlyWakeUp2)
1432 cTodo3rd++;
1433 }
1434 }
1435 }
1436 }
1437 AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1438 }
1439
1440 if (cTodo2nd)
1441 {
1442 for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1443 i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1444 i = pGVMM->aHandles[i].iNext)
1445 {
1446 PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1447 if ( VALID_PTR(pCurGVM)
1448 && pCurGVM->u32Magic == GVM_MAGIC)
1449 {
1450 for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
1451 {
1452 PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1453
1454 if ( pCurGVCpu->gvmm.s.u64HaltExpire
1455 && pCurGVCpu->gvmm.s.u64HaltExpire <= u64Now + pGVMM->nsEarlyWakeUp1)
1456 {
1457 if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1458 {
1459 int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1460 AssertRC(rc);
1461 cWoken++;
1462 }
1463 }
1464 }
1465 }
1466 AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1467 }
1468 }
1469
1470 if (cTodo3rd)
1471 {
1472 for (unsigned i = pGVMM->iUsedHead, cGuard = 0;
1473 i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1474 i = pGVMM->aHandles[i].iNext)
1475 {
1476 PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
1477 if ( VALID_PTR(pCurGVM)
1478 && pCurGVM->u32Magic == GVM_MAGIC)
1479 {
1480 for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
1481 {
1482 PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
1483
1484 if ( pCurGVCpu->gvmm.s.u64HaltExpire
1485 && pCurGVCpu->gvmm.s.u64HaltExpire <= u64Now + pGVMM->nsEarlyWakeUp2)
1486 {
1487 if (ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0))
1488 {
1489 int rc = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
1490 AssertRC(rc);
1491 cWoken++;
1492 }
1493 }
1494 }
1495 }
1496 AssertLogRelBreak(cGuard++ < RT_ELEMENTS(pGVMM->aHandles));
1497 }
1498 }
1499
1500 return cWoken;
1501}
1502
1503
1504/**
1505 * Halt the EMT thread.
1506 *
1507 * @returns VINF_SUCCESS normal wakeup (timeout or kicked by other thread).
1508 * VERR_INTERRUPTED if a signal was scheduled for the thread.
1509 * @param pVM Pointer to the shared VM structure.
1510 * @param idCpu The Virtual CPU ID of the calling EMT.
1511 * @param u64ExpireGipTime The time for the sleep to expire expressed as GIP time.
1512 * @thread EMT(idCpu).
1513 */
1514GVMMR0DECL(int) GVMMR0SchedHalt(PVM pVM, VMCPUID idCpu, uint64_t u64ExpireGipTime)
1515{
1516 LogFlow(("GVMMR0SchedHalt: pVM=%p\n", pVM));
1517
1518 /*
1519 * Validate the VM structure, state and handle.
1520 */
1521 PGVM pGVM;
1522 PGVMM pGVMM;
1523 int rc = gvmmR0ByVMAndEMT(pVM, idCpu, &pGVM, &pGVMM);
1524 if (RT_FAILURE(rc))
1525 return rc;
1526 pGVM->gvmm.s.StatsSched.cHaltCalls++;
1527
1528 PGVMCPU pCurGVCpu = &pGVM->aCpus[idCpu];
1529 Assert(!pCurGVCpu->gvmm.s.u64HaltExpire);
1530
1531 /*
1532 * Take the UsedList semaphore, get the current time
1533 * and check if anyone needs waking up.
1534 * Interrupts must NOT be disabled at this point because we ask for GIP time!
1535 */
1536 rc = gvmmR0UsedLock(pGVMM);
1537 AssertRC(rc);
1538
1539 pCurGVCpu->gvmm.s.iCpuEmt = ASMGetApicId();
1540
1541 Assert(ASMGetFlags() & X86_EFL_IF);
1542 const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
1543 pGVM->gvmm.s.StatsSched.cHaltWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
1544
1545 /*
1546 * Go to sleep if we must...
1547 */
1548 if ( u64Now < u64ExpireGipTime
1549 && u64ExpireGipTime - u64Now > (pGVMM->cEMTs > pGVMM->cEMTsMeansCompany
1550 ? pGVMM->nsMinSleepCompany
1551 : pGVMM->nsMinSleepAlone))
1552 {
1553 pGVM->gvmm.s.StatsSched.cHaltBlocking++;
1554 ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, u64ExpireGipTime);
1555 gvmmR0UsedUnlock(pGVMM);
1556
1557 uint32_t cMillies = (u64ExpireGipTime - u64Now) / 1000000;
1558 rc = RTSemEventMultiWaitNoResume(pCurGVCpu->gvmm.s.HaltEventMulti, cMillies ? cMillies : 1);
1559 ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0);
1560 if (rc == VERR_TIMEOUT)
1561 {
1562 pGVM->gvmm.s.StatsSched.cHaltTimeouts++;
1563 rc = VINF_SUCCESS;
1564 }
1565 }
1566 else
1567 {
1568 pGVM->gvmm.s.StatsSched.cHaltNotBlocking++;
1569 gvmmR0UsedUnlock(pGVMM);
1570 }
1571
1572 /* Make sure false wake up calls (gvmmR0SchedDoWakeUps) cause us to spin. */
1573 RTSemEventMultiReset(pCurGVCpu->gvmm.s.HaltEventMulti);
1574
1575 return rc;
1576}
1577
1578
1579/**
1580 * Worker for GVMMR0SchedWakeUp and GVMMR0SchedWakeUpAndPokeCpus that wakes up
1581 * the a sleeping EMT.
1582 *
1583 * @retval VINF_SUCCESS if successfully woken up.
1584 * @retval VINF_GVM_NOT_BLOCKED if the EMT wasn't blocked.
1585 *
1586 * @param pGVM The global (ring-0) VM structure.
1587 * @param pGVCpu The global (ring-0) VCPU structure.
1588 */
1589DECLINLINE(int) gvmmR0SchedWakeUpOne(PGVM pGVM, PGVMCPU pGVCpu)
1590{
1591 pGVM->gvmm.s.StatsSched.cWakeUpCalls++;
1592
1593 /*
1594 * Signal the semaphore regardless of whether it's current blocked on it.
1595 *
1596 * The reason for this is that there is absolutely no way we can be 100%
1597 * certain that it isn't *about* go to go to sleep on it and just got
1598 * delayed a bit en route. So, we will always signal the semaphore when
1599 * the it is flagged as halted in the VMM.
1600 */
1601/** @todo we can optimize some of that by means of the pVCpu->enmState now. */
1602 int rc;
1603 if (pGVCpu->gvmm.s.u64HaltExpire)
1604 {
1605 rc = VINF_SUCCESS;
1606 ASMAtomicXchgU64(&pGVCpu->gvmm.s.u64HaltExpire, 0);
1607 }
1608 else
1609 {
1610 rc = VINF_GVM_NOT_BLOCKED;
1611 pGVM->gvmm.s.StatsSched.cWakeUpNotHalted++;
1612 }
1613
1614 int rc2 = RTSemEventMultiSignal(pGVCpu->gvmm.s.HaltEventMulti);
1615 AssertRC(rc2);
1616
1617 return rc;
1618}
1619
1620
1621/**
1622 * Wakes up the halted EMT thread so it can service a pending request.
1623 *
1624 * @returns VBox status code.
1625 * @retval VINF_SUCCESS if successfully woken up.
1626 * @retval VINF_GVM_NOT_BLOCKED if the EMT wasn't blocked.
1627 *
1628 * @param pVM Pointer to the shared VM structure.
1629 * @param idCpu The Virtual CPU ID of the EMT to wake up.
1630 * @param fTakeUsedLock Take the used lock or not
1631 * @thread Any but EMT.
1632 */
1633GVMMR0DECL(int) GVMMR0SchedWakeUpEx(PVM pVM, VMCPUID idCpu, bool fTakeUsedLock)
1634{
1635 /*
1636 * Validate input and take the UsedLock.
1637 */
1638 PGVM pGVM;
1639 PGVMM pGVMM;
1640 int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, fTakeUsedLock);
1641 if (RT_SUCCESS(rc))
1642 {
1643 if (idCpu < pGVM->cCpus)
1644 {
1645 /*
1646 * Do the actual job.
1647 */
1648 rc = gvmmR0SchedWakeUpOne(pGVM, &pGVM->aCpus[idCpu]);
1649
1650 if (fTakeUsedLock)
1651 {
1652 /*
1653 * While we're here, do a round of scheduling.
1654 */
1655 Assert(ASMGetFlags() & X86_EFL_IF);
1656 const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
1657 pGVM->gvmm.s.StatsSched.cWakeUpWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
1658 }
1659 }
1660 else
1661 rc = VERR_INVALID_CPU_ID;
1662
1663 if (fTakeUsedLock)
1664 {
1665 int rc2 = gvmmR0UsedUnlock(pGVMM);
1666 AssertRC(rc2);
1667 }
1668 }
1669
1670 LogFlow(("GVMMR0SchedWakeUp: returns %Rrc\n", rc));
1671 return rc;
1672}
1673
1674
1675/**
1676 * Wakes up the halted EMT thread so it can service a pending request.
1677 *
1678 * @returns VBox status code.
1679 * @retval VINF_SUCCESS if successfully woken up.
1680 * @retval VINF_GVM_NOT_BLOCKED if the EMT wasn't blocked.
1681 *
1682 * @param pVM Pointer to the shared VM structure.
1683 * @param idCpu The Virtual CPU ID of the EMT to wake up.
1684 * @thread Any but EMT.
1685 */
1686GVMMR0DECL(int) GVMMR0SchedWakeUp(PVM pVM, VMCPUID idCpu)
1687{
1688 return GVMMR0SchedWakeUpEx(pVM, idCpu, true /* fTakeUsedLock */);
1689}
1690
1691/**
1692 * Worker common to GVMMR0SchedPoke and GVMMR0SchedWakeUpAndPokeCpus that pokes
1693 * the Virtual CPU if it's still busy executing guest code.
1694 *
1695 * @returns VBox status code.
1696 * @retval VINF_SUCCESS if poked successfully.
1697 * @retval VINF_GVM_NOT_BUSY_IN_GC if the EMT wasn't busy in GC.
1698 *
1699 * @param pGVM The global (ring-0) VM structure.
1700 * @param pVCpu The Virtual CPU handle.
1701 */
1702DECLINLINE(int) gvmmR0SchedPokeOne(PGVM pGVM, PVMCPU pVCpu)
1703{
1704 pGVM->gvmm.s.StatsSched.cPokeCalls++;
1705
1706 RTCPUID idHostCpu = pVCpu->idHostCpu;
1707 if ( idHostCpu == NIL_RTCPUID
1708 || VMCPU_GET_STATE(pVCpu) != VMCPUSTATE_STARTED_EXEC)
1709 {
1710 pGVM->gvmm.s.StatsSched.cPokeNotBusy++;
1711 return VINF_GVM_NOT_BUSY_IN_GC;
1712 }
1713
1714 /* Note: this function is not implemented on Darwin and Linux (kernel < 2.6.19) */
1715 RTMpPokeCpu(idHostCpu);
1716 return VINF_SUCCESS;
1717}
1718
1719/**
1720 * Pokes an EMT if it's still busy running guest code.
1721 *
1722 * @returns VBox status code.
1723 * @retval VINF_SUCCESS if poked successfully.
1724 * @retval VINF_GVM_NOT_BUSY_IN_GC if the EMT wasn't busy in GC.
1725 *
1726 * @param pVM Pointer to the shared VM structure.
1727 * @param idCpu The ID of the virtual CPU to poke.
1728 * @param fTakeUsedLock Take the used lock or not
1729 */
1730GVMMR0DECL(int) GVMMR0SchedPokeEx(PVM pVM, VMCPUID idCpu, bool fTakeUsedLock)
1731{
1732 /*
1733 * Validate input and take the UsedLock.
1734 */
1735 PGVM pGVM;
1736 PGVMM pGVMM;
1737 int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, fTakeUsedLock);
1738 if (RT_SUCCESS(rc))
1739 {
1740 if (idCpu < pGVM->cCpus)
1741 rc = gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
1742 else
1743 rc = VERR_INVALID_CPU_ID;
1744
1745 if (fTakeUsedLock)
1746 {
1747 int rc2 = gvmmR0UsedUnlock(pGVMM);
1748 AssertRC(rc2);
1749 }
1750 }
1751
1752 LogFlow(("GVMMR0SchedWakeUpAndPokeCpus: returns %Rrc\n", rc));
1753 return rc;
1754}
1755
1756
1757/**
1758 * Pokes an EMT if it's still busy running guest code.
1759 *
1760 * @returns VBox status code.
1761 * @retval VINF_SUCCESS if poked successfully.
1762 * @retval VINF_GVM_NOT_BUSY_IN_GC if the EMT wasn't busy in GC.
1763 *
1764 * @param pVM Pointer to the shared VM structure.
1765 * @param idCpu The ID of the virtual CPU to poke.
1766 */
1767GVMMR0DECL(int) GVMMR0SchedPoke(PVM pVM, VMCPUID idCpu)
1768{
1769 return GVMMR0SchedPokeEx(pVM, idCpu, true /* fTakeUsedLock */);
1770}
1771
1772
1773/**
1774 * Wakes up a set of halted EMT threads so they can service pending request.
1775 *
1776 * @returns VBox status code, no informational stuff.
1777 *
1778 * @param pVM Pointer to the shared VM structure.
1779 * @param pSleepSet The set of sleepers to wake up.
1780 * @param pPokeSet The set of CPUs to poke.
1781 */
1782GVMMR0DECL(int) GVMMR0SchedWakeUpAndPokeCpus(PVM pVM, PCVMCPUSET pSleepSet, PCVMCPUSET pPokeSet)
1783{
1784 AssertPtrReturn(pSleepSet, VERR_INVALID_POINTER);
1785 AssertPtrReturn(pPokeSet, VERR_INVALID_POINTER);
1786 RTNATIVETHREAD hSelf = RTThreadNativeSelf();
1787
1788 /*
1789 * Validate input and take the UsedLock.
1790 */
1791 PGVM pGVM;
1792 PGVMM pGVMM;
1793 int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /* fTakeUsedLock */);
1794 if (RT_SUCCESS(rc))
1795 {
1796 rc = VINF_SUCCESS;
1797 VMCPUID idCpu = pGVM->cCpus;
1798 while (idCpu-- > 0)
1799 {
1800 /* Don't try poke or wake up ourselves. */
1801 if (pGVM->aCpus[idCpu].hEMT == hSelf)
1802 continue;
1803
1804 /* just ignore errors for now. */
1805 if (VMCPUSET_IS_PRESENT(pSleepSet, idCpu))
1806 gvmmR0SchedWakeUpOne(pGVM, &pGVM->aCpus[idCpu]);
1807 else if (VMCPUSET_IS_PRESENT(pPokeSet, idCpu))
1808 gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
1809 }
1810
1811 int rc2 = gvmmR0UsedUnlock(pGVMM);
1812 AssertRC(rc2);
1813 }
1814
1815 LogFlow(("GVMMR0SchedWakeUpAndPokeCpus: returns %Rrc\n", rc));
1816 return rc;
1817}
1818
1819
1820/**
1821 * VMMR0 request wrapper for GVMMR0SchedWakeUpAndPokeCpus.
1822 *
1823 * @returns see GVMMR0SchedWakeUpAndPokeCpus.
1824 * @param pVM Pointer to the shared VM structure.
1825 * @param pReq The request packet.
1826 */
1827GVMMR0DECL(int) GVMMR0SchedWakeUpAndPokeCpusReq(PVM pVM, PGVMMSCHEDWAKEUPANDPOKECPUSREQ pReq)
1828{
1829 /*
1830 * Validate input and pass it on.
1831 */
1832 AssertPtrReturn(pReq, VERR_INVALID_POINTER);
1833 AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
1834
1835 return GVMMR0SchedWakeUpAndPokeCpus(pVM, &pReq->SleepSet, &pReq->PokeSet);
1836}
1837
1838
1839
1840/**
1841 * Poll the schedule to see if someone else should get a chance to run.
1842 *
1843 * This is a bit hackish and will not work too well if the machine is
1844 * under heavy load from non-VM processes.
1845 *
1846 * @returns VINF_SUCCESS if not yielded.
1847 * VINF_GVM_YIELDED if an attempt to switch to a different VM task was made.
1848 * @param pVM Pointer to the shared VM structure.
1849 * @param idCpu The Virtual CPU ID of the calling EMT.
1850 * @param u64ExpireGipTime The time for the sleep to expire expressed as GIP time.
1851 * @param fYield Whether to yield or not.
1852 * This is for when we're spinning in the halt loop.
1853 * @thread EMT(idCpu).
1854 */
1855GVMMR0DECL(int) GVMMR0SchedPoll(PVM pVM, VMCPUID idCpu, bool fYield)
1856{
1857 /*
1858 * Validate input.
1859 */
1860 PGVM pGVM;
1861 PGVMM pGVMM;
1862 int rc = gvmmR0ByVMAndEMT(pVM, idCpu, &pGVM, &pGVMM);
1863 if (RT_SUCCESS(rc))
1864 {
1865 rc = gvmmR0UsedLock(pGVMM);
1866 AssertRC(rc);
1867 pGVM->gvmm.s.StatsSched.cPollCalls++;
1868
1869 Assert(ASMGetFlags() & X86_EFL_IF);
1870 const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
1871
1872 if (!fYield)
1873 pGVM->gvmm.s.StatsSched.cPollWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
1874 else
1875 {
1876 /** @todo implement this... */
1877 rc = VERR_NOT_IMPLEMENTED;
1878 }
1879
1880 gvmmR0UsedUnlock(pGVMM);
1881 }
1882
1883 LogFlow(("GVMMR0SchedWakeUp: returns %Rrc\n", rc));
1884 return rc;
1885}
1886
1887
1888
1889/**
1890 * Retrieves the GVMM statistics visible to the caller.
1891 *
1892 * @returns VBox status code.
1893 *
1894 * @param pStats Where to put the statistics.
1895 * @param pSession The current session.
1896 * @param pVM The VM to obtain statistics for. Optional.
1897 */
1898GVMMR0DECL(int) GVMMR0QueryStatistics(PGVMMSTATS pStats, PSUPDRVSESSION pSession, PVM pVM)
1899{
1900 LogFlow(("GVMMR0QueryStatistics: pStats=%p pSession=%p pVM=%p\n", pStats, pSession, pVM));
1901
1902 /*
1903 * Validate input.
1904 */
1905 AssertPtrReturn(pSession, VERR_INVALID_POINTER);
1906 AssertPtrReturn(pStats, VERR_INVALID_POINTER);
1907 pStats->cVMs = 0; /* (crash before taking the sem...) */
1908
1909 /*
1910 * Take the lock and get the VM statistics.
1911 */
1912 PGVMM pGVMM;
1913 if (pVM)
1914 {
1915 PGVM pGVM;
1916 int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /*fTakeUsedLock*/);
1917 if (RT_FAILURE(rc))
1918 return rc;
1919 pStats->SchedVM = pGVM->gvmm.s.StatsSched;
1920 }
1921 else
1922 {
1923 GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
1924 memset(&pStats->SchedVM, 0, sizeof(pStats->SchedVM));
1925
1926 int rc = gvmmR0UsedLock(pGVMM);
1927 AssertRCReturn(rc, rc);
1928 }
1929
1930 /*
1931 * Enumerate the VMs and add the ones visibile to the statistics.
1932 */
1933 pStats->cVMs = 0;
1934 pStats->cEMTs = 0;
1935 memset(&pStats->SchedSum, 0, sizeof(pStats->SchedSum));
1936
1937 for (unsigned i = pGVMM->iUsedHead;
1938 i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
1939 i = pGVMM->aHandles[i].iNext)
1940 {
1941 PGVM pGVM = pGVMM->aHandles[i].pGVM;
1942 void *pvObj = pGVMM->aHandles[i].pvObj;
1943 if ( VALID_PTR(pvObj)
1944 && VALID_PTR(pGVM)
1945 && pGVM->u32Magic == GVM_MAGIC
1946 && RT_SUCCESS(SUPR0ObjVerifyAccess(pvObj, pSession, NULL)))
1947 {
1948 pStats->cVMs++;
1949 pStats->cEMTs += pGVM->cCpus;
1950
1951 pStats->SchedSum.cHaltCalls += pGVM->gvmm.s.StatsSched.cHaltCalls;
1952 pStats->SchedSum.cHaltBlocking += pGVM->gvmm.s.StatsSched.cHaltBlocking;
1953 pStats->SchedSum.cHaltTimeouts += pGVM->gvmm.s.StatsSched.cHaltTimeouts;
1954 pStats->SchedSum.cHaltNotBlocking += pGVM->gvmm.s.StatsSched.cHaltNotBlocking;
1955 pStats->SchedSum.cHaltWakeUps += pGVM->gvmm.s.StatsSched.cHaltWakeUps;
1956
1957 pStats->SchedSum.cWakeUpCalls += pGVM->gvmm.s.StatsSched.cWakeUpCalls;
1958 pStats->SchedSum.cWakeUpNotHalted += pGVM->gvmm.s.StatsSched.cWakeUpNotHalted;
1959 pStats->SchedSum.cWakeUpWakeUps += pGVM->gvmm.s.StatsSched.cWakeUpWakeUps;
1960
1961 pStats->SchedSum.cPokeCalls += pGVM->gvmm.s.StatsSched.cPokeCalls;
1962 pStats->SchedSum.cPokeNotBusy += pGVM->gvmm.s.StatsSched.cPokeNotBusy;
1963
1964 pStats->SchedSum.cPollCalls += pGVM->gvmm.s.StatsSched.cPollCalls;
1965 pStats->SchedSum.cPollHalts += pGVM->gvmm.s.StatsSched.cPollHalts;
1966 pStats->SchedSum.cPollWakeUps += pGVM->gvmm.s.StatsSched.cPollWakeUps;
1967 }
1968 }
1969
1970 gvmmR0UsedUnlock(pGVMM);
1971
1972 return VINF_SUCCESS;
1973}
1974
1975
1976/**
1977 * VMMR0 request wrapper for GVMMR0QueryStatistics.
1978 *
1979 * @returns see GVMMR0QueryStatistics.
1980 * @param pVM Pointer to the shared VM structure. Optional.
1981 * @param pReq The request packet.
1982 */
1983GVMMR0DECL(int) GVMMR0QueryStatisticsReq(PVM pVM, PGVMMQUERYSTATISTICSSREQ pReq)
1984{
1985 /*
1986 * Validate input and pass it on.
1987 */
1988 AssertPtrReturn(pReq, VERR_INVALID_POINTER);
1989 AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
1990
1991 return GVMMR0QueryStatistics(&pReq->Stats, pReq->pSession, pVM);
1992}
1993
1994
1995/**
1996 * Resets the specified GVMM statistics.
1997 *
1998 * @returns VBox status code.
1999 *
2000 * @param pStats Which statistics to reset, that is, non-zero fields indicates which to reset.
2001 * @param pSession The current session.
2002 * @param pVM The VM to reset statistics for. Optional.
2003 */
2004GVMMR0DECL(int) GVMMR0ResetStatistics(PCGVMMSTATS pStats, PSUPDRVSESSION pSession, PVM pVM)
2005{
2006 LogFlow(("GVMMR0ResetStatistics: pStats=%p pSession=%p pVM=%p\n", pStats, pSession, pVM));
2007
2008 /*
2009 * Validate input.
2010 */
2011 AssertPtrReturn(pSession, VERR_INVALID_POINTER);
2012 AssertPtrReturn(pStats, VERR_INVALID_POINTER);
2013
2014 /*
2015 * Take the lock and get the VM statistics.
2016 */
2017 PGVMM pGVMM;
2018 if (pVM)
2019 {
2020 PGVM pGVM;
2021 int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /*fTakeUsedLock*/);
2022 if (RT_FAILURE(rc))
2023 return rc;
2024# define MAYBE_RESET_FIELD(field) \
2025 do { if (pStats->SchedVM. field ) { pGVM->gvmm.s.StatsSched. field = 0; } } while (0)
2026 MAYBE_RESET_FIELD(cHaltCalls);
2027 MAYBE_RESET_FIELD(cHaltBlocking);
2028 MAYBE_RESET_FIELD(cHaltTimeouts);
2029 MAYBE_RESET_FIELD(cHaltNotBlocking);
2030 MAYBE_RESET_FIELD(cHaltWakeUps);
2031 MAYBE_RESET_FIELD(cWakeUpCalls);
2032 MAYBE_RESET_FIELD(cWakeUpNotHalted);
2033 MAYBE_RESET_FIELD(cWakeUpWakeUps);
2034 MAYBE_RESET_FIELD(cPokeCalls);
2035 MAYBE_RESET_FIELD(cPokeNotBusy);
2036 MAYBE_RESET_FIELD(cPollCalls);
2037 MAYBE_RESET_FIELD(cPollHalts);
2038 MAYBE_RESET_FIELD(cPollWakeUps);
2039# undef MAYBE_RESET_FIELD
2040 }
2041 else
2042 {
2043 GVMM_GET_VALID_INSTANCE(pGVMM, VERR_INTERNAL_ERROR);
2044
2045 int rc = gvmmR0UsedLock(pGVMM);
2046 AssertRCReturn(rc, rc);
2047 }
2048
2049 /*
2050 * Enumerate the VMs and add the ones visibile to the statistics.
2051 */
2052 if (ASMMemIsAll8(&pStats->SchedSum, sizeof(pStats->SchedSum), 0))
2053 {
2054 for (unsigned i = pGVMM->iUsedHead;
2055 i != NIL_GVM_HANDLE && i < RT_ELEMENTS(pGVMM->aHandles);
2056 i = pGVMM->aHandles[i].iNext)
2057 {
2058 PGVM pGVM = pGVMM->aHandles[i].pGVM;
2059 void *pvObj = pGVMM->aHandles[i].pvObj;
2060 if ( VALID_PTR(pvObj)
2061 && VALID_PTR(pGVM)
2062 && pGVM->u32Magic == GVM_MAGIC
2063 && RT_SUCCESS(SUPR0ObjVerifyAccess(pvObj, pSession, NULL)))
2064 {
2065# define MAYBE_RESET_FIELD(field) \
2066 do { if (pStats->SchedSum. field ) { pGVM->gvmm.s.StatsSched. field = 0; } } while (0)
2067 MAYBE_RESET_FIELD(cHaltCalls);
2068 MAYBE_RESET_FIELD(cHaltBlocking);
2069 MAYBE_RESET_FIELD(cHaltTimeouts);
2070 MAYBE_RESET_FIELD(cHaltNotBlocking);
2071 MAYBE_RESET_FIELD(cHaltWakeUps);
2072 MAYBE_RESET_FIELD(cWakeUpCalls);
2073 MAYBE_RESET_FIELD(cWakeUpNotHalted);
2074 MAYBE_RESET_FIELD(cWakeUpWakeUps);
2075 MAYBE_RESET_FIELD(cPokeCalls);
2076 MAYBE_RESET_FIELD(cPokeNotBusy);
2077 MAYBE_RESET_FIELD(cPollCalls);
2078 MAYBE_RESET_FIELD(cPollHalts);
2079 MAYBE_RESET_FIELD(cPollWakeUps);
2080# undef MAYBE_RESET_FIELD
2081 }
2082 }
2083 }
2084
2085 gvmmR0UsedUnlock(pGVMM);
2086
2087 return VINF_SUCCESS;
2088}
2089
2090
2091/**
2092 * VMMR0 request wrapper for GVMMR0ResetStatistics.
2093 *
2094 * @returns see GVMMR0ResetStatistics.
2095 * @param pVM Pointer to the shared VM structure. Optional.
2096 * @param pReq The request packet.
2097 */
2098GVMMR0DECL(int) GVMMR0ResetStatisticsReq(PVM pVM, PGVMMRESETSTATISTICSSREQ pReq)
2099{
2100 /*
2101 * Validate input and pass it on.
2102 */
2103 AssertPtrReturn(pReq, VERR_INVALID_POINTER);
2104 AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
2105
2106 return GVMMR0ResetStatistics(&pReq->Stats, pReq->pSession, pVM);
2107}
2108
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