/*- * Copyright (c) 2018 VMware, Inc. * * SPDX-License-Identifier: (BSD-2-Clause OR GPL-2.0) */ /* VMCI initialization. */ #include #include "vmci.h" #include "vmci_doorbell.h" #include "vmci_driver.h" #include "vmci_event.h" #include "vmci_kernel_api.h" #include "vmci_kernel_defs.h" #include "vmci_resource.h" #define LGPFX "vmci: " #define VMCI_UTIL_NUM_RESOURCES 1 static vmci_id ctx_update_sub_id = VMCI_INVALID_ID; static volatile int vm_context_id = VMCI_INVALID_ID; /* *------------------------------------------------------------------------------ * * vmci_util_cid_update -- * * Gets called with the new context id if updated or resumed. * * Results: * Context id. * * Side effects: * None. * *------------------------------------------------------------------------------ */ static void vmci_util_cid_update(vmci_id sub_id, struct vmci_event_data *event_data, void *client_data) { struct vmci_event_payload_context *ev_payload; ev_payload = vmci_event_data_payload(event_data); if (sub_id != ctx_update_sub_id) { VMCI_LOG_DEBUG(LGPFX"Invalid subscriber (ID=0x%x).\n", sub_id); return; } if (event_data == NULL || ev_payload->context_id == VMCI_INVALID_ID) { VMCI_LOG_DEBUG(LGPFX"Invalid event data.\n"); return; } VMCI_LOG_INFO(LGPFX"Updating context from (ID=0x%x) to (ID=0x%x) on " "event (type=%d).\n", atomic_load_int(&vm_context_id), ev_payload->context_id, event_data->event); atomic_store_int(&vm_context_id, ev_payload->context_id); } /* *------------------------------------------------------------------------------ * * vmci_util_init -- * * Subscribe to context id update event. * * Results: * None. * * Side effects: * None. * *------------------------------------------------------------------------------ */ void vmci_util_init(void) { /* * We subscribe to the VMCI_EVENT_CTX_ID_UPDATE here so we can update * the internal context id when needed. */ if (vmci_event_subscribe(VMCI_EVENT_CTX_ID_UPDATE, vmci_util_cid_update, NULL, &ctx_update_sub_id) < VMCI_SUCCESS) { VMCI_LOG_WARNING(LGPFX"Failed to subscribe to event " "(type=%d).\n", VMCI_EVENT_CTX_ID_UPDATE); } } /* *------------------------------------------------------------------------------ * * vmci_util_exit -- * * Cleanup * * Results: * None. * * Side effects: * None. * *------------------------------------------------------------------------------ */ void vmci_util_exit(void) { if (vmci_event_unsubscribe(ctx_update_sub_id) < VMCI_SUCCESS) VMCI_LOG_WARNING(LGPFX"Failed to unsubscribe to event " "(type=%d) with subscriber (ID=0x%x).\n", VMCI_EVENT_CTX_ID_UPDATE, ctx_update_sub_id); } /* *------------------------------------------------------------------------------ * * vmci_util_check_host_capabilities -- * * Verify that the host supports the hypercalls we need. If it does not, try * to find fallback hypercalls and use those instead. * * Results: * true if required hypercalls (or fallback hypercalls) are supported by the * host, false otherwise. * * Side effects: * None. * *------------------------------------------------------------------------------ */ static bool vmci_util_check_host_capabilities(void) { struct vmci_resources_query_msg *msg; struct vmci_datagram *check_msg; int result; uint32_t msg_size; msg_size = sizeof(struct vmci_resources_query_hdr) + VMCI_UTIL_NUM_RESOURCES * sizeof(vmci_resource); check_msg = vmci_alloc_kernel_mem(msg_size, VMCI_MEMORY_NORMAL); if (check_msg == NULL) { VMCI_LOG_WARNING(LGPFX"Check host: Insufficient memory.\n"); return (false); } check_msg->dst = VMCI_MAKE_HANDLE(VMCI_HYPERVISOR_CONTEXT_ID, VMCI_RESOURCES_QUERY); check_msg->src = VMCI_ANON_SRC_HANDLE; check_msg->payload_size = msg_size - VMCI_DG_HEADERSIZE; msg = (struct vmci_resources_query_msg *)VMCI_DG_PAYLOAD(check_msg); msg->num_resources = VMCI_UTIL_NUM_RESOURCES; msg->resources[0] = VMCI_GET_CONTEXT_ID; result = vmci_send_datagram(check_msg); vmci_free_kernel_mem(check_msg, msg_size); /* We need the vector. There are no fallbacks. */ return (result == 0x1); } /* *------------------------------------------------------------------------------ * * vmci_check_host_capabilities -- * * Tell host which guestcalls we support and let each API check that the * host supports the hypercalls it needs. If a hypercall is not supported, * the API can check for a fallback hypercall, or fail the check. * * Results: * true if successful, false otherwise. * * Side effects: * Fallback mechanisms may be enabled in the API and vmmon. * *------------------------------------------------------------------------------ */ bool vmci_check_host_capabilities(void) { bool result; result = vmci_event_check_host_capabilities(); result &= vmci_datagram_check_host_capabilities(); result &= vmci_util_check_host_capabilities(); if (!result) { /* * If it failed, then make sure this goes to the system event * log. */ VMCI_LOG_WARNING(LGPFX"Host capability checked failed.\n"); } else VMCI_LOG_DEBUG(LGPFX"Host capability check passed.\n"); return (result); } /* *------------------------------------------------------------------------------ * * vmci_read_datagrams_from_port -- * * Reads datagrams from the data in port and dispatches them. We always * start reading datagrams into only the first page of the datagram buffer. * If the datagrams don't fit into one page, we use the maximum datagram * buffer size for the remainder of the invocation. This is a simple * heuristic for not penalizing small datagrams. * * This function assumes that it has exclusive access to the data in port * for the duration of the call. * * Results: * No result. * * Side effects: * Datagram handlers may be invoked. * *------------------------------------------------------------------------------ */ void vmci_read_datagrams_from_port(vmci_io_handle io_handle, vmci_io_port dg_in_port, uint8_t *dg_in_buffer, size_t dg_in_buffer_size) { struct vmci_datagram *dg; size_t current_dg_in_buffer_size; size_t remaining_bytes; current_dg_in_buffer_size = PAGE_SIZE; ASSERT(dg_in_buffer_size >= PAGE_SIZE); vmci_read_port_bytes(io_handle, dg_in_port, dg_in_buffer, current_dg_in_buffer_size); dg = (struct vmci_datagram *)dg_in_buffer; remaining_bytes = current_dg_in_buffer_size; while (dg->dst.resource != VMCI_INVALID_ID || remaining_bytes > PAGE_SIZE) { size_t dg_in_size; /* * When the input buffer spans multiple pages, a datagram can * start on any page boundary in the buffer. */ if (dg->dst.resource == VMCI_INVALID_ID) { ASSERT(remaining_bytes > PAGE_SIZE); dg = (struct vmci_datagram *)ROUNDUP((uintptr_t)dg + 1, PAGE_SIZE); ASSERT((uint8_t *)dg < dg_in_buffer + current_dg_in_buffer_size); remaining_bytes = (size_t)(dg_in_buffer + current_dg_in_buffer_size - (uint8_t *)dg); continue; } dg_in_size = VMCI_DG_SIZE_ALIGNED(dg); if (dg_in_size <= dg_in_buffer_size) { int result; /* * If the remaining bytes in the datagram buffer doesn't * contain the complete datagram, we first make sure we * have enough room for it and then we read the reminder * of the datagram and possibly any following datagrams. */ if (dg_in_size > remaining_bytes) { if (remaining_bytes != current_dg_in_buffer_size) { /* * We move the partial datagram to the * front and read the reminder of the * datagram and possibly following calls * into the following bytes. */ memmove(dg_in_buffer, dg_in_buffer + current_dg_in_buffer_size - remaining_bytes, remaining_bytes); dg = (struct vmci_datagram *) dg_in_buffer; } if (current_dg_in_buffer_size != dg_in_buffer_size) current_dg_in_buffer_size = dg_in_buffer_size; vmci_read_port_bytes(io_handle, dg_in_port, dg_in_buffer + remaining_bytes, current_dg_in_buffer_size - remaining_bytes); } /* * We special case event datagrams from the * hypervisor. */ if (dg->src.context == VMCI_HYPERVISOR_CONTEXT_ID && dg->dst.resource == VMCI_EVENT_HANDLER) result = vmci_event_dispatch(dg); else result = vmci_datagram_invoke_guest_handler(dg); if (result < VMCI_SUCCESS) VMCI_LOG_DEBUG(LGPFX"Datagram with resource" " (ID=0x%x) failed (err=%d).\n", dg->dst.resource, result); /* On to the next datagram. */ dg = (struct vmci_datagram *)((uint8_t *)dg + dg_in_size); } else { size_t bytes_to_skip; /* * Datagram doesn't fit in datagram buffer of maximal * size. We drop it. */ VMCI_LOG_DEBUG(LGPFX"Failed to receive datagram " "(size=%zu bytes).\n", dg_in_size); bytes_to_skip = dg_in_size - remaining_bytes; if (current_dg_in_buffer_size != dg_in_buffer_size) current_dg_in_buffer_size = dg_in_buffer_size; for (;;) { vmci_read_port_bytes(io_handle, dg_in_port, dg_in_buffer, current_dg_in_buffer_size); if (bytes_to_skip <= current_dg_in_buffer_size) break; bytes_to_skip -= current_dg_in_buffer_size; } dg = (struct vmci_datagram *)(dg_in_buffer + bytes_to_skip); } remaining_bytes = (size_t) (dg_in_buffer + current_dg_in_buffer_size - (uint8_t *)dg); if (remaining_bytes < VMCI_DG_HEADERSIZE) { /* Get the next batch of datagrams. */ vmci_read_port_bytes(io_handle, dg_in_port, dg_in_buffer, current_dg_in_buffer_size); dg = (struct vmci_datagram *)dg_in_buffer; remaining_bytes = current_dg_in_buffer_size; } } } /* *------------------------------------------------------------------------------ * * vmci_get_context_id -- * * Returns the current context ID. Note that since this is accessed only * from code running in the host, this always returns the host context ID. * * Results: * Context ID. * * Side effects: * None. * *------------------------------------------------------------------------------ */ vmci_id vmci_get_context_id(void) { if (atomic_load_int(&vm_context_id) == VMCI_INVALID_ID) { uint32_t result; struct vmci_datagram get_cid_msg; get_cid_msg.dst = VMCI_MAKE_HANDLE(VMCI_HYPERVISOR_CONTEXT_ID, VMCI_GET_CONTEXT_ID); get_cid_msg.src = VMCI_ANON_SRC_HANDLE; get_cid_msg.payload_size = 0; result = vmci_send_datagram(&get_cid_msg); atomic_store_int(&vm_context_id, result); } return (atomic_load_int(&vm_context_id)); } /* *------------------------------------------------------------------------------ * * vmci_components_init -- * * Initializes VMCI components and registers core hypercalls. * * Results: * VMCI_SUCCESS if successful, appropriate error code otherwise. * * Side effects: * None. * *------------------------------------------------------------------------------ */ int vmci_components_init(void) { int result; result = vmci_resource_init(); if (result < VMCI_SUCCESS) { VMCI_LOG_WARNING(LGPFX"Failed to initialize vmci_resource " "(result=%d).\n", result); goto error_exit; } result = vmci_event_init(); if (result < VMCI_SUCCESS) { VMCI_LOG_WARNING(LGPFX"Failed to initialize vmci_event " "(result=%d).\n", result); goto resource_exit; } result = vmci_doorbell_init(); if (result < VMCI_SUCCESS) { VMCI_LOG_WARNING(LGPFX"Failed to initialize vmci_doorbell " "(result=%d).\n", result); goto event_exit; } VMCI_LOG_DEBUG(LGPFX"components initialized.\n"); return (VMCI_SUCCESS); event_exit: vmci_event_exit(); resource_exit: vmci_resource_exit(); error_exit: return (result); } /* *------------------------------------------------------------------------------ * * vmci_components_cleanup -- * * Cleans up VMCI components. * * Results: * None. * * Side effects: * None. * *------------------------------------------------------------------------------ */ void vmci_components_cleanup(void) { vmci_doorbell_exit(); vmci_event_exit(); vmci_resource_exit(); }