VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/DevVirtioNet.cpp@ 42055

Last change on this file since 42055 was 41917, checked in by vboxsync, 12 years ago

Virtio/Net: Feature negotiation and GSO handling on RX path (#5582)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 78.9 KB
Line 
1/* $Id: DevVirtioNet.cpp 41917 2012-06-26 10:33:05Z vboxsync $ */
2/** @file
3 * DevVirtioNet - Virtio Network Device
4 */
5
6/*
7 * Copyright (C) 2009-2011 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19#define LOG_GROUP LOG_GROUP_DEV_VIRTIO_NET
20#define VNET_GC_SUPPORT
21#define VNET_WITH_GSO
22#define VNET_WITH_MERGEABLE_RX_BUFS
23
24#include <VBox/vmm/pdmdev.h>
25#include <VBox/vmm/pdmnetifs.h>
26#include <iprt/asm.h>
27#include <iprt/net.h>
28#include <iprt/semaphore.h>
29#ifdef IN_RING3
30# include <iprt/mem.h>
31# include <iprt/uuid.h>
32#endif /* IN_RING3 */
33#include "VBoxDD.h"
34#include "../VirtIO/Virtio.h"
35
36
37#ifndef VBOX_DEVICE_STRUCT_TESTCASE
38
39#define INSTANCE(pState) pState->VPCI.szInstance
40#define STATUS pState->config.uStatus
41
42#ifdef IN_RING3
43
44#define VNET_PCI_SUBSYSTEM_ID 1 + VIRTIO_NET_ID
45#define VNET_PCI_CLASS 0x0200
46#define VNET_N_QUEUES 3
47#define VNET_NAME_FMT "VNet%d"
48
49#if 0
50/* Virtio Block Device */
51#define VNET_PCI_SUBSYSTEM_ID 1 + VIRTIO_BLK_ID
52#define VNET_PCI_CLASS 0x0180
53#define VNET_N_QUEUES 2
54#define VNET_NAME_FMT "VBlk%d"
55#endif
56
57#endif /* IN_RING3 */
58
59/* Forward declarations ******************************************************/
60RT_C_DECLS_BEGIN
61PDMBOTHCBDECL(int) vnetIOPortIn (PPDMDEVINS pDevIns, void *pvUser, RTIOPORT port, uint32_t *pu32, unsigned cb);
62PDMBOTHCBDECL(int) vnetIOPortOut(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT port, uint32_t u32, unsigned cb);
63RT_C_DECLS_END
64
65#endif /* VBOX_DEVICE_STRUCT_TESTCASE */
66
67
68#define VNET_TX_DELAY 150 /* 150 microseconds */
69#define VNET_MAX_FRAME_SIZE 65536 // TODO: Is it the right limit?
70#define VNET_MAC_FILTER_LEN 32
71#define VNET_MAX_VID (1 << 12)
72
73/* Virtio net features */
74#define VNET_F_CSUM 0x00000001 /* Host handles pkts w/ partial csum */
75#define VNET_F_GUEST_CSUM 0x00000002 /* Guest handles pkts w/ partial csum */
76#define VNET_F_MAC 0x00000020 /* Host has given MAC address. */
77#define VNET_F_GSO 0x00000040 /* Host handles pkts w/ any GSO type */
78#define VNET_F_GUEST_TSO4 0x00000080 /* Guest can handle TSOv4 in. */
79#define VNET_F_GUEST_TSO6 0x00000100 /* Guest can handle TSOv6 in. */
80#define VNET_F_GUEST_ECN 0x00000200 /* Guest can handle TSO[6] w/ ECN in. */
81#define VNET_F_GUEST_UFO 0x00000400 /* Guest can handle UFO in. */
82#define VNET_F_HOST_TSO4 0x00000800 /* Host can handle TSOv4 in. */
83#define VNET_F_HOST_TSO6 0x00001000 /* Host can handle TSOv6 in. */
84#define VNET_F_HOST_ECN 0x00002000 /* Host can handle TSO[6] w/ ECN in. */
85#define VNET_F_HOST_UFO 0x00004000 /* Host can handle UFO in. */
86#define VNET_F_MRG_RXBUF 0x00008000 /* Host can merge receive buffers. */
87#define VNET_F_STATUS 0x00010000 /* virtio_net_config.status available */
88#define VNET_F_CTRL_VQ 0x00020000 /* Control channel available */
89#define VNET_F_CTRL_RX 0x00040000 /* Control channel RX mode support */
90#define VNET_F_CTRL_VLAN 0x00080000 /* Control channel VLAN filtering */
91
92#define VNET_S_LINK_UP 1
93
94
95#ifdef _MSC_VER
96struct VNetPCIConfig
97#else /* !_MSC_VER */
98struct __attribute__ ((__packed__)) VNetPCIConfig
99#endif /* !_MSC_VER */
100{
101 RTMAC mac;
102 uint16_t uStatus;
103};
104AssertCompileMemberOffset(struct VNetPCIConfig, uStatus, 6);
105
106/**
107 * Device state structure. Holds the current state of device.
108 *
109 * @extends VPCISTATE
110 * @implements PDMINETWORKDOWN
111 * @implements PDMINETWORKCONFIG
112 */
113struct VNetState_st
114{
115 /* VPCISTATE must be the first member! */
116 VPCISTATE VPCI;
117
118// PDMCRITSECT csRx; /**< Protects RX queue. */
119
120 PDMINETWORKDOWN INetworkDown;
121 PDMINETWORKCONFIG INetworkConfig;
122 R3PTRTYPE(PPDMIBASE) pDrvBase; /**< Attached network driver. */
123 R3PTRTYPE(PPDMINETWORKUP) pDrv; /**< Connector of attached network driver. */
124
125 R3PTRTYPE(PPDMQUEUE) pCanRxQueueR3; /**< Rx wakeup signaller - R3. */
126 R0PTRTYPE(PPDMQUEUE) pCanRxQueueR0; /**< Rx wakeup signaller - R0. */
127 RCPTRTYPE(PPDMQUEUE) pCanRxQueueRC; /**< Rx wakeup signaller - RC. */
128# if HC_ARCH_BITS == 64
129 uint32_t padding;
130# endif
131
132 /**< Link Up(/Restore) Timer. */
133 PTMTIMERR3 pLinkUpTimer;
134
135#ifdef VNET_TX_DELAY
136 /**< Transmit Delay Timer - R3. */
137 PTMTIMERR3 pTxTimerR3;
138 /**< Transmit Delay Timer - R0. */
139 PTMTIMERR0 pTxTimerR0;
140 /**< Transmit Delay Timer - GC. */
141 PTMTIMERRC pTxTimerRC;
142
143# if HC_ARCH_BITS == 64
144 uint32_t padding2;
145# endif
146
147 uint32_t u32i;
148 uint32_t u32AvgDiff;
149 uint32_t u32MinDiff;
150 uint32_t u32MaxDiff;
151 uint64_t u64NanoTS;
152#endif /* VNET_TX_DELAY */
153
154 /** Indicates transmission in progress -- only one thread is allowed. */
155 uint32_t uIsTransmitting;
156
157 /** PCI config area holding MAC address as well as TBD. */
158 struct VNetPCIConfig config;
159 /** MAC address obtained from the configuration. */
160 RTMAC macConfigured;
161 /** True if physical cable is attached in configuration. */
162 bool fCableConnected;
163 /** Link up delay (in milliseconds). */
164 uint32_t cMsLinkUpDelay;
165
166 uint32_t alignment;
167
168 /** Number of packet being sent/received to show in debug log. */
169 uint32_t u32PktNo;
170
171 /** N/A: */
172 bool volatile fMaybeOutOfSpace;
173
174 /** Promiscuous mode -- RX filter accepts all packets. */
175 bool fPromiscuous;
176 /** AllMulti mode -- RX filter accepts all multicast packets. */
177 bool fAllMulti;
178 /** The number of actually used slots in aMacTable. */
179 uint32_t nMacFilterEntries;
180 /** Array of MAC addresses accepted by RX filter. */
181 RTMAC aMacFilter[VNET_MAC_FILTER_LEN];
182 /** Bit array of VLAN filter, one bit per VLAN ID. */
183 uint8_t aVlanFilter[VNET_MAX_VID / sizeof(uint8_t)];
184
185 R3PTRTYPE(PVQUEUE) pRxQueue;
186 R3PTRTYPE(PVQUEUE) pTxQueue;
187 R3PTRTYPE(PVQUEUE) pCtlQueue;
188 /* Receive-blocking-related fields ***************************************/
189
190 /** EMT: Gets signalled when more RX descriptors become available. */
191 RTSEMEVENT hEventMoreRxDescAvail;
192
193 /* Statistic fields ******************************************************/
194
195 STAMCOUNTER StatReceiveBytes;
196 STAMCOUNTER StatTransmitBytes;
197 STAMCOUNTER StatReceiveGSO;
198 STAMCOUNTER StatTransmitPackets;
199 STAMCOUNTER StatTransmitGSO;
200 STAMCOUNTER StatTransmitCSum;
201#if defined(VBOX_WITH_STATISTICS)
202 STAMPROFILE StatReceive;
203 STAMPROFILE StatReceiveStore;
204 STAMPROFILEADV StatTransmit;
205 STAMPROFILE StatTransmitSend;
206 STAMPROFILE StatRxOverflow;
207 STAMCOUNTER StatRxOverflowWakeup;
208#endif /* VBOX_WITH_STATISTICS */
209
210};
211typedef struct VNetState_st VNETSTATE;
212typedef VNETSTATE *PVNETSTATE;
213
214#ifndef VBOX_DEVICE_STRUCT_TESTCASE
215
216#define VNETHDR_F_NEEDS_CSUM 1 // Use u16CSumStart, u16CSumOffset
217
218#define VNETHDR_GSO_NONE 0 // Not a GSO frame
219#define VNETHDR_GSO_TCPV4 1 // GSO frame, IPv4 TCP (TSO)
220#define VNETHDR_GSO_UDP 3 // GSO frame, IPv4 UDP (UFO)
221#define VNETHDR_GSO_TCPV6 4 // GSO frame, IPv6 TCP
222#define VNETHDR_GSO_ECN 0x80 // TCP has ECN set
223
224struct VNetHdr
225{
226 uint8_t u8Flags;
227 uint8_t u8GSOType;
228 uint16_t u16HdrLen;
229 uint16_t u16GSOSize;
230 uint16_t u16CSumStart;
231 uint16_t u16CSumOffset;
232};
233typedef struct VNetHdr VNETHDR;
234typedef VNETHDR *PVNETHDR;
235AssertCompileSize(VNETHDR, 10);
236
237struct VNetHdrMrx
238{
239 VNETHDR Hdr;
240 uint16_t u16NumBufs;
241};
242typedef struct VNetHdrMrx VNETHDRMRX;
243typedef VNETHDRMRX *PVNETHDRMRX;
244AssertCompileSize(VNETHDRMRX, 12);
245
246AssertCompileMemberOffset(VNETSTATE, VPCI, 0);
247
248#define VNET_OK 0
249#define VNET_ERROR 1
250typedef uint8_t VNETCTLACK;
251
252#define VNET_CTRL_CLS_RX_MODE 0
253#define VNET_CTRL_CMD_RX_MODE_PROMISC 0
254#define VNET_CTRL_CMD_RX_MODE_ALLMULTI 1
255
256#define VNET_CTRL_CLS_MAC 1
257#define VNET_CTRL_CMD_MAC_TABLE_SET 0
258
259#define VNET_CTRL_CLS_VLAN 2
260#define VNET_CTRL_CMD_VLAN_ADD 0
261#define VNET_CTRL_CMD_VLAN_DEL 1
262
263
264struct VNetCtlHdr
265{
266 uint8_t u8Class;
267 uint8_t u8Command;
268};
269typedef struct VNetCtlHdr VNETCTLHDR;
270typedef VNETCTLHDR *PVNETCTLHDR;
271AssertCompileSize(VNETCTLHDR, 2);
272
273/* Returns true if large packets are written into several RX buffers. */
274DECLINLINE(bool) vnetMergeableRxBuffers(PVNETSTATE pState)
275{
276 return !!(pState->VPCI.uGuestFeatures & VNET_F_MRG_RXBUF);
277}
278
279DECLINLINE(int) vnetCsEnter(PVNETSTATE pState, int rcBusy)
280{
281 return vpciCsEnter(&pState->VPCI, rcBusy);
282}
283
284DECLINLINE(void) vnetCsLeave(PVNETSTATE pState)
285{
286 vpciCsLeave(&pState->VPCI);
287}
288
289DECLINLINE(int) vnetCsRxEnter(PVNETSTATE pState, int rcBusy)
290{
291 // STAM_PROFILE_START(&pState->CTXSUFF(StatCsRx), a);
292 // int rc = PDMCritSectEnter(&pState->csRx, rcBusy);
293 // STAM_PROFILE_STOP(&pState->CTXSUFF(StatCsRx), a);
294 // return rc;
295 return VINF_SUCCESS;
296}
297
298DECLINLINE(void) vnetCsRxLeave(PVNETSTATE pState)
299{
300 // PDMCritSectLeave(&pState->csRx);
301}
302
303/**
304 * Dump a packet to debug log.
305 *
306 * @param pState The device state structure.
307 * @param cpPacket The packet.
308 * @param cb The size of the packet.
309 * @param cszText A string denoting direction of packet transfer.
310 */
311DECLINLINE(void) vnetPacketDump(PVNETSTATE pState, const uint8_t *cpPacket, size_t cb, const char *cszText)
312{
313#ifdef DEBUG
314 Log(("%s %s packet #%d (%d bytes):\n",
315 INSTANCE(pState), cszText, ++pState->u32PktNo, cb));
316 Log3(("%.*Rhxd\n", cb, cpPacket));
317#endif
318}
319
320/**
321 * Print features given in uFeatures to debug log.
322 *
323 * @param pState The device state structure.
324 * @param uFeatures Descriptions of which features to print.
325 * @param pcszText A string to print before the list of features.
326 */
327DECLINLINE(void) vnetPrintFeatures(PVNETSTATE pState, uint32_t uFeatures, const char *pcszText)
328{
329#ifdef DEBUG
330 static struct
331 {
332 uint32_t uMask;
333 const char *pcszDesc;
334 } aFeatures[] = {
335 { VNET_F_CSUM, "host handles pkts w/ partial csum" },
336 { VNET_F_GUEST_CSUM, "guest handles pkts w/ partial csum" },
337 { VNET_F_MAC, "host has given MAC address" },
338 { VNET_F_GSO, "host handles pkts w/ any GSO type" },
339 { VNET_F_GUEST_TSO4, "guest can handle TSOv4 in" },
340 { VNET_F_GUEST_TSO6, "guest can handle TSOv6 in" },
341 { VNET_F_GUEST_ECN, "guest can handle TSO[6] w/ ECN in" },
342 { VNET_F_GUEST_UFO, "guest can handle UFO in" },
343 { VNET_F_HOST_TSO4, "host can handle TSOv4 in" },
344 { VNET_F_HOST_TSO6, "host can handle TSOv6 in" },
345 { VNET_F_HOST_ECN, "host can handle TSO[6] w/ ECN in" },
346 { VNET_F_HOST_UFO, "host can handle UFO in" },
347 { VNET_F_MRG_RXBUF, "host can merge receive buffers" },
348 { VNET_F_STATUS, "virtio_net_config.status available" },
349 { VNET_F_CTRL_VQ, "control channel available" },
350 { VNET_F_CTRL_RX, "control channel RX mode support" },
351 { VNET_F_CTRL_VLAN, "control channel VLAN filtering" }
352 };
353
354 Log3(("%s %s:\n", INSTANCE(pState), pcszText));
355 for (unsigned i = 0; i < RT_ELEMENTS(aFeatures); ++i)
356 {
357 if (aFeatures[i].uMask & uFeatures)
358 Log3(("%s --> %s\n", INSTANCE(pState), aFeatures[i].pcszDesc));
359 }
360#endif /* DEBUG */
361}
362
363PDMBOTHCBDECL(uint32_t) vnetGetHostFeatures(void *pvState)
364{
365 /* We support:
366 * - Host-provided MAC address
367 * - Link status reporting in config space
368 * - Control queue
369 * - RX mode setting
370 * - MAC filter table
371 * - VLAN filter
372 */
373 return VNET_F_MAC
374 | VNET_F_STATUS
375 | VNET_F_CTRL_VQ
376 | VNET_F_CTRL_RX
377 | VNET_F_CTRL_VLAN
378#ifdef VNET_WITH_GSO
379 | VNET_F_CSUM
380 | VNET_F_HOST_TSO4
381 | VNET_F_HOST_TSO6
382 | VNET_F_HOST_UFO
383 | VNET_F_GUEST_TSO4
384 | VNET_F_GUEST_TSO6
385 | VNET_F_GUEST_UFO
386#endif
387#ifdef VNET_WITH_MERGEABLE_RX_BUFS
388 | VNET_F_MRG_RXBUF
389#endif
390 ;
391}
392
393PDMBOTHCBDECL(uint32_t) vnetGetHostMinimalFeatures(void *pvState)
394{
395 return VNET_F_MAC;
396}
397
398PDMBOTHCBDECL(void) vnetSetHostFeatures(void *pvState, uint32_t uFeatures)
399{
400 // TODO: Nothing to do here yet
401 VNETSTATE *pState = (VNETSTATE *)pvState;
402 LogFlow(("%s vnetSetHostFeatures: uFeatures=%x\n", INSTANCE(pState), uFeatures));
403 vnetPrintFeatures(pState, uFeatures, "The guest negotiated the following features");
404}
405
406PDMBOTHCBDECL(int) vnetGetConfig(void *pvState, uint32_t port, uint32_t cb, void *data)
407{
408 VNETSTATE *pState = (VNETSTATE *)pvState;
409 if (port + cb > sizeof(struct VNetPCIConfig))
410 {
411 Log(("%s vnetGetConfig: Read beyond the config structure is attempted (port=%RTiop cb=%x).\n", INSTANCE(pState), port, cb));
412 return VERR_IOM_IOPORT_UNUSED;
413 }
414 memcpy(data, ((uint8_t*)&pState->config) + port, cb);
415 return VINF_SUCCESS;
416}
417
418PDMBOTHCBDECL(int) vnetSetConfig(void *pvState, uint32_t port, uint32_t cb, void *data)
419{
420 VNETSTATE *pState = (VNETSTATE *)pvState;
421 if (port + cb > sizeof(struct VNetPCIConfig))
422 {
423 Log(("%s vnetGetConfig: Write beyond the config structure is attempted (port=%RTiop cb=%x).\n", INSTANCE(pState), port, cb));
424 if (port < sizeof(struct VNetPCIConfig))
425 memcpy(((uint8_t*)&pState->config) + port, data,
426 sizeof(struct VNetPCIConfig) - port);
427 return VINF_SUCCESS;
428 }
429 memcpy(((uint8_t*)&pState->config) + port, data, cb);
430 return VINF_SUCCESS;
431}
432
433/**
434 * Hardware reset. Revert all registers to initial values.
435 *
436 * @param pState The device state structure.
437 */
438PDMBOTHCBDECL(int) vnetReset(void *pvState)
439{
440 VNETSTATE *pState = (VNETSTATE*)pvState;
441 Log(("%s Reset triggered\n", INSTANCE(pState)));
442
443 int rc = vnetCsRxEnter(pState, VERR_SEM_BUSY);
444 if (RT_UNLIKELY(rc != VINF_SUCCESS))
445 {
446 LogRel(("vnetReset failed to enter RX critical section!\n"));
447 return rc;
448 }
449 vpciReset(&pState->VPCI);
450 vnetCsRxLeave(pState);
451
452 // TODO: Implement reset
453 if (pState->fCableConnected)
454 STATUS = VNET_S_LINK_UP;
455 else
456 STATUS = 0;
457
458 /*
459 * By default we pass all packets up since the older guests cannot control
460 * virtio mode.
461 */
462 pState->fPromiscuous = true;
463 pState->fAllMulti = false;
464 pState->nMacFilterEntries = 0;
465 memset(pState->aMacFilter, 0, VNET_MAC_FILTER_LEN * sizeof(RTMAC));
466 memset(pState->aVlanFilter, 0, sizeof(pState->aVlanFilter));
467 pState->uIsTransmitting = 0;
468#ifndef IN_RING3
469 return VINF_IOM_R3_IOPORT_WRITE;
470#else
471 if (pState->pDrv)
472 pState->pDrv->pfnSetPromiscuousMode(pState->pDrv, true);
473 return VINF_SUCCESS;
474#endif
475}
476
477#ifdef IN_RING3
478
479/**
480 * Wakeup the RX thread.
481 */
482static void vnetWakeupReceive(PPDMDEVINS pDevIns)
483{
484 VNETSTATE *pState = PDMINS_2_DATA(pDevIns, VNETSTATE *);
485 if ( pState->fMaybeOutOfSpace
486 && pState->hEventMoreRxDescAvail != NIL_RTSEMEVENT)
487 {
488 STAM_COUNTER_INC(&pState->StatRxOverflowWakeup);
489 Log(("%s Waking up Out-of-RX-space semaphore\n", INSTANCE(pState)));
490 RTSemEventSignal(pState->hEventMoreRxDescAvail);
491 }
492}
493
494/**
495 * Link Up Timer handler.
496 *
497 * @param pDevIns Pointer to device instance structure.
498 * @param pTimer Pointer to the timer.
499 * @param pvUser NULL.
500 * @thread EMT
501 */
502static DECLCALLBACK(void) vnetLinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
503{
504 VNETSTATE *pState = (VNETSTATE *)pvUser;
505
506 int rc = vnetCsEnter(pState, VERR_SEM_BUSY);
507 if (RT_UNLIKELY(rc != VINF_SUCCESS))
508 return;
509 STATUS |= VNET_S_LINK_UP;
510 vpciRaiseInterrupt(&pState->VPCI, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
511 vnetWakeupReceive(pDevIns);
512 vnetCsLeave(pState);
513}
514
515
516
517
518/**
519 * Handler for the wakeup signaller queue.
520 */
521static DECLCALLBACK(bool) vnetCanRxQueueConsumer(PPDMDEVINS pDevIns, PPDMQUEUEITEMCORE pItem)
522{
523 vnetWakeupReceive(pDevIns);
524 return true;
525}
526
527#endif /* IN_RING3 */
528
529/**
530 * This function is called when the driver becomes ready.
531 *
532 * @param pState The device state structure.
533 */
534PDMBOTHCBDECL(void) vnetReady(void *pvState)
535{
536 VNETSTATE *pState = (VNETSTATE*)pvState;
537 Log(("%s Driver became ready, waking up RX thread...\n", INSTANCE(pState)));
538#ifdef IN_RING3
539 vnetWakeupReceive(pState->VPCI.CTX_SUFF(pDevIns));
540#else
541 PPDMQUEUEITEMCORE pItem = PDMQueueAlloc(pState->CTX_SUFF(pCanRxQueue));
542 if (pItem)
543 PDMQueueInsert(pState->CTX_SUFF(pCanRxQueue), pItem);
544#endif
545}
546
547/**
548 * Port I/O Handler for IN operations.
549 *
550 * @returns VBox status code.
551 *
552 * @param pDevIns The device instance.
553 * @param pvUser Pointer to the device state structure.
554 * @param port Port number used for the IN operation.
555 * @param pu32 Where to store the result.
556 * @param cb Number of bytes read.
557 * @thread EMT
558 */
559PDMBOTHCBDECL(int) vnetIOPortIn(PPDMDEVINS pDevIns, void *pvUser,
560 RTIOPORT port, uint32_t *pu32, unsigned cb)
561{
562 return vpciIOPortIn(pDevIns, pvUser, port, pu32, cb,
563 vnetGetHostFeatures,
564 vnetGetConfig);
565}
566
567
568/**
569 * Port I/O Handler for OUT operations.
570 *
571 * @returns VBox status code.
572 *
573 * @param pDevIns The device instance.
574 * @param pvUser User argument.
575 * @param Port Port number used for the IN operation.
576 * @param u32 The value to output.
577 * @param cb The value size in bytes.
578 * @thread EMT
579 */
580PDMBOTHCBDECL(int) vnetIOPortOut(PPDMDEVINS pDevIns, void *pvUser,
581 RTIOPORT port, uint32_t u32, unsigned cb)
582{
583 return vpciIOPortOut(pDevIns, pvUser, port, u32, cb,
584 vnetGetHostMinimalFeatures,
585 vnetGetHostFeatures,
586 vnetSetHostFeatures,
587 vnetReset,
588 vnetReady,
589 vnetSetConfig);
590}
591
592
593#ifdef IN_RING3
594
595/**
596 * Check if the device can receive data now.
597 * This must be called before the pfnRecieve() method is called.
598 *
599 * @remarks As a side effect this function enables queue notification
600 * if it cannot receive because the queue is empty.
601 * It disables notification if it can receive.
602 *
603 * @returns VERR_NET_NO_BUFFER_SPACE if it cannot.
604 * @param pInterface Pointer to the interface structure containing the called function pointer.
605 * @thread RX
606 */
607static int vnetCanReceive(VNETSTATE *pState)
608{
609 int rc = vnetCsRxEnter(pState, VERR_SEM_BUSY);
610 AssertRCReturn(rc, rc);
611
612 LogFlow(("%s vnetCanReceive\n", INSTANCE(pState)));
613 if (!(pState->VPCI.uStatus & VPCI_STATUS_DRV_OK))
614 rc = VERR_NET_NO_BUFFER_SPACE;
615 else if (!vqueueIsReady(&pState->VPCI, pState->pRxQueue))
616 rc = VERR_NET_NO_BUFFER_SPACE;
617 else if (vqueueIsEmpty(&pState->VPCI, pState->pRxQueue))
618 {
619 vringSetNotification(&pState->VPCI, &pState->pRxQueue->VRing, true);
620 rc = VERR_NET_NO_BUFFER_SPACE;
621 }
622 else
623 {
624 vringSetNotification(&pState->VPCI, &pState->pRxQueue->VRing, false);
625 rc = VINF_SUCCESS;
626 }
627
628 LogFlow(("%s vnetCanReceive -> %Rrc\n", INSTANCE(pState), rc));
629 vnetCsRxLeave(pState);
630 return rc;
631}
632
633/**
634 * @interface_method_impl{PDMINETWORKDOWN,pfnWaitReceiveAvail}
635 */
636static DECLCALLBACK(int) vnetNetworkDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
637{
638 VNETSTATE *pState = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkDown);
639 LogFlow(("%s vnetNetworkDown_WaitReceiveAvail(cMillies=%u)\n", INSTANCE(pState), cMillies));
640 int rc = vnetCanReceive(pState);
641
642 if (RT_SUCCESS(rc))
643 return VINF_SUCCESS;
644 if (RT_UNLIKELY(cMillies == 0))
645 return VERR_NET_NO_BUFFER_SPACE;
646
647 rc = VERR_INTERRUPTED;
648 ASMAtomicXchgBool(&pState->fMaybeOutOfSpace, true);
649 STAM_PROFILE_START(&pState->StatRxOverflow, a);
650
651 VMSTATE enmVMState;
652 while (RT_LIKELY( (enmVMState = PDMDevHlpVMState(pState->VPCI.CTX_SUFF(pDevIns))) == VMSTATE_RUNNING
653 || enmVMState == VMSTATE_RUNNING_LS))
654 {
655 int rc2 = vnetCanReceive(pState);
656 if (RT_SUCCESS(rc2))
657 {
658 rc = VINF_SUCCESS;
659 break;
660 }
661 Log(("%s vnetNetworkDown_WaitReceiveAvail: waiting cMillies=%u...\n",
662 INSTANCE(pState), cMillies));
663 RTSemEventWait(pState->hEventMoreRxDescAvail, cMillies);
664 }
665 STAM_PROFILE_STOP(&pState->StatRxOverflow, a);
666 ASMAtomicXchgBool(&pState->fMaybeOutOfSpace, false);
667
668 LogFlow(("%s vnetNetworkDown_WaitReceiveAvail -> %d\n", INSTANCE(pState), rc));
669 return rc;
670}
671
672
673/**
674 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
675 */
676static DECLCALLBACK(void *) vnetQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
677{
678 VNETSTATE *pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, VPCI.IBase);
679 Assert(&pThis->VPCI.IBase == pInterface);
680
681 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
682 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis->INetworkConfig);
683 return vpciQueryInterface(pInterface, pszIID);
684}
685
686/**
687 * Returns true if it is a broadcast packet.
688 *
689 * @returns true if destination address indicates broadcast.
690 * @param pvBuf The ethernet packet.
691 */
692DECLINLINE(bool) vnetIsBroadcast(const void *pvBuf)
693{
694 static const uint8_t s_abBcastAddr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
695 return memcmp(pvBuf, s_abBcastAddr, sizeof(s_abBcastAddr)) == 0;
696}
697
698/**
699 * Returns true if it is a multicast packet.
700 *
701 * @remarks returns true for broadcast packets as well.
702 * @returns true if destination address indicates multicast.
703 * @param pvBuf The ethernet packet.
704 */
705DECLINLINE(bool) vnetIsMulticast(const void *pvBuf)
706{
707 return (*(char*)pvBuf) & 1;
708}
709
710/**
711 * Determines if the packet is to be delivered to upper layer.
712 *
713 * @returns true if packet is intended for this node.
714 * @param pState Pointer to the state structure.
715 * @param pvBuf The ethernet packet.
716 * @param cb Number of bytes available in the packet.
717 */
718static bool vnetAddressFilter(PVNETSTATE pState, const void *pvBuf, size_t cb)
719{
720 if (pState->fPromiscuous)
721 return true;
722
723 /* Ignore everything outside of our VLANs */
724 uint16_t *u16Ptr = (uint16_t*)pvBuf;
725 /* Compare TPID with VLAN Ether Type */
726 if ( u16Ptr[6] == RT_H2BE_U16(0x8100)
727 && !ASMBitTest(pState->aVlanFilter, RT_BE2H_U16(u16Ptr[7]) & 0xFFF))
728 {
729 Log4(("%s vnetAddressFilter: not our VLAN, returning false\n", INSTANCE(pState)));
730 return false;
731 }
732
733 if (vnetIsBroadcast(pvBuf))
734 return true;
735
736 if (pState->fAllMulti && vnetIsMulticast(pvBuf))
737 return true;
738
739 if (!memcmp(pState->config.mac.au8, pvBuf, sizeof(RTMAC)))
740 return true;
741 Log4(("%s vnetAddressFilter: %RTmac (conf) != %RTmac (dest)\n",
742 INSTANCE(pState), pState->config.mac.au8, pvBuf));
743
744 for (unsigned i = 0; i < pState->nMacFilterEntries; i++)
745 if (!memcmp(&pState->aMacFilter[i], pvBuf, sizeof(RTMAC)))
746 return true;
747
748 Log2(("%s vnetAddressFilter: failed all tests, returning false, packet dump follows:\n", INSTANCE(pState)));
749 vnetPacketDump(pState, (const uint8_t*)pvBuf, cb, "<-- Incoming");
750
751 return false;
752}
753
754/**
755 * Pad and store received packet.
756 *
757 * @remarks Make sure that the packet appears to upper layer as one coming
758 * from real Ethernet: pad it and insert FCS.
759 *
760 * @returns VBox status code.
761 * @param pState The device state structure.
762 * @param pvBuf The available data.
763 * @param cb Number of bytes available in the buffer.
764 * @thread RX
765 */
766static int vnetHandleRxPacket(PVNETSTATE pState, const void *pvBuf, size_t cb,
767 PCPDMNETWORKGSO pGso)
768{
769 VNETHDRMRX Hdr;
770 PVNETHDRMRX pHdr;
771 unsigned uHdrLen;
772 RTGCPHYS addrHdrMrx = 0;
773
774 if (pGso)
775 {
776 Log2(("%s vnetHandleRxPacket: gso type=%x cbHdrsTotal=%u cbHdrsSeg=%u mss=%u"
777 " off1=0x%x off2=0x%x\n", INSTANCE(pState), pGso->u8Type,
778 pGso->cbHdrsTotal, pGso->cbHdrsSeg, pGso->cbMaxSeg, pGso->offHdr1, pGso->offHdr2));
779 Hdr.Hdr.u8Flags = VNETHDR_F_NEEDS_CSUM;
780 switch (pGso->u8Type)
781 {
782 case PDMNETWORKGSOTYPE_IPV4_TCP:
783 Hdr.Hdr.u8GSOType = VNETHDR_GSO_TCPV4;
784 Hdr.Hdr.u16CSumOffset = RT_OFFSETOF(RTNETTCP, th_sum);
785 break;
786 case PDMNETWORKGSOTYPE_IPV6_TCP:
787 Hdr.Hdr.u8GSOType = VNETHDR_GSO_TCPV6;
788 Hdr.Hdr.u16CSumOffset = RT_OFFSETOF(RTNETTCP, th_sum);
789 break;
790 case PDMNETWORKGSOTYPE_IPV4_UDP:
791 Hdr.Hdr.u8GSOType = VNETHDR_GSO_UDP;
792 Hdr.Hdr.u16CSumOffset = RT_OFFSETOF(RTNETUDP, uh_sum);
793 break;
794 default:
795 return VERR_INVALID_PARAMETER;
796 }
797 Hdr.Hdr.u16HdrLen = pGso->cbHdrsTotal;
798 Hdr.Hdr.u16GSOSize = pGso->cbMaxSeg;
799 Hdr.Hdr.u16CSumStart = pGso->offHdr2;
800 STAM_REL_COUNTER_INC(&pState->StatReceiveGSO);
801 }
802 else
803 {
804 Hdr.Hdr.u8Flags = 0;
805 Hdr.Hdr.u8GSOType = VNETHDR_GSO_NONE;
806 }
807
808 if (vnetMergeableRxBuffers(pState))
809 uHdrLen = sizeof(VNETHDRMRX);
810 else
811 uHdrLen = sizeof(VNETHDR);
812
813 vnetPacketDump(pState, (const uint8_t*)pvBuf, cb, "<-- Incoming");
814
815 unsigned int uOffset = 0;
816 unsigned int nElem;
817 for (nElem = 0; uOffset < cb; nElem++)
818 {
819 VQUEUEELEM elem;
820 unsigned int nSeg = 0, uElemSize = 0, cbReserved = 0;
821
822 if (!vqueueGet(&pState->VPCI, pState->pRxQueue, &elem))
823 {
824 /*
825 * @todo: It is possible to run out of RX buffers if only a few
826 * were added and we received a big packet.
827 */
828 Log(("%s vnetHandleRxPacket: Suddenly there is no space in receive queue!\n", INSTANCE(pState)));
829 return VERR_INTERNAL_ERROR;
830 }
831
832 if (elem.nIn < 1)
833 {
834 Log(("%s vnetHandleRxPacket: No writable descriptors in receive queue!\n", INSTANCE(pState)));
835 return VERR_INTERNAL_ERROR;
836 }
837
838 if (nElem == 0)
839 {
840 if (vnetMergeableRxBuffers(pState))
841 {
842 addrHdrMrx = elem.aSegsIn[nSeg].addr;
843 cbReserved = uHdrLen;
844 }
845 else
846 {
847 /* The very first segment of the very first element gets the header. */
848 if (elem.aSegsIn[nSeg].cb != sizeof(VNETHDR))
849 {
850 Log(("%s vnetHandleRxPacket: The first descriptor does match the header size!\n", INSTANCE(pState)));
851 return VERR_INTERNAL_ERROR;
852 }
853 elem.aSegsIn[nSeg++].pv = &Hdr;
854 }
855 uElemSize += uHdrLen;
856 }
857 while (nSeg < elem.nIn && uOffset < cb)
858 {
859 unsigned int uSize = (unsigned int)RT_MIN(elem.aSegsIn[nSeg].cb - (nSeg?0:cbReserved),
860 cb - uOffset);
861 elem.aSegsIn[nSeg++].pv = (uint8_t*)pvBuf + uOffset;
862 uOffset += uSize;
863 uElemSize += uSize;
864 }
865 STAM_PROFILE_START(&pState->StatReceiveStore, a);
866 vqueuePut(&pState->VPCI, pState->pRxQueue, &elem, uElemSize, cbReserved);
867 STAM_PROFILE_STOP(&pState->StatReceiveStore, a);
868 if (!vnetMergeableRxBuffers(pState))
869 break;
870 cbReserved = 0;
871 }
872 if (vnetMergeableRxBuffers(pState))
873 {
874 Hdr.u16NumBufs = nElem;
875 int rc = PDMDevHlpPhysWrite(pState->VPCI.CTX_SUFF(pDevIns), addrHdrMrx,
876 &Hdr, sizeof(Hdr));
877 if (RT_FAILURE(rc))
878 {
879 Log(("%s vnetHandleRxPacket: Failed to write merged RX buf header: %Rrc\n",
880 INSTANCE(pState), rc));
881 return rc;
882 }
883 }
884 vqueueSync(&pState->VPCI, pState->pRxQueue);
885 if (uOffset < cb)
886 {
887 Log(("%s vnetHandleRxPacket: Packet did not fit into RX queue (packet size=%u)!\n",
888 INSTANCE(pState), cb));
889 return VERR_TOO_MUCH_DATA;
890 }
891
892 return VINF_SUCCESS;
893}
894
895/**
896 * @interface_method_impl{PDMINETWORKDOWN,pfnReceiveGso}
897 */
898static DECLCALLBACK(int) vnetNetworkDown_ReceiveGso(PPDMINETWORKDOWN pInterface,
899 const void *pvBuf, size_t cb,
900 PCPDMNETWORKGSO pGso)
901{
902 VNETSTATE *pState = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkDown);
903
904 if (pGso)
905 {
906 uint32_t uFeatures = pState->VPCI.uGuestFeatures;
907
908 switch (pGso->u8Type)
909 {
910 case PDMNETWORKGSOTYPE_IPV4_TCP:
911 uFeatures &= VNET_F_GUEST_TSO4;
912 break;
913 case PDMNETWORKGSOTYPE_IPV6_TCP:
914 uFeatures &= VNET_F_GUEST_TSO6;
915 break;
916 case PDMNETWORKGSOTYPE_IPV4_UDP:
917 case PDMNETWORKGSOTYPE_IPV6_UDP:
918 uFeatures &= VNET_F_GUEST_UFO;
919 break;
920 default:
921 uFeatures = 0;
922 break;
923 }
924 if (!uFeatures)
925 {
926 Log2(("%s vnetNetworkDown_ReceiveGso: GSO type (0x%x) not supported\n",
927 INSTANCE(pState), pGso->u8Type));
928 return VERR_NOT_SUPPORTED;
929 }
930 }
931
932 Log2(("%s vnetNetworkDown_ReceiveGso: pvBuf=%p cb=%u pGso=%p\n",
933 INSTANCE(pState), pvBuf, cb, pGso));
934 int rc = vnetCanReceive(pState);
935 if (RT_FAILURE(rc))
936 return rc;
937
938 /* Drop packets if VM is not running or cable is disconnected. */
939 VMSTATE enmVMState = PDMDevHlpVMState(pState->VPCI.CTX_SUFF(pDevIns));
940 if (( enmVMState != VMSTATE_RUNNING
941 && enmVMState != VMSTATE_RUNNING_LS)
942 || !(STATUS & VNET_S_LINK_UP))
943 return VINF_SUCCESS;
944
945 STAM_PROFILE_START(&pState->StatReceive, a);
946 vpciSetReadLed(&pState->VPCI, true);
947 if (vnetAddressFilter(pState, pvBuf, cb))
948 {
949 rc = vnetCsRxEnter(pState, VERR_SEM_BUSY);
950 if (RT_SUCCESS(rc))
951 {
952 rc = vnetHandleRxPacket(pState, pvBuf, cb, pGso);
953 STAM_REL_COUNTER_ADD(&pState->StatReceiveBytes, cb);
954 vnetCsRxLeave(pState);
955 }
956 }
957 vpciSetReadLed(&pState->VPCI, false);
958 STAM_PROFILE_STOP(&pState->StatReceive, a);
959 return rc;
960}
961
962/**
963 * @interface_method_impl{PDMINETWORKDOWN,pfnReceive}
964 */
965static DECLCALLBACK(int) vnetNetworkDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
966{
967 return vnetNetworkDown_ReceiveGso(pInterface, pvBuf, cb, NULL);
968}
969
970/**
971 * Gets the current Media Access Control (MAC) address.
972 *
973 * @returns VBox status code.
974 * @param pInterface Pointer to the interface structure containing the called function pointer.
975 * @param pMac Where to store the MAC address.
976 * @thread EMT
977 */
978static DECLCALLBACK(int) vnetGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
979{
980 VNETSTATE *pState = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
981 memcpy(pMac, pState->config.mac.au8, sizeof(RTMAC));
982 return VINF_SUCCESS;
983}
984
985/**
986 * Gets the new link state.
987 *
988 * @returns The current link state.
989 * @param pInterface Pointer to the interface structure containing the called function pointer.
990 * @thread EMT
991 */
992static DECLCALLBACK(PDMNETWORKLINKSTATE) vnetGetLinkState(PPDMINETWORKCONFIG pInterface)
993{
994 VNETSTATE *pState = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
995 if (STATUS & VNET_S_LINK_UP)
996 return PDMNETWORKLINKSTATE_UP;
997 return PDMNETWORKLINKSTATE_DOWN;
998}
999
1000
1001/**
1002 * Sets the new link state.
1003 *
1004 * @returns VBox status code.
1005 * @param pInterface Pointer to the interface structure containing the called function pointer.
1006 * @param enmState The new link state
1007 */
1008static DECLCALLBACK(int) vnetSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
1009{
1010 VNETSTATE *pState = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkConfig);
1011 bool fOldUp = !!(STATUS & VNET_S_LINK_UP);
1012 bool fNewUp = enmState == PDMNETWORKLINKSTATE_UP;
1013
1014 if (fNewUp != fOldUp)
1015 {
1016 if (fNewUp)
1017 {
1018 Log(("%s Link is up\n", INSTANCE(pState)));
1019 STATUS |= VNET_S_LINK_UP;
1020 vpciRaiseInterrupt(&pState->VPCI, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
1021 }
1022 else
1023 {
1024 Log(("%s Link is down\n", INSTANCE(pState)));
1025 STATUS &= ~VNET_S_LINK_UP;
1026 vpciRaiseInterrupt(&pState->VPCI, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
1027 }
1028 if (pState->pDrv)
1029 pState->pDrv->pfnNotifyLinkChanged(pState->pDrv, enmState);
1030 }
1031 return VINF_SUCCESS;
1032}
1033
1034static DECLCALLBACK(void) vnetQueueReceive(void *pvState, PVQUEUE pQueue)
1035{
1036 VNETSTATE *pState = (VNETSTATE*)pvState;
1037 Log(("%s Receive buffers has been added, waking up receive thread.\n", INSTANCE(pState)));
1038 vnetWakeupReceive(pState->VPCI.CTX_SUFF(pDevIns));
1039}
1040
1041/**
1042 * Sets up the GSO context according to the Virtio header.
1043 *
1044 * @param pGso The GSO context to setup.
1045 * @param pCtx The context descriptor.
1046 */
1047DECLINLINE(PPDMNETWORKGSO) vnetSetupGsoCtx(PPDMNETWORKGSO pGso, VNETHDR const *pHdr)
1048{
1049 pGso->u8Type = PDMNETWORKGSOTYPE_INVALID;
1050
1051 if (pHdr->u8GSOType & VNETHDR_GSO_ECN)
1052 {
1053 AssertMsgFailed(("Unsupported flag in virtio header: ECN\n"));
1054 return NULL;
1055 }
1056 switch (pHdr->u8GSOType & ~VNETHDR_GSO_ECN)
1057 {
1058 case VNETHDR_GSO_TCPV4:
1059 pGso->u8Type = PDMNETWORKGSOTYPE_IPV4_TCP;
1060 pGso->cbHdrsSeg = pHdr->u16HdrLen;
1061 break;
1062 case VNETHDR_GSO_TCPV6:
1063 pGso->u8Type = PDMNETWORKGSOTYPE_IPV6_TCP;
1064 pGso->cbHdrsSeg = pHdr->u16HdrLen;
1065 break;
1066 case VNETHDR_GSO_UDP:
1067 pGso->u8Type = PDMNETWORKGSOTYPE_IPV4_UDP;
1068 pGso->cbHdrsSeg = pHdr->u16CSumStart;
1069 break;
1070 default:
1071 return NULL;
1072 }
1073 if (pHdr->u8Flags & VNETHDR_F_NEEDS_CSUM)
1074 pGso->offHdr2 = pHdr->u16CSumStart;
1075 else
1076 {
1077 AssertMsgFailed(("GSO without checksum offloading!\n"));
1078 return NULL;
1079 }
1080 pGso->offHdr1 = sizeof(RTNETETHERHDR);
1081 pGso->cbHdrsTotal = pHdr->u16HdrLen;
1082 pGso->cbMaxSeg = pHdr->u16GSOSize;
1083 return pGso;
1084}
1085
1086DECLINLINE(uint16_t) vnetCSum16(const void *pvBuf, size_t cb)
1087{
1088 uint32_t csum = 0;
1089 uint16_t *pu16 = (uint16_t *)pvBuf;
1090
1091 while (cb > 1)
1092 {
1093 csum += *pu16++;
1094 cb -= 2;
1095 }
1096 if (cb)
1097 csum += *(uint8_t*)pu16;
1098 while (csum >> 16)
1099 csum = (csum >> 16) + (csum & 0xFFFF);
1100 return ~csum;
1101}
1102
1103DECLINLINE(void) vnetCompleteChecksum(uint8_t *pBuf, unsigned cbSize, uint16_t uStart, uint16_t uOffset)
1104{
1105 *(uint16_t*)(pBuf + uStart + uOffset) = vnetCSum16(pBuf + uStart, cbSize - uStart);
1106}
1107
1108static void vnetTransmitPendingPackets(PVNETSTATE pState, PVQUEUE pQueue, bool fOnWorkerThread)
1109{
1110 /*
1111 * Only one thread is allowed to transmit at a time, others should skip
1112 * transmission as the packets will be picked up by the transmitting
1113 * thread.
1114 */
1115 if (!ASMAtomicCmpXchgU32(&pState->uIsTransmitting, 1, 0))
1116 return;
1117
1118 if ((pState->VPCI.uStatus & VPCI_STATUS_DRV_OK) == 0)
1119 {
1120 Log(("%s Ignoring transmit requests from non-existent driver (status=0x%x).\n",
1121 INSTANCE(pState), pState->VPCI.uStatus));
1122 return;
1123 }
1124
1125 PPDMINETWORKUP pDrv = pState->pDrv;
1126 if (pDrv)
1127 {
1128 int rc = pDrv->pfnBeginXmit(pDrv, fOnWorkerThread);
1129 Assert(rc == VINF_SUCCESS || rc == VERR_TRY_AGAIN);
1130 if (rc == VERR_TRY_AGAIN)
1131 {
1132 ASMAtomicWriteU32(&pState->uIsTransmitting, 0);
1133 return;
1134 }
1135 }
1136
1137 unsigned int uHdrLen;
1138 if (vnetMergeableRxBuffers(pState))
1139 uHdrLen = sizeof(VNETHDRMRX);
1140 else
1141 uHdrLen = sizeof(VNETHDR);
1142
1143 Log3(("%s vnetTransmitPendingPackets: About to transmit %d pending packets\n", INSTANCE(pState),
1144 vringReadAvailIndex(&pState->VPCI, &pState->pTxQueue->VRing) - pState->pTxQueue->uNextAvailIndex));
1145
1146 vpciSetWriteLed(&pState->VPCI, true);
1147
1148 VQUEUEELEM elem;
1149 /*
1150 * Do not remove descriptors from available ring yet, try to allocate the
1151 * buffer first.
1152 */
1153 while (vqueuePeek(&pState->VPCI, pQueue, &elem))
1154 {
1155 unsigned int uOffset = 0;
1156 if (elem.nOut < 2 || elem.aSegsOut[0].cb != uHdrLen)
1157 {
1158 Log(("%s vnetQueueTransmit: The first segment is not the header! (%u < 2 || %u != %u).\n",
1159 INSTANCE(pState), elem.nOut, elem.aSegsOut[0].cb, uHdrLen));
1160 break; /* For now we simply ignore the header, but it must be there anyway! */
1161 }
1162 else
1163 {
1164 unsigned int uSize = 0;
1165 STAM_PROFILE_ADV_START(&pState->StatTransmit, a);
1166 /* Compute total frame size. */
1167 for (unsigned int i = 1; i < elem.nOut; i++)
1168 uSize += elem.aSegsOut[i].cb;
1169 Assert(uSize <= VNET_MAX_FRAME_SIZE);
1170 if (pState->pDrv)
1171 {
1172 VNETHDR Hdr;
1173 PDMNETWORKGSO Gso, *pGso;
1174
1175 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns), elem.aSegsOut[0].addr,
1176 &Hdr, sizeof(Hdr));
1177
1178 STAM_REL_COUNTER_INC(&pState->StatTransmitPackets);
1179
1180 STAM_PROFILE_START(&pState->StatTransmitSend, a);
1181
1182 pGso = vnetSetupGsoCtx(&Gso, &Hdr);
1183 /** @todo Optimize away the extra copying! (lazy bird) */
1184 PPDMSCATTERGATHER pSgBuf;
1185 int rc = pState->pDrv->pfnAllocBuf(pState->pDrv, uSize, pGso, &pSgBuf);
1186 if (RT_SUCCESS(rc))
1187 {
1188 Assert(pSgBuf->cSegs == 1);
1189 /* Assemble a complete frame. */
1190 for (unsigned int i = 1; i < elem.nOut; i++)
1191 {
1192 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns), elem.aSegsOut[i].addr,
1193 ((uint8_t*)pSgBuf->aSegs[0].pvSeg) + uOffset,
1194 elem.aSegsOut[i].cb);
1195 uOffset += elem.aSegsOut[i].cb;
1196 }
1197 pSgBuf->cbUsed = uSize;
1198 vnetPacketDump(pState, (uint8_t*)pSgBuf->aSegs[0].pvSeg, uSize, "--> Outgoing");
1199 if (pGso)
1200 {
1201 /* Some guests (RHEL) may report HdrLen excluding transport layer header! */
1202 /*
1203 * We cannot use cdHdrs provided by the guest because of different ways
1204 * it gets filled out by different versions of kernels.
1205 */
1206 //if (pGso->cbHdrs < Hdr.u16CSumStart + Hdr.u16CSumOffset + 2)
1207 {
1208 Log4(("%s vnetTransmitPendingPackets: HdrLen before adjustment %d.\n",
1209 INSTANCE(pState), pGso->cbHdrsTotal));
1210 switch (pGso->u8Type)
1211 {
1212 case PDMNETWORKGSOTYPE_IPV4_TCP:
1213 case PDMNETWORKGSOTYPE_IPV6_TCP:
1214 pGso->cbHdrsTotal = Hdr.u16CSumStart +
1215 ((PRTNETTCP)(((uint8_t*)pSgBuf->aSegs[0].pvSeg) + Hdr.u16CSumStart))->th_off * 4;
1216 pGso->cbHdrsSeg = pGso->cbHdrsTotal;
1217 break;
1218 case PDMNETWORKGSOTYPE_IPV4_UDP:
1219 pGso->cbHdrsTotal = Hdr.u16CSumStart + sizeof(RTNETUDP);
1220 pGso->cbHdrsSeg = Hdr.u16CSumStart;
1221 break;
1222 }
1223 /* Update GSO structure embedded into the frame */
1224 ((PPDMNETWORKGSO)pSgBuf->pvUser)->cbHdrsTotal = pGso->cbHdrsTotal;
1225 ((PPDMNETWORKGSO)pSgBuf->pvUser)->cbHdrsSeg = pGso->cbHdrsTotal;
1226 Log4(("%s vnetTransmitPendingPackets: adjusted HdrLen to %d.\n",
1227 INSTANCE(pState), pGso->cbHdrsTotal));
1228 }
1229 Log2(("%s vnetTransmitPendingPackets: gso type=%x cbHdrsTotal=%u cbHdrsSeg=%u mss=%u"
1230 " off1=0x%x off2=0x%x\n", INSTANCE(pState), pGso->u8Type,
1231 pGso->cbHdrsTotal, pGso->cbHdrsSeg, pGso->cbMaxSeg, pGso->offHdr1, pGso->offHdr2));
1232 STAM_REL_COUNTER_INC(&pState->StatTransmitGSO);
1233 }
1234 else if (Hdr.u8Flags & VNETHDR_F_NEEDS_CSUM)
1235 {
1236 STAM_REL_COUNTER_INC(&pState->StatTransmitCSum);
1237 /*
1238 * This is not GSO frame but checksum offloading is requested.
1239 */
1240 vnetCompleteChecksum((uint8_t*)pSgBuf->aSegs[0].pvSeg, uSize,
1241 Hdr.u16CSumStart, Hdr.u16CSumOffset);
1242 }
1243
1244 rc = pState->pDrv->pfnSendBuf(pState->pDrv, pSgBuf, false);
1245 }
1246 else
1247 {
1248 Log4(("virtio-net: failed to allocate SG buffer: size=%u rc=%Rrc\n", uSize, rc));
1249 STAM_PROFILE_STOP(&pState->StatTransmitSend, a);
1250 STAM_PROFILE_ADV_STOP(&pState->StatTransmit, a);
1251 /* Stop trying to fetch TX descriptors until we get more bandwidth. */
1252 break;
1253 }
1254
1255 STAM_PROFILE_STOP(&pState->StatTransmitSend, a);
1256 STAM_REL_COUNTER_ADD(&pState->StatTransmitBytes, uOffset);
1257 }
1258 }
1259 /* Remove this descriptor chain from the available ring */
1260 vqueueSkip(&pState->VPCI, pQueue);
1261 vqueuePut(&pState->VPCI, pQueue, &elem, sizeof(VNETHDR) + uOffset);
1262 vqueueSync(&pState->VPCI, pQueue);
1263 STAM_PROFILE_ADV_STOP(&pState->StatTransmit, a);
1264 }
1265 vpciSetWriteLed(&pState->VPCI, false);
1266
1267 if (pDrv)
1268 pDrv->pfnEndXmit(pDrv);
1269 ASMAtomicWriteU32(&pState->uIsTransmitting, 0);
1270}
1271
1272/**
1273 * @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
1274 */
1275static DECLCALLBACK(void) vnetNetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
1276{
1277 VNETSTATE *pThis = RT_FROM_MEMBER(pInterface, VNETSTATE, INetworkDown);
1278 vnetTransmitPendingPackets(pThis, pThis->pTxQueue, false /*fOnWorkerThread*/);
1279}
1280
1281#ifdef VNET_TX_DELAY
1282
1283static DECLCALLBACK(void) vnetQueueTransmit(void *pvState, PVQUEUE pQueue)
1284{
1285 VNETSTATE *pState = (VNETSTATE*)pvState;
1286
1287 if (TMTimerIsActive(pState->CTX_SUFF(pTxTimer)))
1288 {
1289 int rc = TMTimerStop(pState->CTX_SUFF(pTxTimer));
1290 Log3(("%s vnetQueueTransmit: Got kicked with notification disabled, "
1291 "re-enable notification and flush TX queue\n", INSTANCE(pState)));
1292 vnetTransmitPendingPackets(pState, pQueue, false /*fOnWorkerThread*/);
1293 if (RT_FAILURE(vnetCsEnter(pState, VERR_SEM_BUSY)))
1294 LogRel(("vnetQueueTransmit: Failed to enter critical section!/n"));
1295 else
1296 {
1297 vringSetNotification(&pState->VPCI, &pState->pTxQueue->VRing, true);
1298 vnetCsLeave(pState);
1299 }
1300 }
1301 else
1302 {
1303 if (RT_FAILURE(vnetCsEnter(pState, VERR_SEM_BUSY)))
1304 LogRel(("vnetQueueTransmit: Failed to enter critical section!/n"));
1305 else
1306 {
1307 vringSetNotification(&pState->VPCI, &pState->pTxQueue->VRing, false);
1308 TMTimerSetMicro(pState->CTX_SUFF(pTxTimer), VNET_TX_DELAY);
1309 pState->u64NanoTS = RTTimeNanoTS();
1310 vnetCsLeave(pState);
1311 }
1312 }
1313}
1314
1315/**
1316 * Transmit Delay Timer handler.
1317 *
1318 * @remarks We only get here when the timer expires.
1319 *
1320 * @param pDevIns Pointer to device instance structure.
1321 * @param pTimer Pointer to the timer.
1322 * @param pvUser NULL.
1323 * @thread EMT
1324 */
1325static DECLCALLBACK(void) vnetTxTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
1326{
1327 VNETSTATE *pState = (VNETSTATE*)pvUser;
1328
1329 uint32_t u32MicroDiff = (uint32_t)((RTTimeNanoTS() - pState->u64NanoTS)/1000);
1330 if (u32MicroDiff < pState->u32MinDiff)
1331 pState->u32MinDiff = u32MicroDiff;
1332 if (u32MicroDiff > pState->u32MaxDiff)
1333 pState->u32MaxDiff = u32MicroDiff;
1334 pState->u32AvgDiff = (pState->u32AvgDiff * pState->u32i + u32MicroDiff) / (pState->u32i + 1);
1335 pState->u32i++;
1336 Log3(("vnetTxTimer: Expired, diff %9d usec, avg %9d usec, min %9d usec, max %9d usec\n",
1337 u32MicroDiff, pState->u32AvgDiff, pState->u32MinDiff, pState->u32MaxDiff));
1338
1339// Log3(("%s vnetTxTimer: Expired\n", INSTANCE(pState)));
1340 vnetTransmitPendingPackets(pState, pState->pTxQueue, false /*fOnWorkerThread*/);
1341 if (RT_FAILURE(vnetCsEnter(pState, VERR_SEM_BUSY)))
1342 {
1343 LogRel(("vnetTxTimer: Failed to enter critical section!/n"));
1344 return;
1345 }
1346 vringSetNotification(&pState->VPCI, &pState->pTxQueue->VRing, true);
1347 vnetCsLeave(pState);
1348}
1349
1350#else /* !VNET_TX_DELAY */
1351
1352static DECLCALLBACK(void) vnetQueueTransmit(void *pvState, PVQUEUE pQueue)
1353{
1354 VNETSTATE *pState = (VNETSTATE*)pvState;
1355
1356 vnetTransmitPendingPackets(pState, pQueue, false /*fOnWorkerThread*/);
1357}
1358
1359#endif /* !VNET_TX_DELAY */
1360
1361static uint8_t vnetControlRx(PVNETSTATE pState, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
1362{
1363 uint8_t u8Ack = VNET_OK;
1364 uint8_t fOn, fDrvWasPromisc = pState->fPromiscuous | pState->fAllMulti;
1365 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns),
1366 pElem->aSegsOut[1].addr,
1367 &fOn, sizeof(fOn));
1368 Log(("%s vnetControlRx: uCommand=%u fOn=%u\n", INSTANCE(pState), pCtlHdr->u8Command, fOn));
1369 switch (pCtlHdr->u8Command)
1370 {
1371 case VNET_CTRL_CMD_RX_MODE_PROMISC:
1372 pState->fPromiscuous = !!fOn;
1373 break;
1374 case VNET_CTRL_CMD_RX_MODE_ALLMULTI:
1375 pState->fAllMulti = !!fOn;
1376 break;
1377 default:
1378 u8Ack = VNET_ERROR;
1379 }
1380 if (fDrvWasPromisc != (pState->fPromiscuous | pState->fAllMulti) && pState->pDrv)
1381 pState->pDrv->pfnSetPromiscuousMode(pState->pDrv,
1382 (pState->fPromiscuous | pState->fAllMulti));
1383
1384 return u8Ack;
1385}
1386
1387static uint8_t vnetControlMac(PVNETSTATE pState, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
1388{
1389 uint32_t nMacs = 0;
1390
1391 if (pCtlHdr->u8Command != VNET_CTRL_CMD_MAC_TABLE_SET
1392 || pElem->nOut != 3
1393 || pElem->aSegsOut[1].cb < sizeof(nMacs)
1394 || pElem->aSegsOut[2].cb < sizeof(nMacs))
1395 {
1396 Log(("%s vnetControlMac: Segment layout is wrong "
1397 "(u8Command=%u nOut=%u cb1=%u cb2=%u)\n", INSTANCE(pState),
1398 pCtlHdr->u8Command, pElem->nOut,
1399 pElem->aSegsOut[1].cb, pElem->aSegsOut[2].cb));
1400 return VNET_ERROR;
1401 }
1402
1403 /* Load unicast addresses */
1404 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns),
1405 pElem->aSegsOut[1].addr,
1406 &nMacs, sizeof(nMacs));
1407
1408 if (pElem->aSegsOut[1].cb < nMacs * sizeof(RTMAC) + sizeof(nMacs))
1409 {
1410 Log(("%s vnetControlMac: The unicast mac segment is too small "
1411 "(nMacs=%u cb=%u)\n", INSTANCE(pState), pElem->aSegsOut[1].cb));
1412 return VNET_ERROR;
1413 }
1414
1415 if (nMacs > VNET_MAC_FILTER_LEN)
1416 {
1417 Log(("%s vnetControlMac: MAC table is too big, have to use promiscuous"
1418 " mode (nMacs=%u)\n", INSTANCE(pState), nMacs));
1419 pState->fPromiscuous = true;
1420 }
1421 else
1422 {
1423 if (nMacs)
1424 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns),
1425 pElem->aSegsOut[1].addr + sizeof(nMacs),
1426 pState->aMacFilter, nMacs * sizeof(RTMAC));
1427 pState->nMacFilterEntries = nMacs;
1428#ifdef DEBUG
1429 Log(("%s vnetControlMac: unicast macs:\n", INSTANCE(pState)));
1430 for(unsigned i = 0; i < nMacs; i++)
1431 Log((" %RTmac\n", &pState->aMacFilter[i]));
1432#endif /* DEBUG */
1433 }
1434
1435 /* Load multicast addresses */
1436 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns),
1437 pElem->aSegsOut[2].addr,
1438 &nMacs, sizeof(nMacs));
1439
1440 if (pElem->aSegsOut[2].cb < nMacs * sizeof(RTMAC) + sizeof(nMacs))
1441 {
1442 Log(("%s vnetControlMac: The multicast mac segment is too small "
1443 "(nMacs=%u cb=%u)\n", INSTANCE(pState), pElem->aSegsOut[2].cb));
1444 return VNET_ERROR;
1445 }
1446
1447 if (nMacs > VNET_MAC_FILTER_LEN - pState->nMacFilterEntries)
1448 {
1449 Log(("%s vnetControlMac: MAC table is too big, have to use allmulti"
1450 " mode (nMacs=%u)\n", INSTANCE(pState), nMacs));
1451 pState->fAllMulti = true;
1452 }
1453 else
1454 {
1455 if (nMacs)
1456 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns),
1457 pElem->aSegsOut[2].addr + sizeof(nMacs),
1458 &pState->aMacFilter[pState->nMacFilterEntries],
1459 nMacs * sizeof(RTMAC));
1460#ifdef DEBUG
1461 Log(("%s vnetControlMac: multicast macs:\n", INSTANCE(pState)));
1462 for(unsigned i = 0; i < nMacs; i++)
1463 Log((" %RTmac\n",
1464 &pState->aMacFilter[i+pState->nMacFilterEntries]));
1465#endif /* DEBUG */
1466 pState->nMacFilterEntries += nMacs;
1467 }
1468
1469 return VNET_OK;
1470}
1471
1472static uint8_t vnetControlVlan(PVNETSTATE pState, PVNETCTLHDR pCtlHdr, PVQUEUEELEM pElem)
1473{
1474 uint8_t u8Ack = VNET_OK;
1475 uint16_t u16Vid;
1476
1477 if (pElem->nOut != 2 || pElem->aSegsOut[1].cb != sizeof(u16Vid))
1478 {
1479 Log(("%s vnetControlVlan: Segment layout is wrong "
1480 "(u8Command=%u nOut=%u cb=%u)\n", INSTANCE(pState),
1481 pCtlHdr->u8Command, pElem->nOut, pElem->aSegsOut[1].cb));
1482 return VNET_ERROR;
1483 }
1484
1485 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns),
1486 pElem->aSegsOut[1].addr,
1487 &u16Vid, sizeof(u16Vid));
1488
1489 if (u16Vid >= VNET_MAX_VID)
1490 {
1491 Log(("%s vnetControlVlan: VLAN ID is out of range "
1492 "(VID=%u)\n", INSTANCE(pState), u16Vid));
1493 return VNET_ERROR;
1494 }
1495
1496 Log(("%s vnetControlVlan: uCommand=%u VID=%u\n", INSTANCE(pState),
1497 pCtlHdr->u8Command, u16Vid));
1498
1499 switch (pCtlHdr->u8Command)
1500 {
1501 case VNET_CTRL_CMD_VLAN_ADD:
1502 ASMBitSet(pState->aVlanFilter, u16Vid);
1503 break;
1504 case VNET_CTRL_CMD_VLAN_DEL:
1505 ASMBitClear(pState->aVlanFilter, u16Vid);
1506 break;
1507 default:
1508 u8Ack = VNET_ERROR;
1509 }
1510
1511 return u8Ack;
1512}
1513
1514
1515static DECLCALLBACK(void) vnetQueueControl(void *pvState, PVQUEUE pQueue)
1516{
1517 VNETSTATE *pState = (VNETSTATE*)pvState;
1518 uint8_t u8Ack;
1519 VQUEUEELEM elem;
1520 while (vqueueGet(&pState->VPCI, pQueue, &elem))
1521 {
1522 unsigned int uOffset = 0;
1523 if (elem.nOut < 1 || elem.aSegsOut[0].cb < sizeof(VNETCTLHDR))
1524 {
1525 Log(("%s vnetQueueControl: The first 'out' segment is not the "
1526 "header! (%u < 1 || %u < %u).\n", INSTANCE(pState), elem.nOut,
1527 elem.aSegsOut[0].cb,sizeof(VNETCTLHDR)));
1528 break; /* Skip the element and hope the next one is good. */
1529 }
1530 else if ( elem.nIn < 1
1531 || elem.aSegsIn[elem.nIn - 1].cb < sizeof(VNETCTLACK))
1532 {
1533 Log(("%s vnetQueueControl: The last 'in' segment is too small "
1534 "to hold the acknowledge! (%u < 1 || %u < %u).\n",
1535 INSTANCE(pState), elem.nIn, elem.aSegsIn[elem.nIn - 1].cb,
1536 sizeof(VNETCTLACK)));
1537 break; /* Skip the element and hope the next one is good. */
1538 }
1539 else
1540 {
1541 VNETCTLHDR CtlHdr;
1542 PDMDevHlpPhysRead(pState->VPCI.CTX_SUFF(pDevIns),
1543 elem.aSegsOut[0].addr,
1544 &CtlHdr, sizeof(CtlHdr));
1545 switch (CtlHdr.u8Class)
1546 {
1547 case VNET_CTRL_CLS_RX_MODE:
1548 u8Ack = vnetControlRx(pState, &CtlHdr, &elem);
1549 break;
1550 case VNET_CTRL_CLS_MAC:
1551 u8Ack = vnetControlMac(pState, &CtlHdr, &elem);
1552 break;
1553 case VNET_CTRL_CLS_VLAN:
1554 u8Ack = vnetControlVlan(pState, &CtlHdr, &elem);
1555 break;
1556 default:
1557 u8Ack = VNET_ERROR;
1558 }
1559 Log(("%s Processed control message %u, ack=%u.\n", INSTANCE(pState),
1560 CtlHdr.u8Class, u8Ack));
1561 PDMDevHlpPhysWrite(pState->VPCI.CTX_SUFF(pDevIns),
1562 elem.aSegsIn[elem.nIn - 1].addr,
1563 &u8Ack, sizeof(u8Ack));
1564 }
1565 vqueuePut(&pState->VPCI, pQueue, &elem, sizeof(u8Ack));
1566 vqueueSync(&pState->VPCI, pQueue);
1567 }
1568}
1569
1570/**
1571 * Saves the configuration.
1572 *
1573 * @param pState The VNET state.
1574 * @param pSSM The handle to the saved state.
1575 */
1576static void vnetSaveConfig(VNETSTATE *pState, PSSMHANDLE pSSM)
1577{
1578 SSMR3PutMem(pSSM, &pState->macConfigured, sizeof(pState->macConfigured));
1579}
1580
1581/**
1582 * Live save - save basic configuration.
1583 *
1584 * @returns VBox status code.
1585 * @param pDevIns The device instance.
1586 * @param pSSM The handle to the saved state.
1587 * @param uPass
1588 */
1589static DECLCALLBACK(int) vnetLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
1590{
1591 VNETSTATE *pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1592 vnetSaveConfig(pState, pSSM);
1593 return VINF_SSM_DONT_CALL_AGAIN;
1594}
1595
1596/**
1597 * Prepares for state saving.
1598 *
1599 * @returns VBox status code.
1600 * @param pDevIns The device instance.
1601 * @param pSSM The handle to the saved state.
1602 */
1603static DECLCALLBACK(int) vnetSavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1604{
1605 VNETSTATE* pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1606
1607 int rc = vnetCsRxEnter(pState, VERR_SEM_BUSY);
1608 if (RT_UNLIKELY(rc != VINF_SUCCESS))
1609 return rc;
1610 vnetCsRxLeave(pState);
1611 return VINF_SUCCESS;
1612}
1613
1614/**
1615 * Saves the state of device.
1616 *
1617 * @returns VBox status code.
1618 * @param pDevIns The device instance.
1619 * @param pSSM The handle to the saved state.
1620 */
1621static DECLCALLBACK(int) vnetSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1622{
1623 VNETSTATE* pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1624
1625 /* Save config first */
1626 vnetSaveConfig(pState, pSSM);
1627
1628 /* Save the common part */
1629 int rc = vpciSaveExec(&pState->VPCI, pSSM);
1630 AssertRCReturn(rc, rc);
1631 /* Save device-specific part */
1632 rc = SSMR3PutMem( pSSM, pState->config.mac.au8, sizeof(pState->config.mac));
1633 AssertRCReturn(rc, rc);
1634 rc = SSMR3PutBool(pSSM, pState->fPromiscuous);
1635 AssertRCReturn(rc, rc);
1636 rc = SSMR3PutBool(pSSM, pState->fAllMulti);
1637 AssertRCReturn(rc, rc);
1638 rc = SSMR3PutU32( pSSM, pState->nMacFilterEntries);
1639 AssertRCReturn(rc, rc);
1640 rc = SSMR3PutMem( pSSM, pState->aMacFilter,
1641 pState->nMacFilterEntries * sizeof(RTMAC));
1642 AssertRCReturn(rc, rc);
1643 rc = SSMR3PutMem( pSSM, pState->aVlanFilter, sizeof(pState->aVlanFilter));
1644 AssertRCReturn(rc, rc);
1645 Log(("%s State has been saved\n", INSTANCE(pState)));
1646 return VINF_SUCCESS;
1647}
1648
1649
1650/**
1651 * Serializes the receive thread, it may be working inside the critsect.
1652 *
1653 * @returns VBox status code.
1654 * @param pDevIns The device instance.
1655 * @param pSSM The handle to the saved state.
1656 */
1657static DECLCALLBACK(int) vnetLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1658{
1659 VNETSTATE* pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1660
1661 int rc = vnetCsRxEnter(pState, VERR_SEM_BUSY);
1662 if (RT_UNLIKELY(rc != VINF_SUCCESS))
1663 return rc;
1664 vnetCsRxLeave(pState);
1665 return VINF_SUCCESS;
1666}
1667
1668/**
1669 * Takes down the link temporarily if it's current status is up.
1670 *
1671 * This is used during restore and when replumbing the network link.
1672 *
1673 * The temporary link outage is supposed to indicate to the OS that all network
1674 * connections have been lost and that it for instance is appropriate to
1675 * renegotiate any DHCP lease.
1676 *
1677 * @param pThis The PCNet instance data.
1678 */
1679static void vnetTempLinkDown(PVNETSTATE pState)
1680{
1681 if (STATUS & VNET_S_LINK_UP)
1682 {
1683 STATUS &= ~VNET_S_LINK_UP;
1684 vpciRaiseInterrupt(&pState->VPCI, VERR_SEM_BUSY, VPCI_ISR_CONFIG);
1685 /* Restore the link back in 5 seconds. */
1686 int rc = TMTimerSetMillies(pState->pLinkUpTimer, pState->cMsLinkUpDelay);
1687 AssertRC(rc);
1688 }
1689}
1690
1691
1692/**
1693 * Restore previously saved state of device.
1694 *
1695 * @returns VBox status code.
1696 * @param pDevIns The device instance.
1697 * @param pSSM The handle to the saved state.
1698 * @param uVersion The data unit version number.
1699 * @param uPass The data pass.
1700 */
1701static DECLCALLBACK(int) vnetLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
1702{
1703 VNETSTATE *pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1704 int rc;
1705
1706 /* config checks */
1707 RTMAC macConfigured;
1708 rc = SSMR3GetMem(pSSM, &macConfigured, sizeof(macConfigured));
1709 AssertRCReturn(rc, rc);
1710 if (memcmp(&macConfigured, &pState->macConfigured, sizeof(macConfigured))
1711 && (uPass == 0 || !PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns)))
1712 LogRel(("%s: The mac address differs: config=%RTmac saved=%RTmac\n", INSTANCE(pState), &pState->macConfigured, &macConfigured));
1713
1714 rc = vpciLoadExec(&pState->VPCI, pSSM, uVersion, uPass, VNET_N_QUEUES);
1715 AssertRCReturn(rc, rc);
1716
1717 if (uPass == SSM_PASS_FINAL)
1718 {
1719 rc = SSMR3GetMem( pSSM, pState->config.mac.au8,
1720 sizeof(pState->config.mac));
1721 AssertRCReturn(rc, rc);
1722
1723 if (uVersion > VIRTIO_SAVEDSTATE_VERSION_3_1_BETA1)
1724 {
1725 rc = SSMR3GetBool(pSSM, &pState->fPromiscuous);
1726 AssertRCReturn(rc, rc);
1727 rc = SSMR3GetBool(pSSM, &pState->fAllMulti);
1728 AssertRCReturn(rc, rc);
1729 rc = SSMR3GetU32(pSSM, &pState->nMacFilterEntries);
1730 AssertRCReturn(rc, rc);
1731 rc = SSMR3GetMem(pSSM, pState->aMacFilter,
1732 pState->nMacFilterEntries * sizeof(RTMAC));
1733 AssertRCReturn(rc, rc);
1734 /* Clear the rest. */
1735 if (pState->nMacFilterEntries < VNET_MAC_FILTER_LEN)
1736 memset(&pState->aMacFilter[pState->nMacFilterEntries],
1737 0,
1738 (VNET_MAC_FILTER_LEN - pState->nMacFilterEntries)
1739 * sizeof(RTMAC));
1740 rc = SSMR3GetMem(pSSM, pState->aVlanFilter,
1741 sizeof(pState->aVlanFilter));
1742 AssertRCReturn(rc, rc);
1743 }
1744 else
1745 {
1746 pState->fPromiscuous = true;
1747 pState->fAllMulti = false;
1748 pState->nMacFilterEntries = 0;
1749 memset(pState->aMacFilter, 0, VNET_MAC_FILTER_LEN * sizeof(RTMAC));
1750 memset(pState->aVlanFilter, 0, sizeof(pState->aVlanFilter));
1751 if (pState->pDrv)
1752 pState->pDrv->pfnSetPromiscuousMode(pState->pDrv, true);
1753 }
1754 }
1755
1756 return rc;
1757}
1758
1759/**
1760 * Link status adjustments after loading.
1761 *
1762 * @returns VBox status code.
1763 * @param pDevIns The device instance.
1764 * @param pSSM The handle to the saved state.
1765 */
1766static DECLCALLBACK(int) vnetLoadDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1767{
1768 VNETSTATE *pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1769
1770 if (pState->pDrv)
1771 pState->pDrv->pfnSetPromiscuousMode(pState->pDrv,
1772 (pState->fPromiscuous | pState->fAllMulti));
1773 /*
1774 * Indicate link down to the guest OS that all network connections have
1775 * been lost, unless we've been teleported here.
1776 */
1777 if (!PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns))
1778 vnetTempLinkDown(pState);
1779
1780 return VINF_SUCCESS;
1781}
1782
1783/**
1784 * Map PCI I/O region.
1785 *
1786 * @return VBox status code.
1787 * @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
1788 * @param iRegion The region number.
1789 * @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
1790 * I/O port, else it's a physical address.
1791 * This address is *NOT* relative to pci_mem_base like earlier!
1792 * @param cb Region size.
1793 * @param enmType One of the PCI_ADDRESS_SPACE_* values.
1794 * @thread EMT
1795 */
1796static DECLCALLBACK(int) vnetMap(PPCIDEVICE pPciDev, int iRegion,
1797 RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
1798{
1799 int rc;
1800 VNETSTATE *pState = PDMINS_2_DATA(pPciDev->pDevIns, VNETSTATE*);
1801
1802 if (enmType != PCI_ADDRESS_SPACE_IO)
1803 {
1804 /* We should never get here */
1805 AssertMsgFailed(("Invalid PCI address space param in map callback"));
1806 return VERR_INTERNAL_ERROR;
1807 }
1808
1809 pState->VPCI.addrIOPort = (RTIOPORT)GCPhysAddress;
1810 rc = PDMDevHlpIOPortRegister(pPciDev->pDevIns, pState->VPCI.addrIOPort,
1811 cb, 0, vnetIOPortOut, vnetIOPortIn,
1812 NULL, NULL, "VirtioNet");
1813#ifdef VNET_GC_SUPPORT
1814 AssertRCReturn(rc, rc);
1815 rc = PDMDevHlpIOPortRegisterR0(pPciDev->pDevIns, pState->VPCI.addrIOPort,
1816 cb, 0, "vnetIOPortOut", "vnetIOPortIn",
1817 NULL, NULL, "VirtioNet");
1818 AssertRCReturn(rc, rc);
1819 rc = PDMDevHlpIOPortRegisterRC(pPciDev->pDevIns, pState->VPCI.addrIOPort,
1820 cb, 0, "vnetIOPortOut", "vnetIOPortIn",
1821 NULL, NULL, "VirtioNet");
1822#endif
1823 AssertRC(rc);
1824 return rc;
1825}
1826
1827
1828/* -=-=-=-=- PDMDEVREG -=-=-=-=- */
1829
1830/**
1831 * Detach notification.
1832 *
1833 * One port on the network card has been disconnected from the network.
1834 *
1835 * @param pDevIns The device instance.
1836 * @param iLUN The logical unit which is being detached.
1837 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1838 */
1839static DECLCALLBACK(void) vnetDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
1840{
1841 VNETSTATE *pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1842 Log(("%s vnetDetach:\n", INSTANCE(pState)));
1843
1844 AssertLogRelReturnVoid(iLUN == 0);
1845
1846 int rc = vnetCsEnter(pState, VERR_SEM_BUSY);
1847 if (RT_FAILURE(rc))
1848 {
1849 LogRel(("vnetDetach failed to enter critical section!\n"));
1850 return;
1851 }
1852
1853 /*
1854 * Zero some important members.
1855 */
1856 pState->pDrvBase = NULL;
1857 pState->pDrv = NULL;
1858
1859 vnetCsLeave(pState);
1860}
1861
1862/**
1863 * Attach the Network attachment.
1864 *
1865 * One port on the network card has been connected to a network.
1866 *
1867 * @returns VBox status code.
1868 * @param pDevIns The device instance.
1869 * @param iLUN The logical unit which is being attached.
1870 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
1871 *
1872 * @remarks This code path is not used during construction.
1873 */
1874static DECLCALLBACK(int) vnetAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
1875{
1876 VNETSTATE *pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1877 LogFlow(("%s vnetAttach:\n", INSTANCE(pState)));
1878
1879 AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
1880
1881 int rc = vnetCsEnter(pState, VERR_SEM_BUSY);
1882 if (RT_FAILURE(rc))
1883 {
1884 LogRel(("vnetAttach failed to enter critical section!\n"));
1885 return rc;
1886 }
1887
1888 /*
1889 * Attach the driver.
1890 */
1891 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pState->VPCI.IBase, &pState->pDrvBase, "Network Port");
1892 if (RT_SUCCESS(rc))
1893 {
1894 if (rc == VINF_NAT_DNS)
1895 {
1896#ifdef RT_OS_LINUX
1897 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "NoDNSforNAT",
1898 N_("A Domain Name Server (DNS) for NAT networking could not be determined. Please check your /etc/resolv.conf for <tt>nameserver</tt> entries. Either add one manually (<i>man resolv.conf</i>) or ensure that your host is correctly connected to an ISP. If you ignore this warning the guest will not be able to perform nameserver lookups and it will probably observe delays if trying so"));
1899#else
1900 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "NoDNSforNAT",
1901 N_("A Domain Name Server (DNS) for NAT networking could not be determined. Ensure that your host is correctly connected to an ISP. If you ignore this warning the guest will not be able to perform nameserver lookups and it will probably observe delays if trying so"));
1902#endif
1903 }
1904 pState->pDrv = PDMIBASE_QUERY_INTERFACE(pState->pDrvBase, PDMINETWORKUP);
1905 AssertMsgStmt(pState->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
1906 rc = VERR_PDM_MISSING_INTERFACE_BELOW);
1907 }
1908 else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
1909 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
1910 {
1911 /* This should never happen because this function is not called
1912 * if there is no driver to attach! */
1913 Log(("%s No attached driver!\n", INSTANCE(pState)));
1914 }
1915
1916 /*
1917 * Temporary set the link down if it was up so that the guest
1918 * will know that we have change the configuration of the
1919 * network card
1920 */
1921 if (RT_SUCCESS(rc))
1922 vnetTempLinkDown(pState);
1923
1924 vnetCsLeave(pState);
1925 return rc;
1926
1927}
1928
1929/**
1930 * @copydoc FNPDMDEVSUSPEND
1931 */
1932static DECLCALLBACK(void) vnetSuspend(PPDMDEVINS pDevIns)
1933{
1934 /* Poke thread waiting for buffer space. */
1935 vnetWakeupReceive(pDevIns);
1936}
1937
1938/**
1939 * @copydoc FNPDMDEVPOWEROFF
1940 */
1941static DECLCALLBACK(void) vnetPowerOff(PPDMDEVINS pDevIns)
1942{
1943 /* Poke thread waiting for buffer space. */
1944 vnetWakeupReceive(pDevIns);
1945}
1946
1947/**
1948 * Device relocation callback.
1949 *
1950 * When this callback is called the device instance data, and if the
1951 * device have a GC component, is being relocated, or/and the selectors
1952 * have been changed. The device must use the chance to perform the
1953 * necessary pointer relocations and data updates.
1954 *
1955 * Before the GC code is executed the first time, this function will be
1956 * called with a 0 delta so GC pointer calculations can be one in one place.
1957 *
1958 * @param pDevIns Pointer to the device instance.
1959 * @param offDelta The relocation delta relative to the old location.
1960 *
1961 * @remark A relocation CANNOT fail.
1962 */
1963static DECLCALLBACK(void) vnetRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
1964{
1965 VNETSTATE* pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1966 vpciRelocate(pDevIns, offDelta);
1967 pState->pCanRxQueueRC = PDMQueueRCPtr(pState->pCanRxQueueR3);
1968#ifdef VNET_TX_DELAY
1969 pState->pTxTimerRC = TMTimerRCPtr(pState->pTxTimerR3);
1970#endif /* VNET_TX_DELAY */
1971 // TBD
1972}
1973
1974/**
1975 * Destruct a device instance.
1976 *
1977 * We need to free non-VM resources only.
1978 *
1979 * @returns VBox status.
1980 * @param pDevIns The device instance data.
1981 * @thread EMT
1982 */
1983static DECLCALLBACK(int) vnetDestruct(PPDMDEVINS pDevIns)
1984{
1985 VNETSTATE* pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
1986 PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
1987
1988 LogRel(("TxTimer stats (avg/min/max): %7d usec %7d usec %7d usec\n",
1989 pState->u32AvgDiff, pState->u32MinDiff, pState->u32MaxDiff));
1990 Log(("%s Destroying instance\n", INSTANCE(pState)));
1991 if (pState->hEventMoreRxDescAvail != NIL_RTSEMEVENT)
1992 {
1993 RTSemEventSignal(pState->hEventMoreRxDescAvail);
1994 RTSemEventDestroy(pState->hEventMoreRxDescAvail);
1995 pState->hEventMoreRxDescAvail = NIL_RTSEMEVENT;
1996 }
1997
1998 // if (PDMCritSectIsInitialized(&pState->csRx))
1999 // PDMR3CritSectDelete(&pState->csRx);
2000
2001 return vpciDestruct(&pState->VPCI);
2002}
2003
2004/**
2005 * @interface_method_impl{PDMDEVREG,pfnConstruct}
2006 */
2007static DECLCALLBACK(int) vnetConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
2008{
2009 VNETSTATE* pState = PDMINS_2_DATA(pDevIns, VNETSTATE*);
2010 int rc;
2011 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2012
2013 /* Initialize PCI part first. */
2014 pState->VPCI.IBase.pfnQueryInterface = vnetQueryInterface;
2015 rc = vpciConstruct(pDevIns, &pState->VPCI, iInstance,
2016 VNET_NAME_FMT, VNET_PCI_SUBSYSTEM_ID,
2017 VNET_PCI_CLASS, VNET_N_QUEUES);
2018 pState->pRxQueue = vpciAddQueue(&pState->VPCI, 256, vnetQueueReceive, "RX ");
2019 pState->pTxQueue = vpciAddQueue(&pState->VPCI, 256, vnetQueueTransmit, "TX ");
2020 pState->pCtlQueue = vpciAddQueue(&pState->VPCI, 16, vnetQueueControl, "CTL");
2021
2022 Log(("%s Constructing new instance\n", INSTANCE(pState)));
2023
2024 pState->hEventMoreRxDescAvail = NIL_RTSEMEVENT;
2025
2026 /*
2027 * Validate configuration.
2028 */
2029 if (!CFGMR3AreValuesValid(pCfg, "MAC\0" "CableConnected\0" "LineSpeed\0" "LinkUpDelay\0"))
2030 return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
2031 N_("Invalid configuration for VirtioNet device"));
2032
2033 /* Get config params */
2034 rc = CFGMR3QueryBytes(pCfg, "MAC", pState->macConfigured.au8,
2035 sizeof(pState->macConfigured));
2036 if (RT_FAILURE(rc))
2037 return PDMDEV_SET_ERROR(pDevIns, rc,
2038 N_("Configuration error: Failed to get MAC address"));
2039 rc = CFGMR3QueryBool(pCfg, "CableConnected", &pState->fCableConnected);
2040 if (RT_FAILURE(rc))
2041 return PDMDEV_SET_ERROR(pDevIns, rc,
2042 N_("Configuration error: Failed to get the value of 'CableConnected'"));
2043 rc = CFGMR3QueryU32Def(pCfg, "LinkUpDelay", (uint32_t*)&pState->cMsLinkUpDelay, 5000); /* ms */
2044 if (RT_FAILURE(rc))
2045 return PDMDEV_SET_ERROR(pDevIns, rc,
2046 N_("Configuration error: Failed to get the value of 'LinkUpDelay'"));
2047 Assert(pState->cMsLinkUpDelay <= 300000); /* less than 5 minutes */
2048 if (pState->cMsLinkUpDelay > 5000 || pState->cMsLinkUpDelay < 100)
2049 {
2050 LogRel(("%s WARNING! Link up delay is set to %u seconds!\n",
2051 INSTANCE(pState), pState->cMsLinkUpDelay / 1000));
2052 }
2053 Log(("%s Link up delay is set to %u seconds\n",
2054 INSTANCE(pState), pState->cMsLinkUpDelay / 1000));
2055
2056
2057 vnetPrintFeatures(pState, vnetGetHostFeatures(pState), "Device supports the following features");
2058
2059 /* Initialize PCI config space */
2060 memcpy(pState->config.mac.au8, pState->macConfigured.au8, sizeof(pState->config.mac.au8));
2061 pState->config.uStatus = 0;
2062
2063 /* Initialize state structure */
2064 pState->u32PktNo = 1;
2065
2066 /* Interfaces */
2067 pState->INetworkDown.pfnWaitReceiveAvail = vnetNetworkDown_WaitReceiveAvail;
2068 pState->INetworkDown.pfnReceive = vnetNetworkDown_Receive;
2069 pState->INetworkDown.pfnReceiveGso = vnetNetworkDown_ReceiveGso;
2070 pState->INetworkDown.pfnXmitPending = vnetNetworkDown_XmitPending;
2071
2072 pState->INetworkConfig.pfnGetMac = vnetGetMac;
2073 pState->INetworkConfig.pfnGetLinkState = vnetGetLinkState;
2074 pState->INetworkConfig.pfnSetLinkState = vnetSetLinkState;
2075
2076 /* Initialize critical section. */
2077 // char szTmp[sizeof(pState->VPCI.szInstance) + 2];
2078 // RTStrPrintf(szTmp, sizeof(szTmp), "%sRX", pState->VPCI.szInstance);
2079 // rc = PDMDevHlpCritSectInit(pDevIns, &pState->csRx, szTmp);
2080 // if (RT_FAILURE(rc))
2081 // return rc;
2082
2083 /* Map our ports to IO space. */
2084 rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0,
2085 VPCI_CONFIG + sizeof(VNetPCIConfig),
2086 PCI_ADDRESS_SPACE_IO, vnetMap);
2087 if (RT_FAILURE(rc))
2088 return rc;
2089
2090
2091 /* Register save/restore state handlers. */
2092 rc = PDMDevHlpSSMRegisterEx(pDevIns, VIRTIO_SAVEDSTATE_VERSION, sizeof(VNETSTATE), NULL,
2093 NULL, vnetLiveExec, NULL,
2094 vnetSavePrep, vnetSaveExec, NULL,
2095 vnetLoadPrep, vnetLoadExec, vnetLoadDone);
2096 if (RT_FAILURE(rc))
2097 return rc;
2098
2099 /* Create the RX notifier signaller. */
2100 rc = PDMDevHlpQueueCreate(pDevIns, sizeof(PDMQUEUEITEMCORE), 1, 0,
2101 vnetCanRxQueueConsumer, true, "VNet-Rcv", &pState->pCanRxQueueR3);
2102 if (RT_FAILURE(rc))
2103 return rc;
2104 pState->pCanRxQueueR0 = PDMQueueR0Ptr(pState->pCanRxQueueR3);
2105 pState->pCanRxQueueRC = PDMQueueRCPtr(pState->pCanRxQueueR3);
2106
2107 /* Create Link Up Timer */
2108 rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetLinkUpTimer, pState,
2109 TMTIMER_FLAGS_NO_CRIT_SECT,
2110 "VirtioNet Link Up Timer", &pState->pLinkUpTimer);
2111 if (RT_FAILURE(rc))
2112 return rc;
2113
2114#ifdef VNET_TX_DELAY
2115 /* Create Transmit Delay Timer */
2116 rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetTxTimer, pState,
2117 TMTIMER_FLAGS_NO_CRIT_SECT,
2118 "VirtioNet TX Delay Timer", &pState->pTxTimerR3);
2119 if (RT_FAILURE(rc))
2120 return rc;
2121 pState->pTxTimerR0 = TMTimerR0Ptr(pState->pTxTimerR3);
2122 pState->pTxTimerRC = TMTimerRCPtr(pState->pTxTimerR3);
2123
2124 pState->u32i = pState->u32AvgDiff = pState->u32MaxDiff = 0;
2125 pState->u32MinDiff = ~0;
2126#endif /* VNET_TX_DELAY */
2127
2128 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pState->VPCI.IBase, &pState->pDrvBase, "Network Port");
2129 if (RT_SUCCESS(rc))
2130 {
2131 if (rc == VINF_NAT_DNS)
2132 {
2133 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "NoDNSforNAT",
2134 N_("A Domain Name Server (DNS) for NAT networking could not be determined. Ensure that your host is correctly connected to an ISP. If you ignore this warning the guest will not be able to perform nameserver lookups and it will probably observe delays if trying so"));
2135 }
2136 pState->pDrv = PDMIBASE_QUERY_INTERFACE(pState->pDrvBase, PDMINETWORKUP);
2137 AssertMsgReturn(pState->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
2138 VERR_PDM_MISSING_INTERFACE_BELOW);
2139 }
2140 else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
2141 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME )
2142 {
2143 /* No error! */
2144 Log(("%s This adapter is not attached to any network!\n", INSTANCE(pState)));
2145 }
2146 else
2147 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to attach the network LUN"));
2148
2149 rc = RTSemEventCreate(&pState->hEventMoreRxDescAvail);
2150 if (RT_FAILURE(rc))
2151 return rc;
2152
2153 rc = vnetReset(pState);
2154 AssertRC(rc);
2155
2156 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatReceiveBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Amount of data received", "/Devices/VNet%d/Bytes/Receive", iInstance);
2157 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatTransmitBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Amount of data transmitted", "/Devices/VNet%d/Bytes/Transmit", iInstance);
2158 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatReceiveGSO, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Number of received GSO packets", "/Devices/VNet%d/Packets/ReceiveGSO", iInstance);
2159 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatTransmitPackets, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Number of sent packets", "/Devices/VNet%d/Packets/Transmit", iInstance);
2160 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatTransmitGSO, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Number of sent GSO packets", "/Devices/VNet%d/Packets/Transmit-Gso", iInstance);
2161 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatTransmitCSum, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Number of completed TX checksums", "/Devices/VNet%d/Packets/Transmit-Csum", iInstance);
2162#if defined(VBOX_WITH_STATISTICS)
2163 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling receive", "/Devices/VNet%d/Receive/Total", iInstance);
2164 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatReceiveStore, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling receive storing", "/Devices/VNet%d/Receive/Store", iInstance);
2165 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatRxOverflow, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_OCCURENCE, "Profiling RX overflows", "/Devices/VNet%d/RxOverflow", iInstance);
2166 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatRxOverflowWakeup, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Nr of RX overflow wakeups", "/Devices/VNet%d/RxOverflowWakeup", iInstance);
2167 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatTransmit, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling transmits in HC", "/Devices/VNet%d/Transmit/Total", iInstance);
2168 PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatTransmitSend, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling send transmit in HC", "/Devices/VNet%d/Transmit/Send", iInstance);
2169#endif /* VBOX_WITH_STATISTICS */
2170
2171 return VINF_SUCCESS;
2172}
2173
2174/**
2175 * The device registration structure.
2176 */
2177const PDMDEVREG g_DeviceVirtioNet =
2178{
2179 /* Structure version. PDM_DEVREG_VERSION defines the current version. */
2180 PDM_DEVREG_VERSION,
2181 /* Device name. */
2182 "virtio-net",
2183 /* Name of guest context module (no path).
2184 * Only evalutated if PDM_DEVREG_FLAGS_RC is set. */
2185 "VBoxDDGC.gc",
2186 /* Name of ring-0 module (no path).
2187 * Only evalutated if PDM_DEVREG_FLAGS_RC is set. */
2188 "VBoxDDR0.r0",
2189 /* The description of the device. The UTF-8 string pointed to shall, like this structure,
2190 * remain unchanged from registration till VM destruction. */
2191 "Virtio Ethernet.\n",
2192
2193 /* Flags, combination of the PDM_DEVREG_FLAGS_* \#defines. */
2194#ifdef VNET_GC_SUPPORT
2195 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0,
2196#else
2197 PDM_DEVREG_FLAGS_DEFAULT_BITS,
2198#endif
2199 /* Device class(es), combination of the PDM_DEVREG_CLASS_* \#defines. */
2200 PDM_DEVREG_CLASS_NETWORK,
2201 /* Maximum number of instances (per VM). */
2202 ~0U,
2203 /* Size of the instance data. */
2204 sizeof(VNETSTATE),
2205
2206 /* Construct instance - required. */
2207 vnetConstruct,
2208 /* Destruct instance - optional. */
2209 vnetDestruct,
2210 /* Relocation command - optional. */
2211 vnetRelocate,
2212 /* I/O Control interface - optional. */
2213 NULL,
2214 /* Power on notification - optional. */
2215 NULL,
2216 /* Reset notification - optional. */
2217 NULL,
2218 /* Suspend notification - optional. */
2219 vnetSuspend,
2220 /* Resume notification - optional. */
2221 NULL,
2222 /* Attach command - optional. */
2223 vnetAttach,
2224 /* Detach notification - optional. */
2225 vnetDetach,
2226 /* Query a LUN base interface - optional. */
2227 NULL,
2228 /* Init complete notification - optional. */
2229 NULL,
2230 /* Power off notification - optional. */
2231 vnetPowerOff,
2232 /* pfnSoftReset */
2233 NULL,
2234 /* u32VersionEnd */
2235 PDM_DEVREG_VERSION
2236};
2237
2238#endif /* IN_RING3 */
2239#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette