/*ARGSUSED1*/
static int
mm_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int i;
struct mem_minor {
char *name;
minor_t minor;
int privonly;
const char *rdpriv;
const char *wrpriv;
mode_t priv_mode;
} mm[] = {
{ "mem", M_MEM, 0, NULL, "all", 0640 },
{ "kmem", M_KMEM, 0, NULL, "all", 0640 },
{ "allkmem", M_ALLKMEM, 0, "all", "all", 0600 },
{ "null", M_NULL, PRIVONLY_DEV, NULL, NULL, 0666 },
{ "zero", M_ZERO, PRIVONLY_DEV, NULL, NULL, 0666 },
};
kstat_t *ksp;
mutex_init(&mm_lock, NULL, MUTEX_DEFAULT, NULL);
mm_map = vmem_alloc(heap_arena, PAGESIZE, VM_SLEEP);
for (i = 0; i < (sizeof (mm) / sizeof (mm[0])); i++) {
if (ddi_create_priv_minor_node(devi, mm[i].name, S_IFCHR,
mm[i].minor, DDI_PSEUDO, mm[i].privonly,
mm[i].rdpriv, mm[i].wrpriv, mm[i].priv_mode) ==
DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
}
mm_dip = devi;
ksp = kstat_create("mm", 0, "phys_installed", "misc",
KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VAR_SIZE | KSTAT_FLAG_VIRTUAL);
if (ksp != NULL) {
ksp->ks_update = mm_kstat_update;
ksp->ks_snapshot = mm_kstat_snapshot;
ksp->ks_lock = &mm_lock; /* XXX - not really needed */
kstat_install(ksp);
}
mm_kmem_io_access = ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
"kmem_io_access", 0);
return (DDI_SUCCESS);
}
/**
* Attach entry point, to attach a device to the system or resume it.
*
* @param pDip The module structure instance.
* @param enmCmd Attach type (ddi_attach_cmd_t)
*
* @returns corresponding solaris error code.
*/
static int VBoxUSBMonSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
{
LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisAttach: pDip=%p enmCmd=%d\n", pDip, enmCmd));
switch (enmCmd)
{
case DDI_ATTACH:
{
if (RT_UNLIKELY(g_pDip))
{
LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: Global instance already initialized\n"));
return DDI_FAILURE;
}
g_pDip = pDip;
int instance = ddi_get_instance(pDip);
int rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME, S_IFCHR, instance, DDI_PSEUDO, 0,
"none", "none", 0660);
if (rc == DDI_SUCCESS)
{
rc = usb_register_dev_driver(g_pDip, VBoxUSBMonSolarisElectDriver);
if (rc == DDI_SUCCESS)
{
ddi_report_dev(pDip);
return DDI_SUCCESS;
}
LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: Failed to register driver election callback! rc=%d\n", rc));
}
else
LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: ddi_create_minor_node failed! rc=%d\n", rc));
return DDI_FAILURE;
}
case DDI_RESUME:
{
/* We don't have to bother about power management. */
return DDI_SUCCESS;
}
default:
return DDI_FAILURE;
}
}
static int
sad_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(devi, "user", S_IFCHR,
0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
if (ddi_create_priv_minor_node(devi, "admin", S_IFCHR,
1, DDI_PSEUDO, PRIVONLY_DEV, PRIV_SYS_CONFIG,
PRIV_SYS_CONFIG, 0666) == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
sad_dip = devi;
return (DDI_SUCCESS);
}
static int
inet_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int i, ndevs;
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
inet_dev_info = devi;
ndevs = sizeof (netdev_privs) / sizeof (struct dev_priv);
for (i = 0; i < ndevs; i++) {
char *drv = netdev_privs[i].driver;
if (drv == NULL || strcmp(drv, ddi_driver_name(devi)) == 0)
break;
}
return (ddi_create_priv_minor_node(devi, INET_NAME, S_IFCHR,
INET_DEVMINOR, DDI_PSEUDO, netdev_privs[i].privonly,
netdev_privs[i].read_priv, netdev_privs[i].write_priv,
INET_DEFAULT_PRIV_MODE));
}
/**
* Attach entry point, to attach a device to the system or resume it.
*
* @param pDip The module structure instance.
* @param enmCmd Operation type (attach/resume).
*
* @return corresponding solaris error code.
*/
static int VBoxDrvSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
{
LogFlowFunc(("VBoxDrvSolarisAttach\n"));
switch (enmCmd)
{
case DDI_ATTACH:
{
int rc;
#ifdef USE_SESSION_HASH
int instance = ddi_get_instance(pDip);
vbox_devstate_t *pState;
if (ddi_soft_state_zalloc(g_pVBoxDrvSolarisState, instance) != DDI_SUCCESS)
{
LogRel(("VBoxDrvSolarisAttach: state alloc failed\n"));
return DDI_FAILURE;
}
pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
#endif
/*
* Register for suspend/resume notifications
*/
rc = ddi_prop_create(DDI_DEV_T_NONE, pDip, DDI_PROP_CANSLEEP /* kmem alloc can sleep */,
"pm-hardware-state", "needs-suspend-resume", sizeof("needs-suspend-resume"));
if (rc != DDI_PROP_SUCCESS)
LogRel(("vboxdrv: Suspend/Resume notification registration failed.\n"));
/*
* Register ourselves as a character device, pseudo-driver
*/
#ifdef VBOX_WITH_HARDENING
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_SYS, S_IFCHR, 0 /*minor*/, DDI_PSEUDO,
0, NULL, NULL, 0600);
#else
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_SYS, S_IFCHR, 0 /*minor*/, DDI_PSEUDO,
0, "none", "none", 0666);
#endif
if (rc == DDI_SUCCESS)
{
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_USR, S_IFCHR, 1 /*minor*/, DDI_PSEUDO,
0, "none", "none", 0666);
if (rc == DDI_SUCCESS)
{
#ifdef USE_SESSION_HASH
pState->pDip = pDip;
#endif
ddi_report_dev(pDip);
return DDI_SUCCESS;
}
ddi_remove_minor_node(pDip, NULL);
}
return DDI_FAILURE;
}
case DDI_RESUME:
{
#if 0
RTSemFastMutexRequest(g_DevExt.mtxGip);
if (g_DevExt.pGipTimer)
RTTimerStart(g_DevExt.pGipTimer, 0);
RTSemFastMutexRelease(g_DevExt.mtxGip);
#endif
RTPowerSignalEvent(RTPOWEREVENT_RESUME);
LogFlow(("vboxdrv: Awakened from suspend.\n"));
return DDI_SUCCESS;
}
default:
return DDI_FAILURE;
}
return DDI_FAILURE;
}
