hw/virtio/vhost-user.c

   1 /*
   2  * vhost-user
   3  *
   4  * Copyright (c) 2013 Virtual Open Systems Sarl.
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  *
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "qapi/error.h"
  13 #include "hw/virtio/vhost.h"
  14 #include "hw/virtio/vhost-backend.h"
  15 #include "hw/virtio/virtio-net.h"
  16 #include "sysemu/char.h"
  17 #include "sysemu/kvm.h"
  18 #include "qemu/error-report.h"
  19 #include "qemu/sockets.h"
  20 #include "migration/migration.h"
  21
  22 #include <sys/ioctl.h>
  23 #include <sys/socket.h>
  24 #include <sys/un.h>
  25 #include <linux/vhost.h>
  26
  27 #define VHOST_MEMORY_MAX_NREGIONS    8
  28 #define VHOST_USER_F_PROTOCOL_FEATURES 30
  29
  30 enum VhostUserProtocolFeature {
  31     VHOST_USER_PROTOCOL_F_MQ = 0,
  32     VHOST_USER_PROTOCOL_F_LOG_SHMFD = 1,
  33     VHOST_USER_PROTOCOL_F_RARP = 2,
  34     VHOST_USER_PROTOCOL_F_REPLY_ACK = 3,
  35
  36     VHOST_USER_PROTOCOL_F_MAX
  37 };
  38
  39 #define VHOST_USER_PROTOCOL_FEATURE_MASK ((1 << VHOST_USER_PROTOCOL_F_MAX) - 1)
  40
  41 typedef enum VhostUserRequest {
  42     VHOST_USER_NONE = 0,
  43     VHOST_USER_GET_FEATURES = 1,
  44     VHOST_USER_SET_FEATURES = 2,
  45     VHOST_USER_SET_OWNER = 3,
  46     VHOST_USER_RESET_OWNER = 4,
  47     VHOST_USER_SET_MEM_TABLE = 5,
  48     VHOST_USER_SET_LOG_BASE = 6,
  49     VHOST_USER_SET_LOG_FD = 7,
  50     VHOST_USER_SET_VRING_NUM = 8,
  51     VHOST_USER_SET_VRING_ADDR = 9,
  52     VHOST_USER_SET_VRING_BASE = 10,
  53     VHOST_USER_GET_VRING_BASE = 11,
  54     VHOST_USER_SET_VRING_KICK = 12,
  55     VHOST_USER_SET_VRING_CALL = 13,
  56     VHOST_USER_SET_VRING_ERR = 14,
  57     VHOST_USER_GET_PROTOCOL_FEATURES = 15,
  58     VHOST_USER_SET_PROTOCOL_FEATURES = 16,
  59     VHOST_USER_GET_QUEUE_NUM = 17,
  60     VHOST_USER_SET_VRING_ENABLE = 18,
  61     VHOST_USER_SEND_RARP = 19,
  62     VHOST_USER_MAX
  63 } VhostUserRequest;
  64
  65 typedef struct VhostUserMemoryRegion {
  66     uint64_t guest_phys_addr;
  67     uint64_t memory_size;
  68     uint64_t userspace_addr;
  69     uint64_t mmap_offset;
  70 } VhostUserMemoryRegion;
  71
  72 typedef struct VhostUserMemory {
  73     uint32_t nregions;
  74     uint32_t padding;
  75     VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
  76 } VhostUserMemory;
  77
  78 typedef struct VhostUserLog {
  79     uint64_t mmap_size;
  80     uint64_t mmap_offset;
  81 } VhostUserLog;
  82
  83 typedef struct VhostUserMsg {
  84     VhostUserRequest request;
  85
  86 #define VHOST_USER_VERSION_MASK     (0x3)
  87 #define VHOST_USER_REPLY_MASK       (0x1<<2)
  88 #define VHOST_USER_NEED_REPLY_MASK  (0x1 << 3)
  89     uint32_t flags;
  90     uint32_t size; /* the following payload size */
  91     union {
  92 #define VHOST_USER_VRING_IDX_MASK   (0xff)
  93 #define VHOST_USER_VRING_NOFD_MASK  (0x1<<8)
  94         uint64_t u64;
  95         struct vhost_vring_state state;
  96         struct vhost_vring_addr addr;
  97         VhostUserMemory memory;
  98         VhostUserLog log;
  99     } payload;
 100 } QEMU_PACKED VhostUserMsg;
 101
 102 static VhostUserMsg m __attribute__ ((unused));
 103 #define VHOST_USER_HDR_SIZE (sizeof(m.request) \
 104                             + sizeof(m.flags) \
 105                             + sizeof(m.size))
 106
 107 #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
 108
 109 /* The version of the protocol we support */
 110 #define VHOST_USER_VERSION    (0x1)
 111
 112 static bool ioeventfd_enabled(void)
 113 {
 114     return kvm_enabled() && kvm_eventfds_enabled();
 115 }
 116
 117 static int vhost_user_read(struct vhost_dev *dev, VhostUserMsg *msg)
 118 {
 119     CharBackend *chr = dev->opaque;
 120     uint8_t *p = (uint8_t *) msg;
 121     int r, size = VHOST_USER_HDR_SIZE;
 122
 123     r = qemu_chr_fe_read_all(chr, p, size);
 124     if (r != size) {
 125         error_report("Failed to read msg header. Read %d instead of %d."
 126                      " Original request %d.", r, size, msg->request);
 127         goto fail;
 128     }
 129
 130     /* validate received flags */
 131     if (msg->flags != (VHOST_USER_REPLY_MASK | VHOST_USER_VERSION)) {
 132         error_report("Failed to read msg header."
 133                 " Flags 0x%x instead of 0x%x.", msg->flags,
 134                 VHOST_USER_REPLY_MASK | VHOST_USER_VERSION);
 135         goto fail;
 136     }
 137
 138     /* validate message size is sane */
 139     if (msg->size > VHOST_USER_PAYLOAD_SIZE) {
 140         error_report("Failed to read msg header."
 141                 " Size %d exceeds the maximum %zu.", msg->size,
 142                 VHOST_USER_PAYLOAD_SIZE);
 143         goto fail;
 144     }
 145
 146     if (msg->size) {
 147         p += VHOST_USER_HDR_SIZE;
 148         size = msg->size;
 149         r = qemu_chr_fe_read_all(chr, p, size);
 150         if (r != size) {
 151             error_report("Failed to read msg payload."
 152                          " Read %d instead of %d.", r, msg->size);
 153             goto fail;
 154         }
 155     }
 156
 157     return 0;
 158
 159 fail:
 160     return -1;
 161 }
 162
 163 static int process_message_reply(struct vhost_dev *dev,
 164                                  VhostUserRequest request)
 165 {
 166     VhostUserMsg msg;
 167
 168     if (vhost_user_read(dev, &msg) < 0) {
 169         return -1;
 170     }
 171
 172     if (msg.request != request) {
 173         error_report("Received unexpected msg type."
 174                      "Expected %d received %d",
 175                      request, msg.request);
 176         return -1;
 177     }
 178
 179     return msg.payload.u64 ? -1 : 0;
 180 }
 181
 182 static bool vhost_user_one_time_request(VhostUserRequest request)
 183 {
 184     switch (request) {
 185     case VHOST_USER_SET_OWNER:
 186     case VHOST_USER_RESET_OWNER:
 187     case VHOST_USER_SET_MEM_TABLE:
 188     case VHOST_USER_GET_QUEUE_NUM:
 189         return true;
 190     default:
 191         return false;
 192     }
 193 }
 194
 195 /* most non-init callers ignore the error */
 196 static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
 197                             int *fds, int fd_num)
 198 {
 199     CharBackend *chr = dev->opaque;
 200     int ret, size = VHOST_USER_HDR_SIZE + msg->size;
 201
 202     /*
 203      * For non-vring specific requests, like VHOST_USER_SET_MEM_TABLE,
 204      * we just need send it once in the first time. For later such
 205      * request, we just ignore it.
 206      */
 207     if (vhost_user_one_time_request(msg->request) && dev->vq_index != 0) {
 208         return 0;
 209     }
 210
 211     if (qemu_chr_fe_set_msgfds(chr, fds, fd_num) < 0) {
 212         error_report("Failed to set msg fds.");
 213         return -1;
 214     }
 215
 216     ret = qemu_chr_fe_write_all(chr, (const uint8_t *) msg, size);
 217     if (ret != size) {
 218         error_report("Failed to write msg."
 219                      " Wrote %d instead of %d.", ret, size);
 220         return -1;
 221     }
 222
 223     return 0;
 224 }
 225
 226 static int vhost_user_set_log_base(struct vhost_dev *dev, uint64_t base,
 227                                    struct vhost_log *log)
 228 {
 229     int fds[VHOST_MEMORY_MAX_NREGIONS];
 230     size_t fd_num = 0;
 231     bool shmfd = virtio_has_feature(dev->protocol_features,
 232                                     VHOST_USER_PROTOCOL_F_LOG_SHMFD);
 233     VhostUserMsg msg = {
 234         .request = VHOST_USER_SET_LOG_BASE,
 235         .flags = VHOST_USER_VERSION,
 236         .payload.log.mmap_size = log->size * sizeof(*(log->log)),
 237         .payload.log.mmap_offset = 0,
 238         .size = sizeof(msg.payload.log),
 239     };
 240
 241     if (shmfd && log->fd != -1) {
 242         fds[fd_num++] = log->fd;
 243     }
 244
 245     if (vhost_user_write(dev, &msg, fds, fd_num) < 0) {
 246         return -1;
 247     }
 248
 249     if (shmfd) {
 250         msg.size = 0;
 251         if (vhost_user_read(dev, &msg) < 0) {
 252             return -1;
 253         }
 254
 255         if (msg.request != VHOST_USER_SET_LOG_BASE) {
 256             error_report("Received unexpected msg type. "
 257                          "Expected %d received %d",
 258                          VHOST_USER_SET_LOG_BASE, msg.request);
 259             return -1;
 260         }
 261     }
 262
 263     return 0;
 264 }
 265
 266 static int vhost_user_set_mem_table(struct vhost_dev *dev,
 267                                     struct vhost_memory *mem)
 268 {
 269     int fds[VHOST_MEMORY_MAX_NREGIONS];
 270     int i, fd;
 271     size_t fd_num = 0;
 272     bool reply_supported = virtio_has_feature(dev->protocol_features,
 273                                               VHOST_USER_PROTOCOL_F_REPLY_ACK);
 274
 275     VhostUserMsg msg = {
 276         .request = VHOST_USER_SET_MEM_TABLE,
 277         .flags = VHOST_USER_VERSION,
 278     };
 279
 280     if (reply_supported) {
 281         msg.flags |= VHOST_USER_NEED_REPLY_MASK;
 282     }
 283
 284     for (i = 0; i < dev->mem->nregions; ++i) {
 285         struct vhost_memory_region *reg = dev->mem->regions + i;
 286         ram_addr_t offset;
 287         MemoryRegion *mr;
 288
 289         assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
 290         mr = memory_region_from_host((void *)(uintptr_t)reg->userspace_addr,
 291                                      &offset);
 292         fd = memory_region_get_fd(mr);
 293         if (fd > 0) {
 294             msg.payload.memory.regions[fd_num].userspace_addr = reg->userspace_addr;
 295             msg.payload.memory.regions[fd_num].memory_size  = reg->memory_size;
 296             msg.payload.memory.regions[fd_num].guest_phys_addr = reg->guest_phys_addr;
 297             msg.payload.memory.regions[fd_num].mmap_offset = offset;
 298             assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
 299             fds[fd_num++] = fd;
 300         }
 301     }
 302
 303     msg.payload.memory.nregions = fd_num;
 304
 305     if (!fd_num) {
 306         error_report("Failed initializing vhost-user memory map, "
 307                      "consider using -object memory-backend-file share=on");
 308         return -1;
 309     }
 310
 311     msg.size = sizeof(msg.payload.memory.nregions);
 312     msg.size += sizeof(msg.payload.memory.padding);
 313     msg.size += fd_num * sizeof(VhostUserMemoryRegion);
 314
 315     if (vhost_user_write(dev, &msg, fds, fd_num) < 0) {
 316         return -1;
 317     }
 318
 319     if (reply_supported) {
 320         return process_message_reply(dev, msg.request);
 321     }
 322
 323     return 0;
 324 }
 325
 326 static int vhost_user_set_vring_addr(struct vhost_dev *dev,
 327                                      struct vhost_vring_addr *addr)
 328 {
 329     VhostUserMsg msg = {
 330         .request = VHOST_USER_SET_VRING_ADDR,
 331         .flags = VHOST_USER_VERSION,
 332         .payload.addr = *addr,
 333         .size = sizeof(msg.payload.addr),
 334     };
 335
 336     if (vhost_user_write(dev, &msg, NULL, 0) < 0) {
 337         return -1;
 338     }
 339
 340     return 0;
 341 }
 342
 343 static int vhost_user_set_vring_endian(struct vhost_dev *dev,
 344                                        struct vhost_vring_state *ring)
 345 {
 346     error_report("vhost-user trying to send unhandled ioctl");
 347     return -1;
 348 }
 349
 350 static int vhost_set_vring(struct vhost_dev *dev,
 351                            unsigned long int request,
 352                            struct vhost_vring_state *ring)
 353 {
 354     VhostUserMsg msg = {
 355         .request = request,
 356         .flags = VHOST_USER_VERSION,
 357         .payload.state = *ring,
 358         .size = sizeof(msg.payload.state),
 359     };
 360
 361     if (vhost_user_write(dev, &msg, NULL, 0) < 0) {
 362         return -1;
 363     }
 364
 365     return 0;
 366 }
 367
 368 static int vhost_user_set_vring_num(struct vhost_dev *dev,
 369                                     struct vhost_vring_state *ring)
 370 {
 371     return vhost_set_vring(dev, VHOST_USER_SET_VRING_NUM, ring);
 372 }
 373
 374 static int vhost_user_set_vring_base(struct vhost_dev *dev,
 375                                      struct vhost_vring_state *ring)
 376 {
 377     return vhost_set_vring(dev, VHOST_USER_SET_VRING_BASE, ring);
 378 }
 379
 380 static int vhost_user_set_vring_enable(struct vhost_dev *dev, int enable)
 381 {
 382     int i;
 383
 384     if (!virtio_has_feature(dev->features, VHOST_USER_F_PROTOCOL_FEATURES)) {
 385         return -1;
 386     }
 387
 388     for (i = 0; i < dev->nvqs; ++i) {
 389         struct vhost_vring_state state = {
 390             .index = dev->vq_index + i,
 391             .num   = enable,
 392         };
 393
 394         vhost_set_vring(dev, VHOST_USER_SET_VRING_ENABLE, &state);
 395     }
 396
 397     return 0;
 398 }
 399
 400 static int vhost_user_get_vring_base(struct vhost_dev *dev,
 401                                      struct vhost_vring_state *ring)
 402 {
 403     VhostUserMsg msg = {
 404         .request = VHOST_USER_GET_VRING_BASE,
 405         .flags = VHOST_USER_VERSION,
 406         .payload.state = *ring,
 407         .size = sizeof(msg.payload.state),
 408     };
 409
 410     if (vhost_user_write(dev, &msg, NULL, 0) < 0) {
 411         return -1;
 412     }
 413
 414     if (vhost_user_read(dev, &msg) < 0) {
 415         return -1;
 416     }
 417
 418     if (msg.request != VHOST_USER_GET_VRING_BASE) {
 419         error_report("Received unexpected msg type. Expected %d received %d",
 420                      VHOST_USER_GET_VRING_BASE, msg.request);
 421         return -1;
 422     }
 423
 424     if (msg.size != sizeof(msg.payload.state)) {
 425         error_report("Received bad msg size.");
 426         return -1;
 427     }
 428
 429     *ring = msg.payload.state;
 430
 431     return 0;
 432 }
 433
 434 static int vhost_set_vring_file(struct vhost_dev *dev,
 435                                 VhostUserRequest request,
 436                                 struct vhost_vring_file *file)
 437 {
 438     int fds[VHOST_MEMORY_MAX_NREGIONS];
 439     size_t fd_num = 0;
 440     VhostUserMsg msg = {
 441         .request = request,
 442         .flags = VHOST_USER_VERSION,
 443         .payload.u64 = file->index & VHOST_USER_VRING_IDX_MASK,
 444         .size = sizeof(msg.payload.u64),
 445     };
 446
 447     if (ioeventfd_enabled() && file->fd > 0) {
 448         fds[fd_num++] = file->fd;
 449     } else {
 450         msg.payload.u64 |= VHOST_USER_VRING_NOFD_MASK;
 451     }
 452
 453     if (vhost_user_write(dev, &msg, fds, fd_num) < 0) {
 454         return -1;
 455     }
 456
 457     return 0;
 458 }
 459
 460 static int vhost_user_set_vring_kick(struct vhost_dev *dev,
 461                                      struct vhost_vring_file *file)
 462 {
 463     return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_KICK, file);
 464 }
 465
 466 static int vhost_user_set_vring_call(struct vhost_dev *dev,
 467                                      struct vhost_vring_file *file)
 468 {
 469     return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_CALL, file);
 470 }
 471
 472 static int vhost_user_set_u64(struct vhost_dev *dev, int request, uint64_t u64)
 473 {
 474     VhostUserMsg msg = {
 475         .request = request,
 476         .flags = VHOST_USER_VERSION,
 477         .payload.u64 = u64,
 478         .size = sizeof(msg.payload.u64),
 479     };
 480
 481     if (vhost_user_write(dev, &msg, NULL, 0) < 0) {
 482         return -1;
 483     }
 484
 485     return 0;
 486 }
 487
 488 static int vhost_user_set_features(struct vhost_dev *dev,
 489                                    uint64_t features)
 490 {
 491     return vhost_user_set_u64(dev, VHOST_USER_SET_FEATURES, features);
 492 }
 493
 494 static int vhost_user_set_protocol_features(struct vhost_dev *dev,
 495                                             uint64_t features)
 496 {
 497     return vhost_user_set_u64(dev, VHOST_USER_SET_PROTOCOL_FEATURES, features);
 498 }
 499
 500 static int vhost_user_get_u64(struct vhost_dev *dev, int request, uint64_t *u64)
 501 {
 502     VhostUserMsg msg = {
 503         .request = request,
 504         .flags = VHOST_USER_VERSION,
 505     };
 506
 507     if (vhost_user_one_time_request(request) && dev->vq_index != 0) {
 508         return 0;
 509     }
 510
 511     if (vhost_user_write(dev, &msg, NULL, 0) < 0) {
 512         return -1;
 513     }
 514
 515     if (vhost_user_read(dev, &msg) < 0) {
 516         return -1;
 517     }
 518
 519     if (msg.request != request) {
 520         error_report("Received unexpected msg type. Expected %d received %d",
 521                      request, msg.request);
 522         return -1;
 523     }
 524
 525     if (msg.size != sizeof(msg.payload.u64)) {
 526         error_report("Received bad msg size.");
 527         return -1;
 528     }
 529
 530     *u64 = msg.payload.u64;
 531
 532     return 0;
 533 }
 534
 535 static int vhost_user_get_features(struct vhost_dev *dev, uint64_t *features)
 536 {
 537     return vhost_user_get_u64(dev, VHOST_USER_GET_FEATURES, features);
 538 }
 539
 540 static int vhost_user_set_owner(struct vhost_dev *dev)
 541 {
 542     VhostUserMsg msg = {
 543         .request = VHOST_USER_SET_OWNER,
 544         .flags = VHOST_USER_VERSION,
 545     };
 546
 547     if (vhost_user_write(dev, &msg, NULL, 0) < 0) {
 548         return -1;
 549     }
 550
 551     return 0;
 552 }
 553
 554 static int vhost_user_reset_device(struct vhost_dev *dev)
 555 {
 556     VhostUserMsg msg = {
 557         .request = VHOST_USER_RESET_OWNER,
 558         .flags = VHOST_USER_VERSION,
 559     };
 560
 561     if (vhost_user_write(dev, &msg, NULL, 0) < 0) {
 562         return -1;
 563     }
 564
 565     return 0;
 566 }
 567
 568 static int vhost_user_init(struct vhost_dev *dev, void *opaque)
 569 {
 570     uint64_t features;
 571     int err;
 572
 573     assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
 574
 575     dev->opaque = opaque;
 576
 577     err = vhost_user_get_features(dev, &features);
 578     if (err < 0) {
 579         return err;
 580     }
 581
 582     if (virtio_has_feature(features, VHOST_USER_F_PROTOCOL_FEATURES)) {
 583         dev->backend_features |= 1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
 584
 585         err = vhost_user_get_u64(dev, VHOST_USER_GET_PROTOCOL_FEATURES,
 586                                  &features);
 587         if (err < 0) {
 588             return err;
 589         }
 590
 591         dev->protocol_features = features & VHOST_USER_PROTOCOL_FEATURE_MASK;
 592         err = vhost_user_set_protocol_features(dev, dev->protocol_features);
 593         if (err < 0) {
 594             return err;
 595         }
 596
 597         /* query the max queues we support if backend supports Multiple Queue */
 598         if (dev->protocol_features & (1ULL << VHOST_USER_PROTOCOL_F_MQ)) {
 599             err = vhost_user_get_u64(dev, VHOST_USER_GET_QUEUE_NUM,
 600                                      &dev->max_queues);
 601             if (err < 0) {
 602                 return err;
 603             }
 604         }
 605     }
 606
 607     if (dev->migration_blocker == NULL &&
 608         !virtio_has_feature(dev->protocol_features,
 609                             VHOST_USER_PROTOCOL_F_LOG_SHMFD)) {
 610         error_setg(&dev->migration_blocker,
 611                    "Migration disabled: vhost-user backend lacks "
 612                    "VHOST_USER_PROTOCOL_F_LOG_SHMFD feature.");
 613     }
 614
 615     return 0;
 616 }
 617
 618 static int vhost_user_cleanup(struct vhost_dev *dev)
 619 {
 620     assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
 621
 622     dev->opaque = 0;
 623
 624     return 0;
 625 }
 626
 627 static int vhost_user_get_vq_index(struct vhost_dev *dev, int idx)
 628 {
 629     assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
 630
 631     return idx;
 632 }
 633
 634 static int vhost_user_memslots_limit(struct vhost_dev *dev)
 635 {
 636     return VHOST_MEMORY_MAX_NREGIONS;
 637 }
 638
 639 static bool vhost_user_requires_shm_log(struct vhost_dev *dev)
 640 {
 641     assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
 642
 643     return virtio_has_feature(dev->protocol_features,
 644                               VHOST_USER_PROTOCOL_F_LOG_SHMFD);
 645 }
 646
 647 static int vhost_user_migration_done(struct vhost_dev *dev, char* mac_addr)
 648 {
 649     VhostUserMsg msg = { 0 };
 650
 651     assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
 652
 653     /* If guest supports GUEST_ANNOUNCE do nothing */
 654     if (virtio_has_feature(dev->acked_features, VIRTIO_NET_F_GUEST_ANNOUNCE)) {
 655         return 0;
 656     }
 657
 658     /* if backend supports VHOST_USER_PROTOCOL_F_RARP ask it to send the RARP */
 659     if (virtio_has_feature(dev->protocol_features,
 660                            VHOST_USER_PROTOCOL_F_RARP)) {
 661         msg.request = VHOST_USER_SEND_RARP;
 662         msg.flags = VHOST_USER_VERSION;
 663         memcpy((char *)&msg.payload.u64, mac_addr, 6);
 664         msg.size = sizeof(msg.payload.u64);
 665
 666         return vhost_user_write(dev, &msg, NULL, 0);
 667     }
 668     return -1;
 669 }
 670
 671 static bool vhost_user_can_merge(struct vhost_dev *dev,
 672                                  uint64_t start1, uint64_t size1,
 673                                  uint64_t start2, uint64_t size2)
 674 {
 675     ram_addr_t offset;
 676     int mfd, rfd;
 677     MemoryRegion *mr;
 678
 679     mr = memory_region_from_host((void *)(uintptr_t)start1, &offset);
 680     mfd = memory_region_get_fd(mr);
 681
 682     mr = memory_region_from_host((void *)(uintptr_t)start2, &offset);
 683     rfd = memory_region_get_fd(mr);
 684
 685     return mfd == rfd;
 686 }
 687
 688 const VhostOps user_ops = {
 689         .backend_type = VHOST_BACKEND_TYPE_USER,
 690         .vhost_backend_init = vhost_user_init,
 691         .vhost_backend_cleanup = vhost_user_cleanup,
 692         .vhost_backend_memslots_limit = vhost_user_memslots_limit,
 693         .vhost_set_log_base = vhost_user_set_log_base,
 694         .vhost_set_mem_table = vhost_user_set_mem_table,
 695         .vhost_set_vring_addr = vhost_user_set_vring_addr,
 696         .vhost_set_vring_endian = vhost_user_set_vring_endian,
 697         .vhost_set_vring_num = vhost_user_set_vring_num,
 698         .vhost_set_vring_base = vhost_user_set_vring_base,
 699         .vhost_get_vring_base = vhost_user_get_vring_base,
 700         .vhost_set_vring_kick = vhost_user_set_vring_kick,
 701         .vhost_set_vring_call = vhost_user_set_vring_call,
 702         .vhost_set_features = vhost_user_set_features,
 703         .vhost_get_features = vhost_user_get_features,
 704         .vhost_set_owner = vhost_user_set_owner,
 705         .vhost_reset_device = vhost_user_reset_device,
 706         .vhost_get_vq_index = vhost_user_get_vq_index,
 707         .vhost_set_vring_enable = vhost_user_set_vring_enable,
 708         .vhost_requires_shm_log = vhost_user_requires_shm_log,
 709         .vhost_migration_done = vhost_user_migration_done,
 710         .vhost_backend_can_merge = vhost_user_can_merge,
 711 };