1
2
3
4
5
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/hw.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
24static 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
40static 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
54static 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
64again:
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
93abort:
94
95
96
97
98 xs_transaction_end(xenbus->xsh, tid, true);
99 error_propagate(errp, local_err);
100}
101
102static 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
110static char *xen_bus_get_dev_path(DeviceState *dev)
111{
112 return xen_device_get_backend_path(XEN_DEVICE(dev));
113}
114
115struct XenWatch {
116 char *node, *key;
117 char *token;
118 XenWatchHandler handler;
119 void *opaque;
120 Notifier notifier;
121};
122
123static 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
133static 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
151static 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
160static XenWatch *xen_bus_add_watch(XenBus *xenbus, const char *node,
161 const char *key, XenWatchHandler handler,
162 void *opaque, Error **errp)
163{
164 XenWatch *watch = new_watch(node, key, handler, opaque);
165 Error *local_err = NULL;
166
167 trace_xen_bus_add_watch(watch->node, watch->key, watch->token);
168
169 notifier_list_add(&xenbus->watch_notifiers, &watch->notifier);
170
171 xs_node_watch(xenbus->xsh, node, key, watch->token, &local_err);
172 if (local_err) {
173 error_propagate(errp, local_err);
174
175 notifier_remove(&watch->notifier);
176 free_watch(watch);
177
178 return NULL;
179 }
180
181 return watch;
182}
183
184static void xen_bus_remove_watch(XenBus *xenbus, XenWatch *watch,
185 Error **errp)
186{
187 trace_xen_bus_remove_watch(watch->node, watch->key, watch->token);
188
189 xs_node_unwatch(xenbus->xsh, watch->node, watch->key, watch->token,
190 errp);
191
192 notifier_remove(&watch->notifier);
193 free_watch(watch);
194}
195
196static void xen_bus_backend_create(XenBus *xenbus, const char *type,
197 const char *name, char *path,
198 Error **errp)
199{
200 xs_transaction_t tid;
201 char **key;
202 QDict *opts;
203 unsigned int i, n;
204 Error *local_err = NULL;
205
206 trace_xen_bus_backend_create(type, path);
207
208again:
209 tid = xs_transaction_start(xenbus->xsh);
210 if (tid == XBT_NULL) {
211 error_setg(errp, "failed xs_transaction_start");
212 return;
213 }
214
215 key = xs_directory(xenbus->xsh, tid, path, &n);
216 if (!key) {
217 if (!xs_transaction_end(xenbus->xsh, tid, true)) {
218 error_setg_errno(errp, errno, "failed xs_transaction_end");
219 }
220 return;
221 }
222
223 opts = qdict_new();
224 for (i = 0; i < n; i++) {
225 char *val;
226
227
228
229
230
231
232 if (!strcmp(key[i], "state") ||
233 !strcmp(key[i], "online") ||
234 !strcmp(key[i], "frontend") ||
235 !strcmp(key[i], "frontend-id") ||
236 !strcmp(key[i], "hotplug-status"))
237 continue;
238
239 if (xs_node_scanf(xenbus->xsh, tid, path, key[i], NULL, "%ms",
240 &val) == 1) {
241 qdict_put_str(opts, key[i], val);
242 free(val);
243 }
244 }
245
246 free(key);
247
248 if (!xs_transaction_end(xenbus->xsh, tid, false)) {
249 qobject_unref(opts);
250
251 if (errno == EAGAIN) {
252 goto again;
253 }
254
255 error_setg_errno(errp, errno, "failed xs_transaction_end");
256 return;
257 }
258
259 xen_backend_device_create(xenbus, type, name, opts, &local_err);
260 qobject_unref(opts);
261
262 if (local_err) {
263 error_propagate_prepend(errp, local_err,
264 "failed to create '%s' device '%s': ",
265 type, name);
266 }
267}
268
269static void xen_bus_type_enumerate(XenBus *xenbus, const char *type)
270{
271 char *domain_path = g_strdup_printf("backend/%s/%u", type, xen_domid);
272 char **backend;
273 unsigned int i, n;
274
275 trace_xen_bus_type_enumerate(type);
276
277 backend = xs_directory(xenbus->xsh, XBT_NULL, domain_path, &n);
278 if (!backend) {
279 goto out;
280 }
281
282 for (i = 0; i < n; i++) {
283 char *backend_path = g_strdup_printf("%s/%s", domain_path,
284 backend[i]);
285 enum xenbus_state backend_state;
286
287 if (xs_node_scanf(xenbus->xsh, XBT_NULL, backend_path, "state",
288 NULL, "%u", &backend_state) != 1)
289 backend_state = XenbusStateUnknown;
290
291 if (backend_state == XenbusStateInitialising) {
292 Error *local_err = NULL;
293
294 xen_bus_backend_create(xenbus, type, backend[i], backend_path,
295 &local_err);
296 if (local_err) {
297 error_report_err(local_err);
298 }
299 }
300
301 g_free(backend_path);
302 }
303
304 free(backend);
305
306out:
307 g_free(domain_path);
308}
309
310static void xen_bus_enumerate(void *opaque)
311{
312 XenBus *xenbus = opaque;
313 char **type;
314 unsigned int i, n;
315
316 trace_xen_bus_enumerate();
317
318 type = xs_directory(xenbus->xsh, XBT_NULL, "backend", &n);
319 if (!type) {
320 return;
321 }
322
323 for (i = 0; i < n; i++) {
324 xen_bus_type_enumerate(xenbus, type[i]);
325 }
326
327 free(type);
328}
329
330static void xen_bus_unrealize(BusState *bus, Error **errp)
331{
332 XenBus *xenbus = XEN_BUS(bus);
333
334 trace_xen_bus_unrealize();
335
336 if (xenbus->backend_watch) {
337 xen_bus_remove_watch(xenbus, xenbus->backend_watch, NULL);
338 xenbus->backend_watch = NULL;
339 }
340
341 if (!xenbus->xsh) {
342 return;
343 }
344
345 qemu_set_fd_handler(xs_fileno(xenbus->xsh), NULL, NULL, NULL);
346
347 xs_close(xenbus->xsh);
348}
349
350static void xen_bus_watch(void *opaque)
351{
352 XenBus *xenbus = opaque;
353 char **v;
354 const char *token;
355
356 g_assert(xenbus->xsh);
357
358 v = xs_check_watch(xenbus->xsh);
359 if (!v) {
360 return;
361 }
362
363 token = v[XS_WATCH_TOKEN];
364
365 trace_xen_bus_watch(token);
366
367 notifier_list_notify(&xenbus->watch_notifiers, (void *)token);
368
369 free(v);
370}
371
372static void xen_bus_realize(BusState *bus, Error **errp)
373{
374 XenBus *xenbus = XEN_BUS(bus);
375 unsigned int domid;
376 Error *local_err = NULL;
377
378 trace_xen_bus_realize();
379
380 xenbus->xsh = xs_open(0);
381 if (!xenbus->xsh) {
382 error_setg_errno(errp, errno, "failed xs_open");
383 goto fail;
384 }
385
386 if (xs_node_scanf(xenbus->xsh, XBT_NULL, "",
387 "domid", NULL, "%u", &domid) == 1) {
388 xenbus->backend_id = domid;
389 } else {
390 xenbus->backend_id = 0;
391 }
392
393 notifier_list_init(&xenbus->watch_notifiers);
394 qemu_set_fd_handler(xs_fileno(xenbus->xsh), xen_bus_watch, NULL,
395 xenbus);
396
397 module_call_init(MODULE_INIT_XEN_BACKEND);
398
399 xenbus->backend_watch =
400 xen_bus_add_watch(xenbus, "",
401 "backend", xen_bus_enumerate, xenbus, &local_err);
402 if (local_err) {
403
404 error_reportf_err(local_err,
405 "failed to set up enumeration watch: ");
406 }
407
408 return;
409
410fail:
411 xen_bus_unrealize(bus, &error_abort);
412}
413
414static void xen_bus_unplug_request(HotplugHandler *hotplug,
415 DeviceState *dev,
416 Error **errp)
417{
418 XenDevice *xendev = XEN_DEVICE(dev);
419
420 xen_device_unplug(xendev, errp);
421}
422
423static void xen_bus_class_init(ObjectClass *class, void *data)
424{
425 BusClass *bus_class = BUS_CLASS(class);
426 HotplugHandlerClass *hotplug_class = HOTPLUG_HANDLER_CLASS(class);
427
428 bus_class->print_dev = xen_bus_print_dev;
429 bus_class->get_dev_path = xen_bus_get_dev_path;
430 bus_class->realize = xen_bus_realize;
431 bus_class->unrealize = xen_bus_unrealize;
432
433 hotplug_class->unplug_request = xen_bus_unplug_request;
434}
435
436static const TypeInfo xen_bus_type_info = {
437 .name = TYPE_XEN_BUS,
438 .parent = TYPE_BUS,
439 .instance_size = sizeof(XenBus),
440 .class_size = sizeof(XenBusClass),
441 .class_init = xen_bus_class_init,
442 .interfaces = (InterfaceInfo[]) {
443 { TYPE_HOTPLUG_HANDLER },
444 { }
445 },
446};
447
448void xen_device_backend_printf(XenDevice *xendev, const char *key,
449 const char *fmt, ...)
450{
451 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
452 Error *local_err = NULL;
453 va_list ap;
454
455 g_assert(xenbus->xsh);
456
457 va_start(ap, fmt);
458 xs_node_vprintf(xenbus->xsh, XBT_NULL, xendev->backend_path, key,
459 &local_err, fmt, ap);
460 va_end(ap);
461
462 if (local_err) {
463 error_report_err(local_err);
464 }
465}
466
467static int xen_device_backend_scanf(XenDevice *xendev, const char *key,
468 const char *fmt, ...)
469{
470 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
471 va_list ap;
472 int rc;
473
474 g_assert(xenbus->xsh);
475
476 va_start(ap, fmt);
477 rc = xs_node_vscanf(xenbus->xsh, XBT_NULL, xendev->backend_path, key,
478 NULL, fmt, ap);
479 va_end(ap);
480
481 return rc;
482}
483
484void xen_device_backend_set_state(XenDevice *xendev,
485 enum xenbus_state state)
486{
487 const char *type = object_get_typename(OBJECT(xendev));
488
489 if (xendev->backend_state == state) {
490 return;
491 }
492
493 trace_xen_device_backend_state(type, xendev->name,
494 xs_strstate(state));
495
496 xendev->backend_state = state;
497 xen_device_backend_printf(xendev, "state", "%u", state);
498}
499
500enum xenbus_state xen_device_backend_get_state(XenDevice *xendev)
501{
502 return xendev->backend_state;
503}
504
505static void xen_device_backend_set_online(XenDevice *xendev, bool online)
506{
507 const char *type = object_get_typename(OBJECT(xendev));
508
509 if (xendev->backend_online == online) {
510 return;
511 }
512
513 trace_xen_device_backend_online(type, xendev->name, online);
514
515 xendev->backend_online = online;
516 xen_device_backend_printf(xendev, "online", "%u", online);
517}
518
519
520
521
522
523static bool xen_device_state_is_active(enum xenbus_state state)
524{
525 switch (state) {
526 case XenbusStateInitWait:
527 case XenbusStateInitialised:
528 case XenbusStateConnected:
529 case XenbusStateClosing:
530 return true;
531 default:
532 return false;
533 }
534}
535
536static void xen_device_backend_changed(void *opaque)
537{
538 XenDevice *xendev = opaque;
539 const char *type = object_get_typename(OBJECT(xendev));
540 enum xenbus_state state;
541 unsigned int online;
542
543 trace_xen_device_backend_changed(type, xendev->name);
544
545 if (xen_device_backend_scanf(xendev, "state", "%u", &state) != 1) {
546 state = XenbusStateUnknown;
547 }
548
549 xen_device_backend_set_state(xendev, state);
550
551 if (xen_device_backend_scanf(xendev, "online", "%u", &online) != 1) {
552 online = 0;
553 }
554
555 xen_device_backend_set_online(xendev, !!online);
556
557
558
559
560
561
562 if (xendev->backend_state == XenbusStateClosing &&
563 !xen_device_state_is_active(xendev->frontend_state)) {
564 xen_device_backend_set_state(xendev, XenbusStateClosed);
565 }
566
567
568
569
570
571
572 if (!xendev->backend_online &&
573 (xendev->backend_state == XenbusStateClosed ||
574 xendev->backend_state == XenbusStateInitialising ||
575 xendev->backend_state == XenbusStateInitWait ||
576 xendev->backend_state == XenbusStateUnknown)) {
577 Error *local_err = NULL;
578
579 if (!xen_backend_try_device_destroy(xendev, &local_err)) {
580 object_unparent(OBJECT(xendev));
581 }
582
583 if (local_err) {
584 error_report_err(local_err);
585 }
586 }
587}
588
589static void xen_device_backend_create(XenDevice *xendev, Error **errp)
590{
591 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
592 struct xs_permissions perms[2];
593 Error *local_err = NULL;
594
595 xendev->backend_path = xen_device_get_backend_path(xendev);
596
597 perms[0].id = xenbus->backend_id;
598 perms[0].perms = XS_PERM_NONE;
599 perms[1].id = xendev->frontend_id;
600 perms[1].perms = XS_PERM_READ;
601
602 g_assert(xenbus->xsh);
603
604 xs_node_create(xenbus->xsh, XBT_NULL, xendev->backend_path, perms,
605 ARRAY_SIZE(perms), &local_err);
606 if (local_err) {
607 error_propagate_prepend(errp, local_err,
608 "failed to create backend: ");
609 return;
610 }
611
612 xendev->backend_state_watch =
613 xen_bus_add_watch(xenbus, xendev->backend_path,
614 "state", xen_device_backend_changed,
615 xendev, &local_err);
616 if (local_err) {
617 error_propagate_prepend(errp, local_err,
618 "failed to watch backend state: ");
619 return;
620 }
621
622 xendev->backend_online_watch =
623 xen_bus_add_watch(xenbus, xendev->backend_path,
624 "online", xen_device_backend_changed,
625 xendev, &local_err);
626 if (local_err) {
627 error_propagate_prepend(errp, local_err,
628 "failed to watch backend online: ");
629 return;
630 }
631}
632
633static void xen_device_backend_destroy(XenDevice *xendev)
634{
635 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
636 Error *local_err = NULL;
637
638 if (xendev->backend_online_watch) {
639 xen_bus_remove_watch(xenbus, xendev->backend_online_watch, NULL);
640 xendev->backend_online_watch = NULL;
641 }
642
643 if (xendev->backend_state_watch) {
644 xen_bus_remove_watch(xenbus, xendev->backend_state_watch, NULL);
645 xendev->backend_state_watch = NULL;
646 }
647
648 if (!xendev->backend_path) {
649 return;
650 }
651
652 g_assert(xenbus->xsh);
653
654 xs_node_destroy(xenbus->xsh, XBT_NULL, xendev->backend_path,
655 &local_err);
656 g_free(xendev->backend_path);
657 xendev->backend_path = NULL;
658
659 if (local_err) {
660 error_report_err(local_err);
661 }
662}
663
664void xen_device_frontend_printf(XenDevice *xendev, const char *key,
665 const char *fmt, ...)
666{
667 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
668 Error *local_err = NULL;
669 va_list ap;
670
671 g_assert(xenbus->xsh);
672
673 va_start(ap, fmt);
674 xs_node_vprintf(xenbus->xsh, XBT_NULL, xendev->frontend_path, key,
675 &local_err, fmt, ap);
676 va_end(ap);
677
678 if (local_err) {
679 error_report_err(local_err);
680 }
681}
682
683int xen_device_frontend_scanf(XenDevice *xendev, const char *key,
684 const char *fmt, ...)
685{
686 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
687 va_list ap;
688 int rc;
689
690 g_assert(xenbus->xsh);
691
692 va_start(ap, fmt);
693 rc = xs_node_vscanf(xenbus->xsh, XBT_NULL, xendev->frontend_path, key,
694 NULL, fmt, ap);
695 va_end(ap);
696
697 return rc;
698}
699
700static void xen_device_frontend_set_state(XenDevice *xendev,
701 enum xenbus_state state)
702{
703 const char *type = object_get_typename(OBJECT(xendev));
704
705 if (xendev->frontend_state == state) {
706 return;
707 }
708
709 trace_xen_device_frontend_state(type, xendev->name,
710 xs_strstate(state));
711
712 xendev->frontend_state = state;
713 xen_device_frontend_printf(xendev, "state", "%u", state);
714}
715
716static void xen_device_frontend_changed(void *opaque)
717{
718 XenDevice *xendev = opaque;
719 XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev);
720 const char *type = object_get_typename(OBJECT(xendev));
721 enum xenbus_state state;
722
723 trace_xen_device_frontend_changed(type, xendev->name);
724
725 if (xen_device_frontend_scanf(xendev, "state", "%u", &state) != 1) {
726 state = XenbusStateUnknown;
727 }
728
729 xen_device_frontend_set_state(xendev, state);
730
731 if (state == XenbusStateInitialising &&
732 xendev->backend_state == XenbusStateClosed &&
733 xendev->backend_online) {
734
735
736
737
738 xen_device_backend_set_state(xendev, XenbusStateInitWait);
739 return;
740 }
741
742 if (xendev_class->frontend_changed) {
743 Error *local_err = NULL;
744
745 xendev_class->frontend_changed(xendev, state, &local_err);
746
747 if (local_err) {
748 error_reportf_err(local_err, "frontend change error: ");
749 }
750 }
751}
752
753static void xen_device_frontend_create(XenDevice *xendev, Error **errp)
754{
755 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
756 struct xs_permissions perms[2];
757 Error *local_err = NULL;
758
759 xendev->frontend_path = xen_device_get_frontend_path(xendev);
760
761 perms[0].id = xendev->frontend_id;
762 perms[0].perms = XS_PERM_NONE;
763 perms[1].id = xenbus->backend_id;
764 perms[1].perms = XS_PERM_READ | XS_PERM_WRITE;
765
766 g_assert(xenbus->xsh);
767
768 xs_node_create(xenbus->xsh, XBT_NULL, xendev->frontend_path, perms,
769 ARRAY_SIZE(perms), &local_err);
770 if (local_err) {
771 error_propagate_prepend(errp, local_err,
772 "failed to create frontend: ");
773 return;
774 }
775
776 xendev->frontend_state_watch =
777 xen_bus_add_watch(xenbus, xendev->frontend_path, "state",
778 xen_device_frontend_changed, xendev, &local_err);
779 if (local_err) {
780 error_propagate_prepend(errp, local_err,
781 "failed to watch frontend state: ");
782 }
783}
784
785static void xen_device_frontend_destroy(XenDevice *xendev)
786{
787 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
788 Error *local_err = NULL;
789
790 if (xendev->frontend_state_watch) {
791 xen_bus_remove_watch(xenbus, xendev->frontend_state_watch, NULL);
792 xendev->frontend_state_watch = NULL;
793 }
794
795 if (!xendev->frontend_path) {
796 return;
797 }
798
799 g_assert(xenbus->xsh);
800
801 xs_node_destroy(xenbus->xsh, XBT_NULL, xendev->frontend_path,
802 &local_err);
803 g_free(xendev->frontend_path);
804 xendev->frontend_path = NULL;
805
806 if (local_err) {
807 error_report_err(local_err);
808 }
809}
810
811void xen_device_set_max_grant_refs(XenDevice *xendev, unsigned int nr_refs,
812 Error **errp)
813{
814 if (xengnttab_set_max_grants(xendev->xgth, nr_refs)) {
815 error_setg_errno(errp, errno, "xengnttab_set_max_grants failed");
816 }
817}
818
819void *xen_device_map_grant_refs(XenDevice *xendev, uint32_t *refs,
820 unsigned int nr_refs, int prot,
821 Error **errp)
822{
823 void *map = xengnttab_map_domain_grant_refs(xendev->xgth, nr_refs,
824 xendev->frontend_id, refs,
825 prot);
826
827 if (!map) {
828 error_setg_errno(errp, errno,
829 "xengnttab_map_domain_grant_refs failed");
830 }
831
832 return map;
833}
834
835void xen_device_unmap_grant_refs(XenDevice *xendev, void *map,
836 unsigned int nr_refs, Error **errp)
837{
838 if (xengnttab_unmap(xendev->xgth, map, nr_refs)) {
839 error_setg_errno(errp, errno, "xengnttab_unmap failed");
840 }
841}
842
843static void compat_copy_grant_refs(XenDevice *xendev, bool to_domain,
844 XenDeviceGrantCopySegment segs[],
845 unsigned int nr_segs, Error **errp)
846{
847 uint32_t *refs = g_new(uint32_t, nr_segs);
848 int prot = to_domain ? PROT_WRITE : PROT_READ;
849 void *map;
850 unsigned int i;
851
852 for (i = 0; i < nr_segs; i++) {
853 XenDeviceGrantCopySegment *seg = &segs[i];
854
855 refs[i] = to_domain ? seg->dest.foreign.ref :
856 seg->source.foreign.ref;
857 }
858
859 map = xengnttab_map_domain_grant_refs(xendev->xgth, nr_segs,
860 xendev->frontend_id, refs,
861 prot);
862 if (!map) {
863 error_setg_errno(errp, errno,
864 "xengnttab_map_domain_grant_refs failed");
865 goto done;
866 }
867
868 for (i = 0; i < nr_segs; i++) {
869 XenDeviceGrantCopySegment *seg = &segs[i];
870 void *page = map + (i * XC_PAGE_SIZE);
871
872 if (to_domain) {
873 memcpy(page + seg->dest.foreign.offset, seg->source.virt,
874 seg->len);
875 } else {
876 memcpy(seg->dest.virt, page + seg->source.foreign.offset,
877 seg->len);
878 }
879 }
880
881 if (xengnttab_unmap(xendev->xgth, map, nr_segs)) {
882 error_setg_errno(errp, errno, "xengnttab_unmap failed");
883 }
884
885done:
886 g_free(refs);
887}
888
889void xen_device_copy_grant_refs(XenDevice *xendev, bool to_domain,
890 XenDeviceGrantCopySegment segs[],
891 unsigned int nr_segs, Error **errp)
892{
893 xengnttab_grant_copy_segment_t *xengnttab_segs;
894 unsigned int i;
895
896 if (!xendev->feature_grant_copy) {
897 compat_copy_grant_refs(xendev, to_domain, segs, nr_segs, errp);
898 return;
899 }
900
901 xengnttab_segs = g_new0(xengnttab_grant_copy_segment_t, nr_segs);
902
903 for (i = 0; i < nr_segs; i++) {
904 XenDeviceGrantCopySegment *seg = &segs[i];
905 xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i];
906
907 if (to_domain) {
908 xengnttab_seg->flags = GNTCOPY_dest_gref;
909 xengnttab_seg->dest.foreign.domid = xendev->frontend_id;
910 xengnttab_seg->dest.foreign.ref = seg->dest.foreign.ref;
911 xengnttab_seg->dest.foreign.offset = seg->dest.foreign.offset;
912 xengnttab_seg->source.virt = seg->source.virt;
913 } else {
914 xengnttab_seg->flags = GNTCOPY_source_gref;
915 xengnttab_seg->source.foreign.domid = xendev->frontend_id;
916 xengnttab_seg->source.foreign.ref = seg->source.foreign.ref;
917 xengnttab_seg->source.foreign.offset =
918 seg->source.foreign.offset;
919 xengnttab_seg->dest.virt = seg->dest.virt;
920 }
921
922 xengnttab_seg->len = seg->len;
923 }
924
925 if (xengnttab_grant_copy(xendev->xgth, nr_segs, xengnttab_segs)) {
926 error_setg_errno(errp, errno, "xengnttab_grant_copy failed");
927 goto done;
928 }
929
930 for (i = 0; i < nr_segs; i++) {
931 xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i];
932
933 if (xengnttab_seg->status != GNTST_okay) {
934 error_setg(errp, "xengnttab_grant_copy seg[%u] failed", i);
935 break;
936 }
937 }
938
939done:
940 g_free(xengnttab_segs);
941}
942
943struct XenEventChannel {
944 QLIST_ENTRY(XenEventChannel) list;
945 AioContext *ctx;
946 xenevtchn_handle *xeh;
947 evtchn_port_t local_port;
948 XenEventHandler handler;
949 void *opaque;
950};
951
952static bool xen_device_poll(void *opaque)
953{
954 XenEventChannel *channel = opaque;
955
956 return channel->handler(channel->opaque);
957}
958
959static void xen_device_event(void *opaque)
960{
961 XenEventChannel *channel = opaque;
962 unsigned long port = xenevtchn_pending(channel->xeh);
963
964 if (port == channel->local_port) {
965 xen_device_poll(channel);
966
967 xenevtchn_unmask(channel->xeh, port);
968 }
969}
970
971XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev,
972 AioContext *ctx,
973 unsigned int port,
974 XenEventHandler handler,
975 void *opaque, Error **errp)
976{
977 XenEventChannel *channel = g_new0(XenEventChannel, 1);
978 xenevtchn_port_or_error_t local_port;
979
980 channel->xeh = xenevtchn_open(NULL, 0);
981 if (!channel->xeh) {
982 error_setg_errno(errp, errno, "failed xenevtchn_open");
983 goto fail;
984 }
985
986 local_port = xenevtchn_bind_interdomain(channel->xeh,
987 xendev->frontend_id,
988 port);
989 if (local_port < 0) {
990 error_setg_errno(errp, errno, "xenevtchn_bind_interdomain failed");
991 goto fail;
992 }
993
994 channel->local_port = local_port;
995 channel->handler = handler;
996 channel->opaque = opaque;
997
998 channel->ctx = ctx;
999 aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
1000 xen_device_event, NULL, xen_device_poll, channel);
1001
1002 QLIST_INSERT_HEAD(&xendev->event_channels, channel, list);
1003
1004 return channel;
1005
1006fail:
1007 if (channel->xeh) {
1008 xenevtchn_close(channel->xeh);
1009 }
1010
1011 g_free(channel);
1012
1013 return NULL;
1014}
1015
1016void xen_device_notify_event_channel(XenDevice *xendev,
1017 XenEventChannel *channel,
1018 Error **errp)
1019{
1020 if (!channel) {
1021 error_setg(errp, "bad channel");
1022 return;
1023 }
1024
1025 if (xenevtchn_notify(channel->xeh, channel->local_port) < 0) {
1026 error_setg_errno(errp, errno, "xenevtchn_notify failed");
1027 }
1028}
1029
1030void xen_device_unbind_event_channel(XenDevice *xendev,
1031 XenEventChannel *channel,
1032 Error **errp)
1033{
1034 if (!channel) {
1035 error_setg(errp, "bad channel");
1036 return;
1037 }
1038
1039 QLIST_REMOVE(channel, list);
1040
1041 aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
1042 NULL, NULL, NULL, NULL);
1043
1044 if (xenevtchn_unbind(channel->xeh, channel->local_port) < 0) {
1045 error_setg_errno(errp, errno, "xenevtchn_unbind failed");
1046 }
1047
1048 xenevtchn_close(channel->xeh);
1049 g_free(channel);
1050}
1051
1052static void xen_device_unrealize(DeviceState *dev, Error **errp)
1053{
1054 XenDevice *xendev = XEN_DEVICE(dev);
1055 XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev);
1056 const char *type = object_get_typename(OBJECT(xendev));
1057 XenEventChannel *channel, *next;
1058
1059 if (!xendev->name) {
1060 return;
1061 }
1062
1063 trace_xen_device_unrealize(type, xendev->name);
1064
1065 if (xendev->exit.notify) {
1066 qemu_remove_exit_notifier(&xendev->exit);
1067 xendev->exit.notify = NULL;
1068 }
1069
1070 if (xendev_class->unrealize) {
1071 xendev_class->unrealize(xendev, errp);
1072 }
1073
1074
1075 QLIST_FOREACH_SAFE(channel, &xendev->event_channels, list, next) {
1076 xen_device_unbind_event_channel(xendev, channel, NULL);
1077 }
1078
1079 xen_device_frontend_destroy(xendev);
1080 xen_device_backend_destroy(xendev);
1081
1082 if (xendev->xgth) {
1083 xengnttab_close(xendev->xgth);
1084 xendev->xgth = NULL;
1085 }
1086
1087 g_free(xendev->name);
1088 xendev->name = NULL;
1089}
1090
1091static void xen_device_exit(Notifier *n, void *data)
1092{
1093 XenDevice *xendev = container_of(n, XenDevice, exit);
1094
1095 xen_device_unrealize(DEVICE(xendev), &error_abort);
1096}
1097
1098static void xen_device_realize(DeviceState *dev, Error **errp)
1099{
1100 XenDevice *xendev = XEN_DEVICE(dev);
1101 XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev);
1102 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
1103 const char *type = object_get_typename(OBJECT(xendev));
1104 Error *local_err = NULL;
1105
1106 if (xendev->frontend_id == DOMID_INVALID) {
1107 xendev->frontend_id = xen_domid;
1108 }
1109
1110 if (xendev->frontend_id >= DOMID_FIRST_RESERVED) {
1111 error_setg(errp, "invalid frontend-id");
1112 goto unrealize;
1113 }
1114
1115 if (!xendev_class->get_name) {
1116 error_setg(errp, "get_name method not implemented");
1117 goto unrealize;
1118 }
1119
1120 xendev->name = xendev_class->get_name(xendev, &local_err);
1121 if (local_err) {
1122 error_propagate_prepend(errp, local_err,
1123 "failed to get device name: ");
1124 goto unrealize;
1125 }
1126
1127 trace_xen_device_realize(type, xendev->name);
1128
1129 xendev->xgth = xengnttab_open(NULL, 0);
1130 if (!xendev->xgth) {
1131 error_setg_errno(errp, errno, "failed xengnttab_open");
1132 goto unrealize;
1133 }
1134
1135 xendev->feature_grant_copy =
1136 (xengnttab_grant_copy(xendev->xgth, 0, NULL) == 0);
1137
1138 xen_device_backend_create(xendev, &local_err);
1139 if (local_err) {
1140 error_propagate(errp, local_err);
1141 goto unrealize;
1142 }
1143
1144 xen_device_frontend_create(xendev, &local_err);
1145 if (local_err) {
1146 error_propagate(errp, local_err);
1147 goto unrealize;
1148 }
1149
1150 if (xendev_class->realize) {
1151 xendev_class->realize(xendev, &local_err);
1152 if (local_err) {
1153 error_propagate(errp, local_err);
1154 goto unrealize;
1155 }
1156 }
1157
1158 xen_device_backend_printf(xendev, "frontend", "%s",
1159 xendev->frontend_path);
1160 xen_device_backend_printf(xendev, "frontend-id", "%u",
1161 xendev->frontend_id);
1162 xen_device_backend_printf(xendev, "hotplug-status", "connected");
1163
1164 xen_device_backend_set_online(xendev, true);
1165 xen_device_backend_set_state(xendev, XenbusStateInitWait);
1166
1167 xen_device_frontend_printf(xendev, "backend", "%s",
1168 xendev->backend_path);
1169 xen_device_frontend_printf(xendev, "backend-id", "%u",
1170 xenbus->backend_id);
1171
1172 xen_device_frontend_set_state(xendev, XenbusStateInitialising);
1173
1174 xendev->exit.notify = xen_device_exit;
1175 qemu_add_exit_notifier(&xendev->exit);
1176 return;
1177
1178unrealize:
1179 xen_device_unrealize(dev, &error_abort);
1180}
1181
1182static Property xen_device_props[] = {
1183 DEFINE_PROP_UINT16("frontend-id", XenDevice, frontend_id,
1184 DOMID_INVALID),
1185 DEFINE_PROP_END_OF_LIST()
1186};
1187
1188static void xen_device_class_init(ObjectClass *class, void *data)
1189{
1190 DeviceClass *dev_class = DEVICE_CLASS(class);
1191
1192 dev_class->realize = xen_device_realize;
1193 dev_class->unrealize = xen_device_unrealize;
1194 dev_class->props = xen_device_props;
1195 dev_class->bus_type = TYPE_XEN_BUS;
1196}
1197
1198static const TypeInfo xen_device_type_info = {
1199 .name = TYPE_XEN_DEVICE,
1200 .parent = TYPE_DEVICE,
1201 .instance_size = sizeof(XenDevice),
1202 .abstract = true,
1203 .class_size = sizeof(XenDeviceClass),
1204 .class_init = xen_device_class_init,
1205};
1206
1207typedef struct XenBridge {
1208 SysBusDevice busdev;
1209} XenBridge;
1210
1211#define TYPE_XEN_BRIDGE "xen-bridge"
1212
1213static const TypeInfo xen_bridge_type_info = {
1214 .name = TYPE_XEN_BRIDGE,
1215 .parent = TYPE_SYS_BUS_DEVICE,
1216 .instance_size = sizeof(XenBridge),
1217};
1218
1219static void xen_register_types(void)
1220{
1221 type_register_static(&xen_bridge_type_info);
1222 type_register_static(&xen_bus_type_info);
1223 type_register_static(&xen_device_type_info);
1224}
1225
1226type_init(xen_register_types)
1227
1228void xen_bus_init(void)
1229{
1230 DeviceState *dev = qdev_create(NULL, TYPE_XEN_BRIDGE);
1231 BusState *bus = qbus_create(TYPE_XEN_BUS, dev, NULL);
1232
1233 qdev_init_nofail(dev);
1234 qbus_set_bus_hotplug_handler(bus, &error_abort);
1235}
1236