linux/drivers/misc/vmw_vmci/vmci_guest.c
<<
>>
Prefs
   1/*
   2 * VMware VMCI Driver
   3 *
   4 * Copyright (C) 2012 VMware, Inc. All rights reserved.
   5 *
   6 * This program is free software; you can redistribute it and/or modify it
   7 * under the terms of the GNU General Public License as published by the
   8 * Free Software Foundation version 2 and no later version.
   9 *
  10 * This program is distributed in the hope that it will be useful, but
  11 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 * for more details.
  14 */
  15
  16#include <linux/vmw_vmci_defs.h>
  17#include <linux/vmw_vmci_api.h>
  18#include <linux/moduleparam.h>
  19#include <linux/interrupt.h>
  20#include <linux/highmem.h>
  21#include <linux/kernel.h>
  22#include <linux/mm.h>
  23#include <linux/module.h>
  24#include <linux/sched.h>
  25#include <linux/slab.h>
  26#include <linux/init.h>
  27#include <linux/pci.h>
  28#include <linux/smp.h>
  29#include <linux/io.h>
  30#include <linux/vmalloc.h>
  31
  32#include "vmci_datagram.h"
  33#include "vmci_doorbell.h"
  34#include "vmci_context.h"
  35#include "vmci_driver.h"
  36#include "vmci_event.h"
  37
  38#define PCI_DEVICE_ID_VMWARE_VMCI       0x0740
  39
  40#define VMCI_UTIL_NUM_RESOURCES 1
  41
  42static bool vmci_disable_msi;
  43module_param_named(disable_msi, vmci_disable_msi, bool, 0);
  44MODULE_PARM_DESC(disable_msi, "Disable MSI use in driver - (default=0)");
  45
  46static bool vmci_disable_msix;
  47module_param_named(disable_msix, vmci_disable_msix, bool, 0);
  48MODULE_PARM_DESC(disable_msix, "Disable MSI-X use in driver - (default=0)");
  49
  50static u32 ctx_update_sub_id = VMCI_INVALID_ID;
  51static u32 vm_context_id = VMCI_INVALID_ID;
  52
  53struct vmci_guest_device {
  54        struct device *dev;     /* PCI device we are attached to */
  55        void __iomem *iobase;
  56
  57        unsigned int irq;
  58        unsigned int intr_type;
  59        bool exclusive_vectors;
  60        struct msix_entry msix_entries[VMCI_MAX_INTRS];
  61
  62        struct tasklet_struct datagram_tasklet;
  63        struct tasklet_struct bm_tasklet;
  64
  65        void *data_buffer;
  66        void *notification_bitmap;
  67        dma_addr_t notification_base;
  68};
  69
  70/* vmci_dev singleton device and supporting data*/
  71struct pci_dev *vmci_pdev;
  72static struct vmci_guest_device *vmci_dev_g;
  73static DEFINE_SPINLOCK(vmci_dev_spinlock);
  74
  75static atomic_t vmci_num_guest_devices = ATOMIC_INIT(0);
  76
  77bool vmci_guest_code_active(void)
  78{
  79        return atomic_read(&vmci_num_guest_devices) != 0;
  80}
  81
  82u32 vmci_get_vm_context_id(void)
  83{
  84        if (vm_context_id == VMCI_INVALID_ID) {
  85                struct vmci_datagram get_cid_msg;
  86                get_cid_msg.dst =
  87                    vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,
  88                                     VMCI_GET_CONTEXT_ID);
  89                get_cid_msg.src = VMCI_ANON_SRC_HANDLE;
  90                get_cid_msg.payload_size = 0;
  91                vm_context_id = vmci_send_datagram(&get_cid_msg);
  92        }
  93        return vm_context_id;
  94}
  95
  96/*
  97 * VM to hypervisor call mechanism. We use the standard VMware naming
  98 * convention since shared code is calling this function as well.
  99 */
 100int vmci_send_datagram(struct vmci_datagram *dg)
 101{
 102        unsigned long flags;
 103        int result;
 104
 105        /* Check args. */
 106        if (dg == NULL)
 107                return VMCI_ERROR_INVALID_ARGS;
 108
 109        /*
 110         * Need to acquire spinlock on the device because the datagram
 111         * data may be spread over multiple pages and the monitor may
 112         * interleave device user rpc calls from multiple
 113         * VCPUs. Acquiring the spinlock precludes that
 114         * possibility. Disabling interrupts to avoid incoming
 115         * datagrams during a "rep out" and possibly landing up in
 116         * this function.
 117         */
 118        spin_lock_irqsave(&vmci_dev_spinlock, flags);
 119
 120        if (vmci_dev_g) {
 121                iowrite8_rep(vmci_dev_g->iobase + VMCI_DATA_OUT_ADDR,
 122                             dg, VMCI_DG_SIZE(dg));
 123                result = ioread32(vmci_dev_g->iobase + VMCI_RESULT_LOW_ADDR);
 124        } else {
 125                result = VMCI_ERROR_UNAVAILABLE;
 126        }
 127
 128        spin_unlock_irqrestore(&vmci_dev_spinlock, flags);
 129
 130        return result;
 131}
 132EXPORT_SYMBOL_GPL(vmci_send_datagram);
 133
 134/*
 135 * Gets called with the new context id if updated or resumed.
 136 * Context id.
 137 */
 138static void vmci_guest_cid_update(u32 sub_id,
 139                                  const struct vmci_event_data *event_data,
 140                                  void *client_data)
 141{
 142        const struct vmci_event_payld_ctx *ev_payload =
 143                                vmci_event_data_const_payload(event_data);
 144
 145        if (sub_id != ctx_update_sub_id) {
 146                pr_devel("Invalid subscriber (ID=0x%x)\n", sub_id);
 147                return;
 148        }
 149
 150        if (!event_data || ev_payload->context_id == VMCI_INVALID_ID) {
 151                pr_devel("Invalid event data\n");
 152                return;
 153        }
 154
 155        pr_devel("Updating context from (ID=0x%x) to (ID=0x%x) on event (type=%d)\n",
 156                 vm_context_id, ev_payload->context_id, event_data->event);
 157
 158        vm_context_id = ev_payload->context_id;
 159}
 160
 161/*
 162 * Verify that the host supports the hypercalls we need. If it does not,
 163 * try to find fallback hypercalls and use those instead.  Returns
 164 * true if required hypercalls (or fallback hypercalls) are
 165 * supported by the host, false otherwise.
 166 */
 167static int vmci_check_host_caps(struct pci_dev *pdev)
 168{
 169        bool result;
 170        struct vmci_resource_query_msg *msg;
 171        u32 msg_size = sizeof(struct vmci_resource_query_hdr) +
 172                                VMCI_UTIL_NUM_RESOURCES * sizeof(u32);
 173        struct vmci_datagram *check_msg;
 174
 175        check_msg = kmalloc(msg_size, GFP_KERNEL);
 176        if (!check_msg) {
 177                dev_err(&pdev->dev, "%s: Insufficient memory\n", __func__);
 178                return -ENOMEM;
 179        }
 180
 181        check_msg->dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,
 182                                          VMCI_RESOURCES_QUERY);
 183        check_msg->src = VMCI_ANON_SRC_HANDLE;
 184        check_msg->payload_size = msg_size - VMCI_DG_HEADERSIZE;
 185        msg = (struct vmci_resource_query_msg *)VMCI_DG_PAYLOAD(check_msg);
 186
 187        msg->num_resources = VMCI_UTIL_NUM_RESOURCES;
 188        msg->resources[0] = VMCI_GET_CONTEXT_ID;
 189
 190        /* Checks that hyper calls are supported */
 191        result = vmci_send_datagram(check_msg) == 0x01;
 192        kfree(check_msg);
 193
 194        dev_dbg(&pdev->dev, "%s: Host capability check: %s\n",
 195                __func__, result ? "PASSED" : "FAILED");
 196
 197        /* We need the vector. There are no fallbacks. */
 198        return result ? 0 : -ENXIO;
 199}
 200
 201/*
 202 * Reads datagrams from the data in port and dispatches them. We
 203 * always start reading datagrams into only the first page of the
 204 * datagram buffer. If the datagrams don't fit into one page, we
 205 * use the maximum datagram buffer size for the remainder of the
 206 * invocation. This is a simple heuristic for not penalizing
 207 * small datagrams.
 208 *
 209 * This function assumes that it has exclusive access to the data
 210 * in port for the duration of the call.
 211 */
 212static void vmci_dispatch_dgs(unsigned long data)
 213{
 214        struct vmci_guest_device *vmci_dev = (struct vmci_guest_device *)data;
 215        u8 *dg_in_buffer = vmci_dev->data_buffer;
 216        struct vmci_datagram *dg;
 217        size_t dg_in_buffer_size = VMCI_MAX_DG_SIZE;
 218        size_t current_dg_in_buffer_size = PAGE_SIZE;
 219        size_t remaining_bytes;
 220
 221        BUILD_BUG_ON(VMCI_MAX_DG_SIZE < PAGE_SIZE);
 222
 223        ioread8_rep(vmci_dev->iobase + VMCI_DATA_IN_ADDR,
 224                    vmci_dev->data_buffer, current_dg_in_buffer_size);
 225        dg = (struct vmci_datagram *)dg_in_buffer;
 226        remaining_bytes = current_dg_in_buffer_size;
 227
 228        while (dg->dst.resource != VMCI_INVALID_ID ||
 229               remaining_bytes > PAGE_SIZE) {
 230                unsigned dg_in_size;
 231
 232                /*
 233                 * When the input buffer spans multiple pages, a datagram can
 234                 * start on any page boundary in the buffer.
 235                 */
 236                if (dg->dst.resource == VMCI_INVALID_ID) {
 237                        dg = (struct vmci_datagram *)roundup(
 238                                (uintptr_t)dg + 1, PAGE_SIZE);
 239                        remaining_bytes =
 240                                (size_t)(dg_in_buffer +
 241                                         current_dg_in_buffer_size -
 242                                         (u8 *)dg);
 243                        continue;
 244                }
 245
 246                dg_in_size = VMCI_DG_SIZE_ALIGNED(dg);
 247
 248                if (dg_in_size <= dg_in_buffer_size) {
 249                        int result;
 250
 251                        /*
 252                         * If the remaining bytes in the datagram
 253                         * buffer doesn't contain the complete
 254                         * datagram, we first make sure we have enough
 255                         * room for it and then we read the reminder
 256                         * of the datagram and possibly any following
 257                         * datagrams.
 258                         */
 259                        if (dg_in_size > remaining_bytes) {
 260                                if (remaining_bytes !=
 261                                    current_dg_in_buffer_size) {
 262
 263                                        /*
 264                                         * We move the partial
 265                                         * datagram to the front and
 266                                         * read the reminder of the
 267                                         * datagram and possibly
 268                                         * following calls into the
 269                                         * following bytes.
 270                                         */
 271                                        memmove(dg_in_buffer, dg_in_buffer +
 272                                                current_dg_in_buffer_size -
 273                                                remaining_bytes,
 274                                                remaining_bytes);
 275                                        dg = (struct vmci_datagram *)
 276                                            dg_in_buffer;
 277                                }
 278
 279                                if (current_dg_in_buffer_size !=
 280                                    dg_in_buffer_size)
 281                                        current_dg_in_buffer_size =
 282                                            dg_in_buffer_size;
 283
 284                                ioread8_rep(vmci_dev->iobase +
 285                                                VMCI_DATA_IN_ADDR,
 286                                        vmci_dev->data_buffer +
 287                                                remaining_bytes,
 288                                        current_dg_in_buffer_size -
 289                                                remaining_bytes);
 290                        }
 291
 292                        /*
 293                         * We special case event datagrams from the
 294                         * hypervisor.
 295                         */
 296                        if (dg->src.context == VMCI_HYPERVISOR_CONTEXT_ID &&
 297                            dg->dst.resource == VMCI_EVENT_HANDLER) {
 298                                result = vmci_event_dispatch(dg);
 299                        } else {
 300                                result = vmci_datagram_invoke_guest_handler(dg);
 301                        }
 302                        if (result < VMCI_SUCCESS)
 303                                dev_dbg(vmci_dev->dev,
 304                                        "Datagram with resource (ID=0x%x) failed (err=%d)\n",
 305                                         dg->dst.resource, result);
 306
 307                        /* On to the next datagram. */
 308                        dg = (struct vmci_datagram *)((u8 *)dg +
 309                                                      dg_in_size);
 310                } else {
 311                        size_t bytes_to_skip;
 312
 313                        /*
 314                         * Datagram doesn't fit in datagram buffer of maximal
 315                         * size. We drop it.
 316                         */
 317                        dev_dbg(vmci_dev->dev,
 318                                "Failed to receive datagram (size=%u bytes)\n",
 319                                 dg_in_size);
 320
 321                        bytes_to_skip = dg_in_size - remaining_bytes;
 322                        if (current_dg_in_buffer_size != dg_in_buffer_size)
 323                                current_dg_in_buffer_size = dg_in_buffer_size;
 324
 325                        for (;;) {
 326                                ioread8_rep(vmci_dev->iobase +
 327                                                VMCI_DATA_IN_ADDR,
 328                                        vmci_dev->data_buffer,
 329                                        current_dg_in_buffer_size);
 330                                if (bytes_to_skip <= current_dg_in_buffer_size)
 331                                        break;
 332
 333                                bytes_to_skip -= current_dg_in_buffer_size;
 334                        }
 335                        dg = (struct vmci_datagram *)(dg_in_buffer +
 336                                                      bytes_to_skip);
 337                }
 338
 339                remaining_bytes =
 340                    (size_t) (dg_in_buffer + current_dg_in_buffer_size -
 341                              (u8 *)dg);
 342
 343                if (remaining_bytes < VMCI_DG_HEADERSIZE) {
 344                        /* Get the next batch of datagrams. */
 345
 346                        ioread8_rep(vmci_dev->iobase + VMCI_DATA_IN_ADDR,
 347                                    vmci_dev->data_buffer,
 348                                    current_dg_in_buffer_size);
 349                        dg = (struct vmci_datagram *)dg_in_buffer;
 350                        remaining_bytes = current_dg_in_buffer_size;
 351                }
 352        }
 353}
 354
 355/*
 356 * Scans the notification bitmap for raised flags, clears them
 357 * and handles the notifications.
 358 */
 359static void vmci_process_bitmap(unsigned long data)
 360{
 361        struct vmci_guest_device *dev = (struct vmci_guest_device *)data;
 362
 363        if (!dev->notification_bitmap) {
 364                dev_dbg(dev->dev, "No bitmap present in %s\n", __func__);
 365                return;
 366        }
 367
 368        vmci_dbell_scan_notification_entries(dev->notification_bitmap);
 369}
 370
 371/*
 372 * Enable MSI-X.  Try exclusive vectors first, then shared vectors.
 373 */
 374static int vmci_enable_msix(struct pci_dev *pdev,
 375                            struct vmci_guest_device *vmci_dev)
 376{
 377        int i;
 378        int result;
 379
 380        for (i = 0; i < VMCI_MAX_INTRS; ++i) {
 381                vmci_dev->msix_entries[i].entry = i;
 382                vmci_dev->msix_entries[i].vector = i;
 383        }
 384
 385        result = pci_enable_msix_exact(pdev,
 386                                       vmci_dev->msix_entries, VMCI_MAX_INTRS);
 387        if (result == 0)
 388                vmci_dev->exclusive_vectors = true;
 389        else if (result == -ENOSPC)
 390                result = pci_enable_msix_exact(pdev, vmci_dev->msix_entries, 1);
 391
 392        return result;
 393}
 394
 395/*
 396 * Interrupt handler for legacy or MSI interrupt, or for first MSI-X
 397 * interrupt (vector VMCI_INTR_DATAGRAM).
 398 */
 399static irqreturn_t vmci_interrupt(int irq, void *_dev)
 400{
 401        struct vmci_guest_device *dev = _dev;
 402
 403        /*
 404         * If we are using MSI-X with exclusive vectors then we simply schedule
 405         * the datagram tasklet, since we know the interrupt was meant for us.
 406         * Otherwise we must read the ICR to determine what to do.
 407         */
 408
 409        if (dev->intr_type == VMCI_INTR_TYPE_MSIX && dev->exclusive_vectors) {
 410                tasklet_schedule(&dev->datagram_tasklet);
 411        } else {
 412                unsigned int icr;
 413
 414                /* Acknowledge interrupt and determine what needs doing. */
 415                icr = ioread32(dev->iobase + VMCI_ICR_ADDR);
 416                if (icr == 0 || icr == ~0)
 417                        return IRQ_NONE;
 418
 419                if (icr & VMCI_ICR_DATAGRAM) {
 420                        tasklet_schedule(&dev->datagram_tasklet);
 421                        icr &= ~VMCI_ICR_DATAGRAM;
 422                }
 423
 424                if (icr & VMCI_ICR_NOTIFICATION) {
 425                        tasklet_schedule(&dev->bm_tasklet);
 426                        icr &= ~VMCI_ICR_NOTIFICATION;
 427                }
 428
 429                if (icr != 0)
 430                        dev_warn(dev->dev,
 431                                 "Ignoring unknown interrupt cause (%d)\n",
 432                                 icr);
 433        }
 434
 435        return IRQ_HANDLED;
 436}
 437
 438/*
 439 * Interrupt handler for MSI-X interrupt vector VMCI_INTR_NOTIFICATION,
 440 * which is for the notification bitmap.  Will only get called if we are
 441 * using MSI-X with exclusive vectors.
 442 */
 443static irqreturn_t vmci_interrupt_bm(int irq, void *_dev)
 444{
 445        struct vmci_guest_device *dev = _dev;
 446
 447        /* For MSI-X we can just assume it was meant for us. */
 448        tasklet_schedule(&dev->bm_tasklet);
 449
 450        return IRQ_HANDLED;
 451}
 452
 453/*
 454 * Most of the initialization at module load time is done here.
 455 */
 456static int vmci_guest_probe_device(struct pci_dev *pdev,
 457                                   const struct pci_device_id *id)
 458{
 459        struct vmci_guest_device *vmci_dev;
 460        void __iomem *iobase;
 461        unsigned int capabilities;
 462        unsigned long cmd;
 463        int vmci_err;
 464        int error;
 465
 466        dev_dbg(&pdev->dev, "Probing for vmci/PCI guest device\n");
 467
 468        error = pcim_enable_device(pdev);
 469        if (error) {
 470                dev_err(&pdev->dev,
 471                        "Failed to enable VMCI device: %d\n", error);
 472                return error;
 473        }
 474
 475        error = pcim_iomap_regions(pdev, 1 << 0, KBUILD_MODNAME);
 476        if (error) {
 477                dev_err(&pdev->dev, "Failed to reserve/map IO regions\n");
 478                return error;
 479        }
 480
 481        iobase = pcim_iomap_table(pdev)[0];
 482
 483        dev_info(&pdev->dev, "Found VMCI PCI device at %#lx, irq %u\n",
 484                 (unsigned long)iobase, pdev->irq);
 485
 486        vmci_dev = devm_kzalloc(&pdev->dev, sizeof(*vmci_dev), GFP_KERNEL);
 487        if (!vmci_dev) {
 488                dev_err(&pdev->dev,
 489                        "Can't allocate memory for VMCI device\n");
 490                return -ENOMEM;
 491        }
 492
 493        vmci_dev->dev = &pdev->dev;
 494        vmci_dev->intr_type = VMCI_INTR_TYPE_INTX;
 495        vmci_dev->exclusive_vectors = false;
 496        vmci_dev->iobase = iobase;
 497
 498        tasklet_init(&vmci_dev->datagram_tasklet,
 499                     vmci_dispatch_dgs, (unsigned long)vmci_dev);
 500        tasklet_init(&vmci_dev->bm_tasklet,
 501                     vmci_process_bitmap, (unsigned long)vmci_dev);
 502
 503        vmci_dev->data_buffer = vmalloc(VMCI_MAX_DG_SIZE);
 504        if (!vmci_dev->data_buffer) {
 505                dev_err(&pdev->dev,
 506                        "Can't allocate memory for datagram buffer\n");
 507                return -ENOMEM;
 508        }
 509
 510        pci_set_master(pdev);   /* To enable queue_pair functionality. */
 511
 512        /*
 513         * Verify that the VMCI Device supports the capabilities that
 514         * we need. If the device is missing capabilities that we would
 515         * like to use, check for fallback capabilities and use those
 516         * instead (so we can run a new VM on old hosts). Fail the load if
 517         * a required capability is missing and there is no fallback.
 518         *
 519         * Right now, we need datagrams. There are no fallbacks.
 520         */
 521        capabilities = ioread32(vmci_dev->iobase + VMCI_CAPS_ADDR);
 522        if (!(capabilities & VMCI_CAPS_DATAGRAM)) {
 523                dev_err(&pdev->dev, "Device does not support datagrams\n");
 524                error = -ENXIO;
 525                goto err_free_data_buffer;
 526        }
 527
 528        /*
 529         * If the hardware supports notifications, we will use that as
 530         * well.
 531         */
 532        if (capabilities & VMCI_CAPS_NOTIFICATIONS) {
 533                vmci_dev->notification_bitmap = dma_alloc_coherent(
 534                        &pdev->dev, PAGE_SIZE, &vmci_dev->notification_base,
 535                        GFP_KERNEL);
 536                if (!vmci_dev->notification_bitmap) {
 537                        dev_warn(&pdev->dev,
 538                                 "Unable to allocate notification bitmap\n");
 539                } else {
 540                        memset(vmci_dev->notification_bitmap, 0, PAGE_SIZE);
 541                        capabilities |= VMCI_CAPS_NOTIFICATIONS;
 542                }
 543        }
 544
 545        dev_info(&pdev->dev, "Using capabilities 0x%x\n", capabilities);
 546
 547        /* Let the host know which capabilities we intend to use. */
 548        iowrite32(capabilities, vmci_dev->iobase + VMCI_CAPS_ADDR);
 549
 550        /* Set up global device so that we can start sending datagrams */
 551        spin_lock_irq(&vmci_dev_spinlock);
 552        vmci_dev_g = vmci_dev;
 553        vmci_pdev = pdev;
 554        spin_unlock_irq(&vmci_dev_spinlock);
 555
 556        /*
 557         * Register notification bitmap with device if that capability is
 558         * used.
 559         */
 560        if (capabilities & VMCI_CAPS_NOTIFICATIONS) {
 561                unsigned long bitmap_ppn =
 562                        vmci_dev->notification_base >> PAGE_SHIFT;
 563                if (!vmci_dbell_register_notification_bitmap(bitmap_ppn)) {
 564                        dev_warn(&pdev->dev,
 565                                 "VMCI device unable to register notification bitmap with PPN 0x%x\n",
 566                                 (u32) bitmap_ppn);
 567                        error = -ENXIO;
 568                        goto err_remove_vmci_dev_g;
 569                }
 570        }
 571
 572        /* Check host capabilities. */
 573        error = vmci_check_host_caps(pdev);
 574        if (error)
 575                goto err_remove_bitmap;
 576
 577        /* Enable device. */
 578
 579        /*
 580         * We subscribe to the VMCI_EVENT_CTX_ID_UPDATE here so we can
 581         * update the internal context id when needed.
 582         */
 583        vmci_err = vmci_event_subscribe(VMCI_EVENT_CTX_ID_UPDATE,
 584                                        vmci_guest_cid_update, NULL,
 585                                        &ctx_update_sub_id);
 586        if (vmci_err < VMCI_SUCCESS)
 587                dev_warn(&pdev->dev,
 588                         "Failed to subscribe to event (type=%d): %d\n",
 589                         VMCI_EVENT_CTX_ID_UPDATE, vmci_err);
 590
 591        /*
 592         * Enable interrupts.  Try MSI-X first, then MSI, and then fallback on
 593         * legacy interrupts.
 594         */
 595        if (!vmci_disable_msix && !vmci_enable_msix(pdev, vmci_dev)) {
 596                vmci_dev->intr_type = VMCI_INTR_TYPE_MSIX;
 597                vmci_dev->irq = vmci_dev->msix_entries[0].vector;
 598        } else if (!vmci_disable_msi && !pci_enable_msi(pdev)) {
 599                vmci_dev->intr_type = VMCI_INTR_TYPE_MSI;
 600                vmci_dev->irq = pdev->irq;
 601        } else {
 602                vmci_dev->intr_type = VMCI_INTR_TYPE_INTX;
 603                vmci_dev->irq = pdev->irq;
 604        }
 605
 606        /*
 607         * Request IRQ for legacy or MSI interrupts, or for first
 608         * MSI-X vector.
 609         */
 610        error = request_irq(vmci_dev->irq, vmci_interrupt, IRQF_SHARED,
 611                            KBUILD_MODNAME, vmci_dev);
 612        if (error) {
 613                dev_err(&pdev->dev, "Irq %u in use: %d\n",
 614                        vmci_dev->irq, error);
 615                goto err_disable_msi;
 616        }
 617
 618        /*
 619         * For MSI-X with exclusive vectors we need to request an
 620         * interrupt for each vector so that we get a separate
 621         * interrupt handler routine.  This allows us to distinguish
 622         * between the vectors.
 623         */
 624        if (vmci_dev->exclusive_vectors) {
 625                error = request_irq(vmci_dev->msix_entries[1].vector,
 626                                    vmci_interrupt_bm, 0, KBUILD_MODNAME,
 627                                    vmci_dev);
 628                if (error) {
 629                        dev_err(&pdev->dev,
 630                                "Failed to allocate irq %u: %d\n",
 631                                vmci_dev->msix_entries[1].vector, error);
 632                        goto err_free_irq;
 633                }
 634        }
 635
 636        dev_dbg(&pdev->dev, "Registered device\n");
 637
 638        atomic_inc(&vmci_num_guest_devices);
 639
 640        /* Enable specific interrupt bits. */
 641        cmd = VMCI_IMR_DATAGRAM;
 642        if (capabilities & VMCI_CAPS_NOTIFICATIONS)
 643                cmd |= VMCI_IMR_NOTIFICATION;
 644        iowrite32(cmd, vmci_dev->iobase + VMCI_IMR_ADDR);
 645
 646        /* Enable interrupts. */
 647        iowrite32(VMCI_CONTROL_INT_ENABLE,
 648                  vmci_dev->iobase + VMCI_CONTROL_ADDR);
 649
 650        pci_set_drvdata(pdev, vmci_dev);
 651        return 0;
 652
 653err_free_irq:
 654        free_irq(vmci_dev->irq, vmci_dev);
 655        tasklet_kill(&vmci_dev->datagram_tasklet);
 656        tasklet_kill(&vmci_dev->bm_tasklet);
 657
 658err_disable_msi:
 659        if (vmci_dev->intr_type == VMCI_INTR_TYPE_MSIX)
 660                pci_disable_msix(pdev);
 661        else if (vmci_dev->intr_type == VMCI_INTR_TYPE_MSI)
 662                pci_disable_msi(pdev);
 663
 664        vmci_err = vmci_event_unsubscribe(ctx_update_sub_id);
 665        if (vmci_err < VMCI_SUCCESS)
 666                dev_warn(&pdev->dev,
 667                         "Failed to unsubscribe from event (type=%d) with subscriber (ID=0x%x): %d\n",
 668                         VMCI_EVENT_CTX_ID_UPDATE, ctx_update_sub_id, vmci_err);
 669
 670err_remove_bitmap:
 671        if (vmci_dev->notification_bitmap) {
 672                iowrite32(VMCI_CONTROL_RESET,
 673                          vmci_dev->iobase + VMCI_CONTROL_ADDR);
 674                dma_free_coherent(&pdev->dev, PAGE_SIZE,
 675                                  vmci_dev->notification_bitmap,
 676                                  vmci_dev->notification_base);
 677        }
 678
 679err_remove_vmci_dev_g:
 680        spin_lock_irq(&vmci_dev_spinlock);
 681        vmci_pdev = NULL;
 682        vmci_dev_g = NULL;
 683        spin_unlock_irq(&vmci_dev_spinlock);
 684
 685err_free_data_buffer:
 686        vfree(vmci_dev->data_buffer);
 687
 688        /* The rest are managed resources and will be freed by PCI core */
 689        return error;
 690}
 691
 692static void vmci_guest_remove_device(struct pci_dev *pdev)
 693{
 694        struct vmci_guest_device *vmci_dev = pci_get_drvdata(pdev);
 695        int vmci_err;
 696
 697        dev_dbg(&pdev->dev, "Removing device\n");
 698
 699        atomic_dec(&vmci_num_guest_devices);
 700
 701        vmci_qp_guest_endpoints_exit();
 702
 703        vmci_err = vmci_event_unsubscribe(ctx_update_sub_id);
 704        if (vmci_err < VMCI_SUCCESS)
 705                dev_warn(&pdev->dev,
 706                         "Failed to unsubscribe from event (type=%d) with subscriber (ID=0x%x): %d\n",
 707                         VMCI_EVENT_CTX_ID_UPDATE, ctx_update_sub_id, vmci_err);
 708
 709        spin_lock_irq(&vmci_dev_spinlock);
 710        vmci_dev_g = NULL;
 711        vmci_pdev = NULL;
 712        spin_unlock_irq(&vmci_dev_spinlock);
 713
 714        dev_dbg(&pdev->dev, "Resetting vmci device\n");
 715        iowrite32(VMCI_CONTROL_RESET, vmci_dev->iobase + VMCI_CONTROL_ADDR);
 716
 717        /*
 718         * Free IRQ and then disable MSI/MSI-X as appropriate.  For
 719         * MSI-X, we might have multiple vectors, each with their own
 720         * IRQ, which we must free too.
 721         */
 722        free_irq(vmci_dev->irq, vmci_dev);
 723        if (vmci_dev->intr_type == VMCI_INTR_TYPE_MSIX) {
 724                if (vmci_dev->exclusive_vectors)
 725                        free_irq(vmci_dev->msix_entries[1].vector, vmci_dev);
 726                pci_disable_msix(pdev);
 727        } else if (vmci_dev->intr_type == VMCI_INTR_TYPE_MSI) {
 728                pci_disable_msi(pdev);
 729        }
 730
 731        tasklet_kill(&vmci_dev->datagram_tasklet);
 732        tasklet_kill(&vmci_dev->bm_tasklet);
 733
 734        if (vmci_dev->notification_bitmap) {
 735                /*
 736                 * The device reset above cleared the bitmap state of the
 737                 * device, so we can safely free it here.
 738                 */
 739
 740                dma_free_coherent(&pdev->dev, PAGE_SIZE,
 741                                  vmci_dev->notification_bitmap,
 742                                  vmci_dev->notification_base);
 743        }
 744
 745        vfree(vmci_dev->data_buffer);
 746
 747        /* The rest are managed resources and will be freed by PCI core */
 748}
 749
 750static const struct pci_device_id vmci_ids[] = {
 751        { PCI_DEVICE(PCI_VENDOR_ID_VMWARE, PCI_DEVICE_ID_VMWARE_VMCI), },
 752        { 0 },
 753};
 754MODULE_DEVICE_TABLE(pci, vmci_ids);
 755
 756static struct pci_driver vmci_guest_driver = {
 757        .name           = KBUILD_MODNAME,
 758        .id_table       = vmci_ids,
 759        .probe          = vmci_guest_probe_device,
 760        .remove         = vmci_guest_remove_device,
 761};
 762
 763int __init vmci_guest_init(void)
 764{
 765        return pci_register_driver(&vmci_guest_driver);
 766}
 767
 768void __exit vmci_guest_exit(void)
 769{
 770        pci_unregister_driver(&vmci_guest_driver);
 771}
 772
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.