VBoxUSB.cpp@ 57004

Last change on this file since 57004 was 56293, checked in by vboxsync, 9 years ago
HostDrivers: Updated (C) year.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 60.1 KB

Line
1	/* $Id: VBoxUSB.cpp 56293 2015-06-09 14:23:56Z 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-2015 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	if (u32Type != VBOXUSB_DARWIN_IOSERVICE_COOKIE)
570	{
571	Log(("VBoxUSBClient::initWithTask: Bade cookie %#x\n", u32Type));
572	return false;
573	}
574
575	proc_t pProc = (proc_t)get_bsdtask_info(OwningTask); /* we need the pid */
576	Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x)\n",
577	this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type));
578
579	if (IOUserClient::initWithTask(OwningTask, pvSecurityId , u32Type))
580	{
581	m_pProvider = NULL;
582	m_Task = OwningTask;
583	m_Process = pProc ? proc_pid(pProc) : NIL_RTPROCESS;
584	m_pNext = NULL;
585
586	uint32_t cInstances = ASMAtomicIncU32(&g_cInstances);
587	Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x) -> true; new g_cInstances=%d\n",
588	this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type, cInstances));
589	return true;
590	}
591
592	Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x) -> false\n",
593	this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type));
594	return false;
595	}
596
597
598	/**
599	* Free the object.
600	* @remark Only for logging.
601	*/
602	void
603	org_virtualbox_VBoxUSBClient::free()
604	{
605	uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances);
606	Log(("VBoxUSBClient::free([%p]) new g_cInstances=%d\n", this, cInstances));
607	IOUserClient::free();
608	}
609
610
611	/**
612	* Start the client service.
613	*/
614	bool
615	org_virtualbox_VBoxUSBClient::start(IOService *pProvider)
616	{
617	Log(("VBoxUSBClient::start([%p], %p)\n", this, pProvider));
618	if (IOUserClient::start(pProvider))
619	{
620	m_pProvider = OSDynamicCast(org_virtualbox_VBoxUSB, pProvider);
621	if (m_pProvider)
622	{
623	/*
624	* Add ourselves to the list of user clients.
625	*/
626	VBOXUSB_LOCK();
627
628	m_pNext = s_pHead;
629	s_pHead = this;
630
631	VBOXUSB_UNLOCK();
632
633	return true;
634	}
635	Log(("VBoxUSBClient::start: %p isn't org_virtualbox_VBoxUSB\n", pProvider));
636	}
637	return false;
638	}
639
640
641	/**
642	* Client exits normally.
643	*/
644	IOReturn
645	org_virtualbox_VBoxUSBClient::clientClose(void)
646	{
647	Log(("VBoxUSBClient::clientClose([%p:{.m_Process=%d}])\n", this, (int)m_Process));
648
649	/*
650	* Remove this process from the client list.
651	*/
652	VBOXUSB_LOCK();
653
654	org_virtualbox_VBoxUSBClient *pPrev = NULL;
655	for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext)
656	{
657	if (pCur == this)
658	{
659	if (pPrev)
660	pPrev->m_pNext = m_pNext;
661	else
662	s_pHead = m_pNext;
663	m_pNext = NULL;
664	break;
665	}
666	pPrev = pCur;
667	}
668
669	VBOXUSB_UNLOCK();
670
671	/*
672	* Drop all filters owned by this client.
673	*/
674	if (m_Process != NIL_RTPROCESS)
675	VBoxUSBFilterRemoveOwner(m_Process);
676
677	/*
678	* Schedule all devices owned (filtered) by this process for
679	* immediate release or release upon close.
680	*/
681	if (m_Process != NIL_RTPROCESS)
682	org_virtualbox_VBoxUSBDevice::scheduleReleaseByOwner(m_Process);
683
684	/*
685	* Initiate termination.
686	*/
687	m_pProvider = NULL;
688	terminate();
689
690	return kIOReturnSuccess;
691	}
692
693
694	/**
695	* The client exits abnormally / forgets to do cleanups.
696	* @remark Only for logging.
697	*/
698	IOReturn
699	org_virtualbox_VBoxUSBClient::clientDied(void)
700	{
701	Log(("VBoxUSBClient::clientDied([%p]) m_Task=%p R0Process=%p Process=%d\n",
702	this, m_Task, RTR0ProcHandleSelf(), RTProcSelf()));
703
704	/* IOUserClient::clientDied() calls clientClose... */
705	return IOUserClient::clientDied();
706	}
707
708
709	/**
710	* Terminate the service (initiate the destruction).
711	* @remark Only for logging.
712	*/
713	bool
714	org_virtualbox_VBoxUSBClient::terminate(IOOptionBits fOptions)
715	{
716	/* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */
717	Log(("VBoxUSBClient::terminate([%p], %#x)\n", this, fOptions));
718	return IOUserClient::terminate(fOptions);
719	}
720
721
722	/**
723	* The final stage of the client service destruction.
724	* @remark Only for logging.
725	*/
726	bool
727	org_virtualbox_VBoxUSBClient::finalize(IOOptionBits fOptions)
728	{
729	Log(("VBoxUSBClient::finalize([%p], %#x)\n", this, fOptions));
730	return IOUserClient::finalize(fOptions);
731	}
732
733
734	/**
735	* Stop the client service.
736	*/
737	void
738	org_virtualbox_VBoxUSBClient::stop(IOService *pProvider)
739	{
740	Log(("VBoxUSBClient::stop([%p])\n", this));
741	IOUserClient::stop(pProvider);
742
743	/*
744	* Paranoia.
745	*/
746	VBOXUSB_LOCK();
747
748	org_virtualbox_VBoxUSBClient *pPrev = NULL;
749	for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext)
750	{
751	if (pCur == this)
752	{
753	if (pPrev)
754	pPrev->m_pNext = m_pNext;
755	else
756	s_pHead = m_pNext;
757	m_pNext = NULL;
758	break;
759	}
760	pPrev = pCur;
761	}
762
763	VBOXUSB_UNLOCK();
764	}
765
766
767	/**
768	* Translate a user method index into a service object and an external method structure.
769	*
770	* @returns Pointer to external method structure descripting the method.
771	* NULL if the index isn't valid.
772	* @param ppService Where to store the service object on success.
773	* @param iMethod The method index.
774	*/
775	IOExternalMethod *
776	org_virtualbox_VBoxUSBClient::getTargetAndMethodForIndex(IOService **ppService, UInt32 iMethod)
777	{
778	static IOExternalMethod s_aMethods[VBOXUSBMETHOD_END] =
779	{
780	/[VBOXUSBMETHOD_ADD_FILTER] = /
781	{
782	(IOService )0, / object */
783	(IOMethod)&org_virtualbox_VBoxUSBClient::addFilter, /* func */
784	kIOUCStructIStructO, /* flags - struct input (count0) and struct output (count1) */
785	sizeof(USBFILTER), /* count0 - size of the input struct. */
786	sizeof(VBOXUSBADDFILTEROUT) /* count1 - size of the return struct. */
787	},
788	/* [VBOXUSBMETHOD_FILTER_REMOVE] = */
789	{
790	(IOService )0, / object */
791	(IOMethod)&org_virtualbox_VBoxUSBClient::removeFilter, /* func */
792	kIOUCStructIStructO, /* flags - struct input (count0) and struct output (count1) */
793	sizeof(uintptr_t), /* count0 - size of the input (id) */
794	sizeof(int) /* count1 - size of the output (rc) */
795	},
796	};
797
798	if (RT_UNLIKELY(iMethod >= RT_ELEMENTS(s_aMethods)))
799	return NULL;
800
801	*ppService = this;
802	return &s_aMethods[iMethod];
803	}
804
805
806	/**
807	* Add filter user request.
808	*
809	* @returns IOKit status code.
810	* @param pFilter The filter to add.
811	* @param pOut Pointer to the output structure.
812	* @param cbFilter Size of the filter structure.
813	* @param pcbOut In/Out - sizeof(*pOut).
814	*/
815	IOReturn
816	org_virtualbox_VBoxUSBClient::addFilter(PUSBFILTER pFilter, PVBOXUSBADDFILTEROUT pOut, IOByteCount cbFilter, IOByteCount *pcbOut)
817	{
818	Log(("VBoxUSBClient::addFilter: [%p:{.m_Process=%d}] pFilter=%p pOut=%p\n", this, (int)m_Process, pFilter, pOut));
819
820	/*
821	* Validate input.
822	*/
823	if (RT_UNLIKELY( cbFilter != sizeof(*pFilter)
824	\|\| pcbOut != sizeof(pOut)))
825	{
826	printf("VBoxUSBClient::addFilter: cbFilter=%#x expected %#x; *pcbOut=%#x expected %#x\n",
827	(int)cbFilter, (int)sizeof(pFilter), (int)pcbOut, (int)sizeof(*pOut));
828	return kIOReturnBadArgument;
829	}
830
831	/*
832	* Log the filter details.
833	*/
834	#ifdef DEBUG
835	Log2(("VBoxUSBClient::addFilter: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n",
836	USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID),
837	USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID),
838	USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_REV),
839	USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_CLASS),
840	USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_SUB_CLASS),
841	USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_PROTOCOL),
842	USBFilterGetNum(pFilter, USBFILTERIDX_BUS),
843	USBFilterGetNum(pFilter, USBFILTERIDX_PORT)));
844	Log2(("VBoxUSBClient::addFilter: Manufacturer=%s Product=%s Serial=%s\n",
845	USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) : "<null>",
846	USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) : "<null>",
847	USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>"));
848	#endif
849
850	/*
851	* Since we cannot query the bus number, make sure the filter
852	* isn't requiring that field to be present.
853	*/
854	int rc = USBFilterSetMustBePresent(pFilter, USBFILTERIDX_BUS, false /* fMustBePresent */); AssertRC(rc);
855
856	/*
857	* Add the filter.
858	*/
859	pOut->uId = 0;
860	pOut->rc = VBoxUSBFilterAdd(pFilter, m_Process, &pOut->uId);
861
862	Log(("VBoxUSBClient::addFilter: returns pOut={.rc=%d, .uId=%p}\n", pOut->rc, (void )pOut->uId));
863	return kIOReturnSuccess;
864	}
865
866
867	/**
868	* Removes filter user request.
869	*
870	* @returns IOKit status code.
871	* @param puId Where to get the filter ID.
872	* @param prc Where to store the return code.
873	* @param cbIn sizeof(*puId).
874	* @param pcbOut In/Out - sizeof(*prc).
875	*/
876	IOReturn
877	org_virtualbox_VBoxUSBClient::removeFilter(uintptr_t puId, int prc, IOByteCount cbIn, IOByteCount *pcbOut)
878	{
879	Log(("VBoxUSBClient::removeFilter: [%p:{.m_Process=%d}] puId=%p m_Proc\n", this, (int)m_Process, puId));
880
881	/*
882	* Validate input.
883	*/
884	if (RT_UNLIKELY( cbIn != sizeof(*puId)
885	\|\| pcbOut != sizeof(prc)))
886	{
887	printf("VBoxUSBClient::removeFilter: cbIn=%#x expected %#x; *pcbOut=%#x expected %#x\n",
888	(int)cbIn, (int)sizeof(puId), (int)pcbOut, (int)sizeof(*prc));
889	return kIOReturnBadArgument;
890	}
891
892	/*
893	* Remove the filter.
894	*/
895	prc = VBoxUSBFilterRemove(m_Process, puId);
896
897	Log(("VBoxUSBClient::removeFilter: returns prc=%d\n", prc));
898	return kIOReturnSuccess;
899	}
900
901
902	/**
903	* Checks whether the specified task is a VBoxUSB client task or not.
904	*
905	* This is used to validate clients trying to open any of the device
906	* or interfaces that we've hijacked.
907	*
908	* @returns true / false.
909	* @param ClientTask The task.
910	*
911	* @remark This protecting against other user clients is not currently implemented
912	* as it turned out to be more bothersome than first imagined.
913	*/
914	/* static*/ bool
915	org_virtualbox_VBoxUSBClient::isClientTask(task_t ClientTask)
916	{
917	VBOXUSB_LOCK();
918
919	for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext)
920	if (pCur->m_Task == ClientTask)
921	{
922	VBOXUSB_UNLOCK();
923	return true;
924	}
925
926	VBOXUSB_UNLOCK();
927	return false;
928	}
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943	/*
944	*
945	* org_virtualbox_VBoxUSBDevice
946	*
947	*/
948
949	/**
950	* Initialize instance data.
951	*
952	* @returns Success indicator.
953	* @param pDictionary The dictionary that will become the registry entry's
954	* property table, or NULL. Hand it up to our parents.
955	*/
956	bool
957	org_virtualbox_VBoxUSBDevice::init(OSDictionary *pDictionary)
958	{
959	uint32_t cInstances = ASMAtomicIncU32(&g_cInstances);
960	Log(("VBoxUSBDevice::init([%p], %p) new g_cInstances=%d\n", this, pDictionary, cInstances));
961
962	m_pDevice = NULL;
963	m_Owner = NIL_RTPROCESS;
964	m_Client = NIL_RTPROCESS;
965	m_uId = ~(uintptr_t)0;
966	m_fOpen = false;
967	m_fOpenOnWasClosed = false;
968	m_fReleaseOnClose = false;
969	m_fBeingUnloaded = false;
970	m_pNext = NULL;
971	#ifdef DEBUG
972	m_pNotifier = NULL;
973	#endif
974
975	return IOUSBUserClientInit::init(pDictionary);
976	}
977
978	/**
979	* Free the object.
980	* @remark Only for logging.
981	*/
982	void
983	org_virtualbox_VBoxUSBDevice::free()
984	{
985	uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances);
986	Log(("VBoxUSBDevice::free([%p]) new g_cInstances=%d\n", this, cInstances));
987	IOUSBUserClientInit::free();
988	}
989
990
991	/**
992	* The device/driver probing.
993	*
994	* I/O Kit will iterate all device drivers suitable for this kind of device
995	* (this is something it figures out from the property file) and call their
996	* probe() method in order to try determine which is the best match for the
997	* device. We will match the device against the registered filters and set
998	* a ridiculously high score if we find it, thus making it extremely likely
999	* that we'll be the first driver to be started. We'll also set a couple of
1000	* attributes so that it's not necessary to do a rematch in init to find
1001	* the appropriate filter (might not be necessary..., see todo).
1002	*
1003	* @returns Service instance to be started and *pi32Score if matching.
1004	* NULL if not a device suitable for this driver.
1005	*
1006	* @param pProvider The provider instance.
1007	* @param pi32Score Where to store the probe score.
1008	*/
1009	IOService *
1010	org_virtualbox_VBoxUSBDevice::probe(IOService pProvider, SInt32 pi32Score)
1011	{
1012	Log(("VBoxUSBDevice::probe([%p], %p {%s}, %p={%d})\n", this,
1013	pProvider, pProvider->getName(), pi32Score, pi32Score ? *pi32Score : 0));
1014
1015	/*
1016	* Check against filters.
1017	*/
1018	USBFILTER Device;
1019	USBFilterInit(&Device, USBFILTERTYPE_CAPTURE);
1020
1021	static const struct
1022	{
1023	const char *pszName;
1024	USBFILTERIDX enmIdx;
1025	bool fNumeric;
1026	} s_aProps[] =
1027	{
1028	{ kUSBVendorID, USBFILTERIDX_VENDOR_ID, true },
1029	{ kUSBProductID, USBFILTERIDX_PRODUCT_ID, true },
1030	{ kUSBDeviceReleaseNumber, USBFILTERIDX_DEVICE_REV, true },
1031	{ kUSBDeviceClass, USBFILTERIDX_DEVICE_CLASS, true },
1032	{ kUSBDeviceSubClass, USBFILTERIDX_DEVICE_SUB_CLASS, true },
1033	{ kUSBDeviceProtocol, USBFILTERIDX_DEVICE_PROTOCOL, true },
1034	{ "PortNum", USBFILTERIDX_PORT, true },
1035	/// @todo { , USBFILTERIDX_BUS, true }, - must be derived :-/
1036	/// Seems to be the upper byte of locationID and our "grand parent" has a USBBusNumber prop.
1037	{ "USB Vendor Name", USBFILTERIDX_MANUFACTURER_STR, false },
1038	{ "USB Product Name", USBFILTERIDX_PRODUCT_STR, false },
1039	{ "USB Serial Number", USBFILTERIDX_SERIAL_NUMBER_STR, false },
1040	};
1041	for (unsigned i = 0; i < RT_ELEMENTS(s_aProps); i++)
1042	{
1043	OSObject *pObj = pProvider->getProperty(s_aProps[i].pszName);
1044	if (!pObj)
1045	continue;
1046	if (s_aProps[i].fNumeric)
1047	{
1048	OSNumber *pNum = OSDynamicCast(OSNumber, pObj);
1049	if (pNum)
1050	{
1051	uint16_t u16 = pNum->unsigned16BitValue();
1052	Log2(("VBoxUSBDevice::probe: %d/%s - %#x (32bit=%#x)\n", i, s_aProps[i].pszName, u16, pNum->unsigned32BitValue()));
1053	int vrc = USBFilterSetNumExact(&Device, s_aProps[i].enmIdx, u16, true);
1054	if (RT_FAILURE(vrc))
1055	Log(("VBoxUSBDevice::probe: pObj=%p pNum=%p - %d/%s - rc=%d!\n", pObj, pNum, i, s_aProps[i].pszName, vrc));
1056	}
1057	else
1058	Log(("VBoxUSBDevice::probe: pObj=%p pNum=%p - %d/%s!\n", pObj, pNum, i, s_aProps[i].pszName));
1059	}
1060	else
1061	{
1062	OSString *pStr = OSDynamicCast(OSString, pObj);
1063	if (pStr)
1064	{
1065	Log2(("VBoxUSBDevice::probe: %d/%s - %s\n", i, s_aProps[i].pszName, pStr->getCStringNoCopy()));
1066	int vrc = USBFilterSetStringExact(&Device, s_aProps[i].enmIdx, pStr->getCStringNoCopy(), true);
1067	if (RT_FAILURE(vrc))
1068	Log(("VBoxUSBDevice::probe: pObj=%p pStr=%p - %d/%s - rc=%d!\n", pObj, pStr, i, s_aProps[i].pszName, vrc));
1069	}
1070	else
1071	Log(("VBoxUSBDevice::probe: pObj=%p pStr=%p - %d/%s\n", pObj, pStr, i, s_aProps[i].pszName));
1072	}
1073	}
1074	/** @todo try figure the blasted bus number */
1075
1076	/*
1077	* Run filters on it.
1078	*/
1079	uintptr_t uId = 0;
1080	RTPROCESS Owner = VBoxUSBFilterMatch(&Device, &uId);
1081	USBFilterDelete(&Device);
1082	if (Owner == NIL_RTPROCESS)
1083	{
1084	Log(("VBoxUSBDevice::probe: returns NULL uId=%d\n", uId));
1085	return NULL;
1086	}
1087
1088	/*
1089	* It matched. Save the owner in the provider registry (hope that works).
1090	*/
1091	IOService *pRet = IOUSBUserClientInit::probe(pProvider, pi32Score);
1092	Assert(pRet == this);
1093	m_Owner = Owner;
1094	m_uId = uId;
1095	Log(("%p: m_Owner=%d m_uId=%d\n", this, (int)m_Owner, (int)m_uId));
1096	*pi32Score = _1G;
1097	Log(("VBoxUSBDevice::probe: returns %p and pi32Score=%d\n", pRet, pi32Score));
1098	return pRet;
1099	}
1100
1101
1102	/**
1103	* Try start the device driver.
1104	*
1105	* We will do device linking, copy the filter and owner properties from the provider,
1106	* set the client property, retain the device, and try open (seize) the device.
1107	*
1108	* @returns Success indicator.
1109	* @param pProvider The provider instance.
1110	*/
1111	bool
1112	org_virtualbox_VBoxUSBDevice::start(IOService *pProvider)
1113	{
1114	Log(("VBoxUSBDevice::start([%p:{.m_Owner=%d, .m_uId=%p}], %p {%s})\n",
1115	this, m_Owner, m_uId, pProvider, pProvider->getName()));
1116
1117	m_pDevice = OSDynamicCast(IOUSBDevice, pProvider);
1118	if (!m_pDevice)
1119	{
1120	printf("VBoxUSBDevice::start([%p], %p {%s}): failed!\n", this, pProvider, pProvider->getName());
1121	return false;
1122	}
1123
1124	#ifdef DEBUG
1125	/* for some extra log messages */
1126	m_pNotifier = pProvider->registerInterest(gIOGeneralInterest,
1127	&org_virtualbox_VBoxUSBDevice::MyInterestHandler,
1128	this, /* pvTarget */
1129	NULL); /* pvRefCon */
1130	#endif
1131
1132	/*
1133	* Exploit IOUSBUserClientInit to process IOProviderMergeProperties.
1134	*/
1135	IOUSBUserClientInit::start(pProvider); /* returns false */
1136
1137	/*
1138	* Link ourselves into the list of hijacked device.
1139	*/
1140	VBOXUSB_LOCK();
1141
1142	m_pNext = s_pHead;
1143	s_pHead = this;
1144
1145	VBOXUSB_UNLOCK();
1146
1147	/*
1148	* Set the VBoxUSB properties.
1149	*/
1150	if (!setProperty(VBOXUSB_OWNER_KEY, (unsigned long long)m_Owner, sizeof(m_Owner) * 8 /* bits */))
1151	Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_OWNER_KEY "' property!\n"));
1152	if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */))
1153	Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n"));
1154	if (!setProperty(VBOXUSB_FILTER_KEY, (unsigned long long)m_uId, sizeof(m_uId) * 8 /* bits */))
1155	Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_FILTER_KEY "' property!\n"));
1156
1157	/*
1158	* Retain and open the device.
1159	*/
1160	m_pDevice->retain();
1161	m_fOpen = m_pDevice->open(this, kIOServiceSeize, 0);
1162	if (!m_fOpen)
1163	Log(("VBoxUSBDevice::start: failed to open the device!\n"));
1164	m_fOpenOnWasClosed = !m_fOpen;
1165
1166	Log(("VBoxUSBDevice::start: returns %d\n", true));
1167	return true;
1168	}
1169
1170
1171	/**
1172	* Stop the device driver.
1173	*
1174	* We'll unlink the device, start device re-enumeration and close it. And call
1175	* the parent stop method of course.
1176	*
1177	* @param pProvider The provider instance.
1178	*/
1179	void
1180	org_virtualbox_VBoxUSBDevice::stop(IOService *pProvider)
1181	{
1182	Log(("VBoxUSBDevice::stop([%p], %p {%s})\n", this, pProvider, pProvider->getName()));
1183
1184	/*
1185	* Remove ourselves from the list of device.
1186	*/
1187	VBOXUSB_LOCK();
1188
1189	org_virtualbox_VBoxUSBDevice *pPrev = NULL;
1190	for (org_virtualbox_VBoxUSBDevice *pCur = s_pHead; pCur; pCur = pCur->m_pNext)
1191	{
1192	if (pCur == this)
1193	{
1194	if (pPrev)
1195	pPrev->m_pNext = m_pNext;
1196	else
1197	s_pHead = m_pNext;
1198	m_pNext = NULL;
1199	break;
1200	}
1201	pPrev = pCur;
1202	}
1203
1204	VBOXUSB_UNLOCK();
1205
1206	/*
1207	* Should we release the device?
1208	*/
1209	if (m_fBeingUnloaded)
1210	{
1211	if (m_pDevice)
1212	{
1213	IOReturn irc = m_pDevice->ReEnumerateDevice(0); NOREF(irc);
1214	Log(("VBoxUSBDevice::stop([%p], %p {%s}): m_pDevice=%p unload & ReEnumerateDevice -> %#x\n",
1215	this, pProvider, pProvider->getName(), m_pDevice, irc));
1216	}
1217	else
1218	{
1219	IOUSBDevice *pDevice = OSDynamicCast(IOUSBDevice, pProvider);
1220	if (pDevice)
1221	{
1222	IOReturn irc = pDevice->ReEnumerateDevice(0); NOREF(irc);
1223	Log(("VBoxUSBDevice::stop([%p], %p {%s}): pDevice=%p unload & ReEnumerateDevice -> %#x\n",
1224	this, pProvider, pProvider->getName(), pDevice, irc));
1225	}
1226	else
1227	Log(("VBoxUSBDevice::stop([%p], %p {%s}): failed to cast provider to IOUSBDevice\n",
1228	this, pProvider, pProvider->getName()));
1229	}
1230	}
1231	else if (m_fReleaseOnClose)
1232	{
1233	ASMAtomicWriteBool(&m_fReleaseOnClose, false);
1234	if (m_pDevice)
1235	{
1236	IOReturn irc = m_pDevice->ReEnumerateDevice(0); NOREF(irc);
1237	Log(("VBoxUSBDevice::stop([%p], %p {%s}): m_pDevice=%p close & ReEnumerateDevice -> %#x\n",
1238	this, pProvider, pProvider->getName(), m_pDevice, irc));
1239	}
1240	}
1241
1242	/*
1243	* Close and release the IOUSBDevice if didn't do that already in message().
1244	*/
1245	if (m_pDevice)
1246	{
1247	/* close it */
1248	if (m_fOpen)
1249	{
1250	m_fOpenOnWasClosed = false;
1251	m_fOpen = false;
1252	m_pDevice->close(this, 0);
1253	}
1254
1255	/* release it (see start()) */
1256	m_pDevice->release();
1257	m_pDevice = NULL;
1258	}
1259
1260	#ifdef DEBUG
1261	/* avoid crashing on unload. */
1262	if (m_pNotifier)
1263	{
1264	m_pNotifier->release();
1265	m_pNotifier = NULL;
1266	}
1267	#endif
1268
1269	IOUSBUserClientInit::stop(pProvider);
1270	Log(("VBoxUSBDevice::stop: returns void\n"));
1271	}
1272
1273
1274	/**
1275	* Terminate the service (initiate the destruction).
1276	* @remark Only for logging.
1277	*/
1278	bool
1279	org_virtualbox_VBoxUSBDevice::terminate(IOOptionBits fOptions)
1280	{
1281	/* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */
1282	Log(("VBoxUSBDevice::terminate([%p], %#x)\n", this, fOptions));
1283
1284	/*
1285	* There aren't too many reasons why we gets terminated.
1286	* The most common one is that the device is being unplugged. Another is
1287	* that we've triggered reenumeration. In both cases we'll get a
1288	* kIOMessageServiceIsTerminated message before we're stopped.
1289	*
1290	* But, when we're unloaded the provider service isn't terminated, and
1291	* for some funny reason we're frequently causing kernel panics when the
1292	* device is detached (after we're unloaded). So, for now, let's try
1293	* re-enumerate it in stop.
1294	*
1295	* To avoid creating unnecessary trouble we'll try guess if we're being
1296	* unloaded from the option bit mask. (kIOServiceRecursing is private btw.)
1297	*/
1298	/** @todo would be nice if there was a documented way of doing the unload detection this, or
1299	* figure out what exactly we're doing wrong in the unload scenario. */
1300	if ((fOptions & 0xffff) == (kIOServiceRequired \| kIOServiceSynchronous))
1301	m_fBeingUnloaded = true;
1302
1303	return IOUSBUserClientInit::terminate(fOptions);
1304	}
1305
1306
1307	/**
1308	* Intercept open requests and only let Mr. Right (the VM process) open the device.
1309	* This is where it all gets a bit complicated...
1310	*
1311	* @return Status code.
1312	*
1313	* @param enmMsg The message number.
1314	* @param pProvider Pointer to the provider instance.
1315	* @param pvArg Message argument.
1316	*/
1317	IOReturn
1318	org_virtualbox_VBoxUSBDevice::message(UInt32 enmMsg, IOService pProvider, void pvArg)
1319	{
1320	Log(("VBoxUSBDevice::message([%p], %#x {%s}, %p {%s}, %p) - pid=%d\n",
1321	this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, RTProcSelf()));
1322
1323	IOReturn irc;
1324	switch (enmMsg)
1325	{
1326	/*
1327	* This message is send to the current IOService client from IOService::handleOpen(),
1328	* expecting it to call pProvider->close() if it agrees to the other party seizing
1329	* the service. It is also called in IOService::didTerminate() and perhaps some other
1330	* odd places. The way to find out is to examin the pvArg, which would be including
1331	* kIOServiceSeize if it's the handleOpen case.
1332	*
1333	* How to validate that the other end is actually our VM process? Well, IOKit doesn't
1334	* provide any clue about the new client really. But fortunately, it seems like the
1335	* calling task/process context when the VM tries to open the device is the VM process.
1336	* We'll ASSUME this'll remain like this for now...
1337	*/
1338	case kIOMessageServiceIsRequestingClose:
1339	irc = kIOReturnExclusiveAccess;
1340	/* If it's not a seize request, assume it's didTerminate and pray that it isn't a rouge driver.
1341	... weird, doesn't seem to match for the post has-terminated messages. */
1342	if (!((uintptr_t)pvArg & kIOServiceSeize))
1343	{
1344	Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d: not seize - closing...\n",
1345	this, pProvider, pProvider->getName(), pvArg, RTProcSelf()));
1346	m_fOpen = false;
1347	m_fOpenOnWasClosed = false;
1348	if (m_pDevice)
1349	m_pDevice->close(this, 0);
1350	m_Client = NIL_RTPROCESS;
1351	irc = kIOReturnSuccess;
1352	}
1353	else
1354	{
1355	if (org_virtualbox_VBoxUSBClient::isClientTask(current_task()))
1356	{
1357	Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d task=%p: client process, closing.\n",
1358	this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task()));
1359	m_fOpen = false;
1360	m_fOpenOnWasClosed = false;
1361	if (m_pDevice)
1362	m_pDevice->close(this, 0);
1363	m_fOpenOnWasClosed = true;
1364	m_Client = RTProcSelf();
1365	irc = kIOReturnSuccess;
1366	}
1367	else
1368	Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d task=%p: not client process!\n",
1369	this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task()));
1370	}
1371	if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */))
1372	Log(("VBoxUSBDevice::message: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n"));
1373	break;
1374
1375	/*
1376	* The service was closed by the current client.
1377	* Update the client property, check for scheduled re-enumeration and re-open.
1378	*
1379	* Note that we will not be called if we're doing the closing. (Even if we was
1380	* called in that case, the code should be able to handle it.)
1381	*/
1382	case kIOMessageServiceWasClosed:
1383	/*
1384	* Update the client property value.
1385	*/
1386	if (m_Client != NIL_RTPROCESS)
1387	{
1388	m_Client = NIL_RTPROCESS;
1389	if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */))
1390	Log(("VBoxUSBDevice::message: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n"));
1391	}
1392
1393	if (m_pDevice)
1394	{
1395	/*
1396	* Should we release the device?
1397	*/
1398	if (ASMAtomicXchgBool(&m_fReleaseOnClose, false))
1399	{
1400	m_fOpenOnWasClosed = false;
1401	irc = m_pDevice->ReEnumerateDevice(0);
1402	Log(("VBoxUSBDevice::message([%p], %p {%s}) - ReEnumerateDevice() -> %#x\n",
1403	this, pProvider, pProvider->getName(), irc));
1404	}
1405	/*
1406	* Should we attempt to re-open the device?
1407	*/
1408	else if (m_fOpenOnWasClosed)
1409	{
1410	Log(("VBoxUSBDevice::message: attempting to re-open the device...\n"));
1411	m_fOpenOnWasClosed = false;
1412	m_fOpen = m_pDevice->open(this, kIOServiceSeize, 0);
1413	if (!m_fOpen)
1414	Log(("VBoxUSBDevice::message: failed to open the device!\n"));
1415	m_fOpenOnWasClosed = !m_fOpen;
1416	}
1417	}
1418
1419	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1420	break;
1421
1422	/*
1423	* The IOUSBDevice is shutting down, so close it if we've opened it.
1424	*/
1425	case kIOMessageServiceIsTerminated:
1426	m_fBeingUnloaded = false;
1427	ASMAtomicWriteBool(&m_fReleaseOnClose, false);
1428	if (m_pDevice)
1429	{
1430	/* close it */
1431	if (m_fOpen)
1432	{
1433	m_fOpen = false;
1434	m_fOpenOnWasClosed = false;
1435	Log(("VBoxUSBDevice::message: closing the device (%p)...\n", m_pDevice));
1436	m_pDevice->close(this, 0);
1437	}
1438
1439	/* release it (see start()) */
1440	Log(("VBoxUSBDevice::message: releasing the device (%p)...\n", m_pDevice));
1441	m_pDevice->release();
1442	m_pDevice = NULL;
1443	}
1444
1445	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1446	break;
1447
1448	default:
1449	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1450	break;
1451	}
1452
1453	Log(("VBoxUSBDevice::message([%p], %#x {%s}, %p {%s}, %p) -> %#x\n",
1454	this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, irc));
1455	return irc;
1456	}
1457
1458
1459	/**
1460	* Schedule all devices belonging to the specified process for release.
1461	*
1462	* Devices that aren't currently in use will be released immediately.
1463	*
1464	* @param Owner The owner process.
1465	*/
1466	/* static */ void
1467	org_virtualbox_VBoxUSBDevice::scheduleReleaseByOwner(RTPROCESS Owner)
1468	{
1469	Log2(("VBoxUSBDevice::scheduleReleaseByOwner: Owner=%d\n", Owner));
1470	AssertReturnVoid(Owner && Owner != NIL_RTPROCESS);
1471
1472	/*
1473	* Walk the list of devices looking for device belonging to this process.
1474	*
1475	* If we release a device, we have to lave the spinlock and will therefore
1476	* have to restart the search.
1477	*/
1478	VBOXUSB_LOCK();
1479
1480	org_virtualbox_VBoxUSBDevice *pCur;
1481	do
1482	{
1483	for (pCur = s_pHead; pCur; pCur = pCur->m_pNext)
1484	{
1485	Log2(("VBoxUSBDevice::scheduleReleaseByOwner: pCur=%p m_Owner=%d (%s) m_fReleaseOnClose=%d\n",
1486	pCur, pCur->m_Owner, pCur->m_Owner == Owner ? "match" : "mismatch", pCur->m_fReleaseOnClose));
1487	if (pCur->m_Owner == Owner)
1488	{
1489	/* make sure we won't hit it again. */
1490	pCur->m_Owner = NIL_RTPROCESS;
1491	IOUSBDevice *pDevice = pCur->m_pDevice;
1492	if ( pDevice
1493	&& !pCur->m_fReleaseOnClose)
1494	{
1495	pCur->m_fOpenOnWasClosed = false;
1496	if (pCur->m_Client != NIL_RTPROCESS)
1497	{
1498	/* It's currently open, so just schedule it for re-enumeration on close. */
1499	ASMAtomicWriteBool(&pCur->m_fReleaseOnClose, true);
1500	Log(("VBoxUSBDevice::scheduleReleaseByOwner: %p {%s} - used by %d\n",
1501	pDevice, pDevice->getName(), pCur->m_Client));
1502	}
1503	else
1504	{
1505	/*
1506	* Get the USBDevice object and do the re-enumeration now.
1507	* Retain the device so we don't run into any trouble.
1508	*/
1509	pDevice->retain();
1510	VBOXUSB_UNLOCK();
1511
1512	IOReturn irc = pDevice->ReEnumerateDevice(0); NOREF(irc);
1513	Log(("VBoxUSBDevice::scheduleReleaseByOwner: %p {%s} - ReEnumerateDevice -> %#x\n",
1514	pDevice, pDevice->getName(), irc));
1515
1516	pDevice->release();
1517	VBOXUSB_LOCK();
1518	break;
1519	}
1520	}
1521	}
1522	}
1523	} while (pCur);
1524
1525	VBOXUSB_UNLOCK();
1526	}
1527
1528
1529	#ifdef DEBUG
1530	/static/ IOReturn
1531	org_virtualbox_VBoxUSBDevice::MyInterestHandler(void pvTarget, void pvRefCon, UInt32 enmMsgType,
1532	IOService pProvider, void pvMsgArg, vm_size_t cbMsgArg)
1533	{
1534	org_virtualbox_VBoxUSBDevice pThis = (org_virtualbox_VBoxUSBDevice )pvTarget;
1535	if (!pThis)
1536	return kIOReturnError;
1537
1538	switch (enmMsgType)
1539	{
1540	case kIOMessageServiceIsAttemptingOpen:
1541	/* pvMsgArg == the open() fOptions, so we could check for kIOServiceSeize if we care.
1542	We'll also get a kIIOServiceRequestingClose message() for that... */
1543	Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceIsAttemptingOpen - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1544	pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1545	break;
1546
1547	case kIOMessageServiceWasClosed:
1548	Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceWasClosed - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1549	pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1550	break;
1551
1552	case kIOMessageServiceIsTerminated:
1553	Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceIsTerminated - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1554	pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1555	break;
1556
1557	case kIOUSBMessagePortHasBeenReset:
1558	Log(("VBoxUSBDevice::MyInterestHandler: kIOUSBMessagePortHasBeenReset - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1559	pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1560	break;
1561
1562	default:
1563	Log(("VBoxUSBDevice::MyInterestHandler: %#x (%s) - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n",
1564	enmMsgType, DbgGetIOKitMessageName(enmMsgType), pvRefCon, pProvider, pvMsgArg, cbMsgArg));
1565	break;
1566	}
1567
1568	return kIOReturnSuccess;
1569	}
1570	#endif /* DEBUG */
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585	/*
1586	*
1587	* org_virtualbox_VBoxUSBInterface
1588	*
1589	*/
1590
1591	/**
1592	* Initialize our data members.
1593	*/
1594	bool
1595	org_virtualbox_VBoxUSBInterface::init(OSDictionary *pDictionary)
1596	{
1597	uint32_t cInstances = ASMAtomicIncU32(&g_cInstances);
1598	Log(("VBoxUSBInterface::init([%p], %p) new g_cInstances=%d\n", this, pDictionary, cInstances));
1599
1600	m_pInterface = NULL;
1601	m_fOpen = false;
1602	m_fOpenOnWasClosed = false;
1603
1604	return IOUSBUserClientInit::init(pDictionary);
1605	}
1606
1607
1608	/**
1609	* Free the object.
1610	* @remark Only for logging.
1611	*/
1612	void
1613	org_virtualbox_VBoxUSBInterface::free()
1614	{
1615	uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances);
1616	Log(("VBoxUSBInterfaces::free([%p]) new g_cInstances=%d\n", this, cInstances));
1617	IOUSBUserClientInit::free();
1618	}
1619
1620
1621	/**
1622	* Probe the interface to see if we're the right driver for it.
1623	*
1624	* We implement this similarly to org_virtualbox_VBoxUSBDevice, except that
1625	* we don't bother matching filters but instead just check if the parent is
1626	* handled by org_virtualbox_VBoxUSBDevice or not.
1627	*/
1628	IOService *
1629	org_virtualbox_VBoxUSBInterface::probe(IOService pProvider, SInt32 pi32Score)
1630	{
1631	Log(("VBoxUSBInterface::probe([%p], %p {%s}, %p={%d})\n", this,
1632	pProvider, pProvider->getName(), pi32Score, pi32Score ? *pi32Score : 0));
1633
1634	/*
1635	* Check if VBoxUSBDevice is the parent's driver.
1636	*/
1637	bool fHijackIt = false;
1638	const IORegistryPlane *pServicePlane = getPlane(kIOServicePlane);
1639	IORegistryEntry *pParent = pProvider->getParentEntry(pServicePlane);
1640	if (pParent)
1641	{
1642	Log(("VBoxUSBInterface::probe: pParent=%p {%s}\n", pParent, pParent->getName()));
1643
1644	OSIterator *pSiblings = pParent->getChildIterator(pServicePlane);
1645	if (pSiblings)
1646	{
1647	IORegistryEntry *pSibling;
1648	while ( (pSibling = OSDynamicCast(IORegistryEntry, pSiblings->getNextObject())) )
1649	{
1650	const OSMetaClass *pMetaClass = pSibling->getMetaClass();
1651	Log2(("sibling: %p - %s - %s\n", pMetaClass, pSibling->getName(), pMetaClass->getClassName()));
1652	if (pMetaClass == &org_virtualbox_VBoxUSBDevice::gMetaClass)
1653	{
1654	fHijackIt = true;
1655	break;
1656	}
1657	}
1658	pSiblings->release();
1659	}
1660	}
1661	if (!fHijackIt)
1662	{
1663	Log(("VBoxUSBInterface::probe: returns NULL\n"));
1664	return NULL;
1665	}
1666
1667	IOService *pRet = IOUSBUserClientInit::probe(pProvider, pi32Score);
1668	*pi32Score = _1G;
1669	Log(("VBoxUSBInterface::probe: returns %p and pi32Score=%d - hijack it.\n", pRet, pi32Score));
1670	return pRet;
1671	}
1672
1673
1674	/**
1675	* Start the driver (this), retain and open the USB interface object (pProvider).
1676	*/
1677	bool
1678	org_virtualbox_VBoxUSBInterface::start(IOService *pProvider)
1679	{
1680	Log(("VBoxUSBInterface::start([%p], %p {%s})\n", this, pProvider, pProvider->getName()));
1681
1682	/*
1683	* Exploit IOUSBUserClientInit to process IOProviderMergeProperties.
1684	*/
1685	IOUSBUserClientInit::start(pProvider); /* returns false */
1686
1687	/*
1688	* Retain the and open the interface (stop() or message() cleans up).
1689	*/
1690	bool fRc = true;
1691	m_pInterface = OSDynamicCast(IOUSBInterface, pProvider);
1692	if (m_pInterface)
1693	{
1694	m_pInterface->retain();
1695	m_fOpen = m_pInterface->open(this, kIOServiceSeize, 0);
1696	if (!m_fOpen)
1697	Log(("VBoxUSBInterface::start: failed to open the interface!\n"));
1698	m_fOpenOnWasClosed = !m_fOpen;
1699	}
1700	else
1701	{
1702	printf("VBoxUSBInterface::start([%p], %p {%s}): failed!\n", this, pProvider, pProvider->getName());
1703	fRc = false;
1704	}
1705
1706	Log(("VBoxUSBInterface::start: returns %d\n", fRc));
1707	return fRc;
1708	}
1709
1710
1711	/**
1712	* Close and release the USB interface object (pProvider) and stop the driver (this).
1713	*/
1714	void
1715	org_virtualbox_VBoxUSBInterface::stop(IOService *pProvider)
1716	{
1717	Log(("org_virtualbox_VBoxUSBInterface::stop([%p], %p {%s})\n", this, pProvider, pProvider->getName()));
1718
1719	/*
1720	* Close and release the IOUSBInterface if didn't do that already in message().
1721	*/
1722	if (m_pInterface)
1723	{
1724	/* close it */
1725	if (m_fOpen)
1726	{
1727	m_fOpenOnWasClosed = false;
1728	m_fOpen = false;
1729	m_pInterface->close(this, 0);
1730	}
1731
1732	/* release it (see start()) */
1733	m_pInterface->release();
1734	m_pInterface = NULL;
1735	}
1736
1737	IOUSBUserClientInit::stop(pProvider);
1738	Log(("VBoxUSBInterface::stop: returns void\n"));
1739	}
1740
1741
1742	/**
1743	* Terminate the service (initiate the destruction).
1744	* @remark Only for logging.
1745	*/
1746	bool
1747	org_virtualbox_VBoxUSBInterface::terminate(IOOptionBits fOptions)
1748	{
1749	/* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */
1750	Log(("VBoxUSBInterface::terminate([%p], %#x)\n", this, fOptions));
1751	return IOUSBUserClientInit::terminate(fOptions);
1752	}
1753
1754
1755	/**
1756	* @copydoc org_virtualbox_VBoxUSBDevice::message
1757	*/
1758	IOReturn
1759	org_virtualbox_VBoxUSBInterface::message(UInt32 enmMsg, IOService pProvider, void pvArg)
1760	{
1761	Log(("VBoxUSBInterface::message([%p], %#x {%s}, %p {%s}, %p)\n",
1762	this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg));
1763
1764	IOReturn irc;
1765	switch (enmMsg)
1766	{
1767	/*
1768	* See explanation in org_virtualbox_VBoxUSBDevice::message.
1769	*/
1770	case kIOMessageServiceIsRequestingClose:
1771	irc = kIOReturnExclusiveAccess;
1772	if (!((uintptr_t)pvArg & kIOServiceSeize))
1773	{
1774	Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d: not seize - closing...\n",
1775	this, pProvider, pProvider->getName(), pvArg, RTProcSelf()));
1776	m_fOpen = false;
1777	m_fOpenOnWasClosed = false;
1778	if (m_pInterface)
1779	m_pInterface->close(this, 0);
1780	irc = kIOReturnSuccess;
1781	}
1782	else
1783	{
1784	if (org_virtualbox_VBoxUSBClient::isClientTask(current_task()))
1785	{
1786	Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d task=%p: client process, closing.\n",
1787	this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task()));
1788	m_fOpen = false;
1789	m_fOpenOnWasClosed = false;
1790	if (m_pInterface)
1791	m_pInterface->close(this, 0);
1792	m_fOpenOnWasClosed = true;
1793	irc = kIOReturnSuccess;
1794	}
1795	else
1796	Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d task=%p: not client process!\n",
1797	this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task()));
1798	}
1799	break;
1800
1801	/*
1802	* The service was closed by the current client, check for re-open.
1803	*/
1804	case kIOMessageServiceWasClosed:
1805	if (m_pInterface && m_fOpenOnWasClosed)
1806	{
1807	Log(("VBoxUSBInterface::message: attempting to re-open the interface...\n"));
1808	m_fOpenOnWasClosed = false;
1809	m_fOpen = m_pInterface->open(this, kIOServiceSeize, 0);
1810	if (!m_fOpen)
1811	Log(("VBoxUSBInterface::message: failed to open the interface!\n"));
1812	m_fOpenOnWasClosed = !m_fOpen;
1813	}
1814
1815	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1816	break;
1817
1818	/*
1819	* The IOUSBInterface/Device is shutting down, so close and release.
1820	*/
1821	case kIOMessageServiceIsTerminated:
1822	if (m_pInterface)
1823	{
1824	/* close it */
1825	if (m_fOpen)
1826	{
1827	m_fOpen = false;
1828	m_fOpenOnWasClosed = false;
1829	m_pInterface->close(this, 0);
1830	}
1831
1832	/* release it (see start()) */
1833	m_pInterface->release();
1834	m_pInterface = NULL;
1835	}
1836
1837	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1838	break;
1839
1840	default:
1841	irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg);
1842	break;
1843	}
1844
1845	Log(("VBoxUSBInterface::message([%p], %#x {%s}, %p {%s}, %p) -> %#x\n",
1846	this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, irc));
1847	return irc;
1848	}
1849

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

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

Download in other formats: