VBoxUSB.cpp@ 37620

Last change on this file since 37620 was 33540, checked in by vboxsync, 14 years ago
*: spelling fixes, thanks Timeless!
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 59.9 KB

Line
1	/* $Id: VBoxUSB.cpp 33540 2010-10-28 09:27:05Z vboxsync $ */
2	/** @file
3	* VirtualBox USB driver for Darwin.
4	*
5	* This driver is responsible for hijacking USB devices when any of the
6	* VBoxSVC daemons requests it. It is also responsible for arbitrating
7	* access to hijacked USB devices.
8	*/
9
10	/*
11	* Copyright (C) 2006-2007 Oracle Corporation
12	*
13	* This file is part of VirtualBox Open Source Edition (OSE), as
14	* available from http://www.virtualbox.org. This file is free software;
15	* you can redistribute it and/or modify it under the terms of the GNU
16	* General Public License (GPL) as published by the Free Software
17	* Foundation, in version 2 as it comes in the "COPYING" file of the
18	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_USB_DRV
27	/* Deal with conflicts first.
28	* (This is mess inherited from BSD. The BSDs has clean this up long ago.) /
29	#include <sys/param.h>
30	#undef PVM
31	#include <IOKit/IOLib.h> /* Assert as function */
32
33	#include "VBoxUSBInterface.h"
34	#include "VBoxUSBFilterMgr.h"
35	#include <VBox/version.h>
36	#include <VBox/usblib-darwin.h>
37	#include <VBox/log.h>
38	#include <iprt/types.h>
39	#include <iprt/initterm.h>
40	#include <iprt/assert.h>
41	#include <iprt/semaphore.h>
42	#include <iprt/process.h>
43	#include <iprt/alloc.h>
44	#include <iprt/err.h>
45	#include <iprt/asm.h>
46
47	#include <mach/kmod.h>
48	#include <miscfs/devfs/devfs.h>
49	#include <sys/conf.h>
50	#include <sys/errno.h>
51	#include <sys/ioccom.h>
52	#include <sys/malloc.h>
53	#include <sys/proc.h>
54	#include <kern/task.h>
55	#include <IOKit/IOService.h>
56	#include <IOKit/IOUserClient.h>
57	#include <IOKit/IOKitKeys.h>
58	#include <IOKit/usb/USB.h>
59	#include <IOKit/usb/IOUSBDevice.h>
60	#include <IOKit/usb/IOUSBInterface.h>
61	#include <IOKit/usb/IOUSBUserClient.h>
62
63	/* private: */
64	RT_C_DECLS_BEGIN
65	extern void *get_bsdtask_info(task_t);
66	RT_C_DECLS_END
67
68
69	/*******************************************************************************
70	* Defined Constants And Macros *
71	*******************************************************************************/
72	/** Locks the lists. */
73	#define VBOXUSB_LOCK() do { int rc = RTSemFastMutexRequest(g_Mtx); AssertRC(rc); } while (0)
74	/** Unlocks the lists. */
75	#define VBOXUSB_UNLOCK() do { int rc = RTSemFastMutexRelease(g_Mtx); AssertRC(rc); } while (0)
76
77
78	/*******************************************************************************
79	* Internal Functions *
80	*******************************************************************************/
81	RT_C_DECLS_BEGIN
82	static kern_return_t VBoxUSBStart(struct kmod_info pKModInfo, void pvData);
83	static kern_return_t VBoxUSBStop(struct kmod_info pKModInfo, void pvData);
84	RT_C_DECLS_END
85
86
87	/*******************************************************************************
88	* Structures and Typedefs *
89	*******************************************************************************/
90	/**
91	* The service class.
92	*
93	* This is the management service that VBoxSVC and the VMs speak to.
94	*
95	* @remark The method prototypes are ordered somewhat after their order of
96	* invocation, while the implementation is ordered by pair.
97	*/
98	class org_virtualbox_VBoxUSB : public IOService
99	{
100	OSDeclareDefaultStructors(org_virtualbox_VBoxUSB);
101
102	public:
103	/** @name IOService
104	* @{ */
105	virtual bool init(OSDictionary *pDictionary = 0);
106	virtual bool start(IOService *pProvider);
107	virtual bool open(IOService pForClient, IOOptionBits fOptions = 0, void pvArg = 0);
108	virtual bool terminate(IOOptionBits fOptions);
109	virtual void close(IOService *pForClient, IOOptionBits fOptions = 0);
110	virtual void stop(IOService *pProvider);
111	virtual void free();
112	/** @} */
113	};
114	OSDefineMetaClassAndStructors(org_virtualbox_VBoxUSB, IOService);
115
116
117	/**
118	* The user client class that pairs up with org_virtualbox_VBoxUSB.
119	*/
120	class org_virtualbox_VBoxUSBClient : public IOUserClient
121	{
122	OSDeclareDefaultStructors(org_virtualbox_VBoxUSBClient);
123
124	public:
125	/** @name IOService & IOUserClient
126	* @{ */
127	virtual bool initWithTask(task_t OwningTask, void *pvSecurityId, UInt32 u32Type);
128	virtual bool start(IOService *pProvider);
129	virtual IOReturn clientClose(void);
130	virtual IOReturn clientDied(void);
131	virtual bool terminate(IOOptionBits fOptions = 0);
132	virtual bool finalize(IOOptionBits fOptions);
133	virtual void stop(IOService *pProvider);
134	virtual void free();
135	virtual IOExternalMethod getTargetAndMethodForIndex(IOService *ppService, UInt32 iMethod);
136	/** @} */
137
138	/** @name User client methods
139	* @{ */
140	IOReturn addFilter(PUSBFILTER pFilter, PVBOXUSBADDFILTEROUT pOut, IOByteCount cbFilter, IOByteCount *pcbOut);
141	IOReturn removeFilter(uintptr_t puId, int prc, IOByteCount cbIn, IOByteCount *pcbOut);
142	/** @} */
143
144	static bool isClientTask(task_t ClientTask);
145
146	private:
147	/** The service provider. */
148	org_virtualbox_VBoxUSB *m_pProvider;
149	/** The client task. */
150	task_t m_Task;
151	/** The client process. */
152	RTPROCESS m_Process;
153	/** Pointer to the next user client. */
154	org_virtualbox_VBoxUSBClient * volatile m_pNext;
155	/** List of user clients. Protected by g_Mtx. */
156	static org_virtualbox_VBoxUSBClient * volatile s_pHead;
157	};
158	OSDefineMetaClassAndStructors(org_virtualbox_VBoxUSBClient, IOUserClient);
159
160
161	/**
162	* The IOUSBDevice driver class.
163	*
164	* The main purpose of this is hijack devices matching current filters.
165	*
166	* @remarks This is derived from IOUSBUserClientInit instead of IOService because we must make
167	* sure IOUSBUserClientInit::start() gets invoked for this provider. The problem is that
168	* there is some kind of magic that prevents this from happening if we boost the probe
169	* score to high. With the result that we don't have the required plugin entry for
170	* user land and consequently cannot open it.
171	*
172	* So, to avoid having to write a lot of code we just inherit from IOUSBUserClientInit
173	* and make some possibly bold assumptions about it not changing. This just means
174	* we'll have to keep an eye on the source apple releases or only call
175	* IOUSBUserClientInit::start() and hand the rest of the super calls to IOService. For
176	* now we're doing it by the C++ book.
177	*/
178	class org_virtualbox_VBoxUSBDevice : public IOUSBUserClientInit
179	{
180	OSDeclareDefaultStructors(org_virtualbox_VBoxUSBDevice);
181
182	public:
183	/** @name IOService
184	* @{ */
185	virtual bool init(OSDictionary *pDictionary = 0);
186	virtual IOService probe(IOService pProvider, SInt32 *pi32Score);
187	virtual bool start(IOService *pProvider);
188	virtual bool terminate(IOOptionBits fOptions = 0);
189	virtual void stop(IOService *pProvider);
190	virtual void free();
191	virtual IOReturn message(UInt32 enmMsg, IOService pProvider, void pvArg = 0);
192	/** @} */
193
194	static void scheduleReleaseByOwner(RTPROCESS Owner);
195	private:
196	/** The interface we're driving (aka. the provider). */
197	IOUSBDevice *m_pDevice;
198	/** The owner process, meaning the VBoxSVC process. */
199	RTPROCESS volatile m_Owner;
200	/** The client process, meaning the VM process. */
201	RTPROCESS volatile m_Client;
202	/** The ID of the matching filter. */
203	uintptr_t m_uId;
204	/** Have we opened the device or not? */
205	bool volatile m_fOpen;
206	/** Should be open the device on the next close notification message? */
207	bool volatile m_fOpenOnWasClosed;
208	/** Whether to re-enumerate this device when the client closes it.
209	* This is something we'll do when the filter owner dies. */
210	bool volatile m_fReleaseOnClose;
211	/** Whether we're being unloaded or not.
212	* Only valid in stop(). */
213	bool m_fBeingUnloaded;
214	/** Pointer to the next device in the list. */
215	org_virtualbox_VBoxUSBDevice * volatile m_pNext;
216	/** Pointer to the list head. Protected by g_Mtx. */
217	static org_virtualbox_VBoxUSBDevice * volatile s_pHead;
218
219	#ifdef DEBUG
220	/** The interest notifier. */
221	IONotifier *m_pNotifier;
222
223	static IOReturn MyInterestHandler(void pvTarget, void pvRefCon, UInt32 enmMsgType,
224	IOService pProvider, void pvMsgArg, vm_size_t cbMsgArg);
225	#endif
226	};
227	OSDefineMetaClassAndStructors(org_virtualbox_VBoxUSBDevice, IOUSBUserClientInit);
228
229
230	/**
231	* The IOUSBInterface driver class.
232	*
233	* The main purpose of this is hijack interfaces which device is driven
234	* by org_virtualbox_VBoxUSBDevice.
235	*
236	* @remarks See org_virtualbox_VBoxUSBDevice for why we use IOUSBUserClientInit.
237	*/
238	class org_virtualbox_VBoxUSBInterface : public IOUSBUserClientInit
239	{
240	OSDeclareDefaultStructors(org_virtualbox_VBoxUSBInterface);
241
242	public:
243	/** @name IOService
244	* @{ */
245	virtual bool init(OSDictionary *pDictionary = 0);
246	virtual IOService probe(IOService pProvider, SInt32 *pi32Score);
247	virtual bool start(IOService *pProvider);
248	virtual bool terminate(IOOptionBits fOptions = 0);
249	virtual void stop(IOService *pProvider);
250	virtual void free();
251	virtual IOReturn message(UInt32 enmMsg, IOService pProvider, void pvArg = 0);
252	/** @} */
253
254	private:
255	/** The interface we're driving (aka. the provider). */
256	IOUSBInterface *m_pInterface;
257	/** Have we opened the device or not? */
258	bool volatile m_fOpen;
259	/** Should be open the device on the next close notification message? */
260	bool volatile m_fOpenOnWasClosed;
261	};
262	OSDefineMetaClassAndStructors(org_virtualbox_VBoxUSBInterface, IOUSBUserClientInit);
263
264
265
266
267
268	/*******************************************************************************
269	* Global Variables *
270	*******************************************************************************/
271	/*
272	* Declare the module stuff.
273	*/
274	RT_C_DECLS_BEGIN
275	extern kern_return_t _start(struct kmod_info pKModInfo, void pvData);
276	extern kern_return_t _stop(struct kmod_info pKModInfo, void pvData);
277
278	KMOD_EXPLICIT_DECL(VBoxDrv, VBOX_VERSION_STRING, _start, _stop)
279	DECLHIDDEN(kmod_start_func_t *) _realmain = VBoxUSBStart;
280	DECLHIDDEN(kmod_stop_func_t *) _antimain = VBoxUSBStop;
281	DECLHIDDEN(int) _kext_apple_cc = __APPLE_CC__;
282	RT_C_DECLS_END
283
284	/** Mutex protecting the lists. */
285	static RTSEMFASTMUTEX g_Mtx = NIL_RTSEMFASTMUTEX;
286	org_virtualbox_VBoxUSBClient * volatile org_virtualbox_VBoxUSBClient::s_pHead = NULL;
287	org_virtualbox_VBoxUSBDevice * volatile org_virtualbox_VBoxUSBDevice::s_pHead = NULL;
288
289	/** Global instance count - just for checking proving that everything is destroyed correctly. */
290	static volatile uint32_t g_cInstances = 0;
291
292
293	/**
294	* Start the kernel module.
295	*/
296	static kern_return_t VBoxUSBStart(struct kmod_info pKModInfo, void pvData)
297	{
298	int rc;
299	Log(("VBoxUSBStart\n"));
300
301	/*
302	* Initialize IPRT.
303	*/
304	rc = RTR0Init(0);
305	if (RT_SUCCESS(rc))
306	{
307	/*
308	* Create the spinlock.
309	*/
310	rc = RTSemFastMutexCreate(&g_Mtx);
311	if (RT_SUCCESS(rc))
312	{
313	rc = VBoxUSBFilterInit();
314	if (RT_SUCCESS(rc))
315	{
316	#if 0 /* testing */
317	USBFILTER Flt;
318	USBFilterInit(&Flt, USBFILTERTYPE_CAPTURE);
319	USBFilterSetNumExact(&Flt, USBFILTERIDX_VENDOR_ID, 0x096e, true);
320	uintptr_t uId;
321	rc = VBoxUSBFilterAdd(&Flt, 1, &uId);
322	printf("VBoxUSB: VBoxUSBFilterAdd #1 -> %d + %p\n", rc, uId);
323
324	USBFilterInit(&Flt, USBFILTERTYPE_CAPTURE);
325	USBFilterSetStringPattern(&Flt, USBFILTERIDX_PRODUCT_STR, "DISK", true);
326	rc = VBoxUSBFilterAdd(&Flt, 2, &uId);
327	printf("VBoxUSB: VBoxUSBFilterAdd #2 -> %d + %p\n", rc, uId);
328	#endif
329	return KMOD_RETURN_SUCCESS;
330	}
331	printf("VBoxUSB: VBoxUSBFilterInit failed (rc=%d)\n", rc);
332	RTSemFastMutexDestroy(g_Mtx);
333	g_Mtx = NIL_RTSEMFASTMUTEX;
334	}
335	else
336	printf("VBoxUSB: RTSemFastMutexCreate failed (rc=%d)\n", rc);
337	RTR0Term();
338	}
339	else
340	printf("VBoxUSB: failed to initialize IPRT (rc=%d)\n", rc);
341
342	return KMOD_RETURN_FAILURE;
343	}
344
345
346	/**
347	* Stop the kernel module.
348	*/
349	static kern_return_t VBoxUSBStop(struct kmod_info pKModInfo, void pvData)
350	{
351	int rc;
352	Log(("VBoxUSBStop: g_cInstances=%d\n", g_cInstances));
353
354	/** @todo Fix problem with crashing when unloading a driver that's in use. */
355
356	/*
357	* Undo the work done during start (in reverse order).
358	*/
359	VBoxUSBFilterTerm();
360
361	rc = RTSemFastMutexDestroy(g_Mtx);
362	AssertRC(rc);
363	g_Mtx = NIL_RTSEMFASTMUTEX;
364
365	RTR0Term();
366
367	Log(("VBoxUSBStop - done\n"));
368	return KMOD_RETURN_SUCCESS;
369	}
370
371
372
373
374
375
376	/**
377	* Gets the name of a IOKit message.
378	*
379	* @returns Message name (read only).
380	* @param enmMsg The message.
381	*/
382	DECLINLINE(const char *) DbgGetIOKitMessageName(UInt32 enmMsg)
383	{
384	#ifdef DEBUG
385	switch (enmMsg)
386	{
387	#define MY_CASE(enm) case enm: return #enm; break
388	MY_CASE(kIOMessageServiceIsTerminated);
389	MY_CASE(kIOMessageServiceIsSuspended);
390	MY_CASE(kIOMessageServiceIsResumed);
391	MY_CASE(kIOMessageServiceIsRequestingClose);
392	MY_CASE(kIOMessageServiceIsAttemptingOpen);
393	MY_CASE(kIOMessageServiceWasClosed);
394	MY_CASE(kIOMessageServiceBusyStateChange);
395	MY_CASE(kIOMessageServicePropertyChange);
396	MY_CASE(kIOMessageCanDevicePowerOff);
397	MY_CASE(kIOMessageDeviceWillPowerOff);
398	MY_CASE(kIOMessageDeviceWillNotPowerOff);
399	MY_CASE(kIOMessageDeviceHasPoweredOn);
400	MY_CASE(kIOMessageCanSystemPowerOff);
401	MY_CASE(kIOMessageSystemWillPowerOff);
402	MY_CASE(kIOMessageSystemWillNotPowerOff);
403	MY_CASE(kIOMessageCanSystemSleep);
404	MY_CASE(kIOMessageSystemWillSleep);
405	MY_CASE(kIOMessageSystemWillNotSleep);
406	MY_CASE(kIOMessageSystemHasPoweredOn);
407	MY_CASE(kIOMessageSystemWillRestart);
408	MY_CASE(kIOMessageSystemWillPowerOn);
409	MY_CASE(kIOUSBMessageHubResetPort);
410	MY_CASE(kIOUSBMessageHubSuspendPort);
411	MY_CASE(kIOUSBMessageHubResumePort);
412	MY_CASE(kIOUSBMessageHubIsDeviceConnected);
413	MY_CASE(kIOUSBMessageHubIsPortEnabled);
414	MY_CASE(kIOUSBMessageHubReEnumeratePort);
415	MY_CASE(kIOUSBMessagePortHasBeenReset);
416	MY_CASE(kIOUSBMessagePortHasBeenResumed);
417	MY_CASE(kIOUSBMessageHubPortClearTT);
418	MY_CASE(kIOUSBMessagePortHasBeenSuspended);
419	MY_CASE(kIOUSBMessageFromThirdParty);
420	MY_CASE(kIOUSBMessagePortWasNotSuspended);
421	MY_CASE(kIOUSBMessageExpressCardCantWake);
422	// MY_CASE(kIOUSBMessageCompositeDriverReconfigured);
423	#undef MY_CASE
424	}
425	#endif /* DEBUG */
426	return "unknown";
427	}
428
429
430
431
432
433	/*
434	*
435	* org_virtualbox_VBoxUSB
436	*
437	*/
438
439
440	/**
441	* Initialize the object.
442	* @remark Only for logging.
443	*/
444	bool
445	org_virtualbox_VBoxUSB::init(OSDictionary *pDictionary)
446	{
447	uint32_t cInstances = ASMAtomicIncU32(&g_cInstances);
448	Log(("VBoxUSB::init([%p], %p) new g_cInstances=%d\n", this, pDictionary, cInstances));
449	if (IOService::init(pDictionary))
450	{
451	/* init members. */
452	return true;
453	}
454	ASMAtomicDecU32(&g_cInstances);
455	return false;
456	}
457
458
459	/**
460	* Free the object.
461	* @remark Only for logging.
462	*/
463	void
464	org_virtualbox_VBoxUSB::free()
465	{
466	uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances);
467	Log(("VBoxUSB::free([%p]) new g_cInstances=%d\n", this, cInstances));
468	IOService::free();
469	}
470
471
472	/**
473	* Start this service.
474	*/
475	bool
476	org_virtualbox_VBoxUSB::start(IOService *pProvider)
477	{
478	Log(("VBoxUSB::start([%p], %p {%s})\n", this, pProvider, pProvider->getName()));
479
480	if (IOService::start(pProvider))
481	{
482	/* register the service. */
483	registerService();
484	return true;
485	}
486	return false;
487	}
488
489
490	/**
491	* Stop this service.
492	* @remark Only for logging.
493	*/
494	void
495	org_virtualbox_VBoxUSB::stop(IOService *pProvider)
496	{
497	Log(("VBoxUSB::stop([%p], %p (%s))\n", this, pProvider, pProvider->getName()));
498	IOService::stop(pProvider);
499	}
500
501
502	/**
503	* Stop this service.
504	* @remark Only for logging.
505	*/
506	bool
507	org_virtualbox_VBoxUSB::open(IOService pForClient, IOOptionBits fOptions/ = 0/, void pvArg/* = 0*/)
508	{
509	Log(("VBoxUSB::open([%p], %p, %#x, %p)\n", this, pForClient, fOptions, pvArg));
510	bool fRc = IOService::open(pForClient, fOptions, pvArg);
511	Log(("VBoxUSB::open([%p], %p, %#x, %p) -> %d\n", this, pForClient, fOptions, pvArg, fRc));
512	return fRc;
513	}
514
515
516	/**
517	* Stop this service.
518	* @remark Only for logging.
519	*/
520	void
521	org_virtualbox_VBoxUSB::close(IOService pForClient, IOOptionBits fOptions/ = 0*/)
522	{
523	Log(("VBoxUSB::close([%p], %p, %#x)\n", this, pForClient, fOptions));
524	IOService::close(pForClient, fOptions);
525	}
526
527
528	/**
529	* Terminate request.
530	* @remark Only for logging.
531	*/
532	bool
533	org_virtualbox_VBoxUSB::terminate(IOOptionBits fOptions)
534	{
535	Log(("VBoxUSB::terminate([%p], %#x): g_cInstances=%d\n", this, fOptions, g_cInstances));
536	bool fRc = IOService::terminate(fOptions);
537	Log(("VBoxUSB::terminate([%p], %#x): returns %d\n", this, fOptions, fRc));
538	return fRc;
539	}
540
541
542
543
544
545
546
547
548
549
550
551	/*
552	*
553	* org_virtualbox_VBoxUSBClient
554	*
555	*/
556
557
558	/**
559	* Initializer called when the client opens the service.
560	*/
561	bool
562	org_virtualbox_VBoxUSBClient::initWithTask(task_t OwningTask, void *pvSecurityId, UInt32 u32Type)
563	{
564	if (!OwningTask)
565	{
566	Log(("VBoxUSBClient::initWithTask([%p], %p, %p, %#x) -> false (no task)\n", this, OwningTask, pvSecurityId, u32Type));
567	return false;
568	}
569	proc_t pProc = (proc_t)get_bsdtask_info(OwningTask); /* we need the pid */
570	Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x)\n",
571	this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type));
572
573	if (IOUserClient::initWithTask(OwningTask, pvSecurityId , u32Type))
574	{
575	m_pProvider = NULL;
576	m_Task = OwningTask;
577	m_Process = pProc ? proc_pid(pProc) : NIL_RTPROCESS;
578	m_pNext = NULL;
579
580	uint32_t cInstances = ASMAtomicIncU32(&g_cInstances);
581	Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x) -> true; new g_cInstances=%d\n",
582	this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type, cInstances));
583	return true;
584	}
585
586	Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x) -> false\n",
587	this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type));
588	return false;
589	}
590
591
592	/**
593	* Free the object.
594	* @remark Only for logging.
595	*/
596	void
597	org_virtualbox_VBoxUSBClient::free()
598	{
599	uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances);
600	Log(("VBoxUSBClient::free([%p]) new g_cInstances=%d\n", this, cInstances));
601	IOService::free();
602	}
603
604
605	/**
606	* Start the client service.
607	*/
608	bool
609	org_virtualbox_VBoxUSBClient::start(IOService *pProvider)
610	{
611	Log(("VBoxUSBClient::start([%p], %p)\n", this, pProvider));
612	if (IOUserClient::start(pProvider))
613	{
614	m_pProvider = OSDynamicCast(org_virtualbox_VBoxUSB, pProvider);
615	if (m_pProvider)
616	{
617	/*
618	* Add ourselves to the list of user clients.
619	*/
620	VBOXUSB_LOCK();
621
622	m_pNext = s_pHead;
623	s_pHead = this;
624
625	VBOXUSB_UNLOCK();
626
627	return true;
628	}
629	Log(("VBoxUSBClient::start: %p isn't org_virtualbox_VBoxUSB\n", pProvider));
630	}
631	return false;
632	}
633
634
635	/**
636	* Client exits normally.
637	*/
638	IOReturn
639	org_virtualbox_VBoxUSBClient::clientClose(void)
640	{
641	Log(("VBoxUSBClient::clientClose([%p:{.m_Process=%d}])\n", this, (int)m_Process));
642
643	/*
644	* Remove this process from the client list.
645	*/
646	VBOXUSB_LOCK();
647
648	org_virtualbox_VBoxUSBClient *pPrev = NULL;
649	for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext)
650	{
651	if (pCur == this)
652	{
653	if (pPrev)
654	pPrev->m_pNext = m_pNext;
655	else
656	s_pHead = m_pNext;
657	m_pNext = NULL;
658	break;
659	}
660	pPrev = pCur;
661	}
662
663	VBOXUSB_UNLOCK();
664
665	/*
666	* Drop all filters owned by this client.
667	*/
668	if (m_Process != NIL_RTPROCESS)
669	VBoxUSBFilterRemoveOwner(m_Process);
670
671	/*
672	* Schedule all devices owned (filtered) by this process for
673	* immediate release or release upon close.
674	*/
675	if (m_Process != NIL_RTPROCESS)
676	org_virtualbox_VBoxUSBDevice::scheduleReleaseByOwner(m_Process);
677
678	/*
679	* Initiate termination.
680	*/
681	m_pProvider = NULL;
682	terminate();
683
684	return kIOReturnSuccess;
685	}
686
687
688	/**
689	* The client exits abnormally / forgets to do cleanups.
690	* @remark Only for logging.
691	*/
692	IOReturn
693	org_virtualbox_VBoxUSBClient::clientDied(void)
694	{
695	Log(("VBoxUSBClient::clientDied([%p]) m_Task=%p R0Process=%p Process=%d\n",
696	this, m_Task, RTR0ProcHandleSelf(), RTProcSelf()));
697
698	/* IOUserClient::clientDied() calls clientClose... */
699	return IOUserClient::clientDied();
700	}
701
702
703	/**
704	* Terminate the service (initiate the destruction).
705	* @remark Only for logging.
706	*/
707	bool
708	org_virtualbox_VBoxUSBClient::terminate(IOOptionBits fOptions)
709	{
710	/* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */
711	Log(("VBoxUSBClient::terminate([%p], %#x)\n", this, fOptions));
712	return IOUserClient::terminate(fOptions);
713	}
714
715
716	/**
717	* The final stage of the client service destruction.
718	* @remark Only for logging.
719	*/
720	bool
721	org_virtualbox_VBoxUSBClient::finalize(IOOptionBits fOptions)
722	{
723	Log(("VBoxUSBClient::finalize([%p], %#x)\n", this, fOptions));
724	return IOUserClient::finalize(fOptions);
725	}
726
727
728	/**
729	* Stop the client service.
730	*/
731	void
732	org_virtualbox_VBoxUSBClient::stop(IOService *pProvider)
733	{
734	Log(("VBoxUSBClient::stop([%p])\n", this));
735	IOUserClient::stop(pProvider);
736
737	/*
738	* Paranoia.
739	*/
740	VBOXUSB_LOCK();
741
742	org_virtualbox_VBoxUSBClient *pPrev = NULL;
743	for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext)
744	{
745	if (pCur == this)
746	{
747	if (pPrev)
748	pPrev->m_pNext = m_pNext;
749	else
750	s_pHead = m_pNext;
751	m_pNext = NULL;
752	break;
753	}
754	pPrev = pCur;
755	}
756
757	VBOXUSB_UNLOCK();
758	}
759
760
761	/**
762	* Translate a user method index into a service object and an external method structure.
763	*
764	* @returns Pointer to external method structure descripting the method.
765	* NULL if the index isn't valid.
766	* @param ppService Where to store the service object on success.
767	* @param iMethod The method index.
768	*/
769	IOExternalMethod *
770	org_virtualbox_VBoxUSBClient::getTargetAndMethodForIndex(IOService **ppService, UInt32 iMethod)
771	{
772	static IOExternalMethod s_aMethods[VBOXUSBMETHOD_END] =
773	{
774	/[VBOXUSBMETHOD_ADD_FILTER] = /
775	{
776	(IOService )0, / object */
777	(IOMethod)&org_virtualbox_VBoxUSBClient::addFilter, /* func */
778	kIOUCStructIStructO, /* flags - struct input (count0) and struct output (count1) */
779	sizeof(USBFILTER), /* count0 - size of the input struct. */
780	sizeof(VBOXUSBADDFILTEROUT) /* count1 - size of the return struct. */
781	},
782	/* [VBOXUSBMETHOD_FILTER_REMOVE] = */
783	{
784	(IOService )0, / object */
785	(IOMethod)&org_virtualbox_VBoxUSBClient::removeFilter, /* func */
786	kIOUCStructIStructO, /* flags - struct input (count0) and struct output (count1) */
787	sizeof(uintptr_t), /* count0 - size of the input (id) */
788	sizeof(int) /* count1 - size of the output (rc) */
789	},
790	};
791
792	if (RT_UNLIKELY(iMethod >= RT_ELEMENTS(s_aMethods)))
793	return NULL;
794
795	*ppService = this;
796	return &s_aMethods[iMethod];
797	}
798
799
800	/**
801	* Add filter user request.
802	*
803	* @returns IOKit status code.
804	* @param pFilter The filter to add.
805	* @param pOut Pointer to the output structure.
806	* @param cbFilter Size of the filter structure.
807	* @param pcbOut In/Out - sizeof(*pOut).
808	*/
809	IOReturn
810	org_virtualbox_VBoxUSBClient::addFilter(PUSBFILTER pFilter, PVBOXUSBADDFILTEROUT pOut, IOByteCount cbFilter, IOByteCount *pcbOut)
811	{
812	Log(("VBoxUSBClient::addFilter: [%p:{.m_Process=%d}] pFilter=%p pOut=%p\n", this, (int)m_Process, pFilter, pOut));
813
814	/*
815	* Validate input.
816	*/
817	if (RT_UNLIKELY( cbFilter != sizeof(*pFilter)
818	\|\| pcbOut != sizeof(pOut)))
819	{
820	printf("VBoxUSBClient::addFilter: cbFilter=%#x expected %#x; *pcbOut=%#x expected %#x\n",
821	(int)cbFilter, (int)sizeof(pFilter), (int)pcbOut, (int)sizeof(*pOut));
822	return kIOReturnBadArgument;
823	}
824
825	/*
826	* Log the filter details.
827	*/
828	#ifdef DEBUG
829	Log2(("VBoxUSBClient::addFilter: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
830	USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID),
831	USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID),
832	USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_REV),
833	USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_CLASS),
834	USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_SUB_CLASS),
835	USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_PROTOCOL),
836	USBFilterGetNum(pFilter, USBFILTERIDX_BUS),
837	USBFilterGetNum(pFilter, USBFILTERIDX_PORT)));
838	Log2(("VBoxUSBClient::addFilter: Manufacturer=%s Product=%s Serial=%s\n",
839	USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) : "<null>",
840	USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) : "<null>",
841	USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>"));
842	#endif
843
844	/*
845	* Since we cannot query the bus number, make sure the filter
846	* isn't requiring that field to be present.
847	*/
848	int rc = USBFilterSetMustBePresent(pFilter, USBFILTERIDX_BUS, false /* fMustBePresent */); AssertRC(rc);
849
850	/*
851	* Add the filter.
852	*/
853	pOut->uId = 0;
854	pOut->rc = VBoxUSBFilterAdd(pFilter, m_Process, &pOut->uId);
855
856	Log(("VBoxUSBClient::addFilter: returns pOut={.rc=%d, .uId=%p}\n", pOut->rc, (void )pOut->uId));
857	return kIOReturnSuccess;
858	}
859
860
861	/**
862	* Removes filter user request.
863	*
864	* @returns IOKit status code.
865	* @param puId Where to get the filter ID.
866	* @param prc Where to store the return code.
867	* @param cbIn sizeof(*puId).
868	* @param pcbOut In/Out - sizeof(*prc).
869	*/
870	IOReturn
871	org_virtualbox_VBoxUSBClient::removeFilter(uintptr_t puId, int prc, IOByteCount cbIn, IOByteCount *pcbOut)
872	{
873	Log(("VBoxUSBClient::removeFilter: [%p:{.m_Process=%d}] puId=%p m_Proc\n", this, (int)m_Process, puId));
874
875	/*
876	* Validate input.
877	*/
878	if (RT_UNLIKELY( cbIn != sizeof(*puId)
879	\|\| pcbOut != sizeof(prc)))
880	{
881	printf("VBoxUSBClient::removeFilter: cbIn=%#x expected %#x; *pcbOut=%#x expected %#x\n",
882	(int)cbIn, (int)sizeof(puId), (int)pcbOut, (int)sizeof(*prc));
883	return kIOReturnBadArgument;
884	}
885
886	/*
887	* Remove the filter.
888	*/
889	prc = VBoxUSBFilterRemove(m_Process, puId);
890
891	Log(("VBoxUSBClient::removeFilter: returns prc=%d\n", prc));
892	return kIOReturnSuccess;
893	}
894
895
896	/**
897	* Checks whether the specified task is a VBoxUSB client task or not.
898	*
899	* This is used to validate clients trying to open any of the device
900	* or interfaces that we've hijacked.
901	*
902	* @returns true / false.
903	* @param ClientTask The task.
904	*
905	* @remark This protecting against other user clients is not currently implemented
906	* as it turned out to be more bothersome than first imagined.
907	*/
908	/* static*/ bool
909	org_virtualbox_VBoxUSBClient::isClientTask(task_t ClientTask)
910	{
911	VBOXUSB_LOCK();
912
913	for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext)
914	if (pCur->m_Task == ClientTask)
915	{
916	VBOXUSB_UNLOCK();
917	return true;
918	}
919
920	VBOXUSB_UNLOCK();
921	return false;
922	}
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937	/*
938	*
939	* org_virtualbox_VBoxUSBDevice
940	*
941	*/
942
943	/**
944	* Initialize instance data.
945	*
946	* @returns Success indicator.
947	* @param pDictionary The dictionary that will become the registry entry's
948	* property table, or NULL. Hand it up to our parents.
949	*/
950	bool
951	org_virtualbox_VBoxUSBDevice::init(OSDictionary *pDictionary)
952	{
953	uint32_t cInstances = ASMAtomicIncU32(&g_cInstances);
954	Log(("VBoxUSBDevice::init([%p], %p) new g_cInstances=%d\n", this, pDictionary, cInstances));
955
956	m_pDevice = NULL;
957	m_Owner = NIL_RTPROCESS;
958	m_Client = NIL_RTPROCESS;
959	m_uId = ~(uintptr_t)0;
960	m_fOpen = false;
961	m_fOpenOnWasClosed = false;
962	m_fReleaseOnClose = false;
963	m_fBeingUnloaded = false;
964	m_pNext = NULL;
965	#ifdef DEBUG
966	m_pNotifier = NULL;
967	#endif
968
969	return IOUSBUserClientInit::init(pDictionary);
970	}
971
972	/**
973	* Free the object.
974	* @remark Only for logging.
975	*/
976	void
977	org_virtualbox_VBoxUSBDevice::free()
978	{
979	uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances);
980	Log(("VBoxUSBDevice::free([%p]) new g_cInstances=%d\n", this, cInstances));
981	IOUSBUserClientInit::free();
982	}
983
984
985	/**
986	* The device/driver probing.
987	*
988	* I/O Kit will iterate all device drivers suitable for this kind of device
989	* (this is something it figures out from the property file) and call their
990	* probe() method in order to try determine which is the best match for the
991	* device. We will match the device against the registered filters and set
992	* a ridiculously high score if we find it, thus making it extremely likely
993	* that we'll be the first driver to be started. We'll also set a couple of
994	* attributes so that it's not necessary to do a rematch in init to find
995	* the appropriate filter (might not be necessary..., see todo).
996	*
997	* @returns Service instance to be started and *pi32Score if matching.
998	* NULL if not a device suitable for this driver.
999	*
1000	* @param pProvider The provider instance.
1001	* @param pi32Score Where to store the probe score.
1002	*/
1003	IOService *
1004	org_virtualbox_VBoxUSBDevice::probe(IOService pProvider, SInt32 pi32Score)
1005	{
1006	Log(("VBoxUSBDevice::probe([%p], %p {%s}, %p={%d})\n", this,
1007	pProvider, pProvider->getName(), pi32Score, pi32Score ? *pi32Score : 0));
1008
1009	/*
1010	* Check against filters.
1011	*/
1012	USBFILTER Device;
1013	USBFilterInit(&Device, USBFILTERTYPE_CAPTURE);
1014
1015	static const struct
1016	{
1017	const char *pszName;
1018	USBFILTERIDX enmIdx;
1019	bool fNumeric;
1020	} s_aProps[] =
1021	{
1022	{ kUSBVendorID, USBFILTERIDX_VENDOR_ID, true },
1023	{ kUSBProductID, USBFILTERIDX_PRODUCT_ID, true },
1024	{ kUSBDeviceReleaseNumber, USBFILTERIDX_DEVICE_REV, true },
1025	{ kUSBDeviceClass, USBFILTERIDX_DEVICE_CLASS, true },
1026	{ kUSBDeviceSubClass, USBFILTERIDX_DEVICE_SUB_CLASS, true },
1027	{ kUSBDeviceProtocol, USBFILTERIDX_DEVICE_PROTOCOL, true },
1028	{ "PortNum", USBFILTERIDX_PORT, true },
1029	/// @todo { , USBFILTERIDX_BUS, true }, - must be derived :-/
1030	/// Seems to be the upper byte of locationID and our "grand parent" has a USBBusNumber prop.
1031	{ "USB Vendor Name", USBFILTERIDX_MANUFACTURER_STR, false },
1032	{ "USB Product Name", USBFILTERIDX_PRODUCT_STR, false },
1033	{ "USB Serial Number", USBFILTERIDX_SERIAL_NUMBER_STR, false },
1034	};
1035	for (unsigned i = 0; i < RT_ELEMENTS(s_aProps); i++)
1036	{
1037	OSObject *pObj = pProvider->getProperty(s_aProps[i].pszName);
1038	if (!pObj)
1039	continue;
1040	if (s_aProps[i].fNumeric)
1041	{
1042	OSNumber *pNum = OSDynamicCast(OSNumber, pObj);
1043	if (pNum)
1044	{
1045	uint16_t u16 = pNum->unsigned16BitValue();
1046	Log2(("VBoxUSBDevice::probe: %d/%s - %#x (32bit=%#x)\n", i, s_aProps[i].pszName, u16, pNum->unsigned32BitValue()));
1047	int vrc = USBFilterSetNumExact(&Device, s_aProps[i].enmIdx, u16, true);
1048	if (RT_FAILURE(vrc))
1049	Log(("VBoxUSBDevice::probe: pObj=%p pNum=%p - %d/%s - rc=%d!\n", pObj, pNum, i, s_aProps[i].pszName, vrc));
1050	}
1051	else
1052	Log(("VBoxUSBDevice::probe: pObj=%p pNum=%p - %d/%s!\n", pObj, pNum, i, s_aProps[i].pszName));
1053	}
1054	else
1055	{
1056	OSString *pStr = OSDynamicCast(OSString, pObj);
1057	if (pStr)
1058	{
1059	Log2(("VBoxUSBDevice::probe: %d/%s - %s\n", i, s_aProps[i].pszName, pStr->getCStringNoCopy()));
1060	int vrc = USBFilterSetStringExact(&Device, s_aProps[i].enmIdx, pStr->getCStringNoCopy(), true);
1061	if (RT_FAILURE(vrc))
1062	Log(("VBoxUSBDevice::probe: pObj=%p pStr=%p - %d/%s - rc=%d!\n", pObj, pStr, i, s_aProps[i].pszName, vrc));
1063	}
1064	else
1065	Log(("VBoxUSBDevice::probe: pObj=%p pStr=%p - %d/%s\n", pObj, pStr, i, s_aProps[i].pszName));
1066	}
1067	}
1068	/** @todo try figure the blasted bus number */
1069
1070	/*
1071	* Run filters on it.
1072	*/
1073	uintptr_t uId = 0;
1074	RTPROCESS Owner = VBoxUSBFilterMatch(&Device, &uId);
1075	USBFilterDelete(&Device);
1076	if (Owner == NIL_RTPROCESS)
1077	{
1078	Log(("VBoxUSBDevice::probe: returns NULL uId=%d\n", uId));
1079	return NULL;
1080	}
1081
1082	/*
1083	* It matched. Save the owner in the provider registry (hope that works).
1084	*/
1085	IOService *pRet = IOUSBUserClientInit::probe(pProvider, pi32Score);
1086	Assert(pRet == this);
1087	m_Owner = Owner;
1088	m_uId = uId;
1089	Log(("%p: m_Owner=%d m_uId=%d\n", this, (int)m_Owner, (int)m_uId));
1090	*pi32Score = _1G;
1091	Log(("VBoxUSBDevice::probe: returns %p and pi32Score=%d\n", pRet, pi32Score));
1092	return pRet;
1093	}
1094
1095
1096	/**
1097	* Try start the device driver.
1098	*
1099	* We will do device linking, copy the filter and owner properties from the provider,
1100	* set the client property, retain the device, and try open (seize) the device.
1101	*
1102	* @returns Success indicator.
1103	* @param pProvider The provider instance.
1104	*/
1105	bool
1106	org_virtualbox_VBoxUSBDevice::start(IOService *pProvider)
1107	{
1108	Log(("VBoxUSBDevice::start([%p:{.m_Owner=%d, .m_uId=%p}], %p {%s})\n",
1109	this, m_Owner, m_uId, pProvider, pProvider->getName()));
1110
1111	m_pDevice = OSDynamicCast(IOUSBDevice, pProvider);
1112	if (!m_pDevice)
1113	{
1114	printf("VBoxUSBDevice::start([%p], %p {%s}): failed!\n", this, pProvider, pProvider->getName());
1115	return false;
1116	}
1117
1118	#ifdef DEBUG
1119	/* for some extra log messages */
1120	m_pNotifier = pProvider->registerInterest(gIOGeneralInterest,
1121	&org_virtualbox_VBoxUSBDevice::MyInterestHandler,
1122	this, /* pvTarget */
1123	NULL); /* pvRefCon */
1124	#endif
1125
1126	/*
1127	* Exploit IOUSBUserClientInit to process IOProviderMergeProperties.
1128	*/
1129	IOUSBUserClientInit::start(pProvider); /* returns false */
1130
1131	/*
1132	* Link ourselves into the list of hijacked device.
1133	*/
1134	VBOXUSB_LOCK();
1135
1136	m_pNext = s_pHead;
1137	s_pHead = this;
1138
1139	VBOXUSB_UNLOCK();
1140
1141	/*
1142	* Set the VBoxUSB properties.
1143	*/
1144	if (!setProperty(VBOXUSB_OWNER_KEY, (unsigned long long)m_Owner, sizeof(m_Owner) * 8 /* bits */))
1145	Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_OWNER_KEY "' property!\n"));
1146	if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */))
1147	Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n"));
1148	if (!setProperty(VBOXUSB_FILTER_KEY, (unsigned long long)m_uId, sizeof(m_uId) * 8 /* bits */))
1149	Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_FILTER_KEY "' property!\n"));
1150
1151	/*
1152	* Retain and open the device.
1153	*/
1154	m_pDevice->retain();
1155	m_fOpen = m_pDevice->open(this, kIOServiceSeize, 0);
1156	if (!m_fOpen)
1157	Log(("VBoxUSBDevice::start: failed to open the device!\n"));
1158	m_fOpenOnWasClosed = !m_fOpen;
1159
1160	Log(("VBoxUSBDevice::start: returns %d\n", true));
1161	return true;
1162	}
1163
1164
1165	/**
1166	* Stop the device driver.
1167	*
1168	* We'll unlink the device, start device re-enumeration and close it. And call
1169	* the parent stop method of course.
1170	*
1171	* @param pProvider The provider instance.
1172	*/
1173	void
1174	org_virtualbox_VBoxUSBDevice::stop(IOService *pProvider)
1175	{
1176	Log(("VBoxUSBDevice::stop([%p], %p {%s})\n", this, pProvider, pProvider->getName()));
1177
1178	/*
1179	* Remove ourselves from the list of device.
1180	*/
1181	VBOXUSB_LOCK();
1182
1183	org_virtualbox_VBoxUSBDevice *pPrev = NULL;
1184	for (org_virtualbox_VBoxUSBDevice *pCur = s_pHead; pCur; pCur = pCur->m_pNext)
1185	{
1186	if (pCur == this)
1187	{
1188	if (pPrev)
1189	pPrev->m_pNext = m_pNext;
1190	else
1191	s_pHead = m_pNext;
1192	m_pNext = NULL;
1193	break;
1194	}
1195	pPrev = pCur;
1196	}
1197
1198	VBOXUSB_UNLOCK();
1199
1200	/*
1201	* Should we release the device?
1202	*/
1203	if (m_fBeingUnloaded)
1204	{
1205	if (m_pDevice)
1206	{
1207	IOReturn irc = m_pDevice->ReEnumerateDevice(0); NOREF(irc);
1208	Log(("VBoxUSBDevice::stop([%p], %p {%s}): m_pDevice=%p unload & ReEnumerateDevice -> %#x\n",
1209	this, pProvider, pProvider->getName(), m_pDevice, irc));
1210	}
1211	else
1212	{
1213	IOUSBDevice *pDevice = OSDynamicCast(IOUSBDevice, pProvider);
1214	if (pDevice)
1215	{
1216	IOReturn irc = pDevice->ReEnumerateDevice(0); NOREF(irc);
1217	Log(("VBoxUSBDevice::stop([%p], %p {%s}): pDevice=%p unload & ReEnumerateDevice -> %#x\n",
1218	this, pProvider, pProvider->getName(), pDevice, irc));
1219	}
1220	else
1221	Log(("VBoxUSBDevice::stop([%p], %p {%s}): failed to cast provider to IOUSBDevice\n",
1222	this, pProvider, pProvider->getName()));
1223	}
1224	}
1225	else if (m_fReleaseOnClose)
1226	{
1227	ASMAtomicWriteBool(&m_fReleaseOnClose, false);
1228	if (m_pDevice)
1229	{
1230	IOReturn irc = m_pDevice->ReEnumerateDevice(0); NOREF(irc);
1231	Log(("VBoxUSBDevice::stop([%p], %p {%s}): m_pDevice=%p close & ReEnumerateDevice -> %#x\n",
1232	this, pProvider, pProvider->getName(), m_pDevice, irc));
1233	}
1234	}
1235
1236	/*
1237	* Close and release the IOUSBDevice if didn't do that already in message().
1238	*/
1239	if (m_pDevice)
1240	{
1241	/* close it */
1242	if (m_fOpen)
1243	{
1244	m_fOpenOnWasClosed = false;
1245	m_fOpen = false;
1246	m_pDevice->close(this, 0);
1247	}
1248
1249	/* release it (see start()) */
1250	m_pDevice->release();
1251	m_pDevice = NULL;
1252	}
1253
1254	#ifdef DEBUG
1255	/* avoid crashing on unload. */
1256	if (m_pNotifier)
1257	{
1258	m_pNotifier->release();
1259	m_pNotifier = NULL;
1260	}
1261	#endif
1262
1263	IOUSBUserClientInit::stop(pProvider);
1264	Log(("VBoxUSBDevice::stop: returns void\n"));
1265	}
1266
1267
1268	/**
1269	* Terminate the service (initiate the destruction).
1270	* @remark Only for logging.
1271	*/
1272	bool
1273	org_virtualbox_VBoxUSBDevice::terminate(IOOptionBits fOptions)
1274	{
1275	/* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */
1276	Log(("VBoxUSBDevice::terminate([%p], %#x)\n", this, fOptions));
1277
1278	/*
1279	* There aren't too many reasons why we gets terminated.
1280	* The most common one is that the device is being unplugged. Another is
1281	* that we've triggered reenumeration. In both cases we'll get a
1282	* kIOMessageServiceIsTerminated message before we're stopped.
1283	*
1284	* But, when we're unloaded the provider service isn't terminated, and
1285	* for some funny reason we're frequently causing kernel panics when the
1286	* device is detached (after we're unloaded). So, for now, let's try
1287	* re-enumerate it in stop.
1288	*
1289	* To avoid creating unnecessary trouble we'll try guess if we're being
1290	* unloaded from the option bit mask. (kIOServiceRecursing is private btw.)
1291	*/
1292	/** @todo would be nice if there was a documented way of doing the unload detection this, or
1293	* figure out what exactly we're doing wrong in the unload scenario. */
1294	if ((fOptions & 0xffff) == (kIOServiceRequired \| kIOServiceSynchronous))
1295	m_fBeingUnloaded = true;
1296
1297	return IOUSBUserClientInit::terminate(fOptions);
1298	}
1299
1300
1301	/**
1302	* Intercept open requests and only let Mr. Right (the VM process) open the device.
1303	* This is where it all gets a bit complicated...
1304	*
1305	* @return Status code.
1306	*
1307	* @param enmMsg The message number.
1308	* @param pProvider Pointer to the provider instance.
1309	* @param pvArg Message argument.
1310	*/
1311	IOReturn
1312	org_virtualbox_VBoxUSBDevice::message(UInt32 enmMsg, IOService pProvider, void pvArg)
1313	{
1314	Log(("VBoxUSBDevice::message([%p], %#x {%s}, %p {%s}, %p) - pid=%d\n",
1315	this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, RTProcSelf()));
1316
1317	IOReturn irc;
1318	switch (enmMsg)
1319	{
1320	/*
1321	* This message is send to the current IOService client from IOService::handleOpen(),
1322	* expecting it to call pProvider->close() if it agrees to the other party seizing
1323	* the service. It is also called in IOService::didTerminate() and perhaps some other
1324	* odd places. The way to find out is to examin the pvArg, which would be including
1325	* kIOServiceSeize if it's the handleOpen case.
1326	*
1327	* How to validate that the other end is actually our VM process? Well, IOKit doesn't
1328	* provide any clue about the new client really. But fortunately, it seems like the
1329	* calling task/process context when the VM tries to open the device is the VM process.
1330	* We'll ASSUME this'll remain like this for now...
1331	*/
1332	case kIOMessageServiceIsRequestingClose:
1333	irc = kIOReturnExclusiveAccess;
1334	/* If it's not a seize request, assume it's didTerminate and pray that it isn't a rouge driver.
1335	... weird, doesn't seem to match for the post has-terminated messages. */
1336	if (!((uintptr_t)pvArg & kIOServiceSeize))
1337	{
1338	Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d: not seize - closing...\n",
1339	this, pProvider, pProvider->getName(), pvArg, RTProcSelf()));
1340	m_fOpen = false;
1341	m_fOpenOnWasClosed = false;
1342	if (m_pDevice)
1343	m_pDevice->close(this, 0);
1344	m_Client = NIL_RTPROCESS;
1345	irc = kIOReturnSuccess;
1346	}
1347	else
1348	{
1349	if (org_virtualbox_VBoxUSBClient::isClientTask(current_task()))
1350	{
1351	Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d task=%p: client process, closing.\n",
1352	this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task()));
1353	m_fOpen = false;
1354	m_fOpenOnWasClosed = false;
1355	if (m_pDevice)
1356	m_pDevice->close(this, 0);
1357	m_fOpenOnWasClosed = true;
1358	m_Client = RTProcSelf();
1359	irc = kIOReturnSuccess;
1360	}
1361	else
1362	Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d task=%p: not client process!\n",
1363	this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task()));
1364	}
1365	if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */))
1366	Log(("VBoxUSBDevice::message: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n"));
1367	break;
1368
1369	/*
1370	* The service was closed by the current client.
1371	* Update the client property, check for scheduled re-enumeration and re-open.
1372	*
1373	* Note that we will not be called if we're doing the closing. (Even if we was
1374	* called in that case, the code should be able to handle it.)
1375	*/
1376	case kIOMessageServiceWasClosed:
1377	/*
1378	* Update the client property value.
1379	*/
1380	if (m_Client != NIL_RTPROCESS)
1381	{
1382	m_Client = NIL_RTPROCESS;
1383	if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */))
1384	Log(("VBoxUSBDevice::message: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n"));
1385	}
1386
1387	if (m_pDevice)
1388	{
1389	/*
1390	* Should we release the device?
1391	*/
1392	if (ASMAtomicXchgBool(&m_fReleaseOnClose, false))
1393	{
1394	m_fOpenOnWasClosed = false;
1395	irc = m_pDevice->ReEnumerateDevice(0);
1396	Log(("VBoxUSBDevice::message([%p], %p {%s}) - ReEnumerateDevice() -> %#x\n",
1397	this, pProvider, pProvider->getName(), irc));
1398	}
1399	/*
1400	* Should we attempt to re-open the device?
1401	*/
1402	else if (m_fOpenOnWasClosed)
1403	{
1404	Log(("VBoxUSBDevice::message: attempting to re-open the device...\n"));
1405	m_fOpenOnWasClosed = false;
1406	m_fOpen = m_pDevice->open(this, kIOServiceSeize, 0);
1407	if (!m_fOpen)
1408	Log(("VBoxUSBDevice::message: failed to open the device!\n"));
1409	m_fOpenOnWasClosed = !m_fOpen;
1410	}
1411	}
1412
1413	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1414	break;
1415
1416	/*
1417	* The IOUSBDevice is shutting down, so close it if we've opened it.
1418	*/
1419	case kIOMessageServiceIsTerminated:
1420	m_fBeingUnloaded = false;
1421	ASMAtomicWriteBool(&m_fReleaseOnClose, false);
1422	if (m_pDevice)
1423	{
1424	/* close it */
1425	if (m_fOpen)
1426	{
1427	m_fOpen = false;
1428	m_fOpenOnWasClosed = false;
1429	Log(("VBoxUSBDevice::message: closing the device (%p)...\n", m_pDevice));
1430	m_pDevice->close(this, 0);
1431	}
1432
1433	/* release it (see start()) */
1434	Log(("VBoxUSBDevice::message: releasing the device (%p)...\n", m_pDevice));
1435	m_pDevice->release();
1436	m_pDevice = NULL;
1437	}
1438
1439	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1440	break;
1441
1442	default:
1443	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1444	break;
1445	}
1446
1447	Log(("VBoxUSBDevice::message([%p], %#x {%s}, %p {%s}, %p) -> %#x\n",
1448	this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, irc));
1449	return irc;
1450	}
1451
1452
1453	/**
1454	* Schedule all devices belonging to the specified process for release.
1455	*
1456	* Devices that aren't currently in use will be released immediately.
1457	*
1458	* @param Owner The owner process.
1459	*/
1460	/* static */ void
1461	org_virtualbox_VBoxUSBDevice::scheduleReleaseByOwner(RTPROCESS Owner)
1462	{
1463	Log2(("VBoxUSBDevice::scheduleReleaseByOwner: Owner=%d\n", Owner));
1464	AssertReturnVoid(Owner && Owner != NIL_RTPROCESS);
1465
1466	/*
1467	* Walk the list of devices looking for device belonging to this process.
1468	*
1469	* If we release a device, we have to lave the spinlock and will therefore
1470	* have to restart the search.
1471	*/
1472	VBOXUSB_LOCK();
1473
1474	org_virtualbox_VBoxUSBDevice *pCur;
1475	do
1476	{
1477	for (pCur = s_pHead; pCur; pCur = pCur->m_pNext)
1478	{
1479	Log2(("VBoxUSBDevice::scheduleReleaseByOwner: pCur=%p m_Owner=%d (%s) m_fReleaseOnClose=%d\n",
1480	pCur, pCur->m_Owner, pCur->m_Owner == Owner ? "match" : "mismatch", pCur->m_fReleaseOnClose));
1481	if (pCur->m_Owner == Owner)
1482	{
1483	/* make sure we won't hit it again. */
1484	pCur->m_Owner = NIL_RTPROCESS;
1485	IOUSBDevice *pDevice = pCur->m_pDevice;
1486	if ( pDevice
1487	&& !pCur->m_fReleaseOnClose)
1488	{
1489	pCur->m_fOpenOnWasClosed = false;
1490	if (pCur->m_Client != NIL_RTPROCESS)
1491	{
1492	/* It's currently open, so just schedule it for re-enumeration on close. */
1493	ASMAtomicWriteBool(&pCur->m_fReleaseOnClose, true);
1494	Log(("VBoxUSBDevice::scheduleReleaseByOwner: %p {%s} - used by %d\n",
1495	pDevice, pDevice->getName(), pCur->m_Client));
1496	}
1497	else
1498	{
1499	/*
1500	* Get the USBDevice object and do the re-enumeration now.
1501	* Retain the device so we don't run into any trouble.
1502	*/
1503	pDevice->retain();
1504	VBOXUSB_UNLOCK();
1505
1506	IOReturn irc = pDevice->ReEnumerateDevice(0); NOREF(irc);
1507	Log(("VBoxUSBDevice::scheduleReleaseByOwner: %p {%s} - ReEnumerateDevice -> %#x\n",
1508	pDevice, pDevice->getName(), irc));
1509
1510	pDevice->release();
1511	VBOXUSB_LOCK();
1512	break;
1513	}
1514	}
1515	}
1516	}
1517	} while (pCur);
1518
1519	VBOXUSB_UNLOCK();
1520	}
1521
1522
1523	#ifdef DEBUG
1524	/static/ IOReturn
1525	org_virtualbox_VBoxUSBDevice::MyInterestHandler(void pvTarget, void pvRefCon, UInt32 enmMsgType,
1526	IOService pProvider, void pvMsgArg, vm_size_t cbMsgArg)
1527	{
1528	org_virtualbox_VBoxUSBDevice pThis = (org_virtualbox_VBoxUSBDevice )pvTarget;
1529	if (!pThis)
1530	return kIOReturnError;
1531
1532	switch (enmMsgType)
1533	{
1534	case kIOMessageServiceIsAttemptingOpen:
1535	/* pvMsgArg == the open() fOptions, so we could check for kIOServiceSeize if we care.
1536	We'll also get a kIIOServiceRequestingClose message() for that... */
1537	Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceIsAttemptingOpen - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1538	pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1539	break;
1540
1541	case kIOMessageServiceWasClosed:
1542	Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceWasClosed - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1543	pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1544	break;
1545
1546	case kIOMessageServiceIsTerminated:
1547	Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceIsTerminated - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1548	pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1549	break;
1550
1551	case kIOUSBMessagePortHasBeenReset:
1552	Log(("VBoxUSBDevice::MyInterestHandler: kIOUSBMessagePortHasBeenReset - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1553	pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1554	break;
1555
1556	default:
1557	Log(("VBoxUSBDevice::MyInterestHandler: %#x (%s) - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1558	enmMsgType, DbgGetIOKitMessageName(enmMsgType), pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1559	break;
1560	}
1561
1562	return kIOReturnSuccess;
1563	}
1564	#endif /* DEBUG */
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579	/*
1580	*
1581	* org_virtualbox_VBoxUSBInterface
1582	*
1583	*/
1584
1585	/**
1586	* Initialize our data members.
1587	*/
1588	bool
1589	org_virtualbox_VBoxUSBInterface::init(OSDictionary *pDictionary)
1590	{
1591	uint32_t cInstances = ASMAtomicIncU32(&g_cInstances);
1592	Log(("VBoxUSBInterface::init([%p], %p) new g_cInstances=%d\n", this, pDictionary, cInstances));
1593
1594	m_pInterface = NULL;
1595	m_fOpen = false;
1596	m_fOpenOnWasClosed = false;
1597
1598	return IOUSBUserClientInit::init(pDictionary);
1599	}
1600
1601
1602	/**
1603	* Free the object.
1604	* @remark Only for logging.
1605	*/
1606	void
1607	org_virtualbox_VBoxUSBInterface::free()
1608	{
1609	uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances);
1610	Log(("VBoxUSBInterfaces::free([%p]) new g_cInstances=%d\n", this, cInstances));
1611	IOUSBUserClientInit::free();
1612	}
1613
1614
1615	/**
1616	* Probe the interface to see if we're the right driver for it.
1617	*
1618	* We implement this similarly to org_virtualbox_VBoxUSBDevice, except that
1619	* we don't bother matching filters but instead just check if the parent is
1620	* handled by org_virtualbox_VBoxUSBDevice or not.
1621	*/
1622	IOService *
1623	org_virtualbox_VBoxUSBInterface::probe(IOService pProvider, SInt32 pi32Score)
1624	{
1625	Log(("VBoxUSBInterface::probe([%p], %p {%s}, %p={%d})\n", this,
1626	pProvider, pProvider->getName(), pi32Score, pi32Score ? *pi32Score : 0));
1627
1628	/*
1629	* Check if VBoxUSBDevice is the parent's driver.
1630	*/
1631	bool fHijackIt = false;
1632	const IORegistryPlane *pServicePlane = getPlane(kIOServicePlane);
1633	IORegistryEntry *pParent = pProvider->getParentEntry(pServicePlane);
1634	if (pParent)
1635	{
1636	Log(("VBoxUSBInterface::probe: pParent=%p {%s}\n", pParent, pParent->getName()));
1637
1638	OSIterator *pSiblings = pParent->getChildIterator(pServicePlane);
1639	if (pSiblings)
1640	{
1641	IORegistryEntry *pSibling;
1642	while ( (pSibling = OSDynamicCast(IORegistryEntry, pSiblings->getNextObject())) )
1643	{
1644	const OSMetaClass *pMetaClass = pSibling->getMetaClass();
1645	Log2(("sibling: %p - %s - %s\n", pMetaClass, pSibling->getName(), pMetaClass->getClassName()));
1646	if (pMetaClass == &org_virtualbox_VBoxUSBDevice::gMetaClass)
1647	{
1648	fHijackIt = true;
1649	break;
1650	}
1651	}
1652	pSiblings->release();
1653	}
1654	}
1655	if (!fHijackIt)
1656	{
1657	Log(("VBoxUSBInterface::probe: returns NULL\n"));
1658	return NULL;
1659	}
1660
1661	IOService *pRet = IOUSBUserClientInit::probe(pProvider, pi32Score);
1662	*pi32Score = _1G;
1663	Log(("VBoxUSBInterface::probe: returns %p and pi32Score=%d - hijack it.\n", pRet, pi32Score));
1664	return pRet;
1665	}
1666
1667
1668	/**
1669	* Start the driver (this), retain and open the USB interface object (pProvider).
1670	*/
1671	bool
1672	org_virtualbox_VBoxUSBInterface::start(IOService *pProvider)
1673	{
1674	Log(("VBoxUSBInterface::start([%p], %p {%s})\n", this, pProvider, pProvider->getName()));
1675
1676	/*
1677	* Exploit IOUSBUserClientInit to process IOProviderMergeProperties.
1678	*/
1679	IOUSBUserClientInit::start(pProvider); /* returns false */
1680
1681	/*
1682	* Retain the and open the interface (stop() or message() cleans up).
1683	*/
1684	bool fRc = true;
1685	m_pInterface = OSDynamicCast(IOUSBInterface, pProvider);
1686	if (m_pInterface)
1687	{
1688	m_pInterface->retain();
1689	m_fOpen = m_pInterface->open(this, kIOServiceSeize, 0);
1690	if (!m_fOpen)
1691	Log(("VBoxUSBInterface::start: failed to open the interface!\n"));
1692	m_fOpenOnWasClosed = !m_fOpen;
1693	}
1694	else
1695	{
1696	printf("VBoxUSBInterface::start([%p], %p {%s}): failed!\n", this, pProvider, pProvider->getName());
1697	fRc = false;
1698	}
1699
1700	Log(("VBoxUSBInterface::start: returns %d\n", fRc));
1701	return fRc;
1702	}
1703
1704
1705	/**
1706	* Close and release the USB interface object (pProvider) and stop the driver (this).
1707	*/
1708	void
1709	org_virtualbox_VBoxUSBInterface::stop(IOService *pProvider)
1710	{
1711	Log(("org_virtualbox_VBoxUSBInterface::stop([%p], %p {%s})\n", this, pProvider, pProvider->getName()));
1712
1713	/*
1714	* Close and release the IOUSBInterface if didn't do that already in message().
1715	*/
1716	if (m_pInterface)
1717	{
1718	/* close it */
1719	if (m_fOpen)
1720	{
1721	m_fOpenOnWasClosed = false;
1722	m_fOpen = false;
1723	m_pInterface->close(this, 0);
1724	}
1725
1726	/* release it (see start()) */
1727	m_pInterface->release();
1728	m_pInterface = NULL;
1729	}
1730
1731	IOUSBUserClientInit::stop(pProvider);
1732	Log(("VBoxUSBInterface::stop: returns void\n"));
1733	}
1734
1735
1736	/**
1737	* Terminate the service (initiate the destruction).
1738	* @remark Only for logging.
1739	*/
1740	bool
1741	org_virtualbox_VBoxUSBInterface::terminate(IOOptionBits fOptions)
1742	{
1743	/* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */
1744	Log(("VBoxUSBInterface::terminate([%p], %#x)\n", this, fOptions));
1745	return IOUSBUserClientInit::terminate(fOptions);
1746	}
1747
1748
1749	/**
1750	* @copydoc org_virtualbox_VBoxUSBDevice::message
1751	*/
1752	IOReturn
1753	org_virtualbox_VBoxUSBInterface::message(UInt32 enmMsg, IOService pProvider, void pvArg)
1754	{
1755	Log(("VBoxUSBInterface::message([%p], %#x {%s}, %p {%s}, %p)\n",
1756	this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg));
1757
1758	IOReturn irc;
1759	switch (enmMsg)
1760	{
1761	/*
1762	* See explanation in org_virtualbox_VBoxUSBDevice::message.
1763	*/
1764	case kIOMessageServiceIsRequestingClose:
1765	irc = kIOReturnExclusiveAccess;
1766	if (!((uintptr_t)pvArg & kIOServiceSeize))
1767	{
1768	Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d: not seize - closing...\n",
1769	this, pProvider, pProvider->getName(), pvArg, RTProcSelf()));
1770	m_fOpen = false;
1771	m_fOpenOnWasClosed = false;
1772	if (m_pInterface)
1773	m_pInterface->close(this, 0);
1774	irc = kIOReturnSuccess;
1775	}
1776	else
1777	{
1778	if (org_virtualbox_VBoxUSBClient::isClientTask(current_task()))
1779	{
1780	Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d task=%p: client process, closing.\n",
1781	this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task()));
1782	m_fOpen = false;
1783	m_fOpenOnWasClosed = false;
1784	if (m_pInterface)
1785	m_pInterface->close(this, 0);
1786	m_fOpenOnWasClosed = true;
1787	irc = kIOReturnSuccess;
1788	}
1789	else
1790	Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d task=%p: not client process!\n",
1791	this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task()));
1792	}
1793	break;
1794
1795	/*
1796	* The service was closed by the current client, check for re-open.
1797	*/
1798	case kIOMessageServiceWasClosed:
1799	if (m_pInterface && m_fOpenOnWasClosed)
1800	{
1801	Log(("VBoxUSBInterface::message: attempting to re-open the interface...\n"));
1802	m_fOpenOnWasClosed = false;
1803	m_fOpen = m_pInterface->open(this, kIOServiceSeize, 0);
1804	if (!m_fOpen)
1805	Log(("VBoxUSBInterface::message: failed to open the interface!\n"));
1806	m_fOpenOnWasClosed = !m_fOpen;
1807	}
1808
1809	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1810	break;
1811
1812	/*
1813	* The IOUSBInterface/Device is shutting down, so close and release.
1814	*/
1815	case kIOMessageServiceIsTerminated:
1816	if (m_pInterface)
1817	{
1818	/* close it */
1819	if (m_fOpen)
1820	{
1821	m_fOpen = false;
1822	m_fOpenOnWasClosed = false;
1823	m_pInterface->close(this, 0);
1824	}
1825
1826	/* release it (see start()) */
1827	m_pInterface->release();
1828	m_pInterface = NULL;
1829	}
1830
1831	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1832	break;
1833
1834	default:
1835	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1836	break;
1837	}
1838
1839	Log(("VBoxUSBInterface::message([%p], %#x {%s}, %p {%s}, %p) -> %#x\n",
1840	this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, irc));
1841	return irc;
1842	}
1843

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

source: vbox/trunk/src/VBox/HostDrivers/VBoxUSB/darwin/VBoxUSB.cpp@ 37620

Download in other formats: