VBoxGuest-freebsd.c@ 78376

Last change on this file since 78376 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.0 KB

Line
1	/* $Id: VBoxGuest-freebsd.c 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* VirtualBox Guest Additions Driver for FreeBSD.
4	*/
5
6	/*
7	* Copyright (C) 2007-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	/** @todo r=bird: This must merge with SUPDrv-freebsd.c before long. The two
28	* source files should only differ on prefixes and the extra bits wrt to the
29	* pci device. I.e. it should be diffable so that fixes to one can easily be
30	* applied to the other. */
31
32
33	/*********************************************************************************************************************************
34	* Header Files *
35	*********************************************************************************************************************************/
36	#include <sys/param.h>
37	#undef PVM
38	#include <sys/types.h>
39	#include <sys/module.h>
40	#include <sys/systm.h>
41	#include <sys/errno.h>
42	#include <sys/kernel.h>
43	#include <sys/fcntl.h>
44	#include <sys/conf.h>
45	#include <sys/uio.h>
46	#include <sys/bus.h>
47	#include <sys/poll.h>
48	#include <sys/selinfo.h>
49	#include <sys/queue.h>
50	#include <sys/lock.h>
51	#include <sys/lockmgr.h>
52	#include <sys/malloc.h>
53	#include <sys/file.h>
54	#include <sys/rman.h>
55	#include <machine/bus.h>
56	#include <machine/resource.h>
57	#include <dev/pci/pcivar.h>
58	#include <dev/pci/pcireg.h>
59
60	#include "VBoxGuestInternal.h"
61	#include <VBox/version.h>
62	#include <VBox/log.h>
63	#include <iprt/assert.h>
64	#include <iprt/initterm.h>
65	#include <iprt/process.h>
66	#include <iprt/string.h>
67	#include <iprt/mem.h>
68	#include <iprt/asm.h>
69
70
71	/*********************************************************************************************************************************
72	* Defined Constants And Macros *
73	*********************************************************************************************************************************/
74	/** The module name. */
75	#define DEVICE_NAME "vboxguest"
76
77
78	/*********************************************************************************************************************************
79	* Structures and Typedefs *
80	*********************************************************************************************************************************/
81	struct VBoxGuestDeviceState
82	{
83	/** Resource ID of the I/O port */
84	int iIOPortResId;
85	/** Pointer to the I/O port resource. */
86	struct resource *pIOPortRes;
87	/** Start address of the IO Port. */
88	uint16_t uIOPortBase;
89	/** Resource ID of the MMIO area */
90	int iVMMDevMemResId;
91	/** Pointer to the MMIO resource. */
92	struct resource *pVMMDevMemRes;
93	/** Handle of the MMIO resource. */
94	bus_space_handle_t VMMDevMemHandle;
95	/** Size of the memory area. */
96	bus_size_t VMMDevMemSize;
97	/** Mapping of the register space */
98	void *pMMIOBase;
99	/** IRQ number */
100	int iIrqResId;
101	/** IRQ resource handle. */
102	struct resource *pIrqRes;
103	/** Pointer to the IRQ handler. */
104	void *pfnIrqHandler;
105	/** VMMDev version */
106	uint32_t u32Version;
107	};
108
109
110	/*********************************************************************************************************************************
111	* Internal Functions *
112	*********************************************************************************************************************************/
113	/*
114	* Character device file handlers.
115	*/
116	static d_fdopen_t vgdrvFreeBSDOpen;
117	static d_close_t vgdrvFreeBSDClose;
118	static d_ioctl_t vgdrvFreeBSDIOCtl;
119	static int vgdrvFreeBSDIOCtlSlow(PVBOXGUESTSESSION pSession, u_long ulCmd, caddr_t pvData, struct thread *pTd);
120	static d_write_t vgdrvFreeBSDWrite;
121	static d_read_t vgdrvFreeBSDRead;
122	static d_poll_t vgdrvFreeBSDPoll;
123
124	/*
125	* IRQ related functions.
126	*/
127	static void vgdrvFreeBSDRemoveIRQ(device_t pDevice, void *pvState);
128	static int vgdrvFreeBSDAddIRQ(device_t pDevice, void *pvState);
129	static int vgdrvFreeBSDISR(void *pvState);
130
131
132	/*********************************************************************************************************************************
133	* Global Variables *
134	*********************************************************************************************************************************/
135	static MALLOC_DEFINE(M_VBOXGUEST, "vboxguest", "VirtualBox Guest Device Driver");
136
137	#ifndef D_NEEDMINOR
138	# define D_NEEDMINOR 0
139	#endif
140
141	/*
142	* The /dev/vboxguest character device entry points.
143	*/
144	static struct cdevsw g_vgdrvFreeBSDChrDevSW =
145	{
146	.d_version = D_VERSION,
147	.d_flags = D_TRACKCLOSE \| D_NEEDMINOR,
148	.d_fdopen = vgdrvFreeBSDOpen,
149	.d_close = vgdrvFreeBSDClose,
150	.d_ioctl = vgdrvFreeBSDIOCtl,
151	.d_read = vgdrvFreeBSDRead,
152	.d_write = vgdrvFreeBSDWrite,
153	.d_poll = vgdrvFreeBSDPoll,
154	.d_name = "vboxguest"
155	};
156
157	/** Device extention & session data association structure. */
158	static VBOXGUESTDEVEXT g_DevExt;
159
160	/** List of cloned device. Managed by the kernel. */
161	static struct clonedevs *g_pvgdrvFreeBSDClones;
162	/** The dev_clone event handler tag. */
163	static eventhandler_tag g_vgdrvFreeBSDEHTag;
164	/** Reference counter */
165	static volatile uint32_t cUsers;
166	/** selinfo structure used for polling. */
167	static struct selinfo g_SelInfo;
168
169	/**
170	* DEVFS event handler.
171	*/
172	static void vgdrvFreeBSDClone(void pvArg, struct ucred pCred, char pszName, int cchName, struct cdev *ppDev)
173	{
174	int iUnit;
175	int rc;
176
177	Log(("vgdrvFreeBSDClone: pszName=%s ppDev=%p\n", pszName, ppDev));
178
179	/*
180	* One device node per user, si_drv1 points to the session.
181	* /dev/vboxguest<N> where N = {0...255}.
182	*/
183	if (!ppDev)
184	return;
185	if (strcmp(pszName, "vboxguest") == 0)
186	iUnit = -1;
187	else if (dev_stdclone(pszName, NULL, "vboxguest", &iUnit) != 1)
188	return;
189	if (iUnit >= 256)
190	{
191	Log(("vgdrvFreeBSDClone: iUnit=%d >= 256 - rejected\n", iUnit));
192	return;
193	}
194
195	Log(("vgdrvFreeBSDClone: pszName=%s iUnit=%d\n", pszName, iUnit));
196
197	rc = clone_create(&g_pvgdrvFreeBSDClones, &g_vgdrvFreeBSDChrDevSW, &iUnit, ppDev, 0);
198	Log(("vgdrvFreeBSDClone: clone_create -> %d; iUnit=%d\n", rc, iUnit));
199	if (rc)
200	{
201	*ppDev = make_dev(&g_vgdrvFreeBSDChrDevSW,
202	iUnit,
203	UID_ROOT,
204	GID_WHEEL,
205	0664,
206	"vboxguest%d", iUnit);
207	if (*ppDev)
208	{
209	dev_ref(*ppDev);
210	(*ppDev)->si_flags \|= SI_CHEAPCLONE;
211	Log(("vgdrvFreeBSDClone: Created *ppDev=%p iUnit=%d si_drv1=%p si_drv2=%p\n",
212	ppDev, iUnit, (ppDev)->si_drv1, (*ppDev)->si_drv2));
213	(ppDev)->si_drv1 = (ppDev)->si_drv2 = NULL;
214	}
215	else
216	Log(("vgdrvFreeBSDClone: make_dev iUnit=%d failed\n", iUnit));
217	}
218	else
219	Log(("vgdrvFreeBSDClone: Existing *ppDev=%p iUnit=%d si_drv1=%p si_drv2=%p\n",
220	ppDev, iUnit, (ppDev)->si_drv1, (*ppDev)->si_drv2));
221	}
222
223	/**
224	* File open handler
225	*
226	*/
227	#if __FreeBSD_version >= 700000
228	static int vgdrvFreeBSDOpen(struct cdev pDev, int fOpen, struct thread pTd, struct file *pFd)
229	#else
230	static int vgdrvFreeBSDOpen(struct cdev pDev, int fOpen, struct thread pTd)
231	#endif
232	{
233	int rc;
234	PVBOXGUESTSESSION pSession;
235	uint32_t fRequestor;
236	struct ucred *pCred = curthread->td_ucred;
237	if (!pCred)
238	pCred = curproc->p_ucred;
239
240	LogFlow(("vgdrvFreeBSDOpen:\n"));
241
242	/*
243	* Try grab it (we don't grab the giant, remember).
244	*/
245	if (!ASMAtomicCmpXchgPtr(&pDev->si_drv1, (void *)0x42, NULL))
246	return EBUSY;
247
248	/*
249	* Create a new session.
250	*/
251	fRequestor = VMMDEV_REQUESTOR_USERMODE \| VMMDEV_REQUESTOR_TRUST_NOT_GIVEN;
252	if (pCred && pCred->cr_uid == 0)
253	fRequestor \|= VMMDEV_REQUESTOR_USR_ROOT;
254	else
255	fRequestor \|= VMMDEV_REQUESTOR_USR_USER;
256	if (pCred && groupmember(0, pCred))
257	fRequestor \|= VMMDEV_REQUESTOR_GRP_WHEEL;
258	fRequestor \|= VMMDEV_REQUESTOR_NO_USER_DEVICE; /** @todo implement /dev/vboxuser
259	if (!fUnrestricted)
260	fRequestor \|= VMMDEV_REQUESTOR_USER_DEVICE; */
261	fRequestor \|= VMMDEV_REQUESTOR_CON_DONT_KNOW; /** @todo see if we can figure out console relationship of pProc. */
262	rc = VGDrvCommonCreateUserSession(&g_DevExt, fRequestor, &pSession);
263	if (RT_SUCCESS(rc))
264	{
265	if (ASMAtomicCmpXchgPtr(&pDev->si_drv1, pSession, (void *)0x42))
266	{
267	Log(("vgdrvFreeBSDOpen: success - g_DevExt=%p pSession=%p rc=%d pid=%d\n", &g_DevExt, pSession, rc, (int)RTProcSelf()));
268	ASMAtomicIncU32(&cUsers);
269	return 0;
270	}
271
272	VGDrvCommonCloseSession(&g_DevExt, pSession);
273	}
274
275	LogRel(("vgdrvFreeBSDOpen: failed. rc=%d\n", rc));
276	return RTErrConvertToErrno(rc);
277	}
278
279	/**
280	* File close handler
281	*
282	*/
283	static int vgdrvFreeBSDClose(struct cdev pDev, int fFile, int DevType, struct thread pTd)
284	{
285	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pDev->si_drv1;
286	Log(("vgdrvFreeBSDClose: fFile=%#x pSession=%p\n", fFile, pSession));
287
288	/*
289	* Close the session if it's still hanging on to the device...
290	*/
291	if (VALID_PTR(pSession))
292	{
293	VGDrvCommonCloseSession(&g_DevExt, pSession);
294	if (!ASMAtomicCmpXchgPtr(&pDev->si_drv1, NULL, pSession))
295	Log(("vgdrvFreeBSDClose: si_drv1=%p expected %p!\n", pDev->si_drv1, pSession));
296	ASMAtomicDecU32(&cUsers);
297	/* Don't use destroy_dev here because it may sleep resulting in a hanging user process. */
298	destroy_dev_sched(pDev);
299	}
300	else
301	Log(("vgdrvFreeBSDClose: si_drv1=%p!\n", pSession));
302	return 0;
303	}
304
305
306	/**
307	* I/O control request.
308	*
309	* @returns depends...
310	* @param pDev The device.
311	* @param ulCmd The command.
312	* @param pvData Pointer to the data.
313	* @param fFile The file descriptor flags.
314	* @param pTd The calling thread.
315	*/
316	static int vgdrvFreeBSDIOCtl(struct cdev pDev, u_long ulCmd, caddr_t pvData, int fFile, struct thread pTd)
317	{
318	PVBOXGUESTSESSION pSession;
319	devfs_get_cdevpriv((void **)&pSession);
320
321	/*
322	* Deal with the fast ioctl path first.
323	*/
324	if (VBGL_IOCTL_IS_FAST(ulCmd))
325	return VGDrvCommonIoCtlFast(ulCmd, &g_DevExt, pSession);
326
327	return vgdrvFreeBSDIOCtlSlow(pSession, ulCmd, pvData, pTd);
328	}
329
330
331	/**
332	* Deal with the 'slow' I/O control requests.
333	*
334	* @returns 0 on success, appropriate errno on failure.
335	* @param pSession The session.
336	* @param ulCmd The command.
337	* @param pvData The request data.
338	* @param pTd The calling thread.
339	*/
340	static int vgdrvFreeBSDIOCtlSlow(PVBOXGUESTSESSION pSession, u_long ulCmd, caddr_t pvData, struct thread *pTd)
341	{
342	PVBGLREQHDR pHdr;
343	uint32_t cbReq = IOCPARM_LEN(ulCmd);
344	void *pvUser = NULL;
345
346	/*
347	* Buffered request?
348	*/
349	if ((IOC_DIRMASK & ulCmd) == IOC_INOUT)
350	{
351	pHdr = (PVBGLREQHDR)pvData;
352	if (RT_UNLIKELY(cbReq < sizeof(*pHdr)))
353	{
354	LogRel(("vgdrvFreeBSDIOCtlSlow: cbReq=%#x < %#x; ulCmd=%#lx\n", cbReq, (int)sizeof(*pHdr), ulCmd));
355	return EINVAL;
356	}
357	if (RT_UNLIKELY(pHdr->uVersion != VBGLREQHDR_VERSION))
358	{
359	LogRel(("vgdrvFreeBSDIOCtlSlow: bad uVersion=%#x; ulCmd=%#lx\n", pHdr->uVersion, ulCmd));
360	return EINVAL;
361	}
362	if (RT_UNLIKELY( RT_MAX(pHdr->cbIn, pHdr->cbOut) != cbReq
363	\|\| pHdr->cbIn < sizeof(*pHdr)
364	\|\| (pHdr->cbOut < sizeof(*pHdr) && pHdr->cbOut != 0)))
365	{
366	LogRel(("vgdrvFreeBSDIOCtlSlow: max(%#x,%#x) != %#x; ulCmd=%#lx\n", pHdr->cbIn, pHdr->cbOut, cbReq, ulCmd));
367	return EINVAL;
368	}
369	}
370	/*
371	* Big unbuffered request?
372	*/
373	else if ((IOC_DIRMASK & ulCmd) == IOC_VOID && !cbReq)
374	{
375	/*
376	* Read the header, validate it and figure out how much that needs to be buffered.
377	*/
378	VBGLREQHDR Hdr;
379	pvUser = (void *)pvData;
380	int rc = copyin(pvUser, &Hdr, sizeof(Hdr));
381	if (RT_UNLIKELY(rc))
382	{
383	LogRel(("vgdrvFreeBSDIOCtlSlow: copyin(%p,Hdr,) -> %#x; ulCmd=%#lx\n", pvUser, rc, ulCmd));
384	return rc;
385	}
386	if (RT_UNLIKELY(Hdr.uVersion != VBGLREQHDR_VERSION))
387	{
388	LogRel(("vgdrvFreeBSDIOCtlSlow: bad uVersion=%#x; ulCmd=%#lx\n", Hdr.uVersion, ulCmd));
389	return EINVAL;
390	}
391	cbReq = RT_MAX(Hdr.cbIn, Hdr.cbOut);
392	if (RT_UNLIKELY( Hdr.cbIn < sizeof(Hdr)
393	\|\| (Hdr.cbOut < sizeof(Hdr) && Hdr.cbOut != 0)
394	\|\| cbReq > _1M*16))
395	{
396	LogRel(("vgdrvFreeBSDIOCtlSlow: max(%#x,%#x); ulCmd=%#lx\n", Hdr.cbIn, Hdr.cbOut, ulCmd));
397	return EINVAL;
398	}
399
400	/*
401	* Allocate buffer and copy in the data.
402	*/
403	pHdr = (PVBGLREQHDR)RTMemTmpAlloc(cbReq);
404	if (RT_UNLIKELY(!pHdr))
405	{
406	LogRel(("vgdrvFreeBSDIOCtlSlow: failed to allocate buffer of %d bytes; ulCmd=%#lx\n", cbReq, ulCmd));
407	return ENOMEM;
408	}
409	rc = copyin(pvUser, pHdr, Hdr.cbIn);
410	if (RT_UNLIKELY(rc))
411	{
412	LogRel(("vgdrvFreeBSDIOCtlSlow: copyin(%p,%p,%#x) -> %#x; ulCmd=%#lx\n",
413	pvUser, pHdr, Hdr.cbIn, rc, ulCmd));
414	RTMemTmpFree(pHdr);
415	return rc;
416	}
417	if (Hdr.cbIn < cbReq)
418	RT_BZERO((uint8_t *)pHdr + Hdr.cbIn, cbReq - Hdr.cbIn);
419	}
420	else
421	{
422	Log(("vgdrvFreeBSDIOCtlSlow: huh? cbReq=%#x ulCmd=%#lx\n", cbReq, ulCmd));
423	return EINVAL;
424	}
425
426	/*
427	* Process the IOCtl.
428	*/
429	int rc = VGDrvCommonIoCtl(ulCmd, &g_DevExt, pSession, pHdr, cbReq);
430	if (RT_LIKELY(!rc))
431	{
432	/*
433	* If unbuffered, copy back the result before returning.
434	*/
435	if (pvUser)
436	{
437	uint32_t cbOut = pHdr->cbOut;
438	if (cbOut > cbReq)
439	{
440	LogRel(("vgdrvFreeBSDIOCtlSlow: too much output! %#x > %#x; uCmd=%#lx!\n", cbOut, cbReq, ulCmd));
441	cbOut = cbReq;
442	}
443	rc = copyout(pHdr, pvUser, cbOut);
444	if (RT_UNLIKELY(rc))
445	LogRel(("vgdrvFreeBSDIOCtlSlow: copyout(%p,%p,%#x) -> %d; uCmd=%#lx!\n", pHdr, pvUser, cbOut, rc, ulCmd));
446
447	Log(("vgdrvFreeBSDIOCtlSlow: returns %d / %d ulCmd=%lx\n", 0, pHdr->rc, ulCmd));
448
449	/* cleanup */
450	RTMemTmpFree(pHdr);
451	}
452	}
453	else
454	{
455	/*
456	* The request failed, just clean up.
457	*/
458	if (pvUser)
459	RTMemTmpFree(pHdr);
460
461	Log(("vgdrvFreeBSDIOCtlSlow: ulCmd=%lx pData=%p failed, rc=%d\n", ulCmd, pvData, rc));
462	rc = EINVAL;
463	}
464
465	return rc;
466	}
467
468
469	/**
470	* @note This code is duplicated on other platforms with variations, so please
471	* keep them all up to date when making changes!
472	*/
473	int VBOXCALL VBoxGuestIDC(void *pvSession, uintptr_t uReq, PVBGLREQHDR pReqHdr, size_t cbReq)
474	{
475	/*
476	* Simple request validation (common code does the rest).
477	*/
478	int rc;
479	if ( RT_VALID_PTR(pReqHdr)
480	&& cbReq >= sizeof(*pReqHdr))
481	{
482	/*
483	* All requests except the connect one requires a valid session.
484	*/
485	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pvSession;
486	if (pSession)
487	{
488	if ( RT_VALID_PTR(pSession)
489	&& pSession->pDevExt == &g_DevExt)
490	rc = VGDrvCommonIoCtl(uReq, &g_DevExt, pSession, pReqHdr, cbReq);
491	else
492	rc = VERR_INVALID_HANDLE;
493	}
494	else if (uReq == VBGL_IOCTL_IDC_CONNECT)
495	{
496	rc = VGDrvCommonCreateKernelSession(&g_DevExt, &pSession);
497	if (RT_SUCCESS(rc))
498	{
499	rc = VGDrvCommonIoCtl(uReq, &g_DevExt, pSession, pReqHdr, cbReq);
500	if (RT_FAILURE(rc))
501	VGDrvCommonCloseSession(&g_DevExt, pSession);
502	}
503	}
504	else
505	rc = VERR_INVALID_HANDLE;
506	}
507	else
508	rc = VERR_INVALID_POINTER;
509	return rc;
510	}
511
512
513	static int vgdrvFreeBSDPoll(struct cdev pDev, int fEvents, struct thread td)
514	{
515	int fEventsProcessed;
516
517	LogFlow(("vgdrvFreeBSDPoll: fEvents=%d\n", fEvents));
518
519	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pDev->si_drv1;
520	if (RT_UNLIKELY(!VALID_PTR(pSession))) {
521	Log(("vgdrvFreeBSDPoll: no state data for %s\n", devtoname(pDev)));
522	return (fEvents & (POLLHUP\|POLLIN\|POLLRDNORM\|POLLOUT\|POLLWRNORM));
523	}
524
525	uint32_t u32CurSeq = ASMAtomicUoReadU32(&g_DevExt.u32MousePosChangedSeq);
526	if (pSession->u32MousePosChangedSeq != u32CurSeq)
527	{
528	fEventsProcessed = fEvents & (POLLIN \| POLLRDNORM);
529	pSession->u32MousePosChangedSeq = u32CurSeq;
530	}
531	else
532	{
533	fEventsProcessed = 0;
534
535	selrecord(td, &g_SelInfo);
536	}
537
538	return fEventsProcessed;
539	}
540
541	static int vgdrvFreeBSDWrite(struct cdev pDev, struct uio pUio, int fIo)
542	{
543	return 0;
544	}
545
546	static int vgdrvFreeBSDRead(struct cdev pDev, struct uio pUio, int fIo)
547	{
548	return 0;
549	}
550
551	static int vgdrvFreeBSDDetach(device_t pDevice)
552	{
553	struct VBoxGuestDeviceState *pState = device_get_softc(pDevice);
554
555	if (cUsers > 0)
556	return EBUSY;
557
558	/*
559	* Reverse what we did in vgdrvFreeBSDAttach.
560	*/
561	if (g_vgdrvFreeBSDEHTag != NULL)
562	EVENTHANDLER_DEREGISTER(dev_clone, g_vgdrvFreeBSDEHTag);
563
564	clone_cleanup(&g_pvgdrvFreeBSDClones);
565
566	vgdrvFreeBSDRemoveIRQ(pDevice, pState);
567
568	if (pState->pVMMDevMemRes)
569	bus_release_resource(pDevice, SYS_RES_MEMORY, pState->iVMMDevMemResId, pState->pVMMDevMemRes);
570	if (pState->pIOPortRes)
571	bus_release_resource(pDevice, SYS_RES_IOPORT, pState->iIOPortResId, pState->pIOPortRes);
572
573	VGDrvCommonDeleteDevExt(&g_DevExt);
574
575	RTR0Term();
576
577	return 0;
578	}
579
580
581	/**
582	* Interrupt service routine.
583	*
584	* @returns Whether the interrupt was from VMMDev.
585	* @param pvState Opaque pointer to the device state.
586	*/
587	static int vgdrvFreeBSDISR(void *pvState)
588	{
589	LogFlow(("vgdrvFreeBSDISR: pvState=%p\n", pvState));
590
591	bool fOurIRQ = VGDrvCommonISR(&g_DevExt);
592
593	return fOurIRQ ? 0 : 1;
594	}
595
596	void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
597	{
598	LogFlow(("VGDrvNativeISRMousePollEvent:\n"));
599
600	/*
601	* Wake up poll waiters.
602	*/
603	selwakeup(&g_SelInfo);
604	}
605
606
607	bool VGDrvNativeProcessOption(PVBOXGUESTDEVEXT pDevExt, const char pszName, const char pszValue)
608	{
609	RT_NOREF(pDevExt); RT_NOREF(pszName); RT_NOREF(pszValue);
610	return false;
611	}
612
613
614	/**
615	* Sets IRQ for VMMDev.
616	*
617	* @returns FreeBSD error code.
618	* @param pDevice Pointer to the device info structure.
619	* @param pvState Pointer to the state info structure.
620	*/
621	static int vgdrvFreeBSDAddIRQ(device_t pDevice, void *pvState)
622	{
623	int iResId = 0;
624	int rc = 0;
625	struct VBoxGuestDeviceState pState = (struct VBoxGuestDeviceState )pvState;
626
627	pState->pIrqRes = bus_alloc_resource_any(pDevice, SYS_RES_IRQ, &iResId, RF_SHAREABLE \| RF_ACTIVE);
628
629	#if __FreeBSD_version >= 700000
630	rc = bus_setup_intr(pDevice, pState->pIrqRes, INTR_TYPE_BIO \| INTR_MPSAFE, NULL, (driver_intr_t *)vgdrvFreeBSDISR, pState,
631	&pState->pfnIrqHandler);
632	#else
633	rc = bus_setup_intr(pDevice, pState->pIrqRes, INTR_TYPE_BIO, (driver_intr_t *)vgdrvFreeBSDISR, pState, &pState->pfnIrqHandler);
634	#endif
635
636	if (rc)
637	{
638	pState->pfnIrqHandler = NULL;
639	return VERR_DEV_IO_ERROR;
640	}
641
642	pState->iIrqResId = iResId;
643
644	return VINF_SUCCESS;
645	}
646
647	/**
648	* Removes IRQ for VMMDev.
649	*
650	* @param pDevice Pointer to the device info structure.
651	* @param pvState Opaque pointer to the state info structure.
652	*/
653	static void vgdrvFreeBSDRemoveIRQ(device_t pDevice, void *pvState)
654	{
655	struct VBoxGuestDeviceState pState = (struct VBoxGuestDeviceState )pvState;
656
657	if (pState->pIrqRes)
658	{
659	bus_teardown_intr(pDevice, pState->pIrqRes, pState->pfnIrqHandler);
660	bus_release_resource(pDevice, SYS_RES_IRQ, 0, pState->pIrqRes);
661	}
662	}
663
664	static int vgdrvFreeBSDAttach(device_t pDevice)
665	{
666	int rc;
667	int iResId;
668	struct VBoxGuestDeviceState *pState;
669
670	cUsers = 0;
671
672	/*
673	* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
674	*/
675	rc = RTR0Init(0);
676	if (RT_FAILURE(rc))
677	{
678	LogFunc(("RTR0Init failed.\n"));
679	return ENXIO;
680	}
681
682	pState = device_get_softc(pDevice);
683
684	/*
685	* Allocate I/O port resource.
686	*/
687	iResId = PCIR_BAR(0);
688	pState->pIOPortRes = bus_alloc_resource_any(pDevice, SYS_RES_IOPORT, &iResId, RF_ACTIVE);
689	pState->uIOPortBase = rman_get_start(pState->pIOPortRes);
690	pState->iIOPortResId = iResId;
691	if (pState->uIOPortBase)
692	{
693	/*
694	* Map the MMIO region.
695	*/
696	iResId = PCIR_BAR(1);
697	pState->pVMMDevMemRes = bus_alloc_resource_any(pDevice, SYS_RES_MEMORY, &iResId, RF_ACTIVE);
698	pState->VMMDevMemHandle = rman_get_bushandle(pState->pVMMDevMemRes);
699	pState->VMMDevMemSize = rman_get_size(pState->pVMMDevMemRes);
700
701	pState->pMMIOBase = rman_get_virtual(pState->pVMMDevMemRes);
702	pState->iVMMDevMemResId = iResId;
703	if (pState->pMMIOBase)
704	{
705	/*
706	* Call the common device extension initializer.
707	*/
708	rc = VGDrvCommonInitDevExt(&g_DevExt, pState->uIOPortBase,
709	pState->pMMIOBase, pState->VMMDevMemSize,
710	#if ARCH_BITS == 64
711	VBOXOSTYPE_FreeBSD_x64,
712	#else
713	VBOXOSTYPE_FreeBSD,
714	#endif
715	VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
716	if (RT_SUCCESS(rc))
717	{
718	/*
719	* Add IRQ of VMMDev.
720	*/
721	rc = vgdrvFreeBSDAddIRQ(pDevice, pState);
722	if (RT_SUCCESS(rc))
723	{
724	/*
725	* Read host configuration.
726	*/
727	VGDrvCommonProcessOptionsFromHost(&g_DevExt);
728
729	/*
730	* Configure device cloning.
731	*/
732	clone_setup(&g_pvgdrvFreeBSDClones);
733	g_vgdrvFreeBSDEHTag = EVENTHANDLER_REGISTER(dev_clone, vgdrvFreeBSDClone, 0, 1000);
734	if (g_vgdrvFreeBSDEHTag)
735	{
736	printf(DEVICE_NAME ": loaded successfully\n");
737	return 0;
738	}
739
740	printf(DEVICE_NAME ": EVENTHANDLER_REGISTER(dev_clone,,,) failed\n");
741	clone_cleanup(&g_pvgdrvFreeBSDClones);
742	vgdrvFreeBSDRemoveIRQ(pDevice, pState);
743	}
744	else
745	printf((DEVICE_NAME ": VGDrvCommonInitDevExt failed.\n"));
746	VGDrvCommonDeleteDevExt(&g_DevExt);
747	}
748	else
749	printf((DEVICE_NAME ": vgdrvFreeBSDAddIRQ failed.\n"));
750	}
751	else
752	printf((DEVICE_NAME ": MMIO region setup failed.\n"));
753	}
754	else
755	printf((DEVICE_NAME ": IOport setup failed.\n"));
756
757	RTR0Term();
758	return ENXIO;
759	}
760
761	static int vgdrvFreeBSDProbe(device_t pDevice)
762	{
763	if ((pci_get_vendor(pDevice) == VMMDEV_VENDORID) && (pci_get_device(pDevice) == VMMDEV_DEVICEID))
764	return 0;
765
766	return ENXIO;
767	}
768
769	static device_method_t vgdrvFreeBSDMethods[] =
770	{
771	/* Device interface. */
772	DEVMETHOD(device_probe, vgdrvFreeBSDProbe),
773	DEVMETHOD(device_attach, vgdrvFreeBSDAttach),
774	DEVMETHOD(device_detach, vgdrvFreeBSDDetach),
775	{0,0}
776	};
777
778	static driver_t vgdrvFreeBSDDriver =
779	{
780	DEVICE_NAME,
781	vgdrvFreeBSDMethods,
782	sizeof(struct VBoxGuestDeviceState),
783	};
784
785	static devclass_t vgdrvFreeBSDClass;
786
787	DRIVER_MODULE(vboxguest, pci, vgdrvFreeBSDDriver, vgdrvFreeBSDClass, 0, 0);
788	MODULE_VERSION(vboxguest, 1);
789

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

source: vbox/trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-freebsd.c@ 78376

Download in other formats: