Commit fc996db9 authored by Linus Torvalds's avatar Linus Torvalds

Merge tag 'vfio-v5.10-rc1' of git://github.com/awilliam/linux-vfio

Pull VFIO updates from Alex Williamson:

 - New fsl-mc vfio bus driver supporting userspace drivers of objects
   within NXP's DPAA2 architecture (Diana Craciun)

 - Support for exposing zPCI information on s390 (Matthew Rosato)

 - Fixes for "detached" VFs on s390 (Matthew Rosato)

 - Fixes for pin-pages and dma-rw accesses (Yan Zhao)

 - Cleanups and optimize vconfig regen (Zenghui Yu)

 - Fix duplicate irq-bypass token registration (Alex Williamson)

* tag 'vfio-v5.10-rc1' of git://github.com/awilliam/linux-vfio: (30 commits)
  vfio iommu type1: Fix memory leak in vfio_iommu_type1_pin_pages
  vfio/pci: Clear token on bypass registration failure
  vfio/fsl-mc: fix the return of the uninitialized variable ret
  vfio/fsl-mc: Fix the dead code in vfio_fsl_mc_set_irq_trigger
  vfio/fsl-mc: Fixed vfio-fsl-mc driver compilation on 32 bit
  MAINTAINERS: Add entry for s390 vfio-pci
  vfio-pci/zdev: Add zPCI capabilities to VFIO_DEVICE_GET_INFO
  vfio/fsl-mc: Add support for device reset
  vfio/fsl-mc: Add read/write support for fsl-mc devices
  vfio/fsl-mc: trigger an interrupt via eventfd
  vfio/fsl-mc: Add irq infrastructure for fsl-mc devices
  vfio/fsl-mc: Added lock support in preparation for interrupt handling
  vfio/fsl-mc: Allow userspace to MMAP fsl-mc device MMIO regions
  vfio/fsl-mc: Implement VFIO_DEVICE_GET_REGION_INFO ioctl call
  vfio/fsl-mc: Implement VFIO_DEVICE_GET_INFO ioctl
  vfio/fsl-mc: Scan DPRC objects on vfio-fsl-mc driver bind
  vfio: Introduce capability definitions for VFIO_DEVICE_GET_INFO
  s390/pci: track whether util_str is valid in the zpci_dev
  s390/pci: stash version in the zpci_dev
  vfio/fsl-mc: Add VFIO framework skeleton for fsl-mc devices
  ...
parents 60573c29 2e6cfd49
...@@ -15287,6 +15287,14 @@ F: Documentation/s390/vfio-ccw.rst ...@@ -15287,6 +15287,14 @@ F: Documentation/s390/vfio-ccw.rst
F: drivers/s390/cio/vfio_ccw* F: drivers/s390/cio/vfio_ccw*
F: include/uapi/linux/vfio_ccw.h F: include/uapi/linux/vfio_ccw.h
S390 VFIO-PCI DRIVER
M: Matthew Rosato <mjrosato@linux.ibm.com>
L: linux-s390@vger.kernel.org
L: kvm@vger.kernel.org
S: Supported
F: drivers/vfio/pci/vfio_pci_zdev.c
F: include/uapi/linux/vfio_zdev.h
S390 ZCRYPT DRIVER S390 ZCRYPT DRIVER
M: Harald Freudenberger <freude@linux.ibm.com> M: Harald Freudenberger <freude@linux.ibm.com>
L: linux-s390@vger.kernel.org L: linux-s390@vger.kernel.org
...@@ -18385,6 +18393,12 @@ F: drivers/vfio/ ...@@ -18385,6 +18393,12 @@ F: drivers/vfio/
F: include/linux/vfio.h F: include/linux/vfio.h
F: include/uapi/linux/vfio.h F: include/uapi/linux/vfio.h
VFIO FSL-MC DRIVER
M: Diana Craciun <diana.craciun@oss.nxp.com>
L: kvm@vger.kernel.org
S: Maintained
F: drivers/vfio/fsl-mc/
VFIO MEDIATED DEVICE DRIVERS VFIO MEDIATED DEVICE DRIVERS
M: Kirti Wankhede <kwankhede@nvidia.com> M: Kirti Wankhede <kwankhede@nvidia.com>
L: kvm@vger.kernel.org L: kvm@vger.kernel.org
......
...@@ -132,7 +132,8 @@ struct zpci_dev { ...@@ -132,7 +132,8 @@ struct zpci_dev {
u8 rid_available : 1; u8 rid_available : 1;
u8 has_hp_slot : 1; u8 has_hp_slot : 1;
u8 is_physfn : 1; u8 is_physfn : 1;
u8 reserved : 5; u8 util_str_avail : 1;
u8 reserved : 4;
unsigned int devfn; /* DEVFN part of the RID*/ unsigned int devfn; /* DEVFN part of the RID*/
struct mutex lock; struct mutex lock;
...@@ -179,6 +180,7 @@ struct zpci_dev { ...@@ -179,6 +180,7 @@ struct zpci_dev {
atomic64_t mapped_pages; atomic64_t mapped_pages;
atomic64_t unmapped_pages; atomic64_t unmapped_pages;
u8 version;
enum pci_bus_speed max_bus_speed; enum pci_bus_speed max_bus_speed;
struct dentry *debugfs_dev; struct dentry *debugfs_dev;
......
...@@ -135,9 +135,10 @@ void pcibios_bus_add_device(struct pci_dev *pdev) ...@@ -135,9 +135,10 @@ void pcibios_bus_add_device(struct pci_dev *pdev)
* With pdev->no_vf_scan the common PCI probing code does not * With pdev->no_vf_scan the common PCI probing code does not
* perform PF/VF linking. * perform PF/VF linking.
*/ */
if (zdev->vfn) if (zdev->vfn) {
zpci_iov_setup_virtfn(zdev->zbus, pdev, zdev->vfn); zpci_iov_setup_virtfn(zdev->zbus, pdev, zdev->vfn);
pdev->no_command_memory = 1;
}
} }
static int zpci_bus_add_device(struct zpci_bus *zbus, struct zpci_dev *zdev) static int zpci_bus_add_device(struct zpci_bus *zbus, struct zpci_dev *zdev)
......
...@@ -102,6 +102,7 @@ static void clp_store_query_pci_fngrp(struct zpci_dev *zdev, ...@@ -102,6 +102,7 @@ static void clp_store_query_pci_fngrp(struct zpci_dev *zdev,
zdev->msi_addr = response->msia; zdev->msi_addr = response->msia;
zdev->max_msi = response->noi; zdev->max_msi = response->noi;
zdev->fmb_update = response->mui; zdev->fmb_update = response->mui;
zdev->version = response->version;
switch (response->version) { switch (response->version) {
case 1: case 1:
...@@ -167,6 +168,7 @@ static int clp_store_query_pci_fn(struct zpci_dev *zdev, ...@@ -167,6 +168,7 @@ static int clp_store_query_pci_fn(struct zpci_dev *zdev,
if (response->util_str_avail) { if (response->util_str_avail) {
memcpy(zdev->util_str, response->util_str, memcpy(zdev->util_str, response->util_str,
sizeof(zdev->util_str)); sizeof(zdev->util_str));
zdev->util_str_avail = 1;
} }
zdev->mio_capable = response->mio_addr_avail; zdev->mio_capable = response->mio_addr_avail;
for (i = 0; i < PCI_STD_NUM_BARS; i++) { for (i = 0; i < PCI_STD_NUM_BARS; i++) {
......
...@@ -180,6 +180,7 @@ int pci_iov_add_virtfn(struct pci_dev *dev, int id) ...@@ -180,6 +180,7 @@ int pci_iov_add_virtfn(struct pci_dev *dev, int id)
virtfn->device = iov->vf_device; virtfn->device = iov->vf_device;
virtfn->is_virtfn = 1; virtfn->is_virtfn = 1;
virtfn->physfn = pci_dev_get(dev); virtfn->physfn = pci_dev_get(dev);
virtfn->no_command_memory = 1;
if (id == 0) if (id == 0)
pci_read_vf_config_common(virtfn); pci_read_vf_config_common(virtfn);
......
...@@ -47,4 +47,5 @@ menuconfig VFIO_NOIOMMU ...@@ -47,4 +47,5 @@ menuconfig VFIO_NOIOMMU
source "drivers/vfio/pci/Kconfig" source "drivers/vfio/pci/Kconfig"
source "drivers/vfio/platform/Kconfig" source "drivers/vfio/platform/Kconfig"
source "drivers/vfio/mdev/Kconfig" source "drivers/vfio/mdev/Kconfig"
source "drivers/vfio/fsl-mc/Kconfig"
source "virt/lib/Kconfig" source "virt/lib/Kconfig"
...@@ -9,3 +9,4 @@ obj-$(CONFIG_VFIO_SPAPR_EEH) += vfio_spapr_eeh.o ...@@ -9,3 +9,4 @@ obj-$(CONFIG_VFIO_SPAPR_EEH) += vfio_spapr_eeh.o
obj-$(CONFIG_VFIO_PCI) += pci/ obj-$(CONFIG_VFIO_PCI) += pci/
obj-$(CONFIG_VFIO_PLATFORM) += platform/ obj-$(CONFIG_VFIO_PLATFORM) += platform/
obj-$(CONFIG_VFIO_MDEV) += mdev/ obj-$(CONFIG_VFIO_MDEV) += mdev/
obj-$(CONFIG_VFIO_FSL_MC) += fsl-mc/
config VFIO_FSL_MC
tristate "VFIO support for QorIQ DPAA2 fsl-mc bus devices"
depends on VFIO && FSL_MC_BUS && EVENTFD
help
Driver to enable support for the VFIO QorIQ DPAA2 fsl-mc
(Management Complex) devices. This is required to passthrough
fsl-mc bus devices using the VFIO framework.
If you don't know what to do here, say N.
# SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
vfio-fsl-mc-y := vfio_fsl_mc.o vfio_fsl_mc_intr.o
obj-$(CONFIG_VFIO_FSL_MC) += vfio-fsl-mc.o
This diff is collapsed.
// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
/*
* Copyright 2013-2016 Freescale Semiconductor Inc.
* Copyright 2019 NXP
*/
#include <linux/vfio.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/eventfd.h>
#include <linux/msi.h>
#include "linux/fsl/mc.h"
#include "vfio_fsl_mc_private.h"
int vfio_fsl_mc_irqs_allocate(struct vfio_fsl_mc_device *vdev)
{
struct fsl_mc_device *mc_dev = vdev->mc_dev;
struct vfio_fsl_mc_irq *mc_irq;
int irq_count;
int ret, i;
/* Device does not support any interrupt */
if (mc_dev->obj_desc.irq_count == 0)
return 0;
/* interrupts were already allocated for this device */
if (vdev->mc_irqs)
return 0;
irq_count = mc_dev->obj_desc.irq_count;
mc_irq = kcalloc(irq_count, sizeof(*mc_irq), GFP_KERNEL);
if (!mc_irq)
return -ENOMEM;
/* Allocate IRQs */
ret = fsl_mc_allocate_irqs(mc_dev);
if (ret) {
kfree(mc_irq);
return ret;
}
for (i = 0; i < irq_count; i++) {
mc_irq[i].count = 1;
mc_irq[i].flags = VFIO_IRQ_INFO_EVENTFD;
}
vdev->mc_irqs = mc_irq;
return 0;
}
static irqreturn_t vfio_fsl_mc_irq_handler(int irq_num, void *arg)
{
struct vfio_fsl_mc_irq *mc_irq = (struct vfio_fsl_mc_irq *)arg;
eventfd_signal(mc_irq->trigger, 1);
return IRQ_HANDLED;
}
static int vfio_set_trigger(struct vfio_fsl_mc_device *vdev,
int index, int fd)
{
struct vfio_fsl_mc_irq *irq = &vdev->mc_irqs[index];
struct eventfd_ctx *trigger;
int hwirq;
int ret;
hwirq = vdev->mc_dev->irqs[index]->msi_desc->irq;
if (irq->trigger) {
free_irq(hwirq, irq);
kfree(irq->name);
eventfd_ctx_put(irq->trigger);
irq->trigger = NULL;
}
if (fd < 0) /* Disable only */
return 0;
irq->name = kasprintf(GFP_KERNEL, "vfio-irq[%d](%s)",
hwirq, dev_name(&vdev->mc_dev->dev));
if (!irq->name)
return -ENOMEM;
trigger = eventfd_ctx_fdget(fd);
if (IS_ERR(trigger)) {
kfree(irq->name);
return PTR_ERR(trigger);
}
irq->trigger = trigger;
ret = request_irq(hwirq, vfio_fsl_mc_irq_handler, 0,
irq->name, irq);
if (ret) {
kfree(irq->name);
eventfd_ctx_put(trigger);
irq->trigger = NULL;
return ret;
}
return 0;
}
static int vfio_fsl_mc_set_irq_trigger(struct vfio_fsl_mc_device *vdev,
unsigned int index, unsigned int start,
unsigned int count, u32 flags,
void *data)
{
struct fsl_mc_device *mc_dev = vdev->mc_dev;
int ret, hwirq;
struct vfio_fsl_mc_irq *irq;
struct device *cont_dev = fsl_mc_cont_dev(&mc_dev->dev);
struct fsl_mc_device *mc_cont = to_fsl_mc_device(cont_dev);
if (!count && (flags & VFIO_IRQ_SET_DATA_NONE))
return vfio_set_trigger(vdev, index, -1);
if (start != 0 || count != 1)
return -EINVAL;
mutex_lock(&vdev->reflck->lock);
ret = fsl_mc_populate_irq_pool(mc_cont,
FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS);
if (ret)
goto unlock;
ret = vfio_fsl_mc_irqs_allocate(vdev);
if (ret)
goto unlock;
mutex_unlock(&vdev->reflck->lock);
if (flags & VFIO_IRQ_SET_DATA_EVENTFD) {
s32 fd = *(s32 *)data;
return vfio_set_trigger(vdev, index, fd);
}
hwirq = vdev->mc_dev->irqs[index]->msi_desc->irq;
irq = &vdev->mc_irqs[index];
if (flags & VFIO_IRQ_SET_DATA_NONE) {
vfio_fsl_mc_irq_handler(hwirq, irq);
} else if (flags & VFIO_IRQ_SET_DATA_BOOL) {
u8 trigger = *(u8 *)data;
if (trigger)
vfio_fsl_mc_irq_handler(hwirq, irq);
}
return 0;
unlock:
mutex_unlock(&vdev->reflck->lock);
return ret;
}
int vfio_fsl_mc_set_irqs_ioctl(struct vfio_fsl_mc_device *vdev,
u32 flags, unsigned int index,
unsigned int start, unsigned int count,
void *data)
{
if (flags & VFIO_IRQ_SET_ACTION_TRIGGER)
return vfio_fsl_mc_set_irq_trigger(vdev, index, start,
count, flags, data);
else
return -EINVAL;
}
/* Free All IRQs for the given MC object */
void vfio_fsl_mc_irqs_cleanup(struct vfio_fsl_mc_device *vdev)
{
struct fsl_mc_device *mc_dev = vdev->mc_dev;
int irq_count = mc_dev->obj_desc.irq_count;
int i;
/*
* Device does not support any interrupt or the interrupts
* were not configured
*/
if (!vdev->mc_irqs)
return;
for (i = 0; i < irq_count; i++)
vfio_set_trigger(vdev, i, -1);
fsl_mc_free_irqs(mc_dev);
kfree(vdev->mc_irqs);
vdev->mc_irqs = NULL;
}
/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
/*
* Copyright 2013-2016 Freescale Semiconductor Inc.
* Copyright 2016,2019-2020 NXP
*/
#ifndef VFIO_FSL_MC_PRIVATE_H
#define VFIO_FSL_MC_PRIVATE_H
#define VFIO_FSL_MC_OFFSET_SHIFT 40
#define VFIO_FSL_MC_OFFSET_MASK (((u64)(1) << VFIO_FSL_MC_OFFSET_SHIFT) - 1)
#define VFIO_FSL_MC_OFFSET_TO_INDEX(off) ((off) >> VFIO_FSL_MC_OFFSET_SHIFT)
#define VFIO_FSL_MC_INDEX_TO_OFFSET(index) \
((u64)(index) << VFIO_FSL_MC_OFFSET_SHIFT)
struct vfio_fsl_mc_irq {
u32 flags;
u32 count;
struct eventfd_ctx *trigger;
char *name;
};
struct vfio_fsl_mc_reflck {
struct kref kref;
struct mutex lock;
};
struct vfio_fsl_mc_region {
u32 flags;
u32 type;
u64 addr;
resource_size_t size;
void __iomem *ioaddr;
};
struct vfio_fsl_mc_device {
struct fsl_mc_device *mc_dev;
struct notifier_block nb;
int refcnt;
struct vfio_fsl_mc_region *regions;
struct vfio_fsl_mc_reflck *reflck;
struct mutex igate;
struct vfio_fsl_mc_irq *mc_irqs;
};
extern int vfio_fsl_mc_set_irqs_ioctl(struct vfio_fsl_mc_device *vdev,
u32 flags, unsigned int index,
unsigned int start, unsigned int count,
void *data);
void vfio_fsl_mc_irqs_cleanup(struct vfio_fsl_mc_device *vdev);
#endif /* VFIO_FSL_MC_PRIVATE_H */
...@@ -45,3 +45,15 @@ config VFIO_PCI_NVLINK2 ...@@ -45,3 +45,15 @@ config VFIO_PCI_NVLINK2
depends on VFIO_PCI && PPC_POWERNV depends on VFIO_PCI && PPC_POWERNV
help help
VFIO PCI support for P9 Witherspoon machine with NVIDIA V100 GPUs VFIO PCI support for P9 Witherspoon machine with NVIDIA V100 GPUs
config VFIO_PCI_ZDEV
bool "VFIO PCI ZPCI device CLP support"
depends on VFIO_PCI && S390
default y
help
Enabling this option exposes VFIO capabilities containing hardware
configuration for zPCI devices. This enables userspace (e.g. QEMU)
to supply proper configuration values instead of hard-coded defaults
for zPCI devices passed through via VFIO on s390.
Say Y here.
...@@ -3,5 +3,6 @@ ...@@ -3,5 +3,6 @@
vfio-pci-y := vfio_pci.o vfio_pci_intrs.o vfio_pci_rdwr.o vfio_pci_config.o vfio-pci-y := vfio_pci.o vfio_pci_intrs.o vfio_pci_rdwr.o vfio_pci_config.o
vfio-pci-$(CONFIG_VFIO_PCI_IGD) += vfio_pci_igd.o vfio-pci-$(CONFIG_VFIO_PCI_IGD) += vfio_pci_igd.o
vfio-pci-$(CONFIG_VFIO_PCI_NVLINK2) += vfio_pci_nvlink2.o vfio-pci-$(CONFIG_VFIO_PCI_NVLINK2) += vfio_pci_nvlink2.o
vfio-pci-$(CONFIG_VFIO_PCI_ZDEV) += vfio_pci_zdev.o
obj-$(CONFIG_VFIO_PCI) += vfio-pci.o obj-$(CONFIG_VFIO_PCI) += vfio-pci.o
...@@ -807,15 +807,25 @@ static long vfio_pci_ioctl(void *device_data, ...@@ -807,15 +807,25 @@ static long vfio_pci_ioctl(void *device_data,
if (cmd == VFIO_DEVICE_GET_INFO) { if (cmd == VFIO_DEVICE_GET_INFO) {
struct vfio_device_info info; struct vfio_device_info info;
struct vfio_info_cap caps = { .buf = NULL, .size = 0 };
unsigned long capsz;
minsz = offsetofend(struct vfio_device_info, num_irqs); minsz = offsetofend(struct vfio_device_info, num_irqs);
/* For backward compatibility, cannot require this */
capsz = offsetofend(struct vfio_iommu_type1_info, cap_offset);
if (copy_from_user(&info, (void __user *)arg, minsz)) if (copy_from_user(&info, (void __user *)arg, minsz))
return -EFAULT; return -EFAULT;
if (info.argsz < minsz) if (info.argsz < minsz)
return -EINVAL; return -EINVAL;
if (info.argsz >= capsz) {
minsz = capsz;
info.cap_offset = 0;
}
info.flags = VFIO_DEVICE_FLAGS_PCI; info.flags = VFIO_DEVICE_FLAGS_PCI;
if (vdev->reset_works) if (vdev->reset_works)
...@@ -824,6 +834,33 @@ static long vfio_pci_ioctl(void *device_data, ...@@ -824,6 +834,33 @@ static long vfio_pci_ioctl(void *device_data,
info.num_regions = VFIO_PCI_NUM_REGIONS + vdev->num_regions; info.num_regions = VFIO_PCI_NUM_REGIONS + vdev->num_regions;
info.num_irqs = VFIO_PCI_NUM_IRQS; info.num_irqs = VFIO_PCI_NUM_IRQS;
if (IS_ENABLED(CONFIG_VFIO_PCI_ZDEV)) {
int ret = vfio_pci_info_zdev_add_caps(vdev, &caps);
if (ret && ret != -ENODEV) {
pci_warn(vdev->pdev, "Failed to setup zPCI info capabilities\n");
return ret;
}
}
if (caps.size) {
info.flags |= VFIO_DEVICE_FLAGS_CAPS;
if (info.argsz < sizeof(info) + caps.size) {
info.argsz = sizeof(info) + caps.size;
} else {
vfio_info_cap_shift(&caps, sizeof(info));
if (copy_to_user((void __user *)arg +
sizeof(info), caps.buf,
caps.size)) {
kfree(caps.buf);
return -EFAULT;
}
info.cap_offset = sizeof(info);
}
kfree(caps.buf);
}
return copy_to_user((void __user *)arg, &info, minsz) ? return copy_to_user((void __user *)arg, &info, minsz) ?
-EFAULT : 0; -EFAULT : 0;
...@@ -1860,7 +1897,6 @@ static const struct vfio_device_ops vfio_pci_ops = { ...@@ -1860,7 +1897,6 @@ static const struct vfio_device_ops vfio_pci_ops = {
static int vfio_pci_reflck_attach(struct vfio_pci_device *vdev); static int vfio_pci_reflck_attach(struct vfio_pci_device *vdev);
static void vfio_pci_reflck_put(struct vfio_pci_reflck *reflck); static void vfio_pci_reflck_put(struct vfio_pci_reflck *reflck);
static struct pci_driver vfio_pci_driver;
static int vfio_pci_bus_notifier(struct notifier_block *nb, static int vfio_pci_bus_notifier(struct notifier_block *nb,
unsigned long action, void *data) unsigned long action, void *data)
......
...@@ -406,7 +406,7 @@ bool __vfio_pci_memory_enabled(struct vfio_pci_device *vdev) ...@@ -406,7 +406,7 @@ bool __vfio_pci_memory_enabled(struct vfio_pci_device *vdev)
* PF SR-IOV capability, there's therefore no need to trigger * PF SR-IOV capability, there's therefore no need to trigger
* faults based on the virtual value. * faults based on the virtual value.
*/ */
return pdev->is_virtfn || (cmd & PCI_COMMAND_MEMORY); return pdev->no_command_memory || (cmd & PCI_COMMAND_MEMORY);
} }
/* /*
...@@ -467,6 +467,9 @@ static void vfio_bar_fixup(struct vfio_pci_device *vdev) ...@@ -467,6 +467,9 @@ static void vfio_bar_fixup(struct vfio_pci_device *vdev)
__le32 *vbar; __le32 *vbar;
u64 mask; u64 mask;
if (!vdev->bardirty)
return;
vbar = (__le32 *)&vdev->vconfig[PCI_BASE_ADDRESS_0]; vbar = (__le32 *)&vdev->vconfig[PCI_BASE_ADDRESS_0];
for (i = 0; i < PCI_STD_NUM_BARS; i++, vbar++) { for (i = 0; i < PCI_STD_NUM_BARS; i++, vbar++) {
...@@ -520,8 +523,8 @@ static int vfio_basic_config_read(struct vfio_pci_device *vdev, int pos, ...@@ -520,8 +523,8 @@ static int vfio_basic_config_read(struct vfio_pci_device *vdev, int pos,
count = vfio_default_config_read(vdev, pos, count, perm, offset, val); count = vfio_default_config_read(vdev, pos, count, perm, offset, val);
/* Mask in virtual memory enable for SR-IOV devices */ /* Mask in virtual memory enable */
if (offset == PCI_COMMAND && vdev->pdev->is_virtfn) { if (offset == PCI_COMMAND && vdev->pdev->no_command_memory) {
u16 cmd = le16_to_cpu(*(__le16 *)&vdev->vconfig[PCI_COMMAND]); u16 cmd = le16_to_cpu(*(__le16 *)&vdev->vconfig[PCI_COMMAND]);
u32 tmp_val = le32_to_cpu(*val); u32 tmp_val = le32_to_cpu(*val);
...@@ -589,9 +592,11 @@ static int vfio_basic_config_write(struct vfio_pci_device *vdev, int pos, ...@@ -589,9 +592,11 @@ static int vfio_basic_config_write(struct vfio_pci_device *vdev, int pos,
* shows it disabled (phys_mem/io, then the device has * shows it disabled (phys_mem/io, then the device has
* undergone some kind of backdoor reset and needs to be * undergone some kind of backdoor reset and needs to be
* restored before we allow it to enable the bars. * restored before we allow it to enable the bars.
* SR-IOV devices will trigger this, but we catch them later * SR-IOV devices will trigger this - for mem enable let's
* catch this now and for io enable it will be caught later
*/ */
if ((new_mem && virt_mem && !phys_mem) || if ((new_mem && virt_mem && !phys_mem &&
!pdev->no_command_memory) ||
(new_io && virt_io && !phys_io) || (new_io && virt_io && !phys_io) ||
vfio_need_bar_restore(vdev)) vfio_need_bar_restore(vdev))
vfio_bar_restore(vdev); vfio_bar_restore(vdev);
...@@ -1734,12 +1739,14 @@ int vfio_config_init(struct vfio_pci_device *vdev) ...@@ -1734,12 +1739,14 @@ int vfio_config_init(struct vfio_pci_device *vdev)
vconfig[PCI_INTERRUPT_PIN]); vconfig[PCI_INTERRUPT_PIN]);
vconfig[PCI_INTERRUPT_PIN] = 0; /* Gratuitous for good VFs */ vconfig[PCI_INTERRUPT_PIN] = 0; /* Gratuitous for good VFs */
}
if (pdev->no_command_memory) {
/* /*
* VFs do no implement the memory enable bit of the COMMAND * VFs and devices that set pdev->no_command_memory do not
* register therefore we'll not have it set in our initial * implement the memory enable bit of the COMMAND register
* copy of config space after pci_enable_device(). For * therefore we'll not have it set in our initial copy of
* consistency with PFs, set the virtual enable bit here. * config space after pci_enable_device(). For consistency
* with PFs, set the virtual enable bit here.
*/ */
*(__le16 *)&vconfig[PCI_COMMAND] |= *(__le16 *)&vconfig[PCI_COMMAND] |=
cpu_to_le16(PCI_COMMAND_MEMORY); cpu_to_le16(PCI_COMMAND_MEMORY);
......
...@@ -352,11 +352,13 @@ static int vfio_msi_set_vector_signal(struct vfio_pci_device *vdev, ...@@ -352,11 +352,13 @@ static int vfio_msi_set_vector_signal(struct vfio_pci_device *vdev,
vdev->ctx[vector].producer.token = trigger; vdev->ctx[vector].producer.token = trigger;
vdev->ctx[vector].producer.irq = irq; vdev->ctx[vector].producer.irq = irq;
ret = irq_bypass_register_producer(&vdev->ctx[vector].producer); ret = irq_bypass_register_producer(&vdev->ctx[vector].producer);
if (unlikely(ret)) if (unlikely(ret)) {
dev_info(&pdev->dev, dev_info(&pdev->dev,
"irq bypass producer (token %p) registration fails: %d\n", "irq bypass producer (token %p) registration fails: %d\n",
vdev->ctx[vector].producer.token, ret); vdev->ctx[vector].producer.token, ret);
vdev->ctx[vector].producer.token = NULL;
}
vdev->ctx[vector].trigger = trigger; vdev->ctx[vector].trigger = trigger;
return 0; return 0;
......
...@@ -213,4 +213,16 @@ static inline int vfio_pci_ibm_npu2_init(struct vfio_pci_device *vdev) ...@@ -213,4 +213,16 @@ static inline int vfio_pci_ibm_npu2_init(struct vfio_pci_device *vdev)
return -ENODEV; return -ENODEV;
} }
#endif #endif
#ifdef CONFIG_VFIO_PCI_ZDEV
extern int vfio_pci_info_zdev_add_caps(struct vfio_pci_device *vdev,
struct vfio_info_cap *caps);
#else
static inline int vfio_pci_info_zdev_add_caps(struct vfio_pci_device *vdev,
struct vfio_info_cap *caps)
{
return -ENODEV;
}
#endif
#endif /* VFIO_PCI_PRIVATE_H */ #endif /* VFIO_PCI_PRIVATE_H */
// SPDX-License-Identifier: GPL-2.0+
/*
* VFIO ZPCI devices support
*
* Copyright (C) IBM Corp. 2020. All rights reserved.
* Author(s): Pierre Morel <pmorel@linux.ibm.com>
* Matthew Rosato <mjrosato@linux.ibm.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/
#include <linux/io.h>
#include <linux/pci.h>
#include <linux/uaccess.h>
#include <linux/vfio.h>
#include <linux/vfio_zdev.h>
#include <asm/pci_clp.h>
#include <asm/pci_io.h>
#include "vfio_pci_private.h"
/*
* Add the Base PCI Function information to the device info region.
*/
static int zpci_base_cap(struct zpci_dev *zdev, struct vfio_pci_device *vdev,
struct vfio_info_cap *caps)
{
struct vfio_device_info_cap_zpci_base cap = {
.header.id = VFIO_DEVICE_INFO_CAP_ZPCI_BASE,
.header.version = 1,
.start_dma = zdev->start_dma,
.end_dma = zdev->end_dma,
.pchid = zdev->pchid,
.vfn = zdev->vfn,
.fmb_length = zdev->fmb_length,
.pft = zdev->pft,
.gid = zdev->pfgid
};
return vfio_info_add_capability(caps, &cap.header, sizeof(cap));
}
/*
* Add the Base PCI Function Group information to the device info region.
*/
static int zpci_group_cap(struct zpci_dev *zdev, struct vfio_pci_device *vdev,
struct vfio_info_cap *caps)
{
struct vfio_device_info_cap_zpci_group cap = {
.header.id = VFIO_DEVICE_INFO_CAP_ZPCI_GROUP,
.header.version = 1,
.dasm = zdev->dma_mask,
.msi_addr = zdev->msi_addr,
.flags = VFIO_DEVICE_INFO_ZPCI_FLAG_REFRESH,
.mui = zdev->fmb_update,
.noi = zdev->max_msi,
.maxstbl = ZPCI_MAX_WRITE_SIZE,
.version = zdev->version
};
return vfio_info_add_capability(caps, &cap.header, sizeof(cap));
}
/*
* Add the device utility string to the device info region.
*/
static int zpci_util_cap(struct zpci_dev *zdev, struct vfio_pci_device *vdev,
struct vfio_info_cap *caps)
{
struct vfio_device_info_cap_zpci_util *cap;
int cap_size = sizeof(*cap) + CLP_UTIL_STR_LEN;
int ret;
cap = kmalloc(cap_size, GFP_KERNEL);
cap->header.id = VFIO_DEVICE_INFO_CAP_ZPCI_UTIL;
cap->header.version = 1;
cap->size = CLP_UTIL_STR_LEN;
memcpy(cap->util_str, zdev->util_str, cap->size);
ret = vfio_info_add_capability(caps, &cap->header, cap_size);
kfree(cap);
return ret;
}
/*
* Add the function path string to the device info region.
*/
static int zpci_pfip_cap(struct zpci_dev *zdev, struct vfio_pci_device *vdev,
struct vfio_info_cap *caps)
{
struct vfio_device_info_cap_zpci_pfip *cap;
int cap_size = sizeof(*cap) + CLP_PFIP_NR_SEGMENTS;
int ret;
cap = kmalloc(cap_size, GFP_KERNEL);
cap->header.id = VFIO_DEVICE_INFO_CAP_ZPCI_PFIP;
cap->header.version = 1;
cap->size = CLP_PFIP_NR_SEGMENTS;
memcpy(cap->pfip, zdev->pfip, cap->size);
ret = vfio_info_add_capability(caps, &cap->header, cap_size);
kfree(cap);
return ret;
}
/*
* Add all supported capabilities to the VFIO_DEVICE_GET_INFO capability chain.
*/
int vfio_pci_info_zdev_add_caps(struct vfio_pci_device *vdev,
struct vfio_info_cap *caps)
{
struct zpci_dev *zdev = to_zpci(vdev->pdev);
int ret;
if (!zdev)
return -ENODEV;
ret = zpci_base_cap(zdev, vdev, caps);
if (ret)
return ret;
ret = zpci_group_cap(zdev, vdev, caps);
if (ret)
return ret;
if (zdev->util_str_avail) {
ret = zpci_util_cap(zdev, vdev, caps);
if (ret)
return ret;
}
ret = zpci_pfip_cap(zdev, vdev, caps);
return ret;
}
...@@ -1949,8 +1949,10 @@ int vfio_pin_pages(struct device *dev, unsigned long *user_pfn, int npage, ...@@ -1949,8 +1949,10 @@ int vfio_pin_pages(struct device *dev, unsigned long *user_pfn, int npage,
if (!group) if (!group)
return -ENODEV; return -ENODEV;
if (group->dev_counter > 1) if (group->dev_counter > 1) {
return -EINVAL; ret = -EINVAL;
goto err_pin_pages;
}
ret = vfio_group_add_container_user(group); ret = vfio_group_add_container_user(group);
if (ret) if (ret)
...@@ -2051,6 +2053,9 @@ int vfio_group_pin_pages(struct vfio_group *group, ...@@ -2051,6 +2053,9 @@ int vfio_group_pin_pages(struct vfio_group *group,
if (!group || !user_iova_pfn || !phys_pfn || !npage) if (!group || !user_iova_pfn || !phys_pfn || !npage)
return -EINVAL; return -EINVAL;
if (group->dev_counter > 1)
return -EINVAL;
if (npage > VFIO_PIN_PAGES_MAX_ENTRIES) if (npage > VFIO_PIN_PAGES_MAX_ENTRIES)
return -E2BIG; return -E2BIG;
......
...@@ -693,7 +693,8 @@ static int vfio_iommu_type1_pin_pages(void *iommu_data, ...@@ -693,7 +693,8 @@ static int vfio_iommu_type1_pin_pages(void *iommu_data,
ret = vfio_add_to_pfn_list(dma, iova, phys_pfn[i]); ret = vfio_add_to_pfn_list(dma, iova, phys_pfn[i]);
if (ret) { if (ret) {
vfio_unpin_page_external(dma, iova, do_accounting); if (put_pfn(phys_pfn[i], dma->prot) && do_accounting)
vfio_lock_acct(dma, -1, true);
goto pin_unwind; goto pin_unwind;
} }
...@@ -2609,6 +2610,20 @@ static int vfio_iommu_migration_build_caps(struct vfio_iommu *iommu, ...@@ -2609,6 +2610,20 @@ static int vfio_iommu_migration_build_caps(struct vfio_iommu *iommu,
return vfio_info_add_capability(caps, &cap_mig.header, sizeof(cap_mig)); return vfio_info_add_capability(caps, &cap_mig.header, sizeof(cap_mig));
} }
static int vfio_iommu_dma_avail_build_caps(struct vfio_iommu *iommu,
struct vfio_info_cap *caps)
{
struct vfio_iommu_type1_info_dma_avail cap_dma_avail;
cap_dma_avail.header.id = VFIO_IOMMU_TYPE1_INFO_DMA_AVAIL;
cap_dma_avail.header.version = 1;
cap_dma_avail.avail = iommu->dma_avail;
return vfio_info_add_capability(caps, &cap_dma_avail.header,
sizeof(cap_dma_avail));
}
static int vfio_iommu_type1_get_info(struct vfio_iommu *iommu, static int vfio_iommu_type1_get_info(struct vfio_iommu *iommu,
unsigned long arg) unsigned long arg)
{ {
...@@ -2641,6 +2656,9 @@ static int vfio_iommu_type1_get_info(struct vfio_iommu *iommu, ...@@ -2641,6 +2656,9 @@ static int vfio_iommu_type1_get_info(struct vfio_iommu *iommu,
ret = vfio_iommu_migration_build_caps(iommu, &caps); ret = vfio_iommu_migration_build_caps(iommu, &caps);
if (!ret)
ret = vfio_iommu_dma_avail_build_caps(iommu, &caps);
if (!ret) if (!ret)
ret = vfio_iommu_iova_build_caps(iommu, &caps); ret = vfio_iommu_iova_build_caps(iommu, &caps);
...@@ -2933,7 +2951,8 @@ static int vfio_iommu_type1_dma_rw_chunk(struct vfio_iommu *iommu, ...@@ -2933,7 +2951,8 @@ static int vfio_iommu_type1_dma_rw_chunk(struct vfio_iommu *iommu,
* size * size
*/ */
bitmap_set(dma->bitmap, offset >> pgshift, bitmap_set(dma->bitmap, offset >> pgshift,
*copied >> pgshift); ((offset + *copied - 1) >> pgshift) -
(offset >> pgshift) + 1);
} }
} else } else
*copied = copy_from_user(data, (void __user *)vaddr, *copied = copy_from_user(data, (void __user *)vaddr,
......
...@@ -446,6 +446,7 @@ struct pci_dev { ...@@ -446,6 +446,7 @@ struct pci_dev {
unsigned int is_probed:1; /* Device probing in progress */ unsigned int is_probed:1; /* Device probing in progress */
unsigned int link_active_reporting:1;/* Device capable of reporting link active */ unsigned int link_active_reporting:1;/* Device capable of reporting link active */
unsigned int no_vf_scan:1; /* Don't scan for VFs after IOV enablement */ unsigned int no_vf_scan:1; /* Don't scan for VFs after IOV enablement */
unsigned int no_command_memory:1; /* No PCI_COMMAND_MEMORY */
pci_dev_flags_t dev_flags; pci_dev_flags_t dev_flags;
atomic_t enable_cnt; /* pci_enable_device has been called */ atomic_t enable_cnt; /* pci_enable_device has been called */
......
...@@ -201,8 +201,11 @@ struct vfio_device_info { ...@@ -201,8 +201,11 @@ struct vfio_device_info {
#define VFIO_DEVICE_FLAGS_AMBA (1 << 3) /* vfio-amba device */ #define VFIO_DEVICE_FLAGS_AMBA (1 << 3) /* vfio-amba device */
#define VFIO_DEVICE_FLAGS_CCW (1 << 4) /* vfio-ccw device */ #define VFIO_DEVICE_FLAGS_CCW (1 << 4) /* vfio-ccw device */
#define VFIO_DEVICE_FLAGS_AP (1 << 5) /* vfio-ap device */ #define VFIO_DEVICE_FLAGS_AP (1 << 5) /* vfio-ap device */
#define VFIO_DEVICE_FLAGS_FSL_MC (1 << 6) /* vfio-fsl-mc device */
#define VFIO_DEVICE_FLAGS_CAPS (1 << 7) /* Info supports caps */
__u32 num_regions; /* Max region index + 1 */ __u32 num_regions; /* Max region index + 1 */
__u32 num_irqs; /* Max IRQ index + 1 */ __u32 num_irqs; /* Max IRQ index + 1 */
__u32 cap_offset; /* Offset within info struct of first cap */
}; };
#define VFIO_DEVICE_GET_INFO _IO(VFIO_TYPE, VFIO_BASE + 7) #define VFIO_DEVICE_GET_INFO _IO(VFIO_TYPE, VFIO_BASE + 7)
...@@ -218,6 +221,15 @@ struct vfio_device_info { ...@@ -218,6 +221,15 @@ struct vfio_device_info {
#define VFIO_DEVICE_API_CCW_STRING "vfio-ccw" #define VFIO_DEVICE_API_CCW_STRING "vfio-ccw"
#define VFIO_DEVICE_API_AP_STRING "vfio-ap" #define VFIO_DEVICE_API_AP_STRING "vfio-ap"
/*
* The following capabilities are unique to s390 zPCI devices. Their contents
* are further-defined in vfio_zdev.h
*/
#define VFIO_DEVICE_INFO_CAP_ZPCI_BASE 1
#define VFIO_DEVICE_INFO_CAP_ZPCI_GROUP 2
#define VFIO_DEVICE_INFO_CAP_ZPCI_UTIL 3
#define VFIO_DEVICE_INFO_CAP_ZPCI_PFIP 4
/** /**
* VFIO_DEVICE_GET_REGION_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 8, * VFIO_DEVICE_GET_REGION_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 8,
* struct vfio_region_info) * struct vfio_region_info)
...@@ -462,7 +474,7 @@ struct vfio_region_gfx_edid { ...@@ -462,7 +474,7 @@ struct vfio_region_gfx_edid {
* 5. Resumed * 5. Resumed
* |--------->| * |--------->|
* *
* 0. Default state of VFIO device is _RUNNNG when the user application starts. * 0. Default state of VFIO device is _RUNNING when the user application starts.
* 1. During normal shutdown of the user application, the user application may * 1. During normal shutdown of the user application, the user application may
* optionally change the VFIO device state from _RUNNING to _STOP. This * optionally change the VFIO device state from _RUNNING to _STOP. This
* transition is optional. The vendor driver must support this transition but * transition is optional. The vendor driver must support this transition but
...@@ -1039,6 +1051,21 @@ struct vfio_iommu_type1_info_cap_migration { ...@@ -1039,6 +1051,21 @@ struct vfio_iommu_type1_info_cap_migration {
__u64 max_dirty_bitmap_size; /* in bytes */ __u64 max_dirty_bitmap_size; /* in bytes */
}; };
/*
* The DMA available capability allows to report the current number of
* simultaneously outstanding DMA mappings that are allowed.
*
* The structure below defines version 1 of this capability.
*
* avail: specifies the current number of outstanding DMA mappings allowed.
*/
#define VFIO_IOMMU_TYPE1_INFO_DMA_AVAIL 3
struct vfio_iommu_type1_info_dma_avail {
struct vfio_info_cap_header header;
__u32 avail;
};
#define VFIO_IOMMU_GET_INFO _IO(VFIO_TYPE, VFIO_BASE + 12) #define VFIO_IOMMU_GET_INFO _IO(VFIO_TYPE, VFIO_BASE + 12)
/** /**
......
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
/*
* VFIO Region definitions for ZPCI devices
*
* Copyright IBM Corp. 2020
*
* Author(s): Pierre Morel <pmorel@linux.ibm.com>
* Matthew Rosato <mjrosato@linux.ibm.com>
*/
#ifndef _VFIO_ZDEV_H_
#define _VFIO_ZDEV_H_
#include <linux/types.h>
#include <linux/vfio.h>
/**
* VFIO_DEVICE_INFO_CAP_ZPCI_BASE - Base PCI Function information
*
* This capability provides a set of descriptive information about the
* associated PCI function.
*/
struct vfio_device_info_cap_zpci_base {
struct vfio_info_cap_header header;
__u64 start_dma; /* Start of available DMA addresses */
__u64 end_dma; /* End of available DMA addresses */
__u16 pchid; /* Physical Channel ID */
__u16 vfn; /* Virtual function number */
__u16 fmb_length; /* Measurement Block Length (in bytes) */
__u8 pft; /* PCI Function Type */
__u8 gid; /* PCI function group ID */
};
/**
* VFIO_DEVICE_INFO_CAP_ZPCI_GROUP - Base PCI Function Group information
*
* This capability provides a set of descriptive information about the group of
* PCI functions that the associated device belongs to.
*/
struct vfio_device_info_cap_zpci_group {
struct vfio_info_cap_header header;
__u64 dasm; /* DMA Address space mask */
__u64 msi_addr; /* MSI address */
__u64 flags;
#define VFIO_DEVICE_INFO_ZPCI_FLAG_REFRESH 1 /* Program-specified TLB refresh */
__u16 mui; /* Measurement Block Update Interval */
__u16 noi; /* Maximum number of MSIs */
__u16 maxstbl; /* Maximum Store Block Length */
__u8 version; /* Supported PCI Version */
};
/**
* VFIO_DEVICE_INFO_CAP_ZPCI_UTIL - Utility String
*
* This capability provides the utility string for the associated device, which
* is a device identifier string made up of EBCDID characters. 'size' specifies
* the length of 'util_str'.
*/
struct vfio_device_info_cap_zpci_util {
struct vfio_info_cap_header header;
__u32 size;
__u8 util_str[];
};
/**
* VFIO_DEVICE_INFO_CAP_ZPCI_PFIP - PCI Function Path
*
* This capability provides the PCI function path string, which is an identifier
* that describes the internal hardware path of the device. 'size' specifies
* the length of 'pfip'.
*/
struct vfio_device_info_cap_zpci_pfip {
struct vfio_info_cap_header header;
__u32 size;
__u8 pfip[];
};
#endif
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment