VBoxModBallooning.cpp@ 44875

Last change on this file since 44875 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
29	using namespace com;
30
31	#define VBOX_MOD_BALLOONING_NAME "balloonctrl"
32
33	/**
34	* The module's RTGetOpt-IDs for the command line.
35	*/
36	enum 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	*/
50	static 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
60	static unsigned long g_ulMemoryBalloonTimeoutMS = 0;
61	static unsigned long g_ulMemoryBalloonIncrementMB = 0;
62	static 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. */
65	static unsigned long g_ulMemoryBalloonMaxMB = 0;
66	static unsigned long g_ulMemoryBalloonLowerLimitMB = 0;
67	static unsigned long g_ulMemoryBalloonSafetyMB = _1K;
68
69	/** The ballooning module's payload. */
70	typedef 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	*/
86	static 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	*/
146	static 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	*/
189	static 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	*/
214	static 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
230	int 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	*/
285	static 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. */
366	static DECLCALLBACK(int) VBoxModBallooningPreInit(void)
367	{
368	return VINF_SUCCESS;
369	}
370
371	static 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
440	static 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
465	static 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
498	static DECLCALLBACK(int) VBoxModBallooningStop(void)
499	{
500	return VINF_SUCCESS;
501	}
502
503	static DECLCALLBACK(void) VBoxModBallooningTerm(void)
504	{
505	}
506
507	static 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
521	static 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
531	static 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
543	static DECLCALLBACK(int) VBoxModBallooningOnServiceStateChanged(bool fAvailable)
544	{
545	return VINF_SUCCESS;
546	}
547
548	/**
549	* The 'balloonctrl' module description.
550	*/
551	VBOXMODULE 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.

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

Download in other formats: