2 * Virtio Network Device
4 * Copyright IBM, Corp. 2007
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
16 #include "qemu-timer.h"
17 #include "virtio-net.h"
19 typedef struct VirtIONet
28 int mergeable_rx_bufs
;
32 * - we could suppress RX interrupt if we were so inclined.
35 static VirtIONet
*to_virtio_net(VirtIODevice
*vdev
)
37 return (VirtIONet
*)vdev
;
40 static void virtio_net_update_config(VirtIODevice
*vdev
, uint8_t *config
)
42 VirtIONet
*n
= to_virtio_net(vdev
);
43 struct virtio_net_config netcfg
;
45 memcpy(netcfg
.mac
, n
->mac
, 6);
46 memcpy(config
, &netcfg
, sizeof(netcfg
));
49 static uint32_t virtio_net_get_features(VirtIODevice
*vdev
)
51 uint32_t features
= (1 << VIRTIO_NET_F_MAC
);
56 static void virtio_net_set_features(VirtIODevice
*vdev
, uint32_t features
)
58 VirtIONet
*n
= to_virtio_net(vdev
);
60 n
->mergeable_rx_bufs
= !!(features
& (1 << VIRTIO_NET_F_MRG_RXBUF
));
65 static void virtio_net_handle_rx(VirtIODevice
*vdev
, VirtQueue
*vq
)
69 static int do_virtio_net_can_receive(VirtIONet
*n
, int bufsize
)
71 if (!virtio_queue_ready(n
->rx_vq
) ||
72 !(n
->vdev
.status
& VIRTIO_CONFIG_S_DRIVER_OK
))
75 if (virtio_queue_empty(n
->rx_vq
) ||
76 (n
->mergeable_rx_bufs
&&
77 !virtqueue_avail_bytes(n
->rx_vq
, bufsize
, 0))) {
78 virtio_queue_set_notification(n
->rx_vq
, 1);
82 virtio_queue_set_notification(n
->rx_vq
, 0);
86 static int virtio_net_can_receive(void *opaque
)
88 VirtIONet
*n
= opaque
;
90 return do_virtio_net_can_receive(n
, VIRTIO_NET_MAX_BUFSIZE
);
93 static int iov_fill(struct iovec
*iov
, int iovcnt
, const void *buf
, int count
)
98 while (offset
< count
&& i
< iovcnt
) {
99 int len
= MIN(iov
[i
].iov_len
, count
- offset
);
100 memcpy(iov
[i
].iov_base
, buf
+ offset
, len
);
108 static int receive_header(VirtIONet
*n
, struct iovec
*iov
, int iovcnt
,
109 const void *buf
, size_t size
, size_t hdr_len
)
111 struct virtio_net_hdr
*hdr
= iov
[0].iov_base
;
115 hdr
->gso_type
= VIRTIO_NET_HDR_GSO_NONE
;
117 /* We only ever receive a struct virtio_net_hdr from the tapfd,
118 * but we may be passing along a larger header to the guest.
120 iov
[0].iov_base
+= hdr_len
;
121 iov
[0].iov_len
-= hdr_len
;
126 static void virtio_net_receive(void *opaque
, const uint8_t *buf
, int size
)
128 VirtIONet
*n
= opaque
;
129 struct virtio_net_hdr_mrg_rxbuf
*mhdr
= NULL
;
130 size_t hdr_len
, offset
, i
;
132 if (!do_virtio_net_can_receive(n
, size
))
135 /* hdr_len refers to the header we supply to the guest */
136 hdr_len
= n
->mergeable_rx_bufs
?
137 sizeof(struct virtio_net_hdr_mrg_rxbuf
) : sizeof(struct virtio_net_hdr
);
141 while (offset
< size
) {
142 VirtQueueElement elem
;
144 struct iovec sg
[VIRTQUEUE_MAX_SIZE
];
148 if ((i
!= 0 && !n
->mergeable_rx_bufs
) ||
149 virtqueue_pop(n
->rx_vq
, &elem
) == 0) {
152 fprintf(stderr
, "virtio-net truncating packet\n");
156 if (elem
.in_num
< 1) {
157 fprintf(stderr
, "virtio-net receive queue contains no in buffers\n");
161 if (!n
->mergeable_rx_bufs
&& elem
.in_sg
[0].iov_len
!= hdr_len
) {
162 fprintf(stderr
, "virtio-net header not in first element\n");
166 memcpy(&sg
, &elem
.in_sg
[0], sizeof(sg
[0]) * elem
.in_num
);
169 if (n
->mergeable_rx_bufs
)
170 mhdr
= (struct virtio_net_hdr_mrg_rxbuf
*)sg
[0].iov_base
;
172 offset
+= receive_header(n
, sg
, elem
.in_num
,
173 buf
+ offset
, size
- offset
, hdr_len
);
177 /* copy in packet. ugh */
178 len
= iov_fill(sg
, elem
.in_num
,
179 buf
+ offset
, size
- offset
);
182 /* signal other side */
183 virtqueue_fill(n
->rx_vq
, &elem
, total
, i
++);
189 mhdr
->num_buffers
= i
;
191 virtqueue_flush(n
->rx_vq
, i
);
192 virtio_notify(&n
->vdev
, n
->rx_vq
);
196 static void virtio_net_flush_tx(VirtIONet
*n
, VirtQueue
*vq
)
198 VirtQueueElement elem
;
199 int has_vnet_hdr
= 0;
201 if (!(n
->vdev
.status
& VIRTIO_CONFIG_S_DRIVER_OK
))
204 while (virtqueue_pop(vq
, &elem
)) {
206 unsigned int out_num
= elem
.out_num
;
207 struct iovec
*out_sg
= &elem
.out_sg
[0];
210 /* hdr_len refers to the header received from the guest */
211 hdr_len
= n
->mergeable_rx_bufs
?
212 sizeof(struct virtio_net_hdr_mrg_rxbuf
) :
213 sizeof(struct virtio_net_hdr
);
215 if (out_num
< 1 || out_sg
->iov_len
!= hdr_len
) {
216 fprintf(stderr
, "virtio-net header not in first element\n");
220 /* ignore the header if GSO is not supported */
225 } else if (n
->mergeable_rx_bufs
) {
226 /* tapfd expects a struct virtio_net_hdr */
227 hdr_len
-= sizeof(struct virtio_net_hdr
);
228 out_sg
->iov_len
-= hdr_len
;
232 len
+= qemu_sendv_packet(n
->vc
, out_sg
, out_num
);
234 virtqueue_push(vq
, &elem
, len
);
235 virtio_notify(&n
->vdev
, vq
);
239 static void virtio_net_handle_tx(VirtIODevice
*vdev
, VirtQueue
*vq
)
241 VirtIONet
*n
= to_virtio_net(vdev
);
243 if (n
->tx_timer_active
) {
244 virtio_queue_set_notification(vq
, 1);
245 qemu_del_timer(n
->tx_timer
);
246 n
->tx_timer_active
= 0;
247 virtio_net_flush_tx(n
, vq
);
249 qemu_mod_timer(n
->tx_timer
,
250 qemu_get_clock(vm_clock
) + TX_TIMER_INTERVAL
);
251 n
->tx_timer_active
= 1;
252 virtio_queue_set_notification(vq
, 0);
256 static void virtio_net_tx_timer(void *opaque
)
258 VirtIONet
*n
= opaque
;
260 n
->tx_timer_active
= 0;
262 /* Just in case the driver is not ready on more */
263 if (!(n
->vdev
.status
& VIRTIO_CONFIG_S_DRIVER_OK
))
266 virtio_queue_set_notification(n
->tx_vq
, 1);
267 virtio_net_flush_tx(n
, n
->tx_vq
);
270 static void virtio_net_save(QEMUFile
*f
, void *opaque
)
272 VirtIONet
*n
= opaque
;
274 virtio_save(&n
->vdev
, f
);
276 qemu_put_buffer(f
, n
->mac
, 6);
277 qemu_put_be32(f
, n
->tx_timer_active
);
280 static int virtio_net_load(QEMUFile
*f
, void *opaque
, int version_id
)
282 VirtIONet
*n
= opaque
;
287 virtio_load(&n
->vdev
, f
);
289 qemu_get_buffer(f
, n
->mac
, 6);
290 n
->tx_timer_active
= qemu_get_be32(f
);
292 if (n
->tx_timer_active
) {
293 qemu_mod_timer(n
->tx_timer
,
294 qemu_get_clock(vm_clock
) + TX_TIMER_INTERVAL
);
300 PCIDevice
*virtio_net_init(PCIBus
*bus
, NICInfo
*nd
, int devfn
)
303 static int virtio_net_id
;
305 n
= (VirtIONet
*)virtio_init_pci(bus
, "virtio-net", 6900, 0x1000,
308 6, sizeof(VirtIONet
));
312 n
->vdev
.get_config
= virtio_net_update_config
;
313 n
->vdev
.get_features
= virtio_net_get_features
;
314 n
->vdev
.set_features
= virtio_net_set_features
;
315 n
->rx_vq
= virtio_add_queue(&n
->vdev
, 256, virtio_net_handle_rx
);
316 n
->tx_vq
= virtio_add_queue(&n
->vdev
, 256, virtio_net_handle_tx
);
317 memcpy(n
->mac
, nd
->macaddr
, 6);
318 n
->vc
= qemu_new_vlan_client(nd
->vlan
, virtio_net_receive
,
319 virtio_net_can_receive
, n
);
321 n
->tx_timer
= qemu_new_timer(vm_clock
, virtio_net_tx_timer
, n
);
322 n
->tx_timer_active
= 0;
323 n
->mergeable_rx_bufs
= 0;
325 register_savevm("virtio-net", virtio_net_id
++, 1,
326 virtio_net_save
, virtio_net_load
, n
);
328 return (PCIDevice
*)n
;