Proxmox-Port/qemu
1
0
Fork 0
mirror of https://github.com/qemu/qemu.git synced 2025-10-31 20:44:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
dae8be368e
qemu/hw/hyperv/vmbus.c
Eduardo Habkost ce35e2295e qdev: Move softmmu properties to qdev-properties-system.h 
Move the property types and property macros implemented in
qdev-properties-system.c to a new qdev-properties-system.h
header.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <20201211220529.2290218-16-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-12-18 15:20:17 -05:00

2776 lines
76 KiB
C
Raw Blame History

/*
* QEMU Hyper-V VMBus
*
* Copyright (c) 2017-2018 Virtuozzo International GmbH.
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#include "qemu/osdep.h"
#include "qemu/error-report.h"
#include "qemu/main-loop.h"
#include "qapi/error.h"
#include "migration/vmstate.h"
#include "hw/qdev-properties.h"
#include "hw/qdev-properties-system.h"
#include "hw/hyperv/hyperv.h"
#include "hw/hyperv/vmbus.h"
#include "hw/hyperv/vmbus-bridge.h"
#include "hw/sysbus.h"
#include "cpu.h"
#include "trace.h"
enum {
VMGPADL_INIT,
VMGPADL_ALIVE,
VMGPADL_TEARINGDOWN,
VMGPADL_TORNDOWN,
};
struct VMBusGpadl {
/* GPADL id */
uint32_t id;
/* associated channel id (rudimentary?) */
uint32_t child_relid;
/* number of pages in the GPADL as declared in GPADL_HEADER message */
uint32_t num_gfns;
/*
* Due to limited message size, GPADL may not fit fully in a single
* GPADL_HEADER message, and is further popluated using GPADL_BODY
* messages. @seen_gfns is the number of pages seen so far; once it
* reaches @num_gfns, the GPADL is ready to use.
*/
uint32_t seen_gfns;
/* array of GFNs (of size @num_gfns once allocated) */
uint64_t *gfns;
uint8_t state;
QTAILQ_ENTRY(VMBusGpadl) link;
VMBus *vmbus;
unsigned refcount;
};
/*
* Wrap sequential read from / write to GPADL.
*/
typedef struct GpadlIter {
VMBusGpadl *gpadl;
AddressSpace *as;
DMADirection dir;
/* offset into GPADL where the next i/o will be performed */
uint32_t off;
/*
* Cached mapping of the currently accessed page, up to page boundary.
* Updated lazily on i/o.
* Note: MemoryRegionCache can not be used here because pages in the GPADL
* are non-contiguous and may belong to different memory regions.
*/
void *map;
/* offset after last i/o (i.e. not affected by seek) */
uint32_t last_off;
/*
* Indicator that the iterator is active and may have a cached mapping.
* Allows to enforce bracketing of all i/o (which may create cached
* mappings) and thus exclude mapping leaks.
*/
bool active;
} GpadlIter;
/*
* Ring buffer. There are two of them, sitting in the same GPADL, for each
* channel.
* Each ring buffer consists of a set of pages, with the first page containing
* the ring buffer header, and the remaining pages being for data packets.
*/
typedef struct VMBusRingBufCommon {
AddressSpace *as;
/* GPA of the ring buffer header */
dma_addr_t rb_addr;
/* start and length of the ring buffer data area within GPADL */
uint32_t base;
uint32_t len;
GpadlIter iter;
} VMBusRingBufCommon;
typedef struct VMBusSendRingBuf {
VMBusRingBufCommon common;
/* current write index, to be committed at the end of send */
uint32_t wr_idx;
/* write index at the start of send */
uint32_t last_wr_idx;
/* space to be requested from the guest */
uint32_t wanted;
/* space reserved for planned sends */
uint32_t reserved;
/* last seen read index */
uint32_t last_seen_rd_idx;
} VMBusSendRingBuf;
typedef struct VMBusRecvRingBuf {
VMBusRingBufCommon common;
/* current read index, to be committed at the end of receive */
uint32_t rd_idx;
/* read index at the start of receive */
uint32_t last_rd_idx;
/* last seen write index */
uint32_t last_seen_wr_idx;
} VMBusRecvRingBuf;
enum {
VMOFFER_INIT,
VMOFFER_SENDING,
VMOFFER_SENT,
};
enum {
VMCHAN_INIT,
VMCHAN_OPENING,
VMCHAN_OPEN,
};
struct VMBusChannel {
VMBusDevice *dev;
/* channel id */
uint32_t id;
/*
* subchannel index within the device; subchannel #0 is "primary" and
* always exists
*/
uint16_t subchan_idx;
uint32_t open_id;
/* VP_INDEX of the vCPU to notify with (synthetic) interrupts */
uint32_t target_vp;
/* GPADL id to use for the ring buffers */
uint32_t ringbuf_gpadl;
/* start (in pages) of the send ring buffer within @ringbuf_gpadl */
uint32_t ringbuf_send_offset;
uint8_t offer_state;
uint8_t state;
bool is_open;
/* main device worker; copied from the device class */
VMBusChannelNotifyCb notify_cb;
/*
* guest->host notifications, either sent directly or dispatched via
* interrupt page (older VMBus)
*/
EventNotifier notifier;
VMBus *vmbus;
/*
* SINT route to signal with host->guest notifications; may be shared with
* the main VMBus SINT route
*/
HvSintRoute *notify_route;
VMBusGpadl *gpadl;
VMBusSendRingBuf send_ringbuf;
VMBusRecvRingBuf recv_ringbuf;
QTAILQ_ENTRY(VMBusChannel) link;
};
/*
* Hyper-V spec mandates that every message port has 16 buffers, which means
* that the guest can post up to this many messages without blocking.
* Therefore a queue for incoming messages has to be provided.
* For outgoing (i.e. host->guest) messages there's no queue; the VMBus just
* doesn't transition to a new state until the message is known to have been
* successfully delivered to the respective SynIC message slot.
*/
#define HV_MSG_QUEUE_LEN 16
/* Hyper-V devices never use channel #0. Must be something special. */
#define VMBUS_FIRST_CHANID 1
/* Each channel occupies one bit within a single event page sint slot. */
#define VMBUS_CHANID_COUNT (HV_EVENT_FLAGS_COUNT - VMBUS_FIRST_CHANID)
/* Leave a few connection numbers for other purposes. */
#define VMBUS_CHAN_CONNECTION_OFFSET 16
/*
* Since the success or failure of sending a message is reported
* asynchronously, the VMBus state machine has effectively two entry points:
* vmbus_run and vmbus_msg_cb (the latter is called when the host->guest
* message delivery status becomes known). Both are run as oneshot BHs on the
* main aio context, ensuring serialization.
*/
enum {
VMBUS_LISTEN,
VMBUS_HANDSHAKE,
VMBUS_OFFER,
VMBUS_CREATE_GPADL,
VMBUS_TEARDOWN_GPADL,
VMBUS_OPEN_CHANNEL,
VMBUS_UNLOAD,
VMBUS_STATE_MAX
};
struct VMBus {
BusState parent;
uint8_t state;
/* protection against recursive aio_poll (see vmbus_run) */
bool in_progress;
/* whether there's a message being delivered to the guest */
bool msg_in_progress;
uint32_t version;
/* VP_INDEX of the vCPU to send messages and interrupts to */
uint32_t target_vp;
HvSintRoute *sint_route;
/*
* interrupt page for older protocol versions; newer ones use SynIC event
* flags directly
*/
hwaddr int_page_gpa;
DECLARE_BITMAP(chanid_bitmap, VMBUS_CHANID_COUNT);
/* incoming message queue */
struct hyperv_post_message_input rx_queue[HV_MSG_QUEUE_LEN];
uint8_t rx_queue_head;
uint8_t rx_queue_size;
QemuMutex rx_queue_lock;
QTAILQ_HEAD(, VMBusGpadl) gpadl_list;
QTAILQ_HEAD(, VMBusChannel) channel_list;
/*
* guest->host notifications for older VMBus, to be dispatched via
* interrupt page
*/
EventNotifier notifier;
};
static bool gpadl_full(VMBusGpadl *gpadl)
{
return gpadl->seen_gfns == gpadl->num_gfns;
}
static VMBusGpadl *create_gpadl(VMBus *vmbus, uint32_t id,
uint32_t child_relid, uint32_t num_gfns)
{
VMBusGpadl *gpadl = g_new0(VMBusGpadl, 1);
gpadl->id = id;
gpadl->child_relid = child_relid;
gpadl->num_gfns = num_gfns;
gpadl->gfns = g_new(uint64_t, num_gfns);
QTAILQ_INSERT_HEAD(&vmbus->gpadl_list, gpadl, link);
gpadl->vmbus = vmbus;
gpadl->refcount = 1;
return gpadl;
}
static void free_gpadl(VMBusGpadl *gpadl)
{
QTAILQ_REMOVE(&gpadl->vmbus->gpadl_list, gpadl, link);
g_free(gpadl->gfns);
g_free(gpadl);
}
static VMBusGpadl *find_gpadl(VMBus *vmbus, uint32_t gpadl_id)
{
VMBusGpadl *gpadl;
QTAILQ_FOREACH(gpadl, &vmbus->gpadl_list, link) {
if (gpadl->id == gpadl_id) {
return gpadl;
}
}
return NULL;
}
VMBusGpadl *vmbus_get_gpadl(VMBusChannel *chan, uint32_t gpadl_id)
{
VMBusGpadl *gpadl = find_gpadl(chan->vmbus, gpadl_id);
if (!gpadl || !gpadl_full(gpadl)) {
return NULL;
}
gpadl->refcount++;
return gpadl;
}
void vmbus_put_gpadl(VMBusGpadl *gpadl)
{
if (!gpadl) {
return;
}
if (--gpadl->refcount) {
return;
}
free_gpadl(gpadl);
}
uint32_t vmbus_gpadl_len(VMBusGpadl *gpadl)
{
return gpadl->num_gfns * TARGET_PAGE_SIZE;
}
static void gpadl_iter_init(GpadlIter *iter, VMBusGpadl *gpadl,
AddressSpace *as, DMADirection dir)
{
iter->gpadl = gpadl;
iter->as = as;
iter->dir = dir;
iter->active = false;
}
static inline void gpadl_iter_cache_unmap(GpadlIter *iter)
{
uint32_t map_start_in_page = (uintptr_t)iter->map & ~TARGET_PAGE_MASK;
uint32_t io_end_in_page = ((iter->last_off - 1) & ~TARGET_PAGE_MASK) + 1;
/* mapping is only done to do non-zero amount of i/o */
assert(iter->last_off > 0);
assert(map_start_in_page < io_end_in_page);
dma_memory_unmap(iter->as, iter->map, TARGET_PAGE_SIZE - map_start_in_page,
iter->dir, io_end_in_page - map_start_in_page);
}
/*
* Copy exactly @len bytes between the GPADL pointed to by @iter and @buf.
* The direction of the copy is determined by @iter->dir.
* The caller must ensure the operation overflows neither @buf nor the GPADL
* (there's an assert for the latter).
* Reuse the currently mapped page in the GPADL if possible.
*/
static ssize_t gpadl_iter_io(GpadlIter *iter, void *buf, uint32_t len)
{
ssize_t ret = len;
assert(iter->active);
while (len) {
uint32_t off_in_page = iter->off & ~TARGET_PAGE_MASK;
uint32_t pgleft = TARGET_PAGE_SIZE - off_in_page;
uint32_t cplen = MIN(pgleft, len);
void *p;
/* try to reuse the cached mapping */
if (iter->map) {
uint32_t map_start_in_page =
(uintptr_t)iter->map & ~TARGET_PAGE_MASK;
uint32_t off_base = iter->off & ~TARGET_PAGE_MASK;
uint32_t mapped_base = (iter->last_off - 1) & ~TARGET_PAGE_MASK;
if (off_base != mapped_base || off_in_page < map_start_in_page) {
gpadl_iter_cache_unmap(iter);
iter->map = NULL;
}
}
if (!iter->map) {
dma_addr_t maddr;
dma_addr_t mlen = pgleft;
uint32_t idx = iter->off >> TARGET_PAGE_BITS;
assert(idx < iter->gpadl->num_gfns);
maddr = (iter->gpadl->gfns[idx] << TARGET_PAGE_BITS) | off_in_page;
iter->map = dma_memory_map(iter->as, maddr, &mlen, iter->dir);
if (mlen != pgleft) {
dma_memory_unmap(iter->as, iter->map, mlen, iter->dir, 0);
iter->map = NULL;
return -EFAULT;
}
}
p = (void *)(uintptr_t)(((uintptr_t)iter->map & TARGET_PAGE_MASK) |
off_in_page);
if (iter->dir == DMA_DIRECTION_FROM_DEVICE) {
memcpy(p, buf, cplen);
} else {
memcpy(buf, p, cplen);
}
buf += cplen;
len -= cplen;
iter->off += cplen;
iter->last_off = iter->off;
}
return ret;
}
/*
* Position the iterator @iter at new offset @new_off.
* If this results in the cached mapping being unusable with the new offset,
* unmap it.
*/
static inline void gpadl_iter_seek(GpadlIter *iter, uint32_t new_off)
{
assert(iter->active);
iter->off = new_off;
}
/*
* Start a series of i/o on the GPADL.
* After this i/o and seek operations on @iter become legal.
*/
static inline void gpadl_iter_start_io(GpadlIter *iter)
{
assert(!iter->active);
/* mapping is cached lazily on i/o */
iter->map = NULL;
iter->active = true;
}
/*
* End the eariler started series of i/o on the GPADL and release the cached
* mapping if any.
*/
static inline void gpadl_iter_end_io(GpadlIter *iter)
{
assert(iter->active);
if (iter->map) {
gpadl_iter_cache_unmap(iter);
}
iter->active = false;
}
static void vmbus_resched(VMBus *vmbus);
static void vmbus_msg_cb(void *data, int status);
ssize_t vmbus_iov_to_gpadl(VMBusChannel *chan, VMBusGpadl *gpadl, uint32_t off,
const struct iovec *iov, size_t iov_cnt)
{
GpadlIter iter;
size_t i;
ssize_t ret = 0;
gpadl_iter_init(&iter, gpadl, chan->dev->dma_as,
DMA_DIRECTION_FROM_DEVICE);
gpadl_iter_start_io(&iter);
gpadl_iter_seek(&iter, off);
for (i = 0; i < iov_cnt; i++) {
ret = gpadl_iter_io(&iter, iov[i].iov_base, iov[i].iov_len);
if (ret < 0) {
goto out;
}
}
out:
gpadl_iter_end_io(&iter);
return ret;
}
int vmbus_map_sgl(VMBusChanReq *req, DMADirection dir, struct iovec *iov,
unsigned iov_cnt, size_t len, size_t off)
{
int ret_cnt = 0, ret;
unsigned i;
QEMUSGList *sgl = &req->sgl;
ScatterGatherEntry *sg = sgl->sg;
for (i = 0; i < sgl->nsg; i++) {
if (sg[i].len > off) {
break;
}
off -= sg[i].len;
}
for (; len && i < sgl->nsg; i++) {
dma_addr_t mlen = MIN(sg[i].len - off, len);
dma_addr_t addr = sg[i].base + off;
len -= mlen;
off = 0;
for (; mlen; ret_cnt++) {
dma_addr_t l = mlen;
dma_addr_t a = addr;
if (ret_cnt == iov_cnt) {
ret = -ENOBUFS;
goto err;
}
iov[ret_cnt].iov_base = dma_memory_map(sgl->as, a, &l, dir);
if (!l) {
ret = -EFAULT;
goto err;
}
iov[ret_cnt].iov_len = l;
addr += l;
mlen -= l;
}
}
return ret_cnt;
err:
vmbus_unmap_sgl(req, dir, iov, ret_cnt, 0);
return ret;
}
void vmbus_unmap_sgl(VMBusChanReq *req, DMADirection dir, struct iovec *iov,
unsigned iov_cnt, size_t accessed)
{
QEMUSGList *sgl = &req->sgl;
unsigned i;
for (i = 0; i < iov_cnt; i++) {
size_t acsd = MIN(accessed, iov[i].iov_len);
dma_memory_unmap(sgl->as, iov[i].iov_base, iov[i].iov_len, dir, acsd);
accessed -= acsd;
}
}
static const VMStateDescription vmstate_gpadl = {
.name = "vmbus/gpadl",
.version_id = 0,
.minimum_version_id = 0,
.fields = (VMStateField[]) {
VMSTATE_UINT32(id, VMBusGpadl),
VMSTATE_UINT32(child_relid, VMBusGpadl),
VMSTATE_UINT32(num_gfns, VMBusGpadl),
VMSTATE_UINT32(seen_gfns, VMBusGpadl),
VMSTATE_VARRAY_UINT32_ALLOC(gfns, VMBusGpadl, num_gfns, 0,
vmstate_info_uint64, uint64_t),
VMSTATE_UINT8(state, VMBusGpadl),
VMSTATE_END_OF_LIST()
}
};
/*
* Wrap the index into a ring buffer of @len bytes.
* @idx is assumed not to exceed twice the size of the ringbuffer, so only
* single wraparound is considered.
*/
static inline uint32_t rb_idx_wrap(uint32_t idx, uint32_t len)
{
if (idx >= len) {
idx -= len;
}
return idx;
}
/*
* Circular difference between two indices into a ring buffer of @len bytes.
* @allow_catchup - whether @idx1 may catch up @idx2; e.g. read index may catch
* up write index but not vice versa.
*/
static inline uint32_t rb_idx_delta(uint32_t idx1, uint32_t idx2, uint32_t len,
bool allow_catchup)
{
return rb_idx_wrap(idx2 + len - idx1 - !allow_catchup, len);
}
static vmbus_ring_buffer *ringbuf_map_hdr(VMBusRingBufCommon *ringbuf)
{
vmbus_ring_buffer *rb;
dma_addr_t mlen = sizeof(*rb);
rb = dma_memory_map(ringbuf->as, ringbuf->rb_addr, &mlen,
DMA_DIRECTION_FROM_DEVICE);
if (mlen != sizeof(*rb)) {
dma_memory_unmap(ringbuf->as, rb, mlen,
DMA_DIRECTION_FROM_DEVICE, 0);
return NULL;
}
return rb;
}
static void ringbuf_unmap_hdr(VMBusRingBufCommon *ringbuf,
vmbus_ring_buffer *rb, bool dirty)
{
assert(rb);
dma_memory_unmap(ringbuf->as, rb, sizeof(*rb), DMA_DIRECTION_FROM_DEVICE,
dirty ? sizeof(*rb) : 0);
}
static void ringbuf_init_common(VMBusRingBufCommon *ringbuf, VMBusGpadl *gpadl,
AddressSpace *as, DMADirection dir,
uint32_t begin, uint32_t end)
{
ringbuf->as = as;
ringbuf->rb_addr = gpadl->gfns[begin] << TARGET_PAGE_BITS;
ringbuf->base = (begin + 1) << TARGET_PAGE_BITS;
ringbuf->len = (end - begin - 1) << TARGET_PAGE_BITS;
gpadl_iter_init(&ringbuf->iter, gpadl, as, dir);
}
static int ringbufs_init(VMBusChannel *chan)
{
vmbus_ring_buffer *rb;
VMBusSendRingBuf *send_ringbuf = &chan->send_ringbuf;
VMBusRecvRingBuf *recv_ringbuf = &chan->recv_ringbuf;
if (chan->ringbuf_send_offset <= 1 ||
chan->gpadl->num_gfns <= chan->ringbuf_send_offset + 1) {
return -EINVAL;
}
ringbuf_init_common(&recv_ringbuf->common, chan->gpadl, chan->dev->dma_as,
DMA_DIRECTION_TO_DEVICE, 0, chan->ringbuf_send_offset);
ringbuf_init_common(&send_ringbuf->common, chan->gpadl, chan->dev->dma_as,
DMA_DIRECTION_FROM_DEVICE, chan->ringbuf_send_offset,
chan->gpadl->num_gfns);
send_ringbuf->wanted = 0;
send_ringbuf->reserved = 0;
rb = ringbuf_map_hdr(&recv_ringbuf->common);
if (!rb) {
return -EFAULT;
}
recv_ringbuf->rd_idx = recv_ringbuf->last_rd_idx = rb->read_index;
ringbuf_unmap_hdr(&recv_ringbuf->common, rb, false);
rb = ringbuf_map_hdr(&send_ringbuf->common);
if (!rb) {
return -EFAULT;
}
send_ringbuf->wr_idx = send_ringbuf->last_wr_idx = rb->write_index;
send_ringbuf->last_seen_rd_idx = rb->read_index;
rb->feature_bits |= VMBUS_RING_BUFFER_FEAT_PENDING_SZ;
ringbuf_unmap_hdr(&send_ringbuf->common, rb, true);
if (recv_ringbuf->rd_idx >= recv_ringbuf->common.len ||
send_ringbuf->wr_idx >= send_ringbuf->common.len) {
return -EOVERFLOW;
}
return 0;
}
/*
* Perform io between the GPADL-backed ringbuffer @ringbuf and @buf, wrapping
* around if needed.
* @len is assumed not to exceed the size of the ringbuffer, so only single
* wraparound is considered.
*/
static ssize_t ringbuf_io(VMBusRingBufCommon *ringbuf, void *buf, uint32_t len)
{
ssize_t ret1 = 0, ret2 = 0;
uint32_t remain = ringbuf->len + ringbuf->base - ringbuf->iter.off;
if (len >= remain) {
ret1 = gpadl_iter_io(&ringbuf->iter, buf, remain);
if (ret1 < 0) {
return ret1;
}
gpadl_iter_seek(&ringbuf->iter, ringbuf->base);
buf += remain;
len -= remain;
}
ret2 = gpadl_iter_io(&ringbuf->iter, buf, len);
if (ret2 < 0) {
return ret2;
}
return ret1 + ret2;
}
/*
* Position the circular iterator within @ringbuf to offset @new_off, wrapping
* around if needed.
* @new_off is assumed not to exceed twice the size of the ringbuffer, so only
* single wraparound is considered.
*/
static inline void ringbuf_seek(VMBusRingBufCommon *ringbuf, uint32_t new_off)
{
gpadl_iter_seek(&ringbuf->iter,
ringbuf->base + rb_idx_wrap(new_off, ringbuf->len));
}
static inline uint32_t ringbuf_tell(VMBusRingBufCommon *ringbuf)
{
return ringbuf->iter.off - ringbuf->base;
}
static inline void ringbuf_start_io(VMBusRingBufCommon *ringbuf)
{
gpadl_iter_start_io(&ringbuf->iter);
}
static inline void ringbuf_end_io(VMBusRingBufCommon *ringbuf)
{
gpadl_iter_end_io(&ringbuf->iter);
}
VMBusDevice *vmbus_channel_device(VMBusChannel *chan)
{
return chan->dev;
}
VMBusChannel *vmbus_device_channel(VMBusDevice *dev, uint32_t chan_idx)
{
if (chan_idx >= dev->num_channels) {
return NULL;
}
return &dev->channels[chan_idx];
}
uint32_t vmbus_channel_idx(VMBusChannel *chan)
{
return chan - chan->dev->channels;
}
void vmbus_channel_notify_host(VMBusChannel *chan)
{
event_notifier_set(&chan->notifier);
}
bool vmbus_channel_is_open(VMBusChannel *chan)
{
return chan->is_open;
}
/*
* Notify the guest side about the data to work on in the channel ring buffer.
* The notification is done by signaling a dedicated per-channel SynIC event
* flag (more recent guests) or setting a bit in the interrupt page and firing
* the VMBus SINT (older guests).
*/
static int vmbus_channel_notify_guest(VMBusChannel *chan)
{
int res = 0;
unsigned long *int_map, mask;
unsigned idx;
hwaddr addr = chan->vmbus->int_page_gpa;
hwaddr len = TARGET_PAGE_SIZE / 2, dirty = 0;
trace_vmbus_channel_notify_guest(chan->id);
if (!addr) {
return hyperv_set_event_flag(chan->notify_route, chan->id);
}
int_map = cpu_physical_memory_map(addr, &len, 1);
if (len != TARGET_PAGE_SIZE / 2) {
res = -ENXIO;
goto unmap;
}
idx = BIT_WORD(chan->id);
mask = BIT_MASK(chan->id);
if ((qatomic_fetch_or(&int_map[idx], mask) & mask) != mask) {
res = hyperv_sint_route_set_sint(chan->notify_route);
dirty = len;
}
unmap:
cpu_physical_memory_unmap(int_map, len, 1, dirty);
return res;
}
#define VMBUS_PKT_TRAILER sizeof(uint64_t)
static uint32_t vmbus_pkt_hdr_set_offsets(vmbus_packet_hdr *hdr,
uint32_t desclen, uint32_t msglen)
{
hdr->offset_qwords = sizeof(*hdr) / sizeof(uint64_t) +
DIV_ROUND_UP(desclen, sizeof(uint64_t));
hdr->len_qwords = hdr->offset_qwords +
DIV_ROUND_UP(msglen, sizeof(uint64_t));
return hdr->len_qwords * sizeof(uint64_t) + VMBUS_PKT_TRAILER;
}
/*
* Simplified ring buffer operation with paired barriers annotations in the
* producer and consumer loops:
*
* producer * consumer
* ~~~~~~~~ * ~~~~~~~~
* write pending_send_sz * read write_index
* smp_mb [A] * smp_mb [C]
* read read_index * read packet
* smp_mb [B] * read/write out-of-band data
* read/write out-of-band data * smp_mb [B]
* write packet * write read_index
* smp_mb [C] * smp_mb [A]
* write write_index * read pending_send_sz
* smp_wmb [D] * smp_rmb [D]
* write pending_send_sz * read write_index
* ... * ...
*/
static inline uint32_t ringbuf_send_avail(VMBusSendRingBuf *ringbuf)
{
/* don't trust guest data */
if (ringbuf->last_seen_rd_idx >= ringbuf->common.len) {
return 0;
}
return rb_idx_delta(ringbuf->wr_idx, ringbuf->last_seen_rd_idx,
ringbuf->common.len, false);
}
static ssize_t ringbuf_send_update_idx(VMBusChannel *chan)
{
VMBusSendRingBuf *ringbuf = &chan->send_ringbuf;
vmbus_ring_buffer *rb;
uint32_t written;
written = rb_idx_delta(ringbuf->last_wr_idx, ringbuf->wr_idx,
ringbuf->common.len, true);
if (!written) {
return 0;
}
rb = ringbuf_map_hdr(&ringbuf->common);
if (!rb) {
return -EFAULT;
}
ringbuf->reserved -= written;
/* prevent reorder with the data operation and packet write */
smp_mb(); /* barrier pair [C] */
rb->write_index = ringbuf->wr_idx;
/*
* If the producer earlier indicated that it wants to be notified when the
* consumer frees certain amount of space in the ring buffer, that amount
* is reduced by the size of the completed write.
*/
if (ringbuf->wanted) {
/* otherwise reservation would fail */
assert(ringbuf->wanted < written);
ringbuf->wanted -= written;
/* prevent reorder with write_index write */
smp_wmb(); /* barrier pair [D] */
rb->pending_send_sz = ringbuf->wanted;
}
/* prevent reorder with write_index or pending_send_sz write */
smp_mb(); /* barrier pair [A] */
ringbuf->last_seen_rd_idx = rb->read_index;
/*
* The consumer may have missed the reduction of pending_send_sz and skip
* notification, so re-check the blocking condition, and, if it's no longer
* true, ensure processing another iteration by simulating consumer's
* notification.
*/
if (ringbuf_send_avail(ringbuf) >= ringbuf->wanted) {
vmbus_channel_notify_host(chan);
}
/* skip notification by consumer's request */
if (rb->interrupt_mask) {
goto out;
}
/*
* The consumer hasn't caught up with the producer's previous state so it's
* not blocked.
* (last_seen_rd_idx comes from the guest but it's safe to use w/o
* validation here as it only affects notification.)
*/
if (rb_idx_delta(ringbuf->last_seen_rd_idx, ringbuf->wr_idx,
ringbuf->common.len, true) > written) {
goto out;
}
vmbus_channel_notify_guest(chan);
out:
ringbuf_unmap_hdr(&ringbuf->common, rb, true);
ringbuf->last_wr_idx = ringbuf->wr_idx;
return written;
}
int vmbus_channel_reserve(VMBusChannel *chan,
uint32_t desclen, uint32_t msglen)
{
VMBusSendRingBuf *ringbuf = &chan->send_ringbuf;
vmbus_ring_buffer *rb = NULL;
vmbus_packet_hdr hdr;
uint32_t needed = ringbuf->reserved +
vmbus_pkt_hdr_set_offsets(&hdr, desclen, msglen);
/* avoid touching the guest memory if possible */
if (likely(needed <= ringbuf_send_avail(ringbuf))) {
goto success;
}
rb = ringbuf_map_hdr(&ringbuf->common);
if (!rb) {
return -EFAULT;
}
/* fetch read index from guest memory and try again */
ringbuf->last_seen_rd_idx = rb->read_index;
if (likely(needed <= ringbuf_send_avail(ringbuf))) {
goto success;
}
rb->pending_send_sz = needed;
/*
* The consumer may have made progress and freed up some space before
* seeing updated pending_send_sz, so re-read read_index (preventing
* reorder with the pending_send_sz write) and try again.
*/
smp_mb(); /* barrier pair [A] */
ringbuf->last_seen_rd_idx = rb->read_index;
if (needed > ringbuf_send_avail(ringbuf)) {
goto out;
}
success:
ringbuf->reserved = needed;
needed = 0;
/* clear pending_send_sz if it was set */
if (ringbuf->wanted) {
if (!rb) {
rb = ringbuf_map_hdr(&ringbuf->common);
if (!rb) {
/* failure to clear pending_send_sz is non-fatal */
goto out;
}
}
rb->pending_send_sz = 0;
}
/* prevent reorder of the following data operation with read_index read */
smp_mb(); /* barrier pair [B] */
out:
if (rb) {
ringbuf_unmap_hdr(&ringbuf->common, rb, ringbuf->wanted == needed);
}
ringbuf->wanted = needed;
return needed ? -ENOSPC : 0;
}
ssize_t vmbus_channel_send(VMBusChannel *chan, uint16_t pkt_type,
void *desc, uint32_t desclen,
void *msg, uint32_t msglen,
bool need_comp, uint64_t transaction_id)
{
ssize_t ret = 0;
vmbus_packet_hdr hdr;
uint32_t totlen;
VMBusSendRingBuf *ringbuf = &chan->send_ringbuf;
if (!vmbus_channel_is_open(chan)) {
return -EINVAL;
}
totlen = vmbus_pkt_hdr_set_offsets(&hdr, desclen, msglen);
hdr.type = pkt_type;
hdr.flags = need_comp ? VMBUS_PACKET_FLAG_REQUEST_COMPLETION : 0;
hdr.transaction_id = transaction_id;
assert(totlen <= ringbuf->reserved);
ringbuf_start_io(&ringbuf->common);
ringbuf_seek(&ringbuf->common, ringbuf->wr_idx);
ret = ringbuf_io(&ringbuf->common, &hdr, sizeof(hdr));
if (ret < 0) {
goto out;
}
if (desclen) {
assert(desc);
ret = ringbuf_io(&ringbuf->common, desc, desclen);
if (ret < 0) {
goto out;
}
ringbuf_seek(&ringbuf->common,
ringbuf->wr_idx + hdr.offset_qwords * sizeof(uint64_t));
}
ret = ringbuf_io(&ringbuf->common, msg, msglen);
if (ret < 0) {
goto out;
}
ringbuf_seek(&ringbuf->common, ringbuf->wr_idx + totlen);
ringbuf->wr_idx = ringbuf_tell(&ringbuf->common);
ret = 0;
out:
ringbuf_end_io(&ringbuf->common);
if (ret) {
return ret;
}
return ringbuf_send_update_idx(chan);
}
ssize_t vmbus_channel_send_completion(VMBusChanReq *req,
void *msg, uint32_t msglen)
{
assert(req->need_comp);
return vmbus_channel_send(req->chan, VMBUS_PACKET_COMP, NULL, 0,
msg, msglen, false, req->transaction_id);
}
static int sgl_from_gpa_ranges(QEMUSGList *sgl, VMBusDevice *dev,
VMBusRingBufCommon *ringbuf, uint32_t len)
{
int ret;
vmbus_pkt_gpa_direct hdr;
hwaddr curaddr = 0;
hwaddr curlen = 0;
int num;
if (len < sizeof(hdr)) {
return -EIO;
}
ret = ringbuf_io(ringbuf, &hdr, sizeof(hdr));
if (ret < 0) {
return ret;
}
len -= sizeof(hdr);
num = (len - hdr.rangecount * sizeof(vmbus_gpa_range)) / sizeof(uint64_t);
if (num < 0) {
return -EIO;
}
qemu_sglist_init(sgl, DEVICE(dev), num, ringbuf->as);
for (; hdr.rangecount; hdr.rangecount--) {
vmbus_gpa_range range;
if (len < sizeof(range)) {
goto eio;
}
ret = ringbuf_io(ringbuf, &range, sizeof(range));
if (ret < 0) {
goto err;
}
len -= sizeof(range);
if (range.byte_offset & TARGET_PAGE_MASK) {
goto eio;
}
for (; range.byte_count; range.byte_offset = 0) {
uint64_t paddr;
uint32_t plen = MIN(range.byte_count,
TARGET_PAGE_SIZE - range.byte_offset);
if (len < sizeof(uint64_t)) {
goto eio;
}
ret = ringbuf_io(ringbuf, &paddr, sizeof(paddr));
if (ret < 0) {
goto err;
}
len -= sizeof(uint64_t);
paddr <<= TARGET_PAGE_BITS;
paddr |= range.byte_offset;
range.byte_count -= plen;
if (curaddr + curlen == paddr) {
/* consecutive fragments - join */
curlen += plen;
} else {
if (curlen) {
qemu_sglist_add(sgl, curaddr, curlen);
}
curaddr = paddr;
curlen = plen;
}
}
}
if (curlen) {
qemu_sglist_add(sgl, curaddr, curlen);
}
return 0;
eio:
ret = -EIO;
err:
qemu_sglist_destroy(sgl);
return ret;
}
static VMBusChanReq *vmbus_alloc_req(VMBusChannel *chan,
uint32_t size, uint16_t pkt_type,
uint32_t msglen, uint64_t transaction_id,
bool need_comp)
{
VMBusChanReq *req;
uint32_t msgoff = QEMU_ALIGN_UP(size, __alignof__(*req->msg));
uint32_t totlen = msgoff + msglen;
req = g_malloc0(totlen);
req->chan = chan;
req->pkt_type = pkt_type;
req->msg = (void *)req + msgoff;
req->msglen = msglen;
req->transaction_id = transaction_id;
req->need_comp = need_comp;
return req;
}
int vmbus_channel_recv_start(VMBusChannel *chan)
{
VMBusRecvRingBuf *ringbuf = &chan->recv_ringbuf;
vmbus_ring_buffer *rb;
rb = ringbuf_map_hdr(&ringbuf->common);
if (!rb) {
return -EFAULT;
}
ringbuf->last_seen_wr_idx = rb->write_index;
ringbuf_unmap_hdr(&ringbuf->common, rb, false);
if (ringbuf->last_seen_wr_idx >= ringbuf->common.len) {
return -EOVERFLOW;
}
/* prevent reorder of the following data operation with write_index read */
smp_mb(); /* barrier pair [C] */
return 0;
}
void *vmbus_channel_recv_peek(VMBusChannel *chan, uint32_t size)
{
VMBusRecvRingBuf *ringbuf = &chan->recv_ringbuf;
vmbus_packet_hdr hdr = {};
VMBusChanReq *req;
uint32_t avail;
uint32_t totlen, pktlen, msglen, msgoff, desclen;
assert(size >= sizeof(*req));
/* safe as last_seen_wr_idx is validated in vmbus_channel_recv_start */
avail = rb_idx_delta(ringbuf->rd_idx, ringbuf->last_seen_wr_idx,
ringbuf->common.len, true);
if (avail < sizeof(hdr)) {
return NULL;
}
ringbuf_seek(&ringbuf->common, ringbuf->rd_idx);
if (ringbuf_io(&ringbuf->common, &hdr, sizeof(hdr)) < 0) {
return NULL;
}
pktlen = hdr.len_qwords * sizeof(uint64_t);
totlen = pktlen + VMBUS_PKT_TRAILER;
if (totlen > avail) {
return NULL;
}
msgoff = hdr.offset_qwords * sizeof(uint64_t);
if (msgoff > pktlen || msgoff < sizeof(hdr)) {
error_report("%s: malformed packet: %u %u", __func__, msgoff, pktlen);
return NULL;
}
msglen = pktlen - msgoff;
req = vmbus_alloc_req(chan, size, hdr.type, msglen, hdr.transaction_id,
hdr.flags & VMBUS_PACKET_FLAG_REQUEST_COMPLETION);
switch (hdr.type) {
case VMBUS_PACKET_DATA_USING_GPA_DIRECT:
desclen = msgoff - sizeof(hdr);
if (sgl_from_gpa_ranges(&req->sgl, chan->dev, &ringbuf->common,
desclen) < 0) {
error_report("%s: failed to convert GPA ranges to SGL", __func__);
goto free_req;
}
break;
case VMBUS_PACKET_DATA_INBAND:
case VMBUS_PACKET_COMP:
break;
default:
error_report("%s: unexpected msg type: %x", __func__, hdr.type);
goto free_req;
}
ringbuf_seek(&ringbuf->common, ringbuf->rd_idx + msgoff);
if (ringbuf_io(&ringbuf->common, req->msg, msglen) < 0) {
goto free_req;
}
ringbuf_seek(&ringbuf->common, ringbuf->rd_idx + totlen);
return req;
free_req:
vmbus_free_req(req);
return NULL;
}
void vmbus_channel_recv_pop(VMBusChannel *chan)
{
VMBusRecvRingBuf *ringbuf = &chan->recv_ringbuf;
ringbuf->rd_idx = ringbuf_tell(&ringbuf->common);
}
ssize_t vmbus_channel_recv_done(VMBusChannel *chan)
{
VMBusRecvRingBuf *ringbuf = &chan->recv_ringbuf;
vmbus_ring_buffer *rb;
uint32_t read;
read = rb_idx_delta(ringbuf->last_rd_idx, ringbuf->rd_idx,
ringbuf->common.len, true);
if (!read) {
return 0;
}
rb = ringbuf_map_hdr(&ringbuf->common);
if (!rb) {
return -EFAULT;
}
/* prevent reorder with the data operation and packet read */
smp_mb(); /* barrier pair [B] */
rb->read_index = ringbuf->rd_idx;
/* prevent reorder of the following pending_send_sz read */
smp_mb(); /* barrier pair [A] */
if (rb->interrupt_mask) {
goto out;
}
if (rb->feature_bits & VMBUS_RING_BUFFER_FEAT_PENDING_SZ) {
uint32_t wr_idx, wr_avail;
uint32_t wanted = rb->pending_send_sz;
if (!wanted) {
goto out;
}
/* prevent reorder with pending_send_sz read */
smp_rmb(); /* barrier pair [D] */
wr_idx = rb->write_index;
wr_avail = rb_idx_delta(wr_idx, ringbuf->rd_idx, ringbuf->common.len,
true);
/* the producer wasn't blocked on the consumer state */
if (wr_avail >= read + wanted) {
goto out;
}
/* there's not enough space for the producer to make progress */
if (wr_avail < wanted) {
goto out;
}
}
vmbus_channel_notify_guest(chan);
out:
ringbuf_unmap_hdr(&ringbuf->common, rb, true);
ringbuf->last_rd_idx = ringbuf->rd_idx;
return read;
}
void vmbus_free_req(void *req)
{
VMBusChanReq *r = req;
if (!req) {
return;
}
if (r->sgl.dev) {
qemu_sglist_destroy(&r->sgl);
}
g_free(req);
}
static const VMStateDescription vmstate_sgent = {
.name = "vmbus/sgentry",
.version_id = 0,
.minimum_version_id = 0,
.fields = (VMStateField[]) {
VMSTATE_UINT64(base, ScatterGatherEntry),
VMSTATE_UINT64(len, ScatterGatherEntry),
VMSTATE_END_OF_LIST()
}
};
typedef struct VMBusChanReqSave {
uint16_t chan_idx;
uint16_t pkt_type;
uint32_t msglen;
void *msg;
uint64_t transaction_id;
bool need_comp;
uint32_t num;
ScatterGatherEntry *sgl;
} VMBusChanReqSave;
static const VMStateDescription vmstate_vmbus_chan_req = {
.name = "vmbus/vmbus_chan_req",
.version_id = 0,
.minimum_version_id = 0,
.fields = (VMStateField[]) {
VMSTATE_UINT16(chan_idx, VMBusChanReqSave),
VMSTATE_UINT16(pkt_type, VMBusChanReqSave),
VMSTATE_UINT32(msglen, VMBusChanReqSave),
VMSTATE_VBUFFER_ALLOC_UINT32(msg, VMBusChanReqSave, 0, NULL, msglen),
VMSTATE_UINT64(transaction_id, VMBusChanReqSave),
VMSTATE_BOOL(need_comp, VMBusChanReqSave),
VMSTATE_UINT32(num, VMBusChanReqSave),
VMSTATE_STRUCT_VARRAY_POINTER_UINT32(sgl, VMBusChanReqSave, num,
vmstate_sgent, ScatterGatherEntry),
VMSTATE_END_OF_LIST()
}
};
void vmbus_save_req(QEMUFile *f, VMBusChanReq *req)
{
VMBusChanReqSave req_save;
req_save.chan_idx = req->chan->subchan_idx;
req_save.pkt_type = req->pkt_type;
req_save.msglen = req->msglen;
req_save.msg = req->msg;
req_save.transaction_id = req->transaction_id;
req_save.need_comp = req->need_comp;
req_save.num = req->sgl.nsg;
req_save.sgl = g_memdup(req->sgl.sg,
req_save.num * sizeof(ScatterGatherEntry));
vmstate_save_state(f, &vmstate_vmbus_chan_req, &req_save, NULL);
g_free(req_save.sgl);
}
void *vmbus_load_req(QEMUFile *f, VMBusDevice *dev, uint32_t size)
{
VMBusChanReqSave req_save;
VMBusChanReq *req = NULL;
VMBusChannel *chan = NULL;
uint32_t i;
vmstate_load_state(f, &vmstate_vmbus_chan_req, &req_save, 0);
if (req_save.chan_idx >= dev->num_channels) {
error_report("%s: %u(chan_idx) > %u(num_channels)", __func__,
req_save.chan_idx, dev->num_channels);
goto out;
}
chan = &dev->channels[req_save.chan_idx];
if (vmbus_channel_reserve(chan, 0, req_save.msglen)) {
goto out;
}
req = vmbus_alloc_req(chan, size, req_save.pkt_type, req_save.msglen,
req_save.transaction_id, req_save.need_comp);
if (req_save.msglen) {
memcpy(req->msg, req_save.msg, req_save.msglen);
}
for (i = 0; i < req_save.num; i++) {
qemu_sglist_add(&req->sgl, req_save.sgl[i].base, req_save.sgl[i].len);
}
out:
if (req_save.msglen) {
g_free(req_save.msg);
}
if (req_save.num) {
g_free(req_save.sgl);
}
return req;
}
static void channel_event_cb(EventNotifier *e)
{
VMBusChannel *chan = container_of(e, VMBusChannel, notifier);
if (event_notifier_test_and_clear(e)) {
/*
* All receives are supposed to happen within the device worker, so
* bracket it with ringbuf_start/end_io on the receive ringbuffer, and
* potentially reuse the cached mapping throughout the worker.
* Can't do this for sends as they may happen outside the device
* worker.
*/
VMBusRecvRingBuf *ringbuf = &chan->recv_ringbuf;
ringbuf_start_io(&ringbuf->common);
chan->notify_cb(chan);
ringbuf_end_io(&ringbuf->common);
}
}
static int alloc_chan_id(VMBus *vmbus)
{
int ret;
ret = find_next_zero_bit(vmbus->chanid_bitmap, VMBUS_CHANID_COUNT, 0);
if (ret == VMBUS_CHANID_COUNT) {
return -ENOMEM;
}
return ret + VMBUS_FIRST_CHANID;
}
static int register_chan_id(VMBusChannel *chan)
{
return test_and_set_bit(chan->id - VMBUS_FIRST_CHANID,
chan->vmbus->chanid_bitmap) ? -EEXIST : 0;
}
static void unregister_chan_id(VMBusChannel *chan)
{
clear_bit(chan->id - VMBUS_FIRST_CHANID, chan->vmbus->chanid_bitmap);
}
static uint32_t chan_connection_id(VMBusChannel *chan)
{
return VMBUS_CHAN_CONNECTION_OFFSET + chan->id;
}
static void init_channel(VMBus *vmbus, VMBusDevice *dev, VMBusDeviceClass *vdc,
VMBusChannel *chan, uint16_t idx, Error **errp)
{
int res;
chan->dev = dev;
chan->notify_cb = vdc->chan_notify_cb;
chan->subchan_idx = idx;
chan->vmbus = vmbus;
res = alloc_chan_id(vmbus);
if (res < 0) {
error_setg(errp, "no spare channel id");
return;
}
chan->id = res;
register_chan_id(chan);
/*
* The guest drivers depend on the device subchannels (idx #1+) to be
* offered after the primary channel (idx #0) of that device. To ensure
* that, record the channels on the channel list in the order they appear
* within the device.
*/
QTAILQ_INSERT_TAIL(&vmbus->channel_list, chan, link);
}
static void deinit_channel(VMBusChannel *chan)
{
assert(chan->state == VMCHAN_INIT);
QTAILQ_REMOVE(&chan->vmbus->channel_list, chan, link);
unregister_chan_id(chan);
}
static void create_channels(VMBus *vmbus, VMBusDevice *dev, Error **errp)
{
uint16_t i;
VMBusDeviceClass *vdc = VMBUS_DEVICE_GET_CLASS(dev);
Error *err = NULL;
dev->num_channels = vdc->num_channels ? vdc->num_channels(dev) : 1;
if (dev->num_channels < 1) {
error_setg(errp, "invalid #channels: %u", dev->num_channels);
return;
}
dev->channels = g_new0(VMBusChannel, dev->num_channels);
for (i = 0; i < dev->num_channels; i++) {
init_channel(vmbus, dev, vdc, &dev->channels[i], i, &err);
if (err) {
goto err_init;
}
}
return;
err_init:
while (i--) {
deinit_channel(&dev->channels[i]);
}
error_propagate(errp, err);
}
static void free_channels(VMBusDevice *dev)
{
uint16_t i;
for (i = 0; i < dev->num_channels; i++) {
deinit_channel(&dev->channels[i]);
}
g_free(dev->channels);
}
static HvSintRoute *make_sint_route(VMBus *vmbus, uint32_t vp_index)
{
VMBusChannel *chan;
if (vp_index == vmbus->target_vp) {
hyperv_sint_route_ref(vmbus->sint_route);
return vmbus->sint_route;
}
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->target_vp == vp_index && vmbus_channel_is_open(chan)) {
hyperv_sint_route_ref(chan->notify_route);
return chan->notify_route;
}
}
return hyperv_sint_route_new(vp_index, VMBUS_SINT, NULL, NULL);
}
static void open_channel(VMBusChannel *chan)
{
VMBusDeviceClass *vdc = VMBUS_DEVICE_GET_CLASS(chan->dev);
chan->gpadl = vmbus_get_gpadl(chan, chan->ringbuf_gpadl);
if (!chan->gpadl) {
return;
}
if (ringbufs_init(chan)) {
goto put_gpadl;
}
if (event_notifier_init(&chan->notifier, 0)) {
goto put_gpadl;
}
event_notifier_set_handler(&chan->notifier, channel_event_cb);
if (hyperv_set_event_flag_handler(chan_connection_id(chan),
&chan->notifier)) {
goto cleanup_notifier;
}
chan->notify_route = make_sint_route(chan->vmbus, chan->target_vp);
if (!chan->notify_route) {
goto clear_event_flag_handler;
}
if (vdc->open_channel && vdc->open_channel(chan)) {
goto unref_sint_route;
}
chan->is_open = true;
return;
unref_sint_route:
hyperv_sint_route_unref(chan->notify_route);
clear_event_flag_handler:
hyperv_set_event_flag_handler(chan_connection_id(chan), NULL);
cleanup_notifier:
event_notifier_set_handler(&chan->notifier, NULL);
event_notifier_cleanup(&chan->notifier);
put_gpadl:
vmbus_put_gpadl(chan->gpadl);
}
static void close_channel(VMBusChannel *chan)
{
VMBusDeviceClass *vdc = VMBUS_DEVICE_GET_CLASS(chan->dev);
if (!chan->is_open) {
return;
}
if (vdc->close_channel) {
vdc->close_channel(chan);
}
hyperv_sint_route_unref(chan->notify_route);
hyperv_set_event_flag_handler(chan_connection_id(chan), NULL);
event_notifier_set_handler(&chan->notifier, NULL);
event_notifier_cleanup(&chan->notifier);
vmbus_put_gpadl(chan->gpadl);
chan->is_open = false;
}
static int channel_post_load(void *opaque, int version_id)
{
VMBusChannel *chan = opaque;
return register_chan_id(chan);
}
static const VMStateDescription vmstate_channel = {
.name = "vmbus/channel",
.version_id = 0,
.minimum_version_id = 0,
.post_load = channel_post_load,
.fields = (VMStateField[]) {
VMSTATE_UINT32(id, VMBusChannel),
VMSTATE_UINT16(subchan_idx, VMBusChannel),
VMSTATE_UINT32(open_id, VMBusChannel),
VMSTATE_UINT32(target_vp, VMBusChannel),
VMSTATE_UINT32(ringbuf_gpadl, VMBusChannel),
VMSTATE_UINT32(ringbuf_send_offset, VMBusChannel),
VMSTATE_UINT8(offer_state, VMBusChannel),
VMSTATE_UINT8(state, VMBusChannel),
VMSTATE_END_OF_LIST()
}
};
static VMBusChannel *find_channel(VMBus *vmbus, uint32_t id)
{
VMBusChannel *chan;
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->id == id) {
return chan;
}
}
return NULL;
}
static int enqueue_incoming_message(VMBus *vmbus,
const struct hyperv_post_message_input *msg)
{
int ret = 0;
uint8_t idx, prev_size;
qemu_mutex_lock(&vmbus->rx_queue_lock);
if (vmbus->rx_queue_size == HV_MSG_QUEUE_LEN) {
ret = -ENOBUFS;
goto out;
}
prev_size = vmbus->rx_queue_size;
idx = (vmbus->rx_queue_head + vmbus->rx_queue_size) % HV_MSG_QUEUE_LEN;
memcpy(&vmbus->rx_queue[idx], msg, sizeof(*msg));
vmbus->rx_queue_size++;
/* only need to resched if the queue was empty before */
if (!prev_size) {
vmbus_resched(vmbus);
}
out:
qemu_mutex_unlock(&vmbus->rx_queue_lock);
return ret;
}
static uint16_t vmbus_recv_message(const struct hyperv_post_message_input *msg,
void *data)
{
VMBus *vmbus = data;
struct vmbus_message_header *vmbus_msg;
if (msg->message_type != HV_MESSAGE_VMBUS) {
return HV_STATUS_INVALID_HYPERCALL_INPUT;
}
if (msg->payload_size < sizeof(struct vmbus_message_header)) {
return HV_STATUS_INVALID_HYPERCALL_INPUT;
}
vmbus_msg = (struct vmbus_message_header *)msg->payload;
trace_vmbus_recv_message(vmbus_msg->message_type, msg->payload_size);
if (vmbus_msg->message_type == VMBUS_MSG_INVALID ||
vmbus_msg->message_type >= VMBUS_MSG_COUNT) {
error_report("vmbus: unknown message type %#x",
vmbus_msg->message_type);
return HV_STATUS_INVALID_HYPERCALL_INPUT;
}
if (enqueue_incoming_message(vmbus, msg)) {
return HV_STATUS_INSUFFICIENT_BUFFERS;
}
return HV_STATUS_SUCCESS;
}
static bool vmbus_initialized(VMBus *vmbus)
{
return vmbus->version > 0 && vmbus->version <= VMBUS_VERSION_CURRENT;
}
static void vmbus_reset_all(VMBus *vmbus)
{
qbus_reset_all(BUS(vmbus));
}
static void post_msg(VMBus *vmbus, void *msgdata, uint32_t msglen)
{
int ret;
struct hyperv_message msg = {
.header.message_type = HV_MESSAGE_VMBUS,
};
assert(!vmbus->msg_in_progress);
assert(msglen <= sizeof(msg.payload));
assert(msglen >= sizeof(struct vmbus_message_header));
vmbus->msg_in_progress = true;
trace_vmbus_post_msg(((struct vmbus_message_header *)msgdata)->message_type,
msglen);
memcpy(msg.payload, msgdata, msglen);
msg.header.payload_size = ROUND_UP(msglen, VMBUS_MESSAGE_SIZE_ALIGN);
ret = hyperv_post_msg(vmbus->sint_route, &msg);
if (ret == 0 || ret == -EAGAIN) {
return;
}
error_report("message delivery fatal failure: %d; aborting vmbus", ret);
vmbus_reset_all(vmbus);
}
static int vmbus_init(VMBus *vmbus)
{
if (vmbus->target_vp != (uint32_t)-1) {
vmbus->sint_route = hyperv_sint_route_new(vmbus->target_vp, VMBUS_SINT,
vmbus_msg_cb, vmbus);
if (!vmbus->sint_route) {
error_report("failed to set up SINT route");
return -ENOMEM;
}
}
return 0;
}
static void vmbus_deinit(VMBus *vmbus)
{
VMBusGpadl *gpadl, *tmp_gpadl;
VMBusChannel *chan;
QTAILQ_FOREACH_SAFE(gpadl, &vmbus->gpadl_list, link, tmp_gpadl) {
if (gpadl->state == VMGPADL_TORNDOWN) {
continue;
}
vmbus_put_gpadl(gpadl);
}
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
chan->offer_state = VMOFFER_INIT;
}
hyperv_sint_route_unref(vmbus->sint_route);
vmbus->sint_route = NULL;
vmbus->int_page_gpa = 0;
vmbus->target_vp = (uint32_t)-1;
vmbus->version = 0;
vmbus->state = VMBUS_LISTEN;
vmbus->msg_in_progress = false;
}
static void handle_initiate_contact(VMBus *vmbus,
vmbus_message_initiate_contact *msg,
uint32_t msglen)
{
if (msglen < sizeof(*msg)) {
return;
}
trace_vmbus_initiate_contact(msg->version_requested >> 16,
msg->version_requested & 0xffff,
msg->target_vcpu, msg->monitor_page1,
msg->monitor_page2, msg->interrupt_page);
/*
* Reset vmbus on INITIATE_CONTACT regardless of its previous state.
* Useful, in particular, with vmbus-aware BIOS which can't shut vmbus down
* before handing over to OS loader.
*/
vmbus_reset_all(vmbus);
vmbus->target_vp = msg->target_vcpu;
vmbus->version = msg->version_requested;
if (vmbus->version < VMBUS_VERSION_WIN8) {
/* linux passes interrupt page even when it doesn't need it */
vmbus->int_page_gpa = msg->interrupt_page;
}
vmbus->state = VMBUS_HANDSHAKE;
if (vmbus_init(vmbus)) {
error_report("failed to init vmbus; aborting");
vmbus_deinit(vmbus);
return;
}
}
static void send_handshake(VMBus *vmbus)
{
struct vmbus_message_version_response msg = {
.header.message_type = VMBUS_MSG_VERSION_RESPONSE,
.version_supported = vmbus_initialized(vmbus),
};
post_msg(vmbus, &msg, sizeof(msg));
}
static void handle_request_offers(VMBus *vmbus, void *msgdata, uint32_t msglen)
{
VMBusChannel *chan;
if (!vmbus_initialized(vmbus)) {
return;
}
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->offer_state == VMOFFER_INIT) {
chan->offer_state = VMOFFER_SENDING;
break;
}
}
vmbus->state = VMBUS_OFFER;
}
static void send_offer(VMBus *vmbus)
{
VMBusChannel *chan;
struct vmbus_message_header alloffers_msg = {
.message_type = VMBUS_MSG_ALLOFFERS_DELIVERED,
};
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->offer_state == VMOFFER_SENDING) {
VMBusDeviceClass *vdc = VMBUS_DEVICE_GET_CLASS(chan->dev);
/* Hyper-V wants LE GUIDs */
QemuUUID classid = qemu_uuid_bswap(vdc->classid);
QemuUUID instanceid = qemu_uuid_bswap(chan->dev->instanceid);
struct vmbus_message_offer_channel msg = {
.header.message_type = VMBUS_MSG_OFFERCHANNEL,
.child_relid = chan->id,
.connection_id = chan_connection_id(chan),
.channel_flags = vdc->channel_flags,
.mmio_size_mb = vdc->mmio_size_mb,
.sub_channel_index = vmbus_channel_idx(chan),
.interrupt_flags = VMBUS_OFFER_INTERRUPT_DEDICATED,
};
memcpy(msg.type_uuid, &classid, sizeof(classid));
memcpy(msg.instance_uuid, &instanceid, sizeof(instanceid));
trace_vmbus_send_offer(chan->id, chan->dev);
post_msg(vmbus, &msg, sizeof(msg));
return;
}
}
/* no more offers, send terminator message */
trace_vmbus_terminate_offers();
post_msg(vmbus, &alloffers_msg, sizeof(alloffers_msg));
}
static bool complete_offer(VMBus *vmbus)
{
VMBusChannel *chan;
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->offer_state == VMOFFER_SENDING) {
chan->offer_state = VMOFFER_SENT;
goto next_offer;
}
}
/*
* no transitioning channels found so this is completing the terminator
* message, and vmbus can move to the next state
*/
return true;
next_offer:
/* try to mark another channel for offering */
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->offer_state == VMOFFER_INIT) {
chan->offer_state = VMOFFER_SENDING;
break;
}
}
/*
* if an offer has been sent there are more offers or the terminator yet to
* send, so no state transition for vmbus
*/
return false;
}
static void handle_gpadl_header(VMBus *vmbus, vmbus_message_gpadl_header *msg,
uint32_t msglen)
{
VMBusGpadl *gpadl;
uint32_t num_gfns, i;
/* must include at least one gpa range */
if (msglen < sizeof(*msg) + sizeof(msg->range[0]) ||
!vmbus_initialized(vmbus)) {
return;
}
num_gfns = (msg->range_buflen - msg->rangecount * sizeof(msg->range[0])) /
sizeof(msg->range[0].pfn_array[0]);
trace_vmbus_gpadl_header(msg->gpadl_id, num_gfns);
/*
* In theory the GPADL_HEADER message can define a GPADL with multiple GPA
* ranges each with arbitrary size and alignment. However in practice only
* single-range page-aligned GPADLs have been observed so just ignore
* anything else and simplify things greatly.
*/
if (msg->rangecount != 1 || msg->range[0].byte_offset ||
(msg->range[0].byte_count != (num_gfns << TARGET_PAGE_BITS))) {
return;
}
/* ignore requests to create already existing GPADLs */
if (find_gpadl(vmbus, msg->gpadl_id)) {
return;
}
gpadl = create_gpadl(vmbus, msg->gpadl_id, msg->child_relid, num_gfns);
for (i = 0; i < num_gfns &&
(void *)&msg->range[0].pfn_array[i + 1] <= (void *)msg + msglen;
i++) {
gpadl->gfns[gpadl->seen_gfns++] = msg->range[0].pfn_array[i];
}
if (gpadl_full(gpadl)) {
vmbus->state = VMBUS_CREATE_GPADL;
}
}
static void handle_gpadl_body(VMBus *vmbus, vmbus_message_gpadl_body *msg,
uint32_t msglen)
{
VMBusGpadl *gpadl;
uint32_t num_gfns_left, i;
if (msglen < sizeof(*msg) || !vmbus_initialized(vmbus)) {
return;
}
trace_vmbus_gpadl_body(msg->gpadl_id);
gpadl = find_gpadl(vmbus, msg->gpadl_id);
if (!gpadl) {
return;
}
num_gfns_left = gpadl->num_gfns - gpadl->seen_gfns;
assert(num_gfns_left);
for (i = 0; i < num_gfns_left &&
(void *)&msg->pfn_array[i + 1] <= (void *)msg + msglen; i++) {
gpadl->gfns[gpadl->seen_gfns++] = msg->pfn_array[i];
}
if (gpadl_full(gpadl)) {
vmbus->state = VMBUS_CREATE_GPADL;
}
}
static void send_create_gpadl(VMBus *vmbus)
{
VMBusGpadl *gpadl;
QTAILQ_FOREACH(gpadl, &vmbus->gpadl_list, link) {
if (gpadl_full(gpadl) && gpadl->state == VMGPADL_INIT) {
struct vmbus_message_gpadl_created msg = {
.header.message_type = VMBUS_MSG_GPADL_CREATED,
.gpadl_id = gpadl->id,
.child_relid = gpadl->child_relid,
};
trace_vmbus_gpadl_created(gpadl->id);
post_msg(vmbus, &msg, sizeof(msg));
return;
}
}
assert(false);
}
static bool complete_create_gpadl(VMBus *vmbus)
{
VMBusGpadl *gpadl;
QTAILQ_FOREACH(gpadl, &vmbus->gpadl_list, link) {
if (gpadl_full(gpadl) && gpadl->state == VMGPADL_INIT) {
gpadl->state = VMGPADL_ALIVE;
return true;
}
}
assert(false);
return false;
}
static void handle_gpadl_teardown(VMBus *vmbus,
vmbus_message_gpadl_teardown *msg,
uint32_t msglen)
{
VMBusGpadl *gpadl;
if (msglen < sizeof(*msg) || !vmbus_initialized(vmbus)) {
return;
}
trace_vmbus_gpadl_teardown(msg->gpadl_id);
gpadl = find_gpadl(vmbus, msg->gpadl_id);
if (!gpadl || gpadl->state == VMGPADL_TORNDOWN) {
return;
}
gpadl->state = VMGPADL_TEARINGDOWN;
vmbus->state = VMBUS_TEARDOWN_GPADL;
}
static void send_teardown_gpadl(VMBus *vmbus)
{
VMBusGpadl *gpadl;
QTAILQ_FOREACH(gpadl, &vmbus->gpadl_list, link) {
if (gpadl->state == VMGPADL_TEARINGDOWN) {
struct vmbus_message_gpadl_torndown msg = {
.header.message_type = VMBUS_MSG_GPADL_TORNDOWN,
.gpadl_id = gpadl->id,
};
trace_vmbus_gpadl_torndown(gpadl->id);
post_msg(vmbus, &msg, sizeof(msg));
return;
}
}
assert(false);
}
static bool complete_teardown_gpadl(VMBus *vmbus)
{
VMBusGpadl *gpadl;
QTAILQ_FOREACH(gpadl, &vmbus->gpadl_list, link) {
if (gpadl->state == VMGPADL_TEARINGDOWN) {
gpadl->state = VMGPADL_TORNDOWN;
vmbus_put_gpadl(gpadl);
return true;
}
}
assert(false);
return false;
}
static void handle_open_channel(VMBus *vmbus, vmbus_message_open_channel *msg,
uint32_t msglen)
{
VMBusChannel *chan;
if (msglen < sizeof(*msg) || !vmbus_initialized(vmbus)) {
return;
}
trace_vmbus_open_channel(msg->child_relid, msg->ring_buffer_gpadl_id,
msg->target_vp);
chan = find_channel(vmbus, msg->child_relid);
if (!chan || chan->state != VMCHAN_INIT) {
return;
}
chan->ringbuf_gpadl = msg->ring_buffer_gpadl_id;
chan->ringbuf_send_offset = msg->ring_buffer_offset;
chan->target_vp = msg->target_vp;
chan->open_id = msg->open_id;
open_channel(chan);
chan->state = VMCHAN_OPENING;
vmbus->state = VMBUS_OPEN_CHANNEL;
}
static void send_open_channel(VMBus *vmbus)
{
VMBusChannel *chan;
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->state == VMCHAN_OPENING) {
struct vmbus_message_open_result msg = {
.header.message_type = VMBUS_MSG_OPENCHANNEL_RESULT,
.child_relid = chan->id,
.open_id = chan->open_id,
.status = !vmbus_channel_is_open(chan),
};
trace_vmbus_channel_open(chan->id, msg.status);
post_msg(vmbus, &msg, sizeof(msg));
return;
}
}
assert(false);
}
static bool complete_open_channel(VMBus *vmbus)
{
VMBusChannel *chan;
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->state == VMCHAN_OPENING) {
if (vmbus_channel_is_open(chan)) {
chan->state = VMCHAN_OPEN;
/*
* simulate guest notification of ringbuffer space made
* available, for the channel protocols where the host
* initiates the communication
*/
vmbus_channel_notify_host(chan);
} else {
chan->state = VMCHAN_INIT;
}
return true;
}
}
assert(false);
return false;
}
static void vdev_reset_on_close(VMBusDevice *vdev)
{
uint16_t i;
for (i = 0; i < vdev->num_channels; i++) {
if (vmbus_channel_is_open(&vdev->channels[i])) {
return;
}
}
/* all channels closed -- reset device */
qdev_reset_all(DEVICE(vdev));
}
static void handle_close_channel(VMBus *vmbus, vmbus_message_close_channel *msg,
uint32_t msglen)
{
VMBusChannel *chan;
if (msglen < sizeof(*msg) || !vmbus_initialized(vmbus)) {
return;
}
trace_vmbus_close_channel(msg->child_relid);
chan = find_channel(vmbus, msg->child_relid);
if (!chan) {
return;
}
close_channel(chan);
chan->state = VMCHAN_INIT;
vdev_reset_on_close(chan->dev);
}
static void handle_unload(VMBus *vmbus, void *msg, uint32_t msglen)
{
vmbus->state = VMBUS_UNLOAD;
}
static void send_unload(VMBus *vmbus)
{
vmbus_message_header msg = {
.message_type = VMBUS_MSG_UNLOAD_RESPONSE,
};
qemu_mutex_lock(&vmbus->rx_queue_lock);
vmbus->rx_queue_size = 0;
qemu_mutex_unlock(&vmbus->rx_queue_lock);
post_msg(vmbus, &msg, sizeof(msg));
return;
}
static bool complete_unload(VMBus *vmbus)
{
vmbus_reset_all(vmbus);
return true;
}
static void process_message(VMBus *vmbus)
{
struct hyperv_post_message_input *hv_msg;
struct vmbus_message_header *msg;
void *msgdata;
uint32_t msglen;
qemu_mutex_lock(&vmbus->rx_queue_lock);
if (!vmbus->rx_queue_size) {
goto unlock;
}
hv_msg = &vmbus->rx_queue[vmbus->rx_queue_head];
msglen = hv_msg->payload_size;
if (msglen < sizeof(*msg)) {
goto out;
}
msgdata = hv_msg->payload;
msg = (struct vmbus_message_header *)msgdata;
trace_vmbus_process_incoming_message(msg->message_type);
switch (msg->message_type) {
case VMBUS_MSG_INITIATE_CONTACT:
handle_initiate_contact(vmbus, msgdata, msglen);
break;
case VMBUS_MSG_REQUESTOFFERS:
handle_request_offers(vmbus, msgdata, msglen);
break;
case VMBUS_MSG_GPADL_HEADER:
handle_gpadl_header(vmbus, msgdata, msglen);
break;
case VMBUS_MSG_GPADL_BODY:
handle_gpadl_body(vmbus, msgdata, msglen);
break;
case VMBUS_MSG_GPADL_TEARDOWN:
handle_gpadl_teardown(vmbus, msgdata, msglen);
break;
case VMBUS_MSG_OPENCHANNEL:
handle_open_channel(vmbus, msgdata, msglen);
break;
case VMBUS_MSG_CLOSECHANNEL:
handle_close_channel(vmbus, msgdata, msglen);
break;
case VMBUS_MSG_UNLOAD:
handle_unload(vmbus, msgdata, msglen);
break;
default:
error_report("unknown message type %#x", msg->message_type);
break;
}
out:
vmbus->rx_queue_size--;
vmbus->rx_queue_head++;
vmbus->rx_queue_head %= HV_MSG_QUEUE_LEN;
vmbus_resched(vmbus);
unlock:
qemu_mutex_unlock(&vmbus->rx_queue_lock);
}
static const struct {
void (*run)(VMBus *vmbus);
bool (*complete)(VMBus *vmbus);
} state_runner[] = {
[VMBUS_LISTEN] = {process_message, NULL},
[VMBUS_HANDSHAKE] = {send_handshake, NULL},
[VMBUS_OFFER] = {send_offer, complete_offer},
[VMBUS_CREATE_GPADL] = {send_create_gpadl, complete_create_gpadl},
[VMBUS_TEARDOWN_GPADL] = {send_teardown_gpadl, complete_teardown_gpadl},
[VMBUS_OPEN_CHANNEL] = {send_open_channel, complete_open_channel},
[VMBUS_UNLOAD] = {send_unload, complete_unload},
};
static void vmbus_do_run(VMBus *vmbus)
{
if (vmbus->msg_in_progress) {
return;
}
assert(vmbus->state < VMBUS_STATE_MAX);
assert(state_runner[vmbus->state].run);
state_runner[vmbus->state].run(vmbus);
}
static void vmbus_run(void *opaque)
{
VMBus *vmbus = opaque;
/* make sure no recursion happens (e.g. due to recursive aio_poll()) */
if (vmbus->in_progress) {
return;
}
vmbus->in_progress = true;
/*
* FIXME: if vmbus_resched() is called from within vmbus_do_run(), it
* should go *after* the code that can result in aio_poll; otherwise
* reschedules can be missed. No idea how to enforce that.
*/
vmbus_do_run(vmbus);
vmbus->in_progress = false;
}
static void vmbus_msg_cb(void *data, int status)
{
VMBus *vmbus = data;
bool (*complete)(VMBus *vmbus);
assert(vmbus->msg_in_progress);
trace_vmbus_msg_cb(status);
if (status == -EAGAIN) {
goto out;
}
if (status) {
error_report("message delivery fatal failure: %d; aborting vmbus",
status);
vmbus_reset_all(vmbus);
return;
}
assert(vmbus->state < VMBUS_STATE_MAX);
complete = state_runner[vmbus->state].complete;
if (!complete || complete(vmbus)) {
vmbus->state = VMBUS_LISTEN;
}
out:
vmbus->msg_in_progress = false;
vmbus_resched(vmbus);
}
static void vmbus_resched(VMBus *vmbus)
{
aio_bh_schedule_oneshot(qemu_get_aio_context(), vmbus_run, vmbus);
}
static void vmbus_signal_event(EventNotifier *e)
{
VMBusChannel *chan;
VMBus *vmbus = container_of(e, VMBus, notifier);
unsigned long *int_map;
hwaddr addr, len;
bool is_dirty = false;
if (!event_notifier_test_and_clear(e)) {
return;
}
trace_vmbus_signal_event();
if (!vmbus->int_page_gpa) {
return;
}
addr = vmbus->int_page_gpa + TARGET_PAGE_SIZE / 2;
len = TARGET_PAGE_SIZE / 2;
int_map = cpu_physical_memory_map(addr, &len, 1);
if (len != TARGET_PAGE_SIZE / 2) {
goto unmap;
}
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (bitmap_test_and_clear_atomic(int_map, chan->id, 1)) {
if (!vmbus_channel_is_open(chan)) {
continue;
}
vmbus_channel_notify_host(chan);
is_dirty = true;
}
}
unmap:
cpu_physical_memory_unmap(int_map, len, 1, is_dirty);
}
static void vmbus_dev_realize(DeviceState *dev, Error **errp)
{
VMBusDevice *vdev = VMBUS_DEVICE(dev);
VMBusDeviceClass *vdc = VMBUS_DEVICE_GET_CLASS(vdev);
VMBus *vmbus = VMBUS(qdev_get_parent_bus(dev));
BusChild *child;
Error *err = NULL;
char idstr[UUID_FMT_LEN + 1];
assert(!qemu_uuid_is_null(&vdev->instanceid));
/* Check for instance id collision for this class id */
QTAILQ_FOREACH(child, &BUS(vmbus)->children, sibling) {
VMBusDevice *child_dev = VMBUS_DEVICE(child->child);
if (child_dev == vdev) {
continue;
}
if (qemu_uuid_is_equal(&child_dev->instanceid, &vdev->instanceid)) {
qemu_uuid_unparse(&vdev->instanceid, idstr);
error_setg(&err, "duplicate vmbus device instance id %s", idstr);
goto error_out;
}
}
vdev->dma_as = &address_space_memory;
create_channels(vmbus, vdev, &err);
if (err) {
goto error_out;
}
if (vdc->vmdev_realize) {
vdc->vmdev_realize(vdev, &err);
if (err) {
goto err_vdc_realize;
}
}
return;
err_vdc_realize:
free_channels(vdev);
error_out:
error_propagate(errp, err);
}
static void vmbus_dev_reset(DeviceState *dev)
{
uint16_t i;
VMBusDevice *vdev = VMBUS_DEVICE(dev);
VMBusDeviceClass *vdc = VMBUS_DEVICE_GET_CLASS(vdev);
if (vdev->channels) {
for (i = 0; i < vdev->num_channels; i++) {
VMBusChannel *chan = &vdev->channels[i];
close_channel(chan);
chan->state = VMCHAN_INIT;
}
}
if (vdc->vmdev_reset) {
vdc->vmdev_reset(vdev);
}
}
static void vmbus_dev_unrealize(DeviceState *dev)
{
VMBusDevice *vdev = VMBUS_DEVICE(dev);
VMBusDeviceClass *vdc = VMBUS_DEVICE_GET_CLASS(vdev);
if (vdc->vmdev_unrealize) {
vdc->vmdev_unrealize(vdev);
}
free_channels(vdev);
}
static void vmbus_dev_class_init(ObjectClass *klass, void *data)
{
DeviceClass *kdev = DEVICE_CLASS(klass);
kdev->bus_type = TYPE_VMBUS;
kdev->realize = vmbus_dev_realize;
kdev->unrealize = vmbus_dev_unrealize;
kdev->reset = vmbus_dev_reset;
}
static Property vmbus_dev_instanceid =
DEFINE_PROP_UUID("instanceid", VMBusDevice, instanceid);
static void vmbus_dev_instance_init(Object *obj)
{
VMBusDevice *vdev = VMBUS_DEVICE(obj);
VMBusDeviceClass *vdc = VMBUS_DEVICE_GET_CLASS(vdev);
if (!qemu_uuid_is_null(&vdc->instanceid)) {
/* Class wants to only have a single instance with a fixed UUID */
vdev->instanceid = vdc->instanceid;
} else {
qdev_property_add_static(DEVICE(vdev), &vmbus_dev_instanceid);
}
}
const VMStateDescription vmstate_vmbus_dev = {
.name = TYPE_VMBUS_DEVICE,
.version_id = 0,
.minimum_version_id = 0,
.fields = (VMStateField[]) {
VMSTATE_UINT8_ARRAY(instanceid.data, VMBusDevice, 16),
VMSTATE_UINT16(num_channels, VMBusDevice),
VMSTATE_STRUCT_VARRAY_POINTER_UINT16(channels, VMBusDevice,
num_channels, vmstate_channel,
VMBusChannel),
VMSTATE_END_OF_LIST()
}
};
/* vmbus generic device base */
static const TypeInfo vmbus_dev_type_info = {
.name = TYPE_VMBUS_DEVICE,
.parent = TYPE_DEVICE,
.abstract = true,
.instance_size = sizeof(VMBusDevice),
.class_size = sizeof(VMBusDeviceClass),
.class_init = vmbus_dev_class_init,
.instance_init = vmbus_dev_instance_init,
};
static void vmbus_realize(BusState *bus, Error **errp)
{
int ret = 0;
Error *local_err = NULL;
VMBus *vmbus = VMBUS(bus);
qemu_mutex_init(&vmbus->rx_queue_lock);
QTAILQ_INIT(&vmbus->gpadl_list);
QTAILQ_INIT(&vmbus->channel_list);
ret = hyperv_set_msg_handler(VMBUS_MESSAGE_CONNECTION_ID,
vmbus_recv_message, vmbus);
if (ret != 0) {
error_setg(&local_err, "hyperv set message handler failed: %d", ret);
goto error_out;
}
ret = event_notifier_init(&vmbus->notifier, 0);
if (ret != 0) {
error_setg(&local_err, "event notifier failed to init with %d", ret);
goto remove_msg_handler;
}
event_notifier_set_handler(&vmbus->notifier, vmbus_signal_event);
ret = hyperv_set_event_flag_handler(VMBUS_EVENT_CONNECTION_ID,
&vmbus->notifier);
if (ret != 0) {
error_setg(&local_err, "hyperv set event handler failed with %d", ret);
goto clear_event_notifier;
}
return;
clear_event_notifier:
event_notifier_cleanup(&vmbus->notifier);
remove_msg_handler:
hyperv_set_msg_handler(VMBUS_MESSAGE_CONNECTION_ID, NULL, NULL);
error_out:
qemu_mutex_destroy(&vmbus->rx_queue_lock);
error_propagate(errp, local_err);
}
static void vmbus_unrealize(BusState *bus)
{
VMBus *vmbus = VMBUS(bus);
hyperv_set_msg_handler(VMBUS_MESSAGE_CONNECTION_ID, NULL, NULL);
hyperv_set_event_flag_handler(VMBUS_EVENT_CONNECTION_ID, NULL);
event_notifier_cleanup(&vmbus->notifier);
qemu_mutex_destroy(&vmbus->rx_queue_lock);
}
static void vmbus_reset(BusState *bus)
{
vmbus_deinit(VMBUS(bus));
}
static char *vmbus_get_dev_path(DeviceState *dev)
{
BusState *bus = qdev_get_parent_bus(dev);
return qdev_get_dev_path(bus->parent);
}
static char *vmbus_get_fw_dev_path(DeviceState *dev)
{
VMBusDevice *vdev = VMBUS_DEVICE(dev);
char uuid[UUID_FMT_LEN + 1];
qemu_uuid_unparse(&vdev->instanceid, uuid);
return g_strdup_printf("%s@%s", qdev_fw_name(dev), uuid);
}
static void vmbus_class_init(ObjectClass *klass, void *data)
{
BusClass *k = BUS_CLASS(klass);
k->get_dev_path = vmbus_get_dev_path;
k->get_fw_dev_path = vmbus_get_fw_dev_path;
k->realize = vmbus_realize;
k->unrealize = vmbus_unrealize;
k->reset = vmbus_reset;
}
static int vmbus_pre_load(void *opaque)
{
VMBusChannel *chan;
VMBus *vmbus = VMBUS(opaque);
/*
* channel IDs allocated by the source will come in the migration stream
* for each channel, so clean up the ones allocated at realize
*/
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
unregister_chan_id(chan);
}
return 0;
}
static int vmbus_post_load(void *opaque, int version_id)
{
int ret;
VMBus *vmbus = VMBUS(opaque);
VMBusGpadl *gpadl;
VMBusChannel *chan;
ret = vmbus_init(vmbus);
if (ret) {
return ret;
}
QTAILQ_FOREACH(gpadl, &vmbus->gpadl_list, link) {
gpadl->vmbus = vmbus;
gpadl->refcount = 1;
}
/*
* reopening channels depends on initialized vmbus so it's done here
* instead of channel_post_load()
*/
QTAILQ_FOREACH(chan, &vmbus->channel_list, link) {
if (chan->state == VMCHAN_OPENING || chan->state == VMCHAN_OPEN) {
open_channel(chan);
}
if (chan->state != VMCHAN_OPEN) {
continue;
}
if (!vmbus_channel_is_open(chan)) {
/* reopen failed, abort loading */
return -1;
}
/* resume processing on the guest side if it missed the notification */
hyperv_sint_route_set_sint(chan->notify_route);
/* ditto on the host side */
vmbus_channel_notify_host(chan);
}
vmbus_resched(vmbus);
return 0;
}
static const VMStateDescription vmstate_post_message_input = {
.name = "vmbus/hyperv_post_message_input",
.version_id = 0,
.minimum_version_id = 0,
.fields = (VMStateField[]) {
/*
* skip connection_id and message_type as they are validated before
* queueing and ignored on dequeueing
*/
VMSTATE_UINT32(payload_size, struct hyperv_post_message_input),
VMSTATE_UINT8_ARRAY(payload, struct hyperv_post_message_input,
HV_MESSAGE_PAYLOAD_SIZE),
VMSTATE_END_OF_LIST()
}
};
static bool vmbus_rx_queue_needed(void *opaque)
{
VMBus *vmbus = VMBUS(opaque);
return vmbus->rx_queue_size;
}
static const VMStateDescription vmstate_rx_queue = {
.name = "vmbus/rx_queue",
.version_id = 0,
.minimum_version_id = 0,
.needed = vmbus_rx_queue_needed,
.fields = (VMStateField[]) {
VMSTATE_UINT8(rx_queue_head, VMBus),
VMSTATE_UINT8(rx_queue_size, VMBus),
VMSTATE_STRUCT_ARRAY(rx_queue, VMBus,
HV_MSG_QUEUE_LEN, 0,
vmstate_post_message_input,
struct hyperv_post_message_input),
VMSTATE_END_OF_LIST()
}
};
static const VMStateDescription vmstate_vmbus = {
.name = TYPE_VMBUS,
.version_id = 0,
.minimum_version_id = 0,
.pre_load = vmbus_pre_load,
.post_load = vmbus_post_load,
.fields = (VMStateField[]) {
VMSTATE_UINT8(state, VMBus),
VMSTATE_UINT32(version, VMBus),
VMSTATE_UINT32(target_vp, VMBus),
VMSTATE_UINT64(int_page_gpa, VMBus),
VMSTATE_QTAILQ_V(gpadl_list, VMBus, 0,
vmstate_gpadl, VMBusGpadl, link),
VMSTATE_END_OF_LIST()
},
.subsections = (const VMStateDescription * []) {
&vmstate_rx_queue,
NULL
}
};
static const TypeInfo vmbus_type_info = {
.name = TYPE_VMBUS,
.parent = TYPE_BUS,
.instance_size = sizeof(VMBus),
.class_init = vmbus_class_init,
};
static void vmbus_bridge_realize(DeviceState *dev, Error **errp)
{
VMBusBridge *bridge = VMBUS_BRIDGE(dev);
/*
* here there's at least one vmbus bridge that is being realized, so
* vmbus_bridge_find can only return NULL if it's not unique
*/
if (!vmbus_bridge_find()) {
error_setg(errp, "there can be at most one %s in the system",
TYPE_VMBUS_BRIDGE);
return;
}
if (!hyperv_is_synic_enabled()) {
error_report("VMBus requires usable Hyper-V SynIC and VP_INDEX");
return;
}
bridge->bus = VMBUS(qbus_create(TYPE_VMBUS, dev, "vmbus"));
}
static char *vmbus_bridge_ofw_unit_address(const SysBusDevice *dev)
{
/* there can be only one VMBus */
return g_strdup("0");
}
static const VMStateDescription vmstate_vmbus_bridge = {
.name = TYPE_VMBUS_BRIDGE,
.version_id = 0,
.minimum_version_id = 0,
.fields = (VMStateField[]) {
VMSTATE_STRUCT_POINTER(bus, VMBusBridge, vmstate_vmbus, VMBus),
VMSTATE_END_OF_LIST()
},
};
static Property vmbus_bridge_props[] = {
DEFINE_PROP_UINT8("irq", VMBusBridge, irq, 7),
DEFINE_PROP_END_OF_LIST()
};
static void vmbus_bridge_class_init(ObjectClass *klass, void *data)
{
DeviceClass *k = DEVICE_CLASS(klass);
SysBusDeviceClass *sk = SYS_BUS_DEVICE_CLASS(klass);
k->realize = vmbus_bridge_realize;
k->fw_name = "vmbus";
sk->explicit_ofw_unit_address = vmbus_bridge_ofw_unit_address;
set_bit(DEVICE_CATEGORY_BRIDGE, k->categories);
k->vmsd = &vmstate_vmbus_bridge;
device_class_set_props(k, vmbus_bridge_props);
/* override SysBusDevice's default */
k->user_creatable = true;
}
static const TypeInfo vmbus_bridge_type_info = {
.name = TYPE_VMBUS_BRIDGE,
.parent = TYPE_SYS_BUS_DEVICE,
.instance_size = sizeof(VMBusBridge),
.class_init = vmbus_bridge_class_init,
};
static void vmbus_register_types(void)
{
type_register_static(&vmbus_bridge_type_info);
type_register_static(&vmbus_dev_type_info);
type_register_static(&vmbus_type_info);
}
type_init(vmbus_register_types)
Reference in New Issue View Git Blame Copy Permalink