SUPDrv-solaris.c@ 44042

Last change on this file since 44042 was 43394, checked in by vboxsync, 13 years ago
VMM: HM cleanup.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 35.7 KB

Line
1	/* $Id: SUPDrv-solaris.c 43394 2012-09-21 11:11:17Z vboxsync $ */
2	/** @file
3	* VBoxDrv - The VirtualBox Support Driver - Solaris specifics.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	/*******************************************************************************
28	* Header Files *
29	*******************************************************************************/
30	#define LOG_GROUP LOG_GROUP_SUP_DRV
31	#ifdef DEBUG_ramshankar
32	# define LOG_ENABLED
33	# define LOG_INSTANCE RTLogRelDefaultInstance()
34	#endif
35	#include <sys/types.h>
36	#include <sys/param.h>
37	#include <sys/errno.h>
38	#include <sys/uio.h>
39	#include <sys/buf.h>
40	#include <sys/modctl.h>
41	#include <sys/kobj.h>
42	#include <sys/kobj_impl.h>
43	#include <sys/open.h>
44	#include <sys/conf.h>
45	#include <sys/cmn_err.h>
46	#include <sys/stat.h>
47	#include <sys/ddi.h>
48	#include <sys/sunddi.h>
49	#include <sys/file.h>
50	#include <sys/priv_names.h>
51	#undef u /* /usr/include/sys/user.h:249:1 is where this is defined to (curproc->p_user). very cool. */
52
53	#include "../SUPDrvInternal.h"
54	#include <VBox/log.h>
55	#include <VBox/version.h>
56	#include <iprt/semaphore.h>
57	#include <iprt/spinlock.h>
58	#include <iprt/mp.h>
59	#include <iprt/path.h>
60	#include <iprt/power.h>
61	#include <iprt/process.h>
62	#include <iprt/thread.h>
63	#include <iprt/initterm.h>
64	#include <iprt/alloc.h>
65	#include <iprt/string.h>
66	#include <iprt/err.h>
67
68	#include "dtrace/SUPDrv.h"
69
70
71	/*******************************************************************************
72	* Defined Constants And Macros *
73	*******************************************************************************/
74	/** The module name. */
75	#define DEVICE_NAME "vboxdrv"
76	/** The module description as seen in 'modinfo'. */
77	#define DEVICE_DESC "VirtualBox HostDrv"
78	/** Maximum number of driver instances. */
79	#define DEVICE_MAXINSTANCES 16
80
81
82	/*******************************************************************************
83	* Internal Functions *
84	*******************************************************************************/
85	static int VBoxDrvSolarisOpen(dev_t pDev, int fFlag, int fType, cred_t pCred);
86	static int VBoxDrvSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred);
87	static int VBoxDrvSolarisRead(dev_t Dev, struct uio pUio, cred_t pCred);
88	static int VBoxDrvSolarisWrite(dev_t Dev, struct uio pUio, cred_t pCred);
89	static int VBoxDrvSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArgs, int mode, cred_t pCred, int pVal);
90
91	static int VBoxDrvSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t Cmd);
92	static int VBoxDrvSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t Cmd);
93
94	static int VBoxSupDrvErr2SolarisErr(int rc);
95	static int VBoxDrvSolarisIOCtlSlow(PSUPDRVSESSION pSession, int Cmd, int Mode, intptr_t pArgs);
96
97
98	/*******************************************************************************
99	* Global Variables *
100	*******************************************************************************/
101	/**
102	* cb_ops: for drivers that support char/block entry points
103	*/
104	static struct cb_ops g_VBoxDrvSolarisCbOps =
105	{
106	VBoxDrvSolarisOpen,
107	VBoxDrvSolarisClose,
108	nodev, /* b strategy */
109	nodev, /* b dump */
110	nodev, /* b print */
111	VBoxDrvSolarisRead,
112	VBoxDrvSolarisWrite,
113	VBoxDrvSolarisIOCtl,
114	nodev, /* c devmap */
115	nodev, /* c mmap */
116	nodev, /* c segmap */
117	nochpoll, /* c poll */
118	ddi_prop_op, /* property ops */
119	NULL, /* streamtab */
120	D_NEW \| D_MP, /* compat. flag */
121	CB_REV /* revision */
122	};
123
124	/**
125	* dev_ops: for driver device operations
126	*/
127	static struct dev_ops g_VBoxDrvSolarisDevOps =
128	{
129	DEVO_REV, /* driver build revision */
130	0, /* ref count */
131	nulldev, /* get info */
132	nulldev, /* identify */
133	nulldev, /* probe */
134	VBoxDrvSolarisAttach,
135	VBoxDrvSolarisDetach,
136	nodev, /* reset */
137	&g_VBoxDrvSolarisCbOps,
138	(struct bus_ops *)0,
139	nodev /* power */
140	};
141
142	/**
143	* modldrv: export driver specifics to the kernel
144	*/
145	static struct modldrv g_VBoxDrvSolarisModule =
146	{
147	&mod_driverops, /* extern from kernel */
148	DEVICE_DESC " " VBOX_VERSION_STRING "r" RT_XSTR(VBOX_SVN_REV),
149	&g_VBoxDrvSolarisDevOps
150	};
151
152	/**
153	* modlinkage: export install/remove/info to the kernel
154	*/
155	static struct modlinkage g_VBoxDrvSolarisModLinkage =
156	{
157	MODREV_1, /* loadable module system revision */
158	{
159	&g_VBoxDrvSolarisModule,
160	NULL /* terminate array of linkage structures */
161	}
162	};
163
164	#ifndef USE_SESSION_HASH
165	/**
166	* State info for each open file handle.
167	*/
168	typedef struct
169	{
170	/*< Pointer to the session data. /
171	PSUPDRVSESSION pSession;
172	} vbox_devstate_t;
173	#else
174	/** State info. for each driver instance. */
175	typedef struct
176	{
177	dev_info_t pDip; / Device handle */
178	} vbox_devstate_t;
179	#endif
180
181	/** Opaque pointer to list of state */
182	static void *g_pVBoxDrvSolarisState;
183
184	/** Device extention & session data association structure */
185	static SUPDRVDEVEXT g_DevExt;
186
187	/** Hash table */
188	static PSUPDRVSESSION g_apSessionHashTab[19];
189	/** Spinlock protecting g_apSessionHashTab. */
190	static RTSPINLOCK g_Spinlock = NIL_RTSPINLOCK;
191	/** Calculates bucket index into g_apSessionHashTab.*/
192	#define SESSION_HASH(sfn) ((sfn) % RT_ELEMENTS(g_apSessionHashTab))
193
194	/**
195	* Kernel entry points
196	*/
197	int _init(void)
198	{
199	LogFlowFunc((DEVICE_NAME ":_init\n"));
200
201	/*
202	* Prevent module autounloading.
203	*/
204	modctl_t *pModCtl = mod_getctl(&g_VBoxDrvSolarisModLinkage);
205	if (pModCtl)
206	pModCtl->mod_loadflags \|= MOD_NOAUTOUNLOAD;
207	else
208	LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
209
210	/*
211	* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
212	*/
213	int rc = RTR0Init(0);
214	if (RT_SUCCESS(rc))
215	{
216	/*
217	* Initialize the device extension
218	*/
219	rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
220	if (RT_SUCCESS(rc))
221	{
222	/*
223	* Initialize the session hash table.
224	*/
225	memset(g_apSessionHashTab, 0, sizeof(g_apSessionHashTab));
226	rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxDrvSol");
227	if (RT_SUCCESS(rc))
228	{
229	rc = ddi_soft_state_init(&g_pVBoxDrvSolarisState, sizeof(vbox_devstate_t), 8);
230	if (!rc)
231	{
232	rc = mod_install(&g_VBoxDrvSolarisModLinkage);
233	if (!rc)
234	return rc; /* success */
235
236	ddi_soft_state_fini(&g_pVBoxDrvSolarisState);
237	LogRel((DEVICE_NAME ":mod_install failed! rc=%d\n", rc));
238	}
239	else
240	LogRel((DEVICE_NAME ":failed to initialize soft state.\n"));
241
242	RTSpinlockDestroy(g_Spinlock);
243	g_Spinlock = NIL_RTSPINLOCK;
244	}
245	else
246	{
247	LogRel((DEVICE_NAME ":VBoxDrvSolarisAttach: RTSpinlockCreate failed\n"));
248	rc = RTErrConvertToErrno(rc);
249	}
250	supdrvDeleteDevExt(&g_DevExt);
251	}
252	else
253	{
254	LogRel((DEVICE_NAME ":VBoxDrvSolarisAttach: supdrvInitDevExt failed\n"));
255	rc = RTErrConvertToErrno(rc);
256	}
257	RTR0TermForced();
258	}
259	else
260	{
261	LogRel((DEVICE_NAME ":VBoxDrvSolarisAttach: failed to init R0Drv\n"));
262	rc = RTErrConvertToErrno(rc);
263	}
264	memset(&g_DevExt, 0, sizeof(g_DevExt));
265
266	return rc;
267	}
268
269
270	int _fini(void)
271	{
272	LogFlowFunc((DEVICE_NAME ":_fini\n"));
273
274	/*
275	* Undo the work we did at start (in the reverse order).
276	*/
277	int rc = mod_remove(&g_VBoxDrvSolarisModLinkage);
278	if (rc != 0)
279	return rc;
280
281	supdrvDeleteDevExt(&g_DevExt);
282
283	rc = RTSpinlockDestroy(g_Spinlock);
284	AssertRC(rc);
285	g_Spinlock = NIL_RTSPINLOCK;
286
287	RTR0TermForced();
288
289	memset(&g_DevExt, 0, sizeof(g_DevExt));
290
291	ddi_soft_state_fini(&g_pVBoxDrvSolarisState);
292	return 0;
293	}
294
295
296	int _info(struct modinfo *pModInfo)
297	{
298	LogFlowFunc((DEVICE_NAME ":_info\n"));
299	int e = mod_info(&g_VBoxDrvSolarisModLinkage, pModInfo);
300	return e;
301	}
302
303
304	/**
305	* Attach entry point, to attach a device to the system or resume it.
306	*
307	* @param pDip The module structure instance.
308	* @param enmCmd Operation type (attach/resume).
309	*
310	* @return corresponding solaris error code.
311	*/
312	static int VBoxDrvSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
313	{
314	LogFlowFunc((DEVICE_NAME ":VBoxDrvSolarisAttach\n"));
315
316	switch (enmCmd)
317	{
318	case DDI_ATTACH:
319	{
320	int rc;
321	int instance = ddi_get_instance(pDip);
322	#ifdef USE_SESSION_HASH
323	vbox_devstate_t *pState;
324
325	if (ddi_soft_state_zalloc(g_pVBoxDrvSolarisState, instance) != DDI_SUCCESS)
326	{
327	LogRel((DEVICE_NAME ":VBoxDrvSolarisAttach: state alloc failed\n"));
328	return DDI_FAILURE;
329	}
330
331	pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
332	#endif
333
334	/*
335	* Register for suspend/resume notifications
336	*/
337	rc = ddi_prop_create(DDI_DEV_T_NONE, pDip, DDI_PROP_CANSLEEP /* kmem alloc can sleep */,
338	"pm-hardware-state", "needs-suspend-resume", sizeof("needs-suspend-resume"));
339	if (rc != DDI_PROP_SUCCESS)
340	LogRel((DEVICE_NAME ":Suspend/Resume notification registration failed.\n"));
341
342	/*
343	* Register ourselves as a character device, pseudo-driver
344	*/
345	#ifdef VBOX_WITH_HARDENING
346	rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME, S_IFCHR, instance, DDI_PSEUDO,
347	0, NULL, NULL, 0600);
348	#else
349	rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME, S_IFCHR, instance, DDI_PSEUDO,
350	0, "none", "none", 0666);
351	#endif
352	if (rc == DDI_SUCCESS)
353	{
354	#ifdef USE_SESSION_HASH
355	pState->pDip = pDip;
356	#endif
357	ddi_report_dev(pDip);
358	return DDI_SUCCESS;
359	}
360
361	return DDI_FAILURE;
362	}
363
364	case DDI_RESUME:
365	{
366	#if 0
367	RTSemFastMutexRequest(g_DevExt.mtxGip);
368	if (g_DevExt.pGipTimer)
369	RTTimerStart(g_DevExt.pGipTimer, 0);
370
371	RTSemFastMutexRelease(g_DevExt.mtxGip);
372	#endif
373	RTPowerSignalEvent(RTPOWEREVENT_RESUME);
374	LogFlow((DEVICE_NAME ": Awakened from suspend.\n"));
375	return DDI_SUCCESS;
376	}
377
378	default:
379	return DDI_FAILURE;
380	}
381
382	return DDI_FAILURE;
383	}
384
385
386	/**
387	* Detach entry point, to detach a device to the system or suspend it.
388	*
389	* @param pDip The module structure instance.
390	* @param enmCmd Operation type (detach/suspend).
391	*
392	* @return corresponding solaris error code.
393	*/
394	static int VBoxDrvSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
395	{
396	LogFlowFunc((DEVICE_NAME ":VBoxDrvSolarisDetach\n"));
397	switch (enmCmd)
398	{
399	case DDI_DETACH:
400	{
401	#ifndef USE_SESSION_HASH
402	ddi_remove_minor_node(pDip, NULL);
403	#else
404	int instance = ddi_get_instance(pDip);
405	vbox_devstate_t *pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
406	ddi_remove_minor_node(pDip, NULL);
407	ddi_soft_state_free(g_pVBoxDrvSolarisState, instance);
408	#endif
409	ddi_prop_remove_all(pDip);
410	return DDI_SUCCESS;
411	}
412
413	case DDI_SUSPEND:
414	{
415	#if 0
416	RTSemFastMutexRequest(g_DevExt.mtxGip);
417	if (g_DevExt.pGipTimer && g_DevExt.cGipUsers > 0)
418	RTTimerStop(g_DevExt.pGipTimer);
419
420	RTSemFastMutexRelease(g_DevExt.mtxGip);
421	#endif
422	RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
423	LogFlow((DEVICE_NAME ": Falling to suspend mode.\n"));
424	return DDI_SUCCESS;
425
426	}
427
428	default:
429	return DDI_FAILURE;
430	}
431	}
432
433
434
435	/**
436	* User context entry points
437	*/
438	static int VBoxDrvSolarisOpen(dev_t pDev, int fFlag, int fType, cred_t pCred)
439	{
440	int rc;
441	PSUPDRVSESSION pSession;
442	LogFlowFunc((DEVICE_NAME ":VBoxDrvSolarisOpen: pDev=%p:%#x\n", pDev, *pDev));
443
444	#ifndef USE_SESSION_HASH
445	/*
446	* Locate a new device open instance.
447	*
448	* For each open call we'll allocate an item in the soft state of the device.
449	* The item index is stored in the dev_t. I hope this is ok...
450	*/
451	vbox_devstate_t *pState = NULL;
452	unsigned iOpenInstance;
453	for (iOpenInstance = 0; iOpenInstance < 4096; iOpenInstance++)
454	{
455	if ( !ddi_get_soft_state(g_pVBoxDrvSolarisState, iOpenInstance) /* faster */
456	&& ddi_soft_state_zalloc(g_pVBoxDrvSolarisState, iOpenInstance) == DDI_SUCCESS)
457	{
458	pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, iOpenInstance);
459	break;
460	}
461	}
462	if (!pState)
463	{
464	LogRel((DEVICE_NAME ":VBoxDrvSolarisOpen: too many open instances.\n"));
465	return ENXIO;
466	}
467
468	/*
469	* Create a new session.
470	*/
471	rc = supdrvCreateSession(&g_DevExt, true /* fUser */, &pSession);
472	if (RT_SUCCESS(rc))
473	{
474	pSession->Uid = crgetruid(pCred);
475	pSession->Gid = crgetrgid(pCred);
476
477	pState->pSession = pSession;
478	pDev = makedevice(getmajor(pDev), iOpenInstance);
479	LogFlow((DEVICE_NAME ":VBoxDrvSolarisOpen: Dev=%#x pSession=%p pid=%d r0proc=%p thread=%p\n",
480	*pDev, pSession, RTProcSelf(), RTR0ProcHandleSelf(), RTThreadNativeSelf() ));
481	return 0;
482	}
483
484	/* failed - clean up */
485	ddi_soft_state_free(g_pVBoxDrvSolarisState, iOpenInstance);
486
487	#else
488	/*
489	* Create a new session.
490	* Sessions in Solaris driver are mostly useless. It's however needed
491	* in VBoxDrvSolarisIOCtlSlow() while calling supdrvIOCtl()
492	*/
493	rc = supdrvCreateSession(&g_DevExt, true /* fUser */, &pSession);
494	if (RT_SUCCESS(rc))
495	{
496	unsigned iHash;
497
498	pSession->Uid = crgetruid(pCred);
499	pSession->Gid = crgetrgid(pCred);
500
501	/*
502	* Insert it into the hash table.
503	*/
504	iHash = SESSION_HASH(pSession->Process);
505	RTSpinlockAcquire(g_Spinlock);
506	pSession->pNextHash = g_apSessionHashTab[iHash];
507	g_apSessionHashTab[iHash] = pSession;
508	RTSpinlockReleaseNoInts(g_Spinlock);
509	LogFlow((DEVICE_NAME ":VBoxDrvSolarisOpen success\n"));
510	}
511
512	int instance;
513	for (instance = 0; instance < DEVICE_MAXINSTANCES; instance++)
514	{
515	vbox_devstate_t *pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
516	if (pState)
517	break;
518	}
519
520	if (instance >= DEVICE_MAXINSTANCES)
521	{
522	LogRel((DEVICE_NAME ":VBoxDrvSolarisOpen: All instances exhausted\n"));
523	return ENXIO;
524	}
525
526	pDev = makedevice(getmajor(pDev), instance);
527	#endif
528
529	return VBoxSupDrvErr2SolarisErr(rc);
530	}
531
532
533	static int VBoxDrvSolarisClose(dev_t Dev, int flag, int otyp, cred_t *cred)
534	{
535	LogFlowFunc((DEVICE_NAME ":VBoxDrvSolarisClose: Dev=%#x\n", Dev));
536
537	#ifndef USE_SESSION_HASH
538	/*
539	* Get the session and free the soft state item.
540	*/
541	vbox_devstate_t *pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, getminor(Dev));
542	if (!pState)
543	{
544	LogRel((DEVICE_NAME ":VBoxDrvSolarisClose: no state data for %#x (%d)\n", Dev, getminor(Dev)));
545	return EFAULT;
546	}
547
548	PSUPDRVSESSION pSession = pState->pSession;
549	pState->pSession = NULL;
550	ddi_soft_state_free(g_pVBoxDrvSolarisState, getminor(Dev));
551
552	if (!pSession)
553	{
554	LogRel((DEVICE_NAME ":VBoxDrvSolarisClose: no session in state data for %#x (%d)\n", Dev, getminor(Dev)));
555	return EFAULT;
556	}
557	LogFlow((DEVICE_NAME ":VBoxDrvSolarisClose: Dev=%#x pSession=%p pid=%d r0proc=%p thread=%p\n",
558	Dev, pSession, RTProcSelf(), RTR0ProcHandleSelf(), RTThreadNativeSelf() ));
559
560	#else
561	const RTPROCESS Process = RTProcSelf();
562	const unsigned iHash = SESSION_HASH(Process);
563	PSUPDRVSESSION pSession;
564
565	/*
566	* Remove from the hash table.
567	*/
568	RTSpinlockAcquire(g_Spinlock);
569	pSession = g_apSessionHashTab[iHash];
570	if (pSession)
571	{
572	if (pSession->Process == Process)
573	{
574	g_apSessionHashTab[iHash] = pSession->pNextHash;
575	pSession->pNextHash = NULL;
576	}
577	else
578	{
579	PSUPDRVSESSION pPrev = pSession;
580	pSession = pSession->pNextHash;
581	while (pSession)
582	{
583	if (pSession->Process == Process)
584	{
585	pPrev->pNextHash = pSession->pNextHash;
586	pSession->pNextHash = NULL;
587	break;
588	}
589
590	/* next */
591	pPrev = pSession;
592	pSession = pSession->pNextHash;
593	}
594	}
595	}
596	RTSpinlockReleaseNoInts(g_Spinlock);
597	if (!pSession)
598	{
599	LogRel((DEVICE_NAME ":VBoxDrvSolarisClose: WHAT?!? pSession == NULL! This must be a mistake... pid=%d (close)\n",
600	(int)Process));
601	return EFAULT;
602	}
603	#endif
604
605	/*
606	* Close the session.
607	*/
608	supdrvCloseSession(&g_DevExt, pSession);
609	return 0;
610	}
611
612
613	static int VBoxDrvSolarisRead(dev_t Dev, struct uio pUio, cred_t pCred)
614	{
615	LogFlowFunc((DEVICE_NAME ":VBoxDrvSolarisRead"));
616	return 0;
617	}
618
619
620	static int VBoxDrvSolarisWrite(dev_t Dev, struct uio pUio, cred_t pCred)
621	{
622	LogFlowFunc((DEVICE_NAME ":VBoxDrvSolarisWrite"));
623	return 0;
624	}
625
626
627	/**
628	* Driver ioctl, an alternate entry point for this character driver.
629	*
630	* @param Dev Device number
631	* @param Cmd Operation identifier
632	* @param pArg Arguments from user to driver
633	* @param Mode Information bitfield (read/write, address space etc.)
634	* @param pCred User credentials
635	* @param pVal Return value for calling process.
636	*
637	* @return corresponding solaris error code.
638	*/
639	static int VBoxDrvSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArgs, int Mode, cred_t pCred, int pVal)
640	{
641	#ifndef USE_SESSION_HASH
642	/*
643	* Get the session from the soft state item.
644	*/
645	vbox_devstate_t *pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, getminor(Dev));
646	if (!pState)
647	{
648	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtl: no state data for %#x (%d)\n", Dev, getminor(Dev)));
649	return EINVAL;
650	}
651
652	PSUPDRVSESSION pSession = pState->pSession;
653	if (!pSession)
654	{
655	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtl: no session in state data for %#x (%d)\n", Dev, getminor(Dev)));
656	return DDI_SUCCESS;
657	}
658	#else
659	const RTPROCESS Process = RTProcSelf();
660	const unsigned iHash = SESSION_HASH(Process);
661	PSUPDRVSESSION pSession;
662
663	/*
664	* Find the session.
665	*/
666	RTSpinlockAcquire(g_Spinlock);
667	pSession = g_apSessionHashTab[iHash];
668	if (pSession && pSession->Process != Process)
669	{
670	do pSession = pSession->pNextHash;
671	while (pSession && pSession->Process != Process);
672	}
673	RTSpinlockReleaseNoInts(g_Spinlock);
674	if (!pSession)
675	{
676	LogRel((DEVICE_NAME ":VBoxSupDrvIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#x\n",
677	(int)Process, Cmd));
678	return EINVAL;
679	}
680	#endif
681
682	/*
683	* Deal with the two high-speed IOCtl that takes it's arguments from
684	* the session and iCmd, and only returns a VBox status code.
685	*/
686	if ( Cmd == SUP_IOCTL_FAST_DO_RAW_RUN
687	\|\| Cmd == SUP_IOCTL_FAST_DO_HM_RUN
688	\|\| Cmd == SUP_IOCTL_FAST_DO_NOP)
689	{
690	*pVal = supdrvIOCtlFast(Cmd, pArgs, &g_DevExt, pSession);
691	return 0;
692	}
693
694	return VBoxDrvSolarisIOCtlSlow(pSession, Cmd, Mode, pArgs);
695	}
696
697
698	/** @def IOCPARM_LEN
699	* Gets the length from the ioctl number.
700	* This is normally defined by sys/ioccom.h on BSD systems...
701	*/
702	#ifndef IOCPARM_LEN
703	# define IOCPARM_LEN(x) ( ((x) >> 16) & IOCPARM_MASK )
704	#endif
705
706
707	/**
708	* Worker for VBoxSupDrvIOCtl that takes the slow IOCtl functions.
709	*
710	* @returns Solaris errno.
711	*
712	* @param pSession The session.
713	* @param Cmd The IOCtl command.
714	* @param Mode Information bitfield (for specifying ownership of data)
715	* @param iArg User space address of the request buffer.
716	*/
717	static int VBoxDrvSolarisIOCtlSlow(PSUPDRVSESSION pSession, int iCmd, int Mode, intptr_t iArg)
718	{
719	int rc;
720	uint32_t cbBuf = 0;
721	union
722	{
723	SUPREQHDR Hdr;
724	uint8_t abBuf[64];
725	} StackBuf;
726	PSUPREQHDR pHdr;
727
728
729	/*
730	* Read the header.
731	*/
732	if (RT_UNLIKELY(IOCPARM_LEN(iCmd) != sizeof(StackBuf.Hdr)))
733	{
734	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtlSlow: iCmd=%#x len %d expected %d\n", iCmd, IOCPARM_LEN(iCmd), sizeof(StackBuf.Hdr)));
735	return EINVAL;
736	}
737	rc = ddi_copyin((void *)iArg, &StackBuf.Hdr, sizeof(StackBuf.Hdr), Mode);
738	if (RT_UNLIKELY(rc))
739	{
740	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtlSlow: ddi_copyin(,%#lx,) failed; iCmd=%#x. rc=%d\n", iArg, iCmd, rc));
741	return EFAULT;
742	}
743	if (RT_UNLIKELY((StackBuf.Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
744	{
745	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtlSlow: bad header magic %#x; iCmd=%#x\n", StackBuf.Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK, iCmd));
746	return EINVAL;
747	}
748	cbBuf = RT_MAX(StackBuf.Hdr.cbIn, StackBuf.Hdr.cbOut);
749	if (RT_UNLIKELY( StackBuf.Hdr.cbIn < sizeof(StackBuf.Hdr)
750	\|\| StackBuf.Hdr.cbOut < sizeof(StackBuf.Hdr)
751	\|\| cbBuf > _1M*16))
752	{
753	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtlSlow: max(%#x,%#x); iCmd=%#x\n", StackBuf.Hdr.cbIn, StackBuf.Hdr.cbOut, iCmd));
754	return EINVAL;
755	}
756
757	/*
758	* Buffer the request.
759	*/
760	if (cbBuf <= sizeof(StackBuf))
761	pHdr = &StackBuf.Hdr;
762	else
763	{
764	pHdr = RTMemTmpAlloc(cbBuf);
765	if (RT_UNLIKELY(!pHdr))
766	{
767	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtlSlow: failed to allocate buffer of %d bytes for iCmd=%#x.\n", cbBuf, iCmd));
768	return ENOMEM;
769	}
770	}
771	rc = ddi_copyin((void *)iArg, pHdr, cbBuf, Mode);
772	if (RT_UNLIKELY(rc))
773	{
774	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtlSlow: copy_from_user(,%#lx, %#x) failed; iCmd=%#x. rc=%d\n", iArg, cbBuf, iCmd, rc));
775	if (pHdr != &StackBuf.Hdr)
776	RTMemFree(pHdr);
777	return EFAULT;
778	}
779
780	/*
781	* Process the IOCtl.
782	*/
783	rc = supdrvIOCtl(iCmd, &g_DevExt, pSession, pHdr);
784
785	/*
786	* Copy ioctl data and output buffer back to user space.
787	*/
788	if (RT_LIKELY(!rc))
789	{
790	uint32_t cbOut = pHdr->cbOut;
791	if (RT_UNLIKELY(cbOut > cbBuf))
792	{
793	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtlSlow: too much output! %#x > %#x; iCmd=%#x!\n", cbOut, cbBuf, iCmd));
794	cbOut = cbBuf;
795	}
796	rc = ddi_copyout(pHdr, (void *)iArg, cbOut, Mode);
797	if (RT_UNLIKELY(rc != 0))
798	{
799	/* this is really bad */
800	LogRel((DEVICE_NAME ":VBoxDrvSolarisIOCtlSlow: ddi_copyout(,%p,%d) failed. rc=%d\n", (void *)iArg, cbBuf, rc));
801	rc = EFAULT;
802	}
803	}
804	else
805	rc = EINVAL;
806
807	if (pHdr != &StackBuf.Hdr)
808	RTMemTmpFree(pHdr);
809	return rc;
810	}
811
812
813	/**
814	* The SUPDRV IDC entry point.
815	*
816	* @returns VBox status code, see supdrvIDC.
817	* @param iReq The request code.
818	* @param pReq The request.
819	*/
820	int VBOXCALL SUPDrvSolarisIDC(uint32_t uReq, PSUPDRVIDCREQHDR pReq)
821	{
822	PSUPDRVSESSION pSession;
823
824	/*
825	* Some quick validations.
826	*/
827	if (RT_UNLIKELY(!VALID_PTR(pReq)))
828	return VERR_INVALID_POINTER;
829
830	pSession = pReq->pSession;
831	if (pSession)
832	{
833	if (RT_UNLIKELY(!VALID_PTR(pSession)))
834	return VERR_INVALID_PARAMETER;
835	if (RT_UNLIKELY(pSession->pDevExt != &g_DevExt))
836	return VERR_INVALID_PARAMETER;
837	}
838	else if (RT_UNLIKELY(uReq != SUPDRV_IDC_REQ_CONNECT))
839	return VERR_INVALID_PARAMETER;
840
841	/*
842	* Do the job.
843	*/
844	return supdrvIDC(uReq, &g_DevExt, pSession, pReq);
845	}
846
847
848	/**
849	* Converts an supdrv error code to a solaris error code.
850	*
851	* @returns corresponding solaris error code.
852	* @param rc IPRT status code.
853	*/
854	static int VBoxSupDrvErr2SolarisErr(int rc)
855	{
856	switch (rc)
857	{
858	case VINF_SUCCESS: return 0;
859	case VERR_GENERAL_FAILURE: return EACCES;
860	case VERR_INVALID_PARAMETER: return EINVAL;
861	case VERR_INVALID_MAGIC: return EILSEQ;
862	case VERR_INVALID_HANDLE: return ENXIO;
863	case VERR_INVALID_POINTER: return EFAULT;
864	case VERR_LOCK_FAILED: return ENOLCK;
865	case VERR_ALREADY_LOADED: return EEXIST;
866	case VERR_PERMISSION_DENIED: return EPERM;
867	case VERR_VERSION_MISMATCH: return ENOSYS;
868	}
869
870	return EPERM;
871	}
872
873
874	/**
875	* Initializes any OS specific object creator fields.
876	*/
877	void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
878	{
879	NOREF(pObj);
880	NOREF(pSession);
881	}
882
883
884	/**
885	* Checks if the session can access the object.
886	*
887	* @returns true if a decision has been made.
888	* @returns false if the default access policy should be applied.
889	*
890	* @param pObj The object in question.
891	* @param pSession The session wanting to access the object.
892	* @param pszObjName The object name, can be NULL.
893	* @param prc Where to store the result when returning true.
894	*/
895	bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char pszObjName, int prc)
896	{
897	NOREF(pObj);
898	NOREF(pSession);
899	NOREF(pszObjName);
900	NOREF(prc);
901	return false;
902	}
903
904
905	bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
906	{
907	return false;
908	}
909
910	#if defined(VBOX_WITH_NATIVE_SOLARIS_LOADING) \
911	&& !defined(VBOX_WITHOUT_NATIVE_R0_LOADER)
912
913	int VBOXCALL supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
914	{
915	pImage->idSolMod = -1;
916	pImage->pSolModCtl = NULL;
917
918	# if 1 /* This approach requires _init/_fini/_info stubs. */
919	/*
920	* Construct a filename that escapes the module search path and let us
921	* specify a root path.
922	*/
923	/** @todo change this to use modctl and use_path=0. */
924	const char *pszName = RTPathFilename(pszFilename);
925	AssertReturn(pszName, VERR_INVALID_PARAMETER);
926	char pszSubDir = RTStrAPrintf2("../../../../../../../../../../..%.s", pszName - pszFilename - 1, pszFilename);
927	if (!pszSubDir)
928	return VERR_NO_STR_MEMORY;
929	int idMod = modload(pszSubDir, pszName);
930	if (idMod == -1)
931	{
932	/* This is an horrible hack for avoiding the mod-present check in
933	modrload on S10. Fortunately, nobody else seems to be using that
934	variable... */
935	extern int swaploaded;
936	int saved_swaploaded = swaploaded;
937	swaploaded = 0;
938	idMod = modload(pszSubDir, pszName);
939	swaploaded = saved_swaploaded;
940	}
941	RTStrFree(pszSubDir);
942	if (idMod == -1)
943	{
944	LogRel(("modload(,%s): failed, could be anything...\n", pszFilename));
945	return VERR_LDR_GENERAL_FAILURE;
946	}
947
948	modctl_t *pModCtl = mod_hold_by_id(idMod);
949	if (!pModCtl)
950	{
951	LogRel(("mod_hold_by_id(,%s): failed, weird.\n", pszFilename));
952	/* No point in calling modunload. */
953	return VERR_LDR_GENERAL_FAILURE;
954	}
955	pModCtl->mod_loadflags \|= MOD_NOAUTOUNLOAD \| MOD_NOUNLOAD; /* paranoia */
956
957	# else
958
959	const int idMod = -1;
960	modctl_t *pModCtl = mod_hold_by_name(pszFilename);
961	if (!pModCtl)
962	{
963	LogRel(("mod_hold_by_name failed for '%s'\n", pszFilename));
964	return VERR_LDR_GENERAL_FAILURE;
965	}
966
967	int rc = kobj_load_module(pModCtl, 0 /use_path/);
968	if (rc != 0)
969	{
970	LogRel(("kobj_load_module failed with rc=%d for '%s'\n", rc, pszFilename));
971	mod_release_mod(pModCtl);
972	return RTErrConvertFromErrno(rc);
973	}
974	# endif
975
976	/*
977	* Get the module info.
978	*
979	* Note! The text section is actually not at mi_base, but and the next
980	* alignment boundrary and there seems to be no easy way of
981	* getting at this address. This sabotages supdrvOSLdrLoad.
982	* Bastards!
983	*/
984	struct modinfo ModInfo;
985	kobj_getmodinfo(pModCtl->mod_mp, &ModInfo);
986	pImage->pvImage = ModInfo.mi_base;
987	pImage->idSolMod = idMod;
988	pImage->pSolModCtl = pModCtl;
989
990	mod_release_mod(pImage->pSolModCtl);
991	LogRel(("supdrvOSLdrOpen: succeeded for '%s' (mi_base=%p mi_size=%#x), id=%d ctl=%p\n",
992	pszFilename, ModInfo.mi_base, ModInfo.mi_size, idMod, pModCtl));
993	return VINF_SUCCESS;
994	}
995
996
997	void VBOXCALL supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
998	{
999	NOREF(pDevExt); NOREF(pImage);
1000	}
1001
1002
1003	int VBOXCALL supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void pv, const uint8_t pbImageBits)
1004	{
1005	NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
1006	if (kobj_addrcheck(pImage->pSolModCtl->mod_mp, pv))
1007	return VERR_INVALID_PARAMETER;
1008	return VINF_SUCCESS;
1009	}
1010
1011
1012	/**
1013	* Resolves a module entry point address.
1014	*
1015	* @returns VBox status code.
1016	* @param pImage The image.
1017	* @param pszSymbol The symbol name.
1018	* @param ppvValue Where to store the value. On input this holds
1019	* the symbol value SUPLib calculated.
1020	*/
1021	static int supdrvSolLdrResolvEp(PSUPDRVLDRIMAGE pImage, const char pszSymbol, void *ppvValue)
1022	{
1023	/* Don't try resolve symbols which, according to SUPLib, aren't there. */
1024	if (!*ppvValue)
1025	return VINF_SUCCESS;
1026
1027	uintptr_t uValue = modlookup_by_modctl(pImage->pSolModCtl, pszSymbol);
1028	if (!uValue)
1029	{
1030	LogRel(("supdrvOSLdrLoad on %s failed to resolve %s\n", pImage->szName, pszSymbol));
1031	return VERR_SYMBOL_NOT_FOUND;
1032	}
1033	ppvValue = (void )uValue;
1034	return VINF_SUCCESS;
1035	}
1036
1037
1038	int VBOXCALL supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, PSUPLDRLOAD pReq)
1039	{
1040	#if 0 /* This doesn't work because of text alignment. */
1041	/*
1042	* Comparing is very very difficult since text and data may be allocated
1043	* separately.
1044	*/
1045	size_t cbCompare = RT_MIN(pImage->cbImageBits, 64);
1046	if (memcmp(pImage->pvImage, pbImageBits, cbCompare))
1047	{
1048	LogRel(("Image mismatch: %s (%p)\n", pImage->szName, pImage->pvImage));
1049	LogRel(("Native: %.*Rhxs\n", cbCompare, pImage->pvImage));
1050	LogRel(("SUPLib: %.*Rhxs\n", cbCompare, pbImageBits));
1051	return VERR_LDR_MISMATCH_NATIVE;
1052	}
1053	#endif
1054
1055	/*
1056	* Get the exported symbol addresses.
1057	*/
1058	int rc;
1059	modctl_t *pModCtl = mod_hold_by_id(pImage->idSolMod);
1060	if (pModCtl && pModCtl == pImage->pSolModCtl)
1061	{
1062	uint32_t iSym = pImage->cSymbols;
1063	while (iSym-- > 0)
1064	{
1065	const char *pszSymbol = &pImage->pachStrTab[pImage->paSymbols[iSym].offName];
1066	uintptr_t uValue = modlookup_by_modctl(pImage->pSolModCtl, pszSymbol);
1067	if (!uValue)
1068	{
1069	LogRel(("supdrvOSLdrLoad on %s failed to resolve the exported symbol: '%s'\n", pImage->szName, pszSymbol));
1070	break;
1071	}
1072	uintptr_t offSymbol = uValue - (uintptr_t)pImage->pvImage;
1073	pImage->paSymbols[iSym].offSymbol = offSymbol;
1074	if (pImage->paSymbols[iSym].offSymbol != (int32_t)offSymbol)
1075	{
1076	LogRel(("supdrvOSLdrLoad on %s symbol out of range: %p (%s) \n", pImage->szName, offSymbol, pszSymbol));
1077	break;
1078	}
1079	}
1080
1081	rc = iSym == UINT32_MAX ? VINF_SUCCESS : VERR_LDR_GENERAL_FAILURE;
1082
1083	/*
1084	* Get the standard module entry points.
1085	*/
1086	if (RT_SUCCESS(rc))
1087	{
1088	rc = supdrvSolLdrResolvEp(pImage, "ModuleInit", (void **)&pImage->pfnModuleInit);
1089	if (RT_SUCCESS(rc))
1090	rc = supdrvSolLdrResolvEp(pImage, "ModuleTerm", (void **)&pImage->pfnModuleTerm);
1091
1092	switch (pReq->u.In.eEPType)
1093	{
1094	case SUPLDRLOADEP_VMMR0:
1095	{
1096	if (RT_SUCCESS(rc))
1097	rc = supdrvSolLdrResolvEp(pImage, "VMMR0EntryInt", (void **)&pReq->u.In.EP.VMMR0.pvVMMR0EntryInt);
1098	if (RT_SUCCESS(rc))
1099	rc = supdrvSolLdrResolvEp(pImage, "VMMR0EntryFast", (void **)&pReq->u.In.EP.VMMR0.pvVMMR0EntryFast);
1100	if (RT_SUCCESS(rc))
1101	rc = supdrvSolLdrResolvEp(pImage, "VMMR0EntryEx", (void **)&pReq->u.In.EP.VMMR0.pvVMMR0EntryEx);
1102	break;
1103	}
1104
1105	case SUPLDRLOADEP_SERVICE:
1106	{
1107	/** @todo we need the name of the entry point. */
1108	return VERR_NOT_SUPPORTED;
1109	}
1110	}
1111	}
1112
1113	mod_release_mod(pImage->pSolModCtl);
1114	}
1115	else
1116	{
1117	LogRel(("mod_hold_by_id failed in supdrvOSLdrLoad on %s: %p\n", pImage->szName, pModCtl));
1118	rc = VERR_LDR_MISMATCH_NATIVE;
1119	}
1120	return rc;
1121	}
1122
1123
1124	void VBOXCALL supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1125	{
1126	# if 1
1127	pImage->pSolModCtl->mod_loadflags &= ~MOD_NOUNLOAD;
1128	int rc = modunload(pImage->idSolMod);
1129	if (rc)
1130	LogRel(("modunload(%u (%s)) failed: %d\n", pImage->idSolMod, pImage->szName, rc));
1131	# else
1132	kobj_unload_module(pImage->pSolModCtl);
1133	# endif
1134	pImage->pSolModCtl = NULL;
1135	pImage->idSolMod = NULL;
1136	}
1137
1138	#else /* !VBOX_WITH_NATIVE_SOLARIS_LOADING */
1139
1140	int VBOXCALL supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
1141	{
1142	NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
1143	return VERR_NOT_SUPPORTED;
1144	}
1145
1146
1147	void VBOXCALL supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1148	{
1149	NOREF(pDevExt); NOREF(pImage);
1150	}
1151
1152
1153	int VBOXCALL supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void pv, const uint8_t pbImageBits)
1154	{
1155	NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
1156	return VERR_NOT_SUPPORTED;
1157	}
1158
1159
1160	int VBOXCALL supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, PSUPLDRLOAD pReq)
1161	{
1162	NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits); NOREF(pReq);
1163	return VERR_NOT_SUPPORTED;
1164	}
1165
1166
1167	void VBOXCALL supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1168	{
1169	NOREF(pDevExt); NOREF(pImage);
1170	}
1171
1172	#endif /* !VBOX_WITH_NATIVE_SOLARIS_LOADING */
1173
1174
1175	RTDECL(int) SUPR0Printf(const char *pszFormat, ...)
1176	{
1177	va_list args;
1178	char szMsg[512];
1179
1180	va_start(args, pszFormat);
1181	RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, args);
1182	va_end(args);
1183
1184	szMsg[sizeof(szMsg) - 1] = '\0';
1185	cmn_err(CE_CONT, "%s", szMsg);
1186	return 0;
1187	}
1188

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

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

Download in other formats: