]>
Commit | Line | Data |
---|---|---|
d5970055 MT |
1 | /* |
2 | * vhost-net support | |
3 | * | |
4 | * Copyright Red Hat, Inc. 2010 | |
5 | * | |
6 | * Authors: | |
7 | * Michael S. Tsirkin <mst@redhat.com> | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2. See | |
10 | * the COPYING file in the top-level directory. | |
6b620ca3 PB |
11 | * |
12 | * Contributions after 2012-01-13 are licensed under the terms of the | |
13 | * GNU GPL, version 2 or (at your option) any later version. | |
d5970055 MT |
14 | */ |
15 | ||
1422e32d | 16 | #include "net/net.h" |
d5970055 MT |
17 | #include "net/tap.h" |
18 | ||
19 | #include "virtio-net.h" | |
20 | #include "vhost_net.h" | |
1de7afc9 | 21 | #include "qemu/error-report.h" |
d5970055 MT |
22 | |
23 | #include "config.h" | |
24 | ||
25 | #ifdef CONFIG_VHOST_NET | |
26 | #include <linux/vhost.h> | |
d5970055 MT |
27 | #include <sys/socket.h> |
28 | #include <linux/kvm.h> | |
29 | #include <fcntl.h> | |
30 | #include <sys/ioctl.h> | |
31 | #include <linux/virtio_ring.h> | |
32 | #include <netpacket/packet.h> | |
33 | #include <net/ethernet.h> | |
34 | #include <net/if.h> | |
35 | #include <netinet/in.h> | |
36 | ||
37 | #include <stdio.h> | |
38 | ||
39 | #include "vhost.h" | |
40 | ||
41 | struct vhost_net { | |
42 | struct vhost_dev dev; | |
43 | struct vhost_virtqueue vqs[2]; | |
44 | int backend; | |
35277d14 | 45 | NetClientState *nc; |
d5970055 MT |
46 | }; |
47 | ||
48 | unsigned vhost_net_get_features(struct vhost_net *net, unsigned features) | |
49 | { | |
50 | /* Clear features not supported by host kernel. */ | |
51 | if (!(net->dev.features & (1 << VIRTIO_F_NOTIFY_ON_EMPTY))) { | |
52 | features &= ~(1 << VIRTIO_F_NOTIFY_ON_EMPTY); | |
53 | } | |
54 | if (!(net->dev.features & (1 << VIRTIO_RING_F_INDIRECT_DESC))) { | |
55 | features &= ~(1 << VIRTIO_RING_F_INDIRECT_DESC); | |
56 | } | |
bcbabae8 MT |
57 | if (!(net->dev.features & (1 << VIRTIO_RING_F_EVENT_IDX))) { |
58 | features &= ~(1 << VIRTIO_RING_F_EVENT_IDX); | |
59 | } | |
ca736c8e MT |
60 | if (!(net->dev.features & (1 << VIRTIO_NET_F_MRG_RXBUF))) { |
61 | features &= ~(1 << VIRTIO_NET_F_MRG_RXBUF); | |
62 | } | |
d5970055 MT |
63 | return features; |
64 | } | |
65 | ||
66 | void vhost_net_ack_features(struct vhost_net *net, unsigned features) | |
67 | { | |
68 | net->dev.acked_features = net->dev.backend_features; | |
69 | if (features & (1 << VIRTIO_F_NOTIFY_ON_EMPTY)) { | |
70 | net->dev.acked_features |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY); | |
71 | } | |
72 | if (features & (1 << VIRTIO_RING_F_INDIRECT_DESC)) { | |
73 | net->dev.acked_features |= (1 << VIRTIO_RING_F_INDIRECT_DESC); | |
74 | } | |
bcbabae8 MT |
75 | if (features & (1 << VIRTIO_RING_F_EVENT_IDX)) { |
76 | net->dev.acked_features |= (1 << VIRTIO_RING_F_EVENT_IDX); | |
77 | } | |
ca736c8e MT |
78 | if (features & (1 << VIRTIO_NET_F_MRG_RXBUF)) { |
79 | net->dev.acked_features |= (1 << VIRTIO_NET_F_MRG_RXBUF); | |
80 | } | |
d5970055 MT |
81 | } |
82 | ||
4e68f7a0 | 83 | static int vhost_net_get_fd(NetClientState *backend) |
d5970055 MT |
84 | { |
85 | switch (backend->info->type) { | |
2be64a68 | 86 | case NET_CLIENT_OPTIONS_KIND_TAP: |
d5970055 MT |
87 | return tap_get_fd(backend); |
88 | default: | |
89 | fprintf(stderr, "vhost-net requires tap backend\n"); | |
90 | return -EBADFD; | |
91 | } | |
92 | } | |
93 | ||
4e68f7a0 | 94 | struct vhost_net *vhost_net_init(NetClientState *backend, int devfd, |
5430a28f | 95 | bool force) |
d5970055 MT |
96 | { |
97 | int r; | |
7267c094 | 98 | struct vhost_net *net = g_malloc(sizeof *net); |
d5970055 MT |
99 | if (!backend) { |
100 | fprintf(stderr, "vhost-net requires backend to be setup\n"); | |
101 | goto fail; | |
102 | } | |
103 | r = vhost_net_get_fd(backend); | |
104 | if (r < 0) { | |
105 | goto fail; | |
106 | } | |
35277d14 | 107 | net->nc = backend; |
d5970055 MT |
108 | net->dev.backend_features = tap_has_vnet_hdr(backend) ? 0 : |
109 | (1 << VHOST_NET_F_VIRTIO_NET_HDR); | |
110 | net->backend = r; | |
111 | ||
f56a1247 MT |
112 | net->dev.nvqs = 2; |
113 | net->dev.vqs = net->vqs; | |
114 | ||
1241ed94 | 115 | r = vhost_dev_init(&net->dev, devfd, "/dev/vhost-net", force); |
d5970055 MT |
116 | if (r < 0) { |
117 | goto fail; | |
118 | } | |
ca736c8e MT |
119 | if (!tap_has_vnet_hdr_len(backend, |
120 | sizeof(struct virtio_net_hdr_mrg_rxbuf))) { | |
121 | net->dev.features &= ~(1 << VIRTIO_NET_F_MRG_RXBUF); | |
122 | } | |
d5970055 | 123 | if (~net->dev.features & net->dev.backend_features) { |
0bfcd599 | 124 | fprintf(stderr, "vhost lacks feature mask %" PRIu64 " for backend\n", |
29f91781 | 125 | (uint64_t)(~net->dev.features & net->dev.backend_features)); |
d5970055 MT |
126 | vhost_dev_cleanup(&net->dev); |
127 | goto fail; | |
128 | } | |
129 | ||
130 | /* Set sane init value. Override when guest acks. */ | |
131 | vhost_net_ack_features(net, 0); | |
132 | return net; | |
133 | fail: | |
7267c094 | 134 | g_free(net); |
d5970055 MT |
135 | return NULL; |
136 | } | |
137 | ||
5430a28f | 138 | bool vhost_net_query(VHostNetState *net, VirtIODevice *dev) |
139 | { | |
140 | return vhost_dev_query(&net->dev, dev); | |
141 | } | |
142 | ||
d5970055 MT |
143 | int vhost_net_start(struct vhost_net *net, |
144 | VirtIODevice *dev) | |
145 | { | |
146 | struct vhost_vring_file file = { }; | |
147 | int r; | |
b0b3db79 | 148 | |
b0b3db79 MT |
149 | r = vhost_dev_enable_notifiers(&net->dev, dev); |
150 | if (r < 0) { | |
151 | goto fail_notifiers; | |
152 | } | |
d5970055 | 153 | |
d5970055 MT |
154 | r = vhost_dev_start(&net->dev, dev); |
155 | if (r < 0) { | |
b0b3db79 | 156 | goto fail_start; |
d5970055 MT |
157 | } |
158 | ||
35277d14 | 159 | net->nc->info->poll(net->nc, false); |
d5970055 MT |
160 | qemu_set_fd_handler(net->backend, NULL, NULL, NULL); |
161 | file.fd = net->backend; | |
162 | for (file.index = 0; file.index < net->dev.nvqs; ++file.index) { | |
163 | r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file); | |
164 | if (r < 0) { | |
165 | r = -errno; | |
166 | goto fail; | |
167 | } | |
168 | } | |
169 | return 0; | |
170 | fail: | |
171 | file.fd = -1; | |
6b37c87c | 172 | while (file.index-- > 0) { |
d5970055 MT |
173 | int r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file); |
174 | assert(r >= 0); | |
175 | } | |
35277d14 | 176 | net->nc->info->poll(net->nc, true); |
d5970055 | 177 | vhost_dev_stop(&net->dev, dev); |
b0b3db79 MT |
178 | fail_start: |
179 | vhost_dev_disable_notifiers(&net->dev, dev); | |
180 | fail_notifiers: | |
d5970055 MT |
181 | return r; |
182 | } | |
183 | ||
184 | void vhost_net_stop(struct vhost_net *net, | |
185 | VirtIODevice *dev) | |
186 | { | |
187 | struct vhost_vring_file file = { .fd = -1 }; | |
188 | ||
189 | for (file.index = 0; file.index < net->dev.nvqs; ++file.index) { | |
190 | int r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file); | |
191 | assert(r >= 0); | |
192 | } | |
35277d14 | 193 | net->nc->info->poll(net->nc, true); |
d5970055 | 194 | vhost_dev_stop(&net->dev, dev); |
b0b3db79 | 195 | vhost_dev_disable_notifiers(&net->dev, dev); |
d5970055 MT |
196 | } |
197 | ||
198 | void vhost_net_cleanup(struct vhost_net *net) | |
199 | { | |
200 | vhost_dev_cleanup(&net->dev); | |
7267c094 | 201 | g_free(net); |
d5970055 | 202 | } |
f56a1247 MT |
203 | |
204 | bool vhost_net_virtqueue_pending(VHostNetState *net, int idx) | |
205 | { | |
206 | return vhost_virtqueue_pending(&net->dev, idx); | |
207 | } | |
208 | ||
209 | void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev, | |
210 | int idx, bool mask) | |
211 | { | |
212 | vhost_virtqueue_mask(&net->dev, dev, idx, mask); | |
213 | } | |
d5970055 | 214 | #else |
4e68f7a0 | 215 | struct vhost_net *vhost_net_init(NetClientState *backend, int devfd, |
5430a28f | 216 | bool force) |
217 | { | |
35f75462 | 218 | error_report("vhost-net support is not compiled in"); |
5430a28f | 219 | return NULL; |
220 | } | |
221 | ||
222 | bool vhost_net_query(VHostNetState *net, VirtIODevice *dev) | |
d5970055 | 223 | { |
5430a28f | 224 | return false; |
d5970055 MT |
225 | } |
226 | ||
227 | int vhost_net_start(struct vhost_net *net, | |
228 | VirtIODevice *dev) | |
229 | { | |
5430a28f | 230 | return -ENOSYS; |
d5970055 MT |
231 | } |
232 | void vhost_net_stop(struct vhost_net *net, | |
233 | VirtIODevice *dev) | |
234 | { | |
235 | } | |
236 | ||
237 | void vhost_net_cleanup(struct vhost_net *net) | |
238 | { | |
239 | } | |
240 | ||
241 | unsigned vhost_net_get_features(struct vhost_net *net, unsigned features) | |
242 | { | |
5430a28f | 243 | return features; |
d5970055 MT |
244 | } |
245 | void vhost_net_ack_features(struct vhost_net *net, unsigned features) | |
246 | { | |
247 | } | |
f56a1247 MT |
248 | |
249 | bool vhost_net_virtqueue_pending(VHostNetState *net, int idx) | |
250 | { | |
251 | return -ENOSYS; | |
252 | } | |
253 | ||
254 | void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev, | |
255 | int idx, bool mask) | |
256 | { | |
257 | } | |
d5970055 | 258 | #endif |