2 * xen backend driver infrastructure
3 * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; under version 2 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, see <http://www.gnu.org/licenses/>.
17 * Contributions after 2012-01-13 are licensed under the terms of the
18 * GNU GPL, version 2 or (at your option) any later version.
22 * TODO: add some xenbus / xenstore concepts overview here.
25 #include "qemu/osdep.h"
26 #include <sys/signal.h>
29 #include "hw/sysbus.h"
30 #include "hw/boards.h"
32 #include "qapi/error.h"
33 #include "hw/xen/xen-legacy-backend.h"
34 #include "hw/xen/xen_pvdev.h"
35 #include "monitor/qdev.h"
37 DeviceState
*xen_sysdev
;
40 /* ------------------------------------------------------------- */
43 struct xs_handle
*xenstore
;
44 const char *xen_protocol
;
47 static bool xen_feature_grant_copy
;
50 int xenstore_write_be_str(struct XenLegacyDevice
*xendev
, const char *node
,
53 return xenstore_write_str(xendev
->be
, node
, val
);
56 int xenstore_write_be_int(struct XenLegacyDevice
*xendev
, const char *node
,
59 return xenstore_write_int(xendev
->be
, node
, ival
);
62 int xenstore_write_be_int64(struct XenLegacyDevice
*xendev
, const char *node
,
65 return xenstore_write_int64(xendev
->be
, node
, ival
);
68 char *xenstore_read_be_str(struct XenLegacyDevice
*xendev
, const char *node
)
70 return xenstore_read_str(xendev
->be
, node
);
73 int xenstore_read_be_int(struct XenLegacyDevice
*xendev
, const char *node
,
76 return xenstore_read_int(xendev
->be
, node
, ival
);
79 char *xenstore_read_fe_str(struct XenLegacyDevice
*xendev
, const char *node
)
81 return xenstore_read_str(xendev
->fe
, node
);
84 int xenstore_read_fe_int(struct XenLegacyDevice
*xendev
, const char *node
,
87 return xenstore_read_int(xendev
->fe
, node
, ival
);
90 int xenstore_read_fe_uint64(struct XenLegacyDevice
*xendev
, const char *node
,
93 return xenstore_read_uint64(xendev
->fe
, node
, uval
);
96 /* ------------------------------------------------------------- */
98 int xen_be_set_state(struct XenLegacyDevice
*xendev
, enum xenbus_state state
)
102 rc
= xenstore_write_be_int(xendev
, "state", state
);
106 xen_pv_printf(xendev
, 1, "backend state: %s -> %s\n",
107 xenbus_strstate(xendev
->be_state
), xenbus_strstate(state
));
108 xendev
->be_state
= state
;
112 void xen_be_set_max_grant_refs(struct XenLegacyDevice
*xendev
,
113 unsigned int nr_refs
)
115 assert(xendev
->ops
->flags
& DEVOPS_FLAG_NEED_GNTDEV
);
117 if (xengnttab_set_max_grants(xendev
->gnttabdev
, nr_refs
)) {
118 xen_pv_printf(xendev
, 0, "xengnttab_set_max_grants failed: %s\n",
123 void *xen_be_map_grant_refs(struct XenLegacyDevice
*xendev
, uint32_t *refs
,
124 unsigned int nr_refs
, int prot
)
128 assert(xendev
->ops
->flags
& DEVOPS_FLAG_NEED_GNTDEV
);
130 ptr
= xengnttab_map_domain_grant_refs(xendev
->gnttabdev
, nr_refs
,
131 xen_domid
, refs
, prot
);
133 xen_pv_printf(xendev
, 0,
134 "xengnttab_map_domain_grant_refs failed: %s\n",
141 void xen_be_unmap_grant_refs(struct XenLegacyDevice
*xendev
, void *ptr
,
142 unsigned int nr_refs
)
144 assert(xendev
->ops
->flags
& DEVOPS_FLAG_NEED_GNTDEV
);
146 if (xengnttab_unmap(xendev
->gnttabdev
, ptr
, nr_refs
)) {
147 xen_pv_printf(xendev
, 0, "xengnttab_unmap failed: %s\n",
152 static int compat_copy_grant_refs(struct XenLegacyDevice
*xendev
,
154 XenGrantCopySegment segs
[],
155 unsigned int nr_segs
)
157 uint32_t *refs
= g_new(uint32_t, nr_segs
);
158 int prot
= to_domain
? PROT_WRITE
: PROT_READ
;
162 for (i
= 0; i
< nr_segs
; i
++) {
163 XenGrantCopySegment
*seg
= &segs
[i
];
165 refs
[i
] = to_domain
?
166 seg
->dest
.foreign
.ref
: seg
->source
.foreign
.ref
;
169 pages
= xengnttab_map_domain_grant_refs(xendev
->gnttabdev
, nr_segs
,
170 xen_domid
, refs
, prot
);
172 xen_pv_printf(xendev
, 0,
173 "xengnttab_map_domain_grant_refs failed: %s\n",
179 for (i
= 0; i
< nr_segs
; i
++) {
180 XenGrantCopySegment
*seg
= &segs
[i
];
181 void *page
= pages
+ (i
* XC_PAGE_SIZE
);
184 memcpy(page
+ seg
->dest
.foreign
.offset
, seg
->source
.virt
,
187 memcpy(seg
->dest
.virt
, page
+ seg
->source
.foreign
.offset
,
192 if (xengnttab_unmap(xendev
->gnttabdev
, pages
, nr_segs
)) {
193 xen_pv_printf(xendev
, 0, "xengnttab_unmap failed: %s\n",
201 int xen_be_copy_grant_refs(struct XenLegacyDevice
*xendev
,
203 XenGrantCopySegment segs
[],
204 unsigned int nr_segs
)
206 xengnttab_grant_copy_segment_t
*xengnttab_segs
;
210 assert(xendev
->ops
->flags
& DEVOPS_FLAG_NEED_GNTDEV
);
212 if (!xen_feature_grant_copy
) {
213 return compat_copy_grant_refs(xendev
, to_domain
, segs
, nr_segs
);
216 xengnttab_segs
= g_new0(xengnttab_grant_copy_segment_t
, nr_segs
);
218 for (i
= 0; i
< nr_segs
; i
++) {
219 XenGrantCopySegment
*seg
= &segs
[i
];
220 xengnttab_grant_copy_segment_t
*xengnttab_seg
= &xengnttab_segs
[i
];
223 xengnttab_seg
->flags
= GNTCOPY_dest_gref
;
224 xengnttab_seg
->dest
.foreign
.domid
= xen_domid
;
225 xengnttab_seg
->dest
.foreign
.ref
= seg
->dest
.foreign
.ref
;
226 xengnttab_seg
->dest
.foreign
.offset
= seg
->dest
.foreign
.offset
;
227 xengnttab_seg
->source
.virt
= seg
->source
.virt
;
229 xengnttab_seg
->flags
= GNTCOPY_source_gref
;
230 xengnttab_seg
->source
.foreign
.domid
= xen_domid
;
231 xengnttab_seg
->source
.foreign
.ref
= seg
->source
.foreign
.ref
;
232 xengnttab_seg
->source
.foreign
.offset
=
233 seg
->source
.foreign
.offset
;
234 xengnttab_seg
->dest
.virt
= seg
->dest
.virt
;
237 xengnttab_seg
->len
= seg
->len
;
240 rc
= xengnttab_grant_copy(xendev
->gnttabdev
, nr_segs
, xengnttab_segs
);
243 xen_pv_printf(xendev
, 0, "xengnttab_copy failed: %s\n",
247 for (i
= 0; i
< nr_segs
; i
++) {
248 xengnttab_grant_copy_segment_t
*xengnttab_seg
=
251 if (xengnttab_seg
->status
!= GNTST_okay
) {
252 xen_pv_printf(xendev
, 0, "segment[%u] status: %d\n", i
,
253 xengnttab_seg
->status
);
258 g_free(xengnttab_segs
);
263 * get xen backend device, allocate a new one if it doesn't exist.
265 static struct XenLegacyDevice
*xen_be_get_xendev(const char *type
, int dom
,
267 struct XenDevOps
*ops
)
269 struct XenLegacyDevice
*xendev
;
271 xendev
= xen_pv_find_xendev(type
, dom
, dev
);
276 /* init new xendev */
277 xendev
= g_malloc0(ops
->size
);
278 object_initialize(&xendev
->qdev
, ops
->size
, TYPE_XENBACKEND
);
279 OBJECT(xendev
)->free
= g_free
;
280 qdev_set_parent_bus(DEVICE(xendev
), xen_sysbus
);
281 qdev_set_id(DEVICE(xendev
), g_strdup_printf("xen-%s-%d", type
, dev
));
282 qdev_init_nofail(DEVICE(xendev
));
283 object_unref(OBJECT(xendev
));
290 snprintf(xendev
->be
, sizeof(xendev
->be
), "backend/%s/%d/%d",
291 xendev
->type
, xendev
->dom
, xendev
->dev
);
292 snprintf(xendev
->name
, sizeof(xendev
->name
), "%s-%d",
293 xendev
->type
, xendev
->dev
);
295 xendev
->debug
= debug
;
296 xendev
->local_port
= -1;
298 xendev
->evtchndev
= xenevtchn_open(NULL
, 0);
299 if (xendev
->evtchndev
== NULL
) {
300 xen_pv_printf(NULL
, 0, "can't open evtchn device\n");
301 qdev_unplug(DEVICE(xendev
), NULL
);
304 qemu_set_cloexec(xenevtchn_fd(xendev
->evtchndev
));
306 xen_pv_insert_xendev(xendev
);
308 if (xendev
->ops
->alloc
) {
309 xendev
->ops
->alloc(xendev
);
317 * Sync internal data structures on xenstore updates.
318 * Node specifies the changed field. node = NULL means
319 * update all fields (used for initialization).
321 static void xen_be_backend_changed(struct XenLegacyDevice
*xendev
,
324 if (node
== NULL
|| strcmp(node
, "online") == 0) {
325 if (xenstore_read_be_int(xendev
, "online", &xendev
->online
) == -1) {
331 xen_pv_printf(xendev
, 2, "backend update: %s\n", node
);
332 if (xendev
->ops
->backend_changed
) {
333 xendev
->ops
->backend_changed(xendev
, node
);
338 static void xen_be_frontend_changed(struct XenLegacyDevice
*xendev
,
343 if (node
== NULL
|| strcmp(node
, "state") == 0) {
344 if (xenstore_read_fe_int(xendev
, "state", &fe_state
) == -1) {
345 fe_state
= XenbusStateUnknown
;
347 if (xendev
->fe_state
!= fe_state
) {
348 xen_pv_printf(xendev
, 1, "frontend state: %s -> %s\n",
349 xenbus_strstate(xendev
->fe_state
),
350 xenbus_strstate(fe_state
));
352 xendev
->fe_state
= fe_state
;
354 if (node
== NULL
|| strcmp(node
, "protocol") == 0) {
355 g_free(xendev
->protocol
);
356 xendev
->protocol
= xenstore_read_fe_str(xendev
, "protocol");
357 if (xendev
->protocol
) {
358 xen_pv_printf(xendev
, 1, "frontend protocol: %s\n",
364 xen_pv_printf(xendev
, 2, "frontend update: %s\n", node
);
365 if (xendev
->ops
->frontend_changed
) {
366 xendev
->ops
->frontend_changed(xendev
, node
);
371 /* ------------------------------------------------------------- */
372 /* Check for possible state transitions and perform them. */
375 * Initial xendev setup. Read frontend path, register watch for it.
376 * Should succeed once xend finished setting up the backend device.
378 * Also sets initial state (-> Initializing) when done. Which
379 * only affects the xendev->be_state variable as xenbus should
380 * already be put into that state by xend.
382 static int xen_be_try_setup(struct XenLegacyDevice
*xendev
)
384 char token
[XEN_BUFSIZE
];
387 if (xenstore_read_be_int(xendev
, "state", &be_state
) == -1) {
388 xen_pv_printf(xendev
, 0, "reading backend state failed\n");
392 if (be_state
!= XenbusStateInitialising
) {
393 xen_pv_printf(xendev
, 0, "initial backend state is wrong (%s)\n",
394 xenbus_strstate(be_state
));
398 xendev
->fe
= xenstore_read_be_str(xendev
, "frontend");
399 if (xendev
->fe
== NULL
) {
400 xen_pv_printf(xendev
, 0, "reading frontend path failed\n");
404 /* setup frontend watch */
405 snprintf(token
, sizeof(token
), "fe:%p", xendev
);
406 if (!xs_watch(xenstore
, xendev
->fe
, token
)) {
407 xen_pv_printf(xendev
, 0, "watching frontend path (%s) failed\n",
411 xen_be_set_state(xendev
, XenbusStateInitialising
);
413 xen_be_backend_changed(xendev
, NULL
);
414 xen_be_frontend_changed(xendev
, NULL
);
419 * Try initialize xendev. Prepare everything the backend can do
420 * without synchronizing with the frontend. Fakes hotplug-status. No
421 * hotplug involved here because this is about userspace drivers, thus
422 * there are kernel backend devices which could invoke hotplug.
424 * Goes to InitWait on success.
426 static int xen_be_try_init(struct XenLegacyDevice
*xendev
)
430 if (!xendev
->online
) {
431 xen_pv_printf(xendev
, 1, "not online\n");
435 if (xendev
->ops
->init
) {
436 rc
= xendev
->ops
->init(xendev
);
439 xen_pv_printf(xendev
, 1, "init() failed\n");
443 xenstore_write_be_str(xendev
, "hotplug-status", "connected");
444 xen_be_set_state(xendev
, XenbusStateInitWait
);
449 * Try to initialise xendev. Depends on the frontend being ready
450 * for it (shared ring and evtchn info in xenstore, state being
451 * Initialised or Connected).
453 * Goes to Connected on success.
455 static int xen_be_try_initialise(struct XenLegacyDevice
*xendev
)
459 if (xendev
->fe_state
!= XenbusStateInitialised
&&
460 xendev
->fe_state
!= XenbusStateConnected
) {
461 if (xendev
->ops
->flags
& DEVOPS_FLAG_IGNORE_STATE
) {
462 xen_pv_printf(xendev
, 2, "frontend not ready, ignoring\n");
464 xen_pv_printf(xendev
, 2, "frontend not ready (yet)\n");
469 if (xendev
->ops
->flags
& DEVOPS_FLAG_NEED_GNTDEV
) {
470 xendev
->gnttabdev
= xengnttab_open(NULL
, 0);
471 if (xendev
->gnttabdev
== NULL
) {
472 xen_pv_printf(NULL
, 0, "can't open gnttab device\n");
476 xendev
->gnttabdev
= NULL
;
479 if (xendev
->ops
->initialise
) {
480 rc
= xendev
->ops
->initialise(xendev
);
483 xen_pv_printf(xendev
, 0, "initialise() failed\n");
487 xen_be_set_state(xendev
, XenbusStateConnected
);
492 * Try to let xendev know that it is connected. Depends on the
493 * frontend being Connected. Note that this may be called more
494 * than once since the backend state is not modified.
496 static void xen_be_try_connected(struct XenLegacyDevice
*xendev
)
498 if (!xendev
->ops
->connected
) {
502 if (xendev
->fe_state
!= XenbusStateConnected
) {
503 if (xendev
->ops
->flags
& DEVOPS_FLAG_IGNORE_STATE
) {
504 xen_pv_printf(xendev
, 2, "frontend not ready, ignoring\n");
506 xen_pv_printf(xendev
, 2, "frontend not ready (yet)\n");
511 xendev
->ops
->connected(xendev
);
515 * Teardown connection.
517 * Goes to Closed when done.
519 static void xen_be_disconnect(struct XenLegacyDevice
*xendev
,
520 enum xenbus_state state
)
522 if (xendev
->be_state
!= XenbusStateClosing
&&
523 xendev
->be_state
!= XenbusStateClosed
&&
524 xendev
->ops
->disconnect
) {
525 xendev
->ops
->disconnect(xendev
);
527 if (xendev
->gnttabdev
) {
528 xengnttab_close(xendev
->gnttabdev
);
529 xendev
->gnttabdev
= NULL
;
531 if (xendev
->be_state
!= state
) {
532 xen_be_set_state(xendev
, state
);
537 * Try to reset xendev, for reconnection by another frontend instance.
539 static int xen_be_try_reset(struct XenLegacyDevice
*xendev
)
541 if (xendev
->fe_state
!= XenbusStateInitialising
) {
545 xen_pv_printf(xendev
, 1, "device reset (for re-connect)\n");
546 xen_be_set_state(xendev
, XenbusStateInitialising
);
551 * state change dispatcher function
553 void xen_be_check_state(struct XenLegacyDevice
*xendev
)
557 /* frontend may request shutdown from almost anywhere */
558 if (xendev
->fe_state
== XenbusStateClosing
||
559 xendev
->fe_state
== XenbusStateClosed
) {
560 xen_be_disconnect(xendev
, xendev
->fe_state
);
564 /* check for possible backend state transitions */
566 switch (xendev
->be_state
) {
567 case XenbusStateUnknown
:
568 rc
= xen_be_try_setup(xendev
);
570 case XenbusStateInitialising
:
571 rc
= xen_be_try_init(xendev
);
573 case XenbusStateInitWait
:
574 rc
= xen_be_try_initialise(xendev
);
576 case XenbusStateConnected
:
577 /* xendev->be_state doesn't change */
578 xen_be_try_connected(xendev
);
581 case XenbusStateClosed
:
582 rc
= xen_be_try_reset(xendev
);
593 /* ------------------------------------------------------------- */
595 static int xenstore_scan(const char *type
, int dom
, struct XenDevOps
*ops
)
597 struct XenLegacyDevice
*xendev
;
598 char path
[XEN_BUFSIZE
], token
[XEN_BUFSIZE
];
600 unsigned int cdev
, j
;
603 snprintf(token
, sizeof(token
), "be:%p:%d:%p", type
, dom
, ops
);
604 snprintf(path
, sizeof(path
), "backend/%s/%d", type
, dom
);
605 if (!xs_watch(xenstore
, path
, token
)) {
606 xen_pv_printf(NULL
, 0, "xen be: watching backend path (%s) failed\n",
611 /* look for backends */
612 dev
= xs_directory(xenstore
, 0, path
, &cdev
);
616 for (j
= 0; j
< cdev
; j
++) {
617 xendev
= xen_be_get_xendev(type
, dom
, atoi(dev
[j
]), ops
);
618 if (xendev
== NULL
) {
621 xen_be_check_state(xendev
);
627 void xenstore_update_be(char *watch
, char *type
, int dom
,
628 struct XenDevOps
*ops
)
630 struct XenLegacyDevice
*xendev
;
631 char path
[XEN_BUFSIZE
], *bepath
;
632 unsigned int len
, dev
;
634 len
= snprintf(path
, sizeof(path
), "backend/%s/%d", type
, dom
);
635 if (strncmp(path
, watch
, len
) != 0) {
638 if (sscanf(watch
+ len
, "/%u/%255s", &dev
, path
) != 2) {
640 if (sscanf(watch
+ len
, "/%u", &dev
) != 1) {
648 xendev
= xen_be_get_xendev(type
, dom
, dev
, ops
);
649 if (xendev
!= NULL
) {
650 bepath
= xs_read(xenstore
, 0, xendev
->be
, &len
);
651 if (bepath
== NULL
) {
652 xen_pv_del_xendev(xendev
);
655 xen_be_backend_changed(xendev
, path
);
656 xen_be_check_state(xendev
);
661 void xenstore_update_fe(char *watch
, struct XenLegacyDevice
*xendev
)
666 len
= strlen(xendev
->fe
);
667 if (strncmp(xendev
->fe
, watch
, len
) != 0) {
670 if (watch
[len
] != '/') {
673 node
= watch
+ len
+ 1;
675 xen_be_frontend_changed(xendev
, node
);
676 xen_be_check_state(xendev
);
678 /* -------------------------------------------------------------------- */
680 int xen_be_init(void)
682 xengnttab_handle
*gnttabdev
;
684 xenstore
= xs_daemon_open();
686 xen_pv_printf(NULL
, 0, "can't connect to xenstored\n");
690 qemu_set_fd_handler(xs_fileno(xenstore
), xenstore_update
, NULL
, NULL
);
692 if (xen_xc
== NULL
|| xen_fmem
== NULL
) {
693 /* Check if xen_init() have been called */
697 gnttabdev
= xengnttab_open(NULL
, 0);
698 if (gnttabdev
!= NULL
) {
699 if (xengnttab_grant_copy(gnttabdev
, 0, NULL
) == 0) {
700 xen_feature_grant_copy
= true;
702 xengnttab_close(gnttabdev
);
705 xen_sysdev
= qdev_create(NULL
, TYPE_XENSYSDEV
);
706 qdev_init_nofail(xen_sysdev
);
707 xen_sysbus
= qbus_create(TYPE_XENSYSBUS
, DEVICE(xen_sysdev
), "xen-sysbus");
708 qbus_set_bus_hotplug_handler(xen_sysbus
, &error_abort
);
713 qemu_set_fd_handler(xs_fileno(xenstore
), NULL
, NULL
, NULL
);
714 xs_daemon_close(xenstore
);
720 static void xen_set_dynamic_sysbus(void)
722 Object
*machine
= qdev_get_machine();
723 ObjectClass
*oc
= object_get_class(machine
);
724 MachineClass
*mc
= MACHINE_CLASS(oc
);
726 machine_class_allow_dynamic_sysbus_dev(mc
, TYPE_XENSYSDEV
);
729 int xen_be_register(const char *type
, struct XenDevOps
*ops
)
734 if (ops
->backend_register
) {
735 rc
= ops
->backend_register();
741 snprintf(path
, sizeof(path
), "device-model/%u/backends/%s", xen_domid
,
743 xenstore_mkdir(path
, XS_PERM_NONE
);
745 return xenstore_scan(type
, xen_domid
, ops
);
748 void xen_be_register_common(void)
750 xen_set_dynamic_sysbus();
752 xen_be_register("console", &xen_console_ops
);
753 xen_be_register("vkbd", &xen_kbdmouse_ops
);
755 xen_be_register("9pfs", &xen_9pfs_ops
);
757 #ifdef CONFIG_USB_LIBUSB
758 xen_be_register("qusb", &xen_usb_ops
);
762 int xen_be_bind_evtchn(struct XenLegacyDevice
*xendev
)
764 if (xendev
->local_port
!= -1) {
767 xendev
->local_port
= xenevtchn_bind_interdomain
768 (xendev
->evtchndev
, xendev
->dom
, xendev
->remote_port
);
769 if (xendev
->local_port
== -1) {
770 xen_pv_printf(xendev
, 0, "xenevtchn_bind_interdomain failed\n");
773 xen_pv_printf(xendev
, 2, "bind evtchn port %d\n", xendev
->local_port
);
774 qemu_set_fd_handler(xenevtchn_fd(xendev
->evtchndev
),
775 xen_pv_evtchn_event
, NULL
, xendev
);
780 static Property xendev_properties
[] = {
781 DEFINE_PROP_END_OF_LIST(),
784 static void xendev_class_init(ObjectClass
*klass
, void *data
)
786 DeviceClass
*dc
= DEVICE_CLASS(klass
);
788 dc
->props
= xendev_properties
;
789 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
790 /* xen-backend devices can be plugged/unplugged dynamically */
791 dc
->user_creatable
= true;
794 static const TypeInfo xendev_type_info
= {
795 .name
= TYPE_XENBACKEND
,
796 .parent
= TYPE_XENSYSDEV
,
797 .class_init
= xendev_class_init
,
798 .instance_size
= sizeof(struct XenLegacyDevice
),
801 static void xen_sysbus_class_init(ObjectClass
*klass
, void *data
)
803 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
805 hc
->unplug
= qdev_simple_device_unplug_cb
;
808 static const TypeInfo xensysbus_info
= {
809 .name
= TYPE_XENSYSBUS
,
811 .class_init
= xen_sysbus_class_init
,
812 .interfaces
= (InterfaceInfo
[]) {
813 { TYPE_HOTPLUG_HANDLER
},
818 static Property xen_sysdev_properties
[] = {
819 {/* end of property list */},
822 static void xen_sysdev_class_init(ObjectClass
*klass
, void *data
)
824 DeviceClass
*dc
= DEVICE_CLASS(klass
);
826 dc
->props
= xen_sysdev_properties
;
827 dc
->bus_type
= TYPE_XENSYSBUS
;
830 static const TypeInfo xensysdev_info
= {
831 .name
= TYPE_XENSYSDEV
,
832 .parent
= TYPE_SYS_BUS_DEVICE
,
833 .instance_size
= sizeof(SysBusDevice
),
834 .class_init
= xen_sysdev_class_init
,
837 static void xenbe_register_types(void)
839 type_register_static(&xensysbus_info
);
840 type_register_static(&xensysdev_info
);
841 type_register_static(&xendev_type_info
);
844 type_init(xenbe_register_types
)