/**
* Kernel entry points
*/
int _init(void)
{
LogFunc((DEVICE_NAME ":_init\n"));
/*
* Prevent module autounloading.
*/
modctl_t *pModCtl = mod_getctl(&g_VBoxNetAdpSolarisModLinkage);
if (pModCtl)
pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
else
LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
/*
* Initialize IPRT.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
rc = mod_install(&g_VBoxNetAdpSolarisModLinkage);
if (!rc)
return rc;
LogRel((DEVICE_NAME ":mod_install failed. rc=%d\n", rc));
RTR0Term();
}
else
LogRel((DEVICE_NAME ":failed to initialize IPRT (rc=%d)\n", rc));
return RTErrConvertToErrno(rc);
}
static int VBoxDrvFreeBSDLoad(void)
{
g_cUsers = 0;
/*
* Initialize the runtime.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
Log(("VBoxDrvFreeBSDLoad:\n"));
/*
* Initialize the device extension.
*/
rc = supdrvInitDevExt(&g_VBoxDrvFreeBSDDevExt, sizeof(SUPDRVSESSION));
if (RT_SUCCESS(rc))
{
/*
* Configure character devices. Add symbolic links for compatibility.
*/
g_pVBoxDrvFreeBSDChrDevSys = make_dev(&g_VBoxDrvFreeBSDChrDevSwSys, 0, UID_ROOT, GID_WHEEL, VBOXDRV_PERM, "vboxdrv");
g_pVBoxDrvFreeBSDChrDevUsr = make_dev(&g_VBoxDrvFreeBSDChrDevSwUsr, 1, UID_ROOT, GID_WHEEL, 0666, "vboxdrvu");
return VINF_SUCCESS;
}
printf("vboxdrv: supdrvInitDevExt failed, rc=%d\n", rc);
RTR0Term();
}
else
printf("vboxdrv: RTR0Init failed, rc=%d\n", rc);
return rc;
}
/**
* Initialize module.
*
* @returns appropriate status code.
*/
static int __init VBoxNetAdpLinuxInit(void)
{
int rc;
/*
* Initialize IPRT.
*/
rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
Log(("VBoxNetAdpLinuxInit\n"));
rc = vboxNetAdpInit();
if (RT_SUCCESS(rc))
{
rc = misc_register(&g_CtlDev);
if (rc)
{
printk(KERN_ERR "VBoxNetAdp: Can't register " VBOXNETADP_CTL_DEV_NAME " device! rc=%d\n", rc);
return rc;
}
LogRel(("VBoxNetAdp: Successfully started.\n"));
return 0;
}
else
LogRel(("VBoxNetAdp: failed to register vboxnet0 device (rc=%d)\n", rc));
}
else
LogRel(("VBoxNetAdp: failed to initialize IPRT (rc=%d)\n", rc));
return -RTErrConvertToErrno(rc);
}
/* Driver entry point */
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
NOREF(RegistryPath);
PAGED_CODE();
int irc = RTR0Init(0);
if (RT_FAILURE(irc))
{
LOGREL(("failed to init IPRT (rc=%#x)", irc));
return STATUS_INTERNAL_ERROR;
}
LOGF_ENTER();
DriverObject->DriverUnload = VBoxDrvUnload;
DriverObject->DriverExtension->AddDevice = VBoxDrvAddDevice;
for (int i=0; i<=IRP_MJ_MAXIMUM_FUNCTION; ++i)
{
DriverObject->MajorFunction[i] = VBoxIrpPassthrough;
}
DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = VBoxIrpInternalIOCTL;
DriverObject->MajorFunction[IRP_MJ_PNP] = VBoxIrpPnP;
DriverObject->MajorFunction[IRP_MJ_POWER] = VBoxIrpPower;
NTSTATUS tmpStatus = VBoxNewProtInit();
if (!NT_SUCCESS(tmpStatus))
{
WARN(("VBoxNewProtInit failed Status (0x%x)", tmpStatus));
}
LOGF_LEAVE();
return STATUS_SUCCESS;
}
/**
* Start the kernel module.
*/
static kern_return_t vboxSfDwnModuleLoad(struct kmod_info *pKModInfo, void *pvData)
{
RT_NOREF(pKModInfo, pvData);
#ifdef DEBUG
printf("vboxSfDwnModuleLoad\n");
RTLogBackdoorPrintf("vboxSfDwnModuleLoad\n");
#endif
/*
* Initialize IPRT and the ring-0 guest library.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
rc = VbglR0SfInit();
if (RT_SUCCESS(rc))
{
/*
* Register the file system.
*/
rc = vfs_fsadd(&g_VBoxSfFsEntry, &g_pVBoxSfVfsTableEntry);
if (rc == 0)
{
/*
* Try find VBoxGuest and connect to the shared folders service on the host.
*/
/** @todo should we just ignore the error here and retry at mount time?
* Technically, VBoxGuest should be available since it's one of our
* dependencies... */
vboxSfDwnConnect();
/*
* We're done for now. We'll deal with
*/
LogRel(("VBoxSF: loaded\n"));
return KERN_SUCCESS;
}
printf("VBoxSF: vfs_fsadd failed: %d\n", rc);
RTLogBackdoorPrintf("VBoxSF: vfs_fsadd failed: %d\n", rc);
VbglR0SfTerm();
}
else
{
printf("VBoxSF: VbglR0SfInit failed: %d\n", rc);
RTLogBackdoorPrintf("VBoxSF: VbglR0SfInit failed: %Rrc\n", rc);
}
RTR0Term();
}
else
{
printf("VBoxSF: RTR0Init failed: %d\n", rc);
RTLogBackdoorPrintf("VBoxSF: RTR0Init failed: %Rrc\n", rc);
}
return KERN_FAILURE;
}
/**
* Kernel entry points
*/
int _init(void)
{
int rc;
LogFunc((DEVICE_NAME ":_init\n"));
g_pDip = NULL;
/*
* Prevent module autounloading.
*/
modctl_t *pModCtl = mod_getctl(&g_VBoxUSBMonSolarisModLinkage);
if (pModCtl)
pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
else
LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
/*
* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
*/
rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
/*
* Initialize global mutex.
*/
mutex_init(&g_VBoxUSBMonSolarisMtx, NULL, MUTEX_DRIVER, NULL);
rc = VBoxUSBFilterInit();
if (RT_SUCCESS(rc))
{
rc = ddi_soft_state_init(&g_pVBoxUSBMonSolarisState, sizeof(vboxusbmon_state_t), 1);
if (!rc)
{
rc = mod_install(&g_VBoxUSBMonSolarisModLinkage);
if (!rc)
return rc;
LogRel((DEVICE_NAME ":mod_install failed! rc=%d\n", rc));
ddi_soft_state_fini(&g_pVBoxUSBMonSolarisState);
}
else
LogRel((DEVICE_NAME ":ddi_soft_state_init failed! rc=%d\n", rc));
}
else
LogRel((DEVICE_NAME ":VBoxUSBFilterInit failed! rc=%d\n", rc));
mutex_destroy(&g_VBoxUSBMonSolarisMtx);
RTR0Term();
}
else
LogRel((DEVICE_NAME ":RTR0Init failed! rc=%d\n", rc));
return -1;
}
/**
* 32-bit Ring-0 initialization.
*
* @returns 0 on success, non-zero on failure.
* @param pszArgs Pointer to the device arguments.
*/
DECLASM(int) VBoxDrvInit(const char *pszArgs)
{
/*
* Initialize the runtime.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
Log(("VBoxDrvInit: pszArgs=%s\n", pszArgs));
/*
* Initialize the device extension.
*/
rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
if (RT_SUCCESS(rc))
{
/*
* Initialize the session hash table.
*/
rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxDrvOS2");
if (RT_SUCCESS(rc))
{
/*
* Process the commandline. Later.
*/
bool fVerbose = true;
/*
* Success
*/
if (fVerbose)
{
strcpy(&g_szInitText[0],
"\r\n"
"VirtualBox.org Support Driver for OS/2 version " VBOX_VERSION_STRING "\r\n"
"Copyright (C) 2007 Knut St. Osmundsen\r\n"
"Copyright (C) 2007 Oracle Corporation\r\n");
g_cchInitText = strlen(&g_szInitText[0]);
}
return VINF_SUCCESS;
}
g_cchInitText = RTStrPrintf(&g_szInitText[0], g_cchInitTextMax, "VBoxDrv.sys: RTSpinlockCreate failed, rc=%Rrc\n", rc);
supdrvDeleteDevExt(&g_DevExt);
}
else
g_cchInitText = RTStrPrintf(&g_szInitText[0], g_cchInitTextMax, "VBoxDrv.sys: supdrvInitDevExt failed, rc=%Rrc\n", rc);
RTR0Term();
}
else
g_cchInitText = RTStrPrintf(&g_szInitText[0], g_cchInitTextMax, "VBoxDrv.sys: RTR0Init failed, rc=%Rrc\n", rc);
return rc;
}
/**
* Start the kernel module.
*/
static kern_return_t vgdrvDarwinStart(struct kmod_info *pKModInfo, void *pvData)
{
/*
* Initialize IPRT.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
Log(("VBoxGuest: driver loaded\n"));
return KMOD_RETURN_SUCCESS;
}
printf("VBoxGuest: RTR0Init failed with rc=%d\n", rc);
return KMOD_RETURN_FAILURE;
}
/**
* Start the kernel module.
*/
static kern_return_t VBoxNetAdpDarwinStart(struct kmod_info *pKModInfo, void *pvData)
{
int rc;
/*
* Initialize IPRT and find our module tag id.
* (IPRT is shared with VBoxDrv, it creates the loggers.)
*/
rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
Log(("VBoxNetAdpDarwinStart\n"));
rc = vboxNetAdpInit();
if (RT_SUCCESS(rc))
{
g_nCtlDev = cdevsw_add(-1, &g_ChDev);
if (g_nCtlDev < 0)
{
LogRel(("VBoxAdp: failed to register control device."));
rc = VERR_CANT_CREATE;
}
else
{
g_hCtlDev = devfs_make_node(makedev(g_nCtlDev, 0), DEVFS_CHAR,
UID_ROOT, GID_WHEEL, 0600, VBOXNETADP_CTL_DEV_NAME);
if (!g_hCtlDev)
{
LogRel(("VBoxAdp: failed to create FS node for control device."));
rc = VERR_CANT_CREATE;
}
}
}
if (RT_SUCCESS(rc))
{
LogRel(("VBoxAdpDrv: version " VBOX_VERSION_STRING " r%d\n", VBOX_SVN_REV));
return KMOD_RETURN_SUCCESS;
}
LogRel(("VBoxAdpDrv: failed to initialize device extension (rc=%d)\n", rc));
RTR0Term();
}
else
printf("VBoxAdpDrv: failed to initialize IPRT (rc=%d)\n", rc);
return KMOD_RETURN_FAILURE;
}
/**
* Kernel entry points
*/
int _init(void)
{
/*
* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
PRTLOGGER pRelLogger;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
rc = RTLogCreate(&pRelLogger, 0 /* fFlags */, "all",
"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
RTLOGDEST_STDOUT | RTLOGDEST_DEBUGGER, NULL);
if (RT_SUCCESS(rc))
RTLogRelSetDefaultInstance(pRelLogger);
else
cmn_err(CE_NOTE, "failed to initialize driver logging rc=%d!\n", rc);
mutex_init(&g_LdiMtx, NULL, MUTEX_DRIVER, NULL);
/*
* Prevent module autounloading.
*/
modctl_t *pModCtl = mod_getctl(&g_VBoxGuestSolarisModLinkage);
if (pModCtl)
pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
else
LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
rc = ddi_soft_state_init(&g_pVBoxGuestSolarisState, sizeof(vboxguest_state_t), 1);
if (!rc)
{
rc = mod_install(&g_VBoxGuestSolarisModLinkage);
if (rc)
ddi_soft_state_fini(&g_pVBoxGuestSolarisState);
}
}
else
{
cmn_err(CE_NOTE, "_init: RTR0Init failed. rc=%d\n", rc);
return EINVAL;
}
return rc;
}
/**
* Start the kernel module.
*/
static kern_return_t VbgdDarwinStart(struct kmod_info *pKModInfo, void *pvData)
{
#ifdef DEBUG
printf("VbgdDarwinStart\n");
#endif
/*
* Initialize IPRT.
*/
int rc = RTR0Init(0);
if (RT_FAILURE(rc))
{
printf("VBoxGuest: RTR0Init failed with rc=%d\n", rc);
return KMOD_RETURN_FAILURE;
}
return KMOD_RETURN_SUCCESS;
}
/**
* Module event handler, called from netgraph subsystem.
*/
static int vboxnetflt_modevent(struct module *pMod, int enmEventType, void *pvArg)
{
int rc;
Log(("VBoxNetFltFreeBSDModuleEvent\n"));
switch (enmEventType)
{
case MOD_LOAD:
rc = RTR0Init(0);
if (RT_FAILURE(rc))
{
printf("RTR0Init failed %d\n", rc);
return RTErrConvertToErrno(rc);
}
memset(&g_VBoxNetFltGlobals, 0, sizeof(VBOXNETFLTGLOBALS));
rc = vboxNetFltInitGlobalsAndIdc(&g_VBoxNetFltGlobals);
if (RT_FAILURE(rc))
{
printf("vboxNetFltInitGlobalsAndIdc failed %d\n", rc);
return RTErrConvertToErrno(rc);
}
/* No MODULE_VERSION in ng_ether so we can't MODULE_DEPEND it */
kern_kldload(curthread, "ng_ether", NULL);
break;
case MOD_UNLOAD:
rc = vboxNetFltTryDeleteIdcAndGlobals(&g_VBoxNetFltGlobals);
memset(&g_VBoxNetFltGlobals, 0, sizeof(VBOXNETFLTGLOBALS));
RTR0Term();
break;
case MOD_SHUTDOWN:
case MOD_QUIESCE:
default:
return EOPNOTSUPP;
}
if (RT_SUCCESS(rc))
return 0;
return RTErrConvertToErrno(rc);
}
/**
* 32-bit Ring-0 init routine.
*
* This is called the first time somebody tries to use the IFS.
* It will initialize IPRT, Vbgl and whatever else is required.
*
* The caller will do the necessary AttachDD and calling of the 16 bit
* IDC to initialize the g_VBoxGuestIDC global. Perhaps we should move
* this bit to VbglInitClient? It's just that it's so much simpler to do it
* while we're on the way here...
*
*/
DECLASM(void) VBoxSFR0Init(void)
{
Log(("VBoxSFR0Init: g_fpfnDevHlp=%lx u32Version=%RX32 u32Session=%RX32 pfnServiceEP=%p g_u32Info=%u (%#x)\n",
g_fpfnDevHlp, g_VBoxGuestIDC.u32Version, g_VBoxGuestIDC.u32Session, g_VBoxGuestIDC.pfnServiceEP, g_u32Info, g_u32Info));
/*
* Start by initializing IPRT.
*/
if ( g_VBoxGuestIDC.u32Version == VMMDEV_VERSION
&& VALID_PTR(g_VBoxGuestIDC.u32Session)
&& VALID_PTR(g_VBoxGuestIDC.pfnServiceEP))
{
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
rc = VbglInitClient();
if (RT_SUCCESS(rc))
{
#ifndef DONT_LOCK_SEGMENTS
/*
* Lock the 32-bit segments in memory.
*/
static KernVMLock_t s_Text32, s_Data32;
rc = KernVMLock(VMDHL_LONG,
&_text, (uintptr_t)&_etext - (uintptr_t)&_text,
&s_Text32, (KernPageList_t *)-1, NULL);
AssertMsg(rc == NO_ERROR, ("locking text32 failed, rc=%d\n"));
rc = KernVMLock(VMDHL_LONG | VMDHL_WRITE,
&_data, (uintptr_t)&_end - (uintptr_t)&_data,
&s_Data32, (KernPageList_t *)-1, NULL);
AssertMsg(rc == NO_ERROR, ("locking text32 failed, rc=%d\n"));
#endif
Log(("VBoxSFR0Init: completed successfully\n"));
return;
}
}
LogRel(("VBoxSF: RTR0Init failed, rc=%Rrc\n", rc));
}
else
LogRel(("VBoxSF: Failed to connect to VBoxGuest.sys.\n"));
}
static int VBoxDrvFreeBSDLoad(void)
{
g_cUsers = 0;
/*
* Initialize the runtime.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
Log(("VBoxDrvFreeBSDLoad:\n"));
/*
* Initialize the device extension.
*/
rc = supdrvInitDevExt(&g_VBoxDrvFreeBSDDevExt, sizeof(SUPDRVSESSION));
if (RT_SUCCESS(rc))
{
/*
* Configure device cloning.
*/
clone_setup(&g_pVBoxDrvFreeBSDClones);
g_VBoxDrvFreeBSDEHTag = EVENTHANDLER_REGISTER(dev_clone, VBoxDrvFreeBSDClone, 0, 1000);
if (g_VBoxDrvFreeBSDEHTag)
{
Log(("VBoxDrvFreeBSDLoad: returns successfully\n"));
return VINF_SUCCESS;
}
printf("vboxdrv: EVENTHANDLER_REGISTER(dev_clone,,,) failed\n");
clone_cleanup(&g_pVBoxDrvFreeBSDClones);
rc = VERR_ALREADY_LOADED;
supdrvDeleteDevExt(&g_VBoxDrvFreeBSDDevExt);
}
else
printf("vboxdrv: supdrvInitDevExt failed, rc=%d\n", rc);
RTR0Term();
}
else
printf("vboxdrv: RTR0Init failed, rc=%d\n", rc);
return rc;
}
/**
* Start the kernel module.
*/
static kern_return_t VBoxNetFltDarwinStart(struct kmod_info *pKModInfo, void *pvData)
{
int rc;
/*
* Initialize IPRT and find our module tag id.
* (IPRT is shared with VBoxDrv, it creates the loggers.)
*/
rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
Log(("VBoxNetFltDarwinStart\n"));
errno_t err = mbuf_tag_id_find("org.VirtualBox.kext.VBoxFltDrv", &g_idTag);
if (!err)
{
/*
* Initialize the globals and connect to the support driver.
*
* This will call back vboxNetFltOsOpenSupDrv (and maybe vboxNetFltOsCloseSupDrv)
* for establishing the connect to the support driver.
*/
memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
rc = vboxNetFltInitGlobalsAndIdc(&g_VBoxNetFltGlobals);
if (RT_SUCCESS(rc))
{
LogRel(("VBoxFltDrv: version " VBOX_VERSION_STRING " r%d\n", VBOX_SVN_REV));
return KMOD_RETURN_SUCCESS;
}
LogRel(("VBoxFltDrv: failed to initialize device extension (rc=%d)\n", rc));
}
else
LogRel(("VBoxFltDrv: mbuf_tag_id_find failed, err=%d\n", err));
RTR0Term();
}
else
printf("VBoxFltDrv: failed to initialize IPRT (rc=%d)\n", rc);
memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
return KMOD_RETURN_FAILURE;
}
/**
* Kernel entry points
*/
int _init(void)
{
LogFlowFunc((VIRTIOLOGNAME ":_init\n"));
/*
* Prevent module autounloading.
*/
modctl_t *pModCtl = mod_getctl(&g_VirtioNetModLinkage);
if (pModCtl)
pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
else
LogRel((VIRTIOLOGNAME ":failed to disable autounloading!\n"));
/*
* Initialize IPRT.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
/*
* Initialize Solaris specific globals here.
*/
mac_init_ops(&g_VirtioNetDevOps, DEVICE_NAME);
rc = mod_install(&g_VirtioNetModLinkage);
if (!rc)
return rc;
LogRel((VIRTIOLOGNAME ":mod_install failed. rc=%d\n", rc));
mac_fini_ops(&g_VirtioNetDevOps);
RTR0Term();
return rc;
}
else
LogRel((VIRTIOLOGNAME ":failed to initialize IPRT (rc=%d)\n", rc));
return RTErrConvertToErrno(rc);
}
RT_C_DECLS_END
/**
* Driver entry point.
*
* @returns appropriate status code.
* @param pDrvObj Pointer to driver object.
* @param pRegPath Registry base path.
*/
ULONG _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath)
{
NTSTATUS rc;
/*
* Create device.
* (That means creating a device object and a symbolic link so the DOS
* subsystems (OS/2, win32, ++) can access the device.)
*/
UNICODE_STRING DevName;
RtlInitUnicodeString(&DevName, DEVICE_NAME_NT);
PDEVICE_OBJECT pDevObj;
rc = IoCreateDevice(pDrvObj, sizeof(SUPDRVDEVEXT), &DevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &pDevObj);
if (NT_SUCCESS(rc))
{
UNICODE_STRING DosName;
RtlInitUnicodeString(&DosName, DEVICE_NAME_DOS);
rc = IoCreateSymbolicLink(&DosName, &DevName);
if (NT_SUCCESS(rc))
{
int vrc = RTR0Init(0);
if (RT_SUCCESS(vrc))
{
Log(("VBoxDrv::DriverEntry\n"));
/*
* Initialize the device extension.
*/
PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension;
memset(pDevExt, 0, sizeof(*pDevExt));
vrc = supdrvInitDevExt(pDevExt, sizeof(SUPDRVSESSION));
if (!vrc)
{
/*
* Setup the driver entry points in pDrvObj.
*/
pDrvObj->DriverUnload = VBoxDrvNtUnload;
pDrvObj->MajorFunction[IRP_MJ_CREATE] = VBoxDrvNtCreate;
pDrvObj->MajorFunction[IRP_MJ_CLEANUP] = VBoxDrvNtCleanup;
pDrvObj->MajorFunction[IRP_MJ_CLOSE] = VBoxDrvNtClose;
pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VBoxDrvNtDeviceControl;
pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = VBoxDrvNtInternalDeviceControl;
pDrvObj->MajorFunction[IRP_MJ_READ] = VBoxDrvNtNotSupportedStub;
pDrvObj->MajorFunction[IRP_MJ_WRITE] = VBoxDrvNtNotSupportedStub;
/* more? */
/* Register ourselves for power state changes. */
UNICODE_STRING CallbackName;
OBJECT_ATTRIBUTES Attr;
RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState");
InitializeObjectAttributes(&Attr, &CallbackName, OBJ_CASE_INSENSITIVE, NULL, NULL);
rc = ExCreateCallback(&pDevExt->pObjPowerCallback, &Attr, TRUE, TRUE);
if (rc == STATUS_SUCCESS)
pDevExt->hPowerCallback = ExRegisterCallback(pDevExt->pObjPowerCallback, VBoxPowerDispatchCallback, pDevObj);
Log(("VBoxDrv::DriverEntry returning STATUS_SUCCESS\n"));
return STATUS_SUCCESS;
}
Log(("supdrvInitDevExit failed with vrc=%d!\n", vrc));
rc = VBoxDrvNtErr2NtStatus(vrc);
IoDeleteSymbolicLink(&DosName);
RTR0Term();
}
else
{
Log(("RTR0Init failed with vrc=%d!\n", vrc));
rc = VBoxDrvNtErr2NtStatus(vrc);
}
}
else
Log(("IoCreateSymbolicLink failed with rc=%#x!\n", rc));
IoDeleteDevice(pDevObj);
}
else
Log(("IoCreateDevice failed with rc=%#x!\n", rc));
if (NT_SUCCESS(rc))
rc = STATUS_INVALID_PARAMETER;
Log(("VBoxDrv::DriverEntry returning %#x\n", rc));
return rc;
}
/**
* Driver entry point.
*
* @returns appropriate status code.
* @param pDrvObj Pointer to driver object.
* @param pRegPath Registry base path.
*/
ULONG _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath)
{
/*
* Create device.
* (That means creating a device object and a symbolic link so the DOS
* subsystems (OS/2, win32, ++) can access the device.)
*/
NTSTATUS rcNt = vboxdrvNtCreateDevices(pDrvObj);
if (NT_SUCCESS(rcNt))
{
int vrc = RTR0Init(0);
if (RT_SUCCESS(vrc))
{
Log(("VBoxDrv::DriverEntry\n"));
/*
* Initialize the device extension.
*/
PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)g_pDevObjSys->DeviceExtension;
memset(pDevExt, 0, sizeof(*pDevExt));
vrc = supdrvInitDevExt(pDevExt, sizeof(SUPDRVSESSION));
if (!vrc)
{
/*
* Setup the driver entry points in pDrvObj.
*/
pDrvObj->DriverUnload = VBoxDrvNtUnload;
pDrvObj->MajorFunction[IRP_MJ_CREATE] = VBoxDrvNtCreate;
pDrvObj->MajorFunction[IRP_MJ_CLEANUP] = VBoxDrvNtCleanup;
pDrvObj->MajorFunction[IRP_MJ_CLOSE] = VBoxDrvNtClose;
pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VBoxDrvNtDeviceControl;
pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = VBoxDrvNtInternalDeviceControl;
pDrvObj->MajorFunction[IRP_MJ_READ] = VBoxDrvNtNotSupportedStub;
pDrvObj->MajorFunction[IRP_MJ_WRITE] = VBoxDrvNtNotSupportedStub;
/* more? */
/* Register ourselves for power state changes. */
UNICODE_STRING CallbackName;
OBJECT_ATTRIBUTES Attr;
RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState");
InitializeObjectAttributes(&Attr, &CallbackName, OBJ_CASE_INSENSITIVE, NULL, NULL);
rcNt = ExCreateCallback(&pDevExt->pObjPowerCallback, &Attr, TRUE, TRUE);
if (rcNt == STATUS_SUCCESS)
pDevExt->hPowerCallback = ExRegisterCallback(pDevExt->pObjPowerCallback, VBoxPowerDispatchCallback,
g_pDevObjSys);
Log(("VBoxDrv::DriverEntry returning STATUS_SUCCESS\n"));
return STATUS_SUCCESS;
}
Log(("supdrvInitDevExit failed with vrc=%d!\n", vrc));
rcNt = VBoxDrvNtErr2NtStatus(vrc);
RTR0Term();
}
else
{
Log(("RTR0Init failed with vrc=%d!\n", vrc));
rcNt = VBoxDrvNtErr2NtStatus(vrc);
}
vboxdrvNtDestroyDevices();
}
if (NT_SUCCESS(rcNt))
rcNt = STATUS_INVALID_PARAMETER;
return rcNt;
}
/**
* Initialize module.
*
* @returns appropriate status code.
*/
static int __init vboxguestLinuxModInit(void)
{
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
PRTLOGGER pRelLogger;
int rc;
/*
* Initialize IPRT first.
*/
rc = RTR0Init(0);
if (RT_FAILURE(rc))
{
printk(KERN_ERR DEVICE_NAME ": RTR0Init failed, rc=%d.\n", rc);
return -EINVAL;
}
/*
* Create the release log.
* (We do that here instead of common code because we want to log
* early failures using the LogRel macro.)
*/
rc = RTLogCreate(&pRelLogger, 0 /* fFlags */, "all",
"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
RTLOGDEST_STDOUT | RTLOGDEST_DEBUGGER | RTLOGDEST_USER, NULL);
if (RT_SUCCESS(rc))
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
RTLogGroupSettings(pRelLogger, g_szLogGrp);
RTLogFlags(pRelLogger, g_szLogFlags);
RTLogDestinations(pRelLogger, g_szLogDst);
#endif
RTLogRelSetDefaultInstance(pRelLogger);
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
g_fLoggerCreated = true;
#endif
/*
* Locate and initialize the PCI device.
*/
rc = pci_register_driver(&g_PciDriver);
if (rc >= 0 && g_pPciDev)
{
/*
* Register the interrupt service routine for it.
*/
rc = vboxguestLinuxInitISR();
if (rc >= 0)
{
/*
* Call the common device extension initializer.
*/
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && defined(RT_ARCH_X86)
VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux26;
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && defined(RT_ARCH_AMD64)
VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux26_x64;
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0) && defined(RT_ARCH_X86)
VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux24;
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0) && defined(RT_ARCH_AMD64)
VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux24_x64;
#else
# warning "huh? which arch + version is this?"
VBOXOSTYPE enmOsType = VBOXOSTYPE_Linux;
#endif
rc = VbgdCommonInitDevExt(&g_DevExt,
g_IOPortBase,
g_pvMMIOBase,
g_cbMMIO,
enmOSType,
VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
if (RT_SUCCESS(rc))
{
/*
* Create the kernel session for this driver.
*/
rc = VbgdCommonCreateKernelSession(&g_DevExt,
&g_pKernelSession);
if (RT_SUCCESS(rc))
{
/*
* Create the kernel input device.
*/
#ifdef VBOXGUEST_WITH_INPUT_DRIVER
rc = vboxguestLinuxCreateInputDevice();
if (rc >= 0)
{
#endif
/*
* Finally, create the device nodes.
*/
rc = vboxguestLinuxInitDeviceNodes();
if (rc >= 0)
{
/* some useful information for the user but don't show this on the console */
LogRel((DEVICE_NAME ": misc device minor %d, IRQ %d, I/O port %RTiop, MMIO at %RHp (size 0x%x)\n",
g_MiscDevice.minor, g_pPciDev->irq, g_IOPortBase, g_MMIOPhysAddr, g_cbMMIO));
printk(KERN_DEBUG DEVICE_NAME ": Successfully loaded version "
VBOX_VERSION_STRING " (interface " RT_XSTR(VMMDEV_VERSION) ")\n");
return rc;
}
/* bail out */
#ifdef VBOXGUEST_WITH_INPUT_DRIVER
vboxguestLinuxTermInputDevice();
}
else
{
LogRel((DEVICE_NAME ": vboxguestCreateInputDevice failed with rc=%Rrc\n", rc));
rc = RTErrConvertFromErrno(rc);
}
#endif
VbgdCommonCloseSession(&g_DevExt, g_pKernelSession);
}
VbgdCommonDeleteDevExt(&g_DevExt);
}
else
{
LogRel((DEVICE_NAME ": VbgdCommonInitDevExt failed with rc=%Rrc\n", rc));
rc = RTErrConvertFromErrno(rc);
}
vboxguestLinuxTermISR();
}
}
else
{
LogRel((DEVICE_NAME ": PCI device not found, probably running on physical hardware.\n"));
rc = -ENODEV;
}
pci_unregister_driver(&g_PciDriver);
RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
RTLogDestroy(RTLogSetDefaultInstance(NULL));
RTR0Term();
return rc;
}
/**
* Start the kernel module.
*/
static kern_return_t VBoxDrvDarwinStart(struct kmod_info *pKModInfo, void *pvData)
{
int rc;
#ifdef DEBUG
printf("VBoxDrvDarwinStart\n");
#endif
/*
* Initialize IPRT.
*/
rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
/*
* Initialize the device extension.
*/
rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
if (RT_SUCCESS(rc))
{
/*
* Initialize the session hash table.
*/
memset(g_apSessionHashTab, 0, sizeof(g_apSessionHashTab)); /* paranoia */
rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxDrvDarwin");
if (RT_SUCCESS(rc))
{
/*
* Registering ourselves as a character device.
*/
g_iMajorDeviceNo = cdevsw_add(-1, &g_DevCW);
if (g_iMajorDeviceNo >= 0)
{
#ifdef VBOX_WITH_HARDENING
g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR,
UID_ROOT, GID_WHEEL, 0600, DEVICE_NAME_SYS);
#else
g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR,
UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_SYS);
#endif
if (g_hDevFsDeviceSys)
{
g_hDevFsDeviceUsr = devfs_make_node(makedev(g_iMajorDeviceNo, 1), DEVFS_CHAR,
UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_USR);
if (g_hDevFsDeviceUsr)
{
LogRel(("VBoxDrv: version " VBOX_VERSION_STRING " r%d; IOCtl version %#x; IDC version %#x; dev major=%d\n",
VBOX_SVN_REV, SUPDRV_IOC_VERSION, SUPDRV_IDC_VERSION, g_iMajorDeviceNo));
/* Register a sleep/wakeup notification callback */
g_pSleepNotifier = registerPrioritySleepWakeInterest(&VBoxDrvDarwinSleepHandler, &g_DevExt, NULL);
if (g_pSleepNotifier == NULL)
LogRel(("VBoxDrv: register for sleep/wakeup events failed\n"));
/* Find kernel symbols that are kind of optional. */
vboxdrvDarwinResolveSymbols();
return KMOD_RETURN_SUCCESS;
}
LogRel(("VBoxDrv: devfs_make_node(makedev(%d,1),,,,%s) failed\n", g_iMajorDeviceNo, DEVICE_NAME_USR));
devfs_remove(g_hDevFsDeviceSys);
g_hDevFsDeviceSys = NULL;
}
else
LogRel(("VBoxDrv: devfs_make_node(makedev(%d,0),,,,%s) failed\n", g_iMajorDeviceNo, DEVICE_NAME_SYS));
cdevsw_remove(g_iMajorDeviceNo, &g_DevCW);
g_iMajorDeviceNo = -1;
}
else
LogRel(("VBoxDrv: cdevsw_add failed (%d)\n", g_iMajorDeviceNo));
RTSpinlockDestroy(g_Spinlock);
g_Spinlock = NIL_RTSPINLOCK;
}
else
LogRel(("VBoxDrv: RTSpinlockCreate failed (rc=%d)\n", rc));
supdrvDeleteDevExt(&g_DevExt);
}
else
printf("VBoxDrv: failed to initialize device extension (rc=%d)\n", rc);
RTR0TermForced();
}
else
printf("VBoxDrv: failed to initialize IPRT (rc=%d)\n", rc);
memset(&g_DevExt, 0, sizeof(g_DevExt));
return KMOD_RETURN_FAILURE;
}
/**
* Kernel entry points
*/
int _init(void)
{
#if 0 /* No IPRT logging before RTR0Init() is done! */
LogFlowFunc(("vboxdrv:_init\n"));
#endif
/*
* Prevent module autounloading.
*/
modctl_t *pModCtl = mod_getctl(&g_VBoxDrvSolarisModLinkage);
if (pModCtl)
pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
else
cmn_err(CE_NOTE, "vboxdrv: failed to disable autounloading!\n");
/*
* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
/*
* Initialize the device extension
*/
rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
if (RT_SUCCESS(rc))
{
cmn_err(CE_CONT, "!tsc::mode %s @ tentative %lu Hz\n", SUPGetGIPModeName(g_DevExt.pGip), g_DevExt.pGip->u64CpuHz);
/*
* Initialize the session hash table.
*/
memset(g_apSessionHashTab, 0, sizeof(g_apSessionHashTab));
rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxDrvSol");
if (RT_SUCCESS(rc))
{
rc = ddi_soft_state_init(&g_pVBoxDrvSolarisState, sizeof(vbox_devstate_t), 8);
if (!rc)
{
rc = mod_install(&g_VBoxDrvSolarisModLinkage);
if (!rc)
return rc; /* success */
ddi_soft_state_fini(&g_pVBoxDrvSolarisState);
LogRel(("vboxdrv: mod_install failed! rc=%d\n", rc));
}
else
LogRel(("vboxdrv: failed to initialize soft state.\n"));
RTSpinlockDestroy(g_Spinlock);
g_Spinlock = NIL_RTSPINLOCK;
}
else
{
LogRel(("VBoxDrvSolarisAttach: RTSpinlockCreate failed\n"));
rc = RTErrConvertToErrno(rc);
}
supdrvDeleteDevExt(&g_DevExt);
}
else
{
LogRel(("VBoxDrvSolarisAttach: supdrvInitDevExt failed\n"));
rc = EINVAL;
}
RTR0TermForced();
}
else
{
LogRel(("VBoxDrvSolarisAttach: failed to init R0Drv\n"));
rc = RTErrConvertToErrno(rc);
}
memset(&g_DevExt, 0, sizeof(g_DevExt));
return rc;
}
static int vgdrvFreeBSDAttach(device_t pDevice)
{
int rc;
int iResId;
struct VBoxGuestDeviceState *pState;
cUsers = 0;
/*
* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
*/
rc = RTR0Init(0);
if (RT_FAILURE(rc))
{
LogFunc(("RTR0Init failed.\n"));
return ENXIO;
}
pState = device_get_softc(pDevice);
/*
* Allocate I/O port resource.
*/
iResId = PCIR_BAR(0);
pState->pIOPortRes = bus_alloc_resource_any(pDevice, SYS_RES_IOPORT, &iResId, RF_ACTIVE);
pState->uIOPortBase = rman_get_start(pState->pIOPortRes);
pState->iIOPortResId = iResId;
if (pState->uIOPortBase)
{
/*
* Map the MMIO region.
*/
iResId = PCIR_BAR(1);
pState->pVMMDevMemRes = bus_alloc_resource_any(pDevice, SYS_RES_MEMORY, &iResId, RF_ACTIVE);
pState->VMMDevMemHandle = rman_get_bushandle(pState->pVMMDevMemRes);
pState->VMMDevMemSize = rman_get_size(pState->pVMMDevMemRes);
pState->pMMIOBase = rman_get_virtual(pState->pVMMDevMemRes);
pState->iVMMDevMemResId = iResId;
if (pState->pMMIOBase)
{
/*
* Call the common device extension initializer.
*/
rc = VGDrvCommonInitDevExt(&g_DevExt, pState->uIOPortBase,
pState->pMMIOBase, pState->VMMDevMemSize,
#if ARCH_BITS == 64
VBOXOSTYPE_FreeBSD_x64,
#else
VBOXOSTYPE_FreeBSD,
#endif
VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
if (RT_SUCCESS(rc))
{
/*
* Add IRQ of VMMDev.
*/
rc = vgdrvFreeBSDAddIRQ(pDevice, pState);
if (RT_SUCCESS(rc))
{
/*
* Read host configuration.
*/
VGDrvCommonProcessOptionsFromHost(&g_DevExt);
/*
* Configure device cloning.
*/
clone_setup(&g_pvgdrvFreeBSDClones);
g_vgdrvFreeBSDEHTag = EVENTHANDLER_REGISTER(dev_clone, vgdrvFreeBSDClone, 0, 1000);
if (g_vgdrvFreeBSDEHTag)
{
printf(DEVICE_NAME ": loaded successfully\n");
return 0;
}
printf(DEVICE_NAME ": EVENTHANDLER_REGISTER(dev_clone,,,) failed\n");
clone_cleanup(&g_pvgdrvFreeBSDClones);
vgdrvFreeBSDRemoveIRQ(pDevice, pState);
}
else
printf((DEVICE_NAME ": VGDrvCommonInitDevExt failed.\n"));
VGDrvCommonDeleteDevExt(&g_DevExt);
}
else
printf((DEVICE_NAME ": vgdrvFreeBSDAddIRQ failed.\n"));
}
else
printf((DEVICE_NAME ": MMIO region setup failed.\n"));
}
else
printf((DEVICE_NAME ": IOport setup failed.\n"));
RTR0Term();
return ENXIO;
}
/**
* Initialize module.
*
* @returns appropriate status code.
*/
static int __init VBoxDrvLinuxInit(void)
{
int rc;
/*
* Check for synchronous/asynchronous TSC mode.
*/
printk(KERN_DEBUG DEVICE_NAME ": Found %u processor cores.\n", (unsigned)RTMpGetOnlineCount());
#ifdef CONFIG_VBOXDRV_AS_MISC
rc = misc_register(&gMiscDevice);
if (rc)
{
printk(KERN_ERR DEVICE_NAME ": Can't register misc device! rc=%d\n", rc);
return rc;
}
#else /* !CONFIG_VBOXDRV_AS_MISC */
/*
* Register character device.
*/
g_iModuleMajor = DEVICE_MAJOR;
rc = register_chrdev((dev_t)g_iModuleMajor, DEVICE_NAME, &gFileOpsVBoxDrv);
if (rc < 0)
{
Log(("register_chrdev() failed with rc=%#x!\n", rc));
return rc;
}
/*
* Save returned module major number
*/
if (DEVICE_MAJOR != 0)
g_iModuleMajor = DEVICE_MAJOR;
else
g_iModuleMajor = rc;
rc = 0;
# ifdef CONFIG_DEVFS_FS
/*
* Register a device entry
*/
if (devfs_mk_cdev(MKDEV(DEVICE_MAJOR, 0), S_IFCHR | VBOX_DEV_FMASK, DEVICE_NAME) != 0)
{
Log(("devfs_register failed!\n"));
rc = -EINVAL;
}
# endif
#endif /* !CONFIG_VBOXDRV_AS_MISC */
if (!rc)
{
/*
* Initialize the runtime.
* On AMD64 we'll have to donate the high rwx memory block to the exec allocator.
*/
rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
#if defined(RT_ARCH_AMD64) && LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
rc = RTR0MemExecDonate(&g_abExecMemory[0], sizeof(g_abExecMemory));
printk(KERN_DEBUG "VBoxDrv: dbg - g_abExecMemory=%p\n", (void *)&g_abExecMemory[0]);
#endif
Log(("VBoxDrv::ModuleInit\n"));
/*
* Initialize the device extension.
*/
if (RT_SUCCESS(rc))
rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
if (RT_SUCCESS(rc))
{
#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
rc = platform_driver_register(&gPlatformDriver);
if (rc == 0)
{
rc = platform_device_register(&gPlatformDevice);
if (rc == 0)
#endif
{
printk(KERN_INFO DEVICE_NAME ": TSC mode is %s, kernel timer mode is 'normal'.\n",
g_DevExt.pGip->u32Mode == SUPGIPMODE_SYNC_TSC ? "'synchronous'" : "'asynchronous'");
LogFlow(("VBoxDrv::ModuleInit returning %#x\n", rc));
printk(KERN_DEBUG DEVICE_NAME ": Successfully loaded version "
VBOX_VERSION_STRING " (interface " RT_XSTR(SUPDRV_IOC_VERSION) ").\n");
return rc;
}
#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
else
platform_driver_unregister(&gPlatformDriver);
}
#endif
}
rc = -EINVAL;
RTR0TermForced();
}
else
rc = -EINVAL;
/*
* Failed, cleanup and return the error code.
*/
#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
devfs_remove(DEVICE_NAME);
#endif
}
#ifdef CONFIG_VBOXDRV_AS_MISC
misc_deregister(&gMiscDevice);
Log(("VBoxDrv::ModuleInit returning %#x (minor:%d)\n", rc, gMiscDevice.minor));
#else
unregister_chrdev(g_iModuleMajor, DEVICE_NAME);
Log(("VBoxDrv::ModuleInit returning %#x (major:%d)\n", rc, g_iModuleMajor));
#endif
return rc;
}
/**
* Initialize module.
*
* @returns appropriate status code.
*/
static int __init VBoxDrvLinuxInit(void)
{
int rc;
/*
* Check for synchronous/asynchronous TSC mode.
*/
printk(KERN_DEBUG "vboxdrv: Found %u processor cores\n", (unsigned)RTMpGetOnlineCount());
#ifdef CONFIG_VBOXDRV_AS_MISC
rc = misc_register(&gMiscDeviceSys);
if (rc)
{
printk(KERN_ERR "vboxdrv: Can't register system misc device! rc=%d\n", rc);
return rc;
}
rc = misc_register(&gMiscDeviceUsr);
if (rc)
{
printk(KERN_ERR "vboxdrv: Can't register user misc device! rc=%d\n", rc);
misc_deregister(&gMiscDeviceSys);
return rc;
}
#else /* !CONFIG_VBOXDRV_AS_MISC */
/*
* Register character devices and save the returned major numbers.
*/
/* /dev/vboxdrv */
g_iModuleMajorSys = DEVICE_MAJOR_SYS;
rc = register_chrdev((dev_t)g_iModuleMajorSys, DEVICE_NAME_SYS, &gFileOpsVBoxDrvSys);
if (rc < 0)
{
Log(("register_chrdev() failed with rc=%#x for vboxdrv!\n", rc));
return rc;
}
if (DEVICE_MAJOR_SYS != 0)
g_iModuleMajorSys = DEVICE_MAJOR_SYS;
else
g_iModuleMajorSys = rc;
/* /dev/vboxdrvu */
/** @todo Use a minor number of this bugger (not sure if this code is used
* though, so not bothering right now.) */
g_iModuleMajorUsr = DEVICE_MAJOR_USR;
rc = register_chrdev((dev_t)g_iModuleMajorUsr, DEVICE_NAME_USR, &gFileOpsVBoxDrvUsr);
if (rc < 0)
{
Log(("register_chrdev() failed with rc=%#x for vboxdrv!\n", rc));
return rc;
}
if (DEVICE_MAJOR_USR != 0)
g_iModuleMajorUsr = DEVICE_MAJOR_USR;
else
g_iModuleMajorUsr = rc;
rc = 0;
# ifdef CONFIG_DEVFS_FS
/*
* Register a device entry
*/
if ( devfs_mk_cdev(MKDEV(DEVICE_MAJOR_SYS, 0), S_IFCHR | VBOX_DEV_FMASK, DEVICE_NAME_SYS) != 0
|| devfs_mk_cdev(MKDEV(DEVICE_MAJOR_USR, 0), S_IFCHR | VBOX_DEV_FMASK, DEVICE_NAME_USR) != 0)
{
Log(("devfs_register failed!\n"));
rc = -EINVAL;
}
# endif
#endif /* !CONFIG_VBOXDRV_AS_MISC */
if (!rc)
{
/*
* Initialize the runtime.
* On AMD64 we'll have to donate the high rwx memory block to the exec allocator.
*/
rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
#if (defined(RT_ARCH_AMD64) && LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)) || defined(VBOX_WITH_TEXT_MODMEM_HACK)
# ifdef VBOX_WITH_TEXT_MODMEM_HACK
set_memory_x(&g_abExecMemory[0], sizeof(g_abExecMemory) / PAGE_SIZE);
set_memory_rw(&g_abExecMemory[0], sizeof(g_abExecMemory) / PAGE_SIZE);
# endif
rc = RTR0MemExecDonate(&g_abExecMemory[0], sizeof(g_abExecMemory));
printk(KERN_DEBUG "VBoxDrv: dbg - g_abExecMemory=%p\n", (void *)&g_abExecMemory[0]);
#endif
Log(("VBoxDrv::ModuleInit\n"));
/*
* Initialize the device extension.
*/
if (RT_SUCCESS(rc))
rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
if (RT_SUCCESS(rc))
{
#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
rc = platform_driver_register(&gPlatformDriver);
if (rc == 0)
{
rc = platform_device_register(&gPlatformDevice);
if (rc == 0)
#endif
{
printk(KERN_INFO "vboxdrv: TSC mode is %s, tentative frequency %llu Hz\n",
SUPGetGIPModeName(g_DevExt.pGip), g_DevExt.pGip->u64CpuHz);
LogFlow(("VBoxDrv::ModuleInit returning %#x\n", rc));
printk(KERN_DEBUG "vboxdrv: Successfully loaded version "
VBOX_VERSION_STRING " (interface " RT_XSTR(SUPDRV_IOC_VERSION) ")\n");
return rc;
}
#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
else
platform_driver_unregister(&gPlatformDriver);
}
#endif
}
rc = -EINVAL;
RTR0TermForced();
}
else
rc = -EINVAL;
/*
* Failed, cleanup and return the error code.
*/
#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
devfs_remove(DEVICE_NAME_SYS);
devfs_remove(DEVICE_NAME_USR);
#endif
}
#ifdef CONFIG_VBOXDRV_AS_MISC
misc_deregister(&gMiscDeviceSys);
misc_deregister(&gMiscDeviceUsr);
Log(("VBoxDrv::ModuleInit returning %#x (minor:%d & %d)\n", rc, gMiscDeviceSys.minor, gMiscDeviceUsr.minor));
#else
unregister_chrdev(g_iModuleMajorUsr, DEVICE_NAME_USR);
unregister_chrdev(g_iModuleMajorSys, DEVICE_NAME_SYS);
Log(("VBoxDrv::ModuleInit returning %#x (major:%d & %d)\n", rc, g_iModuleMajorSys, g_iModuleMajorUsr));
#endif
return rc;
}
static status_t VBoxGuestHaikuAttach(const pci_info *pDevice)
{
status_t status;
int rc = VINF_SUCCESS;
int iResId = 0;
struct VBoxGuestDeviceState *pState = &sState;
static const char *const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
PRTLOGGER pRelLogger;
AssertReturn(pDevice, B_BAD_VALUE);
cUsers = 0;
/*
* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
*/
rc = RTR0Init(0);
if (RT_FAILURE(rc))
{
/** @todo r=ramshankar: use dprintf here. */
LogFunc(("RTR0Init failed.\n"));
return ENXIO;
}
rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxGuestHaiku");
if (RT_FAILURE(rc))
{
LogRel(("VBoxGuestHaikuAttach: RTSpinlock create failed. rc=%Rrc\n", rc));
return ENXIO;
}
#ifdef DO_LOG
/*
* Create the release log.
* (We do that here instead of common code because we want to log
* early failures using the LogRel macro.)
*/
rc = RTLogCreate(&pRelLogger, 0 | RTLOGFLAGS_PREFIX_THREAD /* fFlags */, "all",
"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
RTLOGDEST_STDOUT | RTLOGDEST_DEBUGGER | RTLOGDEST_USER, NULL);
dprintf(MODULE_NAME ": RTLogCreate: %d\n", rc);
if (RT_SUCCESS(rc))
{
//RTLogGroupSettings(pRelLogger, g_szLogGrp);
//RTLogFlags(pRelLogger, g_szLogFlags);
//RTLogDestinations(pRelLogger, "/var/log/vboxguest.log");
RTLogRelSetDefaultInstance(pRelLogger);
RTLogSetDefaultInstance(pRelLogger); //XXX
}
#endif
/*
* Allocate I/O port resource.
*/
pState->uIOPortBase = pDevice->u.h0.base_registers[0];
/* @todo check flags for IO? */
if (pState->uIOPortBase)
{
/*
* Map the MMIO region.
*/
uint32 phys = pDevice->u.h0.base_registers[1];
/* @todo Check flags for mem? */
pState->VMMDevMemSize = pDevice->u.h0.base_register_sizes[1];
pState->iVMMDevMemAreaId = map_physical_memory("VirtualBox Guest MMIO", phys, pState->VMMDevMemSize,
B_ANY_KERNEL_BLOCK_ADDRESS, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,
&pState->pMMIOBase);
if (pState->iVMMDevMemAreaId > 0 && pState->pMMIOBase)
{
/*
* Call the common device extension initializer.
*/
rc = VBoxGuestInitDevExt(&g_DevExt, pState->uIOPortBase, pState->pMMIOBase, pState->VMMDevMemSize,
#if ARCH_BITS == 64
VBOXOSTYPE_Haiku_x64,
#else
VBOXOSTYPE_Haiku,
#endif
VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
if (RT_SUCCESS(rc))
{
/*
* Add IRQ of VMMDev.
*/
pState->iIrqResId = pDevice->u.h0.interrupt_line;
rc = VBoxGuestHaikuAddIRQ(pState);
if (RT_SUCCESS(rc))
{
LogRel((MODULE_NAME ": loaded successfully\n"));
return B_OK;
}
LogRel((MODULE_NAME ":VBoxGuestInitDevExt failed.\n"));
VBoxGuestDeleteDevExt(&g_DevExt);
}
else
LogRel((MODULE_NAME ":VBoxGuestHaikuAddIRQ failed.\n"));
}
else
LogRel((MODULE_NAME ":MMIO region setup failed.\n"));
}
else
LogRel((MODULE_NAME ":IOport setup failed.\n"));
RTR0Term();
return ENXIO;
}
/* Video Miniport Driver entry point */
ULONG DriverEntry(IN PVOID Context1, IN PVOID Context2)
{
PAGED_CODE();
int irc = RTR0Init(0);
if (RT_FAILURE(irc))
{
LogRel(("VBoxMP::failed to init IPRT (rc=%#x)", irc));
return ERROR_INVALID_FUNCTION;
}
LOGF_ENTER();
LOGREL(("VBox XPDM Driver for Windows version %d.%d.%dr%d, %d bit; Built %s %s",
VBOX_VERSION_MAJOR, VBOX_VERSION_MINOR, VBOX_VERSION_BUILD, VBOX_SVN_REV,
(sizeof (void*) << 3), __DATE__, __TIME__));
VIDEO_HW_INITIALIZATION_DATA vhwData;
/*Zero the structure*/
VideoPortZeroMemory(&vhwData, sizeof(vhwData));
/*Required driver callbacks*/
vhwData.HwFindAdapter = VBoxDrvFindAdapter;
vhwData.HwInitialize = VBoxDrvInitialize;
vhwData.HwStartIO = VBoxDrvStartIO;
vhwData.HwSetPowerState = VBoxDrvSetPowerState;
vhwData.HwGetPowerState = VBoxDrvGetPowerState;
vhwData.HwGetVideoChildDescriptor = VBoxDrvGetVideoChildDescriptor;
/*Optional callbacks*/
vhwData.HwResetHw = VBoxDrvResetHW;
#ifdef VBOX_WITH_VIDEOHWACCEL
vhwData.HwInterrupt = VBoxDrvInterrupt;
#endif
/*Our private storage space*/
vhwData.HwDeviceExtensionSize = sizeof(VBOXMP_DEVEXT);
/*Claim legacy VGA resource ranges*/
vhwData.HwLegacyResourceList = g_aVBoxLegacyVGAResources;
vhwData.HwLegacyResourceCount = RT_ELEMENTS(g_aVBoxLegacyVGAResources);
/*Size of this structure changes between windows/ddk versions,
*so we query current version and report the expected size
*to allow our driver to be loaded.
*/
switch (VBoxQueryWinVersion(NULL))
{
case WINVERSION_NT4:
LOG(("WINVERSION_NT4"));
vhwData.HwInitDataSize = SIZE_OF_NT4_VIDEO_HW_INITIALIZATION_DATA;
break;
case WINVERSION_2K:
LOG(("WINVERSION_2K"));
vhwData.HwInitDataSize = SIZE_OF_W2K_VIDEO_HW_INITIALIZATION_DATA;
break;
default:
vhwData.HwInitDataSize = sizeof(VIDEO_HW_INITIALIZATION_DATA);
break;
}
/*Even though msdn claims that this field is ignored and should remain zero-initialized,
windows NT4 SP0 dies without the following line.
*/
vhwData.AdapterInterfaceType = PCIBus;
/*Allocate system resources*/
ULONG rc = VideoPortInitialize(Context1, Context2, &vhwData, NULL);
if (rc != NO_ERROR)
LOG(("VideoPortInitialize failed with %#x", rc));
LOGF_LEAVE();
return rc;
}
/**
* Kernel entry points
*/
int _init(void)
{
LogFlowFunc((DEVICE_NAME ":_init\n"));
/*
* Prevent module autounloading.
*/
modctl_t *pModCtl = mod_getctl(&g_VBoxDrvSolarisModLinkage);
if (pModCtl)
pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
else
LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
/*
* Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
/*
* Initialize the device extension
*/
rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
if (RT_SUCCESS(rc))
{
/*
* Initialize the session hash table.
*/
memset(g_apSessionHashTab, 0, sizeof(g_apSessionHashTab));
rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxDrvSol");
if (RT_SUCCESS(rc))
{
rc = ddi_soft_state_init(&g_pVBoxDrvSolarisState, sizeof(vbox_devstate_t), 8);
if (!rc)
{
rc = mod_install(&g_VBoxDrvSolarisModLinkage);
if (!rc)
return rc; /* success */
ddi_soft_state_fini(&g_pVBoxDrvSolarisState);
LogRel((DEVICE_NAME ":mod_install failed! rc=%d\n", rc));
}
else
LogRel((DEVICE_NAME ":failed to initialize soft state.\n"));
RTSpinlockDestroy(g_Spinlock);
g_Spinlock = NIL_RTSPINLOCK;
}
else
{
LogRel((DEVICE_NAME ":VBoxDrvSolarisAttach: RTSpinlockCreate failed\n"));
rc = RTErrConvertToErrno(rc);
}
supdrvDeleteDevExt(&g_DevExt);
}
else
{
LogRel((DEVICE_NAME ":VBoxDrvSolarisAttach: supdrvInitDevExt failed\n"));
rc = RTErrConvertToErrno(rc);
}
RTR0TermForced();
}
else
{
LogRel((DEVICE_NAME ":VBoxDrvSolarisAttach: failed to init R0Drv\n"));
rc = RTErrConvertToErrno(rc);
}
memset(&g_DevExt, 0, sizeof(g_DevExt));
return rc;
}
/**
* Initialize module.
*
* @returns appropriate status code.
*/
static int __init VBoxPciLinuxInit(void)
{
int rc;
/*
* Initialize IPRT.
*/
rc = RTR0Init(0);
if (RT_FAILURE(rc))
goto error;
LogRel(("VBoxPciLinuxInit\n"));
RT_ZERO(g_VBoxPciGlobals);
rc = vboxPciInit(&g_VBoxPciGlobals);
if (RT_FAILURE(rc))
{
LogRel(("cannot do VBoxPciInit: %Rc\n", rc));
goto error;
}
#if defined(CONFIG_PCI_STUB)
/* nothing to do, pci_stub module part of the kernel */
g_VBoxPciGlobals.fPciStubModuleAvail = true;
#elif defined(CONFIG_PCI_STUB_MODULE)
if (request_module(PCI_STUB_MODULE) == 0)
{
# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
/* find_module() is static before Linux 2.6.30 */
g_VBoxPciGlobals.pciStubModule = find_module(PCI_STUB_MODULE_NAME);
if (g_VBoxPciGlobals.pciStubModule)
{
if (try_module_get(g_VBoxPciGlobals.pciStubModule))
g_VBoxPciGlobals.fPciStubModuleAvail = true;
}
else
printk(KERN_INFO "vboxpci: find_module %s failed\n", PCI_STUB_MODULE);
# endif
}
else
printk(KERN_INFO "vboxpci: cannot load %s\n", PCI_STUB_MODULE);
#else
printk(KERN_INFO "vboxpci: %s module not available, cannot detach PCI devices\n",
PCI_STUB_MODULE);
#endif
#ifdef VBOX_WITH_IOMMU
if (iommu_found())
printk(KERN_INFO "vboxpci: IOMMU found\n");
else
printk(KERN_INFO "vboxpci: IOMMU not found (not registered)\n");
#else
printk(KERN_INFO "vboxpci: IOMMU not found (not compiled)\n");
#endif
return 0;
error:
return -RTErrConvertToErrno(rc);
}
* 32-bit Ring-0 initialization.
*
* This is called from VBoxGuestA-os2.asm upon the first open call to the vboxgst$ device.
*
* @returns 0 on success, non-zero on failure.
* @param pszArgs Pointer to the device arguments.
*/
DECLASM(int) VBoxGuestOS2Init(const char *pszArgs)
{
Log(("VBoxGuestOS2Init: pszArgs='%s' MMIO=0x%RX32 IOPort=0x%RX16 Int=%#x Bus=%#x Dev=%#x Fun=%d\n",
pszArgs, g_PhysMMIOBase, g_IOPortBase, g_bInterruptLine, g_bPciBusNo, g_bPciDevFunNo >> 3, g_bPciDevFunNo & 7));
/*
* Initialize the runtime.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
/*
* Process the commandline. Later.
*/
bool fVerbose = true;
/*
* Map the MMIO memory if found.
*/
rc = vboxGuestOS2MapMemory();
if (RT_SUCCESS(rc))
{
/*
* Initialize the device extension.
