VirtualBox

Ignore:
Timestamp:
Apr 16, 2014 5:57:25 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
93367
Message:

6813 src-client/MachineDebuggerImpl.cpp + various formatting changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/src-client/HGCM.cpp

    r48229 r51092  
    9090
    9191        HGCMTHREADHANDLE m_thread;
    92         friend DECLCALLBACK(void) hgcmServiceThread (HGCMTHREADHANDLE ThreadHandle, void *pvUser);
     92        friend DECLCALLBACK(void) hgcmServiceThread(HGCMTHREADHANDLE ThreadHandle, void *pvUser);
    9393
    9494        uint32_t volatile m_u32RefCnt;
    … …  
    116116        HGCMSVCEXTHANDLE m_hExtension;
    117117
    118         int loadServiceDLL (void);
    119         void unloadServiceDLL (void);
     118        int loadServiceDLL(void);
     119        void unloadServiceDLL(void);
    120120
    121121        /*
    122122         * Main HGCM thread methods.
    123123         */
    124         int instanceCreate (const char *pszServiceLibrary, const char *pszServiceName);
    125         void instanceDestroy (void);
     124        int instanceCreate(const char *pszServiceLibrary, const char *pszServiceName);
     125        void instanceDestroy(void);
    126126
    127127        int saveClientState(uint32_t u32ClientId, PSSMHANDLE pSSM);
    128128        int loadClientState(uint32_t u32ClientId, PSSMHANDLE pSSM);
    129129
    130         HGCMService ();
    131         ~HGCMService () {};
    132 
    133         static DECLCALLBACK(void) svcHlpCallComplete (VBOXHGCMCALLHANDLE callHandle, int32_t rc);
    134         static DECLCALLBACK(void) svcHlpDisconnectClient (void *pvInstance, uint32_t u32ClientId);
     130        HGCMService();
     131        ~HGCMService() {};
     132
     133        static DECLCALLBACK(void) svcHlpCallComplete(VBOXHGCMCALLHANDLE callHandle, int32_t rc);
     134        static DECLCALLBACK(void) svcHlpDisconnectClient(void *pvInstance, uint32_t u32ClientId);
    135135
    136136    public:
    … …  
    139139         * Main HGCM thread methods.
    140140         */
    141         static int LoadService (const char *pszServiceLibrary, const char *pszServiceName);
    142         void UnloadService (void);
    143 
    144         static void UnloadAll (void);
    145 
    146         static int ResolveService (HGCMService **ppsvc, const char *pszServiceName);
    147         void ReferenceService (void);
    148         void ReleaseService (void);
    149 
    150         static void Reset (void);
    151 
    152         static int SaveState (PSSMHANDLE pSSM);
    153         static int LoadState (PSSMHANDLE pSSM);
    154 
    155         int CreateAndConnectClient (uint32_t *pu32ClientIdOut, uint32_t u32ClientIdIn);
    156         int DisconnectClient (uint32_t u32ClientId, bool fFromService);
    157 
    158         int HostCall (uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM *paParms);
     141        static int LoadService(const char *pszServiceLibrary, const char *pszServiceName);
     142        void UnloadService(void);
     143
     144        static void UnloadAll(void);
     145
     146        static int ResolveService(HGCMService **ppsvc, const char *pszServiceName);
     147        void ReferenceService(void);
     148        void ReleaseService(void);
     149
     150        static void Reset(void);
     151
     152        static int SaveState(PSSMHANDLE pSSM);
     153        static int LoadState(PSSMHANDLE pSSM);
     154
     155        int CreateAndConnectClient(uint32_t *pu32ClientIdOut, uint32_t u32ClientIdIn);
     156        int DisconnectClient(uint32_t u32ClientId, bool fFromService);
     157
     158        int HostCall(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM *paParms);
    159159
    160160#ifdef VBOX_WITH_CRHGSMI
    161161        int HandleAcquired();
    162162        int HandleReleased();
    163         int HostFastCallAsync (uint32_t u32Function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion, void *pvCompletion);
     163        int HostFastCallAsync(uint32_t u32Function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion,
     164                              void *pvCompletion);
    164165#endif
    165166
    166         uint32_t SizeOfClient (void) { return m_fntable.cbClient; };
    167 
    168         int RegisterExtension (HGCMSVCEXTHANDLE handle, PFNHGCMSVCEXT pfnExtension, void *pvExtension);
    169         void UnregisterExtension (HGCMSVCEXTHANDLE handle);
     167        uint32_t SizeOfClient(void) { return m_fntable.cbClient; };
     168
     169        int RegisterExtension(HGCMSVCEXTHANDLE handle, PFNHGCMSVCEXT pfnExtension, void *pvExtension);
     170        void UnregisterExtension(HGCMSVCEXTHANDLE handle);
    170171
    171172        /*
    … …  
    173174         */
    174175
    175         int GuestCall (PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmd, uint32_t u32ClientId, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM aParms[]);
     176        int GuestCall(PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmd, uint32_t u32ClientId,
     177                      uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM aParms[]);
    176178};
    177179
    … …  
    180182{
    181183    public:
    182         HGCMClient () : HGCMObject(HGCMOBJ_CLIENT), pService(NULL),
     184        HGCMClient() : HGCMObject(HGCMOBJ_CLIENT), pService(NULL),
    183185                        pvData(NULL) {};
    184         ~HGCMClient ();
    185 
    186         int Init (HGCMService *pSvc);
     186        ~HGCMClient();
     187
     188        int Init(HGCMService *pSvc);
    187189
    188190        /** Service that the client is connected to. */
    … …  
    193195};
    194196
    195 HGCMClient::~HGCMClient ()
    196 {
    197     if (pService->SizeOfClient () > 0)
    198         RTMemFree (pvData);
    199 }
    200 
    201 int HGCMClient::Init (HGCMService *pSvc)
     197HGCMClient::~HGCMClient()
     198{
     199    if (pService->SizeOfClient() > 0)
     200        RTMemFree(pvData);
     201}
     202
     203int HGCMClient::Init(HGCMService *pSvc)
    202204{
    203205    pService = pSvc;
    204206
    205     if (pService->SizeOfClient () > 0)
    206     {
    207         pvData = RTMemAllocZ (pService->SizeOfClient ());
     207    if (pService->SizeOfClient() > 0)
     208    {
     209        pvData = RTMemAllocZ(pService->SizeOfClient());
    208210
    209211        if (!pvData)
    … …  
    217219
    218220
    219 #define HGCM_CLIENT_DATA(pService, pClient) (pClient->pvData)
     221#define HGCM_CLIENT_DATA(pService, pClient)(pClient->pvData)
    220222
    221223
    … …  
    225227int HGCMService::sm_cServices = 0;
    226228
    227 HGCMService::HGCMService ()
     229HGCMService::HGCMService()
    228230    :
    229231    m_thread     (0),
    … …  
    284286        if (RT_FAILURE(rc) || !m_pfnLoad)
    285287        {
    286             Log(("HGCMService::loadServiceDLL: Error resolving the service entry point %s, rc = %d, m_pfnLoad = %p\n", VBOX_HGCM_SVCLOAD_NAME, rc, m_pfnLoad));
     288            Log(("HGCMService::loadServiceDLL: Error resolving the service entry point %s, rc = %d, m_pfnLoad = %p\n",
     289                 VBOX_HGCM_SVCLOAD_NAME, rc, m_pfnLoad));
    287290
    288291            if (RT_SUCCESS(rc))
    … …  
    400403{
    401404    public:
    402         HGCMMsgHeader () : pCmd (NULL), pHGCMPort (NULL) {};
     405        HGCMMsgHeader() : pCmd(NULL), pHGCMPort(NULL) {};
    403406
    404407        /* Command pointer/identifier. */
    … …  
    476479#endif
    477480
    478 static HGCMMsgCore *hgcmMessageAllocSvc (uint32_t u32MsgId)
     481static HGCMMsgCore *hgcmMessageAllocSvc(uint32_t u32MsgId)
    479482{
    480483    switch (u32MsgId)
    481484    {
    482485#ifdef VBOX_WITH_CRHGSMI
    483         case SVC_MSG_HOSTFASTCALLASYNC: return new HGCMMsgHostFastCallAsyncSvc ();
     486        case SVC_MSG_HOSTFASTCALLASYNC: return new HGCMMsgHostFastCallAsyncSvc();
    484487#endif
    485         case SVC_MSG_LOAD:        return new HGCMMsgSvcLoad ();
    486         case SVC_MSG_UNLOAD:      return new HGCMMsgSvcUnload ();
    487         case SVC_MSG_CONNECT:     return new HGCMMsgSvcConnect ();
    488         case SVC_MSG_DISCONNECT:  return new HGCMMsgSvcDisconnect ();
    489         case SVC_MSG_HOSTCALL:    return new HGCMMsgHostCallSvc ();
    490         case SVC_MSG_GUESTCALL:   return new HGCMMsgCall ();
     488        case SVC_MSG_LOAD:        return new HGCMMsgSvcLoad();
     489        case SVC_MSG_UNLOAD:      return new HGCMMsgSvcUnload();
     490        case SVC_MSG_CONNECT:     return new HGCMMsgSvcConnect();
     491        case SVC_MSG_DISCONNECT:  return new HGCMMsgSvcDisconnect();
     492        case SVC_MSG_HOSTCALL:    return new HGCMMsgHostCallSvc();
     493        case SVC_MSG_GUESTCALL:   return new HGCMMsgCall();
    491494        case SVC_MSG_LOADSTATE:
    492         case SVC_MSG_SAVESTATE:   return new HGCMMsgLoadSaveStateClient ();
    493         case SVC_MSG_REGEXT:      return new HGCMMsgSvcRegisterExtension ();
    494         case SVC_MSG_UNREGEXT:    return new HGCMMsgSvcUnregisterExtension ();
     495        case SVC_MSG_SAVESTATE:   return new HGCMMsgLoadSaveStateClient();
     496        case SVC_MSG_REGEXT:      return new HGCMMsgSvcRegisterExtension();
     497        case SVC_MSG_UNREGEXT:    return new HGCMMsgSvcUnregisterExtension();
    495498        default:
    496499            AssertReleaseMsgFailed(("Msg id = %08X\n", u32MsgId));
    … …  
    503506 * The service thread. Loads the service library and calls the service entry points.
    504507 */
    505 DECLCALLBACK(void) hgcmServiceThread (HGCMTHREADHANDLE ThreadHandle, void *pvUser)
     508DECLCALLBACK(void) hgcmServiceThread(HGCMTHREADHANDLE ThreadHandle, void *pvUser)
    506509{
    507510    HGCMService *pSvc = (HGCMService *)pvUser;
    … …  
    513516    {
    514517        HGCMMsgCore *pMsgCore;
    515         int rc = hgcmMsgGet (ThreadHandle, &pMsgCore);
     518        int rc = hgcmMsgGet(ThreadHandle, &pMsgCore);
    516519
    517520        if (RT_FAILURE(rc))
    518521        {
    519522            /* The error means some serious unrecoverable problem in the hgcmMsg/hgcmThread layer. */
    520             AssertMsgFailed (("%Rrc\n", rc));
     523            AssertMsgFailed(("%Rrc\n", rc));
    521524            break;
    522525        }
    523526
    524527        /* Cache required information to avoid unnecessary pMsgCore access. */
    525         uint32_t u32MsgId = pMsgCore->MsgId ();
     528        uint32_t u32MsgId = pMsgCore->MsgId();
    526529
    527530        switch (u32MsgId)
    … …  
    534537                LogFlowFunc(("SVC_MSG_HOSTFASTCALLASYNC u32Function = %d, pParm = %p\n", pMsg->u32Function, &pMsg->Param));
    535538
    536                 rc = pSvc->m_fntable.pfnHostCall (pSvc->m_fntable.pvService, pMsg->u32Function, 1, &pMsg->Param);
     539                rc = pSvc->m_fntable.pfnHostCall(pSvc->m_fntable.pvService, pMsg->u32Function, 1, &pMsg->Param);
    537540            } break;
    538541#endif
    … …  
    540543            {
    541544                LogFlowFunc(("SVC_MSG_LOAD\n"));
    542                 rc = pSvc->loadServiceDLL ();
     545                rc = pSvc->loadServiceDLL();
    543546            } break;
    544547
    … …  
    548551                if (pSvc->m_fntable.pfnUnload)
    549552                {
    550                     pSvc->m_fntable.pfnUnload (pSvc->m_fntable.pvService);
    551                 }
    552 
    553                 pSvc->unloadServiceDLL ();
     553                    pSvc->m_fntable.pfnUnload(pSvc->m_fntable.pvService);
     554                }
     555
     556                pSvc->unloadServiceDLL();
    554557                fQuit = true;
    555558            } break;
    … …  
    561564                LogFlowFunc(("SVC_MSG_CONNECT u32ClientId = %d\n", pMsg->u32ClientId));
    562565
    563                 HGCMClient *pClient = (HGCMClient *)hgcmObjReference (pMsg->u32ClientId, HGCMOBJ_CLIENT);
     566                HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
    564567
    565568                if (pClient)
    566569                {
    567                     rc = pSvc->m_fntable.pfnConnect (pSvc->m_fntable.pvService, pMsg->u32ClientId, HGCM_CLIENT_DATA(pSvc, pClient));
    568 
    569                     hgcmObjDereference (pClient);
     570                    rc = pSvc->m_fntable.pfnConnect(pSvc->m_fntable.pvService, pMsg->u32ClientId,
     571                                                    HGCM_CLIENT_DATA(pSvc, pClient));
     572
     573                    hgcmObjDereference(pClient);
    570574                }
    571575                else
    … …  
    581585                LogFlowFunc(("SVC_MSG_DISCONNECT u32ClientId = %d\n", pMsg->u32ClientId));
    582586
    583                 HGCMClient *pClient = (HGCMClient *)hgcmObjReference (pMsg->u32ClientId, HGCMOBJ_CLIENT);
     587                HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
    584588
    585589                if (pClient)
    586590                {
    587                     rc = pSvc->m_fntable.pfnDisconnect (pSvc->m_fntable.pvService, pMsg->u32ClientId, HGCM_CLIENT_DATA(pSvc, pClient));
    588 
    589                     hgcmObjDereference (pClient);
     591                    rc = pSvc->m_fntable.pfnDisconnect(pSvc->m_fntable.pvService, pMsg->u32ClientId,
     592                                                       HGCM_CLIENT_DATA(pSvc, pClient));
     593
     594                    hgcmObjDereference(pClient);
    590595                }
    591596                else
    … …  
    602607                             pMsg->u32ClientId, pMsg->u32Function, pMsg->cParms, pMsg->paParms));
    603608
    604                 HGCMClient *pClient = (HGCMClient *)hgcmObjReference (pMsg->u32ClientId, HGCMOBJ_CLIENT);
     609                HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
    605610
    606611                if (pClient)
    607612                {
    608                     pSvc->m_fntable.pfnCall (pSvc->m_fntable.pvService, (VBOXHGCMCALLHANDLE)pMsg, pMsg->u32ClientId, HGCM_CLIENT_DATA(pSvc, pClient), pMsg->u32Function, pMsg->cParms, pMsg->paParms);
    609 
    610                     hgcmObjDereference (pClient);
     613                    pSvc->m_fntable.pfnCall(pSvc->m_fntable.pvService, (VBOXHGCMCALLHANDLE)pMsg, pMsg->u32ClientId,
     614                                            HGCM_CLIENT_DATA(pSvc, pClient), pMsg->u32Function,
     615                                            pMsg->cParms, pMsg->paParms);
     616
     617                    hgcmObjDereference(pClient);
    611618                }
    612619                else
    … …  
    620627                HGCMMsgHostCallSvc *pMsg = (HGCMMsgHostCallSvc *)pMsgCore;
    621628
    622                 LogFlowFunc(("SVC_MSG_HOSTCALL u32Function = %d, cParms = %d, paParms = %p\n", pMsg->u32Function, pMsg->cParms, pMsg->paParms));
    623 
    624                 rc = pSvc->m_fntable.pfnHostCall (pSvc->m_fntable.pvService, pMsg->u32Function, pMsg->cParms, pMsg->paParms);
     629                LogFlowFunc(("SVC_MSG_HOSTCALL u32Function = %d, cParms = %d, paParms = %p\n",
     630                             pMsg->u32Function, pMsg->cParms, pMsg->paParms));
     631
     632                rc = pSvc->m_fntable.pfnHostCall(pSvc->m_fntable.pvService, pMsg->u32Function, pMsg->cParms, pMsg->paParms);
    625633            } break;
    626634
    … …  
    631639                LogFlowFunc(("SVC_MSG_LOADSTATE\n"));
    632640
    633                 HGCMClient *pClient = (HGCMClient *)hgcmObjReference (pMsg->u32ClientId, HGCMOBJ_CLIENT);
     641                HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
    634642
    635643                if (pClient)
    … …  
    637645                    if (pSvc->m_fntable.pfnLoadState)
    638646                    {
    639                         rc = pSvc->m_fntable.pfnLoadState (pSvc->m_fntable.pvService, pMsg->u32ClientId, HGCM_CLIENT_DATA(pSvc, pClient), pMsg->pSSM);
     647                        rc = pSvc->m_fntable.pfnLoadState(pSvc->m_fntable.pvService, pMsg->u32ClientId,
     648                                                          HGCM_CLIENT_DATA(pSvc, pClient), pMsg->pSSM);
    640649                    }
    641650
    642                     hgcmObjDereference (pClient);
     651                    hgcmObjDereference(pClient);
    643652                }
    644653                else
    … …  
    654663                LogFlowFunc(("SVC_MSG_SAVESTATE\n"));
    655664
    656                 HGCMClient *pClient = (HGCMClient *)hgcmObjReference (pMsg->u32ClientId, HGCMOBJ_CLIENT);
     665                HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
    657666
    658667                rc = VINF_SUCCESS;
    … …  
    663672                    {
    664673                        g_fSaveState = true;
    665                         rc = pSvc->m_fntable.pfnSaveState (pSvc->m_fntable.pvService, pMsg->u32ClientId, HGCM_CLIENT_DATA(pSvc, pClient), pMsg->pSSM);
     674                        rc = pSvc->m_fntable.pfnSaveState(pSvc->m_fntable.pvService, pMsg->u32ClientId,
     675                                                          HGCM_CLIENT_DATA(pSvc, pClient), pMsg->pSSM);
    666676                        g_fSaveState = false;
    667677                    }
    668678
    669                     hgcmObjDereference (pClient);
     679                    hgcmObjDereference(pClient);
    670680                }
    671681                else
    … …  
    689699                    if (pSvc->m_fntable.pfnRegisterExtension)
    690700                    {
    691                         rc = pSvc->m_fntable.pfnRegisterExtension (pSvc->m_fntable.pvService, pMsg->pfnExtension, pMsg->pvExtension);
     701                        rc = pSvc->m_fntable.pfnRegisterExtension(pSvc->m_fntable.pvService, pMsg->pfnExtension,
     702                                                                  pMsg->pvExtension);
    692703                    }
    693704                    else
    … …  
    717728                    if (pSvc->m_fntable.pfnRegisterExtension)
    718729                    {
    719                         rc = pSvc->m_fntable.pfnRegisterExtension (pSvc->m_fntable.pvService, NULL, NULL);
     730                        rc = pSvc->m_fntable.pfnRegisterExtension(pSvc->m_fntable.pvService, NULL, NULL);
    720731                    }
    721732                    else
    … …  
    745756}
    746757
    747 /* static */ DECLCALLBACK(void) HGCMService::svcHlpCallComplete (VBOXHGCMCALLHANDLE callHandle, int32_t rc)
     758/* static */ DECLCALLBACK(void) HGCMService::svcHlpCallComplete(VBOXHGCMCALLHANDLE callHandle, int32_t rc)
    748759{
    749760   HGCMMsgCore *pMsgCore = (HGCMMsgCore *)callHandle;
    … …  
    755766        * any other messages.
    756767        */
    757        hgcmMsgComplete (pMsgCore, rc);
     768       hgcmMsgComplete(pMsgCore, rc);
    758769   }
    759770   else
    760771   {
    761        AssertFailed ();
     772       AssertFailed();
    762773   }
    763774}
    764775
    765 /* static */ DECLCALLBACK(void) HGCMService::svcHlpDisconnectClient (void *pvInstance, uint32_t u32ClientId)
     776/* static */ DECLCALLBACK(void) HGCMService::svcHlpDisconnectClient(void *pvInstance, uint32_t u32ClientId)
    766777{
    767778     HGCMService *pService = static_cast <HGCMService *> (pvInstance);
    … …  
    769780     if (pService)
    770781     {
    771          pService->DisconnectClient (u32ClientId, true);
     782         pService->DisconnectClient(u32ClientId, true);
    772783     }
    773784}
    774785
    775 static DECLCALLBACK(void) hgcmMsgCompletionCallback (int32_t result, HGCMMsgCore *pMsgCore)
     786static DECLCALLBACK(void) hgcmMsgCompletionCallback(int32_t result, HGCMMsgCore *pMsgCore)
    776787{
    777788    /* Call the VMMDev port interface to issue IRQ notification. */
    … …  
    782793    if (pMsgHdr->pHGCMPort && !g_fResetting)
    783794    {
    784         pMsgHdr->pHGCMPort->pfnCompleted (pMsgHdr->pHGCMPort, g_fSaveState? VINF_HGCM_SAVE_STATE: result, pMsgHdr->pCmd);
     795        pMsgHdr->pHGCMPort->pfnCompleted(pMsgHdr->pHGCMPort, g_fSaveState? VINF_HGCM_SAVE_STATE: result, pMsgHdr->pCmd);
    785796    }
    786797}
    … …  
    790801 */
    791802
    792 int HGCMService::instanceCreate (const char *pszServiceLibrary, const char *pszServiceName)
     803int HGCMService::instanceCreate(const char *pszServiceLibrary, const char *pszServiceName)
    793804{
    794805    LogFlowFunc(("name %s, lib %s\n", pszServiceName, pszServiceLibrary));
    … …  
    796807    /* The maximum length of the thread name, allowed by the RT is 15. */
    797808    char szThreadName[16];
    798     if (!strncmp (pszServiceName, RT_STR_TUPLE("VBoxShared")))
    799         RTStrPrintf (szThreadName, sizeof (szThreadName), "Sh%s", pszServiceName + 10);
    800     else if (!strncmp (pszServiceName, RT_STR_TUPLE("VBox")))
    801         RTStrCopy (szThreadName, sizeof (szThreadName), pszServiceName + 4);
     809    if (!strncmp(pszServiceName, RT_STR_TUPLE("VBoxShared")))
     810        RTStrPrintf(szThreadName, sizeof(szThreadName), "Sh%s", pszServiceName + 10);
     811    else if (!strncmp(pszServiceName, RT_STR_TUPLE("VBox")))
     812        RTStrCopy(szThreadName, sizeof(szThreadName), pszServiceName + 4);
    802813    else
    803         RTStrCopy (szThreadName, sizeof (szThreadName), pszServiceName);
    804 
    805     int rc = hgcmThreadCreate (&m_thread, szThreadName, hgcmServiceThread, this);
     814        RTStrCopy(szThreadName, sizeof(szThreadName), pszServiceName);
     815
     816    int rc = hgcmThreadCreate(&m_thread, szThreadName, hgcmServiceThread, this);
    806817
    807818    if (RT_SUCCESS(rc))
    808819    {
    809         m_pszSvcName    = RTStrDup (pszServiceName);
    810         m_pszSvcLibrary = RTStrDup (pszServiceLibrary);
     820        m_pszSvcName    = RTStrDup(pszServiceName);
     821        m_pszSvcLibrary = RTStrDup(pszServiceLibrary);
    811822
    812823        if (!m_pszSvcName || !m_pszSvcLibrary)
    813824        {
    814             RTStrFree (m_pszSvcLibrary);
     825            RTStrFree(m_pszSvcLibrary);
    815826            m_pszSvcLibrary = NULL;
    816827
    817             RTStrFree (m_pszSvcName);
     828            RTStrFree(m_pszSvcName);
    818829            m_pszSvcName = NULL;
    819830
    … …  
    829840            /* Execute the load request on the service thread. */
    830841            HGCMMSGHANDLE hMsg;
    831             rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_LOAD, hgcmMessageAllocSvc);
     842            rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_LOAD, hgcmMessageAllocSvc);
    832843
    833844            if (RT_SUCCESS(rc))
    834845            {
    835                 rc = hgcmMsgSend (hMsg);
     846                rc = hgcmMsgSend(hMsg);
    836847            }
    837848        }
    … …  
    840851    if (RT_FAILURE(rc))
    841852    {
    842         instanceDestroy ();
     853        instanceDestroy();
    843854    }
    844855
    … …  
    847858}
    848859
    849 void HGCMService::instanceDestroy (void)
     860void HGCMService::instanceDestroy(void)
    850861{
    851862    LogFlowFunc(("%s\n", m_pszSvcName));
    852863
    853864    HGCMMSGHANDLE hMsg;
    854     int rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_UNLOAD, hgcmMessageAllocSvc);
     865    int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_UNLOAD, hgcmMessageAllocSvc);
    855866
    856867    if (RT_SUCCESS(rc))
    857868    {
    858         rc = hgcmMsgSend (hMsg);
     869        rc = hgcmMsgSend(hMsg);
    859870
    860871        if (RT_SUCCESS(rc))
    861872        {
    862             hgcmThreadWait (m_thread);
    863         }
    864     }
    865 
    866     RTStrFree (m_pszSvcLibrary);
     873            hgcmThreadWait(m_thread);
     874        }
     875    }
     876
     877    RTStrFree(m_pszSvcLibrary);
    867878    m_pszSvcLibrary = NULL;
    868879
    869     RTStrFree (m_pszSvcName);
     880    RTStrFree(m_pszSvcName);
    870881    m_pszSvcName = NULL;
    871882}
    … …  
    876887
    877888    HGCMMSGHANDLE hMsg;
    878     int rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_SAVESTATE, hgcmMessageAllocSvc);
     889    int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_SAVESTATE, hgcmMessageAllocSvc);
    879890
    880891    if (RT_SUCCESS(rc))
    881892    {
    882         HGCMMsgLoadSaveStateClient *pMsg = (HGCMMsgLoadSaveStateClient *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     893        HGCMMsgLoadSaveStateClient *pMsg = (HGCMMsgLoadSaveStateClient *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    883894        AssertRelease(pMsg);
    884895
    … …  
    886897        pMsg->pSSM        = pSSM;
    887898
    888         hgcmObjDereference (pMsg);
    889 
    890         rc = hgcmMsgSend (hMsg);
     899        hgcmObjDereference(pMsg);
     900
     901        rc = hgcmMsgSend(hMsg);
    891902    }
    892903
    … …  
    895906}
    896907
    897 int HGCMService::loadClientState (uint32_t u32ClientId, PSSMHANDLE pSSM)
     908int HGCMService::loadClientState(uint32_t u32ClientId, PSSMHANDLE pSSM)
    898909{
    899910    LogFlowFunc(("%s\n", m_pszSvcName));
    900911
    901912    HGCMMSGHANDLE hMsg;
    902     int rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_LOADSTATE, hgcmMessageAllocSvc);
     913    int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_LOADSTATE, hgcmMessageAllocSvc);
    903914
    904915    if (RT_SUCCESS(rc))
    905916    {
    906         HGCMMsgLoadSaveStateClient *pMsg = (HGCMMsgLoadSaveStateClient *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     917        HGCMMsgLoadSaveStateClient *pMsg = (HGCMMsgLoadSaveStateClient *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    907918
    908919        AssertRelease(pMsg);
    … …  
    911922        pMsg->pSSM        = pSSM;
    912923
    913         hgcmObjDereference (pMsg);
    914 
    915         rc = hgcmMsgSend (hMsg);
     924        hgcmObjDereference(pMsg);
     925
     926        rc = hgcmMsgSend(hMsg);
    916927    }
    917928
    … …  
    928939 * @thread main HGCM
    929940 */
    930 /* static */ int HGCMService::LoadService (const char *pszServiceLibrary, const char *pszServiceName)
     941/* static */ int HGCMService::LoadService(const char *pszServiceLibrary, const char *pszServiceName)
    931942{
    932943    LogFlowFunc(("lib %s, name = %s\n", pszServiceLibrary, pszServiceName));
    … …  
    935946
    936947    HGCMService *pSvc;
    937     int rc = HGCMService::ResolveService (&pSvc, pszServiceName);
     948    int rc = HGCMService::ResolveService(&pSvc, pszServiceName);
    938949
    939950    if (RT_SUCCESS(rc))
    940951    {
    941952        /* The service is already loaded. */
    942         pSvc->ReleaseService ();
     953        pSvc->ReleaseService();
    943954        rc = VERR_HGCM_SERVICE_EXISTS;
    944955    }
    … …  
    946957    {
    947958        /* Create the new service. */
    948         pSvc = new HGCMService ();
     959        pSvc = new HGCMService();
    949960
    950961        if (!pSvc)
    … …  
    955966        {
    956967            /* Load the library and call the initialization entry point. */
    957             rc = pSvc->instanceCreate (pszServiceLibrary, pszServiceName);
     968            rc = pSvc->instanceCreate(pszServiceLibrary, pszServiceName);
    958969
    959970            if (RT_SUCCESS(rc))
    … …  
    977988
    978989                /* Reference the service (for first time) until it is unloaded on HGCM termination. */
    979                 AssertRelease (pSvc->m_u32RefCnt == 0);
    980                 pSvc->ReferenceService ();
     990                AssertRelease(pSvc->m_u32RefCnt == 0);
     991                pSvc->ReferenceService();
    981992
    982993                LogFlowFunc(("service %p\n", pSvc));
    … …  
    9931004 * @thread main HGCM
    9941005 */
    995 void HGCMService::UnloadService (void)
     1006void HGCMService::UnloadService(void)
    9961007{
    9971008    LogFlowFunc(("name = %s\n", m_pszSvcName));
    … …  
    10201031    /* The service must be unloaded only if all clients were disconnected. */
    10211032    LogFlowFunc(("m_u32RefCnt = %d\n", m_u32RefCnt));
    1022     AssertRelease (m_u32RefCnt == 1);
     1033    AssertRelease(m_u32RefCnt == 1);
    10231034
    10241035    /* Now the service can be released. */
    1025     ReleaseService ();
     1036    ReleaseService();
    10261037}
    10271038
    … …  
    10301041 * @thread main HGCM
    10311042 */
    1032 /* static */ void HGCMService::UnloadAll (void)
     1043/* static */ void HGCMService::UnloadAll(void)
    10331044{
    10341045    while (sm_pSvcListHead)
    10351046    {
    1036         sm_pSvcListHead->UnloadService ();
     1047        sm_pSvcListHead->UnloadService();
    10371048    }
    10381049}
    … …  
    10471058 * @thread main HGCM
    10481059 */
    1049 /* static */ int HGCMService::ResolveService (HGCMService **ppSvc, const char *pszServiceName)
     1060/* static */ int HGCMService::ResolveService(HGCMService **ppSvc, const char *pszServiceName)
    10501061{
    10511062    LogFlowFunc(("ppSvc = %p name = %s\n",
    … …  
    10611072    while (pSvc)
    10621073    {
    1063         if (strcmp (pSvc->m_pszSvcName, pszServiceName) == 0)
     1074        if (strcmp(pSvc->m_pszSvcName, pszServiceName) == 0)
    10641075        {
    10651076            break;
    … …  
    10771088    }
    10781089
    1079     pSvc->ReferenceService ();
     1090    pSvc->ReferenceService();
    10801091
    10811092    *ppSvc = pSvc;
    … …  
    10881099 * @thread main HGCM
    10891100 */
    1090 void HGCMService::ReferenceService (void)
    1091 {
    1092     ASMAtomicIncU32 (&m_u32RefCnt);
     1101void HGCMService::ReferenceService(void)
     1102{
     1103    ASMAtomicIncU32(&m_u32RefCnt);
    10931104    LogFlowFunc(("[%s] m_u32RefCnt = %d\n", m_pszSvcName, m_u32RefCnt));
    10941105}
    … …  
    10981109 * @thread main HGCM
    10991110 */
    1100 void HGCMService::ReleaseService (void)
     1111void HGCMService::ReleaseService(void)
    11011112{
    11021113    LogFlowFunc(("m_u32RefCnt = %d\n", m_u32RefCnt));
    1103     uint32_t u32RefCnt = ASMAtomicDecU32 (&m_u32RefCnt);
     1114    uint32_t u32RefCnt = ASMAtomicDecU32(&m_u32RefCnt);
    11041115    AssertRelease(u32RefCnt != ~0U);
    11051116
    … …  
    11081119    if (u32RefCnt == 0)
    11091120    {
    1110         instanceDestroy ();
     1121        instanceDestroy();
    11111122        delete this;
    11121123    }
    … …  
    11181129 * @thread main HGCM
    11191130 */
    1120 /* static */ void HGCMService::Reset (void)
     1131/* static */ void HGCMService::Reset(void)
    11211132{
    11221133    g_fResetting = true;
    … …  
    11291140        {
    11301141            LogFlowFunc(("handle %d\n", pSvc->m_paClientIds[0]));
    1131             pSvc->DisconnectClient (pSvc->m_paClientIds[0], false);
     1142            pSvc->DisconnectClient(pSvc->m_paClientIds[0], false);
    11321143        }
    11331144
    … …  
    11371148        while (pSvc->m_cHandleAcquires)
    11381149        {
    1139             pSvc->HandleReleased ();
    1140             pSvc->ReleaseService ();
     1150            pSvc->HandleReleased();
     1151            pSvc->ReleaseService();
    11411152        }
    11421153        pSvc = pNextSvc;
    … …  
    11551166 * @thread main HGCM
    11561167 */
    1157 /* static */ int HGCMService::SaveState (PSSMHANDLE pSSM)
     1168/* static */ int HGCMService::SaveState(PSSMHANDLE pSSM)
    11581169{
    11591170    /* Save the current handle count and restore afterwards to avoid client id conflicts. */
    … …  
    12031214
    12041215            /* Call the service, so the operation is executed by the service thread. */
    1205             rc = pSvc->saveClientState (u32ClientId, pSSM);
     1216            rc = pSvc->saveClientState(u32ClientId, pSSM);
    12061217            AssertRCReturn(rc, rc);
    12071218        }
    … …  
    12191230 * @thread main HGCM
    12201231 */
    1221 /* static */ int HGCMService::LoadState (PSSMHANDLE pSSM)
     1232/* static */ int HGCMService::LoadState(PSSMHANDLE pSSM)
    12221233{
    12231234    /* Restore handle count to avoid client id conflicts. */
    … …  
    12441255        AssertReturn(u32 <= VBOX_HGCM_SVC_NAME_MAX_BYTES, VERR_SSM_UNEXPECTED_DATA);
    12451256
    1246         char *pszServiceName = (char *)alloca (u32);
     1257        char *pszServiceName = (char *)alloca(u32);
    12471258
    12481259        /* Get the service name. */
    … …  
    12541265        /* Resolve the service instance. */
    12551266        HGCMService *pSvc;
    1256         rc = ResolveService (&pSvc, pszServiceName);
     1267        rc = ResolveService(&pSvc, pszServiceName);
    12571268        AssertLogRelMsgReturn(pSvc, ("rc=%Rrc, %s\n", rc, pszServiceName), VERR_SSM_UNEXPECTED_DATA);
    12581269
    … …  
    12621273        if (RT_FAILURE(rc))
    12631274        {
    1264             pSvc->ReleaseService ();
     1275            pSvc->ReleaseService();
    12651276            AssertFailed();
    12661277            return rc;
    … …  
    12741285            if (RT_FAILURE(rc))
    12751286            {
    1276                 pSvc->ReleaseService ();
     1287                pSvc->ReleaseService();
    12771288                AssertFailed();
    12781289                return rc;
    … …  
    12801291
    12811292            /* Connect the client. */
    1282             rc = pSvc->CreateAndConnectClient (NULL, u32ClientId);
     1293            rc = pSvc->CreateAndConnectClient(NULL, u32ClientId);
    12831294            if (RT_FAILURE(rc))
    12841295            {
    1285                 pSvc->ReleaseService ();
     1296                pSvc->ReleaseService();
    12861297                AssertLogRelMsgFailed(("rc=%Rrc %s\n", rc, pszServiceName));
    12871298                return rc;
    … …  
    12891300
    12901301            /* Call the service, so the operation is executed by the service thread. */
    1291             rc = pSvc->loadClientState (u32ClientId, pSSM);
     1302            rc = pSvc->loadClientState(u32ClientId, pSSM);
    12921303            if (RT_FAILURE(rc))
    12931304            {
    1294                 pSvc->ReleaseService ();
     1305                pSvc->ReleaseService();
    12951306                AssertLogRelMsgFailed(("rc=%Rrc %s\n", rc, pszServiceName));
    12961307                return rc;
    … …  
    12981309        }
    12991310
    1300         pSvc->ReleaseService ();
     1311        pSvc->ReleaseService();
    13011312    }
    13021313
    … …  
    13111322 * @return VBox rc.
    13121323 */
    1313 int HGCMService::CreateAndConnectClient (uint32_t *pu32ClientIdOut, uint32_t u32ClientIdIn)
     1324int HGCMService::CreateAndConnectClient(uint32_t *pu32ClientIdOut, uint32_t u32ClientIdIn)
    13141325{
    13151326    LogFlowFunc(("pu32ClientIdOut = %p, u32ClientIdIn = %d\n", pu32ClientIdOut, u32ClientIdIn));
    13161327
    13171328    /* Allocate a client information structure. */
    1318     HGCMClient *pClient = new HGCMClient ();
     1329    HGCMClient *pClient = new HGCMClient();
    13191330
    13201331    if (!pClient)
    … …  
    13281339    if (pu32ClientIdOut != NULL)
    13291340    {
    1330         handle = hgcmObjGenerateHandle (pClient);
     1341        handle = hgcmObjGenerateHandle(pClient);
    13311342    }
    13321343    else
    13331344    {
    1334         handle = hgcmObjAssignHandle (pClient, u32ClientIdIn);
     1345        handle = hgcmObjAssignHandle(pClient, u32ClientIdIn);
    13351346    }
    13361347
    … …  
    13401351
    13411352    /* Initialize the HGCM part of the client. */
    1342     int rc = pClient->Init (this);
     1353    int rc = pClient->Init(this);
    13431354
    13441355    if (RT_SUCCESS(rc))
    … …  
    13471358        HGCMMSGHANDLE hMsg;
    13481359
    1349         rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_CONNECT, hgcmMessageAllocSvc);
     1360        rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_CONNECT, hgcmMessageAllocSvc);
    13501361
    13511362        if (RT_SUCCESS(rc))
    13521363        {
    1353             HGCMMsgSvcConnect *pMsg = (HGCMMsgSvcConnect *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     1364            HGCMMsgSvcConnect *pMsg = (HGCMMsgSvcConnect *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    13541365            AssertRelease(pMsg);
    13551366
    13561367            pMsg->u32ClientId = handle;
    13571368
    1358             hgcmObjDereference (pMsg);
    1359 
    1360             rc = hgcmMsgSend (hMsg);
     1369            hgcmObjDereference(pMsg);
     1370
     1371            rc = hgcmMsgSend(hMsg);
    13611372
    13621373            if (RT_SUCCESS(rc))
    … …  
    13651376                if (m_cClients == m_cClientsAllocated)
    13661377                {
    1367                     m_paClientIds = (uint32_t *)RTMemRealloc (m_paClientIds, (m_cClientsAllocated + 64) * sizeof (m_paClientIds[0]));
     1378                    m_paClientIds = (uint32_t *)RTMemRealloc(m_paClientIds, (m_cClientsAllocated + 64) *
     1379                                                             sizeof(m_paClientIds[0]));
    13681380                    Assert(m_paClientIds);
    13691381                    m_cClientsAllocated += 64;
    … …  
    13781390    if (RT_FAILURE(rc))
    13791391    {
    1380         hgcmObjDeleteHandle (handle);
     1392        hgcmObjDeleteHandle(handle);
    13811393    }
    13821394    else
    … …  
    13871399        }
    13881400
    1389         ReferenceService ();
     1401        ReferenceService();
    13901402    }
    13911403
    … …  
    13991411 * @return VBox rc.
    14001412 */
    1401 int HGCMService::DisconnectClient (uint32_t u32ClientId, bool fFromService)
     1413int HGCMService::DisconnectClient(uint32_t u32ClientId, bool fFromService)
    14021414{
    14031415    int rc = VINF_SUCCESS;
    … …  
    14101422        HGCMMSGHANDLE hMsg;
    14111423
    1412         rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_DISCONNECT, hgcmMessageAllocSvc);
     1424        rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_DISCONNECT, hgcmMessageAllocSvc);
    14131425
    14141426        if (RT_SUCCESS(rc))
    14151427        {
    1416             HGCMMsgSvcDisconnect *pMsg = (HGCMMsgSvcDisconnect *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     1428            HGCMMsgSvcDisconnect *pMsg = (HGCMMsgSvcDisconnect *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    14171429            AssertRelease(pMsg);
    14181430
    14191431            pMsg->u32ClientId = u32ClientId;
    14201432
    1421             hgcmObjDereference (pMsg);
    1422 
    1423             rc = hgcmMsgSend (hMsg);
     1433            hgcmObjDereference(pMsg);
     1434
     1435            rc = hgcmMsgSend(hMsg);
    14241436        }
    14251437        else
    … …  
    14411453            if (m_cClients > i)
    14421454            {
    1443                 memmove (&m_paClientIds[i], &m_paClientIds[i + 1], sizeof (m_paClientIds[0]) * (m_cClients - i));
     1455                memmove (&m_paClientIds[i], &m_paClientIds[i + 1], sizeof(m_paClientIds[0]) * (m_cClients - i));
    14441456            }
    14451457
    14461458            /* Delete the client handle. */
    1447             hgcmObjDeleteHandle (u32ClientId);
     1459            hgcmObjDeleteHandle(u32ClientId);
    14481460
    14491461            /* The service must be released. */
    1450             ReleaseService ();
     1462            ReleaseService();
    14511463
    14521464            break;
    … …  
    14581470}
    14591471
    1460 int HGCMService::RegisterExtension (HGCMSVCEXTHANDLE handle,
    1461                                     PFNHGCMSVCEXT pfnExtension,
    1462                                     void *pvExtension)
     1472int HGCMService::RegisterExtension(HGCMSVCEXTHANDLE handle,
     1473                                   PFNHGCMSVCEXT pfnExtension,
     1474                                   void *pvExtension)
    14631475{
    14641476    LogFlowFunc(("%s\n", handle->pszServiceName));
    … …  
    14661478    /* Forward the message to the service thread. */
    14671479    HGCMMSGHANDLE hMsg = 0;
    1468     int rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_REGEXT, hgcmMessageAllocSvc);
     1480    int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_REGEXT, hgcmMessageAllocSvc);
    14691481
    14701482    if (RT_SUCCESS(rc))
    14711483    {
    1472         HGCMMsgSvcRegisterExtension *pMsg = (HGCMMsgSvcRegisterExtension *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     1484        HGCMMsgSvcRegisterExtension *pMsg = (HGCMMsgSvcRegisterExtension *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    14731485        AssertRelease(pMsg);
    14741486
    … …  
    14771489        pMsg->pvExtension  = pvExtension;
    14781490
    1479         hgcmObjDereference (pMsg);
    1480 
    1481         rc = hgcmMsgSend (hMsg);
     1491        hgcmObjDereference(pMsg);
     1492
     1493        rc = hgcmMsgSend(hMsg);
    14821494    }
    14831495
    … …  
    14861498}
    14871499
    1488 void HGCMService::UnregisterExtension (HGCMSVCEXTHANDLE handle)
     1500void HGCMService::UnregisterExtension(HGCMSVCEXTHANDLE handle)
    14891501{
    14901502    /* Forward the message to the service thread. */
    14911503    HGCMMSGHANDLE hMsg = 0;
    1492     int rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_UNREGEXT, hgcmMessageAllocSvc);
     1504    int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_UNREGEXT, hgcmMessageAllocSvc);
    14931505
    14941506    if (RT_SUCCESS(rc))
    14951507    {
    1496         HGCMMsgSvcUnregisterExtension *pMsg = (HGCMMsgSvcUnregisterExtension *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     1508        HGCMMsgSvcUnregisterExtension *pMsg = (HGCMMsgSvcUnregisterExtension *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    14971509        AssertRelease(pMsg);
    14981510
    14991511        pMsg->handle = handle;
    15001512
    1501         hgcmObjDereference (pMsg);
    1502 
    1503         rc = hgcmMsgSend (hMsg);
     1513        hgcmObjDereference(pMsg);
     1514
     1515        rc = hgcmMsgSend(hMsg);
    15041516    }
    15051517
    … …  
    15171529 * @return VBox rc.
    15181530 */
    1519 int HGCMService::GuestCall (PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmd, uint32_t u32ClientId, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     1531int HGCMService::GuestCall(PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmd, uint32_t u32ClientId, uint32_t u32Function,
     1532                           uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    15201533{
    15211534    HGCMMSGHANDLE hMsg = 0;
    … …  
    15231536    LogFlow(("MAIN::HGCMService::Call\n"));
    15241537
    1525     int rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_GUESTCALL, hgcmMessageAllocSvc);
     1538    int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_GUESTCALL, hgcmMessageAllocSvc);
    15261539
    15271540    if (RT_SUCCESS(rc))
    15281541    {
    1529         HGCMMsgCall *pMsg = (HGCMMsgCall *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     1542        HGCMMsgCall *pMsg = (HGCMMsgCall *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    15301543
    15311544        AssertRelease(pMsg);
    … …  
    15391552        pMsg->paParms     = paParms;
    15401553
    1541         hgcmObjDereference (pMsg);
    1542 
    1543         rc = hgcmMsgPost (hMsg, hgcmMsgCompletionCallback);
     1554        hgcmObjDereference(pMsg);
     1555
     1556        rc = hgcmMsgPost(hMsg, hgcmMsgCompletionCallback);
    15441557    }
    15451558    else
    … …  
    15591572 * @return VBox rc.
    15601573 */
    1561 int HGCMService::HostCall (uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM *paParms)
     1574int HGCMService::HostCall(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM *paParms)
    15621575{
    15631576    LogFlowFunc(("%s u32Function = %d, cParms = %d, paParms = %p\n",
    … …  
    15651578
    15661579    HGCMMSGHANDLE hMsg = 0;
    1567     int rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_HOSTCALL, hgcmMessageAllocSvc);
     1580    int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_HOSTCALL, hgcmMessageAllocSvc);
    15681581
    15691582    if (RT_SUCCESS(rc))
    15701583    {
    1571         HGCMMsgHostCallSvc *pMsg = (HGCMMsgHostCallSvc *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     1584        HGCMMsgHostCallSvc *pMsg = (HGCMMsgHostCallSvc *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    15721585        AssertRelease(pMsg);
    15731586
    … …  
    15761589        pMsg->paParms          = paParms;
    15771590
    1578         hgcmObjDereference (pMsg);
    1579 
    1580         rc = hgcmMsgSend (hMsg);
     1591        hgcmObjDereference(pMsg);
     1592
     1593        rc = hgcmMsgSend(hMsg);
    15811594    }
    15821595
    … …  
    15861599
    15871600#ifdef VBOX_WITH_CRHGSMI
    1588 static DECLCALLBACK(void) hgcmMsgFastCallCompletionCallback (int32_t result, HGCMMsgCore *pMsgCore)
     1601static DECLCALLBACK(void) hgcmMsgFastCallCompletionCallback(int32_t result, HGCMMsgCore *pMsgCore)
    15891602{
    15901603    /* Call the VMMDev port interface to issue IRQ notification. */
    … …  
    15941607    if (pMsg->pfnCompletion)
    15951608    {
    1596         pMsg->pfnCompletion (result, pMsg->u32Function, &pMsg->Param, pMsg->pvCompletion);
     1609        pMsg->pfnCompletion(result, pMsg->u32Function, &pMsg->Param, pMsg->pvCompletion);
    15971610    }
    15981611}
    … …  
    16151628}
    16161629
    1617 int HGCMService::HostFastCallAsync (uint32_t u32Function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion, void *pvCompletion)
     1630int HGCMService::HostFastCallAsync(uint32_t u32Function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion,
     1631                                   void *pvCompletion)
    16181632{
    16191633    LogFlowFunc(("%s u32Function = %d, pParm = %p\n",
    … …  
    16211635
    16221636    HGCMMSGHANDLE hMsg = 0;
    1623     int rc = hgcmMsgAlloc (m_thread, &hMsg, SVC_MSG_HOSTFASTCALLASYNC, hgcmMessageAllocSvc);
     1637    int rc = hgcmMsgAlloc(m_thread, &hMsg, SVC_MSG_HOSTFASTCALLASYNC, hgcmMessageAllocSvc);
    16241638
    16251639    if (RT_SUCCESS(rc))
    16261640    {
    1627         HGCMMsgHostFastCallAsyncSvc *pMsg = (HGCMMsgHostFastCallAsyncSvc *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     1641        HGCMMsgHostFastCallAsyncSvc *pMsg = (HGCMMsgHostFastCallAsyncSvc *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    16281642        AssertRelease(pMsg);
    16291643
    … …  
    16331647        pMsg->pvCompletion = pvCompletion;
    16341648
    1635         hgcmObjDereference (pMsg);
     1649        hgcmObjDereference(pMsg);
    16361650
    16371651        rc = hgcmMsgPost(hMsg, hgcmMsgFastCallCompletionCallback);
    … …  
    17591773    switch (u32MsgId)
    17601774    {
    1761         case HGCM_MSG_CONNECT:    return new HGCMMsgMainConnect ();
    1762         case HGCM_MSG_DISCONNECT: return new HGCMMsgMainDisconnect ();
    1763         case HGCM_MSG_LOAD:       return new HGCMMsgMainLoad ();
    1764         case HGCM_MSG_HOSTCALL:   return new HGCMMsgMainHostCall ();
     1775        case HGCM_MSG_CONNECT:    return new HGCMMsgMainConnect();
     1776        case HGCM_MSG_DISCONNECT: return new HGCMMsgMainDisconnect();
     1777        case HGCM_MSG_LOAD:       return new HGCMMsgMainLoad();
     1778        case HGCM_MSG_HOSTCALL:   return new HGCMMsgMainHostCall();
    17651779        case HGCM_MSG_LOADSTATE:
    1766         case HGCM_MSG_SAVESTATE:  return new HGCMMsgMainLoadSaveState ();
    1767         case HGCM_MSG_RESET:      return new HGCMMsgMainReset ();
    1768         case HGCM_MSG_QUIT:       return new HGCMMsgMainQuit ();
    1769         case HGCM_MSG_REGEXT:     return new HGCMMsgMainRegisterExtension ();
    1770         case HGCM_MSG_UNREGEXT:   return new HGCMMsgMainUnregisterExtension ();
     1780        case HGCM_MSG_SAVESTATE:  return new HGCMMsgMainLoadSaveState();
     1781        case HGCM_MSG_RESET:      return new HGCMMsgMainReset();
     1782        case HGCM_MSG_QUIT:       return new HGCMMsgMainQuit();
     1783        case HGCM_MSG_REGEXT:     return new HGCMMsgMainRegisterExtension();
     1784        case HGCM_MSG_UNREGEXT:   return new HGCMMsgMainUnregisterExtension();
    17711785#ifdef VBOX_WITH_CRHGSMI
    17721786        case HGCM_MSG_SVCAQUIRE: return new HGCMMsgMainSvcAcquire();
    … …  
    17831797
    17841798/* The main HGCM thread handler. */
    1785 static DECLCALLBACK(void) hgcmThread (HGCMTHREADHANDLE ThreadHandle, void *pvUser)
     1799static DECLCALLBACK(void) hgcmThread(HGCMTHREADHANDLE ThreadHandle, void *pvUser)
    17861800{
    17871801    LogFlowFunc(("ThreadHandle = %p, pvUser = %p\n",
    … …  
    17951809    {
    17961810        HGCMMsgCore *pMsgCore;
    1797         int rc = hgcmMsgGet (ThreadHandle, &pMsgCore);
     1811        int rc = hgcmMsgGet(ThreadHandle, &pMsgCore);
    17981812
    17991813        if (RT_FAILURE(rc))
    18001814        {
    18011815            /* The error means some serious unrecoverable problem in the hgcmMsg/hgcmThread layer. */
    1802             AssertMsgFailed (("%Rrc\n", rc));
     1816            AssertMsgFailed(("%Rrc\n", rc));
    18031817            break;
    18041818        }
    18051819
    1806         uint32_t u32MsgId = pMsgCore->MsgId ();
     1820        uint32_t u32MsgId = pMsgCore->MsgId();
    18071821
    18081822        switch (u32MsgId)
    … …  
    18181832                 */
    18191833                HGCMService *pService;
    1820                 rc = HGCMService::ResolveService (&pService, pMsg->pszServiceName);
     1834                rc = HGCMService::ResolveService(&pService, pMsg->pszServiceName);
    18211835
    18221836                if (RT_SUCCESS(rc))
    18231837                {
    18241838                    /* Call the service instance method. */
    1825                     rc = pService->CreateAndConnectClient (pMsg->pu32ClientId, 0);
     1839                    rc = pService->CreateAndConnectClient(pMsg->pu32ClientId, 0);
    18261840
    18271841                    /* Release the service after resolve. */
    1828                     pService->ReleaseService ();
     1842                    pService->ReleaseService();
    18291843                }
    18301844            } break;
    … …  
    18371851                             pMsg->u32ClientId));
    18381852
    1839                 HGCMClient *pClient = (HGCMClient *)hgcmObjReference (pMsg->u32ClientId, HGCMOBJ_CLIENT);
     1853                HGCMClient *pClient = (HGCMClient *)hgcmObjReference(pMsg->u32ClientId, HGCMOBJ_CLIENT);
    18401854
    18411855                if (!pClient)
    … …  
    18491863
    18501864                /* Call the service instance to disconnect the client. */
    1851                 rc = pService->DisconnectClient (pMsg->u32ClientId, false);
    1852 
    1853                 hgcmObjDereference (pClient);
     1865                rc = pService->DisconnectClient(pMsg->u32ClientId, false);
     1866
     1867                hgcmObjDereference(pClient);
    18541868            } break;
    18551869
    … …  
    18611875                             pMsg->pszServiceName, pMsg->pszServiceLibrary));
    18621876
    1863                 rc = HGCMService::LoadService (pMsg->pszServiceLibrary, pMsg->pszServiceName);
     1877                rc = HGCMService::LoadService(pMsg->pszServiceLibrary, pMsg->pszServiceName);
    18641878            } break;
    18651879
    … …  
    18731887                /* Resolve the service name to the pointer to service instance. */
    18741888                HGCMService *pService;
    1875                 rc = HGCMService::ResolveService (&pService, pMsg->pszServiceName);
     1889                rc = HGCMService::ResolveService(&pService, pMsg->pszServiceName);
    18761890
    18771891                if (RT_SUCCESS(rc))
    18781892                {
    1879                     rc = pService->HostCall (pMsg->u32Function, pMsg->cParms, pMsg->paParms);
    1880 
    1881                     pService->ReleaseService ();
     1893                    rc = pService->HostCall(pMsg->u32Function, pMsg->cParms, pMsg->paParms);
     1894
     1895                    pService->ReleaseService();
    18821896                }
    18831897            } break;
    … …  
    18921906                /* Resolve the service name to the pointer to service instance. */
    18931907                HGCMService *pService;
    1894                 rc = HGCMService::ResolveService (&pService, pMsg->pszServiceName);
     1908                rc = HGCMService::ResolveService(&pService, pMsg->pszServiceName);
    18951909                if (RT_SUCCESS(rc))
    18961910                {
    1897                     rc = pService->HandleAcquired ();
     1911                    rc = pService->HandleAcquired();
    18981912                    if (RT_SUCCESS(rc))
    18991913                    {
    … …  
    19021916                    else
    19031917                    {
    1904                         pService->ReleaseService ();
     1918                        pService->ReleaseService();
    19051919                    }
    19061920                }
    … …  
    19151929                /* Resolve the service name to the pointer to service instance. */
    19161930
    1917                 rc = pMsg->pService->HandleReleased ();
     1931                rc = pMsg->pService->HandleReleased();
    19181932                if (RT_SUCCESS(rc))
    19191933                {
    1920                     pMsg->pService->ReleaseService ();
     1934                    pMsg->pService->ReleaseService();
    19211935                }
    19221936            } break;
    … …  
    19271941                LogFlowFunc(("HGCM_MSG_RESET\n"));
    19281942
    1929                 HGCMService::Reset ();
     1943                HGCMService::Reset();
    19301944            } break;
    19311945
    … …  
    19361950                LogFlowFunc(("HGCM_MSG_LOADSTATE\n"));
    19371951
    1938                 rc = HGCMService::LoadState (pMsg->pSSM);
     1952                rc = HGCMService::LoadState(pMsg->pSSM);
    19391953            } break;
    19401954
    … …  
    19451959                LogFlowFunc(("HGCM_MSG_SAVESTATE\n"));
    19461960
    1947                 rc = HGCMService::SaveState (pMsg->pSSM);
     1961                rc = HGCMService::SaveState(pMsg->pSSM);
    19481962            } break;
    19491963
    … …  
    19521966                LogFlowFunc(("HGCM_MSG_QUIT\n"));
    19531967
    1954                 HGCMService::UnloadAll ();
     1968                HGCMService::UnloadAll();
    19551969
    19561970                fQuit = true;
    … …  
    19641978
    19651979                /* Allocate the handle data. */
    1966                 HGCMSVCEXTHANDLE handle = (HGCMSVCEXTHANDLE)RTMemAllocZ (sizeof (struct _HGCMSVCEXTHANDLEDATA)
    1967                                                                          + strlen (pMsg->pszServiceName)
    1968                                                                          + sizeof (char));
     1980                HGCMSVCEXTHANDLE handle = (HGCMSVCEXTHANDLE)RTMemAllocZ(sizeof(struct _HGCMSVCEXTHANDLEDATA)
     1981                                                                        + strlen(pMsg->pszServiceName)
     1982                                                                        + sizeof(char));
    19691983
    19701984                if (handle == NULL)
    … …  
    19741988                else
    19751989                {
    1976                     handle->pszServiceName = (char *)((uint8_t *)handle + sizeof (struct _HGCMSVCEXTHANDLEDATA));
    1977                     strcpy (handle->pszServiceName, pMsg->pszServiceName);
     1990                    handle->pszServiceName = (char *)((uint8_t *)handle + sizeof(struct _HGCMSVCEXTHANDLEDATA));
     1991                    strcpy(handle->pszServiceName, pMsg->pszServiceName);
    19781992
    19791993                    HGCMService *pService;
    1980                     rc = HGCMService::ResolveService (&pService, handle->pszServiceName);
     1994                    rc = HGCMService::ResolveService(&pService, handle->pszServiceName);
    19811995
    19821996                    if (RT_SUCCESS(rc))
    19831997                    {
    1984                         pService->RegisterExtension (handle, pMsg->pfnExtension, pMsg->pvExtension);
    1985 
    1986                         pService->ReleaseService ();
     1998                        pService->RegisterExtension(handle, pMsg->pfnExtension, pMsg->pvExtension);
     1999
     2000                        pService->ReleaseService();
    19872001                    }
    19882002
    19892003                    if (RT_FAILURE(rc))
    19902004                    {
    1991                         RTMemFree (handle);
     2005                        RTMemFree(handle);
    19922006                    }
    19932007                    else
    … …  
    20052019
    20062020                HGCMService *pService;
    2007                 rc = HGCMService::ResolveService (&pService, pMsg->handle->pszServiceName);
     2021                rc = HGCMService::ResolveService(&pService, pMsg->handle->pszServiceName);
    20082022
    20092023                if (RT_SUCCESS(rc))
    20102024                {
    2011                     pService->UnregisterExtension (pMsg->handle);
    2012 
    2013                     pService->ReleaseService ();
    2014                 }
    2015 
    2016                 RTMemFree (pMsg->handle);
     2025                    pService->UnregisterExtension(pMsg->handle);
     2026
     2027                    pService->ReleaseService();
     2028                }
     2029
     2030                RTMemFree(pMsg->handle);
    20172031            } break;
    20182032
    … …  
    20252039
    20262040        /* Complete the message processing. */
    2027         hgcmMsgComplete (pMsgCore, rc);
     2041        hgcmMsgComplete(pMsgCore, rc);
    20282042
    20292043        LogFlowFunc(("message processed %Rrc\n", rc));
    … …  
    20532067 * @return VBox rc.
    20542068 */
    2055 int HGCMHostLoad (const char *pszServiceLibrary,
    2056                   const char *pszServiceName)
     2069int HGCMHostLoad(const char *pszServiceLibrary,
     2070                 const char *pszServiceName)
    20572071{
    20582072    LogFlowFunc(("lib = %s, name = %s\n", pszServiceLibrary, pszServiceName));
    … …  
    20662080    HGCMMSGHANDLE hMsg = 0;
    20672081
    2068     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_LOAD, hgcmMainMessageAlloc);
     2082    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_LOAD, hgcmMainMessageAlloc);
    20692083
    20702084    if (RT_SUCCESS(rc))
    20712085    {
    20722086        /* Initialize the message. Since the message is synchronous, use the supplied pointers. */
    2073         HGCMMsgMainLoad *pMsg = (HGCMMsgMainLoad *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2087        HGCMMsgMainLoad *pMsg = (HGCMMsgMainLoad *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    20742088        AssertRelease(pMsg);
    20752089
    … …  
    20772091        pMsg->pszServiceName    = pszServiceName;
    20782092
    2079         hgcmObjDereference (pMsg);
    2080 
    2081         rc = hgcmMsgSend (hMsg);
     2093        hgcmObjDereference(pMsg);
     2094
     2095        rc = hgcmMsgSend(hMsg);
    20822096    }
    20832097
    … …  
    20942108 * @return VBox rc.
    20952109 */
    2096 int HGCMHostRegisterServiceExtension (HGCMSVCEXTHANDLE *pHandle,
    2097                                       const char *pszServiceName,
    2098                                       PFNHGCMSVCEXT pfnExtension,
    2099                                       void *pvExtension)
     2110int HGCMHostRegisterServiceExtension(HGCMSVCEXTHANDLE *pHandle,
     2111                                     const char *pszServiceName,
     2112                                     PFNHGCMSVCEXT pfnExtension,
     2113                                     void *pvExtension)
    21002114{
    21012115    LogFlowFunc(("pHandle = %p, name = %s, pfn = %p, rv = %p\n", pHandle, pszServiceName, pfnExtension, pvExtension));
    … …  
    21092123    HGCMMSGHANDLE hMsg = 0;
    21102124
    2111     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_REGEXT, hgcmMainMessageAlloc);
     2125    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_REGEXT, hgcmMainMessageAlloc);
    21122126
    21132127    if (RT_SUCCESS(rc))
    21142128    {
    21152129        /* Initialize the message. Since the message is synchronous, use the supplied pointers. */
    2116         HGCMMsgMainRegisterExtension *pMsg = (HGCMMsgMainRegisterExtension *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2130        HGCMMsgMainRegisterExtension *pMsg = (HGCMMsgMainRegisterExtension *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    21172131        AssertRelease(pMsg);
    21182132
    … …  
    21222136        pMsg->pvExtension    = pvExtension;
    21232137
    2124         hgcmObjDereference (pMsg);
    2125 
    2126         rc = hgcmMsgSend (hMsg);
     2138        hgcmObjDereference(pMsg);
     2139
     2140        rc = hgcmMsgSend(hMsg);
    21272141    }
    21282142
    … …  
    21312145}
    21322146
    2133 void HGCMHostUnregisterServiceExtension (HGCMSVCEXTHANDLE handle)
     2147void HGCMHostUnregisterServiceExtension(HGCMSVCEXTHANDLE handle)
    21342148{
    21352149    LogFlowFunc(("handle = %p\n", handle));
    … …  
    21382152    HGCMMSGHANDLE hMsg = 0;
    21392153
    2140     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_UNREGEXT, hgcmMainMessageAlloc);
     2154    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_UNREGEXT, hgcmMainMessageAlloc);
    21412155
    21422156    if (RT_SUCCESS(rc))
    21432157    {
    21442158        /* Initialize the message. */
    2145         HGCMMsgMainUnregisterExtension *pMsg = (HGCMMsgMainUnregisterExtension *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2159        HGCMMsgMainUnregisterExtension *pMsg = (HGCMMsgMainUnregisterExtension *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    21462160        AssertRelease(pMsg);
    21472161
    21482162        pMsg->handle = handle;
    21492163
    2150         hgcmObjDereference (pMsg);
    2151 
    2152         rc = hgcmMsgSend (hMsg);
     2164        hgcmObjDereference(pMsg);
     2165
     2166        rc = hgcmMsgSend(hMsg);
    21532167    }
    21542168
    … …  
    21652179 * @return VBox rc.
    21662180 */
    2167 int HGCMGuestConnect (PPDMIHGCMPORT pHGCMPort,
    2168                       PVBOXHGCMCMD pCmd,
    2169                       const char *pszServiceName,
    2170                       uint32_t *pu32ClientId)
     2181int HGCMGuestConnect(PPDMIHGCMPORT pHGCMPort,
     2182                     PVBOXHGCMCMD pCmd,
     2183                     const char *pszServiceName,
     2184                     uint32_t *pu32ClientId)
    21712185{
    21722186    LogFlowFunc(("pHGCMPort = %p, pCmd = %p, name = %s, pu32ClientId = %p\n",
    … …  
    21812195    HGCMMSGHANDLE hMsg = 0;
    21822196
    2183     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_CONNECT, hgcmMainMessageAlloc);
     2197    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_CONNECT, hgcmMainMessageAlloc);
    21842198
    21852199    if (RT_SUCCESS(rc))
    … …  
    21892203         * use the supplied pointers.
    21902204         */
    2191         HGCMMsgMainConnect *pMsg = (HGCMMsgMainConnect *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2205        HGCMMsgMainConnect *pMsg = (HGCMMsgMainConnect *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    21922206        AssertRelease(pMsg);
    21932207
    … …  
    21972211        pMsg->pu32ClientId   = pu32ClientId;
    21982212
    2199         hgcmObjDereference (pMsg);
    2200 
    2201         rc = hgcmMsgPost (hMsg, hgcmMsgCompletionCallback);
     2213        hgcmObjDereference(pMsg);
     2214
     2215        rc = hgcmMsgPost(hMsg, hgcmMsgCompletionCallback);
    22022216    }
    22032217
    … …  
    22132227 * @return VBox rc.
    22142228 */
    2215 int HGCMGuestDisconnect (PPDMIHGCMPORT pHGCMPort,
    2216                          PVBOXHGCMCMD pCmd,
    2217                          uint32_t u32ClientId)
     2229int HGCMGuestDisconnect(PPDMIHGCMPORT pHGCMPort,
     2230                        PVBOXHGCMCMD pCmd,
     2231                        uint32_t u32ClientId)
    22182232{
    22192233    LogFlowFunc(("pHGCMPort = %p, pCmd = %p, u32ClientId = %d\n",
    … …  
    22282242    HGCMMSGHANDLE hMsg = 0;
    22292243
    2230     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_DISCONNECT, hgcmMainMessageAlloc);
     2244    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_DISCONNECT, hgcmMainMessageAlloc);
    22312245
    22322246    if (RT_SUCCESS(rc))
    22332247    {
    22342248        /* Initialize the message. */
    2235         HGCMMsgMainDisconnect *pMsg = (HGCMMsgMainDisconnect *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2249        HGCMMsgMainDisconnect *pMsg = (HGCMMsgMainDisconnect *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    22362250        AssertRelease(pMsg);
    22372251
    … …  
    22402254        pMsg->u32ClientId = u32ClientId;
    22412255
    2242         hgcmObjDereference (pMsg);
    2243 
    2244         rc = hgcmMsgPost (hMsg, hgcmMsgCompletionCallback);
     2256        hgcmObjDereference(pMsg);
     2257
     2258        rc = hgcmMsgPost(hMsg, hgcmMsgCompletionCallback);
    22452259    }
    22462260
    … …  
    22552269 * @return VBox rc.
    22562270 */
    2257 static int hgcmHostLoadSaveState (PSSMHANDLE pSSM,
    2258                                   uint32_t u32MsgId)
     2271static int hgcmHostLoadSaveState(PSSMHANDLE pSSM,
     2272                                 uint32_t u32MsgId)
    22592273{
    22602274    LogFlowFunc(("pSSM = %p, u32MsgId = %d\n", pSSM, u32MsgId));
    … …  
    22622276    HGCMMSGHANDLE hMsg = 0;
    22632277
    2264     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, u32MsgId, hgcmMainMessageAlloc);
     2278    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, u32MsgId, hgcmMainMessageAlloc);
    22652279
    22662280    if (RT_SUCCESS(rc))
    22672281    {
    2268         HGCMMsgMainLoadSaveState *pMsg = (HGCMMsgMainLoadSaveState *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2282        HGCMMsgMainLoadSaveState *pMsg = (HGCMMsgMainLoadSaveState *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    22692283        AssertRelease(pMsg);
    22702284
    22712285        pMsg->pSSM = pSSM;
    22722286
    2273         hgcmObjDereference (pMsg);
    2274 
    2275         rc = hgcmMsgSend (hMsg);
     2287        hgcmObjDereference(pMsg);
     2288
     2289        rc = hgcmMsgSend(hMsg);
    22762290    }
    22772291
    … …  
    22852299 * @return VBox rc.
    22862300 */
    2287 int HGCMHostSaveState (PSSMHANDLE pSSM)
    2288 {
    2289     return hgcmHostLoadSaveState (pSSM, HGCM_MSG_SAVESTATE);
     2301int HGCMHostSaveState(PSSMHANDLE pSSM)
     2302{
     2303    return hgcmHostLoadSaveState(pSSM, HGCM_MSG_SAVESTATE);
    22902304}
    22912305
    … …  
    22952309 * @return VBox rc.
    22962310 */
    2297 int HGCMHostLoadState (PSSMHANDLE pSSM)
    2298 {
    2299     return hgcmHostLoadSaveState (pSSM, HGCM_MSG_LOADSTATE);
     2311int HGCMHostLoadState(PSSMHANDLE pSSM)
     2312{
     2313    return hgcmHostLoadSaveState(pSSM, HGCM_MSG_LOADSTATE);
    23002314}
    23012315
    … …  
    23102324 * @return VBox rc.
    23112325 */
    2312 int HGCMGuestCall (PPDMIHGCMPORT pHGCMPort,
    2313                    PVBOXHGCMCMD pCmd,
    2314                    uint32_t u32ClientId,
    2315                    uint32_t u32Function,
    2316                    uint32_t cParms,
    2317                    VBOXHGCMSVCPARM *paParms)
     2326int HGCMGuestCall(PPDMIHGCMPORT pHGCMPort,
     2327                  PVBOXHGCMCMD pCmd,
     2328                  uint32_t u32ClientId,
     2329                  uint32_t u32Function,
     2330                  uint32_t cParms,
     2331                  VBOXHGCMSVCPARM *paParms)
    23182332{
    23192333    LogFlowFunc(("pHGCMPort = %p, pCmd = %p, u32ClientId = %d, u32Function = %d, cParms = %d, paParms = %p\n",
    … …  
    23282342
    23292343    /* Resolve the client handle to the client instance pointer. */
    2330     HGCMClient *pClient = (HGCMClient *)hgcmObjReference (u32ClientId, HGCMOBJ_CLIENT);
     2344    HGCMClient *pClient = (HGCMClient *)hgcmObjReference(u32ClientId, HGCMOBJ_CLIENT);
    23312345
    23322346    if (pClient)
    … …  
    23352349
    23362350        /* Forward the message to the service thread. */
    2337         rc = pClient->pService->GuestCall (pHGCMPort, pCmd, u32ClientId, u32Function, cParms, paParms);
    2338 
    2339         hgcmObjDereference (pClient);
     2351        rc = pClient->pService->GuestCall(pHGCMPort, pCmd, u32ClientId, u32Function, cParms, paParms);
     2352
     2353        hgcmObjDereference(pClient);
    23402354    }
    23412355
    … …  
    23522366 * @return VBox rc.
    23532367 */
    2354 int HGCMHostCall (const char *pszServiceName,
    2355                   uint32_t u32Function,
    2356                   uint32_t cParms,
    2357                   VBOXHGCMSVCPARM *paParms)
     2368int HGCMHostCall(const char *pszServiceName,
     2369                 uint32_t u32Function,
     2370                 uint32_t cParms,
     2371                 VBOXHGCMSVCPARM *paParms)
    23582372{
    23592373    LogFlowFunc(("name = %s, u32Function = %d, cParms = %d, paParms = %p\n",
    … …  
    23732387     * other non-time-critical functions.
    23742388     */
    2375     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_HOSTCALL, hgcmMainMessageAlloc);
     2389    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_HOSTCALL, hgcmMainMessageAlloc);
    23762390
    23772391    if (RT_SUCCESS(rc))
    23782392    {
    2379         HGCMMsgMainHostCall *pMsg = (HGCMMsgMainHostCall *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2393        HGCMMsgMainHostCall *pMsg = (HGCMMsgMainHostCall *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    23802394        AssertRelease(pMsg);
    23812395
    … …  
    23852399        pMsg->paParms        = paParms;
    23862400
    2387         hgcmObjDereference (pMsg);
    2388 
    2389         rc = hgcmMsgSend (hMsg);
     2401        hgcmObjDereference(pMsg);
     2402
     2403        rc = hgcmMsgSend(hMsg);
    23902404    }
    23912405
    … …  
    23952409
    23962410#ifdef VBOX_WITH_CRHGSMI
    2397 int HGCMHostSvcHandleCreate (const char *pszServiceName, HGCMCVSHANDLE * phSvc)
     2411int HGCMHostSvcHandleCreate(const char *pszServiceName, HGCMCVSHANDLE * phSvc)
    23982412{
    23992413    LogFlowFunc(("name = %s\n", pszServiceName));
    … …  
    24172431     * other non-time-critical functions.
    24182432     */
    2419     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_SVCAQUIRE, hgcmMainMessageAlloc);
     2433    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_SVCAQUIRE, hgcmMainMessageAlloc);
    24202434
    24212435    if (RT_SUCCESS(rc))
    24222436    {
    2423         HGCMMsgMainSvcAcquire *pMsg = (HGCMMsgMainSvcAcquire *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2437        HGCMMsgMainSvcAcquire *pMsg = (HGCMMsgMainSvcAcquire *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    24242438        AssertRelease(pMsg);
    24252439
    … …  
    24272441        pMsg->pService = NULL;
    24282442
    2429         rc = hgcmMsgSend (hMsg);
     2443        rc = hgcmMsgSend(hMsg);
    24302444        if (RT_SUCCESS(rc))
    24312445        {
    … …  
    24342448        }
    24352449
    2436         hgcmObjDereference (pMsg);
     2450        hgcmObjDereference(pMsg);
    24372451    }
    24382452
    … …  
    24412455}
    24422456
    2443 int HGCMHostSvcHandleDestroy (HGCMCVSHANDLE hSvc)
     2457int HGCMHostSvcHandleDestroy(HGCMCVSHANDLE hSvc)
    24442458{
    24452459    LogFlowFunc(("hSvc = %p\n", hSvc));
    … …  
    24582472     * other non-time-critical functions.
    24592473     */
    2460     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_SVCRELEASE, hgcmMainMessageAlloc);
     2474    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_SVCRELEASE, hgcmMainMessageAlloc);
    24612475
    24622476    if (RT_SUCCESS(rc))
    24632477    {
    2464         HGCMMsgMainSvcRelease *pMsg = (HGCMMsgMainSvcRelease *)hgcmObjReference (hMsg, HGCMOBJ_MSG);
     2478        HGCMMsgMainSvcRelease *pMsg = (HGCMMsgMainSvcRelease *)hgcmObjReference(hMsg, HGCMOBJ_MSG);
    24652479        AssertRelease(pMsg);
    24662480
    24672481        pMsg->pService = (HGCMService *)hSvc;
    24682482
    2469         hgcmObjDereference (pMsg);
    2470 
    2471         rc = hgcmMsgSend (hMsg);
     2483        hgcmObjDereference(pMsg);
     2484
     2485        rc = hgcmMsgSend(hMsg);
    24722486    }
    24732487
    … …  
    24762490}
    24772491
    2478 int HGCMHostFastCallAsync (HGCMCVSHANDLE hSvc, uint32_t function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion, void *pvCompletion)
     2492int HGCMHostFastCallAsync(HGCMCVSHANDLE hSvc, uint32_t function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion,
     2493                          void *pvCompletion)
    24792494{
    24802495    LogFlowFunc(("hSvc = %p, u32Function = %d, pParm = %p\n",
    … …  
    24872502
    24882503    HGCMService *pService = (HGCMService *)hSvc;
    2489     int rc = pService->HostFastCallAsync (function, pParm, pfnCompletion, pvCompletion);
     2504    int rc = pService->HostFastCallAsync(function, pParm, pfnCompletion, pvCompletion);
    24902505
    24912506    LogFlowFunc(("rc = %Rrc\n", rc));
    … …  
    24942509#endif
    24952510
    2496 int HGCMHostReset (void)
     2511int HGCMHostReset(void)
    24972512{
    24982513    LogFlowFunc(("\n"));
    … …  
    25032518    HGCMMSGHANDLE hMsg = 0;
    25042519
    2505     int rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_RESET, hgcmMainMessageAlloc);
     2520    int rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_RESET, hgcmMainMessageAlloc);
    25062521
    25072522    if (RT_SUCCESS(rc))
    25082523    {
    2509         rc = hgcmMsgSend (hMsg);
     2524        rc = hgcmMsgSend(hMsg);
    25102525    }
    25112526
    … …  
    25142529}
    25152530
    2516 int HGCMHostInit (void)
     2531int HGCMHostInit(void)
    25172532{
    25182533    LogFlowFunc(("\n"));
    25192534
    2520     int rc = hgcmThreadInit ();
     2535    int rc = hgcmThreadInit();
    25212536
    25222537    if (RT_SUCCESS(rc))
    … …  
    25262541         */
    25272542
    2528         rc = hgcmThreadCreate (&g_hgcmThread, "MainHGCMthread", hgcmThread, NULL);
     2543        rc = hgcmThreadCreate(&g_hgcmThread, "MainHGCMthread", hgcmThread, NULL);
    25292544
    25302545        if (RT_FAILURE(rc))
    … …  
    25382553}
    25392554
    2540 int HGCMHostShutdown (void)
     2555int HGCMHostShutdown(void)
    25412556{
    25422557    LogFlowFunc(("\n"));
    … …  
    25462561     */
    25472562
    2548     int rc = HGCMHostReset ();
     2563    int rc = HGCMHostReset();
    25492564
    25502565    if (RT_SUCCESS(rc))
    … …  
    25532568        HGCMMSGHANDLE hMsg = 0;
    25542569
    2555         rc = hgcmMsgAlloc (g_hgcmThread, &hMsg, HGCM_MSG_QUIT, hgcmMainMessageAlloc);
     2570        rc = hgcmMsgAlloc(g_hgcmThread, &hMsg, HGCM_MSG_QUIT, hgcmMainMessageAlloc);
    25562571
    25572572        if (RT_SUCCESS(rc))
    25582573        {
    2559             rc = hgcmMsgSend (hMsg);
     2574            rc = hgcmMsgSend(hMsg);
    25602575
    25612576            if (RT_SUCCESS(rc))
    25622577            {
    25632578                /* Wait for the thread termination. */
    2564                 hgcmThreadWait (g_hgcmThread);
     2579                hgcmThreadWait(g_hgcmThread);
    25652580                g_hgcmThread = 0;
    25662581
    2567                 hgcmThreadUninit ();
     2582                hgcmThreadUninit();
    25682583            }
    25692584        }
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