/*
* Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/** @file
*
* Hyper-V virtual machine bus
*
*/
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <byteswap.h>
#include <ipxe/nap.h>
#include <ipxe/malloc.h>
#include <ipxe/iobuf.h>
#include <ipxe/bitops.h>
#include <ipxe/hyperv.h>
#include <ipxe/vmbus.h>
/** VMBus initial GPADL ID
*
* This is an opaque value with no meaning. The Linux kernel uses
* 0xe1e10.
*/
#define VMBUS_GPADL_MAGIC 0x18ae0000
/** Current (i.e. most recently issued) GPADL ID */
static unsigned int vmbus_gpadl = VMBUS_GPADL_MAGIC;
/** Obsolete GPADL ID threshold
*
* When the Hyper-V connection is reset, any previous GPADLs are
* automatically rendered obsolete.
*/
unsigned int vmbus_obsolete_gpadl;
/**
* Post message
*
* @v hv Hyper-V hypervisor
* @v header Message header
* @v len Length of message (including header)
* @ret rc Return status code
*/
static int vmbus_post_message ( struct hv_hypervisor *hv,
const struct vmbus_message_header *header,
size_t len ) {
struct vmbus *vmbus = hv->vmbus;
int rc;
/* Post message */
if ( ( rc = hv_post_message ( hv, VMBUS_MESSAGE_ID, VMBUS_MESSAGE_TYPE,
header, len ) ) != 0 ) {
DBGC ( vmbus, "VMBUS %p could not post message: %s\n",
vmbus, strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Post empty message
*
* @v hv Hyper-V hypervisor
* @v type Message type
* @ret rc Return status code
*/
static int vmbus_post_empty_message ( struct hv_hypervisor *hv,
unsigned int type ) {
struct vmbus_message_header header = { .type = cpu_to_le32 ( type ) };
return vmbus_post_message ( hv, &header, sizeof ( header ) );
}
/**
* Wait for received message of any type
*
* @v hv Hyper-V hypervisor
* @ret rc Return status code
*/
static int vmbus_wait_for_any_message ( struct hv_hypervisor *hv ) {
struct vmbus *vmbus = hv->vmbus;
int rc;
/* Wait for message */
if ( ( rc = hv_wait_for_message ( hv, VMBUS_MESSAGE_SINT ) ) != 0 ) {
DBGC ( vmbus, "VMBUS %p failed waiting for message: %s\n",
vmbus, strerror ( rc ) );
return rc;
}
/* Sanity check */
if ( hv->message->received.type != cpu_to_le32 ( VMBUS_MESSAGE_TYPE ) ){
DBGC ( vmbus, "VMBUS %p invalid message type %d\n",
vmbus, le32_to_cpu ( hv->message->received.type ) );
return -EINVAL;
}
return 0;
}
/**
* Wait for received message of a specified type, ignoring any others
*
* @v hv Hyper-V hypervisor
* @v type Message type
* @ret rc Return status code
*/
static int vmbus_wait_for_message ( struct hv_hypervisor *hv,
unsigned int type ) {
struct vmbus *vmbus = hv->vmbus;
const struct vmbus_message_header *header = &vmbus->message->header;
int rc;
/* Loop until specified message arrives, or until an error occurs */
while ( 1 ) {
/* Wait for message */
if ( ( rc = vmbus_wait_for_any_message ( hv ) ) != 0 )
return rc;
/* Check for requested message type */
if ( header->type == cpu_to_le32 ( type ) )
return 0;
/* Ignore any other messages (e.g. due to additional
* channels being offered at runtime).
*/
DBGC ( vmbus, "VMBUS %p ignoring message type %d (expecting "
"%d)\n", vmbus, le32_to_cpu ( header->type ), type );
}
}
/**
* Initiate contact
*
* @v hv Hyper-V hypervisor
* @v raw VMBus protocol (raw) version
* @ret rc Return status code
*/
static int vmbus_initiate_contact ( struct hv_hypervisor *hv,
unsigned int raw ) {
struct vmbus *vmbus = hv->vmbus;
const struct vmbus_version_response *version = &vmbus->message->version;
struct vmbus_initiate_contact initiate;
int rc;
/* Construct message */
memset ( &initiate, 0, sizeof ( initiate ) );
initiate.header.type = cpu_to_le32 ( VMBUS_INITIATE_CONTACT );
initiate.version.raw = cpu_to_le32 ( raw );
initiate.intr = virt_to_phys ( vmbus->intr );
initiate.monitor_in = virt_to_phys ( vmbus->monitor_in );
initiate.monitor_out = virt_to_phys ( vmbus->monitor_out );
/* Post message */
if ( ( rc = vmbus_post_message ( hv, &initiate.header,
sizeof ( initiate ) ) ) != 0 )
return rc;
/* Wait for response */
if ( ( rc = vmbus_wait_for_message ( hv, VMBUS_VERSION_RESPONSE ) ) !=0)
return rc;
/* Check response */
if ( ! version->supported ) {
DBGC ( vmbus, "VMBUS %p requested version not supported\n",
vmbus );
return -ENOTSUP;
}
DBGC ( vmbus, "VMBUS %p initiated contact using version %d.%d\n",
vmbus, le16_to_cpu ( initiate.version.major ),
le16_to_cpu ( initiate.version.minor ) );
return 0;
}
/**
* Terminate contact
*
* @v hv Hyper-V hypervisor
* @ret rc Return status code
*/
static int vmbus_unload ( struct hv_hypervisor *hv ) {
int rc;
/* Post message */
if ( ( rc = vmbus_post_empty_message ( hv, VMBUS_UNLOAD ) ) != 0 )
return rc;
/* Wait for response */
if ( ( rc = vmbus_wait_for_message ( hv, VMBUS_UNLOAD_RESPONSE ) ) != 0)
return rc;
return 0;
}
/**
* Negotiate protocol version
*
* @v hv Hyper-V hypervisor
* @ret rc Return status code
*/
static int vmbus_negotiate_version ( struct hv_hypervisor *hv ) {
int rc;
/* We require the ability to disconnect from and reconnect to
* VMBus; if we don't have this then there is no (viable) way
* for a loaded operating system to continue to use any VMBus
* devices. (There is also a small but non-zero risk that the
* host will continue to write to our interrupt and monitor
* pages, since the VMBUS_UNLOAD message in earlier versions
* is essentially a no-op.)
*
* This requires us to ensure that the host supports protocol
* version 3.0 (VMBUS_VERSION_WIN8_1). However, we can't
* actually _use_ protocol version 3.0, since doing so causes
* an iSCSI-booted Windows Server 2012 R2 VM to crash due to a
* NULL pointer dereference in vmbus.sys.
*
* To work around this problem, we first ensure that we can
* connect using protocol v3.0, then disconnect and reconnect
* using the oldest known protocol.
*/
/* Initiate contact to check for required protocol support */
if ( ( rc = vmbus_initiate_contact ( hv, VMBUS_VERSION_WIN8_1 ) ) != 0 )
return rc;
/* Terminate contact */
if ( ( rc = vmbus_unload ( hv ) ) != 0 )
return rc;
/* Reinitiate contact using the oldest known protocol version */
if ( ( rc = vmbus_initiate_contact ( hv, VMBUS_VERSION_WS2008 ) ) != 0 )
return rc;
return 0;
}
/**
* Establish GPA descriptor list
*
* @v vmdev VMBus device
* @v data Data buffer
* @v len Length of data buffer
* @ret gpadl GPADL ID, or negative error
*/
int vmbus_establish_gpadl ( struct vmbus_device *vmdev, userptr_t data,
size_t len ) {
struct hv_hypervisor *hv = vmdev->hv;
struct vmbus *vmbus = hv->vmbus;
physaddr_t addr = user_to_phys ( data, 0 );
unsigned int pfn_count = hv_pfn_count ( addr, len );
struct {
struct vmbus_gpadl_header gpadlhdr;
struct vmbus_gpa_range range;
uint64_t pfn[pfn_count];
} __attribute__ (( packed )) gpadlhdr;
const struct vmbus_gpadl_created *created = &vmbus->message->created;
unsigned int gpadl;
unsigned int i;
int rc;
/* Allocate GPADL ID */
gpadl = ++vmbus_gpadl;
/* Construct message */
memset ( &gpadlhdr, 0, sizeof ( gpadlhdr ) );
gpadlhdr.gpadlhdr.header.type = cpu_to_le32 ( VMBUS_GPADL_HEADER );
gpadlhdr.gpadlhdr.channel = cpu_to_le32 ( vmdev->channel );
gpadlhdr.gpadlhdr.gpadl = cpu_to_le32 ( gpadl );
gpadlhdr.gpadlhdr.range_len =
cpu_to_le16 ( ( sizeof ( gpadlhdr.range ) +
sizeof ( gpadlhdr.pfn ) ) );
gpadlhdr.gpadlhdr.range_count = cpu_to_le16 ( 1 );
gpadlhdr.range.len = cpu_to_le32 ( len );
gpadlhdr.range.offset = cpu_to_le32 ( addr & ( PAGE_SIZE - 1 ) );
for ( i = 0 ; i < pfn_count ; i++ )
gpadlhdr.pfn[i] = ( ( addr / PAGE_SIZE ) + i );
/* Post message */
if ( ( rc = vmbus_post_message ( hv, &gpadlhdr.gpadlhdr.header,
sizeof ( gpadlhdr ) ) ) != 0 )
return rc;
/* Wait for response */
if ( ( rc = vmbus_wait_for_message ( hv, VMBUS_GPADL_CREATED ) ) != 0 )
return rc;
/* Check response */
if ( created->channel != cpu_to_le32 ( vmdev->channel ) ) {
DBGC ( vmdev, "VMBUS %s unexpected GPADL channel %d\n",
vmdev->dev.name, le32_to_cpu ( created->channel ) );
return -EPROTO;
}
if ( created->gpadl != cpu_to_le32 ( gpadl ) ) {
DBGC ( vmdev, "VMBUS %s unexpected GPADL ID %#08x\n",
vmdev->dev.name, le32_to_cpu ( created->gpadl ) );
return -EPROTO;
}
if ( created->status != 0 ) {
DBGC ( vmdev, "VMBUS %s GPADL creation failed: %#08x\n",
vmdev->dev.name, le32_to_cpu ( created->status ) );
return -EPROTO;
}
DBGC ( vmdev, "VMBUS %s GPADL %#08x is [%08lx,%08lx)\n",
vmdev->dev.name, gpadl, addr, ( addr + len ) );
return gpadl;
}
/**
* Tear down GPA descriptor list
*
* @v vmdev VMBus device
* @v gpadl GPADL ID
* @ret rc Return status code
*/
int vmbus_gpadl_teardown ( struct vmbus_device *vmdev, unsigned int gpadl ) {
struct hv_hypervisor *hv = vmdev->hv;
struct vmbus *vmbus = hv->vmbus;
struct vmbus_gpadl_teardown teardown;
const struct vmbus_gpadl_torndown *torndown = &vmbus->message->torndown;
int rc;
/* If GPADL is obsolete (i.e. was created before the most
* recent Hyper-V reset), then we will never receive a
* response to the teardown message. Since the GPADL is
* already destroyed as far as the hypervisor is concerned, no
* further action is required.
*/
if ( vmbus_gpadl_is_obsolete ( gpadl ) )
return 0;
/* Construct message */
memset ( &teardown, 0, sizeof ( teardown ) );
teardown.header.type = cpu_to_le32 ( VMBUS_GPADL_TEARDOWN );
teardown.channel = cpu_to_le32 ( vmdev->channel );
teardown.gpadl = cpu_to_le32 ( gpadl );
/* Post message */
if ( ( rc = vmbus_post_message ( hv, &teardown.header,
sizeof ( teardown ) ) ) != 0 )
return rc;
/* Wait for response */
if ( ( rc = vmbus_wait_for_message ( hv, VMBUS_GPADL_TORNDOWN ) ) != 0 )
return rc;
/* Check response */
if ( torndown->gpadl != cpu_to_le32 ( gpadl ) ) {
DBGC ( vmdev, "VMBUS %s unexpected GPADL ID %#08x\n",
vmdev->dev.name, le32_to_cpu ( torndown->gpadl ) );
return -EPROTO;
}
return 0;
}
/**
* Open VMBus channel
*
* @v vmdev VMBus device
* @v op Channel operations
* @v out_len Outbound ring buffer length
* @v in_len Inbound ring buffer length
* @v mtu Maximum expected data packet length (including headers)
* @ret rc Return status code
*
* Both outbound and inbound ring buffer lengths must be a power of
* two and a multiple of PAGE_SIZE. The requirement to be a power of
* two is a policy decision taken to simplify the ring buffer indexing
* logic.
*/
int vmbus_open ( struct vmbus_device *vmdev,
struct vmbus_channel_operations *op,
size_t out_len, size_t in_len, size_t mtu ) {
struct hv_hypervisor *hv = vmdev->hv;
struct vmbus *vmbus = hv->vmbus;
struct vmbus_open_channel open;
const struct vmbus_open_channel_result *opened =
&vmbus->message->opened;
size_t len;
void *ring;
void *packet;
int gpadl;
uint32_t open_id;
int rc;
/* Sanity checks */
assert ( ( out_len % PAGE_SIZE ) == 0 );
assert ( ( out_len & ( out_len - 1 ) ) == 0 );
assert ( ( in_len % PAGE_SIZE ) == 0 );
assert ( ( in_len & ( in_len - 1 ) ) == 0 );
assert ( mtu >= ( sizeof ( struct vmbus_packet_header ) +
sizeof ( struct vmbus_packet_footer ) ) );
/* Allocate packet buffer */
packet = malloc ( mtu );
if ( ! packet ) {
rc = -ENOMEM;
goto err_alloc_packet;
}
/* Allocate ring buffer */
len = ( sizeof ( *vmdev->out ) + out_len +
sizeof ( *vmdev->in ) + in_len );
assert ( ( len % PAGE_SIZE ) == 0 );
ring = malloc_dma ( len, PAGE_SIZE );
if ( ! ring ) {
rc = -ENOMEM;
goto err_alloc_ring;
}
memset ( ring, 0, len );
/* Establish GPADL for ring buffer */
gpadl = vmbus_establish_gpadl ( vmdev, virt_to_user ( ring ), len );
if ( gpadl < 0 ) {
rc = gpadl;
goto err_establish;
}
/* Construct message */
memset ( &open, 0, sizeof ( open ) );
open.header.type = cpu_to_le32 ( VMBUS_OPEN_CHANNEL );
open.channel = cpu_to_le32 ( vmdev->channel );
open_id = random();
open.id = open_id; /* Opaque random value: endianness irrelevant */
open.gpadl = cpu_to_le32 ( gpadl );
open.out_pages = ( ( sizeof ( *vmdev->out ) / PAGE_SIZE ) +
( out_len / PAGE_SIZE ) );
/* Post message */
if ( ( rc = vmbus_post_message ( hv, &open.header,
sizeof ( open ) ) ) != 0 )
goto err_post_message;
/* Wait for response */
if ( ( rc = vmbus_wait_for_message ( hv,
VMBUS_OPEN_CHANNEL_RESULT ) ) != 0)
goto err_wait_for_message;
/* Check response */
if ( opened->channel != cpu_to_le32 ( vmdev->channel ) ) {
DBGC ( vmdev, "VMBUS %s unexpected opened channel %#08x\n",
vmdev->dev.name, le32_to_cpu ( opened->channel ) );
rc = -EPROTO;
goto err_check_response;
}
if ( opened->id != open_id /* Non-endian */ ) {
DBGC ( vmdev, "VMBUS %s unexpected open ID %#08x\n",
vmdev->dev.name, le32_to_cpu ( opened->id ) );
rc = -EPROTO;
goto err_check_response;
}
if ( opened->status != 0 ) {
DBGC ( vmdev, "VMBUS %s open failed: %#08x\n",
vmdev->dev.name, le32_to_cpu ( opened->status ) );
rc = -EPROTO;
goto err_check_response;
}
/* Store channel parameters */
vmdev->out_len = out_len;
vmdev->in_len = in_len;
vmdev->out = ring;
vmdev->in = ( ring + sizeof ( *vmdev->out ) + out_len );
vmdev->gpadl = gpadl;
vmdev->op = op;
vmdev->mtu = mtu;
vmdev->packet = packet;
DBGC ( vmdev, "VMBUS %s channel GPADL %#08x ring "
"[%#08lx,%#08lx,%#08lx)\n", vmdev->dev.name, vmdev->gpadl,
virt_to_phys ( vmdev->out ), virt_to_phys ( vmdev->in ),
( virt_to_phys ( vmdev->out ) + len ) );
return 0;
err_check_response:
err_wait_for_message:
err_post_message:
vmbus_gpadl_teardown ( vmdev, vmdev->gpadl );
err_establish:
free_dma ( ring, len );
err_alloc_ring:
free ( packet );
err_alloc_packet:
return rc;
}
/**
* Close VMBus channel
*
* @v vmdev VMBus device
*/
void vmbus_close ( struct vmbus_device *vmdev ) {
struct hv_hypervisor *hv = vmdev->hv;
struct vmbus_close_channel close;
size_t len;
int rc;
/* Construct message */
memset ( &close, 0, sizeof ( close ) );
close.header.type = cpu_to_le32 ( VMBUS_CLOSE_CHANNEL );
close.channel = cpu_to_le32 ( vmdev->channel );
/* Post message */
if ( ( rc = vmbus_post_message ( hv, &close.header,
sizeof ( close ) ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s failed to close: %s\n",
vmdev->dev.name, strerror ( rc ) );
/* Continue to attempt to tear down GPADL, so that our
* memory is no longer accessible by the remote VM.
*/
}
/* Tear down GPADL */
if ( ( rc = vmbus_gpadl_teardown ( vmdev, vmdev->gpadl ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s failed to tear down channel GPADL: "
"%s\n", vmdev->dev.name, strerror ( rc ) );
/* We can't prevent the remote VM from continuing to
* access this memory, so leak it.
*/
return;
}
/* Free ring buffer */
len = ( sizeof ( *vmdev->out ) + vmdev->out_len +
sizeof ( *vmdev->in ) + vmdev->in_len );
free_dma ( vmdev->out, len );
vmdev->out = NULL;
vmdev->in = NULL;
/* Free packet buffer */
free ( vmdev->packet );
vmdev->packet = NULL;
DBGC ( vmdev, "VMBUS %s closed\n", vmdev->dev.name );
}
/**
* Signal channel via monitor page
*
* @v vmdev VMBus device
*/
static void vmbus_signal_monitor ( struct vmbus_device *vmdev ) {
struct hv_hypervisor *hv = vmdev->hv;
struct vmbus *vmbus = hv->vmbus;
struct hv_monitor_trigger *trigger;
unsigned int group;
unsigned int bit;
/* Set bit in monitor trigger group */
group = ( vmdev->monitor / ( 8 * sizeof ( trigger->pending ) ));
bit = ( vmdev->monitor % ( 8 * sizeof ( trigger->pending ) ) );
trigger = &vmbus->monitor_out->trigger[group];
set_bit ( bit, trigger );
}
/**
* Signal channel via hypervisor event
*
* @v vmdev VMBus device
*/
static void vmbus_signal_event ( struct vmbus_device *vmdev ) {
struct hv_hypervisor *hv = vmdev->hv;
int rc;
/* Signal hypervisor event */
if ( ( rc = hv_signal_event ( hv, VMBUS_EVENT_ID, 0 ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s could not signal event: %s\n",
vmdev->dev.name, strerror ( rc ) );
return;
}
}
/**
* Fill outbound ring buffer
*
* @v vmdev VMBus device
* @v prod Producer index
* @v data Data
* @v len Length
* @ret prod New producer index
*
* The caller must ensure that there is sufficient space in the ring
* buffer.
*/
static size_t vmbus_produce ( struct vmbus_device *vmdev, size_t prod,
const void *data, size_t len ) {
size_t first;
size_t second;
/* Determine fragment lengths */
first = ( vmdev->out_len - prod );
if ( first > len )
first = len;
second = ( len - first );
/* Copy fragment(s) */
memcpy ( &vmdev->out->data[prod], data, first );
if ( second )
memcpy ( &vmdev->out->data[0], ( data + first ), second );
return ( ( prod + len ) & ( vmdev->out_len - 1 ) );
}
/**
* Consume inbound ring buffer
*
* @v vmdev VMBus device
* @v cons Consumer index
* @v data Data buffer, or NULL
* @v len Length to consume
* @ret cons New consumer index
*/
static size_t vmbus_consume ( struct vmbus_device *vmdev, size_t cons,
void *data, size_t len ) {
size_t first;
size_t second;
/* Determine fragment lengths */
first = ( vmdev->in_len - cons );
if ( first > len )
first = len;
second = ( len - first );
/* Copy fragment(s) */
memcpy ( data, &vmdev->in->data[cons], first );
if ( second )
memcpy ( ( data + first ), &vmdev->in->data[0], second );
return ( ( cons + len ) & ( vmdev->in_len - 1 ) );
}
/**
* Send packet via ring buffer
*
* @v vmdev VMBus device
* @v header Packet header
* @v data Data
* @v len Length of data
* @ret rc Return status code
*
* Send a packet via the outbound ring buffer. All fields in the
* packet header must be filled in, with the exception of the total
* packet length.
*/
static int vmbus_send ( struct vmbus_device *vmdev,
struct vmbus_packet_header *header,
const void *data, size_t len ) {
struct hv_hypervisor *hv = vmdev->hv;
struct vmbus *vmbus = hv->vmbus;
static uint8_t padding[ 8 - 1 ];
struct vmbus_packet_footer footer;
size_t header_len;
size_t pad_len;
size_t footer_len;
size_t ring_len;
size_t cons;
size_t prod;
size_t old_prod;
size_t fill;
/* Sanity check */
assert ( vmdev->out != NULL );
/* Calculate lengths */
header_len = ( le16_to_cpu ( header->hdr_qlen ) * 8 );
pad_len = ( ( -len ) & ( 8 - 1 ) );
footer_len = sizeof ( footer );
ring_len = ( header_len + len + pad_len + footer_len );
/* Check that we have enough room in the outbound ring buffer */
cons = le32_to_cpu ( vmdev->out->cons );
prod = le32_to_cpu ( vmdev->out->prod );
old_prod = prod;
fill = ( ( prod - cons ) & ( vmdev->out_len - 1 ) );
if ( ( fill + ring_len ) >= vmdev->out_len ) {
DBGC ( vmdev, "VMBUS %s ring buffer full\n", vmdev->dev.name );
return -ENOBUFS;
}
/* Complete header */
header->qlen = cpu_to_le16 ( ( ring_len - footer_len ) / 8 );
/* Construct footer */
footer.reserved = 0;
footer.prod = vmdev->out->prod;
/* Copy packet to buffer */
DBGC2 ( vmdev, "VMBUS %s sending:\n", vmdev->dev.name );
DBGC2_HDA ( vmdev, prod, header, header_len );
prod = vmbus_produce ( vmdev, prod, header, header_len );
DBGC2_HDA ( vmdev, prod, data, len );
prod = vmbus_produce ( vmdev, prod, data, len );
prod = vmbus_produce ( vmdev, prod, padding, pad_len );
DBGC2_HDA ( vmdev, prod, &footer, sizeof ( footer ) );
prod = vmbus_produce ( vmdev, prod, &footer, sizeof ( footer ) );
assert ( ( ( prod - old_prod ) & ( vmdev->out_len - 1 ) ) == ring_len );
/* Update producer index */
wmb();
vmdev->out->prod = cpu_to_le32 ( prod );
/* Return if we do not need to signal the host. This follows
* the logic of hv_need_to_signal() in the Linux driver.
*/
mb();
if ( vmdev->out->intr_mask )
return 0;
rmb();
cons = le32_to_cpu ( vmdev->out->cons );
if ( cons != old_prod )
return 0;
/* Set channel bit in interrupt page */
set_bit ( vmdev->channel, vmbus->intr->out );
/* Signal the host */
vmdev->signal ( vmdev );
return 0;
}
/**
* Send control packet via ring buffer
*
* @v vmdev VMBus device
* @v xid Transaction ID (or zero to not request completion)
* @v data Data
* @v len Length of data
* @ret rc Return status code
*
* Send data using a VMBUS_DATA_INBAND packet.
*/
int vmbus_send_control ( struct vmbus_device *vmdev, uint64_t xid,
const void *data, size_t len ) {
struct vmbus_packet_header *header = vmdev->packet;
/* Construct header in packet buffer */
assert ( header != NULL );
header->type = cpu_to_le16 ( VMBUS_DATA_INBAND );
header->hdr_qlen = cpu_to_le16 ( sizeof ( *header ) / 8 );
header->flags = ( xid ?
cpu_to_le16 ( VMBUS_COMPLETION_REQUESTED ) : 0 );
header->xid = xid; /* Non-endian */
return vmbus_send ( vmdev, header, data, len );
}
/**
* Send data packet via ring buffer
*
* @v vmdev VMBus device
* @v xid Transaction ID
* @v data Data
* @v len Length of data
* @v iobuf I/O buffer
* @ret rc Return status code
*
* Send data using a VMBUS_DATA_GPA_DIRECT packet. The caller is
* responsible for ensuring that the I/O buffer remains untouched
* until the corresponding completion has been received.
*/
int vmbus_send_data ( struct vmbus_device *vmdev, uint64_t xid,
const void *data, size_t len, struct io_buffer *iobuf ) {
physaddr_t addr = virt_to_phys ( iobuf->data );
unsigned int pfn_count = hv_pfn_count ( addr, iob_len ( iobuf ) );
struct {
struct vmbus_gpa_direct_header gpa;
struct vmbus_gpa_range range;
uint64_t pfn[pfn_count];
} __attribute__ (( packed )) *header = vmdev->packet;
unsigned int i;
/* Sanity check */
assert ( header != NULL );
assert ( sizeof ( *header ) <= vmdev->mtu );
/* Construct header in packet buffer */
header->gpa.header.type = cpu_to_le16 ( VMBUS_DATA_GPA_DIRECT );
header->gpa.header.hdr_qlen = cpu_to_le16 ( sizeof ( *header ) / 8 );
header->gpa.header.flags = cpu_to_le16 ( VMBUS_COMPLETION_REQUESTED );
header->gpa.header.xid = xid; /* Non-endian */
header->gpa.range_count = 1;
header->range.len = cpu_to_le32 ( iob_len ( iobuf ) );
header->range.offset = cpu_to_le32 ( addr & ( PAGE_SIZE - 1 ) );
for ( i = 0 ; i < pfn_count ; i++ )
header->pfn[i] = ( ( addr / PAGE_SIZE ) + i );
return vmbus_send ( vmdev, &header->gpa.header, data, len );
}
/**
* Send completion packet via ring buffer
*
* @v vmdev VMBus device
* @v xid Transaction ID
* @v data Data
* @v len Length of data
* @ret rc Return status code
*
* Send data using a VMBUS_COMPLETION packet.
*/
int vmbus_send_completion ( struct vmbus_device *vmdev, uint64_t xid,
const void *data, size_t len ) {
struct vmbus_packet_header *header = vmdev->packet;
/* Construct header in packet buffer */
assert ( header != NULL );
header->type = cpu_to_le16 ( VMBUS_COMPLETION );
header->hdr_qlen = cpu_to_le16 ( sizeof ( *header ) / 8 );
header->flags = 0;
header->xid = xid; /* Non-endian */
return vmbus_send ( vmdev, header, data, len );
}
/**
* Send cancellation packet via ring buffer
*
* @v vmdev VMBus device
* @v xid Transaction ID
* @ret rc Return status code
*
* Send data using a VMBUS_CANCELLATION packet.
*/
int vmbus_send_cancellation ( struct vmbus_device *vmdev, uint64_t xid ) {
struct vmbus_packet_header *header = vmdev->packet;
/* Construct header in packet buffer */
assert ( header != NULL );
header->type = cpu_to_le16 ( VMBUS_CANCELLATION );
header->hdr_qlen = cpu_to_le16 ( sizeof ( *header ) / 8 );
header->flags = 0;
header->xid = xid; /* Non-endian */
return vmbus_send ( vmdev, header, NULL, 0 );
}
/**
* Get transfer page set from pageset ID
*
* @v vmdev VMBus device
* @v pageset Page set ID (in protocol byte order)
* @ret pages Page set, or NULL if not found
*/
static struct vmbus_xfer_pages * vmbus_xfer_pages ( struct vmbus_device *vmdev,
uint16_t pageset ) {
struct vmbus_xfer_pages *pages;
/* Locate page set */
list_for_each_entry ( pages, &vmdev->pages, list ) {
if ( pages->pageset == pageset )
return pages;
}
DBGC ( vmdev, "VMBUS %s unrecognised page set ID %#04x\n",
vmdev->dev.name, le16_to_cpu ( pageset ) );
return NULL;
}
/**
* Construct I/O buffer list from transfer pages
*
* @v vmdev VMBus device
* @v header Transfer page header
* @v list I/O buffer list to populate
* @ret rc Return status code
*/
static int vmbus_xfer_page_iobufs ( struct vmbus_device *vmdev,
struct vmbus_packet_header *header,
struct list_head *list ) {
struct vmbus_xfer_page_header *page_header =
container_of ( header, struct vmbus_xfer_page_header, header );
struct vmbus_xfer_pages *pages;
struct io_buffer *iobuf;
struct io_buffer *tmp;
size_t len;
size_t offset;
unsigned int range_count;
unsigned int i;
int rc;
/* Sanity check */
assert ( header->type == cpu_to_le16 ( VMBUS_DATA_XFER_PAGES ) );
/* Locate page set */
pages = vmbus_xfer_pages ( vmdev, page_header->pageset );
if ( ! pages ) {
rc = -ENOENT;
goto err_pages;
}
/* Allocate and populate I/O buffers */
range_count = le32_to_cpu ( page_header->range_count );
for ( i = 0 ; i < range_count ; i++ ) {
/* Parse header */
len = le32_to_cpu ( page_header->range[i].len );
offset = le32_to_cpu ( page_header->range[i].offset );
/* Allocate I/O buffer */
iobuf = alloc_iob ( len );
if ( ! iobuf ) {
DBGC ( vmdev, "VMBUS %s could not allocate %zd-byte "
"I/O buffer\n", vmdev->dev.name, len );
rc = -ENOMEM;
goto err_alloc;
}
/* Add I/O buffer to list */
list_add ( &iobuf->list, list );
/* Populate I/O buffer */
if ( ( rc = pages->op->copy ( pages, iob_put ( iobuf, len ),
offset, len ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s could not populate I/O buffer "
"range [%zd,%zd): %s\n",
vmdev->dev.name, offset, len, strerror ( rc ) );
goto err_copy;
}
}
return 0;
err_copy:
err_alloc:
list_for_each_entry_safe ( iobuf, tmp, list, list ) {
list_del ( &iobuf->list );
free_iob ( iobuf );
}
err_pages:
return rc;
}
/**
* Poll ring buffer
*
* @v vmdev VMBus device
* @ret rc Return status code
*/
int vmbus_poll ( struct vmbus_device *vmdev ) {
struct vmbus_packet_header *header = vmdev->packet;
struct list_head list;
void *data;
size_t header_len;
size_t len;
size_t footer_len;
size_t ring_len;
size_t cons;
size_t old_cons;
uint64_t xid;
int rc;
/* Sanity checks */
assert ( vmdev->packet != NULL );
assert ( vmdev->in != NULL );
/* Return immediately if buffer is empty */
if ( ! vmbus_has_data ( vmdev ) )
return 0;
cons = le32_to_cpu ( vmdev->in->cons );
old_cons = cons;
/* Consume (start of) header */
cons = vmbus_consume ( vmdev, cons, header, sizeof ( *header ) );
/* Parse and sanity check header */
header_len = ( le16_to_cpu ( header->hdr_qlen ) * 8 );
if ( header_len < sizeof ( *header ) ) {
DBGC ( vmdev, "VMBUS %s received underlength header (%zd "
"bytes)\n", vmdev->dev.name, header_len );
return -EINVAL;
}
len = ( ( le16_to_cpu ( header->qlen ) * 8 ) - header_len );
footer_len = sizeof ( struct vmbus_packet_footer );
ring_len = ( header_len + len + footer_len );
if ( ring_len > vmdev->mtu ) {
DBGC ( vmdev, "VMBUS %s received overlength packet (%zd "
"bytes)\n", vmdev->dev.name, ring_len );
return -ERANGE;
}
xid = le64_to_cpu ( header->xid );
/* Consume remainder of packet */
cons = vmbus_consume ( vmdev, cons,
( ( ( void * ) header ) + sizeof ( *header ) ),
( ring_len - sizeof ( *header ) ) );
DBGC2 ( vmdev, "VMBUS %s received:\n", vmdev->dev.name );
DBGC2_HDA ( vmdev, old_cons, header, ring_len );
assert ( ( ( cons - old_cons ) & ( vmdev->in_len - 1 ) ) == ring_len );
/* Allocate I/O buffers, if applicable */
INIT_LIST_HEAD ( &list );
if ( header->type == cpu_to_le16 ( VMBUS_DATA_XFER_PAGES ) ) {
if ( ( rc = vmbus_xfer_page_iobufs ( vmdev, header,
&list ) ) != 0 )
return rc;
}
/* Update producer index */
rmb();
vmdev->in->cons = cpu_to_le32 ( cons );
/* Handle packet */
data = ( ( ( void * ) header ) + header_len );
switch ( header->type ) {
case cpu_to_le16 ( VMBUS_DATA_INBAND ) :
if ( ( rc = vmdev->op->recv_control ( vmdev, xid, data,
len ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s could not handle control "
"packet: %s\n",
vmdev->dev.name, strerror ( rc ) );
return rc;
}
break;
case cpu_to_le16 ( VMBUS_DATA_XFER_PAGES ) :
if ( ( rc = vmdev->op->recv_data ( vmdev, xid, data, len,
&list ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s could not handle data packet: "
"%s\n", vmdev->dev.name, strerror ( rc ) );
return rc;
}
break;
case cpu_to_le16 ( VMBUS_COMPLETION ) :
if ( ( rc = vmdev->op->recv_completion ( vmdev, xid, data,
len ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s could not handle completion: "
"%s\n", vmdev->dev.name, strerror ( rc ) );
return rc;
}
break;
case cpu_to_le16 ( VMBUS_CANCELLATION ) :
if ( ( rc = vmdev->op->recv_cancellation ( vmdev, xid ) ) != 0){
DBGC ( vmdev, "VMBUS %s could not handle cancellation: "
"%s\n", vmdev->dev.name, strerror ( rc ) );
return rc;
}
break;
default:
DBGC ( vmdev, "VMBUS %s unknown packet type %d\n",
vmdev->dev.name, le16_to_cpu ( header->type ) );
return -ENOTSUP;
}
return 0;
}
/**
* Dump channel status (for debugging)
*
* @v vmdev VMBus device
*/
void vmbus_dump_channel ( struct vmbus_device *vmdev ) {
size_t out_prod = le32_to_cpu ( vmdev->out->prod );
size_t out_cons = le32_to_cpu ( vmdev->out->cons );
size_t in_prod = le32_to_cpu ( vmdev->in->prod );
size_t in_cons = le32_to_cpu ( vmdev->in->cons );
size_t in_len;
size_t first;
size_t second;
/* Dump ring status */
DBGC ( vmdev, "VMBUS %s out %03zx:%03zx%s in %03zx:%03zx%s\n",
vmdev->dev.name, out_prod, out_cons,
( vmdev->out->intr_mask ? "(m)" : "" ), in_prod, in_cons,
( vmdev->in->intr_mask ? "(m)" : "" ) );
/* Dump inbound ring contents, if any */
if ( in_prod != in_cons ) {
in_len = ( ( in_prod - in_cons ) &
( vmdev->in_len - 1 ) );
first = ( vmdev->in_len - in_cons );
if ( first > in_len )
first = in_len;
second = ( in_len - first );
DBGC_HDA ( vmdev, in_cons, &vmdev->in->data[in_cons], first );
DBGC_HDA ( vmdev, 0, &vmdev->in->data[0], second );
}
}
/**
* Find driver for VMBus device
*
* @v vmdev VMBus device
* @ret driver Driver, or NULL
*/
static struct vmbus_driver * vmbus_find_driver ( const union uuid *type ) {
struct vmbus_driver *vmdrv;
for_each_table_entry ( vmdrv, VMBUS_DRIVERS ) {
if ( memcmp ( &vmdrv->type, type, sizeof ( *type ) ) == 0 )
return vmdrv;
}
return NULL;
}
/**
* Probe channels
*
* @v hv Hyper-V hypervisor
* @v parent Parent device
* @ret rc Return status code
*/
static int vmbus_probe_channels ( struct hv_hypervisor *hv,
struct device *parent ) {
struct vmbus *vmbus = hv->vmbus;
const struct vmbus_message_header *header = &vmbus->message->header;
const struct vmbus_offer_channel *offer = &vmbus->message->offer;
const union uuid *type;
union uuid instance;
struct vmbus_driver *driver;
struct vmbus_device *vmdev;
struct vmbus_device *tmp;
unsigned int channel;
int rc;
/* Post message */
if ( ( rc = vmbus_post_empty_message ( hv, VMBUS_REQUEST_OFFERS ) ) !=0)
goto err_post_message;
/* Collect responses */
while ( 1 ) {
/* Wait for response */
if ( ( rc = vmbus_wait_for_any_message ( hv ) ) != 0 )
goto err_wait_for_any_message;
/* Handle response */
if ( header->type == cpu_to_le32 ( VMBUS_OFFER_CHANNEL ) ) {
/* Parse offer */
type = &offer->type;
channel = le32_to_cpu ( offer->channel );
DBGC2 ( vmbus, "VMBUS %p offer %d type %s",
vmbus, channel, uuid_ntoa ( type ) );
if ( offer->monitored )
DBGC2 ( vmbus, " monitor %d", offer->monitor );
DBGC2 ( vmbus, "\n" );
/* Look for a driver */
driver = vmbus_find_driver ( type );
if ( ! driver ) {
DBGC2 ( vmbus, "VMBUS %p has no driver for "
"type %s\n", vmbus, uuid_ntoa ( type ));
/* Not a fatal error */
continue;
}
/* Allocate and initialise device */
vmdev = zalloc ( sizeof ( *vmdev ) );
if ( ! vmdev ) {
rc = -ENOMEM;
goto err_alloc_vmdev;
}
memcpy ( &instance, &offer->instance,
sizeof ( instance ) );
uuid_mangle ( &instance );
snprintf ( vmdev->dev.name, sizeof ( vmdev->dev.name ),
"{%s}", uuid_ntoa ( &instance ) );
vmdev->dev.desc.bus_type = BUS_TYPE_HV;
INIT_LIST_HEAD ( &vmdev->dev.children );
list_add_tail ( &vmdev->dev.siblings,
&parent->children );
vmdev->dev.parent = parent;
vmdev->hv = hv;
memcpy ( &vmdev->instance, &offer->instance,
sizeof ( vmdev->instance ) );
vmdev->channel = channel;
vmdev->monitor = offer->monitor;
vmdev->signal = ( offer->monitored ?
vmbus_signal_monitor :
vmbus_signal_event );
INIT_LIST_HEAD ( &vmdev->pages );
vmdev->driver = driver;
vmdev->dev.driver_name = driver->name;
DBGC ( vmdev, "VMBUS %s has driver \"%s\"\n",
vmdev->dev.name, vmdev->driver->name );
} else if ( header->type ==
cpu_to_le32 ( VMBUS_ALL_OFFERS_DELIVERED ) ) {
/* End of offer list */
break;
} else {
DBGC ( vmbus, "VMBUS %p unexpected offer response type "
"%d\n", vmbus, le32_to_cpu ( header->type ) );
rc = -EPROTO;
goto err_unexpected_offer;
}
}
/* Probe all devices. We do this only after completing
* enumeration since devices will need to send and receive
* VMBus messages.
*/
list_for_each_entry ( vmdev, &parent->children, dev.siblings ) {
if ( ( rc = vmdev->driver->probe ( vmdev ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s could not probe: %s\n",
vmdev->dev.name, strerror ( rc ) );
goto err_probe;
}
}
return 0;
err_probe:
/* Remove driver from each device that was already probed */
list_for_each_entry_continue_reverse ( vmdev, &parent->children,
dev.siblings ) {
vmdev->driver->remove ( vmdev );
}
err_unexpected_offer:
err_alloc_vmdev:
err_wait_for_any_message:
/* Free any devices allocated (but potentially not yet probed) */
list_for_each_entry_safe ( vmdev, tmp, &parent->children,
dev.siblings ) {
list_del ( &vmdev->dev.siblings );
free ( vmdev );
}
err_post_message:
return rc;
}
/**
* Reset channels
*
* @v hv Hyper-V hypervisor
* @v parent Parent device
* @ret rc Return status code
*/
static int vmbus_reset_channels ( struct hv_hypervisor *hv,
struct device *parent ) {
struct vmbus *vmbus = hv->vmbus;
const struct vmbus_message_header *header = &vmbus->message->header;
const struct vmbus_offer_channel *offer = &vmbus->message->offer;
const union uuid *type;
struct vmbus_device *vmdev;
unsigned int channel;
int rc;
/* Post message */
if ( ( rc = vmbus_post_empty_message ( hv, VMBUS_REQUEST_OFFERS ) ) !=0)
return rc;
/* Collect responses */
while ( 1 ) {
/* Wait for response */
if ( ( rc = vmbus_wait_for_any_message ( hv ) ) != 0 )
return rc;
/* Handle response */
if ( header->type == cpu_to_le32 ( VMBUS_OFFER_CHANNEL ) ) {
/* Parse offer */
type = &offer->type;
channel = le32_to_cpu ( offer->channel );
DBGC2 ( vmbus, "VMBUS %p offer %d type %s",
vmbus, channel, uuid_ntoa ( type ) );
if ( offer->monitored )
DBGC2 ( vmbus, " monitor %d", offer->monitor );
DBGC2 ( vmbus, "\n" );
/* Do nothing with the offer; we already have all
* of the relevant state from the initial probe.
*/
} else if ( header->type ==
cpu_to_le32 ( VMBUS_ALL_OFFERS_DELIVERED ) ) {
/* End of offer list */
break;
} else {
DBGC ( vmbus, "VMBUS %p unexpected offer response type "
"%d\n", vmbus, le32_to_cpu ( header->type ) );
return -EPROTO;
}
}
/* Reset all devices */
list_for_each_entry ( vmdev, &parent->children, dev.siblings ) {
if ( ( rc = vmdev->driver->reset ( vmdev ) ) != 0 ) {
DBGC ( vmdev, "VMBUS %s could not reset: %s\n",
vmdev->dev.name, strerror ( rc ) );
/* Continue attempting to reset other devices */
continue;
}
}
return 0;
}
/**
* Remove channels
*
* @v hv Hyper-V hypervisor
* @v parent Parent device
*/
static void vmbus_remove_channels ( struct hv_hypervisor *hv __unused,
struct device *parent ) {
struct vmbus_device *vmdev;
struct vmbus_device *tmp;
/* Remove devices */
list_for_each_entry_safe ( vmdev, tmp, &parent->children,
dev.siblings ) {
vmdev->driver->remove ( vmdev );
assert ( list_empty ( &vmdev->dev.children ) );
assert ( vmdev->out == NULL );
assert ( vmdev->in == NULL );
assert ( vmdev->packet == NULL );
assert ( list_empty ( &vmdev->pages ) );
list_del ( &vmdev->dev.siblings );
free ( vmdev );
}
}
/**
* Probe Hyper-V virtual machine bus
*
* @v hv Hyper-V hypervisor
* @v parent Parent device
* @ret rc Return status code
*/
int vmbus_probe ( struct hv_hypervisor *hv, struct device *parent ) {
struct vmbus *vmbus;
int rc;
/* Allocate and initialise structure */
vmbus = zalloc ( sizeof ( *vmbus ) );
if ( ! vmbus ) {
rc = -ENOMEM;
goto err_alloc;
}
hv->vmbus = vmbus;
/* Initialise message buffer pointer
*
* We use a pointer to the fixed-size Hyper-V received message
* buffer. This allows us to access fields within received
* messages without first checking the message size: any
* fields beyond the end of the message will read as zero.
*/
vmbus->message = ( ( void * ) hv->message->received.data );
assert ( sizeof ( *vmbus->message ) <=
sizeof ( hv->message->received.data ) );
/* Allocate interrupt and monitor pages */
if ( ( rc = hv_alloc_pages ( hv, &vmbus->intr, &vmbus->monitor_in,
&vmbus->monitor_out, NULL ) ) != 0 )
goto err_alloc_pages;
/* Enable message interrupt */
hv_enable_sint ( hv, VMBUS_MESSAGE_SINT );
/* Negotiate protocol version */
if ( ( rc = vmbus_negotiate_version ( hv ) ) != 0 )
goto err_negotiate_version;
/* Enumerate channels */
if ( ( rc = vmbus_probe_channels ( hv, parent ) ) != 0 )
goto err_probe_channels;
return 0;
vmbus_remove_channels ( hv, parent );
err_probe_channels:
vmbus_unload ( hv );
err_negotiate_version:
hv_disable_sint ( hv, VMBUS_MESSAGE_SINT );
hv_free_pages ( hv, vmbus->intr, vmbus->monitor_in, vmbus->monitor_out,
NULL );
err_alloc_pages:
free ( vmbus );
err_alloc:
return rc;
}
/**
* Reset Hyper-V virtual machine bus
*
* @v hv Hyper-V hypervisor
* @v parent Parent device
* @ret rc Return status code
*/
int vmbus_reset ( struct hv_hypervisor *hv, struct device *parent ) {
struct vmbus *vmbus = hv->vmbus;
int rc;
/* Mark all existent GPADLs as obsolete */
vmbus_obsolete_gpadl = vmbus_gpadl;
/* Clear interrupt and monitor pages */
memset ( vmbus->intr, 0, PAGE_SIZE );
memset ( vmbus->monitor_in, 0, PAGE_SIZE );
memset ( vmbus->monitor_out, 0, PAGE_SIZE );
/* Enable message interrupt */
hv_enable_sint ( hv, VMBUS_MESSAGE_SINT );
/* Renegotiate protocol version */
if ( ( rc = vmbus_negotiate_version ( hv ) ) != 0 )
return rc;
/* Reenumerate channels */
if ( ( rc = vmbus_reset_channels ( hv, parent ) ) != 0 )
return rc;
return 0;
}
/**
* Remove Hyper-V virtual machine bus
*
* @v hv Hyper-V hypervisor
* @v parent Parent device
*/
void vmbus_remove ( struct hv_hypervisor *hv, struct device *parent ) {
struct vmbus *vmbus = hv->vmbus;
vmbus_remove_channels ( hv, parent );
vmbus_unload ( hv );
hv_disable_sint ( hv, VMBUS_MESSAGE_SINT );
hv_free_pages ( hv, vmbus->intr, vmbus->monitor_in, vmbus->monitor_out,
NULL );
free ( vmbus );
}
