vhost-user: fix mmap offset calculation
[qemu.git] / 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 "hw/virtio/vhost.h"
12 #include "hw/virtio/vhost-backend.h"
13 #include "sysemu/char.h"
14 #include "sysemu/kvm.h"
15 #include "qemu/error-report.h"
16 #include "qemu/sockets.h"
17 #include "exec/ram_addr.h"
18
19 #include <fcntl.h>
20 #include <unistd.h>
21 #include <sys/ioctl.h>
22 #include <sys/socket.h>
23 #include <sys/un.h>
24 #include <linux/vhost.h>
25
26 #define VHOST_MEMORY_MAX_NREGIONS 8
27
28 typedef enum VhostUserRequest {
29 VHOST_USER_NONE = 0,
30 VHOST_USER_GET_FEATURES = 1,
31 VHOST_USER_SET_FEATURES = 2,
32 VHOST_USER_SET_OWNER = 3,
33 VHOST_USER_RESET_OWNER = 4,
34 VHOST_USER_SET_MEM_TABLE = 5,
35 VHOST_USER_SET_LOG_BASE = 6,
36 VHOST_USER_SET_LOG_FD = 7,
37 VHOST_USER_SET_VRING_NUM = 8,
38 VHOST_USER_SET_VRING_ADDR = 9,
39 VHOST_USER_SET_VRING_BASE = 10,
40 VHOST_USER_GET_VRING_BASE = 11,
41 VHOST_USER_SET_VRING_KICK = 12,
42 VHOST_USER_SET_VRING_CALL = 13,
43 VHOST_USER_SET_VRING_ERR = 14,
44 VHOST_USER_MAX
45 } VhostUserRequest;
46
47 typedef struct VhostUserMemoryRegion {
48 uint64_t guest_phys_addr;
49 uint64_t memory_size;
50 uint64_t userspace_addr;
51 uint64_t mmap_offset;
52 } VhostUserMemoryRegion;
53
54 typedef struct VhostUserMemory {
55 uint32_t nregions;
56 uint32_t padding;
57 VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
58 } VhostUserMemory;
59
60 typedef struct VhostUserMsg {
61 VhostUserRequest request;
62
63 #define VHOST_USER_VERSION_MASK (0x3)
64 #define VHOST_USER_REPLY_MASK (0x1<<2)
65 uint32_t flags;
66 uint32_t size; /* the following payload size */
67 union {
68 #define VHOST_USER_VRING_IDX_MASK (0xff)
69 #define VHOST_USER_VRING_NOFD_MASK (0x1<<8)
70 uint64_t u64;
71 struct vhost_vring_state state;
72 struct vhost_vring_addr addr;
73 VhostUserMemory memory;
74 };
75 } QEMU_PACKED VhostUserMsg;
76
77 static VhostUserMsg m __attribute__ ((unused));
78 #define VHOST_USER_HDR_SIZE (sizeof(m.request) \
79 + sizeof(m.flags) \
80 + sizeof(m.size))
81
82 #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
83
84 /* The version of the protocol we support */
85 #define VHOST_USER_VERSION (0x1)
86
87 static bool ioeventfd_enabled(void)
88 {
89 return kvm_enabled() && kvm_eventfds_enabled();
90 }
91
92 static unsigned long int ioctl_to_vhost_user_request[VHOST_USER_MAX] = {
93 -1, /* VHOST_USER_NONE */
94 VHOST_GET_FEATURES, /* VHOST_USER_GET_FEATURES */
95 VHOST_SET_FEATURES, /* VHOST_USER_SET_FEATURES */
96 VHOST_SET_OWNER, /* VHOST_USER_SET_OWNER */
97 VHOST_RESET_OWNER, /* VHOST_USER_RESET_OWNER */
98 VHOST_SET_MEM_TABLE, /* VHOST_USER_SET_MEM_TABLE */
99 VHOST_SET_LOG_BASE, /* VHOST_USER_SET_LOG_BASE */
100 VHOST_SET_LOG_FD, /* VHOST_USER_SET_LOG_FD */
101 VHOST_SET_VRING_NUM, /* VHOST_USER_SET_VRING_NUM */
102 VHOST_SET_VRING_ADDR, /* VHOST_USER_SET_VRING_ADDR */
103 VHOST_SET_VRING_BASE, /* VHOST_USER_SET_VRING_BASE */
104 VHOST_GET_VRING_BASE, /* VHOST_USER_GET_VRING_BASE */
105 VHOST_SET_VRING_KICK, /* VHOST_USER_SET_VRING_KICK */
106 VHOST_SET_VRING_CALL, /* VHOST_USER_SET_VRING_CALL */
107 VHOST_SET_VRING_ERR /* VHOST_USER_SET_VRING_ERR */
108 };
109
110 static VhostUserRequest vhost_user_request_translate(unsigned long int request)
111 {
112 VhostUserRequest idx;
113
114 for (idx = 0; idx < VHOST_USER_MAX; idx++) {
115 if (ioctl_to_vhost_user_request[idx] == request) {
116 break;
117 }
118 }
119
120 return (idx == VHOST_USER_MAX) ? VHOST_USER_NONE : idx;
121 }
122
123 static int vhost_user_read(struct vhost_dev *dev, VhostUserMsg *msg)
124 {
125 CharDriverState *chr = dev->opaque;
126 uint8_t *p = (uint8_t *) msg;
127 int r, size = VHOST_USER_HDR_SIZE;
128
129 r = qemu_chr_fe_read_all(chr, p, size);
130 if (r != size) {
131 error_report("Failed to read msg header. Read %d instead of %d.\n", r,
132 size);
133 goto fail;
134 }
135
136 /* validate received flags */
137 if (msg->flags != (VHOST_USER_REPLY_MASK | VHOST_USER_VERSION)) {
138 error_report("Failed to read msg header."
139 " Flags 0x%x instead of 0x%x.\n", msg->flags,
140 VHOST_USER_REPLY_MASK | VHOST_USER_VERSION);
141 goto fail;
142 }
143
144 /* validate message size is sane */
145 if (msg->size > VHOST_USER_PAYLOAD_SIZE) {
146 error_report("Failed to read msg header."
147 " Size %d exceeds the maximum %zu.\n", msg->size,
148 VHOST_USER_PAYLOAD_SIZE);
149 goto fail;
150 }
151
152 if (msg->size) {
153 p += VHOST_USER_HDR_SIZE;
154 size = msg->size;
155 r = qemu_chr_fe_read_all(chr, p, size);
156 if (r != size) {
157 error_report("Failed to read msg payload."
158 " Read %d instead of %d.\n", r, msg->size);
159 goto fail;
160 }
161 }
162
163 return 0;
164
165 fail:
166 return -1;
167 }
168
169 static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
170 int *fds, int fd_num)
171 {
172 CharDriverState *chr = dev->opaque;
173 int size = VHOST_USER_HDR_SIZE + msg->size;
174
175 if (fd_num) {
176 qemu_chr_fe_set_msgfds(chr, fds, fd_num);
177 }
178
179 return qemu_chr_fe_write_all(chr, (const uint8_t *) msg, size) == size ?
180 0 : -1;
181 }
182
183 static int vhost_user_call(struct vhost_dev *dev, unsigned long int request,
184 void *arg)
185 {
186 VhostUserMsg msg;
187 VhostUserRequest msg_request;
188 struct vhost_vring_file *file = 0;
189 int need_reply = 0;
190 int fds[VHOST_MEMORY_MAX_NREGIONS];
191 int i, fd;
192 size_t fd_num = 0;
193
194 assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
195
196 msg_request = vhost_user_request_translate(request);
197 msg.request = msg_request;
198 msg.flags = VHOST_USER_VERSION;
199 msg.size = 0;
200
201 switch (request) {
202 case VHOST_GET_FEATURES:
203 need_reply = 1;
204 break;
205
206 case VHOST_SET_FEATURES:
207 case VHOST_SET_LOG_BASE:
208 msg.u64 = *((__u64 *) arg);
209 msg.size = sizeof(m.u64);
210 break;
211
212 case VHOST_SET_OWNER:
213 case VHOST_RESET_OWNER:
214 break;
215
216 case VHOST_SET_MEM_TABLE:
217 for (i = 0; i < dev->mem->nregions; ++i) {
218 struct vhost_memory_region *reg = dev->mem->regions + i;
219 ram_addr_t ram_addr;
220
221 assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
222 qemu_ram_addr_from_host((void *)(uintptr_t)reg->userspace_addr, &ram_addr);
223 fd = qemu_get_ram_fd(ram_addr);
224 if (fd > 0) {
225 msg.memory.regions[fd_num].userspace_addr = reg->userspace_addr;
226 msg.memory.regions[fd_num].memory_size = reg->memory_size;
227 msg.memory.regions[fd_num].guest_phys_addr = reg->guest_phys_addr;
228 msg.memory.regions[fd_num].mmap_offset = reg->userspace_addr -
229 (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
230 assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
231 fds[fd_num++] = fd;
232 }
233 }
234
235 msg.memory.nregions = fd_num;
236
237 if (!fd_num) {
238 error_report("Failed initializing vhost-user memory map\n"
239 "consider using -object memory-backend-file share=on\n");
240 return -1;
241 }
242
243 msg.size = sizeof(m.memory.nregions);
244 msg.size += sizeof(m.memory.padding);
245 msg.size += fd_num * sizeof(VhostUserMemoryRegion);
246
247 break;
248
249 case VHOST_SET_LOG_FD:
250 fds[fd_num++] = *((int *) arg);
251 break;
252
253 case VHOST_SET_VRING_NUM:
254 case VHOST_SET_VRING_BASE:
255 memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
256 msg.size = sizeof(m.state);
257 break;
258
259 case VHOST_GET_VRING_BASE:
260 memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
261 msg.size = sizeof(m.state);
262 need_reply = 1;
263 break;
264
265 case VHOST_SET_VRING_ADDR:
266 memcpy(&msg.addr, arg, sizeof(struct vhost_vring_addr));
267 msg.size = sizeof(m.addr);
268 break;
269
270 case VHOST_SET_VRING_KICK:
271 case VHOST_SET_VRING_CALL:
272 case VHOST_SET_VRING_ERR:
273 file = arg;
274 msg.u64 = file->index & VHOST_USER_VRING_IDX_MASK;
275 msg.size = sizeof(m.u64);
276 if (ioeventfd_enabled() && file->fd > 0) {
277 fds[fd_num++] = file->fd;
278 } else {
279 msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
280 }
281 break;
282 default:
283 error_report("vhost-user trying to send unhandled ioctl\n");
284 return -1;
285 break;
286 }
287
288 if (vhost_user_write(dev, &msg, fds, fd_num) < 0) {
289 return 0;
290 }
291
292 if (need_reply) {
293 if (vhost_user_read(dev, &msg) < 0) {
294 return 0;
295 }
296
297 if (msg_request != msg.request) {
298 error_report("Received unexpected msg type."
299 " Expected %d received %d\n", msg_request, msg.request);
300 return -1;
301 }
302
303 switch (msg_request) {
304 case VHOST_USER_GET_FEATURES:
305 if (msg.size != sizeof(m.u64)) {
306 error_report("Received bad msg size.\n");
307 return -1;
308 }
309 *((__u64 *) arg) = msg.u64;
310 break;
311 case VHOST_USER_GET_VRING_BASE:
312 if (msg.size != sizeof(m.state)) {
313 error_report("Received bad msg size.\n");
314 return -1;
315 }
316 memcpy(arg, &msg.state, sizeof(struct vhost_vring_state));
317 break;
318 default:
319 error_report("Received unexpected msg type.\n");
320 return -1;
321 break;
322 }
323 }
324
325 return 0;
326 }
327
328 static int vhost_user_init(struct vhost_dev *dev, void *opaque)
329 {
330 assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
331
332 dev->opaque = opaque;
333
334 return 0;
335 }
336
337 static int vhost_user_cleanup(struct vhost_dev *dev)
338 {
339 assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
340
341 dev->opaque = 0;
342
343 return 0;
344 }
345
346 const VhostOps user_ops = {
347 .backend_type = VHOST_BACKEND_TYPE_USER,
348 .vhost_call = vhost_user_call,
349 .vhost_backend_init = vhost_user_init,
350 .vhost_backend_cleanup = vhost_user_cleanup
351 };