VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxService.cpp@ 66891

Last change on this file since 66891 was 62470, checked in by vboxsync, 8 years ago

Additions: scm

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 40.4 KB
Line 
1/* $Id: VBoxService.cpp 62470 2016-07-22 18:02:56Z vboxsync $ */
2/** @file
3 * VBoxService - Guest Additions Service Skeleton.
4 */
5
6/*
7 * Copyright (C) 2007-2016 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/** @page pg_vgsvc VBoxService
20 *
21 * VBoxService is a root daemon for implementing guest additions features.
22 *
23 * It is structured as one binary that contains many sub-services. The reason
24 * for this is partially historical and partially practical. The practical
25 * reason is that the VBoxService binary is typically statically linked, at
26 * least with IPRT and the guest library, so we save quite a lot of space having
27 * on single binary instead individual binaries for each sub-service and their
28 * helpers (currently up to 9 subservices and 8 helpers). The historical is
29 * simply that it started its life on OS/2 dreaming of conquring Windows next,
30 * so it kind of felt natural to have it all in one binary.
31 *
32 * Even if it's structured as a single binary, it is possible, by using command
33 * line options, to start each subservice as an individual process.
34 *
35 * Subservices:
36 * - @subpage pg_vgsvc_timesync "Time Synchronization"
37 * - @subpage pg_vgsvc_vminfo "VM Information"
38 * - @subpage pg_vgsvc_vmstats "VM Statistics"
39 * - @subpage pg_vgsvc_gstctrl "Guest Control"
40 * - @subpage pg_vgsvc_pagesharing "Page Sharing"
41 * - @subpage pg_vgsvc_memballoon "Memory Balooning"
42 * - @subpage pg_vgsvc_cpuhotplug "CPU Hot-Plugging"
43 * - @subpage pg_vgsvc_automount "Shared Folder Automounting"
44 * - @subpage pg_vgsvc_clipboard "Clipboard (OS/2 only)"
45 *
46 * Now, since the service predates a lot of stuff, including RTGetOpt, we're
47 * currently doing our own version of argument parsing here, which is kind of
48 * stupid. That will hopefully be cleaned up eventually.
49 */
50
51
52/*********************************************************************************************************************************
53* Header Files *
54*********************************************************************************************************************************/
55/** @todo LOG_GROUP*/
56#ifndef _MSC_VER
57# include <unistd.h>
58#endif
59#include <errno.h>
60#ifndef RT_OS_WINDOWS
61# include <signal.h>
62# ifdef RT_OS_OS2
63# define pthread_sigmask sigprocmask
64# endif
65#endif
66#ifdef RT_OS_FREEBSD
67# include <pthread.h>
68#endif
69
70#include <package-generated.h>
71#include "product-generated.h"
72
73#include <iprt/asm.h>
74#include <iprt/buildconfig.h>
75#include <iprt/initterm.h>
76#include <iprt/file.h>
77#ifdef DEBUG
78# include <iprt/memtracker.h>
79#endif
80#include <iprt/message.h>
81#include <iprt/path.h>
82#include <iprt/process.h>
83#include <iprt/semaphore.h>
84#include <iprt/string.h>
85#include <iprt/stream.h>
86#include <iprt/system.h>
87#include <iprt/thread.h>
88
89#include <VBox/log.h>
90
91#include "VBoxServiceInternal.h"
92#ifdef VBOX_WITH_VBOXSERVICE_CONTROL
93# include "VBoxServiceControl.h"
94#endif
95#ifdef VBOX_WITH_VBOXSERVICE_TOOLBOX
96# include "VBoxServiceToolBox.h"
97#endif
98
99
100/*********************************************************************************************************************************
101* Global Variables *
102*********************************************************************************************************************************/
103/** The program name (derived from argv[0]). */
104char *g_pszProgName = (char *)"";
105/** The current verbosity level. */
106unsigned g_cVerbosity = 0;
107char g_szLogFile[RTPATH_MAX + 128] = "";
108char g_szPidFile[RTPATH_MAX] = "";
109/** Logging parameters. */
110/** @todo Make this configurable later. */
111static PRTLOGGER g_pLoggerRelease = NULL;
112static uint32_t g_cHistory = 10; /* Enable log rotation, 10 files. */
113static uint32_t g_uHistoryFileTime = RT_SEC_1DAY; /* Max 1 day per file. */
114static uint64_t g_uHistoryFileSize = 100 * _1M; /* Max 100MB per file. */
115/** Critical section for (debug) logging. */
116#ifdef DEBUG
117 RTCRITSECT g_csLog;
118#endif
119/** The default service interval (the -i | --interval) option). */
120uint32_t g_DefaultInterval = 0;
121#ifdef RT_OS_WINDOWS
122/** Signal shutdown to the Windows service thread. */
123static bool volatile g_fWindowsServiceShutdown;
124/** Event the Windows service thread waits for shutdown. */
125static RTSEMEVENT g_hEvtWindowsService;
126#endif
127
128/**
129 * The details of the services that has been compiled in.
130 */
131static struct
132{
133 /** Pointer to the service descriptor. */
134 PCVBOXSERVICE pDesc;
135 /** The worker thread. NIL_RTTHREAD if it's the main thread. */
136 RTTHREAD Thread;
137 /** Whether Pre-init was called. */
138 bool fPreInited;
139 /** Shutdown indicator. */
140 bool volatile fShutdown;
141 /** Indicator set by the service thread exiting. */
142 bool volatile fStopped;
143 /** Whether the service was started or not. */
144 bool fStarted;
145 /** Whether the service is enabled or not. */
146 bool fEnabled;
147} g_aServices[] =
148{
149#ifdef VBOX_WITH_VBOXSERVICE_CONTROL
150 { &g_Control, NIL_RTTHREAD, false, false, false, false, true },
151#endif
152#ifdef VBOX_WITH_VBOXSERVICE_TIMESYNC
153 { &g_TimeSync, NIL_RTTHREAD, false, false, false, false, true },
154#endif
155#ifdef VBOX_WITH_VBOXSERVICE_CLIPBOARD
156 { &g_Clipboard, NIL_RTTHREAD, false, false, false, false, true },
157#endif
158#ifdef VBOX_WITH_VBOXSERVICE_VMINFO
159 { &g_VMInfo, NIL_RTTHREAD, false, false, false, false, true },
160#endif
161#ifdef VBOX_WITH_VBOXSERVICE_CPUHOTPLUG
162 { &g_CpuHotPlug, NIL_RTTHREAD, false, false, false, false, true },
163#endif
164#ifdef VBOX_WITH_VBOXSERVICE_MANAGEMENT
165# ifdef VBOX_WITH_MEMBALLOON
166 { &g_MemBalloon, NIL_RTTHREAD, false, false, false, false, true },
167# endif
168 { &g_VMStatistics, NIL_RTTHREAD, false, false, false, false, true },
169#endif
170#if defined(VBOX_WITH_VBOXSERVICE_PAGE_SHARING)
171 { &g_PageSharing, NIL_RTTHREAD, false, false, false, false, true },
172#endif
173#ifdef VBOX_WITH_SHARED_FOLDERS
174 { &g_AutoMount, NIL_RTTHREAD, false, false, false, false, true },
175#endif
176};
177
178
179/*
180 * Default call-backs for services which do not need special behaviour.
181 */
182
183/**
184 * @interface_method_impl{VBOXSERVICE,pfnPreInit, Default Implementation}
185 */
186DECLCALLBACK(int) VGSvcDefaultPreInit(void)
187{
188 return VINF_SUCCESS;
189}
190
191
192/**
193 * @interface_method_impl{VBOXSERVICE,pfnOption, Default Implementation}
194 */
195DECLCALLBACK(int) VGSvcDefaultOption(const char **ppszShort, int argc,
196 char **argv, int *pi)
197{
198 NOREF(ppszShort);
199 NOREF(argc);
200 NOREF(argv);
201 NOREF(pi);
202
203 return -1;
204}
205
206
207/**
208 * @interface_method_impl{VBOXSERVICE,pfnInit, Default Implementation}
209 */
210DECLCALLBACK(int) VGSvcDefaultInit(void)
211{
212 return VINF_SUCCESS;
213}
214
215
216/**
217 * @interface_method_impl{VBOXSERVICE,pfnTerm, Default Implementation}
218 */
219DECLCALLBACK(void) VGSvcDefaultTerm(void)
220{
221 return;
222}
223
224
225/**
226 * @callback_method_impl{FNRTLOGPHASE, Release logger callback}
227 */
228static DECLCALLBACK(void) vgsvcLogHeaderFooter(PRTLOGGER pLoggerRelease, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
229{
230 /* Some introductory information. */
231 static RTTIMESPEC s_TimeSpec;
232 char szTmp[256];
233 if (enmPhase == RTLOGPHASE_BEGIN)
234 RTTimeNow(&s_TimeSpec);
235 RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
236
237 switch (enmPhase)
238 {
239 case RTLOGPHASE_BEGIN:
240 {
241 pfnLog(pLoggerRelease,
242 "VBoxService %s r%s (verbosity: %u) %s (%s %s) release log\n"
243 "Log opened %s\n",
244 RTBldCfgVersion(), RTBldCfgRevisionStr(), g_cVerbosity, VBOX_BUILD_TARGET,
245 __DATE__, __TIME__, szTmp);
246
247 int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
248 if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
249 pfnLog(pLoggerRelease, "OS Product: %s\n", szTmp);
250 vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
251 if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
252 pfnLog(pLoggerRelease, "OS Release: %s\n", szTmp);
253 vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
254 if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
255 pfnLog(pLoggerRelease, "OS Version: %s\n", szTmp);
256 vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
257 if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
258 pfnLog(pLoggerRelease, "OS Service Pack: %s\n", szTmp);
259
260 /* the package type is interesting for Linux distributions */
261 char szExecName[RTPATH_MAX];
262 char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
263 pfnLog(pLoggerRelease,
264 "Executable: %s\n"
265 "Process ID: %u\n"
266 "Package type: %s"
267#ifdef VBOX_OSE
268 " (OSE)"
269#endif
270 "\n",
271 pszExecName ? pszExecName : "unknown",
272 RTProcSelf(),
273 VBOX_PACKAGE_STRING);
274 break;
275 }
276
277 case RTLOGPHASE_PREROTATE:
278 pfnLog(pLoggerRelease, "Log rotated - Log started %s\n", szTmp);
279 break;
280
281 case RTLOGPHASE_POSTROTATE:
282 pfnLog(pLoggerRelease, "Log continuation - Log started %s\n", szTmp);
283 break;
284
285 case RTLOGPHASE_END:
286 pfnLog(pLoggerRelease, "End of log file - Log started %s\n", szTmp);
287 break;
288
289 default:
290 /* nothing */
291 break;
292 }
293}
294
295
296/**
297 * Creates the default release logger outputting to the specified file.
298 *
299 * Pass NULL to disabled logging.
300 *
301 * @return IPRT status code.
302 * @param pszLogFile Filename for log output. NULL disables logging.
303 */
304int VGSvcLogCreate(const char *pszLogFile)
305{
306 /* Create release logger (stdout + file). */
307 static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
308 RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
309#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
310 fFlags |= RTLOGFLAGS_USECRLF;
311#endif
312 char szError[RTPATH_MAX + 128] = "";
313 int rc = RTLogCreateEx(&g_pLoggerRelease, fFlags, "all",
314#ifdef DEBUG
315 "VBOXSERVICE_LOG",
316#else
317 "VBOXSERVICE_RELEASE_LOG",
318#endif
319 RT_ELEMENTS(s_apszGroups), s_apszGroups,
320 RTLOGDEST_STDOUT | RTLOGDEST_USER,
321 vgsvcLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
322 szError, sizeof(szError), pszLogFile);
323 if (RT_SUCCESS(rc))
324 {
325 /* register this logger as the release logger */
326 RTLogRelSetDefaultInstance(g_pLoggerRelease);
327
328 /* Explicitly flush the log in case of VBOXSERVICE_RELEASE_LOG=buffered. */
329 RTLogFlush(g_pLoggerRelease);
330 }
331
332 return rc;
333}
334
335
336void VGSvcLogDestroy(void)
337{
338 RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
339}
340
341
342/**
343 * Displays the program usage message.
344 *
345 * @returns 1.
346 */
347static int vgsvcUsage(void)
348{
349 RTPrintf("Usage:\n"
350 " %-12s [-f|--foreground] [-v|--verbose] [-l|--logfile <file>]\n"
351 " [-p|--pidfile <file>] [-i|--interval <seconds>]\n"
352 " [--disable-<service>] [--enable-<service>]\n"
353 " [--only-<service>] [-h|-?|--help]\n", g_pszProgName);
354#ifdef RT_OS_WINDOWS
355 RTPrintf(" [-r|--register] [-u|--unregister]\n");
356#endif
357 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
358 if (g_aServices[j].pDesc->pszUsage)
359 RTPrintf("%s\n", g_aServices[j].pDesc->pszUsage);
360 RTPrintf("\n"
361 "Options:\n"
362 " -i | --interval The default interval.\n"
363 " -f | --foreground Don't daemonize the program. For debugging.\n"
364 " -l | --logfile <file> Enables logging to a file.\n"
365 " -p | --pidfile <file> Write the process ID to a file.\n"
366 " -v | --verbose Increment the verbosity level. For debugging.\n"
367 " -V | --version Show version information.\n"
368 " -h | -? | --help Show this message and exit with status 1.\n"
369 );
370#ifdef RT_OS_WINDOWS
371 RTPrintf(" -r | --register Installs the service.\n"
372 " -u | --unregister Uninstall service.\n");
373#endif
374
375 RTPrintf("\n"
376 "Service-specific options:\n");
377 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
378 {
379 RTPrintf(" --enable-%-14s Enables the %s service. (default)\n", g_aServices[j].pDesc->pszName, g_aServices[j].pDesc->pszName);
380 RTPrintf(" --disable-%-13s Disables the %s service.\n", g_aServices[j].pDesc->pszName, g_aServices[j].pDesc->pszName);
381 RTPrintf(" --only-%-16s Only enables the %s service.\n", g_aServices[j].pDesc->pszName, g_aServices[j].pDesc->pszName);
382 if (g_aServices[j].pDesc->pszOptions)
383 RTPrintf("%s", g_aServices[j].pDesc->pszOptions);
384 }
385 RTPrintf("\n"
386 " Copyright (C) 2009-" VBOX_C_YEAR " " VBOX_VENDOR "\n");
387
388 return 1;
389}
390
391
392/**
393 * Displays an error message.
394 *
395 * @returns RTEXITCODE_FAILURE.
396 * @param pszFormat The message text.
397 * @param ... Format arguments.
398 */
399RTEXITCODE VGSvcError(const char *pszFormat, ...)
400{
401 va_list args;
402 va_start(args, pszFormat);
403 char *psz = NULL;
404 RTStrAPrintfV(&psz, pszFormat, args);
405 va_end(args);
406
407 AssertPtr(psz);
408 LogRel(("Error: %s", psz));
409
410 RTStrFree(psz);
411
412 return RTEXITCODE_FAILURE;
413}
414
415
416/**
417 * Displays a verbose message.
418 *
419 * @param iLevel Minimum log level required to display this message.
420 * @param pszFormat The message text.
421 * @param ... Format arguments.
422 */
423void VGSvcVerbose(unsigned iLevel, const char *pszFormat, ...)
424{
425 if (iLevel <= g_cVerbosity)
426 {
427#ifdef DEBUG
428 int rc = RTCritSectEnter(&g_csLog);
429 if (RT_SUCCESS(rc))
430 {
431#endif
432 va_list args;
433 va_start(args, pszFormat);
434 char *psz = NULL;
435 RTStrAPrintfV(&psz, pszFormat, args);
436 va_end(args);
437
438 AssertPtr(psz);
439 LogRel(("%s", psz));
440
441 RTStrFree(psz);
442#ifdef DEBUG
443 RTCritSectLeave(&g_csLog);
444 }
445#endif
446 }
447}
448
449
450/**
451 * Reports the current VBoxService status to the host.
452 *
453 * This makes sure that the Failed state is sticky.
454 *
455 * @return IPRT status code.
456 * @param enmStatus Status to report to the host.
457 */
458int VGSvcReportStatus(VBoxGuestFacilityStatus enmStatus)
459{
460 /*
461 * VBoxGuestFacilityStatus_Failed is sticky.
462 */
463 static VBoxGuestFacilityStatus s_enmLastStatus = VBoxGuestFacilityStatus_Inactive;
464 VGSvcVerbose(4, "Setting VBoxService status to %u\n", enmStatus);
465 if (s_enmLastStatus != VBoxGuestFacilityStatus_Failed)
466 {
467 int rc = VbglR3ReportAdditionsStatus(VBoxGuestFacilityType_VBoxService, enmStatus, 0 /* Flags */);
468 if (RT_FAILURE(rc))
469 {
470 VGSvcError("Could not report VBoxService status (%u), rc=%Rrc\n", enmStatus, rc);
471 return rc;
472 }
473 s_enmLastStatus = enmStatus;
474 }
475 return VINF_SUCCESS;
476}
477
478
479/**
480 * Gets a 32-bit value argument.
481 * @todo Get rid of this and VGSvcArgString() as soon as we have RTOpt handling.
482 *
483 * @returns 0 on success, non-zero exit code on error.
484 * @param argc The argument count.
485 * @param argv The argument vector
486 * @param psz Where in *pi to start looking for the value argument.
487 * @param pi Where to find and perhaps update the argument index.
488 * @param pu32 Where to store the 32-bit value.
489 * @param u32Min The minimum value.
490 * @param u32Max The maximum value.
491 */
492int VGSvcArgUInt32(int argc, char **argv, const char *psz, int *pi, uint32_t *pu32, uint32_t u32Min, uint32_t u32Max)
493{
494 if (*psz == ':' || *psz == '=')
495 psz++;
496 if (!*psz)
497 {
498 if (*pi + 1 >= argc)
499 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Missing value for the '%s' argument\n", argv[*pi]);
500 psz = argv[++*pi];
501 }
502
503 char *pszNext;
504 int rc = RTStrToUInt32Ex(psz, &pszNext, 0, pu32);
505 if (RT_FAILURE(rc) || *pszNext)
506 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Failed to convert interval '%s' to a number\n", psz);
507 if (*pu32 < u32Min || *pu32 > u32Max)
508 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The timesync interval of %RU32 seconds is out of range [%RU32..%RU32]\n",
509 *pu32, u32Min, u32Max);
510 return 0;
511}
512
513
514/** @todo Get rid of this and VGSvcArgUInt32() as soon as we have RTOpt handling. */
515static int vgsvcArgString(int argc, char **argv, const char *psz, int *pi, char *pszBuf, size_t cbBuf)
516{
517 AssertPtrReturn(pszBuf, VERR_INVALID_POINTER);
518 AssertPtrReturn(cbBuf, VERR_INVALID_PARAMETER);
519
520 if (*psz == ':' || *psz == '=')
521 psz++;
522 if (!*psz)
523 {
524 if (*pi + 1 >= argc)
525 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Missing string for the '%s' argument\n", argv[*pi]);
526 psz = argv[++*pi];
527 }
528
529 if (!RTStrPrintf(pszBuf, cbBuf, "%s", psz))
530 return RTMsgErrorExit(RTEXITCODE_FAILURE, "String for '%s' argument too big\n", argv[*pi]);
531 return 0;
532}
533
534
535/**
536 * The service thread.
537 *
538 * @returns Whatever the worker function returns.
539 * @param ThreadSelf My thread handle.
540 * @param pvUser The service index.
541 */
542static DECLCALLBACK(int) vgsvcThread(RTTHREAD ThreadSelf, void *pvUser)
543{
544 const unsigned i = (uintptr_t)pvUser;
545
546#ifndef RT_OS_WINDOWS
547 /*
548 * Block all signals for this thread. Only the main thread will handle signals.
549 */
550 sigset_t signalMask;
551 sigfillset(&signalMask);
552 pthread_sigmask(SIG_BLOCK, &signalMask, NULL);
553#endif
554
555 int rc = g_aServices[i].pDesc->pfnWorker(&g_aServices[i].fShutdown);
556 ASMAtomicXchgBool(&g_aServices[i].fShutdown, true);
557 RTThreadUserSignal(ThreadSelf);
558 return rc;
559}
560
561
562/**
563 * Lazily calls the pfnPreInit method on each service.
564 *
565 * @returns VBox status code, error message displayed.
566 */
567static RTEXITCODE vgsvcLazyPreInit(void)
568{
569 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
570 if (!g_aServices[j].fPreInited)
571 {
572 int rc = g_aServices[j].pDesc->pfnPreInit();
573 if (RT_FAILURE(rc))
574 return VGSvcError("Service '%s' failed pre-init: %Rrc\n", g_aServices[j].pDesc->pszName, rc);
575 g_aServices[j].fPreInited = true;
576 }
577 return RTEXITCODE_SUCCESS;
578}
579
580
581/**
582 * Count the number of enabled services.
583 */
584static unsigned vgsvcCountEnabledServices(void)
585{
586 unsigned cEnabled = 0;
587 for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
588 cEnabled += g_aServices[i].fEnabled;
589 return cEnabled;
590}
591
592
593#ifdef RT_OS_WINDOWS
594/**
595 * Console control event callback.
596 *
597 * @returns TRUE if handled, FALSE if not.
598 * @param dwCtrlType The control event type.
599 *
600 * @remarks This is generally called on a new thread, so we're racing every
601 * other thread in the process.
602 */
603static BOOL WINAPI vgsvcWinConsoleControlHandler(DWORD dwCtrlType)
604{
605 int rc = VINF_SUCCESS;
606 bool fEventHandled = FALSE;
607 switch (dwCtrlType)
608 {
609 /* User pressed CTRL+C or CTRL+BREAK or an external event was sent
610 * via GenerateConsoleCtrlEvent(). */
611 case CTRL_BREAK_EVENT:
612 case CTRL_CLOSE_EVENT:
613 case CTRL_C_EVENT:
614 VGSvcVerbose(2, "ControlHandler: Received break/close event\n");
615 rc = VGSvcStopServices();
616 fEventHandled = TRUE;
617 break;
618 default:
619 break;
620 /** @todo Add other events here. */
621 }
622
623 if (RT_FAILURE(rc))
624 VGSvcError("ControlHandler: Event %ld handled with error rc=%Rrc\n",
625 dwCtrlType, rc);
626 return fEventHandled;
627}
628#endif /* RT_OS_WINDOWS */
629
630
631/**
632 * Starts the service.
633 *
634 * @returns VBox status code, errors are fully bitched.
635 *
636 * @remarks Also called from VBoxService-win.cpp, thus not static.
637 */
638int VGSvcStartServices(void)
639{
640 int rc;
641
642 VGSvcReportStatus(VBoxGuestFacilityStatus_Init);
643
644 /*
645 * Initialize the services.
646 */
647 VGSvcVerbose(2, "Initializing services ...\n");
648 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
649 if (g_aServices[j].fEnabled)
650 {
651 rc = g_aServices[j].pDesc->pfnInit();
652 if (RT_FAILURE(rc))
653 {
654 if (rc != VERR_SERVICE_DISABLED)
655 {
656 VGSvcError("Service '%s' failed to initialize: %Rrc\n", g_aServices[j].pDesc->pszName, rc);
657 VGSvcReportStatus(VBoxGuestFacilityStatus_Failed);
658 return rc;
659 }
660 g_aServices[j].fEnabled = false;
661 VGSvcVerbose(0, "Service '%s' was disabled because of missing functionality\n", g_aServices[j].pDesc->pszName);
662
663 }
664 }
665
666 /*
667 * Start the service(s).
668 */
669 VGSvcVerbose(2, "Starting services ...\n");
670 rc = VINF_SUCCESS;
671 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
672 {
673 if (!g_aServices[j].fEnabled)
674 continue;
675
676 VGSvcVerbose(2, "Starting service '%s' ...\n", g_aServices[j].pDesc->pszName);
677 rc = RTThreadCreate(&g_aServices[j].Thread, vgsvcThread, (void *)(uintptr_t)j, 0,
678 RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, g_aServices[j].pDesc->pszName);
679 if (RT_FAILURE(rc))
680 {
681 VGSvcError("RTThreadCreate failed, rc=%Rrc\n", rc);
682 break;
683 }
684 g_aServices[j].fStarted = true;
685
686 /* Wait for the thread to initialize. */
687 /** @todo There is a race between waiting and checking
688 * the fShutdown flag of a thread here and processing
689 * the thread's actual worker loop. If the thread decides
690 * to exit the loop before we skipped the fShutdown check
691 * below the service will fail to start! */
692 /** @todo This presumably means either a one-shot service or that
693 * something has gone wrong. In the second case treating it as failure
694 * to start is probably right, so we need a way to signal the first
695 * rather than leaving the idle thread hanging around. A flag in the
696 * service description? */
697 RTThreadUserWait(g_aServices[j].Thread, 60 * 1000);
698 if (g_aServices[j].fShutdown)
699 {
700 VGSvcError("Service '%s' failed to start!\n", g_aServices[j].pDesc->pszName);
701 rc = VERR_GENERAL_FAILURE;
702 }
703 }
704
705 if (RT_SUCCESS(rc))
706 VGSvcVerbose(1, "All services started.\n");
707 else
708 {
709 VGSvcError("An error occcurred while the services!\n");
710 VGSvcReportStatus(VBoxGuestFacilityStatus_Failed);
711 }
712 return rc;
713}
714
715
716/**
717 * Stops and terminates the services.
718 *
719 * This should be called even when VBoxServiceStartServices fails so it can
720 * clean up anything that we succeeded in starting.
721 *
722 * @remarks Also called from VBoxService-win.cpp, thus not static.
723 */
724int VGSvcStopServices(void)
725{
726 VGSvcReportStatus(VBoxGuestFacilityStatus_Terminating);
727
728 /*
729 * Signal all the services.
730 */
731 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
732 ASMAtomicWriteBool(&g_aServices[j].fShutdown, true);
733
734 /*
735 * Do the pfnStop callback on all running services.
736 */
737 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
738 if (g_aServices[j].fStarted)
739 {
740 VGSvcVerbose(3, "Calling stop function for service '%s' ...\n", g_aServices[j].pDesc->pszName);
741 g_aServices[j].pDesc->pfnStop();
742 }
743
744 VGSvcVerbose(3, "All stop functions for services called\n");
745
746 /*
747 * Wait for all the service threads to complete.
748 */
749 int rc = VINF_SUCCESS;
750 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
751 {
752 if (!g_aServices[j].fEnabled) /* Only stop services which were started before. */
753 continue;
754 if (g_aServices[j].Thread != NIL_RTTHREAD)
755 {
756 VGSvcVerbose(2, "Waiting for service '%s' to stop ...\n", g_aServices[j].pDesc->pszName);
757 int rc2 = VINF_SUCCESS;
758 for (int i = 0; i < 30; i++) /* Wait 30 seconds in total */
759 {
760 rc2 = RTThreadWait(g_aServices[j].Thread, 1000 /* Wait 1 second */, NULL);
761 if (RT_SUCCESS(rc2))
762 break;
763#ifdef RT_OS_WINDOWS
764 /* Notify SCM that it takes a bit longer ... */
765 VGSvcWinSetStopPendingStatus(i + j*32);
766#endif
767 }
768 if (RT_FAILURE(rc2))
769 {
770 VGSvcError("Service '%s' failed to stop. (%Rrc)\n", g_aServices[j].pDesc->pszName, rc2);
771 rc = rc2;
772 }
773 }
774 VGSvcVerbose(3, "Terminating service '%s' (%d) ...\n", g_aServices[j].pDesc->pszName, j);
775 g_aServices[j].pDesc->pfnTerm();
776 }
777
778#ifdef RT_OS_WINDOWS
779 /*
780 * Wake up and tell the main() thread that we're shutting down (it's
781 * sleeping in VBoxServiceMainWait).
782 */
783 ASMAtomicWriteBool(&g_fWindowsServiceShutdown, true);
784 if (g_hEvtWindowsService != NIL_RTSEMEVENT)
785 {
786 VGSvcVerbose(3, "Stopping the main thread...\n");
787 int rc2 = RTSemEventSignal(g_hEvtWindowsService);
788 AssertRC(rc2);
789 }
790#endif
791
792 VGSvcVerbose(2, "Stopping services returning: %Rrc\n", rc);
793 VGSvcReportStatus(RT_SUCCESS(rc) ? VBoxGuestFacilityStatus_Paused : VBoxGuestFacilityStatus_Failed);
794 return rc;
795}
796
797
798/**
799 * Block the main thread until the service shuts down.
800 *
801 * @remarks Also called from VBoxService-win.cpp, thus not static.
802 */
803void VGSvcMainWait(void)
804{
805 int rc;
806
807 VGSvcReportStatus(VBoxGuestFacilityStatus_Active);
808
809#ifdef RT_OS_WINDOWS
810 /*
811 * Wait for the semaphore to be signalled.
812 */
813 VGSvcVerbose(1, "Waiting in main thread\n");
814 rc = RTSemEventCreate(&g_hEvtWindowsService);
815 AssertRC(rc);
816 while (!ASMAtomicReadBool(&g_fWindowsServiceShutdown))
817 {
818 rc = RTSemEventWait(g_hEvtWindowsService, RT_INDEFINITE_WAIT);
819 AssertRC(rc);
820 }
821 RTSemEventDestroy(g_hEvtWindowsService);
822 g_hEvtWindowsService = NIL_RTSEMEVENT;
823#else
824 /*
825 * Wait explicitly for a HUP, INT, QUIT, ABRT or TERM signal, blocking
826 * all important signals.
827 *
828 * The annoying EINTR/ERESTART loop is for the benefit of Solaris where
829 * sigwait returns when we receive a SIGCHLD. Kind of makes sense since
830 */
831 sigset_t signalMask;
832 sigemptyset(&signalMask);
833 sigaddset(&signalMask, SIGHUP);
834 sigaddset(&signalMask, SIGINT);
835 sigaddset(&signalMask, SIGQUIT);
836 sigaddset(&signalMask, SIGABRT);
837 sigaddset(&signalMask, SIGTERM);
838 pthread_sigmask(SIG_BLOCK, &signalMask, NULL);
839
840 int iSignal;
841 do
842 {
843 iSignal = -1;
844 rc = sigwait(&signalMask, &iSignal);
845 }
846 while ( rc == EINTR
847# ifdef ERESTART
848 || rc == ERESTART
849# endif
850 );
851
852 VGSvcVerbose(3, "VGSvcMainWait: Received signal %d (rc=%d)\n", iSignal, rc);
853#endif /* !RT_OS_WINDOWS */
854}
855
856
857int main(int argc, char **argv)
858{
859 RTEXITCODE rcExit;
860
861 /*
862 * Init globals and such.
863 */
864 int rc = RTR3InitExe(argc, &argv, 0);
865 if (RT_FAILURE(rc))
866 return RTMsgInitFailure(rc);
867 g_pszProgName = RTPathFilename(argv[0]);
868#ifdef DEBUG
869 rc = RTCritSectInit(&g_csLog);
870 AssertRC(rc);
871#endif
872
873#ifdef VBOX_WITH_VBOXSERVICE_TOOLBOX
874 /*
875 * Run toolbox code before all other stuff since these things are simpler
876 * shell/file/text utility like programs that just happens to be inside
877 * VBoxService and shouldn't be subject to /dev/vboxguest, pid-files and
878 * global mutex restrictions.
879 */
880 if (VGSvcToolboxMain(argc, argv, &rcExit))
881 return rcExit;
882#endif
883
884 bool fUserSession = false;
885#ifdef VBOX_WITH_VBOXSERVICE_CONTROL
886 /*
887 * Check if we're the specially spawned VBoxService.exe process that
888 * handles a guest control session.
889 */
890 if ( argc >= 2
891 && !RTStrICmp(argv[1], "guestsession"))
892 fUserSession = true;
893#endif
894
895 /*
896 * Connect to the kernel part before daemonizing so we can fail and
897 * complain if there is some kind of problem. We need to initialize the
898 * guest lib *before* we do the pre-init just in case one of services needs
899 * do to some initial stuff with it.
900 */
901 if (fUserSession)
902 rc = VbglR3InitUser();
903 else
904 rc = VbglR3Init();
905 if (RT_FAILURE(rc))
906 {
907 if (rc == VERR_ACCESS_DENIED)
908 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Insufficient privileges to start %s! Please start with Administrator/root privileges!\n",
909 g_pszProgName);
910 return RTMsgErrorExit(RTEXITCODE_FAILURE, "VbglR3Init failed with rc=%Rrc\n", rc);
911 }
912
913#ifdef RT_OS_WINDOWS
914 /*
915 * Check if we're the specially spawned VBoxService.exe process that
916 * handles page fusion. This saves an extra statically linked executable.
917 */
918 if ( argc == 2
919 && !RTStrICmp(argv[1], "pagefusion"))
920 return VGSvcPageSharingWorkerChild();
921#endif
922
923#ifdef VBOX_WITH_VBOXSERVICE_CONTROL
924 /*
925 * Check if we're the specially spawned VBoxService.exe process that
926 * handles a guest control session.
927 */
928 if (fUserSession)
929 return VGSvcGstCtrlSessionSpawnInit(argc, argv);
930#endif
931
932 /*
933 * Parse the arguments.
934 *
935 * Note! This code predates RTGetOpt, thus the manual parsing.
936 */
937 bool fDaemonize = true;
938 bool fDaemonized = false;
939 for (int i = 1; i < argc; i++)
940 {
941 const char *psz = argv[i];
942 if (*psz != '-')
943 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown argument '%s'\n", psz);
944 psz++;
945
946 /* translate long argument to short */
947 if (*psz == '-')
948 {
949 psz++;
950 size_t cch = strlen(psz);
951#define MATCHES(strconst) ( cch == sizeof(strconst) - 1 \
952 && !memcmp(psz, strconst, sizeof(strconst) - 1) )
953 if (MATCHES("foreground"))
954 psz = "f";
955 else if (MATCHES("verbose"))
956 psz = "v";
957 else if (MATCHES("version"))
958 psz = "V";
959 else if (MATCHES("help"))
960 psz = "h";
961 else if (MATCHES("interval"))
962 psz = "i";
963#ifdef RT_OS_WINDOWS
964 else if (MATCHES("register"))
965 psz = "r";
966 else if (MATCHES("unregister"))
967 psz = "u";
968#endif
969 else if (MATCHES("logfile"))
970 psz = "l";
971 else if (MATCHES("pidfile"))
972 psz = "p";
973 else if (MATCHES("daemonized"))
974 {
975 fDaemonized = true;
976 continue;
977 }
978 else
979 {
980 bool fFound = false;
981
982 if (cch > sizeof("enable-") && !memcmp(psz, RT_STR_TUPLE("enable-")))
983 for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
984 if ((fFound = !RTStrICmp(psz + sizeof("enable-") - 1, g_aServices[j].pDesc->pszName)))
985 g_aServices[j].fEnabled = true;
986
987 if (cch > sizeof("disable-") && !memcmp(psz, RT_STR_TUPLE("disable-")))
988 for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
989 if ((fFound = !RTStrICmp(psz + sizeof("disable-") - 1, g_aServices[j].pDesc->pszName)))
990 g_aServices[j].fEnabled = false;
991
992 if (cch > sizeof("only-") && !memcmp(psz, RT_STR_TUPLE("only-")))
993 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
994 {
995 g_aServices[j].fEnabled = !RTStrICmp(psz + sizeof("only-") - 1, g_aServices[j].pDesc->pszName);
996 if (g_aServices[j].fEnabled)
997 fFound = true;
998 }
999
1000 if (!fFound)
1001 {
1002 rcExit = vgsvcLazyPreInit();
1003 if (rcExit != RTEXITCODE_SUCCESS)
1004 return rcExit;
1005 for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
1006 {
1007 rc = g_aServices[j].pDesc->pfnOption(NULL, argc, argv, &i);
1008 fFound = rc == VINF_SUCCESS;
1009 if (fFound)
1010 break;
1011 if (rc != -1)
1012 return rc;
1013 }
1014 }
1015 if (!fFound)
1016 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option '%s'\n", argv[i]);
1017 continue;
1018 }
1019#undef MATCHES
1020 }
1021
1022 /* handle the string of short options. */
1023 do
1024 {
1025 switch (*psz)
1026 {
1027 case 'i':
1028 rc = VGSvcArgUInt32(argc, argv, psz + 1, &i,
1029 &g_DefaultInterval, 1, (UINT32_MAX / 1000) - 1);
1030 if (rc)
1031 return rc;
1032 psz = NULL;
1033 break;
1034
1035 case 'f':
1036 fDaemonize = false;
1037 break;
1038
1039 case 'v':
1040 g_cVerbosity++;
1041 break;
1042
1043 case 'V':
1044 RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
1045 return RTEXITCODE_SUCCESS;
1046
1047 case 'h':
1048 case '?':
1049 return vgsvcUsage();
1050
1051#ifdef RT_OS_WINDOWS
1052 case 'r':
1053 return VGSvcWinInstall();
1054
1055 case 'u':
1056 return VGSvcWinUninstall();
1057#endif
1058
1059 case 'l':
1060 {
1061 rc = vgsvcArgString(argc, argv, psz + 1, &i,
1062 g_szLogFile, sizeof(g_szLogFile));
1063 if (rc)
1064 return rc;
1065 psz = NULL;
1066 break;
1067 }
1068
1069 case 'p':
1070 {
1071 rc = vgsvcArgString(argc, argv, psz + 1, &i,
1072 g_szPidFile, sizeof(g_szPidFile));
1073 if (rc)
1074 return rc;
1075 psz = NULL;
1076 break;
1077 }
1078
1079 default:
1080 {
1081 rcExit = vgsvcLazyPreInit();
1082 if (rcExit != RTEXITCODE_SUCCESS)
1083 return rcExit;
1084
1085 bool fFound = false;
1086 for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
1087 {
1088 rc = g_aServices[j].pDesc->pfnOption(&psz, argc, argv, &i);
1089 fFound = rc == VINF_SUCCESS;
1090 if (fFound)
1091 break;
1092 if (rc != -1)
1093 return rc;
1094 }
1095 if (!fFound)
1096 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option '%c' (%s)\n", *psz, argv[i]);
1097 break;
1098 }
1099 }
1100 } while (psz && *++psz);
1101 }
1102
1103 /* Check that at least one service is enabled. */
1104 if (vgsvcCountEnabledServices() == 0)
1105 return RTMsgErrorExit(RTEXITCODE_SYNTAX, "At least one service must be enabled\n");
1106
1107 rc = VGSvcLogCreate(g_szLogFile[0] ? g_szLogFile : NULL);
1108 if (RT_FAILURE(rc))
1109 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to create release log '%s', rc=%Rrc\n",
1110 g_szLogFile[0] ? g_szLogFile : "<None>", rc);
1111
1112 /* Call pre-init if we didn't do it already. */
1113 rcExit = vgsvcLazyPreInit();
1114 if (rcExit != RTEXITCODE_SUCCESS)
1115 return rcExit;
1116
1117#ifdef RT_OS_WINDOWS
1118 /*
1119 * Make sure only one instance of VBoxService runs at a time. Create a
1120 * global mutex for that.
1121 *
1122 * Note! The \\Global\ namespace was introduced with Win2K, thus the
1123 * version check.
1124 * Note! If the mutex exists CreateMutex will open it and set last error to
1125 * ERROR_ALREADY_EXISTS.
1126 */
1127 OSVERSIONINFOEX OSInfoEx;
1128 RT_ZERO(OSInfoEx);
1129 OSInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1130
1131 SetLastError(NO_ERROR);
1132 HANDLE hMutexAppRunning;
1133 if ( GetVersionEx((LPOSVERSIONINFO)&OSInfoEx)
1134 && OSInfoEx.dwPlatformId == VER_PLATFORM_WIN32_NT
1135 && OSInfoEx.dwMajorVersion >= 5 /* NT 5.0 a.k.a W2K */)
1136 hMutexAppRunning = CreateMutex(NULL, FALSE, "Global\\" VBOXSERVICE_NAME);
1137 else
1138 hMutexAppRunning = CreateMutex(NULL, FALSE, VBOXSERVICE_NAME);
1139 if (hMutexAppRunning == NULL)
1140 {
1141 DWORD dwErr = GetLastError();
1142 if ( dwErr == ERROR_ALREADY_EXISTS
1143 || dwErr == ERROR_ACCESS_DENIED)
1144 {
1145 VGSvcError("%s is already running! Terminating.\n", g_pszProgName);
1146 return RTEXITCODE_FAILURE;
1147 }
1148
1149 VGSvcError("CreateMutex failed with last error %u! Terminating.\n", GetLastError());
1150 return RTEXITCODE_FAILURE;
1151 }
1152
1153#else /* !RT_OS_WINDOWS */
1154 /** @todo Add PID file creation here? */
1155#endif /* !RT_OS_WINDOWS */
1156
1157 VGSvcVerbose(0, "%s r%s started. Verbose level = %d\n", RTBldCfgVersion(), RTBldCfgRevisionStr(), g_cVerbosity);
1158
1159 /*
1160 * Daemonize if requested.
1161 */
1162 if (fDaemonize && !fDaemonized)
1163 {
1164#ifdef RT_OS_WINDOWS
1165 VGSvcVerbose(2, "Starting service dispatcher ...\n");
1166 rcExit = VGSvcWinEnterCtrlDispatcher();
1167#else
1168 VGSvcVerbose(1, "Daemonizing...\n");
1169 rc = VbglR3Daemonize(false /* fNoChDir */, false /* fNoClose */,
1170 false /* fRespawn */, NULL /* pcRespawn */);
1171 if (RT_FAILURE(rc))
1172 return VGSvcError("Daemon failed: %Rrc\n", rc);
1173 /* in-child */
1174#endif
1175 }
1176#ifdef RT_OS_WINDOWS
1177 else
1178#endif
1179 {
1180 /*
1181 * Windows: We're running the service as a console application now. Start the
1182 * services, enter the main thread's run loop and stop them again
1183 * when it returns.
1184 *
1185 * POSIX: This is used for both daemons and console runs. Start all services
1186 * and return immediately.
1187 */
1188#ifdef RT_OS_WINDOWS
1189# ifndef RT_OS_NT4 /** @todo r=bird: What's RT_OS_NT4??? */
1190 /* Install console control handler. */
1191 if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)vgsvcWinConsoleControlHandler, TRUE /* Add handler */))
1192 {
1193 VGSvcError("Unable to add console control handler, error=%ld\n", GetLastError());
1194 /* Just skip this error, not critical. */
1195 }
1196# endif /* !RT_OS_NT4 */
1197#endif /* RT_OS_WINDOWS */
1198 rc = VGSvcStartServices();
1199 RTFILE hPidFile = NIL_RTFILE;
1200 if (RT_SUCCESS(rc))
1201 if (g_szPidFile[0])
1202 rc = VbglR3PidFile(g_szPidFile, &hPidFile);
1203 rcExit = RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1204 if (RT_SUCCESS(rc))
1205 VGSvcMainWait();
1206 if (g_szPidFile[0] && hPidFile != NIL_RTFILE)
1207 VbglR3ClosePidFile(g_szPidFile, hPidFile);
1208#ifdef RT_OS_WINDOWS
1209# ifndef RT_OS_NT4
1210 /* Uninstall console control handler. */
1211 if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */))
1212 {
1213 VGSvcError("Unable to remove console control handler, error=%ld\n", GetLastError());
1214 /* Just skip this error, not critical. */
1215 }
1216# endif /* !RT_OS_NT4 */
1217#else /* !RT_OS_WINDOWS */
1218 /* On Windows - since we're running as a console application - we already stopped all services
1219 * through the console control handler. So only do the stopping of services here on other platforms
1220 * where the break/shutdown/whatever signal was just received. */
1221 VGSvcStopServices();
1222#endif /* RT_OS_WINDOWS */
1223 }
1224 VGSvcReportStatus(VBoxGuestFacilityStatus_Terminated);
1225
1226#ifdef RT_OS_WINDOWS
1227 /*
1228 * Cleanup mutex.
1229 */
1230 CloseHandle(hMutexAppRunning);
1231#endif
1232
1233 VGSvcVerbose(0, "Ended.\n");
1234
1235#ifdef DEBUG
1236 RTCritSectDelete(&g_csLog);
1237 //RTMemTrackerDumpAllToStdOut();
1238#endif
1239
1240 VGSvcLogDestroy();
1241
1242 return rcExit;
1243}
1244
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette