VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxBalloonCtrl/VBoxWatchdogUtils.cpp

Last change on this file was 98103, checked in by vboxsync, 18 months ago

Copyright year updates by scm.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 9.2 KB
Line 
1/* $Id: */
2/** @file
3 * VBoxWatchdogUtils - Misc. utility functions for modules.
4 */
5
6/*
7 * Copyright (C) 2011-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#include <VBox/com/array.h>
33#include "VBoxWatchdogInternal.h"
34
35#include <iprt/sanitized/sstream>
36#include <algorithm>
37
38
39/**
40 * Adds a group / a set of groups to the specified map.
41 * If a group in the group map exists there will be no action.
42 *
43 * @return IPRT status code.
44 * @param groups Map to add group(s) to.
45 * @param pszGroupsToAdd Comma-separated string of one or more groups to add.
46 * @param fFlags Flags to set to the groups added.
47 */
48int groupAdd(mapGroups &groups, const char *pszGroupsToAdd, uint32_t fFlags)
49{
50 AssertPtrReturn(pszGroupsToAdd, VERR_INVALID_POINTER);
51
52 try
53 {
54 std::istringstream strGroups(pszGroupsToAdd);
55 for(std::string strToken; getline(strGroups, strToken, ','); )
56 {
57 strToken.erase(remove_if(strToken.begin(), strToken.end(), isspace), strToken.end());
58
59 Utf8Str strTokenUtf8(strToken.c_str());
60 mapGroupsIterConst it = groups.find(strTokenUtf8);
61
62 if (it == groups.end())
63 groups.insert(std::make_pair(strTokenUtf8, fFlags));
64 }
65 }
66 catch (...)
67 {
68 AssertFailed();
69 }
70
71 return VINF_SUCCESS;
72}
73
74/**
75 * Retrieves a metric from a specified machine.
76 *
77 * @return IPRT status code.
78 * @param pMachine Pointer to the machine's internal structure.
79 * @param strName Name of metric to retrieve.
80 * @param pulData Pointer to value to retrieve the actual metric value.
81 */
82int getMetric(PVBOXWATCHDOG_MACHINE pMachine, const Bstr& strName, LONG *pulData)
83{
84 AssertPtrReturn(pMachine, VERR_INVALID_POINTER);
85 AssertPtrReturn(pulData, VERR_INVALID_POINTER);
86
87 /* Input. */
88 com::SafeArray<BSTR> metricNames(1);
89 com::SafeIfaceArray<IUnknown> metricObjects(1);
90 pMachine->machine.queryInterfaceTo(&metricObjects[0]);
91
92 /* Output. */
93 com::SafeArray<BSTR> retNames;
94 com::SafeIfaceArray<IUnknown> retObjects;
95 com::SafeArray<BSTR> retUnits;
96 com::SafeArray<ULONG> retScales;
97 com::SafeArray<ULONG> retSequenceNumbers;
98 com::SafeArray<ULONG> retIndices;
99 com::SafeArray<ULONG> retLengths;
100 com::SafeArray<LONG> retData;
101
102 /* Query current memory free. */
103 strName.cloneTo(&metricNames[0]);
104#ifdef VBOX_WATCHDOG_GLOBAL_PERFCOL
105 Assert(!g_pPerfCollector.isNull());
106 HRESULT hrc = g_pPerfCollector->QueryMetricsData(
107#else
108 Assert(!pMachine->collector.isNull());
109 HRESULT hrc = pMachine->collector->QueryMetricsData(
110#endif
111 ComSafeArrayAsInParam(metricNames),
112 ComSafeArrayAsInParam(metricObjects),
113 ComSafeArrayAsOutParam(retNames),
114 ComSafeArrayAsOutParam(retObjects),
115 ComSafeArrayAsOutParam(retUnits),
116 ComSafeArrayAsOutParam(retScales),
117 ComSafeArrayAsOutParam(retSequenceNumbers),
118 ComSafeArrayAsOutParam(retIndices),
119 ComSafeArrayAsOutParam(retLengths),
120 ComSafeArrayAsOutParam(retData));
121#if 0
122 /* Useful for metrics debugging. */
123 for (unsigned j = 0; j < retNames.size(); j++)
124 {
125 Bstr metricUnit(retUnits[j]);
126 Bstr metricName(retNames[j]);
127 RTPrintf("%-20ls ", metricName.raw());
128 const char *separator = "";
129 for (unsigned k = 0; k < retLengths[j]; k++)
130 {
131 if (retScales[j] == 1)
132 RTPrintf("%s%d %ls", separator, retData[retIndices[j] + k], metricUnit.raw());
133 else
134 RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[j] + k] / retScales[j],
135 (retData[retIndices[j] + k] * 100 / retScales[j]) % 100, metricUnit.raw());
136 separator = ", ";
137 }
138 RTPrintf("\n");
139 }
140#endif
141
142 if (SUCCEEDED(hrc))
143 *pulData = retData.size() ? retData[retIndices[0]] : 0;
144
145 return SUCCEEDED(hrc) ? VINF_SUCCESS : VINF_NOT_SUPPORTED;
146}
147
148/**
149 * Returns the payload of a machine.
150 *
151 * @return void* Pointer to payload data. Mutable!
152 * @param pMachine Machine to get payload for.
153 * @param pszModule Module name to get payload from.
154 */
155void* payloadFrom(PVBOXWATCHDOG_MACHINE pMachine, const char *pszModule)
156{
157 AssertPtrReturn(pMachine, NULL);
158 AssertPtrReturn(pszModule, NULL);
159 mapPayloadIter it = pMachine->payload.find(pszModule);
160 if (it == pMachine->payload.end())
161 return NULL;
162 Assert(it->second.cbData);
163 return it->second.pvData;
164}
165
166int payloadAlloc(PVBOXWATCHDOG_MACHINE pMachine, const char *pszModule,
167 size_t cbSize, void **ppszPayload)
168{
169 AssertPtrReturn(pMachine, VERR_INVALID_POINTER);
170 AssertPtrReturn(pszModule, VERR_INVALID_POINTER);
171 AssertReturn(cbSize, VERR_INVALID_PARAMETER);
172
173 void *pvData = RTMemAllocZ(cbSize);
174 AssertPtrReturn(pvData, VERR_NO_MEMORY);
175
176 mapPayloadIter it = pMachine->payload.find(pszModule);
177 AssertReturn(it == pMachine->payload.end(), VERR_INVALID_PARAMETER);
178
179 VBOXWATCHDOG_MODULE_PAYLOAD p;
180 p.pvData = pvData;
181 p.cbData = cbSize;
182
183 if (ppszPayload)
184 *ppszPayload = p.pvData;
185
186 pMachine->payload.insert(std::make_pair(pszModule, p));
187
188 return VINF_SUCCESS;
189}
190
191void payloadFree(PVBOXWATCHDOG_MACHINE pMachine, const char *pszModule)
192{
193 AssertPtrReturnVoid(pMachine);
194 AssertPtrReturnVoid(pszModule);
195
196 mapPayloadIter it = pMachine->payload.find(pszModule);
197 if (it != pMachine->payload.end())
198 {
199 RTMemFree(it->second.pvData);
200 pMachine->payload.erase(it);
201 }
202}
203
204PVBOXWATCHDOG_MACHINE getMachine(const Bstr& strUuid)
205{
206 mapVMIter it = g_mapVM.find(strUuid);
207 if (it != g_mapVM.end())
208 return &it->second;
209 return NULL;
210}
211
212MachineState_T getMachineState(const PVBOXWATCHDOG_MACHINE pMachine)
213{
214 AssertPtrReturn(pMachine, MachineState_Null);
215 MachineState_T machineState;
216 Assert(!pMachine->machine.isNull());
217 HRESULT rc = pMachine->machine->COMGETTER(State)(&machineState);
218 if (SUCCEEDED(rc))
219 return machineState;
220 return MachineState_Null;
221}
222
223int cfgGetValueStr(const ComPtr<IVirtualBox> &rptrVBox, const ComPtr<IMachine> &rptrMachine,
224 const char *pszGlobal, const char *pszVM, Utf8Str &strValue, Utf8Str strDefault)
225{
226 AssertReturn(!rptrVBox.isNull(), VERR_INVALID_POINTER);
227
228
229 /* Try per-VM approach. */
230 Bstr strTemp;
231 HRESULT hr;
232 if (!rptrMachine.isNull())
233 {
234 AssertPtr(pszVM);
235 hr = rptrMachine->GetExtraData(Bstr(pszVM).raw(),
236 strTemp.asOutParam());
237 if ( SUCCEEDED(hr)
238 && !strTemp.isEmpty())
239 {
240 strValue = Utf8Str(strTemp);
241 }
242 }
243
244 if (strValue.isEmpty()) /* Not set by per-VM value? */
245 {
246 AssertPtr(pszGlobal);
247
248 /* Try global approach. */
249 hr = rptrVBox->GetExtraData(Bstr(pszGlobal).raw(),
250 strTemp.asOutParam());
251 if ( SUCCEEDED(hr)
252 && !strTemp.isEmpty())
253 {
254 strValue = Utf8Str(strTemp);
255 }
256 }
257
258 if (strValue.isEmpty())
259 {
260 strValue = strDefault;
261 return VERR_NOT_FOUND;
262 }
263
264 return VINF_SUCCESS;
265}
266
267int cfgGetValueU32(const ComPtr<IVirtualBox> &rptrVBox, const ComPtr<IMachine> &rptrMachine,
268 const char *pszGlobal, const char *pszVM, uint32_t *puValue, uint32_t uDefault)
269{
270 Utf8Str strValue;
271 int rc = cfgGetValueStr(rptrVBox, rptrMachine, pszGlobal, pszVM, strValue, "" /* Default */);
272 if (RT_SUCCESS(rc))
273 *puValue = strValue.toUInt32();
274 else
275 *puValue = uDefault;
276 return rc;
277}
278
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
ContactPrivacy policyTerms of Use