[1] | 1 | /** @file
|
---|
| 2 | * INETNET - Internal Networking.
|
---|
| 3 | */
|
---|
| 4 |
|
---|
| 5 | /*
|
---|
[8155] | 6 | * Copyright (C) 2006-2007 Sun Microsystems, Inc.
|
---|
[1] | 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
|
---|
[5999] | 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.
|
---|
[8155] | 24 | *
|
---|
| 25 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
|
---|
| 26 | * Clara, CA 95054 USA or visit http://www.sun.com if you need
|
---|
| 27 | * additional information or have any questions.
|
---|
[1] | 28 | */
|
---|
| 29 |
|
---|
[3632] | 30 | #ifndef ___VBox_intnet_h
|
---|
| 31 | #define ___VBox_intnet_h
|
---|
[1] | 32 |
|
---|
| 33 | #include <VBox/types.h>
|
---|
| 34 | #include <VBox/stam.h>
|
---|
[5283] | 35 | #include <VBox/sup.h>
|
---|
[1] | 36 | #include <iprt/assert.h>
|
---|
| 37 | #include <iprt/asm.h>
|
---|
| 38 |
|
---|
| 39 | __BEGIN_DECLS
|
---|
| 40 |
|
---|
| 41 |
|
---|
[5283] | 42 | /** Pointer to an internal network ring-0 instance. */
|
---|
| 43 | typedef struct INTNET *PINTNET;
|
---|
| 44 |
|
---|
[1] | 45 | /**
|
---|
| 46 | * Generic two-sided ring buffer.
|
---|
| 47 | *
|
---|
| 48 | * The deal is that there is exactly one writer and one reader.
|
---|
| 49 | * When offRead equals offWrite the buffer is empty. In the other
|
---|
| 50 | * extreme the writer will not use the last free byte in the buffer.
|
---|
| 51 | */
|
---|
| 52 | typedef struct INTNETRINGBUF
|
---|
| 53 | {
|
---|
| 54 | /** The start of the buffer offset relative to the. (inclusive) */
|
---|
| 55 | uint32_t offStart;
|
---|
| 56 | /** The offset to the end of the buffer. (exclusive) */
|
---|
| 57 | uint32_t offEnd;
|
---|
| 58 | /** The current read offset. */
|
---|
| 59 | uint32_t volatile offRead;
|
---|
| 60 | /** The current write offset. */
|
---|
| 61 | uint32_t volatile offWrite;
|
---|
| 62 | } INTNETRINGBUF;
|
---|
| 63 | /** Pointer to a ring buffer. */
|
---|
| 64 | typedef INTNETRINGBUF *PINTNETRINGBUF;
|
---|
| 65 |
|
---|
| 66 | /**
|
---|
| 67 | * Get the amount of space available for writing.
|
---|
| 68 | *
|
---|
| 69 | * @returns Number of available bytes.
|
---|
| 70 | * @param pRingBuf The ring buffer.
|
---|
| 71 | */
|
---|
| 72 | DECLINLINE(uint32_t) INTNETRingGetWritable(PINTNETRINGBUF pRingBuf)
|
---|
| 73 | {
|
---|
| 74 | return pRingBuf->offRead <= pRingBuf->offWrite
|
---|
| 75 | ? pRingBuf->offEnd - pRingBuf->offWrite + pRingBuf->offRead - pRingBuf->offStart - 1
|
---|
| 76 | : pRingBuf->offRead - pRingBuf->offWrite - 1;
|
---|
| 77 | }
|
---|
| 78 |
|
---|
| 79 |
|
---|
| 80 | /**
|
---|
| 81 | * Get the amount of data ready for reading.
|
---|
| 82 | *
|
---|
| 83 | * @returns Number of ready bytes.
|
---|
| 84 | * @param pRingBuf The ring buffer.
|
---|
| 85 | */
|
---|
| 86 | DECLINLINE(uint32_t) INTNETRingGetReadable(PINTNETRINGBUF pRingBuf)
|
---|
| 87 | {
|
---|
| 88 | return pRingBuf->offRead <= pRingBuf->offWrite
|
---|
| 89 | ? pRingBuf->offWrite - pRingBuf->offRead
|
---|
| 90 | : pRingBuf->offEnd - pRingBuf->offRead + pRingBuf->offWrite - pRingBuf->offStart;
|
---|
| 91 | }
|
---|
| 92 |
|
---|
| 93 |
|
---|
| 94 | /**
|
---|
| 95 | * A interface buffer.
|
---|
| 96 | */
|
---|
| 97 | typedef struct INTNETBUF
|
---|
| 98 | {
|
---|
| 99 | /** The size of the entire buffer. */
|
---|
| 100 | uint32_t cbBuf;
|
---|
| 101 | /** The size of the send area. */
|
---|
| 102 | uint32_t cbSend;
|
---|
| 103 | /** The size of the receive area. */
|
---|
| 104 | uint32_t cbRecv;
|
---|
| 105 | /** The receive buffer. */
|
---|
| 106 | INTNETRINGBUF Recv;
|
---|
| 107 | /** The send buffer. */
|
---|
| 108 | INTNETRINGBUF Send;
|
---|
| 109 | /** Number of times yields help solve an overflow. */
|
---|
| 110 | STAMCOUNTER cStatYieldsOk;
|
---|
| 111 | /** Number of times yields didn't help solve an overflow. */
|
---|
| 112 | STAMCOUNTER cStatYieldsNok;
|
---|
| 113 | /** Number of lost packets due to overflows. */
|
---|
| 114 | STAMCOUNTER cStatLost;
|
---|
| 115 | /** Number of packets received (not counting lost ones). */
|
---|
| 116 | STAMCOUNTER cStatRecvs;
|
---|
| 117 | /** Number of frame bytes received (not couting lost frames). */
|
---|
| 118 | STAMCOUNTER cbStatRecv;
|
---|
| 119 | /** Number of packets received. */
|
---|
| 120 | STAMCOUNTER cStatSends;
|
---|
| 121 | /** Number of frame bytes sent. */
|
---|
| 122 | STAMCOUNTER cbStatSend;
|
---|
| 123 | } INTNETBUF;
|
---|
[9735] | 124 | /** Pointer to an interface buffer. */
|
---|
[1] | 125 | typedef INTNETBUF *PINTNETBUF;
|
---|
[9735] | 126 | /** Pointer to a const interface buffer. */
|
---|
| 127 | typedef INTNETBUF const *PCINTNETBUF;
|
---|
[1] | 128 |
|
---|
| 129 | /** Internal networking interface handle. */
|
---|
| 130 | typedef uint32_t INTNETIFHANDLE;
|
---|
| 131 | /** Pointer to an internal networking interface handle. */
|
---|
| 132 | typedef INTNETIFHANDLE *PINTNETIFHANDLE;
|
---|
| 133 |
|
---|
| 134 | /** Or mask to obscure the handle index. */
|
---|
| 135 | #define INTNET_HANDLE_MAGIC 0x88880000
|
---|
| 136 | /** Mask to extract the handle index. */
|
---|
| 137 | #define INTNET_HANDLE_INDEX_MASK 0xffff
|
---|
| 138 | /** The maximum number of handles (exclusive) */
|
---|
| 139 | #define INTNET_HANDLE_MAX 0xffff
|
---|
| 140 | /** Invalid handle. */
|
---|
| 141 | #define INTNET_HANDLE_INVALID (0)
|
---|
| 142 |
|
---|
| 143 |
|
---|
| 144 | /**
|
---|
| 145 | * The packet header.
|
---|
| 146 | *
|
---|
| 147 | * The header is intentionally 8 bytes long. It will always
|
---|
| 148 | * start at an 8 byte aligned address. Assuming that the buffer
|
---|
| 149 | * size is a multiple of 8 bytes, that means that we can guarantee
|
---|
| 150 | * that the entire header is contiguous in both virtual and physical
|
---|
| 151 | * memory.
|
---|
| 152 | */
|
---|
| 153 | #pragma pack(1)
|
---|
| 154 | typedef struct INTNETHDR
|
---|
| 155 | {
|
---|
| 156 | /** Header type. This is currently serving as a magic, it
|
---|
[9735] | 157 | * can be extended later to encode special command packets and stuff. */
|
---|
[1] | 158 | uint16_t u16Type;
|
---|
| 159 | /** The size of the frame. */
|
---|
| 160 | uint16_t cbFrame;
|
---|
| 161 | /** The offset from the start of this header to where the actual frame starts.
|
---|
| 162 | * This is used to keep the frame it self continguous in virtual memory and
|
---|
| 163 | * thereby both simplify reading and */
|
---|
| 164 | int32_t offFrame;
|
---|
[9735] | 165 | } INTNETHDR;
|
---|
[1] | 166 | #pragma pack()
|
---|
[9735] | 167 | /** Pointer to a packet header.*/
|
---|
| 168 | typedef INTNETHDR *PINTNETHDR;
|
---|
| 169 | /** Pointer to a const packet header.*/
|
---|
| 170 | typedef INTNETHDR const *PCINTNETHDR;
|
---|
[1] | 171 |
|
---|
| 172 | /** INTNETHDR::u16Type value for normal frames. */
|
---|
| 173 | #define INTNETHDR_TYPE_FRAME 0x2442
|
---|
| 174 |
|
---|
| 175 |
|
---|
| 176 | /**
|
---|
| 177 | * Calculates the pointer to the frame.
|
---|
| 178 | *
|
---|
| 179 | * @returns Pointer to the start of the frame.
|
---|
| 180 | * @param pHdr Pointer to the packet header
|
---|
| 181 | * @param pBuf The buffer the header is within. Only used in strict builds.
|
---|
| 182 | */
|
---|
[9735] | 183 | DECLINLINE(void *) INTNETHdrGetFramePtr(PCINTNETHDR pHdr, PCINTNETBUF pBuf)
|
---|
[1] | 184 | {
|
---|
| 185 | uint8_t *pu8 = (uint8_t *)pHdr + pHdr->offFrame;
|
---|
| 186 | #ifdef VBOX_STRICT
|
---|
| 187 | const uintptr_t off = (uintptr_t)pu8 - (uintptr_t)pBuf;
|
---|
| 188 | Assert(pHdr->u16Type == INTNETHDR_TYPE_FRAME);
|
---|
| 189 | Assert(off < pBuf->cbBuf);
|
---|
[5283] | 190 | Assert(off + pHdr->cbFrame <= pBuf->cbBuf);
|
---|
[1] | 191 | #endif
|
---|
| 192 | NOREF(pBuf);
|
---|
| 193 | return pu8;
|
---|
| 194 | }
|
---|
| 195 |
|
---|
| 196 |
|
---|
| 197 | /**
|
---|
| 198 | * Skips to the next (read) frame in the buffer.
|
---|
| 199 | *
|
---|
| 200 | * @param pBuf The buffer.
|
---|
| 201 | * @param pRingBuf The ring buffer in question.
|
---|
| 202 | */
|
---|
| 203 | DECLINLINE(void) INTNETRingSkipFrame(PINTNETBUF pBuf, PINTNETRINGBUF pRingBuf)
|
---|
| 204 | {
|
---|
| 205 | Assert(pRingBuf->offRead < pBuf->cbBuf);
|
---|
| 206 | Assert(pRingBuf->offRead >= pRingBuf->offStart);
|
---|
| 207 | Assert(pRingBuf->offRead < pRingBuf->offEnd);
|
---|
| 208 | uint32_t offRead = pRingBuf->offRead;
|
---|
| 209 | PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pBuf + offRead);
|
---|
| 210 |
|
---|
| 211 | /* skip the frame */
|
---|
| 212 | offRead += pHdr->offFrame + pHdr->cbFrame;
|
---|
| 213 | offRead = RT_ALIGN_32(offRead, sizeof(INTNETHDR));
|
---|
| 214 | Assert(offRead <= pRingBuf->offEnd && offRead >= pRingBuf->offStart);
|
---|
| 215 | if (offRead >= pRingBuf->offEnd)
|
---|
| 216 | offRead = pRingBuf->offStart;
|
---|
| 217 | ASMAtomicXchgU32(&pRingBuf->offRead, offRead);
|
---|
| 218 | }
|
---|
| 219 |
|
---|
[9735] | 220 |
|
---|
| 221 | /**
|
---|
| 222 | * Scatter / Gather segment (internal networking).
|
---|
| 223 | */
|
---|
| 224 | typedef struct INTNETSEG
|
---|
| 225 | {
|
---|
| 226 | /** The physical address. NIL_RTHCPHYS is not set. */
|
---|
| 227 | RTHCPHYS Phys;
|
---|
| 228 | /** Pointer to the segment data. */
|
---|
| 229 | void *pv;
|
---|
| 230 | /** The segment size. */
|
---|
| 231 | uint32_t cb;
|
---|
| 232 | } INTNETSEG;
|
---|
| 233 | /** Pointer to a internal networking packet segment. */
|
---|
| 234 | typedef INTNETSEG *PINTNETSEG;
|
---|
| 235 | /** Pointer to a internal networking packet segment. */
|
---|
| 236 | typedef INTNETSEG const *PCINTNETSEG;
|
---|
| 237 |
|
---|
| 238 |
|
---|
| 239 | /**
|
---|
| 240 | * Scatter / Gather list (internal networking).
|
---|
| 241 | *
|
---|
| 242 | * This is used when communicating with the trunk port.
|
---|
| 243 | */
|
---|
| 244 | typedef struct INTNETSG
|
---|
| 245 | {
|
---|
| 246 | /** The total length of the scatter gather list. */
|
---|
| 247 | uint32_t cbTotal;
|
---|
| 248 | /** The number of users (references).
|
---|
| 249 | * This is used by the SGRelease code to decide when it can be freed. */
|
---|
| 250 | uint16_t volatile cUsers;
|
---|
| 251 | /** Flags, see INTNETSG_FLAGS_* */
|
---|
| 252 | uint16_t volatile fFlags;
|
---|
| 253 | /** The number of segments allocated. */
|
---|
| 254 | uint16_t cSegsAlloc;
|
---|
| 255 | /** The number of segments actually used. */
|
---|
| 256 | uint16_t cSegsUsed;
|
---|
| 257 | /** Variable sized list of segments. */
|
---|
| 258 | INTNETSEG aSegs[1];
|
---|
| 259 | } INTNETSG;
|
---|
| 260 | /** Pointer to a scatter / gather list. */
|
---|
| 261 | typedef INTNETSG *PINTNETSG;
|
---|
| 262 | /** Pointer to a const scatter / gather list. */
|
---|
| 263 | typedef INTNETSG const *PCINTNETSG;
|
---|
| 264 |
|
---|
| 265 | /** @name INTNETSG::fFlags definitions.
|
---|
| 266 | * @{ */
|
---|
| 267 | /** Set if the SG is free. */
|
---|
| 268 | #define INTNETSG_FLAGS_FREE RT_BIT_32(1)
|
---|
| 269 | /** Set if the SG is a temporary one that will become invalid upon return.
|
---|
| 270 | * Try to finish using it before returning, and if that's not possible copy
|
---|
| 271 | * to other buffers.
|
---|
| 272 | * When not set, the callee should always free the SG.
|
---|
| 273 | * Attempts to free it made by the callee will be quietly ignored. */
|
---|
| 274 | #define INTNETSG_FLAGS_TEMP RT_BIT_32(2)
|
---|
| 275 | /** @} */
|
---|
| 276 |
|
---|
| 277 |
|
---|
| 278 | /**
|
---|
| 279 | * Initializes a scatter / gather buffer from a internal networking packet.
|
---|
| 280 | *
|
---|
| 281 | * @returns Pointer to the start of the frame.
|
---|
| 282 | * @param pSG Pointer to the scatter / gather structure.
|
---|
| 283 | * (The fFlags, cUsers, and cSegsAlloc members are left untouched.)
|
---|
| 284 | * @param pHdr Pointer to the packet header.
|
---|
| 285 | * @param pBuf The buffer the header is within. Only used in strict builds.
|
---|
| 286 | * @remarks Perhaps move this...
|
---|
| 287 | */
|
---|
| 288 | DECLINLINE(void) INTNETSgInitFromPkt(PINTNETSG pSG, PCINTNETHDR pPktHdr, PCINTNETBUF pBuf)
|
---|
| 289 | {
|
---|
| 290 | pSG->cSegsUsed = 1;
|
---|
| 291 | pSG->cbTotal = pSG->aSegs[0].cb = pPktHdr->cbFrame;
|
---|
| 292 | pSG->aSegs[0].pv = INTNETHdrGetFramePtr(pPktHdr, pBuf);
|
---|
| 293 | pSG->aSegs[0].Phys = NIL_RTHCPHYS;
|
---|
| 294 | }
|
---|
| 295 |
|
---|
| 296 |
|
---|
| 297 |
|
---|
| 298 | /** Pointer to the switch side of a trunk port. */
|
---|
| 299 | typedef struct INTNETTRUNKSWPORT *PINTNETTRUNKSWPORT;
|
---|
| 300 | /**
|
---|
| 301 | * This is the port on the internal network 'switch', i.e.
|
---|
| 302 | * what the driver is connected to.
|
---|
| 303 | *
|
---|
| 304 | * This is only used for the in-kernel trunk connections.
|
---|
| 305 | */
|
---|
| 306 | typedef struct INTNETTRUNKSWPORT
|
---|
| 307 | {
|
---|
| 308 | /** Structure version number. (INTNETTRUNKSWPORT_VERSION) */
|
---|
| 309 | uint32_t u32Version;
|
---|
| 310 |
|
---|
| 311 | /**
|
---|
| 312 | * Selects whether outgoing SGs should have their physical address set.
|
---|
| 313 | *
|
---|
| 314 | * By enabling physical addresses in the scatter / gather segments it should
|
---|
| 315 | * be possible to save some unnecessary address translation and memory locking
|
---|
| 316 | * in the network stack. (Internal networking knows the physical address for
|
---|
| 317 | * all the INTNETBUF data and that it's locked memory.) There is a negative
|
---|
| 318 | * side effects though, frames that crosses page boundraries will require
|
---|
| 319 | * multiple scather / gather segments.
|
---|
| 320 | *
|
---|
| 321 | * @returns The old setting.
|
---|
| 322 | *
|
---|
| 323 | * @param pIfPort Pointer to this structure.
|
---|
| 324 | * @param fEnable Whether to enable or disable it.
|
---|
| 325 | *
|
---|
| 326 | * @remarks Will grab the network semaphore.
|
---|
| 327 | */
|
---|
| 328 | DECLR0CALLBACKMEMBER(bool, pfnSetSGPhys,(PINTNETTRUNKSWPORT pIfPort, bool fEnable));
|
---|
| 329 |
|
---|
| 330 | /**
|
---|
| 331 | * Frame from the host that's about to hit the wire.
|
---|
| 332 | *
|
---|
| 333 | * @returns true if we've handled it and it should be dropped.
|
---|
| 334 | * false if it should hit the wire.
|
---|
| 335 | *
|
---|
| 336 | * @param pIfPort Pointer to this structure.
|
---|
| 337 | * @param pSG The (scatter /) gather structure for the frame.
|
---|
| 338 | * This will only be use during the call, so a temporary one can
|
---|
| 339 | * be used. The Phys member will not be used.
|
---|
| 340 | *
|
---|
| 341 | * @remarks Will grab the network semaphore.
|
---|
| 342 | *
|
---|
| 343 | * @remark NAT and TAP will use this interface.
|
---|
| 344 | */
|
---|
| 345 | DECLR0CALLBACKMEMBER(bool, pfnRecvHost,(PINTNETTRUNKSWPORT pIfPort, PINTNETSG pSG));
|
---|
| 346 |
|
---|
| 347 | /**
|
---|
| 348 | * Frame from the wire that's about to hit the network stack.
|
---|
| 349 | *
|
---|
| 350 | * @returns true if we've handled it and it should be dropped.
|
---|
| 351 | * false if it should hit the network stack.
|
---|
| 352 | *
|
---|
| 353 | * @param pIfPort Pointer to this structure.
|
---|
| 354 | * @param pSG The (scatter /) gather structure for the frame.
|
---|
| 355 | * This will only be use during the call, so a temporary one can
|
---|
| 356 | * be used. The Phys member will not be used.
|
---|
| 357 | *
|
---|
| 358 | * @remarks Will grab the network semaphore.
|
---|
| 359 | *
|
---|
| 360 | * @remark NAT and TAP will not this interface.
|
---|
| 361 | */
|
---|
| 362 | DECLR0CALLBACKMEMBER(bool, pfnRecvWire,(PINTNETTRUNKSWPORT pIfPort, PINTNETSG pSG));
|
---|
| 363 |
|
---|
| 364 | /** Structure version number. (INTNETTRUNKSWPORT_VERSION) */
|
---|
| 365 | uint32_t u32VersionEnd;
|
---|
| 366 | } INTNETTRUNKSWPORT;
|
---|
| 367 |
|
---|
| 368 | /** Version number for the INTNETTRUNKIFPORT::u32Version and INTNETTRUNKIFPORT::u32VersionEnd fields. */
|
---|
| 369 | #define INTNETTRUNKSWPORT_VERSION UINT32_C(0xA2CDf001)
|
---|
| 370 |
|
---|
| 371 |
|
---|
| 372 | /** Pointer to the interface side of a trunk port. */
|
---|
| 373 | typedef struct INTNETTRUNKIFPORT *PINTNETTRUNKIFPORT;
|
---|
| 374 | /**
|
---|
| 375 | * This is the port on the trunk interface, i.e. the driver
|
---|
| 376 | * side which the internal network is connected to.
|
---|
| 377 | *
|
---|
| 378 | * This is only used for the in-kernel trunk connections.
|
---|
| 379 | */
|
---|
| 380 | typedef struct INTNETTRUNKIFPORT
|
---|
| 381 | {
|
---|
| 382 | /** Structure version number. (INTNETTRUNKIFPORT_VERSION) */
|
---|
| 383 | uint32_t u32Version;
|
---|
| 384 |
|
---|
| 385 | /**
|
---|
| 386 | * Changes the active state of the interface.
|
---|
| 387 | *
|
---|
| 388 | * The interface is created in the suspended (non-active) state and then activated
|
---|
| 389 | * when the VM/network is started. It may be suspended and re-activated later
|
---|
| 390 | * for various reasons. It will finally be suspended again before disconnecting
|
---|
| 391 | * the interface from the internal network, however, this might be done immediately
|
---|
| 392 | * before disconnecting and may leave an incoming frame waiting on the internal network
|
---|
| 393 | * semaphore.
|
---|
| 394 | *
|
---|
| 395 | * @returns The previous state.
|
---|
| 396 | *
|
---|
| 397 | * @param pIfPort Pointer to this structure.
|
---|
| 398 | * @param fActive True if the new state is 'active', false if the new state is 'suspended'.
|
---|
| 399 | *
|
---|
| 400 | * @remarks Called while owning the network semaphore.
|
---|
| 401 | */
|
---|
| 402 | DECLR0CALLBACKMEMBER(bool, pfnSetActive,(PINTNETTRUNKIFPORT pIfPort, bool fActive));
|
---|
| 403 |
|
---|
| 404 | /**
|
---|
| 405 | * Tests if the mac address belongs to any of the host NICs
|
---|
| 406 | * and should take the pfnSendToHost route.
|
---|
| 407 | *
|
---|
| 408 | * @returns true / false.
|
---|
| 409 | *
|
---|
| 410 | * @param pIfPort Pointer to this structure.
|
---|
| 411 | * @param pvMac Pointer to the mac address. This can be cast to PCPDMMAC (fixme: make it an common type?)
|
---|
| 412 | *
|
---|
| 413 | * @remarks Called while owning the network semaphore.
|
---|
| 414 | *
|
---|
| 415 | * @remarks TAP and NAT will compare with their own MAC address and let all their
|
---|
| 416 | * traffic go over the pfnSendToHost method.
|
---|
| 417 | */
|
---|
| 418 | DECLR0CALLBACKMEMBER(bool, pfnIsHostMac,(PINTNETTRUNKIFPORT pIfPort, /*PCPDMMAC*/ void const *pvMac));
|
---|
| 419 |
|
---|
| 420 | /**
|
---|
| 421 | * Tests whether the host is operating the interface is promiscuous mode.
|
---|
| 422 | *
|
---|
| 423 | * The default behavior of internal networking 'switch' is to 'autodetect'
|
---|
| 424 | * promiscuous mode on the trunk port, which is where this method is used.
|
---|
| 425 | * For security reasons this default my of course be overridden so that the
|
---|
| 426 | * host cannot sniff at what's going on.
|
---|
| 427 | *
|
---|
| 428 | * Note that this differs from operating the trunk port on the switch in
|
---|
| 429 | * 'promiscuous' mode, because that relates to the bits going to the wire.
|
---|
| 430 | *
|
---|
| 431 | * @returns true / false.
|
---|
| 432 | *
|
---|
| 433 | * @param pIfPort Pointer to this structure.
|
---|
| 434 | *
|
---|
| 435 | * @remarks Called while owning the network semaphore.
|
---|
| 436 | */
|
---|
| 437 | DECLR0CALLBACKMEMBER(bool, pfnIsPromiscuous,(PINTNETTRUNKIFPORT pIfPort));
|
---|
| 438 |
|
---|
| 439 | /**
|
---|
| 440 | * Send the frame to the host.
|
---|
| 441 | *
|
---|
| 442 | * This path is taken if pfnIsHostMac returns true and the trunk port on the
|
---|
| 443 | * internal network is configured to let traffic thru to the host. It may also
|
---|
| 444 | * be taken if the host is in promiscuous mode and the internal network is
|
---|
| 445 | * configured to respect this for internal targets.
|
---|
| 446 | *
|
---|
| 447 | * @return VBox status code. Error generally means we'll drop the packet.
|
---|
| 448 | * @param pIfPort Pointer to this structure.
|
---|
| 449 | * @param pSG Pointer to the (scatter /) gather structure for the frame.
|
---|
| 450 | * This will never be a temporary one, so, it's safe to
|
---|
| 451 | * do this asynchronously to save unnecessary buffer
|
---|
| 452 | * allocating and copying.
|
---|
| 453 | *
|
---|
| 454 | * @remarks Called while owning the network semaphore?
|
---|
| 455 | *
|
---|
| 456 | * @remarks TAP and NAT will use this interface for all their traffic, see pfnIsHostMac.
|
---|
| 457 | */
|
---|
| 458 | DECLR0CALLBACKMEMBER(int, pfnSendToHost,(PINTNETTRUNKIFPORT pIfPort, PINTNETSG pSG));
|
---|
| 459 |
|
---|
| 460 | /**
|
---|
| 461 | * Put the frame on the wire.
|
---|
| 462 | *
|
---|
| 463 | * This path is taken if pfnIsHostMac returns false and the trunk port on the
|
---|
| 464 | * internal network is configured to let traffic out on the wire. This may also
|
---|
| 465 | * be taken for both internal and host traffic if the trunk port is configured
|
---|
| 466 | * to be in promiscuous mode.
|
---|
| 467 | *
|
---|
| 468 | * @return VBox status code. Error generally means we'll drop the packet.
|
---|
| 469 | * @param pIfPort Pointer to this structure.
|
---|
| 470 | * @param pSG Pointer to the (scatter /) gather structure for the frame.
|
---|
| 471 | * This will never be a temporary one, so, it's safe to
|
---|
| 472 | * do this asynchronously to save unnecessary buffer
|
---|
| 473 | * allocating and copying.
|
---|
| 474 | *
|
---|
| 475 | * @remarks Called while owning the network semaphore?
|
---|
| 476 | *
|
---|
| 477 | * @remarks TAP and NAT will call pfnSGRelease and return successfully.
|
---|
| 478 | */
|
---|
| 479 | DECLR0CALLBACKMEMBER(int, pfnSendToWire,(PINTNETTRUNKIFPORT pIfPort, PINTNETSG pSG));
|
---|
| 480 |
|
---|
| 481 | /**
|
---|
| 482 | * This is called by the pfnSendToHost and pfnSendToWire code when they are
|
---|
| 483 | * done with a SG.
|
---|
| 484 | *
|
---|
| 485 | * It may be called after they return if the frame was pushed in an
|
---|
| 486 | * async manner.
|
---|
| 487 | *
|
---|
| 488 | * @param pIfPort Pointer to this structure.
|
---|
| 489 | * @param pSG Pointer to the (scatter /) gather structure.
|
---|
| 490 | *
|
---|
| 491 | * @remarks Will grab the network semaphore.
|
---|
| 492 | */
|
---|
| 493 | DECLR0CALLBACKMEMBER(void, pfnSGRelease,(PINTNETTRUNKIFPORT pIfPort, PINTNETSG pSG));
|
---|
| 494 |
|
---|
| 495 | /**
|
---|
| 496 | * Destroys this network interface port.
|
---|
| 497 | *
|
---|
| 498 | * This is called either when disconnecting the trunk interface at runtime or
|
---|
| 499 | * when the network is being torn down. In both cases, the interface will be
|
---|
| 500 | * suspended first. Note that this may still cause races in the receive path...
|
---|
| 501 | *
|
---|
| 502 | * @param pIfPort Pointer to this structure.
|
---|
| 503 | *
|
---|
| 504 | * @remarks Called while owning the network semaphore.
|
---|
| 505 | */
|
---|
| 506 | DECLR0CALLBACKMEMBER(bool, pfnDestroy,(PINTNETTRUNKIFPORT pIfPort));
|
---|
| 507 |
|
---|
| 508 | /** Structure version number. (INTNETTRUNKIFPORT_VERSION) */
|
---|
| 509 | uint32_t u32VersionEnd;
|
---|
| 510 | } INTNETTRUNKIFPORT;
|
---|
| 511 |
|
---|
| 512 | /** Version number for the INTNETTRUNKIFPORT::u32Version and INTNETTRUNKIFPORT::u32VersionEnd fields. */
|
---|
| 513 | #define INTNETTRUNKIFPORT_VERSION UINT32_C(0xA2CDe001)
|
---|
| 514 |
|
---|
| 515 |
|
---|
| 516 | /**
|
---|
| 517 | * The component factory interface for create a network
|
---|
| 518 | * interface filter (like VBoxNetFlt).
|
---|
| 519 | */
|
---|
| 520 | typedef struct INTNETTRUNKNETFLTFACTORY
|
---|
| 521 | {
|
---|
| 522 | /**
|
---|
| 523 | * Create an instance for the specfied host interface.
|
---|
| 524 | *
|
---|
| 525 | * The initial interface active state is false (suspended).
|
---|
| 526 | *
|
---|
| 527 | *
|
---|
| 528 | * @returns VBox status code.
|
---|
| 529 | * @retval VINF_SUCCESS and *ppIfPort set on success.
|
---|
| 530 | * @retval VERR_INTNET_FLT_IF_NOT_FOUND if the interface was not found.
|
---|
| 531 | * @retval VERR_INTNET_FLT_IF_BUSY if the interface is already connected.
|
---|
| 532 | * @retval VERR_INTNET_FLT_IF_FAILED if it failed for some other reason.
|
---|
| 533 | *
|
---|
| 534 | * @param pIfFactory Pointer to this structure.
|
---|
| 535 | * @param pszName The interface name (OS specific).
|
---|
| 536 | * @param pSwitchPort Pointer to the port interface on the switch that
|
---|
| 537 | * this interface is being connected to.
|
---|
| 538 | * @param ppIfPort Where to store the pointer to the interface port
|
---|
| 539 | * on success.
|
---|
| 540 | *
|
---|
| 541 | * @remarks Called while owning the network semaphore.
|
---|
| 542 | */
|
---|
| 543 | DECLR0CALLBACKMEMBER(int, pfnCreate,(INTNETTRUNKNETFLTFACTORY pIfFactory, const char *pszName,
|
---|
| 544 | PINTNETTRUNKSWPORT pSwitchPort, PINTNETTRUNKIFPORT *ppIfPort));
|
---|
| 545 | } INTNETTRUNKNETFLTFACTORY;
|
---|
| 546 | /** Pointer to the trunk factory. */
|
---|
| 547 | typedef INTNETTRUNKNETFLTFACTORY *PINTNETTRUNKNETFLTFACTORY;
|
---|
| 548 |
|
---|
| 549 | /** The UUID for the current network interface filter factory. */
|
---|
| 550 | #define INTNETTRUNKNETFLTFACTORY_UUID_STR "0e32db7d-165d-4fc9-9bce-acb2798ce7fb"
|
---|
| 551 |
|
---|
| 552 |
|
---|
| 553 |
|
---|
| 554 |
|
---|
[1] | 555 | /** The maximum length of a network name. */
|
---|
[9735] | 556 | #define INTNET_MAX_NETWORK_NAME 128
|
---|
[1] | 557 |
|
---|
| 558 |
|
---|
| 559 | /**
|
---|
[5283] | 560 | * Request buffer for INTNETR0OpenReq / VMMR0_DO_INTNET_OPEN.
|
---|
| 561 | * @see INTNETR0Open.
|
---|
[1] | 562 | */
|
---|
[5283] | 563 | typedef struct INTNETOPENREQ
|
---|
[1] | 564 | {
|
---|
[5283] | 565 | /** The request header. */
|
---|
| 566 | SUPVMMR0REQHDR Hdr;
|
---|
[1] | 567 | /** The network name. (input) */
|
---|
| 568 | char szNetwork[INTNET_MAX_NETWORK_NAME];
|
---|
| 569 | /** The size of the send buffer. (input) */
|
---|
| 570 | uint32_t cbSend;
|
---|
| 571 | /** The size of the receive buffer. (input) */
|
---|
| 572 | uint32_t cbRecv;
|
---|
[1606] | 573 | /** Whether new participants should be subjected to access check or not. */
|
---|
[1599] | 574 | bool fRestrictAccess;
|
---|
[1] | 575 | /** The handle to the network interface. (output) */
|
---|
| 576 | INTNETIFHANDLE hIf;
|
---|
[5283] | 577 | } INTNETOPENREQ;
|
---|
| 578 | /** Pointer to an INTNETR0OpenReq / VMMR0_DO_INTNET_OPEN request buffer. */
|
---|
| 579 | typedef INTNETOPENREQ *PINTNETOPENREQ;
|
---|
[1] | 580 |
|
---|
[5283] | 581 | INTNETR0DECL(int) INTNETR0OpenReq(PINTNET pIntNet, PSUPDRVSESSION pSession, PINTNETOPENREQ pReq);
|
---|
[1] | 582 |
|
---|
[5283] | 583 |
|
---|
[1] | 584 | /**
|
---|
[5283] | 585 | * Request buffer for INTNETR0IfCloseReq / VMMR0_DO_INTNET_IF_CLOSE.
|
---|
| 586 | * @see INTNETR0IfClose.
|
---|
[1] | 587 | */
|
---|
[5283] | 588 | typedef struct INTNETIFCLOSEREQ
|
---|
[1] | 589 | {
|
---|
[5283] | 590 | /** The request header. */
|
---|
| 591 | SUPVMMR0REQHDR Hdr;
|
---|
[1] | 592 | /** The handle to the network interface. */
|
---|
| 593 | INTNETIFHANDLE hIf;
|
---|
[5283] | 594 | } INTNETIFCLOSEREQ;
|
---|
| 595 | /** Pointer to an INTNETR0IfCloseReq / VMMR0_DO_INTNET_IF_CLOSE request buffer. */
|
---|
| 596 | typedef INTNETIFCLOSEREQ *PINTNETIFCLOSEREQ;
|
---|
[1] | 597 |
|
---|
[5283] | 598 | INTNETR0DECL(int) INTNETR0IfCloseReq(PINTNET pIntNet, PINTNETIFCLOSEREQ pReq);
|
---|
[1] | 599 |
|
---|
[5283] | 600 |
|
---|
[1] | 601 | /**
|
---|
[5283] | 602 | * Request buffer for INTNETR0IfGetRing3BufferReq / VMMR0_DO_INTNET_IF_GET_RING3_BUFFER.
|
---|
| 603 | * @see INTNETR0IfGetRing3Buffer.
|
---|
[1] | 604 | */
|
---|
[5283] | 605 | typedef struct INTNETIFGETRING3BUFFERREQ
|
---|
[1] | 606 | {
|
---|
[5283] | 607 | /** The request header. */
|
---|
| 608 | SUPVMMR0REQHDR Hdr;
|
---|
[1] | 609 | /** Handle to the interface. */
|
---|
[5283] | 610 | INTNETIFHANDLE hIf;
|
---|
[1] | 611 | /** The pointer to the ring3 buffer. (output) */
|
---|
[5283] | 612 | R3PTRTYPE(PINTNETBUF) pRing3Buf;
|
---|
| 613 | } INTNETIFGETRING3BUFFERREQ;
|
---|
| 614 | /** Pointer to an INTNETR0IfGetRing3BufferReq / VMMR0_DO_INTNET_IF_GET_RING3_BUFFER request buffer. */
|
---|
| 615 | typedef INTNETIFGETRING3BUFFERREQ *PINTNETIFGETRING3BUFFERREQ;
|
---|
[1] | 616 |
|
---|
[5283] | 617 | INTNETR0DECL(int) INTNETR0IfGetRing3BufferReq(PINTNET pIntNet, PINTNETIFGETRING3BUFFERREQ pReq);
|
---|
| 618 |
|
---|
| 619 |
|
---|
[1] | 620 | /**
|
---|
[5283] | 621 | * Request buffer for INTNETR0IfSetPromiscuousModeReq / VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE.
|
---|
| 622 | * @see INTNETR0IfSetPromiscuousMode.
|
---|
[1] | 623 | */
|
---|
[5283] | 624 | typedef struct INTNETIFSETPROMISCUOUSMODEREQ
|
---|
[1] | 625 | {
|
---|
[5283] | 626 | /** The request header. */
|
---|
| 627 | SUPVMMR0REQHDR Hdr;
|
---|
[1] | 628 | /** Handle to the interface. */
|
---|
| 629 | INTNETIFHANDLE hIf;
|
---|
| 630 | /** The new promiscuous mode. */
|
---|
| 631 | bool fPromiscuous;
|
---|
[5283] | 632 | } INTNETIFSETPROMISCUOUSMODEREQ;
|
---|
| 633 | /** Pointer to an INTNETR0IfSetPromiscuousModeReq / VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE request buffer. */
|
---|
| 634 | typedef INTNETIFSETPROMISCUOUSMODEREQ *PINTNETIFSETPROMISCUOUSMODEREQ;
|
---|
[1] | 635 |
|
---|
[5283] | 636 | INTNETR0DECL(int) INTNETR0IfSetPromiscuousModeReq(PINTNET pIntNet, PINTNETIFSETPROMISCUOUSMODEREQ pReq);
|
---|
[1] | 637 |
|
---|
[5283] | 638 |
|
---|
[1] | 639 | /**
|
---|
[5283] | 640 | * Request buffer for INTNETR0IfSendReq / VMMR0_DO_INTNET_IF_SEND.
|
---|
| 641 | * @see INTNETR0IfSend.
|
---|
[1] | 642 | */
|
---|
[5283] | 643 | typedef struct INTNETIFSENDREQ
|
---|
[1] | 644 | {
|
---|
[5283] | 645 | /** The request header. */
|
---|
| 646 | SUPVMMR0REQHDR Hdr;
|
---|
[1] | 647 | /** Handle to the interface. */
|
---|
| 648 | INTNETIFHANDLE hIf;
|
---|
[5283] | 649 | } INTNETIFSENDREQ;
|
---|
[1] | 650 | /** Pointer to an INTNETR0IfSend() argument package. */
|
---|
[5283] | 651 | typedef INTNETIFSENDREQ *PINTNETIFSENDREQ;
|
---|
[1] | 652 |
|
---|
[5283] | 653 | INTNETR0DECL(int) INTNETR0IfSendReq(PINTNET pIntNet, PINTNETIFSENDREQ pReq);
|
---|
[1] | 654 |
|
---|
[5283] | 655 |
|
---|
[1] | 656 | /**
|
---|
[5283] | 657 | * Request buffer for INTNETR0IfWaitReq / VMMR0_DO_INTNET_IF_WAIT.
|
---|
| 658 | * @see INTNETR0IfWait.
|
---|
[1] | 659 | */
|
---|
[5283] | 660 | typedef struct INTNETIFWAITREQ
|
---|
[1] | 661 | {
|
---|
[5283] | 662 | /** The request header. */
|
---|
| 663 | SUPVMMR0REQHDR Hdr;
|
---|
[1] | 664 | /** Handle to the interface. */
|
---|
| 665 | INTNETIFHANDLE hIf;
|
---|
| 666 | /** The number of milliseconds to wait. */
|
---|
[5283] | 667 | uint32_t cMillies;
|
---|
| 668 | } INTNETIFWAITREQ;
|
---|
| 669 | /** Pointer to an INTNETR0IfWaitReq / VMMR0_DO_INTNET_IF_WAIT request buffer. */
|
---|
| 670 | typedef INTNETIFWAITREQ *PINTNETIFWAITREQ;
|
---|
[1] | 671 |
|
---|
[5283] | 672 | INTNETR0DECL(int) INTNETR0IfWaitReq(PINTNET pIntNet, PINTNETIFWAITREQ pReq);
|
---|
[1] | 673 |
|
---|
[5283] | 674 |
|
---|
[1] | 675 | #if defined(IN_RING0) || defined(IN_INTNET_TESTCASE)
|
---|
| 676 | /** @name
|
---|
| 677 | * @{
|
---|
| 678 | */
|
---|
| 679 |
|
---|
| 680 | /**
|
---|
| 681 | * Create an instance of the Ring-0 internal networking service.
|
---|
| 682 | *
|
---|
| 683 | * @returns VBox status code.
|
---|
| 684 | * @param ppIntNet Where to store the instance pointer.
|
---|
| 685 | */
|
---|
| 686 | INTNETR0DECL(int) INTNETR0Create(PINTNET *ppIntNet);
|
---|
| 687 |
|
---|
| 688 | /**
|
---|
| 689 | * Destroys an instance of the Ring-0 internal networking service.
|
---|
| 690 | *
|
---|
| 691 | * @param pIntNet Pointer to the instance data.
|
---|
| 692 | */
|
---|
| 693 | INTNETR0DECL(void) INTNETR0Destroy(PINTNET pIntNet);
|
---|
| 694 |
|
---|
| 695 | /**
|
---|
| 696 | * Opens a network interface and attaches it to the specified network.
|
---|
| 697 | *
|
---|
| 698 | * @returns VBox status code.
|
---|
[1606] | 699 | * @param pIntNet The internal network instance.
|
---|
| 700 | * @param pSession The session handle.
|
---|
| 701 | * @param pszNetwork The network name.
|
---|
| 702 | * @param cbSend The send buffer size.
|
---|
| 703 | * @param cbRecv The receive buffer size.
|
---|
| 704 | * @param fRestrictAccess Whether new participants should be subjected to access check or not.
|
---|
| 705 | * @param phIf Where to store the handle to the network interface.
|
---|
[1] | 706 | */
|
---|
[1599] | 707 | INTNETR0DECL(int) INTNETR0Open(PINTNET pIntNet, PSUPDRVSESSION pSession, const char *pszNetwork, unsigned cbSend, unsigned cbRecv, bool fRestrictAccess, PINTNETIFHANDLE phIf);
|
---|
[1] | 708 |
|
---|
| 709 | /**
|
---|
| 710 | * Close an interface.
|
---|
| 711 | *
|
---|
| 712 | * @returns VBox status code.
|
---|
| 713 | * @param pIntNet The instance handle.
|
---|
| 714 | * @param hIf The interface handle.
|
---|
| 715 | */
|
---|
| 716 | INTNETR0DECL(int) INTNETR0IfClose(PINTNET pIntNet, INTNETIFHANDLE hIf);
|
---|
| 717 |
|
---|
| 718 | /**
|
---|
| 719 | * Gets the ring-0 address of the current buffer.
|
---|
| 720 | *
|
---|
| 721 | * @returns VBox status code.
|
---|
| 722 | * @param pIntNet The instance data.
|
---|
| 723 | * @param hIF The interface handle.
|
---|
| 724 | * @param ppRing0Buf Where to store the address of the ring-3 mapping.
|
---|
| 725 | */
|
---|
| 726 | INTNETR0DECL(int) INTNETR0IfGetRing0Buffer(PINTNET pIntNet, INTNETIFHANDLE hIf, PINTNETBUF *ppRing0Buf);
|
---|
| 727 |
|
---|
| 728 | /**
|
---|
| 729 | * Maps the default buffer into ring 3.
|
---|
| 730 | *
|
---|
| 731 | * @returns VBox status code.
|
---|
| 732 | * @param pIntNet The instance data.
|
---|
| 733 | * @param hIF The interface handle.
|
---|
| 734 | * @param ppRing3Buf Where to store the address of the ring-3 mapping.
|
---|
| 735 | */
|
---|
[5283] | 736 | INTNETR0DECL(int) INTNETR0IfGetRing3Buffer(PINTNET pIntNet, INTNETIFHANDLE hIf, R3PTRTYPE(PINTNETBUF) *ppRing3Buf);
|
---|
[1] | 737 |
|
---|
| 738 | /**
|
---|
| 739 | * Sets the promiscuous mode property of an interface.
|
---|
| 740 | *
|
---|
| 741 | * @returns VBox status code.
|
---|
| 742 | * @param pIntNet The instance handle.
|
---|
| 743 | * @param hIf The interface handle.
|
---|
| 744 | * @param fPromiscuous Set if the interface should be in promiscuous mode, clear if not.
|
---|
| 745 | */
|
---|
| 746 | INTNETR0DECL(int) INTNETR0IfSetPromiscuousMode(PINTNET pIntNet, INTNETIFHANDLE hIf, bool fPromiscuous);
|
---|
| 747 |
|
---|
| 748 | /**
|
---|
| 749 | * Sends one or more frames.
|
---|
| 750 | *
|
---|
| 751 | * The function will first the frame which is passed as the optional
|
---|
| 752 | * arguments pvFrame and cbFrame. These are optional since it also
|
---|
| 753 | * possible to chain together one or more frames in the send buffer
|
---|
| 754 | * which the function will process after considering it's arguments.
|
---|
| 755 | *
|
---|
| 756 | * @returns VBox status code.
|
---|
| 757 | * @param pIntNet The instance data.
|
---|
| 758 | * @param hIF The interface handle.
|
---|
| 759 | * @param pvFrame Pointer to the frame.
|
---|
| 760 | * @param cbFrame Size of the frame.
|
---|
| 761 | */
|
---|
| 762 | INTNETR0DECL(int) INTNETR0IfSend(PINTNET pIntNet, INTNETIFHANDLE hIf, const void *pvFrame, unsigned cbFrame);
|
---|
| 763 |
|
---|
| 764 | /**
|
---|
| 765 | * Wait for the interface to get signaled.
|
---|
| 766 | * The interface will be signaled when is put into the receive buffer.
|
---|
| 767 | *
|
---|
| 768 | * @returns VBox status code.
|
---|
| 769 | * @param pIntNet The instance handle.
|
---|
| 770 | * @param hIf The interface handle.
|
---|
| 771 | * @param cMillies Number of milliseconds to wait. RT_INDEFINITE_WAIT should be
|
---|
| 772 | * used if indefinite wait is desired.
|
---|
| 773 | */
|
---|
[5283] | 774 | INTNETR0DECL(int) INTNETR0IfWait(PINTNET pIntNet, INTNETIFHANDLE hIf, uint32_t cMillies);
|
---|
[1] | 775 |
|
---|
| 776 | /** @} */
|
---|
| 777 | #endif /* IN_RING0 */
|
---|
| 778 |
|
---|
| 779 | __END_DECLS
|
---|
| 780 |
|
---|
| 781 | #endif
|
---|