xref: /openbmc/qemu/hw/xen/xen-bus.c (revision 423edd9a)
1 /*
2  * Copyright (c) 2018  Citrix Systems Inc.
3  *
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.
6  */
7 
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"
22 #include "trace.h"
23 
24 static char *xen_device_get_backend_path(XenDevice *xendev)
25 {
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;
30 
31     if (!backend) {
32         backend = type;
33     }
34 
35     return g_strdup_printf("/local/domain/%u/backend/%s/%u/%s",
36                            xenbus->backend_id, backend, xendev->frontend_id,
37                            xendev->name);
38 }
39 
40 static char *xen_device_get_frontend_path(XenDevice *xendev)
41 {
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;
45 
46     if (!device) {
47         device = type;
48     }
49 
50     return g_strdup_printf("/local/domain/%u/device/%s/%s",
51                            xendev->frontend_id, device, xendev->name);
52 }
53 
54 static void xen_device_unplug(XenDevice *xendev, Error **errp)
55 {
56     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
57     const char *type = object_get_typename(OBJECT(xendev));
58     Error *local_err = NULL;
59     xs_transaction_t tid;
60 
61     trace_xen_device_unplug(type, xendev->name);
62 
63     /* Mimic the way the Xen toolstack does an unplug */
64 again:
65     tid = xs_transaction_start(xenbus->xsh);
66     if (tid == XBT_NULL) {
67         error_setg_errno(errp, errno, "failed xs_transaction_start");
68         return;
69     }
70 
71     xs_node_printf(xenbus->xsh, tid, xendev->backend_path, "online",
72                    &local_err, "%u", 0);
73     if (local_err) {
74         goto abort;
75     }
76 
77     xs_node_printf(xenbus->xsh, tid, xendev->backend_path, "state",
78                    &local_err, "%u", XenbusStateClosing);
79     if (local_err) {
80         goto abort;
81     }
82 
83     if (!xs_transaction_end(xenbus->xsh, tid, false)) {
84         if (errno == EAGAIN) {
85             goto again;
86         }
87 
88         error_setg_errno(errp, errno, "failed xs_transaction_end");
89     }
90 
91     return;
92 
93 abort:
94     /*
95      * We only abort if there is already a failure so ignore any error
96      * from ending the transaction.
97      */
98     xs_transaction_end(xenbus->xsh, tid, true);
99     error_propagate(errp, local_err);
100 }
101 
102 static void xen_bus_print_dev(Monitor *mon, DeviceState *dev, int indent)
103 {
104     XenDevice *xendev = XEN_DEVICE(dev);
105 
106     monitor_printf(mon, "%*sname = '%s' frontend_id = %u\n",
107                    indent, "", xendev->name, xendev->frontend_id);
108 }
109 
110 static char *xen_bus_get_dev_path(DeviceState *dev)
111 {
112     return xen_device_get_backend_path(XEN_DEVICE(dev));
113 }
114 
115 struct XenWatch {
116     char *node, *key;
117     char *token;
118     XenWatchHandler handler;
119     void *opaque;
120     Notifier notifier;
121 };
122 
123 static void watch_notify(Notifier *n, void *data)
124 {
125     XenWatch *watch = container_of(n, XenWatch, notifier);
126     const char *token = data;
127 
128     if (!strcmp(watch->token, token)) {
129         watch->handler(watch->opaque);
130     }
131 }
132 
133 static XenWatch *new_watch(const char *node, const char *key,
134                            XenWatchHandler handler, void *opaque)
135 {
136     XenWatch *watch = g_new0(XenWatch, 1);
137     QemuUUID uuid;
138 
139     qemu_uuid_generate(&uuid);
140 
141     watch->token = qemu_uuid_unparse_strdup(&uuid);
142     watch->node = g_strdup(node);
143     watch->key = g_strdup(key);
144     watch->handler = handler;
145     watch->opaque = opaque;
146     watch->notifier.notify = watch_notify;
147 
148     return watch;
149 }
150 
151 static void free_watch(XenWatch *watch)
152 {
153     g_free(watch->token);
154     g_free(watch->key);
155     g_free(watch->node);
156 
157     g_free(watch);
158 }
159 
160 struct XenWatchList {
161     struct xs_handle *xsh;
162     NotifierList notifiers;
163 };
164 
165 static void watch_list_event(void *opaque)
166 {
167     XenWatchList *watch_list = opaque;
168     char **v;
169     const char *token;
170 
171     v = xs_check_watch(watch_list->xsh);
172     if (!v) {
173         return;
174     }
175 
176     token = v[XS_WATCH_TOKEN];
177 
178     notifier_list_notify(&watch_list->notifiers, (void *)token);
179 
180     free(v);
181 }
182 
183 static XenWatchList *watch_list_create(struct xs_handle *xsh)
184 {
185     XenWatchList *watch_list = g_new0(XenWatchList, 1);
186 
187     g_assert(xsh);
188 
189     watch_list->xsh = xsh;
190     notifier_list_init(&watch_list->notifiers);
191     qemu_set_fd_handler(xs_fileno(watch_list->xsh), watch_list_event, NULL,
192                         watch_list);
193 
194     return watch_list;
195 }
196 
197 static void watch_list_destroy(XenWatchList *watch_list)
198 {
199     g_assert(notifier_list_empty(&watch_list->notifiers));
200     qemu_set_fd_handler(xs_fileno(watch_list->xsh), NULL, NULL, NULL);
201     g_free(watch_list);
202 }
203 
204 static XenWatch *watch_list_add(XenWatchList *watch_list, const char *node,
205                                 const char *key, XenWatchHandler handler,
206                                 void *opaque, Error **errp)
207 {
208     XenWatch *watch = new_watch(node, key, handler, opaque);
209     Error *local_err = NULL;
210 
211     notifier_list_add(&watch_list->notifiers, &watch->notifier);
212 
213     xs_node_watch(watch_list->xsh, node, key, watch->token, &local_err);
214     if (local_err) {
215         error_propagate(errp, local_err);
216 
217         notifier_remove(&watch->notifier);
218         free_watch(watch);
219 
220         return NULL;
221     }
222 
223     return watch;
224 }
225 
226 static void watch_list_remove(XenWatchList *watch_list, XenWatch *watch,
227                               Error **errp)
228 {
229     xs_node_unwatch(watch_list->xsh, watch->node, watch->key, watch->token,
230                     errp);
231 
232     notifier_remove(&watch->notifier);
233     free_watch(watch);
234 }
235 
236 static XenWatch *xen_bus_add_watch(XenBus *xenbus, const char *node,
237                                    const char *key, XenWatchHandler handler,
238                                    Error **errp)
239 {
240     trace_xen_bus_add_watch(node, key);
241 
242     return watch_list_add(xenbus->watch_list, node, key, handler, xenbus,
243                           errp);
244 }
245 
246 static void xen_bus_remove_watch(XenBus *xenbus, XenWatch *watch,
247                                  Error **errp)
248 {
249     trace_xen_bus_remove_watch(watch->node, watch->key);
250 
251     watch_list_remove(xenbus->watch_list, watch, errp);
252 }
253 
254 static void xen_bus_backend_create(XenBus *xenbus, const char *type,
255                                    const char *name, char *path,
256                                    Error **errp)
257 {
258     xs_transaction_t tid;
259     char **key;
260     QDict *opts;
261     unsigned int i, n;
262     Error *local_err = NULL;
263 
264     trace_xen_bus_backend_create(type, path);
265 
266 again:
267     tid = xs_transaction_start(xenbus->xsh);
268     if (tid == XBT_NULL) {
269         error_setg(errp, "failed xs_transaction_start");
270         return;
271     }
272 
273     key = xs_directory(xenbus->xsh, tid, path, &n);
274     if (!key) {
275         if (!xs_transaction_end(xenbus->xsh, tid, true)) {
276             error_setg_errno(errp, errno, "failed xs_transaction_end");
277         }
278         return;
279     }
280 
281     opts = qdict_new();
282     for (i = 0; i < n; i++) {
283         char *val;
284 
285         /*
286          * Assume anything found in the xenstore backend area, other than
287          * the keys created for a generic XenDevice, are parameters
288          * to be used to configure the backend.
289          */
290         if (!strcmp(key[i], "state") ||
291             !strcmp(key[i], "online") ||
292             !strcmp(key[i], "frontend") ||
293             !strcmp(key[i], "frontend-id") ||
294             !strcmp(key[i], "hotplug-status"))
295             continue;
296 
297         if (xs_node_scanf(xenbus->xsh, tid, path, key[i], NULL, "%ms",
298                           &val) == 1) {
299             qdict_put_str(opts, key[i], val);
300             free(val);
301         }
302     }
303 
304     free(key);
305 
306     if (!xs_transaction_end(xenbus->xsh, tid, false)) {
307         qobject_unref(opts);
308 
309         if (errno == EAGAIN) {
310             goto again;
311         }
312 
313         error_setg_errno(errp, errno, "failed xs_transaction_end");
314         return;
315     }
316 
317     xen_backend_device_create(xenbus, type, name, opts, &local_err);
318     qobject_unref(opts);
319 
320     if (local_err) {
321         error_propagate_prepend(errp, local_err,
322                                 "failed to create '%s' device '%s': ",
323                                 type, name);
324     }
325 }
326 
327 static void xen_bus_type_enumerate(XenBus *xenbus, const char *type)
328 {
329     char *domain_path = g_strdup_printf("backend/%s/%u", type, xen_domid);
330     char **backend;
331     unsigned int i, n;
332 
333     trace_xen_bus_type_enumerate(type);
334 
335     backend = xs_directory(xenbus->xsh, XBT_NULL, domain_path, &n);
336     if (!backend) {
337         goto out;
338     }
339 
340     for (i = 0; i < n; i++) {
341         char *backend_path = g_strdup_printf("%s/%s", domain_path,
342                                              backend[i]);
343         enum xenbus_state state;
344         unsigned int online;
345 
346         if (xs_node_scanf(xenbus->xsh, XBT_NULL, backend_path, "state",
347                           NULL, "%u", &state) != 1)
348             state = XenbusStateUnknown;
349 
350         if (xs_node_scanf(xenbus->xsh, XBT_NULL, backend_path, "online",
351                           NULL, "%u", &online) != 1)
352             online = 0;
353 
354         if (online && state == XenbusStateInitialising) {
355             Error *local_err = NULL;
356 
357             xen_bus_backend_create(xenbus, type, backend[i], backend_path,
358                                    &local_err);
359             if (local_err) {
360                 error_report_err(local_err);
361             }
362         }
363 
364         g_free(backend_path);
365     }
366 
367     free(backend);
368 
369 out:
370     g_free(domain_path);
371 }
372 
373 static void xen_bus_enumerate(XenBus *xenbus)
374 {
375     char **type;
376     unsigned int i, n;
377 
378     trace_xen_bus_enumerate();
379 
380     type = xs_directory(xenbus->xsh, XBT_NULL, "backend", &n);
381     if (!type) {
382         return;
383     }
384 
385     for (i = 0; i < n; i++) {
386         xen_bus_type_enumerate(xenbus, type[i]);
387     }
388 
389     free(type);
390 }
391 
392 static void xen_bus_device_cleanup(XenDevice *xendev)
393 {
394     const char *type = object_get_typename(OBJECT(xendev));
395     Error *local_err = NULL;
396 
397     trace_xen_bus_device_cleanup(type, xendev->name);
398 
399     g_assert(!xendev->backend_online);
400 
401     if (!xen_backend_try_device_destroy(xendev, &local_err)) {
402         object_unparent(OBJECT(xendev));
403     }
404 
405     if (local_err) {
406         error_report_err(local_err);
407     }
408 }
409 
410 static void xen_bus_cleanup(XenBus *xenbus)
411 {
412     XenDevice *xendev, *next;
413 
414     trace_xen_bus_cleanup();
415 
416     QLIST_FOREACH_SAFE(xendev, &xenbus->inactive_devices, list, next) {
417         g_assert(xendev->inactive);
418         QLIST_REMOVE(xendev, list);
419         xen_bus_device_cleanup(xendev);
420     }
421 }
422 
423 static void xen_bus_backend_changed(void *opaque)
424 {
425     XenBus *xenbus = opaque;
426 
427     xen_bus_enumerate(xenbus);
428     xen_bus_cleanup(xenbus);
429 }
430 
431 static void xen_bus_unrealize(BusState *bus, Error **errp)
432 {
433     XenBus *xenbus = XEN_BUS(bus);
434 
435     trace_xen_bus_unrealize();
436 
437     if (xenbus->backend_watch) {
438         xen_bus_remove_watch(xenbus, xenbus->backend_watch, NULL);
439         xenbus->backend_watch = NULL;
440     }
441 
442     if (xenbus->watch_list) {
443         watch_list_destroy(xenbus->watch_list);
444         xenbus->watch_list = NULL;
445     }
446 
447     if (xenbus->xsh) {
448         xs_close(xenbus->xsh);
449     }
450 }
451 
452 static void xen_bus_realize(BusState *bus, Error **errp)
453 {
454     XenBus *xenbus = XEN_BUS(bus);
455     unsigned int domid;
456     Error *local_err = NULL;
457 
458     trace_xen_bus_realize();
459 
460     xenbus->xsh = xs_open(0);
461     if (!xenbus->xsh) {
462         error_setg_errno(errp, errno, "failed xs_open");
463         goto fail;
464     }
465 
466     if (xs_node_scanf(xenbus->xsh, XBT_NULL, "", /* domain root node */
467                       "domid", NULL, "%u", &domid) == 1) {
468         xenbus->backend_id = domid;
469     } else {
470         xenbus->backend_id = 0; /* Assume lack of node means dom0 */
471     }
472 
473     xenbus->watch_list = watch_list_create(xenbus->xsh);
474 
475     module_call_init(MODULE_INIT_XEN_BACKEND);
476 
477     xenbus->backend_watch =
478         xen_bus_add_watch(xenbus, "", /* domain root node */
479                           "backend", xen_bus_backend_changed, &local_err);
480     if (local_err) {
481         /* This need not be treated as a hard error so don't propagate */
482         error_reportf_err(local_err,
483                           "failed to set up enumeration watch: ");
484     }
485 
486     return;
487 
488 fail:
489     xen_bus_unrealize(bus, &error_abort);
490 }
491 
492 static void xen_bus_unplug_request(HotplugHandler *hotplug,
493                                    DeviceState *dev,
494                                    Error **errp)
495 {
496     XenDevice *xendev = XEN_DEVICE(dev);
497 
498     xen_device_unplug(xendev, errp);
499 }
500 
501 static void xen_bus_class_init(ObjectClass *class, void *data)
502 {
503     BusClass *bus_class = BUS_CLASS(class);
504     HotplugHandlerClass *hotplug_class = HOTPLUG_HANDLER_CLASS(class);
505 
506     bus_class->print_dev = xen_bus_print_dev;
507     bus_class->get_dev_path = xen_bus_get_dev_path;
508     bus_class->realize = xen_bus_realize;
509     bus_class->unrealize = xen_bus_unrealize;
510 
511     hotplug_class->unplug_request = xen_bus_unplug_request;
512 }
513 
514 static const TypeInfo xen_bus_type_info = {
515     .name = TYPE_XEN_BUS,
516     .parent = TYPE_BUS,
517     .instance_size = sizeof(XenBus),
518     .class_size = sizeof(XenBusClass),
519     .class_init = xen_bus_class_init,
520     .interfaces = (InterfaceInfo[]) {
521         { TYPE_HOTPLUG_HANDLER },
522         { }
523     },
524 };
525 
526 void xen_device_backend_printf(XenDevice *xendev, const char *key,
527                                const char *fmt, ...)
528 {
529     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
530     Error *local_err = NULL;
531     va_list ap;
532 
533     g_assert(xenbus->xsh);
534 
535     va_start(ap, fmt);
536     xs_node_vprintf(xenbus->xsh, XBT_NULL, xendev->backend_path, key,
537                     &local_err, fmt, ap);
538     va_end(ap);
539 
540     if (local_err) {
541         error_report_err(local_err);
542     }
543 }
544 
545 static int xen_device_backend_scanf(XenDevice *xendev, const char *key,
546                                     const char *fmt, ...)
547 {
548     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
549     va_list ap;
550     int rc;
551 
552     g_assert(xenbus->xsh);
553 
554     va_start(ap, fmt);
555     rc = xs_node_vscanf(xenbus->xsh, XBT_NULL, xendev->backend_path, key,
556                         NULL, fmt, ap);
557     va_end(ap);
558 
559     return rc;
560 }
561 
562 void xen_device_backend_set_state(XenDevice *xendev,
563                                   enum xenbus_state state)
564 {
565     const char *type = object_get_typename(OBJECT(xendev));
566 
567     if (xendev->backend_state == state) {
568         return;
569     }
570 
571     trace_xen_device_backend_state(type, xendev->name,
572                                    xs_strstate(state));
573 
574     xendev->backend_state = state;
575     xen_device_backend_printf(xendev, "state", "%u", state);
576 }
577 
578 enum xenbus_state xen_device_backend_get_state(XenDevice *xendev)
579 {
580     return xendev->backend_state;
581 }
582 
583 static void xen_device_backend_set_online(XenDevice *xendev, bool online)
584 {
585     const char *type = object_get_typename(OBJECT(xendev));
586 
587     if (xendev->backend_online == online) {
588         return;
589     }
590 
591     trace_xen_device_backend_online(type, xendev->name, online);
592 
593     xendev->backend_online = online;
594     xen_device_backend_printf(xendev, "online", "%u", online);
595 }
596 
597 /*
598  * Tell from the state whether the frontend is likely alive,
599  * i.e. it will react to a change of state of the backend.
600  */
601 static bool xen_device_frontend_is_active(XenDevice *xendev)
602 {
603     switch (xendev->frontend_state) {
604     case XenbusStateInitWait:
605     case XenbusStateInitialised:
606     case XenbusStateConnected:
607     case XenbusStateClosing:
608         return true;
609     default:
610         return false;
611     }
612 }
613 
614 static void xen_device_backend_changed(void *opaque)
615 {
616     XenDevice *xendev = opaque;
617     const char *type = object_get_typename(OBJECT(xendev));
618     enum xenbus_state state;
619     unsigned int online;
620 
621     trace_xen_device_backend_changed(type, xendev->name);
622 
623     if (xen_device_backend_scanf(xendev, "state", "%u", &state) != 1) {
624         state = XenbusStateUnknown;
625     }
626 
627     xen_device_backend_set_state(xendev, state);
628 
629     if (xen_device_backend_scanf(xendev, "online", "%u", &online) != 1) {
630         online = 0;
631     }
632 
633     xen_device_backend_set_online(xendev, !!online);
634 
635     /*
636      * If the toolstack (or unplug request callback) has set the backend
637      * state to Closing, but there is no active frontend then set the
638      * backend state to Closed.
639      */
640     if (state == XenbusStateClosing &&
641         !xen_device_frontend_is_active(xendev)) {
642         xen_device_backend_set_state(xendev, XenbusStateClosed);
643     }
644 
645     /*
646      * If a backend is still 'online' then we should leave it alone but,
647      * if a backend is not 'online', then the device is a candidate
648      * for destruction. Hence add it to the 'inactive' list to be cleaned
649      * by xen_bus_cleanup().
650      */
651     if (!online &&
652         (state == XenbusStateClosed ||  state == XenbusStateInitialising ||
653          state == XenbusStateInitWait || state == XenbusStateUnknown) &&
654         !xendev->inactive) {
655         XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
656 
657         xendev->inactive = true;
658         QLIST_INSERT_HEAD(&xenbus->inactive_devices, xendev, list);
659 
660         /*
661          * Re-write the state to cause a XenBus backend_watch notification,
662          * resulting in a call to xen_bus_cleanup().
663          */
664         xen_device_backend_printf(xendev, "state", "%u", state);
665     }
666 }
667 
668 static XenWatch *xen_device_add_watch(XenDevice *xendev, const char *node,
669                                       const char *key,
670                                       XenWatchHandler handler,
671                                       Error **errp)
672 {
673     const char *type = object_get_typename(OBJECT(xendev));
674 
675     trace_xen_device_add_watch(type, xendev->name, node, key);
676 
677     return watch_list_add(xendev->watch_list, node, key, handler, xendev,
678                           errp);
679 }
680 
681 static void xen_device_remove_watch(XenDevice *xendev, XenWatch *watch,
682                                     Error **errp)
683 {
684     const char *type = object_get_typename(OBJECT(xendev));
685 
686     trace_xen_device_remove_watch(type, xendev->name, watch->node,
687                                   watch->key);
688 
689     watch_list_remove(xendev->watch_list, watch, errp);
690 }
691 
692 
693 static void xen_device_backend_create(XenDevice *xendev, Error **errp)
694 {
695     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
696     struct xs_permissions perms[2];
697     Error *local_err = NULL;
698 
699     xendev->backend_path = xen_device_get_backend_path(xendev);
700 
701     perms[0].id = xenbus->backend_id;
702     perms[0].perms = XS_PERM_NONE;
703     perms[1].id = xendev->frontend_id;
704     perms[1].perms = XS_PERM_READ;
705 
706     g_assert(xenbus->xsh);
707 
708     xs_node_create(xenbus->xsh, XBT_NULL, xendev->backend_path, perms,
709                    ARRAY_SIZE(perms), &local_err);
710     if (local_err) {
711         error_propagate_prepend(errp, local_err,
712                                 "failed to create backend: ");
713         return;
714     }
715 
716     xendev->backend_state_watch =
717         xen_device_add_watch(xendev, xendev->backend_path,
718                              "state", xen_device_backend_changed,
719                              &local_err);
720     if (local_err) {
721         error_propagate_prepend(errp, local_err,
722                                 "failed to watch backend state: ");
723         return;
724     }
725 
726     xendev->backend_online_watch =
727         xen_device_add_watch(xendev, xendev->backend_path,
728                              "online", xen_device_backend_changed,
729                              &local_err);
730     if (local_err) {
731         error_propagate_prepend(errp, local_err,
732                                 "failed to watch backend online: ");
733         return;
734     }
735 }
736 
737 static void xen_device_backend_destroy(XenDevice *xendev)
738 {
739     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
740     Error *local_err = NULL;
741 
742     if (xendev->backend_online_watch) {
743         xen_device_remove_watch(xendev, xendev->backend_online_watch, NULL);
744         xendev->backend_online_watch = NULL;
745     }
746 
747     if (xendev->backend_state_watch) {
748         xen_device_remove_watch(xendev, xendev->backend_state_watch, NULL);
749         xendev->backend_state_watch = NULL;
750     }
751 
752     if (!xendev->backend_path) {
753         return;
754     }
755 
756     g_assert(xenbus->xsh);
757 
758     xs_node_destroy(xenbus->xsh, XBT_NULL, xendev->backend_path,
759                     &local_err);
760     g_free(xendev->backend_path);
761     xendev->backend_path = NULL;
762 
763     if (local_err) {
764         error_report_err(local_err);
765     }
766 }
767 
768 void xen_device_frontend_printf(XenDevice *xendev, const char *key,
769                                 const char *fmt, ...)
770 {
771     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
772     Error *local_err = NULL;
773     va_list ap;
774 
775     g_assert(xenbus->xsh);
776 
777     va_start(ap, fmt);
778     xs_node_vprintf(xenbus->xsh, XBT_NULL, xendev->frontend_path, key,
779                     &local_err, fmt, ap);
780     va_end(ap);
781 
782     if (local_err) {
783         error_report_err(local_err);
784     }
785 }
786 
787 int xen_device_frontend_scanf(XenDevice *xendev, const char *key,
788                               const char *fmt, ...)
789 {
790     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
791     va_list ap;
792     int rc;
793 
794     g_assert(xenbus->xsh);
795 
796     va_start(ap, fmt);
797     rc = xs_node_vscanf(xenbus->xsh, XBT_NULL, xendev->frontend_path, key,
798                         NULL, fmt, ap);
799     va_end(ap);
800 
801     return rc;
802 }
803 
804 static void xen_device_frontend_set_state(XenDevice *xendev,
805                                           enum xenbus_state state,
806                                           bool publish)
807 {
808     const char *type = object_get_typename(OBJECT(xendev));
809 
810     if (xendev->frontend_state == state) {
811         return;
812     }
813 
814     trace_xen_device_frontend_state(type, xendev->name,
815                                     xs_strstate(state));
816 
817     xendev->frontend_state = state;
818     if (publish) {
819         xen_device_frontend_printf(xendev, "state", "%u", state);
820     }
821 }
822 
823 static void xen_device_frontend_changed(void *opaque)
824 {
825     XenDevice *xendev = opaque;
826     XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev);
827     const char *type = object_get_typename(OBJECT(xendev));
828     enum xenbus_state state;
829 
830     trace_xen_device_frontend_changed(type, xendev->name);
831 
832     if (xen_device_frontend_scanf(xendev, "state", "%u", &state) != 1) {
833         state = XenbusStateUnknown;
834     }
835 
836     xen_device_frontend_set_state(xendev, state, false);
837 
838     if (state == XenbusStateInitialising &&
839         xendev->backend_state == XenbusStateClosed &&
840         xendev->backend_online) {
841         /*
842          * The frontend is re-initializing so switch back to
843          * InitWait.
844          */
845         xen_device_backend_set_state(xendev, XenbusStateInitWait);
846         return;
847     }
848 
849     if (xendev_class->frontend_changed) {
850         Error *local_err = NULL;
851 
852         xendev_class->frontend_changed(xendev, state, &local_err);
853 
854         if (local_err) {
855             error_reportf_err(local_err, "frontend change error: ");
856         }
857     }
858 }
859 
860 static bool xen_device_frontend_exists(XenDevice *xendev)
861 {
862     enum xenbus_state state;
863 
864     return (xen_device_frontend_scanf(xendev, "state", "%u", &state) == 1);
865 }
866 
867 static void xen_device_frontend_create(XenDevice *xendev, Error **errp)
868 {
869     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
870     struct xs_permissions perms[2];
871     Error *local_err = NULL;
872 
873     xendev->frontend_path = xen_device_get_frontend_path(xendev);
874 
875     /*
876      * The frontend area may have already been created by a legacy
877      * toolstack.
878      */
879     if (!xen_device_frontend_exists(xendev)) {
880         perms[0].id = xendev->frontend_id;
881         perms[0].perms = XS_PERM_NONE;
882         perms[1].id = xenbus->backend_id;
883         perms[1].perms = XS_PERM_READ | XS_PERM_WRITE;
884 
885         g_assert(xenbus->xsh);
886 
887         xs_node_create(xenbus->xsh, XBT_NULL, xendev->frontend_path, perms,
888                        ARRAY_SIZE(perms), &local_err);
889         if (local_err) {
890             error_propagate_prepend(errp, local_err,
891                                     "failed to create frontend: ");
892             return;
893         }
894     }
895 
896     xendev->frontend_state_watch =
897         xen_device_add_watch(xendev, xendev->frontend_path, "state",
898                              xen_device_frontend_changed, &local_err);
899     if (local_err) {
900         error_propagate_prepend(errp, local_err,
901                                 "failed to watch frontend state: ");
902     }
903 }
904 
905 static void xen_device_frontend_destroy(XenDevice *xendev)
906 {
907     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
908     Error *local_err = NULL;
909 
910     if (xendev->frontend_state_watch) {
911         xen_device_remove_watch(xendev, xendev->frontend_state_watch,
912                                 NULL);
913         xendev->frontend_state_watch = NULL;
914     }
915 
916     if (!xendev->frontend_path) {
917         return;
918     }
919 
920     g_assert(xenbus->xsh);
921 
922     xs_node_destroy(xenbus->xsh, XBT_NULL, xendev->frontend_path,
923                     &local_err);
924     g_free(xendev->frontend_path);
925     xendev->frontend_path = NULL;
926 
927     if (local_err) {
928         error_report_err(local_err);
929     }
930 }
931 
932 void xen_device_set_max_grant_refs(XenDevice *xendev, unsigned int nr_refs,
933                                    Error **errp)
934 {
935     if (xengnttab_set_max_grants(xendev->xgth, nr_refs)) {
936         error_setg_errno(errp, errno, "xengnttab_set_max_grants failed");
937     }
938 }
939 
940 void *xen_device_map_grant_refs(XenDevice *xendev, uint32_t *refs,
941                                 unsigned int nr_refs, int prot,
942                                 Error **errp)
943 {
944     void *map = xengnttab_map_domain_grant_refs(xendev->xgth, nr_refs,
945                                                 xendev->frontend_id, refs,
946                                                 prot);
947 
948     if (!map) {
949         error_setg_errno(errp, errno,
950                          "xengnttab_map_domain_grant_refs failed");
951     }
952 
953     return map;
954 }
955 
956 void xen_device_unmap_grant_refs(XenDevice *xendev, void *map,
957                                  unsigned int nr_refs, Error **errp)
958 {
959     if (xengnttab_unmap(xendev->xgth, map, nr_refs)) {
960         error_setg_errno(errp, errno, "xengnttab_unmap failed");
961     }
962 }
963 
964 static void compat_copy_grant_refs(XenDevice *xendev, bool to_domain,
965                                    XenDeviceGrantCopySegment segs[],
966                                    unsigned int nr_segs, Error **errp)
967 {
968     uint32_t *refs = g_new(uint32_t, nr_segs);
969     int prot = to_domain ? PROT_WRITE : PROT_READ;
970     void *map;
971     unsigned int i;
972 
973     for (i = 0; i < nr_segs; i++) {
974         XenDeviceGrantCopySegment *seg = &segs[i];
975 
976         refs[i] = to_domain ? seg->dest.foreign.ref :
977             seg->source.foreign.ref;
978     }
979 
980     map = xengnttab_map_domain_grant_refs(xendev->xgth, nr_segs,
981                                           xendev->frontend_id, refs,
982                                           prot);
983     if (!map) {
984         error_setg_errno(errp, errno,
985                          "xengnttab_map_domain_grant_refs failed");
986         goto done;
987     }
988 
989     for (i = 0; i < nr_segs; i++) {
990         XenDeviceGrantCopySegment *seg = &segs[i];
991         void *page = map + (i * XC_PAGE_SIZE);
992 
993         if (to_domain) {
994             memcpy(page + seg->dest.foreign.offset, seg->source.virt,
995                    seg->len);
996         } else {
997             memcpy(seg->dest.virt, page + seg->source.foreign.offset,
998                    seg->len);
999         }
1000     }
1001 
1002     if (xengnttab_unmap(xendev->xgth, map, nr_segs)) {
1003         error_setg_errno(errp, errno, "xengnttab_unmap failed");
1004     }
1005 
1006 done:
1007     g_free(refs);
1008 }
1009 
1010 void xen_device_copy_grant_refs(XenDevice *xendev, bool to_domain,
1011                                 XenDeviceGrantCopySegment segs[],
1012                                 unsigned int nr_segs, Error **errp)
1013 {
1014     xengnttab_grant_copy_segment_t *xengnttab_segs;
1015     unsigned int i;
1016 
1017     if (!xendev->feature_grant_copy) {
1018         compat_copy_grant_refs(xendev, to_domain, segs, nr_segs, errp);
1019         return;
1020     }
1021 
1022     xengnttab_segs = g_new0(xengnttab_grant_copy_segment_t, nr_segs);
1023 
1024     for (i = 0; i < nr_segs; i++) {
1025         XenDeviceGrantCopySegment *seg = &segs[i];
1026         xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i];
1027 
1028         if (to_domain) {
1029             xengnttab_seg->flags = GNTCOPY_dest_gref;
1030             xengnttab_seg->dest.foreign.domid = xendev->frontend_id;
1031             xengnttab_seg->dest.foreign.ref = seg->dest.foreign.ref;
1032             xengnttab_seg->dest.foreign.offset = seg->dest.foreign.offset;
1033             xengnttab_seg->source.virt = seg->source.virt;
1034         } else {
1035             xengnttab_seg->flags = GNTCOPY_source_gref;
1036             xengnttab_seg->source.foreign.domid = xendev->frontend_id;
1037             xengnttab_seg->source.foreign.ref = seg->source.foreign.ref;
1038             xengnttab_seg->source.foreign.offset =
1039                 seg->source.foreign.offset;
1040             xengnttab_seg->dest.virt = seg->dest.virt;
1041         }
1042 
1043         xengnttab_seg->len = seg->len;
1044     }
1045 
1046     if (xengnttab_grant_copy(xendev->xgth, nr_segs, xengnttab_segs)) {
1047         error_setg_errno(errp, errno, "xengnttab_grant_copy failed");
1048         goto done;
1049     }
1050 
1051     for (i = 0; i < nr_segs; i++) {
1052         xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i];
1053 
1054         if (xengnttab_seg->status != GNTST_okay) {
1055             error_setg(errp, "xengnttab_grant_copy seg[%u] failed", i);
1056             break;
1057         }
1058     }
1059 
1060 done:
1061     g_free(xengnttab_segs);
1062 }
1063 
1064 struct XenEventChannel {
1065     QLIST_ENTRY(XenEventChannel) list;
1066     AioContext *ctx;
1067     xenevtchn_handle *xeh;
1068     evtchn_port_t local_port;
1069     XenEventHandler handler;
1070     void *opaque;
1071 };
1072 
1073 static bool xen_device_poll(void *opaque)
1074 {
1075     XenEventChannel *channel = opaque;
1076 
1077     return channel->handler(channel->opaque);
1078 }
1079 
1080 static void xen_device_event(void *opaque)
1081 {
1082     XenEventChannel *channel = opaque;
1083     unsigned long port = xenevtchn_pending(channel->xeh);
1084 
1085     if (port == channel->local_port) {
1086         xen_device_poll(channel);
1087 
1088         xenevtchn_unmask(channel->xeh, port);
1089     }
1090 }
1091 
1092 XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev,
1093                                                AioContext *ctx,
1094                                                unsigned int port,
1095                                                XenEventHandler handler,
1096                                                void *opaque, Error **errp)
1097 {
1098     XenEventChannel *channel = g_new0(XenEventChannel, 1);
1099     xenevtchn_port_or_error_t local_port;
1100 
1101     channel->xeh = xenevtchn_open(NULL, 0);
1102     if (!channel->xeh) {
1103         error_setg_errno(errp, errno, "failed xenevtchn_open");
1104         goto fail;
1105     }
1106 
1107     local_port = xenevtchn_bind_interdomain(channel->xeh,
1108                                             xendev->frontend_id,
1109                                             port);
1110     if (local_port < 0) {
1111         error_setg_errno(errp, errno, "xenevtchn_bind_interdomain failed");
1112         goto fail;
1113     }
1114 
1115     channel->local_port = local_port;
1116     channel->handler = handler;
1117     channel->opaque = opaque;
1118 
1119     channel->ctx = ctx;
1120     aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
1121                        xen_device_event, NULL, xen_device_poll, channel);
1122 
1123     QLIST_INSERT_HEAD(&xendev->event_channels, channel, list);
1124 
1125     return channel;
1126 
1127 fail:
1128     if (channel->xeh) {
1129         xenevtchn_close(channel->xeh);
1130     }
1131 
1132     g_free(channel);
1133 
1134     return NULL;
1135 }
1136 
1137 void xen_device_notify_event_channel(XenDevice *xendev,
1138                                      XenEventChannel *channel,
1139                                      Error **errp)
1140 {
1141     if (!channel) {
1142         error_setg(errp, "bad channel");
1143         return;
1144     }
1145 
1146     if (xenevtchn_notify(channel->xeh, channel->local_port) < 0) {
1147         error_setg_errno(errp, errno, "xenevtchn_notify failed");
1148     }
1149 }
1150 
1151 void xen_device_unbind_event_channel(XenDevice *xendev,
1152                                      XenEventChannel *channel,
1153                                      Error **errp)
1154 {
1155     if (!channel) {
1156         error_setg(errp, "bad channel");
1157         return;
1158     }
1159 
1160     QLIST_REMOVE(channel, list);
1161 
1162     aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
1163                        NULL, NULL, NULL, NULL);
1164 
1165     if (xenevtchn_unbind(channel->xeh, channel->local_port) < 0) {
1166         error_setg_errno(errp, errno, "xenevtchn_unbind failed");
1167     }
1168 
1169     xenevtchn_close(channel->xeh);
1170     g_free(channel);
1171 }
1172 
1173 static void xen_device_unrealize(DeviceState *dev, Error **errp)
1174 {
1175     XenDevice *xendev = XEN_DEVICE(dev);
1176     XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev);
1177     const char *type = object_get_typename(OBJECT(xendev));
1178     XenEventChannel *channel, *next;
1179 
1180     if (!xendev->name) {
1181         return;
1182     }
1183 
1184     trace_xen_device_unrealize(type, xendev->name);
1185 
1186     if (xendev->exit.notify) {
1187         qemu_remove_exit_notifier(&xendev->exit);
1188         xendev->exit.notify = NULL;
1189     }
1190 
1191     if (xendev_class->unrealize) {
1192         xendev_class->unrealize(xendev, errp);
1193     }
1194 
1195     /* Make sure all event channels are cleaned up */
1196     QLIST_FOREACH_SAFE(channel, &xendev->event_channels, list, next) {
1197         xen_device_unbind_event_channel(xendev, channel, NULL);
1198     }
1199 
1200     xen_device_frontend_destroy(xendev);
1201     xen_device_backend_destroy(xendev);
1202 
1203     if (xendev->xgth) {
1204         xengnttab_close(xendev->xgth);
1205         xendev->xgth = NULL;
1206     }
1207 
1208     if (xendev->watch_list) {
1209         watch_list_destroy(xendev->watch_list);
1210         xendev->watch_list = NULL;
1211     }
1212 
1213     if (xendev->xsh) {
1214         xs_close(xendev->xsh);
1215         xendev->xsh = NULL;
1216     }
1217 
1218     g_free(xendev->name);
1219     xendev->name = NULL;
1220 }
1221 
1222 static void xen_device_exit(Notifier *n, void *data)
1223 {
1224     XenDevice *xendev = container_of(n, XenDevice, exit);
1225 
1226     xen_device_unrealize(DEVICE(xendev), &error_abort);
1227 }
1228 
1229 static void xen_device_realize(DeviceState *dev, Error **errp)
1230 {
1231     XenDevice *xendev = XEN_DEVICE(dev);
1232     XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev);
1233     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
1234     const char *type = object_get_typename(OBJECT(xendev));
1235     Error *local_err = NULL;
1236 
1237     if (xendev->frontend_id == DOMID_INVALID) {
1238         xendev->frontend_id = xen_domid;
1239     }
1240 
1241     if (xendev->frontend_id >= DOMID_FIRST_RESERVED) {
1242         error_setg(errp, "invalid frontend-id");
1243         goto unrealize;
1244     }
1245 
1246     if (!xendev_class->get_name) {
1247         error_setg(errp, "get_name method not implemented");
1248         goto unrealize;
1249     }
1250 
1251     xendev->name = xendev_class->get_name(xendev, &local_err);
1252     if (local_err) {
1253         error_propagate_prepend(errp, local_err,
1254                                 "failed to get device name: ");
1255         goto unrealize;
1256     }
1257 
1258     trace_xen_device_realize(type, xendev->name);
1259 
1260     xendev->xsh = xs_open(0);
1261     if (!xendev->xsh) {
1262         error_setg_errno(errp, errno, "failed xs_open");
1263         goto unrealize;
1264     }
1265 
1266     xendev->watch_list = watch_list_create(xendev->xsh);
1267 
1268     xendev->xgth = xengnttab_open(NULL, 0);
1269     if (!xendev->xgth) {
1270         error_setg_errno(errp, errno, "failed xengnttab_open");
1271         goto unrealize;
1272     }
1273 
1274     xendev->feature_grant_copy =
1275         (xengnttab_grant_copy(xendev->xgth, 0, NULL) == 0);
1276 
1277     xen_device_backend_create(xendev, &local_err);
1278     if (local_err) {
1279         error_propagate(errp, local_err);
1280         goto unrealize;
1281     }
1282 
1283     xen_device_frontend_create(xendev, &local_err);
1284     if (local_err) {
1285         error_propagate(errp, local_err);
1286         goto unrealize;
1287     }
1288 
1289     if (xendev_class->realize) {
1290         xendev_class->realize(xendev, &local_err);
1291         if (local_err) {
1292             error_propagate(errp, local_err);
1293             goto unrealize;
1294         }
1295     }
1296 
1297     xen_device_backend_printf(xendev, "frontend", "%s",
1298                               xendev->frontend_path);
1299     xen_device_backend_printf(xendev, "frontend-id", "%u",
1300                               xendev->frontend_id);
1301     xen_device_backend_printf(xendev, "hotplug-status", "connected");
1302 
1303     xen_device_backend_set_online(xendev, true);
1304     xen_device_backend_set_state(xendev, XenbusStateInitWait);
1305 
1306     if (!xen_device_frontend_exists(xendev)) {
1307         xen_device_frontend_printf(xendev, "backend", "%s",
1308                                    xendev->backend_path);
1309         xen_device_frontend_printf(xendev, "backend-id", "%u",
1310                                    xenbus->backend_id);
1311 
1312         xen_device_frontend_set_state(xendev, XenbusStateInitialising, true);
1313     }
1314 
1315     xendev->exit.notify = xen_device_exit;
1316     qemu_add_exit_notifier(&xendev->exit);
1317     return;
1318 
1319 unrealize:
1320     xen_device_unrealize(dev, &error_abort);
1321 }
1322 
1323 static Property xen_device_props[] = {
1324     DEFINE_PROP_UINT16("frontend-id", XenDevice, frontend_id,
1325                        DOMID_INVALID),
1326     DEFINE_PROP_END_OF_LIST()
1327 };
1328 
1329 static void xen_device_class_init(ObjectClass *class, void *data)
1330 {
1331     DeviceClass *dev_class = DEVICE_CLASS(class);
1332 
1333     dev_class->realize = xen_device_realize;
1334     dev_class->unrealize = xen_device_unrealize;
1335     device_class_set_props(dev_class, xen_device_props);
1336     dev_class->bus_type = TYPE_XEN_BUS;
1337 }
1338 
1339 static const TypeInfo xen_device_type_info = {
1340     .name = TYPE_XEN_DEVICE,
1341     .parent = TYPE_DEVICE,
1342     .instance_size = sizeof(XenDevice),
1343     .abstract = true,
1344     .class_size = sizeof(XenDeviceClass),
1345     .class_init = xen_device_class_init,
1346 };
1347 
1348 typedef struct XenBridge {
1349     SysBusDevice busdev;
1350 } XenBridge;
1351 
1352 #define TYPE_XEN_BRIDGE "xen-bridge"
1353 
1354 static const TypeInfo xen_bridge_type_info = {
1355     .name = TYPE_XEN_BRIDGE,
1356     .parent = TYPE_SYS_BUS_DEVICE,
1357     .instance_size = sizeof(XenBridge),
1358 };
1359 
1360 static void xen_register_types(void)
1361 {
1362     type_register_static(&xen_bridge_type_info);
1363     type_register_static(&xen_bus_type_info);
1364     type_register_static(&xen_device_type_info);
1365 }
1366 
1367 type_init(xen_register_types)
1368 
1369 void xen_bus_init(void)
1370 {
1371     DeviceState *dev = qdev_create(NULL, TYPE_XEN_BRIDGE);
1372     BusState *bus = qbus_create(TYPE_XEN_BUS, dev, NULL);
1373 
1374     qdev_init_nofail(dev);
1375     qbus_set_bus_hotplug_handler(bus, &error_abort);
1376 }
1377