1 /*
2 * Virtio vsock device
3 *
4 * Copyright 2015 Red Hat, Inc.
5 *
6 * Authors:
7 * Stefan Hajnoczi <stefanha@redhat.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or
10 * (at your option) any later version. See the COPYING file in the
11 * top-level directory.
12 */
13
14 #include "qemu/osdep.h"
15 #include "standard-headers/linux/virtio_vsock.h"
16 #include "qapi/error.h"
17 #include "hw/virtio/virtio-access.h"
18 #include "qemu/error-report.h"
19 #include "qemu/sockets.h"
20 #include "hw/qdev-properties.h"
21 #include "hw/virtio/vhost-vsock.h"
22 #include "monitor/monitor.h"
23
vhost_vsock_get_config(VirtIODevice * vdev,uint8_t * config)24 static void vhost_vsock_get_config(VirtIODevice *vdev, uint8_t *config)
25 {
26 VHostVSock *vsock = VHOST_VSOCK(vdev);
27 struct virtio_vsock_config vsockcfg = {};
28
29 virtio_stq_p(vdev, &vsockcfg.guest_cid, vsock->conf.guest_cid);
30 memcpy(config, &vsockcfg, sizeof(vsockcfg));
31 }
32
vhost_vsock_set_guest_cid(VirtIODevice * vdev)33 static int vhost_vsock_set_guest_cid(VirtIODevice *vdev)
34 {
35 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
36 VHostVSock *vsock = VHOST_VSOCK(vdev);
37 const VhostOps *vhost_ops = vvc->vhost_dev.vhost_ops;
38 int ret;
39
40 if (!vhost_ops->vhost_vsock_set_guest_cid) {
41 return -ENOSYS;
42 }
43
44 ret = vhost_ops->vhost_vsock_set_guest_cid(&vvc->vhost_dev,
45 vsock->conf.guest_cid);
46 if (ret < 0) {
47 return -errno;
48 }
49 return 0;
50 }
51
vhost_vsock_set_running(VirtIODevice * vdev,int start)52 static int vhost_vsock_set_running(VirtIODevice *vdev, int start)
53 {
54 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
55 const VhostOps *vhost_ops = vvc->vhost_dev.vhost_ops;
56 int ret;
57
58 if (!vhost_ops->vhost_vsock_set_running) {
59 return -ENOSYS;
60 }
61
62 ret = vhost_ops->vhost_vsock_set_running(&vvc->vhost_dev, start);
63 if (ret < 0) {
64 return -errno;
65 }
66 return 0;
67 }
68
69
vhost_vsock_set_status(VirtIODevice * vdev,uint8_t status)70 static int vhost_vsock_set_status(VirtIODevice *vdev, uint8_t status)
71 {
72 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
73 bool should_start = virtio_device_should_start(vdev, status);
74 int ret;
75
76 if (vhost_dev_is_started(&vvc->vhost_dev) == should_start) {
77 return 0;
78 }
79
80 if (should_start) {
81 ret = vhost_vsock_common_start(vdev);
82 if (ret < 0) {
83 return 0;
84 }
85
86 ret = vhost_vsock_set_running(vdev, 1);
87 if (ret < 0) {
88 vhost_vsock_common_stop(vdev);
89 error_report("Error starting vhost vsock: %d", -ret);
90 return 0;
91 }
92 } else {
93 ret = vhost_vsock_set_running(vdev, 0);
94 if (ret < 0) {
95 error_report("vhost vsock set running failed: %d", ret);
96 return 0;
97 }
98
99 vhost_vsock_common_stop(vdev);
100 }
101 return 0;
102 }
103
vhost_vsock_get_features(VirtIODevice * vdev,uint64_t requested_features,Error ** errp)104 static uint64_t vhost_vsock_get_features(VirtIODevice *vdev,
105 uint64_t requested_features,
106 Error **errp)
107 {
108 return vhost_vsock_common_get_features(vdev, requested_features, errp);
109 }
110
111 static const VMStateDescription vmstate_virtio_vhost_vsock = {
112 .name = "virtio-vhost_vsock",
113 .minimum_version_id = VHOST_VSOCK_SAVEVM_VERSION,
114 .version_id = VHOST_VSOCK_SAVEVM_VERSION,
115 .fields = (const VMStateField[]) {
116 VMSTATE_VIRTIO_DEVICE,
117 VMSTATE_END_OF_LIST()
118 },
119 .pre_save = vhost_vsock_common_pre_save,
120 .post_load = vhost_vsock_common_post_load,
121 };
122
vhost_vsock_device_realize(DeviceState * dev,Error ** errp)123 static void vhost_vsock_device_realize(DeviceState *dev, Error **errp)
124 {
125 ERRP_GUARD();
126 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(dev);
127 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
128 VHostVSock *vsock = VHOST_VSOCK(dev);
129 int vhostfd;
130 int ret;
131
132 /* Refuse to use reserved CID numbers */
133 if (vsock->conf.guest_cid <= 2) {
134 error_setg(errp, "guest-cid property must be greater than 2");
135 return;
136 }
137
138 if (vsock->conf.guest_cid > UINT32_MAX) {
139 error_setg(errp, "guest-cid property must be a 32-bit number");
140 return;
141 }
142
143 if (vsock->conf.vhostfd) {
144 vhostfd = monitor_fd_param(monitor_cur(), vsock->conf.vhostfd, errp);
145 if (vhostfd == -1) {
146 error_prepend(errp, "vhost-vsock: unable to parse vhostfd: ");
147 return;
148 }
149
150 if (!g_unix_set_fd_nonblocking(vhostfd, true, NULL)) {
151 error_setg_errno(errp, errno,
152 "vhost-vsock: unable to set non-blocking mode");
153 return;
154 }
155 } else {
156 vhostfd = open("/dev/vhost-vsock", O_RDWR);
157 if (vhostfd < 0) {
158 error_setg_errno(errp, errno,
159 "vhost-vsock: failed to open vhost device");
160 return;
161 }
162
163 if (!g_unix_set_fd_nonblocking(vhostfd, true, NULL)) {
164 error_setg_errno(errp, errno,
165 "Failed to set FD nonblocking");
166 return;
167 }
168 }
169
170 vhost_vsock_common_realize(vdev);
171
172 ret = vhost_dev_init(&vvc->vhost_dev, (void *)(uintptr_t)vhostfd,
173 VHOST_BACKEND_TYPE_KERNEL, 0, errp);
174 if (ret < 0) {
175 /*
176 * vhostfd is closed by vhost_dev_cleanup, which is called
177 * by vhost_dev_init on initialization error.
178 */
179 goto err_virtio;
180 }
181
182 ret = vhost_vsock_set_guest_cid(vdev);
183 if (ret < 0) {
184 error_setg_errno(errp, -ret, "vhost-vsock: unable to set guest cid");
185 goto err_vhost_dev;
186 }
187
188 return;
189
190 err_vhost_dev:
191 /* vhost_dev_cleanup() closes the vhostfd passed to vhost_dev_init() */
192 vhost_dev_cleanup(&vvc->vhost_dev);
193 err_virtio:
194 vhost_vsock_common_unrealize(vdev);
195 }
196
vhost_vsock_device_unrealize(DeviceState * dev)197 static void vhost_vsock_device_unrealize(DeviceState *dev)
198 {
199 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(dev);
200 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
201
202 /* This will stop vhost backend if appropriate. */
203 vhost_vsock_set_status(vdev, 0);
204
205 vhost_dev_cleanup(&vvc->vhost_dev);
206 vhost_vsock_common_unrealize(vdev);
207 }
208
209 static const Property vhost_vsock_properties[] = {
210 DEFINE_PROP_UINT64("guest-cid", VHostVSock, conf.guest_cid, 0),
211 DEFINE_PROP_STRING("vhostfd", VHostVSock, conf.vhostfd),
212 };
213
vhost_vsock_class_init(ObjectClass * klass,const void * data)214 static void vhost_vsock_class_init(ObjectClass *klass, const void *data)
215 {
216 DeviceClass *dc = DEVICE_CLASS(klass);
217 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
218
219 device_class_set_props(dc, vhost_vsock_properties);
220 dc->vmsd = &vmstate_virtio_vhost_vsock;
221 vdc->realize = vhost_vsock_device_realize;
222 vdc->unrealize = vhost_vsock_device_unrealize;
223 vdc->get_features = vhost_vsock_get_features;
224 vdc->get_config = vhost_vsock_get_config;
225 vdc->set_status = vhost_vsock_set_status;
226 }
227
228 static const TypeInfo vhost_vsock_info = {
229 .name = TYPE_VHOST_VSOCK,
230 .parent = TYPE_VHOST_VSOCK_COMMON,
231 .instance_size = sizeof(VHostVSock),
232 .class_init = vhost_vsock_class_init,
233 };
234
vhost_vsock_register_types(void)235 static void vhost_vsock_register_types(void)
236 {
237 type_register_static(&vhost_vsock_info);
238 }
239
240 type_init(vhost_vsock_register_types)
241