e7c43479c3065094a847ac18d38f30176d0979d1
[dpdk.git] / lib / librte_vhost / virtio-net-user.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include <stdint.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <unistd.h>
39 #include <sys/mman.h>
40 #include <sys/types.h>
41 #include <sys/stat.h>
42
43 #include <rte_common.h>
44 #include <rte_log.h>
45
46 #include "virtio-net-user.h"
47 #include "vhost-net-user.h"
48 #include "vhost-net.h"
49
50 struct orig_region_map {
51         int fd;
52         uint64_t mapped_address;
53         uint64_t mapped_size;
54         uint64_t blksz;
55 };
56
57 #define orig_region(ptr, nregions) \
58         ((struct orig_region_map *)RTE_PTR_ADD((ptr), \
59                 sizeof(struct virtio_memory) + \
60                 sizeof(struct virtio_memory_regions) * (nregions)))
61
62 static uint64_t
63 get_blk_size(int fd)
64 {
65         struct stat stat;
66         int ret;
67
68         ret = fstat(fd, &stat);
69         return ret == -1 ? (uint64_t)-1 : (uint64_t)stat.st_blksize;
70 }
71
72 static void
73 free_mem_region(struct virtio_net *dev)
74 {
75         struct orig_region_map *region;
76         unsigned int idx;
77
78         if (!dev || !dev->mem)
79                 return;
80
81         region = orig_region(dev->mem, dev->mem->nregions);
82         for (idx = 0; idx < dev->mem->nregions; idx++) {
83                 if (region[idx].mapped_address) {
84                         munmap((void *)(uintptr_t)region[idx].mapped_address,
85                                         region[idx].mapped_size);
86                         close(region[idx].fd);
87                 }
88         }
89 }
90
91 void
92 vhost_backend_cleanup(struct virtio_net *dev)
93 {
94         if (dev->mem) {
95                 free_mem_region(dev);
96                 free(dev->mem);
97                 dev->mem = NULL;
98         }
99         if (dev->log_addr) {
100                 munmap((void *)(uintptr_t)dev->log_addr, dev->log_size);
101                 dev->log_addr = 0;
102         }
103 }
104
105 int
106 user_set_mem_table(int vid, struct VhostUserMsg *pmsg)
107 {
108         struct VhostUserMemory memory = pmsg->payload.memory;
109         struct virtio_memory_regions *pregion;
110         uint64_t mapped_address, mapped_size;
111         struct virtio_net *dev;
112         unsigned int idx = 0;
113         struct orig_region_map *pregion_orig;
114         uint64_t alignment;
115
116         /* unmap old memory regions one by one*/
117         dev = get_device(vid);
118         if (dev == NULL)
119                 return -1;
120
121         /* Remove from the data plane. */
122         if (dev->flags & VIRTIO_DEV_RUNNING) {
123                 dev->flags &= ~VIRTIO_DEV_RUNNING;
124                 notify_ops->destroy_device(vid);
125         }
126
127         if (dev->mem) {
128                 free_mem_region(dev);
129                 free(dev->mem);
130                 dev->mem = NULL;
131         }
132
133         dev->mem = calloc(1,
134                 sizeof(struct virtio_memory) +
135                 sizeof(struct virtio_memory_regions) * memory.nregions +
136                 sizeof(struct orig_region_map) * memory.nregions);
137         if (dev->mem == NULL) {
138                 RTE_LOG(ERR, VHOST_CONFIG,
139                         "(%d) failed to allocate memory for dev->mem\n",
140                         dev->vid);
141                 return -1;
142         }
143         dev->mem->nregions = memory.nregions;
144
145         pregion_orig = orig_region(dev->mem, memory.nregions);
146         for (idx = 0; idx < memory.nregions; idx++) {
147                 pregion = &dev->mem->regions[idx];
148                 pregion->guest_phys_address =
149                         memory.regions[idx].guest_phys_addr;
150                 pregion->guest_phys_address_end =
151                         memory.regions[idx].guest_phys_addr +
152                         memory.regions[idx].memory_size;
153                 pregion->memory_size =
154                         memory.regions[idx].memory_size;
155                 pregion->userspace_address =
156                         memory.regions[idx].userspace_addr;
157
158                 /* This is ugly */
159                 mapped_size = memory.regions[idx].memory_size +
160                         memory.regions[idx].mmap_offset;
161
162                 /* mmap() without flag of MAP_ANONYMOUS, should be called
163                  * with length argument aligned with hugepagesz at older
164                  * longterm version Linux, like 2.6.32 and 3.2.72, or
165                  * mmap() will fail with EINVAL.
166                  *
167                  * to avoid failure, make sure in caller to keep length
168                  * aligned.
169                  */
170                 alignment = get_blk_size(pmsg->fds[idx]);
171                 if (alignment == (uint64_t)-1) {
172                         RTE_LOG(ERR, VHOST_CONFIG,
173                                 "couldn't get hugepage size through fstat\n");
174                         goto err_mmap;
175                 }
176                 mapped_size = RTE_ALIGN_CEIL(mapped_size, alignment);
177
178                 mapped_address = (uint64_t)(uintptr_t)mmap(NULL,
179                         mapped_size,
180                         PROT_READ | PROT_WRITE, MAP_SHARED,
181                         pmsg->fds[idx],
182                         0);
183
184                 RTE_LOG(INFO, VHOST_CONFIG,
185                         "mapped region %d fd:%d to:%p sz:0x%"PRIx64" "
186                         "off:0x%"PRIx64" align:0x%"PRIx64"\n",
187                         idx, pmsg->fds[idx], (void *)(uintptr_t)mapped_address,
188                         mapped_size, memory.regions[idx].mmap_offset,
189                         alignment);
190
191                 if (mapped_address == (uint64_t)(uintptr_t)MAP_FAILED) {
192                         RTE_LOG(ERR, VHOST_CONFIG,
193                                 "mmap qemu guest failed.\n");
194                         goto err_mmap;
195                 }
196
197                 pregion_orig[idx].mapped_address = mapped_address;
198                 pregion_orig[idx].mapped_size = mapped_size;
199                 pregion_orig[idx].blksz = alignment;
200                 pregion_orig[idx].fd = pmsg->fds[idx];
201
202                 mapped_address +=  memory.regions[idx].mmap_offset;
203
204                 pregion->address_offset = mapped_address -
205                         pregion->guest_phys_address;
206
207                 if (memory.regions[idx].guest_phys_addr == 0) {
208                         dev->mem->base_address =
209                                 memory.regions[idx].userspace_addr;
210                         dev->mem->mapped_address =
211                                 pregion->address_offset;
212                 }
213
214                 LOG_DEBUG(VHOST_CONFIG,
215                         "REGION: %u GPA: %p QEMU VA: %p SIZE (%"PRIu64")\n",
216                         idx,
217                         (void *)(uintptr_t)pregion->guest_phys_address,
218                         (void *)(uintptr_t)pregion->userspace_address,
219                          pregion->memory_size);
220         }
221
222         return 0;
223
224 err_mmap:
225         while (idx--) {
226                 munmap((void *)(uintptr_t)pregion_orig[idx].mapped_address,
227                                 pregion_orig[idx].mapped_size);
228                 close(pregion_orig[idx].fd);
229         }
230         free(dev->mem);
231         dev->mem = NULL;
232         return -1;
233 }
234
235 static int
236 vq_is_ready(struct vhost_virtqueue *vq)
237 {
238         return vq && vq->desc   &&
239                vq->kickfd != VIRTIO_UNINITIALIZED_EVENTFD &&
240                vq->callfd != VIRTIO_UNINITIALIZED_EVENTFD;
241 }
242
243 static int
244 virtio_is_ready(struct virtio_net *dev)
245 {
246         struct vhost_virtqueue *rvq, *tvq;
247         uint32_t i;
248
249         for (i = 0; i < dev->virt_qp_nb; i++) {
250                 rvq = dev->virtqueue[i * VIRTIO_QNUM + VIRTIO_RXQ];
251                 tvq = dev->virtqueue[i * VIRTIO_QNUM + VIRTIO_TXQ];
252
253                 if (!vq_is_ready(rvq) || !vq_is_ready(tvq)) {
254                         RTE_LOG(INFO, VHOST_CONFIG,
255                                 "virtio is not ready for processing.\n");
256                         return 0;
257                 }
258         }
259
260         RTE_LOG(INFO, VHOST_CONFIG,
261                 "virtio is now ready for processing.\n");
262         return 1;
263 }
264
265 void
266 user_set_vring_call(int vid, struct VhostUserMsg *pmsg)
267 {
268         struct vhost_vring_file file;
269
270         file.index = pmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
271         if (pmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK)
272                 file.fd = VIRTIO_INVALID_EVENTFD;
273         else
274                 file.fd = pmsg->fds[0];
275         RTE_LOG(INFO, VHOST_CONFIG,
276                 "vring call idx:%d file:%d\n", file.index, file.fd);
277         vhost_set_vring_call(vid, &file);
278 }
279
280
281 /*
282  *  In vhost-user, when we receive kick message, will test whether virtio
283  *  device is ready for packet processing.
284  */
285 void
286 user_set_vring_kick(int vid, struct VhostUserMsg *pmsg)
287 {
288         struct vhost_vring_file file;
289         struct virtio_net *dev = get_device(vid);
290
291         if (!dev)
292                 return;
293
294         file.index = pmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
295         if (pmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK)
296                 file.fd = VIRTIO_INVALID_EVENTFD;
297         else
298                 file.fd = pmsg->fds[0];
299         RTE_LOG(INFO, VHOST_CONFIG,
300                 "vring kick idx:%d file:%d\n", file.index, file.fd);
301         vhost_set_vring_kick(vid, &file);
302
303         if (virtio_is_ready(dev) && !(dev->flags & VIRTIO_DEV_RUNNING)) {
304                 if (notify_ops->new_device(vid) == 0)
305                         dev->flags |= VIRTIO_DEV_RUNNING;
306         }
307 }
308
309 /*
310  * when virtio is stopped, qemu will send us the GET_VRING_BASE message.
311  */
312 int
313 user_get_vring_base(int vid, struct vhost_vring_state *state)
314 {
315         struct virtio_net *dev = get_device(vid);
316
317         if (dev == NULL)
318                 return -1;
319         /* We have to stop the queue (virtio) if it is running. */
320         if (dev->flags & VIRTIO_DEV_RUNNING) {
321                 dev->flags &= ~VIRTIO_DEV_RUNNING;
322                 notify_ops->destroy_device(vid);
323         }
324
325         /* Here we are safe to get the last used index */
326         vhost_get_vring_base(vid, state->index, state);
327
328         RTE_LOG(INFO, VHOST_CONFIG,
329                 "vring base idx:%d file:%d\n", state->index, state->num);
330         /*
331          * Based on current qemu vhost-user implementation, this message is
332          * sent and only sent in vhost_vring_stop.
333          * TODO: cleanup the vring, it isn't usable since here.
334          */
335         if (dev->virtqueue[state->index]->kickfd >= 0)
336                 close(dev->virtqueue[state->index]->kickfd);
337
338         dev->virtqueue[state->index]->kickfd = VIRTIO_UNINITIALIZED_EVENTFD;
339
340         return 0;
341 }
342
343 /*
344  * when virtio queues are ready to work, qemu will send us to
345  * enable the virtio queue pair.
346  */
347 int
348 user_set_vring_enable(int vid, struct vhost_vring_state *state)
349 {
350         struct virtio_net *dev;
351         int enable = (int)state->num;
352
353         dev = get_device(vid);
354         if (dev == NULL)
355                 return -1;
356
357         RTE_LOG(INFO, VHOST_CONFIG,
358                 "set queue enable: %d to qp idx: %d\n",
359                 enable, state->index);
360
361         if (notify_ops->vring_state_changed)
362                 notify_ops->vring_state_changed(vid, state->index, enable);
363
364         dev->virtqueue[state->index]->enabled = enable;
365
366         return 0;
367 }
368
369 void
370 user_set_protocol_features(int vid, uint64_t protocol_features)
371 {
372         struct virtio_net *dev;
373
374         dev = get_device(vid);
375         if (dev == NULL || protocol_features & ~VHOST_USER_PROTOCOL_FEATURES)
376                 return;
377
378         dev->protocol_features = protocol_features;
379 }
380
381 int
382 user_set_log_base(int vid, struct VhostUserMsg *msg)
383 {
384         struct virtio_net *dev;
385         int fd = msg->fds[0];
386         uint64_t size, off;
387         void *addr;
388
389         dev = get_device(vid);
390         if (!dev)
391                 return -1;
392
393         if (fd < 0) {
394                 RTE_LOG(ERR, VHOST_CONFIG, "invalid log fd: %d\n", fd);
395                 return -1;
396         }
397
398         if (msg->size != sizeof(VhostUserLog)) {
399                 RTE_LOG(ERR, VHOST_CONFIG,
400                         "invalid log base msg size: %"PRId32" != %d\n",
401                         msg->size, (int)sizeof(VhostUserLog));
402                 return -1;
403         }
404
405         size = msg->payload.log.mmap_size;
406         off  = msg->payload.log.mmap_offset;
407         RTE_LOG(INFO, VHOST_CONFIG,
408                 "log mmap size: %"PRId64", offset: %"PRId64"\n",
409                 size, off);
410
411         /*
412          * mmap from 0 to workaround a hugepage mmap bug: mmap will
413          * fail when offset is not page size aligned.
414          */
415         addr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
416         close(fd);
417         if (addr == MAP_FAILED) {
418                 RTE_LOG(ERR, VHOST_CONFIG, "mmap log base failed!\n");
419                 return -1;
420         }
421
422         /*
423          * Free previously mapped log memory on occasionally
424          * multiple VHOST_USER_SET_LOG_BASE.
425          */
426         if (dev->log_addr) {
427                 munmap((void *)(uintptr_t)dev->log_addr, dev->log_size);
428         }
429         dev->log_addr = (uint64_t)(uintptr_t)addr;
430         dev->log_base = dev->log_addr + off;
431         dev->log_size = size;
432
433         return 0;
434 }
435
436 /*
437  * An rarp packet is constructed and broadcasted to notify switches about
438  * the new location of the migrated VM, so that packets from outside will
439  * not be lost after migration.
440  *
441  * However, we don't actually "send" a rarp packet here, instead, we set
442  * a flag 'broadcast_rarp' to let rte_vhost_dequeue_burst() inject it.
443  */
444 int
445 user_send_rarp(int vid, struct VhostUserMsg *msg)
446 {
447         struct virtio_net *dev;
448         uint8_t *mac = (uint8_t *)&msg->payload.u64;
449
450         dev = get_device(vid);
451         if (!dev)
452                 return -1;
453
454         RTE_LOG(DEBUG, VHOST_CONFIG,
455                 ":: mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
456                 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
457         memcpy(dev->mac.addr_bytes, mac, 6);
458
459         /*
460          * Set the flag to inject a RARP broadcast packet at
461          * rte_vhost_dequeue_burst().
462          *
463          * rte_smp_wmb() is for making sure the mac is copied
464          * before the flag is set.
465          */
466         rte_smp_wmb();
467         rte_atomic16_set(&dev->broadcast_rarp, 1);
468
469         return 0;
470 }