VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/GMM.cpp@ 77758

Last change on this file since 77758 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 13.6 KB
Line 
1/* $Id: GMM.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * GMM - Global Memory Manager, ring-3 request wrappers.
4 */
5
6/*
7 * Copyright (C) 2008-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_GMM
23#include <VBox/vmm/gmm.h>
24#include <VBox/vmm/vmm.h>
25#include <VBox/vmm/vm.h>
26#include <VBox/sup.h>
27#include <VBox/err.h>
28#include <VBox/param.h>
29
30#include <iprt/assert.h>
31#include <VBox/log.h>
32#include <iprt/mem.h>
33#include <iprt/string.h>
34
35
36/**
37 * @see GMMR0InitialReservation
38 */
39GMMR3DECL(int) GMMR3InitialReservation(PVM pVM, uint64_t cBasePages, uint32_t cShadowPages, uint32_t cFixedPages,
40 GMMOCPOLICY enmPolicy, GMMPRIORITY enmPriority)
41{
42 GMMINITIALRESERVATIONREQ Req;
43 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
44 Req.Hdr.cbReq = sizeof(Req);
45 Req.cBasePages = cBasePages;
46 Req.cShadowPages = cShadowPages;
47 Req.cFixedPages = cFixedPages;
48 Req.enmPolicy = enmPolicy;
49 Req.enmPriority = enmPriority;
50 return VMMR3CallR0(pVM, VMMR0_DO_GMM_INITIAL_RESERVATION, 0, &Req.Hdr);
51}
52
53
54/**
55 * @see GMMR0UpdateReservation
56 */
57GMMR3DECL(int) GMMR3UpdateReservation(PVM pVM, uint64_t cBasePages, uint32_t cShadowPages, uint32_t cFixedPages)
58{
59 GMMUPDATERESERVATIONREQ Req;
60 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
61 Req.Hdr.cbReq = sizeof(Req);
62 Req.cBasePages = cBasePages;
63 Req.cShadowPages = cShadowPages;
64 Req.cFixedPages = cFixedPages;
65 return VMMR3CallR0(pVM, VMMR0_DO_GMM_UPDATE_RESERVATION, 0, &Req.Hdr);
66}
67
68
69/**
70 * Prepares a GMMR0AllocatePages request.
71 *
72 * @returns VINF_SUCCESS or VERR_NO_TMP_MEMORY.
73 * @param pVM The cross context VM structure.
74 * @param[out] ppReq Where to store the pointer to the request packet.
75 * @param cPages The number of pages that's to be allocated.
76 * @param enmAccount The account to charge.
77 */
78GMMR3DECL(int) GMMR3AllocatePagesPrepare(PVM pVM, PGMMALLOCATEPAGESREQ *ppReq, uint32_t cPages, GMMACCOUNT enmAccount)
79{
80 uint32_t cb = RT_UOFFSETOF_DYN(GMMALLOCATEPAGESREQ, aPages[cPages]);
81 PGMMALLOCATEPAGESREQ pReq = (PGMMALLOCATEPAGESREQ)RTMemTmpAllocZ(cb);
82 if (!pReq)
83 return VERR_NO_TMP_MEMORY;
84
85 pReq->Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
86 pReq->Hdr.cbReq = cb;
87 pReq->enmAccount = enmAccount;
88 pReq->cPages = cPages;
89 NOREF(pVM);
90 *ppReq = pReq;
91 return VINF_SUCCESS;
92}
93
94
95/**
96 * Performs a GMMR0AllocatePages request.
97 *
98 * This will call VMSetError on failure.
99 *
100 * @returns VBox status code.
101 * @param pVM The cross context VM structure.
102 * @param pReq Pointer to the request (returned by GMMR3AllocatePagesPrepare).
103 */
104GMMR3DECL(int) GMMR3AllocatePagesPerform(PVM pVM, PGMMALLOCATEPAGESREQ pReq)
105{
106 for (unsigned i = 0; ; i++)
107 {
108 int rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_ALLOCATE_PAGES, 0, &pReq->Hdr);
109 if (RT_SUCCESS(rc))
110 {
111#ifdef LOG_ENABLED
112 for (uint32_t iPage = 0; iPage < pReq->cPages; iPage++)
113 Log3(("GMMR3AllocatePagesPerform: idPage=%#x HCPhys=%RHp\n",
114 pReq->aPages[iPage].idPage, pReq->aPages[iPage].HCPhysGCPhys));
115#endif
116 return rc;
117 }
118 if (rc != VERR_GMM_SEED_ME)
119 return VMSetError(pVM, rc, RT_SRC_POS,
120 N_("GMMR0AllocatePages failed to allocate %u pages"),
121 pReq->cPages);
122 Assert(i < pReq->cPages);
123
124 /*
125 * Seed another chunk.
126 */
127 void *pvChunk;
128 rc = SUPR3PageAlloc(GMM_CHUNK_SIZE >> PAGE_SHIFT, &pvChunk);
129 if (RT_FAILURE(rc))
130 return VMSetError(pVM, rc, RT_SRC_POS,
131 N_("Out of memory (SUPR3PageAlloc) seeding a %u pages allocation request"),
132 pReq->cPages);
133
134 rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_SEED_CHUNK, (uintptr_t)pvChunk, NULL);
135 if (RT_FAILURE(rc))
136 return VMSetError(pVM, rc, RT_SRC_POS, N_("GMM seeding failed"));
137 }
138}
139
140
141/**
142 * Cleans up a GMMR0AllocatePages request.
143 * @param pReq Pointer to the request (returned by GMMR3AllocatePagesPrepare).
144 */
145GMMR3DECL(void) GMMR3AllocatePagesCleanup(PGMMALLOCATEPAGESREQ pReq)
146{
147 RTMemTmpFree(pReq);
148}
149
150
151/**
152 * Prepares a GMMR0FreePages request.
153 *
154 * @returns VINF_SUCCESS or VERR_NO_TMP_MEMORY.
155 * @param pVM The cross context VM structure.
156 * @param[out] ppReq Where to store the pointer to the request packet.
157 * @param cPages The number of pages that's to be freed.
158 * @param enmAccount The account to charge.
159 */
160GMMR3DECL(int) GMMR3FreePagesPrepare(PVM pVM, PGMMFREEPAGESREQ *ppReq, uint32_t cPages, GMMACCOUNT enmAccount)
161{
162 uint32_t cb = RT_UOFFSETOF_DYN(GMMFREEPAGESREQ, aPages[cPages]);
163 PGMMFREEPAGESREQ pReq = (PGMMFREEPAGESREQ)RTMemTmpAllocZ(cb);
164 if (!pReq)
165 return VERR_NO_TMP_MEMORY;
166
167 pReq->Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
168 pReq->Hdr.cbReq = cb;
169 pReq->enmAccount = enmAccount;
170 pReq->cPages = cPages;
171 NOREF(pVM);
172 *ppReq = pReq;
173 return VINF_SUCCESS;
174}
175
176
177/**
178 * Re-prepares a GMMR0FreePages request.
179 *
180 * @returns VINF_SUCCESS or VERR_NO_TMP_MEMORY.
181 * @param pVM The cross context VM structure.
182 * @param pReq A request buffer previously returned by
183 * GMMR3FreePagesPrepare().
184 * @param cPages The number of pages originally passed to
185 * GMMR3FreePagesPrepare().
186 * @param enmAccount The account to charge.
187 */
188GMMR3DECL(void) GMMR3FreePagesRePrep(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t cPages, GMMACCOUNT enmAccount)
189{
190 Assert(pReq->Hdr.u32Magic == SUPVMMR0REQHDR_MAGIC);
191 pReq->Hdr.cbReq = RT_UOFFSETOF_DYN(GMMFREEPAGESREQ, aPages[cPages]);
192 pReq->enmAccount = enmAccount;
193 pReq->cPages = cPages;
194 NOREF(pVM);
195}
196
197
198/**
199 * Performs a GMMR0FreePages request.
200 * This will call VMSetError on failure.
201 *
202 * @returns VBox status code.
203 * @param pVM The cross context VM structure.
204 * @param pReq Pointer to the request (returned by GMMR3FreePagesPrepare).
205 * @param cActualPages The number of pages actually freed.
206 */
207GMMR3DECL(int) GMMR3FreePagesPerform(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t cActualPages)
208{
209 /*
210 * Adjust the request if we ended up with fewer pages than anticipated.
211 */
212 if (cActualPages != pReq->cPages)
213 {
214 AssertReturn(cActualPages < pReq->cPages, VERR_GMM_ACTUAL_PAGES_IPE);
215 if (!cActualPages)
216 return VINF_SUCCESS;
217 pReq->cPages = cActualPages;
218 pReq->Hdr.cbReq = RT_UOFFSETOF_DYN(GMMFREEPAGESREQ, aPages[cActualPages]);
219 }
220
221 /*
222 * Do the job.
223 */
224 int rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_FREE_PAGES, 0, &pReq->Hdr);
225 if (RT_SUCCESS(rc))
226 return rc;
227 AssertRC(rc);
228 return VMSetError(pVM, rc, RT_SRC_POS,
229 N_("GMMR0FreePages failed to free %u pages"),
230 pReq->cPages);
231}
232
233
234/**
235 * Cleans up a GMMR0FreePages request.
236 * @param pReq Pointer to the request (returned by GMMR3FreePagesPrepare).
237 */
238GMMR3DECL(void) GMMR3FreePagesCleanup(PGMMFREEPAGESREQ pReq)
239{
240 RTMemTmpFree(pReq);
241}
242
243
244/**
245 * Frees allocated pages, for bailing out on failure.
246 *
247 * This will not call VMSetError on failure but will use AssertLogRel instead.
248 *
249 * @param pVM The cross context VM structure.
250 * @param pAllocReq The allocation request to undo.
251 */
252GMMR3DECL(void) GMMR3FreeAllocatedPages(PVM pVM, GMMALLOCATEPAGESREQ const *pAllocReq)
253{
254 uint32_t cb = RT_UOFFSETOF_DYN(GMMFREEPAGESREQ, aPages[pAllocReq->cPages]);
255 PGMMFREEPAGESREQ pReq = (PGMMFREEPAGESREQ)RTMemTmpAllocZ(cb);
256 AssertLogRelReturnVoid(pReq);
257
258 pReq->Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
259 pReq->Hdr.cbReq = cb;
260 pReq->enmAccount = pAllocReq->enmAccount;
261 pReq->cPages = pAllocReq->cPages;
262 uint32_t iPage = pAllocReq->cPages;
263 while (iPage-- > 0)
264 {
265 Assert(pAllocReq->aPages[iPage].idPage != NIL_GMM_PAGEID);
266 pReq->aPages[iPage].idPage = pAllocReq->aPages[iPage].idPage;
267 }
268
269 int rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_FREE_PAGES, 0, &pReq->Hdr);
270 AssertLogRelRC(rc);
271
272 RTMemTmpFree(pReq);
273}
274
275
276/**
277 * @see GMMR0BalloonedPages
278 */
279GMMR3DECL(int) GMMR3BalloonedPages(PVM pVM, GMMBALLOONACTION enmAction, uint32_t cBalloonedPages)
280{
281 GMMBALLOONEDPAGESREQ Req;
282 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
283 Req.Hdr.cbReq = sizeof(Req);
284 Req.enmAction = enmAction;
285 Req.cBalloonedPages = cBalloonedPages;
286
287 return VMMR3CallR0(pVM, VMMR0_DO_GMM_BALLOONED_PAGES, 0, &Req.Hdr);
288}
289
290
291/**
292 * @see GMMR0QueryVMMMemoryStatsReq
293 */
294GMMR3DECL(int) GMMR3QueryHypervisorMemoryStats(PVM pVM, uint64_t *pcTotalAllocPages, uint64_t *pcTotalFreePages, uint64_t *pcTotalBalloonPages, uint64_t *puTotalBalloonSize)
295{
296 GMMMEMSTATSREQ Req;
297 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
298 Req.Hdr.cbReq = sizeof(Req);
299 Req.cAllocPages = 0;
300 Req.cFreePages = 0;
301 Req.cBalloonedPages = 0;
302 Req.cSharedPages = 0;
303
304 *pcTotalAllocPages = 0;
305 *pcTotalFreePages = 0;
306 *pcTotalBalloonPages = 0;
307 *puTotalBalloonSize = 0;
308
309 /* Must be callable from any thread, so can't use VMMR3CallR0. */
310 int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GMM_QUERY_HYPERVISOR_MEM_STATS, 0, &Req.Hdr);
311 if (rc == VINF_SUCCESS)
312 {
313 *pcTotalAllocPages = Req.cAllocPages;
314 *pcTotalFreePages = Req.cFreePages;
315 *pcTotalBalloonPages = Req.cBalloonedPages;
316 *puTotalBalloonSize = Req.cSharedPages;
317 }
318 return rc;
319}
320
321
322/**
323 * @see GMMR0QueryMemoryStatsReq
324 */
325GMMR3DECL(int) GMMR3QueryMemoryStats(PVM pVM, uint64_t *pcAllocPages, uint64_t *pcMaxPages, uint64_t *pcBalloonPages)
326{
327 GMMMEMSTATSREQ Req;
328 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
329 Req.Hdr.cbReq = sizeof(Req);
330 Req.cAllocPages = 0;
331 Req.cFreePages = 0;
332 Req.cBalloonedPages = 0;
333
334 *pcAllocPages = 0;
335 *pcMaxPages = 0;
336 *pcBalloonPages = 0;
337
338 int rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_QUERY_MEM_STATS, 0, &Req.Hdr);
339 if (rc == VINF_SUCCESS)
340 {
341 *pcAllocPages = Req.cAllocPages;
342 *pcMaxPages = Req.cMaxPages;
343 *pcBalloonPages = Req.cBalloonedPages;
344 }
345 return rc;
346}
347
348
349/**
350 * @see GMMR0MapUnmapChunk
351 */
352GMMR3DECL(int) GMMR3MapUnmapChunk(PVM pVM, uint32_t idChunkMap, uint32_t idChunkUnmap, PRTR3PTR ppvR3)
353{
354 GMMMAPUNMAPCHUNKREQ Req;
355 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
356 Req.Hdr.cbReq = sizeof(Req);
357 Req.idChunkMap = idChunkMap;
358 Req.idChunkUnmap = idChunkUnmap;
359 Req.pvR3 = NULL;
360 int rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_MAP_UNMAP_CHUNK, 0, &Req.Hdr);
361 if (RT_SUCCESS(rc) && ppvR3)
362 *ppvR3 = Req.pvR3;
363 return rc;
364}
365
366
367/**
368 * @see GMMR0FreeLargePage
369 */
370GMMR3DECL(int) GMMR3FreeLargePage(PVM pVM, uint32_t idPage)
371{
372 GMMFREELARGEPAGEREQ Req;
373 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
374 Req.Hdr.cbReq = sizeof(Req);
375 Req.idPage = idPage;
376 return VMMR3CallR0(pVM, VMMR0_DO_GMM_FREE_LARGE_PAGE, 0, &Req.Hdr);
377}
378
379
380/**
381 * @see GMMR0SeedChunk
382 */
383GMMR3DECL(int) GMMR3SeedChunk(PVM pVM, RTR3PTR pvR3)
384{
385 return VMMR3CallR0(pVM, VMMR0_DO_GMM_SEED_CHUNK, (uintptr_t)pvR3, NULL);
386}
387
388
389/**
390 * @see GMMR0RegisterSharedModule
391 */
392GMMR3DECL(int) GMMR3RegisterSharedModule(PVM pVM, PGMMREGISTERSHAREDMODULEREQ pReq)
393{
394 pReq->Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
395 pReq->Hdr.cbReq = RT_UOFFSETOF_DYN(GMMREGISTERSHAREDMODULEREQ, aRegions[pReq->cRegions]);
396 int rc = VMMR3CallR0(pVM, VMMR0_DO_GMM_REGISTER_SHARED_MODULE, 0, &pReq->Hdr);
397 if (rc == VINF_SUCCESS)
398 rc = pReq->rc;
399 return rc;
400}
401
402
403/**
404 * @see GMMR0RegisterSharedModule
405 */
406GMMR3DECL(int) GMMR3UnregisterSharedModule(PVM pVM, PGMMUNREGISTERSHAREDMODULEREQ pReq)
407{
408 pReq->Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
409 pReq->Hdr.cbReq = sizeof(*pReq);
410 return VMMR3CallR0(pVM, VMMR0_DO_GMM_UNREGISTER_SHARED_MODULE, 0, &pReq->Hdr);
411}
412
413
414/**
415 * @see GMMR0ResetSharedModules
416 */
417GMMR3DECL(int) GMMR3ResetSharedModules(PVM pVM)
418{
419 return VMMR3CallR0(pVM, VMMR0_DO_GMM_RESET_SHARED_MODULES, 0, NULL);
420}
421
422
423/**
424 * @see GMMR0CheckSharedModules
425 */
426GMMR3DECL(int) GMMR3CheckSharedModules(PVM pVM)
427{
428 return VMMR3CallR0(pVM, VMMR0_DO_GMM_CHECK_SHARED_MODULES, 0, NULL);
429}
430
431
432#if defined(VBOX_STRICT) && HC_ARCH_BITS == 64
433/**
434 * @see GMMR0FindDuplicatePage
435 */
436GMMR3DECL(bool) GMMR3IsDuplicatePage(PVM pVM, uint32_t idPage)
437{
438 GMMFINDDUPLICATEPAGEREQ Req;
439 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
440 Req.Hdr.cbReq = sizeof(Req);
441 Req.idPage = idPage;
442 Req.fDuplicate = false;
443
444 /* Must be callable from any thread, so can't use VMMR3CallR0. */
445 int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GMM_FIND_DUPLICATE_PAGE, 0, &Req.Hdr);
446 if (rc == VINF_SUCCESS)
447 return Req.fDuplicate;
448 return false;
449}
450#endif /* VBOX_STRICT && HC_ARCH_BITS == 64 */
451
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