Skip to content

Commit 2a50b1e

Browse files
torvaldstorvalds
committed
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
Pull virtio updates from Michael Tsirkin: "A small number of improvements all over the place" * tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost: virtio_vdpa: remove redundant check on desc virtio_fs: store actual queue index in mq_map virtio_fs: add informative log for new tag discovery virtio: Make vring_new_virtqueue support packed vring virtio_pmem: Add freeze/restore callbacks vdpa/mlx5: Fix suboptimal range on iotlb iteration
2 parents 4aca98a + 6a39bb1 commit 2a50b1e

File tree

5 files changed

+152
-117
lines changed

5 files changed

+152
-117
lines changed

‎drivers/nvdimm/virtio_pmem.c‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -143,6 +143,28 @@ static void virtio_pmem_remove(struct virtio_device *vdev)
143143
virtio_reset_device(vdev);
144144
}
145145

146+
static int virtio_pmem_freeze(struct virtio_device *vdev)
147+
{
148+
vdev->config->del_vqs(vdev);
149+
virtio_reset_device(vdev);
150+
151+
return 0;
152+
}
153+
154+
static int virtio_pmem_restore(struct virtio_device *vdev)
155+
{
156+
int ret;
157+
158+
ret = init_vq(vdev->priv);
159+
if (ret) {
160+
dev_err(&vdev->dev, "failed to initialize virtio pmem's vq\n");
161+
return ret;
162+
}
163+
virtio_device_ready(vdev);
164+
165+
return 0;
166+
}
167+
146168
static unsigned int features[] = {
147169
VIRTIO_PMEM_F_SHMEM_REGION,
148170
};
@@ -155,6 +177,8 @@ static struct virtio_driver virtio_pmem_driver = {
155177
.validate = virtio_pmem_validate,
156178
.probe = virtio_pmem_probe,
157179
.remove = virtio_pmem_remove,
180+
.freeze = virtio_pmem_freeze,
181+
.restore = virtio_pmem_restore,
158182
};
159183

160184
module_virtio_driver(virtio_pmem_driver);

‎drivers/vdpa/mlx5/core/mr.c‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -368,7 +368,6 @@ static int map_direct_mr(struct mlx5_vdpa_dev *mvdev, struct mlx5_vdpa_direct_mr
368368
unsigned long lgcd = 0;
369369
int log_entity_size;
370370
unsigned long size;
371-
u64 start = 0;
372371
int err;
373372
struct page *pg;
374373
unsigned int nsg;
@@ -379,10 +378,9 @@ static int map_direct_mr(struct mlx5_vdpa_dev *mvdev, struct mlx5_vdpa_direct_mr
379378
struct device *dma = mvdev->vdev.dma_dev;
380379

381380
for (map = vhost_iotlb_itree_first(iotlb, mr->start, mr->end - 1);
382-
map; map = vhost_iotlb_itree_next(map, start, mr->end - 1)) {
381+
map; map = vhost_iotlb_itree_next(map, mr->start, mr->end - 1)) {
383382
size = maplen(map, mr);
384383
lgcd = gcd(lgcd, size);
385-
start += size;
386384
}
387385
log_entity_size = ilog2(lgcd);
388386

‎drivers/virtio/virtio_ring.c‎

Lines changed: 119 additions & 106 deletions
Original file line numberDiff line numberDiff line change
@@ -223,15 +223,6 @@ struct vring_virtqueue {
223223
#endif
224224
};
225225

226-
static struct virtqueue *__vring_new_virtqueue(unsigned int index,
227-
struct vring_virtqueue_split *vring_split,
228-
struct virtio_device *vdev,
229-
bool weak_barriers,
230-
bool context,
231-
bool (*notify)(struct virtqueue *),
232-
void (*callback)(struct virtqueue *),
233-
const char *name,
234-
struct device *dma_dev);
235226
static struct vring_desc_extra *vring_alloc_desc_extra(unsigned int num);
236227
static void vring_free(struct virtqueue *_vq);
237228

@@ -1135,6 +1126,64 @@ static int vring_alloc_queue_split(struct vring_virtqueue_split *vring_split,
11351126
return 0;
11361127
}
11371128

1129+
static struct virtqueue *__vring_new_virtqueue_split(unsigned int index,
1130+
struct vring_virtqueue_split *vring_split,
1131+
struct virtio_device *vdev,
1132+
bool weak_barriers,
1133+
bool context,
1134+
bool (*notify)(struct virtqueue *),
1135+
void (*callback)(struct virtqueue *),
1136+
const char *name,
1137+
struct device *dma_dev)
1138+
{
1139+
struct vring_virtqueue *vq;
1140+
int err;
1141+
1142+
vq = kmalloc(sizeof(*vq), GFP_KERNEL);
1143+
if (!vq)
1144+
return NULL;
1145+
1146+
vq->packed_ring = false;
1147+
vq->vq.callback = callback;
1148+
vq->vq.vdev = vdev;
1149+
vq->vq.name = name;
1150+
vq->vq.index = index;
1151+
vq->vq.reset = false;
1152+
vq->we_own_ring = false;
1153+
vq->notify = notify;
1154+
vq->weak_barriers = weak_barriers;
1155+
#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
1156+
vq->broken = true;
1157+
#else
1158+
vq->broken = false;
1159+
#endif
1160+
vq->dma_dev = dma_dev;
1161+
vq->use_dma_api = vring_use_dma_api(vdev);
1162+
1163+
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
1164+
!context;
1165+
vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
1166+
1167+
if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
1168+
vq->weak_barriers = false;
1169+
1170+
err = vring_alloc_state_extra_split(vring_split);
1171+
if (err) {
1172+
kfree(vq);
1173+
return NULL;
1174+
}
1175+
1176+
virtqueue_vring_init_split(vring_split, vq);
1177+
1178+
virtqueue_init(vq, vring_split->vring.num);
1179+
virtqueue_vring_attach_split(vq, vring_split);
1180+
1181+
spin_lock(&vdev->vqs_list_lock);
1182+
list_add_tail(&vq->vq.list, &vdev->vqs);
1183+
spin_unlock(&vdev->vqs_list_lock);
1184+
return &vq->vq;
1185+
}
1186+
11381187
static struct virtqueue *vring_create_virtqueue_split(
11391188
unsigned int index,
11401189
unsigned int num,
@@ -1157,7 +1206,7 @@ static struct virtqueue *vring_create_virtqueue_split(
11571206
if (err)
11581207
return NULL;
11591208

1160-
vq = __vring_new_virtqueue(index, &vring_split, vdev, weak_barriers,
1209+
vq = __vring_new_virtqueue_split(index, &vring_split, vdev, weak_barriers,
11611210
context, notify, callback, name, dma_dev);
11621211
if (!vq) {
11631212
vring_free_split(&vring_split, vdev, dma_dev);
@@ -2055,36 +2104,29 @@ static void virtqueue_reinit_packed(struct vring_virtqueue *vq)
20552104
virtqueue_vring_init_packed(&vq->packed, !!vq->vq.callback);
20562105
}
20572106

2058-
static struct virtqueue *vring_create_virtqueue_packed(
2059-
unsigned int index,
2060-
unsigned int num,
2061-
unsigned int vring_align,
2062-
struct virtio_device *vdev,
2063-
bool weak_barriers,
2064-
bool may_reduce_num,
2065-
bool context,
2066-
bool (*notify)(struct virtqueue *),
2067-
void (*callback)(struct virtqueue *),
2068-
const char *name,
2069-
struct device *dma_dev)
2107+
static struct virtqueue *__vring_new_virtqueue_packed(unsigned int index,
2108+
struct vring_virtqueue_packed *vring_packed,
2109+
struct virtio_device *vdev,
2110+
bool weak_barriers,
2111+
bool context,
2112+
bool (*notify)(struct virtqueue *),
2113+
void (*callback)(struct virtqueue *),
2114+
const char *name,
2115+
struct device *dma_dev)
20702116
{
2071-
struct vring_virtqueue_packed vring_packed = {};
20722117
struct vring_virtqueue *vq;
20732118
int err;
20742119

2075-
if (vring_alloc_queue_packed(&vring_packed, vdev, num, dma_dev))
2076-
goto err_ring;
2077-
20782120
vq = kmalloc(sizeof(*vq), GFP_KERNEL);
20792121
if (!vq)
2080-
goto err_vq;
2122+
return NULL;
20812123

20822124
vq->vq.callback = callback;
20832125
vq->vq.vdev = vdev;
20842126
vq->vq.name = name;
20852127
vq->vq.index = index;
20862128
vq->vq.reset = false;
2087-
vq->we_own_ring = true;
2129+
vq->we_own_ring = false;
20882130
vq->notify = notify;
20892131
vq->weak_barriers = weak_barriers;
20902132
#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
@@ -2103,26 +2145,52 @@ static struct virtqueue *vring_create_virtqueue_packed(
21032145
if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
21042146
vq->weak_barriers = false;
21052147

2106-
err = vring_alloc_state_extra_packed(&vring_packed);
2107-
if (err)
2108-
goto err_state_extra;
2148+
err = vring_alloc_state_extra_packed(vring_packed);
2149+
if (err) {
2150+
kfree(vq);
2151+
return NULL;
2152+
}
21092153

2110-
virtqueue_vring_init_packed(&vring_packed, !!callback);
2154+
virtqueue_vring_init_packed(vring_packed, !!callback);
21112155

2112-
virtqueue_init(vq, num);
2113-
virtqueue_vring_attach_packed(vq, &vring_packed);
2156+
virtqueue_init(vq, vring_packed->vring.num);
2157+
virtqueue_vring_attach_packed(vq, vring_packed);
21142158

21152159
spin_lock(&vdev->vqs_list_lock);
21162160
list_add_tail(&vq->vq.list, &vdev->vqs);
21172161
spin_unlock(&vdev->vqs_list_lock);
21182162
return &vq->vq;
2163+
}
21192164

2120-
err_state_extra:
2121-
kfree(vq);
2122-
err_vq:
2123-
vring_free_packed(&vring_packed, vdev, dma_dev);
2124-
err_ring:
2125-
return NULL;
2165+
static struct virtqueue *vring_create_virtqueue_packed(
2166+
unsigned int index,
2167+
unsigned int num,
2168+
unsigned int vring_align,
2169+
struct virtio_device *vdev,
2170+
bool weak_barriers,
2171+
bool may_reduce_num,
2172+
bool context,
2173+
bool (*notify)(struct virtqueue *),
2174+
void (*callback)(struct virtqueue *),
2175+
const char *name,
2176+
struct device *dma_dev)
2177+
{
2178+
struct vring_virtqueue_packed vring_packed = {};
2179+
struct virtqueue *vq;
2180+
2181+
if (vring_alloc_queue_packed(&vring_packed, vdev, num, dma_dev))
2182+
return NULL;
2183+
2184+
vq = __vring_new_virtqueue_packed(index, &vring_packed, vdev, weak_barriers,
2185+
context, notify, callback, name, dma_dev);
2186+
if (!vq) {
2187+
vring_free_packed(&vring_packed, vdev, dma_dev);
2188+
return NULL;
2189+
}
2190+
2191+
to_vvq(vq)->we_own_ring = true;
2192+
2193+
return vq;
21262194
}
21272195

21282196
static int virtqueue_resize_packed(struct virtqueue *_vq, u32 num)
@@ -2650,68 +2718,6 @@ irqreturn_t vring_interrupt(int irq, void *_vq)
26502718
}
26512719
EXPORT_SYMBOL_GPL(vring_interrupt);
26522720

2653-
/* Only available for split ring */
2654-
static struct virtqueue *__vring_new_virtqueue(unsigned int index,
2655-
struct vring_virtqueue_split *vring_split,
2656-
struct virtio_device *vdev,
2657-
bool weak_barriers,
2658-
bool context,
2659-
bool (*notify)(struct virtqueue *),
2660-
void (*callback)(struct virtqueue *),
2661-
const char *name,
2662-
struct device *dma_dev)
2663-
{
2664-
struct vring_virtqueue *vq;
2665-
int err;
2666-
2667-
if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED))
2668-
return NULL;
2669-
2670-
vq = kmalloc(sizeof(*vq), GFP_KERNEL);
2671-
if (!vq)
2672-
return NULL;
2673-
2674-
vq->packed_ring = false;
2675-
vq->vq.callback = callback;
2676-
vq->vq.vdev = vdev;
2677-
vq->vq.name = name;
2678-
vq->vq.index = index;
2679-
vq->vq.reset = false;
2680-
vq->we_own_ring = false;
2681-
vq->notify = notify;
2682-
vq->weak_barriers = weak_barriers;
2683-
#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
2684-
vq->broken = true;
2685-
#else
2686-
vq->broken = false;
2687-
#endif
2688-
vq->dma_dev = dma_dev;
2689-
vq->use_dma_api = vring_use_dma_api(vdev);
2690-
2691-
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
2692-
!context;
2693-
vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
2694-
2695-
if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))
2696-
vq->weak_barriers = false;
2697-
2698-
err = vring_alloc_state_extra_split(vring_split);
2699-
if (err) {
2700-
kfree(vq);
2701-
return NULL;
2702-
}
2703-
2704-
virtqueue_vring_init_split(vring_split, vq);
2705-
2706-
virtqueue_init(vq, vring_split->vring.num);
2707-
virtqueue_vring_attach_split(vq, vring_split);
2708-
2709-
spin_lock(&vdev->vqs_list_lock);
2710-
list_add_tail(&vq->vq.list, &vdev->vqs);
2711-
spin_unlock(&vdev->vqs_list_lock);
2712-
return &vq->vq;
2713-
}
2714-
27152721
struct virtqueue *vring_create_virtqueue(
27162722
unsigned int index,
27172723
unsigned int num,
@@ -2846,7 +2852,6 @@ int virtqueue_reset(struct virtqueue *_vq,
28462852
}
28472853
EXPORT_SYMBOL_GPL(virtqueue_reset);
28482854

2849-
/* Only available for split ring */
28502855
struct virtqueue *vring_new_virtqueue(unsigned int index,
28512856
unsigned int num,
28522857
unsigned int vring_align,
@@ -2860,11 +2865,19 @@ struct virtqueue *vring_new_virtqueue(unsigned int index,
28602865
{
28612866
struct vring_virtqueue_split vring_split = {};
28622867

2863-
if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED))
2864-
return NULL;
2868+
if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED)) {
2869+
struct vring_virtqueue_packed vring_packed = {};
2870+
2871+
vring_packed.vring.num = num;
2872+
vring_packed.vring.desc = pages;
2873+
return __vring_new_virtqueue_packed(index, &vring_packed,
2874+
vdev, weak_barriers,
2875+
context, notify, callback,
2876+
name, vdev->dev.parent);
2877+
}
28652878

28662879
vring_init(&vring_split.vring, num, pages, vring_align);
2867-
return __vring_new_virtqueue(index, &vring_split, vdev, weak_barriers,
2880+
return __vring_new_virtqueue_split(index, &vring_split, vdev, weak_barriers,
28682881
context, notify, callback, name,
28692882
vdev->dev.parent);
28702883
}

‎drivers/virtio/virtio_vdpa.c‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -364,14 +364,13 @@ static int virtio_vdpa_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
364364
struct virtio_vdpa_device *vd_dev = to_virtio_vdpa_device(vdev);
365365
struct vdpa_device *vdpa = vd_get_vdpa(vdev);
366366
const struct vdpa_config_ops *ops = vdpa->config;
367-
struct irq_affinity default_affd = { 0 };
368367
struct cpumask *masks;
369368
struct vdpa_callback cb;
370369
bool has_affinity = desc && ops->set_vq_affinity;
371370
int i, err, queue_idx = 0;
372371

373372
if (has_affinity) {
374-
masks = create_affinity_masks(nvqs, desc ? desc : &default_affd);
373+
masks = create_affinity_masks(nvqs, desc);
375374
if (!masks)
376375
return -ENOMEM;
377376
}

0 commit comments

Comments
 (0)