server.cpp@ 11162

Last change on this file since 11162 was 10958, checked in by vboxsync, 16 years ago
VBoxSVC: Use RTTimerLR instead of RTTimer.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.5 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/xpcom/server.cpp@ 11162

Download in other formats: