VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServiceBalloon.cpp@ 69500

Last change on this file since 69500 was 69500, checked in by vboxsync, 7 years ago

*: scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 13.5 KB
Line 
1/* $Id: VBoxServiceBalloon.cpp 69500 2017-10-28 15:14:05Z vboxsync $ */
2/** @file
3 * VBoxService - Memory Ballooning.
4 */
5
6/*
7 * Copyright (C) 2006-2017 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_vgsvc_memballoon VBoxService - Memory Ballooning
20 *
21 * The Memory Ballooning subservice works with VBoxGuest, PGM and GMM to
22 * dynamically reallocate memory between VMs.
23 *
24 * Memory ballooning is typically used to deal with overcomitting memory on the
25 * host. It allowes you to borrow memory from one or more VMs and make it
26 * available to others. In theory it could also be used to make memory
27 * available to the host system, however memory fragmentation typically makes
28 * that difficult.
29 *
30 * The memory ballooning subservices talks to PGM, GMM and Main via the VMMDev.
31 * It polls for change requests at an interval and executes them when they
32 * arrive. There are two ways we implement the actual ballooning, either
33 * VBoxGuest allocates kernel memory and donates it to the host, or this service
34 * allocates process memory which VBoxGuest then locks down and donates to the
35 * host. While we prefer the former method it is not practicable on all OS and
36 * we have to use the latter.
37 *
38 */
39
40
41/*********************************************************************************************************************************
42* Header Files *
43*********************************************************************************************************************************/
44#include <iprt/assert.h>
45#include <iprt/mem.h>
46#include <iprt/stream.h>
47#include <iprt/string.h>
48#include <iprt/semaphore.h>
49#include <iprt/system.h>
50#include <iprt/thread.h>
51#include <iprt/time.h>
52#include <VBox/VBoxGuestLib.h>
53#include "VBoxServiceInternal.h"
54#include "VBoxServiceUtils.h"
55
56#ifdef RT_OS_LINUX
57# include <iprt/param.h>
58# include <sys/mman.h>
59# ifndef MADV_DONTFORK
60# define MADV_DONTFORK 10
61# endif
62#endif
63
64
65
66/*********************************************************************************************************************************
67* Global Variables *
68*********************************************************************************************************************************/
69/** The balloon size. */
70static uint32_t g_cMemBalloonChunks = 0;
71
72/** The semaphore we're blocking on. */
73static RTSEMEVENTMULTI g_MemBalloonEvent = NIL_RTSEMEVENTMULTI;
74
75/** The array holding the R3 pointers of the balloon. */
76static void **g_pavBalloon = NULL;
77
78#ifdef RT_OS_LINUX
79/** True = madvise(MADV_DONTFORK) works, false otherwise. */
80static bool g_fSysMadviseWorks;
81#endif
82
83
84/**
85 * Check whether madvise() works.
86 */
87static void vgsvcBalloonInitMadvise(void)
88{
89#ifdef RT_OS_LINUX
90 void *pv = (void*)mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
91 if (pv != MAP_FAILED)
92 {
93 g_fSysMadviseWorks = madvise(pv, PAGE_SIZE, MADV_DONTFORK) == 0;
94 munmap(pv, PAGE_SIZE);
95 }
96#endif
97}
98
99
100/**
101 * Allocate a chunk of the balloon. Fulfil the prerequisite that we can lock this memory
102 * and protect it against fork() in R0. See also suplibOsPageAlloc().
103 */
104static void *VGSvcBalloonAllocChunk(void)
105{
106 size_t cb = VMMDEV_MEMORY_BALLOON_CHUNK_SIZE;
107 char *pu8;
108
109#ifdef RT_OS_LINUX
110 if (!g_fSysMadviseWorks)
111 cb += 2 * PAGE_SIZE;
112
113 pu8 = (char*)mmap(NULL, cb, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
114 if (pu8 == MAP_FAILED)
115 return NULL;
116
117 if (g_fSysMadviseWorks)
118 {
119 /*
120 * It is not fatal if we fail here but a forked child (e.g. the ALSA sound server)
121 * could crash. Linux < 2.6.16 does not implement madvise(MADV_DONTFORK) but the
122 * kernel seems to split bigger VMAs and that is all that we want -- later we set the
123 * VM_DONTCOPY attribute in supdrvOSLockMemOne().
124 */
125 madvise(pu8, cb, MADV_DONTFORK);
126 }
127 else
128 {
129 /*
130 * madvise(MADV_DONTFORK) is not available (most probably Linux 2.4). Enclose any
131 * mmapped region by two unmapped pages to guarantee that there is exactly one VM
132 * area struct of the very same size as the mmap area.
133 */
134 RTMemProtect(pu8, PAGE_SIZE, RTMEM_PROT_NONE);
135 RTMemProtect(pu8 + cb - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_NONE);
136 pu8 += PAGE_SIZE;
137 }
138
139#else
140
141 pu8 = (char*)RTMemPageAlloc(cb);
142 if (!pu8)
143 return pu8;
144
145#endif
146
147 memset(pu8, 0, VMMDEV_MEMORY_BALLOON_CHUNK_SIZE);
148 return pu8;
149}
150
151
152/**
153 * Free an allocated chunk undoing VGSvcBalloonAllocChunk().
154 */
155static void vgsvcBalloonFreeChunk(void *pv)
156{
157 char *pu8 = (char*)pv;
158 size_t cb = VMMDEV_MEMORY_BALLOON_CHUNK_SIZE;
159
160#ifdef RT_OS_LINUX
161
162 if (!g_fSysMadviseWorks)
163 {
164 cb += 2 * PAGE_SIZE;
165 pu8 -= PAGE_SIZE;
166 /* This is not really necessary */
167 RTMemProtect(pu8, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
168 RTMemProtect(pu8 + cb - PAGE_SIZE, PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
169 }
170 munmap(pu8, cb);
171
172#else
173
174 RTMemPageFree(pu8, cb);
175
176#endif
177}
178
179
180/**
181 * Adapt the R0 memory balloon by granting/reclaiming 1MB chunks to/from R0.
182 *
183 * returns IPRT status code.
184 * @param cNewChunks The new number of 1MB chunks in the balloon.
185 */
186static int vgsvcBalloonSetUser(uint32_t cNewChunks)
187{
188 if (cNewChunks == g_cMemBalloonChunks)
189 return VINF_SUCCESS;
190
191 VGSvcVerbose(3, "vgsvcBalloonSetUser: cNewChunks=%u g_cMemBalloonChunks=%u\n", cNewChunks, g_cMemBalloonChunks);
192 int rc = VINF_SUCCESS;
193 if (cNewChunks > g_cMemBalloonChunks)
194 {
195 /* inflate */
196 g_pavBalloon = (void**)RTMemRealloc(g_pavBalloon, cNewChunks * sizeof(void*));
197 uint32_t i;
198 for (i = g_cMemBalloonChunks; i < cNewChunks; i++)
199 {
200 void *pv = VGSvcBalloonAllocChunk();
201 if (!pv)
202 break;
203 rc = VbglR3MemBalloonChange(pv, /* inflate=*/ true);
204 if (RT_SUCCESS(rc))
205 {
206 g_pavBalloon[i] = pv;
207#ifndef RT_OS_SOLARIS
208 /*
209 * Protect against access by dangling pointers (ignore errors as it may fail).
210 * On Solaris it corrupts the address space leaving the process unkillable. This
211 * could perhaps be related to what the underlying segment driver does; currently
212 * just disable it.
213 */
214 RTMemProtect(pv, VMMDEV_MEMORY_BALLOON_CHUNK_SIZE, RTMEM_PROT_NONE);
215#endif
216 g_cMemBalloonChunks++;
217 }
218 else
219 {
220 vgsvcBalloonFreeChunk(pv);
221 break;
222 }
223 }
224 VGSvcVerbose(3, "vgsvcBalloonSetUser: inflation complete. chunks=%u rc=%d\n", i, rc);
225 }
226 else
227 {
228 /* deflate */
229 uint32_t i;
230 for (i = g_cMemBalloonChunks; i-- > cNewChunks;)
231 {
232 void *pv = g_pavBalloon[i];
233 rc = VbglR3MemBalloonChange(pv, /* inflate=*/ false);
234 if (RT_SUCCESS(rc))
235 {
236#ifndef RT_OS_SOLARIS
237 /* unprotect */
238 RTMemProtect(pv, VMMDEV_MEMORY_BALLOON_CHUNK_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
239#endif
240 vgsvcBalloonFreeChunk(pv);
241 g_pavBalloon[i] = NULL;
242 g_cMemBalloonChunks--;
243 }
244 else
245 break;
246 VGSvcVerbose(3, "vgsvcBalloonSetUser: deflation complete. chunks=%u rc=%d\n", i, rc);
247 }
248 }
249
250 return VINF_SUCCESS;
251}
252
253
254/**
255 * @interface_method_impl{VBOXSERVICE,pfnInit}
256 */
257static DECLCALLBACK(int) vgsvcBalloonInit(void)
258{
259 VGSvcVerbose(3, "vgsvcBalloonInit\n");
260
261 int rc = RTSemEventMultiCreate(&g_MemBalloonEvent);
262 AssertRCReturn(rc, rc);
263
264 vgsvcBalloonInitMadvise();
265
266 g_cMemBalloonChunks = 0;
267 uint32_t cNewChunks = 0;
268 bool fHandleInR3;
269
270 /* Check balloon size */
271 rc = VbglR3MemBalloonRefresh(&cNewChunks, &fHandleInR3);
272 if (RT_SUCCESS(rc))
273 {
274 VGSvcVerbose(3, "MemBalloon: New balloon size %d MB (%s memory)\n", cNewChunks, fHandleInR3 ? "R3" : "R0");
275 if (fHandleInR3)
276 rc = vgsvcBalloonSetUser(cNewChunks);
277 else
278 g_cMemBalloonChunks = cNewChunks;
279 }
280 if (RT_FAILURE(rc))
281 {
282 /* If the service was not found, we disable this service without
283 causing VBoxService to fail. */
284 if ( rc == VERR_NOT_IMPLEMENTED
285#ifdef RT_OS_WINDOWS /** @todo r=bird: Windows kernel driver should return VERR_NOT_IMPLEMENTED,
286 * VERR_INVALID_PARAMETER has too many other uses. */
287 || rc == VERR_INVALID_PARAMETER
288#endif
289 )
290 {
291 VGSvcVerbose(0, "MemBalloon: Memory ballooning support is not available\n");
292 rc = VERR_SERVICE_DISABLED;
293 }
294 else
295 {
296 VGSvcVerbose(3, "MemBalloon: VbglR3MemBalloonRefresh failed with %Rrc\n", rc);
297 rc = VERR_SERVICE_DISABLED; /** @todo Playing safe for now, figure out the exact status codes here. */
298 }
299 RTSemEventMultiDestroy(g_MemBalloonEvent);
300 g_MemBalloonEvent = NIL_RTSEMEVENTMULTI;
301 }
302
303 return rc;
304}
305
306
307/**
308 * Query the size of the memory balloon, given as a page count.
309 *
310 * @returns Number of pages.
311 * @param cbPage The page size.
312 */
313uint32_t VGSvcBalloonQueryPages(uint32_t cbPage)
314{
315 Assert(cbPage > 0);
316 return g_cMemBalloonChunks * (VMMDEV_MEMORY_BALLOON_CHUNK_SIZE / cbPage);
317}
318
319
320/**
321 * @interface_method_impl{VBOXSERVICE,pfnWorker}
322 */
323static DECLCALLBACK(int) vgsvcBalloonWorker(bool volatile *pfShutdown)
324{
325 /* Start monitoring of the stat event change event. */
326 int rc = VbglR3CtlFilterMask(VMMDEV_EVENT_BALLOON_CHANGE_REQUEST, 0);
327 if (RT_FAILURE(rc))
328 {
329 VGSvcVerbose(3, "vgsvcBalloonInit: VbglR3CtlFilterMask failed with %Rrc\n", rc);
330 return rc;
331 }
332
333 /*
334 * Tell the control thread that it can continue
335 * spawning services.
336 */
337 RTThreadUserSignal(RTThreadSelf());
338
339 /*
340 * Now enter the loop retrieving runtime data continuously.
341 */
342 for (;;)
343 {
344 uint32_t fEvents = 0;
345
346 /* Check if an update interval change is pending. */
347 rc = VbglR3WaitEvent(VMMDEV_EVENT_BALLOON_CHANGE_REQUEST, 0 /* no wait */, &fEvents);
348 if ( RT_SUCCESS(rc)
349 && (fEvents & VMMDEV_EVENT_BALLOON_CHANGE_REQUEST))
350 {
351 uint32_t cNewChunks;
352 bool fHandleInR3;
353 rc = VbglR3MemBalloonRefresh(&cNewChunks, &fHandleInR3);
354 if (RT_SUCCESS(rc))
355 {
356 VGSvcVerbose(3, "vgsvcBalloonInit: new balloon size %d MB (%s memory)\n", cNewChunks, fHandleInR3 ? "R3" : "R0");
357 if (fHandleInR3)
358 {
359 rc = vgsvcBalloonSetUser(cNewChunks);
360 if (RT_FAILURE(rc))
361 {
362 VGSvcVerbose(3, "vgsvcBalloonInit: failed to set balloon size %d MB (%s memory)\n",
363 cNewChunks, fHandleInR3 ? "R3" : "R0");
364 }
365 else
366 VGSvcVerbose(3, "vgsvcBalloonInit: successfully set requested balloon size %d.\n", cNewChunks);
367 }
368 else
369 g_cMemBalloonChunks = cNewChunks;
370 }
371 else
372 VGSvcVerbose(3, "vgsvcBalloonInit: VbglR3MemBalloonRefresh failed with %Rrc\n", rc);
373 }
374
375 /*
376 * Block for a while.
377 *
378 * The event semaphore takes care of ignoring interruptions and it
379 * allows us to implement service wakeup later.
380 */
381 if (*pfShutdown)
382 break;
383 int rc2 = RTSemEventMultiWait(g_MemBalloonEvent, 5000);
384 if (*pfShutdown)
385 break;
386 if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
387 {
388 VGSvcError("vgsvcBalloonInit: RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
389 rc = rc2;
390 break;
391 }
392 }
393
394 /* Cancel monitoring of the memory balloon change event. */
395 rc = VbglR3CtlFilterMask(0, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
396 if (RT_FAILURE(rc))
397 VGSvcVerbose(3, "vgsvcBalloonInit: VbglR3CtlFilterMask failed with %Rrc\n", rc);
398
399 VGSvcVerbose(3, "vgsvcBalloonInit: finished mem balloon change request thread\n");
400 return VINF_SUCCESS;
401}
402
403
404/**
405 * @interface_method_impl{VBOXSERVICE,pfnStop}
406 */
407static DECLCALLBACK(void) vgsvcBalloonStop(void)
408{
409 RTSemEventMultiSignal(g_MemBalloonEvent);
410}
411
412
413/**
414 * @interface_method_impl{VBOXSERVICE,pfnTerm}
415 */
416static DECLCALLBACK(void) vgsvcBalloonTerm(void)
417{
418 if (g_MemBalloonEvent != NIL_RTSEMEVENTMULTI)
419 {
420 RTSemEventMultiDestroy(g_MemBalloonEvent);
421 g_MemBalloonEvent = NIL_RTSEMEVENTMULTI;
422 }
423}
424
425
426/**
427 * The 'memballoon' service description.
428 */
429VBOXSERVICE g_MemBalloon =
430{
431 /* pszName. */
432 "memballoon",
433 /* pszDescription. */
434 "Memory Ballooning",
435 /* pszUsage. */
436 NULL,
437 /* pszOptions. */
438 NULL,
439 /* methods */
440 VGSvcDefaultPreInit,
441 VGSvcDefaultOption,
442 vgsvcBalloonInit,
443 vgsvcBalloonWorker,
444 vgsvcBalloonStop,
445 vgsvcBalloonTerm
446};
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