server.cpp revision 2f9a181941271e999a67c464d94d56cf16cd41c1
247efe202344328bffb8de7e47aee60039cd95e0vboxsync * XPCOM server process (VBoxSVC) start point.
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * Copyright (C) 2004-2014 Oracle Corporation
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * available from http://www.virtualbox.org. This file is free software;
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * you can redistribute it and/or modify it under the terms of the GNU
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * General Public License (GPL) as published by the Free Software
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync/////////////////////////////////////////////////////////////////////////////
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync// VirtualBox component instantiation
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync/////////////////////////////////////////////////////////////////////////////
ec9aa1180070b037866f064ce720254cd9f03721vboxsync// This needs to stay - it is needed by the service registration below, and
ec9aa1180070b037866f064ce720254cd9f03721vboxsync// is defined in the automatically generated VirtualBoxWrap.cpp
dba1919dac01f490c625e0470b528e469c30651dvboxsyncextern nsIClassInfo *NS_CLASSINFO_NAME(VirtualBoxWrap);
8d4665a316d78d6587fd1c9da948f7aa37d0bfddvboxsync// The declarations/implementations of the various XPCOM helper data structures
dba1919dac01f490c625e0470b528e469c30651dvboxsync// and functions have to be removed bit by bit, as the conversion to the
ec9aa1180070b037866f064ce720254cd9f03721vboxsync// automatically generated wrappers makes them obsolete.
969643a53adfd6346c00c1a5fbbe64d9cacff0a7vboxsync/* implement nsISupports parts of our objects with support for nsIClassInfo */
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsyncNS_IMPL_THREADSAFE_ISUPPORTS2_CI(SessionMachine, IMachine, IInternalMachineControl)
ec9aa1180070b037866f064ce720254cd9f03721vboxsyncNS_IMPL_THREADSAFE_ISUPPORTS1_CI(SnapshotMachine, IMachine)
ec9aa1180070b037866f064ce720254cd9f03721vboxsyncNS_IMPL_THREADSAFE_ISUPPORTS1_CI(Progress, IProgress)
ec9aa1180070b037866f064ce720254cd9f03721vboxsyncNS_IMPL_THREADSAFE_ISUPPORTS1_CI(ProgressProxy, IProgress)
ec9aa1180070b037866f064ce720254cd9f03721vboxsyncNS_IMPL_THREADSAFE_ISUPPORTS1_CI(SharedFolder, ISharedFolder)
ec9aa1180070b037866f064ce720254cd9f03721vboxsyncNS_IMPL_THREADSAFE_ISUPPORTS1_CI(PerformanceCollector, IPerformanceCollector)
efe619f27bff8e4d2124d1f09a327c7a63abe1dcvboxsyncNS_IMPL_THREADSAFE_ISUPPORTS1_CI(PerformanceMetric, IPerformanceMetric)
ec9aa1180070b037866f064ce720254cd9f03721vboxsync#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsyncNS_IMPL_THREADSAFE_ISUPPORTS1_CI(ExtPackFile, IExtPackFile)
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsyncNS_IMPL_THREADSAFE_ISUPPORTS1_CI(ExtPackManager, IExtPackManager)
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync////////////////////////////////////////////////////////////////////////////////
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsyncstatic bool gAutoShutdown = false;
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync/** Delay before shutting down the VirtualBox server after the last
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * VirtualBox instance is released, in ms */
969643a53adfd6346c00c1a5fbbe64d9cacff0a7vboxsync/////////////////////////////////////////////////////////////////////////////
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * Simple but smart PLEvent wrapper.
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * @note Instances must be always created with <tt>operator new</tt>!
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * Posts this event to the given message queue. This method may only be
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * called once. @note On success, the event will be deleted automatically
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * after it is delivered and handled. On failure, the event will delete
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * itself before this method returns! The caller must not delete it in
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * either case.
ec9aa1180070b037866f064ce720254cd9f03721vboxsync delete this;
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync virtual void *handler() = 0;
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync static void *PR_CALLBACK eventHandler(PLEvent *self)
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync return reinterpret_cast<Ev *>(self)->that->handler();
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync static void PR_CALLBACK eventDestructor(PLEvent *self)
8d4665a316d78d6587fd1c9da948f7aa37d0bfddvboxsync////////////////////////////////////////////////////////////////////////////////
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * VirtualBox class factory that destroys the created instance right after
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * the last reference to it is released by the client, and recreates it again
1a04ec99647f9be2f2ba19cf247c0f989aa2e80cvboxsync * when necessary (so VirtualBox acts like a singleton object).
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync RTPrintf("Informational: VirtualBox object deleted.\n");
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* we overload Release() to guarantee the VirtualBox destructor is
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * always called on the main thread */
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync /* the last reference held by clients is being released
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * (see GetInstance()) */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* sTimer is null if this call originates from FactoryDestructor()*/
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync LogFlowFunc(("Last VirtualBox instance was released.\n"));
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync LogFlowFunc(("Scheduling server shutdown in %u ms...\n",
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* make sure the previous timer (if any) is stopped;
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * otherwise RTTimerStart() will definitely fail. */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync int vrc = RTTimerLRStart(sTimer, gShutdownDelayMs * RT_NS_1MS_64);
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync LogFlowFunc(("Last VirtualBox instance was released "
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync "on XPCOM shutdown.\n"));
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* Failed to start the timer, post the shutdown event
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * manually if not on the main thread already. */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* Here we come if:
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * a) gEventQ is 0 which means either FactoryDestructor() is called
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * or the IPC/DCONNECT shutdown sequence is initiated by the
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * XPCOM shutdown routine (NS_ShutdownXPCOM()), which always
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync * happens on the main thread.
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * b) gEventQ has reported we're on the main thread. This means
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * that DestructEventHandler() has been called, but another
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * client was faster and requested VirtualBox again.
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * In either case, there is nothing to do.
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync * Note: case b) is actually no more valid since we don't
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * call Release() from DestructEventHandler() in this case
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * any more. Thus, we assert below.
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* called on the main thread */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* stop accepting GetInstance() requests on other threads during
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * possible destruction */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* sInstance is NULL here if it was deleted immediately after
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * creation due to initialization error. See GetInstance(). */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* Release the guard reference added in GetInstance() */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync LogFlowFunc(("Terminating the server process...\n"));
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* make it leave the event loop */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* This condition is quite rare: a new client happened to
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * connect after this event has been posted to the main queue
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * but before it started to process it. */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync LogFlowFunc(("Destruction is canceled (refcnt=%d).\n", count));
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync static void ShutdownTimer(RTTIMERLR hTimerLR, void *pvUser, uint64_t /*iTick*/)
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* A "too late" event is theoretically possible if somebody
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * manually ended the server after a destruction has been scheduled
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * and this method was so lucky that it got a chance to run before
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * the timer was killed. */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* post a quit event to the main queue */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* A failure above means we've been already stopped (for example
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * by Ctrl-C). FactoryDestructor() (NS_ShutdownXPCOM())
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * will do the job. Nothing to do. */
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync /* create a critsect to protect object construction */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync int vrc = RTTimerLRCreateEx(&sTimer, 0, 0, ShutdownTimer, NULL);
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync LogFlowFunc(("Failed to create a timer! (vrc=%Rrc)\n", vrc));
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync /* Either posting a destruction event failed for some reason (most
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * likely, the quit event has been received before the last release),
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * or the client has terminated abnormally w/o releasing its
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * VirtualBox instance (so NS_ShutdownXPCOM() is doing a cleanup).
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync * Release the guard reference we added in GetInstance(). */
f36e34993b3bddde17e7a88121dc26d3ec197ee0vboxsync LogFlowFunc(("Process termination requested first. Refusing.\n"));
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync /* this rv is what CreateInstance() on the client side returns
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * when the server process stops accepting events. Do the same
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * here. The client wrapper should attempt to start a new process in
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync * response to a failure from us. */
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync LogFlowFunc(("Creating new VirtualBox object...\n"));
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync /* make an extra AddRef to take the full control
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * on the VirtualBox destruction (see FinalRelease()) */
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync sInstance->AddRef(); /* protect FinalConstruct() */
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync RTPrintf("Informational: VirtualBox object created (rc=%Rhrc).\n", rv);
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync /* On failure diring VirtualBox initialization, delete it
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * immediately on the current thread by releasing all
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * references in order to properly schedule the server
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync * shutdown. Since the object is fully deleted here, there
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * is a chance to fix the error and request a new
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * instantiation before the server terminates. However,
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * the main reason to maintain the shutdown delay on
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync * failure is to let the front-end completely fetch error
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * info from a server-side IVirtualBoxErrorInfo object. */
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync /* On success, make sure the previous timer is stopped to
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync * cancel a scheduled server termination (if any). */
3c616a9e81ee0ab32e2a3a65379eb9dd386e61d2vboxsync LogFlowFunc(("Using existing VirtualBox object...\n"));
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync LogFlowFunc(("Another client has requested a reference to VirtualBox, canceling destruction...\n"));
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync /* make sure the previous timer is stopped */
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync /* Don't be confused that sInstance is of the *ClassFactory type. This is
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync * actually a singleton instance (*ClassFactory inherits the singleton
efe619f27bff8e4d2124d1f09a327c7a63abe1dcvboxsync * class; we combined them just for "simplicity" and used "static" for
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync * factory methods. *ClassFactory here is necessary for a couple of extra
e8f997cba588730c203f0bdb07bcb9cbb5814c99vboxsync * methods. */
e3ee159035cf31e91f498b4098d4565e7f6d03d1vboxsyncVirtualBoxClassFactory *VirtualBoxClassFactory::sInstance = NULL;
e3ee159035cf31e91f498b4098d4565e7f6d03d1vboxsyncRTTIMERLR VirtualBoxClassFactory::sTimer = NIL_RTTIMERLR;
e3ee159035cf31e91f498b4098d4565e7f6d03d1vboxsyncNS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR_WITH_RC(VirtualBox, VirtualBoxClassFactory::GetInstance)
e3ee159035cf31e91f498b4098d4565e7f6d03d1vboxsync////////////////////////////////////////////////////////////////////////////////
e3ee159035cf31e91f498b4098d4565e7f6d03d1vboxsynctypedef NSFactoryDestructorProcPtr NSFactoryConstructorProcPtr;
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync * Enhanced module component information structure.
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync * nsModuleComponentInfo lacks the factory construction callback, here we add
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync * it. This callback is called straight after a nsGenericFactory instance is
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync * successfully created in RegisterSelfComponents.
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync /** standard module component information */
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync const nsModuleComponentInfo *mpModuleComponentInfo;
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync /** (optional) Factory Construction Callback */
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync/////////////////////////////////////////////////////////////////////////////
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync * Helper function to register self components upon start-up
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync * of the out-of-proc server.
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsyncRegisterSelfComponents(nsIComponentRegistrar *registrar,
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync const nsModuleComponentInfoPlusFactoryConstructor *aComponents,
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync const nsModuleComponentInfoPlusFactoryConstructor *info = aComponents;
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync for (PRUint32 i = 0; i < count && NS_SUCCEEDED(rc); i++, info++)
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync /* skip components w/o a constructor */
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync /* create a new generic factory for a component and register it */
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync rc = NS_NewGenericFactory(&factory, info->mpModuleComponentInfo);
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync rc = registrar->RegisterFactory(info->mpModuleComponentInfo->mCID,
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync/////////////////////////////////////////////////////////////////////////////
7848f1804192634f08444660aacf581a6e89ec4evboxsync VirtualBoxClassFactory::MaybeQuitEvent *ev = new VirtualBoxClassFactory::MaybeQuitEvent();
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync /* else do nothing */
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync /* post a force quit event to the queue */
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsyncstatic nsresult vboxsvcSpawnDaemonByReExec(const char *pszPath, bool fAutoShutdown, const char *pszPidFile)
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync unsigned args_index = 0;
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync // The ugly casts are necessary because the PR_CreateProcessDetached has
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync // a const array of writable strings as a parameter. It won't write. */
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync // Use a pipe to determine when the daemon process is in the position
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync // to actually process requests. The daemon will write "READY" to the pipe.
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync if (PR_CreatePipe(&readable, &writable) != PR_SUCCESS)
488405f715ff0ee309ead17a46749e73088e3c70vboxsync if (PR_ProcessAttrSetInheritableFD(attr, writable, VBOXSVC_STARTUP_PIPE_NAME) != PR_SUCCESS)
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync PR_ProcessAttrSetStdioRedirect(attr, PR_StandardInput, devNull);
7848f1804192634f08444660aacf581a6e89ec4evboxsync PR_ProcessAttrSetStdioRedirect(attr, PR_StandardOutput, devNull);
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync PR_ProcessAttrSetStdioRedirect(attr, PR_StandardError, devNull);
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync if (PR_CreateProcessDetached(pszPath, (char * const *)args, nsnull, attr) != PR_SUCCESS)
7848f1804192634f08444660aacf581a6e89ec4evboxsync // Close the child end of the pipe to make it the only owner of the
d7d635edfa61196a9ffe24d486ffec1c53b4e6f0vboxsync // file descriptor, so that unexpected closing can be detected.
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync * Initialize the VBox runtime without loading
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync * the support driver
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync uint32_t cHistory = 10; // enable log rotation, 10 files
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync uint32_t uHistoryFileTime = RT_SEC_1DAY; // max 1 day per file
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync uint64_t uHistoryFileSize = 100 * _1M; // max 100MB per file
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync bool fDaemonize = false;
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync vrc = RTGetOptInit(&GetOptState, argc, argv, &s_aOptions[0], RT_ELEMENTS(s_aOptions), 1, 0 /*fFlags*/);
83bb1f16d193175abf8fc1c3dffea43611efbf67vboxsync while ((vrc = RTGetOpt(&GetOptState, &ValueUnion)))
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync /* --automate mode means we are started by XPCOM on
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync * demand. Daemonize ourselves and activate
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync * auto-shutdown. */
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync /* --auto-shutdown mode means we're already daemonized. */
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync vboxsvcSpawnDaemonByReExec(argv[0], gAutoShutdown, g_pszPidFile);
7848f1804192634f08444660aacf581a6e89ec4evboxsync /** @todo Merge this code with svcmain.cpp (use Logging.cpp?). */
7848f1804192634f08444660aacf581a6e89ec4evboxsync vrc = com::GetVBoxUserHomeDirectory(szLogFile, sizeof(szLogFile));
7848f1804192634f08444660aacf581a6e89ec4evboxsync vrc = RTPathAppend(szLogFile, sizeof(szLogFile), "VBoxSVC.log");
7848f1804192634f08444660aacf581a6e89ec4evboxsync if (!RTStrPrintf(szLogFile, sizeof(szLogFile), "%s", pszLogFile))
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to create logging file name, rc=%Rrc", vrc);
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync vrc = com::VBoxLogRelCreate("XPCOM Server", szLogFile,
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG,
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync RTLOGDEST_FILE, UINT32_MAX /* cMaxEntriesPerGroup */,
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to open release log (%s, %Rrc)", szError, vrc);
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync daemon_pipe_wr = PR_GetInheritedFD(VBOXSVC_STARTUP_PIPE_NAME);
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync "VirtualBox component",
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync VirtualBoxClassFactory::FactoryDestructor, // factory destructor function
7848f1804192634f08444660aacf581a6e89ec4evboxsync const nsModuleComponentInfoPlusFactoryConstructor components[] = {
3f49ecc2ec9cdf7caa008815d8706737aabad2ebvboxsync VirtualBoxClassFactory::FactoryConstructor // factory constructor function
7848f1804192634f08444660aacf581a6e89ec4evboxsync RTMsgError("Failed to initialize XPCOM! (rc=%Rhrc)\n", rc);
f516542ebf06c536ec627a38d10e3a2b013b0384vboxsync rc = NS_GetComponentRegistrar(getter_AddRefs(registrar));
7848f1804192634f08444660aacf581a6e89ec4evboxsync RTMsgError("Failed to get component registrar! (rc=%Rhrc)", rc);
f516542ebf06c536ec627a38d10e3a2b013b0384vboxsync RTMsgError("Failed to register server components! (rc=%Rhrc)", rc);
488405f715ff0ee309ead17a46749e73088e3c70vboxsync /* get the main thread's event queue (afaik, the dconnect service always
488405f715ff0ee309ead17a46749e73088e3c70vboxsync * gets created upon XPCOM startup, so it will use the main (this)
488405f715ff0ee309ead17a46749e73088e3c70vboxsync * thread's event queue to receive IPC events) */
488405f715ff0ee309ead17a46749e73088e3c70vboxsync RTMsgError("Failed to get the main event queue! (rc=%Rhrc)", rc);
488405f715ff0ee309ead17a46749e73088e3c70vboxsync nsCOMPtr<ipcIService> ipcServ(do_GetService(IPC_SERVICE_CONTRACTID, &rc));
488405f715ff0ee309ead17a46749e73088e3c70vboxsync RTMsgError("Failed to get IPC service! (rc=%Rhrc)", rc);
488405f715ff0ee309ead17a46749e73088e3c70vboxsync LogFlowFunc(("Will use \"%s\" as server name.\n", VBOXSVC_IPC_NAME));
488405f715ff0ee309ead17a46749e73088e3c70vboxsync LogFlowFunc(("Failed to register the server name (rc=%Rhrc (%08X))!\n"
6f0690bb46451c7f777e6ef8e5f5157de449d12bvboxsync RTMsgError("Failed to register the server name \"%s\" (rc=%Rhrc)!\n"
6f0690bb46451c7f777e6ef8e5f5157de449d12bvboxsync "Is another server already running?\n",
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync /* setup signal handling to convert some signals to a quit event */
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync for (int i = iSize; i > 0; i--)
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync RTPrintf("(C) 2004-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync "All rights reserved.\n");
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync RTPrintf("\nStarting event loop....\n[send TERM signal to quit]\n");
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync /* now we're ready, signal the parent process */
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync PR_Write(daemon_pipe_wr, "READY", strlen("READY"));
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync /* close writing end of the pipe, its job is done */
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync RTPrintf("\nStarting event loop....\n[press Ctrl-C to quit]\n");
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync vrc = RTFileOpen(&hPidFile, g_pszPidFile, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_NONE);
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync // Increase the file table size to 10240 or as high as possible.
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync RTPrintf("WARNING: failed to increase file descriptor limit. (%d)\n", errno);
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync RTPrintf("WARNING: failed to obtain per-process file-descriptor limit (%d).\n", errno);
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync /* stop accepting new events. Clients that happen to resolve our
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync * name and issue a CreateInstance() request after this point will
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync * get NS_ERROR_ABORT once we handle the remaining messages. As a
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync * result, they should try to start a new server process. */
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync /* unregister ourselves. After this point, clients will start a new
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync * process because they won't be able to resolve the server name.*/
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync /* process any remaining events. These events may include
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync * CreateInstance() requests received right before we called
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync * StopAcceptingEvents() above, and those will fail. */
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync while (0); // this scopes the nsCOMPtrs
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync /* no nsCOMPtrs are allowed to be alive when you call com::Shutdown(). */
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync LogFlowFunc(("Finished com::Shutdown() (rc=%Rhrc)\n", rc));
68fb5645b4a81ece6ab55633a38be8b04d3a88d8vboxsync RTMsgError("Failed to shutdown XPCOM! (rc=%Rhrc)", rc);