VirtualBox

Changeset 58181 in vbox for trunk/src/VBox/Additions


Ignore:
Timestamp:
Oct 12, 2015 12:54:23 PM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
103295
Message:

VBoxGuestLib: Removed misunderstood common/VBoxGuestLib/VBoxGuestR0LibCrOgl.h moving the function prototypes into VBoxGuestLib.h where they belong, after correcting the prefix. Did some more positive thinking excercises.

Location:
trunk/src/VBox/Additions
Files:
1 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk

    r56301 r58181  
    9797        .. \
    9898        . \
    99         ../../../../common/VBoxGuestLib \
    10099        $(VBOX_PATH_CROGL_INCLUDE) \
    101100        $(VBOX_PATH_CROGL_GENFILES) \

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCr.cpp

    r51330 r58181  
    751751        return VINF_ALREADY_INITIALIZED;
    752752
    753     int rc = vboxCrCtlCreate(&pCrCtlCon->hCrCtl);
     753    int rc = VbglR0CrCtlCreate(&pCrCtlCon->hCrCtl);
    754754    if (RT_SUCCESS(rc))
    755755    {
    … …  
    772772    }
    773773
    774     int rc = vboxCrCtlDestroy(pCrCtlCon->hCrCtl);
     774    int rc = VbglR0CrCtlDestroy(pCrCtlCon->hCrCtl);
    775775    if (RT_SUCCESS(rc))
    776776    {
    … …  
    800800    parms.vMinor.u.value32 = vMinor;
    801801
    802     rc = vboxCrCtlConCall(pCrCtlCon->hCrCtl, &parms.hdr, sizeof (parms));
     802    rc = VbglR0CrCtlConCall(pCrCtlCon->hCrCtl, &parms.hdr, sizeof (parms));
    803803    if (RT_FAILURE(rc))
    804804    {
    … …  
    830830    *pu32Caps = 0;
    831831
    832     rc = vboxCrCtlConCall(pCrCtlCon->hCrCtl, &parms.hdr, sizeof (parms));
     832    rc = VbglR0CrCtlConCall(pCrCtlCon->hCrCtl, &parms.hdr, sizeof (parms));
    833833    if (RT_FAILURE(rc))
    834834    {
    … …  
    869869    parms.Caps.u.Pointer.size = sizeof (*pCapsInfo);
    870870
    871     rc = vboxCrCtlConCall(pCrCtlCon->hCrCtl, &parms.hdr, sizeof (parms));
     871    rc = VbglR0CrCtlConCall(pCrCtlCon->hCrCtl, &parms.hdr, sizeof (parms));
    872872    if (RT_FAILURE(rc))
    873873    {
    … …  
    908908    Assert(parms.u64PID.u.value64);
    909909
    910     rc = vboxCrCtlConCall(pCrCtlCon->hCrCtl, &parms.hdr, sizeof (parms));
     910    rc = VbglR0CrCtlConCall(pCrCtlCon->hCrCtl, &parms.hdr, sizeof (parms));
    911911    if (RT_FAILURE(rc))
    912912    {
    … …  
    931931    if (RT_SUCCESS(rc))
    932932    {
    933         rc = vboxCrCtlConConnect(pCrCtlCon->hCrCtl, &u32ClientID);
     933        rc = VbglR0CrCtlConConnect(pCrCtlCon->hCrCtl, &u32ClientID);
    934934        if (RT_SUCCESS(rc))
    935935        {
    … …  
    952952                WARN(("vboxMpCrCtlConSetVersion failed, rc (%d)", rc));
    953953            }
    954             vboxCrCtlConDisconnect(pCrCtlCon->hCrCtl, u32ClientID);
     954            VbglR0CrCtlConDisconnect(pCrCtlCon->hCrCtl, u32ClientID);
    955955        }
    956956        else
    … …  
    10031003int VBoxMpCrCtlConDisconnectHgcm(PVBOXMP_CRCTLCON pCrCtlCon, uint32_t u32ClientID)
    10041004{
    1005     int rc = vboxCrCtlConDisconnect(pCrCtlCon->hCrCtl, u32ClientID);
     1005    int rc = VbglR0CrCtlConDisconnect(pCrCtlCon->hCrCtl, u32ClientID);
    10061006    if (RT_SUCCESS(rc))
    10071007    {
    … …  
    10091009        return VINF_SUCCESS;
    10101010    }
    1011     else
    1012     {
    1013         WARN(("vboxCrCtlConDisconnect failed, rc (%d)", rc));
    1014     }
     1011    WARN(("vboxCrCtlConDisconnect failed, rc (%d)", rc));
    10151012    return rc;
    10161013}
    … …  
    10321029int VBoxMpCrCtlConCall(PVBOXMP_CRCTLCON pCrCtlCon, VBoxGuestHGCMCallInfo *pData, uint32_t cbData)
    10331030{
    1034     int rc = vboxCrCtlConCall(pCrCtlCon->hCrCtl, pData, cbData);
     1031    int rc = VbglR0CrCtlConCall(pCrCtlCon->hCrCtl, pData, cbData);
    10351032    if (RT_SUCCESS(rc))
    10361033        return VINF_SUCCESS;
    … …  
    10421039int VBoxMpCrCtlConCallUserData(PVBOXMP_CRCTLCON pCrCtlCon, VBoxGuestHGCMCallInfo *pData, uint32_t cbData)
    10431040{
    1044     int rc = vboxCrCtlConCallUserData(pCrCtlCon->hCrCtl, pData, cbData);
     1041    int rc = VbglR0CrCtlConCallUserData(pCrCtlCon->hCrCtl, pData, cbData);
    10451042    if (RT_SUCCESS(rc))
    10461043        return VINF_SUCCESS;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCr.h

    r50940 r58181  
    11/* $Id$ */
    2 
    32/** @file
    43 * VBox WDDM Miniport driver
    … …  
    2120#ifdef VBOX_WITH_CROGL
    2221
    23 #include <VBox/VBoxGuestLib.h>
    24 #include <VBoxGuestR0LibCrOgl.h>
     22# include <VBox/VBoxGuestLib.h>
    2523
    2624typedef struct VBOXMP_CRCTLCON
    … …  
    221219
    222220#endif /* #ifndef ___VBoxMPCr_h__ */
     221

  • trunk/src/VBox/Additions/common/VBoxGuestLib/HGCM.cpp

    r56294 r58181  
    3737#include <iprt/string.h>
    3838
    39 #define VBGL_HGCM_ASSERTMsg AssertReleaseMsg
     39#define VBGL_HGCM_ASSERT_MSG AssertReleaseMsg
    4040
    4141/**
    … …  
    4444 * @return VBox status code.
    4545 */
    46 int vbglR0HGCMInit (void)
     46int vbglR0HGCMInit(void)
    4747{
    4848    return RTSemFastMutexCreate(&g_vbgldata.mutexHGCMHandle);
    … …  
    5454 * @return VBox status code.
    5555 */
    56 int vbglR0HGCMTerminate (void)
     56int vbglR0HGCMTerminate(void)
    5757{
    5858    RTSemFastMutexDestroy(g_vbgldata.mutexHGCMHandle);
    … …  
    6262}
    6363
    64 DECLINLINE(int) vbglHandleHeapEnter (void)
     64DECLINLINE(int) vbglHandleHeapEnter(void)
    6565{
    6666    int rc = RTSemFastMutexRequest(g_vbgldata.mutexHGCMHandle);
    6767
    68     VBGL_HGCM_ASSERTMsg(RT_SUCCESS(rc),
    69                         ("Failed to request handle heap mutex, rc = %Rrc\n", rc));
     68    VBGL_HGCM_ASSERT_MSG(RT_SUCCESS(rc), ("Failed to request handle heap mutex, rc = %Rrc\n", rc));
    7069
    7170    return rc;
    7271}
    7372
    74 DECLINLINE(void) vbglHandleHeapLeave (void)
     73DECLINLINE(void) vbglHandleHeapLeave(void)
    7574{
    7675    RTSemFastMutexRelease(g_vbgldata.mutexHGCMHandle);
    7776}
    7877
    79 struct VBGLHGCMHANDLEDATA *vbglHGCMHandleAlloc (void)
     78struct VBGLHGCMHANDLEDATA *vbglHGCMHandleAlloc(void)
    8079{
    81     struct VBGLHGCMHANDLEDATA *p;
    82     int rc = vbglHandleHeapEnter ();
    83     uint32_t i;
     80    struct VBGLHGCMHANDLEDATA *p = NULL;
     81    int rc = vbglHandleHeapEnter();
     82    if (RT_SUCCESS(rc))
     83    {
     84        uint32_t i;
    8485
    85     if (RT_FAILURE (rc))
    86         return NULL;
     86        /* Simple linear search in array. This will be called not so often, only connect/disconnect. */
     87        /** @todo bitmap for faster search and other obvious optimizations. */
     88        for (i = 0; i < RT_ELEMENTS(g_vbgldata.aHGCMHandleData); i++)
     89        {
     90            if (!g_vbgldata.aHGCMHandleData[i].fAllocated)
     91            {
     92                p = &g_vbgldata.aHGCMHandleData[i];
     93                p->fAllocated = 1;
     94                break;
     95            }
     96        }
    8797
    88     p = NULL;
     98        vbglHandleHeapLeave();
    8999
    90     /** Simple linear search in array. This will be called not so often, only connect/disconnect.
    91      * @todo bitmap for faster search and other obvious optimizations.
    92      */
    93 
    94     for (i = 0; i < RT_ELEMENTS(g_vbgldata.aHGCMHandleData); i++)
    95     {
    96         if (!g_vbgldata.aHGCMHandleData[i].fAllocated)
    97         {
    98             p = &g_vbgldata.aHGCMHandleData[i];
    99             p->fAllocated = 1;
    100             break;
    101         }
     100        VBGL_HGCM_ASSERT_MSG(p != NULL, ("Not enough HGCM handles.\n"));
    102101    }
    103 
    104     vbglHandleHeapLeave ();
    105 
    106     VBGL_HGCM_ASSERTMsg(p != NULL,
    107                         ("Not enough HGCM handles.\n"));
    108 
    109102    return p;
    110103}
    111104
    112 void vbglHGCMHandleFree (struct VBGLHGCMHANDLEDATA *pHandle)
     105void vbglHGCMHandleFree(struct VBGLHGCMHANDLEDATA *pHandle)
     106{
     107    if (pHandle)
     108    {
     109        int rc = vbglHandleHeapEnter();
     110        if (RT_SUCCESS(rc))
     111        {
     112            VBGL_HGCM_ASSERT_MSG(pHandle->fAllocated, ("Freeing not allocated handle.\n"));
     113
     114            RT_ZERO(*pHandle);
     115            vbglHandleHeapLeave();
     116        }
     117    }
     118}
     119
     120DECLVBGL(int) VbglHGCMConnect(VBGLHGCMHANDLE *pHandle, VBoxGuestHGCMConnectInfo *pData)
    113121{
    114122    int rc;
     123    if (pHandle && pData)
     124    {
     125        struct VBGLHGCMHANDLEDATA *pHandleData = vbglHGCMHandleAlloc();
     126        if (pHandleData)
     127        {
     128            rc = vbglDriverOpen(&pHandleData->driver);
     129            if (RT_SUCCESS(rc))
     130            {
     131                rc = vbglDriverIOCtl(&pHandleData->driver, VBOXGUEST_IOCTL_HGCM_CONNECT, pData, sizeof(*pData));
     132                if (RT_SUCCESS(rc))
     133                    rc = pData->result;
     134                if (RT_SUCCESS(rc))
     135                {
     136                    *pHandle = pHandleData;
     137                    return rc;
     138                }
    115139
    116     if (!pHandle)
    117        return;
     140                vbglDriverClose(&pHandleData->driver);
     141            }
    118142
    119     rc = vbglHandleHeapEnter ();
    120 
    121     if (RT_FAILURE (rc))
    122         return;
    123 
    124     VBGL_HGCM_ASSERTMsg(pHandle->fAllocated,
    125                         ("Freeing not allocated handle.\n"));
    126 
    127     memset(pHandle, 0, sizeof (struct VBGLHGCMHANDLEDATA));
    128     vbglHandleHeapLeave ();
    129     return;
     143            vbglHGCMHandleFree(pHandleData);
     144        }
     145        else
     146            rc = VERR_NO_MEMORY;
     147    }
     148    else
     149        rc = VERR_INVALID_PARAMETER;
     150    return rc;
    130151}
    131152
    132 DECLVBGL(int) VbglHGCMConnect (VBGLHGCMHANDLE *pHandle, VBoxGuestHGCMConnectInfo *pData)
     153DECLVBGL(int) VbglHGCMDisconnect(VBGLHGCMHANDLE handle, VBoxGuestHGCMDisconnectInfo *pData)
    133154{
    134     int rc;
    135     struct VBGLHGCMHANDLEDATA *pHandleData;
     155    int rc = vbglDriverIOCtl(&handle->driver, VBOXGUEST_IOCTL_HGCM_DISCONNECT, pData, sizeof(*pData));
    136156
    137     if (!pHandle || !pData)
    138         return VERR_INVALID_PARAMETER;
     157    vbglDriverClose(&handle->driver);
    139158
    140     pHandleData = vbglHGCMHandleAlloc();
    141     if (!pHandleData)
    142         rc = VERR_NO_MEMORY;
    143     else
    144     {
    145         rc = vbglDriverOpen (&pHandleData->driver);
    146         if (RT_SUCCESS(rc))
    147         {
    148             rc = vbglDriverIOCtl (&pHandleData->driver, VBOXGUEST_IOCTL_HGCM_CONNECT, pData, sizeof (*pData));
    149             if (RT_SUCCESS(rc))
    150                 rc = pData->result;
    151             if (RT_SUCCESS(rc))
    152             {
    153                 *pHandle = pHandleData;
    154                 return rc;
    155             }
    156 
    157             vbglDriverClose (&pHandleData->driver);
    158         }
    159 
    160         vbglHGCMHandleFree (pHandleData);
    161     }
     159    vbglHGCMHandleFree(handle);
    162160
    163161    return rc;
    164162}
    165163
    166 DECLVBGL(int) VbglHGCMDisconnect (VBGLHGCMHANDLE handle, VBoxGuestHGCMDisconnectInfo *pData)
     164DECLVBGL(int) VbglHGCMCall(VBGLHGCMHANDLE handle, VBoxGuestHGCMCallInfo *pData, uint32_t cbData)
    167165{
    168     int rc = VINF_SUCCESS;
     166    VBGL_HGCM_ASSERT_MSG(cbData >= sizeof(VBoxGuestHGCMCallInfo) + pData->cParms * sizeof(HGCMFunctionParameter),
     167                         ("cbData = %d, cParms = %d (calculated size %d)\n", cbData, pData->cParms,
     168                          sizeof(VBoxGuestHGCMCallInfo) + pData->cParms * sizeof(VBoxGuestHGCMCallInfo)));
    169169
    170     rc = vbglDriverIOCtl (&handle->driver, VBOXGUEST_IOCTL_HGCM_DISCONNECT, pData, sizeof (*pData));
    171 
    172     vbglDriverClose (&handle->driver);
    173 
    174     vbglHGCMHandleFree (handle);
    175 
    176     return rc;
    177 }
    178 
    179 DECLVBGL(int) VbglHGCMCall (VBGLHGCMHANDLE handle, VBoxGuestHGCMCallInfo *pData, uint32_t cbData)
    180 {
    181     int rc = VINF_SUCCESS;
    182 
    183     VBGL_HGCM_ASSERTMsg(cbData >= sizeof (VBoxGuestHGCMCallInfo) + pData->cParms * sizeof (HGCMFunctionParameter),
    184                         ("cbData = %d, cParms = %d (calculated size %d)\n", cbData, pData->cParms, sizeof (VBoxGuestHGCMCallInfo) + pData->cParms * sizeof (VBoxGuestHGCMCallInfo)));
    185 
    186     rc = vbglDriverIOCtl (&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL(cbData), pData, cbData);
    187 
    188     return rc;
     170    return vbglDriverIOCtl(&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL(cbData), pData, cbData);
    189171}
    190172
    191173DECLVBGL(int) VbglHGCMCallUserData (VBGLHGCMHANDLE handle, VBoxGuestHGCMCallInfo *pData, uint32_t cbData)
    192174{
    193     int rc = VINF_SUCCESS;
     175    VBGL_HGCM_ASSERT_MSG(cbData >= sizeof(VBoxGuestHGCMCallInfo) + pData->cParms * sizeof(HGCMFunctionParameter),
     176                         ("cbData = %d, cParms = %d (calculated size %d)\n", cbData, pData->cParms,
     177                          sizeof(VBoxGuestHGCMCallInfo) + pData->cParms * sizeof(VBoxGuestHGCMCallInfo)));
    194178
    195     VBGL_HGCM_ASSERTMsg(cbData >= sizeof (VBoxGuestHGCMCallInfo) + pData->cParms * sizeof (HGCMFunctionParameter),
    196                         ("cbData = %d, cParms = %d (calculated size %d)\n", cbData, pData->cParms, sizeof (VBoxGuestHGCMCallInfo) + pData->cParms * sizeof (VBoxGuestHGCMCallInfo)));
    197 
    198     rc = vbglDriverIOCtl (&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL_USERDATA(cbData), pData, cbData);
    199 
    200     return rc;
     179    return vbglDriverIOCtl(&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL_USERDATA(cbData), pData, cbData);
    201180}
    202181
    203182
    204 DECLVBGL(int) VbglHGCMCallTimed (VBGLHGCMHANDLE handle,
    205                                  VBoxGuestHGCMCallInfoTimed *pData, uint32_t cbData)
     183DECLVBGL(int) VbglHGCMCallTimed(VBGLHGCMHANDLE handle, VBoxGuestHGCMCallInfoTimed *pData, uint32_t cbData)
    206184{
    207     int rc = VINF_SUCCESS;
     185    uint32_t cbExpected = sizeof(VBoxGuestHGCMCallInfoTimed)
     186                        + pData->info.cParms * sizeof(HGCMFunctionParameter);
     187    VBGL_HGCM_ASSERT_MSG(cbData >= cbExpected,
     188                         ("cbData = %d, cParms = %d (calculated size %d)\n", cbData, pData->info.cParms, cbExpected));
     189    NOREF(cbExpected);
    208190
    209     uint32_t cbExpected =   sizeof (VBoxGuestHGCMCallInfoTimed)
    210                           + pData->info.cParms * sizeof (HGCMFunctionParameter);
    211     VBGL_HGCM_ASSERTMsg(cbData >= cbExpected,
    212                         ("cbData = %d, cParms = %d (calculated size %d)\n",
    213                         cbData, pData->info.cParms, cbExpected));
    214 
    215     rc = vbglDriverIOCtl (&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL_TIMED(cbData),
    216                           pData, cbData);
    217 
    218     return rc;
     191    return vbglDriverIOCtl(&handle->driver, VBOXGUEST_IOCTL_HGCM_CALL_TIMED(cbData), pData, cbData);
    219192}
    220193

  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBGLInternal.h

    r58178 r58181  
    155155#ifdef VBOX_WITH_HGCM
    156156# ifndef VBGL_VBOXGUEST
    157 int vbglR0HGCMInit (void);
    158 int vbglR0HGCMTerminate (void);
     157int                         vbglR0HGCMInit(void);
     158int                         vbglR0HGCMTerminate(void);
    159159# endif
     160struct VBGLHGCMHANDLEDATA  *vbglHGCMHandleAlloc(void);
     161void                        vbglHGCMHandleFree(struct VBGLHGCMHANDLEDATA *pHandle);
    160162#endif /* VBOX_WITH_HGCM */
    161163

  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR0LibCrOgl.cpp

    r56294 r58181  
    11/* $Id$ */
    22/** @file
    3  * VBoxGuestLib - Central calls header.
     3 * VBoxGuestLib - Ring-3 Support Library for VirtualBox guest additions, Chromium OpenGL Service.
    44 */
    55
    … …  
    2929# error "VBGL_VBOXGUEST should not be defined"
    3030#else
    31 #include "VBoxGuestR0LibCrOgl.h"
    3231
    3332#include <iprt/string.h>
    … …  
    3534#include "VBGLInternal.h"
    3635
    37 struct VBGLHGCMHANDLEDATA *vbglHGCMHandleAlloc (void);
    38 void vbglHGCMHandleFree (struct VBGLHGCMHANDLEDATA *pHandle);
    3936
    40 DECLVBGL(int) vboxCrCtlCreate(HVBOXCRCTL *phCtl)
     37DECLVBGL(int) VbglR0CrCtlCreate(HVBOXCRCTL *phCtl)
    4138{
    4239    int rc;
    43     struct VBGLHGCMHANDLEDATA *pHandleData;
    4440
    45     if (!phCtl)
    46         return VERR_INVALID_PARAMETER;
     41    if (phCtl)
     42    {
     43        struct VBGLHGCMHANDLEDATA *pHandleData = vbglHGCMHandleAlloc();
    4744
    48     pHandleData = vbglHGCMHandleAlloc ();
     45        if (pHandleData)
     46        {
     47            rc = vbglDriverOpen(&pHandleData->driver);
    4948
    50     rc = VINF_SUCCESS;
     49            if (RT_SUCCESS(rc))
     50            {
     51                *phCtl = pHandleData;
     52                return VINF_SUCCESS;
     53            }
    5154
    52     if (!pHandleData)
    53     {
    54         rc = VERR_NO_MEMORY;
     55            vbglHGCMHandleFree(pHandleData);
     56        }
     57        else
     58            rc = VERR_NO_MEMORY;
     59
     60        *phCtl = NULL;
    5561    }
    5662    else
    57     {
    58         rc = vbglDriverOpen (&pHandleData->driver);
     63        rc = VERR_INVALID_PARAMETER;
    5964
    60         if (RT_SUCCESS(rc))
    61         {
    62             *phCtl = pHandleData;
    63             return VINF_SUCCESS;
    64         }
    65 
    66         vbglHGCMHandleFree (pHandleData);
    67     }
    68 
    69     *phCtl = NULL;
    7065    return rc;
    7166}
    7267
    73 DECLVBGL(int) vboxCrCtlDestroy(HVBOXCRCTL hCtl)
     68DECLVBGL(int) VbglR0CrCtlDestroy(HVBOXCRCTL hCtl)
    7469{
    7570    vbglDriverClose(&hCtl->driver);
    … …  
    8075}
    8176
    82 DECLVBGL(int) vboxCrCtlConConnect(HVBOXCRCTL hCtl, uint32_t *pu32ClientID)
     77DECLVBGL(int) VbglR0CrCtlConConnect(HVBOXCRCTL hCtl, uint32_t *pu32ClientID)
    8378{
    8479    VBoxGuestHGCMConnectInfo info;
    … …  
    8883        return VERR_INVALID_PARAMETER;
    8984
    90     memset(&info, 0, sizeof (info));
     85    RT_ZERO(info);
    9186    info.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
    92     RTStrCopy(info.Loc.u.host.achName, sizeof (info.Loc.u.host.achName), "VBoxSharedCrOpenGL");
    93     rc = vbglDriverIOCtl (&hCtl->driver, VBOXGUEST_IOCTL_HGCM_CONNECT, &info, sizeof (info));
     87    RTStrCopy(info.Loc.u.host.achName, sizeof(info.Loc.u.host.achName), "VBoxSharedCrOpenGL");
     88    rc = vbglDriverIOCtl(&hCtl->driver, VBOXGUEST_IOCTL_HGCM_CONNECT, &info, sizeof(info));
    9489    if (RT_SUCCESS(rc))
    9590    {
    … …  
    10398    }
    10499
    105     Assert(RT_FAILURE(rc));
     100    AssertRC(rc);
    106101    *pu32ClientID = 0;
    107102    return rc;
    108103}
    109104
    110 DECLVBGL(int) vboxCrCtlConDisconnect(HVBOXCRCTL hCtl, uint32_t u32ClientID)
     105DECLVBGL(int) VbglR0CrCtlConDisconnect(HVBOXCRCTL hCtl, uint32_t u32ClientID)
    111106{
    112107    VBoxGuestHGCMDisconnectInfo info;
    113     memset (&info, 0, sizeof (info));
     108    RT_ZERO(info);
    114109    info.u32ClientID = u32ClientID;
    115     return vbglDriverIOCtl (&hCtl->driver, VBOXGUEST_IOCTL_HGCM_DISCONNECT, &info, sizeof (info));
     110    return vbglDriverIOCtl(&hCtl->driver, VBOXGUEST_IOCTL_HGCM_DISCONNECT, &info, sizeof(info));
    116111}
    117112
    118 DECLVBGL(int) vboxCrCtlConCall(HVBOXCRCTL hCtl, struct VBoxGuestHGCMCallInfo *pCallInfo, int cbCallInfo)
     113DECLVBGL(int) VbglR0CrCtlConCall(HVBOXCRCTL hCtl, struct VBoxGuestHGCMCallInfo *pCallInfo, int cbCallInfo)
    119114{
    120     return vbglDriverIOCtl (&hCtl->driver, VBOXGUEST_IOCTL_HGCM_CALL(cbCallInfo), pCallInfo, cbCallInfo);
     115    return vbglDriverIOCtl(&hCtl->driver, VBOXGUEST_IOCTL_HGCM_CALL(cbCallInfo), pCallInfo, cbCallInfo);
    121116}
    122117
    123 DECLVBGL(int) vboxCrCtlConCallUserData(HVBOXCRCTL hCtl, struct VBoxGuestHGCMCallInfo *pCallInfo, int cbCallInfo)
     118DECLVBGL(int) VbglR0CrCtlConCallUserData(HVBOXCRCTL hCtl, struct VBoxGuestHGCMCallInfo *pCallInfo, int cbCallInfo)
    124119{
    125     return vbglDriverIOCtl (&hCtl->driver, VBOXGUEST_IOCTL_HGCM_CALL_USERDATA(cbCallInfo), pCallInfo, cbCallInfo);
     120    return vbglDriverIOCtl(&hCtl->driver, VBOXGUEST_IOCTL_HGCM_CALL_USERDATA(cbCallInfo), pCallInfo, cbCallInfo);
    126121}
    127122
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