cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

virtio_pci_common.h (4226B)

      1/* SPDX-License-Identifier: GPL-2.0-or-later */
      2#ifndef _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H
      3#define _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H
      4/*
      5 * Virtio PCI driver - APIs for common functionality for all device versions
      6 *
      7 * This module allows virtio devices to be used over a virtual PCI device.
      8 * This can be used with QEMU based VMMs like KVM or Xen.
      9 *
     10 * Copyright IBM Corp. 2007
     11 * Copyright Red Hat, Inc. 2014
     12 *
     13 * Authors:
     14 *  Anthony Liguori  <aliguori@us.ibm.com>
     15 *  Rusty Russell <rusty@rustcorp.com.au>
     16 *  Michael S. Tsirkin <mst@redhat.com>
     17 */
     18
     19#include <linux/module.h>
     20#include <linux/list.h>
     21#include <linux/pci.h>
     22#include <linux/slab.h>
     23#include <linux/interrupt.h>
     24#include <linux/virtio.h>
     25#include <linux/virtio_config.h>
     26#include <linux/virtio_ring.h>
     27#include <linux/virtio_pci.h>
     28#include <linux/virtio_pci_legacy.h>
     29#include <linux/virtio_pci_modern.h>
     30#include <linux/highmem.h>
     31#include <linux/spinlock.h>
     32
     33struct virtio_pci_vq_info {
     34	/* the actual virtqueue */
     35	struct virtqueue *vq;
     36
     37	/* the list node for the virtqueues list */
     38	struct list_head node;
     39
     40	/* MSI-X vector (or none) */
     41	unsigned int msix_vector;
     42};
     43
     44/* Our device structure */
     45struct virtio_pci_device {
     46	struct virtio_device vdev;
     47	struct pci_dev *pci_dev;
     48	struct virtio_pci_legacy_device ldev;
     49	struct virtio_pci_modern_device mdev;
     50
     51	bool is_legacy;
     52
     53	/* Where to read and clear interrupt */
     54	u8 __iomem *isr;
     55
     56	/* a list of queues so we can dispatch IRQs */
     57	spinlock_t lock;
     58	struct list_head virtqueues;
     59
     60	/* array of all queues for house-keeping */
     61	struct virtio_pci_vq_info **vqs;
     62
     63	/* MSI-X support */
     64	int msix_enabled;
     65	int intx_enabled;
     66	cpumask_var_t *msix_affinity_masks;
     67	/* Name strings for interrupts. This size should be enough,
     68	 * and I'm too lazy to allocate each name separately. */
     69	char (*msix_names)[256];
     70	/* Number of available vectors */
     71	unsigned int msix_vectors;
     72	/* Vectors allocated, excluding per-vq vectors if any */
     73	unsigned int msix_used_vectors;
     74
     75	/* Whether we have vector per vq */
     76	bool per_vq_vectors;
     77
     78	struct virtqueue *(*setup_vq)(struct virtio_pci_device *vp_dev,
     79				      struct virtio_pci_vq_info *info,
     80				      unsigned int idx,
     81				      void (*callback)(struct virtqueue *vq),
     82				      const char *name,
     83				      bool ctx,
     84				      u16 msix_vec);
     85	void (*del_vq)(struct virtio_pci_vq_info *info);
     86
     87	u16 (*config_vector)(struct virtio_pci_device *vp_dev, u16 vector);
     88};
     89
     90/* Constants for MSI-X */
     91/* Use first vector for configuration changes, second and the rest for
     92 * virtqueues Thus, we need at least 2 vectors for MSI. */
     93enum {
     94	VP_MSIX_CONFIG_VECTOR = 0,
     95	VP_MSIX_VQ_VECTOR = 1,
     96};
     97
     98/* Convert a generic virtio device to our structure */
     99static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev)
    100{
    101	return container_of(vdev, struct virtio_pci_device, vdev);
    102}
    103
    104/* wait for pending irq handlers */
    105void vp_synchronize_vectors(struct virtio_device *vdev);
    106/* the notify function used when creating a virt queue */
    107bool vp_notify(struct virtqueue *vq);
    108/* the config->del_vqs() implementation */
    109void vp_del_vqs(struct virtio_device *vdev);
    110/* the config->find_vqs() implementation */
    111int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
    112		struct virtqueue *vqs[], vq_callback_t *callbacks[],
    113		const char * const names[], const bool *ctx,
    114		struct irq_affinity *desc);
    115const char *vp_bus_name(struct virtio_device *vdev);
    116
    117/* Setup the affinity for a virtqueue:
    118 * - force the affinity for per vq vector
    119 * - OR over all affinities for shared MSI
    120 * - ignore the affinity request if we're using INTX
    121 */
    122int vp_set_vq_affinity(struct virtqueue *vq, const struct cpumask *cpu_mask);
    123
    124const struct cpumask *vp_get_vq_affinity(struct virtio_device *vdev, int index);
    125
    126#if IS_ENABLED(CONFIG_VIRTIO_PCI_LEGACY)
    127int virtio_pci_legacy_probe(struct virtio_pci_device *);
    128void virtio_pci_legacy_remove(struct virtio_pci_device *);
    129#else
    130static inline int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev)
    131{
    132	return -ENODEV;
    133}
    134static inline void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev)
    135{
    136}
    137#endif
    138int virtio_pci_modern_probe(struct virtio_pci_device *);
    139void virtio_pci_modern_remove(struct virtio_pci_device *);
    140
    141#endif