| /* |
| * Hyper-V guest/hypervisor interaction |
| * |
| * Copyright (c) 2015-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/main-loop.h" |
| #include "qemu/module.h" |
| #include "qapi/error.h" |
| #include "exec/address-spaces.h" |
| #include "sysemu/kvm.h" |
| #include "qemu/bitops.h" |
| #include "qemu/error-report.h" |
| #include "qemu/lockable.h" |
| #include "qemu/queue.h" |
| #include "qemu/rcu.h" |
| #include "qemu/rcu_queue.h" |
| #include "hw/hyperv/hyperv.h" |
| #include "qom/object.h" |
| |
| struct SynICState { |
| DeviceState parent_obj; |
| |
| CPUState *cs; |
| |
| bool sctl_enabled; |
| hwaddr msg_page_addr; |
| hwaddr event_page_addr; |
| MemoryRegion msg_page_mr; |
| MemoryRegion event_page_mr; |
| struct hyperv_message_page *msg_page; |
| struct hyperv_event_flags_page *event_page; |
| |
| QemuMutex sint_routes_mutex; |
| QLIST_HEAD(, HvSintRoute) sint_routes; |
| }; |
| |
| #define TYPE_SYNIC "hyperv-synic" |
| OBJECT_DECLARE_SIMPLE_TYPE(SynICState, SYNIC) |
| |
| static bool synic_enabled; |
| |
| bool hyperv_is_synic_enabled(void) |
| { |
| return synic_enabled; |
| } |
| |
| static SynICState *get_synic(CPUState *cs) |
| { |
| return SYNIC(object_resolve_path_component(OBJECT(cs), "synic")); |
| } |
| |
| static void synic_update(SynICState *synic, bool sctl_enable, |
| hwaddr msg_page_addr, hwaddr event_page_addr) |
| { |
| |
| synic->sctl_enabled = sctl_enable; |
| if (synic->msg_page_addr != msg_page_addr) { |
| if (synic->msg_page_addr) { |
| memory_region_del_subregion(get_system_memory(), |
| &synic->msg_page_mr); |
| } |
| if (msg_page_addr) { |
| memory_region_add_subregion(get_system_memory(), msg_page_addr, |
| &synic->msg_page_mr); |
| } |
| synic->msg_page_addr = msg_page_addr; |
| } |
| if (synic->event_page_addr != event_page_addr) { |
| if (synic->event_page_addr) { |
| memory_region_del_subregion(get_system_memory(), |
| &synic->event_page_mr); |
| } |
| if (event_page_addr) { |
| memory_region_add_subregion(get_system_memory(), event_page_addr, |
| &synic->event_page_mr); |
| } |
| synic->event_page_addr = event_page_addr; |
| } |
| } |
| |
| void hyperv_synic_update(CPUState *cs, bool sctl_enable, |
| hwaddr msg_page_addr, hwaddr event_page_addr) |
| { |
| SynICState *synic = get_synic(cs); |
| |
| if (!synic) { |
| return; |
| } |
| |
| synic_update(synic, sctl_enable, msg_page_addr, event_page_addr); |
| } |
| |
| static void synic_realize(DeviceState *dev, Error **errp) |
| { |
| Object *obj = OBJECT(dev); |
| SynICState *synic = SYNIC(dev); |
| char *msgp_name, *eventp_name; |
| uint32_t vp_index; |
| |
| /* memory region names have to be globally unique */ |
| vp_index = hyperv_vp_index(synic->cs); |
| msgp_name = g_strdup_printf("synic-%u-msg-page", vp_index); |
| eventp_name = g_strdup_printf("synic-%u-event-page", vp_index); |
| |
| memory_region_init_ram(&synic->msg_page_mr, obj, msgp_name, |
| sizeof(*synic->msg_page), &error_abort); |
| memory_region_init_ram(&synic->event_page_mr, obj, eventp_name, |
| sizeof(*synic->event_page), &error_abort); |
| synic->msg_page = memory_region_get_ram_ptr(&synic->msg_page_mr); |
| synic->event_page = memory_region_get_ram_ptr(&synic->event_page_mr); |
| qemu_mutex_init(&synic->sint_routes_mutex); |
| QLIST_INIT(&synic->sint_routes); |
| |
| g_free(msgp_name); |
| g_free(eventp_name); |
| } |
| |
| static void synic_reset(DeviceState *dev) |
| { |
| SynICState *synic = SYNIC(dev); |
| memset(synic->msg_page, 0, sizeof(*synic->msg_page)); |
| memset(synic->event_page, 0, sizeof(*synic->event_page)); |
| synic_update(synic, false, 0, 0); |
| assert(QLIST_EMPTY(&synic->sint_routes)); |
| } |
| |
| static void synic_class_init(ObjectClass *klass, void *data) |
| { |
| DeviceClass *dc = DEVICE_CLASS(klass); |
| |
| dc->realize = synic_realize; |
| dc->reset = synic_reset; |
| dc->user_creatable = false; |
| } |
| |
| void hyperv_synic_add(CPUState *cs) |
| { |
| Object *obj; |
| SynICState *synic; |
| |
| obj = object_new(TYPE_SYNIC); |
| synic = SYNIC(obj); |
| synic->cs = cs; |
| object_property_add_child(OBJECT(cs), "synic", obj); |
| object_unref(obj); |
| qdev_realize(DEVICE(obj), NULL, &error_abort); |
| synic_enabled = true; |
| } |
| |
| void hyperv_synic_reset(CPUState *cs) |
| { |
| SynICState *synic = get_synic(cs); |
| |
| if (synic) { |
| device_legacy_reset(DEVICE(synic)); |
| } |
| } |
| |
| static const TypeInfo synic_type_info = { |
| .name = TYPE_SYNIC, |
| .parent = TYPE_DEVICE, |
| .instance_size = sizeof(SynICState), |
| .class_init = synic_class_init, |
| }; |
| |
| static void synic_register_types(void) |
| { |
| type_register_static(&synic_type_info); |
| } |
| |
| type_init(synic_register_types) |
| |
| /* |
| * KVM has its own message producers (SynIC timers). To guarantee |
| * serialization with both KVM vcpu and the guest cpu, the messages are first |
| * staged in an intermediate area and then posted to the SynIC message page in |
| * the vcpu thread. |
| */ |
| typedef struct HvSintStagedMessage { |
| /* message content staged by hyperv_post_msg */ |
| struct hyperv_message msg; |
| /* callback + data (r/o) to complete the processing in a BH */ |
| HvSintMsgCb cb; |
| void *cb_data; |
| /* message posting status filled by cpu_post_msg */ |
| int status; |
| /* passing the buck: */ |
| enum { |
| /* initial state */ |
| HV_STAGED_MSG_FREE, |
| /* |
| * hyperv_post_msg (e.g. in main loop) grabs the staged area (FREE -> |
| * BUSY), copies msg, and schedules cpu_post_msg on the assigned cpu |
| */ |
| HV_STAGED_MSG_BUSY, |
| /* |
| * cpu_post_msg (vcpu thread) tries to copy staged msg to msg slot, |
| * notify the guest, records the status, marks the posting done (BUSY |
| * -> POSTED), and schedules sint_msg_bh BH |
| */ |
| HV_STAGED_MSG_POSTED, |
| /* |
| * sint_msg_bh (BH) verifies that the posting is done, runs the |
| * callback, and starts over (POSTED -> FREE) |
| */ |
| } state; |
| } HvSintStagedMessage; |
| |
| struct HvSintRoute { |
| uint32_t sint; |
| SynICState *synic; |
| int gsi; |
| EventNotifier sint_set_notifier; |
| EventNotifier sint_ack_notifier; |
| |
| HvSintStagedMessage *staged_msg; |
| |
| unsigned refcount; |
| QLIST_ENTRY(HvSintRoute) link; |
| }; |
| |
| static CPUState *hyperv_find_vcpu(uint32_t vp_index) |
| { |
| CPUState *cs = qemu_get_cpu(vp_index); |
| assert(hyperv_vp_index(cs) == vp_index); |
| return cs; |
| } |
| |
| /* |
| * BH to complete the processing of a staged message. |
| */ |
| static void sint_msg_bh(void *opaque) |
| { |
| HvSintRoute *sint_route = opaque; |
| HvSintStagedMessage *staged_msg = sint_route->staged_msg; |
| |
| if (qatomic_read(&staged_msg->state) != HV_STAGED_MSG_POSTED) { |
| /* status nor ready yet (spurious ack from guest?), ignore */ |
| return; |
| } |
| |
| staged_msg->cb(staged_msg->cb_data, staged_msg->status); |
| staged_msg->status = 0; |
| |
| /* staged message processing finished, ready to start over */ |
| qatomic_set(&staged_msg->state, HV_STAGED_MSG_FREE); |
| /* drop the reference taken in hyperv_post_msg */ |
| hyperv_sint_route_unref(sint_route); |
| } |
| |
| /* |
| * Worker to transfer the message from the staging area into the SynIC message |
| * page in vcpu context. |
| */ |
| static void cpu_post_msg(CPUState *cs, run_on_cpu_data data) |
| { |
| HvSintRoute *sint_route = data.host_ptr; |
| HvSintStagedMessage *staged_msg = sint_route->staged_msg; |
| SynICState *synic = sint_route->synic; |
| struct hyperv_message *dst_msg; |
| bool wait_for_sint_ack = false; |
| |
| assert(staged_msg->state == HV_STAGED_MSG_BUSY); |
| |
| if (!synic->msg_page_addr) { |
| staged_msg->status = -ENXIO; |
| goto posted; |
| } |
| |
| dst_msg = &synic->msg_page->slot[sint_route->sint]; |
| |
| if (dst_msg->header.message_type != HV_MESSAGE_NONE) { |
| dst_msg->header.message_flags |= HV_MESSAGE_FLAG_PENDING; |
| staged_msg->status = -EAGAIN; |
| wait_for_sint_ack = true; |
| } else { |
| memcpy(dst_msg, &staged_msg->msg, sizeof(*dst_msg)); |
| staged_msg->status = hyperv_sint_route_set_sint(sint_route); |
| } |
| |
| memory_region_set_dirty(&synic->msg_page_mr, 0, sizeof(*synic->msg_page)); |
| |
| posted: |
| qatomic_set(&staged_msg->state, HV_STAGED_MSG_POSTED); |
| /* |
| * Notify the msg originator of the progress made; if the slot was busy we |
| * set msg_pending flag in it so it will be the guest who will do EOM and |
| * trigger the notification from KVM via sint_ack_notifier |
| */ |
| if (!wait_for_sint_ack) { |
| aio_bh_schedule_oneshot(qemu_get_aio_context(), sint_msg_bh, |
| sint_route); |
| } |
| } |
| |
| /* |
| * Post a Hyper-V message to the staging area, for delivery to guest in the |
| * vcpu thread. |
| */ |
| int hyperv_post_msg(HvSintRoute *sint_route, struct hyperv_message *src_msg) |
| { |
| HvSintStagedMessage *staged_msg = sint_route->staged_msg; |
| |
| assert(staged_msg); |
| |
| /* grab the staging area */ |
| if (qatomic_cmpxchg(&staged_msg->state, HV_STAGED_MSG_FREE, |
| HV_STAGED_MSG_BUSY) != HV_STAGED_MSG_FREE) { |
| return -EAGAIN; |
| } |
| |
| memcpy(&staged_msg->msg, src_msg, sizeof(*src_msg)); |
| |
| /* hold a reference on sint_route until the callback is finished */ |
| hyperv_sint_route_ref(sint_route); |
| |
| /* schedule message posting attempt in vcpu thread */ |
| async_run_on_cpu(sint_route->synic->cs, cpu_post_msg, |
| RUN_ON_CPU_HOST_PTR(sint_route)); |
| return 0; |
| } |
| |
| static void sint_ack_handler(EventNotifier *notifier) |
| { |
| HvSintRoute *sint_route = container_of(notifier, HvSintRoute, |
| sint_ack_notifier); |
| event_notifier_test_and_clear(notifier); |
| |
| /* |
| * the guest consumed the previous message so complete the current one with |
| * -EAGAIN and let the msg originator retry |
| */ |
| aio_bh_schedule_oneshot(qemu_get_aio_context(), sint_msg_bh, sint_route); |
| } |
| |
| /* |
| * Set given event flag for a given sint on a given vcpu, and signal the sint. |
| */ |
| int hyperv_set_event_flag(HvSintRoute *sint_route, unsigned eventno) |
| { |
| int ret; |
| SynICState *synic = sint_route->synic; |
| unsigned long *flags, set_mask; |
| unsigned set_idx; |
| |
| if (eventno > HV_EVENT_FLAGS_COUNT) { |
| return -EINVAL; |
| } |
| if (!synic->sctl_enabled || !synic->event_page_addr) { |
| return -ENXIO; |
| } |
| |
| set_idx = BIT_WORD(eventno); |
| set_mask = BIT_MASK(eventno); |
| flags = synic->event_page->slot[sint_route->sint].flags; |
| |
| if ((qatomic_fetch_or(&flags[set_idx], set_mask) & set_mask) != set_mask) { |
| memory_region_set_dirty(&synic->event_page_mr, 0, |
| sizeof(*synic->event_page)); |
| ret = hyperv_sint_route_set_sint(sint_route); |
| } else { |
| ret = 0; |
| } |
| return ret; |
| } |
| |
| HvSintRoute *hyperv_sint_route_new(uint32_t vp_index, uint32_t sint, |
| HvSintMsgCb cb, void *cb_data) |
| { |
| HvSintRoute *sint_route = NULL; |
| EventNotifier *ack_notifier = NULL; |
| int r, gsi; |
| CPUState *cs; |
| SynICState *synic; |
| bool ack_event_initialized = false; |
| |
| cs = hyperv_find_vcpu(vp_index); |
| if (!cs) { |
| return NULL; |
| } |
| |
| synic = get_synic(cs); |
| if (!synic) { |
| return NULL; |
| } |
| |
| sint_route = g_new0(HvSintRoute, 1); |
| if (!sint_route) { |
| return NULL; |
| } |
| |
| sint_route->synic = synic; |
| sint_route->sint = sint; |
| sint_route->refcount = 1; |
| |
| ack_notifier = cb ? &sint_route->sint_ack_notifier : NULL; |
| if (ack_notifier) { |
| sint_route->staged_msg = g_new0(HvSintStagedMessage, 1); |
| if (!sint_route->staged_msg) { |
| goto cleanup_err_sint; |
| } |
| sint_route->staged_msg->cb = cb; |
| sint_route->staged_msg->cb_data = cb_data; |
| |
| r = event_notifier_init(ack_notifier, false); |
| if (r) { |
| goto cleanup_err_sint; |
| } |
| event_notifier_set_handler(ack_notifier, sint_ack_handler); |
| ack_event_initialized = true; |
| } |
| |
| /* See if we are done or we need to setup a GSI for this SintRoute */ |
| if (!synic->sctl_enabled) { |
| goto cleanup; |
| } |
| |
| /* We need to setup a GSI for this SintRoute */ |
| r = event_notifier_init(&sint_route->sint_set_notifier, false); |
| if (r) { |
| goto cleanup_err_sint; |
| } |
| |
| gsi = kvm_irqchip_add_hv_sint_route(kvm_state, vp_index, sint); |
| if (gsi < 0) { |
| goto cleanup_err_sint_notifier; |
| } |
| |
| r = kvm_irqchip_add_irqfd_notifier_gsi(kvm_state, |
| &sint_route->sint_set_notifier, |
| ack_notifier, gsi); |
| if (r) { |
| goto cleanup_err_irqfd; |
| } |
| sint_route->gsi = gsi; |
| cleanup: |
| qemu_mutex_lock(&synic->sint_routes_mutex); |
| QLIST_INSERT_HEAD(&synic->sint_routes, sint_route, link); |
| qemu_mutex_unlock(&synic->sint_routes_mutex); |
| return sint_route; |
| |
| cleanup_err_irqfd: |
| kvm_irqchip_release_virq(kvm_state, gsi); |
| |
| cleanup_err_sint_notifier: |
| event_notifier_cleanup(&sint_route->sint_set_notifier); |
| |
| cleanup_err_sint: |
| if (ack_notifier) { |
| if (ack_event_initialized) { |
| event_notifier_set_handler(ack_notifier, NULL); |
| event_notifier_cleanup(ack_notifier); |
| } |
| |
| g_free(sint_route->staged_msg); |
| } |
| |
| g_free(sint_route); |
| return NULL; |
| } |
| |
| void hyperv_sint_route_ref(HvSintRoute *sint_route) |
| { |
| sint_route->refcount++; |
| } |
| |
| void hyperv_sint_route_unref(HvSintRoute *sint_route) |
| { |
| SynICState *synic; |
| |
| if (!sint_route) { |
| return; |
| } |
| |
| assert(sint_route->refcount > 0); |
| |
| if (--sint_route->refcount) { |
| return; |
| } |
| |
| synic = sint_route->synic; |
| qemu_mutex_lock(&synic->sint_routes_mutex); |
| QLIST_REMOVE(sint_route, link); |
| qemu_mutex_unlock(&synic->sint_routes_mutex); |
| |
| if (sint_route->gsi) { |
| kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state, |
| &sint_route->sint_set_notifier, |
| sint_route->gsi); |
| kvm_irqchip_release_virq(kvm_state, sint_route->gsi); |
| event_notifier_cleanup(&sint_route->sint_set_notifier); |
| } |
| |
| if (sint_route->staged_msg) { |
| event_notifier_set_handler(&sint_route->sint_ack_notifier, NULL); |
| event_notifier_cleanup(&sint_route->sint_ack_notifier); |
| g_free(sint_route->staged_msg); |
| } |
| g_free(sint_route); |
| } |
| |
| int hyperv_sint_route_set_sint(HvSintRoute *sint_route) |
| { |
| if (!sint_route->gsi) { |
| return 0; |
| } |
| |
| return event_notifier_set(&sint_route->sint_set_notifier); |
| } |
| |
| typedef struct MsgHandler { |
| struct rcu_head rcu; |
| QLIST_ENTRY(MsgHandler) link; |
| uint32_t conn_id; |
| HvMsgHandler handler; |
| void *data; |
| } MsgHandler; |
| |
| typedef struct EventFlagHandler { |
| struct rcu_head rcu; |
| QLIST_ENTRY(EventFlagHandler) link; |
| uint32_t conn_id; |
| EventNotifier *notifier; |
| } EventFlagHandler; |
| |
| static QLIST_HEAD(, MsgHandler) msg_handlers; |
| static QLIST_HEAD(, EventFlagHandler) event_flag_handlers; |
| static QemuMutex handlers_mutex; |
| |
| static void __attribute__((constructor)) hv_init(void) |
| { |
| QLIST_INIT(&msg_handlers); |
| QLIST_INIT(&event_flag_handlers); |
| qemu_mutex_init(&handlers_mutex); |
| } |
| |
| int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data) |
| { |
| int ret; |
| MsgHandler *mh; |
| |
| QEMU_LOCK_GUARD(&handlers_mutex); |
| QLIST_FOREACH(mh, &msg_handlers, link) { |
| if (mh->conn_id == conn_id) { |
| if (handler) { |
| ret = -EEXIST; |
| } else { |
| QLIST_REMOVE_RCU(mh, link); |
| g_free_rcu(mh, rcu); |
| ret = 0; |
| } |
| return ret; |
| } |
| } |
| |
| if (handler) { |
| mh = g_new(MsgHandler, 1); |
| mh->conn_id = conn_id; |
| mh->handler = handler; |
| mh->data = data; |
| QLIST_INSERT_HEAD_RCU(&msg_handlers, mh, link); |
| ret = 0; |
| } else { |
| ret = -ENOENT; |
| } |
| |
| return ret; |
| } |
| |
| uint16_t hyperv_hcall_post_message(uint64_t param, bool fast) |
| { |
| uint16_t ret; |
| hwaddr len; |
| struct hyperv_post_message_input *msg; |
| MsgHandler *mh; |
| |
| if (fast) { |
| return HV_STATUS_INVALID_HYPERCALL_CODE; |
| } |
| if (param & (__alignof__(*msg) - 1)) { |
| return HV_STATUS_INVALID_ALIGNMENT; |
| } |
| |
| len = sizeof(*msg); |
| msg = cpu_physical_memory_map(param, &len, 0); |
| if (len < sizeof(*msg)) { |
| ret = HV_STATUS_INSUFFICIENT_MEMORY; |
| goto unmap; |
| } |
| if (msg->payload_size > sizeof(msg->payload)) { |
| ret = HV_STATUS_INVALID_HYPERCALL_INPUT; |
| goto unmap; |
| } |
| |
| ret = HV_STATUS_INVALID_CONNECTION_ID; |
| WITH_RCU_READ_LOCK_GUARD() { |
| QLIST_FOREACH_RCU(mh, &msg_handlers, link) { |
| if (mh->conn_id == (msg->connection_id & HV_CONNECTION_ID_MASK)) { |
| ret = mh->handler(msg, mh->data); |
| break; |
| } |
| } |
| } |
| |
| unmap: |
| cpu_physical_memory_unmap(msg, len, 0, 0); |
| return ret; |
| } |
| |
| static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier) |
| { |
| int ret; |
| EventFlagHandler *handler; |
| |
| QEMU_LOCK_GUARD(&handlers_mutex); |
| QLIST_FOREACH(handler, &event_flag_handlers, link) { |
| if (handler->conn_id == conn_id) { |
| if (notifier) { |
| ret = -EEXIST; |
| } else { |
| QLIST_REMOVE_RCU(handler, link); |
| g_free_rcu(handler, rcu); |
| ret = 0; |
| } |
| return ret; |
| } |
| } |
| |
| if (notifier) { |
| handler = g_new(EventFlagHandler, 1); |
| handler->conn_id = conn_id; |
| handler->notifier = notifier; |
| QLIST_INSERT_HEAD_RCU(&event_flag_handlers, handler, link); |
| ret = 0; |
| } else { |
| ret = -ENOENT; |
| } |
| |
| return ret; |
| } |
| |
| static bool process_event_flags_userspace; |
| |
| int hyperv_set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier) |
| { |
| if (!process_event_flags_userspace && |
| !kvm_check_extension(kvm_state, KVM_CAP_HYPERV_EVENTFD)) { |
| process_event_flags_userspace = true; |
| |
| warn_report("Hyper-V event signaling is not supported by this kernel; " |
| "using slower userspace hypercall processing"); |
| } |
| |
| if (!process_event_flags_userspace) { |
| struct kvm_hyperv_eventfd hvevfd = { |
| .conn_id = conn_id, |
| .fd = notifier ? event_notifier_get_fd(notifier) : -1, |
| .flags = notifier ? 0 : KVM_HYPERV_EVENTFD_DEASSIGN, |
| }; |
| |
| return kvm_vm_ioctl(kvm_state, KVM_HYPERV_EVENTFD, &hvevfd); |
| } |
| return set_event_flag_handler(conn_id, notifier); |
| } |
| |
| uint16_t hyperv_hcall_signal_event(uint64_t param, bool fast) |
| { |
| EventFlagHandler *handler; |
| |
| if (unlikely(!fast)) { |
| hwaddr addr = param; |
| |
| if (addr & (__alignof__(addr) - 1)) { |
| return HV_STATUS_INVALID_ALIGNMENT; |
| } |
| |
| param = ldq_phys(&address_space_memory, addr); |
| } |
| |
| /* |
| * Per spec, bits 32-47 contain the extra "flag number". However, we |
| * have no use for it, and in all known usecases it is zero, so just |
| * report lookup failure if it isn't. |
| */ |
| if (param & 0xffff00000000ULL) { |
| return HV_STATUS_INVALID_PORT_ID; |
| } |
| /* remaining bits are reserved-zero */ |
| if (param & ~HV_CONNECTION_ID_MASK) { |
| return HV_STATUS_INVALID_HYPERCALL_INPUT; |
| } |
| |
| RCU_READ_LOCK_GUARD(); |
| QLIST_FOREACH_RCU(handler, &event_flag_handlers, link) { |
| if (handler->conn_id == param) { |
| event_notifier_set(handler->notifier); |
| return 0; |
| } |
| } |
| return HV_STATUS_INVALID_CONNECTION_ID; |
| } |
| |
| static HvSynDbgHandler hv_syndbg_handler; |
| static void *hv_syndbg_context; |
| |
| void hyperv_set_syndbg_handler(HvSynDbgHandler handler, void *context) |
| { |
| assert(!hv_syndbg_handler); |
| hv_syndbg_handler = handler; |
| hv_syndbg_context = context; |
| } |
| |
| uint16_t hyperv_hcall_reset_dbg_session(uint64_t outgpa) |
| { |
| uint16_t ret; |
| HvSynDbgMsg msg; |
| struct hyperv_reset_debug_session_output *reset_dbg_session = NULL; |
| hwaddr len; |
| |
| if (!hv_syndbg_handler) { |
| ret = HV_STATUS_INVALID_HYPERCALL_CODE; |
| goto cleanup; |
| } |
| |
| len = sizeof(*reset_dbg_session); |
| reset_dbg_session = cpu_physical_memory_map(outgpa, &len, 1); |
| if (!reset_dbg_session || len < sizeof(*reset_dbg_session)) { |
| ret = HV_STATUS_INSUFFICIENT_MEMORY; |
| goto cleanup; |
| } |
| |
| msg.type = HV_SYNDBG_MSG_CONNECTION_INFO; |
| ret = hv_syndbg_handler(hv_syndbg_context, &msg); |
| if (ret) { |
| goto cleanup; |
| } |
| |
| reset_dbg_session->host_ip = msg.u.connection_info.host_ip; |
| reset_dbg_session->host_port = msg.u.connection_info.host_port; |
| /* The following fields are only used as validation for KDVM */ |
| memset(&reset_dbg_session->host_mac, 0, |
| sizeof(reset_dbg_session->host_mac)); |
| reset_dbg_session->target_ip = msg.u.connection_info.host_ip; |
| reset_dbg_session->target_port = msg.u.connection_info.host_port; |
| memset(&reset_dbg_session->target_mac, 0, |
| sizeof(reset_dbg_session->target_mac)); |
| cleanup: |
| if (reset_dbg_session) { |
| cpu_physical_memory_unmap(reset_dbg_session, |
| sizeof(*reset_dbg_session), 1, len); |
| } |
| |
| return ret; |
| } |
| |
| uint16_t hyperv_hcall_retreive_dbg_data(uint64_t ingpa, uint64_t outgpa, |
| bool fast) |
| { |
| uint16_t ret; |
| struct hyperv_retrieve_debug_data_input *debug_data_in = NULL; |
| struct hyperv_retrieve_debug_data_output *debug_data_out = NULL; |
| hwaddr in_len, out_len; |
| HvSynDbgMsg msg; |
| |
| if (fast || !hv_syndbg_handler) { |
| ret = HV_STATUS_INVALID_HYPERCALL_CODE; |
| goto cleanup; |
| } |
| |
| in_len = sizeof(*debug_data_in); |
| debug_data_in = cpu_physical_memory_map(ingpa, &in_len, 0); |
| if (!debug_data_in || in_len < sizeof(*debug_data_in)) { |
| ret = HV_STATUS_INSUFFICIENT_MEMORY; |
| goto cleanup; |
| } |
| |
| out_len = sizeof(*debug_data_out); |
| debug_data_out = cpu_physical_memory_map(outgpa, &out_len, 1); |
| if (!debug_data_out || out_len < sizeof(*debug_data_out)) { |
| ret = HV_STATUS_INSUFFICIENT_MEMORY; |
| goto cleanup; |
| } |
| |
| msg.type = HV_SYNDBG_MSG_RECV; |
| msg.u.recv.buf_gpa = outgpa + sizeof(*debug_data_out); |
| msg.u.recv.count = TARGET_PAGE_SIZE - sizeof(*debug_data_out); |
| msg.u.recv.options = debug_data_in->options; |
| msg.u.recv.timeout = debug_data_in->timeout; |
| msg.u.recv.is_raw = true; |
| ret = hv_syndbg_handler(hv_syndbg_context, &msg); |
| if (ret == HV_STATUS_NO_DATA) { |
| debug_data_out->retrieved_count = 0; |
| debug_data_out->remaining_count = debug_data_in->count; |
| goto cleanup; |
| } else if (ret != HV_STATUS_SUCCESS) { |
| goto cleanup; |
| } |
| |
| debug_data_out->retrieved_count = msg.u.recv.retrieved_count; |
| debug_data_out->remaining_count = |
| debug_data_in->count - msg.u.recv.retrieved_count; |
| cleanup: |
| if (debug_data_out) { |
| cpu_physical_memory_unmap(debug_data_out, sizeof(*debug_data_out), 1, |
| out_len); |
| } |
| |
| if (debug_data_in) { |
| cpu_physical_memory_unmap(debug_data_in, sizeof(*debug_data_in), 0, |
| in_len); |
| } |
| |
| return ret; |
| } |
| |
| uint16_t hyperv_hcall_post_dbg_data(uint64_t ingpa, uint64_t outgpa, bool fast) |
| { |
| uint16_t ret; |
| struct hyperv_post_debug_data_input *post_data_in = NULL; |
| struct hyperv_post_debug_data_output *post_data_out = NULL; |
| hwaddr in_len, out_len; |
| HvSynDbgMsg msg; |
| |
| if (fast || !hv_syndbg_handler) { |
| ret = HV_STATUS_INVALID_HYPERCALL_CODE; |
| goto cleanup; |
| } |
| |
| in_len = sizeof(*post_data_in); |
| post_data_in = cpu_physical_memory_map(ingpa, &in_len, 0); |
| if (!post_data_in || in_len < sizeof(*post_data_in)) { |
| ret = HV_STATUS_INSUFFICIENT_MEMORY; |
| goto cleanup; |
| } |
| |
| if (post_data_in->count > TARGET_PAGE_SIZE - sizeof(*post_data_in)) { |
| ret = HV_STATUS_INVALID_PARAMETER; |
| goto cleanup; |
| } |
| |
| out_len = sizeof(*post_data_out); |
| post_data_out = cpu_physical_memory_map(outgpa, &out_len, 1); |
| if (!post_data_out || out_len < sizeof(*post_data_out)) { |
| ret = HV_STATUS_INSUFFICIENT_MEMORY; |
| goto cleanup; |
| } |
| |
| msg.type = HV_SYNDBG_MSG_SEND; |
| msg.u.send.buf_gpa = ingpa + sizeof(*post_data_in); |
| msg.u.send.count = post_data_in->count; |
| msg.u.send.is_raw = true; |
| ret = hv_syndbg_handler(hv_syndbg_context, &msg); |
| if (ret != HV_STATUS_SUCCESS) { |
| goto cleanup; |
| } |
| |
| post_data_out->pending_count = msg.u.send.pending_count; |
| ret = post_data_out->pending_count ? HV_STATUS_INSUFFICIENT_BUFFERS : |
| HV_STATUS_SUCCESS; |
| cleanup: |
| if (post_data_out) { |
| cpu_physical_memory_unmap(post_data_out, |
| sizeof(*post_data_out), 1, out_len); |
| } |
| |
| if (post_data_in) { |
| cpu_physical_memory_unmap(post_data_in, |
| sizeof(*post_data_in), 0, in_len); |
| } |
| |
| return ret; |
| } |
| |
| uint32_t hyperv_syndbg_send(uint64_t ingpa, uint32_t count) |
| { |
| HvSynDbgMsg msg; |
| |
| if (!hv_syndbg_handler) { |
| return HV_SYNDBG_STATUS_INVALID; |
| } |
| |
| msg.type = HV_SYNDBG_MSG_SEND; |
| msg.u.send.buf_gpa = ingpa; |
| msg.u.send.count = count; |
| msg.u.send.is_raw = false; |
| if (hv_syndbg_handler(hv_syndbg_context, &msg)) { |
| return HV_SYNDBG_STATUS_INVALID; |
| } |
| |
| return HV_SYNDBG_STATUS_SEND_SUCCESS; |
| } |
| |
| uint32_t hyperv_syndbg_recv(uint64_t ingpa, uint32_t count) |
| { |
| uint16_t ret; |
| HvSynDbgMsg msg; |
| |
| if (!hv_syndbg_handler) { |
| return HV_SYNDBG_STATUS_INVALID; |
| } |
| |
| msg.type = HV_SYNDBG_MSG_RECV; |
| msg.u.recv.buf_gpa = ingpa; |
| msg.u.recv.count = count; |
| msg.u.recv.options = 0; |
| msg.u.recv.timeout = 0; |
| msg.u.recv.is_raw = false; |
| ret = hv_syndbg_handler(hv_syndbg_context, &msg); |
| if (ret != HV_STATUS_SUCCESS) { |
| return 0; |
| } |
| |
| return HV_SYNDBG_STATUS_SET_SIZE(HV_SYNDBG_STATUS_RECV_SUCCESS, |
| msg.u.recv.retrieved_count); |
| } |
| |
| void hyperv_syndbg_set_pending_page(uint64_t ingpa) |
| { |
| HvSynDbgMsg msg; |
| |
| if (!hv_syndbg_handler) { |
| return; |
| } |
| |
| msg.type = HV_SYNDBG_MSG_SET_PENDING_PAGE; |
| msg.u.pending_page.buf_gpa = ingpa; |
| hv_syndbg_handler(hv_syndbg_context, &msg); |
| } |
| |
| uint64_t hyperv_syndbg_query_options(void) |
| { |
| HvSynDbgMsg msg; |
| |
| if (!hv_syndbg_handler) { |
| return 0; |
| } |
| |
| msg.type = HV_SYNDBG_MSG_QUERY_OPTIONS; |
| if (hv_syndbg_handler(hv_syndbg_context, &msg) != HV_STATUS_SUCCESS) { |
| return 0; |
| } |
| |
| return msg.u.query_options.options; |
| } |
