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