iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

virtio: bugfixes

Browse Source 
A couple vdpa and vhost bugfixes
 
 Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
 -----BEGIN PGP SIGNATURE-----
 
 iQFDBAABCAAtFiEEXQn9CHHI+FuUyooNKB8NuNKNVGkFAl9GYpsPHG1zdEByZWRo
 YXQuY29tAAoJECgfDbjSjVRpE3kIALM7y14Zy/vY72WSjNoZuT7Xmut1ck7p7S9L
 6eHexaQwYfE212pmKayrqvIZESAXdysT6wlL1eTN+K/Tr9Qgbee447YQewAAMAxs
 22sPZvG0a7nSbUyftVVVuhntHQ6Sak4ZiPIRKtLE9GooKb0zPYFNWEngga+DPBqP
 8vuiak1h1zKe77LDai2z6+w68cA0TeX28h1r0A6lGJo+Ohwu8MJRH48kpNT1/N6j
 /Y/wF35hVXp2a9y4ijNIN+aPsY2tgjZ4vQPjGX0qd6zscN1ABiYzZnvLWACfcnvk
 4oZgdGS8wtboAlS7ZT3nawBQWvV37t9ZP7HpTM+1pn+MUFIw1lg=
 =DNw8
 -----END PGP SIGNATURE-----

Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost

Pull virtio bugfixes from Michael Tsirkin:
 "A couple vdpa and vhost bugfixes"

* tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost:
  vdpa/mlx5: Avoid warnings about shifts on 32-bit platforms
  vhost-iotlb: fix vhost_iotlb_itree_next() documentation
  vdpa: ifcvf: free config irq in ifcvf_free_irq()
  vdpa: ifcvf: return err when fail to request config irq
This commit is contained in:
Linus Torvalds 2020-08-26 10:40:09 -07:00
commit e652049b20
4 changed files with 35 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/vdpa/ifcvf/ifcvf_base.h
View File

@ -84,7 +84,7 @@ struct ifcvf_hw {
void __iomem * const *base; void __iomem * const *base;
char config_msix_name[256]; char config_msix_name[256];
struct vdpa_callback config_cb; struct vdpa_callback config_cb;
unsigned int config_irq;
}; };
struct ifcvf_adapter { struct ifcvf_adapter {

9
drivers/vdpa/ifcvf/ifcvf_main.c
View File

@ -55,6 +55,7 @@ static void ifcvf_free_irq(struct ifcvf_adapter *adapter, int queues)
vf->vring[i].irq = -EINVAL; vf->vring[i].irq = -EINVAL;
} }
devm_free_irq(&pdev->dev, vf->config_irq, vf);
ifcvf_free_irq_vectors(pdev); ifcvf_free_irq_vectors(pdev);
} }
@ -74,10 +75,14 @@ static int ifcvf_request_irq(struct ifcvf_adapter *adapter)
snprintf(vf->config_msix_name, 256, "ifcvf[%s]-config\n", snprintf(vf->config_msix_name, 256, "ifcvf[%s]-config\n",
pci_name(pdev)); pci_name(pdev));
vector = 0; vector = 0;
irq = pci_irq_vector(pdev, vector); vf->config_irq = pci_irq_vector(pdev, vector);
ret = devm_request_irq(&pdev->dev, irq, ret = devm_request_irq(&pdev->dev, vf->config_irq,
ifcvf_config_changed, 0, ifcvf_config_changed, 0,
vf->config_msix_name, vf); vf->config_msix_name, vf);
if (ret) {
IFCVF_ERR(pdev, "Failed to request config irq\n");
return ret;
}
for (i = 0; i < IFCVF_MAX_QUEUE_PAIRS * 2; i++) { for (i = 0; i < IFCVF_MAX_QUEUE_PAIRS * 2; i++) {
snprintf(vf->vring[i].msix_name, 256, "ifcvf[%s]-%d\n", snprintf(vf->vring[i].msix_name, 256, "ifcvf[%s]-%d\n",

50
drivers/vdpa/mlx5/net/mlx5_vnet.c
View File

@ -16,19 +16,19 @@
#define to_mvdev(__vdev) container_of((__vdev), struct mlx5_vdpa_dev, vdev) #define to_mvdev(__vdev) container_of((__vdev), struct mlx5_vdpa_dev, vdev)
#define VALID_FEATURES_MASK \ #define VALID_FEATURES_MASK \
(BIT(VIRTIO_NET_F_CSUM) | BIT(VIRTIO_NET_F_GUEST_CSUM) | \ (BIT_ULL(VIRTIO_NET_F_CSUM) | BIT_ULL(VIRTIO_NET_F_GUEST_CSUM) | \
BIT(VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) | BIT(VIRTIO_NET_F_MTU) | BIT(VIRTIO_NET_F_MAC) | \ BIT_ULL(VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) | BIT_ULL(VIRTIO_NET_F_MTU) | BIT_ULL(VIRTIO_NET_F_MAC) | \
BIT(VIRTIO_NET_F_GUEST_TSO4) | BIT(VIRTIO_NET_F_GUEST_TSO6) | \ BIT_ULL(VIRTIO_NET_F_GUEST_TSO4) | BIT_ULL(VIRTIO_NET_F_GUEST_TSO6) | \
BIT(VIRTIO_NET_F_GUEST_ECN) | BIT(VIRTIO_NET_F_GUEST_UFO) | BIT(VIRTIO_NET_F_HOST_TSO4) | \ BIT_ULL(VIRTIO_NET_F_GUEST_ECN) | BIT_ULL(VIRTIO_NET_F_GUEST_UFO) | BIT_ULL(VIRTIO_NET_F_HOST_TSO4) | \
BIT(VIRTIO_NET_F_HOST_TSO6) | BIT(VIRTIO_NET_F_HOST_ECN) | BIT(VIRTIO_NET_F_HOST_UFO) | \ BIT_ULL(VIRTIO_NET_F_HOST_TSO6) | BIT_ULL(VIRTIO_NET_F_HOST_ECN) | BIT_ULL(VIRTIO_NET_F_HOST_UFO) | \
BIT(VIRTIO_NET_F_MRG_RXBUF) | BIT(VIRTIO_NET_F_STATUS) | BIT(VIRTIO_NET_F_CTRL_VQ) | \ BIT_ULL(VIRTIO_NET_F_MRG_RXBUF) | BIT_ULL(VIRTIO_NET_F_STATUS) | BIT_ULL(VIRTIO_NET_F_CTRL_VQ) | \
BIT(VIRTIO_NET_F_CTRL_RX) | BIT(VIRTIO_NET_F_CTRL_VLAN) | \ BIT_ULL(VIRTIO_NET_F_CTRL_RX) | BIT_ULL(VIRTIO_NET_F_CTRL_VLAN) | \
BIT(VIRTIO_NET_F_CTRL_RX_EXTRA) | BIT(VIRTIO_NET_F_GUEST_ANNOUNCE) | \ BIT_ULL(VIRTIO_NET_F_CTRL_RX_EXTRA) | BIT_ULL(VIRTIO_NET_F_GUEST_ANNOUNCE) | \
BIT(VIRTIO_NET_F_MQ) | BIT(VIRTIO_NET_F_CTRL_MAC_ADDR) | BIT(VIRTIO_NET_F_HASH_REPORT) | \ BIT_ULL(VIRTIO_NET_F_MQ) | BIT_ULL(VIRTIO_NET_F_CTRL_MAC_ADDR) | BIT_ULL(VIRTIO_NET_F_HASH_REPORT) | \
BIT(VIRTIO_NET_F_RSS) | BIT(VIRTIO_NET_F_RSC_EXT) | BIT(VIRTIO_NET_F_STANDBY) | \ BIT_ULL(VIRTIO_NET_F_RSS) | BIT_ULL(VIRTIO_NET_F_RSC_EXT) | BIT_ULL(VIRTIO_NET_F_STANDBY) | \
BIT(VIRTIO_NET_F_SPEED_DUPLEX) | BIT(VIRTIO_F_NOTIFY_ON_EMPTY) | \ BIT_ULL(VIRTIO_NET_F_SPEED_DUPLEX) | BIT_ULL(VIRTIO_F_NOTIFY_ON_EMPTY) | \
BIT(VIRTIO_F_ANY_LAYOUT) | BIT(VIRTIO_F_VERSION_1) | BIT(VIRTIO_F_ACCESS_PLATFORM) | \ BIT_ULL(VIRTIO_F_ANY_LAYOUT) | BIT_ULL(VIRTIO_F_VERSION_1) | BIT_ULL(VIRTIO_F_ACCESS_PLATFORM) | \
BIT(VIRTIO_F_RING_PACKED) | BIT(VIRTIO_F_ORDER_PLATFORM) | BIT(VIRTIO_F_SR_IOV)) BIT_ULL(VIRTIO_F_RING_PACKED) | BIT_ULL(VIRTIO_F_ORDER_PLATFORM) | BIT_ULL(VIRTIO_F_SR_IOV))
#define VALID_STATUS_MASK \ #define VALID_STATUS_MASK \
(VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_DRIVER_OK | \ (VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_DRIVER_OK | \
@ -149,7 +149,7 @@ static bool mlx5_vdpa_debug;
#define MLX5_LOG_VIO_FLAG(_feature) \ #define MLX5_LOG_VIO_FLAG(_feature) \
do { \ do { \
if (features & BIT(_feature)) \ if (features & BIT_ULL(_feature)) \
mlx5_vdpa_info(mvdev, "%s\n", #_feature); \ mlx5_vdpa_info(mvdev, "%s\n", #_feature); \
} while (0) } while (0)
@ -750,10 +750,10 @@ static bool vq_is_tx(u16 idx)
static u16 get_features_12_3(u64 features) static u16 get_features_12_3(u64 features)
{ {
return (!!(features & BIT(VIRTIO_NET_F_HOST_TSO4)) << 9) | return (!!(features & BIT_ULL(VIRTIO_NET_F_HOST_TSO4)) << 9) |
(!!(features & BIT(VIRTIO_NET_F_HOST_TSO6)) << 8) | (!!(features & BIT_ULL(VIRTIO_NET_F_HOST_TSO6)) << 8) |
(!!(features & BIT(VIRTIO_NET_F_CSUM)) << 7) | (!!(features & BIT_ULL(VIRTIO_NET_F_CSUM)) << 7) |
(!!(features & BIT(VIRTIO_NET_F_GUEST_CSUM)) << 6); (!!(features & BIT_ULL(VIRTIO_NET_F_GUEST_CSUM)) << 6);
} }
static int create_virtqueue(struct mlx5_vdpa_net *ndev, struct mlx5_vdpa_virtqueue *mvq) static int create_virtqueue(struct mlx5_vdpa_net *ndev, struct mlx5_vdpa_virtqueue *mvq)
@ -1439,13 +1439,13 @@ static u64 mlx_to_vritio_features(u16 dev_features)
u64 result = 0; u64 result = 0;
if (dev_features & MLX5_VIRTIO_NET_F_GUEST_CSUM) if (dev_features & MLX5_VIRTIO_NET_F_GUEST_CSUM)
result |= BIT(VIRTIO_NET_F_GUEST_CSUM); result |= BIT_ULL(VIRTIO_NET_F_GUEST_CSUM);
if (dev_features & MLX5_VIRTIO_NET_F_CSUM) if (dev_features & MLX5_VIRTIO_NET_F_CSUM)
result |= BIT(VIRTIO_NET_F_CSUM); result |= BIT_ULL(VIRTIO_NET_F_CSUM);
if (dev_features & MLX5_VIRTIO_NET_F_HOST_TSO6) if (dev_features & MLX5_VIRTIO_NET_F_HOST_TSO6)
result |= BIT(VIRTIO_NET_F_HOST_TSO6); result |= BIT_ULL(VIRTIO_NET_F_HOST_TSO6);
if (dev_features & MLX5_VIRTIO_NET_F_HOST_TSO4) if (dev_features & MLX5_VIRTIO_NET_F_HOST_TSO4)
result |= BIT(VIRTIO_NET_F_HOST_TSO4); result |= BIT_ULL(VIRTIO_NET_F_HOST_TSO4);
return result; return result;
} }
@ -1459,15 +1459,15 @@ static u64 mlx5_vdpa_get_features(struct vdpa_device *vdev)
dev_features = MLX5_CAP_DEV_VDPA_EMULATION(mvdev->mdev, device_features_bits_mask); dev_features = MLX5_CAP_DEV_VDPA_EMULATION(mvdev->mdev, device_features_bits_mask);
ndev->mvdev.mlx_features = mlx_to_vritio_features(dev_features); ndev->mvdev.mlx_features = mlx_to_vritio_features(dev_features);
if (MLX5_CAP_DEV_VDPA_EMULATION(mvdev->mdev, virtio_version_1_0)) if (MLX5_CAP_DEV_VDPA_EMULATION(mvdev->mdev, virtio_version_1_0))
ndev->mvdev.mlx_features |= BIT(VIRTIO_F_VERSION_1); ndev->mvdev.mlx_features |= BIT_ULL(VIRTIO_F_VERSION_1);
ndev->mvdev.mlx_features |= BIT(VIRTIO_F_ACCESS_PLATFORM); ndev->mvdev.mlx_features |= BIT_ULL(VIRTIO_F_ACCESS_PLATFORM);
print_features(mvdev, ndev->mvdev.mlx_features, false); print_features(mvdev, ndev->mvdev.mlx_features, false);
return ndev->mvdev.mlx_features; return ndev->mvdev.mlx_features;
} }
static int verify_min_features(struct mlx5_vdpa_dev *mvdev, u64 features) static int verify_min_features(struct mlx5_vdpa_dev *mvdev, u64 features)
{ {
if (!(features & BIT(VIRTIO_F_ACCESS_PLATFORM))) if (!(features & BIT_ULL(VIRTIO_F_ACCESS_PLATFORM)))
return -EOPNOTSUPP; return -EOPNOTSUPP;
return 0; return 0;

4
drivers/vhost/iotlb.c
View File

@ -159,8 +159,8 @@ vhost_iotlb_itree_first(struct vhost_iotlb *iotlb, u64 start, u64 last)
EXPORT_SYMBOL_GPL(vhost_iotlb_itree_first); EXPORT_SYMBOL_GPL(vhost_iotlb_itree_first);
/** /**
* vhost_iotlb_itree_first - return the next overlapped range * vhost_iotlb_itree_next - return the next overlapped range
* @iotlb: the IOTLB * @map: the starting map node
* @start: start of IOVA range * @start: start of IOVA range
* @end: end of IOVA range * @end: end of IOVA range
*/ */