VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxBalloonCtrl/VBoxModBallooning.cpp@ 49469

Last change on this file since 49469 was 44875, checked in by vboxsync, 12 years ago

Frontends/VBoxBalloonCtrl: logging fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.7 KB
Line 
1/* $Id: VBoxModBallooning.cpp 44875 2013-02-28 19:34:16Z vboxsync $ */
2/** @file
3 * VBoxModBallooning - Module for handling the automatic ballooning of VMs.
4 */
5
6/*
7 * Copyright (C) 2011-2013 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#ifndef VBOX_ONLY_DOCS
23# include <VBox/com/errorprint.h>
24#endif /* !VBOX_ONLY_DOCS */
25
26#include "VBoxWatchdogInternal.h"
27#include <iprt/system.h>
28
29using namespace com;
30
31#define VBOX_MOD_BALLOONING_NAME "balloonctrl"
32
33/**
34 * The module's RTGetOpt-IDs for the command line.
35 */
36enum GETOPTDEF_BALLOONCTRL
37{
38 GETOPTDEF_BALLOONCTRL_BALLOONINC = 2000,
39 GETOPTDEF_BALLOONCTRL_BALLOONDEC,
40 GETOPTDEF_BALLOONCTRL_BALLOONLOWERLIMIT,
41 GETOPTDEF_BALLOONCTRL_BALLOONMAX,
42 GETOPTDEF_BALLOONCTRL_BALLOONSAFETY,
43 GETOPTDEF_BALLOONCTRL_TIMEOUTMS,
44 GETOPTDEF_BALLOONCTRL_GROUPS
45};
46
47/**
48 * The module's command line arguments.
49 */
50static const RTGETOPTDEF g_aBalloonOpts[] = {
51 { "--balloon-dec", GETOPTDEF_BALLOONCTRL_BALLOONDEC, RTGETOPT_REQ_UINT32 },
52 { "--balloon-groups", GETOPTDEF_BALLOONCTRL_GROUPS, RTGETOPT_REQ_STRING },
53 { "--balloon-inc", GETOPTDEF_BALLOONCTRL_BALLOONINC, RTGETOPT_REQ_UINT32 },
54 { "--balloon-interval", GETOPTDEF_BALLOONCTRL_TIMEOUTMS, RTGETOPT_REQ_UINT32 },
55 { "--balloon-lower-limit", GETOPTDEF_BALLOONCTRL_BALLOONLOWERLIMIT, RTGETOPT_REQ_UINT32 },
56 { "--balloon-max", GETOPTDEF_BALLOONCTRL_BALLOONMAX, RTGETOPT_REQ_UINT32 },
57 { "--balloon-safety-margin", GETOPTDEF_BALLOONCTRL_BALLOONSAFETY, RTGETOPT_REQ_UINT32 }
58};
59
60static unsigned long g_ulMemoryBalloonTimeoutMS = 0;
61static unsigned long g_ulMemoryBalloonIncrementMB = 0;
62static unsigned long g_ulMemoryBalloonDecrementMB = 0;
63/** Global balloon limit is 0, so disabled. Can be overridden by a per-VM
64 * "VBoxInternal/Guest/BalloonSizeMax" value. */
65static unsigned long g_ulMemoryBalloonMaxMB = 0;
66static unsigned long g_ulMemoryBalloonLowerLimitMB = 0;
67static unsigned long g_ulMemoryBalloonSafetyMB = _1K;
68
69/** The ballooning module's payload. */
70typedef struct VBOXWATCHDOG_BALLOONCTRL_PAYLOAD
71{
72 /** The maximum ballooning size for the VM.
73 * Specify 0 for ballooning disabled. */
74 unsigned long ulBalloonSizeMax;
75} VBOXWATCHDOG_BALLOONCTRL_PAYLOAD, *PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD;
76
77
78/**
79 * Retrieves the current delta value
80 *
81 * @return long Delta (MB) of the balloon to be deflated (<0) or inflated (>0).
82 * @param ulCurrentDesktopBalloonSize The balloon's current size.
83 * @param ulDesktopFreeMemory The VM's current free memory.
84 * @param ulMaxBalloonSize The maximum balloon size (MB) it can inflate to.
85 */
86static long balloonGetDelta(unsigned long ulCurrentDesktopBalloonSize,
87 unsigned long ulDesktopFreeMemory, unsigned long ulMaxBalloonSize)
88{
89 if (ulCurrentDesktopBalloonSize > ulMaxBalloonSize)
90 return (ulMaxBalloonSize - ulCurrentDesktopBalloonSize);
91
92 long lBalloonDelta = 0;
93 if (ulDesktopFreeMemory < g_ulMemoryBalloonLowerLimitMB)
94 {
95 /* Guest is running low on memory, we need to
96 * deflate the balloon. */
97 lBalloonDelta = (g_ulMemoryBalloonDecrementMB * -1);
98
99 /* Ensure that the delta will not return a negative
100 * balloon size. */
101 if ((long)ulCurrentDesktopBalloonSize + lBalloonDelta < 0)
102 lBalloonDelta = 0;
103 }
104 else if (ulMaxBalloonSize > ulCurrentDesktopBalloonSize)
105 {
106 /* We want to inflate the balloon if we have room. */
107 long lIncrement = g_ulMemoryBalloonIncrementMB;
108 while (lIncrement >= 16 && (ulDesktopFreeMemory - lIncrement) < g_ulMemoryBalloonLowerLimitMB)
109 {
110 lIncrement = (lIncrement / 2);
111 }
112
113 if ((ulDesktopFreeMemory - lIncrement) > g_ulMemoryBalloonLowerLimitMB)
114 lBalloonDelta = lIncrement;
115 }
116 if (ulCurrentDesktopBalloonSize + lBalloonDelta > ulMaxBalloonSize)
117 lBalloonDelta = (ulMaxBalloonSize - ulCurrentDesktopBalloonSize);
118
119 /* Limit the ballooning to the available memory, leaving some free.
120 * If anything fails clamp the delta to 0. */
121 if (lBalloonDelta < 0)
122 {
123 uint64_t cbSafety = (uint64_t)g_ulMemoryBalloonSafetyMB * _1M;
124 uint64_t cbHostRamAvail = 0;
125 int vrc = RTSystemQueryAvailableRam(&cbHostRamAvail);
126 if (RT_SUCCESS(vrc))
127 {
128 if (cbHostRamAvail < cbSafety)
129 lBalloonDelta = 0;
130 else if ((uint64_t)(-lBalloonDelta) > (cbHostRamAvail - cbSafety) / _1M)
131 lBalloonDelta = -(long)((cbHostRamAvail - cbSafety) / _1M);
132 }
133 else
134 lBalloonDelta = 0;
135 }
136
137 return lBalloonDelta;
138}
139
140/**
141 * Determines the maximum balloon size to set for the specified machine.
142 *
143 * @return unsigned long Balloon size (in MB) to set, 0 if no ballooning required.
144 * @param rptrMachine Pointer to interface of specified machine.
145 */
146static unsigned long balloonGetMaxSize(const ComPtr<IMachine> &rptrMachine)
147{
148 /*
149 * Try to retrieve the balloon maximum size via the following order:
150 * - command line parameter ("--balloon-max")
151 * Legacy (VBoxBalloonCtrl):
152 * - per-VM parameter ("VBoxInternal/Guest/BalloonSizeMax")
153 * Global:
154 * - global parameter ("VBoxInternal/Guest/BalloonSizeMax")
155 * New:
156 * - per-VM parameter ("VBoxInternal2/Watchdog/BalloonCtrl/BalloonSizeMax")
157 *
158 * By default (e.g. if none of above is set), ballooning is disabled.
159 */
160 unsigned long ulBalloonMax = g_ulMemoryBalloonMaxMB;
161 if (!ulBalloonMax)
162 {
163 int vrc = cfgGetValueULong(g_pVirtualBox, rptrMachine,
164 "VBoxInternal/Guest/BalloonSizeMax", "VBoxInternal/Guest/BalloonSizeMax", &ulBalloonMax, 0 /* Ballooning disabled */);
165 if (RT_FAILURE(vrc))
166 {
167 /* Try (new) VBoxWatch per-VM approach. */
168 Bstr strValue;
169 HRESULT rc = rptrMachine->GetExtraData(Bstr("VBoxInternal2/Watchdog/BalloonCtrl/BalloonSizeMax").raw(),
170 strValue.asOutParam());
171 if ( SUCCEEDED(rc)
172 && !strValue.isEmpty())
173 {
174 ulBalloonMax = Utf8Str(strValue).toUInt32();
175 }
176 }
177 }
178
179 return ulBalloonMax;
180}
181
182/**
183 * Indicates whether ballooning on the specified machine state is
184 * possible -- this only is true if the machine is up and running.
185 *
186 * @return bool Flag indicating whether the VM is running or not.
187 * @param enmState The VM's machine state to judge whether it's running or not.
188 */
189static bool balloonIsPossible(MachineState_T enmState)
190{
191 switch (enmState)
192 {
193 case MachineState_Running:
194#if 0
195 /* Not required for ballooning. */
196 case MachineState_Teleporting:
197 case MachineState_LiveSnapshotting:
198 case MachineState_Paused:
199 case MachineState_TeleportingPausedVM:
200#endif
201 return true;
202 default:
203 break;
204 }
205 return false;
206}
207
208/**
209 * Determines whether ballooning is required to the specified machine.
210 *
211 * @return bool True if ballooning is required, false if not.
212 * @param pMachine Machine to determine ballooning for.
213 */
214static bool balloonIsRequired(PVBOXWATCHDOG_MACHINE pMachine)
215{
216 AssertPtrReturn(pMachine, false);
217
218 /* Only do ballooning if we have a maximum balloon size set. */
219 PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD pData = (PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD)
220 payloadFrom(pMachine, VBOX_MOD_BALLOONING_NAME);
221 AssertPtr(pData);
222 pData->ulBalloonSizeMax = pMachine->machine.isNull()
223 ? 0 : balloonGetMaxSize(pMachine->machine);
224
225 /** @todo Add grouping as a criteria! */
226
227 return pData->ulBalloonSizeMax ? true : false;
228}
229
230int balloonMachineSetup(const Bstr& strUuid)
231{
232 int vrc = VINF_SUCCESS;
233
234 do
235 {
236 PVBOXWATCHDOG_MACHINE pMachine = getMachine(strUuid);
237 AssertPtrBreakStmt(pMachine, vrc=VERR_INVALID_PARAMETER);
238
239 ComPtr<IMachine> m = pMachine->machine;
240
241 /*
242 * Setup metrics required for ballooning.
243 */
244 com::SafeArray<BSTR> metricNames(1);
245 com::SafeIfaceArray<IUnknown> metricObjects(1);
246 com::SafeIfaceArray<IPerformanceMetric> metricAffected;
247
248 Bstr strMetricNames(L"Guest/RAM/Usage");
249 strMetricNames.cloneTo(&metricNames[0]);
250
251 HRESULT rc = m.queryInterfaceTo(&metricObjects[0]);
252
253#ifdef VBOX_WATCHDOG_GLOBAL_PERFCOL
254 CHECK_ERROR_BREAK(g_pPerfCollector, SetupMetrics(ComSafeArrayAsInParam(metricNames),
255 ComSafeArrayAsInParam(metricObjects),
256 5 /* 5 seconds */,
257 1 /* One sample is enough */,
258 ComSafeArrayAsOutParam(metricAffected)));
259#else
260 ComPtr<IPerformanceCollector> coll = pMachine->collector;
261
262 CHECK_ERROR_BREAK(g_pVirtualBox, COMGETTER(PerformanceCollector)(coll.asOutParam()));
263 CHECK_ERROR_BREAK(coll, SetupMetrics(ComSafeArrayAsInParam(metricNames),
264 ComSafeArrayAsInParam(metricObjects),
265 5 /* 5 seconds */,
266 1 /* One sample is enough */,
267 ComSafeArrayAsOutParam(metricAffected)));
268#endif
269 if (FAILED(rc))
270 vrc = VERR_COM_IPRT_ERROR; /* @todo Find better rc! */
271
272 } while (0);
273
274 return vrc;
275}
276
277/**
278 * Does the actual ballooning and assumes the machine is
279 * capable and ready for ballooning.
280 *
281 * @return IPRT status code.
282 * @param strUuid UUID of the specified machine.
283 * @param pMachine Pointer to the machine's internal structure.
284 */
285static int balloonMachineUpdate(const Bstr &strUuid, PVBOXWATCHDOG_MACHINE pMachine)
286{
287 AssertPtrReturn(pMachine, VERR_INVALID_POINTER);
288
289 /*
290 * Get metrics collected at this point.
291 */
292 LONG lMemFree, lBalloonCur;
293 int vrc = getMetric(pMachine, L"Guest/RAM/Usage/Free", &lMemFree);
294 if (RT_SUCCESS(vrc))
295 vrc = getMetric(pMachine, L"Guest/RAM/Usage/Balloon", &lBalloonCur);
296
297 if (RT_SUCCESS(vrc))
298 {
299 /* If guest statistics are not up and running yet, skip this iteration
300 * and try next time. */
301 if (lMemFree <= 0)
302 {
303#ifdef DEBUG
304 serviceLogVerbose(("%ls: No metrics available yet!\n", strUuid.raw()));
305#endif
306 return VINF_SUCCESS;
307 }
308
309 lMemFree /= 1024;
310 lBalloonCur /= 1024;
311
312 PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD pData = (PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD)
313 payloadFrom(pMachine, VBOX_MOD_BALLOONING_NAME);
314 AssertPtr(pData);
315
316 serviceLogVerbose(("%ls: Balloon: %ld, Free mem: %ld, Max ballon: %ld\n",
317 strUuid.raw(),
318 lBalloonCur, lMemFree, pData->ulBalloonSizeMax));
319
320 /* Calculate current balloon delta. */
321 long lDelta = balloonGetDelta(lBalloonCur, lMemFree, pData->ulBalloonSizeMax);
322 if (lDelta) /* Only do ballooning if there's really smth. to change ... */
323 {
324 lBalloonCur = lBalloonCur + lDelta;
325 Assert(lBalloonCur > 0);
326
327 serviceLog("%ls: %s balloon by %ld to %ld ...\n",
328 strUuid.raw(),
329 lDelta > 0 ? "Inflating" : "Deflating", lDelta, lBalloonCur);
330
331 if (!g_fDryrun)
332 {
333 /* Open a session for the VM. */
334 HRESULT rc;
335 CHECK_ERROR(pMachine->machine, LockMachine(g_pSession, LockType_Shared));
336
337 do
338 {
339 /* Get the associated console. */
340 ComPtr<IConsole> console;
341 CHECK_ERROR_BREAK(g_pSession, COMGETTER(Console)(console.asOutParam()));
342
343 ComPtr <IGuest> guest;
344 rc = console->COMGETTER(Guest)(guest.asOutParam());
345 if (SUCCEEDED(rc))
346 CHECK_ERROR_BREAK(guest, COMSETTER(MemoryBalloonSize)(lBalloonCur));
347 else
348 serviceLog("Error: Unable to set new balloon size %ld for machine \"%ls\", rc=%Rhrc\n",
349 lBalloonCur, strUuid.raw(), rc);
350 if (FAILED(rc))
351 vrc = VERR_COM_IPRT_ERROR;
352 } while (0);
353
354 /* Unlock the machine again. */
355 g_pSession->UnlockMachine();
356 }
357 }
358 }
359 else
360 serviceLog("Error: Unable to retrieve metrics for machine \"%ls\", rc=%Rrc\n",
361 strUuid.raw(), vrc);
362 return vrc;
363}
364
365/* Callbacks. */
366static DECLCALLBACK(int) VBoxModBallooningPreInit(void)
367{
368 return VINF_SUCCESS;
369}
370
371static DECLCALLBACK(int) VBoxModBallooningOption(int argc, char *argv[], int *piConsumed)
372{
373 if (!argc) /* Take a shortcut. */
374 return -1;
375
376 AssertPtrReturn(argv, VERR_INVALID_POINTER);
377 AssertPtrReturn(piConsumed, VERR_INVALID_POINTER);
378
379 RTGETOPTSTATE GetState;
380 int rc = RTGetOptInit(&GetState, argc, argv,
381 g_aBalloonOpts, RT_ELEMENTS(g_aBalloonOpts),
382 0 /* First */, 0 /*fFlags*/);
383 if (RT_FAILURE(rc))
384 return rc;
385
386 rc = 0; /* Set default parsing result to valid. */
387
388 int c;
389 RTGETOPTUNION ValueUnion;
390 while ((c = RTGetOpt(&GetState, &ValueUnion)))
391 {
392 switch (c)
393 {
394 case GETOPTDEF_BALLOONCTRL_BALLOONDEC:
395 g_ulMemoryBalloonDecrementMB = ValueUnion.u32;
396 break;
397
398 case GETOPTDEF_BALLOONCTRL_BALLOONINC:
399 g_ulMemoryBalloonIncrementMB = ValueUnion.u32;
400 break;
401
402 case GETOPTDEF_BALLOONCTRL_GROUPS:
403 /** @todo Add ballooning groups cmd line arg. */
404 break;
405
406 case GETOPTDEF_BALLOONCTRL_BALLOONLOWERLIMIT:
407 g_ulMemoryBalloonLowerLimitMB = ValueUnion.u32;
408 break;
409
410 case GETOPTDEF_BALLOONCTRL_BALLOONMAX:
411 g_ulMemoryBalloonMaxMB = ValueUnion.u32;
412 break;
413
414 case GETOPTDEF_BALLOONCTRL_BALLOONSAFETY:
415 g_ulMemoryBalloonSafetyMB = ValueUnion.u32;
416 break;
417
418 /** @todo This option is a common module option! Put
419 * this into a utility function! */
420 case GETOPTDEF_BALLOONCTRL_TIMEOUTMS:
421 g_ulMemoryBalloonTimeoutMS = ValueUnion.u32;
422 if (g_ulMemoryBalloonTimeoutMS < 500)
423 g_ulMemoryBalloonTimeoutMS = 500;
424 break;
425
426 default:
427 rc = -1; /* We don't handle this option, skip. */
428 break;
429 }
430
431 /* At the moment we only process one option at a time. */
432 break;
433 }
434
435 *piConsumed += GetState.iNext - 1;
436
437 return rc;
438}
439
440static DECLCALLBACK(int) VBoxModBallooningInit(void)
441{
442 if (!g_ulMemoryBalloonTimeoutMS)
443 cfgGetValueULong(g_pVirtualBox, NULL /* Machine */,
444 "VBoxInternal2/Watchdog/BalloonCtrl/TimeoutMS", NULL /* Per-machine */,
445 &g_ulMemoryBalloonTimeoutMS, 30 * 1000 /* Default is 30 seconds timeout. */);
446
447 if (!g_ulMemoryBalloonIncrementMB)
448 cfgGetValueULong(g_pVirtualBox, NULL /* Machine */,
449 "VBoxInternal2/Watchdog/BalloonCtrl/BalloonIncrementMB", NULL /* Per-machine */,
450 &g_ulMemoryBalloonIncrementMB, 256);
451
452 if (!g_ulMemoryBalloonDecrementMB)
453 cfgGetValueULong(g_pVirtualBox, NULL /* Machine */,
454 "VBoxInternal2/Watchdog/BalloonCtrl/BalloonDecrementMB", NULL /* Per-machine */,
455 &g_ulMemoryBalloonDecrementMB, 128);
456
457 if (!g_ulMemoryBalloonLowerLimitMB)
458 cfgGetValueULong(g_pVirtualBox, NULL /* Machine */,
459 "VBoxInternal2/Watchdog/BalloonCtrl/BalloonLowerLimitMB", NULL /* Per-machine */,
460 &g_ulMemoryBalloonLowerLimitMB, 128);
461
462 return VINF_SUCCESS;
463}
464
465static DECLCALLBACK(int) VBoxModBallooningMain(void)
466{
467 static uint64_t uLast = UINT64_MAX;
468 uint64_t uNow = RTTimeProgramMilliTS() / g_ulMemoryBalloonTimeoutMS;
469 if (uLast == uNow)
470 return VINF_SUCCESS;
471 uLast = uNow;
472
473 int rc = VINF_SUCCESS;
474
475 /** @todo Provide API for enumerating/working w/ machines inside a module! */
476 mapVMIter it = g_mapVM.begin();
477 while (it != g_mapVM.end())
478 {
479 MachineState_T state = getMachineState(&it->second);
480
481 /* Our actual ballooning criteria. */
482 if ( balloonIsPossible(state)
483 && balloonIsRequired(&it->second))
484 {
485 rc = balloonMachineUpdate(it->first /* UUID */,
486 &it->second /* Machine */);
487 AssertRC(rc);
488 }
489 if (RT_FAILURE(rc))
490 break;
491
492 it++;
493 }
494
495 return rc;
496}
497
498static DECLCALLBACK(int) VBoxModBallooningStop(void)
499{
500 return VINF_SUCCESS;
501}
502
503static DECLCALLBACK(void) VBoxModBallooningTerm(void)
504{
505}
506
507static DECLCALLBACK(int) VBoxModBallooningOnMachineRegistered(const Bstr &strUuid)
508{
509 PVBOXWATCHDOG_MACHINE pMachine = getMachine(strUuid);
510 AssertPtrReturn(pMachine, VERR_INVALID_PARAMETER);
511
512 PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD pData;
513 int rc = payloadAlloc(pMachine, VBOX_MOD_BALLOONING_NAME,
514 sizeof(VBOXWATCHDOG_BALLOONCTRL_PAYLOAD), (void**)&pData);
515 if (RT_SUCCESS(rc))
516 rc = balloonMachineUpdate(strUuid, pMachine);
517
518 return rc;
519}
520
521static DECLCALLBACK(int) VBoxModBallooningOnMachineUnregistered(const Bstr &strUuid)
522{
523 PVBOXWATCHDOG_MACHINE pMachine = getMachine(strUuid);
524 AssertPtrReturn(pMachine, VERR_INVALID_PARAMETER);
525
526 payloadFree(pMachine, VBOX_MOD_BALLOONING_NAME);
527
528 return VINF_SUCCESS;
529}
530
531static DECLCALLBACK(int) VBoxModBallooningOnMachineStateChanged(const Bstr &strUuid,
532 MachineState_T enmState)
533{
534 PVBOXWATCHDOG_MACHINE pMachine = getMachine(strUuid);
535 /* Note: The machine state will change to "setting up" when machine gets deleted,
536 * so pMachine might be NULL here. */
537 if (!pMachine)
538 return VINF_SUCCESS;
539
540 return balloonMachineUpdate(strUuid, pMachine);
541}
542
543static DECLCALLBACK(int) VBoxModBallooningOnServiceStateChanged(bool fAvailable)
544{
545 return VINF_SUCCESS;
546}
547
548/**
549 * The 'balloonctrl' module description.
550 */
551VBOXMODULE g_ModBallooning =
552{
553 /* pszName. */
554 VBOX_MOD_BALLOONING_NAME,
555 /* pszDescription. */
556 "Memory Ballooning Control",
557 /* pszDepends. */
558 NULL,
559 /* uPriority. */
560 0 /* Not used */,
561 /* pszUsage. */
562 " [--balloon-dec=<MB>] [--balloon-groups=<string>] [--balloon-inc=<MB>]\n"
563 " [--balloon-interval=<ms>] [--balloon-lower-limit=<MB>]\n"
564 " [--balloon-max=<MB>]\n",
565 /* pszOptions. */
566 "--balloon-dec Sets the ballooning decrement in MB (128 MB).\n"
567 "--balloon-groups Sets the VM groups for ballooning (all).\n"
568 "--balloon-inc Sets the ballooning increment in MB (256 MB).\n"
569 "--balloon-interval Sets the check interval in ms (30 seconds).\n"
570 "--balloon-lower-limit Sets the ballooning lower limit in MB (64 MB).\n"
571 "--balloon-max Sets the balloon maximum limit in MB (0 MB).\n"
572 " Specifying \"0\" means disabled ballooning.\n"
573#if 1
574 /* (Legacy) note. */
575 "Set \"VBoxInternal/Guest/BalloonSizeMax\" for a per-VM maximum ballooning size.\n"
576#endif
577 "--balloon-safety-margin Free memory when deflating a balloon in MB (1024 MB).\n"
578 ,
579 /* methods. */
580 VBoxModBallooningPreInit,
581 VBoxModBallooningOption,
582 VBoxModBallooningInit,
583 VBoxModBallooningMain,
584 VBoxModBallooningStop,
585 VBoxModBallooningTerm,
586 /* callbacks. */
587 VBoxModBallooningOnMachineRegistered,
588 VBoxModBallooningOnMachineUnregistered,
589 VBoxModBallooningOnMachineStateChanged,
590 VBoxModBallooningOnServiceStateChanged
591};
592
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