1 | /* $Id: VBoxModBallooning.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * VBoxModBallooning - Module for handling the automatic ballooning of VMs.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2011-2020 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 "balloon"
|
---|
32 |
|
---|
33 |
|
---|
34 | /*********************************************************************************************************************************
|
---|
35 | * Local Structures *
|
---|
36 | *********************************************************************************************************************************/
|
---|
37 |
|
---|
38 | /**
|
---|
39 | * The module's RTGetOpt-IDs for the command line.
|
---|
40 | */
|
---|
41 | enum GETOPTDEF_BALLOONCTRL
|
---|
42 | {
|
---|
43 | GETOPTDEF_BALLOONCTRL_BALLOONINC = 2000,
|
---|
44 | GETOPTDEF_BALLOONCTRL_BALLOONDEC,
|
---|
45 | GETOPTDEF_BALLOONCTRL_BALLOONLOWERLIMIT,
|
---|
46 | GETOPTDEF_BALLOONCTRL_BALLOONMAX,
|
---|
47 | GETOPTDEF_BALLOONCTRL_BALLOONSAFETY,
|
---|
48 | GETOPTDEF_BALLOONCTRL_TIMEOUTMS,
|
---|
49 | GETOPTDEF_BALLOONCTRL_GROUPS
|
---|
50 | };
|
---|
51 |
|
---|
52 | /**
|
---|
53 | * The module's command line arguments.
|
---|
54 | */
|
---|
55 | static const RTGETOPTDEF g_aBalloonOpts[] = {
|
---|
56 | { "--balloon-dec", GETOPTDEF_BALLOONCTRL_BALLOONDEC, RTGETOPT_REQ_UINT32 },
|
---|
57 | { "--balloon-groups", GETOPTDEF_BALLOONCTRL_GROUPS, RTGETOPT_REQ_STRING },
|
---|
58 | { "--balloon-inc", GETOPTDEF_BALLOONCTRL_BALLOONINC, RTGETOPT_REQ_UINT32 },
|
---|
59 | { "--balloon-interval", GETOPTDEF_BALLOONCTRL_TIMEOUTMS, RTGETOPT_REQ_UINT32 },
|
---|
60 | { "--balloon-lower-limit", GETOPTDEF_BALLOONCTRL_BALLOONLOWERLIMIT, RTGETOPT_REQ_UINT32 },
|
---|
61 | { "--balloon-max", GETOPTDEF_BALLOONCTRL_BALLOONMAX, RTGETOPT_REQ_UINT32 },
|
---|
62 | { "--balloon-safety-margin", GETOPTDEF_BALLOONCTRL_BALLOONSAFETY, RTGETOPT_REQ_UINT32 }
|
---|
63 | };
|
---|
64 |
|
---|
65 | /** The ballooning module's payload. */
|
---|
66 | typedef struct VBOXWATCHDOG_BALLOONCTRL_PAYLOAD
|
---|
67 | {
|
---|
68 | /** Last (most recent) ballooning size reported by the guest. */
|
---|
69 | uint32_t cMbBalloonCurLast;
|
---|
70 | /** Last (most recent) ballooning request received. */
|
---|
71 | uint32_t cMbBalloonReqLast;
|
---|
72 | } VBOXWATCHDOG_BALLOONCTRL_PAYLOAD, *PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD;
|
---|
73 |
|
---|
74 |
|
---|
75 | /*********************************************************************************************************************************
|
---|
76 | * Globals *
|
---|
77 | *********************************************************************************************************************************/
|
---|
78 |
|
---|
79 | static uint32_t g_cMsMemoryBalloonTimeout = 30 * 1000;
|
---|
80 | static uint32_t g_cMbMemoryBalloonIncrement = 256;
|
---|
81 | static uint32_t g_cMbMemoryBalloonDecrement = 128;
|
---|
82 | /** Command line: Global balloon limit (in MB) for all VMs. Default is 0, which means
|
---|
83 | * no global limit is set. See balloonGetMaxSize() for more information. */
|
---|
84 | static uint32_t g_cMbMemoryBalloonMax = 0;
|
---|
85 | static uint32_t g_cMbMemoryBalloonLowerLimit = 128;
|
---|
86 | static uint32_t g_cbMemoryBalloonSafety = 1024;
|
---|
87 |
|
---|
88 |
|
---|
89 | /*********************************************************************************************************************************
|
---|
90 | * Local Function Prototypes *
|
---|
91 | *********************************************************************************************************************************/
|
---|
92 | static int balloonSetSize(PVBOXWATCHDOG_MACHINE pMachine, uint32_t cMbBalloonCur);
|
---|
93 |
|
---|
94 | /**
|
---|
95 | * Retrieves the current delta value
|
---|
96 | *
|
---|
97 | * @return Delta (MB) of the balloon to be deflated (<0) or inflated (>0).
|
---|
98 | * @param pMachine Pointer to the machine's internal structure.
|
---|
99 | * @param uGuestMemFree The guest's current free memory (MB).
|
---|
100 | * @param cMbBalloonOld The balloon's current (old) size (MB).
|
---|
101 | * @param uBalloonNew The balloon's new size (MB).
|
---|
102 | * @param uBalloonMax The maximum ballooning size (MB) it can inflate to.
|
---|
103 | */
|
---|
104 | static int32_t balloonGetDelta(PVBOXWATCHDOG_MACHINE pMachine, uint32_t cMbGuestMemFree,
|
---|
105 | uint32_t cMbBalloonOld, uint32_t cMbBalloonNew, uint32_t cMbBalloonMax)
|
---|
106 | {
|
---|
107 | serviceLogVerbose(("[%ls] cMbGuestMemFree=%RU32, cMbBalloonOld=%RU32, cMbBalloonNew=%RU32, cMbBalloonMax=%RU32\n",
|
---|
108 | pMachine->strName.raw(), cMbGuestMemFree, cMbBalloonOld, cMbBalloonNew, cMbBalloonMax));
|
---|
109 |
|
---|
110 | /* Make sure that the requested new ballooning size does not
|
---|
111 | * exceed the maximum ballooning size (if set). */
|
---|
112 | if ( cMbBalloonMax
|
---|
113 | && cMbBalloonNew > cMbBalloonMax)
|
---|
114 | cMbBalloonNew = cMbBalloonMax;
|
---|
115 |
|
---|
116 | int32_t cMbBalloonDelta = 0;
|
---|
117 | if (cMbGuestMemFree < g_cMbMemoryBalloonLowerLimit)
|
---|
118 | {
|
---|
119 | /* Guest is running low on memory, we need to
|
---|
120 | * deflate the balloon. */
|
---|
121 | cMbBalloonDelta = g_cMbMemoryBalloonDecrement * -1;
|
---|
122 |
|
---|
123 | /* Ensure that the delta will not return a negative
|
---|
124 | * balloon size. */
|
---|
125 | if ((int32_t)cMbBalloonOld + cMbBalloonDelta < 0)
|
---|
126 | cMbBalloonDelta = 0;
|
---|
127 | }
|
---|
128 | else if (cMbBalloonNew > cMbBalloonOld) /* Inflate. */
|
---|
129 | {
|
---|
130 | /* We want to inflate the balloon if we have room. */
|
---|
131 | uint32_t cMbIncrement = g_cMbMemoryBalloonIncrement;
|
---|
132 | while ( cMbIncrement >= 16
|
---|
133 | && cMbGuestMemFree - cMbIncrement < g_cMbMemoryBalloonLowerLimit)
|
---|
134 | cMbIncrement /= 2;
|
---|
135 |
|
---|
136 | if ((cMbGuestMemFree - cMbIncrement) > g_cMbMemoryBalloonLowerLimit)
|
---|
137 | cMbBalloonDelta = (int32_t)cMbIncrement;
|
---|
138 |
|
---|
139 | /* Make sure we're still within bounds. */
|
---|
140 | Assert(cMbBalloonDelta >= 0);
|
---|
141 | if (cMbBalloonOld + cMbBalloonDelta > cMbBalloonNew)
|
---|
142 | cMbBalloonDelta = RT_MIN(g_cMbMemoryBalloonIncrement, cMbBalloonNew - cMbBalloonOld);
|
---|
143 | }
|
---|
144 | else if (cMbBalloonNew < cMbBalloonOld) /* Deflate. */
|
---|
145 | {
|
---|
146 | cMbBalloonDelta = RT_MIN(g_cMbMemoryBalloonDecrement, cMbBalloonOld - cMbBalloonNew) * -1;
|
---|
147 | }
|
---|
148 |
|
---|
149 | /* Limit the ballooning to the available host memory, leaving some free.
|
---|
150 | * If anything fails clamp the delta to 0. */
|
---|
151 | if (cMbBalloonDelta < 0)
|
---|
152 | {
|
---|
153 | uint64_t cbSafety = (uint64_t)g_cbMemoryBalloonSafety * _1M;
|
---|
154 | uint64_t cbHostRamAvail = 0;
|
---|
155 | int vrc = RTSystemQueryAvailableRam(&cbHostRamAvail);
|
---|
156 | if (RT_SUCCESS(vrc))
|
---|
157 | {
|
---|
158 | if (cbHostRamAvail < cbSafety)
|
---|
159 | cMbBalloonDelta = 0;
|
---|
160 | else if ((uint64_t)(-cMbBalloonDelta) > (cbHostRamAvail - cbSafety) / _1M)
|
---|
161 | cMbBalloonDelta = -(int32_t)((cbHostRamAvail - cbSafety) / _1M);
|
---|
162 | }
|
---|
163 | else
|
---|
164 | cMbBalloonDelta = 0;
|
---|
165 | }
|
---|
166 |
|
---|
167 | return cMbBalloonDelta;
|
---|
168 | }
|
---|
169 |
|
---|
170 | /**
|
---|
171 | * Determines the maximum balloon size to set for the specified machine.
|
---|
172 | *
|
---|
173 | * @return Maximum ballooning size (in MB), 0 if no maximum set.
|
---|
174 | * @param pMachine Machine to determine maximum ballooning size for.
|
---|
175 | */
|
---|
176 | static uint32_t balloonGetMaxSize(PVBOXWATCHDOG_MACHINE pMachine)
|
---|
177 | {
|
---|
178 | /*
|
---|
179 | * Is a maximum ballooning size set? Make sure we're within bounds.
|
---|
180 | *
|
---|
181 | * The maximum balloning size can be set
|
---|
182 | * - via global extra-data ("VBoxInternal/Guest/BalloonSizeMax")
|
---|
183 | * - via command line ("--balloon-max")
|
---|
184 | *
|
---|
185 | * Precedence from top to bottom.
|
---|
186 | */
|
---|
187 | uint32_t cMbBalloonMax = 0;
|
---|
188 | char szSource[64];
|
---|
189 |
|
---|
190 | Bstr strValue;
|
---|
191 | HRESULT hr = g_pVirtualBox->GetExtraData(Bstr("VBoxInternal/Guest/BalloonSizeMax").raw(),
|
---|
192 | strValue.asOutParam());
|
---|
193 | if ( SUCCEEDED(hr)
|
---|
194 | && strValue.isNotEmpty())
|
---|
195 | {
|
---|
196 | cMbBalloonMax = Utf8Str(strValue).toUInt32();
|
---|
197 | if (g_fVerbose)
|
---|
198 | RTStrPrintf(szSource, sizeof(szSource), "global extra-data");
|
---|
199 | }
|
---|
200 |
|
---|
201 | if (strValue.isEmpty())
|
---|
202 | {
|
---|
203 | Assert(cMbBalloonMax == 0);
|
---|
204 |
|
---|
205 | cMbBalloonMax = g_cMbMemoryBalloonMax;
|
---|
206 | if (g_fVerbose)
|
---|
207 | RTStrPrintf(szSource, sizeof(szSource), "command line");
|
---|
208 | }
|
---|
209 |
|
---|
210 | serviceLogVerbose(("[%ls] Maximum balloning size is (%s): %RU32MB\n", pMachine->strName.raw(), szSource, cMbBalloonMax));
|
---|
211 | return cMbBalloonMax;
|
---|
212 | }
|
---|
213 |
|
---|
214 | /**
|
---|
215 | * Determines the current (set) balloon size of the specified machine.
|
---|
216 | *
|
---|
217 | * @return IPRT status code.
|
---|
218 | * @param pMachine Machine to determine maximum ballooning size for.
|
---|
219 | * @param pcMbBalloonCur Where to store the current (set) balloon
|
---|
220 | * size (in MB) on success.
|
---|
221 | */
|
---|
222 | static int balloonGetCurrentSize(PVBOXWATCHDOG_MACHINE pMachine, uint32_t *pcMbBalloonCur)
|
---|
223 | {
|
---|
224 | LONG cKbBalloonCur;
|
---|
225 | int vrc = getMetric(pMachine, L"Guest/RAM/Usage/Balloon", &cKbBalloonCur);
|
---|
226 | if (RT_SUCCESS(vrc))
|
---|
227 | {
|
---|
228 | if (pcMbBalloonCur)
|
---|
229 | *pcMbBalloonCur = (uint32_t)(cKbBalloonCur / 1024);
|
---|
230 | }
|
---|
231 |
|
---|
232 | return vrc;
|
---|
233 | }
|
---|
234 |
|
---|
235 | /**
|
---|
236 | * Determines the requested balloon size to set for the specified machine.
|
---|
237 | *
|
---|
238 | * @return Requested ballooning size (in MB), 0 if ballooning should be disabled.
|
---|
239 | * @param pMachine Machine to determine maximum ballooning size for.
|
---|
240 | */
|
---|
241 | static uint32_t balloonGetRequestedSize(PVBOXWATCHDOG_MACHINE pMachine)
|
---|
242 | {
|
---|
243 | const ComPtr<IMachine> &rptrMachine = pMachine->machine;
|
---|
244 |
|
---|
245 | /*
|
---|
246 | * The maximum balloning size can be set
|
---|
247 | * - via per-VM extra-data ("VBoxInternal2/Watchdog/BalloonCtrl/BalloonSizeMax")
|
---|
248 | * - via per-VM extra-data (legacy) ("VBoxInternal/Guest/BalloonSizeMax")
|
---|
249 | *
|
---|
250 | * Precedence from top to bottom.
|
---|
251 | */
|
---|
252 | uint32_t cMbBalloonReq = 0;
|
---|
253 | char szSource[64];
|
---|
254 |
|
---|
255 | Bstr strValue;
|
---|
256 | HRESULT hr = rptrMachine->GetExtraData(Bstr("VBoxInternal2/Watchdog/BalloonCtrl/BalloonSizeMax").raw(),
|
---|
257 | strValue.asOutParam());
|
---|
258 | if ( SUCCEEDED(hr)
|
---|
259 | && strValue.isNotEmpty())
|
---|
260 | {
|
---|
261 | cMbBalloonReq = Utf8Str(strValue).toUInt32();
|
---|
262 | if (g_fVerbose)
|
---|
263 | RTStrPrintf(szSource, sizeof(szSource), "per-VM extra-data");
|
---|
264 | }
|
---|
265 | else
|
---|
266 | {
|
---|
267 | hr = rptrMachine->GetExtraData(Bstr("VBoxInternal/Guest/BalloonSizeMax").raw(),
|
---|
268 | strValue.asOutParam());
|
---|
269 | if ( SUCCEEDED(hr)
|
---|
270 | && strValue.isNotEmpty())
|
---|
271 | {
|
---|
272 | cMbBalloonReq = Utf8Str(strValue).toUInt32();
|
---|
273 | if (g_fVerbose)
|
---|
274 | RTStrPrintf(szSource, sizeof(szSource), "per-VM extra-data (legacy)");
|
---|
275 | }
|
---|
276 | }
|
---|
277 |
|
---|
278 | if ( FAILED(hr)
|
---|
279 | || strValue.isEmpty())
|
---|
280 | {
|
---|
281 | cMbBalloonReq = 0;
|
---|
282 | if (g_fVerbose)
|
---|
283 | RTStrPrintf(szSource, sizeof(szSource), "none (disabled)");
|
---|
284 | }
|
---|
285 |
|
---|
286 | serviceLogVerbose(("[%ls] Requested balloning size is (%s): %RU32MB\n", pMachine->strName.raw(), szSource, cMbBalloonReq));
|
---|
287 | return cMbBalloonReq;
|
---|
288 | }
|
---|
289 |
|
---|
290 | /**
|
---|
291 | * Determines whether ballooning for the specified machine is enabled or not.
|
---|
292 | * This can be specified on a per-VM basis or as a globally set value for all VMs.
|
---|
293 | *
|
---|
294 | * @return bool Whether ballooning is enabled or not.
|
---|
295 | * @param pMachine Machine to determine enable status for.
|
---|
296 | */
|
---|
297 | static bool balloonIsEnabled(PVBOXWATCHDOG_MACHINE pMachine)
|
---|
298 | {
|
---|
299 | const ComPtr<IMachine> &rptrMachine = pMachine->machine;
|
---|
300 |
|
---|
301 | bool fEnabled = true; /* By default ballooning is enabled. */
|
---|
302 | char szSource[64];
|
---|
303 |
|
---|
304 | Bstr strValue;
|
---|
305 | HRESULT hr = g_pVirtualBox->GetExtraData(Bstr("VBoxInternal/Guest/BalloonEnabled").raw(),
|
---|
306 | strValue.asOutParam());
|
---|
307 | if ( SUCCEEDED(hr)
|
---|
308 | && strValue.isNotEmpty())
|
---|
309 | {
|
---|
310 | if (g_fVerbose)
|
---|
311 | RTStrPrintf(szSource, sizeof(szSource), "global extra-data");
|
---|
312 | }
|
---|
313 | else
|
---|
314 | {
|
---|
315 | hr = rptrMachine->GetExtraData(Bstr("VBoxInternal2/Watchdog/BalloonCtrl/BalloonEnabled").raw(),
|
---|
316 | strValue.asOutParam());
|
---|
317 | if (SUCCEEDED(hr))
|
---|
318 | {
|
---|
319 | if (g_fVerbose)
|
---|
320 | RTStrPrintf(szSource, sizeof(szSource), "per-VM extra-data");
|
---|
321 | }
|
---|
322 | }
|
---|
323 |
|
---|
324 | if (strValue.isNotEmpty())
|
---|
325 | {
|
---|
326 | fEnabled = RT_BOOL(Utf8Str(strValue).toUInt32());
|
---|
327 | serviceLogVerbose(("[%ls] Ballooning is forced to %s (%s)\n",
|
---|
328 | pMachine->strName.raw(), fEnabled ? "enabled" : "disabled", szSource));
|
---|
329 | }
|
---|
330 |
|
---|
331 | return fEnabled;
|
---|
332 | }
|
---|
333 |
|
---|
334 | /**
|
---|
335 | * Indicates whether ballooning on the specified machine state is
|
---|
336 | * possible -- this only is true if the machine is up and running.
|
---|
337 | *
|
---|
338 | * @return bool Flag indicating whether the VM is running or not.
|
---|
339 | * @param enmState The VM's machine state to judge whether it's running or not.
|
---|
340 | */
|
---|
341 | static bool balloonIsPossible(MachineState_T enmState)
|
---|
342 | {
|
---|
343 | switch (enmState)
|
---|
344 | {
|
---|
345 | case MachineState_Running:
|
---|
346 | #if 0
|
---|
347 | /* Not required for ballooning. */
|
---|
348 | case MachineState_Teleporting:
|
---|
349 | case MachineState_LiveSnapshotting:
|
---|
350 | case MachineState_Paused:
|
---|
351 | case MachineState_TeleportingPausedVM:
|
---|
352 | #endif
|
---|
353 | return true;
|
---|
354 | default:
|
---|
355 | break;
|
---|
356 | }
|
---|
357 | return false;
|
---|
358 | }
|
---|
359 |
|
---|
360 | int balloonMachineSetup(const Bstr& strUuid)
|
---|
361 | {
|
---|
362 | int vrc = VINF_SUCCESS;
|
---|
363 |
|
---|
364 | do
|
---|
365 | {
|
---|
366 | PVBOXWATCHDOG_MACHINE pMachine = getMachine(strUuid);
|
---|
367 | AssertPtrBreakStmt(pMachine, vrc=VERR_INVALID_PARAMETER);
|
---|
368 |
|
---|
369 | ComPtr<IMachine> m = pMachine->machine;
|
---|
370 |
|
---|
371 | /*
|
---|
372 | * Setup metrics required for ballooning.
|
---|
373 | */
|
---|
374 | com::SafeArray<BSTR> metricNames(1);
|
---|
375 | com::SafeIfaceArray<IUnknown> metricObjects(1);
|
---|
376 | com::SafeIfaceArray<IPerformanceMetric> metricAffected;
|
---|
377 |
|
---|
378 | Bstr strMetricNames(L"Guest/RAM/Usage");
|
---|
379 | strMetricNames.cloneTo(&metricNames[0]);
|
---|
380 |
|
---|
381 | HRESULT rc = m.queryInterfaceTo(&metricObjects[0]);
|
---|
382 |
|
---|
383 | #ifdef VBOX_WATCHDOG_GLOBAL_PERFCOL
|
---|
384 | CHECK_ERROR_BREAK(g_pPerfCollector, SetupMetrics(ComSafeArrayAsInParam(metricNames),
|
---|
385 | ComSafeArrayAsInParam(metricObjects),
|
---|
386 | 5 /* 5 seconds */,
|
---|
387 | 1 /* One sample is enough */,
|
---|
388 | ComSafeArrayAsOutParam(metricAffected)));
|
---|
389 | #else
|
---|
390 | ComPtr<IPerformanceCollector> coll = pMachine->collector;
|
---|
391 |
|
---|
392 | CHECK_ERROR_BREAK(g_pVirtualBox, COMGETTER(PerformanceCollector)(coll.asOutParam()));
|
---|
393 | CHECK_ERROR_BREAK(coll, SetupMetrics(ComSafeArrayAsInParam(metricNames),
|
---|
394 | ComSafeArrayAsInParam(metricObjects),
|
---|
395 | 5 /* 5 seconds */,
|
---|
396 | 1 /* One sample is enough */,
|
---|
397 | ComSafeArrayAsOutParam(metricAffected)));
|
---|
398 | #endif
|
---|
399 | if (FAILED(rc))
|
---|
400 | vrc = VERR_COM_IPRT_ERROR; /** @todo Find better rc! */
|
---|
401 |
|
---|
402 | } while (0);
|
---|
403 |
|
---|
404 | return vrc;
|
---|
405 | }
|
---|
406 |
|
---|
407 | /**
|
---|
408 | * Does the actual ballooning and assumes the machine is
|
---|
409 | * capable and ready for ballooning.
|
---|
410 | *
|
---|
411 | * @return IPRT status code.
|
---|
412 | * @param pMachine Pointer to the machine's internal structure.
|
---|
413 | */
|
---|
414 | static int balloonMachineUpdate(PVBOXWATCHDOG_MACHINE pMachine)
|
---|
415 | {
|
---|
416 | AssertPtrReturn(pMachine, VERR_INVALID_POINTER);
|
---|
417 |
|
---|
418 | /*
|
---|
419 | * Get metrics collected at this point.
|
---|
420 | */
|
---|
421 | LONG cKbGuestMemFree;
|
---|
422 | uint32_t cMbBalloonCur = 0;
|
---|
423 |
|
---|
424 | int vrc = getMetric(pMachine, L"Guest/RAM/Usage/Free", &cKbGuestMemFree);
|
---|
425 | if (RT_SUCCESS(vrc))
|
---|
426 | vrc = balloonGetCurrentSize(pMachine, &cMbBalloonCur);
|
---|
427 |
|
---|
428 | if (RT_SUCCESS(vrc))
|
---|
429 | {
|
---|
430 | /* If guest statistics are not up and running yet, skip this iteration and try next time. */
|
---|
431 | if (cKbGuestMemFree <= 0)
|
---|
432 | {
|
---|
433 | #ifdef DEBUG
|
---|
434 | serviceLogVerbose(("[%ls] No metrics available yet!\n", pMachine->strName.raw()));
|
---|
435 | #endif
|
---|
436 | return VINF_SUCCESS;
|
---|
437 | }
|
---|
438 |
|
---|
439 | uint32_t cMbGuestMemFree = (ULONG)cKbGuestMemFree / 1024;
|
---|
440 |
|
---|
441 | PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD pData;
|
---|
442 | pData = (PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD)payloadFrom(pMachine, VBOX_MOD_BALLOONING_NAME);
|
---|
443 | AssertPtr(pData);
|
---|
444 |
|
---|
445 | /* Determine if ballooning is enabled or disabled. */
|
---|
446 | bool fEnabled = balloonIsEnabled(pMachine);
|
---|
447 |
|
---|
448 | /* Determine the current set maximum balloon size. */
|
---|
449 | uint32_t cMbBalloonMax = balloonGetMaxSize(pMachine);
|
---|
450 |
|
---|
451 | /* Determine the requested balloon size. */
|
---|
452 | uint32_t cMbBalloonReq = balloonGetRequestedSize(pMachine);
|
---|
453 |
|
---|
454 | serviceLogVerbose(("[%ls] Free RAM (MB): %RI32, Ballooning: Current=%RU32MB, Requested=%RU32MB, Maximum=%RU32MB\n",
|
---|
455 | pMachine->strName.raw(), cMbGuestMemFree, cMbBalloonCur, cMbBalloonReq, cMbBalloonMax));
|
---|
456 |
|
---|
457 | if ( cMbBalloonMax
|
---|
458 | && cMbBalloonReq > cMbBalloonMax)
|
---|
459 | {
|
---|
460 | if (pData->cMbBalloonReqLast != cMbBalloonReq)
|
---|
461 | serviceLog("[%ls] Warning: Requested ballooning size (%RU32MB) exceeds set maximum ballooning size (%RU32MB), limiting ...\n",
|
---|
462 | pMachine->strName.raw(), cMbBalloonReq, cMbBalloonMax);
|
---|
463 | }
|
---|
464 |
|
---|
465 | /* Calculate current balloon delta. */
|
---|
466 | int32_t cMbBalloonDelta = balloonGetDelta(pMachine, cMbGuestMemFree, cMbBalloonCur, cMbBalloonReq, cMbBalloonMax);
|
---|
467 | #ifdef DEBUG
|
---|
468 | serviceLogVerbose(("[%ls] cMbBalloonDelta=%RI32\n", pMachine->strName.raw(), cMbBalloonDelta));
|
---|
469 | #endif
|
---|
470 | if (cMbBalloonDelta) /* Only do ballooning if there's really smth. to change ... */
|
---|
471 | {
|
---|
472 | cMbBalloonCur = cMbBalloonCur + cMbBalloonDelta;
|
---|
473 |
|
---|
474 | if (fEnabled)
|
---|
475 | {
|
---|
476 | serviceLog("[%ls] %s balloon by %RU32MB to %RU32MB ...\n",
|
---|
477 | pMachine->strName.raw(), cMbBalloonDelta > 0 ? "Inflating" : "Deflating", RT_ABS(cMbBalloonDelta), cMbBalloonCur);
|
---|
478 | vrc = balloonSetSize(pMachine, cMbBalloonCur);
|
---|
479 | }
|
---|
480 | else
|
---|
481 | serviceLogVerbose(("[%ls] Requested %s balloon by %RU32MB to %RU32MB, but ballooning is disabled\n",
|
---|
482 | pMachine->strName.raw(), cMbBalloonDelta > 0 ? "inflating" : "deflating",
|
---|
483 | RT_ABS(cMbBalloonDelta), cMbBalloonCur));
|
---|
484 | }
|
---|
485 |
|
---|
486 | if (cMbBalloonCur != pData->cMbBalloonCurLast)
|
---|
487 | {
|
---|
488 | /* If ballooning is disabled, always bolt down the ballooning size to 0. */
|
---|
489 | if (!fEnabled)
|
---|
490 | {
|
---|
491 | serviceLogVerbose(("[%ls] Ballooning is disabled, forcing to 0\n", pMachine->strName.raw()));
|
---|
492 | int vrc2 = balloonSetSize(pMachine, 0);
|
---|
493 | if (RT_FAILURE(vrc2))
|
---|
494 | serviceLog("[%ls] Error disabling ballooning, rc=%Rrc\n", pMachine->strName.raw(), vrc2);
|
---|
495 | }
|
---|
496 | }
|
---|
497 |
|
---|
498 | pData->cMbBalloonCurLast = cMbBalloonCur;
|
---|
499 | pData->cMbBalloonReqLast = cMbBalloonReq;
|
---|
500 | }
|
---|
501 | else
|
---|
502 | serviceLog("[%ls] Error retrieving metrics, rc=%Rrc\n", pMachine->strName.raw(), vrc);
|
---|
503 |
|
---|
504 | return vrc;
|
---|
505 | }
|
---|
506 |
|
---|
507 | static int balloonSetSize(PVBOXWATCHDOG_MACHINE pMachine, uint32_t cMbBalloonCur)
|
---|
508 | {
|
---|
509 | int vrc = VINF_SUCCESS;
|
---|
510 |
|
---|
511 | serviceLogVerbose(("[%ls] Setting balloon size to %RU32MB ...\n", pMachine->strName.raw(), cMbBalloonCur));
|
---|
512 |
|
---|
513 | if (g_fDryrun)
|
---|
514 | return VINF_SUCCESS;
|
---|
515 |
|
---|
516 | /* Open a session for the VM. */
|
---|
517 | HRESULT rc;
|
---|
518 | CHECK_ERROR_RET(pMachine->machine, LockMachine(g_pSession, LockType_Shared), VERR_ACCESS_DENIED);
|
---|
519 |
|
---|
520 | do
|
---|
521 | {
|
---|
522 | /* Get the associated console. */
|
---|
523 | ComPtr<IConsole> console;
|
---|
524 | CHECK_ERROR_BREAK(g_pSession, COMGETTER(Console)(console.asOutParam()));
|
---|
525 |
|
---|
526 | ComPtr <IGuest> guest;
|
---|
527 | rc = console->COMGETTER(Guest)(guest.asOutParam());
|
---|
528 | if (SUCCEEDED(rc))
|
---|
529 | CHECK_ERROR_BREAK(guest, COMSETTER(MemoryBalloonSize)((LONG)cMbBalloonCur));
|
---|
530 | else
|
---|
531 | serviceLog("Error: Unable to set new balloon size %RU32 for machine '%ls', rc=%Rhrc\n",
|
---|
532 | cMbBalloonCur, pMachine->strName.raw(), rc);
|
---|
533 | if (FAILED(rc))
|
---|
534 | vrc = VERR_COM_IPRT_ERROR;
|
---|
535 |
|
---|
536 | } while (0);
|
---|
537 |
|
---|
538 |
|
---|
539 | /* Unlock the machine again. */
|
---|
540 | CHECK_ERROR_RET(g_pSession, UnlockMachine(), VERR_ACCESS_DENIED);
|
---|
541 |
|
---|
542 | return vrc;
|
---|
543 | }
|
---|
544 |
|
---|
545 | /* Callbacks. */
|
---|
546 | static DECLCALLBACK(int) VBoxModBallooningPreInit(void)
|
---|
547 | {
|
---|
548 | return VINF_SUCCESS;
|
---|
549 | }
|
---|
550 |
|
---|
551 | static DECLCALLBACK(int) VBoxModBallooningOption(int argc, char *argv[], int *piConsumed)
|
---|
552 | {
|
---|
553 | if (!argc) /* Take a shortcut. */
|
---|
554 | return -1;
|
---|
555 |
|
---|
556 | AssertPtrReturn(argv, VERR_INVALID_POINTER);
|
---|
557 | AssertPtrReturn(piConsumed, VERR_INVALID_POINTER);
|
---|
558 |
|
---|
559 | RTGETOPTSTATE GetState;
|
---|
560 | int rc = RTGetOptInit(&GetState, argc, argv,
|
---|
561 | g_aBalloonOpts, RT_ELEMENTS(g_aBalloonOpts),
|
---|
562 | 0 /* First */, 0 /*fFlags*/);
|
---|
563 | if (RT_FAILURE(rc))
|
---|
564 | return rc;
|
---|
565 |
|
---|
566 | rc = 0; /* Set default parsing result to valid. */
|
---|
567 |
|
---|
568 | int c;
|
---|
569 | RTGETOPTUNION ValueUnion;
|
---|
570 | while ((c = RTGetOpt(&GetState, &ValueUnion)))
|
---|
571 | {
|
---|
572 | switch (c)
|
---|
573 | {
|
---|
574 | case GETOPTDEF_BALLOONCTRL_BALLOONDEC:
|
---|
575 | g_cMbMemoryBalloonDecrement = ValueUnion.u32;
|
---|
576 | break;
|
---|
577 |
|
---|
578 | case GETOPTDEF_BALLOONCTRL_BALLOONINC:
|
---|
579 | g_cMbMemoryBalloonIncrement = ValueUnion.u32;
|
---|
580 | break;
|
---|
581 |
|
---|
582 | case GETOPTDEF_BALLOONCTRL_GROUPS:
|
---|
583 | /** @todo Add ballooning groups cmd line arg. */
|
---|
584 | break;
|
---|
585 |
|
---|
586 | case GETOPTDEF_BALLOONCTRL_BALLOONLOWERLIMIT:
|
---|
587 | g_cMbMemoryBalloonLowerLimit = ValueUnion.u32;
|
---|
588 | break;
|
---|
589 |
|
---|
590 | case GETOPTDEF_BALLOONCTRL_BALLOONMAX:
|
---|
591 | g_cMbMemoryBalloonMax = ValueUnion.u32;
|
---|
592 | break;
|
---|
593 |
|
---|
594 | case GETOPTDEF_BALLOONCTRL_BALLOONSAFETY:
|
---|
595 | g_cbMemoryBalloonSafety = ValueUnion.u32;
|
---|
596 | break;
|
---|
597 |
|
---|
598 | /** @todo This option is a common module option! Put
|
---|
599 | * this into a utility function! */
|
---|
600 | case GETOPTDEF_BALLOONCTRL_TIMEOUTMS:
|
---|
601 | g_cMsMemoryBalloonTimeout = ValueUnion.u32;
|
---|
602 | if (g_cMsMemoryBalloonTimeout < 500)
|
---|
603 | g_cMsMemoryBalloonTimeout = 500;
|
---|
604 | break;
|
---|
605 |
|
---|
606 | default:
|
---|
607 | rc = -1; /* We don't handle this option, skip. */
|
---|
608 | break;
|
---|
609 | }
|
---|
610 |
|
---|
611 | /* At the moment we only process one option at a time. */
|
---|
612 | break;
|
---|
613 | }
|
---|
614 |
|
---|
615 | *piConsumed += GetState.iNext - 1;
|
---|
616 |
|
---|
617 | return rc;
|
---|
618 | }
|
---|
619 |
|
---|
620 | static DECLCALLBACK(int) VBoxModBallooningInit(void)
|
---|
621 | {
|
---|
622 | if (!g_cMsMemoryBalloonTimeout)
|
---|
623 | cfgGetValueU32(g_pVirtualBox, NULL /* Machine */,
|
---|
624 | "VBoxInternal2/Watchdog/BalloonCtrl/TimeoutMS", NULL /* Per-machine */,
|
---|
625 | &g_cMsMemoryBalloonTimeout, 30 * 1000 /* Default is 30 seconds timeout. */);
|
---|
626 |
|
---|
627 | if (!g_cMbMemoryBalloonIncrement)
|
---|
628 | cfgGetValueU32(g_pVirtualBox, NULL /* Machine */,
|
---|
629 | "VBoxInternal2/Watchdog/BalloonCtrl/BalloonIncrementMB", NULL /* Per-machine */,
|
---|
630 | &g_cMbMemoryBalloonIncrement, 256);
|
---|
631 |
|
---|
632 | if (!g_cMbMemoryBalloonDecrement)
|
---|
633 | cfgGetValueU32(g_pVirtualBox, NULL /* Machine */,
|
---|
634 | "VBoxInternal2/Watchdog/BalloonCtrl/BalloonDecrementMB", NULL /* Per-machine */,
|
---|
635 | &g_cMbMemoryBalloonDecrement, 128);
|
---|
636 |
|
---|
637 | if (!g_cMbMemoryBalloonLowerLimit)
|
---|
638 | cfgGetValueU32(g_pVirtualBox, NULL /* Machine */,
|
---|
639 | "VBoxInternal2/Watchdog/BalloonCtrl/BalloonLowerLimitMB", NULL /* Per-machine */,
|
---|
640 | &g_cMbMemoryBalloonLowerLimit, 128);
|
---|
641 |
|
---|
642 | return VINF_SUCCESS;
|
---|
643 | }
|
---|
644 |
|
---|
645 | static DECLCALLBACK(int) VBoxModBallooningMain(void)
|
---|
646 | {
|
---|
647 | static uint64_t s_msLast = UINT64_MAX;
|
---|
648 | if (s_msLast == UINT64_MAX)
|
---|
649 | s_msLast = RTTimeMilliTS();
|
---|
650 | else
|
---|
651 | {
|
---|
652 | uint64_t msDelta = RTTimeMilliTS() - s_msLast;
|
---|
653 | if (msDelta <= g_cMsMemoryBalloonTimeout)
|
---|
654 | return VINF_SUCCESS;
|
---|
655 | }
|
---|
656 |
|
---|
657 | int rc = VINF_SUCCESS;
|
---|
658 |
|
---|
659 | /** @todo Provide API for enumerating/working w/ machines inside a module! */
|
---|
660 | mapVMIter it = g_mapVM.begin();
|
---|
661 | while (it != g_mapVM.end())
|
---|
662 | {
|
---|
663 | MachineState_T state = getMachineState(&it->second);
|
---|
664 |
|
---|
665 | /* Our actual ballooning criteria. */
|
---|
666 | if (balloonIsPossible(state))
|
---|
667 | {
|
---|
668 | rc = balloonMachineUpdate(&it->second);
|
---|
669 | AssertRC(rc);
|
---|
670 | }
|
---|
671 | if (RT_FAILURE(rc))
|
---|
672 | break;
|
---|
673 |
|
---|
674 | ++it;
|
---|
675 | }
|
---|
676 |
|
---|
677 | s_msLast = RTTimeMilliTS();
|
---|
678 | return rc;
|
---|
679 | }
|
---|
680 |
|
---|
681 | static DECLCALLBACK(int) VBoxModBallooningStop(void)
|
---|
682 | {
|
---|
683 | return VINF_SUCCESS;
|
---|
684 | }
|
---|
685 |
|
---|
686 | static DECLCALLBACK(void) VBoxModBallooningTerm(void)
|
---|
687 | {
|
---|
688 | }
|
---|
689 |
|
---|
690 | static DECLCALLBACK(int) VBoxModBallooningOnMachineRegistered(const Bstr &strUuid)
|
---|
691 | {
|
---|
692 | PVBOXWATCHDOG_MACHINE pMachine = getMachine(strUuid);
|
---|
693 | AssertPtrReturn(pMachine, VERR_INVALID_PARAMETER);
|
---|
694 |
|
---|
695 | PVBOXWATCHDOG_BALLOONCTRL_PAYLOAD pData;
|
---|
696 | int rc = payloadAlloc(pMachine, VBOX_MOD_BALLOONING_NAME,
|
---|
697 | sizeof(VBOXWATCHDOG_BALLOONCTRL_PAYLOAD), (void**)&pData);
|
---|
698 | if (RT_SUCCESS(rc))
|
---|
699 | rc = balloonMachineUpdate(pMachine);
|
---|
700 |
|
---|
701 | return rc;
|
---|
702 | }
|
---|
703 |
|
---|
704 | static DECLCALLBACK(int) VBoxModBallooningOnMachineUnregistered(const Bstr &strUuid)
|
---|
705 | {
|
---|
706 | PVBOXWATCHDOG_MACHINE pMachine = getMachine(strUuid);
|
---|
707 | AssertPtrReturn(pMachine, VERR_INVALID_PARAMETER);
|
---|
708 |
|
---|
709 | payloadFree(pMachine, VBOX_MOD_BALLOONING_NAME);
|
---|
710 |
|
---|
711 | return VINF_SUCCESS;
|
---|
712 | }
|
---|
713 |
|
---|
714 | static DECLCALLBACK(int) VBoxModBallooningOnMachineStateChanged(const Bstr &strUuid,
|
---|
715 | MachineState_T enmState)
|
---|
716 | {
|
---|
717 | RT_NOREF(enmState);
|
---|
718 |
|
---|
719 | PVBOXWATCHDOG_MACHINE pMachine = getMachine(strUuid);
|
---|
720 | /* Note: The machine state will change to "setting up" when machine gets deleted,
|
---|
721 | * so pMachine might be NULL here. */
|
---|
722 | if (!pMachine)
|
---|
723 | return VINF_SUCCESS;
|
---|
724 |
|
---|
725 | return balloonMachineUpdate(pMachine);
|
---|
726 | }
|
---|
727 |
|
---|
728 | static DECLCALLBACK(int) VBoxModBallooningOnServiceStateChanged(bool fAvailable)
|
---|
729 | {
|
---|
730 | RT_NOREF(fAvailable);
|
---|
731 | return VINF_SUCCESS;
|
---|
732 | }
|
---|
733 |
|
---|
734 | /**
|
---|
735 | * The 'balloonctrl' module description.
|
---|
736 | */
|
---|
737 | VBOXMODULE g_ModBallooning =
|
---|
738 | {
|
---|
739 | /* pszName. */
|
---|
740 | VBOX_MOD_BALLOONING_NAME,
|
---|
741 | /* pszDescription. */
|
---|
742 | "Memory Ballooning Control",
|
---|
743 | /* pszDepends. */
|
---|
744 | NULL,
|
---|
745 | /* uPriority. */
|
---|
746 | 0 /* Not used */,
|
---|
747 | /* pszUsage. */
|
---|
748 | " [--balloon-dec=<MB>] [--balloon-groups=<string>] [--balloon-inc=<MB>]\n"
|
---|
749 | " [--balloon-interval=<ms>] [--balloon-lower-limit=<MB>]\n"
|
---|
750 | " [--balloon-max=<MB>]\n",
|
---|
751 | /* pszOptions. */
|
---|
752 | "--balloon-dec Sets the ballooning decrement in MB (128 MB).\n"
|
---|
753 | "--balloon-groups Sets the VM groups for ballooning (all).\n"
|
---|
754 | "--balloon-inc Sets the ballooning increment in MB (256 MB).\n"
|
---|
755 | "--balloon-interval Sets the check interval in ms (30 seconds).\n"
|
---|
756 | "--balloon-lower-limit Sets the ballooning lower limit in MB (64 MB).\n"
|
---|
757 | "--balloon-max Sets the balloon maximum limit in MB (0 MB).\n"
|
---|
758 | " Specifying \"0\" means disabled ballooning.\n"
|
---|
759 | #if 1
|
---|
760 | /* (Legacy) note. */
|
---|
761 | "Set \"VBoxInternal/Guest/BalloonSizeMax\" for a per-VM maximum ballooning size.\n"
|
---|
762 | #endif
|
---|
763 | "--balloon-safety-margin Free memory when deflating a balloon in MB (1024 MB).\n"
|
---|
764 | ,
|
---|
765 | /* methods. */
|
---|
766 | VBoxModBallooningPreInit,
|
---|
767 | VBoxModBallooningOption,
|
---|
768 | VBoxModBallooningInit,
|
---|
769 | VBoxModBallooningMain,
|
---|
770 | VBoxModBallooningStop,
|
---|
771 | VBoxModBallooningTerm,
|
---|
772 | /* callbacks. */
|
---|
773 | VBoxModBallooningOnMachineRegistered,
|
---|
774 | VBoxModBallooningOnMachineUnregistered,
|
---|
775 | VBoxModBallooningOnMachineStateChanged,
|
---|
776 | VBoxModBallooningOnServiceStateChanged
|
---|
777 | };
|
---|
778 |
|
---|