/**
* Fallback for VbglR3GetAdditionsVersion.
*/
static int vbglR3GetAdditionsCompileTimeVersion(char **ppszVer, char **ppszVerEx, char **ppszRev)
{
int rc = VINF_SUCCESS;
if (ppszVer)
rc = RTStrDupEx(ppszVer, VBOX_VERSION_STRING_RAW);
if (RT_SUCCESS(rc))
{
if (ppszVerEx)
rc = RTStrDupEx(ppszVerEx, VBOX_VERSION_STRING);
if (RT_SUCCESS(rc))
{
if (ppszRev)
{
#if 0
char szRev[64];
RTStrPrintf(szRev, sizeof(szRev), "%d", VBOX_SVN_REV);
rc = RTStrDupEx(ppszRev, szRev);
#else
rc = RTStrDupEx(ppszRev, RT_XSTR(VBOX_SVN_REV));
#endif
}
if (RT_SUCCESS(rc))
return VINF_SUCCESS;
/* bail out: */
}
if (ppszVerEx)
{
RTStrFree(*ppszVerEx);
*ppszVerEx = NULL;
}
}
if (ppszVer)
{
RTStrFree(*ppszVer);
*ppszVer = NULL;
}
return rc;
}
nulldev, /* probe */
VBoxUSBMonSolarisAttach,
VBoxUSBMonSolarisDetach,
nodev, /* reset */
&g_VBoxUSBMonSolarisCbOps,
(struct bus_ops *)0,
nodev /* power */
};
/**
* modldrv: export driver specifics to the kernel
*/
static struct modldrv g_VBoxUSBMonSolarisModule =
{
&mod_driverops, /* extern from kernel */
DEVICE_DESC_DRV " " VBOX_VERSION_STRING "r" RT_XSTR(VBOX_SVN_REV),
&g_VBoxUSBMonSolarisDevOps
};
/**
* modlinkage: export install/remove/info to the kernel
*/
static struct modlinkage g_VBoxUSBMonSolarisModLinkage =
{
MODREV_1,
&g_VBoxUSBMonSolarisModule,
NULL,
};
/**
* Client driver info.
/**
* 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;
}
static void vboxNetAdpEthGetDrvinfo(struct net_device *dev, struct ethtool_drvinfo *info);
static int vboxNetAdpEthGetSettings(struct net_device *dev, struct ethtool_cmd *cmd);
/*********************************************************************************************************************************
* Global Variables *
*********************************************************************************************************************************/
module_init(VBoxNetAdpLinuxInit);
module_exit(VBoxNetAdpLinuxUnload);
MODULE_AUTHOR(VBOX_VENDOR);
MODULE_DESCRIPTION(VBOX_PRODUCT " Network Adapter Driver");
MODULE_LICENSE("GPL");
#ifdef MODULE_VERSION
MODULE_VERSION(VBOX_VERSION_STRING " (" RT_XSTR(INTNETTRUNKIFPORT_VERSION) ")");
#endif
/**
* The (common) global data.
*/
static struct file_operations gFileOpsVBoxNetAdp =
{
owner: THIS_MODULE,
open: VBoxNetAdpLinuxOpen,
release: VBoxNetAdpLinuxClose,
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
ioctl: VBoxNetAdpLinuxIOCtl,
#else /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36) */
unlocked_ioctl: VBoxNetAdpLinuxIOCtlUnlocked,
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36) */
/* Module initialization/finalization handlers */
static int __init init(void)
{
int rcVBox;
int rcRet = 0;
int err;
TRACE();
if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE)
{
printk(KERN_ERR
"Mount information structure is too large %lu\n"
"Must be less than or equal to %lu\n",
(unsigned long)sizeof (struct vbsf_mount_info_new),
(unsigned long)PAGE_SIZE);
return -EINVAL;
}
err = register_filesystem(&vboxsf_fs_type);
if (err)
{
LogFunc(("register_filesystem err=%d\n", err));
return err;
}
rcVBox = vboxInit();
if (RT_FAILURE(rcVBox))
{
LogRelFunc(("vboxInit failed, rc=%d\n", rcVBox));
rcRet = -EPROTO;
goto fail0;
}
rcVBox = vboxConnect(&client_handle);
if (RT_FAILURE(rcVBox))
{
LogRelFunc(("vboxConnect failed, rc=%d\n", rcVBox));
rcRet = -EPROTO;
goto fail1;
}
rcVBox = vboxCallSetUtf8(&client_handle);
if (RT_FAILURE(rcVBox))
{
LogRelFunc(("vboxCallSetUtf8 failed, rc=%d\n", rcVBox));
rcRet = -EPROTO;
goto fail2;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
if (!follow_symlinks)
{
rcVBox = vboxCallSetSymlinks(&client_handle);
if (RT_FAILURE(rcVBox))
{
printk(KERN_WARNING
"vboxsf: Host unable to show symlinks, rc=%d\n",
rcVBox);
}
}
#endif
printk(KERN_DEBUG
"vboxsf: Successfully loaded version " VBOX_VERSION_STRING
" (interface " RT_XSTR(VMMDEV_VERSION) ")\n");
return 0;
fail2:
vboxDisconnect(&client_handle);
fail1:
vboxUninit();
fail0:
unregister_filesystem(&vboxsf_fs_type);
return rcRet;
}
*/
/**
* @note Anyone wishing to make changes here might wish to take a look at
* http://www.atnf.csiro.au/people/rgooch/linux/vfs.txt
* which seems to be the closest there is to official documentation on
* writing filesystem drivers for Linux.
*/
#include "vfsmod.h"
MODULE_DESCRIPTION(VBOX_PRODUCT " VFS Module for Host File System Access");
MODULE_AUTHOR(VBOX_VENDOR);
MODULE_LICENSE("GPL");
#ifdef MODULE_VERSION
MODULE_VERSION(VBOX_VERSION_STRING " (interface " RT_XSTR(VMMDEV_VERSION) ")");
#endif
/* globals */
VBSFCLIENT client_handle;
/* forward declarations */
static struct super_operations sf_super_ops;
/* allocate global info, try to map host share */
static int sf_glob_alloc(struct vbsf_mount_info_new *info, struct sf_glob_info **sf_gp)
{
int err, rc;
SHFLSTRING *str_name;
size_t name_len, str_len;
struct sf_glob_info *sf_g;
/**
* 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;
}
#ifdef CONFIG_VGA_CONSOLE
if (vgacon_text_force() && vbox_modeset == -1)
return -EINVAL;
#endif
if (vbox_modeset == 0)
return -EINVAL;
/* Do not load if any of the virtual consoles is in graphics mode to be
* sure that we do not pick a fight with a user-mode driver or VESA. */
for (i = 0; i < MAX_NR_CONSOLES - 1; ++i)
if (vc_cons[i].d && vc_cons[i].d->vc_mode == KD_GRAPHICS)
return -EINVAL;
return drm_pci_init(&driver, &vbox_pci_driver);
}
static void __exit vbox_exit(void)
{
drm_pci_exit(&driver, &vbox_pci_driver);
}
module_init(vbox_init);
module_exit(vbox_exit);
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL and additional rights");
#ifdef MODULE_VERSION
MODULE_VERSION(VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV));
#endif
RTDECL(const char *) RTBldCfgRevisionStr(void)
{
return RT_XSTR(IPRT_BLDCFG_SCM_REV);
}
#if (defined(RT_ARCH_AMD64) && LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)) || defined(VBOX_WITH_TEXT_MODMEM_HACK)
/**
* Memory for the executable memory heap (in IPRT).
*/
# ifdef DEBUG
# define EXEC_MEMORY_SIZE 6291456 /* 6 MB */
# else
# define EXEC_MEMORY_SIZE 1572864 /* 1.5 MB */
# endif
extern uint8_t g_abExecMemory[EXEC_MEMORY_SIZE];
# ifndef VBOX_WITH_TEXT_MODMEM_HACK
__asm__(".section execmemory, \"awx\", @progbits\n\t"
".align 32\n\t"
".globl g_abExecMemory\n"
"g_abExecMemory:\n\t"
".zero " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
".type g_abExecMemory, @object\n\t"
".size g_abExecMemory, " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
".text\n\t");
# else
__asm__(".text\n\t"
".align 4096\n\t"
".globl g_abExecMemory\n"
"g_abExecMemory:\n\t"
".zero " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
".type g_abExecMemory, @object\n\t"
".size g_abExecMemory, " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
".text\n\t");
# endif
#endif
BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_mul)(uint8_t bMode)
{
#define MUL_CHECK_EFLAGS_ZERO (uint16_t)(X86_EFL_AF | X86_EFL_ZF)
#define MUL_CHECK_EFLAGS (uint16_t)(X86_EFL_CF | X86_EFL_OF | X86_EFL_SF | X86_EFL_PF)
static const struct
{
RTCCUINTREG uInAX;
RTCCUINTREG uInBX;
RTCCUINTREG uOutDX;
RTCCUINTREG uOutAX;
uint16_t fFlags;
} s_aTests[] =
{
{ 1, 1,
0, 1, 0 },
{ 2, 2,
0, 4, 0 },
{ RTCCUINTREG_MAX, RTCCUINTREG_MAX,
RTCCUINTREG_MAX-1, 1, X86_EFL_CF | X86_EFL_OF },
{ RTCCINTREG_MAX, RTCCINTREG_MAX,
RTCCINTREG_MAX / 2, 1, X86_EFL_CF | X86_EFL_OF },
{ 1, RTCCUINTREG_MAX,
0, RTCCUINTREG_MAX, X86_EFL_PF | X86_EFL_SF },
{ 1, RTCCINTREG_MAX,
0, RTCCINTREG_MAX, X86_EFL_PF },
{ 2, RTCCINTREG_MAX,
0, RTCCUINTREG_MAX - 1, X86_EFL_SF },
{ (RTCCUINTREG)RTCCINTREG_MAX + 1, 2,
1, 0, X86_EFL_PF | X86_EFL_CF | X86_EFL_OF },
{ (RTCCUINTREG)RTCCINTREG_MAX / 2 + 1, 3,
0, ((RTCCUINTREG)RTCCINTREG_MAX / 2 + 1) * 3, X86_EFL_PF | X86_EFL_SF },
};
BS3REGCTX Ctx;
BS3TRAPFRAME TrapFrame;
unsigned i, j, k;
/* Ensure the structures are allocated before we sample the stack pointer. */
Bs3MemSet(&Ctx, 0, sizeof(Ctx));
Bs3MemSet(&TrapFrame, 0, sizeof(TrapFrame));
/*
* Create test context.
*/
Bs3RegCtxSaveEx(&Ctx, bMode, 512);
Bs3RegCtxSetRipCsFromCurPtr(&Ctx, BS3_CMN_NM(bs3CpuInstr2_mul_xBX_ud2));
for (k = 0; k < 2; k++)
{
Ctx.rflags.u16 |= MUL_CHECK_EFLAGS | MUL_CHECK_EFLAGS_ZERO;
for (j = 0; j < 2; j++)
{
for (i = 0; i < RT_ELEMENTS(s_aTests); i++)
{
if (k == 0)
{
Ctx.rax.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInAX;
Ctx.rbx.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInBX;
}
else
{
Ctx.rax.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInBX;
Ctx.rbx.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInAX;
}
Bs3TrapSetJmpAndRestore(&Ctx, &TrapFrame);
if (TrapFrame.bXcpt != X86_XCPT_UD)
Bs3TestFailedF("Expected #UD got %#x", TrapFrame.bXcpt);
else if ( TrapFrame.Ctx.rax.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutAX
|| TrapFrame.Ctx.rdx.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutDX
|| (TrapFrame.Ctx.rflags.u16 & (MUL_CHECK_EFLAGS | MUL_CHECK_EFLAGS_ZERO))
!= (s_aTests[i].fFlags & MUL_CHECK_EFLAGS) )
{
Bs3TestFailedF("test #%i failed: input %#" RTCCUINTREG_XFMT " * %#" RTCCUINTREG_XFMT,
i, s_aTests[i].uInAX, s_aTests[i].uInBX);
if (TrapFrame.Ctx.rax.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutAX)
Bs3TestFailedF("Expected xAX = %#RX" RT_XSTR(ARCH_BITS) " got %#RX" RT_XSTR(ARCH_BITS),
s_aTests[i].uOutAX, TrapFrame.Ctx.rax.RT_CONCAT(u,ARCH_BITS));
if (TrapFrame.Ctx.rdx.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutDX)
Bs3TestFailedF("Expected xDX = %#RX" RT_XSTR(ARCH_BITS) " got %#RX" RT_XSTR(ARCH_BITS),
s_aTests[i].uOutDX, TrapFrame.Ctx.rdx.RT_CONCAT(u,ARCH_BITS));
if ( (TrapFrame.Ctx.rflags.u16 & (MUL_CHECK_EFLAGS | MUL_CHECK_EFLAGS_ZERO))
!= (s_aTests[i].fFlags & MUL_CHECK_EFLAGS) )
Bs3TestFailedF("Expected EFLAGS = %#06RX16, got %#06RX16", s_aTests[i].fFlags & MUL_CHECK_EFLAGS,
TrapFrame.Ctx.rflags.u16 & (MUL_CHECK_EFLAGS | MUL_CHECK_EFLAGS_ZERO));
}
}
Ctx.rflags.u16 &= ~(MUL_CHECK_EFLAGS | MUL_CHECK_EFLAGS_ZERO);
}
}
return 0;
}
BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_imul)(uint8_t bMode)
{
#define IMUL_CHECK_EFLAGS_ZERO (uint16_t)(X86_EFL_AF | X86_EFL_ZF)
#define IMUL_CHECK_EFLAGS (uint16_t)(X86_EFL_CF | X86_EFL_OF | X86_EFL_SF | X86_EFL_PF)
static const struct
{
RTCCUINTREG uInAX;
RTCCUINTREG uInBX;
RTCCUINTREG uOutDX;
RTCCUINTREG uOutAX;
uint16_t fFlags;
} s_aTests[] =
{
/* two positive values. */
{ 1, 1,
0, 1, 0 },
{ 2, 2,
0, 4, 0 },
{ RTCCINTREG_MAX, RTCCINTREG_MAX,
RTCCINTREG_MAX/2, 1, X86_EFL_CF | X86_EFL_OF },
{ 1, RTCCINTREG_MAX,
0, RTCCINTREG_MAX, X86_EFL_PF },
{ 2, RTCCINTREG_MAX,
0, RTCCUINTREG_MAX - 1U, X86_EFL_CF | X86_EFL_OF | X86_EFL_SF },
{ 2, RTCCINTREG_MAX / 2,
0, RTCCINTREG_MAX - 1U, 0 },
{ 2, (RTCCINTREG_MAX / 2 + 1),
0, (RTCCUINTREG)RTCCINTREG_MAX + 1U, X86_EFL_CF | X86_EFL_OF | X86_EFL_SF | X86_EFL_PF },
{ 4, (RTCCINTREG_MAX / 2 + 1),
1, 0, X86_EFL_CF | X86_EFL_OF | X86_EFL_PF },
/* negative and positive */
{ -4, 3,
-1, -12, X86_EFL_SF },
{ 32, -127,
-1, -4064, X86_EFL_SF },
{ RTCCINTREG_MIN, 1,
-1, RTCCINTREG_MIN, X86_EFL_SF | X86_EFL_PF },
{ RTCCINTREG_MIN, 2,
-1, 0, X86_EFL_CF | X86_EFL_OF | X86_EFL_PF },
{ RTCCINTREG_MIN, 3,
-2, RTCCINTREG_MIN, X86_EFL_CF | X86_EFL_OF | X86_EFL_SF | X86_EFL_PF },
{ RTCCINTREG_MIN, 4,
-2, 0, X86_EFL_CF | X86_EFL_OF | X86_EFL_PF },
{ RTCCINTREG_MIN, RTCCINTREG_MAX,
RTCCINTREG_MIN / 2, RTCCINTREG_MIN, X86_EFL_CF | X86_EFL_OF | X86_EFL_SF | X86_EFL_PF },
{ RTCCINTREG_MIN, RTCCINTREG_MAX - 1,
RTCCINTREG_MIN / 2 + 1, 0, X86_EFL_CF | X86_EFL_OF | X86_EFL_PF },
/* two negative values. */
{ -4, -63,
0, 252, X86_EFL_PF },
{ RTCCINTREG_MIN, RTCCINTREG_MIN,
RTCCUINTREG_MAX / 4 + 1, 0, X86_EFL_CF | X86_EFL_OF | X86_EFL_PF },
{ RTCCINTREG_MIN, RTCCINTREG_MIN + 1,
RTCCUINTREG_MAX / 4, RTCCINTREG_MIN, X86_EFL_CF | X86_EFL_OF | X86_EFL_SF | X86_EFL_PF},
{ RTCCINTREG_MIN + 1, RTCCINTREG_MIN + 1,
RTCCUINTREG_MAX / 4, 1, X86_EFL_CF | X86_EFL_OF },
};
BS3REGCTX Ctx;
BS3TRAPFRAME TrapFrame;
unsigned i, j, k;
/* Ensure the structures are allocated before we sample the stack pointer. */
Bs3MemSet(&Ctx, 0, sizeof(Ctx));
Bs3MemSet(&TrapFrame, 0, sizeof(TrapFrame));
/*
* Create test context.
*/
Bs3RegCtxSaveEx(&Ctx, bMode, 512);
Bs3RegCtxSetRipCsFromCurPtr(&Ctx, BS3_CMN_NM(bs3CpuInstr2_imul_xBX_ud2));
for (k = 0; k < 2; k++)
{
Ctx.rflags.u16 |= MUL_CHECK_EFLAGS | MUL_CHECK_EFLAGS_ZERO;
for (j = 0; j < 2; j++)
{
for (i = 0; i < RT_ELEMENTS(s_aTests); i++)
{
if (k == 0)
{
Ctx.rax.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInAX;
Ctx.rbx.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInBX;
}
else
{
Ctx.rax.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInBX;
Ctx.rbx.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInAX;
}
Bs3TrapSetJmpAndRestore(&Ctx, &TrapFrame);
if (TrapFrame.bXcpt != X86_XCPT_UD)
Bs3TestFailedF("Expected #UD got %#x", TrapFrame.bXcpt);
else if ( TrapFrame.Ctx.rax.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutAX
|| TrapFrame.Ctx.rdx.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutDX
|| (TrapFrame.Ctx.rflags.u16 & (IMUL_CHECK_EFLAGS | IMUL_CHECK_EFLAGS_ZERO))
!= (s_aTests[i].fFlags & IMUL_CHECK_EFLAGS) )
{
Bs3TestFailedF("test #%i failed: input %#" RTCCUINTREG_XFMT " * %#" RTCCUINTREG_XFMT,
i, s_aTests[i].uInAX, s_aTests[i].uInBX);
if (TrapFrame.Ctx.rax.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutAX)
Bs3TestFailedF("Expected xAX = %#RX" RT_XSTR(ARCH_BITS) " got %#RX" RT_XSTR(ARCH_BITS),
s_aTests[i].uOutAX, TrapFrame.Ctx.rax.RT_CONCAT(u,ARCH_BITS));
if (TrapFrame.Ctx.rdx.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutDX)
Bs3TestFailedF("Expected xDX = %#RX" RT_XSTR(ARCH_BITS) " got %#RX" RT_XSTR(ARCH_BITS),
s_aTests[i].uOutDX, TrapFrame.Ctx.rdx.RT_CONCAT(u,ARCH_BITS));
if ( (TrapFrame.Ctx.rflags.u16 & (IMUL_CHECK_EFLAGS | IMUL_CHECK_EFLAGS_ZERO))
!= (s_aTests[i].fFlags & IMUL_CHECK_EFLAGS) )
Bs3TestFailedF("Expected EFLAGS = %#06RX16, got %#06RX16", s_aTests[i].fFlags & IMUL_CHECK_EFLAGS,
TrapFrame.Ctx.rflags.u16 & (IMUL_CHECK_EFLAGS | IMUL_CHECK_EFLAGS_ZERO));
}
}
}
}
/*
* Repeat for the truncating two operand version.
*/
Bs3RegCtxSetRipCsFromCurPtr(&Ctx, BS3_CMN_NM(bs3CpuInstr2_imul_xCX_xBX_ud2));
for (k = 0; k < 2; k++)
{
Ctx.rflags.u16 |= MUL_CHECK_EFLAGS | MUL_CHECK_EFLAGS_ZERO;
for (j = 0; j < 2; j++)
{
for (i = 0; i < RT_ELEMENTS(s_aTests); i++)
{
if (k == 0)
{
Ctx.rcx.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInAX;
Ctx.rbx.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInBX;
}
else
{
Ctx.rcx.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInBX;
Ctx.rbx.RT_CONCAT(u,ARCH_BITS) = s_aTests[i].uInAX;
}
Bs3TrapSetJmpAndRestore(&Ctx, &TrapFrame);
if (TrapFrame.bXcpt != X86_XCPT_UD)
Bs3TestFailedF("Expected #UD got %#x", TrapFrame.bXcpt);
else if ( TrapFrame.Ctx.rcx.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutAX
|| TrapFrame.Ctx.rdx.u != Ctx.rdx.u
|| TrapFrame.Ctx.rbx.u != Ctx.rbx.u
|| (TrapFrame.Ctx.rflags.u16 & (IMUL_CHECK_EFLAGS | IMUL_CHECK_EFLAGS_ZERO))
!= (s_aTests[i].fFlags & IMUL_CHECK_EFLAGS) )
{
Bs3TestFailedF("test #%i failed: input %#" RTCCUINTREG_XFMT " * %#" RTCCUINTREG_XFMT,
i, s_aTests[i].uInAX, s_aTests[i].uInBX);
if (TrapFrame.Ctx.rcx.RT_CONCAT(u,ARCH_BITS) != s_aTests[i].uOutAX)
Bs3TestFailedF("Expected xAX = %#RX" RT_XSTR(ARCH_BITS) " got %#RX" RT_XSTR(ARCH_BITS),
s_aTests[i].uOutAX, TrapFrame.Ctx.rcx.RT_CONCAT(u,ARCH_BITS));
if ( (TrapFrame.Ctx.rflags.u16 & (IMUL_CHECK_EFLAGS | IMUL_CHECK_EFLAGS_ZERO))
!= (s_aTests[i].fFlags & IMUL_CHECK_EFLAGS) )
Bs3TestFailedF("Expected EFLAGS = %#06RX16, got %#06RX16", s_aTests[i].fFlags & IMUL_CHECK_EFLAGS,
TrapFrame.Ctx.rflags.u16 & (IMUL_CHECK_EFLAGS | IMUL_CHECK_EFLAGS_ZERO));
}
}
}
}
return 0;
}
#else /* LINUX_VERSION_CODE < KERNEL_VERSION(4, 20, 0) */
static int vboxNetAdpEthGetSettings(struct net_device *dev, struct ethtool_cmd *cmd);
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4, 20, 0) */
/*********************************************************************************************************************************
* Global Variables *
*********************************************************************************************************************************/
module_init(VBoxNetAdpLinuxInit);
module_exit(VBoxNetAdpLinuxUnload);
MODULE_AUTHOR(VBOX_VENDOR);
MODULE_DESCRIPTION(VBOX_PRODUCT " Network Adapter Driver");
MODULE_LICENSE("GPL");
#ifdef MODULE_VERSION
MODULE_VERSION(VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV) " (" RT_XSTR(INTNETTRUNKIFPORT_VERSION) ")");
#endif
/**
* The (common) global data.
*/
static struct file_operations gFileOpsVBoxNetAdp =
{
owner: THIS_MODULE,
open: VBoxNetAdpLinuxOpen,
release: VBoxNetAdpLinuxClose,
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
ioctl: VBoxNetAdpLinuxIOCtl,
#else /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36) */
unlocked_ioctl: VBoxNetAdpLinuxIOCtlUnlocked,
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36) */
/**
* 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;
}
}
RTDECL(int) SUPR0Printf(const char *pszFormat, ...)
{
va_list va;
char szMsg[512];
va_start(va, pszFormat);
RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, va);
va_end(va);
szMsg[sizeof(szMsg) - 1] = '\0';
printk("%s", szMsg);
return 0;
}
module_init(VBoxDrvLinuxInit);
module_exit(VBoxDrvLinuxUnload);
MODULE_AUTHOR(VBOX_VENDOR);
MODULE_DESCRIPTION(VBOX_PRODUCT " Support Driver");
MODULE_LICENSE("GPL");
#ifdef MODULE_VERSION
MODULE_VERSION(VBOX_VERSION_STRING " (" RT_XSTR(SUPDRV_IOC_VERSION) ")");
#endif
module_param(force_async_tsc, int, 0444);
MODULE_PARM_DESC(force_async_tsc, "force the asynchronous TSC mode");
