xref: /openbmc/qemu/hw/hyperv/hyperv.c (revision 2e1cacfb)
1 /*
2  * Hyper-V guest/hypervisor interaction
3  *
4  * Copyright (c) 2015-2018 Virtuozzo International GmbH.
5  *
6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
7  * See the COPYING file in the top-level directory.
8  */
9 
10 #include "qemu/osdep.h"
11 #include "qemu/main-loop.h"
12 #include "qemu/module.h"
13 #include "qapi/error.h"
14 #include "exec/address-spaces.h"
15 #include "exec/memory.h"
16 #include "sysemu/kvm.h"
17 #include "qemu/bitops.h"
18 #include "qemu/error-report.h"
19 #include "qemu/lockable.h"
20 #include "qemu/queue.h"
21 #include "qemu/rcu.h"
22 #include "qemu/rcu_queue.h"
23 #include "hw/hyperv/hyperv.h"
24 #include "qom/object.h"
25 #include "target/i386/kvm/hyperv-proto.h"
26 #include "target/i386/cpu.h"
27 #include "exec/cpu-all.h"
28 
29 struct SynICState {
30     DeviceState parent_obj;
31 
32     CPUState *cs;
33 
34     bool sctl_enabled;
35     hwaddr msg_page_addr;
36     hwaddr event_page_addr;
37     MemoryRegion msg_page_mr;
38     MemoryRegion event_page_mr;
39     struct hyperv_message_page *msg_page;
40     struct hyperv_event_flags_page *event_page;
41 
42     QemuMutex sint_routes_mutex;
43     QLIST_HEAD(, HvSintRoute) sint_routes;
44 };
45 
46 #define TYPE_SYNIC "hyperv-synic"
47 OBJECT_DECLARE_SIMPLE_TYPE(SynICState, SYNIC)
48 
49 static bool synic_enabled;
50 
51 bool hyperv_is_synic_enabled(void)
52 {
53     return synic_enabled;
54 }
55 
56 static SynICState *get_synic(CPUState *cs)
57 {
58     return SYNIC(object_resolve_path_component(OBJECT(cs), "synic"));
59 }
60 
61 static void synic_update(SynICState *synic, bool sctl_enable,
62                          hwaddr msg_page_addr, hwaddr event_page_addr)
63 {
64 
65     synic->sctl_enabled = sctl_enable;
66     if (synic->msg_page_addr != msg_page_addr) {
67         if (synic->msg_page_addr) {
68             memory_region_del_subregion(get_system_memory(),
69                                         &synic->msg_page_mr);
70         }
71         if (msg_page_addr) {
72             memory_region_add_subregion(get_system_memory(), msg_page_addr,
73                                         &synic->msg_page_mr);
74         }
75         synic->msg_page_addr = msg_page_addr;
76     }
77     if (synic->event_page_addr != event_page_addr) {
78         if (synic->event_page_addr) {
79             memory_region_del_subregion(get_system_memory(),
80                                         &synic->event_page_mr);
81         }
82         if (event_page_addr) {
83             memory_region_add_subregion(get_system_memory(), event_page_addr,
84                                         &synic->event_page_mr);
85         }
86         synic->event_page_addr = event_page_addr;
87     }
88 }
89 
90 void hyperv_synic_update(CPUState *cs, bool sctl_enable,
91                          hwaddr msg_page_addr, hwaddr event_page_addr)
92 {
93     SynICState *synic = get_synic(cs);
94 
95     if (!synic) {
96         return;
97     }
98 
99     synic_update(synic, sctl_enable, msg_page_addr, event_page_addr);
100 }
101 
102 static void synic_realize(DeviceState *dev, Error **errp)
103 {
104     Object *obj = OBJECT(dev);
105     SynICState *synic = SYNIC(dev);
106     char *msgp_name, *eventp_name;
107     uint32_t vp_index;
108 
109     /* memory region names have to be globally unique */
110     vp_index = hyperv_vp_index(synic->cs);
111     msgp_name = g_strdup_printf("synic-%u-msg-page", vp_index);
112     eventp_name = g_strdup_printf("synic-%u-event-page", vp_index);
113 
114     memory_region_init_ram(&synic->msg_page_mr, obj, msgp_name,
115                            sizeof(*synic->msg_page), &error_abort);
116     memory_region_init_ram(&synic->event_page_mr, obj, eventp_name,
117                            sizeof(*synic->event_page), &error_abort);
118     synic->msg_page = memory_region_get_ram_ptr(&synic->msg_page_mr);
119     synic->event_page = memory_region_get_ram_ptr(&synic->event_page_mr);
120     qemu_mutex_init(&synic->sint_routes_mutex);
121     QLIST_INIT(&synic->sint_routes);
122 
123     g_free(msgp_name);
124     g_free(eventp_name);
125 }
126 
127 static void synic_reset(DeviceState *dev)
128 {
129     SynICState *synic = SYNIC(dev);
130     memset(synic->msg_page, 0, sizeof(*synic->msg_page));
131     memset(synic->event_page, 0, sizeof(*synic->event_page));
132     synic_update(synic, false, 0, 0);
133     assert(QLIST_EMPTY(&synic->sint_routes));
134 }
135 
136 static void synic_class_init(ObjectClass *klass, void *data)
137 {
138     DeviceClass *dc = DEVICE_CLASS(klass);
139 
140     dc->realize = synic_realize;
141     device_class_set_legacy_reset(dc, synic_reset);
142     dc->user_creatable = false;
143 }
144 
145 void hyperv_synic_add(CPUState *cs)
146 {
147     Object *obj;
148     SynICState *synic;
149 
150     obj = object_new(TYPE_SYNIC);
151     synic = SYNIC(obj);
152     synic->cs = cs;
153     object_property_add_child(OBJECT(cs), "synic", obj);
154     object_unref(obj);
155     qdev_realize(DEVICE(obj), NULL, &error_abort);
156     synic_enabled = true;
157 }
158 
159 void hyperv_synic_reset(CPUState *cs)
160 {
161     SynICState *synic = get_synic(cs);
162 
163     if (synic) {
164         device_cold_reset(DEVICE(synic));
165     }
166 }
167 
168 static const TypeInfo synic_type_info = {
169     .name = TYPE_SYNIC,
170     .parent = TYPE_DEVICE,
171     .instance_size = sizeof(SynICState),
172     .class_init = synic_class_init,
173 };
174 
175 static void synic_register_types(void)
176 {
177     type_register_static(&synic_type_info);
178 }
179 
180 type_init(synic_register_types)
181 
182 /*
183  * KVM has its own message producers (SynIC timers).  To guarantee
184  * serialization with both KVM vcpu and the guest cpu, the messages are first
185  * staged in an intermediate area and then posted to the SynIC message page in
186  * the vcpu thread.
187  */
188 typedef struct HvSintStagedMessage {
189     /* message content staged by hyperv_post_msg */
190     struct hyperv_message msg;
191     /* callback + data (r/o) to complete the processing in a BH */
192     HvSintMsgCb cb;
193     void *cb_data;
194     /* message posting status filled by cpu_post_msg */
195     int status;
196     /* passing the buck: */
197     enum {
198         /* initial state */
199         HV_STAGED_MSG_FREE,
200         /*
201          * hyperv_post_msg (e.g. in main loop) grabs the staged area (FREE ->
202          * BUSY), copies msg, and schedules cpu_post_msg on the assigned cpu
203          */
204         HV_STAGED_MSG_BUSY,
205         /*
206          * cpu_post_msg (vcpu thread) tries to copy staged msg to msg slot,
207          * notify the guest, records the status, marks the posting done (BUSY
208          * -> POSTED), and schedules sint_msg_bh BH
209          */
210         HV_STAGED_MSG_POSTED,
211         /*
212          * sint_msg_bh (BH) verifies that the posting is done, runs the
213          * callback, and starts over (POSTED -> FREE)
214          */
215     } state;
216 } HvSintStagedMessage;
217 
218 struct HvSintRoute {
219     uint32_t sint;
220     SynICState *synic;
221     int gsi;
222     EventNotifier sint_set_notifier;
223     EventNotifier sint_ack_notifier;
224 
225     HvSintStagedMessage *staged_msg;
226 
227     unsigned refcount;
228     QLIST_ENTRY(HvSintRoute) link;
229 };
230 
231 static CPUState *hyperv_find_vcpu(uint32_t vp_index)
232 {
233     CPUState *cs = qemu_get_cpu(vp_index);
234     assert(hyperv_vp_index(cs) == vp_index);
235     return cs;
236 }
237 
238 /*
239  * BH to complete the processing of a staged message.
240  */
241 static void sint_msg_bh(void *opaque)
242 {
243     HvSintRoute *sint_route = opaque;
244     HvSintStagedMessage *staged_msg = sint_route->staged_msg;
245 
246     if (qatomic_read(&staged_msg->state) != HV_STAGED_MSG_POSTED) {
247         /* status nor ready yet (spurious ack from guest?), ignore */
248         return;
249     }
250 
251     staged_msg->cb(staged_msg->cb_data, staged_msg->status);
252     staged_msg->status = 0;
253 
254     /* staged message processing finished, ready to start over */
255     qatomic_set(&staged_msg->state, HV_STAGED_MSG_FREE);
256     /* drop the reference taken in hyperv_post_msg */
257     hyperv_sint_route_unref(sint_route);
258 }
259 
260 /*
261  * Worker to transfer the message from the staging area into the SynIC message
262  * page in vcpu context.
263  */
264 static void cpu_post_msg(CPUState *cs, run_on_cpu_data data)
265 {
266     HvSintRoute *sint_route = data.host_ptr;
267     HvSintStagedMessage *staged_msg = sint_route->staged_msg;
268     SynICState *synic = sint_route->synic;
269     struct hyperv_message *dst_msg;
270     bool wait_for_sint_ack = false;
271 
272     assert(staged_msg->state == HV_STAGED_MSG_BUSY);
273 
274     if (!synic->msg_page_addr) {
275         staged_msg->status = -ENXIO;
276         goto posted;
277     }
278 
279     dst_msg = &synic->msg_page->slot[sint_route->sint];
280 
281     if (dst_msg->header.message_type != HV_MESSAGE_NONE) {
282         dst_msg->header.message_flags |= HV_MESSAGE_FLAG_PENDING;
283         staged_msg->status = -EAGAIN;
284         wait_for_sint_ack = true;
285     } else {
286         memcpy(dst_msg, &staged_msg->msg, sizeof(*dst_msg));
287         staged_msg->status = hyperv_sint_route_set_sint(sint_route);
288     }
289 
290     memory_region_set_dirty(&synic->msg_page_mr, 0, sizeof(*synic->msg_page));
291 
292 posted:
293     qatomic_set(&staged_msg->state, HV_STAGED_MSG_POSTED);
294     /*
295      * Notify the msg originator of the progress made; if the slot was busy we
296      * set msg_pending flag in it so it will be the guest who will do EOM and
297      * trigger the notification from KVM via sint_ack_notifier
298      */
299     if (!wait_for_sint_ack) {
300         aio_bh_schedule_oneshot(qemu_get_aio_context(), sint_msg_bh,
301                                 sint_route);
302     }
303 }
304 
305 /*
306  * Post a Hyper-V message to the staging area, for delivery to guest in the
307  * vcpu thread.
308  */
309 int hyperv_post_msg(HvSintRoute *sint_route, struct hyperv_message *src_msg)
310 {
311     HvSintStagedMessage *staged_msg = sint_route->staged_msg;
312 
313     assert(staged_msg);
314 
315     /* grab the staging area */
316     if (qatomic_cmpxchg(&staged_msg->state, HV_STAGED_MSG_FREE,
317                        HV_STAGED_MSG_BUSY) != HV_STAGED_MSG_FREE) {
318         return -EAGAIN;
319     }
320 
321     memcpy(&staged_msg->msg, src_msg, sizeof(*src_msg));
322 
323     /* hold a reference on sint_route until the callback is finished */
324     hyperv_sint_route_ref(sint_route);
325 
326     /* schedule message posting attempt in vcpu thread */
327     async_run_on_cpu(sint_route->synic->cs, cpu_post_msg,
328                      RUN_ON_CPU_HOST_PTR(sint_route));
329     return 0;
330 }
331 
332 static void sint_ack_handler(EventNotifier *notifier)
333 {
334     HvSintRoute *sint_route = container_of(notifier, HvSintRoute,
335                                            sint_ack_notifier);
336     event_notifier_test_and_clear(notifier);
337 
338     /*
339      * the guest consumed the previous message so complete the current one with
340      * -EAGAIN and let the msg originator retry
341      */
342     aio_bh_schedule_oneshot(qemu_get_aio_context(), sint_msg_bh, sint_route);
343 }
344 
345 /*
346  * Set given event flag for a given sint on a given vcpu, and signal the sint.
347  */
348 int hyperv_set_event_flag(HvSintRoute *sint_route, unsigned eventno)
349 {
350     int ret;
351     SynICState *synic = sint_route->synic;
352     unsigned long *flags, set_mask;
353     unsigned set_idx;
354 
355     if (eventno > HV_EVENT_FLAGS_COUNT) {
356         return -EINVAL;
357     }
358     if (!synic->sctl_enabled || !synic->event_page_addr) {
359         return -ENXIO;
360     }
361 
362     set_idx = BIT_WORD(eventno);
363     set_mask = BIT_MASK(eventno);
364     flags = synic->event_page->slot[sint_route->sint].flags;
365 
366     if ((qatomic_fetch_or(&flags[set_idx], set_mask) & set_mask) != set_mask) {
367         memory_region_set_dirty(&synic->event_page_mr, 0,
368                                 sizeof(*synic->event_page));
369         ret = hyperv_sint_route_set_sint(sint_route);
370     } else {
371         ret = 0;
372     }
373     return ret;
374 }
375 
376 static int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint)
377 {
378     struct kvm_irq_routing_entry kroute = {};
379     int virq;
380 
381     if (!kvm_gsi_routing_enabled()) {
382         return -ENOSYS;
383     }
384     virq = kvm_irqchip_get_virq(s);
385     if (virq < 0) {
386         return virq;
387     }
388 
389     kroute.gsi = virq;
390     kroute.type = KVM_IRQ_ROUTING_HV_SINT;
391     kroute.flags = 0;
392     kroute.u.hv_sint.vcpu = vcpu;
393     kroute.u.hv_sint.sint = sint;
394 
395     kvm_add_routing_entry(s, &kroute);
396     kvm_irqchip_commit_routes(s);
397 
398     return virq;
399 }
400 
401 HvSintRoute *hyperv_sint_route_new(uint32_t vp_index, uint32_t sint,
402                                    HvSintMsgCb cb, void *cb_data)
403 {
404     HvSintRoute *sint_route = NULL;
405     EventNotifier *ack_notifier = NULL;
406     int r, gsi;
407     CPUState *cs;
408     SynICState *synic;
409     bool ack_event_initialized = false;
410 
411     cs = hyperv_find_vcpu(vp_index);
412     if (!cs) {
413         return NULL;
414     }
415 
416     synic = get_synic(cs);
417     if (!synic) {
418         return NULL;
419     }
420 
421     sint_route = g_new0(HvSintRoute, 1);
422     if (!sint_route) {
423         return NULL;
424     }
425 
426     sint_route->synic = synic;
427     sint_route->sint = sint;
428     sint_route->refcount = 1;
429 
430     ack_notifier = cb ? &sint_route->sint_ack_notifier : NULL;
431     if (ack_notifier) {
432         sint_route->staged_msg = g_new0(HvSintStagedMessage, 1);
433         if (!sint_route->staged_msg) {
434             goto cleanup_err_sint;
435         }
436         sint_route->staged_msg->cb = cb;
437         sint_route->staged_msg->cb_data = cb_data;
438 
439         r = event_notifier_init(ack_notifier, false);
440         if (r) {
441             goto cleanup_err_sint;
442         }
443         event_notifier_set_handler(ack_notifier, sint_ack_handler);
444         ack_event_initialized = true;
445     }
446 
447     /* See if we are done or we need to setup a GSI for this SintRoute */
448     if (!synic->sctl_enabled) {
449         goto cleanup;
450     }
451 
452     /* We need to setup a GSI for this SintRoute */
453     r = event_notifier_init(&sint_route->sint_set_notifier, false);
454     if (r) {
455         goto cleanup_err_sint;
456     }
457 
458     gsi = kvm_irqchip_add_hv_sint_route(kvm_state, vp_index, sint);
459     if (gsi < 0) {
460         goto cleanup_err_sint_notifier;
461     }
462 
463     r = kvm_irqchip_add_irqfd_notifier_gsi(kvm_state,
464                                            &sint_route->sint_set_notifier,
465                                            ack_notifier, gsi);
466     if (r) {
467         goto cleanup_err_irqfd;
468     }
469     sint_route->gsi = gsi;
470 cleanup:
471     qemu_mutex_lock(&synic->sint_routes_mutex);
472     QLIST_INSERT_HEAD(&synic->sint_routes, sint_route, link);
473     qemu_mutex_unlock(&synic->sint_routes_mutex);
474     return sint_route;
475 
476 cleanup_err_irqfd:
477     kvm_irqchip_release_virq(kvm_state, gsi);
478 
479 cleanup_err_sint_notifier:
480     event_notifier_cleanup(&sint_route->sint_set_notifier);
481 
482 cleanup_err_sint:
483     if (ack_notifier) {
484         if (ack_event_initialized) {
485             event_notifier_set_handler(ack_notifier, NULL);
486             event_notifier_cleanup(ack_notifier);
487         }
488 
489         g_free(sint_route->staged_msg);
490     }
491 
492     g_free(sint_route);
493     return NULL;
494 }
495 
496 void hyperv_sint_route_ref(HvSintRoute *sint_route)
497 {
498     sint_route->refcount++;
499 }
500 
501 void hyperv_sint_route_unref(HvSintRoute *sint_route)
502 {
503     SynICState *synic;
504 
505     if (!sint_route) {
506         return;
507     }
508 
509     assert(sint_route->refcount > 0);
510 
511     if (--sint_route->refcount) {
512         return;
513     }
514 
515     synic = sint_route->synic;
516     qemu_mutex_lock(&synic->sint_routes_mutex);
517     QLIST_REMOVE(sint_route, link);
518     qemu_mutex_unlock(&synic->sint_routes_mutex);
519 
520     if (sint_route->gsi) {
521         kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state,
522                                               &sint_route->sint_set_notifier,
523                                               sint_route->gsi);
524         kvm_irqchip_release_virq(kvm_state, sint_route->gsi);
525         event_notifier_cleanup(&sint_route->sint_set_notifier);
526     }
527 
528     if (sint_route->staged_msg) {
529         event_notifier_set_handler(&sint_route->sint_ack_notifier, NULL);
530         event_notifier_cleanup(&sint_route->sint_ack_notifier);
531         g_free(sint_route->staged_msg);
532     }
533     g_free(sint_route);
534 }
535 
536 int hyperv_sint_route_set_sint(HvSintRoute *sint_route)
537 {
538     if (!sint_route->gsi) {
539         return 0;
540     }
541 
542     return event_notifier_set(&sint_route->sint_set_notifier);
543 }
544 
545 typedef struct MsgHandler {
546     struct rcu_head rcu;
547     QLIST_ENTRY(MsgHandler) link;
548     uint32_t conn_id;
549     HvMsgHandler handler;
550     void *data;
551 } MsgHandler;
552 
553 typedef struct EventFlagHandler {
554     struct rcu_head rcu;
555     QLIST_ENTRY(EventFlagHandler) link;
556     uint32_t conn_id;
557     EventNotifier *notifier;
558 } EventFlagHandler;
559 
560 static QLIST_HEAD(, MsgHandler) msg_handlers;
561 static QLIST_HEAD(, EventFlagHandler) event_flag_handlers;
562 static QemuMutex handlers_mutex;
563 
564 static void __attribute__((constructor)) hv_init(void)
565 {
566     QLIST_INIT(&msg_handlers);
567     QLIST_INIT(&event_flag_handlers);
568     qemu_mutex_init(&handlers_mutex);
569 }
570 
571 int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data)
572 {
573     int ret;
574     MsgHandler *mh;
575 
576     QEMU_LOCK_GUARD(&handlers_mutex);
577     QLIST_FOREACH(mh, &msg_handlers, link) {
578         if (mh->conn_id == conn_id) {
579             if (handler) {
580                 ret = -EEXIST;
581             } else {
582                 QLIST_REMOVE_RCU(mh, link);
583                 g_free_rcu(mh, rcu);
584                 ret = 0;
585             }
586             return ret;
587         }
588     }
589 
590     if (handler) {
591         mh = g_new(MsgHandler, 1);
592         mh->conn_id = conn_id;
593         mh->handler = handler;
594         mh->data = data;
595         QLIST_INSERT_HEAD_RCU(&msg_handlers, mh, link);
596         ret = 0;
597     } else {
598         ret = -ENOENT;
599     }
600 
601     return ret;
602 }
603 
604 uint16_t hyperv_hcall_post_message(uint64_t param, bool fast)
605 {
606     uint16_t ret;
607     hwaddr len;
608     struct hyperv_post_message_input *msg;
609     MsgHandler *mh;
610 
611     if (fast) {
612         return HV_STATUS_INVALID_HYPERCALL_CODE;
613     }
614     if (param & (__alignof__(*msg) - 1)) {
615         return HV_STATUS_INVALID_ALIGNMENT;
616     }
617 
618     len = sizeof(*msg);
619     msg = cpu_physical_memory_map(param, &len, 0);
620     if (len < sizeof(*msg)) {
621         ret = HV_STATUS_INSUFFICIENT_MEMORY;
622         goto unmap;
623     }
624     if (msg->payload_size > sizeof(msg->payload)) {
625         ret = HV_STATUS_INVALID_HYPERCALL_INPUT;
626         goto unmap;
627     }
628 
629     ret = HV_STATUS_INVALID_CONNECTION_ID;
630     WITH_RCU_READ_LOCK_GUARD() {
631         QLIST_FOREACH_RCU(mh, &msg_handlers, link) {
632             if (mh->conn_id == (msg->connection_id & HV_CONNECTION_ID_MASK)) {
633                 ret = mh->handler(msg, mh->data);
634                 break;
635             }
636         }
637     }
638 
639 unmap:
640     cpu_physical_memory_unmap(msg, len, 0, 0);
641     return ret;
642 }
643 
644 static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier)
645 {
646     int ret;
647     EventFlagHandler *handler;
648 
649     QEMU_LOCK_GUARD(&handlers_mutex);
650     QLIST_FOREACH(handler, &event_flag_handlers, link) {
651         if (handler->conn_id == conn_id) {
652             if (notifier) {
653                 ret = -EEXIST;
654             } else {
655                 QLIST_REMOVE_RCU(handler, link);
656                 g_free_rcu(handler, rcu);
657                 ret = 0;
658             }
659             return ret;
660         }
661     }
662 
663     if (notifier) {
664         handler = g_new(EventFlagHandler, 1);
665         handler->conn_id = conn_id;
666         handler->notifier = notifier;
667         QLIST_INSERT_HEAD_RCU(&event_flag_handlers, handler, link);
668         ret = 0;
669     } else {
670         ret = -ENOENT;
671     }
672 
673     return ret;
674 }
675 
676 static bool process_event_flags_userspace;
677 
678 int hyperv_set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier)
679 {
680     if (!process_event_flags_userspace &&
681         !kvm_check_extension(kvm_state, KVM_CAP_HYPERV_EVENTFD)) {
682         process_event_flags_userspace = true;
683 
684         warn_report("Hyper-V event signaling is not supported by this kernel; "
685                     "using slower userspace hypercall processing");
686     }
687 
688     if (!process_event_flags_userspace) {
689         struct kvm_hyperv_eventfd hvevfd = {
690             .conn_id = conn_id,
691             .fd = notifier ? event_notifier_get_fd(notifier) : -1,
692             .flags = notifier ? 0 : KVM_HYPERV_EVENTFD_DEASSIGN,
693         };
694 
695         return kvm_vm_ioctl(kvm_state, KVM_HYPERV_EVENTFD, &hvevfd);
696     }
697     return set_event_flag_handler(conn_id, notifier);
698 }
699 
700 uint16_t hyperv_hcall_signal_event(uint64_t param, bool fast)
701 {
702     EventFlagHandler *handler;
703 
704     if (unlikely(!fast)) {
705         hwaddr addr = param;
706 
707         if (addr & (__alignof__(addr) - 1)) {
708             return HV_STATUS_INVALID_ALIGNMENT;
709         }
710 
711         param = ldq_phys(&address_space_memory, addr);
712     }
713 
714     /*
715      * Per spec, bits 32-47 contain the extra "flag number".  However, we
716      * have no use for it, and in all known usecases it is zero, so just
717      * report lookup failure if it isn't.
718      */
719     if (param & 0xffff00000000ULL) {
720         return HV_STATUS_INVALID_PORT_ID;
721     }
722     /* remaining bits are reserved-zero */
723     if (param & ~HV_CONNECTION_ID_MASK) {
724         return HV_STATUS_INVALID_HYPERCALL_INPUT;
725     }
726 
727     RCU_READ_LOCK_GUARD();
728     QLIST_FOREACH_RCU(handler, &event_flag_handlers, link) {
729         if (handler->conn_id == param) {
730             event_notifier_set(handler->notifier);
731             return 0;
732         }
733     }
734     return HV_STATUS_INVALID_CONNECTION_ID;
735 }
736 
737 static HvSynDbgHandler hv_syndbg_handler;
738 static void *hv_syndbg_context;
739 
740 void hyperv_set_syndbg_handler(HvSynDbgHandler handler, void *context)
741 {
742     assert(!hv_syndbg_handler);
743     hv_syndbg_handler = handler;
744     hv_syndbg_context = context;
745 }
746 
747 uint16_t hyperv_hcall_reset_dbg_session(uint64_t outgpa)
748 {
749     uint16_t ret;
750     HvSynDbgMsg msg;
751     struct hyperv_reset_debug_session_output *reset_dbg_session = NULL;
752     hwaddr len;
753 
754     if (!hv_syndbg_handler) {
755         ret = HV_STATUS_INVALID_HYPERCALL_CODE;
756         goto cleanup;
757     }
758 
759     len = sizeof(*reset_dbg_session);
760     reset_dbg_session = cpu_physical_memory_map(outgpa, &len, 1);
761     if (!reset_dbg_session || len < sizeof(*reset_dbg_session)) {
762         ret = HV_STATUS_INSUFFICIENT_MEMORY;
763         goto cleanup;
764     }
765 
766     msg.type = HV_SYNDBG_MSG_CONNECTION_INFO;
767     ret = hv_syndbg_handler(hv_syndbg_context, &msg);
768     if (ret) {
769         goto cleanup;
770     }
771 
772     reset_dbg_session->host_ip = msg.u.connection_info.host_ip;
773     reset_dbg_session->host_port = msg.u.connection_info.host_port;
774     /* The following fields are only used as validation for KDVM */
775     memset(&reset_dbg_session->host_mac, 0,
776            sizeof(reset_dbg_session->host_mac));
777     reset_dbg_session->target_ip = msg.u.connection_info.host_ip;
778     reset_dbg_session->target_port = msg.u.connection_info.host_port;
779     memset(&reset_dbg_session->target_mac, 0,
780            sizeof(reset_dbg_session->target_mac));
781 cleanup:
782     if (reset_dbg_session) {
783         cpu_physical_memory_unmap(reset_dbg_session,
784                                   sizeof(*reset_dbg_session), 1, len);
785     }
786 
787     return ret;
788 }
789 
790 uint16_t hyperv_hcall_retreive_dbg_data(uint64_t ingpa, uint64_t outgpa,
791                                         bool fast)
792 {
793     uint16_t ret;
794     struct hyperv_retrieve_debug_data_input *debug_data_in = NULL;
795     struct hyperv_retrieve_debug_data_output *debug_data_out = NULL;
796     hwaddr in_len, out_len;
797     HvSynDbgMsg msg;
798 
799     if (fast || !hv_syndbg_handler) {
800         ret = HV_STATUS_INVALID_HYPERCALL_CODE;
801         goto cleanup;
802     }
803 
804     in_len = sizeof(*debug_data_in);
805     debug_data_in = cpu_physical_memory_map(ingpa, &in_len, 0);
806     if (!debug_data_in || in_len < sizeof(*debug_data_in)) {
807         ret = HV_STATUS_INSUFFICIENT_MEMORY;
808         goto cleanup;
809     }
810 
811     out_len = sizeof(*debug_data_out);
812     debug_data_out = cpu_physical_memory_map(outgpa, &out_len, 1);
813     if (!debug_data_out || out_len < sizeof(*debug_data_out)) {
814         ret = HV_STATUS_INSUFFICIENT_MEMORY;
815         goto cleanup;
816     }
817 
818     msg.type = HV_SYNDBG_MSG_RECV;
819     msg.u.recv.buf_gpa = outgpa + sizeof(*debug_data_out);
820     msg.u.recv.count = TARGET_PAGE_SIZE - sizeof(*debug_data_out);
821     msg.u.recv.options = debug_data_in->options;
822     msg.u.recv.timeout = debug_data_in->timeout;
823     msg.u.recv.is_raw = true;
824     ret = hv_syndbg_handler(hv_syndbg_context, &msg);
825     if (ret == HV_STATUS_NO_DATA) {
826         debug_data_out->retrieved_count = 0;
827         debug_data_out->remaining_count = debug_data_in->count;
828         goto cleanup;
829     } else if (ret != HV_STATUS_SUCCESS) {
830         goto cleanup;
831     }
832 
833     debug_data_out->retrieved_count = msg.u.recv.retrieved_count;
834     debug_data_out->remaining_count =
835         debug_data_in->count - msg.u.recv.retrieved_count;
836 cleanup:
837     if (debug_data_out) {
838         cpu_physical_memory_unmap(debug_data_out, sizeof(*debug_data_out), 1,
839                                   out_len);
840     }
841 
842     if (debug_data_in) {
843         cpu_physical_memory_unmap(debug_data_in, sizeof(*debug_data_in), 0,
844                                   in_len);
845     }
846 
847     return ret;
848 }
849 
850 uint16_t hyperv_hcall_post_dbg_data(uint64_t ingpa, uint64_t outgpa, bool fast)
851 {
852     uint16_t ret;
853     struct hyperv_post_debug_data_input *post_data_in = NULL;
854     struct hyperv_post_debug_data_output *post_data_out = NULL;
855     hwaddr in_len, out_len;
856     HvSynDbgMsg msg;
857 
858     if (fast || !hv_syndbg_handler) {
859         ret = HV_STATUS_INVALID_HYPERCALL_CODE;
860         goto cleanup;
861     }
862 
863     in_len = sizeof(*post_data_in);
864     post_data_in = cpu_physical_memory_map(ingpa, &in_len, 0);
865     if (!post_data_in || in_len < sizeof(*post_data_in)) {
866         ret = HV_STATUS_INSUFFICIENT_MEMORY;
867         goto cleanup;
868     }
869 
870     if (post_data_in->count > TARGET_PAGE_SIZE - sizeof(*post_data_in)) {
871         ret = HV_STATUS_INVALID_PARAMETER;
872         goto cleanup;
873     }
874 
875     out_len = sizeof(*post_data_out);
876     post_data_out = cpu_physical_memory_map(outgpa, &out_len, 1);
877     if (!post_data_out || out_len < sizeof(*post_data_out)) {
878         ret = HV_STATUS_INSUFFICIENT_MEMORY;
879         goto cleanup;
880     }
881 
882     msg.type = HV_SYNDBG_MSG_SEND;
883     msg.u.send.buf_gpa = ingpa + sizeof(*post_data_in);
884     msg.u.send.count = post_data_in->count;
885     msg.u.send.is_raw = true;
886     ret = hv_syndbg_handler(hv_syndbg_context, &msg);
887     if (ret != HV_STATUS_SUCCESS) {
888         goto cleanup;
889     }
890 
891     post_data_out->pending_count = msg.u.send.pending_count;
892     ret = post_data_out->pending_count ? HV_STATUS_INSUFFICIENT_BUFFERS :
893                                          HV_STATUS_SUCCESS;
894 cleanup:
895     if (post_data_out) {
896         cpu_physical_memory_unmap(post_data_out,
897                                   sizeof(*post_data_out), 1, out_len);
898     }
899 
900     if (post_data_in) {
901         cpu_physical_memory_unmap(post_data_in,
902                                   sizeof(*post_data_in), 0, in_len);
903     }
904 
905     return ret;
906 }
907 
908 uint32_t hyperv_syndbg_send(uint64_t ingpa, uint32_t count)
909 {
910     HvSynDbgMsg msg;
911 
912     if (!hv_syndbg_handler) {
913         return HV_SYNDBG_STATUS_INVALID;
914     }
915 
916     msg.type = HV_SYNDBG_MSG_SEND;
917     msg.u.send.buf_gpa = ingpa;
918     msg.u.send.count = count;
919     msg.u.send.is_raw = false;
920     if (hv_syndbg_handler(hv_syndbg_context, &msg)) {
921         return HV_SYNDBG_STATUS_INVALID;
922     }
923 
924     return HV_SYNDBG_STATUS_SEND_SUCCESS;
925 }
926 
927 uint32_t hyperv_syndbg_recv(uint64_t ingpa, uint32_t count)
928 {
929     uint16_t ret;
930     HvSynDbgMsg msg;
931 
932     if (!hv_syndbg_handler) {
933         return HV_SYNDBG_STATUS_INVALID;
934     }
935 
936     msg.type = HV_SYNDBG_MSG_RECV;
937     msg.u.recv.buf_gpa = ingpa;
938     msg.u.recv.count = count;
939     msg.u.recv.options = 0;
940     msg.u.recv.timeout = 0;
941     msg.u.recv.is_raw = false;
942     ret = hv_syndbg_handler(hv_syndbg_context, &msg);
943     if (ret != HV_STATUS_SUCCESS) {
944         return 0;
945     }
946 
947     return HV_SYNDBG_STATUS_SET_SIZE(HV_SYNDBG_STATUS_RECV_SUCCESS,
948                                      msg.u.recv.retrieved_count);
949 }
950 
951 void hyperv_syndbg_set_pending_page(uint64_t ingpa)
952 {
953     HvSynDbgMsg msg;
954 
955     if (!hv_syndbg_handler) {
956         return;
957     }
958 
959     msg.type = HV_SYNDBG_MSG_SET_PENDING_PAGE;
960     msg.u.pending_page.buf_gpa = ingpa;
961     hv_syndbg_handler(hv_syndbg_context, &msg);
962 }
963 
964 uint64_t hyperv_syndbg_query_options(void)
965 {
966     HvSynDbgMsg msg;
967 
968     if (!hv_syndbg_handler) {
969         return 0;
970     }
971 
972     msg.type = HV_SYNDBG_MSG_QUERY_OPTIONS;
973     if (hv_syndbg_handler(hv_syndbg_context, &msg) != HV_STATUS_SUCCESS) {
974         return 0;
975     }
976 
977     return msg.u.query_options.options;
978 }
979 
980 static bool vmbus_recommended_features_enabled;
981 
982 bool hyperv_are_vmbus_recommended_features_enabled(void)
983 {
984     return vmbus_recommended_features_enabled;
985 }
986 
987 void hyperv_set_vmbus_recommended_features_enabled(void)
988 {
989     vmbus_recommended_features_enabled = true;
990 }
991