xref: /openbmc/linux/drivers/vdpa/vdpa_sim/vdpa_sim.c (revision 15e3ae36) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * VDPA networking device simulator.
4  *
5  * Copyright (c) 2020, Red Hat Inc. All rights reserved.
6  *     Author: Jason Wang <jasowang@redhat.com>
7  *
8  */
9 
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/device.h>
13 #include <linux/kernel.h>
14 #include <linux/fs.h>
15 #include <linux/poll.h>
16 #include <linux/slab.h>
17 #include <linux/sched.h>
18 #include <linux/wait.h>
19 #include <linux/uuid.h>
20 #include <linux/iommu.h>
21 #include <linux/dma-mapping.h>
22 #include <linux/sysfs.h>
23 #include <linux/file.h>
24 #include <linux/etherdevice.h>
25 #include <linux/vringh.h>
26 #include <linux/vdpa.h>
27 #include <linux/vhost_iotlb.h>
28 #include <uapi/linux/virtio_config.h>
29 #include <uapi/linux/virtio_net.h>
30 
31 #define DRV_VERSION  "0.1"
32 #define DRV_AUTHOR   "Jason Wang <jasowang@redhat.com>"
33 #define DRV_DESC     "vDPA Device Simulator"
34 #define DRV_LICENSE  "GPL v2"
35 
36 struct vdpasim_virtqueue {
37 	struct vringh vring;
38 	struct vringh_kiov iov;
39 	unsigned short head;
40 	bool ready;
41 	u64 desc_addr;
42 	u64 device_addr;
43 	u64 driver_addr;
44 	u32 num;
45 	void *private;
46 	irqreturn_t (*cb)(void *data);
47 };
48 
49 #define VDPASIM_QUEUE_ALIGN PAGE_SIZE
50 #define VDPASIM_QUEUE_MAX 256
51 #define VDPASIM_DEVICE_ID 0x1
52 #define VDPASIM_VENDOR_ID 0
53 #define VDPASIM_VQ_NUM 0x2
54 #define VDPASIM_NAME "vdpasim-netdev"
55 
56 static u64 vdpasim_features = (1ULL << VIRTIO_F_ANY_LAYOUT) |
57 			      (1ULL << VIRTIO_F_VERSION_1)  |
58 			      (1ULL << VIRTIO_F_IOMMU_PLATFORM);
59 
60 /* State of each vdpasim device */
61 struct vdpasim {
62 	struct vdpa_device vdpa;
63 	struct vdpasim_virtqueue vqs[2];
64 	struct work_struct work;
65 	/* spinlock to synchronize virtqueue state */
66 	spinlock_t lock;
67 	struct virtio_net_config config;
68 	struct vhost_iotlb *iommu;
69 	void *buffer;
70 	u32 status;
71 	u32 generation;
72 	u64 features;
73 };
74 
75 static struct vdpasim *vdpasim_dev;
76 
77 static struct vdpasim *vdpa_to_sim(struct vdpa_device *vdpa)
78 {
79 	return container_of(vdpa, struct vdpasim, vdpa);
80 }
81 
82 static struct vdpasim *dev_to_sim(struct device *dev)
83 {
84 	struct vdpa_device *vdpa = dev_to_vdpa(dev);
85 
86 	return vdpa_to_sim(vdpa);
87 }
88 
89 static void vdpasim_queue_ready(struct vdpasim *vdpasim, unsigned int idx)
90 {
91 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
92 	int ret;
93 
94 	ret = vringh_init_iotlb(&vq->vring, vdpasim_features,
95 				VDPASIM_QUEUE_MAX, false,
96 				(struct vring_desc *)(uintptr_t)vq->desc_addr,
97 				(struct vring_avail *)
98 				(uintptr_t)vq->driver_addr,
99 				(struct vring_used *)
100 				(uintptr_t)vq->device_addr);
101 }
102 
103 static void vdpasim_vq_reset(struct vdpasim_virtqueue *vq)
104 {
105 	vq->ready = 0;
106 	vq->desc_addr = 0;
107 	vq->driver_addr = 0;
108 	vq->device_addr = 0;
109 	vq->cb = NULL;
110 	vq->private = NULL;
111 	vringh_init_iotlb(&vq->vring, vdpasim_features, VDPASIM_QUEUE_MAX,
112 			  false, NULL, NULL, NULL);
113 }
114 
115 static void vdpasim_reset(struct vdpasim *vdpasim)
116 {
117 	int i;
118 
119 	for (i = 0; i < VDPASIM_VQ_NUM; i++)
120 		vdpasim_vq_reset(&vdpasim->vqs[i]);
121 
122 	vhost_iotlb_reset(vdpasim->iommu);
123 
124 	vdpasim->features = 0;
125 	vdpasim->status = 0;
126 	++vdpasim->generation;
127 }
128 
129 static void vdpasim_work(struct work_struct *work)
130 {
131 	struct vdpasim *vdpasim = container_of(work, struct
132 						 vdpasim, work);
133 	struct vdpasim_virtqueue *txq = &vdpasim->vqs[1];
134 	struct vdpasim_virtqueue *rxq = &vdpasim->vqs[0];
135 	size_t read, write, total_write;
136 	int err;
137 	int pkts = 0;
138 
139 	spin_lock(&vdpasim->lock);
140 
141 	if (!(vdpasim->status & VIRTIO_CONFIG_S_DRIVER_OK))
142 		goto out;
143 
144 	if (!txq->ready || !rxq->ready)
145 		goto out;
146 
147 	while (true) {
148 		total_write = 0;
149 		err = vringh_getdesc_iotlb(&txq->vring, &txq->iov, NULL,
150 					   &txq->head, GFP_ATOMIC);
151 		if (err <= 0)
152 			break;
153 
154 		err = vringh_getdesc_iotlb(&rxq->vring, NULL, &rxq->iov,
155 					   &rxq->head, GFP_ATOMIC);
156 		if (err <= 0) {
157 			vringh_complete_iotlb(&txq->vring, txq->head, 0);
158 			break;
159 		}
160 
161 		while (true) {
162 			read = vringh_iov_pull_iotlb(&txq->vring, &txq->iov,
163 						     vdpasim->buffer,
164 						     PAGE_SIZE);
165 			if (read <= 0)
166 				break;
167 
168 			write = vringh_iov_push_iotlb(&rxq->vring, &rxq->iov,
169 						      vdpasim->buffer, read);
170 			if (write <= 0)
171 				break;
172 
173 			total_write += write;
174 		}
175 
176 		/* Make sure data is wrote before advancing index */
177 		smp_wmb();
178 
179 		vringh_complete_iotlb(&txq->vring, txq->head, 0);
180 		vringh_complete_iotlb(&rxq->vring, rxq->head, total_write);
181 
182 		/* Make sure used is visible before rasing the interrupt. */
183 		smp_wmb();
184 
185 		local_bh_disable();
186 		if (txq->cb)
187 			txq->cb(txq->private);
188 		if (rxq->cb)
189 			rxq->cb(rxq->private);
190 		local_bh_enable();
191 
192 		if (++pkts > 4) {
193 			schedule_work(&vdpasim->work);
194 			goto out;
195 		}
196 	}
197 
198 out:
199 	spin_unlock(&vdpasim->lock);
200 }
201 
202 static int dir_to_perm(enum dma_data_direction dir)
203 {
204 	int perm = -EFAULT;
205 
206 	switch (dir) {
207 	case DMA_FROM_DEVICE:
208 		perm = VHOST_MAP_WO;
209 		break;
210 	case DMA_TO_DEVICE:
211 		perm = VHOST_MAP_RO;
212 		break;
213 	case DMA_BIDIRECTIONAL:
214 		perm = VHOST_MAP_RW;
215 		break;
216 	default:
217 		break;
218 	}
219 
220 	return perm;
221 }
222 
223 static dma_addr_t vdpasim_map_page(struct device *dev, struct page *page,
224 				   unsigned long offset, size_t size,
225 				   enum dma_data_direction dir,
226 				   unsigned long attrs)
227 {
228 	struct vdpasim *vdpasim = dev_to_sim(dev);
229 	struct vhost_iotlb *iommu = vdpasim->iommu;
230 	u64 pa = (page_to_pfn(page) << PAGE_SHIFT) + offset;
231 	int ret, perm = dir_to_perm(dir);
232 
233 	if (perm < 0)
234 		return DMA_MAPPING_ERROR;
235 
236 	/* For simplicity, use identical mapping to avoid e.g iova
237 	 * allocator.
238 	 */
239 	ret = vhost_iotlb_add_range(iommu, pa, pa + size - 1,
240 				    pa, dir_to_perm(dir));
241 	if (ret)
242 		return DMA_MAPPING_ERROR;
243 
244 	return (dma_addr_t)(pa);
245 }
246 
247 static void vdpasim_unmap_page(struct device *dev, dma_addr_t dma_addr,
248 			       size_t size, enum dma_data_direction dir,
249 			       unsigned long attrs)
250 {
251 	struct vdpasim *vdpasim = dev_to_sim(dev);
252 	struct vhost_iotlb *iommu = vdpasim->iommu;
253 
254 	vhost_iotlb_del_range(iommu, (u64)dma_addr,
255 			      (u64)dma_addr + size - 1);
256 }
257 
258 static void *vdpasim_alloc_coherent(struct device *dev, size_t size,
259 				    dma_addr_t *dma_addr, gfp_t flag,
260 				    unsigned long attrs)
261 {
262 	struct vdpasim *vdpasim = dev_to_sim(dev);
263 	struct vhost_iotlb *iommu = vdpasim->iommu;
264 	void *addr = kmalloc(size, flag);
265 	int ret;
266 
267 	if (!addr)
268 		*dma_addr = DMA_MAPPING_ERROR;
269 	else {
270 		u64 pa = virt_to_phys(addr);
271 
272 		ret = vhost_iotlb_add_range(iommu, (u64)pa,
273 					    (u64)pa + size - 1,
274 					    pa, VHOST_MAP_RW);
275 		if (ret) {
276 			*dma_addr = DMA_MAPPING_ERROR;
277 			kfree(addr);
278 			addr = NULL;
279 		} else
280 			*dma_addr = (dma_addr_t)pa;
281 	}
282 
283 	return addr;
284 }
285 
286 static void vdpasim_free_coherent(struct device *dev, size_t size,
287 				  void *vaddr, dma_addr_t dma_addr,
288 				  unsigned long attrs)
289 {
290 	struct vdpasim *vdpasim = dev_to_sim(dev);
291 	struct vhost_iotlb *iommu = vdpasim->iommu;
292 
293 	vhost_iotlb_del_range(iommu, (u64)dma_addr,
294 			      (u64)dma_addr + size - 1);
295 	kfree(phys_to_virt((uintptr_t)dma_addr));
296 }
297 
298 static const struct dma_map_ops vdpasim_dma_ops = {
299 	.map_page = vdpasim_map_page,
300 	.unmap_page = vdpasim_unmap_page,
301 	.alloc = vdpasim_alloc_coherent,
302 	.free = vdpasim_free_coherent,
303 };
304 
305 static const struct vdpa_config_ops vdpasim_net_config_ops;
306 
307 static struct vdpasim *vdpasim_create(void)
308 {
309 	struct virtio_net_config *config;
310 	struct vdpasim *vdpasim;
311 	struct device *dev;
312 	int ret = -ENOMEM;
313 
314 	vdpasim = vdpa_alloc_device(struct vdpasim, vdpa, NULL,
315 				    &vdpasim_net_config_ops);
316 	if (!vdpasim)
317 		goto err_alloc;
318 
319 	INIT_WORK(&vdpasim->work, vdpasim_work);
320 	spin_lock_init(&vdpasim->lock);
321 
322 	dev = &vdpasim->vdpa.dev;
323 	dev->coherent_dma_mask = DMA_BIT_MASK(64);
324 	set_dma_ops(dev, &vdpasim_dma_ops);
325 
326 	vdpasim->iommu = vhost_iotlb_alloc(2048, 0);
327 	if (!vdpasim->iommu)
328 		goto err_iommu;
329 
330 	vdpasim->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
331 	if (!vdpasim->buffer)
332 		goto err_iommu;
333 
334 	config = &vdpasim->config;
335 	config->mtu = 1500;
336 	config->status = VIRTIO_NET_S_LINK_UP;
337 	eth_random_addr(config->mac);
338 
339 	vringh_set_iotlb(&vdpasim->vqs[0].vring, vdpasim->iommu);
340 	vringh_set_iotlb(&vdpasim->vqs[1].vring, vdpasim->iommu);
341 
342 	vdpasim->vdpa.dma_dev = dev;
343 	ret = vdpa_register_device(&vdpasim->vdpa);
344 	if (ret)
345 		goto err_iommu;
346 
347 	return vdpasim;
348 
349 err_iommu:
350 	put_device(dev);
351 err_alloc:
352 	return ERR_PTR(ret);
353 }
354 
355 static int vdpasim_set_vq_address(struct vdpa_device *vdpa, u16 idx,
356 				  u64 desc_area, u64 driver_area,
357 				  u64 device_area)
358 {
359 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
360 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
361 
362 	vq->desc_addr = desc_area;
363 	vq->driver_addr = driver_area;
364 	vq->device_addr = device_area;
365 
366 	return 0;
367 }
368 
369 static void vdpasim_set_vq_num(struct vdpa_device *vdpa, u16 idx, u32 num)
370 {
371 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
372 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
373 
374 	vq->num = num;
375 }
376 
377 static void vdpasim_kick_vq(struct vdpa_device *vdpa, u16 idx)
378 {
379 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
380 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
381 
382 	if (vq->ready)
383 		schedule_work(&vdpasim->work);
384 }
385 
386 static void vdpasim_set_vq_cb(struct vdpa_device *vdpa, u16 idx,
387 			      struct vdpa_callback *cb)
388 {
389 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
390 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
391 
392 	vq->cb = cb->callback;
393 	vq->private = cb->private;
394 }
395 
396 static void vdpasim_set_vq_ready(struct vdpa_device *vdpa, u16 idx, bool ready)
397 {
398 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
399 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
400 
401 	spin_lock(&vdpasim->lock);
402 	vq->ready = ready;
403 	if (vq->ready)
404 		vdpasim_queue_ready(vdpasim, idx);
405 	spin_unlock(&vdpasim->lock);
406 }
407 
408 static bool vdpasim_get_vq_ready(struct vdpa_device *vdpa, u16 idx)
409 {
410 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
411 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
412 
413 	return vq->ready;
414 }
415 
416 static int vdpasim_set_vq_state(struct vdpa_device *vdpa, u16 idx, u64 state)
417 {
418 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
419 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
420 	struct vringh *vrh = &vq->vring;
421 
422 	spin_lock(&vdpasim->lock);
423 	vrh->last_avail_idx = state;
424 	spin_unlock(&vdpasim->lock);
425 
426 	return 0;
427 }
428 
429 static u64 vdpasim_get_vq_state(struct vdpa_device *vdpa, u16 idx)
430 {
431 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
432 	struct vdpasim_virtqueue *vq = &vdpasim->vqs[idx];
433 	struct vringh *vrh = &vq->vring;
434 
435 	return vrh->last_avail_idx;
436 }
437 
438 static u16 vdpasim_get_vq_align(struct vdpa_device *vdpa)
439 {
440 	return VDPASIM_QUEUE_ALIGN;
441 }
442 
443 static u64 vdpasim_get_features(struct vdpa_device *vdpa)
444 {
445 	return vdpasim_features;
446 }
447 
448 static int vdpasim_set_features(struct vdpa_device *vdpa, u64 features)
449 {
450 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
451 
452 	/* DMA mapping must be done by driver */
453 	if (!(features & (1ULL << VIRTIO_F_IOMMU_PLATFORM)))
454 		return -EINVAL;
455 
456 	vdpasim->features = features & vdpasim_features;
457 
458 	return 0;
459 }
460 
461 static void vdpasim_set_config_cb(struct vdpa_device *vdpa,
462 				  struct vdpa_callback *cb)
463 {
464 	/* We don't support config interrupt */
465 }
466 
467 static u16 vdpasim_get_vq_num_max(struct vdpa_device *vdpa)
468 {
469 	return VDPASIM_QUEUE_MAX;
470 }
471 
472 static u32 vdpasim_get_device_id(struct vdpa_device *vdpa)
473 {
474 	return VDPASIM_DEVICE_ID;
475 }
476 
477 static u32 vdpasim_get_vendor_id(struct vdpa_device *vdpa)
478 {
479 	return VDPASIM_VENDOR_ID;
480 }
481 
482 static u8 vdpasim_get_status(struct vdpa_device *vdpa)
483 {
484 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
485 	u8 status;
486 
487 	spin_lock(&vdpasim->lock);
488 	status = vdpasim->status;
489 	spin_unlock(&vdpasim->lock);
490 
491 	return vdpasim->status;
492 }
493 
494 static void vdpasim_set_status(struct vdpa_device *vdpa, u8 status)
495 {
496 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
497 
498 	spin_lock(&vdpasim->lock);
499 	vdpasim->status = status;
500 	if (status == 0)
501 		vdpasim_reset(vdpasim);
502 	spin_unlock(&vdpasim->lock);
503 }
504 
505 static void vdpasim_get_config(struct vdpa_device *vdpa, unsigned int offset,
506 			     void *buf, unsigned int len)
507 {
508 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
509 
510 	if (offset + len < sizeof(struct virtio_net_config))
511 		memcpy(buf, &vdpasim->config + offset, len);
512 }
513 
514 static void vdpasim_set_config(struct vdpa_device *vdpa, unsigned int offset,
515 			     const void *buf, unsigned int len)
516 {
517 	/* No writable config supportted by vdpasim */
518 }
519 
520 static u32 vdpasim_get_generation(struct vdpa_device *vdpa)
521 {
522 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
523 
524 	return vdpasim->generation;
525 }
526 
527 static int vdpasim_set_map(struct vdpa_device *vdpa,
528 			   struct vhost_iotlb *iotlb)
529 {
530 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
531 	struct vhost_iotlb_map *map;
532 	u64 start = 0ULL, last = 0ULL - 1;
533 	int ret;
534 
535 	vhost_iotlb_reset(vdpasim->iommu);
536 
537 	for (map = vhost_iotlb_itree_first(iotlb, start, last); map;
538 	     map = vhost_iotlb_itree_next(map, start, last)) {
539 		ret = vhost_iotlb_add_range(vdpasim->iommu, map->start,
540 					    map->last, map->addr, map->perm);
541 		if (ret)
542 			goto err;
543 	}
544 	return 0;
545 
546 err:
547 	vhost_iotlb_reset(vdpasim->iommu);
548 	return ret;
549 }
550 
551 static int vdpasim_dma_map(struct vdpa_device *vdpa, u64 iova, u64 size,
552 			   u64 pa, u32 perm)
553 {
554 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
555 
556 	return vhost_iotlb_add_range(vdpasim->iommu, iova,
557 				     iova + size - 1, pa, perm);
558 }
559 
560 static int vdpasim_dma_unmap(struct vdpa_device *vdpa, u64 iova, u64 size)
561 {
562 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
563 
564 	vhost_iotlb_del_range(vdpasim->iommu, iova, iova + size - 1);
565 
566 	return 0;
567 }
568 
569 static void vdpasim_free(struct vdpa_device *vdpa)
570 {
571 	struct vdpasim *vdpasim = vdpa_to_sim(vdpa);
572 
573 	cancel_work_sync(&vdpasim->work);
574 	kfree(vdpasim->buffer);
575 	if (vdpasim->iommu)
576 		vhost_iotlb_free(vdpasim->iommu);
577 }
578 
579 static const struct vdpa_config_ops vdpasim_net_config_ops = {
580 	.set_vq_address         = vdpasim_set_vq_address,
581 	.set_vq_num             = vdpasim_set_vq_num,
582 	.kick_vq                = vdpasim_kick_vq,
583 	.set_vq_cb              = vdpasim_set_vq_cb,
584 	.set_vq_ready           = vdpasim_set_vq_ready,
585 	.get_vq_ready           = vdpasim_get_vq_ready,
586 	.set_vq_state           = vdpasim_set_vq_state,
587 	.get_vq_state           = vdpasim_get_vq_state,
588 	.get_vq_align           = vdpasim_get_vq_align,
589 	.get_features           = vdpasim_get_features,
590 	.set_features           = vdpasim_set_features,
591 	.set_config_cb          = vdpasim_set_config_cb,
592 	.get_vq_num_max         = vdpasim_get_vq_num_max,
593 	.get_device_id          = vdpasim_get_device_id,
594 	.get_vendor_id          = vdpasim_get_vendor_id,
595 	.get_status             = vdpasim_get_status,
596 	.set_status             = vdpasim_set_status,
597 	.get_config             = vdpasim_get_config,
598 	.set_config             = vdpasim_set_config,
599 	.get_generation         = vdpasim_get_generation,
600 	.set_map                = vdpasim_set_map,
601 	.dma_map                = vdpasim_dma_map,
602 	.dma_unmap              = vdpasim_dma_unmap,
603 	.free                   = vdpasim_free,
604 };
605 
606 static int __init vdpasim_dev_init(void)
607 {
608 	vdpasim_dev = vdpasim_create();
609 
610 	if (!IS_ERR(vdpasim_dev))
611 		return 0;
612 
613 	return PTR_ERR(vdpasim_dev);
614 }
615 
616 static void __exit vdpasim_dev_exit(void)
617 {
618 	struct vdpa_device *vdpa = &vdpasim_dev->vdpa;
619 
620 	vdpa_unregister_device(vdpa);
621 }
622 
623 module_init(vdpasim_dev_init)
624 module_exit(vdpasim_dev_exit)
625 
626 MODULE_VERSION(DRV_VERSION);
627 MODULE_LICENSE(DRV_LICENSE);
628 MODULE_AUTHOR(DRV_AUTHOR);
629 MODULE_DESCRIPTION(DRV_DESC);
630