server.cpp@ 6734

Last change on this file since 6734 was 6361, checked in by vboxsync, 17 years ago
Fixed OS/2 build.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 34.5 KB

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

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

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

Download in other formats: