--- /dev/null
+/*********************************************************
+ * Copyright (C) 2011 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation version 2 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ *********************************************************/
+
+/* Must come before any kernel header file */
+#include "driver-config.h"
+
+#define EXPORT_SYMTAB
+
+#include <asm/io.h>
+
+#include <linux/file.h>
+#include <linux/fs.h>
+#if defined(__x86_64__) && LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12)
+# include <linux/ioctl32.h>
+/* Use weak: not all kernels export sys_ioctl for use by modules */
+asmlinkage __attribute__((weak)) long
+sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
+#endif
+#include <linux/miscdevice.h>
+#include <linux/moduleparam.h>
+#include <linux/poll.h>
+#include <linux/smp.h>
+#include <linux/smp_lock.h>
+
+#include "compat_highmem.h"
+#include "compat_init.h"
+#include "compat_interrupt.h"
+#include "compat_ioport.h"
+#include "compat_kernel.h"
+#include "compat_mm.h"
+#include "compat_module.h"
+#include "compat_mutex.h"
+#include "compat_page.h"
+#include "compat_pci.h"
+#include "compat_sched.h"
+#include "compat_slab.h"
+#include "compat_uaccess.h"
+#include "compat_version.h"
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 9)
+# error "Linux kernels before 2.6.9 are not supported."
+#endif
+
+#include "vm_basic_types.h"
+#include "vm_device_version.h"
+
+#include "vmware.h"
+#include "driverLog.h"
+#include "pgtbl.h"
+#include "vmci_defs.h"
+#include "vmci_handle_array.h"
+#include "vmci_infrastructure.h"
+#include "vmci_iocontrols.h"
+#include "vmci_version.h"
+#include "vmci_kernel_if.h"
+#include "vmciCommonInt.h"
+#include "vmciContext.h"
+#include "vmciDatagram.h"
+#include "vmciDoorbell.h"
+#include "vmciDriver.h"
+#include "vmciEvent.h"
+#include "vmciKernelAPI.h"
+#include "vmciQueuePair.h"
+#include "vmciResource.h"
+
+#define LGPFX "VMCI: "
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * PCI Device interface --
+ *
+ * Declarations of types and functions related to the VMCI PCI
+ * device personality.
+ *
+ *
+ *----------------------------------------------------------------------
+ */
+
+/*
+ * VMCI PCI driver state
+ */
+
+typedef struct vmci_device {
+ compat_mutex_t lock;
+
+ unsigned int ioaddr;
+ unsigned int ioaddr_size;
+ unsigned int irq;
+ unsigned int intr_type;
+ Bool exclusive_vectors;
+ struct msix_entry msix_entries[VMCI_MAX_INTRS];
+
+ Bool enabled;
+ spinlock_t dev_spinlock;
+} vmci_device;
+
+static const struct pci_device_id vmci_ids[] = {
+ { PCI_DEVICE(PCI_VENDOR_ID_VMWARE, PCI_DEVICE_ID_VMWARE_VMCI), },
+ { 0 },
+};
+
+static int vmci_probe_device(struct pci_dev *pdev,
+ const struct pci_device_id *id);
+static void vmci_remove_device(struct pci_dev* pdev);
+
+static struct pci_driver vmci_driver = {
+ .name = "vmci",
+ .id_table = vmci_ids,
+ .probe = vmci_probe_device,
+ .remove = __devexit_p(vmci_remove_device),
+};
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+static compat_irqreturn_t vmci_interrupt(int irq, void *dev_id,
+ struct pt_regs * regs);
+static compat_irqreturn_t vmci_interrupt_bm(int irq, void *dev_id,
+ struct pt_regs * regs);
+#else
+static compat_irqreturn_t vmci_interrupt(int irq, void *dev_id);
+static compat_irqreturn_t vmci_interrupt_bm(int irq, void *dev_id);
+#endif
+static void dispatch_datagrams(unsigned long data);
+static void process_bitmap(unsigned long data);
+
+/* MSI-X has performance problems in < 2.6.19 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
+# define VMCI_DISABLE_MSIX 0
+#else
+# define VMCI_DISABLE_MSIX 1
+#endif
+
+static vmci_device vmci_dev;
+static int vmci_disable_msi;
+static int vmci_disable_msix = VMCI_DISABLE_MSIX;
+
+DECLARE_TASKLET(vmci_dg_tasklet, dispatch_datagrams,
+ (unsigned long)&vmci_dev);
+
+DECLARE_TASKLET(vmci_bm_tasklet, process_bitmap,
+ (unsigned long)&vmci_dev);
+
+/*
+ * Allocate a buffer for incoming datagrams globally to avoid repeated
+ * allocation in the interrupt handler's atomic context.
+ */
+
+static uint8 *data_buffer = NULL;
+static uint32 data_buffer_size = VMCI_MAX_DG_SIZE;
+
+/*
+ * If the VMCI hardware supports the notification bitmap, we allocate
+ * and register a page with the device.
+ */
+
+static uint8 *notification_bitmap = NULL;
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Host device node interface --
+ *
+ * Implements VMCI by implementing open/close/ioctl functions
+ *
+ *
+ *----------------------------------------------------------------------
+ */
+
+/*
+ * Per-instance host state
+ */
+
+typedef struct VMCILinux {
+ VMCIContext *context;
+ int userVersion;
+ VMCIObjType ctType;
+#if defined(HAVE_COMPAT_IOCTL) || defined(HAVE_UNLOCKED_IOCTL)
+ compat_mutex_t lock;
+#endif
+} VMCILinux;
+
+/*
+ * Static driver state.
+ */
+
+#define VM_DEVICE_NAME_SIZE 32
+#define LINUXLOG_BUFFER_SIZE 1024
+
+typedef struct VMCILinuxState {
+ int major;
+ int minor;
+ struct miscdevice misc;
+ char deviceName[VM_DEVICE_NAME_SIZE];
+ char buf[LINUXLOG_BUFFER_SIZE];
+} VMCILinuxState;
+
+static struct VMCILinuxState linuxState;
+
+static int VMCISetupNotify(VMCIContext *context, VA notifyUVA);
+static void VMCIUnsetNotifyInt(VMCIContext *context, Bool useLock);
+
+static int LinuxDriver_Open(struct inode *inode, struct file *filp);
+
+static int LinuxDriver_Ioctl(struct inode *inode, struct file *filp,
+ u_int iocmd, unsigned long ioarg);
+
+#if defined(HAVE_COMPAT_IOCTL) || defined(HAVE_UNLOCKED_IOCTL)
+static long LinuxDriver_UnlockedIoctl(struct file *filp,
+ u_int iocmd, unsigned long ioarg);
+#endif
+
+static int LinuxDriver_Close(struct inode *inode, struct file *filp);
+static unsigned int LinuxDriverPoll(struct file *file, poll_table *wait);
+
+
+#if defined(HAVE_COMPAT_IOCTL) || defined(HAVE_UNLOCKED_IOCTL)
+#define LinuxDriverLockIoctlPerFD(mutex) compat_mutex_lock(mutex)
+#define LinuxDriverUnlockIoctlPerFD(mutex) compat_mutex_unlock(mutex)
+#else
+#define LinuxDriverLockIoctlPerFD(mutex) do {} while (0)
+#define LinuxDriverUnlockIoctlPerFD(mutex) do {} while (0)
+#endif
+
+static struct file_operations vmuser_fops;
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Shared VMCI device definitions --
+ *
+ * Types and variables shared by both host and guest personality
+ *
+ *
+ *----------------------------------------------------------------------
+ */
+
+static Bool guestDeviceInit;
+static Bool hostDeviceInit;
+
+/*
+ * Until we have a single driver, that uses load or runtime
+ * configuration to enable guest and host personalities directly, we
+ * let the tools flag decide.
+ */
+
+#ifdef VMX86_TOOLS
+static Bool isGuestDriver = TRUE;
+#else
+static Bool isGuestDriver = FALSE;
+#endif
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * Host device support --
+ *
+ * The following functions implement the support for the VMCI
+ * host driver.
+ *
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+
+#ifdef VM_X86_64
+#ifndef HAVE_COMPAT_IOCTL
+static int
+LinuxDriver_Ioctl32_Handler(unsigned int fd, unsigned int iocmd,
+ unsigned long ioarg, struct file * filp)
+{
+ int ret;
+ ret = -ENOTTY;
+ if (filp && filp->f_op && filp->f_op->ioctl == LinuxDriver_Ioctl) {
+ ret = LinuxDriver_Ioctl(filp->f_dentry->d_inode, filp, iocmd, ioarg);
+ }
+ return ret;
+}
+#endif /* !HAVE_COMPAT_IOCTL */
+
+static int
+register_ioctl32_handlers(void)
+{
+#ifndef HAVE_COMPAT_IOCTL
+ {
+ int i;
+
+ for (i = IOCTL_VMCI_FIRST; i < IOCTL_VMCI_LAST; i++) {
+ int retval = register_ioctl32_conversion(i,
+ LinuxDriver_Ioctl32_Handler);
+
+ if (retval) {
+ Warning("Fail to register ioctl32 conversion for cmd %d\n", i);
+ return retval;
+ }
+ }
+
+ for (i = IOCTL_VMCI_FIRST2; i < IOCTL_VMCI_LAST2; i++) {
+ int retval = register_ioctl32_conversion(i,
+ LinuxDriver_Ioctl32_Handler);
+
+ if (retval) {
+ Warning("Fail to register ioctl32 conversion for cmd %d\n", i);
+ return retval;
+ }
+ }
+ }
+#endif /* !HAVE_COMPAT_IOCTL */
+ return 0;
+}
+
+static void
+unregister_ioctl32_handlers(void)
+{
+#ifndef HAVE_COMPAT_IOCTL
+ {
+ int i;
+
+ for (i = IOCTL_VMCI_FIRST; i < IOCTL_VMCI_LAST; i++) {
+ int retval = unregister_ioctl32_conversion(i);
+
+ if (retval) {
+ Warning("Fail to unregister ioctl32 conversion for cmd %d\n", i);
+ }
+ }
+
+ for (i = IOCTL_VMCI_FIRST2; i < IOCTL_VMCI_LAST2; i++) {
+ int retval = unregister_ioctl32_conversion(i);
+
+ if (retval) {
+ Warning("Fail to unregister ioctl32 conversion for cmd %d\n", i);
+ }
+ }
+ }
+#endif /* !HAVE_COMPAT_IOCTL */
+}
+#else /* VM_X86_64 */
+#define register_ioctl32_handlers() (0)
+#define unregister_ioctl32_handlers() do { } while (0)
+#endif /* VM_X86_64 */
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * vmci_host_init --
+ *
+ * Initializes the VMCI host device driver.
+ *
+ * Results:
+ * 0 on success, other error codes on failure.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+int
+vmci_host_init(void)
+{
+ int retval;
+
+ if (VMCI_HostInit() < VMCI_SUCCESS) {
+ return -ENOMEM;
+ }
+
+ /*
+ * Initialize the file_operations structure. Because this code is always
+ * compiled as a module, this is fine to do it here and not in a static
+ * initializer.
+ */
+
+ memset(&vmuser_fops, 0, sizeof vmuser_fops);
+ vmuser_fops.owner = THIS_MODULE;
+ vmuser_fops.poll = LinuxDriverPoll;
+#ifdef HAVE_UNLOCKED_IOCTL
+ vmuser_fops.unlocked_ioctl = LinuxDriver_UnlockedIoctl;
+#else
+ vmuser_fops.ioctl = LinuxDriver_Ioctl;
+#endif
+#ifdef HAVE_COMPAT_IOCTL
+ vmuser_fops.compat_ioctl = LinuxDriver_UnlockedIoctl;
+#endif
+ vmuser_fops.open = LinuxDriver_Open;
+ vmuser_fops.release = LinuxDriver_Close;
+
+ sprintf(linuxState.deviceName, "vmci");
+ linuxState.major = 10;
+ linuxState.misc.minor = MISC_DYNAMIC_MINOR;
+ linuxState.misc.name = linuxState.deviceName;
+ linuxState.misc.fops = &vmuser_fops;
+
+ retval = misc_register(&linuxState.misc);
+
+ if (retval) {
+ Warning("Module %s: error %u registering with major=%d minor=%d\n",
+ linuxState.deviceName, -retval, linuxState.major, linuxState.minor);
+ goto exit;
+ }
+ linuxState.minor = linuxState.misc.minor;
+ Log("Module %s: registered with major=%d minor=%d\n",
+ linuxState.deviceName, linuxState.major, linuxState.minor);
+
+ retval = register_ioctl32_handlers();
+ if (retval) {
+ misc_deregister(&linuxState.misc);
+ }
+
+exit:
+ if (retval) {
+ VMCI_HostCleanup();
+ }
+ return retval;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * LinuxDriver_Open --
+ *
+ * called on open of /dev/vmci. Use count used
+ * to determine eventual deallocation of the module
+ *
+ * Side effects:
+ * Increment use count used to determine eventual deallocation of
+ * the module
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+LinuxDriver_Open(struct inode *inode, // IN
+ struct file *filp) // IN
+{
+ VMCILinux *vmciLinux;
+
+ vmciLinux = kmalloc(sizeof *vmciLinux, GFP_KERNEL);
+ if (vmciLinux == NULL) {
+ return -ENOMEM;
+ }
+ memset(vmciLinux, 0, sizeof *vmciLinux);
+ vmciLinux->ctType = VMCIOBJ_NOT_SET;
+ vmciLinux->userVersion = 0;
+#if defined(HAVE_COMPAT_IOCTL) || defined(HAVE_UNLOCKED_IOCTL)
+ compat_mutex_init(&vmciLinux->lock);
+#endif
+
+ filp->private_data = vmciLinux;
+
+ return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * LinuxDriver_Close --
+ *
+ * called on close of /dev/vmci, most often when the
+ * process exits. Decrement use count, allowing for possible uninstalling
+ * of the module.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+LinuxDriver_Close(struct inode *inode, // IN
+ struct file *filp) // IN
+{
+ VMCILinux *vmciLinux;
+
+ vmciLinux = (VMCILinux *)filp->private_data;
+ ASSERT(vmciLinux);
+
+ if (vmciLinux->ctType == VMCIOBJ_CONTEXT) {
+ VMCIId cid;
+
+ ASSERT(vmciLinux->context);
+ cid = VMCIContext_GetId(vmciLinux->context);
+
+ VMCIContext_ReleaseContext(vmciLinux->context);
+ vmciLinux->context = NULL;
+ }
+ vmciLinux->ctType = VMCIOBJ_NOT_SET;
+
+ kfree(vmciLinux);
+ filp->private_data = NULL;
+ return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * LinuxDriverPoll --
+ *
+ * This is used to wake up the VMX when a VMCI call arrives, or
+ * to wake up select() or poll() at the next clock tick.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static unsigned int
+LinuxDriverPoll(struct file *filp,
+ poll_table *wait)
+{
+ VMCILockFlags flags;
+ VMCILinux *vmciLinux = (VMCILinux *) filp->private_data;
+ unsigned int mask = 0;
+
+ if (vmciLinux->ctType == VMCIOBJ_CONTEXT) {
+ ASSERT(vmciLinux->context != NULL);
+ /*
+ * Check for VMCI calls to this VM context.
+ */
+
+ if (wait != NULL) {
+ poll_wait(filp, &vmciLinux->context->hostContext.waitQueue, wait);
+ }
+
+ VMCI_GrabLock(&vmciLinux->context->lock, &flags);
+ if (vmciLinux->context->pendingDatagrams > 0 ||
+ VMCIHandleArray_GetSize(vmciLinux->context->pendingDoorbellArray) > 0) {
+ mask = POLLIN;
+ }
+ VMCI_ReleaseLock(&vmciLinux->context->lock, flags);
+ }
+ return mask;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * VMCICopyHandleArrayToUser --
+ *
+ * Copies the handles of a handle array into a user buffer, and
+ * returns the new length in userBufferSize. If the copy to the
+ * user buffer fails, the functions still returns VMCI_SUCCESS,
+ * but retval != 0.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+VMCICopyHandleArrayToUser(void *userBufUVA, // IN
+ uint64 *userBufSize, // IN/OUT
+ VMCIHandleArray *handleArray, // IN
+ int *retval) // IN
+{
+ uint32 arraySize;
+ VMCIHandle *handles;
+
+ if (handleArray) {
+ arraySize = VMCIHandleArray_GetSize(handleArray);
+ } else {
+ arraySize = 0;
+ }
+
+ if (arraySize * sizeof *handles > *userBufSize) {
+ return VMCI_ERROR_MORE_DATA;
+ }
+
+ *userBufSize = arraySize * sizeof *handles;
+ if (*userBufSize) {
+ *retval = copy_to_user(userBufUVA,
+ VMCIHandleArray_GetHandles(handleArray),
+ *userBufSize);
+ }
+
+ return VMCI_SUCCESS;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * LinuxDriver_Ioctl --
+ *
+ * Main path for UserRPC
+ *
+ * Results:
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+LinuxDriver_Ioctl(struct inode *inode,
+ struct file *filp,
+ u_int iocmd,
+ unsigned long ioarg)
+{
+ VMCILinux *vmciLinux = (VMCILinux *) filp->private_data;
+ int retval = 0;
+
+ switch (iocmd) {
+ case IOCTL_VMCI_VERSION2: {
+ int verFromUser;
+
+ if (copy_from_user(&verFromUser, (void *)ioarg, sizeof verFromUser)) {
+ retval = -EFAULT;
+ break;
+ }
+
+ vmciLinux->userVersion = verFromUser;
+ }
+ /* Fall through. */
+ case IOCTL_VMCI_VERSION:
+ /*
+ * The basic logic here is:
+ *
+ * If the user sends in a version of 0 tell it our version.
+ * If the user didn't send in a version, tell it our version.
+ * If the user sent in an old version, tell it -its- version.
+ * If the user sent in an newer version, tell it our version.
+ *
+ * The rationale behind telling the caller its version is that
+ * Workstation 6.5 required that VMX and VMCI kernel module were
+ * version sync'd. All new VMX users will be programmed to
+ * handle the VMCI kernel module version.
+ */
+
+ if (vmciLinux->userVersion > 0 &&
+ vmciLinux->userVersion < VMCI_VERSION_HOSTQP) {
+ retval = vmciLinux->userVersion;
+ } else {
+ retval = VMCI_VERSION;
+ }
+ break;
+
+ case IOCTL_VMCI_INIT_CONTEXT: {
+ VMCIInitBlock initBlock;
+ VMCIHostUser user;
+
+ retval = copy_from_user(&initBlock, (void *)ioarg, sizeof initBlock);
+ if (retval != 0) {
+ Log("VMCI: Error reading init block.\n");
+ retval = -EFAULT;
+ break;
+ }
+
+ LinuxDriverLockIoctlPerFD(&vmciLinux->lock);
+ if (vmciLinux->ctType != VMCIOBJ_NOT_SET) {
+ Log("VMCI: Received VMCI init on initialized handle\n");
+ retval = -EINVAL;
+ goto init_release;
+ }
+
+ if (initBlock.flags & ~VMCI_PRIVILEGE_FLAG_RESTRICTED) {
+ Log("VMCI: Unsupported VMCI restriction flag.\n");
+ retval = -EINVAL;
+ goto init_release;
+ }
+
+ user = current_uid();
+ retval = VMCIContext_InitContext(initBlock.cid, initBlock.flags,
+ 0 /* Unused */, vmciLinux->userVersion,
+ &user, &vmciLinux->context);
+ if (retval < VMCI_SUCCESS) {
+ Log("VMCI: Error initializing context.\n");
+ retval = retval == VMCI_ERROR_DUPLICATE_ENTRY ? -EEXIST : -EINVAL;
+ goto init_release;
+ }
+
+ /*
+ * Copy cid to userlevel, we do this to allow the VMX to enforce its
+ * policy on cid generation.
+ */
+ initBlock.cid = VMCIContext_GetId(vmciLinux->context);
+ retval = copy_to_user((void *)ioarg, &initBlock, sizeof initBlock);
+ if (retval != 0) {
+ VMCIContext_ReleaseContext(vmciLinux->context);
+ vmciLinux->context = NULL;
+ Log("VMCI: Error writing init block.\n");
+ retval = -EFAULT;
+ goto init_release;
+ }
+ ASSERT(initBlock.cid != VMCI_INVALID_ID);
+
+ vmciLinux->ctType = VMCIOBJ_CONTEXT;
+
+ init_release:
+ LinuxDriverUnlockIoctlPerFD(&vmciLinux->lock);
+ break;
+ }
+
+ case IOCTL_VMCI_DATAGRAM_SEND: {
+ VMCIDatagramSendRecvInfo sendInfo;
+ VMCIDatagram *dg = NULL;
+ VMCIId cid;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Warning("VMCI: Ioctl %d only valid for context handle.\n", iocmd);
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&sendInfo, (void *) ioarg, sizeof sendInfo);
+ if (retval) {
+ Warning("VMCI: copy_from_user failed.\n");
+ retval = -EFAULT;
+ break;
+ }
+
+ if (sendInfo.len > VMCI_MAX_DG_SIZE) {
+ Warning("VMCI: datagram size too big.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ if (sendInfo.len < sizeof *dg) {
+ Warning("VMCI: datagram size too small.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ dg = VMCI_AllocKernelMem(sendInfo.len, VMCI_MEMORY_NORMAL);
+ if (dg == NULL) {
+ Log("VMCI: Cannot allocate memory to dispatch datagram.\n");
+ retval = -ENOMEM;
+ break;
+ }
+
+ retval = copy_from_user(dg, (char *)(VA)sendInfo.addr, sendInfo.len);
+ if (retval != 0) {
+ Log("VMCI: Error getting datagram: %d\n", retval);
+ VMCI_FreeKernelMem(dg, sendInfo.len);
+ retval = -EFAULT;
+ break;
+ }
+
+ VMCI_DEBUG_LOG(10, ("VMCI: Datagram dst handle 0x%"FMT64"x, "
+ "src handle 0x%"FMT64"x, payload size %"FMT64"u.\n",
+ VMCI_HANDLE_TO_UINT64(dg->dst),
+ VMCI_HANDLE_TO_UINT64(dg->src), dg->payloadSize));
+
+ /* Get source context id. */
+ ASSERT(vmciLinux->context);
+ cid = VMCIContext_GetId(vmciLinux->context);
+ ASSERT(cid != VMCI_INVALID_ID);
+ sendInfo.result = VMCIDatagram_Dispatch(cid, dg, TRUE);
+ VMCI_FreeKernelMem(dg, sendInfo.len);
+ retval = copy_to_user((void *)ioarg, &sendInfo, sizeof sendInfo);
+ break;
+ }
+
+ case IOCTL_VMCI_DATAGRAM_RECEIVE: {
+ VMCIDatagramSendRecvInfo recvInfo;
+ VMCIDatagram *dg = NULL;
+ size_t size;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Warning("VMCI: Ioctl %d only valid for context handle.\n", iocmd);
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&recvInfo, (void *) ioarg, sizeof recvInfo);
+ if (retval) {
+ Warning("VMCI: copy_from_user failed.\n");
+ retval = -EFAULT;
+ break;
+ }
+
+ ASSERT(vmciLinux->ctType == VMCIOBJ_CONTEXT);
+
+ size = recvInfo.len;
+ ASSERT(vmciLinux->context);
+ recvInfo.result = VMCIContext_DequeueDatagram(vmciLinux->context,
+ &size, &dg);
+
+ if (recvInfo.result >= VMCI_SUCCESS) {
+ ASSERT(dg);
+ retval = copy_to_user((void *) ((uintptr_t) recvInfo.addr), dg,
+ VMCI_DG_SIZE(dg));
+ VMCI_FreeKernelMem(dg, VMCI_DG_SIZE(dg));
+ if (retval != 0) {
+ break;
+ }
+ }
+ retval = copy_to_user((void *)ioarg, &recvInfo, sizeof recvInfo);
+ break;
+ }
+
+ case IOCTL_VMCI_QUEUEPAIR_ALLOC: {
+ VMCIQueuePairAllocInfo queuePairAllocInfo;
+ VMCIQueuePairAllocInfo *info = (VMCIQueuePairAllocInfo *)ioarg;
+ int32 result;
+ VMCIId cid;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_QUEUEPAIR_ALLOC only valid for contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&queuePairAllocInfo, (void *)ioarg,
+ sizeof queuePairAllocInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ VMCIQPBroker_Lock();
+
+ {
+ QueuePairPageStore pageStore = { TRUE,
+ queuePairAllocInfo.producePageFile,
+ queuePairAllocInfo.consumePageFile,
+ queuePairAllocInfo.producePageFileSize,
+ queuePairAllocInfo.consumePageFileSize,
+ 0,
+ 0 };
+
+ result = VMCIQPBroker_Alloc(queuePairAllocInfo.handle,
+ queuePairAllocInfo.peer,
+ queuePairAllocInfo.flags,
+ VMCI_NO_PRIVILEGE_FLAGS,
+ queuePairAllocInfo.produceSize,
+ queuePairAllocInfo.consumeSize,
+ &pageStore,
+ vmciLinux->context);
+ }
+ Log("VMCI: IOCTL_VMCI_QUEUEPAIR_ALLOC cid = %u result = %d.\n", cid,
+ result);
+ retval = copy_to_user(&info->result, &result, sizeof result);
+ if (retval) {
+ retval = -EFAULT;
+ if (result >= VMCI_SUCCESS) {
+ result = VMCIQPBroker_Detach(queuePairAllocInfo.handle,
+ vmciLinux->context, TRUE);
+ ASSERT(result >= VMCI_SUCCESS);
+ }
+ }
+
+ VMCIQPBroker_Unlock();
+ break;
+ }
+
+ case IOCTL_VMCI_QUEUEPAIR_SETPAGEFILE: {
+ VMCIQueuePairPageFileInfo pageFileInfo;
+ VMCIQueuePairPageFileInfo *info = (VMCIQueuePairPageFileInfo *)ioarg;
+ int32 result;
+ VMCIId cid;
+ Bool useUVA;
+ int size;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_QUEUEPAIR_SETPAGEFILE only valid for "
+ "contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ if (VMCIContext_SupportsHostQP(vmciLinux->context)) {
+ useUVA = TRUE;
+ size = sizeof *info;
+ } else {
+ /*
+ * An older VMX version won't supply the UVA of the page
+ * files backing the queue pair contents (and headers)
+ */
+
+ useUVA = FALSE;
+ size = sizeof(VMCIQueuePairPageFileInfo_NoHostQP);
+ }
+
+ retval = copy_from_user(&pageFileInfo, (void *)ioarg, size);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ /*
+ * Communicate success pre-emptively to the caller. Note that
+ * the basic premise is that it is incumbent upon the caller not
+ * to look at the info.result field until after the ioctl()
+ * returns. And then, only if the ioctl() result indicates no
+ * error. We send up the SUCCESS status before calling
+ * SetPageStore() store because failing to copy up the result
+ * code means unwinding the SetPageStore().
+ *
+ * It turns out the logic to unwind a SetPageStore() opens a can
+ * of worms. For example, if a host had created the QueuePair
+ * and a guest attaches and SetPageStore() is successful but
+ * writing success fails, then ... the host has to be stopped
+ * from writing (anymore) data into the QueuePair. That means
+ * an additional test in the VMCI_Enqueue() code path. Ugh.
+ */
+
+ result = VMCI_SUCCESS;
+ retval = copy_to_user(&info->result, &result, sizeof result);
+ if (retval == 0) {
+ cid = VMCIContext_GetId(vmciLinux->context);
+ VMCIQPBroker_Lock();
+
+ {
+ QueuePairPageStore pageStore = { TRUE,
+ pageFileInfo.producePageFile,
+ pageFileInfo.consumePageFile,
+ pageFileInfo.producePageFileSize,
+ pageFileInfo.consumePageFileSize,
+ useUVA ? pageFileInfo.produceVA : 0,
+ useUVA ? pageFileInfo.consumeVA : 0 };
+
+ result = VMCIQPBroker_SetPageStore(pageFileInfo.handle,
+ &pageStore,
+ vmciLinux->context);
+ }
+ VMCIQPBroker_Unlock();
+
+ if (result < VMCI_SUCCESS) {
+ Log("VMCI: IOCTL_VMCI_QUEUEPAIR_SETPAGEFILE cid = %u result = %d.\n",
+ cid, result);
+
+ retval = copy_to_user(&info->result, &result, sizeof result);
+ if (retval != 0) {
+ /*
+ * Note that in this case the SetPageStore() call
+ * failed but we were unable to communicate that to the
+ * caller (because the copy_to_user() call failed).
+ * So, if we simply return an error (in this case
+ * -EFAULT) then the caller will know that the
+ * SetPageStore failed even though we couldn't put the
+ * result code in the result field and indicate exactly
+ * why it failed.
+ *
+ * That says nothing about the issue where we were once
+ * able to write to the caller's info memory and now
+ * can't. Something more serious is probably going on
+ * than the fact that SetPageStore() didn't work.
+ */
+ retval = -EFAULT;
+ }
+ }
+
+ } else {
+ /*
+ * In this case, we can't write a result field of the
+ * caller's info block. So, we don't even try to
+ * SetPageStore().
+ */
+ retval = -EFAULT;
+ }
+
+ break;
+ }
+
+ case IOCTL_VMCI_QUEUEPAIR_DETACH: {
+ VMCIQueuePairDetachInfo detachInfo;
+ VMCIQueuePairDetachInfo *info = (VMCIQueuePairDetachInfo *)ioarg;
+ int32 result;
+ VMCIId cid;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_QUEUEPAIR_DETACH only valid for contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&detachInfo, (void *)ioarg, sizeof detachInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ VMCIQPBroker_Lock();
+ result = VMCIQPBroker_Detach(detachInfo.handle, vmciLinux->context,
+ FALSE); /* Probe detach operation. */
+ Log("VMCI: IOCTL_VMCI_QUEUEPAIR_DETACH cid = %u result = %d.\n",
+ cid, result);
+
+ retval = copy_to_user(&info->result, &result, sizeof result);
+ if (retval) {
+ /* Could not copy to userland, don't perform the actual detach. */
+ retval = -EFAULT;
+ } else {
+ if (result >= VMCI_SUCCESS) {
+ /* Now perform the actual detach. */
+ int32 result2 = VMCIQPBroker_Detach(detachInfo.handle,
+ vmciLinux->context, TRUE);
+ if (UNLIKELY(result != result2)) {
+ /*
+ * This should never happen. But it's better to log a warning
+ * than to crash the host.
+ */
+ Warning("VMCIQPBroker_Detach returned different results: "
+ "previous = %d, current = %d.\n", result, result2);
+ }
+ }
+ }
+
+ VMCIQPBroker_Unlock();
+ break;
+ }
+
+ case IOCTL_VMCI_DATAGRAM_REQUEST_MAP: {
+ VMCIDatagramMapInfo mapInfo;
+ VMCIDatagramMapInfo *info = (VMCIDatagramMapInfo *)ioarg;
+ int32 result;
+ VMCIId cid;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_REQUEST_MAP only valid for contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&mapInfo, (void *)ioarg, sizeof mapInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ result = VMCIDatagramRequestWellKnownMap(mapInfo.wellKnownID, cid,
+ VMCIContext_GetPrivFlags(cid));
+ retval = copy_to_user(&info->result, &result, sizeof result);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+ break;
+ }
+
+ case IOCTL_VMCI_DATAGRAM_REMOVE_MAP: {
+ VMCIDatagramMapInfo mapInfo;
+ VMCIDatagramMapInfo *info = (VMCIDatagramMapInfo *)ioarg;
+ int32 result;
+ VMCIId cid;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_REMOVE_MAP only valid for contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&mapInfo, (void *)ioarg, sizeof mapInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ result = VMCIDatagramRemoveWellKnownMap(mapInfo.wellKnownID, cid);
+ retval = copy_to_user(&info->result, &result, sizeof result);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+ break;
+ }
+
+ case IOCTL_VMCI_CTX_ADD_NOTIFICATION: {
+ VMCINotifyAddRemoveInfo arInfo;
+ VMCINotifyAddRemoveInfo *info = (VMCINotifyAddRemoveInfo *)ioarg;
+ int32 result;
+ VMCIId cid;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_CTX_ADD_NOTIFICATION only valid for contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&arInfo, (void *)ioarg, sizeof arInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ result = VMCIContext_AddNotification(cid, arInfo.remoteCID);
+ retval = copy_to_user(&info->result, &result, sizeof result);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+ break;
+ }
+
+ case IOCTL_VMCI_CTX_REMOVE_NOTIFICATION: {
+ VMCINotifyAddRemoveInfo arInfo;
+ VMCINotifyAddRemoveInfo *info = (VMCINotifyAddRemoveInfo *)ioarg;
+ int32 result;
+ VMCIId cid;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_CTX_REMOVE_NOTIFICATION only valid for "
+ "contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&arInfo, (void *)ioarg, sizeof arInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ result = VMCIContext_RemoveNotification(cid, arInfo.remoteCID);
+ retval = copy_to_user(&info->result, &result, sizeof result);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+ break;
+ }
+
+ case IOCTL_VMCI_CTX_GET_CPT_STATE: {
+ VMCICptBufInfo getInfo;
+ VMCIId cid;
+ char *cptBuf;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_CTX_GET_CPT_STATE only valid for "
+ "contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&getInfo, (void *)ioarg, sizeof getInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ getInfo.result = VMCIContext_GetCheckpointState(cid, getInfo.cptType,
+ &getInfo.bufSize,
+ &cptBuf);
+ if (getInfo.result == VMCI_SUCCESS && getInfo.bufSize) {
+ retval = copy_to_user((void *)(VA)getInfo.cptBuf, cptBuf,
+ getInfo.bufSize);
+ VMCI_FreeKernelMem(cptBuf, getInfo.bufSize);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+ }
+ retval = copy_to_user((void *)ioarg, &getInfo, sizeof getInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+ break;
+ }
+
+ case IOCTL_VMCI_CTX_SET_CPT_STATE: {
+ VMCICptBufInfo setInfo;
+ VMCIId cid;
+ char *cptBuf;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_CTX_SET_CPT_STATE only valid for "
+ "contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&setInfo, (void *)ioarg, sizeof setInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cptBuf = VMCI_AllocKernelMem(setInfo.bufSize, VMCI_MEMORY_NORMAL);
+ if (cptBuf == NULL) {
+ Log("VMCI: Cannot allocate memory to set cpt state of type %d.\n",
+ setInfo.cptType);
+ retval = -ENOMEM;
+ break;
+ }
+ retval = copy_from_user(cptBuf, (void *)(VA)setInfo.cptBuf,
+ setInfo.bufSize);
+ if (retval) {
+ VMCI_FreeKernelMem(cptBuf, setInfo.bufSize);
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ setInfo.result = VMCIContext_SetCheckpointState(cid, setInfo.cptType,
+ setInfo.bufSize, cptBuf);
+ VMCI_FreeKernelMem(cptBuf, setInfo.bufSize);
+ retval = copy_to_user((void *)ioarg, &setInfo, sizeof setInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+ break;
+ }
+
+ case IOCTL_VMCI_GET_CONTEXT_ID: {
+ VMCIId cid = VMCI_HOST_CONTEXT_ID;
+
+ retval = copy_to_user((void *)ioarg, &cid, sizeof cid);
+ break;
+ }
+
+ case IOCTL_VMCI_SET_NOTIFY: {
+ VMCISetNotifyInfo notifyInfo;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_SET_NOTIFY only valid for contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(¬ifyInfo, (void *)ioarg, sizeof notifyInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ if ((VA)notifyInfo.notifyUVA != (VA)NULL) {
+ notifyInfo.result = VMCISetupNotify(vmciLinux->context,
+ (VA)notifyInfo.notifyUVA);
+ } else {
+ VMCIUnsetNotifyInt(vmciLinux->context, TRUE);
+ notifyInfo.result = VMCI_SUCCESS;
+ }
+
+ retval = copy_to_user((void *)ioarg, ¬ifyInfo, sizeof notifyInfo);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ break;
+ }
+
+ case IOCTL_VMCI_NOTIFY_RESOURCE: {
+ VMCINotifyResourceInfo info;
+ VMCIId cid;
+
+ if (vmciLinux->userVersion < VMCI_VERSION_NOTIFY) {
+ Log("VMCI: IOCTL_VMCI_NOTIFY_RESOURCE is invalid for current"
+ " VMX versions.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_NOTIFY_RESOURCE is only valid for contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&info, (void *)ioarg, sizeof info);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ switch (info.action) {
+ case VMCI_NOTIFY_RESOURCE_ACTION_NOTIFY:
+ if (info.resource == VMCI_NOTIFY_RESOURCE_DOOR_BELL) {
+ info.result = VMCIContext_NotifyDoorbell(cid, info.handle,
+ VMCI_NO_PRIVILEGE_FLAGS);
+ } else {
+ info.result = VMCI_ERROR_UNAVAILABLE;
+ }
+ break;
+ case VMCI_NOTIFY_RESOURCE_ACTION_CREATE:
+ info.result = VMCIContext_DoorbellCreate(cid, info.handle);
+ break;
+ case VMCI_NOTIFY_RESOURCE_ACTION_DESTROY:
+ info.result = VMCIContext_DoorbellDestroy(cid, info.handle);
+ break;
+ default:
+ Log("VMCI: IOCTL_VMCI_NOTIFY_RESOURCE got unknown action %d.\n",
+ info.action);
+ info.result = VMCI_ERROR_INVALID_ARGS;
+ }
+ retval = copy_to_user((void *)ioarg, &info,
+ sizeof info);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ break;
+ }
+
+ case IOCTL_VMCI_NOTIFICATIONS_RECEIVE: {
+ VMCINotificationReceiveInfo info;
+ VMCIHandleArray *dbHandleArray;
+ VMCIHandleArray *qpHandleArray;
+ VMCIId cid;
+
+ if (vmciLinux->ctType != VMCIOBJ_CONTEXT) {
+ Log("VMCI: IOCTL_VMCI_NOTIFICATIONS_RECEIVE is only valid for contexts.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ if (vmciLinux->userVersion < VMCI_VERSION_NOTIFY) {
+ Log("VMCI: IOCTL_VMCI_NOTIFICATIONS_RECEIVE is not supported for the"
+ " current vmx version.\n");
+ retval = -EINVAL;
+ break;
+ }
+
+ retval = copy_from_user(&info, (void *)ioarg, sizeof info);
+ if (retval) {
+ retval = -EFAULT;
+ break;
+ }
+
+ if ((info.dbHandleBufSize && !info.dbHandleBufUVA) ||
+ (info.qpHandleBufSize && !info.qpHandleBufUVA)) {
+ retval = -EINVAL;
+ break;
+ }
+
+ cid = VMCIContext_GetId(vmciLinux->context);
+ info.result = VMCIContext_ReceiveNotificationsGet(cid,
+ &dbHandleArray,
+ &qpHandleArray);
+ if (info.result == VMCI_SUCCESS) {
+ info.result =
+ VMCICopyHandleArrayToUser((void *)(VA)info.dbHandleBufUVA,
+ &info.dbHandleBufSize,
+ dbHandleArray,
+ &retval);
+ if (info.result == VMCI_SUCCESS && !retval) {
+ info.result =
+ VMCICopyHandleArrayToUser((void *)(VA)info.qpHandleBufUVA,
+ &info.qpHandleBufSize,
+ qpHandleArray,
+ &retval);
+ }
+ if (!retval) {
+ retval = copy_to_user((void *)ioarg, &info, sizeof info);
+ }
+ VMCIContext_ReceiveNotificationsRelease(cid, dbHandleArray, qpHandleArray,
+ info.result == VMCI_SUCCESS && !retval);
+ } else {
+ retval = copy_to_user((void *)ioarg, &info, sizeof info);
+ }
+ break;
+ }
+
+ default:
+ Warning("Unknown ioctl %d\n", iocmd);
+ retval = -EINVAL;
+ }
+
+ return retval;
+}
+
+
+#if defined(HAVE_COMPAT_IOCTL) || defined(HAVE_UNLOCKED_IOCTL)
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * LinuxDriver_UnlockedIoctl --
+ *
+ * Wrapper for LinuxDriver_Ioctl supporting the compat_ioctl and
+ * unlocked_ioctl methods that have signatures different from the
+ * old ioctl. Used as compat_ioctl method for 32bit apps running
+ * on 64bit kernel and for unlocked_ioctl on systems supporting
+ * those. LinuxDriver_Ioctl may safely be called without holding
+ * the BKL.
+ *
+ * Results:
+ * Same as LinuxDriver_Ioctl.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static long
+LinuxDriver_UnlockedIoctl(struct file *filp,
+ u_int iocmd,
+ unsigned long ioarg)
+{
+ return LinuxDriver_Ioctl(NULL, filp, iocmd, ioarg);
+}
+#endif
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIUserVAInvalidPointer --
+ *
+ * Checks if a given user VA is valid or not. Copied from
+ * bora/modules/vmnet/linux/hostif.c:VNetUserIfInvalidPointer(). TODO
+ * libify the common code.
+ *
+ * Results:
+ * TRUE iff invalid.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE Bool
+VMCIUserVAInvalidPointer(VA uva, // IN:
+ size_t size) // IN:
+{
+ return !access_ok(VERIFY_WRITE, (void *)uva, size);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIUserVALockPage --
+ *
+ * Lock physical page backing a given user VA. Copied from
+ * bora/modules/vmnet/linux/userif.c:UserIfLockPage(). TODO libify the
+ * common code.
+ *
+ * Results:
+ * Pointer to struct page on success, NULL otherwise.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE struct page *
+VMCIUserVALockPage(VA addr) // IN:
+{
+ struct page *page = NULL;
+ int retval;
+
+ down_read(¤t->mm->mmap_sem);
+ retval = get_user_pages(current, current->mm, addr,
+ 1, 1, 0, &page, NULL);
+ up_read(¤t->mm->mmap_sem);
+
+ if (retval != 1) {
+ return NULL;
+ }
+
+ return page;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIMapBoolPtr --
+ *
+ * Lock physical page backing a given user VA and maps it to kernel
+ * address space. The range of the mapped memory should be within a
+ * single page otherwise an error is returned. Copied from
+ * bora/modules/vmnet/linux/userif.c:VNetUserIfMapUint32Ptr(). TODO
+ * libify the common code.
+ *
+ * Results:
+ * 0 on success, negative error code otherwise.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static INLINE int
+VMCIMapBoolPtr(VA notifyUVA, // IN:
+ struct page **p, // OUT:
+ Bool **notifyPtr) // OUT:
+{
+ if (VMCIUserVAInvalidPointer(notifyUVA, sizeof **notifyPtr) ||
+ (((notifyUVA + sizeof **notifyPtr - 1) & ~(PAGE_SIZE - 1)) !=
+ (notifyUVA & ~(PAGE_SIZE - 1)))) {
+ return -EINVAL;
+ }
+
+ *p = VMCIUserVALockPage(notifyUVA);
+ if (*p == NULL) {
+ return -EAGAIN;
+ }
+
+ *notifyPtr = (Bool *)((uint8 *)kmap(*p) + (notifyUVA & (PAGE_SIZE - 1)));
+ return 0;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCISetupNotify --
+ *
+ * Sets up a given context for notify to work. Calls VMCIMapBoolPtr()
+ * which maps the notify boolean in user VA in kernel space.
+ *
+ * Results:
+ * VMCI_SUCCESS on success, error code otherwise.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+VMCISetupNotify(VMCIContext *context, // IN:
+ VA notifyUVA) // IN:
+{
+ int retval;
+
+ if (context->notify) {
+ Warning("VMCI: Notify mechanism is already set up.\n");
+ return VMCI_ERROR_DUPLICATE_ENTRY;
+ }
+
+ retval =
+ VMCIMapBoolPtr(notifyUVA, &context->notifyPage, &context->notify) == 0 ?
+ VMCI_SUCCESS : VMCI_ERROR_GENERIC;
+ if (retval == VMCI_SUCCESS) {
+ VMCIContext_CheckAndSignalNotify(context);
+ }
+
+ return retval;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIUnsetNotifyInt --
+ *
+ * Internal version of VMCIUnsetNotify, that allows for locking
+ * the context before unsetting the notify pointer. If useLock is
+ * TRUE, the context lock is grabbed.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static void
+VMCIUnsetNotifyInt(VMCIContext *context, // IN
+ Bool useLock) // IN
+{
+ VMCILockFlags flags;
+
+ if (useLock) {
+ VMCI_GrabLock(&context->lock, &flags);
+ }
+
+ if (context->notifyPage) {
+ struct page *notifyPage = context->notifyPage;
+
+ context->notify = NULL;
+ context->notifyPage = NULL;
+
+ if (useLock) {
+ VMCI_ReleaseLock(&context->lock, flags);
+ }
+
+ kunmap(notifyPage);
+ put_page(notifyPage);
+ } else {
+ if (useLock) {
+ VMCI_ReleaseLock(&context->lock, flags);
+ }
+ }
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCIUnsetNotify --
+ *
+ * Reverts actions set up by VMCISetupNotify(). Unmaps and unlocks the
+ * page mapped/locked by VMCISetupNotify().
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+void
+VMCIUnsetNotify(VMCIContext *context) // IN:
+{
+ VMCIUnsetNotifyInt(context, FALSE);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * PCI device support --
+ *
+ * The following functions implement the support for the VMCI
+ * guest device. This includes initializing the device and
+ * interrupt handling.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * vmci_guest_init --
+ *
+ * Initializes the VMCI PCI device. The initialization might fail
+ * if there is no VMCI PCI device.
+ *
+ * Results:
+ * 0 on success, other error codes on failure.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+vmci_guest_init(void)
+{
+ int retval;
+
+ /* Initialize guest device data. */
+ compat_mutex_init(&vmci_dev.lock);
+ vmci_dev.intr_type = VMCI_INTR_TYPE_INTX;
+ vmci_dev.exclusive_vectors = FALSE;
+ spin_lock_init(&vmci_dev.dev_spinlock);
+ vmci_dev.enabled = FALSE;
+
+ data_buffer = vmalloc(data_buffer_size);
+ if (!data_buffer) {
+ return -ENOMEM;
+ }
+
+ /* This should be last to make sure we are done initializing. */
+ retval = pci_register_driver(&vmci_driver);
+ if (retval < 0) {
+ vfree(data_buffer);
+ data_buffer = NULL;
+ return retval;
+ }
+
+ return 0;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * vmci_enable_msix --
+ *
+ * Enable MSI-X. Try exclusive vectors first, then shared vectors.
+ *
+ * Results:
+ * 0 on success, other error codes on failure.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int
+vmci_enable_msix(struct pci_dev *pdev) // IN
+{
+ int i;
+ int result;
+
+ for (i = 0; i < VMCI_MAX_INTRS; ++i) {
+ vmci_dev.msix_entries[i].entry = i;
+ vmci_dev.msix_entries[i].vector = i;
+ }
+
+ result = pci_enable_msix(pdev, vmci_dev.msix_entries, VMCI_MAX_INTRS);
+ if (!result) {
+ vmci_dev.exclusive_vectors = TRUE;
+ } else if (result > 0) {
+ result = pci_enable_msix(pdev, vmci_dev.msix_entries, 1);
+ }
+ return result;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * vmci_probe_device --
+ *
+ * Most of the initialization at module load time is done here.
+ *
+ * Results:
+ * Returns 0 for success, an error otherwise.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static int __devinit
+vmci_probe_device(struct pci_dev *pdev, // IN: vmci PCI device
+ const struct pci_device_id *id) // IN: matching device ID
+{
+ unsigned int ioaddr;
+ unsigned int ioaddr_size;
+ unsigned int capabilities;
+ int result;
+
+ printk(KERN_INFO "Probing for vmci/PCI.\n");
+
+ result = pci_enable_device(pdev);
+ if (result) {
+ printk(KERN_ERR "Cannot VMCI device %s: error %d\n",
+ pci_name(pdev), result);
+ return result;
+ }
+ pci_set_master(pdev); /* To enable QueuePair functionality. */
+ ioaddr = pci_resource_start(pdev, 0);
+ ioaddr_size = pci_resource_len(pdev, 0);
+
+ /*
+ * Request I/O region with adjusted base address and size. The adjusted
+ * values are needed and used if we release the region in case of failure.
+ */
+
+ if (!compat_request_region(ioaddr, ioaddr_size, "vmci")) {
+ printk(KERN_INFO "vmci: Another driver already loaded "
+ "for device in slot %s.\n", pci_name(pdev));
+ goto pci_disable;
+ }
+
+ printk(KERN_INFO "Found vmci/PCI at %#x, irq %u.\n", ioaddr, pdev->irq);
+
+ /*
+ * Verify that the VMCI Device supports the capabilities that
+ * we need. If the device is missing capabilities that we would
+ * like to use, check for fallback capabilities and use those
+ * instead (so we can run a new VM on old hosts). Fail the load if
+ * a required capability is missing and there is no fallback.
+ *
+ * Right now, we need datagrams. There are no fallbacks.
+ */
+ capabilities = inl(ioaddr + VMCI_CAPS_ADDR);
+
+ if ((capabilities & VMCI_CAPS_DATAGRAM) == 0) {
+ printk(KERN_ERR "VMCI device does not support datagrams.\n");
+ goto release;
+ }
+
+ /*
+ * If the hardware supports notifications, we will use that as
+ * well.
+ */
+ if (capabilities & VMCI_CAPS_NOTIFICATIONS) {
+ capabilities = VMCI_CAPS_DATAGRAM;
+ notification_bitmap = vmalloc(PAGE_SIZE);
+ if (notification_bitmap == NULL) {
+ printk(KERN_ERR "VMCI device unable to allocate notification bitmap.\n");
+ } else {
+ memset(notification_bitmap, 0, PAGE_SIZE);
+ capabilities |= VMCI_CAPS_NOTIFICATIONS;
+ }
+ } else {
+ capabilities = VMCI_CAPS_DATAGRAM;
+ }
+ printk(KERN_INFO "VMCI: using capabilities 0x%x.\n", capabilities);
+
+ /* Let the host know which capabilities we intend to use. */
+ outl(capabilities, ioaddr + VMCI_CAPS_ADDR);
+
+ /* Device struct initialization. */
+ compat_mutex_lock(&vmci_dev.lock);
+ if (vmci_dev.enabled) {
+ printk(KERN_ERR "VMCI device already enabled.\n");
+ goto unlock;
+ }
+
+ vmci_dev.ioaddr = ioaddr;
+ vmci_dev.ioaddr_size = ioaddr_size;
+
+ /*
+ * Register notification bitmap with device if that capability is
+ * used
+ */
+ if (capabilities & VMCI_CAPS_NOTIFICATIONS) {
+ unsigned long bitmapPPN;
+ bitmapPPN = page_to_pfn(vmalloc_to_page(notification_bitmap));
+ if (!VMCI_RegisterNotificationBitmap(bitmapPPN)) {
+ printk(KERN_ERR "VMCI device unable to register notification bitmap "
+ "with PPN 0x%x.\n", (uint32)bitmapPPN);
+ goto unlock;
+ }
+ }
+
+ /* Check host capabilities. */
+ if (!VMCI_CheckHostCapabilities()) {
+ goto remove_bitmap;
+ }
+
+ /* Enable device. */
+ vmci_dev.enabled = TRUE;
+ pci_set_drvdata(pdev, &vmci_dev);
+
+ /*
+ * We do global initialization here because we need datagrams
+ * during VMCIUtil_Init, since it registers for VMCI events. If we
+ * ever support more than one VMCI device we will have to create
+ * seperate LateInit/EarlyExit functions that can be used to do
+ * initialization/cleanup that depends on the device being
+ * accessible. We need to initialize VMCI components before
+ * requesting an irq - the VMCI interrupt handler uses these
+ * components, and it may be invoked once request_irq() has
+ * registered the handler (as the irq line may be shared).
+ */
+ VMCIUtil_Init();
+ VMCIQPGuestEndpoints_Init();
+
+ /*
+ * Enable interrupts. Try MSI-X first, then MSI, and then fallback on
+ * legacy interrupts.
+ */
+ if (!vmci_disable_msix && !vmci_enable_msix(pdev)) {
+ vmci_dev.intr_type = VMCI_INTR_TYPE_MSIX;
+ vmci_dev.irq = vmci_dev.msix_entries[0].vector;
+ } else if (!vmci_disable_msi && !pci_enable_msi(pdev)) {
+ vmci_dev.intr_type = VMCI_INTR_TYPE_MSI;
+ vmci_dev.irq = pdev->irq;
+ } else {
+ vmci_dev.intr_type = VMCI_INTR_TYPE_INTX;
+ vmci_dev.irq = pdev->irq;
+ }
+
+ /* Request IRQ for legacy or MSI interrupts, or for first MSI-X vector. */
+ result = request_irq(vmci_dev.irq, vmci_interrupt, COMPAT_IRQF_SHARED,
+ "vmci", &vmci_dev);
+ if (result) {
+ printk(KERN_ERR "vmci: irq %u in use: %d\n", vmci_dev.irq, result);
+ goto components_exit;
+ }
+
+ /*
+ * For MSI-X with exclusive vectors we need to request an interrupt for each
+ * vector so that we get a separate interrupt handler routine. This allows
+ * us to distinguish between the vectors.
+ */
+
+ if (vmci_dev.exclusive_vectors) {
+ ASSERT(vmci_dev.intr_type == VMCI_INTR_TYPE_MSIX);
+ result = request_irq(vmci_dev.msix_entries[1].vector, vmci_interrupt_bm,
+ 0, "vmci", &vmci_dev);
+ if (result) {
+ printk(KERN_ERR "vmci: irq %u in use: %d\n",
+ vmci_dev.msix_entries[1].vector, result);
+ free_irq(vmci_dev.irq, &vmci_dev);
+ goto components_exit;
+ }
+ }
+
+ printk(KERN_INFO "Registered vmci device.\n");
+
+ compat_mutex_unlock(&vmci_dev.lock);
+
+ /* Enable specific interrupt bits. */
+ if (capabilities & VMCI_CAPS_NOTIFICATIONS) {
+ outl(VMCI_IMR_DATAGRAM | VMCI_IMR_NOTIFICATION,
+ vmci_dev.ioaddr + VMCI_IMR_ADDR);
+ } else {
+ outl(VMCI_IMR_DATAGRAM, vmci_dev.ioaddr + VMCI_IMR_ADDR);
+ }
+
+ /* Enable interrupts. */
+ outl(VMCI_CONTROL_INT_ENABLE, vmci_dev.ioaddr + VMCI_CONTROL_ADDR);
+
+ return 0;
+
+ components_exit:
+ VMCIQPGuestEndpoints_Exit();
+ VMCIUtil_Exit();
+ if (vmci_dev.intr_type == VMCI_INTR_TYPE_MSIX) {
+ pci_disable_msix(pdev);
+ } else if (vmci_dev.intr_type == VMCI_INTR_TYPE_MSI) {
+ pci_disable_msi(pdev);
+ }
+ remove_bitmap:
+ if (notification_bitmap) {
+ outl(VMCI_CONTROL_RESET, vmci_dev.ioaddr + VMCI_CONTROL_ADDR);
+ }
+ unlock:
+ compat_mutex_unlock(&vmci_dev.lock);
+ release:
+ if (notification_bitmap) {
+ vfree(notification_bitmap);
+ notification_bitmap = NULL;
+ }
+ release_region(ioaddr, ioaddr_size);
+ pci_disable:
+ pci_disable_device(pdev);
+ return -EBUSY;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * vmci_remove_device --
+ *
+ * Cleanup, called for each device on unload.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static void __devexit
+vmci_remove_device(struct pci_dev* pdev)
+{
+ struct vmci_device *dev = pci_get_drvdata(pdev);
+
+ printk(KERN_INFO "Removing vmci device\n");
+
+ VMCIQPGuestEndpoints_Exit();
+ VMCIUtil_Exit();
+
+ compat_mutex_lock(&dev->lock);
+ printk(KERN_INFO "Resetting vmci device\n");
+ outl(VMCI_CONTROL_RESET, vmci_dev.ioaddr + VMCI_CONTROL_ADDR);
+
+ /*
+ * Free IRQ and then disable MSI/MSI-X as appropriate. For MSI-X, we might
+ * have multiple vectors, each with their own IRQ, which we must free too.
+ */
+
+ free_irq(dev->irq, dev);
+ if (dev->intr_type == VMCI_INTR_TYPE_MSIX) {
+ if (dev->exclusive_vectors) {
+ free_irq(dev->msix_entries[1].vector, dev);
+ }
+ pci_disable_msix(pdev);
+ } else if (dev->intr_type == VMCI_INTR_TYPE_MSI) {
+ pci_disable_msi(pdev);
+ }
+ dev->exclusive_vectors = FALSE;
+ dev->intr_type = VMCI_INTR_TYPE_INTX;
+
+ release_region(dev->ioaddr, dev->ioaddr_size);
+ dev->enabled = FALSE;
+ if (notification_bitmap) {
+ /*
+ * The device reset above cleared the bitmap state of the
+ * device, so we can safely free it here.
+ */
+
+ vfree(notification_bitmap);
+ notification_bitmap = NULL;
+ }
+
+ printk(KERN_INFO "Unregistered vmci device.\n");
+ compat_mutex_unlock(&dev->lock);
+
+ pci_disable_device(pdev);
+}
+
+
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * vmci_interrupt --
+ *
+ * Interrupt handler for legacy or MSI interrupt, or for first MSI-X
+ * interrupt (vector VMCI_INTR_DATAGRAM).
+ *
+ * Results:
+ * COMPAT_IRQ_HANDLED if the interrupt is handled, COMPAT_IRQ_NONE if
+ * not an interrupt.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+static compat_irqreturn_t
+vmci_interrupt(int irq, // IN
+ void *clientdata, // IN
+ struct pt_regs *regs) // IN
+#else
+static compat_irqreturn_t
+vmci_interrupt(int irq, // IN
+ void *clientdata) // IN
+#endif
+{
+ vmci_device *dev = clientdata;
+
+ if (dev == NULL) {
+ printk(KERN_DEBUG "vmci_interrupt(): irq %d for unknown device.\n", irq);
+ return COMPAT_IRQ_NONE;
+ }
+
+ /*
+ * If we are using MSI-X with exclusive vectors then we simply schedule
+ * the datagram tasklet, since we know the interrupt was meant for us.
+ * Otherwise we must read the ICR to determine what to do.
+ */
+
+ if (dev->intr_type == VMCI_INTR_TYPE_MSIX && dev->exclusive_vectors) {
+ tasklet_schedule(&vmci_dg_tasklet);
+ } else {
+ unsigned int icr;
+
+ ASSERT(dev->intr_type == VMCI_INTR_TYPE_INTX ||
+ dev->intr_type == VMCI_INTR_TYPE_MSI);
+
+ /* Acknowledge interrupt and determine what needs doing. */
+ icr = inl(dev->ioaddr + VMCI_ICR_ADDR);
+ if (icr == 0 || icr == 0xffffffff) {
+ return COMPAT_IRQ_NONE;
+ }
+
+ if (icr & VMCI_ICR_DATAGRAM) {
+ tasklet_schedule(&vmci_dg_tasklet);
+ icr &= ~VMCI_ICR_DATAGRAM;
+ }
+ if (icr & VMCI_ICR_NOTIFICATION) {
+ tasklet_schedule(&vmci_bm_tasklet);
+ icr &= ~VMCI_ICR_NOTIFICATION;
+ }
+ if (icr != 0) {
+ printk(KERN_INFO LGPFX"Ignoring unknown interrupt cause (%d).\n", icr);
+ }
+ }
+
+ return COMPAT_IRQ_HANDLED;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * vmci_interrupt_bm --
+ *
+ * Interrupt handler for MSI-X interrupt vector VMCI_INTR_NOTIFICATION,
+ * which is for the notification bitmap. Will only get called if we are
+ * using MSI-X with exclusive vectors.
+ *
+ * Results:
+ * COMPAT_IRQ_HANDLED if the interrupt is handled, COMPAT_IRQ_NONE if
+ * not an interrupt.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+static compat_irqreturn_t
+vmci_interrupt_bm(int irq, // IN
+ void *clientdata, // IN
+ struct pt_regs *regs) // IN
+#else
+static compat_irqreturn_t
+vmci_interrupt_bm(int irq, // IN
+ void *clientdata) // IN
+#endif
+{
+ vmci_device *dev = clientdata;
+
+ if (dev == NULL) {
+ printk(KERN_DEBUG "vmci_interrupt_bm(): irq %d for unknown device.\n", irq);
+ return COMPAT_IRQ_NONE;
+ }
+
+ /* For MSI-X we can just assume it was meant for us. */
+ ASSERT(dev->intr_type == VMCI_INTR_TYPE_MSIX && dev->exclusive_vectors);
+ tasklet_schedule(&vmci_bm_tasklet);
+
+ return COMPAT_IRQ_HANDLED;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCI_DeviceEnabled --
+ *
+ * Checks whether the VMCI device is enabled.
+ *
+ * Results:
+ * TRUE if device is enabled, FALSE otherwise.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+Bool
+VMCI_DeviceEnabled(void)
+{
+ Bool retval;
+
+ if (!guestDeviceInit) {
+ return FALSE;
+ }
+
+ compat_mutex_lock(&vmci_dev.lock);
+ retval = vmci_dev.enabled;
+ compat_mutex_unlock(&vmci_dev.lock);
+
+ return retval;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCI_SendDatagram --
+ *
+ * VM to hypervisor call mechanism. We use the standard VMware naming
+ * convention since shared code is calling this function as well.
+ *
+ * Results:
+ * The result of the hypercall.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+int
+VMCI_SendDatagram(VMCIDatagram *dg)
+{
+ unsigned long flags;
+ int result;
+
+ if (!isGuestDriver) {
+ return VMCI_ERROR_UNAVAILABLE;
+ }
+
+ /* Check args. */
+ if (dg == NULL) {
+ return VMCI_ERROR_INVALID_ARGS;
+ }
+
+ /*
+ * Need to acquire spinlock on the device because
+ * the datagram data may be spread over multiple pages and the monitor may
+ * interleave device user rpc calls from multiple VCPUs. Acquiring the
+ * spinlock precludes that possibility. Disabling interrupts to avoid
+ * incoming datagrams during a "rep out" and possibly landing up in this
+ * function.
+ */
+ spin_lock_irqsave(&vmci_dev.dev_spinlock, flags);
+
+ /*
+ * Send the datagram and retrieve the return value from the result register.
+ */
+ __asm__ __volatile__(
+ "cld\n\t"
+ "rep outsb\n\t"
+ : /* No output. */
+ : "d"(vmci_dev.ioaddr + VMCI_DATA_OUT_ADDR),
+ "c"(VMCI_DG_SIZE(dg)), "S"(dg)
+ );
+
+ /*
+ * XXX Should read result high port as well when updating handlers to
+ * return 64bit.
+ */
+ result = inl(vmci_dev.ioaddr + VMCI_RESULT_LOW_ADDR);
+ spin_unlock_irqrestore(&vmci_dev.dev_spinlock, flags);
+
+ return result;
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * dispatch_datagrams --
+ *
+ * Reads and dispatches incoming datagrams.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Reads data from the device.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+void
+dispatch_datagrams(unsigned long data)
+{
+ vmci_device *dev = (vmci_device *)data;
+
+ if (dev == NULL) {
+ printk(KERN_DEBUG "vmci: dispatch_datagrams(): no vmci device"
+ "present.\n");
+ return;
+ }
+
+ if (data_buffer == NULL) {
+ printk(KERN_DEBUG "vmci: dispatch_datagrams(): no buffer present.\n");
+ return;
+ }
+
+
+ VMCI_ReadDatagramsFromPort((VMCIIoHandle) 0, dev->ioaddr + VMCI_DATA_IN_ADDR,
+ data_buffer, data_buffer_size);
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * process_bitmap --
+ *
+ * Scans the notification bitmap for raised flags, clears them
+ * and handles the notifications.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+void
+process_bitmap(unsigned long data)
+{
+ vmci_device *dev = (vmci_device *)data;
+
+ if (dev == NULL) {
+ printk(KERN_DEBUG "vmci: process_bitmaps(): no vmci device"
+ "present.\n");
+ return;
+ }
+
+ if (notification_bitmap == NULL) {
+ printk(KERN_DEBUG "vmci: process_bitmaps(): no bitmap present.\n");
+ return;
+ }
+
+
+ VMCI_ScanNotificationBitmap(notification_bitmap);
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Shared functions --
+ *
+ * Functions shared between host and guest personality.
+ *
+ *----------------------------------------------------------------------
+ */
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCI_HasGuestDevice --
+ *
+ * Determines whether the VMCI PCI device has been successfully
+ * initialized.
+ *
+ * Results:
+ * TRUE, if VMCI guest device is operational, FALSE otherwise.
+ *
+ * Side effects:
+ * Reads data from the device.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+Bool
+VMCI_HasGuestDevice(void)
+{
+ return VMCI_DeviceEnabled();
+}
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * VMCI_HasHostDevice --
+ *
+ * Determines whether the VMCI host driver has been successfully
+ * initialized.
+ *
+ * Results:
+ * TRUE, if VMCI host driver is operational, FALSE otherwise.
+ *
+ * Side effects:
+ * Reads data from the device.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+Bool
+VMCI_HasHostDevice(void)
+{
+ return hostDeviceInit;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Module definitions --
+ *
+ * Implements support for module load/unload.
+ *
+ *----------------------------------------------------------------------
+ */
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * vmci_init --
+ *
+ * linux module entry point. Called by /sbin/insmod command
+ *
+ * Results:
+ * registers a device driver for a major # that depends
+ * on the uid. Add yourself to that list. List is now in
+ * private/driver-private.c.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int __init
+vmci_init(void)
+{
+ int retval;
+
+ DriverLog_Init("/dev/vmci");
+
+ retval = VMCI_SharedInit();
+ if (retval != VMCI_SUCCESS) {
+ Warning(LGPFX"Failed to initialize VMCI common components (err=%d).\n",
+ retval);
+ return -ENOMEM;
+ }
+
+ if (isGuestDriver) {
+ retval = vmci_guest_init();
+ if (retval != 0) {
+ Warning(LGPFX"VMCI PCI device not initialized (err=%d).\n", retval);
+ }
+ guestDeviceInit = (retval == 0);
+ if (guestDeviceInit) {
+ Log(LGPFX"Using guest personality\n");
+ }
+ } else {
+ retval = vmci_host_init();
+ if (retval != 0) {
+ Warning(LGPFX"Unable to initialize host personality (err=%d).\n", retval);
+ }
+ hostDeviceInit = (retval == 0);
+ if (hostDeviceInit) {
+ Log(LGPFX"Using host personality\n");
+ }
+ }
+
+ if (!guestDeviceInit && !hostDeviceInit) {
+ VMCI_SharedCleanup();
+ return -ENODEV;
+ }
+
+ Log("Module %s: initialized\n", linuxState.deviceName);
+
+ return 0;
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * vmci_exit --
+ *
+ * Called by /sbin/rmmod
+ *
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void __exit
+vmci_exit(void)
+{
+ int retval;
+
+ if (guestDeviceInit) {
+ pci_unregister_driver(&vmci_driver);
+ vfree(data_buffer);
+ guestDeviceInit = FALSE;
+ }
+
+ if (hostDeviceInit) {
+ unregister_ioctl32_handlers();
+
+ VMCI_HostCleanup();
+
+ retval = misc_deregister(&linuxState.misc);
+ if (retval) {
+ Warning("Module %s: error unregistering\n", linuxState.deviceName);
+ } else {
+ Log("Module %s: unloaded\n", linuxState.deviceName);
+ }
+
+ hostDeviceInit = FALSE;
+ }
+
+ VMCI_SharedCleanup();
+}
+
+
+module_init(vmci_init);
+module_exit(vmci_exit);
+MODULE_DEVICE_TABLE(pci, vmci_ids);
+
+module_param_named(disable_msi, vmci_disable_msi, bool, 0);
+MODULE_PARM_DESC(disable_msi, "Disable MSI use in driver - (default=0)");
+
+module_param_named(disable_msix, vmci_disable_msix, bool, 0);
+MODULE_PARM_DESC(disable_msix, "Disable MSI-X use in driver - (default="
+ __stringify(VMCI_DISABLE_MSIX) ")");
+
+
+MODULE_AUTHOR("VMware, Inc.");
+MODULE_DESCRIPTION("VMware Virtual Machine Communication Interface (VMCI).");
+MODULE_VERSION(VMCI_DRIVER_VERSION_STRING);
+MODULE_LICENSE("GPL v2");
+/*
+ * Starting with SLE10sp2, Novell requires that IHVs sign a support agreement
+ * with them and mark their kernel modules as externally supported via a
+ * change to the module header. If this isn't done, the module will not load
+ * by default (i.e., neither mkinitrd nor modprobe will accept it).
+ */
+MODULE_INFO(supported, "external");
+++ /dev/null
-/*********************************************************
- * Copyright (C) 2005 VMware, Inc. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation version 2 and no later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- *
- *********************************************************/
-
-/*
- * vmci.c --
- *
- * Linux guest driver for the VMCI device.
- */
-
-#include "driver-config.h"
-
-#include <linux/moduleparam.h>
-#include <linux/poll.h>
-
-#include "compat_init.h"
-#include "compat_interrupt.h"
-#include "compat_ioport.h"
-#include "compat_kernel.h"
-#include "compat_module.h"
-#include "compat_mutex.h"
-#include "compat_page.h"
-#include "compat_pci.h"
-
-#include "driverLog.h"
-
-#include "vm_basic_types.h"
-#include "vm_device_version.h"
-
-#include "vmci_defs.h"
-#include "vmci_infrastructure.h"
-#include "vmci_iocontrols.h"
-#include "vmci_version.h"
-#include "vmciContext.h"
-#include "vmciDatagram.h"
-#include "vmciDoorbell.h"
-#include "vmciDriver.h"
-#include "vmciEvent.h"
-#include "vmciQueuePair.h"
-#include "vmciResource.h"
-
-#define LGPFX "VMCI: "
-#define VMCI_DEVICE_MINOR_NUM 0
-
-/* MSI-X has performance problems in < 2.6.19 */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
-# define VMCI_DISABLE_MSIX 0
-#else
-# define VMCI_DISABLE_MSIX 1
-#endif
-
-typedef struct vmci_device {
- compat_mutex_t lock;
-
- unsigned int ioaddr;
- unsigned int ioaddr_size;
- unsigned int irq;
- unsigned int intr_type;
- Bool exclusive_vectors;
- struct msix_entry msix_entries[VMCI_MAX_INTRS];
-
- Bool enabled;
- spinlock_t dev_spinlock;
-} vmci_device;
-
-static int vmci_probe_device(struct pci_dev *pdev,
- const struct pci_device_id *id);
-static void vmci_remove_device(struct pci_dev* pdev);
-static int vmci_open(struct inode *inode, struct file *file);
-static int vmci_close(struct inode *inode, struct file *file);
-static long vmci_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
-#if !defined(HAVE_UNLOCKED_IOCTL)
-static int vmci_legacy_ioctl(struct inode *dummy, struct file *file,
- unsigned int cmd, unsigned long arg);
-#endif
-static unsigned int vmci_poll(struct file *file, poll_table *wait);
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
-static compat_irqreturn_t vmci_interrupt(int irq, void *dev_id,
- struct pt_regs * regs);
-static compat_irqreturn_t vmci_interrupt_bm(int irq, void *dev_id,
- struct pt_regs * regs);
-#else
-static compat_irqreturn_t vmci_interrupt(int irq, void *dev_id);
-static compat_irqreturn_t vmci_interrupt_bm(int irq, void *dev_id);
-#endif
-static void dispatch_datagrams(unsigned long data);
-static void process_bitmap(unsigned long data);
-
-static const struct pci_device_id vmci_ids[] = {
- { PCI_DEVICE(PCI_VENDOR_ID_VMWARE, PCI_DEVICE_ID_VMWARE_VMCI), },
- { 0 },
-};
-
-static struct file_operations vmci_ops = {
- .owner = THIS_MODULE,
- .open = vmci_open,
- .release = vmci_close,
-#ifdef HAVE_UNLOCKED_IOCTL
- .unlocked_ioctl = vmci_ioctl,
-#else
- .ioctl = vmci_legacy_ioctl,
-#endif
-#ifdef HAVE_COMPAT_IOCTL
- .compat_ioctl = vmci_ioctl,
-#endif
- .poll = vmci_poll,
-};
-
-static struct pci_driver vmci_driver = {
- .name = "vmci",
- .id_table = vmci_ids,
- .probe = vmci_probe_device,
- .remove = __devexit_p(vmci_remove_device),
-};
-
-static vmci_device vmci_dev;
-
-/* We dynamically request the device major number at init time. */
-static int device_major_nr = 0;
-
-static int vmci_disable_msi;
-static int vmci_disable_msix = VMCI_DISABLE_MSIX;
-
-DECLARE_TASKLET(vmci_dg_tasklet, dispatch_datagrams,
- (unsigned long)&vmci_dev);
-
-DECLARE_TASKLET(vmci_bm_tasklet, process_bitmap,
- (unsigned long)&vmci_dev);
-
-/*
- * Allocate a buffer for incoming datagrams globally to avoid repeated
- * allocation in the interrupt handler's atomic context.
- */
-
-static uint8 *data_buffer = NULL;
-static uint32 data_buffer_size = VMCI_MAX_DG_SIZE;
-
-/*
- * If the VMCI hardware supports the notification bitmap, we allocate
- * and register a page with the device.
- */
-
-static uint8 *notification_bitmap = NULL;
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_init --
- *
- * Initialization, called by Linux when the module is loaded.
- *
- * Results:
- * Returns 0 for success, negative errno value otherwise.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static int __init
-vmci_init(void)
-{
- int err;
-
- DriverLog_Init("/dev/vmci");
-
- /* Initialize device data. */
- compat_mutex_init(&vmci_dev.lock);
- vmci_dev.intr_type = VMCI_INTR_TYPE_INTX;
- vmci_dev.exclusive_vectors = FALSE;
- spin_lock_init(&vmci_dev.dev_spinlock);
- vmci_dev.enabled = FALSE;
-
- data_buffer = vmalloc(data_buffer_size);
- if (!data_buffer) {
- return -ENOMEM;
- }
-
- /* Register device node ops. */
- err = register_chrdev(0, "vmci", &vmci_ops);
- if (err < 0) {
- printk(KERN_ERR "Unable to register vmci device\n");
- goto err_free_mem;
- }
-
- device_major_nr = err;
-
- printk("VMCI: Major device number is: %d\n", device_major_nr);
-
- /* This should be last to make sure we are done initializing. */
- err = pci_register_driver(&vmci_driver);
- if (err < 0) {
- goto err_unregister_chrdev;
- }
-
- return 0;
-
-err_unregister_chrdev:
- unregister_chrdev(device_major_nr, "vmci");
-err_free_mem:
- vfree(data_buffer);
- return err;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_exit --
- *
- * Cleanup, called by Linux when the module is unloaded.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static void __exit
-vmci_exit(void)
-{
- pci_unregister_driver(&vmci_driver);
-
- unregister_chrdev(device_major_nr, "vmci");
-
- vfree(data_buffer);
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_enable_msix --
- *
- * Enable MSI-X. Try exclusive vectors first, then shared vectors.
- *
- * Results:
- * 0 on success, other error codes on failure.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static int
-vmci_enable_msix(struct pci_dev *pdev) // IN
-{
- int i;
- int result;
-
- for (i = 0; i < VMCI_MAX_INTRS; ++i) {
- vmci_dev.msix_entries[i].entry = i;
- vmci_dev.msix_entries[i].vector = i;
- }
-
- result = pci_enable_msix(pdev, vmci_dev.msix_entries, VMCI_MAX_INTRS);
- if (!result) {
- vmci_dev.exclusive_vectors = TRUE;
- } else if (result > 0) {
- result = pci_enable_msix(pdev, vmci_dev.msix_entries, 1);
- }
- return result;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_probe_device --
- *
- * Most of the initialization at module load time is done here.
- *
- * Results:
- * Returns 0 for success, an error otherwise.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static int __devinit
-vmci_probe_device(struct pci_dev *pdev, // IN: vmci PCI device
- const struct pci_device_id *id) // IN: matching device ID
-{
- unsigned int ioaddr;
- unsigned int ioaddr_size;
- unsigned int capabilities;
- int result;
-
- printk(KERN_INFO "Probing for vmci/PCI.\n");
-
- result = pci_enable_device(pdev);
- if (result) {
- printk(KERN_ERR "Cannot VMCI device %s: error %d\n",
- pci_name(pdev), result);
- return result;
- }
- pci_set_master(pdev); /* To enable QueuePair functionality. */
- ioaddr = pci_resource_start(pdev, 0);
- ioaddr_size = pci_resource_len(pdev, 0);
-
- /*
- * Request I/O region with adjusted base address and size. The adjusted
- * values are needed and used if we release the region in case of failure.
- */
-
- if (!compat_request_region(ioaddr, ioaddr_size, "vmci")) {
- printk(KERN_INFO "vmci: Another driver already loaded "
- "for device in slot %s.\n", pci_name(pdev));
- goto pci_disable;
- }
-
- printk(KERN_INFO "Found vmci/PCI at %#x, irq %u.\n", ioaddr, pdev->irq);
-
- /*
- * Verify that the VMCI Device supports the capabilities that
- * we need. If the device is missing capabilities that we would
- * like to use, check for fallback capabilities and use those
- * instead (so we can run a new VM on old hosts). Fail the load if
- * a required capability is missing and there is no fallback.
- *
- * Right now, we need datagrams. There are no fallbacks.
- */
- capabilities = inl(ioaddr + VMCI_CAPS_ADDR);
-
- if ((capabilities & VMCI_CAPS_DATAGRAM) == 0) {
- printk(KERN_ERR "VMCI device does not support datagrams.\n");
- goto release;
- }
-
- /*
- * If the hardware supports notifications, we will use that as
- * well.
- */
- if (capabilities & VMCI_CAPS_NOTIFICATIONS) {
- capabilities = VMCI_CAPS_DATAGRAM;
- notification_bitmap = vmalloc(PAGE_SIZE);
- if (notification_bitmap == NULL) {
- printk(KERN_ERR "VMCI device unable to allocate notification bitmap.\n");
- } else {
- memset(notification_bitmap, 0, PAGE_SIZE);
- capabilities |= VMCI_CAPS_NOTIFICATIONS;
- }
- } else {
- capabilities = VMCI_CAPS_DATAGRAM;
- }
- printk(KERN_INFO "VMCI: using capabilities 0x%x.\n", capabilities);
-
- /* Let the host know which capabilities we intend to use. */
- outl(capabilities, ioaddr + VMCI_CAPS_ADDR);
-
- /* Device struct initialization. */
- compat_mutex_lock(&vmci_dev.lock);
- if (vmci_dev.enabled) {
- printk(KERN_ERR "VMCI device already enabled.\n");
- goto unlock;
- }
-
- vmci_dev.ioaddr = ioaddr;
- vmci_dev.ioaddr_size = ioaddr_size;
-
- /*
- * Register notification bitmap with device if that capability is
- * used
- */
- if (capabilities & VMCI_CAPS_NOTIFICATIONS) {
- unsigned long bitmapPPN;
- bitmapPPN = page_to_pfn(vmalloc_to_page(notification_bitmap));
- if (!VMCI_RegisterNotificationBitmap(bitmapPPN)) {
- printk(KERN_ERR "VMCI device unable to register notification bitmap "
- "with PPN 0x%x.\n", (uint32)bitmapPPN);
- goto unlock;
- }
- }
-
- /* Check host capabilities. */
- if (!VMCI_CheckHostCapabilities()) {
- goto remove_bitmap;
- }
-
- /* Enable device. */
- vmci_dev.enabled = TRUE;
- pci_set_drvdata(pdev, &vmci_dev);
-
- /*
- * We do global initialization here because we need datagrams for
- * event init. If we ever support more than one VMCI device we will
- * have to create seperate LateInit/EarlyExit functions that can be
- * used to do initialization/cleanup that depends on the device
- * being accessible. We need to initialize VMCI components before
- * requesting an irq - the VMCI interrupt handler uses these
- * components, and it may be invoked once request_irq() has
- * registered the handler (as the irq line may be shared).
- */
- VMCIResource_Init();
- VMCIContext_Init();
- VMCIDatagram_Init();
- VMCIEvent_Init();
- VMCIUtil_Init();
- VMCIDoorbell_Init();
- VMCIQPGuestEndpoints_Init();
-
- /*
- * Enable interrupts. Try MSI-X first, then MSI, and then fallback on
- * legacy interrupts.
- */
- if (!vmci_disable_msix && !vmci_enable_msix(pdev)) {
- vmci_dev.intr_type = VMCI_INTR_TYPE_MSIX;
- vmci_dev.irq = vmci_dev.msix_entries[0].vector;
- } else if (!vmci_disable_msi && !pci_enable_msi(pdev)) {
- vmci_dev.intr_type = VMCI_INTR_TYPE_MSI;
- vmci_dev.irq = pdev->irq;
- } else {
- vmci_dev.intr_type = VMCI_INTR_TYPE_INTX;
- vmci_dev.irq = pdev->irq;
- }
-
- /* Request IRQ for legacy or MSI interrupts, or for first MSI-X vector. */
- result = request_irq(vmci_dev.irq, vmci_interrupt, COMPAT_IRQF_SHARED,
- "vmci", &vmci_dev);
- if (result) {
- printk(KERN_ERR "vmci: irq %u in use: %d\n", vmci_dev.irq, result);
- goto components_exit;
- }
-
- /*
- * For MSI-X with exclusive vectors we need to request an interrupt for each
- * vector so that we get a separate interrupt handler routine. This allows
- * us to distinguish between the vectors.
- */
-
- if (vmci_dev.exclusive_vectors) {
- ASSERT(vmci_dev.intr_type == VMCI_INTR_TYPE_MSIX);
- result = request_irq(vmci_dev.msix_entries[1].vector, vmci_interrupt_bm,
- 0, "vmci", &vmci_dev);
- if (result) {
- printk(KERN_ERR "vmci: irq %u in use: %d\n",
- vmci_dev.msix_entries[1].vector, result);
- free_irq(vmci_dev.irq, &vmci_dev);
- goto components_exit;
- }
- }
-
- printk(KERN_INFO "Registered vmci device.\n");
-
- compat_mutex_unlock(&vmci_dev.lock);
-
- /* Enable specific interrupt bits. */
- if (capabilities & VMCI_CAPS_NOTIFICATIONS) {
- outl(VMCI_IMR_DATAGRAM | VMCI_IMR_NOTIFICATION,
- vmci_dev.ioaddr + VMCI_IMR_ADDR);
- } else {
- outl(VMCI_IMR_DATAGRAM, vmci_dev.ioaddr + VMCI_IMR_ADDR);
- }
-
- /* Enable interrupts. */
- outl(VMCI_CONTROL_INT_ENABLE, vmci_dev.ioaddr + VMCI_CONTROL_ADDR);
-
- return 0;
-
- components_exit:
- VMCIQPGuestEndpoints_Exit();
- VMCIDoorbell_Exit();
- VMCIUtil_Exit();
- VMCIEvent_Exit();
- VMCIDatagram_Exit();
- VMCIContext_Exit();
- VMCIResource_Exit();
- if (vmci_dev.intr_type == VMCI_INTR_TYPE_MSIX) {
- pci_disable_msix(pdev);
- } else if (vmci_dev.intr_type == VMCI_INTR_TYPE_MSI) {
- pci_disable_msi(pdev);
- }
- remove_bitmap:
- if (notification_bitmap) {
- outl(VMCI_CONTROL_RESET, vmci_dev.ioaddr + VMCI_CONTROL_ADDR);
- }
- unlock:
- compat_mutex_unlock(&vmci_dev.lock);
- release:
- if (notification_bitmap) {
- vfree(notification_bitmap);
- }
- release_region(ioaddr, ioaddr_size);
- pci_disable:
- pci_disable_device(pdev);
- return -EBUSY;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_remove_device --
- *
- * Cleanup, called for each device on unload.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static void __devexit
-vmci_remove_device(struct pci_dev* pdev)
-{
- struct vmci_device *dev = pci_get_drvdata(pdev);
-
- printk(KERN_INFO "Removing vmci device\n");
-
- VMCIQPGuestEndpoints_Exit();
-
- // XXX Todo add exit/cleanup functions for util, sm, dg, and resource apis.
- VMCIUtil_Exit();
- VMCIEvent_Exit();
-
- compat_mutex_lock(&dev->lock);
- printk(KERN_INFO "Resetting vmci device\n");
- outl(VMCI_CONTROL_RESET, vmci_dev.ioaddr + VMCI_CONTROL_ADDR);
-
- /*
- * Free IRQ and then disable MSI/MSI-X as appropriate. For MSI-X, we might
- * have multiple vectors, each with their own IRQ, which we must free too.
- */
-
- free_irq(dev->irq, dev);
- if (dev->intr_type == VMCI_INTR_TYPE_MSIX) {
- if (dev->exclusive_vectors) {
- free_irq(dev->msix_entries[1].vector, dev);
- }
- pci_disable_msix(pdev);
- } else if (dev->intr_type == VMCI_INTR_TYPE_MSI) {
- pci_disable_msi(pdev);
- }
- dev->exclusive_vectors = FALSE;
- dev->intr_type = VMCI_INTR_TYPE_INTX;
-
- release_region(dev->ioaddr, dev->ioaddr_size);
- dev->enabled = FALSE;
- VMCIDoorbell_Exit();
- if (notification_bitmap) {
- vfree(notification_bitmap);
- }
-
- VMCIDatagram_Exit();
- VMCIContext_Exit();
- VMCIResource_Exit();
-
- printk(KERN_INFO "Unregistered vmci device.\n");
- compat_mutex_unlock(&dev->lock);
-
- pci_disable_device(pdev);
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_open --
- *
- * Open device.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static int
-vmci_open(struct inode *inode, // IN
- struct file *file) // IN
-{
- VMCIObj *devHndl;
- int errcode;
-
- printk(KERN_INFO "Opening vmci device\n");
-
- if (MINOR(inode->i_rdev) != VMCI_DEVICE_MINOR_NUM) {
- return -ENODEV;
- }
-
- compat_mutex_lock(&vmci_dev.lock);
- if (!vmci_dev.enabled) {
- printk(KERN_INFO "Received open on uninitialized vmci device.\n");
- errcode = -ENODEV;
- goto unlock;
- }
-
- /* Do open ... */
- devHndl = VMCI_AllocKernelMem(sizeof *devHndl, VMCI_MEMORY_NORMAL);
- if (!devHndl) {
- printk(KERN_INFO "Failed to create device obj when opening device.\n");
- errcode = -ENOMEM;
- goto unlock;
- }
- devHndl->ptr = NULL;
- devHndl->type = VMCIOBJ_NOT_SET;
- file->private_data = devHndl;
-
- compat_mutex_unlock(&vmci_dev.lock);
-
- return 0;
-
- unlock:
- compat_mutex_unlock(&vmci_dev.lock);
- return errcode;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_close --
- *
- * Close device.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static int
-vmci_close(struct inode *inode, // IN
- struct file *file) // IN
-{
- VMCIObj *devHndl = (VMCIObj *)file->private_data;
-
- if (devHndl) {
- VMCI_FreeKernelMem(devHndl, sizeof *devHndl);
- file->private_data = NULL;
- }
- return 0;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_ioctl --
- *
- * IOCTL interface to device.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static long
-vmci_ioctl(struct file *file, // IN
- unsigned int cmd, // IN
- unsigned long arg) // IN
-{
- return -ENOTTY;
-}
-
-
-#if !defined(HAVE_UNLOCKED_IOCTL)
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_legacy_ioctl --
- *
- * IOCTL interface for kernels that do not have unlocked_ioctl.
- *
- * Results:
- * Negative error code, or per-ioctl result.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static int
-vmci_legacy_ioctl(struct inode *inode, // IN: unused
- struct file *filp, // IN:
- u_int iocmd, // IN:
- unsigned long ioarg) // IN:
-{
- return vmci_ioctl(filp, iocmd, ioarg);
-}
-#endif
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_poll --
- *
- * vmci poll function
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-static unsigned int
-vmci_poll(struct file *file, // IN
- poll_table *wait) // IN
-{
- return 0;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_interrupt --
- *
- * Interrupt handler for legacy or MSI interrupt, or for first MSI-X
- * interrupt (vector VMCI_INTR_DATAGRAM).
- *
- * Results:
- * COMPAT_IRQ_HANDLED if the interrupt is handled, COMPAT_IRQ_NONE if
- * not an interrupt.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
-static compat_irqreturn_t
-vmci_interrupt(int irq, // IN
- void *clientdata, // IN
- struct pt_regs *regs) // IN
-#else
-static compat_irqreturn_t
-vmci_interrupt(int irq, // IN
- void *clientdata) // IN
-#endif
-{
- vmci_device *dev = clientdata;
-
- if (dev == NULL) {
- printk(KERN_DEBUG "vmci_interrupt(): irq %d for unknown device.\n", irq);
- return COMPAT_IRQ_NONE;
- }
-
- /*
- * If we are using MSI-X with exclusive vectors then we simply schedule
- * the datagram tasklet, since we know the interrupt was meant for us.
- * Otherwise we must read the ICR to determine what to do.
- */
-
- if (dev->intr_type == VMCI_INTR_TYPE_MSIX && dev->exclusive_vectors) {
- tasklet_schedule(&vmci_dg_tasklet);
- } else {
- unsigned int icr;
-
- ASSERT(dev->intr_type == VMCI_INTR_TYPE_INTX ||
- dev->intr_type == VMCI_INTR_TYPE_MSI);
-
- /* Acknowledge interrupt and determine what needs doing. */
- icr = inl(dev->ioaddr + VMCI_ICR_ADDR);
- if (icr == 0 || icr == 0xffffffff) {
- return COMPAT_IRQ_NONE;
- }
-
- if (icr & VMCI_ICR_DATAGRAM) {
- tasklet_schedule(&vmci_dg_tasklet);
- icr &= ~VMCI_ICR_DATAGRAM;
- }
- if (icr & VMCI_ICR_NOTIFICATION) {
- tasklet_schedule(&vmci_bm_tasklet);
- icr &= ~VMCI_ICR_NOTIFICATION;
- }
- if (icr != 0) {
- printk(KERN_INFO LGPFX"Ignoring unknown interrupt cause (%d).\n", icr);
- }
- }
-
- return COMPAT_IRQ_HANDLED;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * vmci_interrupt_bm --
- *
- * Interrupt handler for MSI-X interrupt vector VMCI_INTR_NOTIFICATION,
- * which is for the notification bitmap. Will only get called if we are
- * using MSI-X with exclusive vectors.
- *
- * Results:
- * COMPAT_IRQ_HANDLED if the interrupt is handled, COMPAT_IRQ_NONE if
- * not an interrupt.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
-static compat_irqreturn_t
-vmci_interrupt_bm(int irq, // IN
- void *clientdata, // IN
- struct pt_regs *regs) // IN
-#else
-static compat_irqreturn_t
-vmci_interrupt_bm(int irq, // IN
- void *clientdata) // IN
-#endif
-{
- vmci_device *dev = clientdata;
-
- if (dev == NULL) {
- printk(KERN_DEBUG "vmci_interrupt_bm(): irq %d for unknown device.\n", irq);
- return COMPAT_IRQ_NONE;
- }
-
- /* For MSI-X we can just assume it was meant for us. */
- ASSERT(dev->intr_type == VMCI_INTR_TYPE_MSIX && dev->exclusive_vectors);
- tasklet_schedule(&vmci_bm_tasklet);
-
- return COMPAT_IRQ_HANDLED;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * VMCI_DeviceEnabled --
- *
- * Checks whether the VMCI device is enabled.
- *
- * Results:
- * TRUE if device is enabled, FALSE otherwise.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-Bool
-VMCI_DeviceEnabled(void)
-{
- Bool retval;
-
- compat_mutex_lock(&vmci_dev.lock);
- retval = vmci_dev.enabled;
- compat_mutex_unlock(&vmci_dev.lock);
-
- return retval;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * VMCI_SendDatagram --
- *
- * VM to hypervisor call mechanism. We use the standard VMware naming
- * convention since shared code is calling this function as well.
- *
- * Results:
- * The result of the hypercall.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-int
-VMCI_SendDatagram(VMCIDatagram *dg)
-{
- unsigned long flags;
- int result;
-
- /* Check args. */
- if (dg == NULL) {
- return VMCI_ERROR_INVALID_ARGS;
- }
-
- /*
- * Need to acquire spinlock on the device because
- * the datagram data may be spread over multiple pages and the monitor may
- * interleave device user rpc calls from multiple VCPUs. Acquiring the
- * spinlock precludes that possibility. Disabling interrupts to avoid
- * incoming datagrams during a "rep out" and possibly landing up in this
- * function.
- */
- spin_lock_irqsave(&vmci_dev.dev_spinlock, flags);
-
- /*
- * Send the datagram and retrieve the return value from the result register.
- */
- __asm__ __volatile__(
- "cld\n\t"
- "rep outsb\n\t"
- : /* No output. */
- : "d"(vmci_dev.ioaddr + VMCI_DATA_OUT_ADDR),
- "c"(VMCI_DG_SIZE(dg)), "S"(dg)
- );
-
- /*
- * XXX Should read result high port as well when updating handlers to
- * return 64bit.
- */
- result = inl(vmci_dev.ioaddr + VMCI_RESULT_LOW_ADDR);
- spin_unlock_irqrestore(&vmci_dev.dev_spinlock, flags);
-
- return result;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * dispatch_datagrams --
- *
- * Reads and dispatches incoming datagrams.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Reads data from the device.
- *
- *-----------------------------------------------------------------------------
- */
-
-void
-dispatch_datagrams(unsigned long data)
-{
- vmci_device *dev = (vmci_device *)data;
-
- if (dev == NULL) {
- printk(KERN_DEBUG "vmci: dispatch_datagrams(): no vmci device"
- "present.\n");
- return;
- }
-
- if (data_buffer == NULL) {
- printk(KERN_DEBUG "vmci: dispatch_datagrams(): no buffer present.\n");
- return;
- }
-
-
- VMCI_ReadDatagramsFromPort((VMCIIoHandle) 0, dev->ioaddr + VMCI_DATA_IN_ADDR,
- data_buffer, data_buffer_size);
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *
- * process_bitmap --
- *
- * Scans the notification bitmap for raised flags, clears them
- * and handles the notifications.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *-----------------------------------------------------------------------------
- */
-
-void
-process_bitmap(unsigned long data)
-{
- vmci_device *dev = (vmci_device *)data;
-
- if (dev == NULL) {
- printk(KERN_DEBUG "vmci: process_bitmaps(): no vmci device"
- "present.\n");
- return;
- }
-
- if (notification_bitmap == NULL) {
- printk(KERN_DEBUG "vmci: process_bitmaps(): no bitmap present.\n");
- return;
- }
-
-
- VMCI_ScanNotificationBitmap(notification_bitmap);
-}
-
-
-/*
- *------------------------------------------------------------------------------
- *
- * VMCIUnsetNotify --
- *
- * Stub. Not called in the guest driver (yet).
- *
- * Result:
- * Always VMCI_ERROR_GENERIC.
- *
- *------------------------------------------------------------------------------
- */
-
-void
-VMCIUnsetNotify(VMCIContext *context)
-{
-}
-
-
-module_init(vmci_init);
-module_exit(vmci_exit);
-MODULE_DEVICE_TABLE(pci, vmci_ids);
-
-module_param_named(disable_msi, vmci_disable_msi, bool, 0);
-MODULE_PARM_DESC(disable_msi, "Disable MSI use in driver - (default=0)");
-
-module_param_named(disable_msix, vmci_disable_msix, bool, 0);
-MODULE_PARM_DESC(disable_msix, "Disable MSI-X use in driver - (default="
- __stringify(VMCI_DISABLE_MSIX) ")");
-
-/* Module information. */
-MODULE_AUTHOR("VMware, Inc.");
-MODULE_DESCRIPTION("VMware Virtual Machine Communication Interface");
-MODULE_VERSION(VMCI_DRIVER_VERSION_STRING);
-MODULE_LICENSE("GPL v2");
-/*
- * Starting with SLE10sp2, Novell requires that IHVs sign a support agreement
- * with them and mark their kernel modules as externally supported via a
- * change to the module header. If this isn't done, the module will not load
- * by default (i.e., neither mkinitrd nor modprobe will accept it).
- */
-MODULE_INFO(supported, "external");
projects / thirdparty / open-vm-tools.git / commitdiff
