VirtualBox

source: vbox/trunk/src/VBox/Main/linux/server.cpp@ 2266

Last change on this file since 2266 was 2057, checked in by vboxsync, 18 years ago

Main: Removed erroneous extra Release() in auto-shutdown management that caused segfaults when manually stopping the server for whatever reason.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 37.4 KB
Line 
1/** @file
2 *
3 * XPCOM server process start point
4 */
5
6/*
7 * Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * If you received this file as part of a commercial VirtualBox
18 * distribution, then only the terms of your commercial VirtualBox
19 * license agreement apply instead of the previous paragraph.
20 */
21
22#include <ipcIService.h>
23#include <ipcCID.h>
24
25#include <nsIServiceManager.h>
26#include <nsIComponentRegistrar.h>
27
28#include <nsXPCOMGlue.h>
29#include <nsEventQueueUtils.h>
30
31// for NS_InitXPCOM2 with bin dir parameter
32#include <nsEmbedString.h>
33#include <nsIFile.h>
34#include <nsILocalFile.h>
35
36#include "linux/server.h"
37#include "Logging.h"
38
39#include <iprt/runtime.h>
40#include <iprt/path.h>
41#include <iprt/critsect.h>
42#include <iprt/timer.h>
43
44#include <VBox/param.h>
45#include <VBox/version.h>
46
47// for nsMyFactory
48#include "nsIGenericFactory.h"
49#include "nsIClassInfo.h"
50
51#include <stdio.h>
52
53// for the signal handler
54#include <signal.h>
55#include <stdlib.h>
56#include <unistd.h>
57#include <errno.h>
58#include <getopt.h>
59
60// for the backtrace signal handler
61#if defined(DEBUG) && defined(__LINUX__)
62# define USE_BACKTRACE
63#endif
64#if defined(USE_BACKTRACE)
65# include <execinfo.h>
66// get REG_EIP/RIP from ucontext.h
67# ifndef __USE_GNU
68# define __USE_GNU
69# endif
70# include <ucontext.h>
71# ifdef __AMD64__
72# define REG_PC REG_RIP
73# else
74# define REG_PC REG_EIP
75# endif
76#endif
77
78/////////////////////////////////////////////////////////////////////////////
79// VirtualBox component instantiation
80/////////////////////////////////////////////////////////////////////////////
81
82#include <nsIGenericFactory.h>
83
84#include <VirtualBox_XPCOM.h>
85#include <VirtualBoxImpl.h>
86#include <MachineImpl.h>
87#include <SnapshotImpl.h>
88#include <HardDiskImpl.h>
89#include <ProgressImpl.h>
90#include <DVDDriveImpl.h>
91#include <FloppyDriveImpl.h>
92#include <VRDPServerImpl.h>
93#include <DVDImageImpl.h>
94#include <FloppyImageImpl.h>
95#include <SharedFolderImpl.h>
96#include <HostImpl.h>
97#include <HostDVDDriveImpl.h>
98#include <HostFloppyDriveImpl.h>
99#include <HostUSBDeviceImpl.h>
100#include <GuestOSTypeImpl.h>
101#include <NetworkAdapterImpl.h>
102#include <USBControllerImpl.h>
103#include <USBDeviceImpl.h>
104#include <AudioAdapterImpl.h>
105#include <SystemPropertiesImpl.h>
106#include <Collection.h>
107
108// implement nsISupports parts of our objects with support for nsIClassInfo
109NS_DECL_CLASSINFO(VirtualBox)
110NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VirtualBox, IVirtualBox)
111NS_DECL_CLASSINFO(Machine)
112NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Machine, IMachine)
113NS_DECL_CLASSINFO(SessionMachine)
114NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SessionMachine, IMachine, IInternalMachineControl)
115NS_DECL_CLASSINFO(SnapshotMachine)
116NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SnapshotMachine, IMachine)
117NS_DECL_CLASSINFO(Snapshot)
118NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Snapshot, ISnapshot)
119NS_DECL_CLASSINFO(HardDisk)
120NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HardDisk, IHardDisk)
121NS_DECL_CLASSINFO(HVirtualDiskImage)
122NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HVirtualDiskImage, IHardDisk, IVirtualDiskImage)
123NS_DECL_CLASSINFO(HISCSIHardDisk)
124NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HISCSIHardDisk, IHardDisk, IISCSIHardDisk)
125NS_DECL_CLASSINFO(HVMDKImage)
126NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HVMDKImage, IHardDisk, IVMDKImage)
127NS_DECL_CLASSINFO(HardDiskAttachment)
128NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HardDiskAttachment, IHardDiskAttachment)
129NS_DECL_CLASSINFO(Progress)
130NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Progress, IProgress)
131NS_DECL_CLASSINFO(CombinedProgress)
132NS_IMPL_THREADSAFE_ISUPPORTS1_CI(CombinedProgress, IProgress)
133NS_DECL_CLASSINFO(DVDDrive)
134NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DVDDrive, IDVDDrive)
135NS_DECL_CLASSINFO(FloppyDrive)
136NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FloppyDrive, IFloppyDrive)
137NS_DECL_CLASSINFO(SharedFolder)
138NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SharedFolder, ISharedFolder)
139#ifdef VBOX_VRDP
140NS_DECL_CLASSINFO(VRDPServer)
141NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VRDPServer, IVRDPServer)
142#endif
143NS_DECL_CLASSINFO(DVDImage)
144NS_IMPL_THREADSAFE_ISUPPORTS1_CI(DVDImage, IDVDImage)
145NS_DECL_CLASSINFO(FloppyImage)
146NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FloppyImage, IFloppyImage)
147NS_DECL_CLASSINFO(Host)
148NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Host, IHost)
149NS_DECL_CLASSINFO(HostDVDDrive)
150NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostDVDDrive, IHostDVDDrive)
151NS_DECL_CLASSINFO(HostFloppyDrive)
152NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostFloppyDrive, IHostFloppyDrive)
153NS_DECL_CLASSINFO(GuestOSType)
154NS_IMPL_THREADSAFE_ISUPPORTS1_CI(GuestOSType, IGuestOSType)
155NS_DECL_CLASSINFO(NetworkAdapter)
156NS_IMPL_THREADSAFE_ISUPPORTS1_CI(NetworkAdapter, INetworkAdapter)
157NS_DECL_CLASSINFO(USBController)
158NS_IMPL_THREADSAFE_ISUPPORTS1_CI(USBController, IUSBController)
159NS_DECL_CLASSINFO(USBDeviceFilter)
160NS_IMPL_THREADSAFE_ISUPPORTS1_CI(USBDeviceFilter, IUSBDeviceFilter)
161NS_DECL_CLASSINFO(HostUSBDevice)
162NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HostUSBDevice, IUSBDevice, IHostUSBDevice)
163NS_DECL_CLASSINFO(HostUSBDeviceFilter)
164NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostUSBDeviceFilter, IHostUSBDeviceFilter)
165NS_DECL_CLASSINFO(AudioAdapter)
166NS_IMPL_THREADSAFE_ISUPPORTS1_CI(AudioAdapter, IAudioAdapter)
167NS_DECL_CLASSINFO(SystemProperties)
168NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SystemProperties, ISystemProperties)
169NS_DECL_CLASSINFO(BIOSSettings)
170NS_IMPL_THREADSAFE_ISUPPORTS1_CI(BIOSSettings, IBIOSSettings)
171
172// collections and enumerators
173COM_IMPL_READONLY_ENUM_AND_COLLECTION(Machine)
174COM_IMPL_READONLY_ENUM_AND_COLLECTION(Snapshot)
175COM_IMPL_READONLY_ENUM_AND_COLLECTION(HardDiskAttachment)
176COM_IMPL_READONLY_ENUM_AND_COLLECTION(GuestOSType)
177COM_IMPL_READONLY_ENUM_AND_COLLECTION(USBDeviceFilter)
178COM_IMPL_READONLY_ENUM_AND_COLLECTION(HostDVDDrive)
179COM_IMPL_READONLY_ENUM_AND_COLLECTION(HostFloppyDrive)
180COM_IMPL_READONLY_ENUM_AND_COLLECTION(HostUSBDevice)
181COM_IMPL_READONLY_ENUM_AND_COLLECTION(HostUSBDeviceFilter)
182COM_IMPL_READONLY_ENUM_AND_COLLECTION(HardDisk)
183COM_IMPL_READONLY_ENUM_AND_COLLECTION(DVDImage)
184COM_IMPL_READONLY_ENUM_AND_COLLECTION(FloppyImage)
185COM_IMPL_READONLY_ENUM_AND_COLLECTION(SharedFolder)
186
187COM_IMPL_READONLY_ENUM_AND_COLLECTION_AS(Progress, IProgress)
188COM_IMPL_READONLY_ENUM_AND_COLLECTION_AS(IfaceUSBDevice, IUSBDevice)
189
190////////////////////////////////////////////////////////////////////////////////
191
192enum
193{
194 /* Delay before shutting down the VirtualBox server after the last
195 * VirtualBox instance is released, in ms */
196 VBoxSVC_ShutdownDelay = 5000,
197};
198
199static bool gAutoShutdown = false;
200
201static nsIEventQueue* gEventQ = nsnull;
202static PRBool volatile gKeepRunning = PR_TRUE;
203
204////////////////////////////////////////////////////////////////////////////////
205
206/**
207 * VirtualBox class factory that destroys the created instance right after
208 * the last reference to it is released by the client, and recreates it again
209 * when necessary (so VirtualBox acts like a singleton object).
210 */
211class VirtualBoxClassFactory : public VirtualBox
212{
213public:
214
215 virtual ~VirtualBoxClassFactory()
216 {
217 LogFlowFunc (("Deleting VirtualBox...\n"));
218
219 FinalRelease();
220 sInstance = 0;
221
222 LogFlowFunc (("VirtualBox object deleted.\n"));
223 printf ("Informational: VirtualBox object deleted.\n");
224
225 /* Instruct the main event loop to terminate. Note that it's enough
226 * to set gKeepRunning to false because we are on the main thread
227 * already (i.e. no need to post events there). */
228 if (gAutoShutdown)
229 gKeepRunning = PR_FALSE;
230 }
231
232 NS_IMETHOD_(nsrefcnt) Release()
233 {
234 /* we overload Release() to guarantee the VirtualBox destructor is
235 * always called on the main thread */
236
237 nsrefcnt count = VirtualBox::Release();
238
239 if (count == 1)
240 {
241 /* the last reference held by clients is being released
242 * (see GetInstance()) */
243
244 PRBool onMainThread = PR_TRUE;
245 if (gEventQ)
246 gEventQ->IsOnCurrentThread (&onMainThread);
247
248 PRBool timerStarted = PR_FALSE;
249
250 /* sTimes is null if this call originates from
251 * FactoryDestructor() */
252 if (sTimer != NULL)
253 {
254 LogFlowFunc (("Last VirtualBox instance was released, "
255 "scheduling server shutdown in %d ms...\n",
256 VBoxSVC_ShutdownDelay));
257
258 int vrc = RTTimerStart (sTimer, uint64_t (VBoxSVC_ShutdownDelay) * 1000000);
259 AssertRC (vrc);
260 timerStarted = SUCCEEDED (vrc);
261 }
262 else
263 {
264 LogFlowFunc (("Last VirtualBox instance was released "
265 "on XPCOM shutdown.\n"));
266 Assert (onMainThread);
267 }
268
269 if (!timerStarted)
270 {
271 if (!onMainThread)
272 {
273 /* Failed to start the timer, post the shutdown event
274 * manually if not on the main thread alreay. */
275 ShutdownTimer (NULL, NULL);
276 }
277 else
278 {
279 /* Here we come if:
280 *
281 * a) gEventQ is 0 which means either FactoryDestructor() is called
282 * or the IPC/DCONNECT shutdown sequence is initiated by the
283 * XPCOM shutdown routine (NS_ShutdownXPCOM()), which always
284 * happens on the main thread.
285 *
286 * b) gEventQ has reported we're on the main thread. This means
287 * that DestructEventHandler() has been called, but another
288 * client was faster and requested VirtualBox again.
289 *
290 * In either case, there is nothing to do.
291 *
292 * Note: case b) is actually no more valid since we don't
293 * call Release() from DestructEventHandler() in this case
294 * any more. Thus, we assert below.
295 */
296
297 Assert (gEventQ == NULL);
298 }
299 }
300 }
301
302 return count;
303 }
304
305 /* Returns the current value of the reference counter. */
306 nsrefcnt GetRefCount()
307 {
308 /* we don't use our own Release() to avoid its "side effect" */
309 nsrefcnt count = VirtualBox::AddRef();
310 count = VirtualBox::Release();
311 return count;
312 }
313
314 /* called on the main thread */
315 static void *PR_CALLBACK DestructEventHandler (PLEvent* self)
316 {
317 Assert (RTCritSectIsInitialized (&sLock));
318
319 /* stop accepting GetInstance() requests during possible destruction */
320 RTCritSectEnter (&sLock);
321
322 Assert (sInstance);
323
324 nsrefcnt count = sInstance->GetRefCount();
325 AssertMsg (count >= 1, ("count=%d\n", count));
326
327 if (count > 1)
328 {
329 /* This case is very unlikely because we stop the timer when a new
330 * client connects after the instance was scheduled for
331 * destruction, but it's still possible. This is the only reason
332 * for the above GetRefCount() btw. */
333 LogFlowFunc (("Destruction is canceled (refcnt=%d).\n", count));
334 }
335 else
336 {
337 /* release the last (first) reference we added in GetInstance()
338 * (this must call the destructor) */
339 nsrefcnt count = sInstance->Release();
340 AssertMsg (count == 0, ("count=%d\n", count));
341 NOREF(count);
342 }
343
344 RTCritSectLeave (&sLock);
345
346 return 0;
347 }
348
349 static void PR_CALLBACK DestructEventDestructor (PLEvent* self)
350 {
351 delete self;
352 }
353
354 static void ShutdownTimer (PRTTIMER pTimer, void *pvUser)
355 {
356 NOREF (pTimer);
357 NOREF (pvUser);
358
359 /* A "too late" event is theoretically possible if somebody
360 * manually ended the server after a destruction has been scheduled
361 * and this method was so lucky that it got a chance to run before
362 * the timer was killed. */
363 AssertReturnVoid (gEventQ);
364
365 /* post a destruction event to the main thread to safely release the
366 * extra reference added in VirtualBoxClassFactory::GetInstance() */
367
368 LogFlowFunc (("Posting VirtualBox destruction & shtutdown event...\n"));
369
370 PLEvent *ev = new PLEvent;
371 gEventQ->InitEvent (ev, NULL, DestructEventHandler,
372 DestructEventDestructor);
373 nsresult rv = gEventQ->PostEvent (ev);
374 if (NS_FAILED (rv))
375 {
376 /* this means we've been already stopped (for example
377 * by Ctrl-C). FactoryDestructor() (NS_ShutdownXPCOM())
378 * will do the job. */
379 PL_DestroyEvent (ev);
380 }
381 }
382
383 static NS_IMETHODIMP FactoryConstructor()
384 {
385 LogFlowFunc (("\n"));
386
387 /* create a critsect to protect object construction */
388 if (VBOX_FAILURE (RTCritSectInit (&sLock)))
389 return NS_ERROR_OUT_OF_MEMORY;
390
391 int vrc = RTTimerCreateEx (&sTimer, 0, 0, ShutdownTimer, NULL);
392 if (VBOX_FAILURE (vrc))
393 {
394 LogFlowFunc (("Failed to create a timer! (vrc=%Vrc)\n", vrc));
395 return NS_ERROR_FAILURE;
396 }
397
398 return NS_OK;
399 }
400
401 static NS_IMETHODIMP FactoryDestructor()
402 {
403 LogFlowFunc (("\n"));
404
405 RTTimerDestroy (sTimer);
406 sTimer = NULL;
407
408 RTCritSectDelete (&sLock);
409
410 if (sInstance)
411 {
412 /* Either posting a destruction event falied for some reason (most
413 * likely, the quit event has been received before the last release),
414 * or the client has terminated abnormally w/o releasing its
415 * VirtualBox instance (so NS_ShutdownXPCOM() is doing a cleanup).
416 * Release the extra reference we added in GetInstance(). */
417 sInstance->Release();
418 }
419
420 return NS_OK;
421 }
422
423 static nsresult GetInstance (VirtualBox **inst)
424 {
425 LogFlowFunc (("Getting VirtualBox object...\n"));
426
427 RTCritSectEnter (&sLock);
428
429 int rv = NS_OK;
430
431 if (sInstance == 0)
432 {
433 LogFlowFunc (("Creating new VirtualBox object...\n"));
434 sInstance = new VirtualBoxClassFactory();
435 if (sInstance)
436 {
437 /* make an extra AddRef to take the full control
438 * on the VirtualBox destruction (see FinalRelease()) */
439 sInstance->AddRef();
440
441 sInstance->AddRef(); /* protect FinalConstruct() */
442 rv = sInstance->FinalConstruct();
443 printf ("Informational: VirtualBox object created (rc=%08X).\n", rv);
444 if (NS_FAILED (rv))
445 {
446 /* on failure diring VirtualBox initialization, delete it
447 * immediately on the current thread, ignoring the reference
448 * count (VirtualBox should be aware of that meaning that it
449 * has already completely unintialized itself in this
450 * case) */
451 LogFlowFunc (("VirtualBox creation failed "
452 "(rc=%08X), deleting immediately...\n", rv));
453 delete sInstance;
454 sInstance = 0;
455 }
456 }
457 else
458 {
459 rv = NS_ERROR_OUT_OF_MEMORY;
460 }
461 }
462 else
463 {
464 LogFlowFunc (("Using existing VirtualBox object...\n"));
465 nsrefcnt count = sInstance->AddRef();
466 Assert (count > 1);
467
468 if (count == 2)
469 {
470 LogFlowFunc (("Another client has requested "
471 "a reference of VirtualBox scheduled for destruction, "
472 "canceling detruction...\n"));
473
474 /* make sure the previous timer is stopped */
475 RTTimerStop (sTimer);
476 }
477 }
478
479 *inst = sInstance;
480
481 RTCritSectLeave (&sLock);
482
483 return rv;
484 }
485
486private:
487
488 /* Don't be confused that sInstance is of the *ClassFactory type. This is
489 * actually a singleton instance (*ClassFactory inherits the singleton
490 * class; we combined them just for "simplicity" and used "static" for
491 * factory methods. *ClassFactory here is necessary for a couple of extra
492 * methods. */
493
494 static VirtualBoxClassFactory *sInstance;
495 static RTCRITSECT sLock;
496
497 static PRTTIMER sTimer;
498};
499
500VirtualBoxClassFactory *VirtualBoxClassFactory::sInstance = 0;
501RTCRITSECT VirtualBoxClassFactory::sLock = {0};
502
503PRTTIMER VirtualBoxClassFactory::sTimer = NULL;
504
505NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR_WITH_RC
506 (VirtualBox, VirtualBoxClassFactory::GetInstance)
507
508////////////////////////////////////////////////////////////////////////////////
509
510typedef NSFactoryDestructorProcPtr NSFactoryConsructorProcPtr;
511
512/**
513 * Enhanced module component information structure.
514 * nsModuleComponentInfo lacks the factory construction callback,
515 * here we add it. This callback is called by NS_NewMyFactory() after
516 * a nsMyFactory instance is successfully created.
517 */
518struct nsMyModuleComponentInfo : nsModuleComponentInfo
519{
520 nsMyModuleComponentInfo () {}
521 nsMyModuleComponentInfo (int) {}
522
523 nsMyModuleComponentInfo (
524 const char* aDescription,
525 const nsCID& aCID,
526 const char* aContractID,
527 NSConstructorProcPtr aConstructor,
528 NSRegisterSelfProcPtr aRegisterSelfProc,
529 NSUnregisterSelfProcPtr aUnregisterSelfProc,
530 NSFactoryDestructorProcPtr aFactoryDestructor,
531 NSGetInterfacesProcPtr aGetInterfacesProc,
532 NSGetLanguageHelperProcPtr aGetLanguageHelperProc,
533 nsIClassInfo ** aClassInfoGlobal,
534 PRUint32 aFlags,
535 NSFactoryConsructorProcPtr aFactoryConstructor)
536 {
537 mDescription = aDescription;
538 mCID = aCID;
539 mContractID = aContractID;
540 mConstructor = aConstructor;
541 mRegisterSelfProc = aRegisterSelfProc;
542 mUnregisterSelfProc = aUnregisterSelfProc;
543 mFactoryDestructor = aFactoryDestructor;
544 mGetInterfacesProc = aGetInterfacesProc;
545 mGetLanguageHelperProc = aGetLanguageHelperProc;
546 mClassInfoGlobal = aClassInfoGlobal;
547 mFlags = aFlags;
548 mFactoryConstructor = aFactoryConstructor;
549 }
550
551 /** (optional) Factory Construction Callback */
552 NSFactoryConsructorProcPtr mFactoryConstructor;
553};
554
555////////////////////////////////////////////////////////////////////////////////
556
557static const nsMyModuleComponentInfo components[] =
558{
559 nsMyModuleComponentInfo (
560 "VirtualBox component",
561 (nsCID) NS_VIRTUALBOX_CID,
562 NS_VIRTUALBOX_CONTRACTID,
563 VirtualBoxConstructor, // constructor funcion
564 NULL, // registration function
565 NULL, // deregistration function
566 VirtualBoxClassFactory::FactoryDestructor, // factory destructor function
567 NS_CI_INTERFACE_GETTER_NAME(VirtualBox),
568 NULL, // language helper
569 &NS_CLASSINFO_NAME(VirtualBox),
570 0, // flags
571 VirtualBoxClassFactory::FactoryConstructor // factory constructor function
572 )
573};
574
575/////////////////////////////////////////////////////////////////////////////
576
577/**
578 * Generic component factory.
579 *
580 * The code below is stolen from nsGenericFactory.h / nsGenericFactory.cpp,
581 * because we get a segmentation fault for some unknown reason when VBoxSVC
582 * starts up (somewhere during the initialization of the libipcdc.so module)
583 * when we just reference XPCOM's NS_NewGenericFactory() from here (i.e. even
584 * before actually calling it) and run VBoxSVC using the debug XPCOM
585 * libraries.
586 *
587 * Actually, I know why, but I find it too stupid even to discuss.
588 */
589class nsMyFactory : public nsIGenericFactory, public nsIClassInfo {
590public:
591 NS_DEFINE_STATIC_CID_ACCESSOR(NS_GENERICFACTORY_CID);
592
593 nsMyFactory(const nsModuleComponentInfo *info = NULL);
594
595 NS_DECL_ISUPPORTS
596 NS_DECL_NSICLASSINFO
597
598 /* nsIGenericFactory methods */
599 NS_IMETHOD SetComponentInfo(const nsModuleComponentInfo *info);
600 NS_IMETHOD GetComponentInfo(const nsModuleComponentInfo **infop);
601
602 NS_IMETHOD CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult);
603
604 NS_IMETHOD LockFactory(PRBool aLock);
605
606 static NS_METHOD Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr);
607private:
608 ~nsMyFactory();
609
610 const nsModuleComponentInfo *mInfo;
611};
612
613nsMyFactory::nsMyFactory(const nsModuleComponentInfo *info)
614 : mInfo(info)
615{
616 if (mInfo && mInfo->mClassInfoGlobal)
617 *mInfo->mClassInfoGlobal = NS_STATIC_CAST(nsIClassInfo *, this);
618}
619
620nsMyFactory::~nsMyFactory()
621{
622 if (mInfo) {
623 if (mInfo->mFactoryDestructor)
624 mInfo->mFactoryDestructor();
625 if (mInfo->mClassInfoGlobal)
626 *mInfo->mClassInfoGlobal = 0;
627 }
628}
629
630NS_IMPL_THREADSAFE_ISUPPORTS3(nsMyFactory,
631 nsIGenericFactory,
632 nsIFactory,
633 nsIClassInfo)
634
635NS_IMETHODIMP nsMyFactory::CreateInstance(nsISupports *aOuter,
636 REFNSIID aIID, void **aResult)
637{
638 if (mInfo->mConstructor)
639 return mInfo->mConstructor(aOuter, aIID, aResult);
640
641 return NS_ERROR_FACTORY_NOT_REGISTERED;
642}
643
644NS_IMETHODIMP nsMyFactory::LockFactory(PRBool aLock)
645{
646 // XXX do we care if (mInfo->mFlags & THREADSAFE)?
647 return NS_OK;
648}
649
650NS_IMETHODIMP nsMyFactory::GetInterfaces(PRUint32 *countp,
651 nsIID* **array)
652{
653 if (!mInfo->mGetInterfacesProc) {
654 *countp = 0;
655 *array = nsnull;
656 return NS_OK;
657 }
658 return mInfo->mGetInterfacesProc(countp, array);
659}
660
661NS_IMETHODIMP nsMyFactory::GetHelperForLanguage(PRUint32 language,
662 nsISupports **helper)
663{
664 if (mInfo->mGetLanguageHelperProc)
665 return mInfo->mGetLanguageHelperProc(language, helper);
666 *helper = nsnull;
667 return NS_OK;
668}
669
670NS_IMETHODIMP nsMyFactory::GetContractID(char **aContractID)
671{
672 if (mInfo->mContractID) {
673 *aContractID = (char *)nsMemory::Alloc(strlen(mInfo->mContractID) + 1);
674 if (!*aContractID)
675 return NS_ERROR_OUT_OF_MEMORY;
676 strcpy(*aContractID, mInfo->mContractID);
677 } else {
678 *aContractID = nsnull;
679 }
680 return NS_OK;
681}
682
683NS_IMETHODIMP nsMyFactory::GetClassDescription(char * *aClassDescription)
684{
685 if (mInfo->mDescription) {
686 *aClassDescription = (char *)
687 nsMemory::Alloc(strlen(mInfo->mDescription) + 1);
688 if (!*aClassDescription)
689 return NS_ERROR_OUT_OF_MEMORY;
690 strcpy(*aClassDescription, mInfo->mDescription);
691 } else {
692 *aClassDescription = nsnull;
693 }
694 return NS_OK;
695}
696
697NS_IMETHODIMP nsMyFactory::GetClassID(nsCID * *aClassID)
698{
699 *aClassID =
700 NS_REINTERPRET_CAST(nsCID*,
701 nsMemory::Clone(&mInfo->mCID, sizeof mInfo->mCID));
702 if (! *aClassID)
703 return NS_ERROR_OUT_OF_MEMORY;
704 return NS_OK;
705}
706
707NS_IMETHODIMP nsMyFactory::GetClassIDNoAlloc(nsCID *aClassID)
708{
709 *aClassID = mInfo->mCID;
710 return NS_OK;
711}
712
713NS_IMETHODIMP nsMyFactory::GetImplementationLanguage(PRUint32 *langp)
714{
715 *langp = nsIProgrammingLanguage::CPLUSPLUS;
716 return NS_OK;
717}
718
719NS_IMETHODIMP nsMyFactory::GetFlags(PRUint32 *flagsp)
720{
721 *flagsp = mInfo->mFlags;
722 return NS_OK;
723}
724
725// nsIGenericFactory: component-info accessors
726NS_IMETHODIMP nsMyFactory::SetComponentInfo(const nsModuleComponentInfo *info)
727{
728 if (mInfo && mInfo->mClassInfoGlobal)
729 *mInfo->mClassInfoGlobal = 0;
730 mInfo = info;
731 if (mInfo && mInfo->mClassInfoGlobal)
732 *mInfo->mClassInfoGlobal = NS_STATIC_CAST(nsIClassInfo *, this);
733 return NS_OK;
734}
735
736NS_IMETHODIMP nsMyFactory::GetComponentInfo(const nsModuleComponentInfo **infop)
737{
738 *infop = mInfo;
739 return NS_OK;
740}
741
742NS_METHOD nsMyFactory::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
743{
744 // sorry, aggregation not spoken here.
745 nsresult res = NS_ERROR_NO_AGGREGATION;
746 if (outer == NULL) {
747 nsMyFactory* factory = new nsMyFactory;
748 if (factory != NULL) {
749 res = factory->QueryInterface(aIID, aInstancePtr);
750 if (res != NS_OK)
751 delete factory;
752 } else {
753 res = NS_ERROR_OUT_OF_MEMORY;
754 }
755 }
756 return res;
757}
758
759/**
760 * Instantiates a new factory and calls
761 * nsMyModuleComponentInfo::mFactoryConstructor.
762 */
763NS_COM nsresult
764NS_NewMyFactory(nsIGenericFactory* *result,
765 const nsMyModuleComponentInfo *info)
766{
767 nsresult rv;
768 nsMyFactory* fact;
769 rv = nsMyFactory::Create(NULL, NS_GET_IID(nsIGenericFactory), (void**)&fact);
770 if (NS_FAILED(rv)) return rv;
771 rv = fact->SetComponentInfo(info);
772 if (NS_FAILED(rv)) goto error;
773 if (info && info->mFactoryConstructor) {
774 rv = info->mFactoryConstructor();
775 if (NS_FAILED(rv)) goto error;
776 }
777 *result = fact;
778 return rv;
779
780 error:
781 NS_RELEASE(fact);
782 return rv;
783}
784
785/////////////////////////////////////////////////////////////////////////////
786
787/**
788 * Hhelper function to register self components upon start-up
789 * of the out-of-proc server.
790 */
791static nsresult
792RegisterSelfComponents (nsIComponentRegistrar *registrar,
793 const nsMyModuleComponentInfo *components,
794 PRUint32 count)
795{
796 nsresult rc = NS_OK;
797 const nsMyModuleComponentInfo *info = components;
798 for (PRUint32 i = 0; i < count && NS_SUCCEEDED (rc); i++, info++)
799 {
800 /* skip components w/o a constructor */
801 if (!info->mConstructor) continue;
802 /* create a new generic factory for a component and register it */
803 nsIGenericFactory *factory;
804 rc = NS_NewGenericFactory (&factory, info);
805 rc = NS_NewMyFactory (&factory, info);
806 if (NS_SUCCEEDED (rc))
807 {
808 rc = registrar->RegisterFactory (info->mCID,
809 info->mDescription,
810 info->mContractID,
811 factory);
812 factory->Release();
813 }
814 }
815 return rc;
816}
817
818/////////////////////////////////////////////////////////////////////////////
819
820static ipcIService *gIpcServ = nsnull;
821static char *pszPidFile = NULL;
822
823void* PR_CALLBACK quitEventHandler (PLEvent* self) { gKeepRunning = PR_FALSE; return 0; }
824void PR_CALLBACK quitEventDestructor (PLEvent* self) { delete self; }
825
826static void signal_handler (int sig)
827{
828 if (gEventQ && gKeepRunning)
829 {
830 /* post a quit event to the queue */
831 PLEvent *ev = new PLEvent;
832 gEventQ->InitEvent (ev, NULL, quitEventHandler, quitEventDestructor);
833 gEventQ->PostEvent (ev);
834 }
835 if (pszPidFile)
836 {
837 RTFileDelete(pszPidFile);
838 }
839};
840
841#if defined(USE_BACKTRACE)
842/**
843 * the signal handler that prints out a backtrace of the call stack.
844 * the code is taken from http://www.linuxjournal.com/article/6391.
845 */
846static void bt_sighandler (int sig, siginfo_t *info, void *secret)
847{
848
849 void *trace[16];
850 char **messages = (char **)NULL;
851 int i, trace_size = 0;
852 ucontext_t *uc = (ucontext_t *)secret;
853
854 // Do something useful with siginfo_t
855 if (sig == SIGSEGV)
856 Log (("Got signal %d, faulty address is %p, from %p\n",
857 sig, info->si_addr, uc->uc_mcontext.gregs[REG_PC]));
858 else
859 Log (("Got signal %d\n", sig));
860
861 trace_size = backtrace (trace, 16);
862 // overwrite sigaction with caller's address
863 trace[1] = (void *) uc->uc_mcontext.gregs [REG_PC];
864
865 messages = backtrace_symbols (trace, trace_size);
866 // skip first stack frame (points here)
867 Log (("[bt] Execution path:\n"));
868 for (i = 1; i < trace_size; ++i)
869 Log (("[bt] %s\n", messages[i]));
870
871 exit (0);
872}
873#endif
874
875int main (int argc, char **argv)
876{
877 const struct option options[] =
878 {
879 { "automate", no_argument, NULL, 'a' },
880 { "daemonize", no_argument, NULL, 'd' },
881 { "pidfile", required_argument, NULL, 'p' },
882 { NULL, 0, NULL, 0 }
883 };
884 int c;
885
886 bool fDaemonize = false;
887
888 for (;;)
889 {
890 c = getopt_long(argc, argv, "", options, NULL);
891 if (c == -1)
892 break;
893 switch (c)
894 {
895 case 'a':
896 {
897 /* --automate mode means we are started by XPCOM on
898 * demand. Daemonize ourselves and activate
899 * auto-shutdown. */
900 gAutoShutdown = true;
901 fDaemonize = true;
902 break;
903 }
904
905 case 'd':
906 {
907 fDaemonize = true;
908 break;
909 }
910
911 case 'p':
912 {
913 pszPidFile = optarg;
914 break;
915 }
916
917 default:
918 {
919 /* exit on invalid options */
920 return 1;
921 }
922 }
923 }
924
925 static int daemon_pipe_fds[2];
926 static RTFILE pidFile = NIL_RTFILE;
927
928 if (fDaemonize)
929 {
930 /* create a pipe for communication between child and parent */
931 if (pipe(daemon_pipe_fds) < 0)
932 {
933 printf("ERROR: pipe() failed (errno = %d)\n", errno);
934 return 1;
935 }
936
937 pid_t childpid = fork();
938 if (childpid == -1)
939 {
940 printf("ERROR: fork() failed (errno = %d)\n", errno);
941 return 1;
942 }
943
944 if (childpid != 0)
945 {
946 /* we're the parent process */
947 bool fSuccess = false;
948
949 /* close the writing end of the pipe */
950 close(daemon_pipe_fds[1]);
951
952 /* try to read a message from the pipe */
953 char msg[10] = {0}; /* initialize so it's NULL terminated */
954 if (read(daemon_pipe_fds[0], msg, sizeof(msg)) > 0)
955 {
956 if (strcmp(msg, "READY") == 0)
957 fSuccess = true;
958 else
959 printf ("ERROR: Unknown message from child "
960 "process (%s)\n", msg);
961 }
962 else
963 printf ("ERROR: 0 bytes read from child process\n");
964
965 /* close the reading end of the pipe as well and exit */
966 close(daemon_pipe_fds[0]);
967 return fSuccess ? 0 : 1;
968 }
969 /* we're the child process */
970
971 /* Create a new SID for the child process */
972 pid_t sid = setsid();
973 if (sid < 0)
974 {
975 printf("ERROR: setsid() failed (errno = %d)\n", errno);
976 return 1;
977 }
978
979 /* Redirect standard i/o streams to /dev/null */
980 freopen ("/dev/null", "r", stdin);
981 freopen ("/dev/null", "w", stdout);
982 freopen ("/dev/null", "w", stderr);
983
984 /* close the reading end of the pipe */
985 close(daemon_pipe_fds[0]);
986 }
987
988#if defined(USE_BACKTRACE)
989 {
990 /* install our signal handler to backtrace the call stack */
991 struct sigaction sa;
992 sa.sa_sigaction = bt_sighandler;
993 sigemptyset (&sa.sa_mask);
994 sa.sa_flags = SA_RESTART | SA_SIGINFO;
995 sigaction (SIGSEGV, &sa, NULL);
996 sigaction (SIGBUS, &sa, NULL);
997 sigaction (SIGUSR1, &sa, NULL);
998 }
999#endif
1000
1001 /*
1002 * Initialize the VBox runtime without loading
1003 * the support driver
1004 */
1005 RTR3Init(false);
1006
1007 nsresult rc;
1008
1009 do
1010 {
1011 XPCOMGlueStartup (nsnull);
1012
1013 char path [RTPATH_MAX];
1014 path [0] = '\0';
1015
1016 nsCOMPtr<nsIFile> nsAppPath;
1017 {
1018 /* get the path to the executable */
1019 char *appPath = NULL;
1020#if defined (DEBUG)
1021 appPath = getenv ("VIRTUALBOX_APP_HOME");
1022 if (appPath)
1023 RTPathReal (appPath, path, RTPATH_MAX);
1024 else
1025#endif
1026 RTPathProgram (path, RTPATH_MAX);
1027 appPath = path;
1028
1029 nsCOMPtr<nsILocalFile> file;
1030 rc = NS_NewNativeLocalFile (nsEmbedCString (appPath),
1031 PR_FALSE, getter_AddRefs (file));
1032 if (NS_SUCCEEDED (rc))
1033 nsAppPath = do_QueryInterface (file, &rc);
1034 }
1035 if (NS_FAILED (rc))
1036 {
1037 printf ("ERROR: Failed to create file object! (rc=%08X)\n", rc);
1038 break;
1039 }
1040
1041 /* not really necessary at the moment */
1042#if 0
1043 if (!RTProcGetExecutableName (path, sizeof (path)))
1044 {
1045 printf ("ERROR: Failed to get executable name!\n");
1046 break;
1047 }
1048#endif
1049
1050 nsCOMPtr<nsIServiceManager> servMan;
1051 NS_InitXPCOM2 (getter_AddRefs (servMan), nsAppPath, nsnull);
1052 if (!servMan)
1053 {
1054 printf ("ERROR: Failed to get service manager!\n");
1055 break;
1056 }
1057
1058 nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface (servMan);
1059 if (!registrar)
1060 {
1061 printf ("ERROR: Failed to get component registrar!\n");
1062 break;
1063 }
1064
1065 registrar->AutoRegister (nsnull);
1066 rc = RegisterSelfComponents (registrar, components,
1067 NS_ARRAY_LENGTH (components));
1068 if (NS_FAILED (rc))
1069 {
1070 printf ("ERROR: Failed to register server components! (rc=%08X)\n", rc);
1071 break;
1072 }
1073
1074 /* get the main thread's event queue (afaik, the dconnect service always
1075 * gets created upon XPCOM startup, so it will use the main (this)
1076 * thread's event queue to receive IPC events) */
1077 rc = NS_GetMainEventQ (&gEventQ);
1078 if (NS_FAILED (rc))
1079 {
1080 printf ("ERROR: Failed to get the main event queue! (rc=%08X)\n", rc);
1081 break;
1082 }
1083
1084 nsCOMPtr<ipcIService> ipcServ (do_GetService(IPC_SERVICE_CONTRACTID, &rc));
1085 if (NS_FAILED (rc))
1086 {
1087 printf ("ERROR: Failed to get IPC service! (rc=%08X)\n", rc);
1088 break;
1089 }
1090
1091 NS_ADDREF (gIpcServ = ipcServ);
1092
1093 LogFlowFunc (("Will use \"%s\" as server name.\n", VBOXSVC_IPC_NAME));
1094
1095 rc = gIpcServ->AddName (VBOXSVC_IPC_NAME);
1096 if (NS_FAILED (rc))
1097 {
1098 printf ("ERROR: Failed to register VirtualBoxServer! (rc=%08X)\n", rc);
1099 NS_RELEASE (gIpcServ);
1100 break;
1101 }
1102
1103 {
1104 /* setup signal handling to convert some signals to a quit event */
1105 struct sigaction sa;
1106 sa.sa_handler = signal_handler;
1107 sigemptyset (&sa.sa_mask);
1108 sa.sa_flags = 0;
1109 sigaction (SIGINT, &sa, NULL);
1110 sigaction (SIGQUIT, &sa, NULL);
1111 sigaction (SIGTERM, &sa, NULL);
1112 sigaction (SIGTRAP, &sa, NULL);
1113 }
1114
1115 {
1116 char szBuf[80];
1117 int iSize;
1118
1119 iSize = snprintf (szBuf, sizeof(szBuf),
1120 "InnoTek VirtualBox XPCOM Server Version %s",
1121 VBOX_VERSION_STRING);
1122 for (int i=iSize; i>0; i--)
1123 putchar('*');
1124 printf ("\n%s\n", szBuf);
1125 printf ("(C) 2004-2007 InnoTek Systemberatung GmbH\n");
1126 printf ("All rights reserved.\n");
1127#ifdef DEBUG
1128 printf ("Debug version.\n");
1129#endif
1130#if 0
1131 /* in my opinion two lines enclosing the text look better */
1132 for (int i=iSize; i>0; i--)
1133 putchar('*');
1134 putchar('\n');
1135#endif
1136 }
1137
1138 if (fDaemonize)
1139 {
1140 printf ("\nStarting event loop....\n[send TERM signal to quit]\n");
1141 /* now we're ready, signal the parent process */
1142 write(daemon_pipe_fds[1], "READY", strlen("READY"));
1143 }
1144 else
1145 {
1146 printf ("\nStarting event loop....\n[press Ctrl-C to quit]\n");
1147 }
1148
1149 if (pszPidFile)
1150 {
1151 char szBuf[32];
1152 char *lf = "\n";
1153 RTFileOpen(&pidFile, pszPidFile, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE);
1154 RTStrFormatNumber(szBuf, getpid(), 10, 0, 0, 0);
1155 RTFileWrite(pidFile, szBuf, strlen(szBuf), NULL);
1156 RTFileWrite(pidFile, lf, strlen(lf), NULL);
1157 RTFileClose(pidFile);
1158 }
1159
1160 PLEvent *ev;
1161 while (gKeepRunning)
1162 {
1163 gEventQ->WaitForEvent (&ev);
1164 gEventQ->HandleEvent (ev);
1165 }
1166
1167 gIpcServ->RemoveName (path);
1168
1169 // stop accepting new events
1170 gEventQ->StopAcceptingEvents();
1171 // process any remaining events
1172 gEventQ->ProcessPendingEvents();
1173
1174 printf ("Terminated event loop.\n");
1175
1176 }
1177 while (0); // this scopes the nsCOMPtrs
1178
1179 NS_IF_RELEASE (gIpcServ);
1180 NS_IF_RELEASE (gEventQ);
1181
1182 // no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
1183 LogFlowFunc (("Calling NS_ShutdownXPCOM()...\n"));
1184 rc = NS_ShutdownXPCOM (nsnull);
1185 LogFlowFunc (("Finished NS_ShutdownXPCOM() (rc=%08X)\n", rc));
1186
1187 if (NS_FAILED (rc))
1188 printf ("ERROR: Failed to shutdown XPCOM! (rc=%08X)\n", rc);
1189
1190 XPCOMGlueShutdown();
1191
1192 printf ("XPCOM server has shutdown.\n");
1193
1194 if (pszPidFile)
1195 {
1196 RTFileDelete(pszPidFile);
1197 }
1198
1199 if (fDaemonize)
1200 {
1201 /* close writing end of the pipe as well */
1202 close(daemon_pipe_fds[1]);
1203 }
1204
1205 return 0;
1206}
Note: See TracBrowser for help on using the repository browser.

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