hw/xen/xen-legacy-backend.c

   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 xs_handle *xenstore;
  43 const char *xen_protocol;
  44
  45 /* private */
  46 static bool xen_feature_grant_copy;
  47 static int debug;
  48
  49 int xenstore_write_be_str(struct XenLegacyDevice *xendev, const char *node,
  50                           const char *val)
  51 {
  52     return xenstore_write_str(xendev->be, node, val);
  53 }
  54
  55 int xenstore_write_be_int(struct XenLegacyDevice *xendev, const char *node,
  56                           int ival)
  57 {
  58     return xenstore_write_int(xendev->be, node, ival);
  59 }
  60
  61 int xenstore_write_be_int64(struct XenLegacyDevice *xendev, const char *node,
  62                             int64_t ival)
  63 {
  64     return xenstore_write_int64(xendev->be, node, ival);
  65 }
  66
  67 char *xenstore_read_be_str(struct XenLegacyDevice *xendev, const char *node)
  68 {
  69     return xenstore_read_str(xendev->be, node);
  70 }
  71
  72 int xenstore_read_be_int(struct XenLegacyDevice *xendev, const char *node,
  73                          int *ival)
  74 {
  75     return xenstore_read_int(xendev->be, node, ival);
  76 }
  77
  78 char *xenstore_read_fe_str(struct XenLegacyDevice *xendev, const char *node)
  79 {
  80     return xenstore_read_str(xendev->fe, node);
  81 }
  82
  83 int xenstore_read_fe_int(struct XenLegacyDevice *xendev, const char *node,
  84                          int *ival)
  85 {
  86     return xenstore_read_int(xendev->fe, node, ival);
  87 }
  88
  89 int xenstore_read_fe_uint64(struct XenLegacyDevice *xendev, const char *node,
  90                             uint64_t *uval)
  91 {
  92     return xenstore_read_uint64(xendev->fe, node, uval);
  93 }
  94
  95 /* ------------------------------------------------------------- */
  96
  97 int xen_be_set_state(struct XenLegacyDevice *xendev, enum xenbus_state state)
  98 {
  99     int rc;
 100
 101     rc = xenstore_write_be_int(xendev, "state", state);
 102     if (rc < 0) {
 103         return rc;
 104     }
 105     xen_pv_printf(xendev, 1, "backend state: %s -> %s\n",
 106                   xenbus_strstate(xendev->be_state), xenbus_strstate(state));
 107     xendev->be_state = state;
 108     return 0;
 109 }
 110
 111 void xen_be_set_max_grant_refs(struct XenLegacyDevice *xendev,
 112                                unsigned int nr_refs)
 113 {
 114     assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV);
 115
 116     if (xengnttab_set_max_grants(xendev->gnttabdev, nr_refs)) {
 117         xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n",
 118                       strerror(errno));
 119     }
 120 }
 121
 122 void *xen_be_map_grant_refs(struct XenLegacyDevice *xendev, uint32_t *refs,
 123                             unsigned int nr_refs, int prot)
 124 {
 125     void *ptr;
 126
 127     assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV);
 128
 129     ptr = xengnttab_map_domain_grant_refs(xendev->gnttabdev, nr_refs,
 130                                           xen_domid, refs, prot);
 131     if (!ptr) {
 132         xen_pv_printf(xendev, 0,
 133                       "xengnttab_map_domain_grant_refs failed: %s\n",
 134                       strerror(errno));
 135     }
 136
 137     return ptr;
 138 }
 139
 140 void xen_be_unmap_grant_refs(struct XenLegacyDevice *xendev, void *ptr,
 141                              unsigned int nr_refs)
 142 {
 143     assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV);
 144
 145     if (xengnttab_unmap(xendev->gnttabdev, ptr, nr_refs)) {
 146         xen_pv_printf(xendev, 0, "xengnttab_unmap failed: %s\n",
 147                       strerror(errno));
 148     }
 149 }
 150
 151 static int compat_copy_grant_refs(struct XenLegacyDevice *xendev,
 152                                   bool to_domain,
 153                                   XenGrantCopySegment segs[],
 154                                   unsigned int nr_segs)
 155 {
 156     uint32_t *refs = g_new(uint32_t, nr_segs);
 157     int prot = to_domain ? PROT_WRITE : PROT_READ;
 158     void *pages;
 159     unsigned int i;
 160
 161     for (i = 0; i < nr_segs; i++) {
 162         XenGrantCopySegment *seg = &segs[i];
 163
 164         refs[i] = to_domain ?
 165             seg->dest.foreign.ref : seg->source.foreign.ref;
 166     }
 167
 168     pages = xengnttab_map_domain_grant_refs(xendev->gnttabdev, nr_segs,
 169                                             xen_domid, refs, prot);
 170     if (!pages) {
 171         xen_pv_printf(xendev, 0,
 172                       "xengnttab_map_domain_grant_refs failed: %s\n",
 173                       strerror(errno));
 174         g_free(refs);
 175         return -1;
 176     }
 177
 178     for (i = 0; i < nr_segs; i++) {
 179         XenGrantCopySegment *seg = &segs[i];
 180         void *page = pages + (i * XC_PAGE_SIZE);
 181
 182         if (to_domain) {
 183             memcpy(page + seg->dest.foreign.offset, seg->source.virt,
 184                    seg->len);
 185         } else {
 186             memcpy(seg->dest.virt, page + seg->source.foreign.offset,
 187                    seg->len);
 188         }
 189     }
 190
 191     if (xengnttab_unmap(xendev->gnttabdev, pages, nr_segs)) {
 192         xen_pv_printf(xendev, 0, "xengnttab_unmap failed: %s\n",
 193                       strerror(errno));
 194     }
 195
 196     g_free(refs);
 197     return 0;
 198 }
 199
 200 int xen_be_copy_grant_refs(struct XenLegacyDevice *xendev,
 201                            bool to_domain,
 202                            XenGrantCopySegment segs[],
 203                            unsigned int nr_segs)
 204 {
 205     xengnttab_grant_copy_segment_t *xengnttab_segs;
 206     unsigned int i;
 207     int rc;
 208
 209     assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV);
 210
 211     if (!xen_feature_grant_copy) {
 212         return compat_copy_grant_refs(xendev, to_domain, segs, nr_segs);
 213     }
 214
 215     xengnttab_segs = g_new0(xengnttab_grant_copy_segment_t, nr_segs);
 216
 217     for (i = 0; i < nr_segs; i++) {
 218         XenGrantCopySegment *seg = &segs[i];
 219         xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i];
 220
 221         if (to_domain) {
 222             xengnttab_seg->flags = GNTCOPY_dest_gref;
 223             xengnttab_seg->dest.foreign.domid = xen_domid;
 224             xengnttab_seg->dest.foreign.ref = seg->dest.foreign.ref;
 225             xengnttab_seg->dest.foreign.offset = seg->dest.foreign.offset;
 226             xengnttab_seg->source.virt = seg->source.virt;
 227         } else {
 228             xengnttab_seg->flags = GNTCOPY_source_gref;
 229             xengnttab_seg->source.foreign.domid = xen_domid;
 230             xengnttab_seg->source.foreign.ref = seg->source.foreign.ref;
 231             xengnttab_seg->source.foreign.offset =
 232                 seg->source.foreign.offset;
 233             xengnttab_seg->dest.virt = seg->dest.virt;
 234         }
 235
 236         xengnttab_seg->len = seg->len;
 237     }
 238
 239     rc = xengnttab_grant_copy(xendev->gnttabdev, nr_segs, xengnttab_segs);
 240
 241     if (rc) {
 242         xen_pv_printf(xendev, 0, "xengnttab_copy failed: %s\n",
 243                       strerror(errno));
 244     }
 245
 246     for (i = 0; i < nr_segs; i++) {
 247         xengnttab_grant_copy_segment_t *xengnttab_seg =
 248             &xengnttab_segs[i];
 249
 250         if (xengnttab_seg->status != GNTST_okay) {
 251             xen_pv_printf(xendev, 0, "segment[%u] status: %d\n", i,
 252                           xengnttab_seg->status);
 253             rc = -1;
 254         }
 255     }
 256
 257     g_free(xengnttab_segs);
 258     return rc;
 259 }
 260
 261 /*
 262  * get xen backend device, allocate a new one if it doesn't exist.
 263  */
 264 static struct XenLegacyDevice *xen_be_get_xendev(const char *type, int dom,
 265                                                  int dev,
 266                                                  struct XenDevOps *ops)
 267 {
 268     struct XenLegacyDevice *xendev;
 269
 270     xendev = xen_pv_find_xendev(type, dom, dev);
 271     if (xendev) {
 272         return xendev;
 273     }
 274
 275     /* init new xendev */
 276     xendev = g_malloc0(ops->size);
 277     object_initialize(&xendev->qdev, ops->size, TYPE_XENBACKEND);
 278     OBJECT(xendev)->free = g_free;
 279     qdev_set_id(DEVICE(xendev), g_strdup_printf("xen-%s-%d", type, dev));
 280     qdev_realize(DEVICE(xendev), xen_sysbus, &error_fatal);
 281     object_unref(OBJECT(xendev));
 282
 283     xendev->type  = type;
 284     xendev->dom   = dom;
 285     xendev->dev   = dev;
 286     xendev->ops   = ops;
 287
 288     snprintf(xendev->be, sizeof(xendev->be), "backend/%s/%d/%d",
 289              xendev->type, xendev->dom, xendev->dev);
 290     snprintf(xendev->name, sizeof(xendev->name), "%s-%d",
 291              xendev->type, xendev->dev);
 292
 293     xendev->debug      = debug;
 294     xendev->local_port = -1;
 295
 296     xendev->evtchndev = xenevtchn_open(NULL, 0);
 297     if (xendev->evtchndev == NULL) {
 298         xen_pv_printf(NULL, 0, "can't open evtchn device\n");
 299         qdev_unplug(DEVICE(xendev), NULL);
 300         return NULL;
 301     }
 302     qemu_set_cloexec(xenevtchn_fd(xendev->evtchndev));
 303
 304     xen_pv_insert_xendev(xendev);
 305
 306     if (xendev->ops->alloc) {
 307         xendev->ops->alloc(xendev);
 308     }
 309
 310     return xendev;
 311 }
 312
 313
 314 /*
 315  * Sync internal data structures on xenstore updates.
 316  * Node specifies the changed field.  node = NULL means
 317  * update all fields (used for initialization).
 318  */
 319 static void xen_be_backend_changed(struct XenLegacyDevice *xendev,
 320                                    const char *node)
 321 {
 322     if (node == NULL  ||  strcmp(node, "online") == 0) {
 323         if (xenstore_read_be_int(xendev, "online", &xendev->online) == -1) {
 324             xendev->online = 0;
 325         }
 326     }
 327
 328     if (node) {
 329         xen_pv_printf(xendev, 2, "backend update: %s\n", node);
 330         if (xendev->ops->backend_changed) {
 331             xendev->ops->backend_changed(xendev, node);
 332         }
 333     }
 334 }
 335
 336 static void xen_be_frontend_changed(struct XenLegacyDevice *xendev,
 337                                     const char *node)
 338 {
 339     int fe_state;
 340
 341     if (node == NULL  ||  strcmp(node, "state") == 0) {
 342         if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
 343             fe_state = XenbusStateUnknown;
 344         }
 345         if (xendev->fe_state != fe_state) {
 346             xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n",
 347                           xenbus_strstate(xendev->fe_state),
 348                           xenbus_strstate(fe_state));
 349         }
 350         xendev->fe_state = fe_state;
 351     }
 352     if (node == NULL  ||  strcmp(node, "protocol") == 0) {
 353         g_free(xendev->protocol);
 354         xendev->protocol = xenstore_read_fe_str(xendev, "protocol");
 355         if (xendev->protocol) {
 356             xen_pv_printf(xendev, 1, "frontend protocol: %s\n",
 357                           xendev->protocol);
 358         }
 359     }
 360
 361     if (node) {
 362         xen_pv_printf(xendev, 2, "frontend update: %s\n", node);
 363         if (xendev->ops->frontend_changed) {
 364             xendev->ops->frontend_changed(xendev, node);
 365         }
 366     }
 367 }
 368
 369 /* ------------------------------------------------------------- */
 370 /* Check for possible state transitions and perform them.        */
 371
 372 /*
 373  * Initial xendev setup.  Read frontend path, register watch for it.
 374  * Should succeed once xend finished setting up the backend device.
 375  *
 376  * Also sets initial state (-> Initializing) when done.  Which
 377  * only affects the xendev->be_state variable as xenbus should
 378  * already be put into that state by xend.
 379  */
 380 static int xen_be_try_setup(struct XenLegacyDevice *xendev)
 381 {
 382     char token[XEN_BUFSIZE];
 383     int be_state;
 384
 385     if (xenstore_read_be_int(xendev, "state", &be_state) == -1) {
 386         xen_pv_printf(xendev, 0, "reading backend state failed\n");
 387         return -1;
 388     }
 389
 390     if (be_state != XenbusStateInitialising) {
 391         xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n",
 392                       xenbus_strstate(be_state));
 393         return -1;
 394     }
 395
 396     xendev->fe = xenstore_read_be_str(xendev, "frontend");
 397     if (xendev->fe == NULL) {
 398         xen_pv_printf(xendev, 0, "reading frontend path failed\n");
 399         return -1;
 400     }
 401
 402     /* setup frontend watch */
 403     snprintf(token, sizeof(token), "fe:%p", xendev);
 404     if (!xs_watch(xenstore, xendev->fe, token)) {
 405         xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n",
 406                       xendev->fe);
 407         return -1;
 408     }
 409     xen_be_set_state(xendev, XenbusStateInitialising);
 410
 411     xen_be_backend_changed(xendev, NULL);
 412     xen_be_frontend_changed(xendev, NULL);
 413     return 0;
 414 }
 415
 416 /*
 417  * Try initialize xendev.  Prepare everything the backend can do
 418  * without synchronizing with the frontend.  Fakes hotplug-status.  No
 419  * hotplug involved here because this is about userspace drivers, thus
 420  * there are kernel backend devices which could invoke hotplug.
 421  *
 422  * Goes to InitWait on success.
 423  */
 424 static int xen_be_try_init(struct XenLegacyDevice *xendev)
 425 {
 426     int rc = 0;
 427
 428     if (!xendev->online) {
 429         xen_pv_printf(xendev, 1, "not online\n");
 430         return -1;
 431     }
 432
 433     if (xendev->ops->init) {
 434         rc = xendev->ops->init(xendev);
 435     }
 436     if (rc != 0) {
 437         xen_pv_printf(xendev, 1, "init() failed\n");
 438         return rc;
 439     }
 440
 441     xenstore_write_be_str(xendev, "hotplug-status", "connected");
 442     xen_be_set_state(xendev, XenbusStateInitWait);
 443     return 0;
 444 }
 445
 446 /*
 447  * Try to initialise xendev.  Depends on the frontend being ready
 448  * for it (shared ring and evtchn info in xenstore, state being
 449  * Initialised or Connected).
 450  *
 451  * Goes to Connected on success.
 452  */
 453 static int xen_be_try_initialise(struct XenLegacyDevice *xendev)
 454 {
 455     int rc = 0;
 456
 457     if (xendev->fe_state != XenbusStateInitialised  &&
 458         xendev->fe_state != XenbusStateConnected) {
 459         if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
 460             xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
 461         } else {
 462             xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
 463             return -1;
 464         }
 465     }
 466
 467     if (xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
 468         xendev->gnttabdev = xengnttab_open(NULL, 0);
 469         if (xendev->gnttabdev == NULL) {
 470             xen_pv_printf(NULL, 0, "can't open gnttab device\n");
 471             return -1;
 472         }
 473     } else {
 474         xendev->gnttabdev = NULL;
 475     }
 476
 477     if (xendev->ops->initialise) {
 478         rc = xendev->ops->initialise(xendev);
 479     }
 480     if (rc != 0) {
 481         xen_pv_printf(xendev, 0, "initialise() failed\n");
 482         return rc;
 483     }
 484
 485     xen_be_set_state(xendev, XenbusStateConnected);
 486     return 0;
 487 }
 488
 489 /*
 490  * Try to let xendev know that it is connected.  Depends on the
 491  * frontend being Connected.  Note that this may be called more
 492  * than once since the backend state is not modified.
 493  */
 494 static void xen_be_try_connected(struct XenLegacyDevice *xendev)
 495 {
 496     if (!xendev->ops->connected) {
 497         return;
 498     }
 499
 500     if (xendev->fe_state != XenbusStateConnected) {
 501         if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
 502             xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
 503         } else {
 504             xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
 505             return;
 506         }
 507     }
 508
 509     xendev->ops->connected(xendev);
 510 }
 511
 512 /*
 513  * Teardown connection.
 514  *
 515  * Goes to Closed when done.
 516  */
 517 static void xen_be_disconnect(struct XenLegacyDevice *xendev,
 518                               enum xenbus_state state)
 519 {
 520     if (xendev->be_state != XenbusStateClosing &&
 521         xendev->be_state != XenbusStateClosed  &&
 522         xendev->ops->disconnect) {
 523         xendev->ops->disconnect(xendev);
 524     }
 525     if (xendev->gnttabdev) {
 526         xengnttab_close(xendev->gnttabdev);
 527         xendev->gnttabdev = NULL;
 528     }
 529     if (xendev->be_state != state) {
 530         xen_be_set_state(xendev, state);
 531     }
 532 }
 533
 534 /*
 535  * Try to reset xendev, for reconnection by another frontend instance.
 536  */
 537 static int xen_be_try_reset(struct XenLegacyDevice *xendev)
 538 {
 539     if (xendev->fe_state != XenbusStateInitialising) {
 540         return -1;
 541     }
 542
 543     xen_pv_printf(xendev, 1, "device reset (for re-connect)\n");
 544     xen_be_set_state(xendev, XenbusStateInitialising);
 545     return 0;
 546 }
 547
 548 /*
 549  * state change dispatcher function
 550  */
 551 void xen_be_check_state(struct XenLegacyDevice *xendev)
 552 {
 553     int rc = 0;
 554
 555     /* frontend may request shutdown from almost anywhere */
 556     if (xendev->fe_state == XenbusStateClosing ||
 557         xendev->fe_state == XenbusStateClosed) {
 558         xen_be_disconnect(xendev, xendev->fe_state);
 559         return;
 560     }
 561
 562     /* check for possible backend state transitions */
 563     for (;;) {
 564         switch (xendev->be_state) {
 565         case XenbusStateUnknown:
 566             rc = xen_be_try_setup(xendev);
 567             break;
 568         case XenbusStateInitialising:
 569             rc = xen_be_try_init(xendev);
 570             break;
 571         case XenbusStateInitWait:
 572             rc = xen_be_try_initialise(xendev);
 573             break;
 574         case XenbusStateConnected:
 575             /* xendev->be_state doesn't change */
 576             xen_be_try_connected(xendev);
 577             rc = -1;
 578             break;
 579         case XenbusStateClosed:
 580             rc = xen_be_try_reset(xendev);
 581             break;
 582         default:
 583             rc = -1;
 584         }
 585         if (rc != 0) {
 586             break;
 587         }
 588     }
 589 }
 590
 591 /* ------------------------------------------------------------- */
 592
 593 static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops)
 594 {
 595     struct XenLegacyDevice *xendev;
 596     char path[XEN_BUFSIZE], token[XEN_BUFSIZE];
 597     char **dev = NULL;
 598     unsigned int cdev, j;
 599
 600     /* setup watch */
 601     snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops);
 602     snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
 603     if (!xs_watch(xenstore, path, token)) {
 604         xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n",
 605                       path);
 606         return -1;
 607     }
 608
 609     /* look for backends */
 610     dev = xs_directory(xenstore, 0, path, &cdev);
 611     if (!dev) {
 612         return 0;
 613     }
 614     for (j = 0; j < cdev; j++) {
 615         xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops);
 616         if (xendev == NULL) {
 617             continue;
 618         }
 619         xen_be_check_state(xendev);
 620     }
 621     free(dev);
 622     return 0;
 623 }
 624
 625 void xenstore_update_be(char *watch, char *type, int dom,
 626                         struct XenDevOps *ops)
 627 {
 628     struct XenLegacyDevice *xendev;
 629     char path[XEN_BUFSIZE], *bepath;
 630     unsigned int len, dev;
 631
 632     len = snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
 633     if (strncmp(path, watch, len) != 0) {
 634         return;
 635     }
 636     if (sscanf(watch + len, "/%u/%255s", &dev, path) != 2) {
 637         strcpy(path, "");
 638         if (sscanf(watch + len, "/%u", &dev) != 1) {
 639             dev = -1;
 640         }
 641     }
 642     if (dev == -1) {
 643         return;
 644     }
 645
 646     xendev = xen_be_get_xendev(type, dom, dev, ops);
 647     if (xendev != NULL) {
 648         bepath = xs_read(xenstore, 0, xendev->be, &len);
 649         if (bepath == NULL) {
 650             xen_pv_del_xendev(xendev);
 651         } else {
 652             free(bepath);
 653             xen_be_backend_changed(xendev, path);
 654             xen_be_check_state(xendev);
 655         }
 656     }
 657 }
 658
 659 void xenstore_update_fe(char *watch, struct XenLegacyDevice *xendev)
 660 {
 661     char *node;
 662     unsigned int len;
 663
 664     len = strlen(xendev->fe);
 665     if (strncmp(xendev->fe, watch, len) != 0) {
 666         return;
 667     }
 668     if (watch[len] != '/') {
 669         return;
 670     }
 671     node = watch + len + 1;
 672
 673     xen_be_frontend_changed(xendev, node);
 674     xen_be_check_state(xendev);
 675 }
 676 /* -------------------------------------------------------------------- */
 677
 678 int xen_be_init(void)
 679 {
 680     xengnttab_handle *gnttabdev;
 681
 682     xenstore = xs_daemon_open();
 683     if (!xenstore) {
 684         xen_pv_printf(NULL, 0, "can't connect to xenstored\n");
 685         return -1;
 686     }
 687
 688     qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL);
 689
 690     if (xen_xc == NULL || xen_fmem == NULL) {
 691         /* Check if xen_init() have been called */
 692         goto err;
 693     }
 694
 695     gnttabdev = xengnttab_open(NULL, 0);
 696     if (gnttabdev != NULL) {
 697         if (xengnttab_grant_copy(gnttabdev, 0, NULL) == 0) {
 698             xen_feature_grant_copy = true;
 699         }
 700         xengnttab_close(gnttabdev);
 701     }
 702
 703     xen_sysdev = qdev_new(TYPE_XENSYSDEV);
 704     sysbus_realize_and_unref(SYS_BUS_DEVICE(xen_sysdev), &error_fatal);
 705     xen_sysbus = qbus_create(TYPE_XENSYSBUS, xen_sysdev, "xen-sysbus");
 706     qbus_set_bus_hotplug_handler(xen_sysbus);
 707
 708     return 0;
 709
 710 err:
 711     qemu_set_fd_handler(xs_fileno(xenstore), NULL, NULL, NULL);
 712     xs_daemon_close(xenstore);
 713     xenstore = NULL;
 714
 715     return -1;
 716 }
 717
 718 static void xen_set_dynamic_sysbus(void)
 719 {
 720     Object *machine = qdev_get_machine();
 721     ObjectClass *oc = object_get_class(machine);
 722     MachineClass *mc = MACHINE_CLASS(oc);
 723
 724     machine_class_allow_dynamic_sysbus_dev(mc, TYPE_XENSYSDEV);
 725 }
 726
 727 int xen_be_register(const char *type, struct XenDevOps *ops)
 728 {
 729     char path[50];
 730     int rc;
 731
 732     if (ops->backend_register) {
 733         rc = ops->backend_register();
 734         if (rc) {
 735             return rc;
 736         }
 737     }
 738
 739     snprintf(path, sizeof(path), "device-model/%u/backends/%s", xen_domid,
 740              type);
 741     xenstore_mkdir(path, XS_PERM_NONE);
 742
 743     return xenstore_scan(type, xen_domid, ops);
 744 }
 745
 746 void xen_be_register_common(void)
 747 {
 748     xen_set_dynamic_sysbus();
 749
 750     xen_be_register("console", &xen_console_ops);
 751     xen_be_register("vkbd", &xen_kbdmouse_ops);
 752 #ifdef CONFIG_VIRTFS
 753     xen_be_register("9pfs", &xen_9pfs_ops);
 754 #endif
 755 #ifdef CONFIG_USB_LIBUSB
 756     xen_be_register("qusb", &xen_usb_ops);
 757 #endif
 758 }
 759
 760 int xen_be_bind_evtchn(struct XenLegacyDevice *xendev)
 761 {
 762     if (xendev->local_port != -1) {
 763         return 0;
 764     }
 765     xendev->local_port = xenevtchn_bind_interdomain
 766         (xendev->evtchndev, xendev->dom, xendev->remote_port);
 767     if (xendev->local_port == -1) {
 768         xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n");
 769         return -1;
 770     }
 771     xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
 772     qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
 773                         xen_pv_evtchn_event, NULL, xendev);
 774     return 0;
 775 }
 776
 777
 778 static Property xendev_properties[] = {
 779     DEFINE_PROP_END_OF_LIST(),
 780 };
 781
 782 static void xendev_class_init(ObjectClass *klass, void *data)
 783 {
 784     DeviceClass *dc = DEVICE_CLASS(klass);
 785
 786     device_class_set_props(dc, xendev_properties);
 787     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
 788     /* xen-backend devices can be plugged/unplugged dynamically */
 789     dc->user_creatable = true;
 790     dc->bus_type = TYPE_XENSYSBUS;
 791 }
 792
 793 static const TypeInfo xendev_type_info = {
 794     .name          = TYPE_XENBACKEND,
 795     .parent        = TYPE_DEVICE,
 796     .class_init    = xendev_class_init,
 797     .instance_size = sizeof(struct XenLegacyDevice),
 798 };
 799
 800 static void xen_sysbus_class_init(ObjectClass *klass, void *data)
 801 {
 802     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
 803
 804     hc->unplug = qdev_simple_device_unplug_cb;
 805 }
 806
 807 static const TypeInfo xensysbus_info = {
 808     .name       = TYPE_XENSYSBUS,
 809     .parent     = TYPE_BUS,
 810     .class_init = xen_sysbus_class_init,
 811     .interfaces = (InterfaceInfo[]) {
 812         { TYPE_HOTPLUG_HANDLER },
 813         { }
 814     }
 815 };
 816
 817 static Property xen_sysdev_properties[] = {
 818     {/* end of property list */},
 819 };
 820
 821 static void xen_sysdev_class_init(ObjectClass *klass, void *data)
 822 {
 823     DeviceClass *dc = DEVICE_CLASS(klass);
 824
 825     device_class_set_props(dc, xen_sysdev_properties);
 826 }
 827
 828 static const TypeInfo xensysdev_info = {
 829     .name          = TYPE_XENSYSDEV,
 830     .parent        = TYPE_SYS_BUS_DEVICE,
 831     .instance_size = sizeof(SysBusDevice),
 832     .class_init    = xen_sysdev_class_init,
 833 };
 834
 835 static void xenbe_register_types(void)
 836 {
 837     type_register_static(&xensysbus_info);
 838     type_register_static(&xensysdev_info);
 839     type_register_static(&xendev_type_info);
 840 }
 841
 842 type_init(xenbe_register_types)