VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/DevVirtioNet_1_0.cpp@ 83153

Last change on this file since 83153 was 83153, checked in by vboxsync, 5 years ago

Updates since last integration. Troubleshooting why client is not transmitting any data and I can't get ping to work
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 110.3 KB
Line 
1/* $Id: DevVirtioNet_1_0.cpp 83153 2020-02-25 13:54:08Z vboxsync $ $Revision: 83153 $ $Date: 2020-02-25 13:54:08 +0000 (Tue, 25 Feb 2020) $ $Author: vboxsync $ */
2
3/** @file
4 * VBox storage devices - Virtio NET Driver
5 *
6 * Log-levels used:
7 * - Level 1: The most important (but usually rare) things to note
8 * - Level 2: NET command logging
9 * - Level 3: Vector and I/O transfer summary (shows what client sent an expects and fulfillment)
10 * - Level 6: Device <-> Guest Driver negotation, traffic, notifications and state handling
11 * - Level 12: Brief formatted hex dumps of I/O data
12 */
13
14/*
15 * Copyright (C) 2006-2020 Oracle Corporation
16 *
17 * This file is part of VirtualBox Open Source Edition (OSE), as
18 * available from http://www.virtualbox.org. This file is free software;
19 * you can redistribute it and/or modify it under the terms of the GNU
20 * General Public License (GPL) as published by the Free Software
21 * Foundation, in version 2 as it comes in the "COPYING" file of the
22 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
23 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
24 */
25
26
27/*********************************************************************************************************************************
28* Header Files *
29*********************************************************************************************************************************/
30//#define LOG_GROUP LOG_GROUP_DRV_NET
31#define LOG_GROUP LOG_GROUP_DEV_VIRTIO
32#define VIRTIONET_WITH_GSO
33
34#include <VBox/vmm/pdmdev.h>
35#include <VBox/vmm/pdmcritsect.h>
36#include <VBox/vmm/pdmnetifs.h>
37#include <VBox/msi.h>
38#include <VBox/version.h>
39//#include <VBox/asm.h>
40#include <VBox/log.h>
41#include <iprt/errcore.h>
42#include <iprt/assert.h>
43#include <iprt/string.h>
44#include <VBox/sup.h>
45#ifdef IN_RING3
46#include <VBox/VBoxPktDmp.h>
47#endif
48#ifdef IN_RING3
49# include <iprt/alloc.h>
50# include <iprt/memcache.h>
51# include <iprt/semaphore.h>
52# include <iprt/sg.h>
53# include <iprt/param.h>
54# include <iprt/uuid.h>
55#endif
56#include "../VirtIO/Virtio_1_0.h"
57
58//#include "VBoxNET.h"
59#include "VBoxDD.h"
60
61/** @todo FIX UP THESE HACKS AFTER DEBUGGING */
62
63/* After debugging single instance case, restore instance name logging */
64#define INSTANCE(pState) (char *)(pState->szInstanceName ? "" : "") // Avoid requiring RT_NOREF in some funcs
65
66
67#define VIRTIONET_SAVED_STATE_VERSION UINT32_C(1)
68#define VIRTIONET_MAX_QPAIRS 1
69#define VIRTIONET_MAX_QUEUES (VIRTIONET_MAX_QPAIRS * 2 + 1)
70#define VIRTIONET_MAX_FRAME_SIZE 65535 + 18 /**< Max IP pkt size + Ethernet header with VLAN tag */
71#define VIRTIONET_MAC_FILTER_LEN 32
72#define VIRTIONET_MAX_VLAN_ID (1 << 12)
73#define VIRTIONET_PREALLOCATE_RX_SEG_COUNT 32
74
75
76#define QUEUE_NAME(a_pVirtio, a_idxQueue) ((a_pVirtio)->virtqState[(a_idxQueue)].szVirtqName)
77#define VIRTQNAME(idxQueue) (pThis->aszVirtqNames[idxQueue])
78#define CBVIRTQNAME(idxQueue) RTStrNLen(VIRTQNAME(idxQueue), sizeof(VIRTQNAME(idxQueue)))
79#define FEATURE_ENABLED(feature) (pThis->fNegotiatedFeatures & VIRTIONET_F_##feature)
80#define FEATURE_DISABLED(feature) (!FEATURE_ENABLED(feature))
81#define FEATURE_OFFERED(feature) VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_##feature
82
83#define SET_LINK_UP(pState) \
84 pState->virtioNetConfig.uStatus |= VIRTIONET_F_LINK_UP; \
85 virtioCoreNotifyConfigChanged(&pThis->Virtio)
86
87#define SET_LINK_DOWN(pState) \
88 pState->virtioNetConfig.uStatus &= !VIRTIONET_F_LINK_UP; \
89 virtioCoreNotifyConfigChanged(&pThis->Virtio)
90
91#define IS_LINK_UP(pState) (pState->virtioNetConfig.uStatus & VIRTIONET_F_LINK_UP)
92#define IS_LINK_DOWN(pState) !IS_LINK_UP(pState)
93
94/* Macros to calculate queue specific index number VirtIO 1.0, 5.1.2 */
95#define IS_TX_QUEUE(n) ((n) != CTRLQIDX && ((n) & 1))
96#define IS_RX_QUEUE(n) ((n) != CTRLQIDX && !IS_TX_QUEUE(n))
97#define IS_CTRL_QUEUE(n) ((n) == CTRLQIDX)
98#define RXQIDX_QPAIR(qPairIdx) (qPairIdx * 2)
99#define TXQIDX_QPAIR(qPairIdx) (qPairIdx * 2 + 1)
100#define CTRLQIDX (FEATURE_ENABLED(MQ) ? ((VIRTIONET_MAX_QPAIRS - 1) * 2 + 2) : 2)
101
102#define RXVIRTQNAME(qPairIdx) (pThis->aszVirtqNames[RXQIDX_QPAIR(qPairIdx)])
103#define TXVIRTQNAME(qPairIdx) (pThis->aszVirtqNames[TXQIDX_QPAIR(qPairIdx)])
104#define CTLVIRTQNAME(qPairIdx) (pThis->aszVirtqNames[CTRLQIDX])
105
106#define LUN0 0
107
108
109/*
110 * Glossary of networking acronyms used in the following bit definitions:
111 *
112 * GSO = Generic Segmentation Offload
113 * TSO = TCP Segmentation Offload
114 * UFO = UDP Fragmentation Offload
115 * ECN = Explicit Congestion Notification
116 */
117
118/** @name VirtIO 1.0 NET Host feature bits (See VirtIO 1.0 specification, Section 5.6.3)
119 * @{ */
120#define VIRTIONET_F_CSUM RT_BIT_64(0) /**< Handle packets with partial checksum */
121#define VIRTIONET_F_GUEST_CSUM RT_BIT_64(1) /**< Handles packets with partial checksum */
122#define VIRTIONET_F_CTRL_GUEST_OFFLOADS RT_BIT_64(2) /**< Control channel offloads reconfig support */
123#define VIRTIONET_F_MAC RT_BIT_64(5) /**< Device has given MAC address */
124#define VIRTIONET_F_GUEST_TSO4 RT_BIT_64(7) /**< Driver can receive TSOv4 */
125#define VIRTIONET_F_GUEST_TSO6 RT_BIT_64(8) /**< Driver can receive TSOv6 */
126#define VIRTIONET_F_GUEST_ECN RT_BIT_64(9) /**< Driver can receive TSO with ECN */
127#define VIRTIONET_F_GUEST_UFO RT_BIT_64(10) /**< Driver can receive UFO */
128#define VIRTIONET_F_HOST_TSO4 RT_BIT_64(11) /**< Device can receive TSOv4 */
129#define VIRTIONET_F_HOST_TSO6 RT_BIT_64(12) /**< Device can receive TSOv6 */
130#define VIRTIONET_F_HOST_ECN RT_BIT_64(13) /**< Device can receive TSO with ECN */
131#define VIRTIONET_F_HOST_UFO RT_BIT_64(14) /**< Device can receive UFO */
132#define VIRTIONET_F_MRG_RXBUF RT_BIT_64(15) /**< Driver can merge receive buffers */
133#define VIRTIONET_F_STATUS RT_BIT_64(16) /**< Config status field is available */
134#define VIRTIONET_F_CTRL_VQ RT_BIT_64(17) /**< Control channel is available */
135#define VIRTIONET_F_CTRL_RX RT_BIT_64(18) /**< Control channel RX mode + MAC addr filtering */
136#define VIRTIONET_F_CTRL_VLAN RT_BIT_64(19) /**< Control channel VLAN filtering */
137#define VIRTIONET_F_CTRL_RX_EXTRA RT_BIT_64(20) /**< Control channel RX mode extra functions */
138#define VIRTIONET_F_GUEST_ANNOUNCE RT_BIT_64(21) /**< Driver can send gratuitous packets */
139#define VIRTIONET_F_MQ RT_BIT_64(22) /**< Support ultiqueue with auto receive steering */
140#define VIRTIONET_F_CTRL_MAC_ADDR RT_BIT_64(23) /**< Set MAC address through control channel */
141/** @} */
142
143#ifdef VIRTIONET_WITH_GSO
144# define VIRTIONET_HOST_FEATURES_GSO \
145 VIRTIONET_F_CSUM \
146 | VIRTIONET_F_HOST_TSO4 \
147 | VIRTIONET_F_HOST_TSO6 \
148 | VIRTIONET_F_HOST_UFO \
149 | VIRTIONET_F_GUEST_TSO4 \
150 | VIRTIONET_F_GUEST_TSO6 \
151 | VIRTIONET_F_GUEST_UFO \
152 | VIRTIONET_F_GUEST_CSUM /* @bugref(4796) Guest must handle partial chksums */
153#else
154# define VIRTIONET_HOST_FEATURES_GSO
155#endif
156
157#define VIRTIONET_HOST_FEATURES_OFFERED \
158 VIRTIONET_F_STATUS \
159 | VIRTIONET_F_GUEST_ANNOUNCE \
160 | VIRTIONET_F_MAC \
161 | VIRTIONET_F_CTRL_VQ \
162 | VIRTIONET_F_CTRL_RX \
163 | VIRTIONET_F_CTRL_VLAN \
164 | VIRTIONET_HOST_FEATURES_GSO \
165 | VIRTIONET_F_MRG_RXBUF
166
167#define PCI_DEVICE_ID_VIRTIONET_HOST 0x1041 /**< Informs guest driver of type of VirtIO device */
168#define PCI_CLASS_BASE_NETWORK_CONTROLLER 0x02 /**< PCI Network device class */
169#define PCI_CLASS_SUB_NET_ETHERNET_CONTROLLER 0x00 /**< PCI NET Controller subclass */
170#define PCI_CLASS_PROG_UNSPECIFIED 0x00 /**< Programming interface. N/A. */
171#define VIRTIONET_PCI_CLASS 0x01 /**< Base class Mass Storage? */
172
173
174/*********************************************************************************************************************************
175* Structures and Typedefs *
176*********************************************************************************************************************************/
177/**
178 * Virtio Net Host Device device-specific configuration (VirtIO 1.0, 5.1.4)
179 * VBox VirtIO core issues callback to this VirtIO device-specific implementation to handle
180 * MMIO accesses to device-specific configuration parameters.
181 */
182
183#pragma pack(1)
184typedef struct virtio_net_config
185{
186 RTMAC uMacAddress; /**< mac */
187#if FEATURE_OFFERED(STATUS)
188 uint16_t uStatus; /**< status */
189#endif
190#if FEATURE_OFFERED(MQ)
191 uint16_t uMaxVirtqPairs; /**< max_virtq_pairs */
192#endif
193} VIRTIONET_CONFIG_T, PVIRTIONET_CONFIG_T;
194#pragma pack()
195
196#define VIRTIONET_F_LINK_UP RT_BIT(1) /**< config status: Link is up */
197#define VIRTIONET_F_ANNOUNCE RT_BIT(2) /**< config status: Announce */
198
199/** @name VirtIO 1.0 NET Host Device device specific control types
200 * @{ */
201#define VIRTIONET_HDR_F_NEEDS_CSUM 1 /**< Packet needs checksum */
202#define VIRTIONET_HDR_GSO_NONE 0 /**< No Global Segmentation Offset */
203#define VIRTIONET_HDR_GSO_TCPV4 1 /**< Global Segment Offset for TCPV4 */
204#define VIRTIONET_HDR_GSO_UDP 3 /**< Global Segment Offset for UDP */
205#define VIRTIONET_HDR_GSO_TCPV6 4 /**< Global Segment Offset for TCPV6 */
206#define VIRTIONET_HDR_GSO_ECN 0x80 /**< Explicit Congestion Notification */
207/** @} */
208
209/* Device operation: Net header packet (VirtIO 1.0, 5.1.6) */
210#pragma pack(1)
211struct virtio_net_hdr {
212 uint8_t uFlags; /**< flags */
213 uint8_t uGsoType; /**< gso_type */
214 uint16_t uHdrLen; /**< hdr_len */
215 uint16_t uGsoSize; /**< gso_size */
216 uint16_t uChksumStart; /**< Chksum_start */
217 uint16_t uChksumOffset; /**< Chksum_offset */
218 uint16_t uNumBuffers; /**< num_buffers */
219};
220#pragma pack()
221typedef virtio_net_hdr VIRTIONET_PKT_HDR_T, *PVIRTIONET_PKT_HDR_T;
222AssertCompileSize(VIRTIONET_PKT_HDR_T, 12);
223
224/* Control virtq: Command entry (VirtIO 1.0, 5.1.6.5) */
225#pragma pack(1)
226struct virtio_net_ctrl_hdr {
227 uint8_t uClass; /**< class */
228 uint8_t uCmd; /**< command */
229};
230#pragma pack()
231typedef virtio_net_ctrl_hdr VIRTIONET_CTRL_HDR_T, *PVIRTIONET_CTRL_HDR_T;
232
233typedef uint8_t VIRTIONET_CTRL_HDR_T_ACK;
234
235/* Command entry fAck values */
236#define VIRTIONET_OK 0
237#define VIRTIONET_ERROR 1
238
239/** @name Control virtq: Receive filtering flags (VirtIO 1.0, 5.1.6.5.1)
240 * @{ */
241#define VIRTIONET_CTRL_RX 0 /**< Control class: Receive filtering */
242#define VIRTIONET_CTRL_RX_PROMISC 0 /**< Promiscuous mode */
243#define VIRTIONET_CTRL_RX_ALLMULTI 1 /**< All-multicast receive */
244#define VIRTIONET_CTRL_RX_ALLUNI 2 /**< All-unicast receive */
245#define VIRTIONET_CTRL_RX_NOMULTI 3 /**< No multicast receive */
246#define VIRTIONET_CTRL_RX_NOUNI 4 /**< No unicast receive */
247#define VIRTIONET_CTRL_RX_NOBCAST 5 /**< No broadcast receive */
248/** @} */
249
250typedef uint8_t VIRTIONET_MAC_ADDRESS[6];
251typedef uint32_t VIRTIONET_CTRL_MAC_TABLE_LEN;
252typedef uint8_t VIRTIONET_CTRL_MAC_ENTRIES[][6];
253
254/** @name Control virtq: MAC address filtering flags (VirtIO 1.0, 5.1.6.5.2)
255 * @{ */
256#define VIRTIONET_CTRL_MAC 1 /**< Control class: MAC address filtering */
257#define VIRTIONET_CTRL_MAC_TABLE_SET 0 /**< Set MAC table */
258#define VIRTIONET_CTRL_MAC_ADDR_SET 1 /**< Set default MAC address */
259/** @} */
260
261/** @name Control virtq: MAC address filtering flags (VirtIO 1.0, 5.1.6.5.3)
262 * @{ */
263#define VIRTIONET_CTRL_VLAN 2 /**< Control class: VLAN filtering */
264#define VIRTIONET_CTRL_VLAN_ADD 0 /**< Add VLAN to filter table */
265#define VIRTIONET_CTRL_VLAN_DEL 1 /**< Delete VLAN from filter table */
266/** @} */
267
268/** @name Control virtq: Gratuitous packet sending (VirtIO 1.0, 5.1.6.5.4)
269 * @{ */
270#define VIRTIONET_CTRL_ANNOUNCE 3 /**< Control class: Gratuitous Packet Sending */
271#define VIRTIONET_CTRL_ANNOUNCE_ACK 0 /**< Gratuitous Packet Sending ACK */
272/** @} */
273
274struct virtio_net_ctrl_mq {
275 uint16_t uVirtqueuePairs; /**< virtqueue_pairs */
276};
277
278/** @name Control virtq: Receive steering in multiqueue mode (VirtIO 1.0, 5.1.6.5.5)
279 * @{ */
280#define VIRTIONET_CTRL_MQ 4 /**< Control class: Receive steering */
281#define VIRTIONET_CTRL_MQ_VQ_PAIRS_SET 0 /**< Set number of TX/RX queues */
282#define VIRTIONET_CTRL_MQ_VQ_PAIRS_MIN 1 /**< Minimum number of TX/RX queues */
283#define VIRTIONET_CTRL_MQ_VQ_PAIRS_MAX 0x8000 /**< Maximum number of TX/RX queues */
284/** @} */
285
286uint64_t uOffloads; /**< offloads */
287
288/** @name Control virtq: Setting Offloads State (VirtIO 1.0, 5.1.6.5.6.1)
289 * @{ */
290#define VIRTIO_NET_CTRL_GUEST_OFFLOADS 5 /**< Control class: Offloads state configuration */
291#define VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET 0 /** Apply new offloads configuration */
292/** @} */
293
294/**
295 * Worker thread context, shared state.
296 */
297typedef struct VIRTIONETWORKER
298{
299 SUPSEMEVENT hEvtProcess; /**< handle of associated sleep/wake-up semaphore */
300} VIRTIONETWORKER;
301/** Pointer to a VirtIO SCSI worker. */
302typedef VIRTIONETWORKER *PVIRTIONETWORKER;
303
304/**
305 * Worker thread context, ring-3 state.
306 */
307typedef struct VIRTIONETWORKERR3
308{
309 R3PTRTYPE(PPDMTHREAD) pThread; /**< pointer to worker thread's handle */
310 bool volatile fSleeping; /**< Flags whether worker thread is sleeping or not */
311 bool volatile fNotified; /**< Flags whether worker thread notified */
312} VIRTIONETWORKERR3;
313/** Pointer to a VirtIO SCSI worker. */
314typedef VIRTIONETWORKERR3 *PVIRTIONETWORKERR3;
315
316/**
317 * VirtIO Host NET device state, shared edition.
318 *
319 * @extends VIRTIOCORE
320 */
321typedef struct VIRTIONET
322{
323 /** The core virtio state. */
324 VIRTIOCORE Virtio;
325
326 /** Virtio device-specific configuration */
327 VIRTIONET_CONFIG_T virtioNetConfig;
328
329 /** Per device-bound virtq worker-thread contexts (eventq slot unused) */
330 VIRTIONETWORKER aWorkers[VIRTIONET_MAX_QUEUES];
331
332 /** Track which VirtIO queues we've attached to */
333 bool afQueueAttached[VIRTIONET_MAX_QUEUES];
334
335 /** Device-specific spec-based VirtIO VIRTQNAMEs */
336 char aszVirtqNames[VIRTIONET_MAX_QUEUES][VIRTIO_MAX_QUEUE_NAME_SIZE];
337
338 /** Instance name */
339 char szInstanceName[16];
340
341 uint16_t cVirtqPairs;
342
343 uint16_t cVirtQueues;
344
345 uint64_t fNegotiatedFeatures;
346
347 SUPSEMEVENT hTxEvent;
348
349 /** Indicates transmission in progress -- only one thread is allowed. */
350 uint32_t uIsTransmitting;
351
352 /** MAC address obtained from the configuration. */
353 RTMAC macConfigured;
354
355 /** Default MAC address which rx filtering accepts */
356 RTMAC rxFilterMacDefault;
357
358 /** True if physical cable is attached in configuration. */
359 bool fCableConnected;
360
361 /** virtio-net-1-dot-0 (in milliseconds). */
362 uint32_t cMsLinkUpDelay;
363
364 uint32_t alignment;
365
366 /** Number of packet being sent/received to show in debug log. */
367 uint32_t uPktNo;
368
369 /** N/A: */
370 bool volatile fLeafWantsRxBuffers;
371
372 SUPSEMEVENT hEventRxDescAvail;
373
374 /** Flags whether VirtIO core is in ready state */
375 uint8_t fVirtioReady;
376
377 /** Resetting flag */
378 uint8_t fResetting;
379
380 /** Quiescing I/O activity flag */
381 uint8_t fQuiescing;
382
383
384 /** Promiscuous mode -- RX filter accepts all packets. */
385 uint8_t fPromiscuous;
386
387 /** All multicast mode -- RX filter accepts all multicast packets. */
388 uint8_t fAllMulticast;
389
390 /** All unicast mode -- RX filter accepts all unicast packets. */
391 uint8_t fAllUnicast;
392
393 /** No multicast mode - Supresses multicast receive */
394 uint8_t fNoMulticast;
395
396 /** No unicast mode - Suppresses unicast receive */
397 uint8_t fNoUnicast;
398
399 /** No broadcast mode - Supresses broadcast receive */
400 uint8_t fNoBroadcast;
401
402 /** The number of actually used slots in aMacMulticastFilter. */
403 uint32_t cMulticastFilterMacs;
404
405 /** Array of MAC multicast addresses accepted by RX filter. */
406 RTMAC aMacMulticastFilter[VIRTIONET_MAC_FILTER_LEN];
407
408 /** The number of actually used slots in aMacUniicastFilter. */
409 uint32_t cUnicastFilterMacs;
410
411 /** Array of MAC unicast addresses accepted by RX filter. */
412 RTMAC aMacUnicastFilter[VIRTIONET_MAC_FILTER_LEN];
413
414 /** Bit array of VLAN filter, one bit per VLAN ID. */
415 uint8_t aVlanFilter[VIRTIONET_MAX_VLAN_ID / sizeof(uint8_t)];
416
417 bool fLog;
418
419 /* Receive-blocking-related fields ***************************************/
420
421} VIRTIONET;
422/** Pointer to the shared state of the VirtIO Host NET device. */
423typedef VIRTIONET *PVIRTIONET;
424
425/**
426 * VirtIO Host NET device state, ring-3 edition.
427 *
428 * @extends VIRTIOCORER3
429 */
430typedef struct VIRTIONETR3
431{
432 /** The core virtio ring-3 state. */
433 VIRTIOCORER3 Virtio;
434
435 /** Per device-bound virtq worker-thread contexts (eventq slot unused) */
436 VIRTIONETWORKERR3 aWorkers[VIRTIONET_MAX_QUEUES];
437
438 /** The device instance.
439 * @note This is _only_ for use when dealing with interface callbacks. */
440 PPDMDEVINSR3 pDevIns;
441
442 /** Status LUN: Base interface. */
443 PDMIBASE IBase;
444
445 /** Status LUN: LED port interface. */
446 PDMILEDPORTS ILeds;
447
448 /** Status LUN: LED connector (peer). */
449 R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
450
451 /** Status: LED */
452 PDMLED led;
453
454 /** Attached network driver. */
455 R3PTRTYPE(PPDMIBASE) pDrvBase;
456
457 /** Network port interface (down) */
458 PDMINETWORKDOWN INetworkDown;
459
460 /** Network config port interface (main). */
461 PDMINETWORKCONFIG INetworkConfig;
462
463 /** Connector of attached network driver. */
464 R3PTRTYPE(PPDMINETWORKUP) pDrv;
465
466 R3PTRTYPE(PPDMTHREAD) pTxThread;
467
468 /** Link Up(/Restore) Timer. */
469 TMTIMERHANDLE hLinkUpTimer;
470
471 /** Queue to send tasks to R3. - HC ptr */
472 R3PTRTYPE(PPDMQUEUE) pNotifierQueueR3;
473
474 /** True if in the process of quiescing I/O */
475 uint32_t fQuiescing;
476
477 /** For which purpose we're quiescing. */
478 VIRTIOVMSTATECHANGED enmQuiescingFor;
479
480} VIRTIONETR3;
481
482
483/** Pointer to the ring-3 state of the VirtIO Host NET device. */
484typedef VIRTIONETR3 *PVIRTIONETR3;
485
486/**
487 * VirtIO Host NET device state, ring-0 edition.
488 */
489typedef struct VIRTIONETR0
490{
491 /** The core virtio ring-0 state. */
492 VIRTIOCORER0 Virtio;
493} VIRTIONETR0;
494/** Pointer to the ring-0 state of the VirtIO Host NET device. */
495typedef VIRTIONETR0 *PVIRTIONETR0;
496
497
498/**
499 * VirtIO Host NET device state, raw-mode edition.
500 */
501typedef struct VIRTIONETRC
502{
503 /** The core virtio raw-mode state. */
504 VIRTIOCORERC Virtio;
505} VIRTIONETRC;
506/** Pointer to the ring-0 state of the VirtIO Host NET device. */
507typedef VIRTIONETRC *PVIRTIONETRC;
508
509
510/** @typedef VIRTIONETCC
511 * The instance data for the current context. */
512typedef CTX_SUFF(VIRTIONET) VIRTIONETCC;
513
514/** @typedef PVIRTIONETCC
515 * Pointer to the instance data for the current context. */
516typedef CTX_SUFF(PVIRTIONET) PVIRTIONETCC;
517
518#ifdef IN_RING3 /* spans most of the file, at the moment. */
519
520/**
521 * @callback_method_impl{FNPDMTHREADWAKEUPDEV}
522 */
523static DECLCALLBACK(int) virtioNetR3WakeupWorker(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
524{
525 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
526 Log10Func(("%s\n", INSTANCE(pThis)));
527 return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[(uintptr_t)pThread->pvUser].hEvtProcess);
528}
529
530/**
531 * Wakeup the RX thread.
532 */
533static void virtioNetR3WakeupRxBufWaiter(PPDMDEVINS pDevIns)
534{
535 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
536
537 AssertReturnVoid(pThis->hEventRxDescAvail != NIL_SUPSEMEVENT);
538
539 Log10Func(("%s Waking downstream driver's Rx buf waiter thread\n", INSTANCE(pThis)));
540 int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hEventRxDescAvail);
541 AssertRC(rc);
542}
543
544DECLINLINE(void) virtioNetR3SetVirtqNames(PVIRTIONET pThis)
545{
546 for (uint16_t qPairIdx = 0; qPairIdx < pThis->cVirtqPairs; qPairIdx++)
547 {
548 RTStrPrintf(pThis->aszVirtqNames[RXQIDX_QPAIR(qPairIdx)], VIRTIO_MAX_QUEUE_NAME_SIZE, "receiveq<%d>", qPairIdx);
549 RTStrPrintf(pThis->aszVirtqNames[TXQIDX_QPAIR(qPairIdx)], VIRTIO_MAX_QUEUE_NAME_SIZE, "transmitq<%d>", qPairIdx);
550 }
551 RTStrCopy(pThis->aszVirtqNames[CTRLQIDX], VIRTIO_MAX_QUEUE_NAME_SIZE, "controlq");
552}
553
554/**
555 * Dump a packet to debug log.
556 *
557 * @param pThis The virtio-net shared instance data.
558 * @param pbPacket The packet.
559 * @param cb The size of the packet.
560 * @param pszText A string denoting direction of packet transfer.
561 */
562DECLINLINE(void) virtioNetR3PacketDump(PVIRTIONET pThis, const uint8_t *pbPacket, size_t cb, const char *pszText)
563{
564// if (!LogIs12Enabled())
565// return;
566
567 vboxEthPacketDump(INSTANCE(pThis), pszText, pbPacket, (uint32_t)cb);
568}
569
570DECLINLINE(void) virtioNetPrintFeatures(PVIRTIONET pThis, uint32_t fFeatures, const char *pcszText)
571{
572#ifdef LOG_ENABLED
573 static struct
574 {
575 uint32_t fMask;
576 const char *pcszDesc;
577 } const s_aFeatures[] =
578 {
579 { VIRTIONET_F_CSUM, "Host handles packets with partial checksum." },
580 { VIRTIONET_F_GUEST_CSUM, "Guest handles packets with partial checksum." },
581 { VIRTIONET_F_CTRL_GUEST_OFFLOADS, "Control channel offloads reconfiguration support." },
582 { VIRTIONET_F_MAC, "Host has given MAC address." },
583 { VIRTIONET_F_GUEST_TSO4, "Guest can receive TSOv4." },
584 { VIRTIONET_F_GUEST_TSO6, "Guest can receive TSOv6." },
585 { VIRTIONET_F_GUEST_ECN, "Guest can receive TSO with ECN." },
586 { VIRTIONET_F_GUEST_UFO, "Guest can receive UFO." },
587 { VIRTIONET_F_HOST_TSO4, "Host can receive TSOv4." },
588 { VIRTIONET_F_HOST_TSO6, "Host can receive TSOv6." },
589 { VIRTIONET_F_HOST_ECN, "Host can receive TSO with ECN." },
590 { VIRTIONET_F_HOST_UFO, "Host can receive UFO." },
591 { VIRTIONET_F_MRG_RXBUF, "Guest can merge receive buffers." },
592 { VIRTIONET_F_STATUS, "Configuration status field is available." },
593 { VIRTIONET_F_CTRL_VQ, "Control channel is available." },
594 { VIRTIONET_F_CTRL_RX, "Control channel RX mode support." },
595 { VIRTIONET_F_CTRL_VLAN, "Control channel VLAN filtering." },
596 { VIRTIONET_F_GUEST_ANNOUNCE, "Guest can send gratuitous packets." },
597 { VIRTIONET_F_MQ, "Host supports multiqueue with automatic receive steering." },
598 { VIRTIONET_F_CTRL_MAC_ADDR, "Set MAC address through control channel." }
599 };
600
601 Log3(("%s %s:\n", INSTANCE(pThis), pcszText));
602 for (unsigned i = 0; i < RT_ELEMENTS(s_aFeatures); ++i)
603 {
604 if (s_aFeatures[i].fMask & fFeatures)
605 Log3(("%s --> %s\n", INSTANCE(pThis), s_aFeatures[i].pcszDesc));
606 }
607#else /* !LOG_ENABLED */
608 RT_NOREF3(pThis, fFeatures, pcszText);
609#endif /* !LOG_ENABLED */
610}
611
612/*
613 * Checks whether negotiated features have required flag combinations.
614 * See VirtIO 1.0 specification, Section 5.1.3.1 */
615DECLINLINE(bool) virtioNetValidateRequiredFeatures(uint32_t fFeatures)
616{
617 uint32_t fGuestChksumRequired = fFeatures & VIRTIONET_F_GUEST_TSO4
618 || fFeatures & VIRTIONET_F_GUEST_TSO6
619 || fFeatures & VIRTIONET_F_GUEST_UFO;
620
621 uint32_t fHostChksumRequired = fFeatures & VIRTIONET_F_HOST_TSO4
622 || fFeatures & VIRTIONET_F_HOST_TSO6
623 || fFeatures & VIRTIONET_F_HOST_UFO;
624
625 uint32_t fCtrlVqRequired = fFeatures & VIRTIONET_F_CTRL_RX
626 || fFeatures & VIRTIONET_F_CTRL_VLAN
627 || fFeatures & VIRTIONET_F_GUEST_ANNOUNCE
628 || fFeatures & VIRTIONET_F_MQ
629 || fFeatures & VIRTIONET_F_CTRL_MAC_ADDR;
630
631 if (fGuestChksumRequired && !(fFeatures & VIRTIONET_F_GUEST_CSUM))
632 return false;
633
634 if (fHostChksumRequired && !(fFeatures & VIRTIONET_F_CSUM))
635 return false;
636
637 if (fCtrlVqRequired && !(fFeatures & VIRTIONET_F_CTRL_VQ))
638 return false;
639
640 if ( fFeatures & VIRTIONET_F_GUEST_ECN
641 && !( fFeatures & VIRTIONET_F_GUEST_TSO4
642 || fFeatures & VIRTIONET_F_GUEST_TSO6))
643 return false;
644
645 if ( fFeatures & VIRTIONET_F_HOST_ECN
646 && !( fFeatures & VIRTIONET_F_HOST_TSO4
647 || fFeatures & VIRTIONET_F_HOST_TSO6))
648 return false;
649 return true;
650}
651
652/**
653 * Resolves to boolean true if uOffset matches a field offset and size exactly,
654 * (or if 64-bit field, if it accesses either 32-bit part as a 32-bit access)
655 * Assumption is this critereon is mandated by VirtIO 1.0, Section 4.1.3.1)
656 * (Easily re-written to allow unaligned bounded access to a field).
657 *
658 * @param member - Member of VIRTIO_PCI_COMMON_CFG_T
659 * @result - true or false
660 */
661#define MATCH_NET_CONFIG(member) \
662 ( ( RT_SIZEOFMEMB(VIRTIONET_CONFIG_T, member) == 8 \
663 && ( offConfig == RT_UOFFSETOF(VIRTIONET_CONFIG_T, member) \
664 || offConfig == RT_UOFFSETOF(VIRTIONET_CONFIG_T, member) + sizeof(uint32_t)) \
665 && cb == sizeof(uint32_t)) \
666 || ( offConfig >= RT_UOFFSETOF(VIRTIONET_CONFIG_T, member) \
667 && offConfig + cb <= RT_UOFFSETOF(VIRTIONET_CONFIG_T, member) \
668 + RT_SIZEOFMEMB(VIRTIONET_CONFIG_T, member)) )
669
670/* || ( offConfig == RT_UOFFSETOF(VIRTIONET_CONFIG_T, member) \
671 && cb == RT_SIZEOFMEMB(VIRTIONET_CONFIG_T, member)) )
672*/
673
674#ifdef LOG_ENABLED
675# define LOG_NET_CONFIG_ACCESSOR(member) \
676 virtioCoreLogMappedIoValue(__FUNCTION__, #member, RT_SIZEOFMEMB(VIRTIONET_CONFIG_T, member), \
677 pv, cb, offIntra, fWrite, false, 0);
678#else
679# define LOG_NET_CONFIG_ACCESSOR(member) do { } while (0)
680#endif
681
682#define NET_CONFIG_ACCESSOR(member) \
683 do \
684 { \
685 uint32_t offIntra = offConfig - RT_UOFFSETOF(VIRTIONET_CONFIG_T, member); \
686 if (fWrite) \
687 memcpy((char *)&pThis->virtioNetConfig.member + offIntra, pv, cb); \
688 else \
689 memcpy(pv, (const char *)&pThis->virtioNetConfig.member + offIntra, cb); \
690 LOG_NET_CONFIG_ACCESSOR(member); \
691 } while(0)
692
693#define NET_CONFIG_ACCESSOR_READONLY(member) \
694 do \
695 { \
696 uint32_t offIntra = offConfig - RT_UOFFSETOF(VIRTIONET_CONFIG_T, member); \
697 if (fWrite) \
698 LogFunc(("%s Guest attempted to write readonly virtio_pci_common_cfg.%s\n", INSTANCE(pThis), #member)); \
699 else \
700 { \
701 memcpy(pv, (const char *)&pThis->virtioNetConfig.member + offIntra, cb); \
702 LOG_NET_CONFIG_ACCESSOR(member); \
703 } \
704 } while(0)
705
706
707static int virtioNetR3CfgAccessed(PVIRTIONET pThis, uint32_t offConfig, void *pv, uint32_t cb, bool fWrite)
708{
709 AssertReturn(pv && cb <= sizeof(uint32_t), fWrite ? VINF_SUCCESS : VINF_IOM_MMIO_UNUSED_00);
710
711 if (MATCH_NET_CONFIG(uMacAddress))
712 NET_CONFIG_ACCESSOR_READONLY(uMacAddress);
713#if FEATURE_OFFERED(STATUS)
714 else
715 if (MATCH_NET_CONFIG(uStatus))
716 NET_CONFIG_ACCESSOR_READONLY(uStatus);
717#endif
718#if FEATURE_OFFERED(MQ)
719 else
720 if (MATCH_NET_CONFIG(uMaxVirtqPairs))
721 NET_CONFIG_ACCESSOR_READONLY(uMaxVirtqPairs);
722#endif
723 else
724 {
725 LogFunc(("%s Bad access by guest to virtio_net_config: off=%u (%#x), cb=%u\n", INSTANCE(pThis), offConfig, offConfig, cb));
726 return fWrite ? VINF_SUCCESS : VINF_IOM_MMIO_UNUSED_00;
727 }
728 return VINF_SUCCESS;
729}
730
731#undef NET_CONFIG_ACCESSOR_READONLY
732#undef NET_CONFIG_ACCESSOR
733#undef LOG_ACCESSOR
734#undef MATCH_NET_CONFIG
735
736/**
737 * @callback_method_impl{VIRTIOCORER3,pfnDevCapRead}
738 */
739static DECLCALLBACK(int) virtioNetR3DevCapRead(PPDMDEVINS pDevIns, uint32_t uOffset, void *pv, uint32_t cb)
740{
741 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
742
743 LogFunc(("%s uOffset: %d, cb: %d\n", INSTANCE(pThis), uOffset, cb));
744 return virtioNetR3CfgAccessed(PDMDEVINS_2_DATA(pDevIns, PVIRTIONET), uOffset, pv, cb, false /*fRead*/);
745}
746
747/**
748 * @callback_method_impl{VIRTIOCORER3,pfnDevCapWrite}
749 */
750static DECLCALLBACK(int) virtioNetR3DevCapWrite(PPDMDEVINS pDevIns, uint32_t uOffset, const void *pv, uint32_t cb)
751{
752 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
753
754 Log10Func(("%s uOffset: %d, cb: %d: %.*Rhxs\n", INSTANCE(pThis), uOffset, cb, RT_MAX(cb, 8) , pv));
755 return virtioNetR3CfgAccessed(PDMDEVINS_2_DATA(pDevIns, PVIRTIONET), uOffset, (void *)pv, cb, true /*fWrite*/);
756}
757
758
759/*********************************************************************************************************************************
760* Misc *
761*********************************************************************************************************************************/
762
763/**
764 * @callback_method_impl{FNDBGFHANDLERDEV, virtio-net debugger info callback.}
765 */
766static DECLCALLBACK(void) virtioNetR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
767{
768 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
769
770 /* Parse arguments. */
771 RT_NOREF2(pThis, pszArgs); //bool fVerbose = pszArgs && strstr(pszArgs, "verbose") != NULL;
772
773 /* Show basic information. */
774 pHlp->pfnPrintf(pHlp, "%s#%d: virtio-scsci ",
775 pDevIns->pReg->szName,
776 pDevIns->iInstance);
777}
778
779
780/*********************************************************************************************************************************
781* Saved state *
782*********************************************************************************************************************************/
783
784/**
785 * @callback_method_impl{FNSSMDEVLOADEXEC}
786 */
787static DECLCALLBACK(int) virtioNetR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
788{
789 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
790 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
791 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
792
793 RT_NOREF(pThisCC);
794 Log7Func(("%s LOAD EXEC!!\n", INSTANCE(pThis)));
795
796 AssertReturn(uPass == SSM_PASS_FINAL, VERR_SSM_UNEXPECTED_PASS);
797 AssertLogRelMsgReturn(uVersion == VIRTIONET_SAVED_STATE_VERSION,
798 ("uVersion=%u\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
799
800 virtioNetR3SetVirtqNames(pThis);
801
802 for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
803 pHlp->pfnSSMGetBool(pSSM, &pThis->afQueueAttached[idxQueue]);
804
805 /*
806 * Call the virtio core to let it load its state.
807 */
808 int rc = virtioCoreR3LoadExec(&pThis->Virtio, pDevIns->pHlpR3, pSSM);
809
810 /*
811 * Nudge queue workers
812 */
813 for (int idxQueue = 0; idxQueue < pThis->cVirtqPairs; idxQueue++)
814 {
815 if (pThis->afQueueAttached[idxQueue])
816 {
817 Log7Func(("%s Waking %s worker.\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
818 rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[idxQueue].hEvtProcess);
819 AssertRCReturn(rc, rc);
820 }
821 }
822 return rc;
823}
824
825/**
826 * @callback_method_impl{FNSSMDEVSAVEEXEC}
827 */
828static DECLCALLBACK(int) virtioNetR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
829{
830 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
831 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
832 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
833
834 RT_NOREF(pThisCC);
835
836 Log7Func(("%s SAVE EXEC!!\n", INSTANCE(pThis)));
837
838 for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
839 pHlp->pfnSSMPutBool(pSSM, pThis->afQueueAttached[idxQueue]);
840
841 /*
842 * Call the virtio core to let it save its state.
843 */
844 return virtioCoreR3SaveExec(&pThis->Virtio, pDevIns->pHlpR3, pSSM);
845}
846
847
848/*********************************************************************************************************************************
849* Device interface. *
850*********************************************************************************************************************************/
851
852/**
853 * @callback_method_impl{FNPDMDEVASYNCNOTIFY}
854 */
855static DECLCALLBACK(bool) virtioNetR3DeviceQuiesced(PPDMDEVINS pDevIns)
856{
857 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
858 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
859
860 /** @todo create test to conclusively determine I/O has been quiesced and add it here: */
861
862 Log7Func(("%s Device I/O activity quiesced: %s\n",
863 INSTANCE(pThis), virtioCoreGetStateChangeText(pThisCC->enmQuiescingFor)));
864
865 virtioCoreR3VmStateChanged(&pThis->Virtio, pThisCC->enmQuiescingFor);
866
867 pThis->fResetting = false;
868 pThisCC->fQuiescing = false;
869
870 return true;
871}
872
873/**
874 * Worker for virtioNetR3Reset() and virtioNetR3SuspendOrPowerOff().
875 */
876static void virtioNetR3QuiesceDevice(PPDMDEVINS pDevIns, VIRTIOVMSTATECHANGED enmQuiescingFor)
877{
878 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
879 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
880
881 RT_NOREF(pThis);
882
883 /* Prevent worker threads from removing/processing elements from virtq's */
884 pThisCC->fQuiescing = true;
885 pThisCC->enmQuiescingFor = enmQuiescingFor;
886
887 /*
888 * Wake downstream network driver thread that's waiting for Rx buffers to be available
889 * to tell it that's going to happen...
890 */
891 virtioNetR3WakeupRxBufWaiter(pDevIns);
892
893 PDMDevHlpSetAsyncNotification(pDevIns, virtioNetR3DeviceQuiesced);
894
895 /* If already quiesced invoke async callback. */
896 if (!ASMAtomicReadBool(&pThis->fLeafWantsRxBuffers))
897 PDMDevHlpAsyncNotificationCompleted(pDevIns);
898
899 /** @todo make sure Rx and Tx are really quiesced (how to we synchronize w/downstream driver?) */
900}
901
902/**
903 * @interface_method_impl{PDMDEVREGR3,pfnReset}
904 */
905static DECLCALLBACK(void) virtioNetR3Reset(PPDMDEVINS pDevIns)
906{
907 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
908 Log7Func(("%s\n", INSTANCE(pThis)));
909 pThis->fResetting = true;
910 virtioNetR3QuiesceDevice(pDevIns, kvirtIoVmStateChangedReset);
911}
912
913/**
914 * @interface_method_impl{PDMDEVREGR3,pfnPowerOff}
915 */
916static DECLCALLBACK(void) virtioNetR3SuspendOrPowerOff(PPDMDEVINS pDevIns, VIRTIOVMSTATECHANGED enmType)
917{
918
919 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
920 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
921 Log7Func(("%s\n", INSTANCE(pThis)));
922
923 RT_NOREF2(pThis, pThisCC);
924
925 virtioNetR3QuiesceDevice(pDevIns, enmType);
926}
927
928/**
929 * @interface_method_impl{PDMDEVREGR3,pfnSuspend}
930 */
931static DECLCALLBACK(void) virtioNetR3PowerOff(PPDMDEVINS pDevIns)
932{
933 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
934 Log7Func(("%s\n", INSTANCE(pThis)));
935
936 virtioNetR3SuspendOrPowerOff(pDevIns, kvirtIoVmStateChangedPowerOff);
937}
938
939/**
940 * @interface_method_impl{PDMDEVREGR3,pfnSuspend}
941 */
942static DECLCALLBACK(void) virtioNetR3Suspend(PPDMDEVINS pDevIns)
943{
944 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
945 Log7Func(("%s \n", INSTANCE(pThis)));
946 virtioNetR3SuspendOrPowerOff(pDevIns, kvirtIoVmStateChangedSuspend);
947}
948
949/**
950 * @interface_method_impl{PDMDEVREGR3,pfnResume}
951 */
952static DECLCALLBACK(void) virtioNetR3Resume(PPDMDEVINS pDevIns)
953{
954 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
955 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
956 Log7Func(("\n"));
957
958 pThisCC->fQuiescing = false;
959
960
961 /** @todo implement this function properly */
962
963 /* Wake worker threads flagged to skip pulling queue entries during quiesce
964 * to ensure they re-check their queues. Active request queues may already
965 * be awake due to new reqs coming in.
966 */
967/*
968 for (uint16_t idxQueue = 0; idxQueue < VIRTIONET_REQ_QUEUE_CNT; idxQueue++)
969 {
970 if (ASMAtomicReadBool(&pThisCC->aWorkers[idxQueue].fSleeping))
971 {
972 Log7Func(("%s waking %s worker.\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
973 int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[idxQueue].hEvtProcess);
974 AssertRC(rc);
975 }
976 }
977*/
978 /* Ensure guest is working the queues too. */
979 virtioCoreR3VmStateChanged(&pThis->Virtio, kvirtIoVmStateChangedResume);
980}
981
982#ifdef IN_RING3
983
984DECLINLINE(uint16_t) virtioNetR3Checkum16(const void *pvBuf, size_t cb)
985{
986 uint32_t chksum = 0;
987 uint16_t *pu = (uint16_t *)pvBuf;
988
989 while (cb > 1)
990 {
991 chksum += *pu++;
992 cb -= 2;
993 }
994 if (cb)
995 chksum += *(uint8_t*)pu;
996 while (chksum >> 16)
997 chksum = (chksum >> 16) + (chksum & 0xFFFF);
998 return ~chksum;
999}
1000
1001DECLINLINE(void) virtioNetR3CompleteChecksum(uint8_t *pBuf, size_t cbSize, uint16_t uStart, uint16_t uOffset)
1002{
1003 AssertReturnVoid(uStart < cbSize);
1004 AssertReturnVoid(uStart + uOffset + sizeof(uint16_t) <= cbSize);
1005 *(uint16_t *)(pBuf + uStart + uOffset) = virtioNetR3Checkum16(pBuf + uStart, cbSize - uStart);
1006}
1007
1008/**
1009 * Turns on/off the read status LED.
1010 *
1011 * @returns VBox status code.
1012 * @param pThis Pointer to the device state structure.
1013 * @param fOn New LED state.
1014 */
1015void virtioNetR3SetReadLed(PVIRTIONETR3 pThisR3, bool fOn)
1016{
1017 Log10Func(("%s\n", fOn ? "on" : "off"));
1018 if (fOn)
1019 pThisR3->led.Asserted.s.fReading = pThisR3->led.Actual.s.fReading = 1;
1020 else
1021 pThisR3->led.Actual.s.fReading = fOn;
1022}
1023
1024/**
1025 * Turns on/off the write status LED.
1026 *
1027 * @returns VBox status code.
1028 * @param pThis Pointer to the device state structure.
1029 * @param fOn New LED state.
1030 */
1031void virtioNetR3SetWriteLed(PVIRTIONETR3 pThisR3, bool fOn)
1032{
1033 Log10Func(("%s\n", fOn ? "on" : "off"));
1034 if (fOn)
1035 pThisR3->led.Asserted.s.fWriting = pThisR3->led.Actual.s.fWriting = 1;
1036 else
1037 pThisR3->led.Actual.s.fWriting = fOn;
1038}
1039
1040/**
1041 * Check whether specific queue is ready and has Rx buffers (virtqueue descriptors)
1042 * available. This must be called before the pfnRecieve() method is called.
1043 *
1044 * @remarks As a side effect this function enables queue notification
1045 * if it cannot receive because the queue is empty.
1046 * It disables notification if it can receive.
1047 *
1048 * @returns VERR_NET_NO_BUFFER_SPACE if it cannot.
1049 * @thread RX
1050 */
1051static int virtioNetR3IsRxQueuePrimed(PPDMDEVINS pDevIns, PVIRTIONET pThis, uint16_t idxQueue)
1052{
1053#define LOGPARAMS INSTANCE(pThis), VIRTQNAME(idxQueue)
1054
1055 if (!pThis->fVirtioReady)
1056 {
1057 Log8Func(("%s %s VirtIO not ready (rc = VERR_NET_NO_BUFFER_SPACE)\n", LOGPARAMS));
1058 }
1059 else if (!virtioCoreIsQueueEnabled(&pThis->Virtio, RXQIDX_QPAIR(idxQueue)))
1060 {
1061 Log8Func(("%s %s queue not enabled (rc = VERR_NET_NO_BUFFER_SPACE)\n", LOGPARAMS));
1062 }
1063 else if (virtioCoreQueueIsEmpty(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(idxQueue)))
1064 {
1065 Log8Func(("%s %s queue is empty (rc = VERR_NET_NO_BUFFER_SPACE)\n", LOGPARAMS));
1066 virtioCoreQueueSetNotify(&pThis->Virtio, RXQIDX_QPAIR(idxQueue), true);
1067 }
1068 else
1069 {
1070 Log8Func(("%s %s ready with available buffers\n", LOGPARAMS));
1071 virtioCoreQueueSetNotify(&pThis->Virtio, RXQIDX_QPAIR(idxQueue), false);
1072 return VINF_SUCCESS;
1073 }
1074 return VERR_NET_NO_BUFFER_SPACE;
1075}
1076
1077
1078static bool virtioNetR3AreRxBufsAvail(PPDMDEVINS pDevIns, PVIRTIONET pThis)
1079{
1080 /** @todo If we ever start using more than one Rx/Tx queue pair, is a random queue
1081 selection algorithm feasible or even necessary to prevent starvation? */
1082 for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue += 2) /* Skip odd queue #'s because Rx queues only! */
1083 {
1084 if (!IS_RX_QUEUE(idxQueue))
1085 continue;
1086
1087 if (RT_SUCCESS(virtioNetR3IsRxQueuePrimed(pDevIns, pThis, idxQueue)))
1088 return true;
1089 }
1090 return false;
1091}
1092/*
1093 * Returns true if VirtIO core and device are in a running and operational state
1094 */
1095DECLINLINE(bool) virtioNetAllSystemsGo(PVIRTIONET pThis, PPDMDEVINS pDevIns)
1096{
1097 if (!pThis->fVirtioReady)
1098 return false;
1099
1100 if (pThis->fQuiescing)
1101 return false;
1102
1103 VMSTATE enmVMState = PDMDevHlpVMState(pDevIns);
1104 if (!RT_LIKELY(enmVMState == VMSTATE_RUNNING || enmVMState == VMSTATE_RUNNING_LS))
1105 return false;
1106
1107 return true;
1108}
1109
1110/**
1111 * @interface_method_impl{PDMINETWORKDOWN,pfnWaitReceiveAvail}
1112 */
1113static DECLCALLBACK(int) virtioNetR3NetworkDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL timeoutMs)
1114{
1115 PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkDown);
1116 PPDMDEVINS pDevIns = pThisCC->pDevIns;
1117 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
1118
1119 if (virtioNetR3AreRxBufsAvail(pDevIns, pThis))
1120 {
1121 Log10Func(("%s Rx bufs now available, releasing waiter...\n", INSTANCE(pThis)));
1122 return VINF_SUCCESS;
1123 }
1124 if (!timeoutMs)
1125 return VERR_NET_NO_BUFFER_SPACE;
1126
1127 LogFlowFunc(("%s timeoutMs=%u\n", INSTANCE(pThis), timeoutMs));
1128
1129 ASMAtomicXchgBool(&pThis->fLeafWantsRxBuffers, true);
1130
1131 do {
1132 if (virtioNetR3AreRxBufsAvail(pDevIns, pThis))
1133 {
1134 Log10Func(("%s Rx bufs now available, releasing waiter...\n", INSTANCE(pThis)));
1135 return VINF_SUCCESS;
1136 }
1137 Log9Func(("%s Starved for guest Rx bufs, waiting %u ms ...\n",
1138 INSTANCE(pThis), timeoutMs));
1139
1140 int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->hEventRxDescAvail, timeoutMs);
1141
1142 if (rc == VERR_TIMEOUT || rc == VERR_INTERRUPTED)
1143 continue;
1144
1145 if (RT_FAILURE(rc))
1146 RTThreadSleep(1);
1147
1148 } while (virtioNetAllSystemsGo(pThis, pDevIns));
1149
1150 ASMAtomicXchgBool(&pThis->fLeafWantsRxBuffers, false);
1151
1152 Log7Func(("%s Wait for Rx buffers available was interrupted\n", INSTANCE(pThis)));
1153 return VERR_INTERRUPTED;
1154}
1155
1156
1157/**
1158 * Sets up the GSO context according to the Virtio header.
1159 *
1160 * @param pGso The GSO context to setup.
1161 * @param pCtx The context descriptor.
1162 */
1163DECLINLINE(PPDMNETWORKGSO) virtioNetR3SetupGsoCtx(PPDMNETWORKGSO pGso, VIRTIONET_PKT_HDR_T const *pPktHdr)
1164{
1165 pGso->u8Type = PDMNETWORKGSOTYPE_INVALID;
1166
1167 if (pPktHdr->uGsoType & VIRTIONET_HDR_GSO_ECN)
1168 {
1169 AssertMsgFailed(("Unsupported flag in virtio header: ECN\n"));
1170 return NULL;
1171 }
1172 switch (pPktHdr->uGsoType & ~VIRTIONET_HDR_GSO_ECN)
1173 {
1174 case VIRTIONET_HDR_GSO_TCPV4:
1175 pGso->u8Type = PDMNETWORKGSOTYPE_IPV4_TCP;
1176 pGso->cbHdrsSeg = pPktHdr->uHdrLen;
1177 break;
1178 case VIRTIONET_HDR_GSO_TCPV6:
1179 pGso->u8Type = PDMNETWORKGSOTYPE_IPV6_TCP;
1180 pGso->cbHdrsSeg = pPktHdr->uHdrLen;
1181 break;
1182 case VIRTIONET_HDR_GSO_UDP:
1183 pGso->u8Type = PDMNETWORKGSOTYPE_IPV4_UDP;
1184 pGso->cbHdrsSeg = pPktHdr->uChksumStart;
1185 break;
1186 default:
1187 return NULL;
1188 }
1189 if (pPktHdr->uFlags & VIRTIONET_HDR_F_NEEDS_CSUM)
1190 pGso->offHdr2 = pPktHdr->uChksumStart;
1191 else
1192 {
1193 AssertMsgFailed(("GSO without checksum offloading!\n"));
1194 return NULL;
1195 }
1196 pGso->offHdr1 = sizeof(RTNETETHERHDR);
1197 pGso->cbHdrsTotal = pPktHdr->uHdrLen;
1198 pGso->cbMaxSeg = pPktHdr->uGsoSize;
1199 return pGso;
1200}
1201
1202
1203/**
1204 * @interface_method_impl{PDMINETWORKCONFIG,pfnGetMac}
1205 */
1206static DECLCALLBACK(int) virtioNetR3NetworkConfig_GetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
1207{
1208 PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkConfig);
1209 PVIRTIONET pThis = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIONET);
1210 memcpy(pMac, pThis->virtioNetConfig.uMacAddress.au8, sizeof(RTMAC));
1211 return VINF_SUCCESS;
1212}
1213
1214/**
1215 * Returns true if it is a broadcast packet.
1216 *
1217 * @returns true if destination address indicates broadcast.
1218 * @param pvBuf The ethernet packet.
1219 */
1220DECLINLINE(bool) virtioNetR3IsBroadcast(const void *pvBuf)
1221{
1222 static const uint8_t s_abBcastAddr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
1223 return memcmp(pvBuf, s_abBcastAddr, sizeof(s_abBcastAddr)) == 0;
1224}
1225
1226/**
1227 * Returns true if it is a multicast packet.
1228 *
1229 * @remarks returns true for broadcast packets as well.
1230 * @returns true if destination address indicates multicast.
1231 * @param pvBuf The ethernet packet.
1232 */
1233DECLINLINE(bool) virtioNetR3IsMulticast(const void *pvBuf)
1234{
1235 return (*(char*)pvBuf) & 1;
1236}
1237/**
1238 * Determines if the packet is to be delivered to upper layer.
1239 *
1240 * @returns true if packet is intended for this node.
1241 * @param pThis Pointer to the state structure.
1242 * @param pvBuf The ethernet packet.
1243 * @param cb Number of bytes available in the packet.
1244 */
1245static bool virtioNetR3AddressFilter(PVIRTIONET pThis, const void *pvBuf, size_t cb)
1246{
1247
1248 if (LogIs11Enabled())
1249 {
1250 char *pszType;
1251 if (virtioNetR3IsMulticast(pvBuf))
1252 pszType = (char *)"Multicast";
1253 else if (virtioNetR3IsBroadcast(pvBuf))
1254 pszType = (char *)"Broadcast";
1255 else
1256 pszType = (char *)"Unicast";
1257
1258 LogFunc(("%s node(%RTmac %s%s), pkt(%RTmac %s)",
1259 INSTANCE(pThis), pThis->virtioNetConfig.uMacAddress.au8,
1260 pThis->fPromiscuous ? "promiscuous" : "",
1261 pThis->fAllMulticast ? " all-multicast" : "",
1262 pvBuf, pszType));
1263 }
1264
1265 if (pThis->fPromiscuous)
1266 return true;
1267
1268 /* Ignore everything outside of our VLANs */
1269 uint16_t *uPtr = (uint16_t *)pvBuf;
1270
1271 /* Compare TPID with VLAN Ether Type */
1272 if ( uPtr[6] == RT_H2BE_U16(0x8100)
1273 && !ASMBitTest(pThis->aVlanFilter, RT_BE2H_U16(uPtr[7]) & 0xFFF))
1274 {
1275 Log11Func(("\n%s not our VLAN, returning false\n", INSTANCE(pThis)));
1276 return false;
1277 }
1278
1279uint8_t src[6] = { 0xA8, 0x20, 0x66, 0x57, 0x50, 0x3C };
1280uint8_t dst[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
1281if (memcmp(pvBuf, dst, 6) == 0 && memcmp(((uint8_t *)pvBuf) + 6, src, 6) == 0)
1282{
1283 pThis->fLog = true;
1284 virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
1285}
1286
1287 if (virtioNetR3IsBroadcast(pvBuf))
1288 {
1289 Log11(("... accept (broadcast)\n"));
1290 if (LogIs12Enabled())
1291 virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
1292 return true;
1293 }
1294 if (pThis->fAllMulticast && virtioNetR3IsMulticast(pvBuf))
1295 {
1296 Log11(("... accept (all-multicast mode)\n"));
1297 if (LogIs12Enabled())
1298 virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
1299 return true;
1300 }
1301
1302 if (!memcmp(pThis->virtioNetConfig.uMacAddress.au8, pvBuf, sizeof(RTMAC)))
1303 {
1304 Log11((". . . accept (direct to this node)\n"));
1305 if (LogIs12Enabled())
1306 virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
1307 return true;
1308 }
1309
1310 for (uint16_t i = 0; i < pThis->cMulticastFilterMacs; i++)
1311 {
1312 if (!memcmp(&pThis->aMacMulticastFilter[i], pvBuf, sizeof(RTMAC)))
1313 {
1314 Log11(("... accept (in multicast array)\n"));
1315 if (LogIs12Enabled())
1316 virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
1317 return true;
1318 }
1319 }
1320
1321 /** @todo Original combined unicast & multicast into one table. Should we distinguish? */
1322
1323 for (uint16_t i = 0; i < pThis->cUnicastFilterMacs; i++)
1324 if (!memcmp(&pThis->aMacUnicastFilter[i], pvBuf, sizeof(RTMAC)))
1325 {
1326 Log11(("... accept (in unicast array)\n"));
1327 return true;
1328 }
1329
1330 if (LogIs12Enabled())
1331 Log(("... reject\n"));
1332
1333 return false;
1334}
1335
1336/**
1337 * Pad and store received packet.
1338 *
1339 * @remarks Make sure that the packet appears to upper layer as one coming
1340 * from real Ethernet: pad it and insert FCS.
1341 *
1342 * @returns VBox status code.
1343 * @param pDevIns The device instance.
1344 * @param pThis The virtio-net shared instance data.
1345 * @param pvBuf The available data.
1346 * @param cb Number of bytes available in the buffer.
1347 * @param pGso Pointer to Global Segmentation Offload structure
1348 * @param idxQueue Queue to work with
1349 * @thread RX
1350 */
1351static int virtioNetR3HandleRxPacket(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
1352 const void *pvBuf, size_t cb, PCPDMNETWORKGSO pGso, uint16_t idxQueue)
1353{
1354 RT_NOREF(pThisCC);
1355
1356 LogFunc(("%s (%RTmac)\n", INSTANCE(pThis), pvBuf));
1357 VIRTIONET_PKT_HDR_T rxPktHdr;
1358
1359 if (pGso)
1360 {
1361 Log2Func(("%s gso type=%x cbPktHdrsTotal=%u cbPktHdrsSeg=%u mss=%u off1=0x%x off2=0x%x\n",
1362 INSTANCE(pThis), pGso->u8Type, pGso->cbHdrsTotal,
1363 pGso->cbHdrsSeg, pGso->cbMaxSeg, pGso->offHdr1, pGso->offHdr2));
1364
1365 rxPktHdr.uFlags = VIRTIONET_HDR_F_NEEDS_CSUM;
1366 switch (pGso->u8Type)
1367 {
1368 case PDMNETWORKGSOTYPE_IPV4_TCP:
1369 rxPktHdr.uGsoType = VIRTIONET_HDR_GSO_TCPV4;
1370 rxPktHdr.uChksumOffset = RT_OFFSETOF(RTNETTCP, th_sum);
1371 break;
1372 case PDMNETWORKGSOTYPE_IPV6_TCP:
1373 rxPktHdr.uGsoType = VIRTIONET_HDR_GSO_TCPV6;
1374 rxPktHdr.uChksumOffset = RT_OFFSETOF(RTNETTCP, th_sum);
1375 break;
1376 case PDMNETWORKGSOTYPE_IPV4_UDP:
1377 rxPktHdr.uGsoType = VIRTIONET_HDR_GSO_UDP;
1378 rxPktHdr.uChksumOffset = RT_OFFSETOF(RTNETUDP, uh_sum);
1379 break;
1380 default:
1381 return VERR_INVALID_PARAMETER;
1382 }
1383 rxPktHdr.uHdrLen = pGso->cbHdrsTotal;
1384 rxPktHdr.uGsoSize = pGso->cbMaxSeg;
1385 rxPktHdr.uChksumOffset = pGso->offHdr2;
1386 }
1387 else
1388 {
1389 rxPktHdr.uFlags = 0;
1390 rxPktHdr.uGsoType = VIRTIONET_HDR_GSO_NONE;
1391 }
1392
1393// virtioNetR3PacketDump(pThis, (const uint8_t *)pvBuf, cb, "<-- Incoming");
1394
1395 uint16_t cSegsAllocated = VIRTIONET_PREALLOCATE_RX_SEG_COUNT;
1396
1397 PRTSGBUF pVirtSegBufToGuest = (PRTSGBUF)RTMemAllocZ(sizeof(RTSGBUF));
1398 PRTSGSEG paVirtSegsToGuest = (PRTSGSEG)RTMemAllocZ(sizeof(RTSGSEG) * cSegsAllocated);
1399 AssertReturn(paVirtSegsToGuest, VERR_NO_MEMORY);
1400
1401 RTGCPHYS gcPhysPktHdrNumBuffers;
1402 uint32_t cDescs = 0;
1403
1404 uint8_t fAddPktHdr = true;
1405 uint32_t uOffset = 0;
1406
1407 while (uOffset < cb)
1408 {
1409 PVIRTIO_DESC_CHAIN_T pDescChain;
1410 int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(idxQueue), &pDescChain, true);
1411
1412 AssertRC(rc == VINF_SUCCESS || rc == VERR_NOT_AVAILABLE);
1413
1414 /** @todo Find a better way to deal with this */
1415
1416 AssertMsgReturn(rc == VINF_SUCCESS && pDescChain->cbPhysReturn,
1417 ("Not enough Rx buffers in queue to accomodate ethernet packet\n"),
1418 VERR_INTERNAL_ERROR);
1419
1420 /* Unlikely that len of 1st seg of guest Rx (IN) buf is less than sizeof(virtio_net_hdr) == 12.
1421 * Assert it to reduce complexity. Robust solution would entail finding seg idx and offset of
1422 * virtio_net_header.num_buffers (to update field *after* hdr & pkts copied to gcPhys) */
1423
1424 AssertMsgReturn(pDescChain->pSgPhysReturn->paSegs[0].cbSeg >= sizeof(VIRTIONET_PKT_HDR_T),
1425 ("Desc chain's first seg has insufficient space for pkt header!\n"),
1426 VERR_INTERNAL_ERROR);
1427
1428 uint32_t cbDescChainLeft = pDescChain->cbPhysSend;
1429
1430 uint16_t cSegs = 0;
1431 if (fAddPktHdr)
1432 {
1433LogFunc(("Add pkthdr\n"));
1434 /* Lead with packet header */
1435 paVirtSegsToGuest[cSegs].cbSeg = sizeof(VIRTIONET_PKT_HDR_T);
1436 paVirtSegsToGuest[cSegs].pvSeg = RTMemAlloc(sizeof(VIRTIONET_PKT_HDR_T));
1437 AssertReturn(paVirtSegsToGuest[0].pvSeg, VERR_NO_MEMORY);
1438
1439 cbDescChainLeft -= sizeof(VIRTIONET_PKT_HDR_T);
1440
1441 memcpy(paVirtSegsToGuest[cSegs].pvSeg, &rxPktHdr, sizeof(VIRTIONET_PKT_HDR_T));
1442
1443 /* Calculate & cache the field we will need to update later in gcPhys memory */
1444 gcPhysPktHdrNumBuffers = pDescChain->pSgPhysReturn->paSegs[0].gcPhys
1445 + RT_UOFFSETOF(VIRTIONET_PKT_HDR_T, uNumBuffers);
1446
1447 fAddPktHdr = false;
1448 }
1449 if (cSegs++ >= cSegsAllocated)
1450 {
1451 cSegsAllocated <<= 1; /* double the allocation size */
1452 paVirtSegsToGuest = (PRTSGSEG)RTMemRealloc(paVirtSegsToGuest, sizeof(RTSGSEG) * cSegsAllocated);
1453 AssertReturn(paVirtSegsToGuest, VERR_NO_MEMORY);
1454 }
1455LogFunc(("Add new post-hdr segment\n"));
1456
1457 /* Append remaining Rx pkt or as much current desc chain has room for */
1458 uint32_t cbLim = RT_MIN(cb, cbDescChainLeft);
1459 paVirtSegsToGuest[cSegs].cbSeg = cbLim;
1460 paVirtSegsToGuest[cSegs++].pvSeg = ((uint8_t *)pvBuf) + uOffset;
1461 uOffset += cbLim;
1462 cDescs++;
1463
1464 RTSgBufInit(pVirtSegBufToGuest, paVirtSegsToGuest, cSegs);
1465//if (pThis->fLog)
1466// RT_BREAKPOINT();
1467 Log7Func(("Send Rx pkt to guest...\n"));
1468 virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(idxQueue),
1469 pVirtSegBufToGuest, pDescChain, true);
1470
1471 if (FEATURE_DISABLED(MRG_RXBUF))
1472 break;
1473 }
1474
1475 /* Fix-up pkthdr (in guest phys. memory) with number buffers (descriptors) processed */
1476
1477 int rc = PDMDevHlpPCIPhysWrite(pDevIns, gcPhysPktHdrNumBuffers, &cDescs, sizeof(cDescs));
1478 AssertMsgRCReturn(rc,
1479 ("Failure updating descriptor count in pkt hdr in guest physical memory\n"),
1480 rc);
1481
1482 virtioCoreQueueSync(pDevIns, &pThis->Virtio, RXQIDX_QPAIR(idxQueue));
1483
1484// for (int i = 0; i < cSegs; i++)
1485// RTMemFree(paVirtSegsToGuest[i].pvSeg);
1486
1487 RTMemFree(paVirtSegsToGuest);
1488 RTMemFree(pVirtSegBufToGuest);
1489
1490 Log7(("\n"));
1491 if (uOffset < cb)
1492 {
1493 LogFunc(("%s Packet did not fit into RX queue (packet size=%u)!\n", INSTANCE(pThis), cb));
1494 return VERR_TOO_MUCH_DATA;
1495 }
1496pThis->fLog = false;
1497 return VINF_SUCCESS;
1498}
1499
1500/**
1501 * @interface_method_impl{PDMINETWORKDOWN,pfnReceiveGso}
1502 */
1503static DECLCALLBACK(int) virtioNetR3NetworkDown_ReceiveGso(PPDMINETWORKDOWN pInterface, const void *pvBuf,
1504 size_t cb, PCPDMNETWORKGSO pGso)
1505{
1506 PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkDown);
1507 PPDMDEVINS pDevIns = pThisCC->pDevIns;
1508 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
1509
1510 if (!pThis->fVirtioReady)
1511 {
1512 LogRelFunc(("VirtIO not ready, aborting downstream receive\n"));
1513 return VERR_INTERRUPTED;
1514 }
1515 if (pThis->fQuiescing)
1516 {
1517 LogRelFunc(("Quiescing I/O for suspend or power off, aborting downstream receive\n"));
1518 return VERR_INTERRUPTED;
1519 }
1520
1521 if (pGso)
1522 {
1523 uint32_t uFeatures = pThis->fNegotiatedFeatures;
1524
1525 switch (pGso->u8Type)
1526 {
1527 case PDMNETWORKGSOTYPE_IPV4_TCP:
1528 uFeatures &= VIRTIONET_F_GUEST_TSO4;
1529 break;
1530 case PDMNETWORKGSOTYPE_IPV6_TCP:
1531 uFeatures &= VIRTIONET_F_GUEST_TSO6;
1532 break;
1533 case PDMNETWORKGSOTYPE_IPV4_UDP:
1534 case PDMNETWORKGSOTYPE_IPV6_UDP:
1535 uFeatures &= VIRTIONET_F_GUEST_UFO;
1536 break;
1537 default:
1538 uFeatures = 0;
1539 break;
1540 }
1541 if (!uFeatures)
1542 {
1543 Log2Func(("GSO type (0x%x) not supported\n", INSTANCE(pThis), pGso->u8Type));
1544 return VERR_NOT_SUPPORTED;
1545 }
1546 }
1547
1548 Log10Func(("%s pvBuf=%p cb=%3u pGso=%p ...", INSTANCE(pThis), pvBuf, cb, pGso));
1549
1550 /** @todo If we ever start using more than one Rx/Tx queue pair, is a random queue
1551 selection algorithm feasible or even necessary to prevent starvation? */
1552
1553 for (int idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue += 2) /* Skip odd queue #'s because Rx queues only */
1554 {
1555 if (RT_SUCCESS(!virtioNetR3IsRxQueuePrimed(pDevIns, pThis, idxQueue)))
1556 {
1557 /* Drop packets if VM is not running or cable is disconnected. */
1558 if (!virtioNetAllSystemsGo(pThis, pDevIns) || !IS_LINK_UP(pThis))
1559 return VINF_SUCCESS;
1560
1561 virtioNetR3SetReadLed(pThisCC, true);
1562
1563 int rc = VINF_SUCCESS;
1564 if (virtioNetR3AddressFilter(pThis, pvBuf, cb))
1565 rc = virtioNetR3HandleRxPacket(pDevIns, pThis, pThisCC, pvBuf, cb, pGso, idxQueue);
1566
1567 virtioNetR3SetReadLed(pThisCC, false);
1568
1569 return rc;
1570 }
1571 }
1572 return VERR_INTERRUPTED;
1573}
1574
1575/**
1576 * @interface_method_impl{PDMINETWORKDOWN,pfnReceive}
1577 */
1578static DECLCALLBACK(int) virtioNetR3NetworkDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
1579{
1580 return virtioNetR3NetworkDown_ReceiveGso(pInterface, pvBuf, cb, NULL);
1581}
1582
1583/* Read physical bytes from the out segment(s) of descriptor chain */
1584static void virtioNetR3PullChain(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIO_DESC_CHAIN_T pDescChain, void *pv, uint16_t cb)
1585{
1586 uint8_t *pb = (uint8_t *)pv;
1587 uint16_t cbLim = RT_MIN(pDescChain->cbPhysSend, cb);
1588 while (cbLim)
1589 {
1590 size_t cbSeg = cbLim;
1591 RTGCPHYS GCPhys = virtioCoreSgBufGetNextSegment(pDescChain->pSgPhysSend, &cbSeg);
1592 PDMDevHlpPCIPhysRead(pDevIns, GCPhys, pb, cbSeg);
1593 pb += cbSeg;
1594 cbLim -= cbSeg;
1595 pDescChain->cbPhysSend -= cbSeg;
1596 }
1597 LogFunc(("%s Pulled %d/%d bytes from desc chain (%d bytes left)\n",
1598 INSTANCE(pThis), cb - cbLim, cb, pDescChain->cbPhysSend));
1599}
1600
1601static uint8_t virtioNetR3CtrlRx(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
1602 PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
1603{
1604
1605#define LOG_VIRTIONET_FLAG(fld) LogFunc(("%s Setting %s=%d\n", INSTANCE(pThis), #fld, pThis->fld))
1606
1607 LogFunc(("%s Processing CTRL Rx command\n", INSTANCE(pThis)));
1608 switch(pCtrlPktHdr->uCmd)
1609 {
1610 case VIRTIONET_CTRL_RX_PROMISC:
1611 break;
1612 case VIRTIONET_CTRL_RX_ALLMULTI:
1613 break;
1614 case VIRTIONET_CTRL_RX_ALLUNI:
1615 /* fallthrough */
1616 case VIRTIONET_CTRL_RX_NOMULTI:
1617 /* fallthrough */
1618 case VIRTIONET_CTRL_RX_NOUNI:
1619 /* fallthrough */
1620 case VIRTIONET_CTRL_RX_NOBCAST:
1621 AssertMsgReturn(FEATURE_ENABLED(CTRL_RX_EXTRA),
1622 ("CTRL 'extra' cmd w/o VIRTIONET_F_CTRL_RX_EXTRA feature negotiated - skipping\n"),
1623 VIRTIONET_ERROR);
1624 /* fall out */
1625 }
1626
1627 uint8_t fOn, fPromiscChanged = false;
1628 virtioNetR3PullChain(pDevIns, pThis, pDescChain, &fOn, RT_MIN(pDescChain->cbPhysSend, sizeof(fOn)));
1629
1630 switch(pCtrlPktHdr->uCmd)
1631 {
1632 case VIRTIONET_CTRL_RX_PROMISC:
1633 pThis->fPromiscuous = !!fOn;
1634 fPromiscChanged = true;
1635 LOG_VIRTIONET_FLAG(fPromiscuous);
1636 break;
1637 case VIRTIONET_CTRL_RX_ALLMULTI:
1638 pThis->fAllMulticast = !!fOn;
1639 fPromiscChanged = true;
1640 LOG_VIRTIONET_FLAG(fAllMulticast);
1641 break;
1642 case VIRTIONET_CTRL_RX_ALLUNI:
1643 pThis->fAllUnicast = !!fOn;
1644 LOG_VIRTIONET_FLAG(fAllUnicast);
1645 break;
1646 case VIRTIONET_CTRL_RX_NOMULTI:
1647 pThis->fNoMulticast = !!fOn;
1648 LOG_VIRTIONET_FLAG(fNoMulticast);
1649 break;
1650 case VIRTIONET_CTRL_RX_NOUNI:
1651 pThis->fNoUnicast = !!fOn;
1652 LOG_VIRTIONET_FLAG(fNoUnicast);
1653 break;
1654 case VIRTIONET_CTRL_RX_NOBCAST:
1655 pThis->fNoBroadcast = !!fOn;
1656 LOG_VIRTIONET_FLAG(fNoBroadcast);
1657 break;
1658 }
1659
1660 if (pThisCC->pDrv && fPromiscChanged)
1661 {
1662 uint8_t fPromiscuous = pThis->fPromiscuous | pThis->fAllMulticast;
1663 pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, fPromiscuous);
1664 }
1665
1666 return VIRTIONET_OK;
1667}
1668
1669static uint8_t virtioNetR3CtrlMac(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
1670 PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
1671{
1672 LogFunc(("%s Processing CTRL MAC command\n", INSTANCE(pThis)));
1673
1674 RT_NOREF(pThisCC);
1675
1676#define ASSERT_CTRL_ADDR_SET(v) \
1677 AssertMsgReturn((v), ("DESC chain too small to process CTRL_MAC_ADDR_SET cmd\n"), VIRTIONET_ERROR)
1678
1679#define ASSERT_CTRL_TABLE_SET(v) \
1680 AssertMsgReturn((v), ("DESC chain too small to process CTRL_MAC_TABLE_SET cmd\n"), VIRTIONET_ERROR)
1681
1682 AssertMsgReturn(pDescChain->cbPhysSend >= sizeof(*pCtrlPktHdr),
1683 ("insufficient descriptor space for ctrl pkt hdr"),
1684 VIRTIONET_ERROR);
1685
1686 size_t cbRemaining = pDescChain->cbPhysSend;
1687 switch(pCtrlPktHdr->uCmd)
1688 {
1689 case VIRTIONET_CTRL_MAC_ADDR_SET:
1690 {
1691 /* Set default Rx filter MAC */
1692 ASSERT_CTRL_ADDR_SET(cbRemaining >= sizeof(VIRTIONET_CTRL_MAC_TABLE_LEN));
1693 virtioNetR3PullChain(pDevIns, pThis, pDescChain, &pThis->rxFilterMacDefault, sizeof(VIRTIONET_CTRL_MAC_TABLE_LEN));
1694 break;
1695 }
1696 case VIRTIONET_CTRL_MAC_TABLE_SET:
1697 {
1698 VIRTIONET_CTRL_MAC_TABLE_LEN cMacs;
1699
1700 /* Load unicast MAC filter table */
1701 ASSERT_CTRL_TABLE_SET(cbRemaining >= sizeof(cMacs));
1702 virtioNetR3PullChain(pDevIns, pThis, pDescChain, &cMacs, sizeof(cMacs));
1703 cbRemaining -= sizeof(cMacs);
1704 Log7Func(("%s Guest provided %d unicast MAC Table entries\n", INSTANCE(pThis), cMacs));
1705 if (cMacs)
1706 {
1707 uint32_t cbMacs = cMacs * sizeof(RTMAC);
1708 ASSERT_CTRL_TABLE_SET(cbRemaining >= cbMacs);
1709 virtioNetR3PullChain(pDevIns, pThis, pDescChain, &pThis->aMacUnicastFilter, cbMacs);
1710 cbRemaining -= cbMacs;
1711 }
1712 pThis->cUnicastFilterMacs = cMacs;
1713
1714 /* Load multicast MAC filter table */
1715 ASSERT_CTRL_TABLE_SET(cbRemaining >= sizeof(cMacs));
1716 virtioNetR3PullChain(pDevIns, pThis, pDescChain, &cMacs, sizeof(cMacs));
1717 cbRemaining -= sizeof(cMacs);
1718 Log10Func(("%s Guest provided %d multicast MAC Table entries\n", INSTANCE(pThis), cMacs));
1719 if (cMacs)
1720 {
1721 uint32_t cbMacs = cMacs * sizeof(RTMAC);
1722 ASSERT_CTRL_TABLE_SET(cbRemaining >= cbMacs);
1723 virtioNetR3PullChain(pDevIns, pThis, pDescChain, &pThis->aMacMulticastFilter, cbMacs);
1724 cbRemaining -= cbMacs;
1725 }
1726 pThis->cMulticastFilterMacs = cMacs;
1727
1728#ifdef LOG_ENABLED
1729 LogFunc(("%s unicast MACs:\n", INSTANCE(pThis)));
1730 for(unsigned i = 0; i < cMacs; i++)
1731 LogFunc((" %RTmac\n", &pThis->aMacUnicastFilter[i]));
1732
1733 LogFunc(("%s multicast MACs:\n", INSTANCE(pThis)));
1734 for(unsigned i = 0; i < cMacs; i++)
1735 LogFunc((" %RTmac\n", &pThis->aMacMulticastFilter[i]));
1736#endif
1737
1738 }
1739 }
1740 return VIRTIONET_OK;
1741}
1742
1743static uint8_t virtioNetR3CtrlVlan(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
1744 PVIRTIONET_CTRL_HDR_T pCtrlPktHdr, PVIRTIO_DESC_CHAIN_T pDescChain)
1745{
1746 LogFunc(("%s Processing CTRL VLAN command\n", INSTANCE(pThis)));
1747
1748 RT_NOREF(pThisCC);
1749
1750 uint16_t uVlanId;
1751 uint16_t cbRemaining = pDescChain->cbPhysSend - sizeof(*pCtrlPktHdr);
1752 AssertMsgReturn(cbRemaining > sizeof(uVlanId),
1753 ("DESC chain too small for VIRTIO_NET_CTRL_VLAN cmd processing"), VIRTIONET_ERROR);
1754 virtioNetR3PullChain(pDevIns, pThis, pDescChain, &uVlanId, sizeof(uVlanId));
1755 AssertMsgReturn(uVlanId > VIRTIONET_MAX_VLAN_ID,
1756 ("%s VLAN ID out of range (VLAN ID=%u)\n", INSTANCE(pThis), uVlanId), VIRTIONET_ERROR);
1757 LogFunc(("%s uCommand=%u VLAN ID=%u\n", INSTANCE(pThis), pCtrlPktHdr->uCmd, uVlanId));
1758 switch (pCtrlPktHdr->uCmd)
1759 {
1760 case VIRTIONET_CTRL_VLAN_ADD:
1761 ASMBitSet(pThis->aVlanFilter, uVlanId);
1762 break;
1763 case VIRTIONET_CTRL_VLAN_DEL:
1764 ASMBitClear(pThis->aVlanFilter, uVlanId);
1765 break;
1766 default:
1767 return VIRTIONET_ERROR;
1768 }
1769 return VIRTIONET_OK;
1770}
1771
1772static void virtioNetR3Ctrl(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
1773 PVIRTIO_DESC_CHAIN_T pDescChain)
1774{
1775 LogFunc(("%s Received CTRL packet from guest\n", INSTANCE(pThis)));
1776
1777 if (pDescChain->cbPhysSend < 2)
1778 {
1779 LogFunc(("%s CTRL packet from guest driver incomplete. Skipping ctrl cmd\n", INSTANCE(pThis)));
1780 return;
1781 }
1782 else if (pDescChain->cbPhysReturn < sizeof(VIRTIONET_CTRL_HDR_T_ACK))
1783 {
1784 LogFunc(("%s Guest driver didn't allocate memory to receive ctrl pkt ACK. Skipping ctrl cmd\n", INSTANCE(pThis)));
1785 return;
1786 }
1787
1788 /*
1789 * Allocate buffer and read in the control command
1790 */
1791 PVIRTIONET_CTRL_HDR_T pCtrlPktHdr = (PVIRTIONET_CTRL_HDR_T)RTMemAllocZ(sizeof(VIRTIONET_CTRL_HDR_T));
1792
1793 AssertPtrReturnVoid(pCtrlPktHdr);
1794
1795 AssertMsgReturnVoid(pDescChain->cbPhysSend >= sizeof(VIRTIONET_CTRL_HDR_T),
1796 ("DESC chain too small for CTRL pkt header"));
1797
1798 virtioNetR3PullChain(pDevIns, pThis, pDescChain, pCtrlPktHdr,
1799 RT_MIN(pDescChain->cbPhysSend, sizeof(VIRTIONET_CTRL_HDR_T)));
1800
1801 Log7Func(("%s CTRL COMMAND: class=%d command=%d\n", INSTANCE(pThis), pCtrlPktHdr->uClass, pCtrlPktHdr->uCmd));
1802
1803 uint8_t uAck;
1804 switch (pCtrlPktHdr->uClass)
1805 {
1806 case VIRTIONET_CTRL_RX:
1807 uAck = virtioNetR3CtrlRx(pDevIns, pThis, pThisCC, pCtrlPktHdr, pDescChain);
1808 break;
1809 case VIRTIONET_CTRL_MAC:
1810 uAck = virtioNetR3CtrlMac(pDevIns, pThis, pThisCC, pCtrlPktHdr, pDescChain);
1811 break;
1812 case VIRTIONET_CTRL_VLAN:
1813 uAck = virtioNetR3CtrlVlan(pDevIns, pThis, pThisCC, pCtrlPktHdr, pDescChain);
1814 break;
1815 case VIRTIONET_CTRL_ANNOUNCE:
1816 uAck = VIRTIONET_OK;
1817 if (FEATURE_DISABLED(STATUS) || FEATURE_DISABLED(GUEST_ANNOUNCE))
1818 {
1819 LogFunc(("%s Ignoring CTRL class VIRTIONET_CTRL_ANNOUNCE. Not configured to handle it\n", INSTANCE(pThis)));
1820 virtioNetPrintFeatures(pThis, pThis->fNegotiatedFeatures, "Features");
1821 break;
1822 }
1823 if (pCtrlPktHdr->uCmd != VIRTIONET_CTRL_ANNOUNCE_ACK)
1824 {
1825 LogFunc(("%s Ignoring CTRL class VIRTIONET_CTRL_ANNOUNCE. Unrecognized uCmd\n", INSTANCE(pThis)));
1826 break;
1827 }
1828 pThis->virtioNetConfig.uStatus &= ~VIRTIONET_F_ANNOUNCE;
1829 Log7Func(("%s Clearing VIRTIONET_F_ANNOUNCE in config status\n", INSTANCE(pThis)));
1830 break;
1831
1832 default:
1833 LogRelFunc(("Unrecognized CTRL pkt hdr class (%d)\n", pCtrlPktHdr->uClass));
1834 uAck = VIRTIONET_ERROR;
1835 }
1836
1837 /* Currently CTRL pkt header just returns ack, but keeping segment logic generic/flexible
1838 * in case that changes to make adapting more straightforward */
1839 int cSegs = 1;
1840
1841 /* Return CTRL packet Ack byte (result code) to guest driver */
1842 PRTSGSEG paReturnSegs = (PRTSGSEG)RTMemAllocZ(sizeof(RTSGSEG));
1843 AssertMsgReturnVoid(paReturnSegs, ("Out of memory"));
1844
1845 RTSGSEG aStaticSegs[] = { { &uAck, sizeof(uAck) } };
1846 memcpy(paReturnSegs, aStaticSegs, sizeof(RTSGSEG));
1847
1848 PRTSGBUF pReturnSegBuf = (PRTSGBUF)RTMemAllocZ(sizeof(RTSGBUF));
1849 AssertMsgReturnVoid(pReturnSegBuf, ("Out of memory"));
1850
1851 /* Copy segment data to malloc'd memory to avoid stack out-of-scope errors sanitizer doesn't detect */
1852 for (int i = 0; i < cSegs; i++)
1853 {
1854 void *pv = paReturnSegs[i].pvSeg;
1855 paReturnSegs[i].pvSeg = RTMemAlloc(aStaticSegs[i].cbSeg);
1856 AssertMsgReturnVoid(paReturnSegs[i].pvSeg, ("Out of memory"));
1857 memcpy(paReturnSegs[i].pvSeg, pv, aStaticSegs[i].cbSeg);
1858 }
1859
1860 RTSgBufInit(pReturnSegBuf, paReturnSegs, cSegs);
1861
1862 virtioCoreR3QueuePut(pDevIns, &pThis->Virtio, CTRLQIDX, pReturnSegBuf, pDescChain, true);
1863 virtioCoreQueueSync(pDevIns, &pThis->Virtio, CTRLQIDX);
1864
1865 for (int i = 0; i < cSegs; i++)
1866 RTMemFree(paReturnSegs[i].pvSeg);
1867
1868 RTMemFree(paReturnSegs);
1869 RTMemFree(pReturnSegBuf);
1870
1871 LogFunc(("%s Finished processing CTRL command with status %s\n",
1872 INSTANCE(pThis), uAck == VIRTIONET_OK ? "VIRTIONET_OK" : "VIRTIONET_ERROR"));
1873
1874}
1875
1876static bool virtioNetR3ReadHeader(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, PVIRTIONET_PKT_HDR_T pPktHdr, uint32_t cbMax)
1877{
1878 int rc = PDMDevHlpPCIPhysRead(pDevIns, GCPhys, pPktHdr, sizeof(*pPktHdr));
1879 if (RT_FAILURE(rc))
1880 return false;
1881
1882 Log4(("virtio-net: header flags=%x gso-type=%x len=%x gso-size=%x Chksum-start=%x Chksum-offset=%x cb=%x\n",
1883 pPktHdr->uFlags, pPktHdr->uGsoType, pPktHdr->uHdrLen,
1884 pPktHdr->uGsoSize, pPktHdr->uChksumStart, pPktHdr->uChksumOffset, cbMax));
1885
1886 if (pPktHdr->uGsoType)
1887 {
1888 uint32_t uMinHdrSize;
1889
1890 /* Segmentation offloading cannot be done without checksumming, and we do not support ECN */
1891 if ( RT_UNLIKELY(!(pPktHdr->uFlags & VIRTIONET_HDR_F_NEEDS_CSUM))
1892 | RT_UNLIKELY(pPktHdr->uGsoType & VIRTIONET_HDR_GSO_ECN))
1893 return false;
1894
1895 switch (pPktHdr->uGsoType)
1896 {
1897 case VIRTIONET_HDR_GSO_TCPV4:
1898 case VIRTIONET_HDR_GSO_TCPV6:
1899 uMinHdrSize = sizeof(RTNETTCP);
1900 break;
1901 case VIRTIONET_HDR_GSO_UDP:
1902 uMinHdrSize = 0;
1903 break;
1904 default:
1905 return false;
1906 }
1907 /* Header + MSS must not exceed the packet size. */
1908 if (RT_UNLIKELY(uMinHdrSize + pPktHdr->uChksumStart + pPktHdr->uGsoSize > cbMax))
1909 return false;
1910 }
1911 /* Checksum must fit into the frame (validating both checksum fields). */
1912 if (( pPktHdr->uFlags & VIRTIONET_HDR_F_NEEDS_CSUM)
1913 && sizeof(uint16_t) + pPktHdr->uChksumStart + pPktHdr->uChksumOffset > cbMax)
1914 return false;
1915 Log4Func(("returning true\n"));
1916 return true;
1917}
1918
1919static int virtioNetR3TransmitFrame(PVIRTIONET pThis, PVIRTIONETCC pThisCC, PPDMSCATTERGATHER pSgBuf,
1920 PPDMNETWORKGSO pGso, PVIRTIONET_PKT_HDR_T pPktHdr)
1921{
1922LogFunc(("\n"));
1923 virtioNetR3PacketDump(pThis, (uint8_t *)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, "--> Outgoing");
1924 if (pGso)
1925 {
1926 /* Some guests (RHEL) may report HdrLen excluding transport layer header! */
1927 /*
1928 * We cannot use cdHdrs provided by the guest because of different ways
1929 * it gets filled out by different versions of kernels.
1930 */
1931 //if (pGso->cbHdrs < pPktHdr->uCSumStart + pPktHdr->uCSumOffset + 2)
1932 {
1933 Log4Func(("%s HdrLen before adjustment %d.\n",
1934 INSTANCE(pThis), pGso->cbHdrsTotal));
1935 switch (pGso->u8Type)
1936 {
1937 case PDMNETWORKGSOTYPE_IPV4_TCP:
1938 case PDMNETWORKGSOTYPE_IPV6_TCP:
1939 pGso->cbHdrsTotal = pPktHdr->uChksumStart +
1940 ((PRTNETTCP)(((uint8_t*)pSgBuf->aSegs[0].pvSeg) + pPktHdr->uChksumStart))->th_off * 4;
1941 pGso->cbHdrsSeg = pGso->cbHdrsTotal;
1942 break;
1943 case PDMNETWORKGSOTYPE_IPV4_UDP:
1944 pGso->cbHdrsTotal = (uint8_t)(pPktHdr->uChksumStart + sizeof(RTNETUDP));
1945 pGso->cbHdrsSeg = pPktHdr->uChksumStart;
1946 break;
1947 }
1948 /* Update GSO structure embedded into the frame */
1949 ((PPDMNETWORKGSO)pSgBuf->pvUser)->cbHdrsTotal = pGso->cbHdrsTotal;
1950 ((PPDMNETWORKGSO)pSgBuf->pvUser)->cbHdrsSeg = pGso->cbHdrsSeg;
1951 Log4Func(("%s adjusted HdrLen to %d.\n",
1952 INSTANCE(pThis), pGso->cbHdrsTotal));
1953 }
1954 Log2Func(("%s gso type=%x cbHdrsTotal=%u cbHdrsSeg=%u mss=%u off1=0x%x off2=0x%x\n",
1955 INSTANCE(pThis), pGso->u8Type, pGso->cbHdrsTotal, pGso->cbHdrsSeg,
1956 pGso->cbMaxSeg, pGso->offHdr1, pGso->offHdr2));
1957 }
1958 else if (pPktHdr->uFlags & VIRTIONET_HDR_F_NEEDS_CSUM)
1959 {
1960 /*
1961 * This is not GSO frame but checksum offloading is requested.
1962 */
1963 virtioNetR3CompleteChecksum((uint8_t*)pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed,
1964 pPktHdr->uChksumStart, pPktHdr->uChksumOffset);
1965 }
1966
1967 return pThisCC->pDrv->pfnSendBuf(pThisCC->pDrv, pSgBuf, false);
1968}
1969
1970static void virtioNetR3TransmitPendingPackets(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC,
1971 uint16_t idxQueue, bool fOnWorkerThread)
1972{
1973
1974LogFunc(("\n"));
1975 PVIRTIOCORE pVirtio = &pThis->Virtio;
1976
1977 /*
1978 * Only one thread is allowed to transmit at a time, others should skip
1979 * transmission as the packets will be picked up by the transmitting
1980 * thread.
1981 */
1982 if (!ASMAtomicCmpXchgU32(&pThis->uIsTransmitting, 1, 0))
1983 return;
1984
1985 if (!pThis->fVirtioReady)
1986 {
1987 LogFunc(("%s Ignoring Tx requests. VirtIO not ready (status=0x%x).\n",
1988 INSTANCE(pThis), pThis->virtioNetConfig.uStatus));
1989 return;
1990 }
1991
1992 if (!pThis->fCableConnected)
1993 {
1994 Log(("%s Ignoring transmit requests while cable is disconnected.\n", INSTANCE(pThis)));
1995 return;
1996 }
1997
1998 PPDMINETWORKUP pDrv = pThisCC->pDrv;
1999 if (pDrv)
2000 {
2001 int rc = pDrv->pfnBeginXmit(pDrv, fOnWorkerThread);
2002 Assert(rc == VINF_SUCCESS || rc == VERR_TRY_AGAIN);
2003 if (rc == VERR_TRY_AGAIN)
2004 {
2005 ASMAtomicWriteU32(&pThis->uIsTransmitting, 0);
2006 return;
2007 }
2008 }
2009
2010 unsigned int cbPktHdr = sizeof(VIRTIONET_PKT_HDR_T);
2011
2012 int cPkts = virtioCoreR3QueuePendingCount(pVirtio->pDevIns, pVirtio, idxQueue);
2013 if (!cPkts)
2014 {
2015 LogFunc(("%s No packets to send found on %s\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2016
2017 if (pDrv)
2018 pDrv->pfnEndXmit(pDrv);
2019
2020 ASMAtomicWriteU32(&pThis->uIsTransmitting, 0);
2021 return;
2022 }
2023 LogFunc(("%s About to transmit %d pending packets\n", INSTANCE(pThis), cPkts));
2024
2025 virtioNetR3SetWriteLed(pThisCC, true);
2026
2027 int rc;
2028 PVIRTIO_DESC_CHAIN_T pDescChain;
2029 while ((rc = virtioCoreR3QueuePeek(pVirtio->pDevIns, pVirtio, idxQueue, &pDescChain)))
2030 {
2031 if (RT_SUCCESS(rc))
2032 Log10Func(("%s fetched descriptor chain from %s\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2033 else
2034 {
2035 LogFunc(("%s failed to find expected data on %s, rc = %Rrc\n", INSTANCE(pThis), VIRTQNAME(idxQueue), rc));
2036 break;
2037 }
2038
2039 uint32_t cSegsFromGuest = pDescChain->pSgPhysSend->cSegs;
2040 PVIRTIOSGSEG paSegsFromGuest = pDescChain->pSgPhysSend->paSegs;
2041
2042 if (cSegsFromGuest < 2 || paSegsFromGuest[0].cbSeg != cbPktHdr)
2043 {
2044 /* This check could be made more complex, because in theory (but not likely nor
2045 * seen in practice) the first segment could contain header and data. */
2046 LogFunc(("%s The first segment is not the header! (%u < 2 || %u != %u).\n",
2047 INSTANCE(pThis), cSegsFromGuest, paSegsFromGuest[0].cbSeg, cbPktHdr));
2048 break;
2049 }
2050
2051 VIRTIONET_PKT_HDR_T PktHdr;
2052 uint32_t uSize = 0;
2053
2054 /* Compute total frame size. */
2055 for (unsigned i = 1; i < cSegsFromGuest && uSize < VIRTIONET_MAX_FRAME_SIZE; i++)
2056 uSize += paSegsFromGuest[i].cbSeg;
2057
2058 Log5Func(("%s complete frame is %u bytes.\n", INSTANCE(pThis), uSize));
2059 Assert(uSize <= VIRTIONET_MAX_FRAME_SIZE);
2060
2061 /* Truncate oversized frames. */
2062 if (uSize > VIRTIONET_MAX_FRAME_SIZE)
2063 uSize = VIRTIONET_MAX_FRAME_SIZE;
2064
2065 if (pThisCC->pDrv && virtioNetR3ReadHeader(pDevIns, paSegsFromGuest[0].gcPhys, &PktHdr, uSize))
2066 {
2067 PDMNETWORKGSO Gso, *pGso = virtioNetR3SetupGsoCtx(&Gso, &PktHdr);
2068
2069 /** @todo Optimize away the extra copying! (lazy bird) */
2070 PPDMSCATTERGATHER pSgBufToPdmLeafDevice;
2071 rc = pThisCC->pDrv->pfnAllocBuf(pThisCC->pDrv, uSize, pGso, &pSgBufToPdmLeafDevice);
2072 if (RT_SUCCESS(rc))
2073 {
2074 pSgBufToPdmLeafDevice->cbUsed = uSize;
2075
2076 /* Assemble a complete frame. */
2077 for (unsigned i = 1; i < cSegsFromGuest && uSize > 0; i++)
2078 {
2079 unsigned uOffset;
2080 unsigned cbSeg = RT_MIN(uSize, paSegsFromGuest[i].cbSeg);
2081
2082 PDMDevHlpPCIPhysRead(pDevIns, paSegsFromGuest[i].gcPhys,
2083 ((uint8_t *)pSgBufToPdmLeafDevice->aSegs[0].pvSeg) + uOffset,
2084 cbSeg);
2085 uOffset += cbSeg;
2086 uSize -= cbSeg;
2087 }
2088 rc = virtioNetR3TransmitFrame(pThis, pThisCC, pSgBufToPdmLeafDevice, pGso, &PktHdr);
2089 if (RT_FAILURE(rc))
2090 {
2091 LogFunc(("%s Failed to transmit frame, rc = %Rrc\n", INSTANCE(pThis), rc));
2092 pThisCC->pDrv->pfnFreeBuf(pThisCC->pDrv, pSgBufToPdmLeafDevice);
2093 }
2094 }
2095 else
2096 {
2097 Log4Func(("Failed to allocate S/G buffer: size=%u rc=%Rrc\n", uSize, rc));
2098 /* Stop trying to fetch TX descriptors until we get more bandwidth. */
2099 break;
2100 }
2101 }
2102 /* Remove this descriptor chain from the available ring */
2103 virtioCoreR3QueueSkip(pVirtio, idxQueue);
2104
2105 /* No data to return to guest, but call is needed put elem (e.g. desc chain) on used ring */
2106 virtioCoreR3QueuePut(pVirtio->pDevIns, pVirtio, idxQueue, NULL, pDescChain, false);
2107
2108 virtioCoreQueueSync(pVirtio->pDevIns, pVirtio, idxQueue);
2109
2110 }
2111 virtioNetR3SetWriteLed(pThisCC, false);
2112
2113 if (pDrv)
2114 pDrv->pfnEndXmit(pDrv);
2115
2116 ASMAtomicWriteU32(&pThis->uIsTransmitting, 0);
2117}
2118
2119/**
2120 * @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
2121 */
2122static DECLCALLBACK(void) virtioNetR3NetworkDown_XmitPending(PPDMINETWORKDOWN pInterface)
2123{
2124 LogFunc(("\n"));
2125 PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkDown);
2126 PPDMDEVINS pDevIns = pThisCC->pDevIns;
2127 PVIRTIONET pThis = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIONET);
2128
2129 /** @todo If we ever start using more than one Rx/Tx queue pair, is a random queue
2130 selection algorithm feasible or even necessary */
2131 virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC, TXQIDX_QPAIR(0), false /*fOnWorkerThread*/);
2132}
2133
2134/**
2135 * @callback_method_impl{VIRTIOCORER3,pfnQueueNotified}
2136 */
2137static DECLCALLBACK(void) virtioNetR3QueueNotified(PVIRTIOCORE pVirtio, PVIRTIOCORECC pVirtioCC, uint16_t idxQueue)
2138{
2139 PVIRTIONET pThis = RT_FROM_MEMBER(pVirtio, VIRTIONET, Virtio);
2140 PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pVirtioCC, VIRTIONETCC, Virtio);
2141 PPDMDEVINS pDevIns = pThisCC->pDevIns;
2142 PVIRTIONETWORKER pWorker = &pThis->aWorkers[idxQueue];
2143 PVIRTIONETWORKERR3 pWorkerR3 = &pThisCC->aWorkers[idxQueue];
2144 AssertReturnVoid(idxQueue < pThis->cVirtQueues);
2145
2146#ifdef LOG_ENABLED
2147 RTLogFlush(NULL);
2148#endif
2149
2150 Log10Func(("%s %s has available buffers\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2151
2152 if (IS_RX_QUEUE(idxQueue))
2153 {
2154 Log10Func(("%s Receive buffers have been added, waking Rx thread.\n",
2155 INSTANCE(pThis)));
2156 virtioNetR3WakeupRxBufWaiter(pDevIns);
2157 }
2158 else
2159 {
2160 /* Wake queue's worker thread up if sleeping */
2161 if (!ASMAtomicXchgBool(&pWorkerR3->fNotified, true))
2162 {
2163 if (ASMAtomicReadBool(&pWorkerR3->fSleeping))
2164 {
2165 Log10Func(("%s waking %s worker.\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2166 int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
2167 AssertRC(rc);
2168 }
2169 }
2170 }
2171}
2172
2173/**
2174 * @callback_method_impl{FNPDMTHREADDEV}
2175 */
2176static DECLCALLBACK(int) virtioNetR3WorkerThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
2177{
2178 uint16_t const idxQueue = (uint16_t)(uintptr_t)pThread->pvUser;
2179 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
2180 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
2181 PVIRTIONETWORKER pWorker = &pThis->aWorkers[idxQueue];
2182 PVIRTIONETWORKERR3 pWorkerR3 = &pThisCC->aWorkers[idxQueue];
2183 if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
2184 {
2185 return VINF_SUCCESS;
2186 }
2187 LogFunc(("%s %s\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2188 while (pThread->enmState == PDMTHREADSTATE_RUNNING)
2189 {
2190 virtioCoreQueueSetNotify(&pThis->Virtio, idxQueue, true);
2191
2192 if (virtioCoreQueueIsEmpty(pDevIns, &pThis->Virtio, idxQueue))
2193 {
2194 /* Atomic interlocks avoid missing alarm while going to sleep & notifier waking the awoken */
2195 ASMAtomicWriteBool(&pWorkerR3->fSleeping, true);
2196 bool fNotificationSent = ASMAtomicXchgBool(&pWorkerR3->fNotified, false);
2197 if (!fNotificationSent)
2198 {
2199 Log10Func(("%s %s worker sleeping...\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2200 Assert(ASMAtomicReadBool(&pWorkerR3->fSleeping));
2201 int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pWorker->hEvtProcess, RT_INDEFINITE_WAIT);
2202 AssertLogRelMsgReturn(RT_SUCCESS(rc) || rc == VERR_INTERRUPTED, ("%Rrc\n", rc), rc);
2203 if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
2204 return VINF_SUCCESS;
2205 if (rc == VERR_INTERRUPTED)
2206 {
2207 virtioCoreQueueSetNotify(&pThis->Virtio, idxQueue, false);
2208 continue;
2209 }
2210 Log10Func(("%s %s worker woken\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2211 ASMAtomicWriteBool(&pWorkerR3->fNotified, false);
2212 }
2213 ASMAtomicWriteBool(&pWorkerR3->fSleeping, false);
2214 }
2215 virtioCoreQueueSetNotify(&pThis->Virtio, idxQueue, false);
2216
2217 /* Dispatch to the handler for the queue this worker is set up to drive */
2218
2219 if (!pThisCC->fQuiescing)
2220 {
2221 if (IS_CTRL_QUEUE(idxQueue))
2222 {
2223 Log10Func(("%s fetching next descriptor chain from %s\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2224 PVIRTIO_DESC_CHAIN_T pDescChain;
2225 int rc = virtioCoreR3QueueGet(pDevIns, &pThis->Virtio, idxQueue, &pDescChain, true);
2226 if (rc == VERR_NOT_AVAILABLE)
2227 {
2228 Log10Func(("%s Nothing found in %s\n", INSTANCE(pThis), VIRTQNAME(idxQueue)));
2229 continue;
2230 }
2231 virtioNetR3Ctrl(pDevIns, pThis, pThisCC, pDescChain);
2232 }
2233 else if (IS_TX_QUEUE(idxQueue))
2234 {
2235LogFunc(("Worker thread notified of pending Xmit packets!!!!!!\n"));
2236 Log10Func(("%s Notified of data to transmit\n", INSTANCE(pThis)));
2237 virtioNetR3TransmitPendingPackets(pDevIns, pThis, pThisCC,
2238 idxQueue, true /* fOnWorkerThread */);
2239 }
2240
2241 /* Rx queues aren't handled by our worker threads. Instead, the PDM network
2242 * leaf driver invokes PDMINETWORKDOWN.pfnWaitReceiveAvail() callback,
2243 * which waits until notified directly by virtioNetR3QueueNotified()
2244 * that guest IN buffers have been added to receive virt queue. */
2245 }
2246 }
2247 return VINF_SUCCESS;
2248}
2249
2250DECLINLINE(int) virtioNetR3CsEnter(PPDMDEVINS pDevIns, PVIRTIONET pThis, int rcBusy)
2251{
2252 RT_NOREF(pDevIns, pThis, rcBusy);
2253 /* Original DevVirtioNet uses CS in attach/detach/link-up timer/tx timer/transmit */
2254 LogFunc(("%s CS unimplemented. What does the critical section protect in orig driver??", INSTANCE(pThis)));
2255 return VINF_SUCCESS;
2256}
2257
2258DECLINLINE(void) virtioNetR3CsLeave(PPDMDEVINS pDevIns, PVIRTIONET pThis)
2259{
2260 RT_NOREF(pDevIns, pThis);
2261 LogFunc(("%s CS unimplemented. What does the critical section protect in orig driver??", INSTANCE(pThis)));
2262}
2263
2264
2265/**
2266 * @callback_method_impl{FNTMTIMERDEV, Link Up Timer handler.}
2267 */
2268static DECLCALLBACK(void) virtioNetR3LinkUpTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
2269{
2270 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
2271 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
2272 RT_NOREF(pTimer, pvUser);
2273
2274 int rc = virtioNetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
2275 AssertRCReturnVoid(rc);
2276
2277 SET_LINK_UP(pThis);
2278
2279 virtioNetR3WakeupRxBufWaiter(pDevIns);
2280
2281 virtioNetR3CsLeave(pDevIns, pThis);
2282
2283 LogFunc(("%s Link is up\n", INSTANCE(pThis)));
2284
2285 if (pThisCC->pDrv)
2286 pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, PDMNETWORKLINKSTATE_UP);
2287}
2288
2289/**
2290 * Takes down the link temporarily if it's current status is up.
2291 *
2292 * This is used during restore and when replumbing the network link.
2293 *
2294 * The temporary link outage is supposed to indicate to the OS that all network
2295 * connections have been lost and that it for instance is appropriate to
2296 * renegotiate any DHCP lease.
2297 *
2298 * @param pDevIns The device instance.
2299 * @param pThis The virtio-net shared instance data.
2300 * @param pThisCC The virtio-net ring-3 instance data.
2301 */
2302static void virtioNetR3TempLinkDown(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
2303{
2304 if (IS_LINK_UP(pThis))
2305 {
2306 SET_LINK_DOWN(pThis);
2307
2308 /* Restore the link back in 5 seconds. */
2309 int rc = PDMDevHlpTimerSetMillies(pDevIns, pThisCC->hLinkUpTimer, pThis->cMsLinkUpDelay);
2310 AssertRC(rc);
2311
2312 LogFunc(("%s Link is down temporarily\n", INSTANCE(pThis)));
2313 }
2314}
2315
2316/**
2317 * @interface_method_impl{PDMINETWORKCONFIG,pfnGetLinkState}
2318 */
2319static DECLCALLBACK(PDMNETWORKLINKSTATE) virtioNetR3NetworkConfig_GetLinkState(PPDMINETWORKCONFIG pInterface)
2320{
2321 PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkConfig);
2322 PVIRTIONET pThis = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIONET);
2323
2324 return IS_LINK_UP(pThis) ? PDMNETWORKLINKSTATE_UP : PDMNETWORKLINKSTATE_DOWN;
2325}
2326
2327/**
2328 * @interface_method_impl{PDMINETWORKCONFIG,pfnSetLinkState}
2329 */
2330static DECLCALLBACK(int) virtioNetR3NetworkConfig_SetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
2331{
2332 PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, INetworkConfig);
2333 PPDMDEVINS pDevIns = pThisCC->pDevIns;
2334 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
2335
2336 bool fCachedLinkIsUp = IS_LINK_UP(pThis);
2337 bool fActiveLinkIsUp = (enmState == PDMNETWORKLINKSTATE_UP);
2338
2339 Log7Func(("%s enmState=%d\n", INSTANCE(pThis), enmState));
2340 if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME)
2341 {
2342 if (fCachedLinkIsUp)
2343 {
2344 /*
2345 * We bother to bring the link down only if it was up previously. The UP link state
2346 * notification will be sent when the link actually goes up in virtioNetR3LinkUpTimer().
2347 */
2348 virtioNetR3TempLinkDown(pDevIns, pThis, pThisCC);
2349 if (pThisCC->pDrv)
2350 pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
2351 }
2352 }
2353 else if (fActiveLinkIsUp != fCachedLinkIsUp)
2354 {
2355 if (fCachedLinkIsUp)
2356 {
2357 Log(("%s Link is up\n", INSTANCE(pThis)));
2358 pThis->fCableConnected = true;
2359 SET_LINK_UP(pThis);
2360 virtioCoreNotifyConfigChanged(&pThis->Virtio);
2361 }
2362 else /* cached Link state is down */
2363 {
2364 /* The link was brought down explicitly, make sure it won't come up by timer. */
2365 PDMDevHlpTimerStop(pDevIns, pThisCC->hLinkUpTimer);
2366 Log(("%s Link is down\n", INSTANCE(pThis)));
2367 pThis->fCableConnected = false;
2368 SET_LINK_DOWN(pThis);
2369 virtioCoreNotifyConfigChanged(&pThis->Virtio);
2370 }
2371 if (pThisCC->pDrv)
2372 pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState);
2373 }
2374 return VINF_SUCCESS;
2375}
2376
2377static int virtioNetR3DestroyWorkerThreads(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
2378{
2379 Log10Func(("%s\n", INSTANCE(pThis)));
2380 int rc = VINF_SUCCESS;
2381 for (unsigned idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
2382 {
2383 PVIRTIONETWORKER pWorker = &pThis->aWorkers[idxQueue];
2384 if (pWorker->hEvtProcess != NIL_SUPSEMEVENT)
2385 {
2386 PDMDevHlpSUPSemEventClose(pDevIns, pWorker->hEvtProcess);
2387 pWorker->hEvtProcess = NIL_SUPSEMEVENT;
2388 }
2389 if (pThisCC->aWorkers[idxQueue].pThread)
2390 {
2391 int rcThread;
2392 rc = PDMDevHlpThreadDestroy(pDevIns, pThisCC->aWorkers[idxQueue].pThread, &rcThread);
2393 if (RT_FAILURE(rc) || RT_FAILURE(rcThread))
2394 AssertMsgFailed(("%s Failed to destroythread rc=%Rrc rcThread=%Rrc\n", __FUNCTION__, rc, rcThread));
2395 pThisCC->aWorkers[idxQueue].pThread = NULL;
2396 }
2397 }
2398 return rc;
2399}
2400
2401static int virtioNetR3CreateWorkerThreads(PPDMDEVINS pDevIns, PVIRTIONET pThis, PVIRTIONETCC pThisCC)
2402{
2403 Log10Func(("%s\n", INSTANCE(pThis)));
2404 int rc = VINF_SUCCESS;
2405 /* Attach the queues and create worker threads for them: */
2406 for (uint16_t idxQueue = 1; idxQueue < pThis->cVirtQueues; idxQueue++)
2407 {
2408 /* Skip creating threads for receive queues, only create for transmit queues & control queue */
2409 if (!IS_RX_QUEUE(idxQueue))
2410 {
2411 rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->aWorkers[idxQueue].hEvtProcess);
2412
2413 if (RT_FAILURE(rc))
2414 return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2415 N_("DevVirtioNET: Failed to create SUP event semaphore"));
2416
2417 rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->aWorkers[idxQueue].pThread,
2418 (void *)(uintptr_t)idxQueue, virtioNetR3WorkerThread,
2419 virtioNetR3WakeupWorker, 0, RTTHREADTYPE_IO, VIRTQNAME(idxQueue));
2420 if (rc != VINF_SUCCESS)
2421 {
2422 LogRel(("Error creating thread for Virtual Queue %s: %Rrc\n", VIRTQNAME(idxQueue), rc));
2423 return rc;
2424 }
2425 }
2426 pThis->afQueueAttached[idxQueue] = true;
2427 }
2428 return rc;
2429}
2430
2431/**
2432 * @callback_method_impl{VIRTIOCORER3,pfnStatusChanged}
2433 */
2434static DECLCALLBACK(void) virtioNetR3StatusChanged(PVIRTIOCORE pVirtio, PVIRTIOCORECC pVirtioCC, uint32_t fVirtioReady)
2435{
2436 PVIRTIONET pThis = RT_FROM_MEMBER(pVirtio, VIRTIONET, Virtio);
2437 PVIRTIONETCC pThisCC = RT_FROM_MEMBER(pVirtioCC, VIRTIONETCC, Virtio);
2438
2439 pThis->fVirtioReady = fVirtioReady;
2440
2441 if (fVirtioReady)
2442 {
2443 LogFunc(("%s VirtIO ready\n-----------------------------------------------------------------------------------------\n",
2444 INSTANCE(pThis)));
2445
2446 pThis->fResetting = false;
2447 pThisCC->fQuiescing = false;
2448 pThis->fNegotiatedFeatures = virtioCoreGetAcceptedFeatures(pVirtio);
2449 for (unsigned idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
2450 {
2451 (void) virtioCoreR3QueueAttach(&pThis->Virtio, idxQueue, VIRTQNAME(idxQueue));
2452 pThis->afQueueAttached[idxQueue] = true;
2453 virtioCoreQueueIsEmpty(pThisCC->pDevIns, &pThis->Virtio, idxQueue);
2454 virtioCoreQueueSetNotify(&pThis->Virtio, idxQueue, true);
2455 }
2456 }
2457 else
2458 {
2459 LogFunc(("%s VirtIO is resetting\n", INSTANCE(pThis)));
2460
2461 pThis->virtioNetConfig.uStatus = pThis->fCableConnected ? VIRTIONET_F_LINK_UP : 0;
2462 Log7Func(("%s Link is %s\n", INSTANCE(pThis), pThis->fCableConnected ? "up" : "down"));
2463
2464 pThis->fPromiscuous = true;
2465 pThis->fAllMulticast = false;
2466 pThis->fAllUnicast = false;
2467 pThis->fNoMulticast = false;
2468 pThis->fNoUnicast = false;
2469 pThis->fNoBroadcast = false;
2470 pThis->uIsTransmitting = 0;
2471 pThis->cUnicastFilterMacs = 0;
2472 pThis->cMulticastFilterMacs = 0;
2473
2474 memset(pThis->aMacMulticastFilter, 0, sizeof(pThis->aMacMulticastFilter));
2475 memset(pThis->aMacUnicastFilter, 0, sizeof(pThis->aMacUnicastFilter));
2476 memset(pThis->aVlanFilter, 0, sizeof(pThis->aVlanFilter));
2477
2478 pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, true);
2479
2480 for (unsigned idxQueue = 0; idxQueue < pThis->cVirtQueues; idxQueue++)
2481 pThis->afQueueAttached[idxQueue] = false;
2482 }
2483}
2484#endif /* IN_RING3 */
2485
2486/**
2487 * @interface_method_impl{PDMDEVREGR3,pfnDetach}
2488 *
2489 * One harddisk at one port has been unplugged.
2490 * The VM is suspended at this point.
2491 */
2492static DECLCALLBACK(void) virtioNetR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
2493{
2494 RT_NOREF(fFlags);
2495
2496 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
2497 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
2498
2499 Log7Func(("%s\n", INSTANCE(pThis)));
2500 AssertLogRelReturnVoid(iLUN == 0);
2501
2502 int rc = virtioNetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
2503 AssertMsgRCReturnVoid(rc, ("Failed to enter critical section"));
2504
2505 /*
2506 * Zero important members.
2507 */
2508 pThisCC->pDrvBase = NULL;
2509 pThisCC->pDrv = NULL;
2510
2511 virtioNetR3CsLeave(pDevIns, pThis);
2512}
2513
2514/**
2515 * @interface_method_impl{PDMDEVREGR3,pfnAttach}
2516 *
2517 * This is called when we change block driver.
2518 */
2519static DECLCALLBACK(int) virtioNetR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
2520{
2521 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
2522 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
2523
2524 RT_NOREF(fFlags);
2525
2526 Log7Func(("%s", INSTANCE(pThis)));
2527
2528 AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN);
2529
2530 int rc = virtioNetR3CsEnter(pDevIns, pThis, VERR_SEM_BUSY);
2531 AssertMsgRCReturn(rc, ("Failed to enter critical section"), rc);
2532
2533 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pDevIns->IBase, &pThisCC->pDrvBase, "Network Port");
2534 if (RT_SUCCESS(rc))
2535 {
2536 pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
2537 AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
2538 rc = VERR_PDM_MISSING_INTERFACE_BELOW);
2539 }
2540 else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
2541 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
2542 Log(("%s No attached driver!\n", INSTANCE(pThis)));
2543
2544 virtioNetR3CsLeave(pDevIns, pThis);
2545 return rc;
2546
2547 AssertRelease(!pThisCC->pDrvBase);
2548 return rc;
2549}
2550
2551/**
2552 * @interface_method_impl{PDMILEDPORTS,pfnQueryStatusLed}
2553 */
2554static DECLCALLBACK(int) virtioNetR3QueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
2555{
2556 PVIRTIONETR3 pThisR3 = RT_FROM_MEMBER(pInterface, VIRTIONETR3, ILeds);
2557 if (iLUN)
2558 return VERR_PDM_LUN_NOT_FOUND;
2559 *ppLed = &pThisR3->led;
2560 return VINF_SUCCESS;
2561}
2562
2563
2564/**
2565 * @interface_method_impl{PDMIBASE,pfnQueryInterface,
2566 */
2567static DECLCALLBACK(void *) virtioNetR3QueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
2568{
2569 PVIRTIONETR3 pThisCC = RT_FROM_MEMBER(pInterface, VIRTIONETCC, IBase);
2570
2571 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown);
2572 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig);
2573 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
2574 PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
2575 return NULL;
2576}
2577
2578/**
2579 * @interface_method_impl{PDMDEVREGR3,pfnDestruct}
2580 */
2581static DECLCALLBACK(int) virtioNetR3Destruct(PPDMDEVINS pDevIns)
2582{
2583 PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
2584
2585 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
2586 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
2587
2588 Log(("%s Destroying instance\n", INSTANCE(pThis)));
2589
2590 if (pThis->hEventRxDescAvail != NIL_SUPSEMEVENT)
2591 {
2592 PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hEventRxDescAvail);
2593 PDMDevHlpSUPSemEventClose(pDevIns, pThis->hEventRxDescAvail);
2594 pThis->hEventRxDescAvail = NIL_SUPSEMEVENT;
2595 }
2596
2597 virtioNetR3DestroyWorkerThreads(pDevIns, pThis, pThisCC);
2598
2599 virtioCoreR3Term(pDevIns, &pThis->Virtio, &pThisCC->Virtio);
2600
2601 return VINF_SUCCESS;
2602}
2603
2604/**
2605 * @interface_method_impl{PDMDEVREGR3,pfnConstruct}
2606 */
2607static DECLCALLBACK(int) virtioNetR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
2608{
2609 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2610 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
2611 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
2612 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2613
2614 /*
2615 * Quick initialization of the state data, making sure that the destructor always works.
2616 */
2617 Log7Func(("PDM device instance: %d\n", iInstance));
2618
2619
2620 RTStrPrintf(pThis->szInstanceName, sizeof(pThis->szInstanceName), "VIRTIONET", iInstance);
2621
2622 pThisCC->pDevIns = pDevIns;
2623
2624 pThisCC->IBase.pfnQueryInterface = virtioNetR3QueryInterface;
2625 pThisCC->ILeds.pfnQueryStatusLed = virtioNetR3QueryStatusLed;
2626 pThisCC->led.u32Magic = PDMLED_MAGIC;
2627
2628 /* Interfaces */
2629 pThisCC->INetworkDown.pfnWaitReceiveAvail = virtioNetR3NetworkDown_WaitReceiveAvail;
2630 pThisCC->INetworkDown.pfnReceive = virtioNetR3NetworkDown_Receive;
2631 pThisCC->INetworkDown.pfnReceiveGso = virtioNetR3NetworkDown_ReceiveGso;
2632 pThisCC->INetworkDown.pfnXmitPending = virtioNetR3NetworkDown_XmitPending;
2633 pThisCC->INetworkConfig.pfnGetMac = virtioNetR3NetworkConfig_GetMac;
2634 pThisCC->INetworkConfig.pfnGetLinkState = virtioNetR3NetworkConfig_GetLinkState;
2635 pThisCC->INetworkConfig.pfnSetLinkState = virtioNetR3NetworkConfig_SetLinkState;
2636
2637 /*
2638 * Validate configuration.
2639 */
2640 PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "MAC|CableConnected|LineSpeed|LinkUpDelay|StatNo", "");
2641
2642 /* Get config params */
2643 int rc = pHlp->pfnCFGMQueryBytes(pCfg, "MAC", pThis->macConfigured.au8, sizeof(pThis->macConfigured));
2644 if (RT_FAILURE(rc))
2645 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get MAC address"));
2646
2647 rc = pHlp->pfnCFGMQueryBool(pCfg, "CableConnected", &pThis->fCableConnected);
2648 if (RT_FAILURE(rc))
2649 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get the value of 'CableConnected'"));
2650
2651 uint32_t uStatNo = iInstance;
2652 rc = pHlp->pfnCFGMQueryU32Def(pCfg, "StatNo", &uStatNo, iInstance);
2653 if (RT_FAILURE(rc))
2654 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get the \"StatNo\" value"));
2655
2656 rc = pHlp->pfnCFGMQueryU32Def(pCfg, "LinkUpDelay", &pThis->cMsLinkUpDelay, 5000); /* ms */
2657 if (RT_FAILURE(rc))
2658 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to get the value of 'LinkUpDelay'"));
2659
2660 Assert(pThis->cMsLinkUpDelay <= 300000); /* less than 5 minutes */
2661
2662 if (pThis->cMsLinkUpDelay > 5000 || pThis->cMsLinkUpDelay < 100)
2663 LogRel(("%s WARNING! Link up delay is set to %u seconds!\n",
2664 INSTANCE(pThis), pThis->cMsLinkUpDelay / 1000));
2665
2666 Log(("%s Link up delay is set to %u seconds\n", INSTANCE(pThis), pThis->cMsLinkUpDelay / 1000));
2667
2668 /* Copy the MAC address configured for the VM to the MMIO accessible Virtio dev-specific config area */
2669 memcpy(pThis->virtioNetConfig.uMacAddress.au8, pThis->macConfigured.au8, sizeof(pThis->virtioNetConfig.uMacAddress)); /* TBD */
2670
2671 /*
2672 * Do core virtio initialization.
2673 */
2674
2675#if VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_STATUS
2676 pThis->virtioNetConfig.uStatus = 0;
2677#endif
2678
2679#if VIRTIONET_HOST_FEATURES_OFFERED & VIRTIONET_F_MQ
2680 pThis->virtioNetConfig.uMaxVirtqPairs = VIRTIONET_MAX_QPAIRS;
2681#endif
2682
2683 /* Initialize the generic Virtio core: */
2684 pThisCC->Virtio.pfnStatusChanged = virtioNetR3StatusChanged;
2685 pThisCC->Virtio.pfnQueueNotified = virtioNetR3QueueNotified;
2686 pThisCC->Virtio.pfnDevCapRead = virtioNetR3DevCapRead;
2687 pThisCC->Virtio.pfnDevCapWrite = virtioNetR3DevCapWrite;
2688
2689 VIRTIOPCIPARAMS VirtioPciParams;
2690 VirtioPciParams.uDeviceId = PCI_DEVICE_ID_VIRTIONET_HOST;
2691 VirtioPciParams.uClassBase = PCI_CLASS_BASE_NETWORK_CONTROLLER;
2692 VirtioPciParams.uClassSub = PCI_CLASS_SUB_NET_ETHERNET_CONTROLLER;
2693 VirtioPciParams.uClassProg = PCI_CLASS_PROG_UNSPECIFIED;
2694 VirtioPciParams.uSubsystemId = PCI_DEVICE_ID_VIRTIONET_HOST; /* VirtIO 1.0 spec allows PCI Device ID here */
2695 VirtioPciParams.uInterruptLine = 0x00;
2696 VirtioPciParams.uInterruptPin = 0x01;
2697
2698 /*
2699 * Initialize VirtIO core. This will result in a "status changed" callback
2700 * when VirtIO is ready, at which time the Rx queue and ctrl queue worker threads will be created.
2701 */
2702 rc = virtioCoreR3Init(pDevIns, &pThis->Virtio, &pThisCC->Virtio, &VirtioPciParams, INSTANCE(pThis),
2703 VIRTIONET_HOST_FEATURES_OFFERED,
2704 &pThis->virtioNetConfig /*pvDevSpecificCap*/, sizeof(pThis->virtioNetConfig));
2705 if (RT_FAILURE(rc))
2706 return PDMDEV_SET_ERROR(pDevIns, rc, N_("virtio-net: failed to initialize VirtIO"));
2707
2708 pThis->fNegotiatedFeatures = virtioCoreGetNegotiatedFeatures(&pThis->Virtio);
2709 if (!virtioNetValidateRequiredFeatures(pThis->fNegotiatedFeatures))
2710 return PDMDEV_SET_ERROR(pDevIns, rc, N_("virtio-net: Required features not successfully negotiated."));
2711
2712 pThis->cVirtqPairs = pThis->fNegotiatedFeatures & VIRTIONET_F_MQ
2713 ? pThis->virtioNetConfig.uMaxVirtqPairs : 1;
2714
2715 pThis->cVirtQueues += pThis->cVirtqPairs * 2 + 1;
2716
2717 /* Create Link Up Timer */
2718 rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL, virtioNetR3LinkUpTimer, NULL, TMTIMER_FLAGS_NO_CRIT_SECT,
2719 "VirtioNet Link Up Timer", &pThisCC->hLinkUpTimer);
2720
2721 /*
2722 * Initialize queues.
2723 */
2724 virtioNetR3SetVirtqNames(pThis);
2725
2726 /*
2727 * Create queue workers for life of instance. (I.e. they persist through VirtIO bounces)
2728 */
2729 rc = virtioNetR3CreateWorkerThreads(pDevIns, pThis, pThisCC);
2730 if (RT_FAILURE(rc))
2731 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to worker threads"));
2732
2733 /*
2734 * Create the semaphore that will be used to synchronize/throttle
2735 * the downstream LUN's Rx waiter thread.
2736 */
2737 rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->hEventRxDescAvail);
2738 if (RT_FAILURE(rc))
2739 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to create event semaphore"));
2740
2741 /*
2742 * Attach network driver instance
2743 */
2744 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port");
2745 if (RT_SUCCESS(rc))
2746 {
2747 pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP);
2748 AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"),
2749 rc = VERR_PDM_MISSING_INTERFACE_BELOW);
2750 }
2751 else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
2752 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
2753 Log(("%s No attached driver!\n", INSTANCE(pThis)));
2754
2755 /*
2756 * Status driver
2757 */
2758 PPDMIBASE pUpBase;
2759 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pUpBase, "Status Port");
2760 if (RT_FAILURE(rc) && rc != VERR_PDM_NO_ATTACHED_DRIVER)
2761 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to attach the status LUN"));
2762
2763 pThisCC->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pUpBase, PDMILEDCONNECTORS);
2764
2765 /*
2766 * Register saved state.
2767 */
2768 rc = PDMDevHlpSSMRegister(pDevIns, VIRTIONET_SAVED_STATE_VERSION, sizeof(*pThis),
2769 virtioNetR3SaveExec, virtioNetR3LoadExec);
2770 AssertRCReturn(rc, rc);
2771
2772 /*
2773 * Register the debugger info callback (ignore errors).
2774 */
2775 char szTmp[128];
2776 RTStrPrintf(szTmp, sizeof(szTmp), "%s%u", pDevIns->pReg->szName, pDevIns->iInstance);
2777 PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "virtio-net info", virtioNetR3Info);
2778 return rc;
2779}
2780
2781#else /* !IN_RING3 */
2782
2783/**
2784 * @callback_method_impl{PDMDEVREGR0,pfnConstruct}
2785 */
2786static DECLCALLBACK(int) virtioNetRZConstruct(PPDMDEVINS pDevIns)
2787{
2788 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2789 PVIRTIONET pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIONET);
2790 PVIRTIONETCC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIONETCC);
2791
2792 return virtioCoreRZInit(pDevIns, &pThis->Virtio, &pThisCC->Virtio);
2793}
2794
2795#endif /* !IN_RING3 */
2796
2797
2798
2799/**
2800 * The device registration structure.
2801 */
2802const PDMDEVREG g_DeviceVirtioNet_1_0 =
2803{
2804 /* .uVersion = */ PDM_DEVREG_VERSION,
2805 /* .uReserved0 = */ 0,
2806 /* .szName = */ "virtio-net-1-dot-0",
2807 /* .fFlags = */ PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_NEW_STYLE //| PDM_DEVREG_FLAGS_RZ
2808 | PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION
2809 | PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION,
2810 /* .fClass = */ PDM_DEVREG_CLASS_NETWORK,
2811 /* .cMaxInstances = */ ~0U,
2812 /* .uSharedVersion = */ 42,
2813 /* .cbInstanceShared = */ sizeof(VIRTIONET),
2814 /* .cbInstanceCC = */ sizeof(VIRTIONETCC),
2815 /* .cbInstanceRC = */ sizeof(VIRTIONETRC),
2816 /* .cMaxPciDevices = */ 1,
2817 /* .cMaxMsixVectors = */ VBOX_MSIX_MAX_ENTRIES,
2818 /* .pszDescription = */ "Virtio Host NET.\n",
2819#if defined(IN_RING3)
2820 /* .pszRCMod = */ "VBoxDDRC.rc",
2821 /* .pszR0Mod = */ "VBoxDDR0.r0",
2822 /* .pfnConstruct = */ virtioNetR3Construct,
2823 /* .pfnDestruct = */ virtioNetR3Destruct,
2824 /* .pfnRelocate = */ NULL,
2825 /* .pfnMemSetup = */ NULL,
2826 /* .pfnPowerOn = */ NULL,
2827 /* .pfnReset = */ virtioNetR3Reset,
2828 /* .pfnSuspend = */ virtioNetR3Suspend,
2829 /* .pfnResume = */ virtioNetR3Resume,
2830 /* .pfnAttach = */ virtioNetR3Attach,
2831 /* .pfnDetach = */ virtioNetR3Detach,
2832 /* .pfnQueryInterface = */ NULL,
2833 /* .pfnInitComplete = */ NULL,
2834 /* .pfnPowerOff = */ virtioNetR3PowerOff,
2835 /* .pfnSoftReset = */ NULL,
2836 /* .pfnReserved0 = */ NULL,
2837 /* .pfnReserved1 = */ NULL,
2838 /* .pfnReserved2 = */ NULL,
2839 /* .pfnReserved3 = */ NULL,
2840 /* .pfnReserved4 = */ NULL,
2841 /* .pfnReserved5 = */ NULL,
2842 /* .pfnReserved6 = */ NULL,
2843 /* .pfnReserved7 = */ NULL,
2844#elif defined(IN_RING0)
2845 /* .pfnEarlyConstruct = */ NULL,
2846 /* .pfnConstruct = */ virtioNetRZConstruct,
2847 /* .pfnDestruct = */ NULL,
2848 /* .pfnFinalDestruct = */ NULL,
2849 /* .pfnRequest = */ NULL,
2850 /* .pfnReserved0 = */ NULL,
2851 /* .pfnReserved1 = */ NULL,
2852 /* .pfnReserved2 = */ NULL,
2853 /* .pfnReserved3 = */ NULL,
2854 /* .pfnReserved4 = */ NULL,
2855 /* .pfnReserved5 = */ NULL,
2856 /* .pfnReserved6 = */ NULL,
2857 /* .pfnReserved7 = */ NULL,
2858#elif defined(IN_RC)
2859 /* .pfnConstruct = */ virtioNetRZConstruct,
2860 /* .pfnReserved0 = */ NULL,
2861 /* .pfnReserved1 = */ NULL,
2862 /* .pfnReserved2 = */ NULL,
2863 /* .pfnReserved3 = */ NULL,
2864 /* .pfnReserved4 = */ NULL,
2865 /* .pfnReserved5 = */ NULL,
2866 /* .pfnReserved6 = */ NULL,
2867 /* .pfnReserved7 = */ NULL,
2868#else
2869# error "Not in IN_RING3, IN_RING0 or IN_RC!"
2870#endif
2871 /* .uVersionEnd = */ PDM_DEVREG_VERSION
2872};
2873
Note: See TracBrowser for help on using the repository browser.

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