VirtualBox

Ignore:
Timestamp:
Nov 14, 2011 9:58:38 AM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
74838
Message:

CrOpenGL: avoid blocked client polling & extra memcpy (block hgsmi command until completion)

Location:
trunk/src/VBox/HostServices/SharedOpenGL/crserverlib
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/crserverlib.def

    r15532 r39288  
    1111crVBoxServerClientWrite
    1212crVBoxServerClientRead
     13crVBoxServerCrHgsmiCmd
     14crVBoxServerCrHgsmiCtl

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r36843 r39288  
    1515
    1616#include "cr_server.h"
     17
     18#ifdef VBOX_WITH_CRHGSMI
     19# include <VBox/VBoxVideo.h>
     20
     21extern uint8_t* g_pvVRamBase;
     22extern HCRHGSMICMDCOMPLETION g_hCrHgsmiCompletion;
     23extern PFNCRHGSMICMDCOMPLETION g_pfnCrHgsmiCompletion;
     24
     25#define VBOXCRHGSMI_PTR(_off, _t) ((_t*)(g_pvVRamBase + (_off)))
     26
     27DECLINLINE(void) crServerCrHgsmiCmdComplete(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd, int cmdProcessingRc)
     28{
     29    g_pfnCrHgsmiCompletion(g_hCrHgsmiCompletion, pCmd, cmdProcessingRc);
     30}
     31
     32#define VBOXCRHGSMI_CMD_COMPLETE(_pData, _rc) do { \
     33        CRVBOXHGSMI_CMDDATA_ASSERT_ISSET(_pData); \
     34        CRVBOXHGSMI_CMDDATA_RC(_pData, _rc); \
     35        crServerCrHgsmiCmdComplete((_pData)->pCmd, VINF_SUCCESS); \
     36    } while (0)
     37
     38#define VBOXCRHGSMI_CMD_CHECK_COMPLETE(_pData, _rc) do { \
     39        if (CRVBOXHGSMI_CMDDATA_IS_SET(_pData)) { \
     40            VBOXCRHGSMI_CMD_COMPLETE(_pData, _rc); \
     41        } \
     42    } while (0)
     43
     44#endif
    1745
    1846/*
    … …  
    98126GLboolean crServerIsRedirectedToFBO();
    99127
     128int32_t crVBoxServerInternalClientRead(CRClient *pClient, uint8_t *pBuffer, uint32_t *pcbBuffer);
     129
    100130#endif /* CR_SERVER_H */

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c

    r38505 r39288  
    3030#endif
    3131
     32#ifdef VBOX_WITH_CRHGSMI
     33# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
     34uint8_t* g_pvVRamBase = NULL;
     35HCRHGSMICMDCOMPLETION g_hCrHgsmiCompletion = NULL;
     36PFNCRHGSMICMDCOMPLETION g_pfnCrHgsmiCompletion = NULL;
     37#endif
     38
    3239/**
    3340 * \mainpage CrServerLib
    … …  
    4855int tearingdown = 0; /* can't be static */
    4956
     57DECLINLINE(int32_t) crVBoxServerClientGet(uint32_t u32ClientID, CRClient **ppClient)
     58{
     59    CRClient *pClient = NULL;
     60    int32_t i;
     61
     62    *ppClient = NULL;
     63
     64    for (i = 0; i < cr_server.numClients; i++)
     65    {
     66        if (cr_server.clients[i] && cr_server.clients[i]->conn
     67            && cr_server.clients[i]->conn->u32ClientID==u32ClientID)
     68        {
     69            pClient = cr_server.clients[i];
     70            break;
     71        }
     72    }
     73    if (!pClient)
     74    {
     75        crWarning("client not found!");
     76        return VERR_INVALID_PARAMETER;
     77    }
     78
     79    if (!pClient->conn->vMajor)
     80    {
     81        crWarning("no major version specified for client!");
     82        return VERR_NOT_SUPPORTED;
     83    }
     84
     85    *ppClient = pClient;
     86
     87    return VINF_SUCCESS;
     88}
     89
    5090
    5191/**
    … …  
    398438    }
    399439
     440#ifdef VBOX_WITH_CRHGSMI
     441    CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     442#endif
     443
    400444    /* Disconnect the client */
    401445    pClient->conn->Disconnect(pClient->conn);
    … …  
    405449}
    406450
    407 int32_t crVBoxServerClientWrite(uint32_t u32ClientID, uint8_t *pBuffer, uint32_t cbBuffer)
    408 {
    409     CRClient *pClient = NULL;
    410     int32_t i;
     451static int32_t crVBoxServerInternalClientWriteRead(CRClient *pClient)
     452{
    411453#ifdef VBOXCR_LOGFPS
    412454    uint64_t tstart, tend;
    … …  
    415457    /*crDebug("=>crServer: ClientWrite u32ClientID=%d", u32ClientID);*/
    416458
    417     for (i = 0; i < cr_server.numClients; i++)
    418     {
    419         if (cr_server.clients[i] && cr_server.clients[i]->conn
    420             && cr_server.clients[i]->conn->u32ClientID==u32ClientID)
    421         {
    422             pClient = cr_server.clients[i];
    423             break;
    424         }
    425     }
    426     if (!pClient) return VERR_INVALID_PARAMETER;
    427 
    428     if (!pClient->conn->vMajor) return VERR_NOT_SUPPORTED;
    429459
    430460#ifdef VBOXCR_LOGFPS
    … …  
    432462#endif
    433463
    434     CRASSERT(pBuffer);
    435 
    436     /* This should never fire unless we start to multithread */
    437     CRASSERT(pClient->conn->pBuffer==NULL && pClient->conn->cbBuffer==0);
    438 
    439     /* Check if there's a blocker in queue and it's not this client */
    440     if (cr_server.run_queue->client != pClient
    441         && crServerClientInBeginEnd(cr_server.run_queue->client))
    442     {
    443         crDebug("crServer: client %d blocked, allow_redir_ptr = 0", u32ClientID);
     464    /* This should be setup already */
     465    CRASSERT(pClient->conn->pBuffer);
     466    CRASSERT(pClient->conn->cbBuffer);
     467#ifdef VBOX_WITH_CRHGSMI
     468    CRVBOXHGSMI_CMDDATA_ASSERT_CONSISTENT(&pClient->conn->CmdData);
     469#endif
     470
     471    if (
     472#ifdef VBOX_WITH_CRHGSMI
     473         !CRVBOXHGSMI_CMDDATA_IS_SET(&pClient->conn->CmdData) &&
     474#endif
     475         cr_server.run_queue->client != pClient
     476         && crServerClientInBeginEnd(cr_server.run_queue->client))
     477    {
     478        crDebug("crServer: client %d blocked, allow_redir_ptr = 0", pClient->conn->u32ClientID);
    444479        pClient->conn->allow_redir_ptr = 0;
    445480    }
    … …  
    448483        pClient->conn->allow_redir_ptr = 1;
    449484    }
    450 
    451     pClient->conn->pBuffer = pBuffer;
    452     pClient->conn->cbBuffer = cbBuffer;
    453485
    454486    crNetRecv();
    455487    CRASSERT(pClient->conn->pBuffer==NULL && pClient->conn->cbBuffer==0);
     488    CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
    456489
    457490    crServerServiceClients();
    … …  
    486519    crStateResetCurrentPointers(&cr_server.current);
    487520
     521#ifndef VBOX_WITH_CRHGSMI
    488522    CRASSERT(!pClient->conn->allow_redir_ptr || crNetNumMessages(pClient->conn)==0);
     523#endif
    489524
    490525#ifdef VBOXCR_LOGFPS
    … …  
    497532}
    498533
    499 int32_t crVBoxServerClientRead(uint32_t u32ClientID, uint8_t *pBuffer, uint32_t *pcbBuffer)
     534
     535int32_t crVBoxServerClientWrite(uint32_t u32ClientID, uint8_t *pBuffer, uint32_t cbBuffer)
    500536{
    501537    CRClient *pClient=NULL;
    502     int32_t i;
    503 
    504     //crDebug("crServer: [%x] ClientRead u32ClientID=%d", crThreadID(), u32ClientID);
    505 
    506     for (i = 0; i < cr_server.numClients; i++)
    507     {
    508         if (cr_server.clients[i] && cr_server.clients[i]->conn
    509             && cr_server.clients[i]->conn->u32ClientID==u32ClientID)
    510         {
    511             pClient = cr_server.clients[i];
    512             break;
    513         }
    514     }
    515     if (!pClient) return VERR_INVALID_PARAMETER;   
    516 
    517     if (!pClient->conn->vMajor) return VERR_NOT_SUPPORTED;
    518 
     538    int32_t rc = crVBoxServerClientGet(u32ClientID, &pClient);
     539
     540    if (RT_FAILURE(rc))
     541        return rc;
     542
     543
     544    CRASSERT(pBuffer);
     545
     546    /* This should never fire unless we start to multithread */
     547    CRASSERT(pClient->conn->pBuffer==NULL && pClient->conn->cbBuffer==0);
     548
     549    pClient->conn->pBuffer = pBuffer;
     550    pClient->conn->cbBuffer = cbBuffer;
     551#ifdef VBOX_WITH_CRHGSMI
     552    CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     553#endif
     554
     555    return crVBoxServerInternalClientWriteRead(pClient);
     556}
     557
     558int32_t crVBoxServerInternalClientRead(CRClient *pClient, uint8_t *pBuffer, uint32_t *pcbBuffer)
     559{
    519560    if (pClient->conn->cbHostBuffer > *pcbBuffer)
    520561    {
    521562        crDebug("crServer: [%lx] ClientRead u32ClientID=%d FAIL, host buffer too small %d of %d",
    522                   crThreadID(), u32ClientID, *pcbBuffer, pClient->conn->cbHostBuffer);
     563                  crThreadID(), pClient->conn->u32ClientID, *pcbBuffer, pClient->conn->cbHostBuffer);
    523564
    524565        /* Return the size of needed buffer */
    … …  
    539580
    540581    return VINF_SUCCESS;
     582}
     583
     584int32_t crVBoxServerClientRead(uint32_t u32ClientID, uint8_t *pBuffer, uint32_t *pcbBuffer)
     585{
     586    CRClient *pClient=NULL;
     587    int32_t rc = crVBoxServerClientGet(u32ClientID, &pClient);
     588
     589    if (RT_FAILURE(rc))
     590        return rc;
     591
     592#ifdef VBOX_WITH_CRHGSMI
     593    CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     594#endif
     595
     596    return crVBoxServerInternalClientRead(pClient, pBuffer, pcbBuffer);
    541597}
    542598
    … …  
    10301086            if (0)
    10311087            {
    1032             CRContext *tmpCtx;
    1033             CRCreateInfo_t *createInfo;
     1088//            CRContext *tmpCtx;
     1089//            CRCreateInfo_t *createInfo;
    10341090            GLfloat one[4] = { 1, 1, 1, 1 };
    10351091            GLfloat amb[4] = { 0.4f, 0.4f, 0.4f, 1.0f };
    … …  
    12811337    return VINF_SUCCESS;
    12821338}
     1339
     1340
     1341#ifdef VBOX_WITH_CRHGSMI
     1342/* We moved all CrHgsmi command processing to crserverlib to keep the logic of dealing with CrHgsmi commands in one place.
     1343 *
     1344 * For now we need the notion of CrHgdmi commands in the crserver_lib to be able to complete it asynchronously once it is really processed.
     1345 * This help avoiding the "blocked-client" issues. The client is blocked if another client is doing begin-end stuff.
     1346 * For now we eliminated polling that could occur on block, which caused a higher-priority thread (in guest) polling for the blocked command complition
     1347 * to block the lower-priority thread trying to complete the blocking command.
     1348 * And removed extra memcpy done on blocked command arrival.
     1349 *
     1350 * In the future we will extend CrHgsmi functionality to maintain texture data directly in CrHgsmi allocation to avoid extra memcpy-ing with PBO,
     1351 * implement command completion and stuff necessary for GPU scheduling to work properly for WDDM Windows guests, etc.
     1352 *
     1353 * NOTE: it is ALWAYS responsibility of the crVBoxServerCrHgsmiCmd to complete the command!
     1354 * */
     1355int32_t crVBoxServerCrHgsmiCmd(struct VBOXVDMACMD_CHROMIUM_CMD *pCmd)
     1356{
     1357    int32_t rc;
     1358    uint32_t cBuffers = pCmd->cBuffers;
     1359    uint32_t cParams;
     1360    CRVBOXHGSMIHDR *pHdr;
     1361    uint32_t u32Function;
     1362    uint32_t u32ClientID;
     1363    CRClient *pClient;
     1364
     1365    if (!g_pvVRamBase)
     1366    {
     1367        CRASSERT(0);
     1368        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_STATE);
     1369        return VINF_SUCCESS;
     1370    }
     1371
     1372    if (!cBuffers)
     1373    {
     1374        CRASSERT(0);
     1375        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
     1376        return VINF_SUCCESS;
     1377    }
     1378
     1379    cParams = cBuffers-1;
     1380
     1381    pHdr = VBOXCRHGSMI_PTR(pCmd->aBuffers[0].offBuffer, CRVBOXHGSMIHDR);
     1382    u32Function = pHdr->u32Function;
     1383    u32ClientID = pHdr->u32ClientID;
     1384
     1385    switch (u32Function)
     1386    {
     1387        case SHCRGL_GUEST_FN_WRITE:
     1388        {
     1389            crDebug(("svcCall: SHCRGL_GUEST_FN_WRITE\n"));
     1390
     1391            /* @todo: Verify  */
     1392            if (cParams == 1)
     1393            {
     1394                CRVBOXHGSMIWRITE* pFnCmd = (CRVBOXHGSMIWRITE*)pHdr;
     1395                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
     1396                /* Fetch parameters. */
     1397                uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
     1398                uint32_t cbBuffer = pBuf->cbBuffer;
     1399
     1400                CRASSERT(pBuffer);
     1401                CRASSERT(cbBuffer);
     1402
     1403                rc = crVBoxServerClientGet(u32ClientID, &pClient);
     1404                if (RT_FAILURE(rc))
     1405                {
     1406                    break;
     1407                }
     1408
     1409                /* This should never fire unless we start to multithread */
     1410                CRASSERT(pClient->conn->pBuffer==NULL && pClient->conn->cbBuffer==0);
     1411                CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     1412
     1413                pClient->conn->pBuffer = pBuffer;
     1414                pClient->conn->cbBuffer = cbBuffer;
     1415                CRVBOXHGSMI_CMDDATA_SET(&pClient->conn->CmdData, pCmd, pHdr);
     1416                rc = crVBoxServerInternalClientWriteRead(pClient);
     1417                CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     1418                return rc;
     1419            }
     1420            else
     1421            {
     1422                crWarning("invalid number of args");
     1423                rc = VERR_INVALID_PARAMETER;
     1424                break;
     1425            }
     1426            break;
     1427        }
     1428
     1429        case SHCRGL_GUEST_FN_INJECT:
     1430        {
     1431            crDebug(("svcCall: SHCRGL_GUEST_FN_INJECT\n"));
     1432
     1433            /* @todo: Verify  */
     1434            if (cParams == 1)
     1435            {
     1436                CRVBOXHGSMIINJECT *pFnCmd = (CRVBOXHGSMIINJECT*)pHdr;
     1437                /* Fetch parameters. */
     1438                uint32_t u32InjectClientID = pFnCmd->u32ClientID;
     1439                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
     1440                uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
     1441                uint32_t cbBuffer = pBuf->cbBuffer;
     1442
     1443                CRASSERT(pBuffer);
     1444                CRASSERT(cbBuffer);
     1445
     1446                rc = crVBoxServerClientGet(u32InjectClientID, &pClient);
     1447                if (RT_FAILURE(rc))
     1448                {
     1449                    break;
     1450                }
     1451
     1452                /* This should never fire unless we start to multithread */
     1453                CRASSERT(pClient->conn->pBuffer==NULL && pClient->conn->cbBuffer==0);
     1454                CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     1455
     1456                pClient->conn->pBuffer = pBuffer;
     1457                pClient->conn->cbBuffer = cbBuffer;
     1458                CRVBOXHGSMI_CMDDATA_SET(&pClient->conn->CmdData, pCmd, pHdr);
     1459                rc = crVBoxServerInternalClientWriteRead(pClient);
     1460                CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     1461                return rc;
     1462            }
     1463
     1464            crWarning("invalid number of args");
     1465            rc = VERR_INVALID_PARAMETER;
     1466            break;
     1467        }
     1468
     1469        case SHCRGL_GUEST_FN_READ:
     1470        {
     1471            crDebug(("svcCall: SHCRGL_GUEST_FN_READ\n"));
     1472
     1473            /* @todo: Verify  */
     1474            if (cParams == 1)
     1475            {
     1476                CRVBOXHGSMIREAD *pFnCmd = (CRVBOXHGSMIREAD*)pHdr;
     1477                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
     1478                /* Fetch parameters. */
     1479                uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
     1480                uint32_t cbBuffer = pBuf->cbBuffer;
     1481
     1482                rc = crVBoxServerClientGet(u32ClientID, &pClient);
     1483                if (RT_FAILURE(rc))
     1484                {
     1485                    break;
     1486                }
     1487
     1488                CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     1489
     1490                rc = crVBoxServerInternalClientRead(pClient, pBuffer, &cbBuffer);
     1491
     1492                /* Return the required buffer size always */
     1493                pFnCmd->cbBuffer = cbBuffer;
     1494
     1495                CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     1496
     1497                /* the read command is never pended, complete it right away */
     1498                pHdr->result = rc;
     1499                crServerCrHgsmiCmdComplete(pCmd, VINF_SUCCESS);
     1500                return VINF_SUCCESS;
     1501            }
     1502
     1503            crWarning("invalid number of args");
     1504            rc = VERR_INVALID_PARAMETER;
     1505            break;
     1506        }
     1507
     1508        case SHCRGL_GUEST_FN_WRITE_READ:
     1509        {
     1510            crDebug(("svcCall: SHCRGL_GUEST_FN_WRITE_READ\n"));
     1511
     1512            /* @todo: Verify  */
     1513            if (cParams == 2)
     1514            {
     1515                CRVBOXHGSMIWRITEREAD *pFnCmd = (CRVBOXHGSMIWRITEREAD*)pHdr;
     1516                VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
     1517                VBOXVDMACMD_CHROMIUM_BUFFER *pWbBuf = &pCmd->aBuffers[2];
     1518
     1519                /* Fetch parameters. */
     1520                uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
     1521                uint32_t cbBuffer = pBuf->cbBuffer;
     1522
     1523                uint8_t *pWriteback  = VBOXCRHGSMI_PTR(pWbBuf->offBuffer, uint8_t);
     1524                uint32_t cbWriteback = pWbBuf->cbBuffer;
     1525
     1526                CRASSERT(pBuffer);
     1527                CRASSERT(cbBuffer);
     1528
     1529                rc = crVBoxServerClientGet(u32ClientID, &pClient);
     1530                if (RT_FAILURE(rc))
     1531                {
     1532                    pHdr->result = rc;
     1533                    crServerCrHgsmiCmdComplete(pCmd, VINF_SUCCESS);
     1534                    return rc;
     1535                }
     1536
     1537                /* This should never fire unless we start to multithread */
     1538                CRASSERT(pClient->conn->pBuffer==NULL && pClient->conn->cbBuffer==0);
     1539                CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     1540
     1541                pClient->conn->pBuffer = pBuffer;
     1542                pClient->conn->cbBuffer = cbBuffer;
     1543                CRVBOXHGSMI_CMDDATA_SETWB(&pClient->conn->CmdData, pCmd, pHdr, pWriteback, cbWriteback, &pFnCmd->cbWriteback);
     1544                rc = crVBoxServerInternalClientWriteRead(pClient);
     1545                CRVBOXHGSMI_CMDDATA_ASSERT_CLEANED(&pClient->conn->CmdData);
     1546                return rc;
     1547            }
     1548
     1549            crWarning("invalid number of args");
     1550            rc = VERR_INVALID_PARAMETER;
     1551            break;
     1552        }
     1553
     1554        case SHCRGL_GUEST_FN_SET_VERSION:
     1555        {
     1556            crWarning("invalid function");
     1557            rc = VERR_NOT_IMPLEMENTED;
     1558            break;
     1559        }
     1560
     1561        case SHCRGL_GUEST_FN_SET_PID:
     1562        {
     1563            crWarning("invalid function");
     1564            rc = VERR_NOT_IMPLEMENTED;
     1565            break;
     1566        }
     1567
     1568        default:
     1569        {
     1570            crWarning("invalid function");
     1571            rc = VERR_NOT_IMPLEMENTED;
     1572            break;
     1573        }
     1574
     1575    }
     1576
     1577    /* we can be on fail only here */
     1578    CRASSERT(RT_FAILURE(rc));
     1579    pHdr->result = rc;
     1580    crServerCrHgsmiCmdComplete(pCmd, VINF_SUCCESS);
     1581    return rc;
     1582}
     1583
     1584int32_t crVBoxServerCrHgsmiCtl(struct VBOXVDMACMD_CHROMIUM_CTL *pCtl)
     1585{
     1586    int rc = VINF_SUCCESS;
     1587
     1588    switch (pCtl->enmType)
     1589    {
     1590        case VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP:
     1591        {
     1592            PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP pSetup = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP)pCtl;
     1593            g_pvVRamBase = (uint8_t*)pSetup->pvRamBase;
     1594            rc = VINF_SUCCESS;
     1595            break;
     1596        }
     1597        case VBOXVDMACMD_CHROMIUM_CTL_TYPE_SAVESTATE_BEGIN:
     1598        case VBOXVDMACMD_CHROMIUM_CTL_TYPE_SAVESTATE_END:
     1599            rc = VINF_SUCCESS;
     1600            break;
     1601        case VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_COMPLETION:
     1602        {
     1603            PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_COMPLETION pSetup = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_COMPLETION)pCtl;
     1604            g_hCrHgsmiCompletion = pSetup->hCompletion;
     1605            g_pfnCrHgsmiCompletion = pSetup->pfnCompletion;
     1606            rc = VINF_SUCCESS;
     1607            break;
     1608        }
     1609        default:
     1610            AssertMsgFailed(("invalid param %d", pCtl->enmType));
     1611            rc = VERR_INVALID_PARAMETER;
     1612    }
     1613
     1614    /* NOTE: Control commands can NEVER be pended here, this is why its a task of a caller (Main)
     1615     * to complete them accordingly.
     1616     * This approach allows using host->host and host->guest commands in the same way here
     1617     * making the command completion to be the responsibility of the command originator.
     1618     * E.g. ctl commands can be both Hgcm Host synchronous commands that do not require completion at all,
     1619     * or Hgcm Host Fast Call commands that do require completion. All this details are hidden here */
     1620    return rc;
     1621}
     1622#endif

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_retval.py

    r30458 r39288  
    3636
    3737    rb->header.type = CR_MESSAGE_READBACK;
     38    CRDBGPTR_PRINTWB(cr_server.curClient->conn->u32ClientID, &cr_server.writeback_ptr);
     39    CRDBGPTR_CHECKNZ(&cr_server.writeback_ptr);
     40    CRDBGPTR_CHECKNZ(&cr_server.return_ptr);
    3841    crMemcpy( &(rb->writeback_ptr), &(cr_server.writeback_ptr), sizeof( rb->writeback_ptr ) );
    3942    crMemcpy( &(rb->readback_ptr), &(cr_server.return_ptr), sizeof( rb->readback_ptr ) );
    4043    crMemcpy( rb+1, payload, payload_len );
    4144    crNetSend( cr_server.curClient->conn, NULL, rb, msg_len );
     45    CRDBGPTR_SETZ(&cr_server.writeback_ptr);
     46    CRDBGPTR_SETZ(&cr_server.return_ptr);
    4247    crFree( rb );
    4348}

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_stream.c

    r33989 r39288  
    2525                                                                                 cr_server.tcpip_port,
    2626                                                                                 cr_server.mtu, 1 );
     27
    2728        newClient->currentCtx = cr_server.DummyContext;
    2829
    … …  
    7677{
    7778    RunQueue *q = (RunQueue *) crAlloc( sizeof( *q ) );
     79
     80#ifdef VBOX_WITH_CRHGSMI
     81    client->conn->pClient = client;
     82    CRVBOXHGSMI_CMDDATA_CLEANUP(&client->conn->CmdData);
     83#endif
    7884
    7985    /* give this client a unique number if needed */
    … …  
    393399 */
    394400static void
    395 crServerDispatchMessage(CRMessage *msg)
     401crServerDispatchMessage(CRConnection *conn, CRMessage *msg)
    396402{
    397403    const CRMessageOpcodes *msg_opcodes;
    398404    int opcodeBytes;
    399405    const char *data_ptr;
     406#ifdef VBOX_WITH_CRHGSMI
     407    PCRVBOXHGSMI_CMDDATA pCmdData = NULL;
     408#endif
    400409
    401410    if (msg->header.type == CR_MESSAGE_REDIR_PTR)
    402411    {
     412#ifdef VBOX_WITH_CRHGSMI
     413        pCmdData = &msg->redirptr.CmdData;
     414#endif
    403415        msg = (CRMessage *) msg->redirptr.pMessage;
    404416    }
    … …  
    419431             msg_opcodes->numOpcodes,  /* how many opcodes */
    420432             &(cr_server.dispatch));   /* the CR dispatch table */
     433
     434#ifdef VBOX_WITH_CRHGSMI
     435    if (pCmdData)
     436    {
     437        int rc = VINF_SUCCESS;
     438        CRVBOXHGSMI_CMDDATA_ASSERT_CONSISTENT(pCmdData);
     439        if (CRVBOXHGSMI_CMDDATA_IS_SETWB(pCmdData))
     440        {
     441            uint32_t cbWriteback = pCmdData->cbWriteback;
     442            rc = crVBoxServerInternalClientRead(conn->pClient, pCmdData->pWriteback, &cbWriteback);
     443            CRASSERT(rc == VINF_SUCCESS || rc == VERR_BUFFER_OVERFLOW);
     444            *pCmdData->pcbWriteback = cbWriteback;
     445        }
     446        VBOXCRHGSMI_CMD_CHECK_COMPLETE(pCmdData, rc);
     447    }
     448#endif
    421449}
    422450
    … …  
    532560
    533561        /* Commands get dispatched here */
    534         crServerDispatchMessage(msg);
     562        crServerDispatchMessage( conn, msg );
    535563
    536564        crNetFree( conn, msg );
    … …  
    540568             * glEndList pair at this time!
    541569             */
     570            CRASSERT(0);
    542571            return CLIENT_NEXT;
    543572        }

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_writeback.c

    r15532 r39288  
    2020        CRMessageWriteback *wb = (CRMessageWriteback *) crAlloc( sizeof( *wb ) );
    2121        wb->header.type = CR_MESSAGE_WRITEBACK;
     22        CRDBGPTR_PRINTWB(cr_server.curClient->conn->u32ClientID, &cr_server.writeback_ptr);
     23        CRDBGPTR_CHECKNZ(&cr_server.writeback_ptr);
    2224        crMemcpy( &(wb->writeback_ptr), &(cr_server.writeback_ptr), sizeof( wb->writeback_ptr ) );
    2325        crNetSend( cr_server.curClient->conn, NULL, wb, sizeof( *wb ) );
     26        CRDBGPTR_SETZ(&cr_server.writeback_ptr);
    2427        crFree( wb );
    2528}
Note: See TracChangeset for help on using the changeset viewer.

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