ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

tests/vhost-user-bridge: implement logging of dirty pages 

During migration devices continue writing to the guest's memory.
The writes has to be reported to QEMU. This change implements
minimal support in vhost-user-bridge required for successful
migration of a guest with virtio-net device.

Signed-off-by: Victor Kaplansky <victork@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
Victor Kaplansky 2015-11-17 12:04:06 +02:00 committed by Michael S. Tsirkin
parent 8d211f622b
commit 5c93c47338
1 changed files with 195 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
tests/vhost-user-bridge.c
View File

@ -13,16 +13,22 @@
/* /*
* TODO: * TODO:
* - main should get parameters from the command line. * - main should get parameters from the command line.
* - implement all request handlers. * - implement all request handlers. Still not implemented:
* vubr_get_queue_num_exec()
* vubr_send_rarp_exec()
* - test for broken requests and virtqueue. * - test for broken requests and virtqueue.
* - implement features defined by Virtio 1.0 spec. * - implement features defined by Virtio 1.0 spec.
* - support mergeable buffers and indirect descriptors. * - support mergeable buffers and indirect descriptors.
* - implement RESET_DEVICE request.
* - implement clean shutdown. * - implement clean shutdown.
* - implement non-blocking writes to UDP backend. * - implement non-blocking writes to UDP backend.
* - implement polling strategy. * - implement polling strategy.
* - implement clean starting/stopping of vq processing
* - implement clean starting/stopping of used and buffers
* dirty page logging.
*/ */
#define _FILE_OFFSET_BITS 64
#include <stddef.h> #include <stddef.h>
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
@ -166,6 +172,8 @@ typedef struct VubrVirtq {
struct vring_desc *desc; struct vring_desc *desc;
struct vring_avail *avail; struct vring_avail *avail;
struct vring_used *used; struct vring_used *used;
uint64_t log_guest_addr;
int enable;
} VubrVirtq; } VubrVirtq;
/* Based on qemu/hw/virtio/vhost-user.c */ /* Based on qemu/hw/virtio/vhost-user.c */
@ -173,6 +181,8 @@ typedef struct VubrVirtq {
#define VHOST_MEMORY_MAX_NREGIONS 8 #define VHOST_MEMORY_MAX_NREGIONS 8
#define VHOST_USER_F_PROTOCOL_FEATURES 30 #define VHOST_USER_F_PROTOCOL_FEATURES 30
#define VHOST_LOG_PAGE 4096
enum VhostUserProtocolFeature { enum VhostUserProtocolFeature {
VHOST_USER_PROTOCOL_F_MQ = 0, VHOST_USER_PROTOCOL_F_MQ = 0,
VHOST_USER_PROTOCOL_F_LOG_SHMFD = 1, VHOST_USER_PROTOCOL_F_LOG_SHMFD = 1,
@ -220,6 +230,11 @@ typedef struct VhostUserMemory {
VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS]; VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
} VhostUserMemory; } VhostUserMemory;
typedef struct VhostUserLog {
uint64_t mmap_size;
uint64_t mmap_offset;
} VhostUserLog;
typedef struct VhostUserMsg { typedef struct VhostUserMsg {
VhostUserRequest request; VhostUserRequest request;
@ -234,6 +249,7 @@ typedef struct VhostUserMsg {
struct vhost_vring_state state; struct vhost_vring_state state;
struct vhost_vring_addr addr; struct vhost_vring_addr addr;
VhostUserMemory memory; VhostUserMemory memory;
VhostUserLog log;
} payload; } payload;
int fds[VHOST_MEMORY_MAX_NREGIONS]; int fds[VHOST_MEMORY_MAX_NREGIONS];
int fd_num; int fd_num;
@ -265,8 +281,13 @@ typedef struct VubrDev {
uint32_t nregions; uint32_t nregions;
VubrDevRegion regions[VHOST_MEMORY_MAX_NREGIONS]; VubrDevRegion regions[VHOST_MEMORY_MAX_NREGIONS];
VubrVirtq vq[MAX_NR_VIRTQUEUE]; VubrVirtq vq[MAX_NR_VIRTQUEUE];
int log_call_fd;
uint64_t log_size;
uint8_t *log_table;
int backend_udp_sock; int backend_udp_sock;
struct sockaddr_in backend_udp_dest; struct sockaddr_in backend_udp_dest;
int ready;
uint64_t features;
} VubrDev; } VubrDev;
static const char *vubr_request_str[] = { static const char *vubr_request_str[] = {
@ -368,7 +389,12 @@ vubr_message_read(int conn_fd, VhostUserMsg *vmsg)
rc = recvmsg(conn_fd, &msg, 0); rc = recvmsg(conn_fd, &msg, 0);
if (rc <= 0) { if (rc == 0) {
vubr_die("recvmsg");
fprintf(stderr, "Peer disconnected.\n");
exit(1);
}
if (rc < 0) {
vubr_die("recvmsg"); vubr_die("recvmsg");
} }
@ -395,7 +421,12 @@ vubr_message_read(int conn_fd, VhostUserMsg *vmsg)
if (vmsg->size) { if (vmsg->size) {
rc = read(conn_fd, &vmsg->payload, vmsg->size); rc = read(conn_fd, &vmsg->payload, vmsg->size);
if (rc <= 0) { if (rc == 0) {
vubr_die("recvmsg");
fprintf(stderr, "Peer disconnected.\n");
exit(1);
}
if (rc < 0) {
vubr_die("recvmsg"); vubr_die("recvmsg");
} }
@ -455,6 +486,16 @@ vubr_consume_raw_packet(VubrDev *dev, uint8_t *buf, uint32_t len)
vubr_backend_udp_sendbuf(dev, buf + hdrlen, len - hdrlen); vubr_backend_udp_sendbuf(dev, buf + hdrlen, len - hdrlen);
} }
/* Kick the log_call_fd if required. */
static void
vubr_log_kick(VubrDev *dev)
{
if (dev->log_call_fd != -1) {
DPRINT("Kicking the QEMU's log...\n");
eventfd_write(dev->log_call_fd, 1);
}
}
/* Kick the guest if necessary. */ /* Kick the guest if necessary. */
static void static void
vubr_virtqueue_kick(VubrVirtq *vq) vubr_virtqueue_kick(VubrVirtq *vq)
@ -465,12 +506,40 @@ vubr_virtqueue_kick(VubrVirtq *vq)
} }
} }
static void
vubr_log_page(uint8_t *log_table, uint64_t page)
{
DPRINT("Logged dirty guest page: %"PRId64"\n", page);
atomic_or(&log_table[page / 8], 1 << (page % 8));
}
static void
vubr_log_write(VubrDev *dev, uint64_t address, uint64_t length)
{
uint64_t page;
if (!(dev->features & (1ULL << VHOST_F_LOG_ALL)) ||
!dev->log_table || !length) {
return;
}
assert(dev->log_size > ((address + length - 1) / VHOST_LOG_PAGE / 8));
page = address / VHOST_LOG_PAGE;
while (page * VHOST_LOG_PAGE < address + length) {
vubr_log_page(dev->log_table, page);
page += VHOST_LOG_PAGE;
}
vubr_log_kick(dev);
}
static void static void
vubr_post_buffer(VubrDev *dev, VubrVirtq *vq, uint8_t *buf, int32_t len) vubr_post_buffer(VubrDev *dev, VubrVirtq *vq, uint8_t *buf, int32_t len)
{ {
struct vring_desc *desc = vq->desc; struct vring_desc *desc = vq->desc;
struct vring_avail *avail = vq->avail; struct vring_avail *avail = vq->avail;
struct vring_used *used = vq->used; struct vring_used *used = vq->used;
uint64_t log_guest_addr = vq->log_guest_addr;
unsigned int size = vq->size; unsigned int size = vq->size;
@ -510,6 +579,7 @@ vubr_post_buffer(VubrDev *dev, VubrVirtq *vq, uint8_t *buf, int32_t len)
if (len <= chunk_len) { if (len <= chunk_len) {
memcpy(chunk_start, buf, len); memcpy(chunk_start, buf, len);
vubr_log_write(dev, desc[i].addr, len);
} else { } else {
fprintf(stderr, fprintf(stderr,
"Received too long packet from the backend. Dropping...\n"); "Received too long packet from the backend. Dropping...\n");
@ -519,11 +589,17 @@ vubr_post_buffer(VubrDev *dev, VubrVirtq *vq, uint8_t *buf, int32_t len)
/* Add descriptor to the used ring. */ /* Add descriptor to the used ring. */
used->ring[u_index].id = d_index; used->ring[u_index].id = d_index;
used->ring[u_index].len = len; used->ring[u_index].len = len;
vubr_log_write(dev,
log_guest_addr + offsetof(struct vring_used, ring[u_index]),
sizeof(used->ring[u_index]));
vq->last_avail_index++; vq->last_avail_index++;
vq->last_used_index++; vq->last_used_index++;
atomic_mb_set(&used->idx, vq->last_used_index); atomic_mb_set(&used->idx, vq->last_used_index);
vubr_log_write(dev,
log_guest_addr + offsetof(struct vring_used, idx),
sizeof(used->idx));
/* Kick the guest if necessary. */ /* Kick the guest if necessary. */
vubr_virtqueue_kick(vq); vubr_virtqueue_kick(vq);
@ -532,9 +608,10 @@ vubr_post_buffer(VubrDev *dev, VubrVirtq *vq, uint8_t *buf, int32_t len)
static int static int
vubr_process_desc(VubrDev *dev, VubrVirtq *vq) vubr_process_desc(VubrDev *dev, VubrVirtq *vq)
{ {
struct vring_desc *desc = vq->desc; struct vring_desc *desc = vq->desc;
struct vring_avail *avail = vq->avail; struct vring_avail *avail = vq->avail;
struct vring_used *used = vq->used; struct vring_used *used = vq->used;
uint64_t log_guest_addr = vq->log_guest_addr;
unsigned int size = vq->size; unsigned int size = vq->size;
@ -552,6 +629,8 @@ vubr_process_desc(VubrDev *dev, VubrVirtq *vq)
void *chunk_start = (void *)gpa_to_va(dev, desc[i].addr); void *chunk_start = (void *)gpa_to_va(dev, desc[i].addr);
uint32_t chunk_len = desc[i].len; uint32_t chunk_len = desc[i].len;
assert(!(desc[i].flags & VRING_DESC_F_WRITE));
if (len + chunk_len < buf_size) { if (len + chunk_len < buf_size) {
memcpy(buf + len, chunk_start, chunk_len); memcpy(buf + len, chunk_start, chunk_len);
DPRINT("%d ", chunk_len); DPRINT("%d ", chunk_len);
@ -577,6 +656,9 @@ vubr_process_desc(VubrDev *dev, VubrVirtq *vq)
/* Add descriptor to the used ring. */ /* Add descriptor to the used ring. */
used->ring[u_index].id = d_index; used->ring[u_index].id = d_index;
used->ring[u_index].len = len; used->ring[u_index].len = len;
vubr_log_write(dev,
log_guest_addr + offsetof(struct vring_used, ring[u_index]),
sizeof(used->ring[u_index]));
vubr_consume_raw_packet(dev, buf, len); vubr_consume_raw_packet(dev, buf, len);
@ -588,6 +670,7 @@ vubr_process_avail(VubrDev *dev, VubrVirtq *vq)
{ {
struct vring_avail *avail = vq->avail; struct vring_avail *avail = vq->avail;
struct vring_used *used = vq->used; struct vring_used *used = vq->used;
uint64_t log_guest_addr = vq->log_guest_addr;
while (vq->last_avail_index != atomic_mb_read(&avail->idx)) { while (vq->last_avail_index != atomic_mb_read(&avail->idx)) {
vubr_process_desc(dev, vq); vubr_process_desc(dev, vq);
@ -596,6 +679,9 @@ vubr_process_avail(VubrDev *dev, VubrVirtq *vq)
} }
atomic_mb_set(&used->idx, vq->last_used_index); atomic_mb_set(&used->idx, vq->last_used_index);
vubr_log_write(dev,
log_guest_addr + offsetof(struct vring_used, idx),
sizeof(used->idx));
} }
static void static void
@ -609,6 +695,10 @@ vubr_backend_recv_cb(int sock, void *ctx)
int buflen = sizeof(buf); int buflen = sizeof(buf);
int len; int len;
if (!dev->ready) {
return;
}
DPRINT("\n\n *** IN UDP RECEIVE CALLBACK ***\n\n"); DPRINT("\n\n *** IN UDP RECEIVE CALLBACK ***\n\n");
uint16_t avail_index = atomic_mb_read(&rx_vq->avail->idx); uint16_t avail_index = atomic_mb_read(&rx_vq->avail->idx);
@ -656,14 +746,14 @@ vubr_get_features_exec(VubrDev *dev, VhostUserMsg *vmsg)
{ {
vmsg->payload.u64 = vmsg->payload.u64 =
((1ULL << VIRTIO_NET_F_MRG_RXBUF) | ((1ULL << VIRTIO_NET_F_MRG_RXBUF) |
(1ULL << VIRTIO_NET_F_CTRL_VQ) | (1ULL << VHOST_F_LOG_ALL) |
(1ULL << VIRTIO_NET_F_CTRL_RX) | (1ULL << VHOST_USER_F_PROTOCOL_FEATURES));
(1ULL << VHOST_F_LOG_ALL));
vmsg->size = sizeof(vmsg->payload.u64); vmsg->size = sizeof(vmsg->payload.u64);
DPRINT("Sending back to guest u64: 0x%016"PRIx64"\n", vmsg->payload.u64); DPRINT("Sending back to guest u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
/* reply */ /* Reply */
return 1; return 1;
} }
@ -671,6 +761,7 @@ static int
vubr_set_features_exec(VubrDev *dev, VhostUserMsg *vmsg) vubr_set_features_exec(VubrDev *dev, VhostUserMsg *vmsg)
{ {
DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64); DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
dev->features = vmsg->payload.u64;
return 0; return 0;
} }
@ -680,10 +771,28 @@ vubr_set_owner_exec(VubrDev *dev, VhostUserMsg *vmsg)
return 0; return 0;
} }
static void
vubr_close_log(VubrDev *dev)
{
if (dev->log_table) {
if (munmap(dev->log_table, dev->log_size) != 0) {
vubr_die("munmap()");
}
dev->log_table = 0;
}
if (dev->log_call_fd != -1) {
close(dev->log_call_fd);
dev->log_call_fd = -1;
}
}
static int static int
vubr_reset_device_exec(VubrDev *dev, VhostUserMsg *vmsg) vubr_reset_device_exec(VubrDev *dev, VhostUserMsg *vmsg)
{ {
DPRINT("Function %s() not implemented yet.\n", __func__); vubr_close_log(dev);
dev->ready = 0;
dev->features = 0;
return 0; return 0;
} }
@ -710,9 +819,9 @@ vubr_set_mem_table_exec(VubrDev *dev, VhostUserMsg *vmsg)
DPRINT(" mmap_offset 0x%016"PRIx64"\n", DPRINT(" mmap_offset 0x%016"PRIx64"\n",
msg_region->mmap_offset); msg_region->mmap_offset);
dev_region->gpa = msg_region->guest_phys_addr; dev_region->gpa = msg_region->guest_phys_addr;
dev_region->size = msg_region->memory_size; dev_region->size = msg_region->memory_size;
dev_region->qva = msg_region->userspace_addr; dev_region->qva = msg_region->userspace_addr;
dev_region->mmap_offset = msg_region->mmap_offset; dev_region->mmap_offset = msg_region->mmap_offset;
/* We don't use offset argument of mmap() since the /* We don't use offset argument of mmap() since the
@ -736,14 +845,38 @@ vubr_set_mem_table_exec(VubrDev *dev, VhostUserMsg *vmsg)
static int static int
vubr_set_log_base_exec(VubrDev *dev, VhostUserMsg *vmsg) vubr_set_log_base_exec(VubrDev *dev, VhostUserMsg *vmsg)
{ {
DPRINT("Function %s() not implemented yet.\n", __func__); int fd;
return 0; uint64_t log_mmap_size, log_mmap_offset;
void *rc;
assert(vmsg->fd_num == 1);
fd = vmsg->fds[0];
assert(vmsg->size == sizeof(vmsg->payload.log));
log_mmap_offset = vmsg->payload.log.mmap_offset;
log_mmap_size = vmsg->payload.log.mmap_size;
DPRINT("Log mmap_offset: %"PRId64"\n", log_mmap_offset);
DPRINT("Log mmap_size: %"PRId64"\n", log_mmap_size);
rc = mmap(0, log_mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
log_mmap_offset);
if (rc == MAP_FAILED) {
vubr_die("mmap");
}
dev->log_table = rc;
dev->log_size = log_mmap_size;
vmsg->size = sizeof(vmsg->payload.u64);
/* Reply */
return 1;
} }
static int static int
vubr_set_log_fd_exec(VubrDev *dev, VhostUserMsg *vmsg) vubr_set_log_fd_exec(VubrDev *dev, VhostUserMsg *vmsg)
{ {
DPRINT("Function %s() not implemented yet.\n", __func__); assert(vmsg->fd_num == 1);
dev->log_call_fd = vmsg->fds[0];
DPRINT("Got log_call_fd: %d\n", vmsg->fds[0]);
return 0; return 0;
} }
@ -777,6 +910,7 @@ vubr_set_vring_addr_exec(VubrDev *dev, VhostUserMsg *vmsg)
vq->desc = (struct vring_desc *)qva_to_va(dev, vra->desc_user_addr); vq->desc = (struct vring_desc *)qva_to_va(dev, vra->desc_user_addr);
vq->used = (struct vring_used *)qva_to_va(dev, vra->used_user_addr); vq->used = (struct vring_used *)qva_to_va(dev, vra->used_user_addr);
vq->avail = (struct vring_avail *)qva_to_va(dev, vra->avail_user_addr); vq->avail = (struct vring_avail *)qva_to_va(dev, vra->avail_user_addr);
vq->log_guest_addr = vra->log_guest_addr;
DPRINT("Setting virtq addresses:\n"); DPRINT("Setting virtq addresses:\n");
DPRINT(" vring_desc at %p\n", vq->desc); DPRINT(" vring_desc at %p\n", vq->desc);
@ -803,8 +937,18 @@ vubr_set_vring_base_exec(VubrDev *dev, VhostUserMsg *vmsg)
static int static int
vubr_get_vring_base_exec(VubrDev *dev, VhostUserMsg *vmsg) vubr_get_vring_base_exec(VubrDev *dev, VhostUserMsg *vmsg)
{ {
DPRINT("Function %s() not implemented yet.\n", __func__); unsigned int index = vmsg->payload.state.index;
return 0;
DPRINT("State.index: %d\n", index);
vmsg->payload.state.num = dev->vq[index].last_avail_index;
vmsg->size = sizeof(vmsg->payload.state);
/* FIXME: this is a work-around for a bug in QEMU enabling
* too early vrings. When protocol features are enabled,
* we have to respect * VHOST_USER_SET_VRING_ENABLE request. */
dev->ready = 0;
/* Reply */
return 1;
} }
static int static int
@ -829,7 +973,17 @@ vubr_set_vring_kick_exec(VubrDev *dev, VhostUserMsg *vmsg)
DPRINT("Waiting for kicks on fd: %d for vq: %d\n", DPRINT("Waiting for kicks on fd: %d for vq: %d\n",
dev->vq[index].kick_fd, index); dev->vq[index].kick_fd, index);
} }
/* We temporarily use this hack to determine that both TX and RX
* queues are set up and ready for processing.
* FIXME: we need to rely in VHOST_USER_SET_VRING_ENABLE and
* actual kicks. */
if (dev->vq[0].kick_fd != -1 &&
dev->vq[1].kick_fd != -1) {
dev->ready = 1;
DPRINT("vhost-user-bridge is ready for processing queues.\n");
}
return 0; return 0;
} }
static int static int
@ -858,9 +1012,12 @@ vubr_set_vring_err_exec(VubrDev *dev, VhostUserMsg *vmsg)
static int static int
vubr_get_protocol_features_exec(VubrDev *dev, VhostUserMsg *vmsg) vubr_get_protocol_features_exec(VubrDev *dev, VhostUserMsg *vmsg)
{ {
/* FIXME: unimplented */ vmsg->payload.u64 = 1ULL << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64); DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
return 0; vmsg->size = sizeof(vmsg->payload.u64);
/* Reply */
return 1;
} }
static int static int
@ -881,7 +1038,12 @@ vubr_get_queue_num_exec(VubrDev *dev, VhostUserMsg *vmsg)
static int static int
vubr_set_vring_enable_exec(VubrDev *dev, VhostUserMsg *vmsg) vubr_set_vring_enable_exec(VubrDev *dev, VhostUserMsg *vmsg)
{ {
DPRINT("Function %s() not implemented yet.\n", __func__); unsigned int index = vmsg->payload.state.index;
unsigned int enable = vmsg->payload.state.num;
DPRINT("State.index: %d\n", index);
DPRINT("State.enable: %d\n", enable);
dev->vq[index].enable = enable;
return 0; return 0;
} }
@ -987,7 +1149,7 @@ vubr_accept_cb(int sock, void *ctx)
socklen_t len = sizeof(un); socklen_t len = sizeof(un);
conn_fd = accept(sock, (struct sockaddr *) &un, &len); conn_fd = accept(sock, (struct sockaddr *) &un, &len);
if (conn_fd == -1) { if (conn_fd == -1) {
vubr_die("accept()"); vubr_die("accept()");
} }
DPRINT("Got connection from remote peer on sock %d\n", conn_fd); DPRINT("Got connection from remote peer on sock %d\n", conn_fd);
@ -1009,9 +1171,17 @@ vubr_new(const char *path)
.size = 0, .size = 0,
.last_avail_index = 0, .last_used_index = 0, .last_avail_index = 0, .last_used_index = 0,
.desc = 0, .avail = 0, .used = 0, .desc = 0, .avail = 0, .used = 0,
.enable = 0,
}; };
} }
/* Init log */
dev->log_call_fd = -1;
dev->log_size = 0;
dev->log_table = 0;
dev->ready = 0;
dev->features = 0;
/* Get a UNIX socket. */ /* Get a UNIX socket. */
dev->sock = socket(AF_UNIX, SOCK_STREAM, 0); dev->sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (dev->sock == -1) { if (dev->sock == -1) {