4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
40 #include <sys/types.h>
43 #include <rte_common.h>
46 #include "virtio-net-user.h"
47 #include "vhost-net-user.h"
48 #include "vhost-net.h"
50 struct orig_region_map {
52 uint64_t mapped_address;
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)))
68 return (uint64_t)stat.st_blksize;
72 free_mem_region(struct virtio_net *dev)
74 struct orig_region_map *region;
77 if (!dev || !dev->mem)
80 region = orig_region(dev->mem, dev->mem->nregions);
81 for (idx = 0; idx < dev->mem->nregions; idx++) {
82 if (region[idx].mapped_address) {
83 munmap((void *)(uintptr_t)region[idx].mapped_address,
84 region[idx].mapped_size);
85 close(region[idx].fd);
91 vhost_backend_cleanup(struct virtio_net *dev)
99 munmap((void *)(uintptr_t)dev->log_addr, dev->log_size);
105 user_set_mem_table(int vid, struct VhostUserMsg *pmsg)
107 struct VhostUserMemory memory = pmsg->payload.memory;
108 struct virtio_memory_regions *pregion;
109 uint64_t mapped_address, mapped_size;
110 struct virtio_net *dev;
111 unsigned int idx = 0;
112 struct orig_region_map *pregion_orig;
115 /* unmap old memory regions one by one*/
116 dev = get_device(vid);
120 /* Remove from the data plane. */
121 if (dev->flags & VIRTIO_DEV_RUNNING) {
122 dev->flags &= ~VIRTIO_DEV_RUNNING;
123 notify_ops->destroy_device(vid);
127 free_mem_region(dev);
133 sizeof(struct virtio_memory) +
134 sizeof(struct virtio_memory_regions) * memory.nregions +
135 sizeof(struct orig_region_map) * memory.nregions);
136 if (dev->mem == NULL) {
137 RTE_LOG(ERR, VHOST_CONFIG,
138 "(%d) failed to allocate memory for dev->mem\n",
142 dev->mem->nregions = memory.nregions;
144 pregion_orig = orig_region(dev->mem, memory.nregions);
145 for (idx = 0; idx < memory.nregions; idx++) {
146 pregion = &dev->mem->regions[idx];
147 pregion->guest_phys_address =
148 memory.regions[idx].guest_phys_addr;
149 pregion->guest_phys_address_end =
150 memory.regions[idx].guest_phys_addr +
151 memory.regions[idx].memory_size;
152 pregion->memory_size =
153 memory.regions[idx].memory_size;
154 pregion->userspace_address =
155 memory.regions[idx].userspace_addr;
158 mapped_size = memory.regions[idx].memory_size +
159 memory.regions[idx].mmap_offset;
161 /* mmap() without flag of MAP_ANONYMOUS, should be called
162 * with length argument aligned with hugepagesz at older
163 * longterm version Linux, like 2.6.32 and 3.2.72, or
164 * mmap() will fail with EINVAL.
166 * to avoid failure, make sure in caller to keep length
169 alignment = get_blk_size(pmsg->fds[idx]);
170 mapped_size = RTE_ALIGN_CEIL(mapped_size, alignment);
172 mapped_address = (uint64_t)(uintptr_t)mmap(NULL,
174 PROT_READ | PROT_WRITE, MAP_SHARED,
178 RTE_LOG(INFO, VHOST_CONFIG,
179 "mapped region %d fd:%d to:%p sz:0x%"PRIx64" "
180 "off:0x%"PRIx64" align:0x%"PRIx64"\n",
181 idx, pmsg->fds[idx], (void *)(uintptr_t)mapped_address,
182 mapped_size, memory.regions[idx].mmap_offset,
185 if (mapped_address == (uint64_t)(uintptr_t)MAP_FAILED) {
186 RTE_LOG(ERR, VHOST_CONFIG,
187 "mmap qemu guest failed.\n");
191 pregion_orig[idx].mapped_address = mapped_address;
192 pregion_orig[idx].mapped_size = mapped_size;
193 pregion_orig[idx].blksz = alignment;
194 pregion_orig[idx].fd = pmsg->fds[idx];
196 mapped_address += memory.regions[idx].mmap_offset;
198 pregion->address_offset = mapped_address -
199 pregion->guest_phys_address;
201 if (memory.regions[idx].guest_phys_addr == 0) {
202 dev->mem->base_address =
203 memory.regions[idx].userspace_addr;
204 dev->mem->mapped_address =
205 pregion->address_offset;
208 LOG_DEBUG(VHOST_CONFIG,
209 "REGION: %u GPA: %p QEMU VA: %p SIZE (%"PRIu64")\n",
211 (void *)(uintptr_t)pregion->guest_phys_address,
212 (void *)(uintptr_t)pregion->userspace_address,
213 pregion->memory_size);
220 munmap((void *)(uintptr_t)pregion_orig[idx].mapped_address,
221 pregion_orig[idx].mapped_size);
222 close(pregion_orig[idx].fd);
230 vq_is_ready(struct vhost_virtqueue *vq)
232 return vq && vq->desc &&
233 vq->kickfd != VIRTIO_UNINITIALIZED_EVENTFD &&
234 vq->callfd != VIRTIO_UNINITIALIZED_EVENTFD;
238 virtio_is_ready(struct virtio_net *dev)
240 struct vhost_virtqueue *rvq, *tvq;
243 for (i = 0; i < dev->virt_qp_nb; i++) {
244 rvq = dev->virtqueue[i * VIRTIO_QNUM + VIRTIO_RXQ];
245 tvq = dev->virtqueue[i * VIRTIO_QNUM + VIRTIO_TXQ];
247 if (!vq_is_ready(rvq) || !vq_is_ready(tvq)) {
248 RTE_LOG(INFO, VHOST_CONFIG,
249 "virtio is not ready for processing.\n");
254 RTE_LOG(INFO, VHOST_CONFIG,
255 "virtio is now ready for processing.\n");
260 user_set_vring_call(int vid, struct VhostUserMsg *pmsg)
262 struct vhost_vring_file file;
264 file.index = pmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
265 if (pmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK)
266 file.fd = VIRTIO_INVALID_EVENTFD;
268 file.fd = pmsg->fds[0];
269 RTE_LOG(INFO, VHOST_CONFIG,
270 "vring call idx:%d file:%d\n", file.index, file.fd);
271 vhost_set_vring_call(vid, &file);
276 * In vhost-user, when we receive kick message, will test whether virtio
277 * device is ready for packet processing.
280 user_set_vring_kick(int vid, struct VhostUserMsg *pmsg)
282 struct vhost_vring_file file;
283 struct virtio_net *dev = get_device(vid);
288 file.index = pmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
289 if (pmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK)
290 file.fd = VIRTIO_INVALID_EVENTFD;
292 file.fd = pmsg->fds[0];
293 RTE_LOG(INFO, VHOST_CONFIG,
294 "vring kick idx:%d file:%d\n", file.index, file.fd);
295 vhost_set_vring_kick(vid, &file);
297 if (virtio_is_ready(dev) && !(dev->flags & VIRTIO_DEV_RUNNING)) {
298 if (notify_ops->new_device(vid) == 0)
299 dev->flags |= VIRTIO_DEV_RUNNING;
304 * when virtio is stopped, qemu will send us the GET_VRING_BASE message.
307 user_get_vring_base(int vid, struct vhost_vring_state *state)
309 struct virtio_net *dev = get_device(vid);
313 /* We have to stop the queue (virtio) if it is running. */
314 if (dev->flags & VIRTIO_DEV_RUNNING)
315 notify_ops->destroy_device(vid);
317 /* Here we are safe to get the last used index */
318 vhost_get_vring_base(vid, state->index, state);
320 RTE_LOG(INFO, VHOST_CONFIG,
321 "vring base idx:%d file:%d\n", state->index, state->num);
323 * Based on current qemu vhost-user implementation, this message is
324 * sent and only sent in vhost_vring_stop.
325 * TODO: cleanup the vring, it isn't usable since here.
327 if (dev->virtqueue[state->index]->kickfd >= 0)
328 close(dev->virtqueue[state->index]->kickfd);
330 dev->virtqueue[state->index]->kickfd = VIRTIO_UNINITIALIZED_EVENTFD;
336 * when virtio queues are ready to work, qemu will send us to
337 * enable the virtio queue pair.
340 user_set_vring_enable(int vid, struct vhost_vring_state *state)
342 struct virtio_net *dev;
343 int enable = (int)state->num;
345 dev = get_device(vid);
349 RTE_LOG(INFO, VHOST_CONFIG,
350 "set queue enable: %d to qp idx: %d\n",
351 enable, state->index);
353 if (notify_ops->vring_state_changed)
354 notify_ops->vring_state_changed(vid, state->index, enable);
356 dev->virtqueue[state->index]->enabled = enable;
362 user_set_protocol_features(int vid, uint64_t protocol_features)
364 struct virtio_net *dev;
366 dev = get_device(vid);
367 if (dev == NULL || protocol_features & ~VHOST_USER_PROTOCOL_FEATURES)
370 dev->protocol_features = protocol_features;
374 user_set_log_base(int vid, struct VhostUserMsg *msg)
376 struct virtio_net *dev;
377 int fd = msg->fds[0];
381 dev = get_device(vid);
386 RTE_LOG(ERR, VHOST_CONFIG, "invalid log fd: %d\n", fd);
390 if (msg->size != sizeof(VhostUserLog)) {
391 RTE_LOG(ERR, VHOST_CONFIG,
392 "invalid log base msg size: %"PRId32" != %d\n",
393 msg->size, (int)sizeof(VhostUserLog));
397 size = msg->payload.log.mmap_size;
398 off = msg->payload.log.mmap_offset;
399 RTE_LOG(INFO, VHOST_CONFIG,
400 "log mmap size: %"PRId64", offset: %"PRId64"\n",
404 * mmap from 0 to workaround a hugepage mmap bug: mmap will
405 * fail when offset is not page size aligned.
407 addr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
409 if (addr == MAP_FAILED) {
410 RTE_LOG(ERR, VHOST_CONFIG, "mmap log base failed!\n");
415 * Free previously mapped log memory on occasionally
416 * multiple VHOST_USER_SET_LOG_BASE.
419 munmap((void *)(uintptr_t)dev->log_addr, dev->log_size);
421 dev->log_addr = (uint64_t)(uintptr_t)addr;
422 dev->log_base = dev->log_addr + off;
423 dev->log_size = size;
429 * An rarp packet is constructed and broadcasted to notify switches about
430 * the new location of the migrated VM, so that packets from outside will
431 * not be lost after migration.
433 * However, we don't actually "send" a rarp packet here, instead, we set
434 * a flag 'broadcast_rarp' to let rte_vhost_dequeue_burst() inject it.
437 user_send_rarp(int vid, struct VhostUserMsg *msg)
439 struct virtio_net *dev;
440 uint8_t *mac = (uint8_t *)&msg->payload.u64;
442 dev = get_device(vid);
446 RTE_LOG(DEBUG, VHOST_CONFIG,
447 ":: mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
448 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
449 memcpy(dev->mac.addr_bytes, mac, 6);
452 * Set the flag to inject a RARP broadcast packet at
453 * rte_vhost_dequeue_burst().
455 * rte_smp_wmb() is for making sure the mac is copied
456 * before the flag is set.
459 rte_atomic16_set(&dev->broadcast_rarp, 1);