2 * Copyright (c) 2018 Citrix Systems Inc.
4 * This work is licensed under the terms of the GNU GPL, version 2 or later.
5 * See the COPYING file in the top-level directory.
8 #include "qemu/osdep.h"
9 #include "qemu/main-loop.h"
10 #include "qemu/module.h"
11 #include "qemu/uuid.h"
12 #include "hw/qdev-properties.h"
13 #include "hw/sysbus.h"
14 #include "hw/xen/xen.h"
15 #include "hw/xen/xen-backend.h"
16 #include "hw/xen/xen-bus.h"
17 #include "hw/xen/xen-bus-helper.h"
18 #include "monitor/monitor.h"
19 #include "qapi/error.h"
20 #include "qapi/qmp/qdict.h"
21 #include "sysemu/sysemu.h"
24 static char *xen_device_get_backend_path(XenDevice
*xendev
)
26 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
27 XenDeviceClass
*xendev_class
= XEN_DEVICE_GET_CLASS(xendev
);
28 const char *type
= object_get_typename(OBJECT(xendev
));
29 const char *backend
= xendev_class
->backend
;
35 return g_strdup_printf("/local/domain/%u/backend/%s/%u/%s",
36 xenbus
->backend_id
, backend
, xendev
->frontend_id
,
40 static char *xen_device_get_frontend_path(XenDevice
*xendev
)
42 XenDeviceClass
*xendev_class
= XEN_DEVICE_GET_CLASS(xendev
);
43 const char *type
= object_get_typename(OBJECT(xendev
));
44 const char *device
= xendev_class
->device
;
50 return g_strdup_printf("/local/domain/%u/device/%s/%s",
51 xendev
->frontend_id
, device
, xendev
->name
);
54 static void xen_device_unplug(XenDevice
*xendev
, Error
**errp
)
57 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
58 const char *type
= object_get_typename(OBJECT(xendev
));
61 trace_xen_device_unplug(type
, xendev
->name
);
63 /* Mimic the way the Xen toolstack does an unplug */
65 tid
= qemu_xen_xs_transaction_start(xenbus
->xsh
);
66 if (tid
== XBT_NULL
) {
67 error_setg_errno(errp
, errno
, "failed xs_transaction_start");
71 xs_node_printf(xenbus
->xsh
, tid
, xendev
->backend_path
, "online",
77 xs_node_printf(xenbus
->xsh
, tid
, xendev
->backend_path
, "state",
78 errp
, "%u", XenbusStateClosing
);
83 if (!qemu_xen_xs_transaction_end(xenbus
->xsh
, tid
, false)) {
84 if (errno
== EAGAIN
) {
88 error_setg_errno(errp
, errno
, "failed xs_transaction_end");
95 * We only abort if there is already a failure so ignore any error
96 * from ending the transaction.
98 qemu_xen_xs_transaction_end(xenbus
->xsh
, tid
, true);
101 static void xen_bus_print_dev(Monitor
*mon
, DeviceState
*dev
, int indent
)
103 XenDevice
*xendev
= XEN_DEVICE(dev
);
105 monitor_printf(mon
, "%*sname = '%s' frontend_id = %u\n",
106 indent
, "", xendev
->name
, xendev
->frontend_id
);
109 static char *xen_bus_get_dev_path(DeviceState
*dev
)
111 return xen_device_get_backend_path(XEN_DEVICE(dev
));
114 static void xen_bus_backend_create(XenBus
*xenbus
, const char *type
,
115 const char *name
, char *path
,
119 xs_transaction_t tid
;
124 trace_xen_bus_backend_create(type
, path
);
127 tid
= qemu_xen_xs_transaction_start(xenbus
->xsh
);
128 if (tid
== XBT_NULL
) {
129 error_setg(errp
, "failed xs_transaction_start");
133 key
= qemu_xen_xs_directory(xenbus
->xsh
, tid
, path
, &n
);
135 if (!qemu_xen_xs_transaction_end(xenbus
->xsh
, tid
, true)) {
136 error_setg_errno(errp
, errno
, "failed xs_transaction_end");
142 for (i
= 0; i
< n
; i
++) {
146 * Assume anything found in the xenstore backend area, other than
147 * the keys created for a generic XenDevice, are parameters
148 * to be used to configure the backend.
150 if (!strcmp(key
[i
], "state") ||
151 !strcmp(key
[i
], "online") ||
152 !strcmp(key
[i
], "frontend") ||
153 !strcmp(key
[i
], "frontend-id") ||
154 !strcmp(key
[i
], "hotplug-status"))
157 if (xs_node_scanf(xenbus
->xsh
, tid
, path
, key
[i
], NULL
, "%ms",
159 qdict_put_str(opts
, key
[i
], val
);
166 if (!qemu_xen_xs_transaction_end(xenbus
->xsh
, tid
, false)) {
169 if (errno
== EAGAIN
) {
173 error_setg_errno(errp
, errno
, "failed xs_transaction_end");
177 xen_backend_device_create(xenbus
, type
, name
, opts
, errp
);
181 error_prepend(errp
, "failed to create '%s' device '%s': ", type
, name
);
185 static void xen_bus_type_enumerate(XenBus
*xenbus
, const char *type
)
187 char *domain_path
= g_strdup_printf("backend/%s/%u", type
, xen_domid
);
191 trace_xen_bus_type_enumerate(type
);
193 backend
= qemu_xen_xs_directory(xenbus
->xsh
, XBT_NULL
, domain_path
, &n
);
198 for (i
= 0; i
< n
; i
++) {
199 char *backend_path
= g_strdup_printf("%s/%s", domain_path
,
201 enum xenbus_state state
;
204 if (xs_node_scanf(xenbus
->xsh
, XBT_NULL
, backend_path
, "state",
205 NULL
, "%u", &state
) != 1)
206 state
= XenbusStateUnknown
;
208 if (xs_node_scanf(xenbus
->xsh
, XBT_NULL
, backend_path
, "online",
209 NULL
, "%u", &online
) != 1)
212 if (online
&& state
== XenbusStateInitialising
) {
213 Error
*local_err
= NULL
;
215 xen_bus_backend_create(xenbus
, type
, backend
[i
], backend_path
,
218 error_report_err(local_err
);
222 g_free(backend_path
);
231 static void xen_bus_enumerate(XenBus
*xenbus
)
236 trace_xen_bus_enumerate();
238 type
= qemu_xen_xs_directory(xenbus
->xsh
, XBT_NULL
, "backend", &n
);
243 for (i
= 0; i
< n
; i
++) {
244 xen_bus_type_enumerate(xenbus
, type
[i
]);
250 static void xen_bus_device_cleanup(XenDevice
*xendev
)
252 const char *type
= object_get_typename(OBJECT(xendev
));
253 Error
*local_err
= NULL
;
255 trace_xen_bus_device_cleanup(type
, xendev
->name
);
257 g_assert(!xendev
->backend_online
);
259 if (!xen_backend_try_device_destroy(xendev
, &local_err
)) {
260 object_unparent(OBJECT(xendev
));
264 error_report_err(local_err
);
268 static void xen_bus_cleanup(XenBus
*xenbus
)
270 XenDevice
*xendev
, *next
;
272 trace_xen_bus_cleanup();
274 QLIST_FOREACH_SAFE(xendev
, &xenbus
->inactive_devices
, list
, next
) {
275 g_assert(xendev
->inactive
);
276 QLIST_REMOVE(xendev
, list
);
277 xen_bus_device_cleanup(xendev
);
281 static void xen_bus_backend_changed(void *opaque
, const char *path
)
283 XenBus
*xenbus
= opaque
;
285 xen_bus_enumerate(xenbus
);
286 xen_bus_cleanup(xenbus
);
289 static void xen_bus_unrealize(BusState
*bus
)
291 XenBus
*xenbus
= XEN_BUS(bus
);
293 trace_xen_bus_unrealize();
295 if (xenbus
->backend_watch
) {
298 for (i
= 0; i
< xenbus
->backend_types
; i
++) {
299 if (xenbus
->backend_watch
[i
]) {
300 xs_node_unwatch(xenbus
->xsh
, xenbus
->backend_watch
[i
]);
304 g_free(xenbus
->backend_watch
);
305 xenbus
->backend_watch
= NULL
;
309 qemu_xen_xs_close(xenbus
->xsh
);
313 static void xen_bus_realize(BusState
*bus
, Error
**errp
)
315 char *key
= g_strdup_printf("%u", xen_domid
);
316 XenBus
*xenbus
= XEN_BUS(bus
);
320 Error
*local_err
= NULL
;
322 trace_xen_bus_realize();
324 xenbus
->xsh
= qemu_xen_xs_open();
326 error_setg_errno(errp
, errno
, "failed xs_open");
330 if (xs_node_scanf(xenbus
->xsh
, XBT_NULL
, "", /* domain root node */
331 "domid", NULL
, "%u", &domid
) == 1) {
332 xenbus
->backend_id
= domid
;
334 xenbus
->backend_id
= 0; /* Assume lack of node means dom0 */
337 module_call_init(MODULE_INIT_XEN_BACKEND
);
339 type
= xen_backend_get_types(&xenbus
->backend_types
);
340 xenbus
->backend_watch
= g_new(struct qemu_xs_watch
*,
341 xenbus
->backend_types
);
343 for (i
= 0; i
< xenbus
->backend_types
; i
++) {
344 char *node
= g_strdup_printf("backend/%s", type
[i
]);
346 xenbus
->backend_watch
[i
] =
347 xs_node_watch(xenbus
->xsh
, node
, key
, xen_bus_backend_changed
,
350 /* This need not be treated as a hard error so don't propagate */
351 error_reportf_err(local_err
,
352 "failed to set up '%s' enumeration watch: ",
364 xen_bus_unrealize(bus
);
368 static void xen_bus_unplug_request(HotplugHandler
*hotplug
,
372 XenDevice
*xendev
= XEN_DEVICE(dev
);
374 xen_device_unplug(xendev
, errp
);
377 static void xen_bus_class_init(ObjectClass
*class, void *data
)
379 BusClass
*bus_class
= BUS_CLASS(class);
380 HotplugHandlerClass
*hotplug_class
= HOTPLUG_HANDLER_CLASS(class);
382 bus_class
->print_dev
= xen_bus_print_dev
;
383 bus_class
->get_dev_path
= xen_bus_get_dev_path
;
384 bus_class
->realize
= xen_bus_realize
;
385 bus_class
->unrealize
= xen_bus_unrealize
;
387 hotplug_class
->unplug_request
= xen_bus_unplug_request
;
390 static const TypeInfo xen_bus_type_info
= {
391 .name
= TYPE_XEN_BUS
,
393 .instance_size
= sizeof(XenBus
),
394 .class_size
= sizeof(XenBusClass
),
395 .class_init
= xen_bus_class_init
,
396 .interfaces
= (InterfaceInfo
[]) {
397 { TYPE_HOTPLUG_HANDLER
},
402 void xen_device_backend_printf(XenDevice
*xendev
, const char *key
,
403 const char *fmt
, ...)
405 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
406 Error
*local_err
= NULL
;
409 g_assert(xenbus
->xsh
);
412 xs_node_vprintf(xenbus
->xsh
, XBT_NULL
, xendev
->backend_path
, key
,
413 &local_err
, fmt
, ap
);
417 error_report_err(local_err
);
422 static int xen_device_backend_scanf(XenDevice
*xendev
, const char *key
,
423 const char *fmt
, ...)
425 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
429 g_assert(xenbus
->xsh
);
432 rc
= xs_node_vscanf(xenbus
->xsh
, XBT_NULL
, xendev
->backend_path
, key
,
439 void xen_device_backend_set_state(XenDevice
*xendev
,
440 enum xenbus_state state
)
442 const char *type
= object_get_typename(OBJECT(xendev
));
444 if (xendev
->backend_state
== state
) {
448 trace_xen_device_backend_state(type
, xendev
->name
,
451 xendev
->backend_state
= state
;
452 xen_device_backend_printf(xendev
, "state", "%u", state
);
455 enum xenbus_state
xen_device_backend_get_state(XenDevice
*xendev
)
457 return xendev
->backend_state
;
460 static void xen_device_backend_set_online(XenDevice
*xendev
, bool online
)
462 const char *type
= object_get_typename(OBJECT(xendev
));
464 if (xendev
->backend_online
== online
) {
468 trace_xen_device_backend_online(type
, xendev
->name
, online
);
470 xendev
->backend_online
= online
;
471 xen_device_backend_printf(xendev
, "online", "%u", online
);
475 * Tell from the state whether the frontend is likely alive,
476 * i.e. it will react to a change of state of the backend.
478 static bool xen_device_frontend_is_active(XenDevice
*xendev
)
480 switch (xendev
->frontend_state
) {
481 case XenbusStateInitWait
:
482 case XenbusStateInitialised
:
483 case XenbusStateConnected
:
484 case XenbusStateClosing
:
491 static void xen_device_backend_changed(void *opaque
, const char *path
)
493 XenDevice
*xendev
= opaque
;
494 const char *type
= object_get_typename(OBJECT(xendev
));
495 enum xenbus_state state
;
498 trace_xen_device_backend_changed(type
, xendev
->name
);
500 if (xen_device_backend_scanf(xendev
, "state", "%u", &state
) != 1) {
501 state
= XenbusStateUnknown
;
504 xen_device_backend_set_state(xendev
, state
);
506 if (xen_device_backend_scanf(xendev
, "online", "%u", &online
) != 1) {
510 xen_device_backend_set_online(xendev
, !!online
);
513 * If the toolstack (or unplug request callback) has set the backend
514 * state to Closing, but there is no active frontend then set the
515 * backend state to Closed.
517 if (state
== XenbusStateClosing
&&
518 !xen_device_frontend_is_active(xendev
)) {
519 xen_device_backend_set_state(xendev
, XenbusStateClosed
);
523 * If a backend is still 'online' then we should leave it alone but,
524 * if a backend is not 'online', then the device is a candidate
525 * for destruction. Hence add it to the 'inactive' list to be cleaned
526 * by xen_bus_cleanup().
529 (state
== XenbusStateClosed
|| state
== XenbusStateInitialising
||
530 state
== XenbusStateInitWait
|| state
== XenbusStateUnknown
) &&
532 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
534 xendev
->inactive
= true;
535 QLIST_INSERT_HEAD(&xenbus
->inactive_devices
, xendev
, list
);
538 * Re-write the state to cause a XenBus backend_watch notification,
539 * resulting in a call to xen_bus_cleanup().
541 xen_device_backend_printf(xendev
, "state", "%u", state
);
545 static void xen_device_backend_create(XenDevice
*xendev
, Error
**errp
)
548 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
550 xendev
->backend_path
= xen_device_get_backend_path(xendev
);
552 g_assert(xenbus
->xsh
);
554 xs_node_create(xenbus
->xsh
, XBT_NULL
, xendev
->backend_path
,
555 xenbus
->backend_id
, xendev
->frontend_id
, XS_PERM_READ
, errp
);
557 error_prepend(errp
, "failed to create backend: ");
561 xendev
->backend_state_watch
=
562 xs_node_watch(xendev
->xsh
, xendev
->backend_path
,
563 "state", xen_device_backend_changed
, xendev
,
566 error_prepend(errp
, "failed to watch backend state: ");
570 xendev
->backend_online_watch
=
571 xs_node_watch(xendev
->xsh
, xendev
->backend_path
,
572 "online", xen_device_backend_changed
, xendev
,
575 error_prepend(errp
, "failed to watch backend online: ");
580 static void xen_device_backend_destroy(XenDevice
*xendev
)
582 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
583 Error
*local_err
= NULL
;
585 if (xendev
->backend_online_watch
) {
586 xs_node_unwatch(xendev
->xsh
, xendev
->backend_online_watch
);
587 xendev
->backend_online_watch
= NULL
;
590 if (xendev
->backend_state_watch
) {
591 xs_node_unwatch(xendev
->xsh
, xendev
->backend_state_watch
);
592 xendev
->backend_state_watch
= NULL
;
595 if (!xendev
->backend_path
) {
599 g_assert(xenbus
->xsh
);
601 xs_node_destroy(xenbus
->xsh
, XBT_NULL
, xendev
->backend_path
,
603 g_free(xendev
->backend_path
);
604 xendev
->backend_path
= NULL
;
607 error_report_err(local_err
);
611 void xen_device_frontend_printf(XenDevice
*xendev
, const char *key
,
612 const char *fmt
, ...)
614 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
615 Error
*local_err
= NULL
;
618 g_assert(xenbus
->xsh
);
621 xs_node_vprintf(xenbus
->xsh
, XBT_NULL
, xendev
->frontend_path
, key
,
622 &local_err
, fmt
, ap
);
626 error_report_err(local_err
);
630 int xen_device_frontend_scanf(XenDevice
*xendev
, const char *key
,
631 const char *fmt
, ...)
633 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
637 g_assert(xenbus
->xsh
);
640 rc
= xs_node_vscanf(xenbus
->xsh
, XBT_NULL
, xendev
->frontend_path
, key
,
647 static void xen_device_frontend_set_state(XenDevice
*xendev
,
648 enum xenbus_state state
,
651 const char *type
= object_get_typename(OBJECT(xendev
));
653 if (xendev
->frontend_state
== state
) {
657 trace_xen_device_frontend_state(type
, xendev
->name
,
660 xendev
->frontend_state
= state
;
662 xen_device_frontend_printf(xendev
, "state", "%u", state
);
666 static void xen_device_frontend_changed(void *opaque
, const char *path
)
668 XenDevice
*xendev
= opaque
;
669 XenDeviceClass
*xendev_class
= XEN_DEVICE_GET_CLASS(xendev
);
670 const char *type
= object_get_typename(OBJECT(xendev
));
671 enum xenbus_state state
;
673 trace_xen_device_frontend_changed(type
, xendev
->name
);
675 if (xen_device_frontend_scanf(xendev
, "state", "%u", &state
) != 1) {
676 state
= XenbusStateUnknown
;
679 xen_device_frontend_set_state(xendev
, state
, false);
681 if (state
== XenbusStateInitialising
&&
682 xendev
->backend_state
== XenbusStateClosed
&&
683 xendev
->backend_online
) {
685 * The frontend is re-initializing so switch back to
688 xen_device_backend_set_state(xendev
, XenbusStateInitWait
);
692 if (xendev_class
->frontend_changed
) {
693 Error
*local_err
= NULL
;
695 xendev_class
->frontend_changed(xendev
, state
, &local_err
);
698 error_reportf_err(local_err
, "frontend change error: ");
703 static bool xen_device_frontend_exists(XenDevice
*xendev
)
705 enum xenbus_state state
;
707 return (xen_device_frontend_scanf(xendev
, "state", "%u", &state
) == 1);
710 static void xen_device_frontend_create(XenDevice
*xendev
, Error
**errp
)
713 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
715 xendev
->frontend_path
= xen_device_get_frontend_path(xendev
);
718 * The frontend area may have already been created by a legacy
721 if (!xen_device_frontend_exists(xendev
)) {
722 g_assert(xenbus
->xsh
);
724 xs_node_create(xenbus
->xsh
, XBT_NULL
, xendev
->frontend_path
,
725 xendev
->frontend_id
, xenbus
->backend_id
,
726 XS_PERM_READ
| XS_PERM_WRITE
, errp
);
728 error_prepend(errp
, "failed to create frontend: ");
733 xendev
->frontend_state_watch
=
734 xs_node_watch(xendev
->xsh
, xendev
->frontend_path
, "state",
735 xen_device_frontend_changed
, xendev
, errp
);
737 error_prepend(errp
, "failed to watch frontend state: ");
741 static void xen_device_frontend_destroy(XenDevice
*xendev
)
743 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
744 Error
*local_err
= NULL
;
746 if (xendev
->frontend_state_watch
) {
747 xs_node_unwatch(xendev
->xsh
, xendev
->frontend_state_watch
);
748 xendev
->frontend_state_watch
= NULL
;
751 if (!xendev
->frontend_path
) {
755 g_assert(xenbus
->xsh
);
757 xs_node_destroy(xenbus
->xsh
, XBT_NULL
, xendev
->frontend_path
,
759 g_free(xendev
->frontend_path
);
760 xendev
->frontend_path
= NULL
;
763 error_report_err(local_err
);
767 void xen_device_set_max_grant_refs(XenDevice
*xendev
, unsigned int nr_refs
,
770 if (qemu_xen_gnttab_set_max_grants(xendev
->xgth
, nr_refs
)) {
771 error_setg_errno(errp
, errno
, "xengnttab_set_max_grants failed");
775 void *xen_device_map_grant_refs(XenDevice
*xendev
, uint32_t *refs
,
776 unsigned int nr_refs
, int prot
,
779 void *map
= qemu_xen_gnttab_map_refs(xendev
->xgth
, nr_refs
,
780 xendev
->frontend_id
, refs
, prot
);
783 error_setg_errno(errp
, errno
,
784 "xengnttab_map_domain_grant_refs failed");
790 void xen_device_unmap_grant_refs(XenDevice
*xendev
, void *map
, uint32_t *refs
,
791 unsigned int nr_refs
, Error
**errp
)
793 if (qemu_xen_gnttab_unmap(xendev
->xgth
, map
, refs
, nr_refs
)) {
794 error_setg_errno(errp
, errno
, "xengnttab_unmap failed");
798 void xen_device_copy_grant_refs(XenDevice
*xendev
, bool to_domain
,
799 XenDeviceGrantCopySegment segs
[],
800 unsigned int nr_segs
, Error
**errp
)
802 qemu_xen_gnttab_grant_copy(xendev
->xgth
, to_domain
, xendev
->frontend_id
,
803 (XenGrantCopySegment
*)segs
, nr_segs
, errp
);
806 struct XenEventChannel
{
807 QLIST_ENTRY(XenEventChannel
) list
;
809 xenevtchn_handle
*xeh
;
810 evtchn_port_t local_port
;
811 XenEventHandler handler
;
815 static bool xen_device_poll(void *opaque
)
817 XenEventChannel
*channel
= opaque
;
819 return channel
->handler(channel
->opaque
);
822 static void xen_device_event(void *opaque
)
824 XenEventChannel
*channel
= opaque
;
825 unsigned long port
= qemu_xen_evtchn_pending(channel
->xeh
);
827 if (port
== channel
->local_port
) {
828 xen_device_poll(channel
);
830 qemu_xen_evtchn_unmask(channel
->xeh
, port
);
834 void xen_device_set_event_channel_context(XenDevice
*xendev
,
835 XenEventChannel
*channel
,
840 error_setg(errp
, "bad channel");
845 aio_set_fd_handler(channel
->ctx
, qemu_xen_evtchn_fd(channel
->xeh
), true,
846 NULL
, NULL
, NULL
, NULL
, NULL
);
850 aio_set_fd_handler(channel
->ctx
, qemu_xen_evtchn_fd(channel
->xeh
),
851 true, xen_device_event
, NULL
, xen_device_poll
, NULL
,
856 XenEventChannel
*xen_device_bind_event_channel(XenDevice
*xendev
,
858 XenEventHandler handler
,
859 void *opaque
, Error
**errp
)
861 XenEventChannel
*channel
= g_new0(XenEventChannel
, 1);
862 xenevtchn_port_or_error_t local_port
;
864 channel
->xeh
= qemu_xen_evtchn_open();
866 error_setg_errno(errp
, errno
, "failed xenevtchn_open");
870 local_port
= qemu_xen_evtchn_bind_interdomain(channel
->xeh
,
873 if (local_port
< 0) {
874 error_setg_errno(errp
, errno
, "xenevtchn_bind_interdomain failed");
878 channel
->local_port
= local_port
;
879 channel
->handler
= handler
;
880 channel
->opaque
= opaque
;
882 /* Only reason for failure is a NULL channel */
883 xen_device_set_event_channel_context(xendev
, channel
,
884 qemu_get_aio_context(),
887 QLIST_INSERT_HEAD(&xendev
->event_channels
, channel
, list
);
893 qemu_xen_evtchn_close(channel
->xeh
);
901 void xen_device_notify_event_channel(XenDevice
*xendev
,
902 XenEventChannel
*channel
,
906 error_setg(errp
, "bad channel");
910 if (qemu_xen_evtchn_notify(channel
->xeh
, channel
->local_port
) < 0) {
911 error_setg_errno(errp
, errno
, "xenevtchn_notify failed");
915 void xen_device_unbind_event_channel(XenDevice
*xendev
,
916 XenEventChannel
*channel
,
920 error_setg(errp
, "bad channel");
924 QLIST_REMOVE(channel
, list
);
926 aio_set_fd_handler(channel
->ctx
, qemu_xen_evtchn_fd(channel
->xeh
), true,
927 NULL
, NULL
, NULL
, NULL
, NULL
);
929 if (qemu_xen_evtchn_unbind(channel
->xeh
, channel
->local_port
) < 0) {
930 error_setg_errno(errp
, errno
, "xenevtchn_unbind failed");
933 qemu_xen_evtchn_close(channel
->xeh
);
937 static void xen_device_unrealize(DeviceState
*dev
)
939 XenDevice
*xendev
= XEN_DEVICE(dev
);
940 XenDeviceClass
*xendev_class
= XEN_DEVICE_GET_CLASS(xendev
);
941 const char *type
= object_get_typename(OBJECT(xendev
));
942 XenEventChannel
*channel
, *next
;
948 trace_xen_device_unrealize(type
, xendev
->name
);
950 if (xendev
->exit
.notify
) {
951 qemu_remove_exit_notifier(&xendev
->exit
);
952 xendev
->exit
.notify
= NULL
;
955 if (xendev_class
->unrealize
) {
956 xendev_class
->unrealize(xendev
);
959 /* Make sure all event channels are cleaned up */
960 QLIST_FOREACH_SAFE(channel
, &xendev
->event_channels
, list
, next
) {
961 xen_device_unbind_event_channel(xendev
, channel
, NULL
);
964 xen_device_frontend_destroy(xendev
);
965 xen_device_backend_destroy(xendev
);
968 qemu_xen_gnttab_close(xendev
->xgth
);
973 qemu_xen_xs_close(xendev
->xsh
);
977 g_free(xendev
->name
);
981 static void xen_device_exit(Notifier
*n
, void *data
)
983 XenDevice
*xendev
= container_of(n
, XenDevice
, exit
);
985 xen_device_unrealize(DEVICE(xendev
));
988 static void xen_device_realize(DeviceState
*dev
, Error
**errp
)
991 XenDevice
*xendev
= XEN_DEVICE(dev
);
992 XenDeviceClass
*xendev_class
= XEN_DEVICE_GET_CLASS(xendev
);
993 XenBus
*xenbus
= XEN_BUS(qdev_get_parent_bus(DEVICE(xendev
)));
994 const char *type
= object_get_typename(OBJECT(xendev
));
996 if (xendev
->frontend_id
== DOMID_INVALID
) {
997 xendev
->frontend_id
= xen_domid
;
1000 if (xendev
->frontend_id
>= DOMID_FIRST_RESERVED
) {
1001 error_setg(errp
, "invalid frontend-id");
1005 if (!xendev_class
->get_name
) {
1006 error_setg(errp
, "get_name method not implemented");
1010 xendev
->name
= xendev_class
->get_name(xendev
, errp
);
1012 error_prepend(errp
, "failed to get device name: ");
1016 trace_xen_device_realize(type
, xendev
->name
);
1018 xendev
->xsh
= qemu_xen_xs_open();
1020 error_setg_errno(errp
, errno
, "failed xs_open");
1024 xendev
->xgth
= qemu_xen_gnttab_open();
1025 if (!xendev
->xgth
) {
1026 error_setg_errno(errp
, errno
, "failed xengnttab_open");
1030 xen_device_backend_create(xendev
, errp
);
1035 xen_device_frontend_create(xendev
, errp
);
1040 xen_device_backend_printf(xendev
, "frontend", "%s",
1041 xendev
->frontend_path
);
1042 xen_device_backend_printf(xendev
, "frontend-id", "%u",
1043 xendev
->frontend_id
);
1044 xen_device_backend_printf(xendev
, "hotplug-status", "connected");
1046 xen_device_backend_set_online(xendev
, true);
1047 xen_device_backend_set_state(xendev
, XenbusStateInitWait
);
1049 if (!xen_device_frontend_exists(xendev
)) {
1050 xen_device_frontend_printf(xendev
, "backend", "%s",
1051 xendev
->backend_path
);
1052 xen_device_frontend_printf(xendev
, "backend-id", "%u",
1053 xenbus
->backend_id
);
1055 xen_device_frontend_set_state(xendev
, XenbusStateInitialising
, true);
1058 if (xendev_class
->realize
) {
1059 xendev_class
->realize(xendev
, errp
);
1065 xendev
->exit
.notify
= xen_device_exit
;
1066 qemu_add_exit_notifier(&xendev
->exit
);
1070 xen_device_unrealize(dev
);
1073 static Property xen_device_props
[] = {
1074 DEFINE_PROP_UINT16("frontend-id", XenDevice
, frontend_id
,
1076 DEFINE_PROP_END_OF_LIST()
1079 static void xen_device_class_init(ObjectClass
*class, void *data
)
1081 DeviceClass
*dev_class
= DEVICE_CLASS(class);
1083 dev_class
->realize
= xen_device_realize
;
1084 dev_class
->unrealize
= xen_device_unrealize
;
1085 device_class_set_props(dev_class
, xen_device_props
);
1086 dev_class
->bus_type
= TYPE_XEN_BUS
;
1089 static const TypeInfo xen_device_type_info
= {
1090 .name
= TYPE_XEN_DEVICE
,
1091 .parent
= TYPE_DEVICE
,
1092 .instance_size
= sizeof(XenDevice
),
1094 .class_size
= sizeof(XenDeviceClass
),
1095 .class_init
= xen_device_class_init
,
1098 typedef struct XenBridge
{
1099 SysBusDevice busdev
;
1102 #define TYPE_XEN_BRIDGE "xen-bridge"
1104 static const TypeInfo xen_bridge_type_info
= {
1105 .name
= TYPE_XEN_BRIDGE
,
1106 .parent
= TYPE_SYS_BUS_DEVICE
,
1107 .instance_size
= sizeof(XenBridge
),
1110 static void xen_register_types(void)
1112 type_register_static(&xen_bridge_type_info
);
1113 type_register_static(&xen_bus_type_info
);
1114 type_register_static(&xen_device_type_info
);
1117 type_init(xen_register_types
)
1119 void xen_bus_init(void)
1121 DeviceState
*dev
= qdev_new(TYPE_XEN_BRIDGE
);
1122 BusState
*bus
= qbus_new(TYPE_XEN_BUS
, dev
, NULL
);
1124 sysbus_realize_and_unref(SYS_BUS_DEVICE(dev
), &error_fatal
);
1125 qbus_set_bus_hotplug_handler(bus
);