SUPDrv-solaris.c@ 4547

Last change on this file since 4547 was 4474, checked in by vboxsync, 18 years ago
Solaris.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 19.5 KB

Line
1	/** @file
2	* VBox host drivers - Ring-0 support drivers - Solaris host:
3	* Solaris driver C code
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#include <sys/types.h>
23	#include <sys/param.h>
24	#include <sys/errno.h>
25	#include <sys/uio.h>
26	#include <sys/buf.h>
27	#include <sys/modctl.h>
28	#include <sys/open.h>
29	#include <sys/conf.h>
30	#include <sys/cmn_err.h>
31	#include <sys/stat.h>
32	#include <sys/ddi.h>
33	#include <sys/sunddi.h>
34	#include <sys/file.h>
35
36	#include "SUPDRV.h"
37	#include <iprt/spinlock.h>
38	#include <iprt/process.h>
39	#include <iprt/initterm.h>
40	#include <iprt/alloc.h>
41
42
43	/*******************************************************************************
44	* Defined Constants And Macros *
45	*******************************************************************************/
46	/** The module name. */
47	#define DEVICE_NAME "vboxdrv"
48	#define DEVICE_DESC "VirtualBox Driver"
49	#define DEVICE_MAXINSTANCES 16
50
51
52	/*******************************************************************************
53	* Internal Functions *
54	*******************************************************************************/
55	static int VBoxDrvSolarisOpen(dev_t* pDev, int fFlag, int fType, cred_t* pCred);
56	static int VBoxDrvSolarisClose(dev_t Dev, int fFlag, int fType, cred_t* pCred);
57	static int VBoxDrvSolarisRead(dev_t Dev, struct uio* pUio, cred_t* pCred);
58	static int VBoxDrvSolarisWrite(dev_t Dev, struct uio* pUio, cred_t* pCred);
59	static int VBoxDrvSolarisIOCtl (dev_t Dev, int Cmd, intptr_t pArgs, int mode, cred_t* pCred, int* pVal);
60
61	static int VBoxDrvSolarisAttach(dev_info_t* pDip, ddi_attach_cmd_t Cmd);
62	static int VBoxDrvSolarisDetach(dev_info_t* pDip, ddi_detach_cmd_t Cmd);
63
64	static int VBoxSupDrvErr2SolarisErr(int rc);
65	static int VBoxDrvSolarisIOCtlSlow(PSUPDRVSESSION pSession, int Cmd, int Mode, intptr_t pArgs);
66
67
68	/*******************************************************************************
69	* Global Variables *
70	*******************************************************************************/
71	/**
72	* cb_ops: for drivers that support char/block entry points
73	*/
74	static struct cb_ops g_VBoxDrvSolarisCbOps =
75	{
76	VBoxDrvSolarisOpen,
77	VBoxDrvSolarisClose,
78	nodev, /* b strategy */
79	nodev, /* b dump */
80	nodev, /* b print */
81	VBoxDrvSolarisRead,
82	VBoxDrvSolarisWrite,
83	VBoxDrvSolarisIOCtl,
84	nodev, /* c devmap */
85	nodev, /* c mmap */
86	nodev, /* c segmap */
87	nochpoll, /* c poll */
88	ddi_prop_op, /* property ops */
89	NULL, /* streamtab */
90	D_NEW \| D_MP, /* compat. flag */
91	CB_REV /* revision */
92	};
93
94	/**
95	* dev_ops: for driver device operations
96	*/
97	static struct dev_ops g_VBoxDrvSolarisDevOps =
98	{
99	DEVO_REV, /* driver build revision */
100	0, /* ref count */
101	nulldev, /* get info */
102	nulldev, /* identify */
103	nulldev, /* probe */
104	VBoxDrvSolarisAttach,
105	VBoxDrvSolarisDetach,
106	nodev, /* reset */
107	&g_VBoxDrvSolarisCbOps,
108	(struct bus_ops *)0,
109	nodev /* power */
110	};
111
112	/**
113	* modldrv: export driver specifics to the kernel
114	*/
115	static struct modldrv g_VBoxDrvSolarisModule =
116	{
117	&mod_driverops, /* extern from kernel */
118	DEVICE_DESC,
119	&g_VBoxDrvSolarisDevOps
120	};
121
122	/**
123	* modlinkage: export install/remove/info to the kernel
124	*/
125	static struct modlinkage g_VBoxDrvSolarisModLinkage =
126	{
127	MODREV_1, /* loadable module system revision */
128	&g_VBoxDrvSolarisModule,
129	NULL /* terminate array of linkage structures */
130	};
131
132	/** State info. each our kernel module instances */
133	typedef struct
134	{
135	dev_info_t* pDip; /* Device handle */
136	} vbox_devstate_t;
137
138	/** Opaque pointer to state */
139	static void* g_pVBoxDrvSolarisState;
140
141	/** Device extention & session data association structure */
142	static SUPDRVDEVEXT g_DevExt;
143
144	/* GCC C++ hack. */
145	unsigned __gxx_personality_v0 = 0xcccccccc;
146
147	/** Hash table */
148	static PSUPDRVSESSION g_apSessionHashTab[19];
149	/** Spinlock protecting g_apSessionHashTab. */
150	static RTSPINLOCK g_Spinlock = NIL_RTSPINLOCK;
151	/** Calculates bucket index into g_apSessionHashTab.*/
152	#define SESSION_HASH(sfn) ((sfn) % RT_ELEMENTS(g_apSessionHashTab))
153
154	/**
155	* Kernel entry points
156	*/
157	int _init (void)
158	{
159	cmn_err(CE_CONT, "VBoxDrvSolaris _init");
160
161	int e = ddi_soft_state_init(&g_pVBoxDrvSolarisState, sizeof (vbox_devstate_t), 1);
162	if (e != 0)
163	return e;
164
165	e = mod_install(&g_VBoxDrvSolarisModLinkage);
166	if (e != 0)
167	ddi_soft_state_fini(&g_pVBoxDrvSolarisState);
168
169	return e;
170	}
171
172	int _fini (void)
173	{
174	cmn_err(CE_CONT, "VBoxDrvSolaris _fini");
175
176	int e = mod_remove(&g_VBoxDrvSolarisModLinkage);
177	if (e != 0)
178	return e;
179
180	ddi_soft_state_fini(&g_pVBoxDrvSolarisState);
181	return e;
182	}
183
184	int _info (struct modinfo *pModInfo)
185	{
186	cmn_err(CE_CONT, "VBoxDrvSolaris _info");
187	return mod_info (&g_VBoxDrvSolarisModLinkage, pModInfo);
188	}
189
190	/**
191	* User context entry points
192	*/
193	static int VBoxDrvSolarisOpen(dev_t pDev, int fFlag, int fType, cred_t pCred)
194	{
195	cmn_err(CE_CONT, "VBoxDrvSolarisOpen");
196
197	int rc;
198	PSUPDRVSESSION pSession;
199
200	/*
201	* Create a new session.
202	* Sessions in Solaris driver are mostly useless. It's however needed
203	* in VBoxDrvSolarisIOCtlSlow() while calling supdrvIOCtl()
204	*/
205	rc = supdrvCreateSession(&g_DevExt, &pSession);
206	if (RT_SUCCESS(rc))
207	{
208	cmn_err(CE_NOTE,"supdrvCreateSession success");
209	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
210	unsigned iHash;
211
212	pSession->Uid = crgetuid(pCred);
213	pSession->Gid = crgetgid(pCred);
214	pSession->Process = RTProcSelf();
215	pSession->R0Process = RTR0ProcHandleSelf();
216
217	/*
218	* Insert it into the hash table.
219	*/
220	iHash = SESSION_HASH(pSession->Process);
221	RTSpinlockAcquireNoInts(g_Spinlock, &Tmp);
222	pSession->pNextHash = g_apSessionHashTab[iHash];
223	g_apSessionHashTab[iHash] = pSession;
224	RTSpinlockReleaseNoInts(g_Spinlock, &Tmp);
225	cmn_err(CE_NOTE,"VBoxDrvSolarisOpen success");
226	}
227
228	int instance;
229	for (instance = 0; instance < DEVICE_MAXINSTANCES; instance++)
230	{
231	vbox_devstate_t *pState = ddi_get_soft_state (g_pVBoxDrvSolarisState, instance);
232	if (pState)
233	break;
234	}
235
236	if (instance >= DEVICE_MAXINSTANCES)
237	{
238	cmn_err(CE_NOTE, "All instances exhausted\n");
239	return ENXIO;
240	}
241
242	pDev = makedevice(getmajor(pDev), instance);
243
244	return VBoxSupDrvErr2SolarisErr(rc);
245	}
246
247	static int VBoxDrvSolarisClose(dev_t pDev, int flag, int otyp, cred_t *cred)
248	{
249	cmn_err(CE_CONT, "VBoxDrvSolarisClose");
250
251	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
252	const RTPROCESS Process = RTProcSelf();
253	const unsigned iHash = SESSION_HASH(Process);
254	PSUPDRVSESSION pSession;
255
256	/*
257	* Remove from the hash table.
258	*/
259	RTSpinlockAcquireNoInts(g_Spinlock, &Tmp);
260	pSession = g_apSessionHashTab[iHash];
261	if (pSession)
262	{
263	if (pSession->Process == Process)
264	{
265	g_apSessionHashTab[iHash] = pSession->pNextHash;
266	pSession->pNextHash = NULL;
267	}
268	else
269	{
270	PSUPDRVSESSION pPrev = pSession;
271	pSession = pSession->pNextHash;
272	while (pSession)
273	{
274	if (pSession->Process == Process)
275	{
276	pPrev->pNextHash = pSession->pNextHash;
277	pSession->pNextHash = NULL;
278	break;
279	}
280
281	/* next */
282	pPrev = pSession;
283	pSession = pSession->pNextHash;
284	}
285	}
286	}
287	RTSpinlockReleaseNoInts(g_Spinlock, &Tmp);
288	if (!pSession)
289	{
290	OSDBGPRINT(("VBoxDrvSolarisClose: WHAT?!? pSession == NULL! This must be a mistake... pid=%d (close)\n",
291	(int)Process));
292	return DDI_FAILURE;
293	}
294
295	/*
296	* Close the session.
297	*/
298	supdrvCloseSession(&g_DevExt, pSession);
299	return DDI_SUCCESS;
300	}
301
302	static int VBoxDrvSolarisRead(dev_t dev, struct uio* pUio, cred_t* credp)
303	{
304	cmn_err(CE_CONT, "VBoxDrvSolarisRead");
305	return DDI_SUCCESS;
306	}
307
308	static int VBoxDrvSolarisWrite(dev_t dev, struct uio* pUio, cred_t* credp)
309	{
310	cmn_err(CE_CONT, "VBoxDrvSolarisWrite");
311	return DDI_SUCCESS;
312	}
313
314	/**
315	* Attach entry point, to attach a device to the system or resume it.
316	*
317	* @param pDip The module structure instance.
318	* @param enmCmd Attach type (ddi_attach_cmd_t)
319	*
320	* @return corresponding solaris error code.
321	*/
322	static int VBoxDrvSolarisAttach(dev_info_t* pDip, ddi_attach_cmd_t enmCmd)
323	{
324	cmn_err(CE_CONT, "VBoxDrvSolarisAttach");
325	int rc = VINF_SUCCESS;
326	int instance = 0;
327	vbox_devstate_t* pState;
328
329	switch (enmCmd)
330	{
331	case DDI_ATTACH:
332	{
333	instance = ddi_get_instance (pDip);
334
335	if (ddi_soft_state_zalloc(g_pVBoxDrvSolarisState, instance) != DDI_SUCCESS)
336	{
337	cmn_err(CE_NOTE, "VBoxDrvSolarisAttach: state alloc failed");
338	return DDI_FAILURE;
339	}
340
341	pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
342
343	/*
344	* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
345	*/
346	rc = RTR0Init(0);
347	if (RT_SUCCESS(rc))
348	{
349	/*
350	* Initialize the device extension
351	*/
352	rc = supdrvInitDevExt(&g_DevExt);
353	if (RT_SUCCESS(rc))
354	{
355	/*
356	* Initialize the session hash table.
357	*/
358	memset(g_apSessionHashTab, 0, sizeof(g_apSessionHashTab));
359	rc = RTSpinlockCreate(&g_Spinlock);
360	if (RT_SUCCESS(rc))
361	{
362	/*
363	* Register ourselves as a character device, pseudo-driver
364	*/
365	if (ddi_create_minor_node(pDip, "0", S_IFCHR,
366	instance, DDI_PSEUDO, 0) == DDI_SUCCESS)
367	{
368	pState->pDip = pDip;
369	ddi_report_dev(pDip);
370	return DDI_SUCCESS;
371	}
372
373	/* Is this really necessary? */
374	ddi_remove_minor_node(pDip, NULL);
375	cmn_err(CE_NOTE,"VBoxDrvSolarisAttach: ddi_create_minor_node failed.");
376
377	RTSpinlockDestroy(g_Spinlock);
378	g_Spinlock = NIL_RTSPINLOCK;
379	}
380	else
381	cmn_err(CE_NOTE, "VBoxDrvSolarisAttach: RTSpinlockCreate failed");
382	supdrvDeleteDevExt(&g_DevExt);
383	}
384	else
385	cmn_err(CE_NOTE, "VBoxDrvSolarisAttach: supdrvInitDevExt failed");
386	RTR0Term ();
387	}
388	else
389	cmn_err(CE_NOTE, "VBoxDrvSolarisAttach: failed to init R0Drv");
390	memset(&g_DevExt, 0, sizeof(g_DevExt));
391	break;
392	}
393
394	default:
395	return DDI_FAILURE;
396	}
397
398	return DDI_FAILURE;
399	}
400
401	/**
402	* Detach entry point, to detach a device to the system or suspend it.
403	*
404	* @param pDip The module structure instance.
405	* @param enmCmd Attach type (ddi_attach_cmd_t)
406	*
407	* @return corresponding solaris error code.
408	*/
409	static int VBoxDrvSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
410	{
411	int rc = VINF_SUCCESS;
412	int instance;
413	register vbox_devstate_t* pState;
414
415	cmn_err(CE_CONT, "VBoxDrvSolarisDetach");
416	switch (enmCmd)
417	{
418	case DDI_DETACH:
419	{
420	instance = ddi_get_instance(pDip);
421	pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
422
423	ddi_remove_minor_node(pDip, NULL);
424	ddi_soft_state_free(g_pVBoxDrvSolarisState, instance);
425
426	rc = supdrvDeleteDevExt(&g_DevExt);
427	AssertRC(rc);
428
429	rc = RTSpinlockDestroy(g_Spinlock);
430	AssertRC(rc);
431	g_Spinlock = NIL_RTSPINLOCK;
432
433	RTR0Term();
434
435	memset(&g_DevExt, 0, sizeof(g_DevExt));
436	cmn_err(CE_CONT, "VBoxDrvSolarisDetach: Clean Up Done.");
437	return DDI_SUCCESS;
438	}
439
440	default:
441	return DDI_FAILURE;
442	}
443	}
444
445	/**
446	* Driver ioctl, an alternate entry point for this character driver.
447	*
448	* @param Dev Device number
449	* @param Cmd Operation identifier
450	* @param pArg Arguments from user to driver
451	* @param Mode Information bitfield (read/write, address space etc.)
452	* @param pCred User credentials
453	* @param pVal Return value for calling process.
454	*
455	* @return corresponding solaris error code.
456	*/
457	static int VBoxDrvSolarisIOCtl (dev_t Dev, int Cmd, intptr_t pArgs, int Mode, cred_t* pCred, int* pVal)
458	{
459	RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
460	const RTPROCESS Process = RTProcSelf();
461	const unsigned iHash = SESSION_HASH(Process);
462	PSUPDRVSESSION pSession;
463
464	cmn_err(CE_CONT, "VBoxDrvSolarisIOCtl\n");
465	/*
466	* Find the session.
467	*/
468	RTSpinlockAcquireNoInts(g_Spinlock, &Tmp);
469	pSession = g_apSessionHashTab[iHash];
470	if (pSession && pSession->Process != Process)
471	{
472	do pSession = pSession->pNextHash;
473	while (pSession && pSession->Process != Process);
474	}
475	RTSpinlockReleaseNoInts(g_Spinlock, &Tmp);
476	if (!pSession)
477	{
478	OSDBGPRINT(("VBoxSupDrvIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#x\n",
479	(int)Process, Cmd));
480	return EINVAL;
481	}
482
483	/*
484	* Deal with the two high-speed IOCtl that takes it's arguments from
485	* the session and iCmd, and only returns a VBox status code.
486	*/
487	#ifdef VBOX_WITHOUT_IDT_PATCHING
488	if ( Cmd == SUP_IOCTL_FAST_DO_RAW_RUN
489	\|\| Cmd == SUP_IOCTL_FAST_DO_HWACC_RUN
490	\|\| Cmd == SUP_IOCTL_FAST_DO_NOP)
491	return supdrvIOCtlFast(Cmd, &g_DevExt, pSession);
492	#endif
493
494	return VBoxDrvSolarisIOCtlSlow(pSession, Cmd, Mode, pArgs);
495	}
496
497	/**
498	* Worker for VBoxSupDrvIOCtl that takes the slow IOCtl functions.
499	*
500	* @returns Solaris errno.
501	*
502	* @param pSession The session.
503	* @param Cmd The IOCtl command.
504	* @param Mode Information bitfield (for specifying ownership of data)
505	* @param pArgs Pointer to the kernel copy of the SUPDRVIOCTLDATA buffer.
506	*/
507	static int VBoxDrvSolarisIOCtlSlow(PSUPDRVSESSION pSession, int Cmd, int Mode, intptr_t pArgs)
508	{
509	int rc;
510	void *pvBuf = NULL;
511	unsigned long cbBuf = 0;
512	unsigned cbOut = 0;
513	PSUPDRVIOCTLDATA pArgData = (PSUPDRVIOCTLDATA)pArgs;
514
515	/*
516	* Allocate and copy user space input data buffer to kernel space.
517	*/
518	if (pArgData->cbIn > 0 \|\| pArgData->cbOut > 0)
519	{
520	cbBuf = max(pArgData->cbIn, pArgData->cbOut);
521	pvBuf = RTMemTmpAlloc(cbBuf);
522
523	if (pvBuf == NULL)
524	{
525	OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: failed to allocate buffer of %d bytes.\n", cbBuf));
526	return ENOMEM;
527	}
528
529	rc = ddi_copyin(pArgData->pvIn, pvBuf, pArgData->cbIn, Mode);
530
531	if (rc != 0)
532	{
533	OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: ddi_copyin(%p,%d) failed.\n", pArgData->pvIn, pArgData->cbIn));
534
535	RTMemTmpFree(pvBuf);
536	return EFAULT;
537	}
538	}
539
540	/*
541	* Process the IOCtl.
542	*/
543	rc = supdrvIOCtl(Cmd, &g_DevExt, pSession, pvBuf, pArgData->cbIn, pvBuf, pArgData->cbOut, &cbOut);
544
545	/*
546	* Copy ioctl data and output buffer back to user space.
547	*/
548	if (rc != 0)
549	rc = VBoxSupDrvErr2SolarisErr(rc);
550	else if (cbOut > 0)
551	{
552	if (pvBuf != NULL && cbOut <= cbBuf)
553	{
554	rc = ddi_copyout(pvBuf, pArgData->pvOut, cbOut, Mode);
555	if (rc != 0)
556	{
557	OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: ddi_copyout(,%p,%d) failed.\n", pArgData->pvOut, cbBuf));
558
559	/** @todo r=bird: why this extra return? setting rc = EFAULT; should do the trick, shouldn't it? */
560	RTMemTmpFree(pvBuf);
561	return EFAULT;
562	}
563	}
564	else
565	{
566	OSDBGPRINT(("WHAT!?! supdrvIOCtl messed up! cbOut=%d cbBuf=%d pvBuf=%p\n", cbOut, cbBuf, pvBuf));
567	rc = EPERM;
568	}
569	}
570
571	if (pvBuf)
572	RTMemTmpFree(pvBuf);
573
574	OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: returns %d cbOut=%d\n", rc, cbOut));
575	return rc;
576	}
577
578
579	/**
580	* Converts an supdrv error code to a solaris error code.
581	*
582	* @returns corresponding solaris error code.
583	* @param rc supdrv error code (SUPDRV_ERR_* defines).
584	*/
585	static int VBoxSupDrvErr2SolarisErr(int rc)
586	{
587	switch (rc)
588	{
589	case 0: return 0;
590	case SUPDRV_ERR_GENERAL_FAILURE: return EACCES;
591	case SUPDRV_ERR_INVALID_PARAM: return EINVAL;
592	case SUPDRV_ERR_INVALID_MAGIC: return EILSEQ;
593	case SUPDRV_ERR_INVALID_HANDLE: return ENXIO;
594	case SUPDRV_ERR_INVALID_POINTER: return EFAULT;
595	case SUPDRV_ERR_LOCK_FAILED: return ENOLCK;
596	case SUPDRV_ERR_ALREADY_LOADED: return EEXIST;
597	case SUPDRV_ERR_PERMISSION_DENIED: return EPERM;
598	case SUPDRV_ERR_VERSION_MISMATCH: return ENOSYS;
599	}
600
601	return EPERM;
602	}
603
604	/**
605	* Initializes any OS specific object creator fields.
606	*/
607	void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
608	{
609	NOREF(pObj);
610	NOREF(pSession);
611	}
612
613
614	/**
615	* Checks if the session can access the object.
616	*
617	* @returns true if a decision has been made.
618	* @returns false if the default access policy should be applied.
619	*
620	* @param pObj The object in question.
621	* @param pSession The session wanting to access the object.
622	* @param pszObjName The object name, can be NULL.
623	* @param prc Where to store the result when returning true.
624	*/
625	bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char pszObjName, int prc)
626	{
627	NOREF(pObj);
628	NOREF(pSession);
629	NOREF(pszObjName);
630	NOREF(prc);
631	return false;
632	}
633
634	RTDECL(int) SUPR0Printf(const char *pszFormat, ...)
635	{
636	va_list args;
637	char szMsg[512];
638
639	va_start(args, pszFormat);
640	vsnprintf(szMsg, sizeof(szMsg) - 1, pszFormat, args);
641	va_end(args);
642
643	szMsg[sizeof(szMsg) - 1] = '\0';
644	printf("%s", szMsg);
645	return 0;
646	}

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

source: vbox/trunk/src/VBox/HostDrivers/Support/solaris/SUPDrv-solaris.c@ 4547

Download in other formats: