VBoxWatchdog.cpp@ 105016

Last change on this file since 105016 was 98103, checked in by vboxsync, 22 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: 38.7 KB

Line
1	/* $Id: VBoxWatchdog.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VBoxWatchdog.cpp - VirtualBox Watchdog.
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	#ifndef VBOX_ONLY_DOCS
33	# include <VBox/com/com.h>
34	# include <VBox/com/string.h>
35	# include <VBox/com/Guid.h>
36	# include <VBox/com/array.h>
37	# include <VBox/com/ErrorInfo.h>
38	# include <VBox/com/errorprint.h>
39
40	# include <VBox/com/NativeEventQueue.h>
41	# include <VBox/com/listeners.h>
42	# include <VBox/com/VirtualBox.h>
43	#endif /* !VBOX_ONLY_DOCS */
44
45	#include <VBox/err.h>
46	#include <VBox/log.h>
47	#include <VBox/version.h>
48
49	#include <package-generated.h>
50
51	#include <iprt/asm.h>
52	#include <iprt/buildconfig.h>
53	#include <iprt/critsect.h>
54	#include <iprt/getopt.h>
55	#include <iprt/initterm.h>
56	#include <iprt/message.h>
57	#include <iprt/path.h>
58	#include <iprt/process.h>
59	#include <iprt/semaphore.h>
60	#include <iprt/stream.h>
61	#include <iprt/string.h>
62	#include <iprt/system.h>
63	#include <iprt/time.h>
64
65	#include <algorithm>
66	#include <signal.h>
67
68	#include "VBoxWatchdogInternal.h"
69
70	using namespace com;
71
72
73	/*********************************************************************************************************************************
74	* Structures and Typedefs *
75	*********************************************************************************************************************************/
76	/**
77	* The details of the services that has been compiled in.
78	*/
79	typedef struct VBOXWATCHDOGMOD
80	{
81	/** Pointer to the service descriptor. */
82	PCVBOXMODULE pDesc;
83	/** Whether Pre-init was called. */
84	bool fPreInited;
85	/** Whether the module is enabled or not. */
86	bool fEnabled;
87	} VBOXWATCHDOGMOD, *PVBOXWATCHDOGMOD;
88
89	enum GETOPTDEF_WATCHDOG
90	{
91	GETOPTDEF_WATCHDOG_DISABLE_MODULE = 1000,
92	GETOPTDEF_WATCHDOG_DRYRUN
93	};
94
95
96	/*********************************************************************************************************************************
97	* Global Variables *
98	*********************************************************************************************************************************/
99	/** External globals. */
100	bool g_fDryrun = false;
101	bool g_fVerbose = false;
102	ComPtr<IVirtualBox> g_pVirtualBox = NULL;
103	ComPtr<ISession> g_pSession = NULL;
104	mapVM g_mapVM;
105	mapGroup g_mapGroup;
106	#ifdef VBOX_WATCHDOG_GLOBAL_PERFCOL
107	ComPtr<IPerformanceCollector> g_pPerfCollector = NULL;
108	#endif
109
110	/** The critical section for the machines map. */
111	static RTCRITSECT g_csMachines;
112
113	/** Set by the signal handler. */
114	static volatile bool g_fCanceled = false;
115
116	/** Logging parameters. */
117	static uint32_t g_cHistory = 10; /* Enable log rotation, 10 files. */
118	static uint32_t g_uHistoryFileTime = RT_SEC_1DAY; /* Max 1 day per file. */
119	static uint64_t g_uHistoryFileSize = 100 * _1M; /* Max 100MB per file. */
120
121	/** Run in background. */
122	static bool g_fDaemonize = false;
123
124	static VBOXWATCHDOGMOD g_aModules[] =
125	{
126	{ &g_ModBallooning, false /* Pre-inited /, true / Enabled */ },
127	{ &g_ModAPIMonitor, false /* Pre-inited /, true / Enabled */ }
128	};
129
130	/**
131	* Command line arguments.
132	*/
133	static const RTGETOPTDEF g_aOptions[] =
134	{
135	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX) \|\| defined (RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
136	{ "--background", 'b', RTGETOPT_REQ_NOTHING },
137	#endif
138	/** For displayHelp(). */
139	{ "--disable-<module>", GETOPTDEF_WATCHDOG_DISABLE_MODULE, RTGETOPT_REQ_NOTHING },
140	{ "--dryrun", GETOPTDEF_WATCHDOG_DRYRUN, RTGETOPT_REQ_NOTHING },
141	{ "--help", 'h', RTGETOPT_REQ_NOTHING },
142	{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
143	{ "--pidfile", 'P', RTGETOPT_REQ_STRING },
144	{ "--logfile", 'F', RTGETOPT_REQ_STRING },
145	{ "--logrotate", 'R', RTGETOPT_REQ_UINT32 },
146	{ "--logsize", 'S', RTGETOPT_REQ_UINT64 },
147	{ "--loginterval", 'I', RTGETOPT_REQ_UINT32 }
148	};
149
150	/** Global static objects. */
151	static ComPtr<IVirtualBoxClient> g_pVirtualBoxClient = NULL;
152	static ComPtr<IEventSource> g_pEventSource = NULL;
153	static ComPtr<IEventSource> g_pEventSourceClient = NULL;
154	static ComPtr<IEventListener> g_pVBoxEventListener = NULL;
155	static NativeEventQueue *g_pEventQ = NULL;
156
157
158	/*********************************************************************************************************************************
159	* Internal Functions *
160	*********************************************************************************************************************************/
161	static int machineAdd(const Bstr &strUuid);
162	static int machineRemove(const Bstr &strUuid);
163	static int watchdogSetup();
164	static void watchdogShutdown();
165
166
167	/**
168	* Handler for global events.
169	*/
170	class VirtualBoxEventListener
171	{
172	public:
173	VirtualBoxEventListener()
174	{
175	}
176
177	virtual ~VirtualBoxEventListener()
178	{
179	}
180
181	HRESULT init()
182	{
183	return S_OK;
184	}
185
186	void uninit()
187	{
188	}
189
190	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
191	{
192	switch (aType)
193	{
194	case VBoxEventType_OnMachineRegistered:
195	{
196	ComPtr<IMachineRegisteredEvent> pEvent = aEvent;
197	Assert(pEvent);
198
199	Bstr uuid;
200	BOOL fRegistered;
201	HRESULT hrc = pEvent->COMGETTER(Registered)(&fRegistered);
202	if (SUCCEEDED(hrc))
203	hrc = pEvent->COMGETTER(MachineId)(uuid.asOutParam());
204
205	if (SUCCEEDED(hrc))
206	{
207	int rc = RTCritSectEnter(&g_csMachines);
208	if (RT_SUCCESS(rc))
209	{
210	rc = fRegistered
211	? machineAdd(uuid)
212	: machineRemove(uuid);
213	int rc2 = RTCritSectLeave(&g_csMachines);
214	if (RT_SUCCESS(rc))
215	rc = rc2;
216	AssertRC(rc);
217	}
218	}
219	break;
220	}
221
222	case VBoxEventType_OnMachineStateChanged:
223	{
224	ComPtr<IMachineStateChangedEvent> pEvent = aEvent;
225	Assert(pEvent);
226
227	MachineState_T machineState;
228	Bstr uuid;
229
230	HRESULT hrc = pEvent->COMGETTER(State)(&machineState);
231	if (SUCCEEDED(hrc))
232	hrc = pEvent->COMGETTER(MachineId)(uuid.asOutParam());
233
234	if (SUCCEEDED(hrc))
235	{
236	int rc = RTCritSectEnter(&g_csMachines);
237	if (RT_SUCCESS(rc))
238	{
239	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
240	if (g_aModules[j].fEnabled)
241	{
242	int rc2 = g_aModules[j].pDesc->pfnOnMachineStateChanged(uuid,
243	machineState);
244	if (RT_FAILURE(rc2))
245	serviceLog("Module '%s' reported an error: %Rrc\n",
246	g_aModules[j].pDesc->pszName, rc);
247	/* Keep going. */
248	}
249
250	int rc2 = RTCritSectLeave(&g_csMachines);
251	if (RT_SUCCESS(rc))
252	rc = rc2;
253	AssertRC(rc);
254	}
255	}
256	break;
257	}
258
259	case VBoxEventType_OnVBoxSVCAvailabilityChanged:
260	{
261	ComPtr<IVBoxSVCAvailabilityChangedEvent> pVSACEv = aEvent;
262	Assert(pVSACEv);
263	BOOL fAvailable = FALSE;
264	pVSACEv->COMGETTER(Available)(&fAvailable);
265
266	/* First, notify all modules. */
267	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
268	if (g_aModules[j].fEnabled)
269	{
270	int rc2 = g_aModules[j].pDesc->pfnOnServiceStateChanged(RT_BOOL(fAvailable));
271	if (RT_FAILURE(rc2))
272	serviceLog("Module '%s' reported an error: %Rrc\n",
273	g_aModules[j].pDesc->pszName, rc2);
274	/* Keep going. */
275	}
276
277	/* Do global teardown/re-creation stuff. */
278	if (!fAvailable)
279	{
280	serviceLog("VBoxSVC became unavailable\n");
281	watchdogShutdown();
282	}
283	else
284	{
285	serviceLog("VBoxSVC became available\n");
286	int rc2 = watchdogSetup();
287	if (RT_FAILURE(rc2))
288	serviceLog("Unable to re-set up watchdog (rc=%Rrc)!\n", rc2);
289	}
290
291	break;
292	}
293
294	default:
295	/* Not handled event, just skip it. */
296	break;
297	}
298
299	return S_OK;
300	}
301
302	private:
303	};
304	typedef ListenerImpl<VirtualBoxEventListener> VirtualBoxEventListenerImpl;
305	VBOX_LISTENER_DECLARE(VirtualBoxEventListenerImpl)
306
307	/**
308	* Signal handler that sets g_fGuestCtrlCanceled.
309	*
310	* This can be executed on any thread in the process, on Windows it may even be
311	* a thread dedicated to delivering this signal. Do not doing anything
312	* unnecessary here.
313	*/
314	static void signalHandler(int iSignal) RT_NOTHROW_DEF
315	{
316	NOREF(iSignal);
317	ASMAtomicWriteBool(&g_fCanceled, true);
318
319	if (g_pEventQ)
320	{
321	int rc = g_pEventQ->interruptEventQueueProcessing();
322	if (RT_FAILURE(rc))
323	serviceLog("Error: interruptEventQueueProcessing failed with rc=%Rrc\n", rc);
324	}
325	}
326
327	#if 0 /** @todo signal handler installer / uninstallers are unused. */
328	/**
329	* Installs a custom signal handler to get notified
330	* whenever the user wants to intercept the program.
331	*/
332	static void signalHandlerInstall()
333	{
334	signal(SIGINT, signalHandler);
335	#ifdef SIGBREAK
336	signal(SIGBREAK, signalHandler);
337	#endif
338	}
339
340	/**
341	* Uninstalls a previously installed signal handler.
342	*/
343	static void signalHandlerUninstall()
344	{
345	signal(SIGINT, SIG_DFL);
346	#ifdef SIGBREAK
347	signal(SIGBREAK, SIG_DFL);
348	#endif
349	}
350	#endif /* unused */
351
352	/**
353	* Adds a specified machine to the list (map) of handled machines.
354	* Does not do locking -- needs to be done by caller!
355	*
356	* @return IPRT status code.
357	* @param strUuid UUID of the specified machine.
358	*/
359	static int machineAdd(const Bstr &strUuid)
360	{
361	HRESULT hrc;
362
363	/** @todo Add exception handling! */
364
365	do
366	{
367	ComPtr <IMachine> machine;
368	CHECK_ERROR_BREAK(g_pVirtualBox, FindMachine(strUuid.raw(), machine.asOutParam()));
369	Assert(!machine.isNull());
370
371	/*
372	* Get groups for this machine.
373	*/
374	com::SafeArray<BSTR> groups;
375	CHECK_ERROR_BREAK(machine, COMGETTER(Groups)(ComSafeArrayAsOutParam(groups)));
376	Utf8Str strGroups;
377	for (size_t i = 0; i < groups.size(); i++)
378	{
379	if (i != 0)
380	strGroups.append(",");
381	strGroups.append(Utf8Str(groups[i]));
382	}
383
384	/*
385	* Add machine to map.
386	*/
387	VBOXWATCHDOG_MACHINE m;
388	m.machine = machine;
389	CHECK_ERROR_BREAK(machine, COMGETTER(Name)(m.strName.asOutParam()));
390
391	int rc2 = groupAdd(m.groups, strGroups.c_str(), 0 /* Flags */);
392	AssertRC(rc2);
393
394	Assert(g_mapVM.find(strUuid) == g_mapVM.end());
395	g_mapVM.insert(std::make_pair(strUuid, m));
396	serviceLogVerbose(("Added machine \"%ls\"\n", strUuid.raw()));
397
398	/*
399	* Get the machine's VM group(s).
400	*/
401	mapGroupsIterConst itGroup = m.groups.begin();
402	while (itGroup != m.groups.end())
403	{
404	serviceLogVerbose(("Machine \"%ls\" is in VM group \"%s\"\n",
405	strUuid.raw(), itGroup->first.c_str()));
406
407	/* Add machine to group(s). */
408	mapGroupIter itGroups = g_mapGroup.find(itGroup->first);
409	if (itGroups == g_mapGroup.end())
410	{
411	vecGroupMembers vecMembers;
412	vecMembers.push_back(strUuid);
413	g_mapGroup.insert(std::make_pair(itGroup->first, vecMembers));
414
415	itGroups = g_mapGroup.find(itGroup->first);
416	Assert(itGroups != g_mapGroup.end());
417	}
418	else
419	itGroups->second.push_back(strUuid);
420	serviceLogVerbose(("Group \"%s\" has now %ld machine(s)\n",
421	itGroup->first.c_str(), itGroups->second.size()));
422	++itGroup;
423	}
424
425	/*
426	* Let all modules know. Typically all modules would register
427	* their per-machine payload here.
428	*/
429	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
430	if (g_aModules[j].fEnabled)
431	{
432	rc2 = g_aModules[j].pDesc->pfnOnMachineRegistered(strUuid);
433	if (RT_FAILURE(rc2))
434	serviceLog("OnMachineRegistered: Module '%s' reported an error: %Rrc\n",
435	g_aModules[j].pDesc->pszName, hrc);
436	/* Keep going. */
437	}
438
439	} while (0);
440
441	/** @todo Add std exception handling! */
442
443	return SUCCEEDED(hrc) ? VINF_SUCCESS : VERR_COM_IPRT_ERROR; /** @todo Find a better error! */
444	}
445
446	static int machineDestroy(const Bstr &strUuid)
447	{
448	AssertReturn(!strUuid.isEmpty(), VERR_INVALID_PARAMETER);
449	int rc = VINF_SUCCESS;
450
451	/* Let all modules know. */
452	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
453	if (g_aModules[j].fEnabled)
454	{
455	int rc2 = g_aModules[j].pDesc->pfnOnMachineUnregistered(strUuid);
456	if (RT_FAILURE(rc2))
457	serviceLog("OnMachineUnregistered: Module '%s' reported an error: %Rrc\n",
458	g_aModules[j].pDesc->pszName, rc);
459	/* Keep going. */
460	}
461
462	/* Must log before erasing the iterator because of the UUID ref! */
463	serviceLogVerbose(("Removing machine \"%ls\"\n", strUuid.raw()));
464
465	try
466	{
467	mapVMIter itVM = g_mapVM.find(strUuid);
468	Assert(itVM != g_mapVM.end());
469
470	/* Remove machine from group(s). */
471	mapGroupsIterConst itGroups = itVM->second.groups.begin();
472	while (itGroups != itVM->second.groups.end())
473	{
474	mapGroupIter itGroup = g_mapGroup.find(itGroups->first);
475	Assert(itGroup != g_mapGroup.end());
476
477	vecGroupMembers vecMembers = itGroup->second;
478	vecGroupMembersIter itMember = std::find(vecMembers.begin(),
479	vecMembers.end(),
480	strUuid);
481	Assert(itMember != vecMembers.end());
482	vecMembers.erase(itMember);
483
484	serviceLogVerbose(("Group \"%s\" has %ld machines left\n",
485	itGroup->first.c_str(), vecMembers.size()));
486	if (!vecMembers.size())
487	{
488	serviceLogVerbose(("Deleting group \"%s\"\n", itGroup->first.c_str()));
489	g_mapGroup.erase(itGroup);
490	}
491
492	++itGroups;
493	}
494
495	#ifndef VBOX_WATCHDOG_GLOBAL_PERFCOL
496	itVM->second.collector.setNull();
497	#endif
498	itVM->second.machine.setNull();
499
500	/*
501	* Remove machine from map.
502	*/
503	g_mapVM.erase(itVM);
504	}
505	catch (...)
506	{
507	AssertFailed();
508	}
509
510	return rc;
511	}
512
513	/**
514	* Removes a specified machine from the list of handled machines.
515	* Does not do locking -- needs to be done by caller!
516	*
517	* @return IPRT status code.
518	* @param strUuid UUID of the specified machine.
519	*/
520	static int machineRemove(const Bstr &strUuid)
521	{
522	AssertReturn(!strUuid.isEmpty(), VERR_INVALID_PARAMETER);
523	int rc = VINF_SUCCESS;
524
525	mapVMIter it = g_mapVM.find(strUuid);
526	if (it != g_mapVM.end())
527	{
528	int rc2 = machineDestroy(strUuid);
529	if (RT_FAILURE(rc))
530	{
531	serviceLog(("Machine \"%ls\" failed to destroy, rc=%Rc\n"));
532	if (RT_SUCCESS(rc))
533	rc = rc2;
534	}
535	}
536	else
537	{
538	serviceLogVerbose(("Warning: Removing not added machine \"%ls\"\n", strUuid.raw()));
539	rc = VERR_NOT_FOUND;
540	}
541
542	return rc;
543	}
544
545	static void vmListDestroy()
546	{
547	serviceLogVerbose(("Destroying VM list ...\n"));
548
549	int rc = RTCritSectEnter(&g_csMachines);
550	if (RT_SUCCESS(rc))
551	{
552	mapVMIter it = g_mapVM.begin();
553	while (it != g_mapVM.end())
554	{
555	machineDestroy(it->first);
556	it = g_mapVM.begin();
557	}
558
559	g_mapVM.clear();
560
561	rc = RTCritSectLeave(&g_csMachines);
562	}
563	AssertRC(rc);
564	}
565
566	static int vmListBuild()
567	{
568	serviceLogVerbose(("Building VM list ...\n"));
569
570	int rc = RTCritSectEnter(&g_csMachines);
571	if (RT_SUCCESS(rc))
572	{
573	/*
574	* Make sure the list is empty.
575	*/
576	g_mapVM.clear();
577
578	/*
579	* Get the list of all _running_ VMs
580	*/
581	com::SafeIfaceArray<IMachine> machines;
582	HRESULT hrc = g_pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
583	if (SUCCEEDED(hrc))
584	{
585	/*
586	* Iterate through the collection
587	*/
588	for (size_t i = 0; i < machines.size(); ++i)
589	{
590	if (machines[i])
591	{
592	Bstr strUUID;
593	CHECK_ERROR_BREAK(machines[i], COMGETTER(Id)(strUUID.asOutParam()));
594
595	BOOL fAccessible;
596	CHECK_ERROR_BREAK(machines[i], COMGETTER(Accessible)(&fAccessible));
597	if (!fAccessible)
598	{
599	serviceLogVerbose(("Machine \"%ls\" is inaccessible, skipping\n",
600	strUUID.raw()));
601	continue;
602	}
603
604	rc = machineAdd(strUUID);
605	if (RT_FAILURE(rc))
606	break;
607	}
608	}
609
610	if (!machines.size())
611	serviceLogVerbose(("No machines to add found at the moment!\n"));
612	}
613
614	int rc2 = RTCritSectLeave(&g_csMachines);
615	if (RT_SUCCESS(rc))
616	rc = rc2;
617	}
618	return rc;
619	}
620
621	/**
622	* Lazily calls the pfnPreInit method on each service.
623	*
624	* @returns VBox status code, error message displayed.
625	*/
626	static int watchdogLazyPreInit(void)
627	{
628	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
629	if (!g_aModules[j].fPreInited)
630	{
631	int rc = g_aModules[j].pDesc->pfnPreInit();
632	if (RT_FAILURE(rc))
633	{
634	serviceLog("Module '%s' failed pre-init: %Rrc\n",
635	g_aModules[j].pDesc->pszName, rc);
636	return rc;
637	}
638	g_aModules[j].fPreInited = true;
639	}
640	return VINF_SUCCESS;
641	}
642
643	/**
644	* Starts all registered modules.
645	*
646	* @return IPRT status code.
647	* @return int
648	*/
649	static int watchdogStartModules()
650	{
651	int rc = VINF_SUCCESS;
652
653	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
654	{
655	const PVBOXWATCHDOGMOD pMod = &g_aModules[j];
656	if (pMod->fEnabled)
657	{
658	int rc2 = pMod->pDesc->pfnInit();
659	if (RT_FAILURE(rc2))
660	{
661	if (rc2 != VERR_SERVICE_DISABLED)
662	{
663	serviceLog("Module '%s' failed to initialize: %Rrc\n", pMod->pDesc->pszName, rc2);
664	return rc;
665	}
666	pMod->fEnabled = false;
667	serviceLog("Module '%s' was disabled because of missing functionality\n", pMod->pDesc->pszName);
668
669	}
670	}
671	else
672	serviceLog("Module '%s' disabled, skipping ...\n", pMod->pDesc->pszName);
673	}
674
675	return rc;
676	}
677
678	static int watchdogShutdownModules()
679	{
680	int rc = VINF_SUCCESS;
681
682	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
683	if (g_aModules[j].fEnabled)
684	{
685	int rc2 = g_aModules[j].pDesc->pfnStop();
686	if (RT_FAILURE(rc2))
687	{
688	serviceLog("Module '%s' failed to stop: %Rrc\n",
689	g_aModules[j].pDesc->pszName, rc);
690	/* Keep original rc. */
691	if (RT_SUCCESS(rc))
692	rc = rc2;
693	}
694	/* Keep going. */
695	}
696
697	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
698	if (g_aModules[j].fEnabled)
699	{
700	g_aModules[j].pDesc->pfnTerm();
701	}
702
703	return rc;
704	}
705
706	static RTEXITCODE watchdogMain(/HandlerArg a */)
707	{
708	HRESULT hrc = S_OK;
709
710	do
711	{
712	/* Initialize global weak references. */
713	g_pEventQ = com::NativeEventQueue::getMainEventQueue();
714
715	/*
716	* Install signal handlers.
717	*/
718	signal(SIGINT, signalHandler);
719	#ifdef SIGBREAK
720	signal(SIGBREAK, signalHandler);
721	#endif
722
723	/*
724	* Setup the global event listeners:
725	* - g_pEventSource for machine events
726	* - g_pEventSourceClient for VBoxClient events (like VBoxSVC handling)
727	*/
728	CHECK_ERROR_BREAK(g_pVirtualBox, COMGETTER(EventSource)(g_pEventSource.asOutParam()));
729	CHECK_ERROR_BREAK(g_pVirtualBoxClient, COMGETTER(EventSource)(g_pEventSourceClient.asOutParam()));
730
731	ComObjPtr<VirtualBoxEventListenerImpl> vboxListenerImpl;
732	vboxListenerImpl.createObject();
733	vboxListenerImpl->init(new VirtualBoxEventListener());
734
735	com::SafeArray<VBoxEventType_T> eventTypes;
736	eventTypes.push_back(VBoxEventType_OnMachineRegistered);
737	eventTypes.push_back(VBoxEventType_OnMachineStateChanged);
738	eventTypes.push_back(VBoxEventType_OnVBoxSVCAvailabilityChanged); /* Processed by g_pEventSourceClient. */
739
740	g_pVBoxEventListener = vboxListenerImpl;
741	CHECK_ERROR_BREAK(g_pEventSource, RegisterListener(g_pVBoxEventListener, ComSafeArrayAsInParam(eventTypes), true /* Active listener */));
742	CHECK_ERROR_BREAK(g_pEventSourceClient, RegisterListener(g_pVBoxEventListener, ComSafeArrayAsInParam(eventTypes), true /* Active listener */));
743
744	/*
745	* Set up modules.
746	*/
747	int vrc = watchdogStartModules();
748	if (RT_FAILURE(vrc))
749	break;
750
751	for (;;)
752	{
753	/*
754	* Do the actual work.
755	*/
756
757	vrc = RTCritSectEnter(&g_csMachines);
758	if (RT_SUCCESS(vrc))
759	{
760	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
761	if (g_aModules[j].fEnabled)
762	{
763	int rc2 = g_aModules[j].pDesc->pfnMain();
764	if (RT_FAILURE(rc2))
765	serviceLog("Module '%s' reported an error: %Rrc\n",
766	g_aModules[j].pDesc->pszName, rc2);
767	/* Keep going. */
768	}
769
770	int rc2 = RTCritSectLeave(&g_csMachines);
771	if (RT_SUCCESS(vrc))
772	vrc = rc2;
773	AssertRC(vrc);
774	}
775
776	/*
777	* Process pending events, then wait for new ones. Note, this
778	* processes NULL events signalling event loop termination.
779	*/
780	g_pEventQ->processEventQueue(50);
781
782	if (g_fCanceled)
783	{
784	serviceLog("Signal caught, exiting ...\n");
785	break;
786	}
787	}
788
789	signal(SIGINT, SIG_DFL);
790	#ifdef SIGBREAK
791	signal(SIGBREAK, SIG_DFL);
792	#endif
793
794	/* VirtualBox callback unregistration. */
795	if (g_pVBoxEventListener)
796	{
797	if (!g_pEventSource.isNull())
798	CHECK_ERROR(g_pEventSource, UnregisterListener(g_pVBoxEventListener));
799	g_pVBoxEventListener.setNull();
800	}
801
802	g_pEventSource.setNull();
803	g_pEventSourceClient.setNull();
804
805	vrc = watchdogShutdownModules();
806	AssertRC(vrc);
807
808	if (RT_FAILURE(vrc))
809	hrc = VBOX_E_IPRT_ERROR;
810
811	} while (0);
812
813	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
814	}
815
816	void serviceLog(const char *pszFormat, ...)
817	{
818	va_list args;
819	va_start(args, pszFormat);
820	char *psz = NULL;
821	RTStrAPrintfV(&psz, pszFormat, args);
822	va_end(args);
823
824	LogRel(("%s", psz));
825
826	RTStrFree(psz);
827	}
828
829	static void displayHeader()
830	{
831	RTStrmPrintf(g_pStdErr, VBOX_PRODUCT " Watchdog " VBOX_VERSION_STRING "\n"
832	"Copyright (C) " VBOX_C_YEAR " " VBOX_VENDOR "\n\n");
833	}
834
835	/**
836	* Displays the help.
837	*
838	* @param pszImage Name of program name (image).
839	*/
840	static void displayHelp(const char *pszImage)
841	{
842	AssertPtrReturnVoid(pszImage);
843
844	displayHeader();
845
846	RTStrmPrintf(g_pStdErr,
847	"Usage: %s [-v\|--verbose] [-h\|-?\|--help] [-P\|--pidfile]\n"
848	" [-F\|--logfile=<file>] [-R\|--logrotate=<num>] \n"
849	" [-S\|--logsize=<bytes>] [-I\|--loginterval=<seconds>]\n",
850	pszImage);
851	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
852	if (g_aModules[j].pDesc->pszUsage)
853	RTStrmPrintf(g_pStdErr, "%s", g_aModules[j].pDesc->pszUsage);
854
855	RTStrmPrintf(g_pStdErr,
856	"\n"
857	"Options:\n");
858
859	for (unsigned i = 0; i < RT_ELEMENTS(g_aOptions); i++)
860	{
861	const char *pcszDescr;
862	switch (g_aOptions[i].iShort)
863	{
864	case GETOPTDEF_WATCHDOG_DISABLE_MODULE:
865	pcszDescr = "Disables a module. See module list for built-in modules.";
866	break;
867
868	case GETOPTDEF_WATCHDOG_DRYRUN:
869	pcszDescr = "Dryrun mode -- do not perform any actions.";
870	break;
871
872	case 'h':
873	pcszDescr = "Print this help message and exit.";
874	break;
875
876	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX) \|\| defined (RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
877	case 'b':
878	pcszDescr = "Run in background (daemon mode).";
879	break;
880	#endif
881	case 'P':
882	pcszDescr = "Name of the PID file which is created when the daemon was started.";
883	break;
884
885	case 'F':
886	pcszDescr = "Name of file to write log to (no file).";
887	break;
888
889	case 'R':
890	pcszDescr = "Number of log files (0 disables log rotation).";
891	break;
892
893	case 'S':
894	pcszDescr = "Maximum size of a log file to trigger rotation (bytes).";
895	break;
896
897	case 'I':
898	pcszDescr = "Maximum time interval to trigger log rotation (seconds).";
899	break;
900	default:
901	AssertFailedBreakStmt(pcszDescr = "");
902	}
903
904	if (g_aOptions[i].iShort < 1000)
905	RTStrmPrintf(g_pStdErr,
906	" %s, -%c\n"
907	" %s\n", g_aOptions[i].pszLong, g_aOptions[i].iShort, pcszDescr);
908	else
909	RTStrmPrintf(g_pStdErr,
910	" %s\n"
911	" %s\n", g_aOptions[i].pszLong, pcszDescr);
912	}
913
914	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
915	{
916	if (g_aModules[j].pDesc->pszOptions)
917	RTStrmPrintf(g_pStdErr, "%s", g_aModules[j].pDesc->pszOptions);
918	}
919
920	/** @todo Change VBOXBALLOONCTRL_RELEASE_LOG to WATCHDOG. /
921	RTStrmPrintf(g_pStdErr, "\nUse environment variable VBOXBALLOONCTRL_RELEASE_LOG for logging options.\n");
922
923	RTStrmPrintf(g_pStdErr, "\nValid module names are: ");
924	for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
925	{
926	if (j > 0)
927	RTStrmPrintf(g_pStdErr, ", ");
928	RTStrmPrintf(g_pStdErr, "%s", g_aModules[j].pDesc->pszName);
929	}
930	RTStrmPrintf(g_pStdErr, "\n\n");
931	}
932
933	/**
934	* Creates all global COM objects.
935	*
936	* @return HRESULT
937	*/
938	static int watchdogSetup()
939	{
940	serviceLogVerbose(("Setting up ...\n"));
941
942	/*
943	* Setup VirtualBox + session interfaces.
944	*/
945	HRESULT hrc = g_pVirtualBoxClient->COMGETTER(VirtualBox)(g_pVirtualBox.asOutParam());
946	if (SUCCEEDED(hrc))
947	{
948	hrc = g_pSession.createInprocObject(CLSID_Session);
949	if (FAILED(hrc))
950	RTMsgError("Failed to create a session object (rc=%Rhrc)!", hrc);
951	}
952	else
953	RTMsgError("Failed to get VirtualBox object (rc=%Rhrc)!", hrc);
954
955	if (FAILED(hrc))
956	return VERR_COM_OBJECT_NOT_FOUND;
957
958	/*
959	* Setup metrics.
960	*/
961	#ifdef VBOX_WATCHDOG_GLOBAL_PERFCOL
962	CHECK_ERROR_RET(g_pVirtualBox,
963	COMGETTER(PerformanceCollector)(g_pPerfCollector.asOutParam()), VERR_COM_UNEXPECTED);
964	#endif
965
966	int vrc = RTCritSectInit(&g_csMachines);
967	if (RT_SUCCESS(vrc))
968	{
969
970	/*
971	* Build up initial VM list.
972	*/
973	vrc = vmListBuild();
974	}
975
976	return vrc;
977	}
978
979	static void watchdogShutdown()
980	{
981	serviceLogVerbose(("Shutting down ...\n"));
982
983	vmListDestroy();
984
985	int rc = RTCritSectDelete(&g_csMachines);
986	AssertRC(rc);
987
988	#ifdef VBOX_WATCHDOG_GLOBAL_PERFCOL
989	g_pPerfCollector.setNull();
990	#endif
991
992	g_pSession.setNull();
993	g_pVirtualBox.setNull();
994	}
995
996	int main(int argc, char *argv[])
997	{
998	/*
999	* Before we do anything, init the runtime without loading
1000	* the support driver.
1001	*/
1002	int rc = RTR3InitExe(argc, &argv, 0);
1003	if (RT_FAILURE(rc))
1004	return RTMsgInitFailure(rc);
1005	#ifdef RT_OS_WINDOWS
1006	ATL::CComModule _Module; /* Required internally by ATL (constructor records instance in global variable). */
1007	#endif
1008
1009	/*
1010	* Parse the global options
1011	*/
1012	int c;
1013	const char *pszLogFile = NULL;
1014	const char *pszPidFile = NULL;
1015	RTGETOPTUNION ValueUnion;
1016	RTGETOPTSTATE GetState;
1017	RTGetOptInit(&GetState, argc, argv,
1018	g_aOptions, RT_ELEMENTS(g_aOptions), 1 /* First /, 0 /fFlags*/);
1019	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1020	{
1021	switch (c)
1022	{
1023	case GETOPTDEF_WATCHDOG_DRYRUN:
1024	g_fDryrun = true;
1025	break;
1026
1027	case 'h':
1028	displayHelp(argv[0]);
1029	return 0;
1030
1031	case 'v':
1032	g_fVerbose = true;
1033	break;
1034
1035	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX) \|\| defined (RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1036	case 'b':
1037	g_fDaemonize = true;
1038	break;
1039	#endif
1040	case 'V':
1041	RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
1042	return 0;
1043
1044	case 'P':
1045	pszPidFile = ValueUnion.psz;
1046	break;
1047
1048	case 'F':
1049	pszLogFile = ValueUnion.psz;
1050	break;
1051
1052	case 'R':
1053	g_cHistory = ValueUnion.u32;
1054	break;
1055
1056	case 'S':
1057	g_uHistoryFileSize = ValueUnion.u64;
1058	break;
1059
1060	case 'I':
1061	g_uHistoryFileTime = ValueUnion.u32;
1062	break;
1063
1064	default:
1065	{
1066	bool fFound = false;
1067
1068	char szModDisable[64];
1069	for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aModules); j++)
1070	{
1071	if (!RTStrPrintf(szModDisable, sizeof(szModDisable), "--disable-%s", g_aModules[j].pDesc->pszName))
1072	continue;
1073
1074	if (!RTStrICmp(szModDisable, ValueUnion.psz))
1075	{
1076	g_aModules[j].fEnabled = false;
1077	fFound = true;
1078	}
1079	}
1080
1081	if (!fFound)
1082	{
1083	rc = watchdogLazyPreInit();
1084	if (RT_FAILURE(rc))
1085	return RTEXITCODE_FAILURE;
1086
1087	for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aModules); j++)
1088	{
1089	if (!g_aModules[j].fEnabled)
1090	continue;
1091
1092	int iArgCnt = argc - GetState.iNext + 1;
1093	int iArgIndex = GetState.iNext - 1;
1094	int iConsumed = 0;
1095	rc = g_aModules[j].pDesc->pfnOption(iArgCnt,
1096	&argv[iArgIndex],
1097	&iConsumed);
1098	fFound = rc == 0;
1099	if (fFound)
1100	{
1101	GetState.iNext += iConsumed;
1102	break;
1103	}
1104	if (rc != -1)
1105	return rc;
1106	}
1107	}
1108	if (!fFound)
1109	return RTGetOptPrintError(c, &ValueUnion);
1110	continue;
1111	}
1112	}
1113	}
1114
1115	/** @todo Add "--quiet/-q" option to not show the header. */
1116	displayHeader();
1117
1118	/* create release logger, to stdout */
1119	RTERRINFOSTATIC ErrInfo;
1120	rc = com::VBoxLogRelCreate("Watchdog", g_fDaemonize ? NULL : pszLogFile,
1121	RTLOGFLAGS_PREFIX_THREAD \| RTLOGFLAGS_PREFIX_TIME_PROG,
1122	"all", "VBOXBALLOONCTRL_RELEASE_LOG",
1123	RTLOGDEST_STDOUT, UINT32_MAX /* cMaxEntriesPerGroup */,
1124	g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
1125	RTErrInfoInitStatic(&ErrInfo));
1126	if (RT_FAILURE(rc))
1127	return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", ErrInfo.Core.pszMsg, rc);
1128
1129	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX) \|\| defined (RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1130	if (g_fDaemonize)
1131	{
1132	/* prepare release logging */
1133	char szLogFile[RTPATH_MAX];
1134
1135	if (!pszLogFile \|\| !*pszLogFile)
1136	{
1137	rc = com::GetVBoxUserHomeDirectory(szLogFile, sizeof(szLogFile));
1138	if (RT_FAILURE(rc))
1139	return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not get base directory for logging: %Rrc", rc);
1140	rc = RTPathAppend(szLogFile, sizeof(szLogFile), "vboxballoonctrl.log");
1141	if (RT_FAILURE(rc))
1142	return RTMsgErrorExit(RTEXITCODE_FAILURE, "could not construct logging path: %Rrc", rc);
1143	pszLogFile = szLogFile;
1144	}
1145
1146	rc = RTProcDaemonizeUsingFork(false /* fNoChDir /, false / fNoClose */, pszPidFile);
1147	if (RT_FAILURE(rc))
1148	return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to daemonize, rc=%Rrc. exiting.", rc);
1149	/* create release logger, to file */
1150	rc = com::VBoxLogRelCreate("Watchdog", pszLogFile,
1151	RTLOGFLAGS_PREFIX_THREAD \| RTLOGFLAGS_PREFIX_TIME_PROG,
1152	"all", "VBOXBALLOONCTRL_RELEASE_LOG",
1153	RTLOGDEST_FILE, UINT32_MAX /* cMaxEntriesPerGroup */,
1154	g_cHistory, g_uHistoryFileTime, g_uHistoryFileSize,
1155	RTErrInfoInitStatic(&ErrInfo));
1156	if (RT_FAILURE(rc))
1157	return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", ErrInfo.Core.pszMsg, rc);
1158	}
1159	#endif
1160
1161	#ifndef VBOX_ONLY_DOCS
1162	/*
1163	* Initialize COM.
1164	*/
1165	using namespace com;
1166	HRESULT hrc = com::Initialize();
1167	# ifdef VBOX_WITH_XPCOM
1168	if (hrc == NS_ERROR_FILE_ACCESS_DENIED)
1169	{
1170	char szHome[RTPATH_MAX] = "";
1171	com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome));
1172	return RTMsgErrorExit(RTEXITCODE_FAILURE,
1173	"Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome);
1174	}
1175	# endif
1176	if (FAILED(hrc))
1177	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize COM (%Rhrc)!", hrc);
1178
1179	hrc = g_pVirtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
1180	if (FAILED(hrc))
1181	{
1182	RTMsgError("Failed to create the VirtualBoxClient object (%Rhrc)!", hrc);
1183	com::ErrorInfo info;
1184	if (!info.isFullAvailable() && !info.isBasicAvailable())
1185	{
1186	com::GluePrintRCMessage(hrc);
1187	RTMsgError("Most likely, the VirtualBox COM server is not running or failed to start.");
1188	}
1189	else
1190	com::GluePrintErrorInfo(info);
1191	return RTEXITCODE_FAILURE;
1192	}
1193
1194	if (g_fDryrun)
1195	serviceLog("Running in dryrun mode\n");
1196
1197	rc = watchdogSetup();
1198	if (RT_FAILURE(rc))
1199	return RTEXITCODE_FAILURE;
1200
1201	//HandlerArg handlerArg = { argc, argv };
1202	RTEXITCODE rcExit = watchdogMain(/&handlerArg/);
1203
1204	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
1205
1206	watchdogShutdown();
1207
1208	g_pVirtualBoxClient.setNull();
1209
1210	com::Shutdown();
1211
1212	return rcExit;
1213	#else /* VBOX_ONLY_DOCS */
1214	return RTEXITCODE_SUCCESS;
1215	#endif /* VBOX_ONLY_DOCS */
1216	}
1217

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Frontends/VBoxBalloonCtrl/VBoxWatchdog.cpp@ 105016

Download in other formats: