xref: /openbmc/qemu/hw/xen/xen-legacy-backend.c (revision 19c2d53c)
1 /*
2  *  xen backend driver infrastructure
3  *  (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
4  *
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.
8  *
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.
13  *
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/>.
16  *
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.
19  */
20 
21 /*
22  * TODO: add some xenbus / xenstore concepts overview here.
23  */
24 
25 #include "qemu/osdep.h"
26 
27 #include "hw/sysbus.h"
28 #include "hw/boards.h"
29 #include "hw/qdev-properties.h"
30 #include "qemu/main-loop.h"
31 #include "qapi/error.h"
32 #include "hw/xen/xen-legacy-backend.h"
33 #include "hw/xen/xen_pvdev.h"
34 #include "monitor/qdev.h"
35 
36 DeviceState *xen_sysdev;
37 BusState *xen_sysbus;
38 
39 /* ------------------------------------------------------------- */
40 
41 /* public */
42 struct qemu_xs_handle *xenstore;
43 const char *xen_protocol;
44 
45 /* private */
46 static int debug;
47 
xenstore_write_be_str(struct XenLegacyDevice * xendev,const char * node,const char * val)48 int xenstore_write_be_str(struct XenLegacyDevice *xendev, const char *node,
49                           const char *val)
50 {
51     return xenstore_write_str(xendev->be, node, val);
52 }
53 
xenstore_write_be_int(struct XenLegacyDevice * xendev,const char * node,int ival)54 int xenstore_write_be_int(struct XenLegacyDevice *xendev, const char *node,
55                           int ival)
56 {
57     return xenstore_write_int(xendev->be, node, ival);
58 }
59 
xenstore_write_be_int64(struct XenLegacyDevice * xendev,const char * node,int64_t ival)60 int xenstore_write_be_int64(struct XenLegacyDevice *xendev, const char *node,
61                             int64_t ival)
62 {
63     return xenstore_write_int64(xendev->be, node, ival);
64 }
65 
xenstore_read_be_str(struct XenLegacyDevice * xendev,const char * node)66 char *xenstore_read_be_str(struct XenLegacyDevice *xendev, const char *node)
67 {
68     return xenstore_read_str(xendev->be, node);
69 }
70 
xenstore_read_be_int(struct XenLegacyDevice * xendev,const char * node,int * ival)71 int xenstore_read_be_int(struct XenLegacyDevice *xendev, const char *node,
72                          int *ival)
73 {
74     return xenstore_read_int(xendev->be, node, ival);
75 }
76 
xenstore_read_fe_str(struct XenLegacyDevice * xendev,const char * node)77 char *xenstore_read_fe_str(struct XenLegacyDevice *xendev, const char *node)
78 {
79     return xenstore_read_str(xendev->fe, node);
80 }
81 
xenstore_read_fe_int(struct XenLegacyDevice * xendev,const char * node,int * ival)82 int xenstore_read_fe_int(struct XenLegacyDevice *xendev, const char *node,
83                          int *ival)
84 {
85     return xenstore_read_int(xendev->fe, node, ival);
86 }
87 
xenstore_read_fe_uint64(struct XenLegacyDevice * xendev,const char * node,uint64_t * uval)88 int xenstore_read_fe_uint64(struct XenLegacyDevice *xendev, const char *node,
89                             uint64_t *uval)
90 {
91     return xenstore_read_uint64(xendev->fe, node, uval);
92 }
93 
94 /* ------------------------------------------------------------- */
95 
xen_be_set_state(struct XenLegacyDevice * xendev,enum xenbus_state state)96 int xen_be_set_state(struct XenLegacyDevice *xendev, enum xenbus_state state)
97 {
98     int rc;
99 
100     rc = xenstore_write_be_int(xendev, "state", state);
101     if (rc < 0) {
102         return rc;
103     }
104     xen_pv_printf(xendev, 1, "backend state: %s -> %s\n",
105                   xenbus_strstate(xendev->be_state), xenbus_strstate(state));
106     xendev->be_state = state;
107     return 0;
108 }
109 
xen_be_set_max_grant_refs(struct XenLegacyDevice * xendev,unsigned int nr_refs)110 void xen_be_set_max_grant_refs(struct XenLegacyDevice *xendev,
111                                unsigned int nr_refs)
112 {
113     assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV);
114 
115     if (qemu_xen_gnttab_set_max_grants(xendev->gnttabdev, nr_refs)) {
116         xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n",
117                       strerror(errno));
118     }
119 }
120 
xen_be_map_grant_refs(struct XenLegacyDevice * xendev,uint32_t * refs,unsigned int nr_refs,int prot)121 void *xen_be_map_grant_refs(struct XenLegacyDevice *xendev, uint32_t *refs,
122                             unsigned int nr_refs, int prot)
123 {
124     void *ptr;
125 
126     assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV);
127 
128     ptr = qemu_xen_gnttab_map_refs(xendev->gnttabdev, nr_refs, xen_domid, refs,
129                                    prot);
130     if (!ptr) {
131         xen_pv_printf(xendev, 0,
132                       "xengnttab_map_domain_grant_refs failed: %s\n",
133                       strerror(errno));
134     }
135 
136     return ptr;
137 }
138 
xen_be_unmap_grant_refs(struct XenLegacyDevice * xendev,void * ptr,uint32_t * refs,unsigned int nr_refs)139 void xen_be_unmap_grant_refs(struct XenLegacyDevice *xendev, void *ptr,
140                              uint32_t *refs, unsigned int nr_refs)
141 {
142     assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV);
143 
144     if (qemu_xen_gnttab_unmap(xendev->gnttabdev, ptr, refs, nr_refs)) {
145         xen_pv_printf(xendev, 0, "xengnttab_unmap failed: %s\n",
146                       strerror(errno));
147     }
148 }
149 
xen_be_copy_grant_refs(struct XenLegacyDevice * xendev,bool to_domain,XenGrantCopySegment segs[],unsigned int nr_segs)150 int xen_be_copy_grant_refs(struct XenLegacyDevice *xendev,
151                            bool to_domain,
152                            XenGrantCopySegment segs[],
153                            unsigned int nr_segs)
154 {
155     int rc;
156 
157     assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV);
158 
159     rc = qemu_xen_gnttab_grant_copy(xendev->gnttabdev, to_domain, xen_domid,
160                                     segs, nr_segs, NULL);
161     if (rc) {
162         xen_pv_printf(xendev, 0, "xengnttab_grant_copy failed: %s\n",
163                       strerror(-rc));
164     }
165     return rc;
166 }
167 
168 /*
169  * get xen backend device, allocate a new one if it doesn't exist.
170  */
xen_be_get_xendev(const char * type,int dom,int dev,const struct XenDevOps * ops)171 static struct XenLegacyDevice *xen_be_get_xendev(const char *type, int dom,
172                                                  int dev,
173                                                  const struct XenDevOps *ops)
174 {
175     struct XenLegacyDevice *xendev;
176 
177     xendev = xen_pv_find_xendev(type, dom, dev);
178     if (xendev) {
179         return xendev;
180     }
181 
182     /* init new xendev */
183     xendev = g_malloc0(ops->size);
184     object_initialize(&xendev->qdev, ops->size, TYPE_XENBACKEND);
185     OBJECT(xendev)->free = g_free;
186     qdev_set_id(DEVICE(xendev), g_strdup_printf("xen-%s-%d", type, dev),
187                 &error_fatal);
188     qdev_realize(DEVICE(xendev), xen_sysbus, &error_fatal);
189     object_unref(OBJECT(xendev));
190 
191     xendev->type  = type;
192     xendev->dom   = dom;
193     xendev->dev   = dev;
194     xendev->ops   = ops;
195 
196     snprintf(xendev->be, sizeof(xendev->be), "backend/%s/%d/%d",
197              xendev->type, xendev->dom, xendev->dev);
198     snprintf(xendev->name, sizeof(xendev->name), "%s-%d",
199              xendev->type, xendev->dev);
200 
201     xendev->debug      = debug;
202     xendev->local_port = -1;
203 
204     xendev->evtchndev = qemu_xen_evtchn_open();
205     if (xendev->evtchndev == NULL) {
206         xen_pv_printf(NULL, 0, "can't open evtchn device\n");
207         qdev_unplug(DEVICE(xendev), NULL);
208         return NULL;
209     }
210     qemu_set_cloexec(qemu_xen_evtchn_fd(xendev->evtchndev));
211 
212     xen_pv_insert_xendev(xendev);
213 
214     if (xendev->ops->alloc) {
215         xendev->ops->alloc(xendev);
216     }
217 
218     return xendev;
219 }
220 
221 
222 /*
223  * Sync internal data structures on xenstore updates.
224  * Node specifies the changed field.  node = NULL means
225  * update all fields (used for initialization).
226  */
xen_be_backend_changed(struct XenLegacyDevice * xendev,const char * node)227 static void xen_be_backend_changed(struct XenLegacyDevice *xendev,
228                                    const char *node)
229 {
230     if (node == NULL  ||  strcmp(node, "online") == 0) {
231         if (xenstore_read_be_int(xendev, "online", &xendev->online) == -1) {
232             xendev->online = 0;
233         }
234     }
235 
236     if (node) {
237         xen_pv_printf(xendev, 2, "backend update: %s\n", node);
238         if (xendev->ops->backend_changed) {
239             xendev->ops->backend_changed(xendev, node);
240         }
241     }
242 }
243 
xen_be_frontend_changed(struct XenLegacyDevice * xendev,const char * node)244 static void xen_be_frontend_changed(struct XenLegacyDevice *xendev,
245                                     const char *node)
246 {
247     int fe_state;
248 
249     if (node == NULL  ||  strcmp(node, "state") == 0) {
250         if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
251             fe_state = XenbusStateUnknown;
252         }
253         if (xendev->fe_state != fe_state) {
254             xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n",
255                           xenbus_strstate(xendev->fe_state),
256                           xenbus_strstate(fe_state));
257         }
258         xendev->fe_state = fe_state;
259     }
260     if (node == NULL  ||  strcmp(node, "protocol") == 0) {
261         g_free(xendev->protocol);
262         xendev->protocol = xenstore_read_fe_str(xendev, "protocol");
263         if (xendev->protocol) {
264             xen_pv_printf(xendev, 1, "frontend protocol: %s\n",
265                           xendev->protocol);
266         }
267     }
268 
269     if (node) {
270         xen_pv_printf(xendev, 2, "frontend update: %s\n", node);
271         if (xendev->ops->frontend_changed) {
272             xendev->ops->frontend_changed(xendev, node);
273         }
274     }
275 }
276 
xenstore_update_fe(void * opaque,const char * watch)277 static void xenstore_update_fe(void *opaque, const char *watch)
278 {
279     struct XenLegacyDevice *xendev = opaque;
280     const char *node;
281     unsigned int len;
282 
283     len = strlen(xendev->fe);
284     if (strncmp(xendev->fe, watch, len) != 0) {
285         return;
286     }
287     if (watch[len] != '/') {
288         return;
289     }
290     node = watch + len + 1;
291 
292     xen_be_frontend_changed(xendev, node);
293     xen_be_check_state(xendev);
294 }
295 
296 /* ------------------------------------------------------------- */
297 /* Check for possible state transitions and perform them.        */
298 
299 /*
300  * Initial xendev setup.  Read frontend path, register watch for it.
301  * Should succeed once xend finished setting up the backend device.
302  *
303  * Also sets initial state (-> Initializing) when done.  Which
304  * only affects the xendev->be_state variable as xenbus should
305  * already be put into that state by xend.
306  */
xen_be_try_setup(struct XenLegacyDevice * xendev)307 static int xen_be_try_setup(struct XenLegacyDevice *xendev)
308 {
309     int be_state;
310 
311     if (xenstore_read_be_int(xendev, "state", &be_state) == -1) {
312         xen_pv_printf(xendev, 0, "reading backend state failed\n");
313         return -1;
314     }
315 
316     if (be_state != XenbusStateInitialising) {
317         xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n",
318                       xenbus_strstate(be_state));
319         return -1;
320     }
321 
322     xendev->fe = xenstore_read_be_str(xendev, "frontend");
323     if (xendev->fe == NULL) {
324         xen_pv_printf(xendev, 0, "reading frontend path failed\n");
325         return -1;
326     }
327 
328     /* setup frontend watch */
329     xendev->watch = qemu_xen_xs_watch(xenstore, xendev->fe, xenstore_update_fe,
330                                       xendev);
331     if (!xendev->watch) {
332         xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n",
333                       xendev->fe);
334         return -1;
335     }
336     xen_be_set_state(xendev, XenbusStateInitialising);
337 
338     xen_be_backend_changed(xendev, NULL);
339     xen_be_frontend_changed(xendev, NULL);
340     return 0;
341 }
342 
343 /*
344  * Try initialize xendev.  Prepare everything the backend can do
345  * without synchronizing with the frontend.  Fakes hotplug-status.  No
346  * hotplug involved here because this is about userspace drivers, thus
347  * there are kernel backend devices which could invoke hotplug.
348  *
349  * Goes to InitWait on success.
350  */
xen_be_try_init(struct XenLegacyDevice * xendev)351 static int xen_be_try_init(struct XenLegacyDevice *xendev)
352 {
353     int rc = 0;
354 
355     if (!xendev->online) {
356         xen_pv_printf(xendev, 1, "not online\n");
357         return -1;
358     }
359 
360     if (xendev->ops->init) {
361         rc = xendev->ops->init(xendev);
362     }
363     if (rc != 0) {
364         xen_pv_printf(xendev, 1, "init() failed\n");
365         return rc;
366     }
367 
368     xenstore_write_be_str(xendev, "hotplug-status", "connected");
369     xen_be_set_state(xendev, XenbusStateInitWait);
370     return 0;
371 }
372 
373 /*
374  * Try to initialise xendev.  Depends on the frontend being ready
375  * for it (shared ring and evtchn info in xenstore, state being
376  * Initialised or Connected).
377  *
378  * Goes to Connected on success.
379  */
xen_be_try_initialise(struct XenLegacyDevice * xendev)380 static int xen_be_try_initialise(struct XenLegacyDevice *xendev)
381 {
382     int rc = 0;
383 
384     if (xendev->fe_state != XenbusStateInitialised  &&
385         xendev->fe_state != XenbusStateConnected) {
386         if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
387             xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
388         } else {
389             xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
390             return -1;
391         }
392     }
393 
394     if (xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
395         xendev->gnttabdev = qemu_xen_gnttab_open();
396         if (xendev->gnttabdev == NULL) {
397             xen_pv_printf(NULL, 0, "can't open gnttab device\n");
398             return -1;
399         }
400     } else {
401         xendev->gnttabdev = NULL;
402     }
403 
404     if (xendev->ops->initialise) {
405         rc = xendev->ops->initialise(xendev);
406     }
407     if (rc != 0) {
408         xen_pv_printf(xendev, 0, "initialise() failed\n");
409         return rc;
410     }
411 
412     xen_be_set_state(xendev, XenbusStateConnected);
413     return 0;
414 }
415 
416 /*
417  * Try to let xendev know that it is connected.  Depends on the
418  * frontend being Connected.  Note that this may be called more
419  * than once since the backend state is not modified.
420  */
xen_be_try_connected(struct XenLegacyDevice * xendev)421 static void xen_be_try_connected(struct XenLegacyDevice *xendev)
422 {
423     if (!xendev->ops->connected) {
424         return;
425     }
426 
427     if (xendev->fe_state != XenbusStateConnected) {
428         if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
429             xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
430         } else {
431             xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
432             return;
433         }
434     }
435 
436     xendev->ops->connected(xendev);
437 }
438 
439 /*
440  * Teardown connection.
441  *
442  * Goes to Closed when done.
443  */
xen_be_disconnect(struct XenLegacyDevice * xendev,enum xenbus_state state)444 static void xen_be_disconnect(struct XenLegacyDevice *xendev,
445                               enum xenbus_state state)
446 {
447     if (xendev->be_state != XenbusStateClosing &&
448         xendev->be_state != XenbusStateClosed  &&
449         xendev->ops->disconnect) {
450         xendev->ops->disconnect(xendev);
451     }
452     if (xendev->gnttabdev) {
453         qemu_xen_gnttab_close(xendev->gnttabdev);
454         xendev->gnttabdev = NULL;
455     }
456     if (xendev->be_state != state) {
457         xen_be_set_state(xendev, state);
458     }
459 }
460 
461 /*
462  * Try to reset xendev, for reconnection by another frontend instance.
463  */
xen_be_try_reset(struct XenLegacyDevice * xendev)464 static int xen_be_try_reset(struct XenLegacyDevice *xendev)
465 {
466     if (xendev->fe_state != XenbusStateInitialising) {
467         return -1;
468     }
469 
470     xen_pv_printf(xendev, 1, "device reset (for re-connect)\n");
471     xen_be_set_state(xendev, XenbusStateInitialising);
472     return 0;
473 }
474 
475 /*
476  * state change dispatcher function
477  */
xen_be_check_state(struct XenLegacyDevice * xendev)478 void xen_be_check_state(struct XenLegacyDevice *xendev)
479 {
480     int rc = 0;
481 
482     /* frontend may request shutdown from almost anywhere */
483     if (xendev->fe_state == XenbusStateClosing ||
484         xendev->fe_state == XenbusStateClosed) {
485         xen_be_disconnect(xendev, xendev->fe_state);
486         return;
487     }
488 
489     /* check for possible backend state transitions */
490     for (;;) {
491         switch (xendev->be_state) {
492         case XenbusStateUnknown:
493             rc = xen_be_try_setup(xendev);
494             break;
495         case XenbusStateInitialising:
496             rc = xen_be_try_init(xendev);
497             break;
498         case XenbusStateInitWait:
499             rc = xen_be_try_initialise(xendev);
500             break;
501         case XenbusStateConnected:
502             /* xendev->be_state doesn't change */
503             xen_be_try_connected(xendev);
504             rc = -1;
505             break;
506         case XenbusStateClosed:
507             rc = xen_be_try_reset(xendev);
508             break;
509         default:
510             rc = -1;
511         }
512         if (rc != 0) {
513             break;
514         }
515     }
516 }
517 
518 /* ------------------------------------------------------------- */
519 
520 struct xenstore_be {
521     const char *type;
522     int dom;
523     const struct XenDevOps *ops;
524 };
525 
xenstore_update_be(void * opaque,const char * watch)526 static void xenstore_update_be(void *opaque, const char *watch)
527 {
528     struct xenstore_be *be = opaque;
529     struct XenLegacyDevice *xendev;
530     char path[XEN_BUFSIZE], *bepath;
531     unsigned int len, dev;
532 
533     len = snprintf(path, sizeof(path), "backend/%s/%d", be->type, be->dom);
534     if (strncmp(path, watch, len) != 0) {
535         return;
536     }
537     if (sscanf(watch + len, "/%u/%255s", &dev, path) != 2) {
538         strcpy(path, "");
539         if (sscanf(watch + len, "/%u", &dev) != 1) {
540             dev = -1;
541         }
542     }
543     if (dev == -1) {
544         return;
545     }
546 
547     xendev = xen_be_get_xendev(be->type, be->dom, dev, be->ops);
548     if (xendev != NULL) {
549         bepath = qemu_xen_xs_read(xenstore, 0, xendev->be, &len);
550         if (bepath == NULL) {
551             xen_pv_del_xendev(xendev);
552         } else {
553             free(bepath);
554             xen_be_backend_changed(xendev, path);
555             xen_be_check_state(xendev);
556         }
557     }
558 }
559 
xenstore_scan(const char * type,int dom,const struct XenDevOps * ops)560 static int xenstore_scan(const char *type, int dom, const struct XenDevOps *ops)
561 {
562     struct XenLegacyDevice *xendev;
563     char path[XEN_BUFSIZE];
564     struct xenstore_be *be = g_new0(struct xenstore_be, 1);
565     char **dev = NULL;
566     unsigned int cdev, j;
567 
568     /* setup watch */
569     be->type = type;
570     be->dom = dom;
571     be->ops = ops;
572     snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
573     if (!qemu_xen_xs_watch(xenstore, path, xenstore_update_be, be)) {
574         xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n",
575                       path);
576         return -1;
577     }
578 
579     /* look for backends */
580     dev = qemu_xen_xs_directory(xenstore, 0, path, &cdev);
581     if (!dev) {
582         return 0;
583     }
584     for (j = 0; j < cdev; j++) {
585         xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops);
586         if (xendev == NULL) {
587             continue;
588         }
589         xen_be_check_state(xendev);
590     }
591     free(dev);
592     return 0;
593 }
594 
595 /* -------------------------------------------------------------------- */
596 
xen_set_dynamic_sysbus(void)597 static void xen_set_dynamic_sysbus(void)
598 {
599     Object *machine = qdev_get_machine();
600     ObjectClass *oc = object_get_class(machine);
601     MachineClass *mc = MACHINE_CLASS(oc);
602 
603     machine_class_allow_dynamic_sysbus_dev(mc, TYPE_XENSYSDEV);
604 }
605 
xen_be_init(void)606 void xen_be_init(void)
607 {
608     xenstore = qemu_xen_xs_open();
609     if (!xenstore) {
610         xen_pv_printf(NULL, 0, "can't connect to xenstored\n");
611         exit(1);
612     }
613 
614     if (xen_evtchn_ops == NULL || xen_gnttab_ops == NULL) {
615         xen_pv_printf(NULL, 0, "Xen operations not set up\n");
616         exit(1);
617     }
618 
619     xen_sysdev = qdev_new(TYPE_XENSYSDEV);
620     sysbus_realize_and_unref(SYS_BUS_DEVICE(xen_sysdev), &error_fatal);
621     xen_sysbus = qbus_new(TYPE_XENSYSBUS, xen_sysdev, "xen-sysbus");
622     qbus_set_bus_hotplug_handler(xen_sysbus);
623 
624     xen_set_dynamic_sysbus();
625 }
626 
xen_be_register(const char * type,const struct XenDevOps * ops)627 int xen_be_register(const char *type, const struct XenDevOps *ops)
628 {
629     char path[50];
630 
631     snprintf(path, sizeof(path), "device-model/%u/backends/%s", xen_domid,
632              type);
633     xenstore_mkdir(path, XS_PERM_NONE);
634 
635     return xenstore_scan(type, xen_domid, ops);
636 }
637 
xen_be_bind_evtchn(struct XenLegacyDevice * xendev)638 int xen_be_bind_evtchn(struct XenLegacyDevice *xendev)
639 {
640     if (xendev->local_port != -1) {
641         return 0;
642     }
643     xendev->local_port = qemu_xen_evtchn_bind_interdomain
644         (xendev->evtchndev, xendev->dom, xendev->remote_port);
645     if (xendev->local_port == -1) {
646         xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n");
647         return -1;
648     }
649     xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
650     qemu_set_fd_handler(qemu_xen_evtchn_fd(xendev->evtchndev),
651                         xen_pv_evtchn_event, NULL, xendev);
652     return 0;
653 }
654 
655 
656 static Property xendev_properties[] = {
657     DEFINE_PROP_END_OF_LIST(),
658 };
659 
xendev_class_init(ObjectClass * klass,void * data)660 static void xendev_class_init(ObjectClass *klass, void *data)
661 {
662     DeviceClass *dc = DEVICE_CLASS(klass);
663 
664     device_class_set_props(dc, xendev_properties);
665     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
666     /* xen-backend devices can be plugged/unplugged dynamically */
667     dc->user_creatable = true;
668     dc->bus_type = TYPE_XENSYSBUS;
669 }
670 
671 static const TypeInfo xendev_type_info = {
672     .name          = TYPE_XENBACKEND,
673     .parent        = TYPE_DEVICE,
674     .class_init    = xendev_class_init,
675     .instance_size = sizeof(struct XenLegacyDevice),
676 };
677 
xen_sysbus_class_init(ObjectClass * klass,void * data)678 static void xen_sysbus_class_init(ObjectClass *klass, void *data)
679 {
680     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
681 
682     hc->unplug = qdev_simple_device_unplug_cb;
683 }
684 
685 static const TypeInfo xensysbus_info = {
686     .name       = TYPE_XENSYSBUS,
687     .parent     = TYPE_BUS,
688     .class_init = xen_sysbus_class_init,
689     .interfaces = (InterfaceInfo[]) {
690         { TYPE_HOTPLUG_HANDLER },
691         { }
692     }
693 };
694 
695 static Property xen_sysdev_properties[] = {
696     {/* end of property list */},
697 };
698 
xen_sysdev_class_init(ObjectClass * klass,void * data)699 static void xen_sysdev_class_init(ObjectClass *klass, void *data)
700 {
701     DeviceClass *dc = DEVICE_CLASS(klass);
702 
703     device_class_set_props(dc, xen_sysdev_properties);
704 }
705 
706 static const TypeInfo xensysdev_info = {
707     .name          = TYPE_XENSYSDEV,
708     .parent        = TYPE_SYS_BUS_DEVICE,
709     .instance_size = sizeof(SysBusDevice),
710     .class_init    = xen_sysdev_class_init,
711 };
712 
xenbe_register_types(void)713 static void xenbe_register_types(void)
714 {
715     type_register_static(&xensysbus_info);
716     type_register_static(&xensysdev_info);
717     type_register_static(&xendev_type_info);
718 }
719 
720 type_init(xenbe_register_types)
721