VMCI: datagram implementation.
VMCI datagram Implements datagrams to allow data to be sent between host and guest. Signed-off-by: George Zhang <georgezhang@vmware.com> Acked-by: Andy king <acking@vmware.com> Acked-by: Dmitry Torokhov <dtor@vmware.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
George Zhang
Greg Kroah-Hartman
parent
28d6692cd8
commit
a110b7ebb9
|
|
@ -0,0 +1,500 @@
|
|||
/*
|
||||
* VMware VMCI Driver
|
||||
*
|
||||
* Copyright (C) 2012 VMware, Inc. All rights reserved.
|
||||
*
|
||||
* 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 version 2 and no 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.
|
||||
*/
|
||||
|
||||
#include <linux/vmw_vmci_defs.h>
|
||||
#include <linux/vmw_vmci_api.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/bug.h>
|
||||
|
||||
#include "vmci_datagram.h"
|
||||
#include "vmci_resource.h"
|
||||
#include "vmci_context.h"
|
||||
#include "vmci_driver.h"
|
||||
#include "vmci_event.h"
|
||||
#include "vmci_route.h"
|
||||
|
||||
/*
|
||||
* struct datagram_entry describes the datagram entity. It is used for datagram
|
||||
* entities created only on the host.
|
||||
*/
|
||||
struct datagram_entry {
|
||||
struct vmci_resource resource;
|
||||
u32 flags;
|
||||
bool run_delayed;
|
||||
vmci_datagram_recv_cb recv_cb;
|
||||
void *client_data;
|
||||
u32 priv_flags;
|
||||
};
|
||||
|
||||
struct delayed_datagram_info {
|
||||
struct datagram_entry *entry;
|
||||
struct vmci_datagram msg;
|
||||
struct work_struct work;
|
||||
bool in_dg_host_queue;
|
||||
};
|
||||
|
||||
/* Number of in-flight host->host datagrams */
|
||||
static atomic_t delayed_dg_host_queue_size = ATOMIC_INIT(0);
|
||||
|
||||
/*
|
||||
* Create a datagram entry given a handle pointer.
|
||||
*/
|
||||
static int dg_create_handle(u32 resource_id,
|
||||
u32 flags,
|
||||
u32 priv_flags,
|
||||
vmci_datagram_recv_cb recv_cb,
|
||||
void *client_data, struct vmci_handle *out_handle)
|
||||
{
|
||||
int result;
|
||||
u32 context_id;
|
||||
struct vmci_handle handle;
|
||||
struct datagram_entry *entry;
|
||||
|
||||
if ((flags & VMCI_FLAG_WELLKNOWN_DG_HND) != 0)
|
||||
return VMCI_ERROR_INVALID_ARGS;
|
||||
|
||||
if ((flags & VMCI_FLAG_ANYCID_DG_HND) != 0) {
|
||||
context_id = VMCI_INVALID_ID;
|
||||
} else {
|
||||
context_id = vmci_get_context_id();
|
||||
if (context_id == VMCI_INVALID_ID)
|
||||
return VMCI_ERROR_NO_RESOURCES;
|
||||
}
|
||||
|
||||
handle = vmci_make_handle(context_id, resource_id);
|
||||
|
||||
entry = kmalloc(sizeof(*entry), GFP_KERNEL);
|
||||
if (!entry) {
|
||||
pr_warn("Failed allocating memory for datagram entry\n");
|
||||
return VMCI_ERROR_NO_MEM;
|
||||
}
|
||||
|
||||
entry->run_delayed = (flags & VMCI_FLAG_DG_DELAYED_CB) ? true : false;
|
||||
entry->flags = flags;
|
||||
entry->recv_cb = recv_cb;
|
||||
entry->client_data = client_data;
|
||||
entry->priv_flags = priv_flags;
|
||||
|
||||
/* Make datagram resource live. */
|
||||
result = vmci_resource_add(&entry->resource,
|
||||
VMCI_RESOURCE_TYPE_DATAGRAM,
|
||||
handle);
|
||||
if (result != VMCI_SUCCESS) {
|
||||
pr_warn("Failed to add new resource (handle=0x%x:0x%x), error: %d\n",
|
||||
handle.context, handle.resource, result);
|
||||
kfree(entry);
|
||||
return result;
|
||||
}
|
||||
|
||||
*out_handle = vmci_resource_handle(&entry->resource);
|
||||
return VMCI_SUCCESS;
|
||||
}
|
||||
|
||||
/*
|
||||
* Internal utility function with the same purpose as
|
||||
* vmci_datagram_get_priv_flags that also takes a context_id.
|
||||
*/
|
||||
static int vmci_datagram_get_priv_flags(u32 context_id,
|
||||
struct vmci_handle handle,
|
||||
u32 *priv_flags)
|
||||
{
|
||||
if (context_id == VMCI_INVALID_ID)
|
||||
return VMCI_ERROR_INVALID_ARGS;
|
||||
|
||||
if (context_id == VMCI_HOST_CONTEXT_ID) {
|
||||
struct datagram_entry *src_entry;
|
||||
struct vmci_resource *resource;
|
||||
|
||||
resource = vmci_resource_by_handle(handle,
|
||||
VMCI_RESOURCE_TYPE_DATAGRAM);
|
||||
if (!resource)
|
||||
return VMCI_ERROR_INVALID_ARGS;
|
||||
|
||||
src_entry = container_of(resource, struct datagram_entry,
|
||||
resource);
|
||||
*priv_flags = src_entry->priv_flags;
|
||||
vmci_resource_put(resource);
|
||||
} else if (context_id == VMCI_HYPERVISOR_CONTEXT_ID)
|
||||
*priv_flags = VMCI_MAX_PRIVILEGE_FLAGS;
|
||||
else
|
||||
*priv_flags = vmci_context_get_priv_flags(context_id);
|
||||
|
||||
return VMCI_SUCCESS;
|
||||
}
|
||||
|
||||
/*
|
||||
* Calls the specified callback in a delayed context.
|
||||
*/
|
||||
static void dg_delayed_dispatch(struct work_struct *work)
|
||||
{
|
||||
struct delayed_datagram_info *dg_info =
|
||||
container_of(work, struct delayed_datagram_info, work);
|
||||
|
||||
dg_info->entry->recv_cb(dg_info->entry->client_data, &dg_info->msg);
|
||||
|
||||
vmci_resource_put(&dg_info->entry->resource);
|
||||
|
||||
if (dg_info->in_dg_host_queue)
|
||||
atomic_dec(&delayed_dg_host_queue_size);
|
||||
|
||||
kfree(dg_info);
|
||||
}
|
||||
|
||||
/*
|
||||
* Dispatch datagram as a host, to the host, or other vm context. This
|
||||
* function cannot dispatch to hypervisor context handlers. This should
|
||||
* have been handled before we get here by vmci_datagram_dispatch.
|
||||
* Returns number of bytes sent on success, error code otherwise.
|
||||
*/
|
||||
static int dg_dispatch_as_host(u32 context_id, struct vmci_datagram *dg)
|
||||
{
|
||||
int retval;
|
||||
size_t dg_size;
|
||||
u32 src_priv_flags;
|
||||
|
||||
dg_size = VMCI_DG_SIZE(dg);
|
||||
|
||||
/* Host cannot send to the hypervisor. */
|
||||
if (dg->dst.context == VMCI_HYPERVISOR_CONTEXT_ID)
|
||||
return VMCI_ERROR_DST_UNREACHABLE;
|
||||
|
||||
/* Check that source handle matches sending context. */
|
||||
if (dg->src.context != context_id) {
|
||||
pr_devel("Sender context (ID=0x%x) is not owner of src datagram entry (handle=0x%x:0x%x)\n",
|
||||
context_id, dg->src.context, dg->src.resource);
|
||||
return VMCI_ERROR_NO_ACCESS;
|
||||
}
|
||||
|
||||
/* Get hold of privileges of sending endpoint. */
|
||||
retval = vmci_datagram_get_priv_flags(context_id, dg->src,
|
||||
&src_priv_flags);
|
||||
if (retval != VMCI_SUCCESS) {
|
||||
pr_warn("Couldn't get privileges (handle=0x%x:0x%x)\n",
|
||||
dg->src.context, dg->src.resource);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* Determine if we should route to host or guest destination. */
|
||||
if (dg->dst.context == VMCI_HOST_CONTEXT_ID) {
|
||||
/* Route to host datagram entry. */
|
||||
struct datagram_entry *dst_entry;
|
||||
struct vmci_resource *resource;
|
||||
|
||||
if (dg->src.context == VMCI_HYPERVISOR_CONTEXT_ID &&
|
||||
dg->dst.resource == VMCI_EVENT_HANDLER) {
|
||||
return vmci_event_dispatch(dg);
|
||||
}
|
||||
|
||||
resource = vmci_resource_by_handle(dg->dst,
|
||||
VMCI_RESOURCE_TYPE_DATAGRAM);
|
||||
if (!resource) {
|
||||
pr_devel("Sending to invalid destination (handle=0x%x:0x%x)\n",
|
||||
dg->dst.context, dg->dst.resource);
|
||||
return VMCI_ERROR_INVALID_RESOURCE;
|
||||
}
|
||||
dst_entry = container_of(resource, struct datagram_entry,
|
||||
resource);
|
||||
if (vmci_deny_interaction(src_priv_flags,
|
||||
dst_entry->priv_flags)) {
|
||||
vmci_resource_put(resource);
|
||||
return VMCI_ERROR_NO_ACCESS;
|
||||
}
|
||||
|
||||
/*
|
||||
* If a VMCI datagram destined for the host is also sent by the
|
||||
* host, we always run it delayed. This ensures that no locks
|
||||
* are held when the datagram callback runs.
|
||||
*/
|
||||
if (dst_entry->run_delayed ||
|
||||
dg->src.context == VMCI_HOST_CONTEXT_ID) {
|
||||
struct delayed_datagram_info *dg_info;
|
||||
|
||||
if (atomic_add_return(1, &delayed_dg_host_queue_size)
|
||||
== VMCI_MAX_DELAYED_DG_HOST_QUEUE_SIZE) {
|
||||
atomic_dec(&delayed_dg_host_queue_size);
|
||||
vmci_resource_put(resource);
|
||||
return VMCI_ERROR_NO_MEM;
|
||||
}
|
||||
|
||||
dg_info = kmalloc(sizeof(*dg_info) +
|
||||
(size_t) dg->payload_size, GFP_ATOMIC);
|
||||
if (!dg_info) {
|
||||
atomic_dec(&delayed_dg_host_queue_size);
|
||||
vmci_resource_put(resource);
|
||||
return VMCI_ERROR_NO_MEM;
|
||||
}
|
||||
|
||||
dg_info->in_dg_host_queue = true;
|
||||
dg_info->entry = dst_entry;
|
||||
memcpy(&dg_info->msg, dg, dg_size);
|
||||
|
||||
INIT_WORK(&dg_info->work, dg_delayed_dispatch);
|
||||
schedule_work(&dg_info->work);
|
||||
retval = VMCI_SUCCESS;
|
||||
|
||||
} else {
|
||||
retval = dst_entry->recv_cb(dst_entry->client_data, dg);
|
||||
vmci_resource_put(resource);
|
||||
if (retval < VMCI_SUCCESS)
|
||||
return retval;
|
||||
}
|
||||
} else {
|
||||
/* Route to destination VM context. */
|
||||
struct vmci_datagram *new_dg;
|
||||
|
||||
if (context_id != dg->dst.context) {
|
||||
if (vmci_deny_interaction(src_priv_flags,
|
||||
vmci_context_get_priv_flags
|
||||
(dg->dst.context))) {
|
||||
return VMCI_ERROR_NO_ACCESS;
|
||||
} else if (VMCI_CONTEXT_IS_VM(context_id)) {
|
||||
/*
|
||||
* If the sending context is a VM, it
|
||||
* cannot reach another VM.
|
||||
*/
|
||||
|
||||
pr_devel("Datagram communication between VMs not supported (src=0x%x, dst=0x%x)\n",
|
||||
context_id, dg->dst.context);
|
||||
return VMCI_ERROR_DST_UNREACHABLE;
|
||||
}
|
||||
}
|
||||
|
||||
/* We make a copy to enqueue. */
|
||||
new_dg = kmalloc(dg_size, GFP_KERNEL);
|
||||
if (new_dg == NULL)
|
||||
return VMCI_ERROR_NO_MEM;
|
||||
|
||||
memcpy(new_dg, dg, dg_size);
|
||||
retval = vmci_ctx_enqueue_datagram(dg->dst.context, new_dg);
|
||||
if (retval < VMCI_SUCCESS) {
|
||||
kfree(new_dg);
|
||||
return retval;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* We currently truncate the size to signed 32 bits. This doesn't
|
||||
* matter for this handler as it only support 4Kb messages.
|
||||
*/
|
||||
return (int)dg_size;
|
||||
}
|
||||
|
||||
/*
|
||||
* Dispatch datagram as a guest, down through the VMX and potentially to
|
||||
* the host.
|
||||
* Returns number of bytes sent on success, error code otherwise.
|
||||
*/
|
||||
static int dg_dispatch_as_guest(struct vmci_datagram *dg)
|
||||
{
|
||||
int retval;
|
||||
struct vmci_resource *resource;
|
||||
|
||||
resource = vmci_resource_by_handle(dg->src,
|
||||
VMCI_RESOURCE_TYPE_DATAGRAM);
|
||||
if (!resource)
|
||||
return VMCI_ERROR_NO_HANDLE;
|
||||
|
||||
retval = vmci_send_datagram(dg);
|
||||
vmci_resource_put(resource);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* Dispatch datagram. This will determine the routing for the datagram
|
||||
* and dispatch it accordingly.
|
||||
* Returns number of bytes sent on success, error code otherwise.
|
||||
*/
|
||||
int vmci_datagram_dispatch(u32 context_id,
|
||||
struct vmci_datagram *dg, bool from_guest)
|
||||
{
|
||||
int retval;
|
||||
enum vmci_route route;
|
||||
|
||||
BUILD_BUG_ON(sizeof(struct vmci_datagram) != 24);
|
||||
|
||||
if (VMCI_DG_SIZE(dg) > VMCI_MAX_DG_SIZE) {
|
||||
pr_devel("Payload (size=%llu bytes) too big to send\n",
|
||||
(unsigned long long)dg->payload_size);
|
||||
return VMCI_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
retval = vmci_route(&dg->src, &dg->dst, from_guest, &route);
|
||||
if (retval < VMCI_SUCCESS) {
|
||||
pr_devel("Failed to route datagram (src=0x%x, dst=0x%x, err=%d)\n",
|
||||
dg->src.context, dg->dst.context, retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
if (VMCI_ROUTE_AS_HOST == route) {
|
||||
if (VMCI_INVALID_ID == context_id)
|
||||
context_id = VMCI_HOST_CONTEXT_ID;
|
||||
return dg_dispatch_as_host(context_id, dg);
|
||||
}
|
||||
|
||||
if (VMCI_ROUTE_AS_GUEST == route)
|
||||
return dg_dispatch_as_guest(dg);
|
||||
|
||||
pr_warn("Unknown route (%d) for datagram\n", route);
|
||||
return VMCI_ERROR_DST_UNREACHABLE;
|
||||
}
|
||||
|
||||
/*
|
||||
* Invoke the handler for the given datagram. This is intended to be
|
||||
* called only when acting as a guest and receiving a datagram from the
|
||||
* virtual device.
|
||||
*/
|
||||
int vmci_datagram_invoke_guest_handler(struct vmci_datagram *dg)
|
||||
{
|
||||
struct vmci_resource *resource;
|
||||
struct datagram_entry *dst_entry;
|
||||
|
||||
resource = vmci_resource_by_handle(dg->dst,
|
||||
VMCI_RESOURCE_TYPE_DATAGRAM);
|
||||
if (!resource) {
|
||||
pr_devel("destination (handle=0x%x:0x%x) doesn't exist\n",
|
||||
dg->dst.context, dg->dst.resource);
|
||||
return VMCI_ERROR_NO_HANDLE;
|
||||
}
|
||||
|
||||
dst_entry = container_of(resource, struct datagram_entry, resource);
|
||||
if (dst_entry->run_delayed) {
|
||||
struct delayed_datagram_info *dg_info;
|
||||
|
||||
dg_info = kmalloc(sizeof(*dg_info) + (size_t)dg->payload_size,
|
||||
GFP_ATOMIC);
|
||||
if (!dg_info) {
|
||||
vmci_resource_put(resource);
|
||||
return VMCI_ERROR_NO_MEM;
|
||||
}
|
||||
|
||||
dg_info->in_dg_host_queue = false;
|
||||
dg_info->entry = dst_entry;
|
||||
memcpy(&dg_info->msg, dg, VMCI_DG_SIZE(dg));
|
||||
|
||||
INIT_WORK(&dg_info->work, dg_delayed_dispatch);
|
||||
schedule_work(&dg_info->work);
|
||||
} else {
|
||||
dst_entry->recv_cb(dst_entry->client_data, dg);
|
||||
vmci_resource_put(resource);
|
||||
}
|
||||
|
||||
return VMCI_SUCCESS;
|
||||
}
|
||||
|
||||
/*
|
||||
* vmci_datagram_create_handle_priv() - Create host context datagram endpoint
|
||||
* @resource_id: The resource ID.
|
||||
* @flags: Datagram Flags.
|
||||
* @priv_flags: Privilege Flags.
|
||||
* @recv_cb: Callback when receiving datagrams.
|
||||
* @client_data: Pointer for a datagram_entry struct
|
||||
* @out_handle: vmci_handle that is populated as a result of this function.
|
||||
*
|
||||
* Creates a host context datagram endpoint and returns a handle to it.
|
||||
*/
|
||||
int vmci_datagram_create_handle_priv(u32 resource_id,
|
||||
u32 flags,
|
||||
u32 priv_flags,
|
||||
vmci_datagram_recv_cb recv_cb,
|
||||
void *client_data,
|
||||
struct vmci_handle *out_handle)
|
||||
{
|
||||
if (out_handle == NULL)
|
||||
return VMCI_ERROR_INVALID_ARGS;
|
||||
|
||||
if (recv_cb == NULL) {
|
||||
pr_devel("Client callback needed when creating datagram\n");
|
||||
return VMCI_ERROR_INVALID_ARGS;
|
||||
}
|
||||
|
||||
if (priv_flags & ~VMCI_PRIVILEGE_ALL_FLAGS)
|
||||
return VMCI_ERROR_INVALID_ARGS;
|
||||
|
||||
return dg_create_handle(resource_id, flags, priv_flags, recv_cb,
|
||||
client_data, out_handle);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(vmci_datagram_create_handle_priv);
|
||||
|
||||
/*
|
||||
* vmci_datagram_create_handle() - Create host context datagram endpoint
|
||||
* @resource_id: Resource ID.
|
||||
* @flags: Datagram Flags.
|
||||
* @recv_cb: Callback when receiving datagrams.
|
||||
* @client_ata: Pointer for a datagram_entry struct
|
||||
* @out_handle: vmci_handle that is populated as a result of this function.
|
||||
*
|
||||
* Creates a host context datagram endpoint and returns a handle to
|
||||
* it. Same as vmci_datagram_create_handle_priv without the priviledge
|
||||
* flags argument.
|
||||
*/
|
||||
int vmci_datagram_create_handle(u32 resource_id,
|
||||
u32 flags,
|
||||
vmci_datagram_recv_cb recv_cb,
|
||||
void *client_data,
|
||||
struct vmci_handle *out_handle)
|
||||
{
|
||||
return vmci_datagram_create_handle_priv(
|
||||
resource_id, flags,
|
||||
VMCI_DEFAULT_PROC_PRIVILEGE_FLAGS,
|
||||
recv_cb, client_data,
|
||||
out_handle);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(vmci_datagram_create_handle);
|
||||
|
||||
/*
|
||||
* vmci_datagram_destroy_handle() - Destroys datagram handle
|
||||
* @handle: vmci_handle to be destroyed and reaped.
|
||||
*
|
||||
* Use this function to destroy any datagram handles created by
|
||||
* vmci_datagram_create_handle{,Priv} functions.
|
||||
*/
|
||||
int vmci_datagram_destroy_handle(struct vmci_handle handle)
|
||||
{
|
||||
struct datagram_entry *entry;
|
||||
struct vmci_resource *resource;
|
||||
|
||||
resource = vmci_resource_by_handle(handle, VMCI_RESOURCE_TYPE_DATAGRAM);
|
||||
if (!resource) {
|
||||
pr_devel("Failed to destroy datagram (handle=0x%x:0x%x)\n",
|
||||
handle.context, handle.resource);
|
||||
return VMCI_ERROR_NOT_FOUND;
|
||||
}
|
||||
|
||||
entry = container_of(resource, struct datagram_entry, resource);
|
||||
|
||||
vmci_resource_put(&entry->resource);
|
||||
vmci_resource_remove(&entry->resource);
|
||||
kfree(entry);
|
||||
|
||||
return VMCI_SUCCESS;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(vmci_datagram_destroy_handle);
|
||||
|
||||
/*
|
||||
* vmci_datagram_send() - Send a datagram
|
||||
* @msg: The datagram to send.
|
||||
*
|
||||
* Sends the provided datagram on its merry way.
|
||||
*/
|
||||
int vmci_datagram_send(struct vmci_datagram *msg)
|
||||
{
|
||||
if (msg == NULL)
|
||||
return VMCI_ERROR_INVALID_ARGS;
|
||||
|
||||
return vmci_datagram_dispatch(VMCI_INVALID_ID, msg, false);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(vmci_datagram_send);
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
/*
|
||||
* VMware VMCI Driver
|
||||
*
|
||||
* Copyright (C) 2012 VMware, Inc. All rights reserved.
|
||||
*
|
||||
* 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 version 2 and no 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.
|
||||
*/
|
||||
|
||||
#ifndef _VMCI_DATAGRAM_H_
|
||||
#define _VMCI_DATAGRAM_H_
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/list.h>
|
||||
|
||||
#include "vmci_context.h"
|
||||
|
||||
#define VMCI_MAX_DELAYED_DG_HOST_QUEUE_SIZE 256
|
||||
|
||||
/*
|
||||
* The struct vmci_datagram_queue_entry is a queue header for the in-kernel VMCI
|
||||
* datagram queues. It is allocated in non-paged memory, as the
|
||||
* content is accessed while holding a spinlock. The pending datagram
|
||||
* itself may be allocated from paged memory. We shadow the size of
|
||||
* the datagram in the non-paged queue entry as this size is used
|
||||
* while holding the same spinlock as above.
|
||||
*/
|
||||
struct vmci_datagram_queue_entry {
|
||||
struct list_head list_item; /* For queuing. */
|
||||
size_t dg_size; /* Size of datagram. */
|
||||
struct vmci_datagram *dg; /* Pending datagram. */
|
||||
};
|
||||
|
||||
/* VMCIDatagramSendRecvInfo */
|
||||
struct vmci_datagram_snd_rcv_info {
|
||||
u64 addr;
|
||||
u32 len;
|
||||
s32 result;
|
||||
};
|
||||
|
||||
/* Datagram API for non-public use. */
|
||||
int vmci_datagram_dispatch(u32 context_id, struct vmci_datagram *dg,
|
||||
bool from_guest);
|
||||
int vmci_datagram_invoke_guest_handler(struct vmci_datagram *dg);
|
||||
|
||||
#endif /* _VMCI_DATAGRAM_H_ */
|
||||
Loading…
Reference in New Issue