VirtualBox

source: vbox/trunk/include/VBox/intnet.h@ 51757

Last change on this file since 51757 was 46904, checked in by vboxsync, 11 years ago

IntNet, VirtioNet, NetFilter: Large frame support + drop oversized + UFO fix (#6821)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 48.9 KB
Line 
1/** @file
2 * INTNET - Internal Networking. (DEV,++)
3 */
4
5/*
6 * Copyright (C) 2006-2011 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef ___VBox_intnet_h
27#define ___VBox_intnet_h
28
29#include <VBox/types.h>
30#include <VBox/vmm/stam.h>
31#include <VBox/sup.h>
32#include <iprt/assert.h>
33#include <iprt/asm.h>
34
35RT_C_DECLS_BEGIN
36
37
38/**
39 * Generic two-sided ring buffer.
40 *
41 * The deal is that there is exactly one writer and one reader.
42 * When offRead equals offWrite the buffer is empty. In the other
43 * extreme the writer will not use the last free byte in the buffer.
44 */
45typedef struct INTNETRINGBUF
46{
47 /** The offset from this structure to the start of the buffer. */
48 uint32_t offStart;
49 /** The offset from this structure to the end of the buffer. (exclusive). */
50 uint32_t offEnd;
51 /** The current read offset. */
52 uint32_t volatile offReadX;
53 /** Alignment. */
54 uint32_t u32Align0;
55
56 /** The committed write offset. */
57 uint32_t volatile offWriteCom;
58 /** Writer internal current write offset.
59 * This is ahead of offWriteCom when buffer space is handed to a third party for
60 * data gathering. offWriteCom will be assigned this value by the writer then
61 * the frame is ready. */
62 uint32_t volatile offWriteInt;
63 /** The number of bytes written (not counting overflows). */
64 STAMCOUNTER cbStatWritten;
65 /** The number of frames written (not counting overflows). */
66 STAMCOUNTER cStatFrames;
67 /** The number of overflows. */
68 STAMCOUNTER cOverflows;
69} INTNETRINGBUF;
70AssertCompileSize(INTNETRINGBUF, 48);
71/** Pointer to a ring buffer. */
72typedef INTNETRINGBUF *PINTNETRINGBUF;
73
74/** The alignment of a ring buffer. */
75#define INTNETRINGBUF_ALIGNMENT sizeof(INTNETHDR)
76
77/**
78 * Asserts the sanity of the specified INTNETRINGBUF structure.
79 */
80#ifdef VBOX_STRICT
81# define INTNETRINGBUF_ASSERT_SANITY(pRingBuf) \
82 do \
83 { \
84 AssertPtr(pRingBuf); \
85 { \
86 uint32_t const offWriteCom = (pRingBuf)->offWriteCom; \
87 uint32_t const offRead = (pRingBuf)->offReadX; \
88 uint32_t const offWriteInt = (pRingBuf)->offWriteInt; \
89 \
90 AssertMsg(offWriteCom == RT_ALIGN_32(offWriteCom, INTNETHDR_ALIGNMENT), ("%#x\n", offWriteCom)); \
91 AssertMsg(offWriteCom >= (pRingBuf)->offStart, ("%#x %#x\n", offWriteCom, (pRingBuf)->offStart)); \
92 AssertMsg(offWriteCom < (pRingBuf)->offEnd, ("%#x %#x\n", offWriteCom, (pRingBuf)->offEnd)); \
93 \
94 AssertMsg(offRead == RT_ALIGN_32(offRead, INTNETHDR_ALIGNMENT), ("%#x\n", offRead)); \
95 AssertMsg(offRead >= (pRingBuf)->offStart, ("%#x %#x\n", offRead, (pRingBuf)->offStart)); \
96 AssertMsg(offRead < (pRingBuf)->offEnd, ("%#x %#x\n", offRead, (pRingBuf)->offEnd)); \
97 \
98 AssertMsg(offWriteInt == RT_ALIGN_32(offWriteInt, INTNETHDR_ALIGNMENT), ("%#x\n", offWriteInt)); \
99 AssertMsg(offWriteInt >= (pRingBuf)->offStart, ("%#x %#x\n", offWriteInt, (pRingBuf)->offStart)); \
100 AssertMsg(offWriteInt < (pRingBuf)->offEnd, ("%#x %#x\n", offWriteInt, (pRingBuf)->offEnd)); \
101 AssertMsg( offRead <= offWriteCom \
102 ? offWriteCom <= offWriteInt || offWriteInt < offRead \
103 : offWriteCom <= offWriteInt, \
104 ("W=%#x W'=%#x R=%#x\n", offWriteCom, offWriteInt, offRead)); \
105 } \
106 } while (0)
107#else
108# define INTNETRINGBUF_ASSERT_SANITY(pRingBuf) do { } while (0)
109#endif
110
111
112
113/**
114 * A interface buffer.
115 */
116typedef struct INTNETBUF
117{
118 /** Magic number (INTNETBUF_MAGIC). */
119 uint32_t u32Magic;
120 /** The size of the entire buffer. */
121 uint32_t cbBuf;
122 /** The size of the send area. */
123 uint32_t cbSend;
124 /** The size of the receive area. */
125 uint32_t cbRecv;
126 /** The receive buffer. */
127 INTNETRINGBUF Recv;
128 /** The send buffer. */
129 INTNETRINGBUF Send;
130 /** Number of times yields help solve an overflow. */
131 STAMCOUNTER cStatYieldsOk;
132 /** Number of times yields didn't help solve an overflow. */
133 STAMCOUNTER cStatYieldsNok;
134 /** Number of lost packets due to overflows. */
135 STAMCOUNTER cStatLost;
136 /** Number of bad frames (both rings). */
137 STAMCOUNTER cStatBadFrames;
138 /** Reserved for future use. */
139 STAMCOUNTER aStatReserved[2];
140 /** Reserved for future send profiling. */
141 STAMPROFILE StatSend1;
142 /** Reserved for future send profiling. */
143 STAMPROFILE StatSend2;
144 /** Reserved for future receive profiling. */
145 STAMPROFILE StatRecv1;
146 /** Reserved for future receive profiling. */
147 STAMPROFILE StatRecv2;
148 /** Reserved for future profiling. */
149 STAMPROFILE StatReserved;
150} INTNETBUF;
151AssertCompileSize(INTNETBUF, 320);
152AssertCompileMemberOffset(INTNETBUF, Recv, 16);
153AssertCompileMemberOffset(INTNETBUF, Send, 64);
154
155/** Pointer to an interface buffer. */
156typedef INTNETBUF *PINTNETBUF;
157/** Pointer to a const interface buffer. */
158typedef INTNETBUF const *PCINTNETBUF;
159
160/** Magic number for INTNETBUF::u32Magic (Sir William Gerald Golding). */
161#define INTNETBUF_MAGIC UINT32_C(0x19110919)
162
163/**
164 * Asserts the sanity of the specified INTNETBUF structure.
165 */
166#define INTNETBUF_ASSERT_SANITY(pBuf) \
167 do \
168 { \
169 AssertPtr(pBuf); \
170 Assert((pBuf)->u32Magic == INTNETBUF_MAGIC); \
171 { \
172 uint32_t const offRecvStart = (pBuf)->Recv.offStart + RT_OFFSETOF(INTNETBUF, Recv); \
173 uint32_t const offRecvEnd = (pBuf)->Recv.offStart + RT_OFFSETOF(INTNETBUF, Recv); \
174 uint32_t const offSendStart = (pBuf)->Send.offStart + RT_OFFSETOF(INTNETBUF, Send); \
175 uint32_t const offSendEnd = (pBuf)->Send.offStart + RT_OFFSETOF(INTNETBUF, Send); \
176 \
177 Assert(offRecvEnd > offRecvStart); \
178 Assert(offRecvEnd - offRecvStart == (pBuf)->cbRecv); \
179 Assert(offRecvStart == sizeof(INTNETBUF)); \
180 \
181 Assert(offSendEnd > offSendStart); \
182 Assert(offSendEnd - offSendStart == (pBuf)->cbSend); \
183 Assert(pffSendEnd <= (pBuf)->cbBuf); \
184 \
185 Assert(offSendStart == offRecvEnd); \
186 } \
187 } while (0)
188
189
190/** Internal networking interface handle. */
191typedef uint32_t INTNETIFHANDLE;
192/** Pointer to an internal networking interface handle. */
193typedef INTNETIFHANDLE *PINTNETIFHANDLE;
194
195/** Or mask to obscure the handle index. */
196#define INTNET_HANDLE_MAGIC 0x88880000
197/** Mask to extract the handle index. */
198#define INTNET_HANDLE_INDEX_MASK 0xffff
199/** The maximum number of handles (exclusive) */
200#define INTNET_HANDLE_MAX 0xffff
201/** Invalid handle. */
202#define INTNET_HANDLE_INVALID (0)
203
204
205/**
206 * The frame header.
207 *
208 * The header is intentionally 8 bytes long. It will always
209 * start at an 8 byte aligned address. Assuming that the buffer
210 * size is a multiple of 8 bytes, that means that we can guarantee
211 * that the entire header is contiguous in both virtual and physical
212 * memory.
213 */
214typedef struct INTNETHDR
215{
216 /** The size of the frame. */
217 uint32_t cbFrame : 24;
218 /** Header type. This is currently serving as a magic, it
219 * can be extended later to encode special command frames and stuff. */
220 uint32_t u8Type : 8;
221 /** The offset from the start of this header to where the actual frame starts.
222 * This is used to keep the frame it self contiguous in virtual memory and
223 * thereby both simplify access as well as the descriptor. */
224 int32_t offFrame;
225} INTNETHDR;
226AssertCompileSize(INTNETHDR, 8);
227AssertCompileSizeAlignment(INTNETBUF, sizeof(INTNETHDR));
228/** Pointer to a frame header.*/
229typedef INTNETHDR *PINTNETHDR;
230/** Pointer to a const frame header.*/
231typedef INTNETHDR const *PCINTNETHDR;
232
233/** The alignment of a frame header. */
234#define INTNETHDR_ALIGNMENT sizeof(INTNETHDR)
235AssertCompile(sizeof(INTNETHDR) == INTNETHDR_ALIGNMENT);
236AssertCompile(INTNETHDR_ALIGNMENT <= INTNETRINGBUF_ALIGNMENT);
237
238/** @name Frame types (INTNETHDR::u8Type).
239 * @{ */
240/** Normal frames. */
241#define INTNETHDR_TYPE_FRAME 0x42
242/** Padding frames. */
243#define INTNETHDR_TYPE_PADDING 0x53
244/** Generic segment offload frames.
245 * The frame starts with a PDMNETWORKGSO structure which is followed by the
246 * header template and data. */
247#define INTNETHDR_TYPE_GSO 0x64
248AssertCompileSize(PDMNETWORKGSO, 8);
249/** @} */
250
251/**
252 * Asserts the sanity of the specified INTNETHDR.
253 */
254#ifdef VBOX_STRICT
255#define INTNETHDR_ASSERT_SANITY(pHdr, pRingBuf) \
256 do \
257 { \
258 AssertPtr(pHdr); \
259 Assert(RT_ALIGN_PT(pHdr, INTNETHDR_ALIGNMENT, INTNETHDR *) == pHdr); \
260 Assert( (pHdr)->u8Type == INTNETHDR_TYPE_FRAME \
261 || (pHdr)->u8Type == INTNETHDR_TYPE_GSO \
262 || (pHdr)->u8Type == INTNETHDR_TYPE_PADDING); \
263 { \
264 uintptr_t const offHdr = (uintptr_t)pHdr - (uintptr_t)pRingBuf; \
265 uintptr_t const offFrame = offHdr + (pHdr)->offFrame; \
266 \
267 Assert(offHdr >= (pRingBuf)->offStart); \
268 Assert(offHdr < (pRingBuf)->offEnd); \
269 \
270 /* could do more thorough work here... later, perhaps. */ \
271 Assert(offFrame >= (pRingBuf)->offStart); \
272 Assert(offFrame < (pRingBuf)->offEnd); \
273 } \
274 } while (0)
275#else
276# define INTNETHDR_ASSERT_SANITY(pHdr, pRingBuf) do { } while (0)
277#endif
278
279
280/**
281 * Scatter / Gather segment (internal networking).
282 */
283typedef struct INTNETSEG
284{
285 /** The physical address. NIL_RTHCPHYS is not set. */
286 RTHCPHYS Phys;
287 /** Pointer to the segment data. */
288 void *pv;
289 /** The segment size. */
290 uint32_t cb;
291} INTNETSEG;
292/** Pointer to a internal networking frame segment. */
293typedef INTNETSEG *PINTNETSEG;
294/** Pointer to a internal networking frame segment. */
295typedef INTNETSEG const *PCINTNETSEG;
296
297
298/**
299 * Scatter / Gather list (internal networking).
300 *
301 * This is used when communicating with the trunk port.
302 */
303typedef struct INTNETSG
304{
305 /** Owner data, don't touch! */
306 void *pvOwnerData;
307 /** User data. */
308 void *pvUserData;
309 /** User data 2 in case anyone needs it. */
310 void *pvUserData2;
311 /** GSO context information, set the type to invalid if not relevant. */
312 PDMNETWORKGSO GsoCtx;
313 /** The total length of the scatter gather list. */
314 uint32_t cbTotal;
315 /** The number of users (references).
316 * This is used by the SGRelease code to decide when it can be freed. */
317 uint16_t volatile cUsers;
318 /** Flags, see INTNETSG_FLAGS_* */
319 uint16_t volatile fFlags;
320#if ARCH_BITS == 64
321 /** Alignment padding. */
322 uint16_t uPadding;
323#endif
324 /** The number of segments allocated. */
325 uint16_t cSegsAlloc;
326 /** The number of segments actually used. */
327 uint16_t cSegsUsed;
328 /** Variable sized list of segments. */
329 INTNETSEG aSegs[1];
330} INTNETSG;
331AssertCompileSizeAlignment(INTNETSG, 8);
332/** Pointer to a scatter / gather list. */
333typedef INTNETSG *PINTNETSG;
334/** Pointer to a const scatter / gather list. */
335typedef INTNETSG const *PCINTNETSG;
336
337/** @name INTNETSG::fFlags definitions.
338 * @{ */
339/** Set if the SG is free. */
340#define INTNETSG_FLAGS_FREE RT_BIT_32(1)
341/** Set if the SG is a temporary one that will become invalid upon return.
342 * Try to finish using it before returning, and if that's not possible copy
343 * to other buffers.
344 * When not set, the callee should always free the SG.
345 * Attempts to free it made by the callee will be quietly ignored. */
346#define INTNETSG_FLAGS_TEMP RT_BIT_32(2)
347/** ARP packet, IPv4 + MAC.
348 * @internal */
349#define INTNETSG_FLAGS_ARP_IPV4 RT_BIT_32(3)
350/** Copied to the temporary buffer.
351 * @internal */
352#define INTNETSG_FLAGS_PKT_CP_IN_TMP RT_BIT_32(4)
353/** @} */
354
355
356/** @name Direction (frame source or destination)
357 * @{ */
358/** To/From the wire. */
359#define INTNETTRUNKDIR_WIRE RT_BIT_32(0)
360/** To/From the host. */
361#define INTNETTRUNKDIR_HOST RT_BIT_32(1)
362/** Mask of valid bits. */
363#define INTNETTRUNKDIR_VALID_MASK UINT32_C(3)
364/** @} */
365
366/**
367 * Switch decisions returned by INTNETTRUNKSWPORT::pfnPreRecv.
368 */
369typedef enum INTNETSWDECISION
370{
371 /** The usual invalid zero value. */
372 INTNETSWDECISION_INVALID = 0,
373 /** Everywhere. */
374 INTNETSWDECISION_BROADCAST,
375 /** Only to the internal network. */
376 INTNETSWDECISION_INTNET,
377 /** Only for the trunk (host/wire). */
378 INTNETSWDECISION_TRUNK,
379 /** Used internally to indicate that the packet cannot be handled in the
380 * current context. */
381 INTNETSWDECISION_BAD_CONTEXT,
382 /** Used internally to indicate that the packet should be dropped. */
383 INTNETSWDECISION_DROP,
384 /** The usual 32-bit type expansion. */
385 INTNETSWDECISION_32BIT_HACK = 0x7fffffff
386} INTNETSWDECISION;
387
388
389/** Pointer to the switch side of a trunk port. */
390typedef struct INTNETTRUNKSWPORT *PINTNETTRUNKSWPORT;
391/**
392 * This is the port on the internal network 'switch', i.e.
393 * what the driver is connected to.
394 *
395 * This is only used for the in-kernel trunk connections.
396 */
397typedef struct INTNETTRUNKSWPORT
398{
399 /** Structure version number. (INTNETTRUNKSWPORT_VERSION) */
400 uint32_t u32Version;
401
402 /**
403 * Examine the packet and figure out where it is going.
404 *
405 * This method is for making packet switching decisions in contexts where
406 * pfnRecv cannot be called or is no longer applicable. This method can be
407 * called from any context.
408 *
409 * @returns INTNETSWDECISION_BROADCAST, INTNETSWDECISION_INTNET or
410 * INTNETSWDECISION_TRUNK. The source is excluded from broadcast &
411 * trunk, of course.
412 *
413 * @param pSwitchPort Pointer to this structure.
414 * @param pvHdrs Pointer to the packet headers.
415 * @param cbHdrs Size of the packet headers. This must be at least 6
416 * bytes (the destination MAC address), but should if
417 * possible also include any VLAN tag and network
418 * layer header (wireless mac address sharing).
419 * @param fSrc Where this frame comes from. Only one bit should be
420 * set!
421 *
422 * @remarks Will only grab the switch table spinlock (interrupt safe). May
423 * signal an event semaphore iff we're racing network cleanup. The
424 * caller must be busy when calling.
425 */
426 DECLR0CALLBACKMEMBER(INTNETSWDECISION, pfnPreRecv,(PINTNETTRUNKSWPORT pSwitchPort,
427 void const *pvHdrs, size_t cbHdrs, uint32_t fSrc));
428
429 /**
430 * Incoming frame.
431 *
432 * The frame may be modified when the trunk port on the switch is set to share
433 * the mac address of the host when hitting the wire. Currently frames
434 * containing ARP packets are subject to this, later other protocols like
435 * NDP/ICMPv6 may need editing as well when operating in this mode. The edited
436 * packet should be forwarded to the host/wire when @c false is returned.
437 *
438 * @returns true if we've handled it and it should be dropped.
439 * false if it should hit the wire/host.
440 *
441 * @param pSwitchPort Pointer to this structure.
442 * @param pvIf Pointer to the interface which received this frame
443 * if available. Can be NULL.
444 * @param pSG The (scatter /) gather structure for the frame. This
445 * will only be use during the call, so a temporary one can
446 * be used. The Phys member will not be used.
447 * @param fSrc Where this frame comes from. Exactly one bit shall be
448 * set!
449 *
450 * @remarks Will only grab the switch table spinlock (interrupt safe). Will
451 * signal event semaphores. The caller must be busy when calling.
452 *
453 * @remarks NAT and TAP will use this interface.
454 *
455 * @todo Do any of the host require notification before frame modifications?
456 * If so, we'll add a callback to INTNETTRUNKIFPORT for this
457 * (pfnSGModifying) and a SG flag.
458 */
459 DECLR0CALLBACKMEMBER(bool, pfnRecv,(PINTNETTRUNKSWPORT pSwitchPort, void *pvIf, PINTNETSG pSG, uint32_t fSrc));
460
461 /**
462 * Retain a SG.
463 *
464 * @param pSwitchPort Pointer to this structure.
465 * @param pSG Pointer to the (scatter /) gather structure.
466 *
467 * @remarks Will not grab any locks. The caller must be busy when calling.
468 */
469 DECLR0CALLBACKMEMBER(void, pfnSGRetain,(PINTNETTRUNKSWPORT pSwitchPort, PINTNETSG pSG));
470
471 /**
472 * Release a SG.
473 *
474 * This is called by the pfnXmit code when done with a SG. This may safe
475 * be done in an asynchronous manner.
476 *
477 * @param pSwitchPort Pointer to this structure.
478 * @param pSG Pointer to the (scatter /) gather structure.
479 *
480 * @remarks May signal an event semaphore later on, currently code won't though.
481 * The caller is busy when making this call.
482 */
483 DECLR0CALLBACKMEMBER(void, pfnSGRelease,(PINTNETTRUNKSWPORT pSwitchPort, PINTNETSG pSG));
484
485 /**
486 * Selects whether outgoing SGs should have their physical address set.
487 *
488 * By enabling physical addresses in the scatter / gather segments it should
489 * be possible to save some unnecessary address translation and memory locking
490 * in the network stack. (Internal networking knows the physical address for
491 * all the INTNETBUF data and that it's locked memory.) There is a negative
492 * side effects though, frames that crosses page boundaries will require
493 * multiple scather / gather segments.
494 *
495 * @returns The old setting.
496 *
497 * @param pSwitchPort Pointer to this structure.
498 * @param fEnable Whether to enable or disable it.
499 *
500 * @remarks Will not grab any locks. The caller must be busy when calling.
501 */
502 DECLR0CALLBACKMEMBER(bool, pfnSetSGPhys,(PINTNETTRUNKSWPORT pSwitchPort, bool fEnable));
503
504 /**
505 * Reports the MAC address of the trunk.
506 *
507 * This is supposed to be called when creating, connection or reconnecting the
508 * trunk and when the MAC address is changed by the system admin.
509 *
510 * @param pSwitchPort Pointer to this structure.
511 * @param pMacAddr The MAC address.
512 *
513 * @remarks May take a spinlock or two. The caller must be busy when calling.
514 */
515 DECLR0CALLBACKMEMBER(void, pfnReportMacAddress,(PINTNETTRUNKSWPORT pSwitchPort, PCRTMAC pMacAddr));
516
517 /**
518 * Reports the promicuousness of the interface.
519 *
520 * This is supposed to be called when creating, connection or reconnecting the
521 * trunk and when the mode is changed by the system admin.
522 *
523 * @param pSwitchPort Pointer to this structure.
524 * @param fPromiscuous True if the host operates the interface in
525 * promiscuous mode, false if not.
526 *
527 * @remarks May take a spinlock or two. The caller must be busy when calling.
528 */
529 DECLR0CALLBACKMEMBER(void, pfnReportPromiscuousMode,(PINTNETTRUNKSWPORT pSwitchPort, bool fPromiscuous));
530
531 /**
532 * Reports the GSO capabilities of the host, wire or both.
533 *
534 * This is supposed to be used only when creating, connecting or reconnecting
535 * the trunk. It is assumed that the GSO capabilities are kind of static the
536 * rest of the time.
537 *
538 * @param pSwitchPort Pointer to this structure.
539 * @param fGsoCapabilities The GSO capability bit mask. The bits
540 * corresponds to the GSO type with the same value.
541 * @param fDst The destination mask (INTNETTRUNKDIR_XXX).
542 *
543 * @remarks Does not take any locks. The caller must be busy when calling.
544 */
545 DECLR0CALLBACKMEMBER(void, pfnReportGsoCapabilities,(PINTNETTRUNKSWPORT pSwitchPort, uint32_t fGsoCapabilities, uint32_t fDst));
546
547 /**
548 * Reports the no-preemption-xmit capabilities of the host and wire.
549 *
550 * This is supposed to be used only when creating, connecting or reconnecting
551 * the trunk. It is assumed that the GSO capabilities are kind of static the
552 * rest of the time.
553 *
554 * @param pSwitchPort Pointer to this structure.
555 * @param fNoPreemptDsts The destinations (INTNETTRUNKDIR_XXX) which it
556 * is safe to transmit to with preemption disabled.
557 * @param fDst The destination mask (INTNETTRUNKDIR_XXX).
558 *
559 * @remarks Does not take any locks. The caller must be busy when calling.
560 */
561 DECLR0CALLBACKMEMBER(void, pfnReportNoPreemptDsts,(PINTNETTRUNKSWPORT pSwitchPort, uint32_t fNoPreemptDsts));
562
563 /** Structure version number. (INTNETTRUNKSWPORT_VERSION) */
564 uint32_t u32VersionEnd;
565} INTNETTRUNKSWPORT;
566
567/** Version number for the INTNETTRUNKIFPORT::u32Version and INTNETTRUNKIFPORT::u32VersionEnd fields. */
568#define INTNETTRUNKSWPORT_VERSION UINT32_C(0xA2CDf001)
569
570
571/**
572 * The trunk interface state used set by INTNETTRUNKIFPORT::pfnSetState.
573 */
574typedef enum INTNETTRUNKIFSTATE
575{
576 /** The invalid zero entry. */
577 INTNETTRUNKIFSTATE_INVALID = 0,
578 /** The trunk is inactive. No calls to INTNETTRUNKSWPORT::pfnRecv or
579 * INTNETTRUNKSWPORT::pfnPreRecv. Calling other methods is OK. */
580 INTNETTRUNKIFSTATE_INACTIVE,
581 /** The trunk is active, no restrictions on methods or anything. */
582 INTNETTRUNKIFSTATE_ACTIVE,
583 /** The trunk is about to be disconnected from the internal network. No
584 * calls to any INTNETRUNKSWPORT methods. */
585 INTNETTRUNKIFSTATE_DISCONNECTING,
586 /** The end of the valid states. */
587 INTNETTRUNKIFSTATE_END,
588 /** The usual 32-bit type blow up hack. */
589 INTNETTRUNKIFSTATE_32BIT_HACK = 0x7fffffff
590} INTNETTRUNKIFSTATE;
591
592/** Pointer to the interface side of a trunk port. */
593typedef struct INTNETTRUNKIFPORT *PINTNETTRUNKIFPORT;
594/**
595 * This is the port on the trunk interface, i.e. the driver side which the
596 * internal network is connected to.
597 *
598 * This is only used for the in-kernel trunk connections.
599 */
600typedef struct INTNETTRUNKIFPORT
601{
602 /** Structure version number. (INTNETTRUNKIFPORT_VERSION) */
603 uint32_t u32Version;
604
605 /**
606 * Retain the object.
607 *
608 * It will normally be called while owning the internal network semaphore.
609 *
610 * @param pIfPort Pointer to this structure.
611 *
612 * @remarks May own the big mutex, no spinlocks.
613 */
614 DECLR0CALLBACKMEMBER(void, pfnRetain,(PINTNETTRUNKIFPORT pIfPort));
615
616 /**
617 * Releases the object.
618 *
619 * This must be called for every pfnRetain call.
620 *
621 *
622 * @param pIfPort Pointer to this structure.
623 *
624 * @remarks May own the big mutex, no spinlocks.
625 */
626 DECLR0CALLBACKMEMBER(void, pfnRelease,(PINTNETTRUNKIFPORT pIfPort));
627
628 /**
629 * Disconnect from the switch and release the object.
630 *
631 * The is the counter action of the
632 * INTNETTRUNKNETFLTFACTORY::pfnCreateAndConnect method.
633 *
634 * @param pIfPort Pointer to this structure.
635 *
636 * @remarks Owns the big mutex.
637 */
638 DECLR0CALLBACKMEMBER(void, pfnDisconnectAndRelease,(PINTNETTRUNKIFPORT pIfPort));
639
640 /**
641 * Changes the state of the trunk interface.
642 *
643 * The interface is created in the inactive state (INTNETTRUNKIFSTATE_INACTIVE).
644 * When the first connect VM or service is activated, the internal network
645 * activates the trunk (INTNETTRUNKIFSTATE_ACTIVE). The state may then be set
646 * back and forth between INACTIVE and ACTIVE as VMs are paused, added and
647 * removed.
648 *
649 * Eventually though, the network is destroyed as a result of there being no
650 * more VMs left in it and the state is changed to disconnecting
651 * (INTNETTRUNKIFSTATE_DISCONNECTING) and pfnWaitForIdle is called to make sure
652 * there are no active calls in either direction when pfnDisconnectAndRelease is
653 * called.
654 *
655 * A typical operation to performed by this method is to enable/disable promiscuous
656 * mode on the host network interface when entering/leaving the active state.
657 *
658 * @returns The previous state.
659 *
660 * @param pIfPort Pointer to this structure.
661 * @param enmState The new state.
662 *
663 * @remarks Owns the big mutex. No racing pfnSetState, pfnWaitForIdle,
664 * pfnDisconnectAndRelease or INTNETTRUNKFACTORY::pfnCreateAndConnect
665 * calls.
666 */
667 DECLR0CALLBACKMEMBER(INTNETTRUNKIFSTATE, pfnSetState,(PINTNETTRUNKIFPORT pIfPort, INTNETTRUNKIFSTATE enmState));
668
669 /**
670 * Notifies when the MAC address of an interface is set or changes.
671 *
672 * @param pIfPort Pointer to this structure.
673 * @param pvIfData Pointer to the trunk's interface data (see
674 * pfnConnectInterface).
675 * @param pMac Pointer to the MAC address of the connecting VM NIC.
676 *
677 * @remarks Only busy references to the trunk and the interface.
678 */
679 DECLR0CALLBACKMEMBER(void, pfnNotifyMacAddress,(PINTNETTRUNKIFPORT pIfPort, void *pvIfData, PCRTMAC pMac));
680
681 /**
682 * Called when an interface is connected to the network.
683 *
684 * @returns IPRT status code.
685 * @param pIfPort Pointer to this structure.
686 * @param pvIf Opaque pointer to the interface being connected.
687 * For use INTNETTRUNKSWPORT::pfnRecv.
688 * @param ppvIfData Pointer to a pointer variable that the trunk
689 * implementation can use to associate data with the
690 * interface. This pointer will be passed to the
691 * pfnXmit, pfnNotifyMacAddress and
692 * pfnDisconnectInterface methods.
693 *
694 * @remarks Owns the big mutex. No racing pfnDisconnectAndRelease.
695 */
696 DECLR0CALLBACKMEMBER(int, pfnConnectInterface,(PINTNETTRUNKIFPORT pIfPort, void *pvIf, void **ppvIfData));
697
698 /**
699 * Called when an interface is disconnected from the network.
700 *
701 * @param pIfPort Pointer to this structure.
702 * @param pvIfData Pointer to the trunk's interface data (see
703 * pfnConnectInterface).
704 *
705 * @remarks Owns the big mutex. No racing pfnDisconnectAndRelease.
706 */
707 DECLR0CALLBACKMEMBER(void, pfnDisconnectInterface,(PINTNETTRUNKIFPORT pIfPort, void *pvIfData));
708
709 /**
710 * Waits for the interface to become idle.
711 *
712 * This method must be called before disconnecting and releasing the object in
713 * order to prevent racing incoming/outgoing frames and device
714 * enabling/disabling.
715 *
716 * @returns IPRT status code (see RTSemEventWait).
717 * @param pIfPort Pointer to this structure.
718 * @param cMillies The number of milliseconds to wait. 0 means
719 * no waiting at all. Use RT_INDEFINITE_WAIT for
720 * an indefinite wait.
721 *
722 * @remarks Owns the big mutex. No racing pfnDisconnectAndRelease.
723 */
724 DECLR0CALLBACKMEMBER(int, pfnWaitForIdle,(PINTNETTRUNKIFPORT pIfPort, uint32_t cMillies));
725
726 /**
727 * Transmit a frame.
728 *
729 * @return VBox status code. Error generally means we'll drop the frame.
730 * @param pIfPort Pointer to this structure.
731 * @param pvIfData Pointer to the trunk's interface data (see
732 * pfnConnectInterface).
733 * @param pSG Pointer to the (scatter /) gather structure for the frame.
734 * This may or may not be a temporary buffer. If it's temporary
735 * the transmit operation(s) then it's required to make a copy
736 * of the frame unless it can be transmitted synchronously.
737 * @param fDst The destination mask. At least one bit will be set.
738 *
739 * @remarks No locks. May be called concurrently on several threads.
740 */
741 DECLR0CALLBACKMEMBER(int, pfnXmit,(PINTNETTRUNKIFPORT pIfPort, void *pvIfData, PINTNETSG pSG, uint32_t fDst));
742
743 /** Structure version number. (INTNETTRUNKIFPORT_VERSION) */
744 uint32_t u32VersionEnd;
745} INTNETTRUNKIFPORT;
746
747/** Version number for the INTNETTRUNKIFPORT::u32Version and INTNETTRUNKIFPORT::u32VersionEnd fields. */
748#define INTNETTRUNKIFPORT_VERSION UINT32_C(0xA2CDe001)
749
750
751/**
752 * The component factory interface for create a network
753 * interface filter (like VBoxNetFlt).
754 */
755typedef struct INTNETTRUNKFACTORY
756{
757 /**
758 * Release this factory.
759 *
760 * SUPR0ComponentQueryFactory (SUPDRVFACTORY::pfnQueryFactoryInterface to be precise)
761 * will retain a reference to the factory and the caller has to call this method to
762 * release it once the pfnCreateAndConnect call(s) has been done.
763 *
764 * @param pIfFactory Pointer to this structure.
765 */
766 DECLR0CALLBACKMEMBER(void, pfnRelease,(struct INTNETTRUNKFACTORY *pIfFactory));
767
768 /**
769 * Create an instance for the specfied host interface and connects it
770 * to the internal network trunk port.
771 *
772 * The initial interface active state is false (suspended).
773 *
774 *
775 * @returns VBox status code.
776 * @retval VINF_SUCCESS and *ppIfPort set on success.
777 * @retval VERR_INTNET_FLT_IF_NOT_FOUND if the interface was not found.
778 * @retval VERR_INTNET_FLT_IF_BUSY if the interface is already connected.
779 * @retval VERR_INTNET_FLT_IF_FAILED if it failed for some other reason.
780 *
781 * @param pIfFactory Pointer to this structure.
782 * @param pszName The interface name (OS specific).
783 * @param pSwitchPort Pointer to the port interface on the switch that
784 * this interface is being connected to.
785 * @param fFlags Creation flags, see below.
786 * @param ppIfPort Where to store the pointer to the interface port
787 * on success.
788 *
789 * @remarks Called while owning the network and the out-bound trunk semaphores.
790 */
791 DECLR0CALLBACKMEMBER(int, pfnCreateAndConnect,(struct INTNETTRUNKFACTORY *pIfFactory, const char *pszName,
792 PINTNETTRUNKSWPORT pSwitchPort, uint32_t fFlags,
793 PINTNETTRUNKIFPORT *ppIfPort));
794} INTNETTRUNKFACTORY;
795/** Pointer to the trunk factory. */
796typedef INTNETTRUNKFACTORY *PINTNETTRUNKFACTORY;
797
798/** The UUID for the (current) trunk factory. (case sensitive) */
799#define INTNETTRUNKFACTORY_UUID_STR "de504d93-1d1e-4781-8b73-6ea39a0e36a2"
800
801/** @name INTNETTRUNKFACTORY::pfnCreateAndConnect flags.
802 * @{ */
803/** Don't put the filtered interface in promiscuous mode.
804 * This is used for wireless interface since these can misbehave if
805 * we try to put them in promiscuous mode. (Wireless interfaces are
806 * normally bridged on level 3 instead of level 2.) */
807#define INTNETTRUNKFACTORY_FLAG_NO_PROMISC RT_BIT_32(0)
808/** @} */
809
810
811/**
812 * The trunk connection type.
813 *
814 * Used by IntNetR0Open and associated interfaces.
815 */
816typedef enum INTNETTRUNKTYPE
817{
818 /** Invalid trunk type. */
819 kIntNetTrunkType_Invalid = 0,
820 /** No trunk connection. */
821 kIntNetTrunkType_None,
822 /** We don't care which kind of trunk connection if the network exists,
823 * if it doesn't exist create it without a connection. */
824 kIntNetTrunkType_WhateverNone,
825 /** VirtualBox host network interface filter driver.
826 * The trunk name is the name of the host network interface. */
827 kIntNetTrunkType_NetFlt,
828 /** VirtualBox adapter host driver. */
829 kIntNetTrunkType_NetAdp,
830 /** Nat service (ring-0). */
831 kIntNetTrunkType_SrvNat,
832 /** The end of valid types. */
833 kIntNetTrunkType_End,
834 /** The usual 32-bit hack. */
835 kIntNetTrunkType_32bitHack = 0x7fffffff
836} INTNETTRUNKTYPE;
837
838/** @name IntNetR0Open flags.
839 *
840 * The desired policy options must be specified explicitly, if omitted it is
841 * understood that whatever is current or default is fine with the caller.
842 *
843 * @todo Move the policies out of the flags, use three new parameters.
844 *
845 * @{ */
846/** Share the MAC address with the host when sending something to the wire via the trunk.
847 * This is typically used when the trunk is a NetFlt for a wireless interface. */
848#define INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE RT_BIT_32(0)
849/** Require that the current security and promiscuous policies of the network
850 * is exactly as the ones specified in this open network request.
851 *
852 * Use this with INTNET_OPEN_FLAGS_REQUIRE_AS_RESTRICTIVE_POLICIES to prevent
853 * restrictions from being lifted. If no further policy changes are desired,
854 * apply the relevant _FIXED flags. */
855#define INTNET_OPEN_FLAGS_REQUIRE_EXACT RT_BIT_32(1)
856/** Require that the security and promiscuous policies of the network is at
857 * least as restrictive as specified this request specifies and prevent them
858 * being lifted later on. */
859#define INTNET_OPEN_FLAGS_REQUIRE_AS_RESTRICTIVE_POLICIES RT_BIT_32(2)
860
861/** Network access policy: Fixed if set, changable if clear. */
862#define INTNET_OPEN_FLAGS_ACCESS_FIXED RT_BIT_32(3)
863/** Network access policy: Public network. */
864#define INTNET_OPEN_FLAGS_ACCESS_PUBLIC RT_BIT_32(4)
865/** Network access policy: Restricted network. */
866#define INTNET_OPEN_FLAGS_ACCESS_RESTRICTED RT_BIT_32(5)
867
868/** Promiscuous mode policy: Is it fixed or changable by new participants? */
869#define INTNET_OPEN_FLAGS_PROMISC_FIXED RT_BIT_32(6)
870/** Promiscuous mode policy: Allow the clients to request it. */
871#define INTNET_OPEN_FLAGS_PROMISC_ALLOW_CLIENTS RT_BIT_32(7)
872/** Promiscuous mode policy: Deny the clients from requesting it. */
873#define INTNET_OPEN_FLAGS_PROMISC_DENY_CLIENTS RT_BIT_32(8)
874/** Promiscuous mode policy: Allow the trunk-host to request it. */
875#define INTNET_OPEN_FLAGS_PROMISC_ALLOW_TRUNK_HOST RT_BIT_32(9)
876/** Promiscuous mode policy: Deny the trunk-host from requesting it. */
877#define INTNET_OPEN_FLAGS_PROMISC_DENY_TRUNK_HOST RT_BIT_32(10)
878/** Promiscuous mode policy: Allow the trunk-wire to request it. */
879#define INTNET_OPEN_FLAGS_PROMISC_ALLOW_TRUNK_WIRE RT_BIT_32(11)
880/** Promiscuous mode policy: Deny the trunk-wire from requesting it. */
881#define INTNET_OPEN_FLAGS_PROMISC_DENY_TRUNK_WIRE RT_BIT_32(12)
882
883/** Interface policies: Is it fixed or changable (by admin).
884 * @note Per interface, not network wide. */
885#define INTNET_OPEN_FLAGS_IF_FIXED RT_BIT_32(13)
886/** Interface promiscuous mode policy: Allow the interface to request it. */
887#define INTNET_OPEN_FLAGS_IF_PROMISC_ALLOW RT_BIT_32(14)
888/** Interface promiscuous mode policy: Deny the interface from requesting it. */
889#define INTNET_OPEN_FLAGS_IF_PROMISC_DENY RT_BIT_32(15)
890/** Interface promiscuous mode policy: See unrelated trunk traffic. */
891#define INTNET_OPEN_FLAGS_IF_PROMISC_SEE_TRUNK RT_BIT_32(16)
892/** Interface promiscuous mode policy: No unrelated trunk traffic visible. */
893#define INTNET_OPEN_FLAGS_IF_PROMISC_NO_TRUNK RT_BIT_32(17)
894
895/** Trunk policy: Fixed if set, changable if clear.
896 * @remarks The DISABLED options are considered more restrictive by
897 * INTNET_OPEN_FLAGS_REQUIRE_AS_RESTRICTIVE_POLICIES. */
898#define INTNET_OPEN_FLAGS_TRUNK_FIXED RT_BIT_32(18)
899/** Trunk policy: The host end should be enabled. */
900#define INTNET_OPEN_FLAGS_TRUNK_HOST_ENABLED RT_BIT_32(19)
901/** Trunk policy: The host end should be disabled. */
902#define INTNET_OPEN_FLAGS_TRUNK_HOST_DISABLED RT_BIT_32(20)
903/** Trunk policy: The host should only see packets destined for it. */
904#define INTNET_OPEN_FLAGS_TRUNK_HOST_CHASTE_MODE RT_BIT_32(21)
905/** Trunk policy: The host should see all packets. */
906#define INTNET_OPEN_FLAGS_TRUNK_HOST_PROMISC_MODE RT_BIT_32(22)
907/** Trunk policy: The wire end should be enabled. */
908#define INTNET_OPEN_FLAGS_TRUNK_WIRE_ENABLED RT_BIT_32(23)
909/** Trunk policy: The wire end should be disabled. */
910#define INTNET_OPEN_FLAGS_TRUNK_WIRE_DISABLED RT_BIT_32(24)
911/** Trunk policy: The wire should only see packets destined for it. */
912#define INTNET_OPEN_FLAGS_TRUNK_WIRE_CHASTE_MODE RT_BIT_32(25)
913/** Trunk policy: The wire should see all packets. */
914#define INTNET_OPEN_FLAGS_TRUNK_WIRE_PROMISC_MODE RT_BIT_32(26)
915
916/** Used to enable host specific workarounds.
917 *
918 * On darwin this will clear ip_tos in DHCP packets when
919 * INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE is also set. */
920#define INTNET_OPEN_FLAGS_WORKAROUND_1 RT_BIT_32(31)
921
922
923/** The mask of valid flags. */
924#define INTNET_OPEN_FLAGS_MASK UINT32_C(0x83ffffff)
925/** The mask of all flags use to fix (lock) settings. */
926#define INTNET_OPEN_FLAGS_FIXED_MASK \
927 ( INTNET_OPEN_FLAGS_ACCESS_FIXED \
928 | INTNET_OPEN_FLAGS_PROMISC_FIXED \
929 | INTNET_OPEN_FLAGS_IF_FIXED \
930 | INTNET_OPEN_FLAGS_TRUNK_FIXED )
931
932/** The mask of all policy pairs. */
933#define INTNET_OPEN_FLAGS_PAIR_MASK \
934 ( INTNET_OPEN_FLAGS_ACCESS_PUBLIC | INTNET_OPEN_FLAGS_ACCESS_RESTRICTED \
935 | INTNET_OPEN_FLAGS_PROMISC_ALLOW_CLIENTS | INTNET_OPEN_FLAGS_PROMISC_DENY_CLIENTS \
936 | INTNET_OPEN_FLAGS_PROMISC_ALLOW_TRUNK_HOST | INTNET_OPEN_FLAGS_PROMISC_DENY_TRUNK_HOST \
937 | INTNET_OPEN_FLAGS_PROMISC_ALLOW_TRUNK_WIRE | INTNET_OPEN_FLAGS_PROMISC_DENY_TRUNK_WIRE \
938 | INTNET_OPEN_FLAGS_IF_PROMISC_ALLOW | INTNET_OPEN_FLAGS_IF_PROMISC_DENY \
939 | INTNET_OPEN_FLAGS_IF_PROMISC_SEE_TRUNK | INTNET_OPEN_FLAGS_IF_PROMISC_NO_TRUNK \
940 | INTNET_OPEN_FLAGS_TRUNK_HOST_ENABLED | INTNET_OPEN_FLAGS_TRUNK_HOST_DISABLED \
941 | INTNET_OPEN_FLAGS_TRUNK_HOST_PROMISC_MODE | INTNET_OPEN_FLAGS_TRUNK_HOST_CHASTE_MODE \
942 | INTNET_OPEN_FLAGS_TRUNK_WIRE_ENABLED | INTNET_OPEN_FLAGS_TRUNK_WIRE_DISABLED \
943 | INTNET_OPEN_FLAGS_TRUNK_WIRE_PROMISC_MODE | INTNET_OPEN_FLAGS_TRUNK_WIRE_CHASTE_MODE \
944 )
945/** The mask of all relaxed policy bits. */
946#define INTNET_OPEN_FLAGS_RELAXED_MASK \
947 ( INTNET_OPEN_FLAGS_ACCESS_PUBLIC \
948 | INTNET_OPEN_FLAGS_PROMISC_ALLOW_CLIENTS \
949 | INTNET_OPEN_FLAGS_PROMISC_ALLOW_TRUNK_HOST \
950 | INTNET_OPEN_FLAGS_PROMISC_ALLOW_TRUNK_WIRE \
951 | INTNET_OPEN_FLAGS_IF_PROMISC_ALLOW \
952 | INTNET_OPEN_FLAGS_IF_PROMISC_SEE_TRUNK \
953 | INTNET_OPEN_FLAGS_TRUNK_HOST_ENABLED \
954 | INTNET_OPEN_FLAGS_TRUNK_WIRE_PROMISC_MODE \
955 | INTNET_OPEN_FLAGS_TRUNK_WIRE_ENABLED \
956 | INTNET_OPEN_FLAGS_TRUNK_WIRE_PROMISC_MODE \
957 )
958/** The mask of all strict policy bits. */
959#define INTNET_OPEN_FLAGS_STRICT_MASK \
960 ( INTNET_OPEN_FLAGS_ACCESS_RESTRICTED \
961 | INTNET_OPEN_FLAGS_PROMISC_DENY_CLIENTS \
962 | INTNET_OPEN_FLAGS_PROMISC_DENY_TRUNK_HOST \
963 | INTNET_OPEN_FLAGS_PROMISC_DENY_TRUNK_WIRE \
964 | INTNET_OPEN_FLAGS_IF_PROMISC_DENY \
965 | INTNET_OPEN_FLAGS_IF_PROMISC_NO_TRUNK \
966 | INTNET_OPEN_FLAGS_TRUNK_HOST_DISABLED \
967 | INTNET_OPEN_FLAGS_TRUNK_HOST_CHASTE_MODE \
968 | INTNET_OPEN_FLAGS_TRUNK_WIRE_DISABLED \
969 | INTNET_OPEN_FLAGS_TRUNK_WIRE_CHASTE_MODE \
970 )
971/** @} */
972
973/** The maximum length of a network name. */
974#define INTNET_MAX_NETWORK_NAME 128
975
976/** The maximum length of a trunk name. */
977#define INTNET_MAX_TRUNK_NAME 64
978
979
980/**
981 * Request buffer for IntNetR0OpenReq / VMMR0_DO_INTNET_OPEN.
982 * @see IntNetR0Open.
983 */
984typedef struct INTNETOPENREQ
985{
986 /** The request header. */
987 SUPVMMR0REQHDR Hdr;
988 /** Alternative to passing the taking the session from the VM handle.
989 * Either use this member or use the VM handle, don't do both. */
990 PSUPDRVSESSION pSession;
991 /** The network name. (input) */
992 char szNetwork[INTNET_MAX_NETWORK_NAME];
993 /** What to connect to the trunk port. (input)
994 * This is specific to the trunk type below. */
995 char szTrunk[INTNET_MAX_TRUNK_NAME];
996 /** The type of trunk link (NAT, Filter, TAP, etc). (input) */
997 INTNETTRUNKTYPE enmTrunkType;
998 /** Flags, see INTNET_OPEN_FLAGS_*. (input) */
999 uint32_t fFlags;
1000 /** The size of the send buffer. (input) */
1001 uint32_t cbSend;
1002 /** The size of the receive buffer. (input) */
1003 uint32_t cbRecv;
1004 /** The handle to the network interface. (output) */
1005 INTNETIFHANDLE hIf;
1006} INTNETOPENREQ;
1007/** Pointer to an IntNetR0OpenReq / VMMR0_DO_INTNET_OPEN request buffer. */
1008typedef INTNETOPENREQ *PINTNETOPENREQ;
1009
1010INTNETR0DECL(int) IntNetR0OpenReq(PSUPDRVSESSION pSession, PINTNETOPENREQ pReq);
1011
1012
1013/**
1014 * Request buffer for IntNetR0IfCloseReq / VMMR0_DO_INTNET_IF_CLOSE.
1015 * @see IntNetR0IfClose.
1016 */
1017typedef struct INTNETIFCLOSEREQ
1018{
1019 /** The request header. */
1020 SUPVMMR0REQHDR Hdr;
1021 /** Alternative to passing the taking the session from the VM handle.
1022 * Either use this member or use the VM handle, don't do both. */
1023 PSUPDRVSESSION pSession;
1024 /** The handle to the network interface. */
1025 INTNETIFHANDLE hIf;
1026} INTNETIFCLOSEREQ;
1027/** Pointer to an IntNetR0IfCloseReq / VMMR0_DO_INTNET_IF_CLOSE request
1028 * buffer. */
1029typedef INTNETIFCLOSEREQ *PINTNETIFCLOSEREQ;
1030
1031INTNETR0DECL(int) IntNetR0IfCloseReq(PSUPDRVSESSION pSession, PINTNETIFCLOSEREQ pReq);
1032
1033
1034/**
1035 * Request buffer for IntNetR0IfGetRing3BufferReq /
1036 * VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS.
1037 * @see IntNetR0IfGetRing3Buffer.
1038 */
1039typedef struct INTNETIFGETBUFFERPTRSREQ
1040{
1041 /** The request header. */
1042 SUPVMMR0REQHDR Hdr;
1043 /** Alternative to passing the taking the session from the VM handle.
1044 * Either use this member or use the VM handle, don't do both. */
1045 PSUPDRVSESSION pSession;
1046 /** Handle to the interface. */
1047 INTNETIFHANDLE hIf;
1048 /** The pointer to the ring-3 buffer. (output) */
1049 R3PTRTYPE(PINTNETBUF) pRing3Buf;
1050 /** The pointer to the ring-0 buffer. (output) */
1051 R0PTRTYPE(PINTNETBUF) pRing0Buf;
1052} INTNETIFGETBUFFERPTRSREQ;
1053/** Pointer to an IntNetR0IfGetRing3BufferReq /
1054 * VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS request buffer. */
1055typedef INTNETIFGETBUFFERPTRSREQ *PINTNETIFGETBUFFERPTRSREQ;
1056
1057INTNETR0DECL(int) IntNetR0IfGetBufferPtrsReq(PSUPDRVSESSION pSession, PINTNETIFGETBUFFERPTRSREQ pReq);
1058
1059
1060/**
1061 * Request buffer for IntNetR0IfSetPromiscuousModeReq /
1062 * VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE.
1063 * @see IntNetR0IfSetPromiscuousMode.
1064 */
1065typedef struct INTNETIFSETPROMISCUOUSMODEREQ
1066{
1067 /** The request header. */
1068 SUPVMMR0REQHDR Hdr;
1069 /** Alternative to passing the taking the session from the VM handle.
1070 * Either use this member or use the VM handle, don't do both. */
1071 PSUPDRVSESSION pSession;
1072 /** Handle to the interface. */
1073 INTNETIFHANDLE hIf;
1074 /** The new promiscuous mode. */
1075 bool fPromiscuous;
1076} INTNETIFSETPROMISCUOUSMODEREQ;
1077/** Pointer to an IntNetR0IfSetPromiscuousModeReq /
1078 * VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE request buffer. */
1079typedef INTNETIFSETPROMISCUOUSMODEREQ *PINTNETIFSETPROMISCUOUSMODEREQ;
1080
1081INTNETR0DECL(int) IntNetR0IfSetPromiscuousModeReq(PSUPDRVSESSION pSession, PINTNETIFSETPROMISCUOUSMODEREQ pReq);
1082
1083
1084/**
1085 * Request buffer for IntNetR0IfSetMacAddressReq /
1086 * VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS.
1087 * @see IntNetR0IfSetMacAddress.
1088 */
1089typedef struct INTNETIFSETMACADDRESSREQ
1090{
1091 /** The request header. */
1092 SUPVMMR0REQHDR Hdr;
1093 /** Alternative to passing the taking the session from the VM handle.
1094 * Either use this member or use the VM handle, don't do both. */
1095 PSUPDRVSESSION pSession;
1096 /** Handle to the interface. */
1097 INTNETIFHANDLE hIf;
1098 /** The new MAC address. */
1099 RTMAC Mac;
1100} INTNETIFSETMACADDRESSREQ;
1101/** Pointer to an IntNetR0IfSetMacAddressReq /
1102 * VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS request buffer. */
1103typedef INTNETIFSETMACADDRESSREQ *PINTNETIFSETMACADDRESSREQ;
1104
1105INTNETR0DECL(int) IntNetR0IfSetMacAddressReq(PSUPDRVSESSION pSession, PINTNETIFSETMACADDRESSREQ pReq);
1106
1107
1108/**
1109 * Request buffer for IntNetR0IfSetActiveReq / VMMR0_DO_INTNET_IF_SET_ACTIVE.
1110 * @see IntNetR0IfSetActive.
1111 */
1112typedef struct INTNETIFSETACTIVEREQ
1113{
1114 /** The request header. */
1115 SUPVMMR0REQHDR Hdr;
1116 /** Alternative to passing the taking the session from the VM handle.
1117 * Either use this member or use the VM handle, don't do both. */
1118 PSUPDRVSESSION pSession;
1119 /** Handle to the interface. */
1120 INTNETIFHANDLE hIf;
1121 /** The new state. */
1122 bool fActive;
1123} INTNETIFSETACTIVEREQ;
1124/** Pointer to an IntNetR0IfSetActiveReq / VMMR0_DO_INTNET_IF_SET_ACTIVE
1125 * request buffer. */
1126typedef INTNETIFSETACTIVEREQ *PINTNETIFSETACTIVEREQ;
1127
1128INTNETR0DECL(int) IntNetR0IfSetActiveReq(PSUPDRVSESSION pSession, PINTNETIFSETACTIVEREQ pReq);
1129
1130
1131/**
1132 * Request buffer for IntNetR0IfSendReq / VMMR0_DO_INTNET_IF_SEND.
1133 * @see IntNetR0IfSend.
1134 */
1135typedef struct INTNETIFSENDREQ
1136{
1137 /** The request header. */
1138 SUPVMMR0REQHDR Hdr;
1139 /** Alternative to passing the taking the session from the VM handle.
1140 * Either use this member or use the VM handle, don't do both. */
1141 PSUPDRVSESSION pSession;
1142 /** Handle to the interface. */
1143 INTNETIFHANDLE hIf;
1144} INTNETIFSENDREQ;
1145/** Pointer to an IntNetR0IfSend() argument package. */
1146typedef INTNETIFSENDREQ *PINTNETIFSENDREQ;
1147
1148INTNETR0DECL(int) IntNetR0IfSendReq(PSUPDRVSESSION pSession, PINTNETIFSENDREQ pReq);
1149
1150
1151/**
1152 * Request buffer for IntNetR0IfWaitReq / VMMR0_DO_INTNET_IF_WAIT.
1153 * @see IntNetR0IfWait.
1154 */
1155typedef struct INTNETIFWAITREQ
1156{
1157 /** The request header. */
1158 SUPVMMR0REQHDR Hdr;
1159 /** Alternative to passing the taking the session from the VM handle.
1160 * Either use this member or use the VM handle, don't do both. */
1161 PSUPDRVSESSION pSession;
1162 /** Handle to the interface. */
1163 INTNETIFHANDLE hIf;
1164 /** The number of milliseconds to wait. */
1165 uint32_t cMillies;
1166} INTNETIFWAITREQ;
1167/** Pointer to an IntNetR0IfWaitReq / VMMR0_DO_INTNET_IF_WAIT request buffer. */
1168typedef INTNETIFWAITREQ *PINTNETIFWAITREQ;
1169
1170INTNETR0DECL(int) IntNetR0IfWaitReq(PSUPDRVSESSION pSession, PINTNETIFWAITREQ pReq);
1171
1172
1173/**
1174 * Request buffer for IntNetR0IfAbortWaitReq / VMMR0_DO_INTNET_IF_ABORT_WAIT.
1175 * @see IntNetR0IfAbortWait.
1176 */
1177typedef struct INTNETIFABORTWAITREQ
1178{
1179 /** The request header. */
1180 SUPVMMR0REQHDR Hdr;
1181 /** Alternative to passing the taking the session from the VM handle.
1182 * Either use this member or use the VM handle, don't do both. */
1183 PSUPDRVSESSION pSession;
1184 /** Handle to the interface. */
1185 INTNETIFHANDLE hIf;
1186 /** Set this to fend off all future IntNetR0Wait calls. */
1187 bool fNoMoreWaits;
1188} INTNETIFABORTWAITREQ;
1189/** Pointer to an IntNetR0IfAbortWaitReq / VMMR0_DO_INTNET_IF_ABORT_WAIT
1190 * request buffer. */
1191typedef INTNETIFABORTWAITREQ *PINTNETIFABORTWAITREQ;
1192
1193INTNETR0DECL(int) IntNetR0IfAbortWaitReq(PSUPDRVSESSION pSession, PINTNETIFABORTWAITREQ pReq);
1194
1195
1196#if defined(IN_RING0) || defined(IN_INTNET_TESTCASE)
1197/** @name
1198 * @{
1199 */
1200
1201INTNETR0DECL(int) IntNetR0Init(void);
1202INTNETR0DECL(void) IntNetR0Term(void);
1203INTNETR0DECL(int) IntNetR0Open(PSUPDRVSESSION pSession, const char *pszNetwork,
1204 INTNETTRUNKTYPE enmTrunkType, const char *pszTrunk, uint32_t fFlags,
1205 uint32_t cbSend, uint32_t cbRecv, PINTNETIFHANDLE phIf);
1206INTNETR0DECL(uint32_t) IntNetR0GetNetworkCount(void);
1207
1208INTNETR0DECL(int) IntNetR0IfClose(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession);
1209INTNETR0DECL(int) IntNetR0IfGetBufferPtrs(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession,
1210 R3PTRTYPE(PINTNETBUF) *ppRing3Buf, R0PTRTYPE(PINTNETBUF) *ppRing0Buf);
1211INTNETR0DECL(int) IntNetR0IfSetPromiscuousMode(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, bool fPromiscuous);
1212INTNETR0DECL(int) IntNetR0IfSetMacAddress(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, PCRTMAC pMac);
1213INTNETR0DECL(int) IntNetR0IfSetActive(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, bool fActive);
1214INTNETR0DECL(int) IntNetR0IfSend(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession);
1215INTNETR0DECL(int) IntNetR0IfWait(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, uint32_t cMillies);
1216INTNETR0DECL(int) IntNetR0IfAbortWait(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession);
1217
1218/** @} */
1219#endif /* IN_RING0 */
1220
1221RT_C_DECLS_END
1222
1223#endif
Note: See TracBrowser for help on using the repository browser.

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