VirtualBox

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

Last change on this file since 76553 was 76553, checked in by vboxsync, 5 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use