VirtualBox

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

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

    r38505 r39288  
    5353#endif /* RT_OS_WINDOWS */
    5454
    55 #ifdef VBOX_WITH_CRHGSMI
    56 # include <VBox/VBoxVideo.h>
    57 #endif
    58 
    5955#include <VBox/com/errorprint.h>
    6056#include <iprt/thread.h>
     
    6864static IConsole* g_pConsole = NULL;
    6965static PVM g_pVM = NULL;
    70 #ifdef VBOX_WITH_CRHGSMI
    71 static uint8_t* g_pvVRamBase;
    72 #endif
    7366
    7467#ifndef RT_OS_WINDOWS
     
    919912}
    920913
    921 #ifdef VBOX_WITH_CRHGSMI
    922 static int vboxCrHgsmiCtl(PVBOXVDMACMD_CHROMIUM_CTL pCtl)
    923 {
    924     int rc;
    925 
    926     switch (pCtl->enmType)
    927     {
    928         case VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP:
    929         {
    930             PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP pSetup = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP)pCtl;
    931             g_pvVRamBase = (uint8_t*)pSetup->pvRamBase;
    932             rc = VINF_SUCCESS;
    933         } break;
    934         case VBOXVDMACMD_CHROMIUM_CTL_TYPE_SAVESTATE_BEGIN:
    935         case VBOXVDMACMD_CHROMIUM_CTL_TYPE_SAVESTATE_END:
    936             rc = VINF_SUCCESS;
    937             break;
    938         default:
    939             Assert(0);
    940             rc = VERR_INVALID_PARAMETER;
    941     }
    942 
    943     return rc;
    944 }
    945 
    946 #define VBOXCRHGSMI_PTR(_off, _t) ((_t*)(g_pvVRamBase + (_off)))
    947 static int vboxCrHgsmiCmd(PVBOXVDMACMD_CHROMIUM_CMD pCmd)
    948 {
    949     int rc;
    950     uint32_t cBuffers = pCmd->cBuffers;
    951     uint32_t cParams;
    952 
    953     if (!g_pvVRamBase)
    954     {
    955         Assert(0);
    956         return VERR_INVALID_STATE;
    957     }
    958 
    959     if (!cBuffers)
    960     {
    961         Assert(0);
    962         return VERR_INVALID_PARAMETER;
    963     }
    964 
    965     cParams = cBuffers-1;
    966 
    967     CRVBOXHGSMIHDR *pHdr = VBOXCRHGSMI_PTR(pCmd->aBuffers[0].offBuffer, CRVBOXHGSMIHDR);
    968     uint32_t u32Function = pHdr->u32Function;
    969     uint32_t u32ClientID = pHdr->u32ClientID;
    970     /* now we compile HGCM params out of HGSMI
    971      * @todo: can we avoid this ? */
    972     switch (u32Function)
    973     {
    974 
    975         case SHCRGL_GUEST_FN_WRITE:
    976         {
    977             Log(("svcCall: SHCRGL_GUEST_FN_WRITE\n"));
    978 
    979             CRVBOXHGSMIWRITE* pFnCmd = (CRVBOXHGSMIWRITE*)pHdr;
    980 
    981             /* @todo: Verify  */
    982             if (cParams == 1)
    983             {
    984                 VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    985                 /* Fetch parameters. */
    986                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    987                 uint32_t cbBuffer = pBuf->cbBuffer;
    988 
    989                 /* Execute the function. */
    990                 rc = crVBoxServerClientWrite(u32ClientID, pBuffer, cbBuffer);
    991                 if (!RT_SUCCESS(rc))
    992                 {
    993                     Assert(VERR_NOT_SUPPORTED==rc);
    994                     svcClientVersionUnsupported(0, 0);
    995                 }
    996             }
    997             else
    998             {
    999                 Assert(0);
    1000                 rc = VERR_INVALID_PARAMETER;
    1001             }
    1002             break;
    1003         }
    1004 
    1005         case SHCRGL_GUEST_FN_INJECT:
    1006         {
    1007             Log(("svcCall: SHCRGL_GUEST_FN_INJECT\n"));
    1008 
    1009             CRVBOXHGSMIINJECT *pFnCmd = (CRVBOXHGSMIINJECT*)pHdr;
    1010 
    1011             /* @todo: Verify  */
    1012             if (cParams == 1)
    1013             {
    1014                 /* Fetch parameters. */
    1015                 uint32_t u32InjectClientID = pFnCmd->u32ClientID;
    1016                 VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    1017                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    1018                 uint32_t cbBuffer = pBuf->cbBuffer;
    1019 
    1020                 /* Execute the function. */
    1021                 rc = crVBoxServerClientWrite(u32InjectClientID, pBuffer, cbBuffer);
    1022                 if (!RT_SUCCESS(rc))
    1023                 {
    1024                     if (VERR_NOT_SUPPORTED==rc)
    1025                     {
    1026                         svcClientVersionUnsupported(0, 0);
    1027                     }
    1028                     else
    1029                     {
    1030                         crWarning("SHCRGL_GUEST_FN_INJECT failed to inject for %i from %i", u32InjectClientID, u32ClientID);
    1031                     }
    1032                 }
    1033             }
    1034             else
    1035             {
    1036                 Assert(0);
    1037                 rc = VERR_INVALID_PARAMETER;
    1038             }
    1039             break;
    1040         }
    1041 
    1042         case SHCRGL_GUEST_FN_READ:
    1043         {
    1044             Log(("svcCall: SHCRGL_GUEST_FN_READ\n"));
    1045 
    1046             /* @todo: Verify  */
    1047             if (cParams == 1)
    1048             {
    1049                 CRVBOXHGSMIREAD *pFnCmd = (CRVBOXHGSMIREAD*)pHdr;
    1050                 VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    1051                 /* Fetch parameters. */
    1052                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    1053                 uint32_t cbBuffer = pBuf->cbBuffer;
    1054 
    1055                 /* Execute the function. */
    1056                 rc = crVBoxServerClientRead(u32ClientID, pBuffer, &cbBuffer);
    1057 
    1058                 if (RT_SUCCESS(rc))
    1059                 {
    1060                     /* Update parameters.*/
    1061 //                    paParms[0].u.pointer.size = cbBuffer; //@todo guest doesn't see this change somehow?
    1062                 } else if (VERR_NOT_SUPPORTED==rc)
    1063                 {
    1064                     svcClientVersionUnsupported(0, 0);
    1065                 }
    1066 
    1067                 /* Return the required buffer size always */
    1068                 pFnCmd->cbBuffer = cbBuffer;
    1069             }
    1070             else
    1071             {
    1072                 Assert(0);
    1073                 rc = VERR_INVALID_PARAMETER;
    1074             }
    1075 
    1076             break;
    1077         }
    1078 
    1079         case SHCRGL_GUEST_FN_WRITE_READ:
    1080         {
    1081             Log(("svcCall: SHCRGL_GUEST_FN_WRITE_READ\n"));
    1082 
    1083             /* @todo: Verify  */
    1084             if (cParams == 2)
    1085             {
    1086                 CRVBOXHGSMIWRITEREAD *pFnCmd = (CRVBOXHGSMIWRITEREAD*)pHdr;
    1087                 VBOXVDMACMD_CHROMIUM_BUFFER *pBuf = &pCmd->aBuffers[1];
    1088                 VBOXVDMACMD_CHROMIUM_BUFFER *pWbBuf = &pCmd->aBuffers[2];
    1089 
    1090                 /* Fetch parameters. */
    1091                 uint8_t *pBuffer  = VBOXCRHGSMI_PTR(pBuf->offBuffer, uint8_t);
    1092                 uint32_t cbBuffer = pBuf->cbBuffer;
    1093 
    1094                 uint8_t *pWriteback  = VBOXCRHGSMI_PTR(pWbBuf->offBuffer, uint8_t);
    1095                 uint32_t cbWriteback = pWbBuf->cbBuffer;
    1096 
    1097                 /* Execute the function. */
    1098                 rc = crVBoxServerClientWrite(u32ClientID, pBuffer, cbBuffer);
    1099                 if (!RT_SUCCESS(rc))
    1100                 {
    1101                     Assert(VERR_NOT_SUPPORTED==rc);
    1102                     svcClientVersionUnsupported(0, 0);
    1103                 }
    1104 
    1105                 rc = crVBoxServerClientRead(u32ClientID, pWriteback, &cbWriteback);
    1106 
    1107 //                if (RT_SUCCESS(rc))
    1108 //                {
    1109 //                    /* Update parameters.*/
    1110 //                    paParms[1].u.pointer.size = cbWriteback;
    1111 //                }
    1112                 /* Return the required buffer size always */
    1113                 pFnCmd->cbWriteback = cbWriteback;
    1114             }
    1115             else
    1116             {
    1117                 Assert(0);
    1118                 rc = VERR_INVALID_PARAMETER;
    1119             }
    1120 
    1121             break;
    1122         }
    1123 
    1124         case SHCRGL_GUEST_FN_SET_VERSION:
    1125         {
    1126             Assert(0);
    1127             rc = VERR_NOT_IMPLEMENTED;
    1128             break;
    1129         }
    1130 
    1131         case SHCRGL_GUEST_FN_SET_PID:
    1132         {
    1133             Assert(0);
    1134             rc = VERR_NOT_IMPLEMENTED;
    1135             break;
    1136         }
    1137 
    1138         default:
    1139         {
    1140             Assert(0);
    1141             rc = VERR_NOT_IMPLEMENTED;
    1142         }
    1143 
    1144     }
    1145 
    1146     pHdr->result = rc;
    1147 
    1148     return VINF_SUCCESS;
    1149 }
    1150 #endif
    1151 
    1152914/*
    1153915 * We differentiate between a function handler for the guest and one for the host.
     
    1176938            Assert(cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR);
    1177939            if (cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR)
    1178                 rc = vboxCrHgsmiCmd((PVBOXVDMACMD_CHROMIUM_CMD)paParms[0].u.pointer.addr);
     940            {
     941                rc = crVBoxServerCrHgsmiCmd((PVBOXVDMACMD_CHROMIUM_CMD)paParms[0].u.pointer.addr);
     942                if (VERR_NOT_SUPPORTED == rc)
     943                {
     944                    svcClientVersionUnsupported(0, 0);
     945                }
     946            }
    1179947            else
    1180948                rc = VERR_INVALID_PARAMETER;
     
    1184952            Assert(cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR);
    1185953            if (cParms == 1 && paParms[0].type == VBOX_HGCM_SVC_PARM_PTR)
    1186                 rc = vboxCrHgsmiCtl((PVBOXVDMACMD_CHROMIUM_CTL)paParms[0].u.pointer.addr);
     954                rc = crVBoxServerCrHgsmiCtl((PVBOXVDMACMD_CHROMIUM_CTL)paParms[0].u.pointer.addr);
    1187955            else
    1188956                rc = VERR_INVALID_PARAMETER;
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