VirtualBox

Changeset 5283

Show
Ignore:
Timestamp:
10/13/07 01:21:09 (1 year ago)
Author:
vboxsync
Message:

internal networking fixes.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/include/VBox/intnet.h

    r4071 r5283  
    2020#include <VBox/types.h> 
    2121#include <VBox/stam.h> 
     22#include <VBox/sup.h> 
    2223#include <iprt/assert.h> 
    2324#include <iprt/asm.h> 
     
    2526__BEGIN_DECLS 
    2627 
     28 
     29/** Pointer to an internal network ring-0 instance. */ 
     30typedef struct INTNET *PINTNET; 
    2731 
    2832/** 
     
    164168    Assert(pHdr->u16Type == INTNETHDR_TYPE_FRAME); 
    165169    Assert(off < pBuf->cbBuf); 
    166     Assert(off + pHdr->cbFrame < pBuf->cbBuf); 
     170    Assert(off + pHdr->cbFrame <= pBuf->cbBuf); 
    167171#endif 
    168172    NOREF(pBuf); 
     
    198202 
    199203 
    200  
    201 /** 
    202  * The packed down arguments of INTNETR0Open(). 
    203  * @see INTNETR0Open() 
    204  */ 
    205 typedef struct INTNETOPENARGS 
    206 
     204/** 
     205 * Request buffer for INTNETR0OpenReq / VMMR0_DO_INTNET_OPEN. 
     206 * @see INTNETR0Open. 
     207 */ 
     208typedef struct INTNETOPENREQ 
     209
     210    /** The request header. */ 
     211    SUPVMMR0REQHDR  Hdr; 
    207212    /** The network name. (input) */ 
    208213    char            szNetwork[INTNET_MAX_NETWORK_NAME]; 
     
    215220    /** The handle to the network interface. (output) */ 
    216221    INTNETIFHANDLE  hIf; 
    217 } INTNETOPENARGS; 
    218 /** Pointer to an INTNETR0Open() argument package. */ 
    219 typedef INTNETOPENARGS *PINTNETOPENARGS; 
    220  
    221  
    222 /** 
    223  * The packed down arguments of INTNETR0IfClose(). 
    224  * @see INTNETR0IfClose() 
    225  */ 
    226 typedef struct INTNETCLOSEARGS 
    227 
     222} INTNETOPENREQ; 
     223/** Pointer to an INTNETR0OpenReq / VMMR0_DO_INTNET_OPEN request buffer. */ 
     224typedef INTNETOPENREQ *PINTNETOPENREQ; 
     225 
     226INTNETR0DECL(int) INTNETR0OpenReq(PINTNET pIntNet, PSUPDRVSESSION pSession, PINTNETOPENREQ pReq); 
     227 
     228 
     229/** 
     230 * Request buffer for INTNETR0IfCloseReq / VMMR0_DO_INTNET_IF_CLOSE. 
     231 * @see INTNETR0IfClose. 
     232 */ 
     233typedef struct INTNETIFCLOSEREQ 
     234
     235    /** The request header. */ 
     236    SUPVMMR0REQHDR  Hdr; 
    228237    /** The handle to the network interface. */ 
    229238    INTNETIFHANDLE  hIf; 
    230 } INTNETIFCLOSEARGS; 
    231 /** Pointer to an INTNETR0Open() argument package. */ 
    232 typedef INTNETIFCLOSEARGS *PINTNETIFCLOSEARGS; 
    233  
    234  
    235 /** 
    236  * Argument buffer for calling INTNETR0IfGetRing3Buffer(). 
    237  * @see INTNETR0IfGetRing3Buffer() 
    238  */ 
    239 typedef struct INTNETIFGETRING3BUFFERARGS 
    240 
     239} INTNETIFCLOSEREQ; 
     240/** Pointer to an INTNETR0IfCloseReq / VMMR0_DO_INTNET_IF_CLOSE request buffer. */ 
     241typedef INTNETIFCLOSEREQ *PINTNETIFCLOSEREQ; 
     242 
     243INTNETR0DECL(int) INTNETR0IfCloseReq(PINTNET pIntNet, PINTNETIFCLOSEREQ pReq); 
     244 
     245 
     246/** 
     247 * Request buffer for INTNETR0IfGetRing3BufferReq / VMMR0_DO_INTNET_IF_GET_RING3_BUFFER. 
     248 * @see INTNETR0IfGetRing3Buffer. 
     249 */ 
     250typedef struct INTNETIFGETRING3BUFFERREQ 
     251
     252    /** The request header. */ 
     253    SUPVMMR0REQHDR          Hdr; 
    241254    /** Handle to the interface. */ 
    242     INTNETIFHANDLE  hIf; 
     255    INTNETIFHANDLE          hIf; 
    243256    /** The pointer to the ring3 buffer. (output) */ 
    244     PINTNETBUF      pRing3Buf; 
    245 } INTNETIFGETRING3BUFFERARGS; 
    246 /** Pointer to an INTNETR0IfGetRing3Buffer() argument package. */ 
    247 typedef INTNETIFGETRING3BUFFERARGS *PINTNETIFGETRING3BUFFERARGS; 
    248  
    249 /** 
    250  * Argument buffer for calling INTNETR0IfSetPromiscuousMode(). 
    251  * @see INTNETR0IfSetPromiscuousMode() 
    252  */ 
    253 typedef struct INTNETIFSETPROMISCUOUSMODEARGS 
    254 
     257    R3PTRTYPE(PINTNETBUF)   pRing3Buf; 
     258} INTNETIFGETRING3BUFFERREQ; 
     259/** Pointer to an INTNETR0IfGetRing3BufferReq / VMMR0_DO_INTNET_IF_GET_RING3_BUFFER request buffer. */ 
     260typedef INTNETIFGETRING3BUFFERREQ *PINTNETIFGETRING3BUFFERREQ; 
     261 
     262INTNETR0DECL(int) INTNETR0IfGetRing3BufferReq(PINTNET pIntNet, PINTNETIFGETRING3BUFFERREQ pReq); 
     263 
     264 
     265/** 
     266 * Request buffer for INTNETR0IfSetPromiscuousModeReq / VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE. 
     267 * @see INTNETR0IfSetPromiscuousMode. 
     268 */ 
     269typedef struct INTNETIFSETPROMISCUOUSMODEREQ 
     270
     271    /** The request header. */ 
     272    SUPVMMR0REQHDR  Hdr; 
    255273    /** Handle to the interface. */ 
    256274    INTNETIFHANDLE  hIf; 
    257275    /** The new promiscuous mode. */ 
    258276    bool            fPromiscuous; 
    259 } INTNETIFSETPROMISCUOUSMODEARGS; 
    260 /** Pointer to an INTNETR0IfSetPromiscuousMode() argument package. */ 
    261 typedef INTNETIFSETPROMISCUOUSMODEARGS *PINTNETIFSETPROMISCUOUSMODEARGS; 
    262  
    263  
    264 /** 
    265  * Argument buffer for calling INTNETR0IfSend(). 
    266  * @see INTNETR0IfSend() 
    267  */ 
    268 typedef struct INTNETIFSENDARGS 
    269 
     277} INTNETIFSETPROMISCUOUSMODEREQ; 
     278/** Pointer to an INTNETR0IfSetPromiscuousModeReq / VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE request buffer. */ 
     279typedef INTNETIFSETPROMISCUOUSMODEREQ *PINTNETIFSETPROMISCUOUSMODEREQ; 
     280 
     281INTNETR0DECL(int) INTNETR0IfSetPromiscuousModeReq(PINTNET pIntNet, PINTNETIFSETPROMISCUOUSMODEREQ pReq); 
     282 
     283 
     284/** 
     285 * Request buffer for INTNETR0IfSendReq / VMMR0_DO_INTNET_IF_SEND. 
     286 * @see INTNETR0IfSend. 
     287 */ 
     288typedef struct INTNETIFSENDREQ 
     289
     290    /** The request header. */ 
     291    SUPVMMR0REQHDR  Hdr; 
    270292    /** Handle to the interface. */ 
    271293    INTNETIFHANDLE  hIf; 
    272     /** Pointer to the frame. (Optional) */ 
    273     const void     *pvFrame; 
    274     /** The size of the frame. (Optional) */ 
    275     uint32_t        cbFrame; 
    276 } INTNETIFSENDARGS; 
     294} INTNETIFSENDREQ; 
    277295/** Pointer to an INTNETR0IfSend() argument package. */ 
    278 typedef INTNETIFSENDARGS *PINTNETIFSENDARGS; 
    279  
    280  
    281 /** 
    282  * Argument buffer for calling INTNETR0IfWait(). 
    283  * @see INTNETR0IfWait() 
    284  */ 
    285 typedef struct INTNETIFWAITARGS 
    286 
     296typedef INTNETIFSENDREQ *PINTNETIFSENDREQ; 
     297 
     298INTNETR0DECL(int) INTNETR0IfSendReq(PINTNET pIntNet, PINTNETIFSENDREQ pReq); 
     299 
     300 
     301/** 
     302 * Request buffer for INTNETR0IfWaitReq / VMMR0_DO_INTNET_IF_WAIT. 
     303 * @see INTNETR0IfWait. 
     304 */ 
     305typedef struct INTNETIFWAITREQ 
     306
     307    /** The request header. */ 
     308    SUPVMMR0REQHDR  Hdr; 
    287309    /** Handle to the interface. */ 
    288310    INTNETIFHANDLE  hIf; 
    289311    /** The number of milliseconds to wait. */ 
    290     unsigned        cMillies; 
    291 } INTNETSENDARGS; 
    292 /** Pointer to an INTNETR0IfWait() argument package. */ 
    293 typedef INTNETIFWAITARGS *PINTNETIFWAITARGS; 
     312    uint32_t        cMillies; 
     313} INTNETIFWAITREQ; 
     314/** Pointer to an INTNETR0IfWaitReq / VMMR0_DO_INTNET_IF_WAIT request buffer. */ 
     315typedef INTNETIFWAITREQ *PINTNETIFWAITREQ; 
     316 
     317INTNETR0DECL(int) INTNETR0IfWaitReq(PINTNET pIntNet, PINTNETIFWAITREQ pReq); 
    294318 
    295319 
     
    298322 * @{ 
    299323 */ 
    300  
    301 /** Pointer to an internal network ring-0 instance. */ 
    302 typedef struct INTNET *PINTNET; 
    303324 
    304325/** 
     
    358379 * @param   ppRing3Buf  Where to store the address of the ring-3 mapping. 
    359380 */ 
    360 INTNETR0DECL(int) INTNETR0IfGetRing3Buffer(PINTNET pIntNet, INTNETIFHANDLE hIf, PINTNETBUF *ppRing3Buf); 
     381INTNETR0DECL(int) INTNETR0IfGetRing3Buffer(PINTNET pIntNet, INTNETIFHANDLE hIf, R3PTRTYPE(PINTNETBUF) *ppRing3Buf); 
    361382 
    362383/** 
     
    396417 *                      used if indefinite wait is desired. 
    397418 */ 
    398 INTNETR0DECL(int) INTNETR0IfWait(PINTNET pIntNet, INTNETIFHANDLE hIf, unsigned cMillies); 
     419INTNETR0DECL(int) INTNETR0IfWait(PINTNET pIntNet, INTNETIFHANDLE hIf, uint32_t cMillies); 
    399420 
    400421/** @} */ 
  • trunk/src/VBox/Devices/Network/DrvIntNet.cpp

    r4071 r5283  
    113113 
    114114/** 
     115 * Writes a frame packet to the buffer. 
     116 * 
     117 * @returns VBox status code. 
     118 * @param   pBuf        The buffer. 
     119 * @param   pRingBuf    The ring buffer to read from. 
     120 * @param   pvFrame     The frame to write. 
     121 * @param   cbFrame     The size of the frame. 
     122 * @remark  This is the same as INTNETRingWriteFrame 
     123 */ 
     124static int drvIntNetRingWriteFrame(PINTNETBUF pBuf, PINTNETRINGBUF pRingBuf, const void *pvFrame, uint32_t cbFrame) 
     125{ 
     126    /* 
     127     * Validate input. 
     128     */ 
     129    Assert(pBuf); 
     130    Assert(pRingBuf); 
     131    Assert(pvFrame); 
     132    Assert(cbFrame >= sizeof(PDMMAC) * 2); 
     133    uint32_t offWrite = pRingBuf->offWrite; 
     134    Assert(offWrite == RT_ALIGN_32(offWrite, sizeof(INTNETHDR))); 
     135    uint32_t offRead = pRingBuf->offRead; 
     136    Assert(offRead == RT_ALIGN_32(offRead, sizeof(INTNETHDR))); 
     137 
     138    const uint32_t cb = RT_ALIGN_32(cbFrame, sizeof(INTNETHDR)); 
     139    if (offRead <= offWrite) 
     140    { 
     141        /* 
     142         * Try fit it all before the end of the buffer. 
     143         */ 
     144        if (pRingBuf->offEnd - offWrite >= cb + sizeof(INTNETHDR)) 
     145        { 
     146            PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pBuf + offWrite); 
     147            pHdr->u16Type  = INTNETHDR_TYPE_FRAME; 
     148            pHdr->cbFrame  = cbFrame; 
     149            pHdr->offFrame = sizeof(INTNETHDR); 
     150 
     151            memcpy(pHdr + 1, pvFrame, cbFrame); 
     152 
     153            offWrite += cb + sizeof(INTNETHDR); 
     154            Assert(offWrite <= pRingBuf->offEnd && offWrite >= pRingBuf->offStart); 
     155            if (offWrite >= pRingBuf->offEnd) 
     156                offWrite = pRingBuf->offStart; 
     157            Log2(("WriteFrame: offWrite: %#x -> %#x (1)\n", pRingBuf->offWrite, offWrite)); 
     158            ASMAtomicXchgU32(&pRingBuf->offWrite, offWrite); 
     159            return VINF_SUCCESS; 
     160        } 
     161 
     162        /* 
     163         * Try fit the frame at the start of the buffer. 
     164         * (The header fits before the end of the buffer because of alignment.) 
     165         */ 
     166        AssertMsg(pRingBuf->offEnd - offWrite >= sizeof(INTNETHDR), ("offEnd=%x offWrite=%x\n", pRingBuf->offEnd, offWrite)); 
     167        if (offRead - pRingBuf->offStart > cb) /* not >= ! */ 
     168        { 
     169            PINTNETHDR  pHdr = (PINTNETHDR)((uint8_t *)pBuf + offWrite); 
     170            void       *pvFrameOut = (PINTNETHDR)((uint8_t *)pBuf + pRingBuf->offStart); 
     171            pHdr->u16Type  = INTNETHDR_TYPE_FRAME; 
     172            pHdr->cbFrame  = cbFrame; 
     173            pHdr->offFrame = (intptr_t)pvFrameOut - (intptr_t)pHdr; 
     174 
     175            memcpy(pvFrameOut, pvFrame, cbFrame); 
     176 
     177            offWrite = pRingBuf->offStart + cb; 
     178            ASMAtomicXchgU32(&pRingBuf->offWrite, offWrite); 
     179            Log2(("WriteFrame: offWrite: %#x -> %#x (2)\n", pRingBuf->offWrite, offWrite)); 
     180            return VINF_SUCCESS; 
     181        } 
     182    } 
     183    /* 
     184     * The reader is ahead of the writer, try fit it into that space. 
     185     */ 
     186    else if (offRead - offWrite > cb + sizeof(INTNETHDR)) /* not >= ! */ 
     187    { 
     188        PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pBuf + offWrite); 
     189        pHdr->u16Type  = INTNETHDR_TYPE_FRAME; 
     190        pHdr->cbFrame  = cbFrame; 
     191        pHdr->offFrame = sizeof(INTNETHDR); 
     192 
     193        memcpy(pHdr + 1, pvFrame, cbFrame); 
     194 
     195        offWrite += cb + sizeof(INTNETHDR); 
     196        ASMAtomicXchgU32(&pRingBuf->offWrite, offWrite); 
     197        Log2(("WriteFrame: offWrite: %#x -> %#x (3)\n", pRingBuf->offWrite, offWrite)); 
     198        return VINF_SUCCESS; 
     199    } 
     200 
     201    /* (it didn't fit) */ 
     202    /** @todo stats */ 
     203    return VERR_BUFFER_OVERFLOW; 
     204} 
     205 
     206 
     207/** 
    115208 * Send data to the network. 
    116209 * 
     
    136229#endif 
    137230 
    138     /** @todo copy to send buffer, this is not safe. */ 
    139     INTNETIFSENDARGS SendArgs; 
    140     SendArgs.hIf = pThis->hIf; 
    141     SendArgs.pvFrame = pvBuf; 
    142     SendArgs.cbFrame = cb; 
    143     int rc = pThis->pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pThis->pDrvIns, VMMR0_DO_INTNET_IF_SEND, &SendArgs, sizeof(SendArgs)); 
     231    /* 
     232     * Add the frame to the send buffer and push it onto the network. 
     233     */ 
     234    int rc = drvIntNetRingWriteFrame(pThis->pBuf, &pThis->pBuf->Send, pvBuf, cb); 
     235    if (    rc == VERR_BUFFER_OVERFLOW 
     236        &&  pThis->pBuf->cbSend < cb) 
     237    { 
     238        INTNETIFSENDREQ SendReq; 
     239        SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC; 
     240        SendReq.Hdr.cbReq = sizeof(SendReq); 
     241        SendReq.hIf = pThis->hIf; 
     242        pThis->pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pThis->pDrvIns, VMMR0_DO_INTNET_IF_SEND, &SendReq, sizeof(SendReq)); 
     243 
     244        rc = drvIntNetRingWriteFrame(pThis->pBuf, &pThis->pBuf->Send, pvBuf, cb); 
     245    } 
     246 
     247    if (RT_SUCCESS(rc)) 
     248    { 
     249        INTNETIFSENDREQ SendReq; 
     250        SendReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC; 
     251        SendReq.Hdr.cbReq = sizeof(SendReq); 
     252        SendReq.hIf = pThis->hIf; 
     253        rc = pThis->pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pThis->pDrvIns, VMMR0_DO_INTNET_IF_SEND, &SendReq, sizeof(SendReq)); 
     254    } 
    144255 
    145256    STAM_PROFILE_STOP(&pThis->StatTransmit, a); 
     
    162273{ 
    163274    PDRVINTNET pThis = PDMINETWORKCONNECTOR_2_DRVINTNET(pInterface); 
    164     INTNETIFSETPROMISCUOUSMODEARGS SetArgs = {0}; 
    165     SetArgs.hIf          = pThis->hIf; 
    166     SetArgs.fPromiscuous = fPromiscuous; 
    167     int rc = pThis->pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pThis->pDrvIns, VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE, &SetArgs, sizeof(SetArgs)); 
    168     LogFlow(("drvIntNetSetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous)); 
     275    INTNETIFSETPROMISCUOUSMODEREQ Req; 
     276    Req.Hdr.u32Magic    = SUPVMMR0REQHDR_MAGIC; 
     277    Req.Hdr.cbReq       = sizeof(Req); 
     278    Req.hIf             = pThis->hIf; 
     279    Req.fPromiscuous    = fPromiscuous; 
     280    int rc = pThis->pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pThis->pDrvIns, VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE, &Req, sizeof(Req)); 
     281    LogFlow(("drvIntNetSetPromiscuousMode: fPromiscuous=%RTbool\n", fPromiscuous)); 
    169282    AssertRC(rc); 
    170283} 
     
    368481            return VERR_STATE_CHANGED; 
    369482        } 
    370         INTNETIFWAITARGS WaitArgs; 
    371         WaitArgs.hIf      = pThis->hIf; 
    372         WaitArgs.cMillies = 30000;      /* don't wait forever, timeout now and then. */ 
     483        INTNETIFWAITREQ WaitReq; 
     484        WaitReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC; 
     485        WaitReq.Hdr.cbReq    = sizeof(WaitReq); 
     486        WaitReq.hIf          = pThis->hIf; 
     487        WaitReq.cMillies     = 30000; /* 30s - don't wait forever, timeout now and then. */ 
    373488        STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a); 
    374         int rc = pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_WAIT, &WaitArgs, sizeof(WaitArgs)); 
     489        int rc = pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_WAIT, &WaitReq, sizeof(WaitReq)); 
    375490        if (    VBOX_FAILURE(rc) 
    376491            &&  rc != VERR_TIMEOUT 
     
    547662    if (pThis->hIf != INTNET_HANDLE_INVALID) 
    548663    { 
    549         INTNETIFCLOSEARGS CloseArgs = {0}; 
    550         CloseArgs.hIf = pThis->hIf; 
     664        INTNETIFCLOSEREQ CloseReq; 
     665        CloseReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC; 
     666        CloseReq.Hdr.cbReq = sizeof(CloseReq); 
     667        CloseReq.hIf = pThis->hIf; 
    551668        pThis->hIf = INTNET_HANDLE_INVALID; 
    552         int rc = pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_CLOSE, &CloseArgs, sizeof(CloseArgs)); 
     669        int rc = pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_CLOSE, &CloseReq, sizeof(CloseReq)); 
    553670        AssertRC(rc); 
    554671    } 
     
    638755     * Read the configuration. 
    639756     */ 
    640     INTNETOPENARGS OpenArgs; 
    641     memset(&OpenArgs, 0, sizeof(OpenArgs)); 
    642     rc = CFGMR3QueryString(pCfgHandle, "Network", OpenArgs.szNetwork, sizeof(OpenArgs.szNetwork)); 
     757    INTNETOPENREQ OpenReq; 
     758    memset(&OpenReq, 0, sizeof(OpenReq)); 
     759    OpenReq.Hdr.cbReq = sizeof(OpenReq); 
     760    OpenReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC; 
     761 
     762    rc = CFGMR3QueryString(pCfgHandle, "Network", OpenReq.szNetwork, sizeof(OpenReq.szNetwork)); 
    643763    if (VBOX_FAILURE(rc)) 
    644764        return PDMDRV_SET_ERROR(pDrvIns, rc, 
    645765                                N_("Configuration error: Failed to get the \"Network\" value")); 
    646     strcpy(pThis->szNetwork, OpenArgs.szNetwork); 
    647  
    648     rc = CFGMR3QueryU32(pCfgHandle, "ReceiveBufferSize", &OpenArgs.cbRecv); 
     766    strcpy(pThis->szNetwork, OpenReq.szNetwork); 
     767 
     768    rc = CFGMR3QueryU32(pCfgHandle, "ReceiveBufferSize", &OpenReq.cbRecv); 
    649769    if (rc == VERR_CFGM_VALUE_NOT_FOUND) 
    650         OpenArgs.cbRecv = _256K; 
     770        OpenReq.cbRecv = _256K; 
    651771    else if (VBOX_FAILURE(rc)) 
    652772        return PDMDRV_SET_ERROR(pDrvIns, rc, 
    653773                                N_("Configuration error: Failed to get the \"ReceiveBufferSize\" value")); 
    654774 
    655     rc = CFGMR3QueryU32(pCfgHandle, "SendBufferSize", &OpenArgs.cbSend); 
     775    rc = CFGMR3QueryU32(pCfgHandle, "SendBufferSize", &OpenReq.cbSend); 
    656776    if (rc == VERR_CFGM_VALUE_NOT_FOUND) 
    657         OpenArgs.cbSend = _4K; 
     777        OpenReq.cbSend = _4K; 
    658778    else if (VBOX_FAILURE(rc)) 
    659779        return PDMDRV_SET_ERROR(pDrvIns, rc, 
    660780                                N_("Configuration error: Failed to get the \"SendBufferSize\" value")); 
    661  
    662     rc = CFGMR3QueryBool(pCfgHandle, "RestrictAccess", &OpenArgs.fRestrictAccess); 
     781    if (OpenReq.cbSend < 16) 
     782        return PDMDRV_SET_ERROR(pDrvIns, rc, 
     783                                N_("Configuration error: The \"SendBufferSize\" value is too small.")); 
     784    if (OpenReq.cbSend < 1536*2 + 4) 
     785        LogRel(("DrvIntNet: Warning! SendBufferSize=%u, Recommended minimum size %u butes.\n", OpenReq.cbSend, 1536*2 + 4)); 
     786 
     787    rc = CFGMR3QueryBool(pCfgHandle, "RestrictAccess", &OpenReq.fRestrictAccess); 
    663788    if (rc == VERR_CFGM_VALUE_NOT_FOUND) 
    664         OpenArgs.fRestrictAccess = true; 
     789        OpenReq.fRestrictAccess = true; 
    665790    else if (VBOX_FAILURE(rc)) 
    666791        return PDMDRV_SET_ERROR(pDrvIns, rc, 
     
    680805     * Create the interface. 
    681806     */ 
    682     OpenArgs.hIf = INTNET_HANDLE_INVALID; 
    683     rc = pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_OPEN, &OpenArgs, sizeof(OpenArgs)); 
     807    OpenReq.hIf = INTNET_HANDLE_INVALID; 
     808    rc = pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_OPEN, &OpenReq, sizeof(OpenReq)); 
    684809    if (VBOX_FAILURE(rc)) 
    685810        return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, 
    686811                                   N_("Failed to open/create the internal network '%s'"), pThis->szNetwork); 
    687     AssertRelease(OpenArgs.hIf != INTNET_HANDLE_INVALID); 
    688     pThis->hIf = OpenArgs.hIf; 
     812    AssertRelease(OpenReq.hIf != INTNET_HANDLE_INVALID); 
     813    pThis->hIf = OpenReq.hIf; 
    689814    Log(("IntNet%d: hIf=%RX32 '%s'\n", pDrvIns->iInstance, pThis->hIf, pThis->szNetwork)); 
    690815 
     
    692817     * Get default buffer. 
    693818     */ 
    694     INTNETIFGETRING3BUFFERARGS GetRing3BufferArgs = {0}; 
    695     GetRing3BufferArgs.hIf = pThis->hIf; 
    696     GetRing3BufferArgs.pRing3Buf = NULL; 
    697     rc = pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_GET_RING3_BUFFER, &GetRing3BufferArgs, sizeof(GetRing3BufferArgs)); 
     819    INTNETIFGETRING3BUFFERREQ GetRing3BufferReq; 
     820    GetRing3BufferReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC; 
     821    GetRing3BufferReq.Hdr.cbReq = sizeof(GetRing3BufferReq); 
     822    GetRing3BufferReq.hIf = pThis->hIf; 
     823    GetRing3BufferReq.pRing3Buf = NULL; 
     824    rc = pDrvIns->pDrvHlp->pfnSUPCallVMMR0Ex(pDrvIns, VMMR0_DO_INTNET_IF_GET_RING3_BUFFER, &GetRing3BufferReq, sizeof(GetRing3BufferReq)); 
    698825    if (VBOX_FAILURE(rc)) 
    699826        return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, 
    700827                                   N_("Failed to get ring-3 buffer for the newly created interface to '%s'"), pThis->szNetwork); 
    701     AssertRelease(VALID_PTR(GetRing3BufferArgs.pRing3Buf)); 
    702     pThis->pBuf = GetRing3BufferArgs.pRing3Buf; 
     828    AssertRelease(VALID_PTR(GetRing3BufferReq.pRing3Buf)); 
     829    pThis->pBuf = GetRing3BufferReq.pRing3Buf; 
    703830 
    704831    /* 
     
    737864#endif 
    738865 
    739     LogRel(("IntNet#%u: cbRecv=%u cbSend=%u fRestrictAccess=%d\n", pDrvIns->iInstance, OpenArgs.cbRecv, OpenArgs.cbSend, OpenArgs.fRestrictAccess)); 
     866    LogRel(("IntNet#%u: cbRecv=%u cbSend=%u fRestrictAccess=%d\n", pDrvIns->iInstance, OpenReq.cbRecv, OpenReq.cbSend, OpenReq.fRestrictAccess)); 
    740867 
    741868    return rc; 
  • trunk/src/VBox/Devices/Network/SrvIntNetR0.cpp

    r4071 r5283  
    6060    PINTNETBUF              pIntBuf; 
    6161    /** Pointer to ring-3 mapping of the current exchange buffer. */ 
    62     PINTNETBUF              pIntBufR3; 
     62    R3PTRTYPE(PINTNETBUF)   pIntBufR3; 
    6363    /** Pointer to the default exchange buffer for the interface. */ 
    6464    PINTNETBUF              pIntBufDefault; 
    6565    /** Pointer to ring-3 mapping of the default exchange buffer. */ 
    66     PINTNETBUF              pIntBufDefaultR3; 
     66    R3PTRTYPE(PINTNETBUF)   pIntBufDefaultR3; 
    6767    /** Event semaphore which a receiver thread will sleep on while waiting for data to arrive. */ 
    6868    RTSEMEVENT              Event; 
     
    625625     * Process the send buffer. 
    626626     */ 
    627     if (pIf->pIntBuf->Send.offRead != pIf->pIntBuf->Send.offWrite) 
    628     { 
    629         for (;;) 
     627    while (pIf->pIntBuf->Send.offRead != pIf->pIntBuf->Send.offWrite) 
     628    { 
     629        /* Send the frame if the type is sane. */ 
     630        PINTNETHDR pHdr = (PINTNETHDR)((uintptr_t)pIf->pIntBuf + pIf->pIntBuf->Send.offRead); 
     631        if (pHdr->u16Type == INTNETHDR_TYPE_FRAME) 
    630632        { 
    631             /* 
    632              * Anything we know what is, if so send it. 
    633              */ 
    634             PINTNETHDR pHdr = (PINTNETHDR)((uintptr_t)pIf->pIntBuf + pIf->pIntBuf->Send.offRead); 
    635             if (pHdr->u16Type == INTNETHDR_TYPE_FRAME) 
    636             { 
    637                 void *pvCurFrame = INTNETHdrGetFramePtr(pHdr, pIf->pIntBuf); 
    638                 if (pvCurFrame) 
    639                     intnetNetworkSend(pIf->pNetwork, pIf, pvCurFrame, pHdr->cbFrame); 
    640             } 
    641             /* else: ignore the frame */ 
    642  
    643             /* 
    644              * Skip to the next frame. 
    645              */ 
    646             INTNETRingSkipFrame(pIf->pIntBuf, &pIf->pIntBuf->Send); 
     633            void *pvCurFrame = INTNETHdrGetFramePtr(pHdr, pIf->pIntBuf); 
     634            if (pvCurFrame) 
     635                intnetNetworkSend(pIf->pNetwork, pIf, pvCurFrame, pHdr->cbFrame); 
    647636        } 
     637        /* else: ignore the frame */ 
     638 
     639        /* Skip to the next frame. */ 
     640        INTNETRingSkipFrame(pIf->pIntBuf, &pIf->pIntBuf->Send); 
    648641    } 
    649642 
    650643    return RTSemFastMutexRelease(pIf->pNetwork->FastMutex); 
     644} 
     645 
     646 
     647/** 
     648 * VMMR0 request wrapper for INTNETR0IfSend. 
     649 * 
     650 * @returns see INTNETR0IfSend. 
     651 * @param   pIntNet         The internal networking instance. 
     652 * @param   pReq            The request packet. 
     653 */ 
     654INTNETR0DECL(int) INTNETR0IfSendReq(PINTNET pIntNet, PINTNETIFSENDREQ pReq) 
     655{ 
     656    if (RT_UNLIKELY(pReq->Hdr.cbReq != sizeof(*pReq))) 
     657        return VERR_INVALID_PARAMETER; 
     658    return INTNETR0IfSend(pIntNet, pReq->hIf, NULL, 0); 
    651659} 
    652660 
     
    660668 * @param   ppRing3Buf  Where to store the address of the ring-3 mapping. 
    661669 */ 
    662 INTNETR0DECL(int) INTNETR0IfGetRing3Buffer(PINTNET pIntNet, INTNETIFHANDLE hIf, PINTNETBUF *ppRing3Buf) 
     670INTNETR0DECL(int) INTNETR0IfGetRing3Buffer(PINTNET pIntNet, INTNETIFHANDLE hIf, R3PTRTYPE(PINTNETBUF) *ppRing3Buf) 
    663671{ 
    664672    LogFlow(("INTNETR0IfGetRing3Buffer: pIntNet=%p hIf=%RX32 ppRing3Buf=%p\n", pIntNet, hIf, ppRing3Buf)); 
     
    687695    LogFlow(("INTNETR0IfGetRing3Buffer: returns %Vrc *ppRing3Buf=%p\n", rc, *ppRing3Buf)); 
    688696    return rc; 
     697} 
     698 
     699 
     700/** 
     701 * VMMR0 request wrapper for INTNETR0IfGetRing3Buffer. 
     702 * 
     703 * @returns see INTNETR0IfGetRing3Buffer. 
     704 * @param   pIntNet         The internal networking instance. 
     705 * @param   pReq            The request packet. 
     706 */ 
     707INTNETR0DECL(int) INTNETR0IfGetRing3BufferReq(PINTNET pIntNet, PINTNETIFGETRING3BUFFERREQ pReq) 
     708{ 
     709    if (RT_UNLIKELY(pReq->Hdr.cbReq != sizeof(*pReq))) 
     710        return VERR_INVALID_PARAMETER; 
     711    return INTNETR0IfGetRing3Buffer(pIntNet, pReq->hIf, &pReq->pRing3Buf); 
    689712} 
    690713 
     
    799822 
    800823/** 
     824 * VMMR0 request wrapper for INTNETR0IfSetPromiscuousMode. 
     825 * 
     826 * @returns see INTNETR0IfSetPromiscuousMode. 
     827 * @param   pIntNet         The internal networking instance. 
     828 * @param   pReq            The request packet. 
     829 */ 
     830INTNETR0DECL(int) INTNETR0IfSetPromiscuousModeReq(PINTNET pIntNet, PINTNETIFSETPROMISCUOUSMODEREQ pReq) 
     831{ 
     832    if (RT_UNLIKELY(pReq->Hdr.cbReq != sizeof(*pReq))) 
     833        return VERR_INVALID_PARAMETER; 
     834    return INTNETR0IfSetPromiscuousMode(pIntNet, pReq->hIf, pReq->fPromiscuous); 
     835} 
     836 
     837 
     838/** 
    801839 * Wait for the interface to get signaled. 
    802840 * The interface will be signaled when is put into the receive buffer. 
     
    808846 *                      used if indefinite wait is desired. 
    809847 */ 
    810 INTNETR0DECL(int) INTNETR0IfWait(PINTNET pIntNet, INTNETIFHANDLE hIf, unsigned cMillies) 
     848INTNETR0DECL(int) INTNETR0IfWait(PINTNET pIntNet, INTNETIFHANDLE hIf, uint32_t cMillies) 
    811849{ 
    812850    LogFlow(("INTNETR0IfWait: pIntNet=%p hIf=%RX32 cMillies=%u\n", pIntNet, hIf, cMillies)); 
     
    844882     */ 
    845883    ASMAtomicIncU32(&pIf->cSleepers); 
    846     int rc = RTSemEventWait(Event, cMillies); 
     884    int rc = RTSemEventWaitNoResume(Event, cMillies); 
    847885    if (pIf->Event == Event) 
    848886    { 
     
    859897 
    860898/** 
     899 * VMMR0 request wrapper for INTNETR0IfWait. 
     900 * 
     901 * @returns see INTNETR0IfWait. 
     902 * @param   pIntNet         The internal networking instance. 
     903 * @param   pReq            The request packet. 
     904 */ 
     905INTNETR0DECL(int) INTNETR0IfWaitReq(PINTNET pIntNet, PINTNETIFWAITREQ pReq) 
     906{ 
     907    if (RT_UNLIKELY(pReq->Hdr.cbReq != sizeof(*pReq))) 
     908        return VERR_INVALID_PARAMETER; 
     909    return INTNETR0IfWait(pIntNet, pReq->hIf, pReq->cMillies); 
     910} 
     911 
     912 
     913/** 
    861914 * Close an interface. 
    862915 * 
     
    880933    LogFlow(("INTNETR0IfClose: returns %Vrc\n", rc)); 
    881934    return rc; 
     935} 
     936 
     937 
     938/** 
     939 * VMMR0 request wrapper for INTNETR0IfCloseReq. 
     940 * 
     941 * @returns see INTNETR0IfClose. 
     942 * @param   pIntNet         The internal networking instance. 
     943 * @param   pReq            The request packet. 
     944 */ 
     945INTNETR0DECL(int) INTNETR0IfCloseReq(PINTNET pIntNet, PINTNETIFCLOSEREQ pReq) 
     946{ 
     947    if (RT_UNLIKELY(pReq->Hdr.cbReq != sizeof(*pReq))) 
     948        return VERR_INVALID_PARAMETER; 
     949    return INTNETR0IfClose(pIntNet, pReq->hIf); 
    882950} 
    883951 
     
    9781046        SUPR0MemFree(pIf->pSession, (RTHCUINTPTR)pIf->pIntBufDefault); 
    9791047        pIf->pIntBufDefault = NULL; 
    980         pIf->pIntBufDefaultR3 = NULL; 
    981         pIf->pIntBufR3 = NULL; 
     1048        pIf->pIntBufDefaultR3 = 0; 
    9821049        pIf->pIntBuf = NULL; 
     1050        pIf->pIntBufR3 = 0; 
    9831051    } 
    9841052 
     
    14191487 
    14201488/** 
     1489 * VMMR0 request wrapper for GMMR0MapUnmapChunk. 
     1490 * 
     1491 * @returns see GMMR0MapUnmapChunk. 
     1492 * @param   pIntNet         The internal networking instance. 
     1493 * @param   pSession        The session handle. 
     1494 * @param   pReq            The request packet. 
     1495 */ 
     1496INTNETR0DECL(int) INTNETR0OpenReq(PINTNET pIntNet, PSUPDRVSESSION pSession, PINTNETOPENREQ pReq) 
     1497{ 
     1498    if (RT_UNLIKELY(pReq->Hdr.cbReq != sizeof(*pReq))) 
     1499        return VERR_INVALID_PARAMETER; 
     1500    return INTNETR0Open(pIntNet, pSession, &pReq->szNetwork[0], pReq->cbSend, pReq->cbRecv, pReq->fRestrictAccess, &pReq->hIf); 
     1501} 
     1502 
     1503 
     1504/** 
    14211505 * Destroys an instance of the Ring-0 internal networking service. 
    14221506 * 
  • trunk/src/VBox/Devices/Network/testcase/tstIntNetR0.cpp

    r4071 r5283  
    202202 
    203203 
    204 #define TEST_TRANSFER_SIZE (_1M*128
     204#define TEST_TRANSFER_SIZE (_1M*384
    205205 
    206206/** 
     
    229229        const unsigned cb = iFrame % 1519 + 12 + sizeof(unsigned); 
    230230        *puFrame = iFrame; 
     231#if 0 
    231232        int rc = INTNETR0IfSend(pArgs->pIntNet, pArgs->hIf, abBuf, cb); 
     233#else 
     234        int rc = INTNETRingWriteFrame(pArgs->pBuf, &pArgs->pBuf->Send, abBuf, cb); 
     235        if (RT_SUCCESS(rc)) 
     236            rc = INTNETR0IfSend(pArgs->pIntNet, pArgs->hIf, NULL, 0); 
     237#endif 
    232238        if (VBOX_FAILURE(rc)) 
    233239        { 
    234240            g_cErrors++; 
    235             RTPrintf("tstIntNetR0: Failed sending %d bytes, rc=%Vrc\n", cb, rc); 
     241            RTPrintf("tstIntNetR0: Failed sending %d bytes, rc=%Vrc (%d)\n", cb, rc, INTNETRingGetWritable(&pArgs->pBuf->Send)); 
    236242        } 
    237243        cbSent += cb; 
     
    384390     */ 
    385391    INTNETIFHANDLE hIf0 = INTNET_HANDLE_INVALID; 
    386     rc = INTNETR0Open(pIntNet, g_pSession, "test", 1536, 0x8000, true, &hIf0); 
     392    rc = INTNETR0Open(pIntNet, g_pSession, "test", 1536*2 + 4, 0x8000, true, &hIf0); 
    387393    if (VBOX_SUCCESS(rc)) 
    388394    { 
     
    390396        { 
    391397            INTNETIFHANDLE hIf1 = INTNET_HANDLE_INVALID; 
    392             rc = INTNETR0Open(pIntNet, g_pSession, "test", 1536, 0x8000, true, &hIf1); 
     398            rc = INTNETR0Open(pIntNet, g_pSession, "test", 1536*2 + 4, 0x8000, true, &hIf1); 
    393399            if (VBOX_SUCCESS(rc)) 
    394400            { 
  • trunk/src/VBox/VMM/PDMDriver.cpp

    r4800 r5283  
    991991    if (    uOperation >= VMMR0_DO_SRV_START 
    992992        &&  uOperation <  VMMR0_DO_SRV_END) 
    993 #if 0 /** @todo fix internal networking */ 
    994         rc = SUPCallVMMR0Ex(pDrvIns->Internal.s.pVM->pVMR0, uOperation, pvArg, cbArg); 
    995 #else 
    996 
    997 LogRel(("Sorry, internal networking is currently broken in the devlopment tree. Will be fixed in a bit, no time right now.\n")); 
    998 rc = VERR_NOT_IMPLEMENTED; 
    999 
    1000 #endif 
     993        rc = SUPCallVMMR0Ex(pDrvIns->Internal.s.pVM->pVMR0, uOperation, 0, (PSUPVMMR0REQHDR)pvArg); 
    1001994    else 
    1002995    { 
  • trunk/src/VBox/VMM/VMMR0/VMMR0.cpp

    r5274 r5283  
    832832 
    833833 
    834 #if 0//def VBOX_WITH_INTERNAL_NETWORKING - currently busted 
    835         /* 
    836          * Services
     834#ifdef VBOX_WITH_INTERNAL_NETWORKING 
     835        /* 
     836         * Requests to the internal networking service
    837837         */ 
    838838        case VMMR0_DO_INTNET_OPEN: 
     839            if (!pVM || u64Arg) 
     840                return VERR_INVALID_PARAMETER; 
     841            if (!g_pIntNet) 
     842                return VERR_NOT_SUPPORTED; 
     843            return INTNETR0OpenReq(g_pIntNet, pVM->pSession, (PINTNETOPENREQ)pReqHdr); 
     844 
    839845        case VMMR0_DO_INTNET_IF_CLOSE: 
     846            if (!pVM || u64Arg) 
     847                return VERR_INVALID_PARAMETER; 
     848            if (!g_pIntNet) 
     849                return VERR_NOT_SUPPORTED; 
     850            return INTNETR0IfCloseReq(g_pIntNet, (PINTNETIFCLOSEREQ)pReqHdr); 
     851 
    840852        case VMMR0_DO_INTNET_IF_GET_RING3_BUFFER: 
     853            if (!pVM || u64Arg) 
     854                return VERR_INVALID_PARAMETER; 
     855            if (!g_pIntNet) 
     856                return VERR_NOT_SUPPORTED; 
     857            return INTNETR0IfGetRing3BufferReq(g_pIntNet, (PINTNETIFGETRING3BUFFERREQ)pReqHdr); 
     858 
    841859        case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE: 
     860            if (!pVM || u64Arg) 
     861                return VERR_INVALID_PARAMETER; 
     862            if (!g_pIntNet) 
     863                return VERR_NOT_SUPPORTED; 
     864            return INTNETR0IfSetPromiscuousModeReq(g_pIntNet, (PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr); 
     865 
    842866        case VMMR0_DO_INTNET_IF_SEND: 
     867            if (!pVM || u64Arg) 
     868                return VERR_INVALID_PARAMETER; 
     869            if (!g_pIntNet) 
     870                return VERR_NOT_SUPPORTED; 
     871            return INTNETR0IfSendReq(g_pIntNet, (PINTNETIFSENDREQ)pReqHdr); 
     872 
    843873        case VMMR0_DO_INTNET_IF_WAIT: 
    844         { 
    845             /* 
    846              * Validate arguments a bit first. 
    847              */ 
    848             if (!VALID_PTR(pvArg)) 
    849                 return VERR_INVALID_POINTER; 
    850             if (!VALID_PTR(pVM)) 
    851                 return VERR_INVALID_POINTER; 
    852             if (pVM->pVMR0 != pVM) 
    853                 return VERR_INVALID_POINTER; 
    854             if (!VALID_PTR(pVM->pSession)) 
    855                 return VERR_INVALID_POINTER; 
     874            if (!pVM || u64Arg) 
     875                return VERR_INVALID_PARAMETER; 
    856876            if (!g_pIntNet) 
    857                 return VERR_FILE_NOT_FOUND; ///@todo fix this status code! 
    858  
    859             /* 
    860              * Unpack the arguments and call the service. 
    861              */ 
    862             switch (enmOperation) 
    863             { 
    864                 case VMMR0_DO_INTNET_OPEN: 
    865                 { 
    866                     PINTNETOPENARGS pArgs = (PINTNETOPENARGS)pvArg; 
    867                     return INTNETR0Open(g_pIntNet, pVM->pSession, &pArgs->szNetwork[0], pArgs->cbSend, pArgs->cbRecv, pArgs->fRestrictAccess, &pArgs->hIf); 
    868                 } 
    869  
    870                 case VMMR0_DO_INTNET_IF_CLOSE: 
    871                 { 
    872                     PINTNETIFCLOSEARGS pArgs = (PINTNETIFCLOSEARGS)pvArg; 
    873                     return INTNETR0IfClose(g_pIntNet, pArgs->hIf); 
    874                 } 
    875  
    876                 case VMMR0_DO_INTNET_IF_GET_RING3_BUFFER: 
    877                 { 
    878                     PINTNETIFGETRING3BUFFERARGS pArgs = (PINTNETIFGETRING3BUFFERARGS)pvArg; 
    879                     return INTNETR0IfGetRing3Buffer(g_pIntNet, pArgs->hIf, &pArgs->pRing3Buf); 
    880                 } 
    881  
    882                 case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE: 
    883                 { 
    884                     PINTNETIFSETPROMISCUOUSMODEARGS pArgs = (PINTNETIFSETPROMISCUOUSMODEARGS)pvArg; 
    885                     return INTNETR0IfSetPromiscuousMode(g_pIntNet, pArgs->hIf, pArgs->fPromiscuous); 
    886                 } 
    887  
    888                 case VMMR0_DO_INTNET_IF_SEND: 
    889                 { 
    890                     PINTNETIFSENDARGS pArgs = (PINTNETIFSENDARGS)pvArg; 
    891                     return INTNETR0IfSend(g_pIntNet, pArgs->hIf, pArgs->pvFrame, pArgs->cbFrame); 
    892                 } 
    893  
    894                 case VMMR0_DO_INTNET_IF_WAIT: 
    895                 { 
    896                     PINTNETIFWAITARGS pArgs = (PINTNETIFWAITARGS)pvArg; 
    897                     return INTNETR0IfWait(g_pIntNet, pArgs->hIf, pArgs->cMillies); 
    898                 } 
    899  
    900                 default: 
    901                     return VERR_NOT_SUPPORTED; 
    902             } 
    903         } 
     877                return VERR_NOT_SUPPORTED; 
     878            return INTNETR0IfWaitReq(g_pIntNet, (PINTNETIFWAITREQ)pReqHdr); 
    904879#endif /* VBOX_WITH_INTERNAL_NETWORKING */ 
    905880 

© 2008 Sun Microsystems, Inc.
ContactPrivacy policy