VBoxGuestR3Lib.cpp@ 45459

Last change on this file since 45459 was 45459, checked in by vboxsync, 12 years ago
BUGZ:4686 OS X guest: VBoxGuest device driver + VBoxService and VBoxControl now work.
Property svn:eol-style set to `native` Property svn:keyword set to `Id` Property svn:keywords set to `Id`
File size: 14.3 KB

Line
1	/* $Id: VBoxGuestR3Lib.cpp 45459 2013-04-10 15:24:23Z vboxsync $ */
2	/** @file
3	* VBoxGuestR3Lib - Ring-3 Support Library for VirtualBox guest additions, Core.
4	*/
5
6	/*
7	* Copyright (C) 2007-2013 Oracle Corporation
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	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#if defined(RT_OS_WINDOWS)
32	# include <Windows.h>
33
34	#elif defined(RT_OS_OS2)
35	# define INCL_BASE
36	# define INCL_ERRORS
37	# include <os2.h>
38
39	#elif defined(RT_OS_DARWIN) \
40	\|\| defined(RT_OS_FREEBSD) \
41	\|\| defined(RT_OS_HAIKU) \
42	\|\| defined(RT_OS_LINUX) \
43	\|\| defined(RT_OS_SOLARIS)
44	# include <sys/types.h>
45	# include <sys/stat.h>
46	# if defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX) /** @todo check this on solaris+freebsd as well. */
47	# include <sys/ioctl.h>
48	# endif
49	# if defined(RT_OS_DARWIN)
50	# include <mach/mach_port.h>
51	# include <IOKit/IOKitLib.h>
52	# endif
53	# include <errno.h>
54	# include <unistd.h>
55	#endif
56
57	#include <iprt/assert.h>
58	#include <iprt/asm.h>
59	#include <iprt/file.h>
60	#include <iprt/time.h>
61	#include <iprt/string.h>
62	#include <iprt/thread.h>
63	#include <VBox/log.h>
64	#include "VBGLR3Internal.h"
65
66	#ifdef VBOX_VBGLR3_XFREE86
67	/* Rather than try to resolve all the header file conflicts, I will just
68	prototype what we need here. */
69	# define XF86_O_RDWR 0x0002
70	typedef void *pointer;
71	extern "C" int xf86open(const char *, int, ...);
72	extern "C" int xf86close(int);
73	extern "C" int xf86ioctl(int, unsigned long, pointer);
74	#endif
75
76
77	/*******************************************************************************
78	* Global Variables *
79	*******************************************************************************/
80	/** The VBoxGuest device handle. */
81	#ifdef VBOX_VBGLR3_XFREE86
82	static int g_File = -1;
83	#elif defined(RT_OS_WINDOWS)
84	static HANDLE g_hFile = INVALID_HANDLE_VALUE;
85	#else
86	static RTFILE g_File = NIL_RTFILE;
87	#endif
88	/** User counter.
89	* A counter of the number of times the library has been initialised, for use with
90	* X.org drivers, where the library may be shared by multiple independent modules
91	* inside a single process space.
92	*/
93	static uint32_t volatile g_cInits = 0;
94	#ifdef RT_OS_DARWIN
95	/** I/O Kit connection handle. */
96	static io_connect_t g_uConnection = 0;
97	#endif
98
99
100
101	/**
102	* Implementation of VbglR3Init and VbglR3InitUser
103	*/
104	static int vbglR3Init(const char *pszDeviceName)
105	{
106	uint32_t cInits = ASMAtomicIncU32(&g_cInits);
107	Assert(cInits > 0);
108	if (cInits > 1)
109	{
110	/*
111	* This will fail if two (or more) threads race each other calling VbglR3Init.
112	* However it will work fine for single threaded or otherwise serialized
113	* processed calling us more than once.
114	*/
115	#ifdef RT_OS_WINDOWS
116	if (g_hFile == INVALID_HANDLE_VALUE)
117	#elif !defined (VBOX_VBGLR3_XFREE86)
118	if (g_File == NIL_RTFILE)
119	#else
120	if (g_File == -1)
121	#endif
122	return VERR_INTERNAL_ERROR;
123	return VINF_SUCCESS;
124	}
125	#if defined(RT_OS_WINDOWS)
126	if (g_hFile != INVALID_HANDLE_VALUE)
127	#elif !defined(VBOX_VBGLR3_XFREE86)
128	if (g_File != NIL_RTFILE)
129	#else
130	if (g_File != -1)
131	#endif
132	return VERR_INTERNAL_ERROR;
133
134	#if defined(RT_OS_WINDOWS)
135	/*
136	* Have to use CreateFile here as we want to specify FILE_FLAG_OVERLAPPED
137	* and possible some other bits not available thru iprt/file.h.
138	*/
139	HANDLE hFile = CreateFile(pszDeviceName,
140	GENERIC_READ \| GENERIC_WRITE,
141	FILE_SHARE_READ \| FILE_SHARE_WRITE,
142	NULL,
143	OPEN_EXISTING,
144	FILE_ATTRIBUTE_NORMAL \| FILE_FLAG_OVERLAPPED,
145	NULL);
146
147	if (hFile == INVALID_HANDLE_VALUE)
148	return VERR_OPEN_FAILED;
149	g_hFile = hFile;
150
151	#elif defined(RT_OS_OS2)
152	/*
153	* We might wish to compile this with Watcom, so stick to
154	* the OS/2 APIs all the way. And in any case we have to use
155	* DosDevIOCtl for the requests, why not use Dos* for everything.
156	*/
157	HFILE hf = NULLHANDLE;
158	ULONG ulAction = 0;
159	APIRET rc = DosOpen((PCSZ)pszDeviceName, &hf, &ulAction, 0, FILE_NORMAL,
160	OPEN_ACTION_OPEN_IF_EXISTS,
161	OPEN_FLAGS_FAIL_ON_ERROR \| OPEN_FLAGS_NOINHERIT \| OPEN_SHARE_DENYNONE \| OPEN_ACCESS_READWRITE,
162	NULL);
163	if (rc)
164	return RTErrConvertFromOS2(rc);
165
166	if (hf < 16)
167	{
168	HFILE ahfs[16];
169	unsigned i;
170	for (i = 0; i < RT_ELEMENTS(ahfs); i++)
171	{
172	ahfs[i] = 0xffffffff;
173	rc = DosDupHandle(hf, &ahfs[i]);
174	if (rc)
175	break;
176	}
177
178	if (i-- > 1)
179	{
180	ULONG fulState = 0;
181	rc = DosQueryFHState(ahfs[i], &fulState);
182	if (!rc)
183	{
184	fulState \|= OPEN_FLAGS_NOINHERIT;
185	fulState &= OPEN_FLAGS_WRITE_THROUGH \| OPEN_FLAGS_FAIL_ON_ERROR \| OPEN_FLAGS_NO_CACHE \| OPEN_FLAGS_NOINHERIT; /* Turn off non-participating bits. */
186	rc = DosSetFHState(ahfs[i], fulState);
187	}
188	if (!rc)
189	{
190	rc = DosClose(hf);
191	AssertMsg(!rc, ("%ld\n", rc));
192	hf = ahfs[i];
193	}
194	else
195	i++;
196	while (i-- > 0)
197	DosClose(ahfs[i]);
198	}
199	}
200	g_File = (RTFILE)hf;
201
202	#elif defined(RT_OS_DARWIN)
203	/*
204	* Darwin is kind of special we need to engage the device via I/O first
205	* before we open it via the BSD device node.
206	*/
207	mach_port_t MasterPort;
208	kern_return_t kr = IOMasterPort(MACH_PORT_NULL, &MasterPort);
209	if (kr != kIOReturnSuccess)
210	return VERR_GENERAL_FAILURE;
211
212	CFDictionaryRef ClassToMatch = IOServiceMatching("org_virtualbox_VBoxGuest");
213	if (!ClassToMatch)
214	return VERR_GENERAL_FAILURE;
215
216	io_service_t ServiceObject = IOServiceGetMatchingService(kIOMasterPortDefault, ClassToMatch);
217	if (!ServiceObject)
218	return VERR_NOT_FOUND;
219
220	io_connect_t uConnection;
221	kr = IOServiceOpen(ServiceObject, mach_task_self(), 0, &uConnection);
222	IOObjectRelease(ServiceObject);
223	if (kr != kIOReturnSuccess)
224	return VERR_OPEN_FAILED;
225
226	RTFILE hFile;
227	int rc = RTFileOpen(&hFile, pszDeviceName, RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
228	if (RT_FAILURE(rc))
229	{
230	IOServiceClose(uConnection);
231	return rc;
232	}
233	g_File = hFile;
234	g_uConnection = uConnection;
235
236	#elif defined(VBOX_VBGLR3_XFREE86)
237	int File = xf86open(pszDeviceName, XF86_O_RDWR);
238	if (File == -1)
239	return VERR_OPEN_FAILED;
240	g_File = File;
241
242	#else
243
244	/* The default implementation. (linux, solaris, freebsd, haiku) */
245	RTFILE File;
246	int rc = RTFileOpen(&File, pszDeviceName, RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
247	if (RT_FAILURE(rc))
248	return rc;
249	g_File = File;
250
251	#endif
252
253	#ifndef VBOX_VBGLR3_XFREE86
254	/*
255	* Create release logger
256	*/
257	PRTLOGGER pReleaseLogger;
258	static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
259	int rc2 = RTLogCreate(&pReleaseLogger, 0, "all", "VBOX_RELEASE_LOG",
260	RT_ELEMENTS(s_apszGroups), &s_apszGroups[0], RTLOGDEST_USER, NULL);
261	/* This may legitimately fail if we are using the mini-runtime. */
262	if (RT_SUCCESS(rc2))
263	RTLogRelSetDefaultInstance(pReleaseLogger);
264	#endif
265
266	return VINF_SUCCESS;
267	}
268
269
270	/**
271	* Open the VBox R3 Guest Library. This should be called by system daemons
272	* and processes.
273	*/
274	VBGLR3DECL(int) VbglR3Init(void)
275	{
276	return vbglR3Init(VBOXGUEST_DEVICE_NAME);
277	}
278
279
280	/**
281	* Open the VBox R3 Guest Library. Equivalent to VbglR3Init, but for user
282	* session processes.
283	*/
284	VBGLR3DECL(int) VbglR3InitUser(void)
285	{
286	return vbglR3Init(VBOXGUEST_USER_DEVICE_NAME);
287	}
288
289
290	VBGLR3DECL(void) VbglR3Term(void)
291	{
292	/*
293	* Decrement the reference count and see if we're the last one out.
294	*/
295	uint32_t cInits = ASMAtomicDecU32(&g_cInits);
296	if (cInits > 0)
297	return;
298	#if !defined(VBOX_VBGLR3_XFREE86)
299	AssertReturnVoid(!cInits);
300
301	# if defined(RT_OS_WINDOWS)
302	HANDLE hFile = g_hFile;
303	g_hFile = INVALID_HANDLE_VALUE;
304	AssertReturnVoid(hFile != INVALID_HANDLE_VALUE);
305	BOOL fRc = CloseHandle(hFile);
306	Assert(fRc); NOREF(fRc);
307
308	# elif defined(RT_OS_OS2)
309	RTFILE File = g_File;
310	g_File = NIL_RTFILE;
311	AssertReturnVoid(File != NIL_RTFILE);
312	APIRET rc = DosClose((uintptr_t)File);
313	AssertMsg(!rc, ("%ld\n", rc));
314
315	#elif defined(RT_OS_DARWIN)
316	io_connect_t uConnection = g_uConnection;
317	RTFILE hFile = g_File;
318	g_uConnection = 0;
319	g_File = NIL_RTFILE;
320	kern_return_t kr = IOServiceClose(uConnection);
321	AssertMsg(kr == kIOReturnSuccess, ("%#x (%d)\n", kr, kr));
322	int rc = RTFileClose(hFile);
323	AssertRC(rc);
324
325	# else /* The IPRT case. */
326	RTFILE File = g_File;
327	g_File = NIL_RTFILE;
328	AssertReturnVoid(File != NIL_RTFILE);
329	int rc = RTFileClose(File);
330	AssertRC(rc);
331	# endif
332
333	#else /* VBOX_VBGLR3_XFREE86 */
334	int File = g_File;
335	g_File = -1;
336	if (File == -1)
337	return;
338	xf86close(File);
339	#endif /* VBOX_VBGLR3_XFREE86 */
340	}
341
342
343	/**
344	* Internal wrapper around various OS specific ioctl implementations.
345	*
346	* @returns VBox status code as returned by VBoxGuestCommonIOCtl, or
347	* an failure returned by the OS specific ioctl APIs.
348	*
349	* @param iFunction The requested function.
350	* @param pvData The input and output data buffer.
351	* @param cbData The size of the buffer.
352	*
353	* @remark Exactly how the VBoxGuestCommonIOCtl is ferried back
354	* here is OS specific. On BSD and Darwin we can use errno,
355	* while on OS/2 we use the 2nd buffer of the IOCtl.
356	*/
357	int vbglR3DoIOCtl(unsigned iFunction, void *pvData, size_t cbData)
358	{
359	#if defined(RT_OS_WINDOWS)
360	DWORD cbReturned = 0;
361	if (!DeviceIoControl(g_hFile, iFunction, pvData, (DWORD)cbData, pvData, (DWORD)cbData, &cbReturned, NULL))
362	{
363	/** @todo The passing of error codes needs to be tested and fixed (as does all the other hosts except for
364	* OS/2). The idea is that the VBox status codes in ring-0 should be transferred without loss down to
365	* ring-3. However, it's not vitally important right now (obviously, since the other guys has been
366	* ignoring it for 1+ years now). On Linux and Solaris the transfer is done, but it is currently not
367	* lossless, so still needs fixing. */
368	DWORD LastErr = GetLastError();
369	return RTErrConvertFromWin32(LastErr);
370	}
371
372	return VINF_SUCCESS;
373
374	#elif defined(RT_OS_OS2)
375	ULONG cbOS2Parm = cbData;
376	int32_t vrc = VERR_INTERNAL_ERROR;
377	ULONG cbOS2Data = sizeof(vrc);
378	APIRET rc = DosDevIOCtl((uintptr_t)g_File, VBOXGUEST_IOCTL_CATEGORY, iFunction,
379	pvData, cbData, &cbOS2Parm,
380	&vrc, sizeof(vrc), &cbOS2Data);
381	if (RT_LIKELY(!rc))
382	return vrc;
383	return RTErrConvertFromOS2(rc);
384
385	#elif defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
386	VBGLBIGREQ Hdr;
387	Hdr.u32Magic = VBGLBIGREQ_MAGIC;
388	Hdr.cbData = cbData;
389	Hdr.pvDataR3 = pvData;
390	# if HC_ARCH_BITS == 32
391	Hdr.u32Padding = 0;
392	# endif
393
394	/** @todo test status code passing! Check that the kernel doesn't do any
395	* error checks using specific errno values, and just pass an VBox
396	* error instead of an errno.h one. Alternatively, extend/redefine the
397	* header with an error code return field (much better alternative
398	* actually). */
399	#ifdef VBOX_VBGLR3_XFREE86
400	int rc = xf86ioctl(g_File, iFunction, &Hdr);
401	#else
402	if (g_File == NIL_RTFILE)
403	return VERR_INVALID_HANDLE;
404	int rc = ioctl(RTFileToNative(g_File), iFunction, &Hdr);
405	#endif
406	if (rc == -1)
407	{
408	rc = errno;
409	return RTErrConvertFromErrno(rc);
410	}
411	return VINF_SUCCESS;
412
413	#elif defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX)
414	# ifdef VBOX_VBGLR3_XFREE86
415	int rc = xf86ioctl((int)g_File, iFunction, pvData);
416	# else
417	if (g_File == NIL_RTFILE)
418	return VERR_INVALID_HANDLE;
419	int rc = ioctl(RTFileToNative(g_File), iFunction, pvData);
420	# endif
421	if (RT_LIKELY(rc == 0))
422	return VINF_SUCCESS;
423
424	/* Positive values are negated VBox error status codes. */
425	if (rc > 0)
426	rc = -rc;
427	else
428	# ifdef VBOX_VBGLR3_XFREE86
429	rc = VERR_FILE_IO_ERROR;
430	# else
431	rc = RTErrConvertFromErrno(errno);
432	# endif
433	NOREF(cbData);
434	return rc;
435
436	#elif defined(RT_OS_HAIKU)
437	/* The ioctl hook in Haiku does take the len parameter when specified,
438	* so just use it. */
439	int rc = ioctl((int)g_File, iFunction, pvData, cbData);
440	if (RT_LIKELY(rc == 0))
441	return VINF_SUCCESS;
442
443	/* Positive values are negated VBox error status codes. */
444	if (rc > 0)
445	rc = -rc;
446	else
447	rc = RTErrConvertFromErrno(errno);
448	return rc;
449
450	#elif defined(VBOX_VBGLR3_XFREE86)
451	/* PORTME - This is preferred over the RTFileIOCtl variant below, just be careful with the (int). */
452	/** @todo test status code passing! */
453	int rc = xf86ioctl(g_File, iFunction, pvData);
454	if (rc == -1)
455	return VERR_FILE_IO_ERROR; /* This is purely legacy stuff, it has to work and no more. */
456	return VINF_SUCCESS;
457
458	#else
459	/* Default implementation - PORTME: Do not use this without testings that passing errors works! */
460	/** @todo test status code passing! */
461	int rc2 = VERR_INTERNAL_ERROR;
462	int rc = RTFileIoCtl(g_File, (int)iFunction, pvData, cbData, &rc2);
463	if (RT_SUCCESS(rc))
464	rc = rc2;
465	return rc;
466	#endif
467	}
468

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

source: vbox/trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3Lib.cpp@ 45459

Download in other formats: