VirtualBox

Changeset 71607 in vbox for trunk/src/VBox/HostServices


Ignore:
Timestamp:
Apr 1, 2018 11:38:00 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
121634
Message:

DevVGA,SharedOpenGL: Code cleanup in progress. bugref:9094

Location:
trunk/src/VBox/HostServices/SharedOpenGL/crserverlib
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/presenter/server_presenter.cpp

    r69500 r71607  
    38883888}
    38893889
    3890 int8_t crVBoxServerCrCmdClrFillProcess(const VBOXCMDVBVA_CLRFILL_HDR *pCmd, uint32_t cbCmd)
    3891 {
     3890/** @todo RT_UNTRUSTED_VOLATILE_GUEST */
     3891int8_t crVBoxServerCrCmdClrFillProcess(VBOXCMDVBVA_CLRFILL_HDR const RT_UNTRUSTED_VOLATILE_GUEST *pCmdTodo, uint32_t cbCmd)
     3892{
     3893    VBOXCMDVBVA_CLRFILL_HDR const *pCmd = (VBOXCMDVBVA_CLRFILL_HDR const *)pCmdTodo;
    38923894    uint8_t u8Flags = pCmd->Hdr.u8Flags;
    38933895    uint8_t u8Cmd = (VBOXCMDVBVA_OPF_CLRFILL_TYPE_MASK & u8Flags);
    … …  
    39123914}
    39133915
    3914 int8_t crVBoxServerCrCmdBltProcess(const VBOXCMDVBVA_BLT_HDR *pCmd, uint32_t cbCmd)
    3915 {
     3916/** @todo RT_UNTRUSTED_VOLATILE_GUEST */
     3917int8_t crVBoxServerCrCmdBltProcess(VBOXCMDVBVA_BLT_HDR const RT_UNTRUSTED_VOLATILE_GUEST *pCmdTodo, uint32_t cbCmd)
     3918{
     3919    VBOXCMDVBVA_BLT_HDR const *pCmd = (VBOXCMDVBVA_BLT_HDR const *)pCmdTodo;
    39163920    uint8_t u8Flags = pCmd->Hdr.u8Flags;
    39173921    uint8_t u8Cmd = (VBOXCMDVBVA_OPF_BLT_TYPE_MASK & u8Flags);
    … …  
    39553959}
    39563960
    3957 int8_t crVBoxServerCrCmdFlipProcess(const VBOXCMDVBVA_FLIP *pFlip, uint32_t cbCmd)
    3958 {
     3961/** @todo RT_UNTRUSTED_VOLATILE_GUEST   */
     3962int8_t crVBoxServerCrCmdFlipProcess(VBOXCMDVBVA_FLIP const RT_UNTRUSTED_VOLATILE_GUEST *pFlipTodo, uint32_t cbCmd)
     3963{
     3964    VBOXCMDVBVA_FLIP const *pFlip = (VBOXCMDVBVA_FLIP const *)pFlipTodo;
    39593965    uint32_t hostId;
    39603966    const VBOXCMDVBVA_RECT *pPRects = pFlip->aRects;

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

    r69474 r71607  
    470470void CrFbTexDataInit(CR_TEXDATA* pFbTex, const VBOXVR_TEXTURE *pTex, PFNCRTEXDATA_RELEASED pfnTextureReleased);
    471471
    472 int8_t crVBoxServerCrCmdBltProcess(const VBOXCMDVBVA_BLT_HDR *pCmd, uint32_t cbCmd);
    473 int8_t crVBoxServerCrCmdClrFillProcess(const VBOXCMDVBVA_CLRFILL_HDR *pCmd, uint32_t cbCmd);
    474 int8_t crVBoxServerCrCmdFlipProcess(const VBOXCMDVBVA_FLIP *pFlip, uint32_t cbCmd);
     472int8_t crVBoxServerCrCmdBltProcess(VBOXCMDVBVA_BLT_HDR const RT_UNTRUSTED_VOLATILE_GUEST *pCmd, uint32_t cbCmd);
     473int8_t crVBoxServerCrCmdClrFillProcess(VBOXCMDVBVA_CLRFILL_HDR const RT_UNTRUSTED_VOLATILE_GUEST *pCmd, uint32_t cbCmd);
     474int8_t crVBoxServerCrCmdFlipProcess(VBOXCMDVBVA_FLIP const RT_UNTRUSTED_VOLATILE_GUEST *pFlip, uint32_t cbCmd);
    475475
    476476

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

    r69390 r71607  
    3434#include <VBox/err.h>
    3535#include <VBox/log.h>
     36#include <VBox/AssertGuest.h>
    3637
    3738#ifdef VBOXCR_LOGFPS
    … …  
    6768int tearingdown = 0; /* can't be static */
    6869
    69 static DECLCALLBACK(int8_t) crVBoxCrCmdCmd(HVBOXCRCMDSVR hSvr, const VBOXCMDVBVA_HDR *pCmd, uint32_t cbCmd);
     70static DECLCALLBACK(int8_t) crVBoxCrCmdCmd(HVBOXCRCMDSVR hSvr,
     71                                           const VBOXCMDVBVA_HDR RT_UNTRUSTED_VOLATILE_GUEST *pCmd, uint32_t cbCmd);
    7072
    7173DECLINLINE(CRClient*) crVBoxServerClientById(uint32_t u32ClientID)
    … …  
    28732875#ifdef VBOX_WITH_CRHGSMI
    28742876
    2875 static int32_t crVBoxServerCmdVbvaCrCmdProcess(const struct VBOXCMDVBVA_CRCMD_CMD *pCmd, uint32_t cbCmd)
    2876 {
     2877/** @todo RT_UNTRUSTED_VOLATILE_GUEST   */
     2878static int32_t crVBoxServerCmdVbvaCrCmdProcess(VBOXCMDVBVA_CRCMD_CMD const RT_UNTRUSTED_VOLATILE_GUEST *pCmdTodo, uint32_t cbCmd)
     2879{
     2880    VBOXCMDVBVA_CRCMD_CMD const *pCmd = (VBOXCMDVBVA_CRCMD_CMD const *)pCmdTodo;
    28772881    int32_t rc;
    28782882    uint32_t cBuffers = pCmd->cBuffers;
    … …  
    32333237}
    32343238
    3235 static int crVBoxCrConnectEx(VBOXCMDVBVA_3DCTL_CONNECT *pConnect, uint32_t u32ClientId)
     3239static int crVBoxCrConnectEx(VBOXCMDVBVA_3DCTL_CONNECT RT_UNTRUSTED_VOLATILE_GUEST *pConnect, uint32_t u32ClientId)
    32363240{
    32373241    CRClient *pClient;
    32383242    int rc;
     3243    uint32_t const uMajorVersion = pConnect->u32MajorVersion;
     3244    uint32_t const uMinorVersion = pConnect->u32MinorVersion;
     3245    uint64_t const uPid          = pConnect->u64Pid;
     3246    RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
    32393247
    32403248    if (u32ClientId == CRHTABLE_HANDLE_INVALID)
    … …  
    32523260    if (RT_SUCCESS(rc))
    32533261    {
    3254         rc = crVBoxServerClientObjSetVersion(pClient, pConnect->u32MajorVersion, pConnect->u32MinorVersion);
     3262        rc = crVBoxServerClientObjSetVersion(pClient, uMajorVersion, uMinorVersion);
    32553263        if (RT_SUCCESS(rc))
    32563264        {
    3257             rc = crVBoxServerClientObjSetPID(pClient, pConnect->u64Pid);
     3265            rc = crVBoxServerClientObjSetPID(pClient, uPid);
    32583266            if (RT_SUCCESS(rc))
    32593267            {
    … …  
    32643272                    return VINF_SUCCESS;
    32653273                }
    3266                 else
    3267                     WARN(("CrHTablePutToSlot failed %d", rc));
     3274                WARN(("CrHTablePutToSlot failed %d", rc));
    32683275            }
    32693276            else
    … …  
    32833290}
    32843291
    3285 static int crVBoxCrConnect(VBOXCMDVBVA_3DCTL_CONNECT *pConnect)
     3292static int crVBoxCrConnect(VBOXCMDVBVA_3DCTL_CONNECT RT_UNTRUSTED_VOLATILE_GUEST *pConnect)
    32863293{
    32873294    return crVBoxCrConnectEx(pConnect, CRHTABLE_HANDLE_INVALID);
    32883295}
    32893296
    3290 static DECLCALLBACK(int) crVBoxCrCmdGuestCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
    3291 {
    3292     VBOXCMDVBVA_3DCTL *pCtl = (VBOXCMDVBVA_3DCTL*)pCmd;
    3293     if (cbCmd < sizeof (VBOXCMDVBVA_3DCTL))
    3294     {
    3295         WARN(("invalid buffer size"));
    3296         return VERR_INVALID_PARAMETER;
    3297     }
    3298 
    3299     switch (pCtl->u32Type)
    3300     {
    3301         case VBOXCMDVBVA3DCTL_TYPE_CONNECT:
    3302         {
    3303             if (cbCmd != sizeof (VBOXCMDVBVA_3DCTL_CONNECT))
    3304             {
    3305                 WARN(("invalid command size"));
    3306                 return VERR_INVALID_PARAMETER;
    3307             }
    3308 
    3309             return crVBoxCrConnect((VBOXCMDVBVA_3DCTL_CONNECT*)pCtl);
    3310         }
    3311         case VBOXCMDVBVA3DCTL_TYPE_DISCONNECT:
    3312         {
    3313             if (cbCmd != sizeof (VBOXCMDVBVA_3DCTL))
    3314             {
    3315                 WARN(("invalid command size"));
    3316                 return VERR_INVALID_PARAMETER;
    3317             }
    3318 
    3319             return crVBoxCrDisconnect(pCtl->u32CmdClientId);
    3320         }
    3321         case VBOXCMDVBVA3DCTL_TYPE_CMD:
    3322         {
    3323             VBOXCMDVBVA_3DCTL_CMD *p3DCmd;
    3324             if (cbCmd < sizeof (VBOXCMDVBVA_3DCTL_CMD))
    3325             {
    3326                 WARN(("invalid size"));
    3327                 return VERR_INVALID_PARAMETER;
    3328             }
    3329 
    3330             p3DCmd = (VBOXCMDVBVA_3DCTL_CMD*)pCmd;
    3331 
    3332             return crVBoxCrCmdCmd(NULL, &p3DCmd->Cmd, cbCmd - RT_OFFSETOF(VBOXCMDVBVA_3DCTL_CMD, Cmd));
    3333         }
    3334         default:
    3335             WARN(("crVBoxCrCmdGuestCtl: invalid function %d", pCtl->u32Type));
    3336             return VERR_INVALID_PARAMETER;
     3297/**
     3298 * @interface_method_impl{VBOXCRCMD_SVRINFO,pfnGuestCtl}
     3299 */
     3300static DECLCALLBACK(int) crVBoxCrCmdGuestCtl(HVBOXCRCMDSVR hSvr, uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbCmd, uint32_t cbCmd)
     3301{
     3302    /*
     3303     * Toplevel input validation.
     3304     */
     3305    ASSERT_GUEST_LOGREL_RETURN(cbCmd >= sizeof(VBOXCMDVBVA_3DCTL), VERR_INVALID_PARAMETER);
     3306    {
     3307        VBOXCMDVBVA_3DCTL RT_UNTRUSTED_VOLATILE_GUEST *pCtl = (VBOXCMDVBVA_3DCTL RT_UNTRUSTED_VOLATILE_GUEST*)pbCmd;
     3308        const uint32_t uType = pCtl->u32Type;
     3309        RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
     3310
     3311        ASSERT_GUEST_LOGREL_RETURN(   uType == VBOXCMDVBVA3DCTL_TYPE_CMD
     3312                                   || uType == VBOXCMDVBVA3DCTL_TYPE_CONNECT
     3313                                   || uType == VBOXCMDVBVA3DCTL_TYPE_DISCONNECT
     3314                                   , VERR_INVALID_PARAMETER);
     3315        RT_UNTRUSTED_VALIDATED_FENCE();
     3316
     3317        /*
     3318         * Call worker abd process the request.
     3319         */
     3320        switch (uType)
     3321        {
     3322            case VBOXCMDVBVA3DCTL_TYPE_CMD:
     3323                ASSERT_GUEST_LOGREL_RETURN(cbCmd >= sizeof(VBOXCMDVBVA_3DCTL_CMD), VERR_INVALID_PARAMETER);
     3324                {
     3325                    VBOXCMDVBVA_3DCTL_CMD RT_UNTRUSTED_VOLATILE_GUEST *p3DCmd
     3326                        = (VBOXCMDVBVA_3DCTL_CMD RT_UNTRUSTED_VOLATILE_GUEST *)pbCmd;
     3327                    return crVBoxCrCmdCmd(NULL, &p3DCmd->Cmd, cbCmd - RT_OFFSETOF(VBOXCMDVBVA_3DCTL_CMD, Cmd));
     3328                }
     3329
     3330            case VBOXCMDVBVA3DCTL_TYPE_CONNECT:
     3331                ASSERT_GUEST_LOGREL_RETURN(cbCmd == sizeof(VBOXCMDVBVA_3DCTL_CONNECT), VERR_INVALID_PARAMETER);
     3332                return crVBoxCrConnect((VBOXCMDVBVA_3DCTL_CONNECT RT_UNTRUSTED_VOLATILE_GUEST *)pCtl);
     3333
     3334            case VBOXCMDVBVA3DCTL_TYPE_DISCONNECT:
     3335                ASSERT_GUEST_LOGREL_RETURN(cbCmd == sizeof(VBOXCMDVBVA_3DCTL), VERR_INVALID_PARAMETER);
     3336                {
     3337                    uint32_t idClient = pCtl->u32CmdClientId;
     3338                    RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
     3339                    return crVBoxCrDisconnect(idClient);
     3340                }
     3341
     3342            default:
     3343                AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE);
     3344        }
    33373345    }
    33383346}
    … …  
    35123520
    35133521
    3514 static DECLCALLBACK(int8_t) crVBoxCrCmdCmd(HVBOXCRCMDSVR hSvr, const VBOXCMDVBVA_HDR *pCmd, uint32_t cbCmd)
    3515 {
    3516     switch (pCmd->u8OpCode)
     3522/**
     3523 * @interface_method_impl{VBOXCRCMD_SVRINFO,pfnCmd}
     3524 */
     3525static DECLCALLBACK(int8_t) crVBoxCrCmdCmd(HVBOXCRCMDSVR hSvr,
     3526                                           const VBOXCMDVBVA_HDR RT_UNTRUSTED_VOLATILE_GUEST *pCmd, uint32_t cbCmd)
     3527{
     3528    uint8_t bOpcode = pCmd->u8OpCode;
     3529    RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
     3530    ASSERT_GUEST_LOGREL_MSG_RETURN(   bOpcode == VBOXCMDVBVA_OPTYPE_CRCMD
     3531                                   || bOpcode == VBOXCMDVBVA_OPTYPE_FLIP
     3532                                   || bOpcode == VBOXCMDVBVA_OPTYPE_BLT
     3533                                   || bOpcode == VBOXCMDVBVA_OPTYPE_CLRFILL,
     3534                                   ("%#x\n", bOpcode), -1);
     3535    RT_UNTRUSTED_VALIDATED_FENCE();
     3536
     3537    switch (bOpcode)
    35173538    {
    35183539        case VBOXCMDVBVA_OPTYPE_CRCMD:
    3519         {
    3520             const VBOXCMDVBVA_CRCMD *pCrCmdDr;
    3521             const VBOXCMDVBVA_CRCMD_CMD *pCrCmd;
    3522             int rc;
    3523             pCrCmdDr = (const VBOXCMDVBVA_CRCMD*)pCmd;
    3524             pCrCmd = &pCrCmdDr->Cmd;
    3525             if (cbCmd < sizeof (VBOXCMDVBVA_CRCMD))
     3540            ASSERT_GUEST_LOGREL_MSG_RETURN(cbCmd >= sizeof(VBOXCMDVBVA_CRCMD), ("cbCmd=%u\n", cbCmd), -1);
    35263541            {
    3527                 WARN(("invalid buffer size"));
    3528                 return -1;
    3529             }
    3530             rc = crVBoxServerCmdVbvaCrCmdProcess(pCrCmd, cbCmd - RT_OFFSETOF(VBOXCMDVBVA_CRCMD, Cmd));
    3531             if (RT_SUCCESS(rc))
    3532             {
    3533                 /* success */
     3542                VBOXCMDVBVA_CRCMD const RT_UNTRUSTED_VOLATILE_GUEST *pCrCmdDr
     3543                    = (VBOXCMDVBVA_CRCMD const RT_UNTRUSTED_VOLATILE_GUEST *)pCmd;
     3544                VBOXCMDVBVA_CRCMD_CMD const RT_UNTRUSTED_VOLATILE_GUEST *pCrCmd = &pCrCmdDr->Cmd;
     3545                int rc = crVBoxServerCmdVbvaCrCmdProcess(pCrCmd, cbCmd - RT_OFFSETOF(VBOXCMDVBVA_CRCMD, Cmd));
     3546                ASSERT_GUEST_LOGREL_RC_RETURN(rc, -1);
    35343547                return 0;
    35353548            }
    35363549
    3537             WARN(("crVBoxServerCmdVbvaCrCmdProcess failed, rc %d", rc));
    3538             return -1;
    3539         }
    35403550        case VBOXCMDVBVA_OPTYPE_FLIP:
    3541         {
    3542             const VBOXCMDVBVA_FLIP *pFlip;
    3543 
    3544             if (cbCmd < VBOXCMDVBVA_SIZEOF_FLIPSTRUCT_MIN)
     3551            ASSERT_GUEST_LOGREL_MSG_RETURN(cbCmd >= VBOXCMDVBVA_SIZEOF_FLIPSTRUCT_MIN, ("cbCmd=%u\n", cbCmd), -1);
    35453552            {
    3546                 WARN(("invalid buffer size (cbCmd(%u) < sizeof(VBOXCMDVBVA_FLIP)(%u))", cbCmd, sizeof(VBOXCMDVBVA_FLIP)));
    3547                 return -1;
     3553                VBOXCMDVBVA_FLIP const RT_UNTRUSTED_VOLATILE_GUEST *pFlip
     3554                    = (VBOXCMDVBVA_FLIP const RT_UNTRUSTED_VOLATILE_GUEST *)pCmd;
     3555                return crVBoxServerCrCmdFlipProcess(pFlip, cbCmd);
    35483556            }
    35493557
    3550             pFlip = (const VBOXCMDVBVA_FLIP*)pCmd;
    3551             return crVBoxServerCrCmdFlipProcess(pFlip, cbCmd);
    3552         }
    35533558        case VBOXCMDVBVA_OPTYPE_BLT:
    3554         {
    3555             if (cbCmd < sizeof (VBOXCMDVBVA_BLT_HDR))
    3556             {
    3557                 WARN(("invalid buffer size"));
    3558                 return -1;
    3559             }
    3560 
    3561             return crVBoxServerCrCmdBltProcess((const VBOXCMDVBVA_BLT_HDR*)pCmd, cbCmd);
    3562         }
     3559            ASSERT_GUEST_LOGREL_MSG_RETURN(cbCmd >= sizeof(VBOXCMDVBVA_BLT_HDR), ("cbCmd=%u\n", cbCmd), -1);
     3560            return crVBoxServerCrCmdBltProcess((VBOXCMDVBVA_BLT_HDR const RT_UNTRUSTED_VOLATILE_GUEST *)pCmd, cbCmd);
     3561
    35633562        case VBOXCMDVBVA_OPTYPE_CLRFILL:
    3564         {
    3565             if (cbCmd < sizeof (VBOXCMDVBVA_CLRFILL_HDR))
    3566             {
    3567                 WARN(("invalid buffer size"));
    3568                 return -1;
    3569             }
    3570 
    3571             return crVBoxServerCrCmdClrFillProcess((const VBOXCMDVBVA_CLRFILL_HDR*)pCmd, cbCmd);
    3572         }
     3563            ASSERT_GUEST_LOGREL_MSG_RETURN(cbCmd >= sizeof(VBOXCMDVBVA_CLRFILL_HDR), ("cbCmd=%u\n", cbCmd), -1);
     3564            return crVBoxServerCrCmdClrFillProcess((VBOXCMDVBVA_CLRFILL_HDR const RT_UNTRUSTED_VOLATILE_GUEST *)pCmd, cbCmd);
     3565
    35733566        default:
    3574             WARN(("unsupported command"));
    3575             return -1;
     3567            AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE);
    35763568    }
    35773569    /* not reached */
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