static void WINAPI vboxServiceWinMain(DWORD argc, LPTSTR *argv)
{
VBoxServiceVerbose(2, "Registering service control handler ...\n");
#ifdef TARGET_NT4
g_hWinServiceStatus = RegisterServiceCtrlHandler(VBOXSERVICE_NAME, vboxServiceWinCtrlHandler);
#else
g_hWinServiceStatus = RegisterServiceCtrlHandlerEx(VBOXSERVICE_NAME, vboxServiceWinCtrlHandler, NULL);
#endif
if (g_hWinServiceStatus != NULL)
{
VBoxServiceVerbose(2, "Service control handler registered.\n");
vboxServiceWinStart();
}
else
{
DWORD dwErr = GetLastError();
switch (dwErr)
{
case ERROR_INVALID_NAME:
VBoxServiceError("Invalid service name!\n");
break;
case ERROR_SERVICE_DOES_NOT_EXIST:
VBoxServiceError("Service does not exist!\n");
break;
default:
VBoxServiceError("Could not register service control handle! Error: %ld\n", dwErr);
break;
}
}
}
/**
* Handles VMMDevCpuEventType_Unplug.
*
* @param idCpuCore The CPU core ID.
* @param idCpuPackage The CPU package ID.
*/
static void VBoxServiceCpuHotPlugHandleUnplugEvent(uint32_t idCpuCore, uint32_t idCpuPackage)
{
#ifdef RT_OS_LINUX
char *pszCpuDevicePath = NULL;
int rc = VBoxServiceCpuHotPlugGetACPIDevicePath(&pszCpuDevicePath, idCpuCore, idCpuPackage);
if (RT_SUCCESS(rc))
{
RTFILE hFileCpuEject;
rc = RTFileOpenF(&hFileCpuEject, RTFILE_O_WRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
"%s/eject", pszCpuDevicePath);
if (RT_SUCCESS(rc))
{
/* Write a 1 to eject the CPU */
rc = RTFileWrite(hFileCpuEject, "1", 1, NULL);
if (RT_SUCCESS(rc))
VBoxServiceVerbose(1, "CpuHotPlug: CPU %u/%u was ejected\n", idCpuPackage, idCpuCore);
else
VBoxServiceError("CpuHotPlug: Failed to eject CPU %u/%u rc=%Rrc\n", idCpuPackage, idCpuCore, rc);
RTFileClose(hFileCpuEject);
}
else
VBoxServiceError("CpuHotPlug: Failed to open \"%s/eject\" rc=%Rrc\n", pszCpuDevicePath, rc);
RTStrFree(pszCpuDevicePath);
}
else
VBoxServiceError("CpuHotPlug: Failed to get CPU device path rc=%Rrc\n", rc);
#else
# error "Port me"
#endif
}
/**
* Wrapper around VbglR3GuestPropWriteValue that does value formatting and
* logging.
*
* @returns VBox status code. Errors will be logged.
*
* @param u32ClientId The HGCM client ID for the guest property session.
* @param pszName The property name.
* @param pszValueFormat The property format string. If this is NULL then
* the property will be deleted (if possible).
* @param ... Format arguments.
*/
int VBoxServiceWritePropF(uint32_t u32ClientId, const char *pszName, const char *pszValueFormat, ...)
{
AssertPtr(pszName);
int rc;
if (pszValueFormat != NULL)
{
va_list va;
va_start(va, pszValueFormat);
VBoxServiceVerbose(3, "Writing guest property \"%s\" = \"%N\"\n", pszName, pszValueFormat, &va);
va_end(va);
va_start(va, pszValueFormat);
rc = VbglR3GuestPropWriteValueV(u32ClientId, pszName, pszValueFormat, va);
va_end(va);
if (RT_FAILURE(rc))
VBoxServiceError("Error writing guest property \"%s\" (rc=%Rrc)\n", pszName, rc);
}
else
{
VBoxServiceVerbose(3, "Deleting guest property \"%s\"\n", pszName);
rc = VbglR3GuestPropWriteValue(u32ClientId, pszName, NULL);
if (RT_FAILURE(rc))
VBoxServiceError("Error deleting guest property \"%s\" (rc=%Rrc)\n", pszName, rc);
}
return rc;
}
/** @todo Integrate into RTFsQueryMountpoint(). */
static bool VBoxServiceAutoMountShareIsMounted(const char *pszShare,
char *pszMountPoint, size_t cbMountPoint)
{
AssertPtrReturn(pszShare, VERR_INVALID_PARAMETER);
AssertPtrReturn(pszMountPoint, VERR_INVALID_PARAMETER);
AssertReturn(cbMountPoint, VERR_INVALID_PARAMETER);
bool fMounted = false;
/* @todo What to do if we have a relative path in mtab instead
* of an absolute one ("temp" vs. "/media/temp")?
* procfs contains the full path but not the actual share name ...
* FILE *pFh = setmntent("/proc/mounts", "r+t"); */
#ifdef RT_OS_SOLARIS
FILE *pFh = fopen(_PATH_MOUNTED, "r");
if (!pFh)
VBoxServiceError("VBoxServiceAutoMountShareIsMounted: Could not open mount tab \"%s\"!\n",
_PATH_MOUNTED);
else
{
mnttab mntTab;
while ((getmntent(pFh, &mntTab)))
{
if (!RTStrICmp(mntTab.mnt_special, pszShare))
{
fMounted = RTStrPrintf(pszMountPoint, cbMountPoint, "%s", mntTab.mnt_mountp)
? true : false;
break;
}
}
fclose(pFh);
}
#else
FILE *pFh = setmntent(_PATH_MOUNTED, "r+t");
if (pFh == NULL)
VBoxServiceError("VBoxServiceAutoMountShareIsMounted: Could not open mount tab \"%s\"!\n",
_PATH_MOUNTED);
else
{
mntent *pMntEnt;
while ((pMntEnt = getmntent(pFh)))
{
if (!RTStrICmp(pMntEnt->mnt_fsname, pszShare))
{
fMounted = RTStrPrintf(pszMountPoint, cbMountPoint, "%s", pMntEnt->mnt_dir)
? true : false;
break;
}
}
endmntent(pFh);
}
#endif
VBoxServiceVerbose(4, "VBoxServiceAutoMountShareIsMounted: Share \"%s\" at mount point \"%s\" = %s\n",
pszShare, fMounted ? pszMountPoint : "<None>", fMounted ? "Yes" : "No");
return fMounted;
}
static BOOL WINAPI VBoxServiceConsoleControlHandler(DWORD dwCtrlType)
{
int rc = VINF_SUCCESS;
bool fEventHandled = FALSE;
switch (dwCtrlType)
{
/* User pressed CTRL+C or CTRL+BREAK or an external event was sent
* via GenerateConsoleCtrlEvent(). */
case CTRL_BREAK_EVENT:
case CTRL_CLOSE_EVENT:
case CTRL_C_EVENT:
VBoxServiceVerbose(2, "ControlHandler: Received break/close event\n");
rc = VBoxServiceStopServices();
fEventHandled = TRUE;
break;
default:
break;
/** @todo Add other events here. */
}
if (RT_FAILURE(rc))
VBoxServiceError("ControlHandler: Event %ld handled with error rc=%Rrc\n",
dwCtrlType, rc);
return fEventHandled;
}
/** @copydoc VBOXSERVICE::pfnTerm */
static DECLCALLBACK(void) VBoxServiceVMInfoTerm(void)
{
if (g_hVMInfoEvent != NIL_RTSEMEVENTMULTI)
{
/** @todo temporary solution: Zap all values which are not valid
* anymore when VM goes down (reboot/shutdown ). Needs to
* be replaced with "temporary properties" later.
*
* One idea is to introduce a (HGCM-)session guest property
* flag meaning that a guest property is only valid as long
* as the HGCM session isn't closed (e.g. guest application
* terminates). [don't remove till implemented]
*/
/** @todo r=bird: Drop the VbglR3GuestPropDelSet call here and use the cache
* since it remembers what we've written. */
/* Delete the "../Net" branch. */
const char *apszPat[1] = { "/VirtualBox/GuestInfo/Net/*" };
int rc = VbglR3GuestPropDelSet(g_uVMInfoGuestPropSvcClientID, &apszPat[0], RT_ELEMENTS(apszPat));
/* Destroy property cache. */
VBoxServicePropCacheDestroy(&g_VMInfoPropCache);
/* Disconnect from guest properties service. */
rc = VbglR3GuestPropDisconnect(g_uVMInfoGuestPropSvcClientID);
if (RT_FAILURE(rc))
VBoxServiceError("VMInfo: Failed to disconnect from guest property service! Error: %Rrc\n", rc);
g_uVMInfoGuestPropSvcClientID = 0;
RTSemEventMultiDestroy(g_hVMInfoEvent);
g_hVMInfoEvent = NIL_RTSEMEVENTMULTI;
}
}
/** @copydoc VBOXSERVICE::pfnInit */
static DECLCALLBACK(int) VBoxServiceAutoMountInit(void)
{
VBoxServiceVerbose(3, "VBoxServiceAutoMountInit\n");
int rc = RTSemEventMultiCreate(&g_AutoMountEvent);
AssertRCReturn(rc, rc);
rc = VbglR3SharedFolderConnect(&g_SharedFoldersSvcClientID);
if (RT_SUCCESS(rc))
{
VBoxServiceVerbose(3, "VBoxServiceAutoMountInit: Service Client ID: %#x\n", g_SharedFoldersSvcClientID);
}
else
{
/* If the service was not found, we disable this service without
causing VBoxService to fail. */
if (rc == VERR_HGCM_SERVICE_NOT_FOUND) /* Host service is not available. */
{
VBoxServiceVerbose(0, "VBoxServiceAutoMountInit: Shared Folders service is not available\n");
rc = VERR_SERVICE_DISABLED;
}
else
VBoxServiceError("Control: Failed to connect to the Shared Folders service! Error: %Rrc\n", rc);
RTSemEventMultiDestroy(g_AutoMountEvent);
g_AutoMountEvent = NIL_RTSEMEVENTMULTI;
}
return rc;
}
/**
* Call StartServiceCtrlDispatcher.
*
* The main() thread invokes this when not started in foreground mode. It
* won't return till the service is being shutdown (unless start up fails).
*
* @returns RTEXITCODE_SUCCESS on normal return after service shutdown.
* Something else on failure, error will have been reported.
*/
RTEXITCODE VBoxServiceWinEnterCtrlDispatcher(void)
{
if (!StartServiceCtrlDispatcher(&g_aServiceTable[0]))
return VBoxServiceError("StartServiceCtrlDispatcher: %u. Please start %s with option -f (foreground)!\n",
GetLastError(), g_pszProgName);
return RTEXITCODE_SUCCESS;
}
/**
* Try adjust the time using adjtime or similar.
*
* @returns true on success, false on failure.
*
* @param pDrift The time adjustment.
*/
static void VBoxServiceTimeSyncSet(PCRTTIMESPEC pDrift)
{
/*
* Query the current time, adjust it by adding the drift and set it.
*/
RTTIMESPEC NewGuestTime;
int rc = RTTimeSet(RTTimeSpecAdd(RTTimeNow(&NewGuestTime), pDrift));
if (RT_SUCCESS(rc))
{
/* Succeeded - reset the error count and log the change. */
g_cTimeSyncErrors = 0;
if (g_cVerbosity >= 1)
{
char sz[64];
RTTIME Time;
VBoxServiceVerbose(1, "time set to %s\n",
RTTimeToString(RTTimeExplode(&Time, &NewGuestTime), sz, sizeof(sz)));
#ifdef DEBUG
RTTIMESPEC Tmp;
if (g_cVerbosity >= 3)
VBoxServiceVerbose(3, " now %s\n",
RTTimeToString(RTTimeExplode(&Time, RTTimeNow(&Tmp)), sz, sizeof(sz)));
#endif
}
}
else if (g_cTimeSyncErrors++ < 10)
VBoxServiceError("VBoxServiceTimeSyncSet: RTTimeSet(%RDtimespec) failed: %Rrc\n", &NewGuestTime, rc);
}
/**
* Uninstalls the service.
*/
RTEXITCODE VBoxServiceWinUninstall(void)
{
VBoxServiceVerbose(1, "Uninstalling service ...\n");
SC_HANDLE hSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
if (hSCManager == NULL)
{
VBoxServiceError("Could not open SCM! Error: %d\n", GetLastError());
return RTEXITCODE_FAILURE;
}
RTEXITCODE rcExit;
SC_HANDLE hService = OpenService(hSCManager, VBOXSERVICE_NAME, SERVICE_ALL_ACCESS );
if (hService != NULL)
{
if (DeleteService(hService))
{
/*
* ???
*/
HKEY hKey = NULL;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Services\\EventLog\\System",
0,
KEY_ALL_ACCESS,
&hKey)
== ERROR_SUCCESS)
{
RegDeleteKey(hKey, VBOXSERVICE_NAME);
RegCloseKey(hKey);
}
VBoxServiceVerbose(0, "Service successfully uninstalled!\n");
rcExit = RTEXITCODE_SUCCESS;
}
else
rcExit = VBoxServiceError("Could not remove service! Error: %d\n", GetLastError());
CloseServiceHandle(hService);
}
else
rcExit = VBoxServiceError("Could not open service! Error: %d\n", GetLastError());
CloseServiceHandle(hSCManager);
return rcExit;
}
/** Reports our current status to the SCM. */
static BOOL vboxServiceWinSetStatus(DWORD dwStatus, DWORD dwCheckPoint)
{
if (g_hWinServiceStatus == NULL) /* Program could be in testing mode, so no service environment available. */
return FALSE;
VBoxServiceVerbose(2, "Setting service status to: %ld\n", dwStatus);
g_dwWinServiceLastStatus = dwStatus;
SERVICE_STATUS ss;
RT_ZERO(ss);
ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
ss.dwCurrentState = dwStatus;
/* Don't accept controls when in start pending state. */
if (ss.dwCurrentState != SERVICE_START_PENDING)
{
ss.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
#ifndef TARGET_NT4
/* Don't use SERVICE_ACCEPT_SESSIONCHANGE on Windows 2000.
* This makes SCM angry. */
char szOSVersion[32];
int rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE,
szOSVersion, sizeof(szOSVersion));
if (RT_SUCCESS(rc))
{
if (RTStrVersionCompare(szOSVersion, "5.1") >= 0)
ss.dwControlsAccepted |= SERVICE_ACCEPT_SESSIONCHANGE;
}
else
VBoxServiceError("Error determining OS version, rc=%Rrc\n", rc);
#endif
}
ss.dwWin32ExitCode = NO_ERROR;
ss.dwServiceSpecificExitCode = 0; /* Not used */
ss.dwCheckPoint = dwCheckPoint;
ss.dwWaitHint = 3000;
BOOL fStatusSet = SetServiceStatus(g_hWinServiceStatus, &ss);
if (!fStatusSet)
VBoxServiceError("Error reporting service status=%ld (controls=%x, checkpoint=%ld) to SCM: %ld\n",
dwStatus, ss.dwControlsAccepted, dwCheckPoint, GetLastError());
return fStatusSet;
}
/**
* Lazily calls the pfnPreInit method on each service.
*
* @returns VBox status code, error message displayed.
*/
static RTEXITCODE vboxServiceLazyPreInit(void)
{
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
if (!g_aServices[j].fPreInited)
{
int rc = g_aServices[j].pDesc->pfnPreInit();
if (RT_FAILURE(rc))
return VBoxServiceError("Service '%s' failed pre-init: %Rrc\n", g_aServices[j].pDesc->pszName, rc);
g_aServices[j].fPreInited = true;
}
return RTEXITCODE_SUCCESS;
}
/** @copydoc VBOXSERVICE::pfnInit */
static DECLCALLBACK(int) VBoxServiceVMInfoInit(void)
{
/*
* If not specified, find the right interval default.
* Then create the event sem to block on.
*/
if (!g_cMsVMInfoInterval)
g_cMsVMInfoInterval = g_DefaultInterval * 1000;
if (!g_cMsVMInfoInterval)
g_cMsVMInfoInterval = 10 * 1000;
int rc = RTSemEventMultiCreate(&g_hVMInfoEvent);
AssertRCReturn(rc, rc);
VbglR3GetSessionId(&g_idVMInfoSession);
/* The status code is ignored as this information is not available with VBox < 3.2.10. */
rc = VbglR3GuestPropConnect(&g_uVMInfoGuestPropSvcClientID);
if (RT_SUCCESS(rc))
VBoxServiceVerbose(3, "VMInfo: Property Service Client ID: %#x\n", g_uVMInfoGuestPropSvcClientID);
else
{
/* If the service was not found, we disable this service without
causing VBoxService to fail. */
if (rc == VERR_HGCM_SERVICE_NOT_FOUND) /* Host service is not available. */
{
VBoxServiceVerbose(0, "VMInfo: Guest property service is not available, disabling the service\n");
rc = VERR_SERVICE_DISABLED;
}
else
VBoxServiceError("VMInfo: Failed to connect to the guest property service! Error: %Rrc\n", rc);
RTSemEventMultiDestroy(g_hVMInfoEvent);
g_hVMInfoEvent = NIL_RTSEMEVENTMULTI;
}
if (RT_SUCCESS(rc))
{
VBoxServicePropCacheCreate(&g_VMInfoPropCache, g_uVMInfoGuestPropSvcClientID);
/*
* Declare some guest properties with flags and reset values.
*/
VBoxServicePropCacheUpdateEntry(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/LoggedInUsersList",
VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_TRANSIENT, NULL /* Delete on exit */);
VBoxServicePropCacheUpdateEntry(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/LoggedInUsers",
VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_TRANSIENT, "0");
VBoxServicePropCacheUpdateEntry(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/NoLoggedInUsers",
VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_TRANSIENT, "true");
VBoxServicePropCacheUpdateEntry(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/Net/Count",
VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_ALWAYS_UPDATE, NULL /* Delete on exit */);
}
return rc;
}
/**
* Cancels any pending time adjustment.
*
* Called when we've caught up and before calls to VBoxServiceTimeSyncSet.
*/
static void VBoxServiceTimeSyncCancelAdjust(void)
{
#ifdef RT_OS_WINDOWS
/** @todo r=bird: g_hTokenProcess cannot be NULL here. See argumentation in
* VBoxServiceTimeSyncAdjust. */
if (g_hTokenProcess == NULL) /* No process token (anymore)? */
return;
if (SetSystemTimeAdjustment(0, TRUE /* Periodic adjustments disabled. */))
VBoxServiceVerbose(3, "VBoxServiceTimeSyncCancelAdjust: Windows Time Adjustment is now disabled.\n");
else if (g_cTimeSyncErrors++ < 10)
VBoxServiceError("VBoxServiceTimeSyncCancelAdjust: SetSystemTimeAdjustment(,disable) failed, error=%u\n", GetLastError());
#endif /* !RT_OS_WINDOWS */
}
static int VBoxServiceAutoMountPrepareMountPoint(const char *pszMountPoint, const char *pszShareName,
vbsf_mount_opts *pOpts)
{
AssertPtrReturn(pOpts, VERR_INVALID_PARAMETER);
AssertPtrReturn(pszMountPoint, VERR_INVALID_PARAMETER);
AssertPtrReturn(pszShareName, VERR_INVALID_PARAMETER);
RTFMODE fMode = RTFS_UNIX_IRWXU | RTFS_UNIX_IRWXG; /* Owner (=root) and the group (=vboxsf) have full access. */
int rc = RTDirCreateFullPath(pszMountPoint, fMode);
if (RT_SUCCESS(rc))
{
rc = RTPathSetOwnerEx(pszMountPoint, NIL_RTUID /* Owner, unchanged */, pOpts->gid, RTPATH_F_ON_LINK);
if (RT_SUCCESS(rc))
{
rc = RTPathSetMode(pszMountPoint, fMode);
if (RT_FAILURE(rc))
{
if (rc == VERR_WRITE_PROTECT)
{
VBoxServiceVerbose(3, "VBoxServiceAutoMountPrepareMountPoint: Mount directory \"%s\" already is used/mounted\n", pszMountPoint);
rc = VINF_SUCCESS;
}
else
VBoxServiceError("VBoxServiceAutoMountPrepareMountPoint: Could not set mode %RTfmode for mount directory \"%s\", rc = %Rrc\n",
fMode, pszMountPoint, rc);
}
}
else
VBoxServiceError("VBoxServiceAutoMountPrepareMountPoint: Could not set permissions for mount directory \"%s\", rc = %Rrc\n",
pszMountPoint, rc);
}
else
VBoxServiceError("VBoxServiceAutoMountPrepareMountPoint: Could not create mount directory \"%s\" with mode %RTfmode, rc = %Rrc\n",
pszMountPoint, fMode, rc);
return rc;
}
static RTEXITCODE vboxServiceWinSetDesc(SC_HANDLE hService)
{
#ifndef TARGET_NT4
/* On W2K+ there's ChangeServiceConfig2() which lets us set some fields
like a longer service description. */
/** @todo On Vista+ SERVICE_DESCRIPTION also supports localized strings! */
SERVICE_DESCRIPTION desc;
desc.lpDescription = VBOXSERVICE_DESCRIPTION;
if (!ChangeServiceConfig2(hService,
SERVICE_CONFIG_DESCRIPTION, /* Service info level */
&desc))
{
VBoxServiceError("Cannot set the service description! Error: %ld\n", GetLastError());
return RTEXITCODE_FAILURE;
}
#endif
return RTEXITCODE_SUCCESS;
}
/**
* Reports the current VBoxService status to the host.
*
* This makes sure that the Failed state is sticky.
*
* @return IPRT status code.
* @param enmStatus Status to report to the host.
*/
int VBoxServiceReportStatus(VBoxGuestFacilityStatus enmStatus)
{
/*
* VBoxGuestFacilityStatus_Failed is sticky.
*/
static VBoxGuestFacilityStatus s_enmLastStatus = VBoxGuestFacilityStatus_Inactive;
VBoxServiceVerbose(4, "Setting VBoxService status to %u\n", enmStatus);
if (s_enmLastStatus != VBoxGuestFacilityStatus_Failed)
{
int rc = VbglR3ReportAdditionsStatus(VBoxGuestFacilityType_VBoxService,
enmStatus, 0 /* Flags */);
if (RT_FAILURE(rc))
{
VBoxServiceError("Could not report VBoxService status (%u), rc=%Rrc\n", enmStatus, rc);
return rc;
}
s_enmLastStatus = enmStatus;
}
return VINF_SUCCESS;
}
/**
* Reads a guest property as a 32-bit value.
*
* @returns VBox status code, fully bitched.
*
* @param u32ClientId The HGCM client ID for the guest property session.
* @param pszPropName The property name.
* @param pu32 Where to store the 32-bit value.
*
*/
int VBoxServiceReadPropUInt32(uint32_t u32ClientId, const char *pszPropName,
uint32_t *pu32, uint32_t u32Min, uint32_t u32Max)
{
char *pszValue;
int rc = VBoxServiceReadProp(u32ClientId, pszPropName, &pszValue,
NULL /* ppszFlags */, NULL /* puTimestamp */);
if (RT_SUCCESS(rc))
{
char *pszNext;
rc = RTStrToUInt32Ex(pszValue, &pszNext, 0, pu32);
if ( RT_SUCCESS(rc)
&& (*pu32 < u32Min || *pu32 > u32Max))
{
rc = VBoxServiceError("The guest property value %s = %RU32 is out of range [%RU32..%RU32].\n",
pszPropName, *pu32, u32Min, u32Max);
}
RTStrFree(pszValue);
}
return rc;
}
/** @copydoc VBOXSERVICE::pfnTerm */
static DECLCALLBACK(void) VBoxServiceTimeSyncTerm(void)
{
#ifdef RT_OS_WINDOWS
/*
* Restore the SE_SYSTEMTIME_NAME token privileges (if init succeeded).
*/
if (g_hTokenProcess)
{
if (!AdjustTokenPrivileges(g_hTokenProcess, FALSE, &g_TkOldPrivileges, sizeof(TOKEN_PRIVILEGES), NULL, NULL))
{
DWORD dwErr = GetLastError();
VBoxServiceError("VBoxServiceTimeSyncTerm: Restoring token privileges (SE_SYSTEMTIME_NAME) failed with code %u!\n", dwErr);
}
CloseHandle(g_hTokenProcess);
g_hTokenProcess = NULL;
}
#endif /* !RT_OS_WINDOWS */
if (g_TimeSyncEvent != NIL_RTSEMEVENTMULTI)
{
RTSemEventMultiDestroy(g_TimeSyncEvent);
g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
}
}
/** @copydoc VBOXSERVICE::pfnWorker */
DECLCALLBACK(int) VBoxServiceCpuHotPlugWorker(bool volatile *pfShutdown)
{
/*
* Tell the control thread that it can continue spawning services.
*/
RTThreadUserSignal(RTThreadSelf());
/*
* Enable the CPU hotplug notifier.
*/
int rc = VbglR3CpuHotPlugInit();
if (RT_FAILURE(rc))
return rc;
/*
* The Work Loop.
*/
for (;;)
{
/* Wait for CPU hot plugging event. */
uint32_t idCpuCore;
uint32_t idCpuPackage;
VMMDevCpuEventType enmEventType;
rc = VbglR3CpuHotPlugWaitForEvent(&enmEventType, &idCpuCore, &idCpuPackage);
if (RT_SUCCESS(rc))
{
VBoxServiceVerbose(3, "CpuHotPlug: Event happened idCpuCore=%u idCpuPackage=%u enmEventType=%d\n",
idCpuCore, idCpuPackage, enmEventType);
switch (enmEventType)
{
case VMMDevCpuEventType_Plug:
VBoxServiceCpuHotPlugHandlePlugEvent(idCpuCore, idCpuPackage);
break;
case VMMDevCpuEventType_Unplug:
VBoxServiceCpuHotPlugHandleUnplugEvent(idCpuCore, idCpuPackage);
break;
default:
{
static uint32_t s_iErrors = 0;
if (s_iErrors++ < 10)
VBoxServiceError("CpuHotPlug: Unknown event: idCpuCore=%u idCpuPackage=%u enmEventType=%d\n",
idCpuCore, idCpuPackage, enmEventType);
break;
}
}
}
else if (rc != VERR_INTERRUPTED && rc != VERR_TRY_AGAIN)
{
VBoxServiceError("CpuHotPlug: VbglR3CpuHotPlugWaitForEvent returned %Rrc\n", rc);
break;
}
if (*pfShutdown)
break;
}
VbglR3CpuHotPlugTerm();
return rc;
}
/** @copydoc VBOXSERVICE::pfnPreInit */
static DECLCALLBACK(int) VBoxServiceTimeSyncPreInit(void)
{
#ifdef VBOX_WITH_GUEST_PROPS
/** @todo Merge this function with VBoxServiceTimeSyncOption() to generalize
* the "command line args override guest property values" behavior. */
/*
* Read the service options from the VM's guest properties.
* Note that these options can be overridden by the command line options later.
*/
uint32_t uGuestPropSvcClientID;
int rc = VbglR3GuestPropConnect(&uGuestPropSvcClientID);
if (RT_FAILURE(rc))
{
if (rc == VERR_HGCM_SERVICE_NOT_FOUND) /* Host service is not available. */
{
VBoxServiceVerbose(0, "VMInfo: Guest property service is not available, skipping\n");
rc = VINF_SUCCESS;
}
else
VBoxServiceError("Failed to connect to the guest property service! Error: %Rrc\n", rc);
}
else
{
rc = VBoxServiceReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-interval",
&g_TimeSyncInterval, 50, UINT32_MAX - 1);
if ( RT_SUCCESS(rc)
|| rc == VERR_NOT_FOUND)
{
rc = VBoxServiceReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-min-adjust",
&g_TimeSyncMinAdjust, 0, 3600000);
}
if ( RT_SUCCESS(rc)
|| rc == VERR_NOT_FOUND)
{
rc = VBoxServiceReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-latency-factor",
&g_TimeSyncLatencyFactor, 1, 1024);
}
if ( RT_SUCCESS(rc)
|| rc == VERR_NOT_FOUND)
{
rc = VBoxServiceReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-max-latency",
&g_TimeSyncMaxLatency, 1, 3600000);
}
if ( RT_SUCCESS(rc)
|| rc == VERR_NOT_FOUND)
{
rc = VBoxServiceReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold",
&g_TimeSyncSetThreshold, 0, 7*24*60*60*1000 /* a week */);
}
if ( RT_SUCCESS(rc)
|| rc == VERR_NOT_FOUND)
{
char *pszValue;
rc = VBoxServiceReadProp(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-start",
&pszValue, NULL /* ppszFlags */, NULL /* puTimestamp */);
if (RT_SUCCESS(rc))
{
g_fTimeSyncSetNext = true;
RTStrFree(pszValue);
}
}
if ( RT_SUCCESS(rc)
|| rc == VERR_NOT_FOUND)
{
uint32_t value;
rc = VBoxServiceReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-on-restore",
&value, 1, 1);
if (RT_SUCCESS(rc))
g_fTimeSyncSetOnRestore = !!value;
}
VbglR3GuestPropDisconnect(uGuestPropSvcClientID);
}
if (rc == VERR_NOT_FOUND) /* If a value is not found, don't be sad! */
rc = VINF_SUCCESS;
return rc;
#else
/* Nothing to do here yet. */
return VINF_SUCCESS;
#endif
}
/**
* Handles VMMDevCpuEventType_Plug.
*
* @param idCpuCore The CPU core ID.
* @param idCpuPackage The CPU package ID.
*/
static void VBoxServiceCpuHotPlugHandlePlugEvent(uint32_t idCpuCore, uint32_t idCpuPackage)
{
#ifdef RT_OS_LINUX
/*
* The topology directory (containing the physical and core id properties)
* is not available until the CPU is online. So we just iterate over all directories
* and enable every CPU which is not online already.
* Because the directory might not be available immediately we try a few times.
*
* @todo: Maybe use udev to monitor hot-add events from the kernel
*/
bool fCpuOnline = false;
unsigned cTries = 5;
do
{
PRTDIR pDirDevices = NULL;
int rc = RTDirOpen(&pDirDevices, SYSFS_CPU_PATH);
if (RT_SUCCESS(rc))
{
RTDIRENTRY DirFolderContent;
while (RT_SUCCESS(RTDirRead(pDirDevices, &DirFolderContent, NULL))) /* Assumption that szName has always enough space */
{
/** @todo r-bird: This code is bringing all CPUs online; the idCpuCore and
* idCpuPackage parameters are unused!
* aeichner: These files are not available at this point unfortunately. (see comment above)
* bird: Yes, but isn't that easily dealt with by doing:
* if (matching_topology() || !have_topology_directory())
* bring_cpu_online()
* That could save you the cpu0 and cpuidle checks to.
*/
/*
* Check if this is a CPU object.
* cpu0 is excluded because it is not possible to change the state
* of the first CPU on Linux (it doesn't even have an online file)
* and cpuidle is no CPU device. Prevents error messages later.
*/
if( !strncmp(DirFolderContent.szName, "cpu", 3)
&& strncmp(DirFolderContent.szName, "cpu0", 4)
&& strncmp(DirFolderContent.szName, "cpuidle", 7))
{
/* Get the sysdev */
RTFILE hFileCpuOnline = NIL_RTFILE;
rc = RTFileOpenF(&hFileCpuOnline, RTFILE_O_WRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
"%s/%s/online", SYSFS_CPU_PATH, DirFolderContent.szName);
if (RT_SUCCESS(rc))
{
/* Write a 1 to online the CPU */
rc = RTFileWrite(hFileCpuOnline, "1", 1, NULL);
RTFileClose(hFileCpuOnline);
if (RT_SUCCESS(rc))
{
VBoxServiceVerbose(1, "CpuHotPlug: CPU %u/%u was brought online\n", idCpuPackage, idCpuCore);
fCpuOnline = true;
break;
}
/* Error means CPU not present or online already */
}
else
VBoxServiceError("CpuHotPlug: Failed to open \"%s/%s/online\" rc=%Rrc\n",
SYSFS_CPU_PATH, DirFolderContent.szName, rc);
}
}
}
else
VBoxServiceError("CpuHotPlug: Failed to open path %s rc=%Rrc\n", SYSFS_CPU_PATH, rc);
/* Sleep a bit */
if (!fCpuOnline)
RTThreadSleep(10);
} while ( !fCpuOnline
&& cTries-- > 0);
#else
# error "Port me"
#endif
}
int main(int argc, char **argv)
{
RTEXITCODE rcExit;
/*
* Init globals and such.
*/
int rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
g_pszProgName = RTPathFilename(argv[0]);
#ifdef DEBUG
rc = RTCritSectInit(&g_csLog);
AssertRC(rc);
#endif
#ifdef VBOXSERVICE_TOOLBOX
/*
* Run toolbox code before all other stuff since these things are simpler
* shell/file/text utility like programs that just happens to be inside
* VBoxService and shouldn't be subject to /dev/vboxguest, pid-files and
* global mutex restrictions.
*/
if (VBoxServiceToolboxMain(argc, argv, &rcExit))
return rcExit;
#endif
/*
* Connect to the kernel part before daemonizing so we can fail and
* complain if there is some kind of problem. We need to initialize the
* guest lib *before* we do the pre-init just in case one of services needs
* do to some initial stuff with it.
*/
VBoxServiceVerbose(2, "Calling VbgR3Init()\n");
rc = VbglR3Init();
if (RT_FAILURE(rc))
{
if (rc == VERR_ACCESS_DENIED)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Insufficient privileges to start %s! Please start with Administrator/root privileges!\n",
g_pszProgName);
return RTMsgErrorExit(RTEXITCODE_FAILURE, "VbglR3Init failed with rc=%Rrc\n", rc);
}
#ifdef RT_OS_WINDOWS
/*
* Check if we're the specially spawned VBoxService.exe process that
* handles page fusion. This saves an extra executable.
*/
if ( argc == 2
&& !strcmp(argv[1], "--pagefusionfork"))
return VBoxServicePageSharingInitFork();
#endif
char szLogFile[RTPATH_MAX + 128] = "";
/*
* Parse the arguments.
*
* Note! This code predates RTGetOpt, thus the manual parsing.
*/
bool fDaemonize = true;
bool fDaemonized = false;
for (int i = 1; i < argc; i++)
{
const char *psz = argv[i];
if (*psz != '-')
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown argument '%s'\n", psz);
psz++;
/* translate long argument to short */
if (*psz == '-')
{
psz++;
size_t cch = strlen(psz);
#define MATCHES(strconst) ( cch == sizeof(strconst) - 1 \
&& !memcmp(psz, strconst, sizeof(strconst) - 1) )
if (MATCHES("foreground"))
psz = "f";
else if (MATCHES("verbose"))
psz = "v";
else if (MATCHES("version"))
psz = "V";
else if (MATCHES("help"))
psz = "h";
else if (MATCHES("interval"))
psz = "i";
#ifdef RT_OS_WINDOWS
else if (MATCHES("register"))
psz = "r";
else if (MATCHES("unregister"))
psz = "u";
#endif
else if (MATCHES("logfile"))
psz = "l";
else if (MATCHES("daemonized"))
{
fDaemonized = true;
continue;
}
else
{
bool fFound = false;
if (cch > sizeof("enable-") && !memcmp(psz, "enable-", sizeof("enable-") - 1))
for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
if ((fFound = !RTStrICmp(psz + sizeof("enable-") - 1, g_aServices[j].pDesc->pszName)))
g_aServices[j].fEnabled = true;
if (cch > sizeof("disable-") && !memcmp(psz, "disable-", sizeof("disable-") - 1))
for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
if ((fFound = !RTStrICmp(psz + sizeof("disable-") - 1, g_aServices[j].pDesc->pszName)))
g_aServices[j].fEnabled = false;
if (cch > sizeof("only-") && !memcmp(psz, "only-", sizeof("only-") - 1))
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
{
g_aServices[j].fEnabled = !RTStrICmp(psz + sizeof("only-") - 1, g_aServices[j].pDesc->pszName);
if (g_aServices[j].fEnabled)
fFound = true;
}
if (!fFound)
{
rcExit = vboxServiceLazyPreInit();
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
{
rc = g_aServices[j].pDesc->pfnOption(NULL, argc, argv, &i);
fFound = rc == VINF_SUCCESS;
if (fFound)
break;
if (rc != -1)
return rc;
}
}
if (!fFound)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option '%s'\n", argv[i]);
continue;
}
#undef MATCHES
}
/* handle the string of short options. */
do
{
switch (*psz)
{
case 'i':
rc = VBoxServiceArgUInt32(argc, argv, psz + 1, &i,
&g_DefaultInterval, 1, (UINT32_MAX / 1000) - 1);
if (rc)
return rc;
psz = NULL;
break;
case 'f':
fDaemonize = false;
break;
case 'v':
g_cVerbosity++;
break;
case 'V':
RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
return RTEXITCODE_SUCCESS;
case 'h':
case '?':
return vboxServiceUsage();
#ifdef RT_OS_WINDOWS
case 'r':
return VBoxServiceWinInstall();
case 'u':
return VBoxServiceWinUninstall();
#endif
case 'l':
{
rc = VBoxServiceArgString(argc, argv, psz + 1, &i,
szLogFile, sizeof(szLogFile));
if (rc)
return rc;
psz = NULL;
break;
}
default:
{
rcExit = vboxServiceLazyPreInit();
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
bool fFound = false;
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
{
rc = g_aServices[j].pDesc->pfnOption(&psz, argc, argv, &i);
fFound = rc == VINF_SUCCESS;
if (fFound)
break;
if (rc != -1)
return rc;
}
if (!fFound)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option '%c' (%s)\n", *psz, argv[i]);
break;
}
}
} while (psz && *++psz);
}
/* Check that at least one service is enabled. */
if (vboxServiceCountEnabledServices() == 0)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "At least one service must be enabled\n");
rc = VBoxServiceLogCreate(strlen(szLogFile) ? szLogFile : NULL);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to create release log (%s, %Rrc)",
strlen(szLogFile) ? szLogFile : "<None>", rc);
/* Call pre-init if we didn't do it already. */
rcExit = vboxServiceLazyPreInit();
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
#ifdef RT_OS_WINDOWS
/*
* Make sure only one instance of VBoxService runs at a time. Create a
* global mutex for that.
*
* Note! The \\Global\ namespace was introduced with Win2K, thus the
* version check.
* Note! If the mutex exists CreateMutex will open it and set last error to
* ERROR_ALREADY_EXISTS.
*/
OSVERSIONINFOEX OSInfoEx;
RT_ZERO(OSInfoEx);
OSInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
SetLastError(NO_ERROR);
HANDLE hMutexAppRunning;
if ( GetVersionEx((LPOSVERSIONINFO)&OSInfoEx)
&& OSInfoEx.dwPlatformId == VER_PLATFORM_WIN32_NT
&& OSInfoEx.dwMajorVersion >= 5 /* NT 5.0 a.k.a W2K */)
hMutexAppRunning = CreateMutex(NULL, FALSE, "Global\\" VBOXSERVICE_NAME);
else
hMutexAppRunning = CreateMutex(NULL, FALSE, VBOXSERVICE_NAME);
if (hMutexAppRunning == NULL)
{
DWORD dwErr = GetLastError();
if ( dwErr == ERROR_ALREADY_EXISTS
|| dwErr == ERROR_ACCESS_DENIED)
{
VBoxServiceError("%s is already running! Terminating.", g_pszProgName);
return RTEXITCODE_FAILURE;
}
VBoxServiceError("CreateMutex failed with last error %u! Terminating", GetLastError());
return RTEXITCODE_FAILURE;
}
#else /* !RT_OS_WINDOWS */
/** @todo Add PID file creation here? */
#endif /* !RT_OS_WINDOWS */
VBoxServiceVerbose(0, "%s r%s started. Verbose level = %d\n",
RTBldCfgVersion(), RTBldCfgRevisionStr(), g_cVerbosity);
/*
* Daemonize if requested.
*/
if (fDaemonize && !fDaemonized)
{
#ifdef RT_OS_WINDOWS
VBoxServiceVerbose(2, "Starting service dispatcher ...\n");
rcExit = VBoxServiceWinEnterCtrlDispatcher();
#else
VBoxServiceVerbose(1, "Daemonizing...\n");
rc = VbglR3Daemonize(false /* fNoChDir */, false /* fNoClose */);
if (RT_FAILURE(rc))
return VBoxServiceError("Daemon failed: %Rrc\n", rc);
/* in-child */
#endif
}
#ifdef RT_OS_WINDOWS
else
#endif
{
/*
* Windows: We're running the service as a console application now. Start the
* services, enter the main thread's run loop and stop them again
* when it returns.
*
* POSIX: This is used for both daemons and console runs. Start all services
* and return immediately.
*/
#ifdef RT_OS_WINDOWS
# ifndef RT_OS_NT4
/* Install console control handler. */
if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)VBoxServiceConsoleControlHandler, TRUE /* Add handler */))
{
VBoxServiceError("Unable to add console control handler, error=%ld\n", GetLastError());
/* Just skip this error, not critical. */
}
# endif /* !RT_OS_NT4 */
#endif /* RT_OS_WINDOWS */
rc = VBoxServiceStartServices();
rcExit = RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
if (RT_SUCCESS(rc))
VBoxServiceMainWait();
#ifdef RT_OS_WINDOWS
# ifndef RT_OS_NT4
/* Uninstall console control handler. */
if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */))
{
VBoxServiceError("Unable to remove console control handler, error=%ld\n", GetLastError());
/* Just skip this error, not critical. */
}
# endif /* !RT_OS_NT4 */
#else /* !RT_OS_WINDOWS */
/* On Windows - since we're running as a console application - we already stopped all services
* through the console control handler. So only do the stopping of services here on other platforms
* where the break/shutdown/whatever signal was just received. */
VBoxServiceStopServices();
#endif /* RT_OS_WINDOWS */
}
VBoxServiceReportStatus(VBoxGuestFacilityStatus_Terminated);
#ifdef RT_OS_WINDOWS
/*
* Cleanup mutex.
*/
CloseHandle(hMutexAppRunning);
#endif
VBoxServiceVerbose(0, "Ended.\n");
#ifdef DEBUG
RTCritSectDelete(&g_csLog);
//RTMemTrackerDumpAllToStdOut();
#endif
VBoxServiceLogDestroy();
return rcExit;
}
/**
* Stops and terminates the services.
*
* This should be called even when VBoxServiceStartServices fails so it can
* clean up anything that we succeeded in starting.
*/
int VBoxServiceStopServices(void)
{
VBoxServiceReportStatus(VBoxGuestFacilityStatus_Terminating);
/*
* Signal all the services.
*/
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
ASMAtomicWriteBool(&g_aServices[j].fShutdown, true);
/*
* Do the pfnStop callback on all running services.
*/
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
if (g_aServices[j].fStarted)
{
VBoxServiceVerbose(3, "Calling stop function for service '%s' ...\n", g_aServices[j].pDesc->pszName);
g_aServices[j].pDesc->pfnStop();
}
/*
* Wait for all the service threads to complete.
*/
int rc = VINF_SUCCESS;
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
{
if (!g_aServices[j].fEnabled) /* Only stop services which were started before. */
continue;
if (g_aServices[j].Thread != NIL_RTTHREAD)
{
VBoxServiceVerbose(2, "Waiting for service '%s' to stop ...\n", g_aServices[j].pDesc->pszName);
int rc2 = VINF_SUCCESS;
for (int i = 0; i < 30; i++) /* Wait 30 seconds in total */
{
rc2 = RTThreadWait(g_aServices[j].Thread, 1000 /* Wait 1 second */, NULL);
if (RT_SUCCESS(rc2))
break;
#ifdef RT_OS_WINDOWS
/* Notify SCM that it takes a bit longer ... */
VBoxServiceWinSetStopPendingStatus(i + j*32);
#endif
}
if (RT_FAILURE(rc2))
{
VBoxServiceError("Service '%s' failed to stop. (%Rrc)\n", g_aServices[j].pDesc->pszName, rc2);
rc = rc2;
}
}
VBoxServiceVerbose(3, "Terminating service '%s' (%d) ...\n", g_aServices[j].pDesc->pszName, j);
g_aServices[j].pDesc->pfnTerm();
}
#ifdef RT_OS_WINDOWS
/*
* Wake up and tell the main() thread that we're shutting down (it's
* sleeping in VBoxServiceMainWait).
*/
ASMAtomicWriteBool(&g_fWindowsServiceShutdown, true);
if (g_hEvtWindowsService != NIL_RTSEMEVENT)
{
VBoxServiceVerbose(3, "Stopping the main thread...\n");
int rc2 = RTSemEventSignal(g_hEvtWindowsService);
AssertRC(rc2);
}
#endif
VBoxServiceVerbose(2, "Stopping services returning: %Rrc\n", rc);
VBoxServiceReportStatus(RT_SUCCESS(rc) ? VBoxGuestFacilityStatus_Paused : VBoxGuestFacilityStatus_Failed);
return rc;
}
/**
* Starts the service.
*
* @returns VBox status code, errors are fully bitched.
*/
int VBoxServiceStartServices(void)
{
int rc;
VBoxServiceReportStatus(VBoxGuestFacilityStatus_Init);
/*
* Initialize the services.
*/
VBoxServiceVerbose(2, "Initializing services ...\n");
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
if (g_aServices[j].fEnabled)
{
rc = g_aServices[j].pDesc->pfnInit();
if (RT_FAILURE(rc))
{
if (rc != VERR_SERVICE_DISABLED)
{
VBoxServiceError("Service '%s' failed to initialize: %Rrc\n",
g_aServices[j].pDesc->pszName, rc);
VBoxServiceReportStatus(VBoxGuestFacilityStatus_Failed);
return rc;
}
g_aServices[j].fEnabled = false;
VBoxServiceVerbose(0, "Service '%s' was disabled because of missing functionality\n",
g_aServices[j].pDesc->pszName);
}
}
/*
* Start the service(s).
*/
VBoxServiceVerbose(2, "Starting services ...\n");
rc = VINF_SUCCESS;
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
{
if (!g_aServices[j].fEnabled)
continue;
VBoxServiceVerbose(2, "Starting service '%s' ...\n", g_aServices[j].pDesc->pszName);
rc = RTThreadCreate(&g_aServices[j].Thread, vboxServiceThread, (void *)(uintptr_t)j, 0,
RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, g_aServices[j].pDesc->pszName);
if (RT_FAILURE(rc))
{
VBoxServiceError("RTThreadCreate failed, rc=%Rrc\n", rc);
break;
}
g_aServices[j].fStarted = true;
/* Wait for the thread to initialize. */
/** @todo There is a race between waiting and checking
* the fShutdown flag of a thread here and processing
* the thread's actual worker loop. If the thread decides
* to exit the loop before we skipped the fShutdown check
* below the service will fail to start! */
RTThreadUserWait(g_aServices[j].Thread, 60 * 1000);
if (g_aServices[j].fShutdown)
{
VBoxServiceError("Service '%s' failed to start!\n", g_aServices[j].pDesc->pszName);
rc = VERR_GENERAL_FAILURE;
}
}
if (RT_SUCCESS(rc))
VBoxServiceVerbose(1, "All services started.\n");
else
{
VBoxServiceError("An error occcurred while the services!\n");
VBoxServiceReportStatus(VBoxGuestFacilityStatus_Failed);
}
return rc;
}
/** @copydoc VBOXSERVICE::pfnInit */
static DECLCALLBACK(int) VBoxServiceTimeSyncInit(void)
{
/*
* If not specified, find the right interval default.
* Then create the event sem to block on.
*/
if (!g_TimeSyncInterval)
g_TimeSyncInterval = g_DefaultInterval * 1000;
if (!g_TimeSyncInterval)
g_TimeSyncInterval = 10 * 1000;
VbglR3GetSessionId(&g_idTimeSyncSession);
/* The status code is ignored as this information is not available with VBox < 3.2.10. */
int rc = RTSemEventMultiCreate(&g_TimeSyncEvent);
AssertRC(rc);
#ifdef RT_OS_WINDOWS
if (RT_SUCCESS(rc))
{
/*
* Adjust privileges of this process so we can make system time adjustments.
*/
if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &g_hTokenProcess))
{
TOKEN_PRIVILEGES tkPriv;
RT_ZERO(tkPriv);
tkPriv.PrivilegeCount = 1;
tkPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkPriv.Privileges[0].Luid))
{
DWORD cbRet = sizeof(g_TkOldPrivileges);
if (AdjustTokenPrivileges(g_hTokenProcess, FALSE, &tkPriv, sizeof(TOKEN_PRIVILEGES), &g_TkOldPrivileges, &cbRet))
rc = VINF_SUCCESS;
else
{
DWORD dwErr = GetLastError();
rc = RTErrConvertFromWin32(dwErr);
VBoxServiceError("VBoxServiceTimeSyncInit: Adjusting token privileges (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n", dwErr, rc);
}
}
else
{
DWORD dwErr = GetLastError();
rc = RTErrConvertFromWin32(dwErr);
VBoxServiceError("VBoxServiceTimeSyncInit: Looking up token privileges (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n", dwErr, rc);
}
if (RT_FAILURE(rc))
{
CloseHandle(g_hTokenProcess);
g_hTokenProcess = NULL;
}
}
else
{
DWORD dwErr = GetLastError();
rc = RTErrConvertFromWin32(dwErr);
VBoxServiceError("VBoxServiceTimeSyncInit: Opening process token (SE_SYSTEMTIME_NAME) failed with status code %u/%Rrc!\n", dwErr, rc);
g_hTokenProcess = NULL;
}
}
if (GetSystemTimeAdjustment(&g_dwWinTimeAdjustment, &g_dwWinTimeIncrement, &g_bWinTimeAdjustmentDisabled))
VBoxServiceVerbose(3, "VBoxServiceTimeSyncInit: Initially %ld (100ns) units per %ld (100 ns) units interval, disabled=%d\n",
g_dwWinTimeAdjustment, g_dwWinTimeIncrement, g_bWinTimeAdjustmentDisabled ? 1 : 0);
else
{
DWORD dwErr = GetLastError();
rc = RTErrConvertFromWin32(dwErr);
VBoxServiceError("VBoxServiceTimeSyncInit: Could not get time adjustment values! Last error: %ld!\n", dwErr);
}
#endif /* RT_OS_WINDOWS */
return rc;
}
/**
* Try adjust the time using adjtime or similar.
*
* @returns true on success, false on failure.
*
* @param pDrift The time adjustment.
*/
static bool VBoxServiceTimeSyncAdjust(PCRTTIMESPEC pDrift)
{
#ifdef RT_OS_WINDOWS
/** @todo r=bird: NT4 doesn't have GetSystemTimeAdjustment according to MSDN. */
/** @todo r=bird: g_hTokenProcess cannot be NULL here.
* VBoxServiceTimeSyncInit will fail and the service will not be
* started with it being NULL. VBoxServiceTimeSyncInit OTOH will *NOT*
* be called until the service thread has terminated. If anything
* else is the case, there is buggy code somewhere.*/
if (g_hTokenProcess == NULL) /* Is the token already closed when shutting down? */
return false;
DWORD dwWinTimeAdjustment, dwWinNewTimeAdjustment, dwWinTimeIncrement;
BOOL fWinTimeAdjustmentDisabled;
if (GetSystemTimeAdjustment(&dwWinTimeAdjustment, &dwWinTimeIncrement, &fWinTimeAdjustmentDisabled))
{
DWORD dwDiffMax = g_dwWinTimeAdjustment * 0.50;
DWORD dwDiffNew = dwWinTimeAdjustment * 0.10;
if (RTTimeSpecGetMilli(pDrift) > 0)
{
dwWinNewTimeAdjustment = dwWinTimeAdjustment + dwDiffNew;
if (dwWinNewTimeAdjustment > (g_dwWinTimeAdjustment + dwDiffMax))
{
dwWinNewTimeAdjustment = g_dwWinTimeAdjustment + dwDiffMax;
dwDiffNew = dwDiffMax;
}
}
else
{
dwWinNewTimeAdjustment = dwWinTimeAdjustment - dwDiffNew;
if (dwWinNewTimeAdjustment < (g_dwWinTimeAdjustment - dwDiffMax))
{
dwWinNewTimeAdjustment = g_dwWinTimeAdjustment - dwDiffMax;
dwDiffNew = dwDiffMax;
}
}
VBoxServiceVerbose(3, "VBoxServiceTimeSyncAdjust: Drift=%lldms\n", RTTimeSpecGetMilli(pDrift));
VBoxServiceVerbose(3, "VBoxServiceTimeSyncAdjust: OrgTA=%ld, CurTA=%ld, NewTA=%ld, DiffNew=%ld, DiffMax=%ld\n",
g_dwWinTimeAdjustment, dwWinTimeAdjustment, dwWinNewTimeAdjustment, dwDiffNew, dwDiffMax);
if (SetSystemTimeAdjustment(dwWinNewTimeAdjustment, FALSE /* Periodic adjustments enabled. */))
{
g_cTimeSyncErrors = 0;
return true;
}
if (g_cTimeSyncErrors++ < 10)
VBoxServiceError("VBoxServiceTimeSyncAdjust: SetSystemTimeAdjustment failed, error=%u\n", GetLastError());
}
else if (g_cTimeSyncErrors++ < 10)
VBoxServiceError("VBoxServiceTimeSyncAdjust: GetSystemTimeAdjustment failed, error=%ld\n", GetLastError());
#elif defined(RT_OS_OS2) || defined(RT_OS_HAIKU)
/* No API for doing gradual time adjustments. */
#else /* PORTME */
/*
* Try use adjtime(), most unix-like systems have this.
*/
struct timeval tv;
RTTimeSpecGetTimeval(pDrift, &tv);
if (adjtime(&tv, NULL) == 0)
{
if (g_cVerbosity >= 1)
VBoxServiceVerbose(1, "VBoxServiceTimeSyncAdjust: adjtime by %RDtimespec\n", pDrift);
g_cTimeSyncErrors = 0;
return true;
}
#endif
/* failed */
return false;
}
/**
* Reads a guest property.
*
* @returns VBox status code, fully bitched.
*
* @param u32ClientId The HGCM client ID for the guest property session.
* @param pszPropName The property name.
* @param ppszValue Where to return the value. This is always set
* to NULL. Free it using RTStrFree().
* @param ppszFlags Where to return the value flags. Free it
* using RTStrFree(). Optional.
* @param puTimestamp Where to return the timestamp. This is only set
* on success. Optional.
*/
int VBoxServiceReadProp(uint32_t u32ClientId, const char *pszPropName,
char **ppszValue, char **ppszFlags, uint64_t *puTimestamp)
{
AssertPtrReturn(pszPropName, VERR_INVALID_POINTER);
AssertPtrReturn(ppszValue, VERR_INVALID_POINTER);
uint32_t cbBuf = _1K;
void *pvBuf = NULL;
int rc;
*ppszValue = NULL;
for (unsigned cTries = 0; cTries < 10; cTries++)
{
/*
* (Re-)Allocate the buffer and try read the property.
*/
RTMemFree(pvBuf);
pvBuf = RTMemAlloc(cbBuf);
if (!pvBuf)
{
VBoxServiceError("Guest Property: Failed to allocate %zu bytes\n", cbBuf);
rc = VERR_NO_MEMORY;
break;
}
char *pszValue;
char *pszFlags;
uint64_t uTimestamp;
rc = VbglR3GuestPropRead(u32ClientId, pszPropName,
pvBuf, cbBuf,
&pszValue, &uTimestamp, &pszFlags, NULL);
if (RT_FAILURE(rc))
{
if (rc == VERR_BUFFER_OVERFLOW)
{
/* try again with a bigger buffer. */
cbBuf *= 2;
continue;
}
if (rc == VERR_NOT_FOUND)
VBoxServiceVerbose(2, "Guest Property: %s not found\n", pszPropName);
else
VBoxServiceError("Guest Property: Failed to query \"%s\": %Rrc\n", pszPropName, rc);
break;
}
VBoxServiceVerbose(2, "Guest Property: Read \"%s\" = \"%s\", timestamp %RU64n\n",
pszPropName, pszValue, uTimestamp);
*ppszValue = RTStrDup(pszValue);
if (!*ppszValue)
{
VBoxServiceError("Guest Property: RTStrDup failed for \"%s\"\n", pszValue);
rc = VERR_NO_MEMORY;
break;
}
if (puTimestamp)
*puTimestamp = uTimestamp;
if (ppszFlags)
*ppszFlags = RTStrDup(pszFlags);
break; /* done */
}
if (pvBuf)
RTMemFree(pvBuf);
return rc;
}
/** @copydoc VBOXSERVICE::pfnWorker */
DECLCALLBACK(int) VBoxServiceVMStatsWorker(bool volatile *pfShutdown)
{
int rc = VINF_SUCCESS;
/* Start monitoring of the stat event change event. */
rc = VbglR3CtlFilterMask(VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST, 0);
if (RT_FAILURE(rc))
{
VBoxServiceVerbose(3, "VBoxServiceVMStatsWorker: VbglR3CtlFilterMask failed with %d\n", rc);
return rc;
}
/*
* Tell the control thread that it can continue
* spawning services.
*/
RTThreadUserSignal(RTThreadSelf());
/*
* Now enter the loop retrieving runtime data continuously.
*/
for (;;)
{
uint32_t fEvents = 0;
RTMSINTERVAL cWaitMillies;
/* Check if an update interval change is pending. */
rc = VbglR3WaitEvent(VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST, 0 /* no wait */, &fEvents);
if ( RT_SUCCESS(rc)
&& (fEvents & VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST))
{
VbglR3StatQueryInterval(&gCtx.cMsStatInterval);
}
if (gCtx.cMsStatInterval)
{
VBoxServiceVMStatsReport();
cWaitMillies = gCtx.cMsStatInterval;
}
else
cWaitMillies = 3000;
/*
* Block for a while.
*
* The event semaphore takes care of ignoring interruptions and it
* allows us to implement service wakeup later.
*/
if (*pfShutdown)
break;
int rc2 = RTSemEventMultiWait(g_VMStatEvent, cWaitMillies);
if (*pfShutdown)
break;
if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
{
VBoxServiceError("VBoxServiceVMStatsWorker: RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
rc = rc2;
break;
}
}
/* Cancel monitoring of the stat event change event. */
rc = VbglR3CtlFilterMask(0, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
if (RT_FAILURE(rc))
VBoxServiceVerbose(3, "VBoxServiceVMStatsWorker: VbglR3CtlFilterMask failed with %d\n", rc);
RTSemEventMultiDestroy(g_VMStatEvent);
g_VMStatEvent = NIL_RTSEMEVENTMULTI;
VBoxServiceVerbose(3, "VBoxStatsThread: finished statistics change request thread\n");
return 0;
}
/** @copydoc VBOXSERVICE::pfnWorker */
DECLCALLBACK(int) VBoxServiceTimeSyncWorker(bool volatile *pfShutdown)
{
RTTIME Time;
char sz[64];
int rc = VINF_SUCCESS;
/*
* Tell the control thread that it can continue spawning services.
*/
RTThreadUserSignal(RTThreadSelf());
/*
* The Work Loop.
*/
for (;;)
{
/*
* Try get a reliable time reading.
*/
int cTries = 3;
do
{
/* query it. */
RTTIMESPEC GuestNow0, GuestNow, HostNow;
RTTimeNow(&GuestNow0);
int rc2 = VbglR3GetHostTime(&HostNow);
if (RT_FAILURE(rc2))
{
if (g_cTimeSyncErrors++ < 10)
VBoxServiceError("VBoxServiceTimeSyncWorker: VbglR3GetHostTime failed; rc2=%Rrc\n", rc2);
break;
}
RTTimeNow(&GuestNow);
/* calc latency and check if it's ok. */
RTTIMESPEC GuestElapsed = GuestNow;
RTTimeSpecSub(&GuestElapsed, &GuestNow0);
if ((uint32_t)RTTimeSpecGetMilli(&GuestElapsed) < g_TimeSyncMaxLatency)
{
/*
* Set the time once after we were restored.
* (Of course only if the drift is bigger than MinAdjust)
*/
uint32_t TimeSyncSetThreshold = g_TimeSyncSetThreshold;
if (g_fTimeSyncSetOnRestore)
{
uint64_t idNewSession = g_idTimeSyncSession;
VbglR3GetSessionId(&idNewSession);
if (idNewSession != g_idTimeSyncSession)
{
VBoxServiceVerbose(3, "VBoxServiceTimeSyncWorker: The VM session ID changed, forcing resync.\n");
TimeSyncSetThreshold = 0;
g_idTimeSyncSession = idNewSession;
}
}
/*
* Calculate the adjustment threshold and the current drift.
*/
uint32_t MinAdjust = RTTimeSpecGetMilli(&GuestElapsed) * g_TimeSyncLatencyFactor;
if (MinAdjust < g_TimeSyncMinAdjust)
MinAdjust = g_TimeSyncMinAdjust;
RTTIMESPEC Drift = HostNow;
RTTimeSpecSub(&Drift, &GuestNow);
if (RTTimeSpecGetMilli(&Drift) < 0)
MinAdjust += g_TimeSyncMinAdjust; /* extra buffer against moving time backwards. */
RTTIMESPEC AbsDrift = Drift;
RTTimeSpecAbsolute(&AbsDrift);
if (g_cVerbosity >= 3)
{
VBoxServiceVerbose(3, "VBoxServiceTimeSyncWorker: Host: %s (MinAdjust: %RU32 ms)\n",
RTTimeToString(RTTimeExplode(&Time, &HostNow), sz, sizeof(sz)), MinAdjust);
VBoxServiceVerbose(3, "VBoxServiceTimeSyncWorker: Guest: - %s => %RDtimespec drift\n",
RTTimeToString(RTTimeExplode(&Time, &GuestNow), sz, sizeof(sz)),
&Drift);
}
uint32_t AbsDriftMilli = RTTimeSpecGetMilli(&AbsDrift);
if (AbsDriftMilli > MinAdjust)
{
/*
* Ok, the drift is above the threshold.
*
* Try a gradual adjustment first, if that fails or the drift is
* too big, fall back on just setting the time.
*/
if ( AbsDriftMilli > TimeSyncSetThreshold
|| g_fTimeSyncSetNext
|| !VBoxServiceTimeSyncAdjust(&Drift))
{
VBoxServiceTimeSyncCancelAdjust();
VBoxServiceTimeSyncSet(&Drift);
}
}
else
VBoxServiceTimeSyncCancelAdjust();
break;
}
VBoxServiceVerbose(3, "VBoxServiceTimeSyncWorker: %RDtimespec: latency too high (%RDtimespec) sleeping 1s\n", GuestElapsed);
RTThreadSleep(1000);
} while (--cTries > 0);
/* Clear the set-next/set-start flag. */
g_fTimeSyncSetNext = false;
/*
* Block for a while.
*
* The event semaphore takes care of ignoring interruptions and it
* allows us to implement service wakeup later.
*/
if (*pfShutdown)
break;
int rc2 = RTSemEventMultiWait(g_TimeSyncEvent, g_TimeSyncInterval);
if (*pfShutdown)
break;
if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
{
VBoxServiceError("VBoxServiceTimeSyncWorker: RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
rc = rc2;
break;
}
}
VBoxServiceTimeSyncCancelAdjust();
RTSemEventMultiDestroy(g_TimeSyncEvent);
g_TimeSyncEvent = NIL_RTSEMEVENTMULTI;
return rc;
}
