static status_t VBoxGuestHaikuDetach(void)
{
struct VBoxGuestDeviceState *pState = &sState;
if (cUsers > 0)
return EBUSY;
/*
* Reverse what we did in VBoxGuestHaikuAttach.
*/
VBoxGuestHaikuRemoveIRQ(pState);
if (pState->iVMMDevMemAreaId)
delete_area(pState->iVMMDevMemAreaId);
VBoxGuestDeleteDevExt(&g_DevExt);
#ifdef DO_LOG
RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
RTLogSetDefaultInstance(NULL);
// RTLogDestroy(RTLogSetDefaultInstance(NULL));
#endif
RTSpinlockDestroy(g_Spinlock);
g_Spinlock = NIL_RTSPINLOCK;
RTR0Term();
return B_OK;
}
int VBoxLogRelCreate(const char *pcszEntity, const char *pcszLogFile,
uint32_t fFlags, const char *pcszGroupSettings,
const char *pcszEnvVarBase, uint32_t fDestFlags,
uint32_t cMaxEntriesPerGroup, uint32_t cHistory,
uint32_t uHistoryFileTime, uint64_t uHistoryFileSize,
char *pszError, size_t cbError)
{
Assert(cbError >= RTPATH_MAX + 128);
/* create release logger */
PRTLOGGER pReleaseLogger;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
g_pszLogEntity = pcszEntity;
int vrc = RTLogCreateEx(&pReleaseLogger, fFlags, "all all.restrict default.unrestricted",
pcszEnvVarBase, RT_ELEMENTS(s_apszGroups), s_apszGroups, fDestFlags,
vboxHeaderFooter, cHistory, uHistoryFileSize, uHistoryFileTime,
pszError, cbError, pcszLogFile);
if (RT_SUCCESS(vrc))
{
/* make sure that we don't flood logfiles */
RTLogSetGroupLimit(pReleaseLogger, cMaxEntriesPerGroup);
/* explicitly flush the log, to have some info when buffering */
RTLogFlush(pReleaseLogger);
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(pReleaseLogger);
}
return vrc;
}
/**
* Creates the default release logger outputting to the specified file.
*
* @return IPRT status code.
* @param pszLogFile Filename for log output. Optional.
*/
static int VBoxServiceLogCreate(const char *pszLogFile)
{
/* Create release logger (stdout + file). */
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
char szError[RTPATH_MAX + 128] = "";
int rc = RTLogCreateEx(&g_pLoggerRelease, fFlags, "all",
"VBOXSERVICE_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
RTLOGDEST_STDOUT,
VBoxServiceLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
szError, sizeof(szError), pszLogFile);
if (RT_SUCCESS(rc))
{
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(g_pLoggerRelease);
/* Explicitly flush the log in case of VBOXSERVICE_RELEASE_LOG=buffered. */
RTLogFlush(g_pLoggerRelease);
}
return rc;
}
/**
* Creates the default release logger outputting to the specified file.
*
* Pass NULL to disabled logging.
*
* @return IPRT status code.
* @param pszLogFile Filename for log output. NULL disables logging
* (r=bird: No, it doesn't!).
*/
int VGSvcLogCreate(const char *pszLogFile)
{
/* Create release logger (stdout + file). */
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
int rc = RTLogCreateEx(&g_pLoggerRelease, fFlags, "all",
#ifdef DEBUG
"VBOXSERVICE_LOG",
#else
"VBOXSERVICE_RELEASE_LOG",
#endif
RT_ELEMENTS(s_apszGroups), s_apszGroups,
RTLOGDEST_STDOUT | RTLOGDEST_USER,
vgsvcLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
NULL /*pErrInfo*/, "%s", pszLogFile ? pszLogFile : "");
if (RT_SUCCESS(rc))
{
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(g_pLoggerRelease);
/* Explicitly flush the log in case of VBOXSERVICE_RELEASE_LOG=buffered. */
RTLogFlush(g_pLoggerRelease);
}
return rc;
}
int VBoxSVCLogRelCreate(const char *pszLogFile, uint32_t cHistory,
uint32_t uHistoryFileTime, uint64_t uHistoryFileSize)
{
/* create release logger */
PRTLOGGER pLoggerReleaseFile;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
char szError[RTPATH_MAX + 128] = "";
int vrc = RTLogCreateEx(&pLoggerReleaseFile, fFlags, "all",
"VBOXSVC_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, 0 /* fDestFlags */,
vboxsvcHeaderFooter, cHistory, uHistoryFileSize, uHistoryFileTime,
szError, sizeof(szError), pszLogFile);
if (RT_SUCCESS(vrc))
{
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(pLoggerReleaseFile);
/* Explicitly flush the log in case of VBOXWEBSRV_RELEASE_LOG=buffered. */
RTLogFlush(pLoggerReleaseFile);
}
else
{
/* print a message, but do not fail */
RTMsgError("failed to open release log (%s, %Rrc)", szError, vrc);
}
return vrc;
}
/**
* Create default logger in order to print output to the specified file.
*
* @return IPRT status code.
*/
static int vbclInitLogger(char *szLogFileName)
{
int rc;
uint32_t fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
uint32_t fDestFlags = RTLOGDEST_STDOUT;
rc = RTLogCreateEx(&g_pLogger,
fFlags, /* Logger instance flags, a combination of the RTLOGFLAGS_* values */
"all", /* The initial group settings */
"VBOXCLIENT_RELEASE_LOG", /* Base name for the environment variables for this instance */
RT_ELEMENTS(s_apszGroups), /* Number of groups in the array */
s_apszGroups, /* Pointer to array of groups. This must stick around for the life of the logger instance */
fDestFlags, /* The destination flags */
NULL, /* Callback function for starting logging and for ending or starting a new file for log history rotation */
szLogFileName ? 10 : 0, /* Number of old log files to keep when performing log history rotation */
szLogFileName ? 100 * _1M : 0, /* Maximum size of log file when performing history rotation */
szLogFileName ? RT_SEC_1DAY : 0, /* Maximum time interval per log file when performing history rotation */
0, /* A buffer which is filled with an error message if something fails */
0, /* The size of the error message buffer */
szLogFileName /* Log filename format string */
);
AssertReturn(RT_SUCCESS(rc), rc);
/* Register this logger as the release logger */
RTLogRelSetDefaultInstance(g_pLogger);
/* Explicitly flush the log in case of VBOXCLIENT_RELEASE_LOG=buffered. */
RTLogFlush(g_pLogger);
return rc;
}
/**
* Destroy logger.
*/
static void vbclTermLogger(char *szLogFileName)
{
// Why SIGBUS here?
RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
if (szLogFileName)
RTStrFree(szLogFileName);
}
int _fini(void)
{
LogFlow((DEVICE_NAME ":_fini\n"));
int rc = mod_remove(&g_VBoxGuestSolarisModLinkage);
if (!rc)
ddi_soft_state_fini(&g_pVBoxGuestSolarisState);
RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
RTLogDestroy(RTLogSetDefaultInstance(NULL));
RTR0Term();
return rc;
}
/**
* Unload the module.
*/
static void __exit vboxguestLinuxModExit(void)
{
/*
* Inverse order of init.
*/
vboxguestLinuxTermDeviceNodes();
#ifdef VBOXGUEST_WITH_INPUT_DRIVER
vboxguestLinuxTermInputDevice();
#endif
VbgdCommonCloseSession(&g_DevExt, g_pKernelSession);
VbgdCommonDeleteDevExt(&g_DevExt);
vboxguestLinuxTermISR();
pci_unregister_driver(&g_PciDriver);
RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
RTLogDestroy(RTLogSetDefaultInstance(NULL));
RTR0Term();
}
/**
* 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;
}
static VOID vboxUsbDdiUnload(PDRIVER_OBJECT pDriverObject)
{
LogRel(("VBoxUsb::DriverUnload. Built Date (%s) Time (%s)\n", __DATE__, __TIME__));
VBoxDrvToolStrFree(&g_VBoxUsbGlobals.RegPath);
vboxUsbRtGlobalsTerm();
PRTLOGGER pLogger = RTLogRelSetDefaultInstance(NULL);
if (pLogger)
{
RTLogDestroy(pLogger);
}
pLogger = RTLogSetDefaultInstance(NULL);
if (pLogger)
{
RTLogDestroy(pLogger);
}
}
/**
* 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;
}
/**
* Implementation of VbglR3Init and VbglR3InitUser
*/
static int vbglR3Init(const char *pszDeviceName)
{
uint32_t cInits = ASMAtomicIncU32(&g_cInits);
Assert(cInits > 0);
if (cInits > 1)
{
/*
* This will fail if two (or more) threads race each other calling VbglR3Init.
* However it will work fine for single threaded or otherwise serialized
* processed calling us more than once.
*/
#ifdef RT_OS_WINDOWS
if (g_hFile == INVALID_HANDLE_VALUE)
#elif !defined (VBOX_VBGLR3_XFREE86)
if (g_File == NIL_RTFILE)
#else
if (g_File == -1)
#endif
return VERR_INTERNAL_ERROR;
return VINF_SUCCESS;
}
#if defined(RT_OS_WINDOWS)
if (g_hFile != INVALID_HANDLE_VALUE)
#elif !defined(VBOX_VBGLR3_XFREE86)
if (g_File != NIL_RTFILE)
#else
if (g_File != -1)
#endif
return VERR_INTERNAL_ERROR;
#if defined(RT_OS_WINDOWS)
/*
* Have to use CreateFile here as we want to specify FILE_FLAG_OVERLAPPED
* and possible some other bits not available thru iprt/file.h.
*/
HANDLE hFile = CreateFile(pszDeviceName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
return VERR_OPEN_FAILED;
g_hFile = hFile;
#elif defined(RT_OS_OS2)
/*
* We might wish to compile this with Watcom, so stick to
* the OS/2 APIs all the way. And in any case we have to use
* DosDevIOCtl for the requests, why not use Dos* for everything.
*/
HFILE hf = NULLHANDLE;
ULONG ulAction = 0;
APIRET rc = DosOpen((PCSZ)pszDeviceName, &hf, &ulAction, 0, FILE_NORMAL,
OPEN_ACTION_OPEN_IF_EXISTS,
OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE | OPEN_ACCESS_READWRITE,
NULL);
if (rc)
return RTErrConvertFromOS2(rc);
if (hf < 16)
{
HFILE ahfs[16];
unsigned i;
for (i = 0; i < RT_ELEMENTS(ahfs); i++)
{
ahfs[i] = 0xffffffff;
rc = DosDupHandle(hf, &ahfs[i]);
if (rc)
break;
}
if (i-- > 1)
{
ULONG fulState = 0;
rc = DosQueryFHState(ahfs[i], &fulState);
if (!rc)
{
fulState |= OPEN_FLAGS_NOINHERIT;
fulState &= OPEN_FLAGS_WRITE_THROUGH | OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_CACHE | OPEN_FLAGS_NOINHERIT; /* Turn off non-participating bits. */
rc = DosSetFHState(ahfs[i], fulState);
}
if (!rc)
{
rc = DosClose(hf);
AssertMsg(!rc, ("%ld\n", rc));
hf = ahfs[i];
}
else
i++;
while (i-- > 0)
DosClose(ahfs[i]);
}
}
g_File = (RTFILE)hf;
#elif defined(VBOX_VBGLR3_XFREE86)
int File = xf86open(pszDeviceName, XF86_O_RDWR);
if (File == -1)
return VERR_OPEN_FAILED;
g_File = File;
#else
/* The default implementation. (linux, solaris, freebsd) */
RTFILE File;
int rc = RTFileOpen(&File, pszDeviceName, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
if (RT_FAILURE(rc))
return rc;
g_File = File;
#endif
#ifndef VBOX_VBGLR3_XFREE86
/*
* Create release logger
*/
PRTLOGGER pReleaseLogger;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
int rc2 = RTLogCreate(&pReleaseLogger, 0, "all", "VBOX_RELEASE_LOG",
RT_ELEMENTS(s_apszGroups), &s_apszGroups[0], RTLOGDEST_USER, NULL);
/* This may legitimately fail if we are using the mini-runtime. */
if (RT_SUCCESS(rc2))
RTLogRelSetDefaultInstance(pReleaseLogger);
#endif
return VINF_SUCCESS;
}
static void VBoxServiceLogDestroy(void)
{
RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
}
/**
* Destroys the currently active logging instance.
*/
void VGSvcLogDestroy(void)
{
RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
}
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;
}
int main(int argc, char **argv)
{
int rcRet = 1;
int rc;
RTR3InitAndSUPLib();
/*
* Parse input.
*/
if (argc <= 1)
{
syntax();
return 1;
}
bool fPowerOn = false;
uint32_t u32WarpDrive = 100; /* % */
uint64_t cbMem = ~0ULL;
const char *pszSavedState = NULL;
const char *pszRawMem = NULL;
uint64_t offRawMem = 0;
const char *pszScript = NULL;
for (int i = 1; i < argc; i++)
{
if (argv[i][0] == '-')
{
/* check that it's on short form */
if (argv[i][2])
{
if ( strcmp(argv[i], "--help")
&& strcmp(argv[i], "-help"))
RTPrintf("tstAnimate: Syntax error: Unknown argument '%s'.\n", argv[i]);
else
syntax();
return 1;
}
/* check for 2nd argument */
switch (argv[i][1])
{
case 'r':
case 'o':
case 'c':
case 'm':
case 'w':
case 'z':
if (i + 1 < argc)
break;
RTPrintf("tstAnimate: Syntax error: '%s' takes a 2nd argument.\n", argv[i]);
return 1;
}
/* process argument */
switch (argv[i][1])
{
case 'r':
pszRawMem = argv[++i];
break;
case 'z':
pszSavedState = argv[++i];
break;
case 'o':
{
rc = RTStrToUInt64Ex(argv[++i], NULL, 0, &offRawMem);
if (RT_FAILURE(rc))
{
RTPrintf("tstAnimate: Syntax error: Invalid offset given to -o.\n");
return 1;
}
break;
}
case 'm':
{
char *pszNext;
rc = RTStrToUInt64Ex(argv[++i], &pszNext, 0, &cbMem);
if (RT_FAILURE(rc))
{
RTPrintf("tstAnimate: Syntax error: Invalid memory size given to -m.\n");
return 1;
}
switch (*pszNext)
{
case 'G': cbMem *= _1G; pszNext++; break;
case 'M': cbMem *= _1M; pszNext++; break;
case 'K': cbMem *= _1K; pszNext++; break;
case '\0': break;
default:
RTPrintf("tstAnimate: Syntax error: Invalid memory size given to -m.\n");
return 1;
}
if (*pszNext)
{
RTPrintf("tstAnimate: Syntax error: Invalid memory size given to -m.\n");
return 1;
}
break;
}
case 's':
pszScript = argv[++i];
break;
case 'p':
fPowerOn = true;
break;
case 'w':
{
rc = RTStrToUInt32Ex(argv[++i], NULL, 0, &u32WarpDrive);
if (RT_FAILURE(rc))
{
RTPrintf("tstAnimate: Syntax error: Invalid number given to -w.\n");
return 1;
}
break;
}
case 'h':
case 'H':
case '?':
syntax();
return 1;
default:
RTPrintf("tstAnimate: Syntax error: Unknown argument '%s'.\n", argv[i]);
return 1;
}
}
else
{
RTPrintf("tstAnimate: Syntax error at arg no. %d '%s'.\n", i, argv[i]);
syntax();
return 1;
}
}
/*
* Check that the basic requirements are met.
*/
if (pszRawMem && pszSavedState)
{
RTPrintf("tstAnimate: Syntax error: Either -z or -r, not both.\n");
return 1;
}
if (!pszRawMem && !pszSavedState)
{
RTPrintf("tstAnimate: Syntax error: The -r argument is compulsory.\n");
return 1;
}
/*
* Open the files.
*/
RTFILE FileRawMem = NIL_RTFILE;
if (pszRawMem)
{
rc = RTFileOpen(&FileRawMem, pszRawMem, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
if (RT_FAILURE(rc))
{
RTPrintf("tstAnimate: error: Failed to open '%s': %Rrc\n", pszRawMem, rc);
return 1;
}
}
RTFILE FileScript = NIL_RTFILE;
if (pszScript)
{
rc = RTFileOpen(&FileScript, pszScript, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
if (RT_FAILURE(rc))
{
RTPrintf("tstAnimate: error: Failed to open '%s': %Rrc\n", pszScript, rc);
return 1;
}
}
/*
* Figure the memsize if not specified.
*/
if (cbMem == ~0ULL)
{
if (FileRawMem != NIL_RTFILE)
{
rc = RTFileGetSize(FileRawMem, &cbMem);
AssertReleaseRC(rc);
cbMem -= offRawMem;
cbMem &= ~(PAGE_SIZE - 1);
}
else
{
RTPrintf("tstAnimate: error: too lazy to figure out the memsize in a saved state.\n");
return 1;
}
}
RTPrintf("tstAnimate: info: cbMem=0x%llx bytes\n", cbMem);
/*
* Open a release log.
*/
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
PRTLOGGER pRelLogger;
rc = RTLogCreate(&pRelLogger, RTLOGFLAGS_PREFIX_TIME_PROG, "all", "VBOX_RELEASE_LOG",
RT_ELEMENTS(s_apszGroups), s_apszGroups, RTLOGDEST_FILE, "./tstAnimate.log");
if (RT_SUCCESS(rc))
RTLogRelSetDefaultInstance(pRelLogger);
else
RTPrintf("tstAnimate: rtLogCreateEx failed - %Rrc\n", rc);
/*
* Create empty VM.
*/
PVM pVM;
rc = VMR3Create(1, NULL, NULL, NULL, cfgmR3CreateDefault, &cbMem, &pVM);
if (RT_SUCCESS(rc))
{
/*
* Load memory.
*/
if (FileRawMem != NIL_RTFILE)
rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)loadMem, 3, pVM, FileRawMem, &offRawMem);
else
rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)SSMR3Load,
7, pVM, pszSavedState, (uintptr_t)NULL /*pStreamOps*/, (uintptr_t)NULL /*pvUser*/,
SSMAFTER_DEBUG_IT, (uintptr_t)NULL /*pfnProgress*/, (uintptr_t)NULL /*pvProgressUser*/);
if (RT_SUCCESS(rc))
{
/*
* Load register script.
*/
if (FileScript != NIL_RTFILE)
rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)scriptRun, 2, pVM, FileScript);
if (RT_SUCCESS(rc))
{
if (fPowerOn)
{
/*
* Adjust warpspeed?
*/
if (u32WarpDrive != 100)
{
rc = TMR3SetWarpDrive(pVM, u32WarpDrive);
if (RT_FAILURE(rc))
RTPrintf("warning: TMVirtualSetWarpDrive(,%u) -> %Rrc\n", u32WarpDrive, rc);
}
/*
* Start the thing with single stepping and stuff enabled.
* (Try make sure we don't execute anything in raw mode.)
*/
RTPrintf("info: powering on the VM...\n");
RTLogGroupSettings(NULL, "+REM_DISAS.e.l.f");
rc = REMR3DisasEnableStepping(pVM, true);
if (RT_SUCCESS(rc))
{
rc = EMR3SetExecutionPolicy(pVM, EMEXECPOLICY_RECOMPILE_RING0, true); AssertReleaseRC(rc);
rc = EMR3SetExecutionPolicy(pVM, EMEXECPOLICY_RECOMPILE_RING3, true); AssertReleaseRC(rc);
DBGFR3Info(pVM, "cpumguest", "verbose", NULL);
if (fPowerOn)
rc = VMR3PowerOn(pVM);
if (RT_SUCCESS(rc))
{
RTPrintf("info: VM is running\n");
signal(SIGINT, SigInterrupt);
while (!g_fSignaled)
RTThreadSleep(1000);
}
else
RTPrintf("error: Failed to power on the VM: %Rrc\n", rc);
}
else
RTPrintf("error: Failed to enabled singlestepping: %Rrc\n", rc);
}
else
{
/*
* Don't start it, just enter the debugger.
*/
RTPrintf("info: entering debugger...\n");
DBGFR3Info(pVM, "cpumguest", "verbose", NULL);
signal(SIGINT, SigInterrupt);
while (!g_fSignaled)
RTThreadSleep(1000);
}
RTPrintf("info: shutting down the VM...\n");
}
/* execScript complains */
}
else if (FileRawMem == NIL_RTFILE) /* loadMem complains, SSMR3Load doesn't */
RTPrintf("tstAnimate: error: SSMR3Load failed: rc=%Rrc\n", rc);
rcRet = RT_SUCCESS(rc) ? 0 : 1;
/*
* Cleanup.
*/
rc = VMR3Destroy(pVM);
if (!RT_SUCCESS(rc))
{
RTPrintf("tstAnimate: error: failed to destroy vm! rc=%Rrc\n", rc);
rcRet++;
}
}
else
{
RTPrintf("tstAnimate: fatal error: failed to create vm! rc=%Rrc\n", rc);
rcRet++;
}
return rcRet;
}
static int vboxInitLogging(const char *pszFilename, bool bGenNameSuffix)
{
PRTLOGGER loggerRelease;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
char szError[RTPATH_MAX + 128] = "";
const char * pszFilenameFmt;
RTLOGDEST enmLogDest;
if(pszFilename)
{
if(bGenNameSuffix)
pszFilenameFmt = "%s.%ld.log";
else
pszFilenameFmt = "%s";
enmLogDest = RTLOGDEST_FILE;
}
else
{
pszFilenameFmt = NULL;
enmLogDest = RTLOGDEST_STDOUT;
}
int vrc = RTLogCreateEx(&loggerRelease, fFlags, "all",
"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, enmLogDest,
NULL /* pfnBeginEnd */, 0 /* cHistory */, 0 /* cbHistoryFileMax */, 0 /* uHistoryTimeMax */,
szError, sizeof(szError), pszFilenameFmt, pszFilename, RTTimeMilliTS());
if (RT_SUCCESS(vrc))
{
/* some introductory information */
RTTIMESPEC timeSpec;
char szTmp[256];
RTTimeSpecToString(RTTimeNow(&timeSpec), szTmp, sizeof(szTmp));
RTLogRelLogger(loggerRelease, 0, ~0U,
"VBoxTestGL %s r%u %s (%s %s) release log\n"
#ifdef VBOX_BLEEDING_EDGE
"EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
#endif
"Log opened %s\n",
VBOX_VERSION_STRING, RTBldCfgRevision(), VBOX_BUILD_TARGET,
__DATE__, __TIME__, szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Product: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Release: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Version: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Service Pack: %s\n", szTmp);
// RTLogRelLogger(loggerRelease, 0, ~0U, "Host RAM: %uMB RAM, available: %uMB\n",
// uHostRamMb, uHostRamAvailMb);
/* the package type is interesting for Linux distributions */
char szExecName[RTPATH_MAX];
char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
RTLogRelLogger(loggerRelease, 0, ~0U,
"Executable: %s\n"
"Process ID: %u\n"
"Package type: %s"
#ifdef VBOX_OSE
" (OSE)"
#endif
"\n",
pszExecName ? pszExecName : "unknown",
RTProcSelf(),
VBOX_PACKAGE_STRING);
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(loggerRelease);
return VINF_SUCCESS;
}
return vrc;
}
/**
* Implementation of VbglR3Init and VbglR3InitUser
*/
static int vbglR3Init(const char *pszDeviceName)
{
uint32_t cInits = ASMAtomicIncU32(&g_cInits);
Assert(cInits > 0);
if (cInits > 1)
{
/*
* This will fail if two (or more) threads race each other calling VbglR3Init.
* However it will work fine for single threaded or otherwise serialized
* processed calling us more than once.
*/
#ifdef RT_OS_WINDOWS
if (g_hFile == INVALID_HANDLE_VALUE)
#elif !defined (VBOX_VBGLR3_XSERVER)
if (g_File == NIL_RTFILE)
#else
if (g_File == -1)
#endif
return VERR_INTERNAL_ERROR;
return VINF_SUCCESS;
}
#if defined(RT_OS_WINDOWS)
if (g_hFile != INVALID_HANDLE_VALUE)
#elif !defined(VBOX_VBGLR3_XSERVER)
if (g_File != NIL_RTFILE)
#else
if (g_File != -1)
#endif
return VERR_INTERNAL_ERROR;
#if defined(RT_OS_WINDOWS)
/*
* Have to use CreateFile here as we want to specify FILE_FLAG_OVERLAPPED
* and possible some other bits not available thru iprt/file.h.
*/
HANDLE hFile = CreateFile(pszDeviceName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
return VERR_OPEN_FAILED;
g_hFile = hFile;
#elif defined(RT_OS_OS2)
/*
* We might wish to compile this with Watcom, so stick to
* the OS/2 APIs all the way. And in any case we have to use
* DosDevIOCtl for the requests, why not use Dos* for everything.
*/
HFILE hf = NULLHANDLE;
ULONG ulAction = 0;
APIRET rc = DosOpen((PCSZ)pszDeviceName, &hf, &ulAction, 0, FILE_NORMAL,
OPEN_ACTION_OPEN_IF_EXISTS,
OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE | OPEN_ACCESS_READWRITE,
NULL);
if (rc)
return RTErrConvertFromOS2(rc);
if (hf < 16)
{
HFILE ahfs[16];
unsigned i;
for (i = 0; i < RT_ELEMENTS(ahfs); i++)
{
ahfs[i] = 0xffffffff;
rc = DosDupHandle(hf, &ahfs[i]);
if (rc)
break;
}
if (i-- > 1)
{
ULONG fulState = 0;
rc = DosQueryFHState(ahfs[i], &fulState);
if (!rc)
{
fulState |= OPEN_FLAGS_NOINHERIT;
fulState &= OPEN_FLAGS_WRITE_THROUGH | OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_CACHE | OPEN_FLAGS_NOINHERIT; /* Turn off non-participating bits. */
rc = DosSetFHState(ahfs[i], fulState);
}
if (!rc)
{
rc = DosClose(hf);
AssertMsg(!rc, ("%ld\n", rc));
hf = ahfs[i];
}
else
i++;
while (i-- > 0)
DosClose(ahfs[i]);
}
}
g_File = (RTFILE)hf;
#elif defined(RT_OS_DARWIN)
/*
* Darwin is kind of special we need to engage the device via I/O first
* before we open it via the BSD device node.
*/
mach_port_t MasterPort;
kern_return_t kr = IOMasterPort(MACH_PORT_NULL, &MasterPort);
if (kr != kIOReturnSuccess)
return VERR_GENERAL_FAILURE;
CFDictionaryRef ClassToMatch = IOServiceMatching("org_virtualbox_VBoxGuest");
if (!ClassToMatch)
return VERR_GENERAL_FAILURE;
io_service_t ServiceObject = IOServiceGetMatchingService(kIOMasterPortDefault, ClassToMatch);
if (!ServiceObject)
return VERR_NOT_FOUND;
io_connect_t uConnection;
kr = IOServiceOpen(ServiceObject, mach_task_self(), VBOXGUEST_DARWIN_IOSERVICE_COOKIE, &uConnection);
IOObjectRelease(ServiceObject);
if (kr != kIOReturnSuccess)
return VERR_OPEN_FAILED;
RTFILE hFile;
int rc = RTFileOpen(&hFile, pszDeviceName, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
if (RT_FAILURE(rc))
{
IOServiceClose(uConnection);
return rc;
}
g_File = hFile;
g_uConnection = uConnection;
#elif defined(VBOX_VBGLR3_XSERVER)
int File = xf86open(pszDeviceName, XF86_O_RDWR);
if (File == -1)
return VERR_OPEN_FAILED;
g_File = File;
#else
/* The default implementation. (linux, solaris, freebsd, haiku) */
RTFILE File;
int rc = RTFileOpen(&File, pszDeviceName, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
if (RT_FAILURE(rc))
return rc;
g_File = File;
#endif
#ifndef VBOX_VBGLR3_XSERVER
/*
* Create release logger
*/
PRTLOGGER pReleaseLogger;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
int rc2 = RTLogCreate(&pReleaseLogger, 0, "all", "VBOX_RELEASE_LOG",
RT_ELEMENTS(s_apszGroups), &s_apszGroups[0], RTLOGDEST_USER, NULL);
/* This may legitimately fail if we are using the mini-runtime. */
if (RT_SUCCESS(rc2))
RTLogRelSetDefaultInstance(pReleaseLogger);
#endif
return VINF_SUCCESS;
}
