VirtualBox

Changeset 51092 in vbox for trunk/src


Ignore:
Timestamp:
Apr 16, 2014 5:57:25 PM (11 years ago)
Author:
vboxsync
Message:

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

Location:
trunk/src/VBox/Main
Files:
44 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/include/MachineDebuggerImpl.h

    r46423 r51092  
    2121#define ____H_MACHINEDEBUGGER
    2222
    23 #include "VirtualBoxBase.h"
     23#include "MachineDebuggerWrap.h"
    2424#include <iprt/log.h>
    2525#include <VBox/vmm/em.h>
    … …  
    2828
    2929class ATL_NO_VTABLE MachineDebugger :
    30     public VirtualBoxBase,
    31     VBOX_SCRIPTABLE_IMPL(IMachineDebugger)
     30    public MachineDebuggerWrap
    3231{
     32
    3333public:
    34 
    35     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (MachineDebugger, IMachineDebugger)
    36 
    37     DECLARE_NOT_AGGREGATABLE (MachineDebugger)
    38 
    39     DECLARE_PROTECT_FINAL_CONSTRUCT()
    40 
    41     BEGIN_COM_MAP(MachineDebugger)
    42         VBOX_DEFAULT_INTERFACE_ENTRIES (IMachineDebugger)
    43     END_COM_MAP()
    4434
    4535    DECLARE_EMPTY_CTOR_DTOR (MachineDebugger)
    … …  
    5242    void uninit();
    5343
    54     // IMachineDebugger properties
    55     STDMETHOD(COMGETTER(SingleStep))(BOOL *a_pfEnabled);
    56     STDMETHOD(COMSETTER(SingleStep))(BOOL a_fEnable);
    57     STDMETHOD(COMGETTER(RecompileUser))(BOOL *a_pfEnabled);
    58     STDMETHOD(COMSETTER(RecompileUser))(BOOL a_fEnable);
    59     STDMETHOD(COMGETTER(RecompileSupervisor))(BOOL *a_pfEnabled);
    60     STDMETHOD(COMSETTER(RecompileSupervisor))(BOOL a_fEnable);
    61     STDMETHOD(COMGETTER(ExecuteAllInIEM))(BOOL *a_pfEnabled);
    62     STDMETHOD(COMSETTER(ExecuteAllInIEM))(BOOL a_fEnable);
    63     STDMETHOD(COMGETTER(PATMEnabled))(BOOL *a_pfEnabled);
    64     STDMETHOD(COMSETTER(PATMEnabled))(BOOL a_fEnable);
    65     STDMETHOD(COMGETTER(CSAMEnabled))(BOOL *a_pfEnabled);
    66     STDMETHOD(COMSETTER(CSAMEnabled))(BOOL a_fEnable);
    67     STDMETHOD(COMGETTER(LogEnabled))(BOOL *a_pfEnabled);
    68     STDMETHOD(COMSETTER(LogEnabled))(BOOL a_fEnable);
    69     STDMETHOD(COMGETTER(LogDbgFlags))(BSTR *a_pbstrSettings);
    70     STDMETHOD(COMGETTER(LogDbgGroups))(BSTR *a_pbstrSettings);
    71     STDMETHOD(COMGETTER(LogDbgDestinations))(BSTR *a_pbstrSettings);
    72     STDMETHOD(COMGETTER(LogRelFlags))(BSTR *a_pbstrSettings);
    73     STDMETHOD(COMGETTER(LogRelGroups))(BSTR *a_pbstrSettings);
    74     STDMETHOD(COMGETTER(LogRelDestinations))(BSTR *a_pbstrSettings);
    75     STDMETHOD(COMGETTER(HWVirtExEnabled))(BOOL *a_pfEnabled);
    76     STDMETHOD(COMGETTER(HWVirtExNestedPagingEnabled))(BOOL *a_pfEnabled);
    77     STDMETHOD(COMGETTER(HWVirtExVPIDEnabled))(BOOL *a_pfEnabled);
    78     STDMETHOD(COMGETTER(HWVirtExUXEnabled))(BOOL *a_pfEnabled);
    79     STDMETHOD(COMGETTER(PAEEnabled))(BOOL *a_pfEnabled);
    80     STDMETHOD(COMGETTER(OSName))(BSTR *a_pbstrName);
    81     STDMETHOD(COMGETTER(OSVersion))(BSTR *a_pbstrVersion);
    82     STDMETHOD(COMGETTER(VirtualTimeRate))(ULONG *a_puPct);
    83     STDMETHOD(COMSETTER(VirtualTimeRate))(ULONG a_uPct);
    84     STDMETHOD(COMGETTER(VM))(LONG64 *a_u64Vm);
    85 
    86     // IMachineDebugger methods
    87     STDMETHOD(DumpGuestCore)(IN_BSTR a_bstrFilename, IN_BSTR a_bstrCompression);
    88     STDMETHOD(DumpHostProcessCore)(IN_BSTR a_bstrFilename, IN_BSTR a_bstrCompression);
    89     STDMETHOD(Info)(IN_BSTR a_bstrName, IN_BSTR a_bstrArgs, BSTR *a_bstrInfo);
    90     STDMETHOD(InjectNMI)();
    91     STDMETHOD(ModifyLogFlags)(IN_BSTR a_bstrSettings);
    92     STDMETHOD(ModifyLogGroups)(IN_BSTR a_bstrSettings);
    93     STDMETHOD(ModifyLogDestinations)(IN_BSTR a_bstrSettings);
    94     STDMETHOD(ReadPhysicalMemory)(LONG64 a_Address, ULONG a_cbRead, ComSafeArrayOut(BYTE, a_abData));
    95     STDMETHOD(WritePhysicalMemory)(LONG64 a_Address, ULONG a_cbRead, ComSafeArrayIn(BYTE, a_abData));
    96     STDMETHOD(ReadVirtualMemory)(ULONG a_idCpu, LONG64 a_Address, ULONG a_cbRead, ComSafeArrayOut(BYTE, a_abData));
    97     STDMETHOD(WriteVirtualMemory)(ULONG a_idCpu, LONG64 a_Address, ULONG a_cbRead, ComSafeArrayIn(BYTE, a_abData));
    98     STDMETHOD(DetectOS)(BSTR *a_pbstrName);
    99     STDMETHOD(GetRegister)(ULONG a_idCpu, IN_BSTR a_bstrName, BSTR *a_pbstrValue);
    100     STDMETHOD(GetRegisters)(ULONG a_idCpu, ComSafeArrayOut(BSTR, a_bstrNames), ComSafeArrayOut(BSTR, a_bstrValues));
    101     STDMETHOD(SetRegister)(ULONG a_idCpu, IN_BSTR a_bstrName, IN_BSTR a_bstrValue);
    102     STDMETHOD(SetRegisters)(ULONG a_idCpu, ComSafeArrayIn(IN_BSTR, a_bstrNames), ComSafeArrayIn(IN_BSTR, a_bstrValues));
    103     STDMETHOD(DumpGuestStack)(ULONG a_idCpu, BSTR *a_pbstrStack);
    104     STDMETHOD(ResetStats)(IN_BSTR aPattern);
    105     STDMETHOD(DumpStats)(IN_BSTR aPattern);
    106     STDMETHOD(GetStats)(IN_BSTR aPattern, BOOL aWithDescriptions, BSTR *aStats);
    107 
    108 
    10944    // "public-private methods"
    110     void flushQueuedSettings();
     45    void i_flushQueuedSettings();
    11146
    11247private:
     48
     49    // wrapped IMachineDeugger properties
     50    HRESULT getSingleStep(BOOL *aSingleStep);
     51    HRESULT setSingleStep(BOOL aSingleStep);
     52    HRESULT getRecompileUser(BOOL *aRecompileUser);
     53    HRESULT setRecompileUser(BOOL aRecompileUser);
     54    HRESULT getRecompileSupervisor(BOOL *aRecompileSupervisor);
     55    HRESULT setRecompileSupervisor(BOOL aRecompileSupervisor);
     56    HRESULT getExecuteAllInIEM(BOOL *aExecuteAllInIEM);
     57    HRESULT setExecuteAllInIEM(BOOL aExecuteAllInIEM);
     58    HRESULT getPATMEnabled(BOOL *aPATMEnabled);
     59    HRESULT setPATMEnabled(BOOL aPATMEnabled);
     60    HRESULT getCSAMEnabled(BOOL *aCSAMEnabled);
     61    HRESULT setCSAMEnabled(BOOL aCSAMEnabled);
     62    HRESULT getLogEnabled(BOOL *aLogEnabled);
     63    HRESULT setLogEnabled(BOOL aLogEnabled);
     64    HRESULT getLogDbgFlags(com::Utf8Str &aLogDbgFlags);
     65    HRESULT getLogDbgGroups(com::Utf8Str &aLogDbgGroups);
     66    HRESULT getLogDbgDestinations(com::Utf8Str &aLogDbgDestinations);
     67    HRESULT getLogRelFlags(com::Utf8Str &aLogRelFlags);
     68    HRESULT getLogRelGroups(com::Utf8Str &aLogRelGroups);
     69    HRESULT getLogRelDestinations(com::Utf8Str &aLogRelDestinations);
     70    HRESULT getHWVirtExEnabled(BOOL *aHWVirtExEnabled);
     71    HRESULT getHWVirtExNestedPagingEnabled(BOOL *aHWVirtExNestedPagingEnabled);
     72    HRESULT getHWVirtExVPIDEnabled(BOOL *aHWVirtExVPIDEnabled);
     73    HRESULT getHWVirtExUXEnabled(BOOL *aHWVirtExUXEnabled);
     74    HRESULT getOSName(com::Utf8Str &aOSName);
     75    HRESULT getOSVersion(com::Utf8Str &aOSVersion);
     76    HRESULT getPAEEnabled(BOOL *aPAEEnabled);
     77    HRESULT getVirtualTimeRate(ULONG *aVirtualTimeRate);
     78    HRESULT setVirtualTimeRate(ULONG aVirtualTimeRate);
     79    HRESULT getVM(LONG64 *aVM);
     80
     81    // wrapped IMachineDeugger properties
     82    HRESULT dumpGuestCore(const com::Utf8Str &aFilename,
     83                          const com::Utf8Str &aCompression);
     84    HRESULT dumpHostProcessCore(const com::Utf8Str &aFilename,
     85                                const com::Utf8Str &aCompression);
     86    HRESULT info(const com::Utf8Str &aName,
     87                 const com::Utf8Str &aArgs,
     88                 com::Utf8Str &aInfo);
     89    HRESULT injectNMI();
     90    HRESULT modifyLogGroups(const com::Utf8Str &aSettings);
     91    HRESULT modifyLogFlags(const com::Utf8Str &aSettings);
     92    HRESULT modifyLogDestinations(const com::Utf8Str &aSettings);
     93    HRESULT readPhysicalMemory(LONG64 aAddress,
     94                               ULONG aSize,
     95                               std::vector<BYTE> &aBytes);
     96    HRESULT writePhysicalMemory(LONG64 aAddress,
     97                                ULONG aSize,
     98                                const std::vector<BYTE> &aBytes);
     99    HRESULT readVirtualMemory(ULONG aCpuId,
     100                              LONG64 aAddress,
     101                              ULONG aSize,
     102                              std::vector<BYTE> &aBytes);
     103    HRESULT writeVirtualMemory(ULONG aCpuId,
     104                               LONG64 aAddress,
     105                               ULONG aSize,
     106                               const std::vector<BYTE> &aBytes);
     107    HRESULT detectOS(com::Utf8Str &aOs);
     108    HRESULT getRegister(ULONG aCpuId,
     109                        const com::Utf8Str &aName,
     110                        com::Utf8Str &aValue);
     111    HRESULT getRegisters(ULONG aCpuId,
     112                         std::vector<com::Utf8Str> &aNames,
     113                         std::vector<com::Utf8Str> &aValues);
     114    HRESULT setRegister(ULONG aCpuId,
     115                        const com::Utf8Str &aName,
     116                        const com::Utf8Str &aValue);
     117    HRESULT setRegisters(ULONG aCpuId,
     118                         const std::vector<com::Utf8Str> &aNames,
     119                         const std::vector<com::Utf8Str> &aValues);
     120    HRESULT dumpGuestStack(ULONG aCpuId,
     121                           com::Utf8Str &aStack);
     122    HRESULT resetStats(const com::Utf8Str &aPattern);
     123    HRESULT dumpStats(const com::Utf8Str &aPattern);
     124    HRESULT getStats(const com::Utf8Str &aPattern,
     125                     BOOL aWithDescriptions,
     126                     com::Utf8Str &aStats);
     127
    113128    // private methods
    114     bool queueSettings() const;
    115     HRESULT getEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL *pfEnforced);
    116     HRESULT setEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL fEnforce);
     129    bool i_queueSettings() const;
     130    HRESULT i_getEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL *pfEnforced);
     131    HRESULT i_setEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL fEnforce);
    117132
    118133    /** RTLogGetFlags, RTLogGetGroupSettings and RTLogGetDestinations function. */
    … …  
    120135    /** Function pointer.  */
    121136    typedef FNLOGGETSTR *PFNLOGGETSTR;
    122     HRESULT logStringProps(PRTLOGGER pLogger, PFNLOGGETSTR pfnLogGetStr, const char *pszLogGetStr, BSTR *a_bstrSettings);
     137    HRESULT i_logStringProps(PRTLOGGER pLogger, PFNLOGGETSTR pfnLogGetStr, const char *pszLogGetStr, Utf8Str aSettings);
    123138
    124139    Console * const mParent;

  • trunk/src/VBox/Main/src-all/DisplayUtils.cpp

    r44529 r51092  
    2323#include <VBox/VBoxVideo.h>
    2424
    25 int readSavedDisplayScreenshot(const Utf8Str &strStateFilePath, uint32_t u32Type, uint8_t **ppu8Data, uint32_t *pcbData, uint32_t *pu32Width, uint32_t *pu32Height)
     25int readSavedDisplayScreenshot(const Utf8Str &strStateFilePath, uint32_t u32Type, uint8_t **ppu8Data, uint32_t *pcbData,
     26                               uint32_t *pu32Width, uint32_t *pu32Height)
    2627{
    2728    LogFlowFunc(("u32Type = %d [%s]\n", u32Type, strStateFilePath.c_str()));

  • trunk/src/VBox/Main/src-all/ExtPackUtil.cpp

    r48778 r51092  
    11231123 *                              stream is at an end.  Optional.
    11241124 */
    1125 int VBoxExtPackOpenTarFss(RTFILE hTarballFile, char *pszError, size_t cbError, PRTVFSFSSTREAM phTarFss, PRTMANIFEST phFileManifest)
     1125int VBoxExtPackOpenTarFss(RTFILE hTarballFile, char *pszError, size_t cbError, PRTVFSFSSTREAM phTarFss,
     1126                          PRTMANIFEST phFileManifest)
    11261127{
    11271128    Assert(cbError > 0);
    … …  
    11471148    {
    11481149        RTVFSIOSTREAM hPtIos;
    1149         rc = RTManifestEntryAddPassthruIoStream(hFileManifest, hTarballIos, "extpack", RTMANIFEST_ATTR_SHA256, true /*read*/, &hPtIos);
     1150        rc = RTManifestEntryAddPassthruIoStream(hFileManifest, hTarballIos, "extpack", RTMANIFEST_ATTR_SHA256,
     1151                                                true /*read*/, &hPtIos);
    11501152        if (RT_SUCCESS(rc))
    11511153        {
    … …  
    13321334        {
    13331335            if (hXmlFile == NIL_RTVFSFILE)
    1334                 rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing", VBOX_EXTPACK_DESCRIPTION_NAME);
     1336                rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing",
     1337                                            VBOX_EXTPACK_DESCRIPTION_NAME);
    13351338            if (hManifestFile == NIL_RTVFSFILE)
    1336                 rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing", VBOX_EXTPACK_MANIFEST_NAME);
     1339                rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing",
     1340                                            VBOX_EXTPACK_MANIFEST_NAME);
    13371341            if (hSignatureFile == NIL_RTVFSFILE)
    1338                 rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing", VBOX_EXTPACK_SIGNATURE_NAME);
     1342                rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing",
     1343                                            VBOX_EXTPACK_SIGNATURE_NAME);
    13391344        }
    13401345

  • trunk/src/VBox/Main/src-all/ProgressImpl.cpp

    r50952 r51092  
    159159            uint64_t ullTimeRemaining = ullTimeTotal - ullTimeElapsed;
    160160
    161 //          Log(("Progress::GetTimeRemaining: dPercentDone %RI32, ullTimeNow = %RI64, ullTimeElapsed = %RI64, ullTimeTotal = %RI64, ullTimeRemaining = %RI64\n",
     161//          Log(("Progress::GetTimeRemaining: dPercentDone %RI32, ullTimeNow = %RI64, ullTimeElapsed = %RI64,
     162//          ullTimeTotal = %RI64, ullTimeRemaining = %RI64\n",
    162163//          (uint32_t)dPercentDone, ullTimeNow, ullTimeElapsed, ullTimeTotal, ullTimeRemaining));
    163164

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

    r50919 r51092  
    11421142                    if (RT_SUCCESS(rc))
    11431143                    {
    1144                         switch (u32GuestFlags & (VMMDEV_CREDENTIALS_JUDGE_OK | VMMDEV_CREDENTIALS_JUDGE_DENY | VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT))
     1144                        switch (u32GuestFlags & (VMMDEV_CREDENTIALS_JUDGE_OK | VMMDEV_CREDENTIALS_JUDGE_DENY |
     1145                                                 VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT))
    11451146                        {
    11461147                            case VMMDEV_CREDENTIALS_JUDGE_DENY:        guestJudgement = AuthGuestAccessDenied;  break;
    … …  
    12091210    AssertComRCReturn(hrc, VERR_ACCESS_DENIED);
    12101211
    1211     LogFlowFunc(("allowMultiConnection %d, reuseSingleConnection = %d, mcVRDPClients = %d, mu32SingleRDPClientId = %d\n", allowMultiConnection, reuseSingleConnection, mcVRDPClients, mu32SingleRDPClientId));
     1212    LogFlowFunc(("allowMultiConnection %d, reuseSingleConnection = %d, mcVRDPClients = %d, mu32SingleRDPClientId = %d\n",
     1213                 allowMultiConnection, reuseSingleConnection, mcVRDPClients, mu32SingleRDPClientId));
    12121214
    12131215    if (allowMultiConnection == FALSE)
    … …  
    42874289                    {
    42884290                        VMSTATE enmVMState = VMR3GetStateU(ptrVM.rawUVM());
    4289                         if (    enmVMState == VMSTATE_RUNNING    /** @todo LiveMigration: Forbid or deal correctly with the _LS variants */
     4291                        if (    enmVMState == VMSTATE_RUNNING    /** @todo LiveMigration: Forbid or deal
     4292                                                                     correctly with the _LS variants */
    42904293                            ||  enmVMState == VMSTATE_SUSPENDED)
    42914294                        {
    … …  
    67316734                vrc = RTDirCreateFullPath(pszDumpDir, 0700);
    67326735                if (RT_FAILURE(vrc))
    6733                     throw setError(E_FAIL, "Failed to setup CoreDumper. Couldn't create dump directory '%s' (%Rrc)\n", pszDumpDir, vrc);
     6736                    throw setError(E_FAIL, "Failed to setup CoreDumper. Couldn't create dump directory '%s' (%Rrc)\n",
     6737                                   pszDumpDir, vrc);
    67346738            }
    67356739
    … …  
    78987902
    78997903                default:
    7900                     AssertMsgFailed(("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState),  VMR3GetStateName(enmState) ));
     7904                    AssertMsgFailed(("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState),
     7905                                    VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
    79017906                    that->setMachineState(MachineState_Paused);
    79027907                    break;
    … …  
    79377942            AssertMsg(   that->mMachineState == MachineState_LiveSnapshotting
    79387943                      || that->mMachineState == MachineState_Teleporting,
    7939                       ("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState),  VMR3GetStateName(enmState) ));
     7944                      ("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState),
     7945                      VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
    79407946            break;
    79417947
    79427948        case VMSTATE_RUNNING_FT:
    79437949            AssertMsg(that->mMachineState == MachineState_FaultTolerantSyncing,
    7944                       ("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState),  VMR3GetStateName(enmState) ));
     7950                      ("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState),
     7951                      VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
    79457952            break;
    79467953
    … …  
    87028709{
    87038710    LogFlowThisFuncEnter();
    8704     LogFlowThisFunc(("u32ClientId = %d, pDevList=%p, cbDevList = %d, fDescExt = %d\n", u32ClientId, pDevList, cbDevList, fDescExt));
     8711    LogFlowThisFunc(("u32ClientId = %d, pDevList=%p, cbDevList = %d, fDescExt = %d\n",
     8712                     u32ClientId, pDevList, cbDevList, fDescExt));
    87058713
    87068714    AutoCaller autoCaller(this);
    … …  
    90629070                MachineDebugger *machineDebugger = pConsole->getMachineDebugger();
    90639071                if (machineDebugger)
    9064                     machineDebugger->flushQueuedSettings();
     9072                    machineDebugger->i_flushQueuedSettings();
    90659073
    90669074                /*
    … …  
    90839091                            ErrorInfoKeeper eik;
    90849092                            pConsole->setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
    9085                                     N_("The shared folder '%s' could not be set up: %ls.\n"
    9086                                        "The shared folder setup will not be complete. It is recommended to power down the virtual "
    9087                                        "machine and fix the shared folder settings while the machine is not running"),
     9093                                   N_("The shared folder '%s' could not be set up: %ls.\n"
     9094                                      "The shared folder setup will not be complete. It is recommended to power down the virtual "
     9095                                      "machine and fix the shared folder settings while the machine is not running"),
    90889096                                    it->first.c_str(), eik.getText().raw());
    90899097                        }
    … …  
    95139521
    95149522            pTask->mProgress->SetNextOperation(Bstr(tr("Saving the machine state")).raw(),
    9515                                                pTask->ulMemSize);       // operation weight, same as computed when setting up progress object
     9523                                               pTask->ulMemSize);       // operation weight, same as computed
     9524                                                                        // when setting up progress object
    95169525            if (!pTask->bstrSavedStateFile.isEmpty())
    95179526            {

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

    r50996 r51092  
    10261026            else if (   osTypeId == "MacOS107"
    10271027                     || osTypeId == "MacOS107_64")
    1028                 uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 */ /** @todo figure out what is required here. */
     1028                uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 */ /** @todo figure out
     1029                                                                                what is required here. */
    10291030            else if (   osTypeId == "MacOS108"
    10301031                     || osTypeId == "MacOS108_64")
    1031                 uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 */ /** @todo figure out what is required here. */
     1032                uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 */ /** @todo figure out
     1033                                                                                what is required here. */
    10321034            else if (   osTypeId == "MacOS109"
    10331035                     || osTypeId == "MacOS109_64")
    1034                 uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 */ /** @todo figure out what is required here. */
     1036                uMaxIntelFamilyModelStep = RT_MAKE_U32_FROM_U8(1, 23, 6, 7); /* Penryn / X5482 */ /** @todo figure
     1037                                                                                out what is required here. */
    10351038            if (uMaxIntelFamilyModelStep != UINT32_MAX)
    10361039                InsertConfigInteger(pCPUM, "MaxIntelFamilyModelStep", uMaxIntelFamilyModelStep);
    … …  
    11411144#endif
    11421145
    1143             /** @todo Not exactly pretty to check strings; VBOXOSTYPE would be better, but that requires quite a bit of API change in Main. */
     1146            /** @todo Not exactly pretty to check strings; VBOXOSTYPE would be better,
     1147                but that requires quite a bit of API change in Main. */
    11441148            if (    fIOAPIC
    11451149                &&  (   osTypeId == "WindowsNT4"
    … …  
    29022906                    parm.u.pointer.size = sizeof(IConsole *);
    29032907
    2904                     rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SET_CONSOLE, SHCRGL_CPARMS_SET_CONSOLE, &parm);
     2908                    rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SET_CONSOLE,
     2909                                               SHCRGL_CPARMS_SET_CONSOLE, &parm);
    29052910                    if (!RT_SUCCESS(rc))
    29062911                        AssertMsgFailed(("SHCRGL_HOST_FN_SET_CONSOLE failed with %Rrc\n", rc));
    … …  
    32873292                else
    32883293                    InsertConfigString(pNode, pszCFGMValueName, strCFGMValueUtf8);
    3289                 AssertLogRelMsgRCBreak(rc, ("failed to insert CFGM value '%s' to key '%s'\n", strCFGMValueUtf8.c_str(), pszExtraDataKey));
     3294                AssertLogRelMsgRCBreak(rc, ("failed to insert CFGM value '%s' to key '%s'\n",
     3295                                            strCFGMValueUtf8.c_str(), pszExtraDataKey));
    32903296            }
    32913297        }
    … …  
    36393645
    36403646                if (enmBus == StorageBus_USB)
    3641                     rc = PDMR3UsbDriverDetach(pUVM, pcszDevice, uInstance, uLUN, NULL, 0, fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
     3647                    rc = PDMR3UsbDriverDetach(pUVM, pcszDevice, uInstance, uLUN, NULL, 0,
     3648                                              fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
    36423649                else
    36433650                    rc = PDMR3DeviceDetach(pUVM, pcszDevice, uInstance, uLUN, fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
    … …  
    40704077                    hrc = pMedium->COMGETTER(Location)(loc.asOutParam());                   H();
    40714078                    setVMRuntimeErrorCallbackF(0, "DvdOrFloppyImageInaccessible",
    4072                                                "The image file '%ls' is inaccessible and is being ignored. Please select a different image file for the virtual %s drive.",
     4079"The image file '%ls' is inaccessible and is being ignored. Please select a different image file for the virtual %s drive.",
    40734080                                               loc.raw(),
    40744081                                               enmType == DeviceType_DVD ? "DVD" : "floppy");
    … …  
    46854692
    46864693                /* get the adapter's INetCfgComponent*/
    4687                 hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.raw(), pAdaptorComponent.asOutParam());
     4694                hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.raw(),
     4695                                                      pAdaptorComponent.asOutParam());
    46884696                if (hrc != S_OK)
    46894697                {
    … …  
    47124720                            hrc = HRESULT_FROM_WIN32(err);
    47134721                            AssertMsgFailed(("%hrc=%Rhrc %#x\n", hrc, hrc));
    4714                             AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: WideCharToMultiByte failed, hr=%Rhrc (0x%x) err=%u\n", hrc, hrc, err));
     4722                            AssertLogRelMsgFailed((
     4723                            "NetworkAttachmentType_Bridged: WideCharToMultiByte failed, hr=%Rhrc (0x%x) err=%u\n",
     4724                                                   hrc, hrc, err));
    47154725                        }
    47164726                    }
    … …  
    47354745                {
    47364746                    VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
    4737                     AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)", hrc));
     4747                    AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: VBoxNetCfgWinGetComponentByGuid failed, hrc (0x%x)",
     4748                                           hrc));
    47384749                    H();
    47394750                }
    … …  
    47614772                                                "sysctl is set.  Either run 'chmod 0666 /dev/%s' or "
    47624773                                                "change the group of that node to vboxusers and make yourself "
    4763                                                 "a member of that group.  Make sure that these changes are permanent."), pszBridgedIfName, pszBridgedIfName);
     4774                                                "a member of that group.  Make sure that these changes are permanent."),
     4775                                                pszBridgedIfName, pszBridgedIfName);
    47644776                            default:
    47654777                                AssertMsgFailed(("Could not attach to tap interface! Bad!\n"));
    … …  
    50645076
    50655077                /* get the adapter's INetCfgComponent*/
    5066                 hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.raw(), pAdaptorComponent.asOutParam());
     5078                hrc = VBoxNetCfgWinGetComponentByGuid(pNc, &GUID_DEVCLASS_NET, (GUID*)hostIFGuid.raw(),
     5079                                                      pAdaptorComponent.asOutParam());
    50675080                if (hrc != S_OK)
    50685081                {
    … …  
    50905103                            DWORD err = GetLastError();
    50915104                            hrc = HRESULT_FROM_WIN32(err);
    5092                             AssertLogRelMsgFailed(("NetworkAttachmentType_HostOnly: WideCharToMultiByte failed, hr=%Rhrc (0x%x) err=%u\n", hrc, hrc, err));
     5105                            AssertLogRelMsgFailed((
     5106                        "NetworkAttachmentType_HostOnly: WideCharToMultiByte failed, hr=%Rhrc (0x%x) err=%u\n", hrc, hrc, err));
    50935107                        }
    50945108                    }
    … …  
    51115125                {
    51125126                    VBoxNetCfgWinReleaseINetCfg(pNc, FALSE /*fHasWriteLock*/);
    5113                     AssertLogRelMsgFailed(("NetworkAttachmentType_HostOnly: VBoxNetCfgWinGetComponentByGuid failed, hrc=%Rhrc (0x%x)\n", hrc, hrc));
     5127                    AssertLogRelMsgFailed((
     5128                    "NetworkAttachmentType_HostOnly: VBoxNetCfgWinGetComponentByGuid failed, hrc=%Rhrc (0x%x)\n", hrc, hrc));
    51145129                    H();
    51155130                }
    … …  
    51275142                InsertConfigString(pCfg, "Trunk", pszTrunk);
    51285143                InsertConfigString(pCfg, "Network", szNetwork);
    5129                 InsertConfigInteger(pCfg, "IgnoreConnectFailure", (uint64_t)fIgnoreConnectFailure); /** @todo why is this windows only?? */
     5144                InsertConfigInteger(pCfg, "IgnoreConnectFailure", (uint64_t)fIgnoreConnectFailure); /** @todo why is this
     5145                                                                                                        windows only?? */
    51305146                networkName = Bstr(szNetwork);
    51315147                trunkName   = Bstr(pszTrunk);

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

    r50874 r51092  
    807807         */
    808808        AssertLogRelMsg(enmVMState == VMSTATE_SUSPENDED, ("%s\n", VMR3GetStateName(enmVMState)));
    809         AssertLogRelMsg(enmMachineState == MachineState_TeleportingPausedVM, ("%s\n", Global::stringifyMachineState(enmMachineState)));
     809        AssertLogRelMsg(enmMachineState == MachineState_TeleportingPausedVM,("%s\n",
     810                                                                             Global::stringifyMachineState(enmMachineState)));
    810811
    811812        ptrVM.release();

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

    r50940 r51092  
    197197#endif /* DEBUG_sunlover */
    198198
    199 static void findTopLeftBorder(const uint8_t *pu8AndMask, const uint8_t *pu8XorMask, uint32_t width, uint32_t height, uint32_t *pxSkip, uint32_t *pySkip)
     199static void findTopLeftBorder(const uint8_t *pu8AndMask, const uint8_t *pu8XorMask, uint32_t width,
     200                              uint32_t height, uint32_t *pxSkip, uint32_t *pySkip)
    200201{
    201202    /*
    … …  
    365366                                                            ComSafeArrayIn(BYTE,inShape))
    366367{
    367     LogSunlover(("VRDPConsoleListener::OnMousePointerShapeChange: %d, %d, %lux%lu, @%lu,%lu\n", visible, alpha, width, height, xHot, yHot));
     368    LogSunlover(("VRDPConsoleListener::OnMousePointerShapeChange: %d, %d, %lux%lu, @%lu,%lu\n",
     369                 visible, alpha, width, height, xHot, yHot));
    368370
    369371    if (m_server)
    … …  
    557559};
    558560
    559 DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackQueryProperty(void *pvCallback, uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut)
     561DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackQueryProperty(void *pvCallback, uint32_t index, void *pvBuffer,
     562                                                               uint32_t cbBuffer, uint32_t *pcbOut)
    560563{
    561564    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    675678        {
    676679            com::Bstr bstr;
    677             HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Enabled").raw(), bstr.asOutParam());
     680            HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
     681                                                                             bstr.asOutParam());
    678682
    679683            if (hrc != S_OK)
    … …  
    703707        {
    704708            com::Bstr bstr;
    705             HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Quality").raw(), bstr.asOutParam());
     709            HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
     710                                                                             bstr.asOutParam());
    706711
    707712            if (hrc != S_OK)
    … …  
    815820                /* Generic properties. */
    816821                const char *pszPropertyName = &pFeature->achInfo[9];
    817                 HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr(pszPropertyName).raw(), bstrValue.asOutParam());
     822                HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr(pszPropertyName).raw(),
     823                                                                                 bstrValue.asOutParam());
    818824                if (FAILED(hrc))
    819825                {
    … …  
    916922}
    917923
    918 DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackClientLogon(void *pvCallback, uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain)
     924DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackClientLogon(void *pvCallback, uint32_t u32ClientId, const char *pszUser,
     925                                                             const char *pszPassword, const char *pszDomain)
    919926{
    920927    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    940947}
    941948
    942 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientDisconnect(void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercepted)
     949DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientDisconnect(void *pvCallback, uint32_t u32ClientId,
     950                                                                   uint32_t fu32Intercepted)
    943951{
    944952    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    974982}
    975983
    976 DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackIntercept(void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercept, void **ppvIntercept)
     984DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackIntercept(void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercept,
     985                                                           void **ppvIntercept)
    977986{
    978987    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    10521061}
    10531062
    1054 DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackUSB(void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint8_t u8Code, const void *pvRet, uint32_t cbRet)
     1063DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackUSB(void *pvCallback, void *pvIntercept, uint32_t u32ClientId,
     1064                                                     uint8_t u8Code, const void *pvRet, uint32_t cbRet)
    10551065{
    10561066#ifdef VBOX_WITH_USB
    … …  
    10611071}
    10621072
    1063 DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackClipboard(void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData)
     1073DECLCALLBACK(int) ConsoleVRDPServer::VRDPCallbackClipboard(void *pvCallback, void *pvIntercept, uint32_t u32ClientId,
     1074                                                           uint32_t u32Function, uint32_t u32Format,
     1075                                                           const void *pvData, uint32_t cbData)
    10641076{
    10651077    return ClipboardCallback(pvIntercept, u32ClientId, u32Function, u32Format, pvData, cbData);
    10661078}
    10671079
    1068 DECLCALLBACK(bool) ConsoleVRDPServer::VRDPCallbackFramebufferQuery(void *pvCallback, unsigned uScreenId, VRDEFRAMEBUFFERINFO *pInfo)
     1080DECLCALLBACK(bool) ConsoleVRDPServer::VRDPCallbackFramebufferQuery(void *pvCallback, unsigned uScreenId,
     1081                                                                   VRDEFRAMEBUFFERINFO *pInfo)
    10691082{
    10701083    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    12311244                if (server->m_fGuestWantsAbsolute)
    12321245                {
    1233                     pConsole->getMouse()->PutMouseEventAbsolute(pInputPoint->x + 1, pInputPoint->y + 1, iWheel, 0 /* Horizontal wheel */, mouseButtons);
     1246                    pConsole->getMouse()->PutMouseEventAbsolute(pInputPoint->x + 1, pInputPoint->y + 1, iWheel,
     1247                                                                0 /* Horizontal wheel */, mouseButtons);
    12341248                } else
    12351249                {
    … …  
    12881302}
    12891303
    1290 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackVideoModeHint(void *pvCallback, unsigned cWidth, unsigned cHeight, unsigned cBitsPerPixel, unsigned uScreenId)
     1304DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackVideoModeHint(void *pvCallback, unsigned cWidth, unsigned cHeight,
     1305                                                                unsigned cBitsPerPixel, unsigned uScreenId)
    12911306{
    12921307    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);

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

    r51029 r51092  
    282282{
    283283    VBOX_DISPLAY_SAVESCREENSHOT_DATA *pData = (VBOX_DISPLAY_SAVESCREENSHOT_DATA*)pvCtx;
    284     displayMakeThumbnail(pu8BufferAddress, uGuestWidth, uGuestHeight, &pData->pu8Thumbnail, &pData->cbThumbnail, &pData->cxThumbnail, &pData->cyThumbnail);
    285     int rc = DisplayMakePNG(pu8BufferAddress, uGuestWidth, uGuestHeight, &pData->pu8PNG, &pData->cbPNG, &pData->cxPNG, &pData->cyPNG, 1);
     284    displayMakeThumbnail(pu8BufferAddress, uGuestWidth, uGuestHeight, &pData->pu8Thumbnail,
     285                         &pData->cbThumbnail, &pData->cxThumbnail, &pData->cyThumbnail);
     286    int rc = DisplayMakePNG(pu8BufferAddress, uGuestWidth, uGuestHeight, &pData->pu8PNG,
     287                            &pData->cbPNG, &pData->cxPNG, &pData->cyPNG, 1);
    286288    if (RT_FAILURE(rc))
    287289    {
    … …  
    334336            if (pVMMDev)
    335337            {
    336                 VBOX_DISPLAY_SAVESCREENSHOT_DATA *pScreenshot = (VBOX_DISPLAY_SAVESCREENSHOT_DATA*)RTMemAllocZ(sizeof (*pScreenshot));
     338                VBOX_DISPLAY_SAVESCREENSHOT_DATA *pScreenshot =
     339                    (VBOX_DISPLAY_SAVESCREENSHOT_DATA*)RTMemAllocZ(sizeof (*pScreenshot));
    337340                if (pScreenshot)
    338341                {
    … …  
    879882            if (pVMMDev)
    880883            {
    881                 VBOXCRCMDCTL_HGCM *pCtl = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof (CRVBOXHGCMDEVRESIZE) + sizeof (VBOXCRCMDCTL_HGCM));
     884                VBOXCRCMDCTL_HGCM *pCtl =
     885                    (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof (CRVBOXHGCMDEVRESIZE) + sizeof (VBOXCRCMDCTL_HGCM));
    882886                if (pCtl)
    883887                {
    … …  
    10591063            pFBInfo->pendingResize.fPending = false;
    10601064            handleDisplayResize (uScreenId, pFBInfo->pendingResize.bpp, pFBInfo->pendingResize.pvVRAM,
    1061                                  pFBInfo->pendingResize.cbLine, pFBInfo->pendingResize.w, pFBInfo->pendingResize.h, pFBInfo->pendingResize.flags);
     1065                                 pFBInfo->pendingResize.cbLine, pFBInfo->pendingResize.w, pFBInfo->pendingResize.h,
     1066                                 pFBInfo->pendingResize.flags);
    10621067            break;
    10631068        }
    … …  
    15221527} VBVADIRTYREGION;
    15231528
    1524 static void vbvaRgnInit (VBVADIRTYREGION *prgn, DISPLAYFBINFO *paFramebuffers, unsigned cMonitors, Display *pd, PPDMIDISPLAYPORT pp)
     1529static void vbvaRgnInit (VBVADIRTYREGION *prgn, DISPLAYFBINFO *paFramebuffers, unsigned cMonitors,
     1530                         Display *pd, PPDMIDISPLAYPORT pp)
    15251531{
    15261532    prgn->paFramebuffers = paFramebuffers;
    … …  
    18661872        mfu32SupportedOrders = 0;
    18671873
    1868         vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
     1874        vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
     1875                            maFramebuffers, mcMonitors);
    18691876#ifdef VBOX_WITH_HGSMI
    18701877        /* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
    … …  
    18851892        mfu32SupportedOrders = ~0;
    18861893
    1887         vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
     1894        vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
     1895                            maFramebuffers, mcMonitors);
    18881896#ifdef VBOX_WITH_HGSMI
    18891897        /* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
    … …  
    21992207#ifdef DEBUG_sunlover_2
    22002208    LogFlowFunc(("indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
    2201                   mpVbvaMemory->indexRecordFirst, mpVbvaMemory->indexRecordFree, mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
     2209                  mpVbvaMemory->indexRecordFirst, mpVbvaMemory->indexRecordFree,
     2210                  mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
    22022211#endif /* DEBUG_sunlover_2 */
    22032212
    … …  
    26082617
    26092618#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
    2610 BOOL Display::displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pu8Data, uint32_t u32Width, uint32_t u32Height)
     2619BOOL Display::displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pu8Data,
     2620                                              uint32_t u32Width, uint32_t u32Height)
    26112621{
    26122622    BOOL is3denabled;
    … …  
    26572667#endif
    26582668
    2659 int Display::displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData, uint32_t *pu32Width, uint32_t *pu32Height)
     2669int Display::displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData,
     2670                                      uint32_t *pu32Width, uint32_t *pu32Height)
    26602671{
    26612672    int rc;
    … …  
    40304041 * @see PDMIDISPLAYCONNECTOR::pfnProcessAdapterData
    40314042 */
    4032 DECLCALLBACK(void) Display::displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, uint32_t u32VRAMSize)
     4043DECLCALLBACK(void) Display::displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM,
     4044                                                              uint32_t u32VRAMSize)
    40334045{
    40344046    PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
    … …  
    40904102                 pFBInfo->u32InformationSize = pDisplay->u32InformationSize;
    40914103
    4092                  LogRelFlow(("VBOX_VIDEO_INFO_TYPE_DISPLAY: %d: at 0x%08X, size 0x%08X, info 0x%08X\n", pDisplay->u32Index, pDisplay->u32Offset, pDisplay->u32FramebufferSize, pDisplay->u32InformationSize));
     4104                 LogRelFlow(("VBOX_VIDEO_INFO_TYPE_DISPLAY: %d: at 0x%08X, size 0x%08X, info 0x%08X\n", pDisplay->u32Index,
     4105                             pDisplay->u32Offset, pDisplay->u32FramebufferSize, pDisplay->u32InformationSize));
    40934106             }
    40944107             else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_QUERY_CONF32)
    … …  
    41294142                 break;
    41304143             }
    4131              else if (pHdr->u8Type != VBOX_VIDEO_INFO_TYPE_NV_HEAP) /** @todo why is Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp pushing this to us? */
     4144             else if (pHdr->u8Type != VBOX_VIDEO_INFO_TYPE_NV_HEAP) /** @todo why is
     4145                                                                     Additions/WINNT/Graphics/Miniport/VBoxVideo. cpp
     4146                                                                     pushing this to us? */
    41324147             {
    41334148                 LogRel(("Guest adapter information contains unsupported type %d. The block has been skipped.\n", pHdr->u8Type));
    … …  
    41944209
    41954210            LogRelFlow(("VBOX_VIDEO_INFO_TYPE_SCREEN: (%p) %d: at %d,%d, linesize 0x%X, size %dx%d, bpp %d, flags 0x%02X\n",
    4196                      pHdr, uScreenId, pScreen->xOrigin, pScreen->yOrigin, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, pScreen->bitsPerPixel, pScreen->u8Flags));
     4211                     pHdr, uScreenId, pScreen->xOrigin, pScreen->yOrigin, pScreen->u32LineSize, pScreen->u16Width,
     4212                     pScreen->u16Height, pScreen->bitsPerPixel, pScreen->u8Flags));
    41974213
    41984214            if (uScreenId != VBOX_VIDEO_PRIMARY_SCREEN)
    … …  
    42094225                }
    42104226
    4211                 pDrv->pDisplay->handleDisplayResize(uScreenId, pScreen->bitsPerPixel, (uint8_t *)pvVRAM + pFBInfo->u32Offset, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, VBVA_SCREEN_F_ACTIVE);
     4227                pDrv->pDisplay->handleDisplayResize(uScreenId, pScreen->bitsPerPixel,
     4228                                                    (uint8_t *)pvVRAM + pFBInfo->u32Offset,
     4229                                                    pScreen->u32LineSize,
     4230                                                    pScreen->u16Width, pScreen->u16Height,
     4231                                                    VBVA_SCREEN_F_ACTIVE);
    42124232            }
    42134233        }
    … …  
    43014321void Display::handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
    43024322{
    4303     mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVDMACMD_CHROMIUM_CMD)pParam->u.pointer.addr, result);
     4323    mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync(mpDrv->pVBVACallbacks,
     4324                                                          (PVBOXVDMACMD_CHROMIUM_CMD)pParam->u.pointer.addr, result);
    43044325}
    43054326
    … …  
    43524373        {
    43534374            bool fCheckPendingViewport = (pCtl->enmType == VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP);
    4354             rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm, Display::displayCrHgsmiControlCompletion, this);
     4375            rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm,
     4376                                                Display::displayCrHgsmiControlCompletion, this);
    43554377            AssertRC(rc);
    43564378            if (RT_SUCCESS(rc))
    … …  
    43654387                            continue;
    43664388
    4367                         rc = crViewportNotify(ul, pFb->pendingViewportInfo.x, pFb->pendingViewportInfo.y, pFb->pendingViewportInfo.width, pFb->pendingViewportInfo.height);
     4389                        rc = crViewportNotify(ul, pFb->pendingViewportInfo.x, pFb->pendingViewportInfo.y,
     4390                                              pFb->pendingViewportInfo.width, pFb->pendingViewportInfo.height);
    43684391                        if (RT_SUCCESS(rc))
    43694392                            pFb->pendingViewportInfo.fPending = false;
    … …  
    43864409}
    43874410
    4388 DECLCALLBACK(void) Display::displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
     4411DECLCALLBACK(void) Display::displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd,
     4412                                                         uint32_t cbCmd)
    43894413{
    43904414    PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
    … …  
    43934417}
    43944418
    4395 DECLCALLBACK(void) Display::displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd, uint32_t cbCmd)
     4419DECLCALLBACK(void) Display::displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd,
     4420                                                         uint32_t cbCmd)
    43964421{
    43974422    PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
    … …  
    44004425}
    44014426
    4402 DECLCALLBACK(void) Display::displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
     4427DECLCALLBACK(void) Display::displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
     4428                                                            void *pvContext)
    44034429{
    44044430    AssertMsgFailed(("not expected!"));
    … …  
    44074433}
    44084434
    4409 DECLCALLBACK(void) Display::displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
     4435DECLCALLBACK(void) Display::displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
     4436                                                            void *pvContext)
    44104437{
    44114438    Display *pDisplay = (Display *)pvContext;
    … …  
    44164443
    44174444#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
    4418 DECLCALLBACK(void)  Display::displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
     4445DECLCALLBACK(void)  Display::displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
     4446                                                              void *pvContext)
    44194447{
    44204448    VBOXCRCMDCTL *pCmd = (VBOXCRCMDCTL*)pParam->u.pointer.addr;
    … …  
    44244452
    44254453int  Display::handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
    4426                                         PFNCRCTLCOMPLETION pfnCompletion,
    4427                                         void *pvCompletion)
     4454                                    PFNCRCTLCOMPLETION pfnCompletion,
     4455                                    void *pvCompletion)
    44284456{
    44294457    VMMDev *pVMMDev = mParent->getVMMDev();
    … …  
    44414469
    44424470    pCmd->u.pfnInternal = (void(*)())pfnCompletion;
    4443     int rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CTL, &parm, displayCrHgcmCtlSubmitCompletion, pvCompletion);
     4471    int rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CTL, &parm, displayCrHgcmCtlSubmitCompletion,
     4472                                            pvCompletion);
    44444473    if (!RT_SUCCESS(rc))
    44454474        AssertMsgFailed(("hgcmHostFastCallAsync failed rc %d\n", rc));
    … …  
    46244653    if (ASMAtomicReadU32(&pThis->mu32UpdateVBVAFlags) > 0)
    46254654    {
    4626         vbvaSetMemoryFlagsAllHGSMI(pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, pThis->maFramebuffers, pThis->mcMonitors);
     4655        vbvaSetMemoryFlagsAllHGSMI(pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, pThis->maFramebuffers,
     4656                                   pThis->mcMonitors);
    46274657        ASMAtomicDecU32(&pThis->mu32UpdateVBVAFlags);
    46284658    }
    … …  
    46494679}
    46504680
    4651 DECLCALLBACK(void) Display::displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, const PVBVACMDHDR pCmd, size_t cbCmd)
     4681DECLCALLBACK(void) Display::displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
     4682                                                     const PVBVACMDHDR pCmd, size_t cbCmd)
    46524683{
    46534684    LogFlowFunc(("uScreenId %d pCmd %p cbCmd %d, @%d,%d %dx%d\n", uScreenId, pCmd, cbCmd, pCmd->x, pCmd->y, pCmd->w, pCmd->h));
    … …  
    47234754}
    47244755
    4725 DECLCALLBACK(void) Display::displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y, uint32_t cx, uint32_t cy)
     4756DECLCALLBACK(void) Display::displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
     4757                                                 uint32_t cx, uint32_t cy)
    47264758{
    47274759    LogFlowFunc(("uScreenId %d %d,%d %dx%d\n", uScreenId, x, y, cx, cy));
    … …  
    48704902#endif /* DEBUG_sunlover */
    48714903
    4872 DECLCALLBACK(int) Display::displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM)
     4904DECLCALLBACK(int) Display::displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView,
     4905                                             const PVBVAINFOSCREEN pScreen, void *pvVRAM)
    48734906{
    48744907    LogRelFlowFunc(("pScreen %p, pvVRAM %p\n", pScreen, pvVRAM));

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

    r50686 r51092  
    570570
    571571
    572 STDMETHODIMP AudioVRDE::handleVRDESvrCmdAudioInputEventBegin(void *pvContext, int iSampleHz, int cChannels, int cBits, bool fUnsigned)
     572STDMETHODIMP AudioVRDE::handleVRDESvrCmdAudioInputEventBegin(void *pvContext, int iSampleHz, int cChannels,
     573                                                             int cBits, bool fUnsigned)
    573574{
    574575    int bitIdx;

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

    r50874 r51092  
    259259    static void                toMainActions(uint32_t uActions, ComSafeArrayOut(DragAndDropAction_T, actions));
    260260    static uint32_t            toHGCMAction(DragAndDropAction_T action);
    261     static void                toHGCMActions(DragAndDropAction_T inDefAction, uint32_t *pOutDefAction, ComSafeArrayIn(DragAndDropAction_T, inAllowedActions), uint32_t *pOutAllowedActions);
     261    static void                toHGCMActions(DragAndDropAction_T inDefAction, uint32_t *pOutDefAction,
     262                                             ComSafeArrayIn(DragAndDropAction_T, inAllowedActions),
     263                                             uint32_t *pOutAllowedActions);
    262264
    263265    /* Private q and parent pointer */
    … …  
    678680        case DragAndDropAction_Copy:   a = DND_COPY_ACTION; break;
    679681        case DragAndDropAction_Move:   a = DND_MOVE_ACTION; break;
    680         case DragAndDropAction_Link:   /* For now it doesn't seems useful to allow a link action between host & guest. Maybe later! */
     682        case DragAndDropAction_Link:   /* For now it doesn't seems useful to allow a link
     683                                          action between host & guest. Maybe later! */
    681684        case DragAndDropAction_Ignore: /* Ignored */ break;
    682685        default: AssertMsgFailed(("Action %u not recognized!\n", action)); break;
    … …  
    13021305        case DragAndDropSvc::GUEST_DND_HG_EVT_PROGRESS:
    13031306        {
    1304             DragAndDropSvc::PVBOXDNDCBHGEVTPROGRESSDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBHGEVTPROGRESSDATA>(pvParms);
     1307            DragAndDropSvc::PVBOXDNDCBHGEVTPROGRESSDATA pCBData =
     1308                reinterpret_cast <DragAndDropSvc::PVBOXDNDCBHGEVTPROGRESSDATA>(pvParms);
    13051309            AssertPtr(pCBData);
    13061310            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGEVTPROGRESSDATA) == cbParms, VERR_INVALID_PARAMETER);
    … …  
    13141318        case DragAndDropSvc::GUEST_DND_GH_ACK_PENDING:
    13151319        {
    1316             DragAndDropSvc::PVBOXDNDCBGHACKPENDINGDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBGHACKPENDINGDATA>(pvParms);
     1320            DragAndDropSvc::PVBOXDNDCBGHACKPENDINGDATA pCBData =
     1321                reinterpret_cast <DragAndDropSvc::PVBOXDNDCBGHACKPENDINGDATA>(pvParms);
    13171322            AssertPtr(pCBData);
    13181323            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBGHACKPENDINGDATA) == cbParms, VERR_INVALID_PARAMETER);

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

    r50544 r51092  
    646646
    647647STDMETHODIMP Guest::InternalGetStatistics(ULONG *aCpuUser, ULONG *aCpuKernel, ULONG *aCpuIdle,
    648                                           ULONG *aMemTotal, ULONG *aMemFree, ULONG *aMemBalloon, ULONG *aMemShared,
    649                                           ULONG *aMemCache, ULONG *aPageTotal,
    650                                           ULONG *aMemAllocTotal, ULONG *aMemFreeTotal, ULONG *aMemBalloonTotal, ULONG *aMemSharedTotal)
     648                                          ULONG *aMemTotal, ULONG *aMemFree, ULONG *aMemBalloon,
     649                                          ULONG *aMemShared, ULONG *aMemCache, ULONG *aPageTotal,
     650                                          ULONG *aMemAllocTotal, ULONG *aMemFreeTotal,
     651                                          ULONG *aMemBalloonTotal, ULONG *aMemSharedTotal)
    651652{
    652653    CheckComArgOutPointerValid(aCpuUser);

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

    r50874 r51092  
    506506                    if (RT_FAILURE(rc))
    507507                        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    508                                             Utf8StrFmt(GuestSession::tr("Waiting on termination for copying file \"%s\" failed: %Rrc"),
     508                                            Utf8StrFmt(GuestSession::tr(
     509                                            "Waiting on termination for copying file \"%s\" failed: %Rrc"),
    509510                                                       mSource.c_str(), rc));
    510511                    else
    511512                    {
    512513                        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    513                                             Utf8StrFmt(GuestSession::tr("Waiting on termination for copying file \"%s\" failed with wait result %ld"),
     514                                            Utf8StrFmt(GuestSession::tr(
     515                                            "Waiting on termination for copying file \"%s\" failed with wait result %ld"),
    514516                                                       mSource.c_str(), waitRes));
    515517                        rc = VERR_GENERAL_FAILURE; /* Fudge. */
    … …  
    528530                    {
    529531                        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    530                                             Utf8StrFmt(GuestSession::tr("Copying file \"%s\" failed with status %ld, exit code %ld"),
     532                                            Utf8StrFmt(GuestSession::tr(
     533                                                       "Copying file \"%s\" failed with status %ld, exit code %ld"),
    531534                                                       mSource.c_str(), procStatus, exitCode)); /**@todo Add stringify methods! */
    532535                        rc = VERR_GENERAL_FAILURE; /* Fudge. */
    533536                    }
    534537                }
     538
    535539
    536540                if (RT_SUCCESS(rc))
    … …  
    608612        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    609613                            Utf8StrFmt(GuestSession::tr("Querying guest file information for \"%s\" failed: %Rrc"),
    610                             mSource.c_str(), rc));
     614                                       mSource.c_str(), rc));
    611615    }
    612616    else if (objData.mType != FsObjType_File) /* Only single files are supported at the moment. */
    … …  
    631635        {
    632636            GuestProcessStartupInfo procInfo;
    633             procInfo.mName      = Utf8StrFmt(GuestSession::tr("Copying file \"%s\" from guest to the host to \"%s\" (%RI64 bytes)"),
    634                                                               mSource.c_str(), mDest.c_str(), objData.mObjectSize);
     637            procInfo.mName = Utf8StrFmt(GuestSession::tr("Copying file \"%s\" from guest to the host to \"%s\" (%RI64 bytes)"),
     638                                        mSource.c_str(), mDest.c_str(), objData.mObjectSize);
    635639            procInfo.mCommand   = Utf8Str(VBOXSERVICE_TOOL_CAT);
    636640            procInfo.mFlags     = ProcessCreateFlag_Hidden | ProcessCreateFlag_WaitForStdOut;
    … …  
    685689                            default:
    686690                                setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    687                                                     Utf8StrFmt(GuestSession::tr("Error while creating guest process for copying file \"%s\" from guest to host: %Rrc"),
     691                                                    Utf8StrFmt(GuestSession::tr(
     692                                                               "Error while creating guest process for copying file \"%s\" from guest to host: %Rrc"),
    688693                                                               mSource.c_str(), rc));
    689694                                break;
    … …  
    716721                                default:
    717722                                    setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    718                                                         Utf8StrFmt(GuestSession::tr("Reading from file \"%s\" (offset %RU64) failed: %Rrc"),
     723                                                        Utf8StrFmt(GuestSession::tr(
     724                                                                   "Reading from file \"%s\" (offset %RU64) failed: %Rrc"),
    719725                                                                   mSource.c_str(), cbWrittenTotal, rc));
    720726                                    break;
    … …  
    730736                            {
    731737                                setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    732                                                     Utf8StrFmt(GuestSession::tr("Error writing to file \"%s\" (%RU64 bytes left): %Rrc"),
    733                                                     mDest.c_str(), cbToRead, rc));
     738                                                    Utf8StrFmt(GuestSession::tr(
     739                                                               "Error writing to file \"%s\" (%RU64 bytes left): %Rrc"),
     740                                                                mDest.c_str(), cbToRead, rc));
    734741                                break;
    735742                            }
    … …  
    784791                        /* If we did not copy all let the user know. */
    785792                        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    786                                             Utf8StrFmt(GuestSession::tr("Copying file \"%s\" failed (%RU64/%RI64 bytes transfered)"),
    787                                             mSource.c_str(), cbWrittenTotal, objData.mObjectSize));
     793                                            Utf8StrFmt(GuestSession::tr(
     794                                                       "Copying file \"%s\" failed (%RU64/%RI64 bytes transfered)"),
     795                                                       mSource.c_str(), cbWrittenTotal, objData.mObjectSize));
    788796                        rc = VERR_GENERAL_FAILURE; /* Fudge. */
    789797                    }
    … …  
    799807                        {
    800808                            setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    801                                                 Utf8StrFmt(GuestSession::tr("Copying file \"%s\" failed with status %ld, exit code %d"),
    802                                                 mSource.c_str(), procStatus, exitCode)); /**@todo Add stringify methods! */
     809                                                Utf8StrFmt(GuestSession::tr(
     810                                                           "Copying file \"%s\" failed with status %ld, exit code %d"),
     811                                                           mSource.c_str(), procStatus, exitCode)); /**@todo Add
     812                                                                                                       stringify methods! */
    803813                            rc = VERR_GENERAL_FAILURE; /* Fudge. */
    804814                        }
    … …  
    935945
    936946            ComObjPtr<Progress> pProgressCopyTo;
    937             rc = pSession->i_startTaskAsync(Utf8StrFmt(GuestSession::tr("Copying Guest Additions installer file \"%s\" to \"%s\" on guest"),
     947            rc = pSession->i_startTaskAsync(Utf8StrFmt(GuestSession::tr(
     948                                                       "Copying Guest Additions installer file \"%s\" to \"%s\" on guest"),
    938949                                                       mSource.c_str(), strFileDest.c_str()),
    939950                                                       pTask, pProgressCopyTo);
    … …  
    10331044            case VERR_NOT_EQUAL: /** @todo Special guest control rc needed! */
    10341045                setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    1035                                     Utf8StrFmt(GuestSession::tr("Running update file \"%s\" on guest terminated with exit code %ld"),
     1046                                    Utf8StrFmt(GuestSession::tr(
     1047                                               "Running update file \"%s\" on guest terminated with exit code %ld"),
    10361048                                               procInfo.mCommand.c_str(), exitCode));
    10371049                break;
    … …  
    10441056            case VERR_INVALID_STATE: /** @todo Special guest control rc needed! */
    10451057                setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    1046                                     Utf8StrFmt(GuestSession::tr("Update file \"%s\" reported invalid running state"),
     1058                                    Utf8StrFmt(GuestSession::tr(
     1059                                               "Update file \"%s\" reported invalid running state"),
    10471060                                               procInfo.mCommand.c_str()));
    10481061                break;
    … …  
    10501063            default:
    10511064                setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    1052                                     Utf8StrFmt(GuestSession::tr("Error while running update file \"%s\" on guest: %Rrc"),
     1065                                    Utf8StrFmt(GuestSession::tr(
     1066                                               "Error while running update file \"%s\" on guest: %Rrc"),
    10531067                                               procInfo.mCommand.c_str(), vrc));
    10541068                break;
    … …  
    11131127        if (addsRunLevel == AdditionsRunLevelType_System)
    11141128            hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
    1115                                      Utf8StrFmt(GuestSession::tr("Guest Additions are installed but not fully loaded yet, aborting automatic update")));
     1129                                     Utf8StrFmt(GuestSession::tr(
     1130                                                "Guest Additions are installed but not fully loaded yet, aborting automatic update")));
    11161131        else
    11171132            hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
    1118                                      Utf8StrFmt(GuestSession::tr("Guest Additions not installed or ready, aborting automatic update")));
     1133                                     Utf8StrFmt(GuestSession::tr(
     1134                                                "Guest Additions not installed or ready, aborting automatic update")));
    11191135        rc = VERR_NOT_SUPPORTED;
    11201136    }
    … …  
    11621178                {
    11631179                    hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
    1164                                          Utf8StrFmt(GuestSession::tr("Unable to detected guest OS version, please update manually")));
     1180                                             Utf8StrFmt(GuestSession::tr("Unable to detected guest OS version, please update manually")));
    11651181                    rc = VERR_NOT_SUPPORTED;
    11661182                }
    … …  
    11821198                        {
    11831199                            hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
    1184                                                      Utf8StrFmt(GuestSession::tr("Windows 2000 and XP are not supported for automatic updating due to WHQL interaction, please update manually")));
     1200                                                     Utf8StrFmt(GuestSession::tr(
     1201                                                                "Windows 2000 and XP are not supported for automatic updating due to WHQL interaction, please update manually")));
    11851202                            rc = VERR_NOT_SUPPORTED;
    11861203                        }
    … …  
    11901207                {
    11911208                    hr = setProgressErrorMsg(VBOX_E_NOT_SUPPORTED,
    1192                                              Utf8StrFmt(GuestSession::tr("%s (%s) not supported for automatic updating, please update manually"),
     1209                                             Utf8StrFmt(GuestSession::tr(
     1210                                                        "%s (%s) not supported for automatic updating, please update manually"),
    11931211                                                        strOSType.c_str(), strOSVer.c_str()));
    11941212                    rc = VERR_NOT_SUPPORTED;
    … …  
    12931311                    default:
    12941312                        hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    1295                                                  Utf8StrFmt(GuestSession::tr("Error creating installation directory \"%s\" on the guest: %Rrc"),
    1296                                                  strUpdateDir.c_str(), rc));
     1313                                                 Utf8StrFmt(GuestSession::tr(
     1314                                                            "Error creating installation directory \"%s\" on the guest: %Rrc"),
     1315                                                            strUpdateDir.c_str(), rc));
    12971316                        break;
    12981317                }
    … …  
    13381357                            mFiles.push_back(InstallerFile("CERT/VBOXCERTUTIL.EXE",
    13391358                                                           strUpdateDir + "VBoxCertUtil.exe",
    1340                                                            UPDATEFILE_FLAG_COPY_FROM_ISO | UPDATEFILE_FLAG_EXECUTE | UPDATEFILE_FLAG_OPTIONAL,
     1359                                                           UPDATEFILE_FLAG_COPY_FROM_ISO | UPDATEFILE_FLAG_EXECUTE |
     1360                                                           UPDATEFILE_FLAG_OPTIONAL,
    13411361                                                           siCertUtilRem));
    13421362                            /* Second pass: Only execute (but don't copy) again, this time installng the
    … …  
    14231443                        {
    14241444                            hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    1425                                                      Utf8StrFmt(GuestSession::tr("Error while copying file \"%s\" to \"%s\" on the guest: %Rrc"),
     1445                                                     Utf8StrFmt(GuestSession::tr(
     1446                                                                "Error while copying file \"%s\" to \"%s\" on the guest: %Rrc"),
    14261447                                                                itFiles->strSource.c_str(), itFiles->strDest.c_str(), rc));
    14271448                            break;

  • 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        }

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

    r47117 r51092  
    287287
    288288                RTTHREAD thread;
    289                 rc = RTThreadCreate (&thread, hgcmWorkerThreadFunc, this, 0, /* default stack size; some service may need quite a bit */
     289                rc = RTThreadCreate (&thread, hgcmWorkerThreadFunc, this, 0, /* default stack size; some service
     290                                                                                may need quite a bit */
    290291                                     RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE,
    291292                                     pszThreadName);
    … …  
    696697int hgcmMsgAlloc (HGCMTHREADHANDLE hThread, HGCMMSGHANDLE *pHandle, uint32_t u32MsgId, PFNHGCMNEWMSGALLOC pfnNewMessage)
    697698{
    698     LogFlow(("hgcmMsgAlloc: thread handle = 0x%08X, pHandle = %p, sizeof (HGCMMsgCore) = %d\n", hThread, pHandle, sizeof (HGCMMsgCore)));
     699    LogFlow(("hgcmMsgAlloc: thread handle = 0x%08X, pHandle = %p, sizeof (HGCMMsgCore) = %d\n",
     700             hThread, pHandle, sizeof (HGCMMsgCore)));
    699701
    700702    if (!pHandle)

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

    r47905 r51092  
    125125 * @param   a_fEnabled      Where to store the result.
    126126 */
    127 STDMETHODIMP MachineDebugger::COMGETTER(SingleStep)(BOOL *a_fEnabled)
    128 {
    129     CheckComArgOutPointerValid(a_fEnabled);
    130 
    131     AutoCaller autoCaller(this);
    132     HRESULT hrc = autoCaller.rc();
    133     if (SUCCEEDED(hrc))
    134     {
    135         AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    136         Console::SafeVMPtr ptrVM(mParent);
    137         hrc = ptrVM.rc();
    138         if (SUCCEEDED(hrc))
    139         {
    140             /** @todo */
    141             ReturnComNotImplemented();
    142         }
     127HRESULT MachineDebugger::getSingleStep(BOOL *aSingleStep)
     128{
     129    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     130    Console::SafeVMPtr ptrVM(mParent);
     131    HRESULT hrc = ptrVM.rc();
     132    if (SUCCEEDED(hrc))
     133    {
     134        /** @todo */
     135        ReturnComNotImplemented();
    143136    }
    144137    return hrc;
    … …  
    151144 * @param   a_fEnable       The new state.
    152145 */
    153 STDMETHODIMP MachineDebugger::COMSETTER(SingleStep)(BOOL a_fEnable)
    154 {
    155     AutoCaller autoCaller(this);
    156     HRESULT hrc = autoCaller.rc();
    157     if (SUCCEEDED(hrc))
    158     {
    159         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    160         Console::SafeVMPtr ptrVM(mParent);
    161         hrc = ptrVM.rc();
    162         if (SUCCEEDED(hrc))
    163         {
    164             /** @todo */
    165             ReturnComNotImplemented();
    166         }
     146HRESULT MachineDebugger::setSingleStep(BOOL aSingleStep)
     147{
     148    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     149    Console::SafeVMPtr ptrVM(mParent);
     150    HRESULT hrc = ptrVM.rc();
     151    if (SUCCEEDED(hrc))
     152    {
     153        /** @todo */
     154        ReturnComNotImplemented();
    167155    }
    168156    return hrc;
    … …  
    176164 * @param   pfEnforced          Where to return the policy setting.
    177165 */
    178 HRESULT MachineDebugger::getEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL *pfEnforced)
     166HRESULT MachineDebugger::i_getEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL *pfEnforced)
    179167{
    180168    CheckComArgOutPointerValid(pfEnforced);
    … …  
    185173    {
    186174        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    187         if (queueSettings())
     175        if (i_queueSettings())
    188176            *pfEnforced = maiQueuedEmExecPolicyParams[enmPolicy] == 1;
    189177        else
    … …  
    207195 * @param   fEnforce            Whether to enforce the policy or not.
    208196 */
    209 HRESULT MachineDebugger::setEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL fEnforce)
     197HRESULT MachineDebugger::i_setEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL fEnforce)
    210198{
    211199    AutoCaller autoCaller(this);
    … …  
    214202    {
    215203        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    216         if (queueSettings())
     204        if (i_queueSettings())
    217205            maiQueuedEmExecPolicyParams[enmPolicy] = fEnforce ? 1 : 0;
    218206        else
    … …  
    237225 * @param   a_fEnabled address of result variable
    238226 */
    239 STDMETHODIMP MachineDebugger::COMGETTER(RecompileUser) (BOOL *aEnabled)
    240 {
    241     return getEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING3, aEnabled);
     227HRESULT MachineDebugger::getRecompileUser(BOOL *aRecompileUser)
     228{
     229    return i_getEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING3, aRecompileUser);
    242230}
    243231
    … …  
    248236 * @param   aEnable new user mode code recompile flag.
    249237 */
    250 STDMETHODIMP MachineDebugger::COMSETTER(RecompileUser)(BOOL aEnable)
    251 {
    252     LogFlowThisFunc(("enable=%d\n", aEnable));
    253     return setEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING3, aEnable);
     238HRESULT MachineDebugger::setRecompileUser(BOOL aRecompileUser)
     239{
     240    LogFlowThisFunc(("enable=%d\n", aRecompileUser));
     241    return i_setEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING3, aRecompileUser);
    254242}
    255243
    … …  
    260248 * @param   aEnabled address of result variable
    261249 */
    262 STDMETHODIMP MachineDebugger::COMGETTER(RecompileSupervisor) (BOOL *aEnabled)
    263 {
    264     return getEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING0, aEnabled);
     250HRESULT MachineDebugger::getRecompileSupervisor(BOOL *aRecompileSupervisor)
     251{
     252    return i_getEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING0, aRecompileSupervisor);
    265253}
    266254
    … …  
    271259 * @param   aEnable new recompile supervisor code flag
    272260 */
    273 STDMETHODIMP MachineDebugger::COMSETTER(RecompileSupervisor)(BOOL aEnable)
    274 {
    275     LogFlowThisFunc(("enable=%d\n", aEnable));
    276     return setEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING0, aEnable);
     261HRESULT MachineDebugger::setRecompileSupervisor(BOOL aRecompileSupervisor)
     262{
     263    LogFlowThisFunc(("enable=%d\n", aRecompileSupervisor));
     264    return i_setEmExecPolicyProperty(EMEXECPOLICY_RECOMPILE_RING0, aRecompileSupervisor);
    277265}
    278266
    … …  
    283271 * @param   aEnabled    Address of result variable.
    284272 */
    285 STDMETHODIMP MachineDebugger::COMGETTER(ExecuteAllInIEM) (BOOL *aEnabled)
    286 {
    287     return getEmExecPolicyProperty(EMEXECPOLICY_IEM_ALL, aEnabled);
     273HRESULT MachineDebugger::getExecuteAllInIEM(BOOL *aExecuteAllInIEM)
     274{
     275    return i_getEmExecPolicyProperty(EMEXECPOLICY_IEM_ALL, aExecuteAllInIEM);
    288276}
    289277
    … …  
    294282 * @param   aEnable     New setting.
    295283 */
    296 STDMETHODIMP MachineDebugger::COMSETTER(ExecuteAllInIEM)(BOOL aEnable)
    297 {
    298     LogFlowThisFunc(("enable=%d\n", aEnable));
    299     return setEmExecPolicyProperty(EMEXECPOLICY_IEM_ALL, aEnable);
     284HRESULT MachineDebugger::setExecuteAllInIEM(BOOL aExecuteAllInIEM)
     285{
     286    LogFlowThisFunc(("enable=%d\n", aExecuteAllInIEM));
     287    return i_setEmExecPolicyProperty(EMEXECPOLICY_IEM_ALL, aExecuteAllInIEM);
    300288}
    301289
    … …  
    306294 * @param   aEnabled address of result variable
    307295 */
    308 STDMETHODIMP MachineDebugger::COMGETTER(PATMEnabled) (BOOL *aEnabled)
    309 {
    310     CheckComArgOutPointerValid(aEnabled);
    311 
    312     AutoCaller autoCaller(this);
    313     if (FAILED(autoCaller.rc()))
    314         return autoCaller.rc();
    315 
     296HRESULT MachineDebugger::getPATMEnabled(BOOL *aPATMEnabled)
     297{
    316298#ifdef VBOX_WITH_RAW_MODE
    317299    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    319301    Console::SafeVMPtrQuiet ptrVM(mParent);
    320302    if (ptrVM.isOk())
    321         *aEnabled = PATMR3IsEnabled (ptrVM.rawUVM());
     303        *aPATMEnabled = PATMR3IsEnabled (ptrVM.rawUVM());
    322304    else
    323305#endif
    324         *aEnabled = false;
     306        *aPATMEnabled = false;
    325307
    326308    return S_OK;
    … …  
    333315 * @param   aEnable new patch manager enabled flag
    334316 */
    335 STDMETHODIMP MachineDebugger::COMSETTER(PATMEnabled) (BOOL aEnable)
    336 {
    337     LogFlowThisFunc(("enable=%d\n", aEnable));
    338 
    339     AutoCaller autoCaller(this);
    340     if (FAILED(autoCaller.rc())) return autoCaller.rc();
     317HRESULT MachineDebugger::setPATMEnabled(BOOL aPATMEnabled)
     318{
     319    LogFlowThisFunc(("enable=%d\n", aPATMEnabled));
    341320
    342321#ifdef VBOX_WITH_RAW_MODE
    343322    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    344323
    345     if (queueSettings())
     324    if (i_queueSettings())
    346325    {
    347326        // queue the request
    348         mPatmEnabledQueued = aEnable;
     327        mPatmEnabledQueued = aPATMEnabled;
    349328        return S_OK;
    350329    }
    … …  
    354333        return ptrVM.rc();
    355334
    356     int vrc = PATMR3AllowPatching(ptrVM.rawUVM(), RT_BOOL(aEnable));
     335    int vrc = PATMR3AllowPatching(ptrVM.rawUVM(), RT_BOOL(aPATMEnabled));
    357336    if (RT_FAILURE(vrc))
    358337        return setError(VBOX_E_VM_ERROR, tr("PATMR3AllowPatching returned %Rrc"), vrc);
    359338
    360339#else  /* !VBOX_WITH_RAW_MODE */
    361     if (aEnable)
     340    if (aPATMEnabled)
    362341        return setError(VBOX_E_VM_ERROR, tr("PATM not present"), VERR_NOT_SUPPORTED);
    363342#endif /* !VBOX_WITH_RAW_MODE */
    … …  
    371350 * @param   aEnabled address of result variable
    372351 */
    373 STDMETHODIMP MachineDebugger::COMGETTER(CSAMEnabled) (BOOL *aEnabled)
    374 {
    375     CheckComArgOutPointerValid(aEnabled);
    376 
    377     AutoCaller autoCaller(this);
    378     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    379 
     352HRESULT MachineDebugger::getCSAMEnabled(BOOL *aCSAMEnabled)
     353{
    380354#ifdef VBOX_WITH_RAW_MODE
    381355    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    384358
    385359    if (ptrVM.isOk())
    386         *aEnabled = CSAMR3IsEnabled(ptrVM.rawUVM());
     360        *aCSAMEnabled = CSAMR3IsEnabled(ptrVM.rawUVM());
    387361    else
    388362#endif /* VBOX_WITH_RAW_MODE */
    389         *aEnabled = false;
     363        *aCSAMEnabled = false;
    390364
    391365    return S_OK;
    … …  
    398372 * @param   aEnable new code scanner enabled flag
    399373 */
    400 STDMETHODIMP MachineDebugger::COMSETTER(CSAMEnabled) (BOOL aEnable)
    401 {
    402     LogFlowThisFunc(("enable=%d\n", aEnable));
    403 
    404     AutoCaller autoCaller(this);
    405     if (FAILED(autoCaller.rc())) return autoCaller.rc();
     374HRESULT MachineDebugger::setCSAMEnabled(BOOL aCSAMEnabled)
     375{
     376    LogFlowThisFunc(("enable=%d\n", aCSAMEnabled));
    406377
    407378#ifdef VBOX_WITH_RAW_MODE
    408379    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    409380
    410     if (queueSettings())
     381    if (i_queueSettings())
    411382    {
    412383        // queue the request
    413         mCsamEnabledQueued = aEnable;
     384        mCsamEnabledQueued = aCSAMEnabled;
    414385        return S_OK;
    415386    }
    … …  
    419390        return ptrVM.rc();
    420391
    421     int vrc = CSAMR3SetScanningEnabled(ptrVM.rawUVM(), aEnable != FALSE);
     392    int vrc = CSAMR3SetScanningEnabled(ptrVM.rawUVM(), aCSAMEnabled != FALSE);
    422393    if (RT_FAILURE(vrc))
    423394        return setError(VBOX_E_VM_ERROR, tr("CSAMR3SetScanningEnabled returned %Rrc"), vrc);
    424395
    425396#else  /* !VBOX_WITH_RAW_MODE */
    426     if (aEnable)
     397    if (aCSAMEnabled)
    427398        return setError(VBOX_E_VM_ERROR, tr("CASM not present"), VERR_NOT_SUPPORTED);
    428399#endif /* !VBOX_WITH_RAW_MODE */
    … …  
    436407 * @param   aEnabled     address of result variable
    437408 */
    438 STDMETHODIMP MachineDebugger::COMGETTER(LogEnabled) (BOOL *aEnabled)
    439 {
    440     CheckComArgOutPointerValid(aEnabled);
    441 
    442     AutoCaller autoCaller(this);
    443     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    444 
     409HRESULT MachineDebugger::getLogEnabled(BOOL *aLogEnabled)
     410{
    445411#ifdef LOG_ENABLED
    446412    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    447413
    448414    const PRTLOGGER pLogInstance = RTLogDefaultInstance();
    449     *aEnabled = pLogInstance && !(pLogInstance->fFlags & RTLOGFLAGS_DISABLED);
     415    *aLogEnabled = pLogInstance && !(pLogInstance->fFlags & RTLOGFLAGS_DISABLED);
    450416#else
    451     *aEnabled = false;
     417    *aLogEnabled = false;
    452418#endif
    453419
    … …  
    461427 * @param   aEnabled    The new code log state.
    462428 */
    463 STDMETHODIMP MachineDebugger::COMSETTER(LogEnabled) (BOOL aEnabled)
    464 {
    465     LogFlowThisFunc(("aEnabled=%d\n", aEnabled));
    466 
    467     AutoCaller autoCaller(this);
    468     if (FAILED(autoCaller.rc())) return autoCaller.rc();
     429HRESULT MachineDebugger::setLogEnabled(BOOL aLogEnabled)
     430{
     431    LogFlowThisFunc(("aLogEnabled=%d\n", aLogEnabled));
    469432
    470433    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    471434
    472     if (queueSettings())
     435    if (i_queueSettings())
    473436    {
    474437        // queue the request
    475         mLogEnabledQueued = aEnabled;
     438        mLogEnabledQueued = aLogEnabled;
    476439        return S_OK;
    477440    }
    … …  
    481444
    482445#ifdef LOG_ENABLED
    483     int vrc = DBGFR3LogModifyFlags(ptrVM.rawUVM(), aEnabled ? "enabled" : "disabled");
     446    int vrc = DBGFR3LogModifyFlags(ptrVM.rawUVM(), aLogEnabled ? "enabled" : "disabled");
    484447    if (RT_FAILURE(vrc))
    485448    {
    … …  
    491454}
    492455
    493 HRESULT MachineDebugger::logStringProps(PRTLOGGER pLogger, PFNLOGGETSTR pfnLogGetStr,
    494                                         const char *pszLogGetStr, BSTR *a_pbstrSettings)
    495 {
     456HRESULT MachineDebugger::i_logStringProps(PRTLOGGER pLogger, PFNLOGGETSTR pfnLogGetStr,
     457                                          const char *pszLogGetStr, Utf8Str astrSettings)
     458{
     459    BSTR *a_pbstrSettings = new BSTR;
     460    astrSettings.cloneTo(a_pbstrSettings);
     461
    496462    /* Make sure the VM is powered up. */
    497463    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    541507}
    542508
    543 
    544 STDMETHODIMP MachineDebugger::COMGETTER(LogDbgFlags)(BSTR *a_pbstrSettings)
    545 {
    546     CheckComArgOutPointerValid(a_pbstrSettings);
    547 
    548     AutoCaller autoCaller(this);
    549     HRESULT hrc = autoCaller.rc();
    550     if (SUCCEEDED(hrc))
    551         hrc = logStringProps(RTLogGetDefaultInstance(), RTLogGetFlags, "RTGetFlags", a_pbstrSettings);
    552 
    553     return hrc;
    554 }
    555 
    556 STDMETHODIMP MachineDebugger::COMGETTER(LogDbgGroups)(BSTR *a_pbstrSettings)
    557 {
    558     CheckComArgOutPointerValid(a_pbstrSettings);
    559 
    560     AutoCaller autoCaller(this);
    561     HRESULT hrc = autoCaller.rc();
    562     if (SUCCEEDED(hrc))
    563         hrc = logStringProps(RTLogGetDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", a_pbstrSettings);
    564 
    565     return hrc;
    566 }
    567 
    568 STDMETHODIMP MachineDebugger::COMGETTER(LogDbgDestinations)(BSTR *a_pbstrSettings)
    569 {
    570     CheckComArgOutPointerValid(a_pbstrSettings);
    571 
    572     AutoCaller autoCaller(this);
    573     HRESULT hrc = autoCaller.rc();
    574     if (SUCCEEDED(hrc))
    575         hrc = logStringProps(RTLogGetDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", a_pbstrSettings);
    576 
    577     return hrc;
    578 }
    579 
    580 
    581 STDMETHODIMP MachineDebugger::COMGETTER(LogRelFlags)(BSTR *a_pbstrSettings)
    582 {
    583     CheckComArgOutPointerValid(a_pbstrSettings);
    584 
    585     AutoCaller autoCaller(this);
    586     HRESULT hrc = autoCaller.rc();
    587     if (SUCCEEDED(hrc))
    588         hrc = logStringProps(RTLogRelDefaultInstance(), RTLogGetFlags, "RTGetFlags", a_pbstrSettings);
    589 
    590     return hrc;
    591 }
    592 
    593 STDMETHODIMP MachineDebugger::COMGETTER(LogRelGroups)(BSTR *a_pbstrSettings)
    594 {
    595     CheckComArgOutPointerValid(a_pbstrSettings);
    596 
    597     AutoCaller autoCaller(this);
    598     HRESULT hrc = autoCaller.rc();
    599     if (SUCCEEDED(hrc))
    600         hrc = logStringProps(RTLogRelDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", a_pbstrSettings);
    601 
    602     return hrc;
    603 }
    604 
    605 STDMETHODIMP MachineDebugger::COMGETTER(LogRelDestinations)(BSTR *a_pbstrSettings)
    606 {
    607     CheckComArgOutPointerValid(a_pbstrSettings);
    608 
    609     AutoCaller autoCaller(this);
    610     HRESULT hrc = autoCaller.rc();
    611     if (SUCCEEDED(hrc))
    612         hrc = logStringProps(RTLogRelDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", a_pbstrSettings);
     509HRESULT MachineDebugger::getLogDbgFlags(com::Utf8Str &aLogDbgFlags)
     510{
     511    HRESULT hrc = i_logStringProps(RTLogGetDefaultInstance(), RTLogGetFlags, "RTGetFlags", aLogDbgFlags);
     512
     513    return hrc;
     514}
     515
     516HRESULT MachineDebugger::getLogDbgGroups(com::Utf8Str &aLogDbgGroups)
     517{
     518    HRESULT hrc = i_logStringProps(RTLogGetDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", aLogDbgGroups);
     519
     520    return hrc;
     521}
     522
     523HRESULT MachineDebugger::getLogDbgDestinations(com::Utf8Str &aLogDbgDestinations)
     524{
     525    HRESULT hrc = i_logStringProps(RTLogGetDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", aLogDbgDestinations);
     526    return hrc;
     527}
     528
     529HRESULT MachineDebugger::getLogRelFlags(com::Utf8Str &aLogRelFlags)
     530{
     531    HRESULT hrc = i_logStringProps(RTLogRelDefaultInstance(), RTLogGetFlags, "RTGetFlags", aLogRelFlags);
     532
     533    return hrc;
     534}
     535
     536HRESULT MachineDebugger::getLogRelGroups(com::Utf8Str &aLogRelGroups)
     537{
     538    HRESULT hrc = i_logStringProps(RTLogRelDefaultInstance(), RTLogGetGroupSettings, "RTLogGetGroupSettings", aLogRelGroups);
     539
     540    return hrc;
     541}
     542
     543HRESULT MachineDebugger::getLogRelDestinations(com::Utf8Str &aLogRelDestinations)
     544{
     545    HRESULT hrc = i_logStringProps(RTLogRelDefaultInstance(), RTLogGetDestinations, "RTLogGetDestinations", aLogRelDestinations);
    613546
    614547    return hrc;
    … …  
    621554 * @param   aEnabled address of result variable
    622555 */
    623 STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExEnabled) (BOOL *aEnabled)
    624 {
    625     CheckComArgOutPointerValid(aEnabled);
    626 
    627     AutoCaller autoCaller(this);
    628     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    629 
     556HRESULT MachineDebugger::getHWVirtExEnabled(BOOL *aHWVirtExEnabled)
     557{
    630558    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    631559
    … …  
    633561
    634562    if (ptrVM.isOk())
    635         *aEnabled = HMR3IsEnabled(ptrVM.rawUVM());
     563        *aHWVirtExEnabled = HMR3IsEnabled(ptrVM.rawUVM());
    636564    else
    637         *aEnabled = false;
     565        *aHWVirtExEnabled = false;
    638566
    639567    return S_OK;
    … …  
    646574 * @param   aEnabled address of result variable
    647575 */
    648 STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExNestedPagingEnabled)(BOOL *aEnabled)
    649 {
    650     CheckComArgOutPointerValid(aEnabled);
    651 
    652     AutoCaller autoCaller(this);
    653     if (FAILED(autoCaller.rc()))
    654         return autoCaller.rc();
    655 
     576HRESULT MachineDebugger::getHWVirtExNestedPagingEnabled(BOOL *aHWVirtExNestedPagingEnabled)
     577{
    656578    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    657579
    … …  
    659581
    660582    if (ptrVM.isOk())
    661         *aEnabled = HMR3IsNestedPagingActive(ptrVM.rawUVM());
     583        *aHWVirtExNestedPagingEnabled = HMR3IsNestedPagingActive(ptrVM.rawUVM());
    662584    else
    663         *aEnabled = false;
     585        *aHWVirtExNestedPagingEnabled = false;
    664586
    665587    return S_OK;
    … …  
    672594 * @param   aEnabled address of result variable
    673595 */
    674 STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExVPIDEnabled) (BOOL *aEnabled)
    675 {
    676     CheckComArgOutPointerValid(aEnabled);
    677 
    678     AutoCaller autoCaller(this);
    679     if (FAILED(autoCaller.rc()))
    680         return autoCaller.rc();
    681 
     596HRESULT MachineDebugger::getHWVirtExVPIDEnabled(BOOL *aHWVirtExVPIDEnabled)
     597{
    682598    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    683599
    … …  
    685601
    686602    if (ptrVM.isOk())
    687         *aEnabled = HMR3IsVpidActive(ptrVM.rawUVM());
     603        *aHWVirtExVPIDEnabled = HMR3IsVpidActive(ptrVM.rawUVM());
    688604    else
    689         *aEnabled = false;
     605        *aHWVirtExVPIDEnabled = false;
    690606
    691607    return S_OK;
    … …  
    698614 * @param   aEnabled address of result variable
    699615 */
    700 STDMETHODIMP MachineDebugger::COMGETTER(HWVirtExUXEnabled) (BOOL *aEnabled)
    701 {
    702     CheckComArgOutPointerValid(aEnabled);
    703 
    704     AutoCaller autoCaller(this);
    705     if (FAILED(autoCaller.rc()))
    706         return autoCaller.rc();
    707 
     616HRESULT MachineDebugger::getHWVirtExUXEnabled(BOOL *aHWVirtExUXEnabled)
     617{
    708618    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    709619
    … …  
    711621
    712622    if (ptrVM.isOk())
    713         *aEnabled = HMR3IsUXActive(ptrVM.rawUVM());
     623        *aHWVirtExUXEnabled = HMR3IsUXActive(ptrVM.rawUVM());
    714624    else
    715         *aEnabled = false;
    716 
    717     return S_OK;
    718 }
    719 
    720 STDMETHODIMP MachineDebugger::COMGETTER(OSName)(BSTR *a_pbstrName)
     625        *aHWVirtExUXEnabled = false;
     626
     627    return S_OK;
     628}
     629
     630HRESULT MachineDebugger::getOSName(com::Utf8Str &aOSName)
    721631{
    722632    LogFlowThisFunc(("\n"));
    723     CheckComArgNotNull(a_pbstrName);
    724     AutoCaller autoCaller(this);
    725     HRESULT hrc = autoCaller.rc();
    726     if (SUCCEEDED(hrc))
    727     {
    728         AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     633    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     634    Console::SafeVMPtr ptrVM(mParent);
     635    HRESULT hrc = ptrVM.rc();
     636    if (SUCCEEDED(hrc))
     637    {
     638        /*
     639         * Do the job and try convert the name.
     640         */
     641        char szName[64];
     642        int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.rawUVM(), szName, sizeof(szName), NULL, 0);
     643        if (RT_SUCCESS(vrc))
     644        {
     645            try
     646            {
     647                Bstr bstrName(szName);
     648                aOSName = Utf8Str(bstrName);
     649            }
     650            catch (std::bad_alloc)
     651            {
     652                hrc = E_OUTOFMEMORY;
     653            }
     654        }
     655        else
     656            hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
     657    }
     658    return hrc;
     659}
     660
     661HRESULT MachineDebugger::getOSVersion(com::Utf8Str &aOSVersion)
     662{
     663    LogFlowThisFunc(("\n"));
     664    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     665    Console::SafeVMPtr ptrVM(mParent);
     666    HRESULT hrc = ptrVM.rc();
     667    if (SUCCEEDED(hrc))
     668    {
     669        /*
     670         * Do the job and try convert the name.
     671         */
     672        char szVersion[256];
     673        int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.rawUVM(), NULL, 0, szVersion, sizeof(szVersion));
     674        if (RT_SUCCESS(vrc))
     675        {
     676            try
     677            {
     678                Bstr bstrVersion(szVersion);
     679                aOSVersion = Utf8Str(bstrVersion);
     680            }
     681            catch (std::bad_alloc)
     682            {
     683                hrc = E_OUTOFMEMORY;
     684            }
     685        }
     686        else
     687            hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
     688    }
     689    return hrc;
     690}
     691
     692/**
     693 * Returns the current PAE flag.
     694 *
     695 * @returns COM status code
     696 * @param   aEnabled address of result variable
     697 */
     698HRESULT MachineDebugger::getPAEEnabled(BOOL *aPAEEnabled)
     699{
     700    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     701
     702    Console::SafeVMPtrQuiet ptrVM(mParent);
     703
     704    if (ptrVM.isOk())
     705    {
     706        uint32_t cr4;
     707        int rc = DBGFR3RegCpuQueryU32(ptrVM.rawUVM(), 0 /*idCpu*/,  DBGFREG_CR4, &cr4); AssertRC(rc);
     708        *aPAEEnabled = RT_BOOL(cr4 & X86_CR4_PAE);
     709    }
     710    else
     711        *aPAEEnabled = false;
     712
     713    return S_OK;
     714}
     715
     716/**
     717 * Returns the current virtual time rate.
     718 *
     719 * @returns COM status code.
     720 * @param   a_puPct      Where to store the rate.
     721 */
     722HRESULT MachineDebugger::getVirtualTimeRate(ULONG *aVirtualTimeRate)
     723{
     724    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     725
     726    Console::SafeVMPtr ptrVM(mParent);
     727    HRESULT hrc = ptrVM.rc();
     728    if (SUCCEEDED(hrc))
     729        *aVirtualTimeRate = TMR3GetWarpDrive(ptrVM.rawUVM());
     730
     731    return hrc;
     732}
     733
     734/**
     735 * Returns the current virtual time rate.
     736 *
     737 * @returns COM status code.
     738 * @param   aPct     Where to store the rate.
     739 */
     740HRESULT MachineDebugger::setVirtualTimeRate(ULONG aVirtualTimeRate)
     741{
     742    HRESULT hrc = S_OK;
     743
     744    if (aVirtualTimeRate < 2 || aVirtualTimeRate > 20000)
     745        return setError(E_INVALIDARG, tr("%u is out of range [2..20000]"), aVirtualTimeRate);
     746
     747    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     748    if (i_queueSettings())
     749        mVirtualTimeRateQueued = aVirtualTimeRate;
     750    else
     751    {
    729752        Console::SafeVMPtr ptrVM(mParent);
    730753        hrc = ptrVM.rc();
    731754        if (SUCCEEDED(hrc))
    732755        {
    733             /*
    734              * Do the job and try convert the name.
    735              */
    736             char szName[64];
    737             int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.rawUVM(), szName, sizeof(szName), NULL, 0);
    738             if (RT_SUCCESS(vrc))
    739             {
    740                 try
    741                 {
    742                     Bstr bstrName(szName);
    743                     bstrName.detachTo(a_pbstrName);
    744                 }
    745                 catch (std::bad_alloc)
    746                 {
    747                     hrc = E_OUTOFMEMORY;
    748                 }
    749             }
    750             else
    751                 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
    752         }
    753     }
    754     return hrc;
    755 }
    756 
    757 STDMETHODIMP MachineDebugger::COMGETTER(OSVersion)(BSTR *a_pbstrVersion)
    758 {
    759     LogFlowThisFunc(("\n"));
    760     CheckComArgNotNull(a_pbstrVersion);
    761     AutoCaller autoCaller(this);
    762     HRESULT hrc = autoCaller.rc();
    763     if (SUCCEEDED(hrc))
    764     {
    765         AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    766         Console::SafeVMPtr ptrVM(mParent);
    767         hrc = ptrVM.rc();
    768         if (SUCCEEDED(hrc))
    769         {
    770             /*
    771              * Do the job and try convert the name.
    772              */
    773             char szVersion[256];
    774             int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.rawUVM(), NULL, 0, szVersion, sizeof(szVersion));
    775             if (RT_SUCCESS(vrc))
    776             {
    777                 try
    778                 {
    779                     Bstr bstrVersion(szVersion);
    780                     bstrVersion.detachTo(a_pbstrVersion);
    781                 }
    782                 catch (std::bad_alloc)
    783                 {
    784                     hrc = E_OUTOFMEMORY;
    785                 }
    786             }
    787             else
    788                 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
    789         }
    790     }
    791     return hrc;
    792 }
    793 
    794 /**
    795  * Returns the current PAE flag.
    796  *
    797  * @returns COM status code
    798  * @param   aEnabled address of result variable
    799  */
    800 STDMETHODIMP MachineDebugger::COMGETTER(PAEEnabled) (BOOL *aEnabled)
    801 {
    802     CheckComArgOutPointerValid(aEnabled);
    803 
    804     AutoCaller autoCaller(this);
    805     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    806 
    807     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    808 
    809     Console::SafeVMPtrQuiet ptrVM(mParent);
    810 
    811     if (ptrVM.isOk())
    812     {
    813         uint32_t cr4;
    814         int rc = DBGFR3RegCpuQueryU32(ptrVM.rawUVM(), 0 /*idCpu*/,  DBGFREG_CR4, &cr4); AssertRC(rc);
    815         *aEnabled = RT_BOOL(cr4 & X86_CR4_PAE);
    816     }
    817     else
    818         *aEnabled = false;
    819 
    820     return S_OK;
    821 }
    822 
    823 /**
    824  * Returns the current virtual time rate.
    825  *
    826  * @returns COM status code.
    827  * @param   a_puPct      Where to store the rate.
    828  */
    829 STDMETHODIMP MachineDebugger::COMGETTER(VirtualTimeRate)(ULONG *a_puPct)
    830 {
    831     CheckComArgOutPointerValid(a_puPct);
    832 
    833     AutoCaller autoCaller(this);
    834     HRESULT hrc = autoCaller.rc();
    835     if (SUCCEEDED(hrc))
    836     {
    837         AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    838 
    839         Console::SafeVMPtr ptrVM(mParent);
    840         hrc = ptrVM.rc();
    841         if (SUCCEEDED(hrc))
    842             *a_puPct = TMR3GetWarpDrive(ptrVM.rawUVM());
    843     }
    844 
    845     return hrc;
    846 }
    847 
    848 /**
    849  * Returns the current virtual time rate.
    850  *
    851  * @returns COM status code.
    852  * @param   aPct     Where to store the rate.
    853  */
    854 STDMETHODIMP MachineDebugger::COMSETTER(VirtualTimeRate)(ULONG a_uPct)
    855 {
    856     if (a_uPct < 2 || a_uPct > 20000)
    857         return setError(E_INVALIDARG, tr("%u is out of range [2..20000]"), a_uPct);
    858 
    859     AutoCaller autoCaller(this);
    860     HRESULT hrc = autoCaller.rc();
    861     if (SUCCEEDED(hrc))
    862     {
    863         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    864         if (queueSettings())
    865             mVirtualTimeRateQueued = a_uPct;
    866         else
    867         {
    868             Console::SafeVMPtr ptrVM(mParent);
    869             hrc = ptrVM.rc();
    870             if (SUCCEEDED(hrc))
    871             {
    872                 int vrc = TMR3SetWarpDrive(ptrVM.rawUVM(), a_uPct);
    873                 if (RT_FAILURE(vrc))
    874                     hrc = setError(VBOX_E_VM_ERROR, tr("TMR3SetWarpDrive(, %u) failed with rc=%Rrc"), a_uPct, vrc);
    875             }
     756            int vrc = TMR3SetWarpDrive(ptrVM.rawUVM(), aVirtualTimeRate);
     757            if (RT_FAILURE(vrc))
     758                hrc = setError(VBOX_E_VM_ERROR, tr("TMR3SetWarpDrive(, %u) failed with rc=%Rrc"), aVirtualTimeRate, vrc);
    876759        }
    877760    }
    … …  
    892775 * @remarks Prior to 4.3 this returned PVM.
    893776 */
    894 STDMETHODIMP MachineDebugger::COMGETTER(VM)(LONG64 *a_i64Vm)
    895 {
    896     CheckComArgOutPointerValid(a_i64Vm);
    897 
    898     AutoCaller autoCaller(this);
    899     HRESULT hrc = autoCaller.rc();
    900     if (SUCCEEDED(hrc))
    901     {
    902         AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    903 
    904         Console::SafeVMPtr ptrVM(mParent);
    905         hrc = ptrVM.rc();
    906         if (SUCCEEDED(hrc))
    907         {
    908             VMR3RetainUVM(ptrVM.rawUVM());
    909             *a_i64Vm = (intptr_t)ptrVM.rawUVM();
    910         }
    911 
    912         /*
    913          * Note! ptrVM protection provided by SafeVMPtr is no long effective
    914          *       after we return from this method.
    915          */
    916     }
    917 
     777HRESULT MachineDebugger::getVM(LONG64 *aVM)
     778{
     779    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     780
     781    Console::SafeVMPtr ptrVM(mParent);
     782    HRESULT hrc = ptrVM.rc();
     783    if (SUCCEEDED(hrc))
     784    {
     785        VMR3RetainUVM(ptrVM.rawUVM());
     786        *aVM = (intptr_t)ptrVM.rawUVM();
     787    }
     788
     789    /*
     790     * Note! ptrVM protection provided by SafeVMPtr is no long effective
     791     *       after we return from this method.
     792     */
    918793    return hrc;
    919794}
    … …  
    922797/////////////////////////////////////////////////////////////////////////////
    923798
    924 STDMETHODIMP MachineDebugger::DumpGuestCore(IN_BSTR a_bstrFilename, IN_BSTR a_bstrCompression)
    925 {
    926     CheckComArgStrNotEmptyOrNull(a_bstrFilename);
    927     Utf8Str strFilename(a_bstrFilename);
    928     if (a_bstrCompression && *a_bstrCompression)
     799HRESULT MachineDebugger::dumpGuestCore(const com::Utf8Str &aFilename, const com::Utf8Str &aCompression)
     800{
     801    if (aCompression.length())
    929802        return setError(E_INVALIDARG, tr("The compression parameter must be empty"));
    930803
    931     AutoCaller autoCaller(this);
    932     HRESULT hrc = autoCaller.rc();
    933     if (SUCCEEDED(hrc))
    934     {
    935         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    936         Console::SafeVMPtr ptrVM(mParent);
    937         hrc = ptrVM.rc();
    938         if (SUCCEEDED(hrc))
    939         {
    940             int vrc = DBGFR3CoreWrite(ptrVM.rawUVM(), strFilename.c_str(), false /*fReplaceFile*/);
    941             if (RT_SUCCESS(vrc))
    942                 hrc = S_OK;
    943             else
    944                 hrc = setError(E_FAIL, tr("DBGFR3CoreWrite failed with %Rrc"), vrc);
    945         }
    946     }
    947 
    948     return hrc;
    949 }
    950 
    951 STDMETHODIMP MachineDebugger::DumpHostProcessCore(IN_BSTR a_bstrFilename, IN_BSTR a_bstrCompression)
     804    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     805    Console::SafeVMPtr ptrVM(mParent);
     806    HRESULT hrc = ptrVM.rc();
     807    if (SUCCEEDED(hrc))
     808    {
     809        int vrc = DBGFR3CoreWrite(ptrVM.rawUVM(), aFilename.c_str(), false /*fReplaceFile*/);
     810        if (RT_SUCCESS(vrc))
     811            hrc = S_OK;
     812        else
     813            hrc = setError(E_FAIL, tr("DBGFR3CoreWrite failed with %Rrc"), vrc);
     814    }
     815
     816    return hrc;
     817}
     818
     819HRESULT MachineDebugger::dumpHostProcessCore(const com::Utf8Str &aFilename, const com::Utf8Str &aCompression)
    952820{
    953821    ReturnComNotImplemented();
    … …  
    1062930}
    1063931
    1064 STDMETHODIMP MachineDebugger::Info(IN_BSTR a_bstrName, IN_BSTR a_bstrArgs, BSTR *a_pbstrInfo)
     932HRESULT MachineDebugger::info(const com::Utf8Str &aName, const com::Utf8Str &aArgs, com::Utf8Str &aInfo)
    1065933{
    1066934    LogFlowThisFunc(("\n"));
    1067 
    1068     /*
    1069      * Validate and convert input.
    1070      */
    1071     CheckComArgStrNotEmptyOrNull(a_bstrName);
    1072     Utf8Str strName, strArgs;
    1073     try
    1074     {
    1075         strName = a_bstrName;
    1076         strArgs = a_bstrArgs;
    1077     }
    1078     catch (std::bad_alloc)
    1079     {
    1080         return E_OUTOFMEMORY;
    1081     }
    1082935
    1083936    /*
    … …  
    1098951            MACHINEDEBUGGERINOFHLP Hlp;
    1099952            MachineDebuggerInfoInit(&Hlp);
    1100             int vrc = DBGFR3Info(ptrVM.rawUVM(),  strName.c_str(),  strArgs.c_str(), &Hlp.Core);
     953            int vrc = DBGFR3Info(ptrVM.rawUVM(),  aName.c_str(),  aArgs.c_str(), &Hlp.Core);
    1101954            if (RT_SUCCESS(vrc))
    1102955            {
    … …  
    1109962                    {
    1110963                        Bstr bstrInfo(Hlp.pszBuf);
    1111                         bstrInfo.detachTo(a_pbstrInfo);
     964                        aInfo = bstrInfo;
    1112965                    }
    1113966                    catch (std::bad_alloc)
    … …  
    1127980}
    1128981
    1129 STDMETHODIMP MachineDebugger::InjectNMI()
     982HRESULT MachineDebugger::injectNMI()
    1130983{
    1131984    LogFlowThisFunc(("\n"));
    1132985
    1133     AutoCaller autoCaller(this);
    1134     HRESULT hrc = autoCaller.rc();
    1135     if (SUCCEEDED(hrc))
    1136     {
    1137         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1138         Console::SafeVMPtr ptrVM(mParent);
    1139         hrc = ptrVM.rc();
    1140         if (SUCCEEDED(hrc))
    1141         {
    1142             int vrc = DBGFR3InjectNMI(ptrVM.rawUVM(), 0);
    1143             if (RT_SUCCESS(vrc))
    1144                 hrc = S_OK;
    1145             else
    1146                 hrc = setError(E_FAIL, tr("DBGFR3InjectNMI failed with %Rrc"), vrc);
    1147         }
    1148     }
    1149     return hrc;
    1150 }
    1151 
    1152 STDMETHODIMP MachineDebugger::ModifyLogFlags(IN_BSTR a_bstrSettings)
    1153 {
    1154     CheckComArgStrNotEmptyOrNull(a_bstrSettings);
    1155     Utf8Str strSettings(a_bstrSettings);
    1156 
    1157     LogFlowThisFunc(("a_bstrSettings=%s\n", strSettings.c_str()));
    1158     AutoCaller autoCaller(this);
    1159     HRESULT hrc = autoCaller.rc();
    1160     if (SUCCEEDED(hrc))
    1161     {
    1162         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1163         Console::SafeVMPtr ptrVM(mParent);
    1164         hrc = ptrVM.rc();
    1165         if (SUCCEEDED(hrc))
    1166         {
    1167             int vrc = DBGFR3LogModifyFlags(ptrVM.rawUVM(), strSettings.c_str());
    1168             if (RT_SUCCESS(vrc))
    1169                 hrc = S_OK;
    1170             else
    1171                 hrc = setError(E_FAIL, tr("DBGFR3LogModifyFlags failed with %Rrc"), vrc);
    1172         }
    1173     }
    1174     return hrc;
    1175 }
    1176 
    1177 STDMETHODIMP MachineDebugger::ModifyLogGroups(IN_BSTR a_bstrSettings)
    1178 {
    1179     CheckComArgStrNotEmptyOrNull(a_bstrSettings);
    1180     Utf8Str strSettings(a_bstrSettings);
    1181 
    1182     LogFlowThisFunc(("a_bstrSettings=%s\n", strSettings.c_str()));
    1183     AutoCaller autoCaller(this);
    1184     HRESULT hrc = autoCaller.rc();
    1185     if (SUCCEEDED(hrc))
    1186     {
    1187         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1188         Console::SafeVMPtr ptrVM(mParent);
    1189         hrc = ptrVM.rc();
    1190         if (SUCCEEDED(hrc))
    1191         {
    1192             int vrc = DBGFR3LogModifyGroups(ptrVM.rawUVM(), strSettings.c_str());
    1193             if (RT_SUCCESS(vrc))
    1194                 hrc = S_OK;
    1195             else
    1196                 hrc = setError(E_FAIL, tr("DBGFR3LogModifyGroups failed with %Rrc"), vrc);
    1197         }
    1198     }
    1199     return hrc;
    1200 }
    1201 
    1202 STDMETHODIMP MachineDebugger::ModifyLogDestinations(IN_BSTR a_bstrSettings)
    1203 {
    1204     CheckComArgStrNotEmptyOrNull(a_bstrSettings);
    1205     Utf8Str strSettings(a_bstrSettings);
    1206 
    1207     LogFlowThisFunc(("a_bstrSettings=%s\n", strSettings.c_str()));
    1208     AutoCaller autoCaller(this);
    1209     HRESULT hrc = autoCaller.rc();
    1210     if (SUCCEEDED(hrc))
    1211     {
    1212         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1213         Console::SafeVMPtr ptrVM(mParent);
    1214         hrc = ptrVM.rc();
    1215         if (SUCCEEDED(hrc))
    1216         {
    1217             int vrc = DBGFR3LogModifyDestinations(ptrVM.rawUVM(), strSettings.c_str());
    1218             if (RT_SUCCESS(vrc))
    1219                 hrc = S_OK;
    1220             else
    1221                 hrc = setError(E_FAIL, tr("DBGFR3LogModifyDestinations failed with %Rrc"), vrc);
    1222         }
    1223     }
    1224     return hrc;
    1225 }
    1226 
    1227 STDMETHODIMP MachineDebugger::ReadPhysicalMemory(LONG64 a_Address, ULONG a_cbRead, ComSafeArrayOut(BYTE, a_abData))
     986    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     987    Console::SafeVMPtr ptrVM(mParent);
     988    HRESULT hrc = ptrVM.rc();
     989    if (SUCCEEDED(hrc))
     990    {
     991        int vrc = DBGFR3InjectNMI(ptrVM.rawUVM(), 0);
     992        if (RT_SUCCESS(vrc))
     993            hrc = S_OK;
     994        else
     995            hrc = setError(E_FAIL, tr("DBGFR3InjectNMI failed with %Rrc"), vrc);
     996    }
     997    return hrc;
     998}
     999
     1000HRESULT MachineDebugger::modifyLogFlags(const com::Utf8Str &aSettings)
     1001{
     1002    LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
     1003    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1004    Console::SafeVMPtr ptrVM(mParent);
     1005    HRESULT hrc = ptrVM.rc();
     1006    if (SUCCEEDED(hrc))
     1007    {
     1008        int vrc = DBGFR3LogModifyFlags(ptrVM.rawUVM(), aSettings.c_str());
     1009        if (RT_SUCCESS(vrc))
     1010            hrc = S_OK;
     1011        else
     1012            hrc = setError(E_FAIL, tr("DBGFR3LogModifyFlags failed with %Rrc"), vrc);
     1013    }
     1014    return hrc;
     1015}
     1016
     1017HRESULT MachineDebugger::modifyLogGroups(const com::Utf8Str &aSettings)
     1018{
     1019    LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
     1020    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1021    Console::SafeVMPtr ptrVM(mParent);
     1022    HRESULT hrc = ptrVM.rc();
     1023    if (SUCCEEDED(hrc))
     1024    {
     1025        int vrc = DBGFR3LogModifyGroups(ptrVM.rawUVM(), aSettings.c_str());
     1026        if (RT_SUCCESS(vrc))
     1027            hrc = S_OK;
     1028        else
     1029            hrc = setError(E_FAIL, tr("DBGFR3LogModifyGroups failed with %Rrc"), vrc);
     1030    }
     1031    return hrc;
     1032}
     1033
     1034HRESULT MachineDebugger::modifyLogDestinations(const com::Utf8Str &aSettings)
     1035{
     1036    LogFlowThisFunc(("aSettings=%s\n", aSettings.c_str()));
     1037    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1038    Console::SafeVMPtr ptrVM(mParent);
     1039    HRESULT hrc = ptrVM.rc();
     1040    if (SUCCEEDED(hrc))
     1041    {
     1042        int vrc = DBGFR3LogModifyDestinations(ptrVM.rawUVM(), aSettings.c_str());
     1043        if (RT_SUCCESS(vrc))
     1044            hrc = S_OK;
     1045        else
     1046            hrc = setError(E_FAIL, tr("DBGFR3LogModifyDestinations failed with %Rrc"), vrc);
     1047    }
     1048    return hrc;
     1049}
     1050
     1051HRESULT MachineDebugger::readPhysicalMemory(LONG64 aAddress, ULONG aSize, std::vector<BYTE> &aBytes)
    12281052{
    12291053    ReturnComNotImplemented();
    12301054}
    12311055
    1232 STDMETHODIMP MachineDebugger::WritePhysicalMemory(LONG64 a_Address, ULONG a_cbRead, ComSafeArrayIn(BYTE, a_abData))
     1056HRESULT MachineDebugger::writePhysicalMemory(LONG64 aAddress, ULONG aSize, const std::vector<BYTE> &aBytes)
    12331057{
    12341058    ReturnComNotImplemented();
    12351059}
    12361060
    1237 STDMETHODIMP MachineDebugger::ReadVirtualMemory(ULONG a_idCpu, LONG64 a_Address, ULONG a_cbRead, ComSafeArrayOut(BYTE, a_abData))
     1061HRESULT MachineDebugger::readVirtualMemory(ULONG aCpuId, LONG64 aAddress, ULONG aSize, std::vector<BYTE> &aBytes)
    12381062{
    12391063    ReturnComNotImplemented();
    12401064}
    12411065
    1242 STDMETHODIMP MachineDebugger::WriteVirtualMemory(ULONG a_idCpu, LONG64 a_Address, ULONG a_cbRead, ComSafeArrayIn(BYTE, a_abData))
     1066HRESULT MachineDebugger::writeVirtualMemory(ULONG aCpuId, LONG64 aAddress, ULONG aSize, const std::vector<BYTE> &aBytes)
    12431067{
    12441068    ReturnComNotImplemented();
    12451069}
    12461070
    1247 STDMETHODIMP MachineDebugger::DetectOS(BSTR *a_pbstrName)
     1071HRESULT MachineDebugger::detectOS(com::Utf8Str &aOs)
    12481072{
    12491073    LogFlowThisFunc(("\n"));
    1250     CheckComArgNotNull(a_pbstrName);
    12511074
    12521075    /*
    12531076     * Do the autocaller and lock bits.
    12541077     */
    1255     AutoCaller autoCaller(this);
    1256     HRESULT hrc = autoCaller.rc();
    1257     if (SUCCEEDED(hrc))
    1258     {
    1259         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1260         Console::SafeVMPtr ptrVM(mParent);
    1261         hrc = ptrVM.rc();
    1262         if (SUCCEEDED(hrc))
     1078    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1079    Console::SafeVMPtr ptrVM(mParent);
     1080    HRESULT hrc = ptrVM.rc();
     1081    if (SUCCEEDED(hrc))
     1082    {
     1083        /*
     1084         * Do the job and try convert the name.
     1085         */
     1086/** @todo automatically load the DBGC plugins or this is a waste of time. */
     1087        char szName[64];
     1088        int vrc = DBGFR3OSDetect(ptrVM.rawUVM(), szName, sizeof(szName));
     1089        if (RT_SUCCESS(vrc) && vrc != VINF_DBGF_OS_NOT_DETCTED)
    12631090        {
    1264             /*
    1265              * Do the job and try convert the name.
    1266              */
    1267 /** @todo automatically load the DBGC plugins or this is a waste of time. */
    1268             char szName[64];
    1269             int vrc = DBGFR3OSDetect(ptrVM.rawUVM(), szName, sizeof(szName));
    1270             if (RT_SUCCESS(vrc) && vrc != VINF_DBGF_OS_NOT_DETCTED)
     1091            try
    12711092            {
    1272                 try
    1273                 {
    1274                     Bstr bstrName(szName);
    1275                     bstrName.detachTo(a_pbstrName);
    1276                 }
    1277                 catch (std::bad_alloc)
    1278                 {
    1279                     hrc = E_OUTOFMEMORY;
    1280                 }
     1093                Bstr bstrName(szName);
     1094                aOs = Utf8Str(bstrName);
    12811095            }
    1282             else
    1283                 hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSDetect failed with %Rrc"), vrc);
     1096            catch (std::bad_alloc)
     1097            {
     1098                hrc = E_OUTOFMEMORY;
     1099            }
    12841100        }
     1101        else
     1102            hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSDetect failed with %Rrc"), vrc);
    12851103    }
    12861104    return hrc;
    … …  
    13071125}
    13081126
    1309 STDMETHODIMP MachineDebugger::GetRegister(ULONG a_idCpu, IN_BSTR a_bstrName, BSTR *a_pbstrValue)
    1310 {
    1311     /*
    1312      * Validate and convert input.
    1313      */
    1314     CheckComArgStrNotEmptyOrNull(a_bstrName);
    1315     CheckComArgNotNull(a_pbstrValue);
    1316     Utf8Str strName;
    1317     try
    1318     {
    1319         strName = a_bstrName;
    1320     }
    1321     catch (std::bad_alloc)
    1322     {
    1323         return E_OUTOFMEMORY;
    1324     }
    1325 
     1127HRESULT MachineDebugger::getRegister(ULONG aCpuId, const com::Utf8Str &aName, com::Utf8Str &aValue)
     1128{
    13261129    /*
    13271130     * The prologue.
    13281131     */
    13291132    LogFlowThisFunc(("\n"));
    1330     AutoCaller autoCaller(this);
    1331     HRESULT hrc = autoCaller.rc();
    1332     if (SUCCEEDED(hrc))
    1333     {
    1334         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1335         Console::SafeVMPtr ptrVM(mParent);
    1336         hrc = ptrVM.rc();
    1337         if (SUCCEEDED(hrc))
     1133    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1134    Console::SafeVMPtr ptrVM(mParent);
     1135    HRESULT hrc = ptrVM.rc();
     1136    if (SUCCEEDED(hrc))
     1137    {
     1138        /*
     1139         * Real work.
     1140         */
     1141        DBGFREGVAL      Value;
     1142        DBGFREGVALTYPE  enmType;
     1143        int vrc = DBGFR3RegNmQuery(ptrVM.rawUVM(), aCpuId, aName.c_str(), &Value, &enmType);
     1144        if (RT_SUCCESS(vrc))
    13381145        {
    1339             /*
    1340              * Real work.
    1341              */
    1342             DBGFREGVAL      Value;
    1343             DBGFREGVALTYPE  enmType;
    1344             int vrc = DBGFR3RegNmQuery(ptrVM.rawUVM(), a_idCpu, strName.c_str(), &Value, &enmType);
    1345             if (RT_SUCCESS(vrc))
     1146            try
    13461147            {
    1347                 try
    1348                 {
    1349                     Bstr bstrValue;
    1350                     hrc = formatRegisterValue(&bstrValue, &Value, enmType);
    1351                     if (SUCCEEDED(hrc))
    1352                         bstrValue.detachTo(a_pbstrValue);
    1353                 }
    1354                 catch (std::bad_alloc)
    1355                 {
    1356                     hrc = E_OUTOFMEMORY;
    1357                 }
     1148                Bstr bstrValue;
     1149                hrc = formatRegisterValue(&bstrValue, &Value, enmType);
     1150                if (SUCCEEDED(hrc))
     1151                    aValue = Utf8Str(bstrValue);
    13581152            }
    1359             else if (vrc == VERR_DBGF_REGISTER_NOT_FOUND)
    1360                 hrc = setError(E_FAIL, tr("Register '%s' was not found"), strName.c_str());
    1361             else if (vrc == VERR_INVALID_CPU_ID)
    1362                 hrc = setError(E_FAIL, tr("Invalid CPU ID: %u"), a_idCpu);
    1363             else
    1364                 hrc = setError(VBOX_E_VM_ERROR,
    1365                                tr("DBGFR3RegNmQuery failed with rc=%Rrc querying register '%s' with default cpu set to %u"),
    1366                                vrc, strName.c_str(), a_idCpu);
     1153            catch (std::bad_alloc)
     1154            {
     1155                hrc = E_OUTOFMEMORY;
     1156            }
    13671157        }
    1368     }
    1369 
    1370     return hrc;
    1371 }
    1372 
    1373 STDMETHODIMP MachineDebugger::GetRegisters(ULONG a_idCpu, ComSafeArrayOut(BSTR, a_bstrNames), ComSafeArrayOut(BSTR, a_bstrValues))
     1158        else if (vrc == VERR_DBGF_REGISTER_NOT_FOUND)
     1159            hrc = setError(E_FAIL, tr("Register '%s' was not found"), aName.c_str());
     1160        else if (vrc == VERR_INVALID_CPU_ID)
     1161            hrc = setError(E_FAIL, tr("Invalid CPU ID: %u"), aCpuId);
     1162        else
     1163            hrc = setError(VBOX_E_VM_ERROR,
     1164                           tr("DBGFR3RegNmQuery failed with rc=%Rrc querying register '%s' with default cpu set to %u"),
     1165                           vrc, aName.c_str(), aCpuId);
     1166    }
     1167
     1168    return hrc;
     1169}
     1170
     1171HRESULT MachineDebugger::getRegisters(ULONG aCpuId, std::vector<com::Utf8Str> &aNames, std::vector<com::Utf8Str> &aValues)
    13741172{
    13751173    /*
    … …  
    13771175     */
    13781176    LogFlowThisFunc(("\n"));
    1379     AutoCaller autoCaller(this);
    1380     HRESULT hrc = autoCaller.rc();
    1381     if (SUCCEEDED(hrc))
    1382     {
    1383         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    1384         Console::SafeVMPtr ptrVM(mParent);
    1385         hrc = ptrVM.rc();
    1386         if (SUCCEEDED(hrc))
     1177    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     1178    Console::SafeVMPtr ptrVM(mParent);
     1179    HRESULT hrc = ptrVM.rc();
     1180    if (SUCCEEDED(hrc))
     1181    {
     1182        /*
     1183         * Real work.
     1184         */
     1185        size_t cRegs;
     1186        int vrc = DBGFR3RegNmQueryAllCount(ptrVM.rawUVM(), &cRegs);
     1187        if (RT_SUCCESS(vrc))
    13871188        {
    1388             /*
    1389              * Real work.
    1390              */
    1391             size_t cRegs;
    1392             int vrc = DBGFR3RegNmQueryAllCount(ptrVM.rawUVM(), &cRegs);
    1393             if (RT_SUCCESS(vrc))
     1189            PDBGFREGENTRYNM paRegs = (PDBGFREGENTRYNM)RTMemAllocZ(sizeof(paRegs[0]) * cRegs);
     1190            if (paRegs)
    13941191            {
    1395                 PDBGFREGENTRYNM paRegs = (PDBGFREGENTRYNM)RTMemAllocZ(sizeof(paRegs[0]) * cRegs);
    1396                 if (paRegs)
     1192                vrc = DBGFR3RegNmQueryAll(ptrVM.rawUVM(), paRegs, cRegs);
     1193                if (RT_SUCCESS(vrc))
    13971194                {
    1398                     vrc = DBGFR3RegNmQueryAll(ptrVM.rawUVM(), paRegs, cRegs);
    1399                     if (RT_SUCCESS(vrc))
     1195                    try
    14001196                    {
    1401                         try
     1197
     1198                        for (uint32_t iReg = 0; iReg < cRegs; iReg++)
    14021199                        {
    1403                             com::SafeArray<BSTR> abstrNames(cRegs);
    1404                             com::SafeArray<BSTR> abstrValues(cRegs);
    1405 
    1406                             for (uint32_t iReg = 0; iReg < cRegs; iReg++)
    1407                             {
    1408                                 Bstr bstrValue;
    1409 
    1410                                 hrc = formatRegisterValue(&bstrValue, &paRegs[iReg].Val, paRegs[iReg].enmType);
    1411                                 AssertComRC(hrc);
    1412                                 bstrValue.detachTo(&abstrValues[iReg]);
    1413 
    1414                                 Bstr bstrName(paRegs[iReg].pszName);
    1415                                 bstrName.detachTo(&abstrNames[iReg]);
    1416                             }
    1417 
    1418                             abstrNames.detachTo(ComSafeArrayOutArg(a_bstrNames));
    1419                             abstrValues.detachTo(ComSafeArrayOutArg(a_bstrValues));
    1420                         }
    1421                         catch (std::bad_alloc)
    1422                         {
    1423                             hrc = E_OUTOFMEMORY;
     1200                            Bstr bstrValue;
     1201
     1202                            hrc = formatRegisterValue(&bstrValue, &paRegs[iReg].Val, paRegs[iReg].enmType);
     1203                            AssertComRC(hrc);
     1204                            aNames[iReg] = Utf8Str(paRegs[iReg].pszName);
     1205                            aValues[iReg] = Utf8Str(bstrValue);
    14241206                        }
    14251207                    }
    1426                     else
    1427                         hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAll failed with %Rrc"), vrc);
    1428 
    1429                     RTMemFree(paRegs);
     1208                    catch (std::bad_alloc)
     1209                    {
     1210                        hrc = E_OUTOFMEMORY;
     1211                    }
    14301212                }
    14311213                else
    1432                     hrc = E_OUTOFMEMORY;
     1214                    hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAll failed with %Rrc"), vrc);
     1215
     1216                RTMemFree(paRegs);
    14331217            }
    14341218            else
    1435                 hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAllCount failed with %Rrc"), vrc);
     1219                hrc = E_OUTOFMEMORY;
    14361220        }
    1437     }
    1438     return hrc;
    1439 }
    1440 
    1441 STDMETHODIMP MachineDebugger::SetRegister(ULONG a_idCpu, IN_BSTR a_bstrName, IN_BSTR a_bstrValue)
     1221        else
     1222            hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAllCount failed with %Rrc"), vrc);
     1223    }
     1224    return hrc;
     1225}
     1226
     1227HRESULT MachineDebugger::setRegister(ULONG aCpuId, const com::Utf8Str &aName, const com::Utf8Str &aValue)
    14421228{
    14431229    ReturnComNotImplemented();
    14441230}
    14451231
    1446 STDMETHODIMP MachineDebugger::SetRegisters(ULONG a_idCpu, ComSafeArrayIn(IN_BSTR, a_bstrNames), ComSafeArrayIn(IN_BSTR, a_bstrValues))
     1232HRESULT MachineDebugger::setRegisters(ULONG aCpuId, const std::vector<com::Utf8Str> &aNames,
     1233                                      const std::vector<com::Utf8Str> &aValues)
    14471234{
    14481235    ReturnComNotImplemented();
    14491236}
    14501237
    1451 STDMETHODIMP MachineDebugger::DumpGuestStack(ULONG a_idCpu, BSTR *a_pbstrStack)
     1238HRESULT MachineDebugger::dumpGuestStack(ULONG aCpuId, com::Utf8Str &aStack)
    14521239{
    14531240    ReturnComNotImplemented();
    … …  
    14601247 * @param   aPattern            The selection pattern. A bit similar to filename globbing.
    14611248 */
    1462 STDMETHODIMP MachineDebugger::ResetStats(IN_BSTR aPattern)
     1249HRESULT MachineDebugger::resetStats(const com::Utf8Str &aPattern)
    14631250{
    14641251    Console::SafeVMPtrQuiet ptrVM(mParent);
    … …  
    14671254        return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
    14681255
    1469     STAMR3Reset(ptrVM.rawUVM(), Utf8Str(aPattern).c_str());
     1256    STAMR3Reset(ptrVM.rawUVM(), aPattern.c_str());
    14701257
    14711258    return S_OK;
    … …  
    14781265 * @param   aPattern            The selection pattern. A bit similar to filename globbing.
    14791266 */
    1480 STDMETHODIMP MachineDebugger::DumpStats(IN_BSTR aPattern)
     1267HRESULT MachineDebugger::dumpStats(const com::Utf8Str &aPattern)
    14811268{
    14821269    Console::SafeVMPtrQuiet ptrVM(mParent);
    … …  
    14851272        return setError(VBOX_E_INVALID_VM_STATE, "Machine is not running");
    14861273
    1487     STAMR3Dump(ptrVM.rawUVM(), Utf8Str(aPattern).c_str());
     1274    STAMR3Dump(ptrVM.rawUVM(), aPattern.c_str());
    14881275
    14891276    return S_OK;
    … …  
    14981285 * @param   aStats              The XML document containing the statistics.
    14991286 */
    1500 STDMETHODIMP MachineDebugger::GetStats (IN_BSTR aPattern, BOOL aWithDescriptions, BSTR *aStats)
     1287HRESULT MachineDebugger::getStats(const com::Utf8Str &aPattern, BOOL aWithDescriptions, com::Utf8Str &aStats)
    15011288{
    15021289    Console::SafeVMPtrQuiet ptrVM (mParent);
    … …  
    15061293
    15071294    char *pszSnapshot;
    1508     int vrc = STAMR3Snapshot(ptrVM.rawUVM(), Utf8Str(aPattern).c_str(), &pszSnapshot, NULL,
     1295    int vrc = STAMR3Snapshot(ptrVM.rawUVM(), aPattern.c_str(), &pszSnapshot, NULL,
    15091296                             !!aWithDescriptions);
    15101297    if (RT_FAILURE(vrc))
    … …  
    15151302     * Until that's done, this method is kind of useless for debugger statistics GUI because
    15161303     * of the amount statistics in a debug build. */
    1517     Bstr(pszSnapshot).detachTo(aStats);
     1304    aStats = Utf8Str(pszSnapshot);
    15181305    STAMR3SnapshotFree(ptrVM.rawUVM(), pszSnapshot);
    15191306
    … …  
    15251312/////////////////////////////////////////////////////////////////////////////
    15261313
    1527 void MachineDebugger::flushQueuedSettings()
     1314void MachineDebugger::i_flushQueuedSettings()
    15281315{
    15291316    mFlushMode = true;
    … …  
    15361323        if (maiQueuedEmExecPolicyParams[i] != UINT8_MAX)
    15371324        {
    1538             setEmExecPolicyProperty((EMEXECPOLICY)i, RT_BOOL(maiQueuedEmExecPolicyParams[i]));
     1325            i_setEmExecPolicyProperty((EMEXECPOLICY)i, RT_BOOL(maiQueuedEmExecPolicyParams[i]));
    15391326            maiQueuedEmExecPolicyParams[i] = UINT8_MAX;
    15401327        }
    … …  
    15651352/////////////////////////////////////////////////////////////////////////////
    15661353
    1567 bool MachineDebugger::queueSettings() const
     1354bool MachineDebugger::i_queueSettings() const
    15681355{
    15691356    if (!mFlushMode)

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

    r50530 r51092  
    153153
    154154/* Called by VRDP server when the client responds to a request on USB channel. */
    155 DECLCALLBACK(int) USBClientResponseCallback (void *pv, uint32_t u32ClientId, uint8_t code, const void *pvRet, uint32_t cbRet)
     155DECLCALLBACK(int) USBClientResponseCallback(void *pv, uint32_t u32ClientId, uint8_t code, const void *pvRet, uint32_t cbRet)
    156156{
    157157    int rc = VINF_SUCCESS;
    … …  
    166166        case VRDE_USB_REQ_DEVICE_LIST:
    167167        {
    168             rc = pThis->saveDeviceList (pvRet, cbRet);
     168            rc = pThis->saveDeviceList(pvRet, cbRet);
    169169        } break;
    170170
    171171        case VRDE_USB_REQ_NEGOTIATE:
    172172        {
    173             if (pvRet && cbRet >= sizeof (VRDEUSBREQNEGOTIATERET))
     173            if (pvRet && cbRet >= sizeof(VRDEUSBREQNEGOTIATERET))
    174174            {
    175175                VRDEUSBREQNEGOTIATERET *pret = (VRDEUSBREQNEGOTIATERET *)pvRet;
    176176
    177                 rc = pThis->negotiateResponse (pret, cbRet);
     177                rc = pThis->negotiateResponse(pret, cbRet);
    178178            }
    179179            else
    180180            {
    181181                Log(("USBClientResponseCallback: WARNING: not enough data in response: pv = %p, cb = %d, expected %d.\n",
    182                      pvRet, cbRet, sizeof (VRDEUSBREQNEGOTIATERET)));
     182                     pvRet, cbRet, sizeof(VRDEUSBREQNEGOTIATERET)));
    183183
    184184                rc = VERR_INVALID_PARAMETER;
    … …  
    188188        case VRDE_USB_REQ_REAP_URB:
    189189        {
    190             rc = pThis->reapURB (pvRet, cbRet);
     190            rc = pThis->reapURB(pvRet, cbRet);
    191191
    192192            LogFlow(("USBClientResponseCallback: reap URB, rc = %Rrc.\n", rc));
    … …  
    212212             * Device specific responses with status codes.
    213213             */
    214             if (pvRet && cbRet >= sizeof (VRDEUSBREQRETHDR))
     214            if (pvRet && cbRet >= sizeof(VRDEUSBREQRETHDR))
    215215            {
    216216                VRDEUSBREQRETHDR *pret = (VRDEUSBREQRETHDR *)pvRet;
    … …  
    218218                if (pret->status != VRDE_USB_STATUS_SUCCESS)
    219219                {
    220                     REMOTEUSBDEVICE *pDevice = pThis->deviceFromId (pret->id);
     220                    REMOTEUSBDEVICE *pDevice = pThis->deviceFromId(pret->id);
    221221
    222222                    if (!pDevice)
    … …  
    235235            {
    236236                Log(("USBClientResponseCallback: WARNING: not enough data in response: pv = %p, cb = %d, expected %d.\n",
    237                      pvRet, cbRet, sizeof (VRDEUSBREQRETHDR)));
     237                     pvRet, cbRet, sizeof(VRDEUSBREQRETHDR)));
    238238            }
    239239        } break;
    … …  
    251251 * Backend entry points.
    252252 */
    253 static DECLCALLBACK(int) iface_Open (PREMOTEUSBBACKEND pInstance, const char *pszAddress, size_t cbAddress, PREMOTEUSBDEVICE *ppDevice)
     253static DECLCALLBACK(int) iface_Open(PREMOTEUSBBACKEND pInstance, const char *pszAddress,
     254                                    size_t cbAddress, PREMOTEUSBDEVICE *ppDevice)
    254255{
    255256    int rc = VINF_SUCCESS;
    … …  
    257258    RemoteUSBBackend *pThis = (RemoteUSBBackend *)pInstance;
    258259
    259     REMOTEUSBDEVICE *pDevice = (REMOTEUSBDEVICE *)RTMemAllocZ (sizeof (REMOTEUSBDEVICE));
     260    REMOTEUSBDEVICE *pDevice = (REMOTEUSBDEVICE *)RTMemAllocZ(sizeof(REMOTEUSBDEVICE));
    260261
    261262    if (!pDevice)
    … …  
    269270         * and CCCCDDDD is hex client id.
    270271         */
    271         if (strncmp (pszAddress, REMOTE_USB_BACKEND_PREFIX_S, REMOTE_USB_BACKEND_PREFIX_LEN) != 0)
     272        if (strncmp(pszAddress, REMOTE_USB_BACKEND_PREFIX_S, REMOTE_USB_BACKEND_PREFIX_LEN) != 0)
    272273        {
    273274            AssertFailed();
    … …  
    285286            if (RT_SUCCESS(rc))
    286287            {
    287                 pDevice->id = RTStrToUInt32 (&pszAddress[REMOTE_USB_BACKEND_PREFIX_LEN]);
    288 
    289                 size_t l = strlen (pszAddress);
    290 
    291                 if (l >= REMOTE_USB_BACKEND_PREFIX_LEN + strlen ("0x12345678&0x87654321"))
     288                pDevice->id = RTStrToUInt32(&pszAddress[REMOTE_USB_BACKEND_PREFIX_LEN]);
     289
     290                size_t l = strlen(pszAddress);
     291
     292                if (l >= REMOTE_USB_BACKEND_PREFIX_LEN + strlen("0x12345678&0x87654321"))
    292293                {
    293                     const char *p = &pszAddress[REMOTE_USB_BACKEND_PREFIX_LEN + strlen ("0x12345678")];
     294                    const char *p = &pszAddress[REMOTE_USB_BACKEND_PREFIX_LEN + strlen("0x12345678")];
    294295                    if (*p == '&')
    295296                    {
    296                         pDevice->u32ClientId = RTStrToUInt32 (p + 1);
     297                        pDevice->u32ClientId = RTStrToUInt32(p + 1);
    297298                    }
    298299                    else
    299300                    {
    300                         AssertFailed ();
     301                        AssertFailed();
    301302                        rc = VERR_INVALID_PARAMETER;
    302303                    }
    … …  
    304305                else
    305306                {
    306                     AssertFailed ();
     307                    AssertFailed();
    307308                    rc = VERR_INVALID_PARAMETER;
    308309                }
    … …  
    315316                    parm.id = pDevice->id;
    316317
    317                     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     318                    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    318319                }
    319320            }
    … …  
    325326        *ppDevice = pDevice;
    326327
    327         pThis->addDevice (pDevice);
     328        pThis->addDevice(pDevice);
    328329    }
    329330    else
    330331    {
    331         RTMemFree (pDevice);
     332        RTMemFree(pDevice);
    332333    }
    333334
    … …  
    335336}
    336337
    337 static DECLCALLBACK(void) iface_Close (PREMOTEUSBDEVICE pDevice)
     338static DECLCALLBACK(void) iface_Close(PREMOTEUSBDEVICE pDevice)
    338339{
    339340    RemoteUSBBackend *pThis = pDevice->pOwner;
    … …  
    344345    parm.id = pDevice->id;
    345346
    346     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
    347 
    348     pThis->removeDevice (pDevice);
    349 
    350     if (RTCritSectIsInitialized (&pDevice->critsect))
    351     {
    352         RTCritSectDelete (&pDevice->critsect);
    353     }
    354 
    355     RTMemFree (pDevice);
     347    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
     348
     349    pThis->removeDevice(pDevice);
     350
     351    if (RTCritSectIsInitialized(&pDevice->critsect))
     352    {
     353        RTCritSectDelete(&pDevice->critsect);
     354    }
     355
     356    RTMemFree(pDevice);
    356357
    357358    return;
    358359}
    359360
    360 static DECLCALLBACK(int) iface_Reset (PREMOTEUSBDEVICE pDevice)
     361static DECLCALLBACK(int) iface_Reset(PREMOTEUSBDEVICE pDevice)
    361362{
    362363    RemoteUSBBackend *pThis = pDevice->pOwner;
    … …  
    372373    parm.id = pDevice->id;
    373374
    374     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     375    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    375376
    376377    return VINF_SUCCESS;
    377378}
    378379
    379 static DECLCALLBACK(int) iface_SetConfig (PREMOTEUSBDEVICE pDevice, uint8_t u8Cfg)
     380static DECLCALLBACK(int) iface_SetConfig(PREMOTEUSBDEVICE pDevice, uint8_t u8Cfg)
    380381{
    381382    RemoteUSBBackend *pThis = pDevice->pOwner;
    … …  
    392393    parm.configuration = u8Cfg;
    393394
    394     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     395    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    395396
    396397    return VINF_SUCCESS;
    397398}
    398399
    399 static DECLCALLBACK(int) iface_ClaimInterface (PREMOTEUSBDEVICE pDevice, uint8_t u8Ifnum)
     400static DECLCALLBACK(int) iface_ClaimInterface(PREMOTEUSBDEVICE pDevice, uint8_t u8Ifnum)
    400401{
    401402    RemoteUSBBackend *pThis = pDevice->pOwner;
    … …  
    412413    parm.iface = u8Ifnum;
    413414
    414     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     415    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    415416
    416417    return VINF_SUCCESS;
    417418}
    418419
    419 static DECLCALLBACK(int) iface_ReleaseInterface (PREMOTEUSBDEVICE pDevice, uint8_t u8Ifnum)
     420static DECLCALLBACK(int) iface_ReleaseInterface(PREMOTEUSBDEVICE pDevice, uint8_t u8Ifnum)
    420421{
    421422    RemoteUSBBackend *pThis = pDevice->pOwner;
    … …  
    432433    parm.iface = u8Ifnum;
    433434
    434     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     435    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    435436
    436437    return VINF_SUCCESS;
    437438}
    438439
    439 static DECLCALLBACK(int) iface_InterfaceSetting (PREMOTEUSBDEVICE pDevice, uint8_t u8Ifnum, uint8_t u8Setting)
     440static DECLCALLBACK(int) iface_InterfaceSetting(PREMOTEUSBDEVICE pDevice, uint8_t u8Ifnum, uint8_t u8Setting)
    440441{
    441442    RemoteUSBBackend *pThis = pDevice->pOwner;
    … …  
    453454    parm.setting = u8Setting;
    454455
    455     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     456    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    456457
    457458    return VINF_SUCCESS;
    458459}
    459460
    460 static DECLCALLBACK(int) iface_ClearHaltedEP (PREMOTEUSBDEVICE pDevice, uint8_t u8Ep)
     461static DECLCALLBACK(int) iface_ClearHaltedEP(PREMOTEUSBDEVICE pDevice, uint8_t u8Ep)
    461462{
    462463    RemoteUSBBackend *pThis = pDevice->pOwner;
    … …  
    473474    parm.ep = u8Ep;
    474475
    475     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     476    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    476477
    477478    return VINF_SUCCESS;
    478479}
    479480
    480 static DECLCALLBACK(void) iface_CancelURB (PREMOTEUSBDEVICE pDevice, PREMOTEUSBQURB pRemoteURB)
     481static DECLCALLBACK(void) iface_CancelURB(PREMOTEUSBDEVICE pDevice, PREMOTEUSBQURB pRemoteURB)
    481482{
    482483    RemoteUSBBackend *pThis = pDevice->pOwner;
    … …  
    488489    parm.handle = pRemoteURB->u32Handle;
    489490
    490     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
    491 
    492     requestDevice (pDevice);
     491    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
     492
     493    requestDevice(pDevice);
    493494
    494495    /* Remove this urb from the queue. It is safe because if
    … …  
    514515    }
    515516
    516     qurbFree (pRemoteURB);
    517 
    518     releaseDevice (pDevice);
     517    qurbFree(pRemoteURB);
     518
     519    releaseDevice(pDevice);
    519520
    520521    return;
    521522}
    522523
    523 static DECLCALLBACK(int) iface_QueueURB (PREMOTEUSBDEVICE pDevice, uint8_t u8Type, uint8_t u8Ep, uint8_t u8Direction, uint32_t u32Len, void *pvData, void *pvURB, PREMOTEUSBQURB *ppRemoteURB)
     524static DECLCALLBACK(int) iface_QueueURB(PREMOTEUSBDEVICE pDevice, uint8_t u8Type, uint8_t u8Ep, uint8_t u8Direction,
     525                                        uint32_t u32Len, void *pvData, void *pvURB, PREMOTEUSBQURB *ppRemoteURB)
    524526{
    525527    int rc = VINF_SUCCESS;
    526528
    527529#ifdef DEBUG_sunlover
    528     LogFlow(("RemoteUSBBackend::iface_QueueURB: u8Type = %d, u8Ep = %d, u8Direction = %d, data\n%.*Rhxd\n", u8Type, u8Ep, u8Direction, u32Len, pvData));
     530    LogFlow(("RemoteUSBBackend::iface_QueueURB: u8Type = %d, u8Ep = %d, u8Direction = %d, data\n%.*Rhxd\n",
     531             u8Type, u8Ep, u8Direction, u32Len, pvData));
    529532#endif /* DEBUG_sunlover */
    530533
    … …  
    540543    uint32_t u32DataLen = 0;
    541544
    542     REMOTEUSBQURB *qurb = qurbAlloc (pDevice);
     545    REMOTEUSBQURB *qurb = qurbAlloc(pDevice);
    543546
    544547    if (qurb == NULL)
    … …  
    644647    pDevice->pTailQURBs = qurb;
    645648
    646     releaseDevice (pDevice);
     649    releaseDevice(pDevice);
    647650
    648651    *ppRemoteURB = qurb;
    649652
    650     pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     653    pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    651654
    652655l_leave:
    653656    if (RT_FAILURE(rc))
    654657    {
    655         qurbFree (qurb);
     658        qurbFree(qurb);
    656659    }
    657660
    … …  
    662665 * has requested URB polling, the function will send URB poll requests.
    663666 */
    664 static DECLCALLBACK(int) iface_ReapURB (PREMOTEUSBDEVICE pDevice, uint32_t u32Millies, void **ppvURB, uint32_t *pu32Len, uint32_t *pu32Err)
     667static DECLCALLBACK(int) iface_ReapURB(PREMOTEUSBDEVICE pDevice, uint32_t u32Millies, void **ppvURB,
     668                                       uint32_t *pu32Len, uint32_t *pu32Err)
    665669{
    666670    int rc = VINF_SUCCESS;
    … …  
    676680
    677681    /* Wait for transaction completion. */
    678     uint64_t u64StartTime = RTTimeMilliTS ();
    679 
    680     if (pThis->pollingEnabledURB ())
     682    uint64_t u64StartTime = RTTimeMilliTS();
     683
     684    if (pThis->pollingEnabledURB())
    681685    {
    682686        VRDE_USB_REQ_REAP_URB_PARM parm;
    … …  
    684688        parm.code = VRDE_USB_REQ_REAP_URB;
    685689
    686         pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
     690        pThis->VRDPServer()->SendUSBRequest(pDevice->u32ClientId, &parm, sizeof(parm));
    687691    }
    688692
    … …  
    697701
    698702        /* Scan queued URBs, look for completed. */
    699         requestDevice (pDevice);
     703        requestDevice(pDevice);
    700704
    701705        u32ClientId = pDevice->u32ClientId;
    … …  
    735739        }
    736740
    737         releaseDevice (pDevice);
     741        releaseDevice(pDevice);
    738742
    739743        if (   qurb
    … …  
    741745            || u32Millies == 0
    742746            || pDevice->fFailed
    743             || (RTTimeMilliTS () - u64StartTime >= (uint64_t)u32Millies))
     747            || (RTTimeMilliTS() - u64StartTime >= (uint64_t)u32Millies))
    744748        {
    745749            /* Got an URB or do not have to wait for an URB. */
    … …  
    749753        LogFlow(("RemoteUSBBackend::iface_ReapURB iteration.\n"));
    750754
    751         RTThreadSleep (10);
    752 
    753         if (pThis->pollingEnabledURB ())
     755        RTThreadSleep(10);
     756
     757        if (pThis->pollingEnabledURB())
    754758        {
    755759            VRDE_USB_REQ_REAP_URB_PARM parm;
    … …  
    757761            parm.code = VRDE_USB_REQ_REAP_URB;
    758762
    759             pThis->VRDPServer()->SendUSBRequest (u32ClientId, &parm, sizeof (parm));
     763            pThis->VRDPServer()->SendUSBRequest(u32ClientId, &parm, sizeof(parm));
    760764        }
    761765    }
    … …  
    783787#endif
    784788
    785         qurbFree (qurb);
     789        qurbFree(qurb);
    786790    }
    787791
    … …  
    789793}
    790794
    791 static DECLCALLBACK(int) iface_Wakeup (PREMOTEUSBDEVICE pDevice)
     795static DECLCALLBACK(int) iface_Wakeup(PREMOTEUSBDEVICE pDevice)
    792796{
    793797    ASMAtomicXchgBool(&pDevice->fWokenUp, true);
    … …  
    795799}
    796800
    797 void RemoteUSBBackend::AddRef (void)
     801void RemoteUSBBackend::AddRef(void)
    798802{
    799803    cRefs++;
    800804}
    801805
    802 void RemoteUSBBackend::Release (void)
     806void RemoteUSBBackend::Release(void)
    803807{
    804808    cRefs--;
    … …  
    810814}
    811815
    812 void RemoteUSBBackend::PollRemoteDevices (void)
     816void RemoteUSBBackend::PollRemoteDevices(void)
    813817{
    814818    if (   mfWillBeDeleted
    … …  
    816820    {
    817821        /* Unmount all remote USB devices. */
    818         mConsole->processRemoteUSBDevices (mu32ClientId, NULL, 0, false);
     822        mConsole->processRemoteUSBDevices(mu32ClientId, NULL, 0, false);
    819823
    820824        menmPollRemoteDevicesStatus = PollRemoteDevicesStatus_Dereferenced;
    821825
    822         Release ();
     826        Release();
    823827
    824828        return;
    825829    }
    826830
    827     switch (menmPollRemoteDevicesStatus)
     831    switch(menmPollRemoteDevicesStatus)
    828832    {
    829833        case PollRemoteDevicesStatus_Negotiate:
    … …  
    836840            parm.flags = VRDE_USB_SERVER_CAPS_PORT_VERSION;
    837841
    838             mServer->SendUSBRequest (mu32ClientId, &parm, sizeof (parm));
     842            mServer->SendUSBRequest(mu32ClientId, &parm, sizeof(parm));
    839843
    840844            /* Reference the object. When the client disconnects and
    … …  
    842846             * to disconnect the USB devices (as stated above).
    843847             */
    844             AddRef ();
     848            AddRef();
    845849
    846850            /* Goto the disabled state. When a response will be received
    … …  
    865869            parm.code = VRDE_USB_REQ_DEVICE_LIST;
    866870
    867             mServer->SendUSBRequest (mu32ClientId, &parm, sizeof (parm));
     871            mServer->SendUSBRequest(mu32ClientId, &parm, sizeof(parm));
    868872
    869873            menmPollRemoteDevicesStatus = PollRemoteDevicesStatus_WaitResponse;
    … …  
    876880            if (mfHasDeviceList)
    877881            {
    878                 mConsole->processRemoteUSBDevices (mu32ClientId, (VRDEUSBDEVICEDESC *)mpvDeviceList, mcbDeviceList, mfDescExt);
     882                mConsole->processRemoteUSBDevices(mu32ClientId, (VRDEUSBDEVICEDESC *)mpvDeviceList, mcbDeviceList, mfDescExt);
    879883                LogFlow(("USB::PollRemoteDevices: WaitResponse after process\n"));
    880884
    … …  
    893897        default:
    894898        {
    895            AssertFailed ();
     899           AssertFailed();
    896900        } break;
    897901    }
    898902}
    899903
    900 void RemoteUSBBackend::NotifyDelete (void)
     904void RemoteUSBBackend::NotifyDelete(void)
    901905{
    902906    mfWillBeDeleted = true;
    … …  
    907911 * which are managed by the backend.
    908912 */
    909 bool RemoteUSBBackend::addUUID (const Guid *pUuid)
     913bool RemoteUSBBackend::addUUID(const Guid *pUuid)
    910914{
    911915    unsigned i;
    … …  
    922926}
    923927
    924 bool RemoteUSBBackend::findUUID (const Guid *pUuid)
     928bool RemoteUSBBackend::findUUID(const Guid *pUuid)
    925929{
    926930    unsigned i;
    … …  
    936940}
    937941
    938 void RemoteUSBBackend::removeUUID (const Guid *pUuid)
     942void RemoteUSBBackend::removeUUID(const Guid *pUuid)
    939943{
    940944    unsigned i;
    … …  
    943947        if (aGuids[i] == *pUuid)
    944948        {
    945             aGuids[i].clear ();
     949            aGuids[i].clear();
    946950            break;
    947951        }
    … …  
    951955RemoteUSBBackend::RemoteUSBBackend(Console *console, ConsoleVRDPServer *server, uint32_t u32ClientId)
    952956    :
    953     mConsole (console),
    954     mServer (server),
    955     cRefs (0),
    956     mu32ClientId (u32ClientId),
    957     mfHasDeviceList (false),
    958     mpvDeviceList (NULL),
    959     mcbDeviceList (0),
    960     menmPollRemoteDevicesStatus (PollRemoteDevicesStatus_Negotiate),
    961     mfPollURB (true),
    962     mpDevices (NULL),
    963     mfWillBeDeleted (false),
    964     mClientVersion (0),                   /* VRDE_USB_VERSION_2: the client version. */
    965     mfDescExt (false)                     /* VRDE_USB_VERSION_3: VRDE_USB_REQ_DEVICE_LIST_EXT_RET. */
     957    mConsole(console),
     958    mServer(server),
     959    cRefs(0),
     960    mu32ClientId(u32ClientId),
     961    mfHasDeviceList(false),
     962    mpvDeviceList(NULL),
     963    mcbDeviceList(0),
     964    menmPollRemoteDevicesStatus(PollRemoteDevicesStatus_Negotiate),
     965    mfPollURB(true),
     966    mpDevices(NULL),
     967    mfWillBeDeleted(false),
     968    mClientVersion(0),                   /* VRDE_USB_VERSION_2: the client version. */
     969    mfDescExt(false)                     /* VRDE_USB_VERSION_3: VRDE_USB_REQ_DEVICE_LIST_EXT_RET. */
    966970{
    967971    Assert(console);
    968972    Assert(server);
    969973
    970     int rc = RTCritSectInit (&mCritsect);
     974    int rc = RTCritSectInit(&mCritsect);
    971975
    972976    if (RT_FAILURE(rc))
    973977    {
    974         AssertFailed ();
     978        AssertFailed();
    975979        RT_ZERO(mCritsect);
    976980    }
    … …  
    995999    Assert(cRefs == 0);
    9961000
    997     if (RTCritSectIsInitialized (&mCritsect))
    998     {
    999         RTCritSectDelete (&mCritsect);
    1000     }
    1001 
    1002     RTMemFree (mpvDeviceList);
    1003 
    1004     mServer->usbBackendRemoveFromList (this);
    1005 }
    1006 
    1007 int RemoteUSBBackend::negotiateResponse (const VRDEUSBREQNEGOTIATERET *pret, uint32_t cbRet)
     1001    if (RTCritSectIsInitialized(&mCritsect))
     1002    {
     1003        RTCritSectDelete(&mCritsect);
     1004    }
     1005
     1006    RTMemFree(mpvDeviceList);
     1007
     1008    mServer->usbBackendRemoveFromList(this);
     1009}
     1010
     1011int RemoteUSBBackend::negotiateResponse(const VRDEUSBREQNEGOTIATERET *pret, uint32_t cbRet)
    10081012{
    10091013    int rc = VINF_SUCCESS;
    … …  
    10281032    {
    10291033        /* This could be a client version > 1. */
    1030         if (cbRet >= sizeof (VRDEUSBREQNEGOTIATERET_2))
     1034        if (cbRet >= sizeof(VRDEUSBREQNEGOTIATERET_2))
    10311035        {
    10321036            VRDEUSBREQNEGOTIATERET_2 *pret2 = (VRDEUSBREQNEGOTIATERET_2 *)pret;
    … …  
    10621066        if (mClientVersion == VRDE_USB_VERSION_3)
    10631067        {
    1064             if (cbRet >= sizeof (VRDEUSBREQNEGOTIATERET_3))
     1068            if (cbRet >= sizeof(VRDEUSBREQNEGOTIATERET_3))
    10651069            {
    10661070                VRDEUSBREQNEGOTIATERET_3 *pret3 = (VRDEUSBREQNEGOTIATERET_3 *)pret;
    … …  
    10811085}
    10821086
    1083 int RemoteUSBBackend::saveDeviceList (const void *pvList, uint32_t cbList)
     1087int RemoteUSBBackend::saveDeviceList(const void *pvList, uint32_t cbList)
    10841088{
    10851089    Log(("RemoteUSBBackend::saveDeviceList: pvList = %p, cbList = %d\n", pvList, cbList));
    … …  
    10871091    if (!mfHasDeviceList)
    10881092    {
    1089         RTMemFree (mpvDeviceList);
     1093        RTMemFree(mpvDeviceList);
    10901094        mpvDeviceList = NULL;
    10911095
    … …  
    10941098        if (cbList > 0)
    10951099        {
    1096             mpvDeviceList = RTMemAlloc (cbList);
    1097             memcpy (mpvDeviceList, pvList, cbList);
     1100            mpvDeviceList = RTMemAlloc(cbList);
     1101            memcpy(mpvDeviceList, pvList, cbList);
    10981102        }
    10991103
    … …  
    11041108}
    11051109
    1106 void RemoteUSBBackend::request (void)
     1110void RemoteUSBBackend::request(void)
    11071111{
    11081112    int rc = RTCritSectEnter(&mCritsect);
    … …  
    11101114}
    11111115
    1112 void RemoteUSBBackend::release (void)
     1116void RemoteUSBBackend::release(void)
    11131117{
    11141118    RTCritSectLeave(&mCritsect);
    11151119}
    11161120
    1117 PREMOTEUSBDEVICE RemoteUSBBackend::deviceFromId (VRDEUSBDEVID id)
    1118 {
    1119     request ();
     1121PREMOTEUSBDEVICE RemoteUSBBackend::deviceFromId(VRDEUSBDEVID id)
     1122{
     1123    request();
    11201124
    11211125    REMOTEUSBDEVICE *pDevice = mpDevices;
    … …  
    11261130    }
    11271131
    1128     release ();
     1132    release();
    11291133
    11301134    return pDevice;
    11311135}
    11321136
    1133 void RemoteUSBBackend::addDevice (PREMOTEUSBDEVICE pDevice)
    1134 {
    1135     request ();
     1137void RemoteUSBBackend::addDevice(PREMOTEUSBDEVICE pDevice)
     1138{
     1139    request();
    11361140
    11371141    pDevice->next = mpDevices;
    … …  
    11441148    mpDevices = pDevice;
    11451149
    1146     release ();
    1147 }
    1148 
    1149 void RemoteUSBBackend::removeDevice (PREMOTEUSBDEVICE pDevice)
    1150 {
    1151     request ();
     1150    release();
     1151}
     1152
     1153void RemoteUSBBackend::removeDevice(PREMOTEUSBDEVICE pDevice)
     1154{
     1155    request();
    11521156
    11531157    if (pDevice->prev)
    … …  
    11651169    }
    11661170
    1167     release ();
    1168 }
    1169 
    1170 int RemoteUSBBackend::reapURB (const void *pvBody, uint32_t cbBody)
     1171    release();
     1172}
     1173
     1174int RemoteUSBBackend::reapURB(const void *pvBody, uint32_t cbBody)
    11711175{
    11721176    int rc = VINF_SUCCESS;
    … …  
    11761180    VRDEUSBREQREAPURBBODY *pBody = (VRDEUSBREQREAPURBBODY *)pvBody;
    11771181
    1178     while (cbBody >= sizeof (VRDEUSBREQREAPURBBODY))
     1182    while (cbBody >= sizeof(VRDEUSBREQREAPURBBODY))
    11791183    {
    11801184        Log(("RemoteUSBBackend::reapURB: id = %d,  flags = %02X, error = %d, handle %d, len = %d.\n",
    … …  
    11941198        /* Verify client's data. */
    11951199        if (   (pBody->flags & ~fu8ReapValidFlags) != 0
    1196             || sizeof (VRDEUSBREQREAPURBBODY) > cbBody
     1200            || sizeof(VRDEUSBREQREAPURBBODY) > cbBody
    11971201            || pBody->handle == 0)
    11981202        {
    … …  
    12021206        }
    12031207
    1204         PREMOTEUSBDEVICE pDevice = deviceFromId (pBody->id);
     1208        PREMOTEUSBDEVICE pDevice = deviceFromId(pBody->id);
    12051209
    12061210        if (!pDevice)
    … …  
    12131217        uint32_t cbBodyData = 0; /* Data contained in the URB body structure for input URBs. */
    12141218
    1215         requestDevice (pDevice);
     1219        requestDevice(pDevice);
    12161220
    12171221        /* Search the queued URB for given handle. */

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

    r50613 r51092  
    627627/* HGCM connector interface */
    628628
    629 static DECLCALLBACK(int) iface_hgcmConnect (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, PHGCMSERVICELOCATION pServiceLocation, uint32_t *pu32ClientID)
     629static DECLCALLBACK(int) iface_hgcmConnect(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd,
     630                                           PHGCMSERVICELOCATION pServiceLocation,
     631                                           uint32_t *pu32ClientID)
    630632{
    631633    LogSunlover(("Enter\n"));
    … …  
    646648}
    647649
    648 static DECLCALLBACK(int) iface_hgcmDisconnect (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID)
     650static DECLCALLBACK(int) iface_hgcmDisconnect(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID)
    649651{
    650652    LogSunlover(("Enter\n"));
    … …  
    658660}
    659661
    660 static DECLCALLBACK(int) iface_hgcmCall (PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID, uint32_t u32Function,
    661                                         uint32_t cParms, PVBOXHGCMSVCPARM paParms)
     662static DECLCALLBACK(int) iface_hgcmCall(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID,
     663                                        uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms)
    662664{
    663665    LogSunlover(("Enter\n"));
    … …  
    718720    if (!hgcmIsActive())
    719721        return VERR_INVALID_STATE;
    720     return HGCMHostCall (pszServiceName, u32Function, cParms, paParms);
     722    return HGCMHostCall(pszServiceName, u32Function, cParms, paParms);
    721723}
    722724
    … …  
    728730
    729731# ifdef VBOX_WITH_CRHGSMI
    730 int VMMDev::hgcmHostSvcHandleCreate (const char *pszServiceName, HGCMCVSHANDLE * phSvc)
     732int VMMDev::hgcmHostSvcHandleCreate(const char *pszServiceName, HGCMCVSHANDLE * phSvc)
    731733{
    732734    if (!hgcmIsActive())
    … …  
    735737}
    736738
    737 int VMMDev::hgcmHostSvcHandleDestroy (HGCMCVSHANDLE hSvc)
     739int VMMDev::hgcmHostSvcHandleDestroy(HGCMCVSHANDLE hSvc)
    738740{
    739741    if (!hgcmIsActive())
    … …  
    742744}
    743745
    744 int VMMDev::hgcmHostFastCallAsync (HGCMCVSHANDLE hSvc, uint32_t function, PVBOXHGCMSVCPARM pParm, PHGCMHOSTFASTCALLCB pfnCompletion, void *pvCompletion)
     746int VMMDev::hgcmHostFastCallAsync(HGCMCVSHANDLE hSvc, uint32_t function, PVBOXHGCMSVCPARM pParm,
     747                                  PHGCMHOSTFASTCALLCB pfnCompletion, void *pvCompletion)
    745748{
    746749    if (!hgcmIsActive())

  • trunk/src/VBox/Main/src-client/xpcom/module.cpp

    r50919 r51092  
    7272NS_DECL_CLASSINFO(Display)
    7373NS_IMPL_THREADSAFE_ISUPPORTS2_CI(Display, IDisplay, IEventListener)
    74 NS_DECL_CLASSINFO(MachineDebugger)
    75 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MachineDebugger, IMachineDebugger)
    7674NS_DECL_CLASSINFO(RemoteUSBDevice)
    7775NS_IMPL_THREADSAFE_ISUPPORTS2_CI(RemoteUSBDevice, IHostUSBDevice, IUSBDevice)

  • trunk/src/VBox/Main/src-server/ApplianceImplExport.cpp

    r50447 r51092  
    433433                        lChannelVsys = 1;
    434434                    }
    435                     else if (lChannel == 1 && lDevice == 0) // secondary master; by default this is the CD-ROM but as of VirtualBox 3.1 that can change
     435                    else if (lChannel == 1 && lDevice == 0) // secondary master; by default this is the CD-ROM but
     436                                                            // as of VirtualBox 3.1 that can change
    436437                    {
    437438                        lControllerVsys = lIDEControllerSecondaryIndex;
    … …  
    445446                    else
    446447                        throw setError(VBOX_E_NOT_SUPPORTED,
    447                                     tr("Cannot handle medium attachment: channel is %d, device is %d"), lChannel, lDevice);
     448                                       tr("Cannot handle medium attachment: channel is %d, device is %d"), lChannel, lDevice);
    448449                break;
    449450
    … …  
    466467                default:
    467468                    throw setError(VBOX_E_NOT_SUPPORTED,
    468                                 tr("Cannot handle medium attachment: storageBus is %d, channel is %d, device is %d"), storageBus, lChannel, lDevice);
     469                                   tr("Cannot handle medium attachment: storageBus is %d, channel is %d, device is %d"),
     470                                   storageBus, lChannel, lDevice);
    469471                break;
    470472            }
    … …  
    599601    }
    600602
    601 //  AssertReturn(!(m->optListExport.contains(ExportOptions_CreateManifest) && m->optListExport.contains(ExportOptions_ExportDVDImages)), E_INVALIDARG);
     603//  AssertReturn(!(m->optListExport.contains(ExportOptions_CreateManifest)
     604//  && m->optListExport.contains(ExportOptions_ExportDVDImages)), E_INVALIDARG);
    602605
    603606    m->fExportISOImages = m->optListExport.contains(ExportOptions_ExportDVDImages);
    … …  
    13031306                        desc.strVBoxCurrent.toInt(uTemp);
    13041307                        lVirtualQuantity = (int32_t)uTemp;
    1305                         strCaption = Utf8StrFmt("%d virtual CPU", lVirtualQuantity);     // without this ovftool won't eat the item
     1308                        strCaption = Utf8StrFmt("%d virtual CPU", lVirtualQuantity);     // without this ovftool
     1309                                                                                         // won't eat the item
    13061310                    }
    13071311                break;
    … …  
    13241328                        lVirtualQuantity = (int32_t)(uTemp / _1M);
    13251329                        strAllocationUnits = "MegaBytes";
    1326                         strCaption = Utf8StrFmt("%d MB of memory", lVirtualQuantity);     // without this ovftool won't eat the item
     1330                        strCaption = Utf8StrFmt("%d MB of memory", lVirtualQuantity);     // without this ovftool
     1331                                                                                          // won't eat the item
    13271332                    }
    13281333                break;
    … …  
    14331438                        else
    14341439                            throw setError(VBOX_E_NOT_SUPPORTED,
    1435                                             tr("Invalid config string \"%s\" in SCSI/SAS controller"), desc.strVBoxCurrent.c_str());
     1440                                           tr("Invalid config string \"%s\" in SCSI/SAS controller"),
     1441                                           desc.strVBoxCurrent.c_str());
    14361442
    14371443                        // remember this ID
    … …  
    14821488
    14831489                        LogFlowFunc(("HardDiskImage details: pos1=%d, pos2=%d, lControllerIndex=%d, lIDEPrimaryControllerIndex=%d, lIDESecondaryControllerIndex=%d, ulParent=%d, lAddressOnParent=%d\n",
    1484                                      pos1, pos2, lControllerIndex, lIDEPrimaryControllerIndex, lIDESecondaryControllerIndex, ulParent, lAddressOnParent));
     1490                                     pos1, pos2, lControllerIndex, lIDEPrimaryControllerIndex, lIDESecondaryControllerIndex,
     1491                                     ulParent, lAddressOnParent));
    14851492
    14861493                        if (    !ulParent
    … …  
    14881495                           )
    14891496                            throw setError(VBOX_E_NOT_SUPPORTED,
    1490                                             tr("Missing or bad extra config string in hard disk image: \"%s\""), desc.strExtraConfigCurrent.c_str());
     1497                                           tr("Missing or bad extra config string in hard disk image: \"%s\""),
     1498                                           desc.strExtraConfigCurrent.c_str());
    14911499
    14921500                        stack.mapDisks[strDiskID] = &desc;
    … …  
    15521560
    15531561                        LogFlowFunc(("DVD drive details: pos1=%d, pos2=%d, lControllerIndex=%d, lIDEPrimaryControllerIndex=%d, lIDESecondaryControllerIndex=%d, ulParent=%d, lAddressOnParent=%d\n",
    1554                                      pos1, pos2, lControllerIndex, lIDEPrimaryControllerIndex, lIDESecondaryControllerIndex, ulParent, lAddressOnParent));
     1562                                     pos1, pos2, lControllerIndex, lIDEPrimaryControllerIndex,
     1563                                     lIDESecondaryControllerIndex, ulParent, lAddressOnParent));
    15551564
    15561565                        if (    !ulParent
    … …  
    15581567                           )
    15591568                            throw setError(VBOX_E_NOT_SUPPORTED,
    1560                                             tr("Missing or bad extra config string in DVD drive medium: \"%s\""), desc.strExtraConfigCurrent.c_str());
     1569                                           tr("Missing or bad extra config string in DVD drive medium: \"%s\""),
     1570                                           desc.strExtraConfigCurrent.c_str());
    15611571
    15621572                        stack.mapDisks[strDiskID] = &desc;
    … …  
    21492159                pTask->pProgress->SetNextOperation(BstrFmt(tr("Exporting to disk image '%s'"),
    21502160                                                           RTPathFilename(strTargetFilePath.c_str())).raw(),
    2151                                                    pDiskEntry->ulSizeMB);     // operation's weight, as set up with the IProgress originally
     2161                                                   pDiskEntry->ulSizeMB);     // operation's weight, as set up
     2162                                                                              // with the IProgress originally
    21522163
    21532164                // create a flat copy of the source disk image
    … …  
    21562167                    ComObjPtr<Progress> pProgress2;
    21572168                    pProgress2.createObject();
    2158                     rc = pProgress2->init(mVirtualBox, static_cast<IAppliance*>(this), BstrFmt(tr("Creating medium '%s'"),
    2159                                                                                                strTargetFilePath.c_str()).raw(), TRUE);
     2169                    rc = pProgress2->init(mVirtualBox, static_cast<IAppliance*>(this),
     2170                                          BstrFmt(tr("Creating medium '%s'"),
     2171                                          strTargetFilePath.c_str()).raw(), TRUE);
    21602172                    if (FAILED(rc)) throw rc;
    21612173

  • trunk/src/VBox/Main/src-server/ApplianceImplIO.cpp

    r50355 r51092  
    168168
    169169/** @interface_method_impl{VDINTERFACEIO,pfnWriteSync}  */
    170 static DECLCALLBACK(int) notImpl_WriteSync(void *pvUser, void *pvStorage, uint64_t off, const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
     170static DECLCALLBACK(int) notImpl_WriteSync(void *pvUser, void *pvStorage, uint64_t off, const void *pvBuf,
     171                                           size_t cbWrite, size_t *pcbWritten)
    171172{
    172173    NOREF(pvUser); NOREF(pvStorage); NOREF(off); NOREF(pvBuf); NOREF(cbWrite); NOREF(pcbWritten);
    … …  
    507508
    508509/** @interface_method_impl{VDINTERFACEIO,pfnOpen}  */
    509 static DECLCALLBACK(int) fssRdOnly_Open(void *pvUser, const char *pszLocation, uint32_t fOpen, PFNVDCOMPLETED pfnCompleted, void **ppInt)
     510static DECLCALLBACK(int) fssRdOnly_Open(void *pvUser, const char *pszLocation, uint32_t fOpen,
     511                                        PFNVDCOMPLETED pfnCompleted, void **ppInt)
    510512{
    511513    PFSSRDONLYINTERFACEIO pThis = (PFSSRDONLYINTERFACEIO)pvUser;
    … …  
    613615
    614616/** @interface_method_impl{VDINTERFACEIO,pfnRead}  */
    615 static DECLCALLBACK(int) fssRdOnly_ReadSync(void *pvUser, void *pvStorage, uint64_t off, void *pvBuf, size_t cbToRead, size_t *pcbRead)
     617static DECLCALLBACK(int) fssRdOnly_ReadSync(void *pvUser, void *pvStorage, uint64_t off, void *pvBuf,
     618                                            size_t cbToRead, size_t *pcbRead)
    616619{
    617620    PIOSRDONLYINTERNAL      pFile = (PIOSRDONLYINTERNAL)pvStorage;
    … …  
    867870                        size_t cbToWrite = cbMemRead - cbAllWritten;
    868871                        size_t cbWritten = 0;
    869                         rc = vdIfIoFileWriteSync(pIfIo, pInt->pvStorage, pInt->cbCurFile, &pcBuf[cbAllWritten], cbToWrite, &cbWritten);
     872                        rc = vdIfIoFileWriteSync(pIfIo, pInt->pvStorage, pInt->cbCurFile, &pcBuf[cbAllWritten],
     873                                                 cbToWrite, &cbWritten);
    870874//                        RTPrintf ("%lu %lu %lu %Rrc\n", pInt->cbCurFile, cbToRead, cbRead, rc);
    871875                        if (RT_FAILURE(rc))
    … …  
    10771081            break;
    10781082        /* Create the worker thread. */
    1079         rc = RTThreadCreate(&pInt->pWorkerThread, shaCalcWorkerThread, pInt, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, RTTHREADFLAGS_WAITABLE, "SHA-Worker");
     1083        rc = RTThreadCreate(&pInt->pWorkerThread, shaCalcWorkerThread, pInt, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER,
     1084                            RTTHREADFLAGS_WAITABLE, "SHA-Worker");
    10801085        if (RT_FAILURE(rc))
    10811086            break;
    … …  
    13181323
    13191324    /* Check that the write is linear */
    1320     AssertMsgReturn(pInt->cbCurAll <= uOffset, ("Backward seeking is not allowed (uOffset: %7lu cbCurAll: %7lu)!", uOffset, pInt->cbCurAll), VERR_INVALID_PARAMETER);
     1325    AssertMsgReturn(pInt->cbCurAll <= uOffset, ("Backward seeking is not allowed (uOffset: %7lu cbCurAll: %7lu)!",
     1326                    uOffset, pInt->cbCurAll), VERR_INVALID_PARAMETER);
    13211327
    13221328    int rc = VINF_SUCCESS;

  • trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

    r51014 r51092  
    18401840        {
    18411841            ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
    1842             std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskImage);
     1842            std::list<VirtualSystemDescriptionEntry*> avsdeHDs =
     1843                vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskImage);
    18431844            std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
    18441845            for (itH = avsdeHDs.begin();
    … …  
    21712172            if(vrc == VINF_X509_NOT_SELFSIGNED_CERTIFICATE)
    21722173            {
    2173                 setWarning(VBOX_E_FILE_ERROR, 
     2174                setWarning(VBOX_E_FILE_ERROR,
    21742175                           tr("Signature from the X509 certificate has been verified. "
    21752176                              "But VirtualBox can't validate the given X509 certificate. "
    … …  
    28662867
    28672868    // IDE Hard disk controller
    2868     std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
     2869    std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE =
     2870        vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
    28692871    /*
    28702872     * In OVF (at least VMware's version of it), an IDE controller has two ports,
    … …  
    28982900
    28992901    /* Hard disk controller SATA */
    2900     std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA = vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
     2902    std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA =
     2903        vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
    29012904    if (vsdeHDCSATA.size() > 1)
    29022905        throw setError(VBOX_E_FILE_ERROR,
    … …  
    29202923
    29212924    /* Hard disk controller SCSI */
    2922     std::list<VirtualSystemDescriptionEntry*> vsdeHDCSCSI = vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
     2925    std::list<VirtualSystemDescriptionEntry*> vsdeHDCSCSI =
     2926        vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
    29232927    if (vsdeHDCSCSI.size() > 1)
    29242928        throw setError(VBOX_E_FILE_ERROR,
    … …  
    29542958
    29552959    /* Hard disk controller SAS */
    2956     std::list<VirtualSystemDescriptionEntry*> vsdeHDCSAS = vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSAS);
     2960    std::list<VirtualSystemDescriptionEntry*> vsdeHDCSAS =
     2961        vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSAS);
    29572962    if (vsdeHDCSAS.size() > 1)
    29582963        throw setError(VBOX_E_FILE_ERROR,
    … …  
    30703075            {
    30713076                size_t i = 0;
    3072                 for (list<VirtualSystemDescriptionEntry*>::const_iterator itHD = avsdeHDs.begin(); itHD != avsdeHDs.end(); ++itHD, i++)
    3073                     Log(("avsdeHDs[%zu]: strRef=%s strOvf=%s\n", i, (*itHD)->strRef.c_str(), (*itHD)->strOvf.c_str()));
     3077                for (list<VirtualSystemDescriptionEntry*>::const_iterator itHD =
     3078                     avsdeHDs.begin(); itHD != avsdeHDs.end(); ++itHD, i++)
     3079                     Log(("avsdeHDs[%zu]: strRef=%s strOvf=%s\n", i, (*itHD)->strRef.c_str(), (*itHD)->strOvf.c_str()));
    30743080                i = 0;
    30753081                for (ovf::DiskImagesMap::const_iterator itDisk = stack.mapDisks.begin(); itDisk != stack.mapDisks.end(); ++itDisk)
    3076                     Log(("mapDisks[%zu]: strDiskId=%s strHref=%s\n", i, itDisk->second.strDiskId.c_str(), itDisk->second.strHref.c_str()));
     3082                    Log(("mapDisks[%zu]: strDiskId=%s strHref=%s\n",
     3083                         i, itDisk->second.strDiskId.c_str(), itDisk->second.strHref.c_str()));
    30773084
    30783085            }
    … …  
    34443451    if (stack.fUSBEnabled)
    34453452    {
    3446         /** @todo r=klaus add support for arbitrary USB controller types, this can't handle multiple controllers due to its design anyway */
    3447 
     3453        /** @todo r=klaus add support for arbitrary USB controller types, this can't handle
     3454         *  multiple controllers due to its design anyway */
    34483455        /* usually the OHCI controller is enabled already, need to check */
    34493456        bool fOHCIEnabled = false;
    … …  
    40044011#ifdef VBOX_WITH_USB
    40054012        // USB controller
    4006         std::list<VirtualSystemDescriptionEntry*> vsdeUSBController = vsdescThis->i_findByType(VirtualSystemDescriptionType_USBController);
     4013        std::list<VirtualSystemDescriptionEntry*> vsdeUSBController =
     4014            vsdescThis->i_findByType(VirtualSystemDescriptionType_USBController);
    40074015        // USB support is enabled if there's at least one such entry; to disable USB support,
    40084016        // the type of the USB item would have been changed to "ignore"
    … …  
    40104018#endif
    40114019        // audio adapter
    4012         std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter = vsdescThis->i_findByType(VirtualSystemDescriptionType_SoundCard);
     4020        std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter =
     4021            vsdescThis->i_findByType(VirtualSystemDescriptionType_SoundCard);
    40134022        /* @todo: we support one audio adapter only */
    40144023        if (vsdeAudioAdapter.size() > 0)
    … …  
    40164025
    40174026        // for the description of the new machine, always use the OVF entry, the user may have changed it in the import config
    4018         std::list<VirtualSystemDescriptionEntry*> vsdeDescription = vsdescThis->i_findByType(VirtualSystemDescriptionType_Description);
     4027        std::list<VirtualSystemDescriptionEntry*> vsdeDescription =
     4028            vsdescThis->i_findByType(VirtualSystemDescriptionType_Description);
    40194029        if (vsdeDescription.size())
    40204030            stack.strDescription = vsdeDescription.front()->strVBoxCurrent;

  • trunk/src/VBox/Main/src-server/HostImpl.cpp

    r50472 r51092  
    23782378                                    if (RT_LIKELY(pDrive))
    23792379                                    {
    2380                                         RTStrPrintf(pDrive->szDescription, sizeof(pDrive->szDescription), "%s %s", pszVendor, pszProduct);
     2380                                        RTStrPrintf(pDrive->szDescription, sizeof(pDrive->szDescription),
     2381                                                    "%s %s", pszVendor, pszProduct);
    23812382                                        RTStrCopy(pDrive->szRawDiskPath, sizeof(pDrive->szRawDiskPath), pszDevLinkPath);
    23822383                                        if (*ppDrives)
    … …  
    25512552                    if (!gLibHalCtxShutdown(halContext, &dbusError))  /* what now? */
    25522553                    {
    2553                         LogRel(("Host::COMGETTER(DVDDrives): failed to shutdown the libhal context.  dbus error: %s (%s)\n", dbusError.name, dbusError.message));
     2554                        LogRel(("Host::COMGETTER(DVDDrives): failed to shutdown the libhal context.  dbus error: %s (%s)\n",
     2555                                dbusError.name, dbusError.message));
    25542556                        gDBusErrorFree(&dbusError);
    25552557                    }
    … …  
    25572559                else
    25582560                {
    2559                     LogRel(("Host::COMGETTER(DVDDrives): failed to initialise libhal context.  dbus error: %s (%s)\n", dbusError.name, dbusError.message));
     2561                    LogRel(("Host::COMGETTER(DVDDrives): failed to initialise libhal context.  dbus error: %s (%s)\n",
     2562                            dbusError.name, dbusError.message));
    25602563                    gDBusErrorFree(&dbusError);
    25612564                }
    … …  
    25752578    else
    25762579    {
    2577         LogRel(("Host::COMGETTER(DVDDrives): failed to connect to dbus.  dbus error: %s (%s)\n", dbusError.name, dbusError.message));
     2580        LogRel(("Host::COMGETTER(DVDDrives): failed to connect to dbus.  dbus error: %s (%s)\n",
     2581                dbusError.name, dbusError.message));
    25782582        gDBusErrorFree(&dbusError);
    25792583    }
    … …  
    27102714                    if (!gLibHalCtxShutdown(halContext, &dbusError))  /* what now? */
    27112715                    {
    2712                         LogRel(("Host::COMGETTER(FloppyDrives): failed to shutdown the libhal context.  dbus error: %s (%s)\n", dbusError.name, dbusError.message));
     2716                        LogRel(("Host::COMGETTER(FloppyDrives): failed to shutdown the libhal context.  dbus error: %s (%s)\n",
     2717                                dbusError.name, dbusError.message));
    27132718                        gDBusErrorFree(&dbusError);
    27142719                    }
    … …  
    27162721                else
    27172722                {
    2718                     LogRel(("Host::COMGETTER(FloppyDrives): failed to initialise libhal context.  dbus error: %s (%s)\n", dbusError.name, dbusError.message));
     2723                    LogRel(("Host::COMGETTER(FloppyDrives): failed to initialise libhal context.  dbus error: %s (%s)\n",
     2724                            dbusError.name, dbusError.message));
    27192725                    gDBusErrorFree(&dbusError);
    27202726                }
    … …  
    27342740    else
    27352741    {
    2736         LogRel(("Host::COMGETTER(FloppyDrives): failed to connect to dbus.  dbus error: %s (%s)\n", dbusError.name, dbusError.message));
     2742        LogRel(("Host::COMGETTER(FloppyDrives): failed to connect to dbus.  dbus error: %s (%s)\n",
     2743                dbusError.name, dbusError.message));
    27372744        gDBusErrorFree(&dbusError);
    27382745    }
    … …  
    28212828            {
    28222829                // skip devices we are not interested in
    2823                 if ((*mountName && mountName[0] == '/') &&                      // skip 'fake' devices (like -hosts, proc, fd, swap)
    2824                     (*mountFSType && (strncmp(mountFSType, RT_STR_TUPLE("devfs")) != 0 &&  // skip devfs (i.e. /devices)
     2830                if ((*mountName && mountName[0] == '/') &&                      // skip 'fake' devices (like -hosts,
     2831                                                                                // proc, fd, swap)
     2832                    (*mountFSType && (strncmp(mountFSType, RT_STR_TUPLE("devfs")) != 0 &&  // skip devfs
     2833                                                                                           // (i.e. /devices)
    28252834                                      strncmp(mountFSType, RT_STR_TUPLE("dev")) != 0 &&    // skip dev (i.e. /dev)
    28262835                                      strncmp(mountFSType, RT_STR_TUPLE("lofs")) != 0)))   // skip loop-back file-system (lofs)

  • trunk/src/VBox/Main/src-server/HostUSBDeviceImpl.cpp

    r49960 r51092  
    566566    }
    567567    else
    568         AssertMsgReturn(    mUniState == kHostUSBDeviceState_DetachingFromVM /** @todo capturing for VM ends up here on termination. */
     568        AssertMsgReturn(    mUniState == kHostUSBDeviceState_DetachingFromVM /** @todo capturing for VM
     569                                                                                 ends up here on termination. */
    569570                        ||  (mUniState == kHostUSBDeviceState_UsedByVM && aAbnormal),
    570571                        ("{%s} %s\n", mName, i_getStateName()), E_UNEXPECTED);
    … …  
    14051406    {
    14061407        LogFlowThisFunc(("%p {%s} %s - no change %d\n", this, mName, i_getStateName(), enmOldState));
    1407         /** @todo might have to handle some stuff here too if we cannot make the release/capture handling deal with that above ... */
     1408        /** @todo might have to handle some stuff here too if we cannot make the release/capture
     1409         *  handling deal with that above ... */
    14081410    }
    14091411
    … …  
    21072109    else
    21082110        LogFlowThisFunc(("%s -> %s (prev: %s) [%s]\n",
    2109                          i_getStateName(), i_stateName(aNewState, aNewPendingState, aNewSubState), i_stateName(NewPrevState), mName));
     2111                         i_getStateName(), i_stateName(aNewState, aNewPendingState, aNewSubState),
     2112                         i_stateName(NewPrevState), mName));
    21102113    mPrevUniState = NewPrevState;
    21112114    mUniState = aNewState;
    … …  
    22012204                            break;
    22022205                        default:
    2203                             AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n", this, enmPending, i_getStateName()), false);
     2206                            AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
     2207                                                   this, enmPending, i_getStateName()), false);
    22042208                    }
    22052209                    break;
    … …  
    22292233                            break;
    22302234                        default:
    2231                             AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n", this, enmPending, i_getStateName()), false);
     2235                            AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
     2236                                                   this, enmPending, i_getStateName()), false);
    22322237                    }
    22332238                    break;
    … …  
    22542259                            break;
    22552260                        default:
    2256                             AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n", this, enmPending, i_getStateName()), false);
     2261                            AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
     2262                                                   this, enmPending, i_getStateName()), false);
    22572263                    }
    22582264                    break;
    … …  
    22822288                            break;
    22832289                        default:
    2284                             AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n", this, enmPending, i_getStateName()), false);
     2290                            AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
     2291                                                   this, enmPending, i_getStateName()), false);
    22852292                    }
    22862293                    break;
    … …  
    23012308                            break;
    23022309                        default:
    2303                             AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n", this, enmPending, i_getStateName()), false);
     2310                            AssertMsgFailedReturn(("this=%p invalid pending state %d: %s\n",
     2311                                                   this, enmPending, i_getStateName()), false);
    23042312                    }
    23052313                    break;

  • trunk/src/VBox/Main/src-server/MediumAttachmentImpl.cpp

    r49871 r51092  
    367367        hrc = m->pMachine->getBandwidthGroup(m->bd->strBandwidthGroup, pBwGroup, true /* fSetError */);
    368368
    369         Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence of the group was checked when it was attached. */
     369        Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence of the
     370                                   group was checked when it was attached. */
    370371
    371372        if (SUCCEEDED(hrc))

  • trunk/src/VBox/Main/src-server/MediumImpl.cpp

    r50874 r51092  
    112112    // pParent and llChildren are protected by VirtualBox::i_getMediaTreeLockHandle()
    113113    ComObjPtr<Medium> pParent;
    114     MediaList llChildren;           // to add a child, just call push_back; to remove a child, call child->deparent() which does a lookup
     114    MediaList llChildren;           // to add a child, just call push_back; to remove
     115                                    // a child, call child->deparent() which does a lookup
    115116
    116117    GuidList llRegistryIDs;         // media registries in which this medium is listed
    … …  
    896897 * @param aFormat
    897898 * @param aLocation     Storage unit location.
    898  * @param uuidMachineRegistry The registry to which this medium should be added (global registry UUID or machine UUID or empty if none).
     899 * @param uuidMachineRegistry The registry to which this medium should be added
     900 *                            (global registry UUID or machine UUID or empty if none).
    899901 */
    900902HRESULT Medium::init(VirtualBox *aVirtualBox,
    … …  
    11101112 * @param aParent       Parent medium disk or NULL for a root (base) medium.
    11111113 * @param aDeviceType   Device type of the medium.
    1112  * @param uuidMachineRegistry The registry to which this medium should be added (global registry UUID or machine UUID).
     1114 * @param uuidMachineRegistry The registry to which this medium should be
     1115 *                            added (global registry UUID or machine UUID).
    11131116 * @param aNode         Configuration settings.
    1114  * @param strMachineFolder The machine folder with which to resolve relative paths; if empty, then we use the VirtualBox home directory
     1117 * @param strMachineFolder The machine folder with which to resolve relative paths;
     1118 *                         if empty, then we use the VirtualBox home directory
    11151119 *
    11161120 * @note Locks the medium tree for writing.
    … …  
    38863890                rc = pProgress->init(m->pVirtualBox,
    38873891                                     static_cast<IMedium*>(this),
    3888                                      BstrFmt(tr("Creating differencing medium storage unit '%s'"), aTarget->m->strLocationFull.c_str()).raw(),
     3892                                     BstrFmt(tr("Creating differencing medium storage unit '%s'"),
     3893                                             aTarget->m->strLocationFull.c_str()).raw(),
    38893894                                     TRUE /* aCancelable */);
    38903895                if (FAILED(rc))
    … …  
    39553960 * the object is no longer usable ("not ready" state).
    39563961 *
    3957  * @param autoCaller AutoCaller instance which must have been created on the caller's stack for this medium. This gets released here
    3958  *                   upon which the Medium instance gets uninitialized.
     3962 * @param autoCaller AutoCaller instance which must have been created on the caller's
     3963 *                              stack for this medium. This gets released hereupon
     3964 *                              which the Medium instance gets uninitialized.
    39593965 * @return
    39603966 */
    … …  
    40064012        // in i_saveModifiedRegistries(), which needs the media tree lock, which
    40074013        // the other thread holds until after uninit() below.
    4008         /// @todo redesign the locking here, as holding the locks over uninit causes lock order trouble which the lock validator can't detect
     4014        // @todo redesign the locking here, as holding the locks over uninit
     4015        // causes lock order trouble which the lock validator can't detect
    40094016        autoCaller.release();
    40104017        m->pVirtualBox->i_saveModifiedRegistries();
    … …  
    53495356 *
    53505357 * @param fSetImageId Whether to reset the UUID contained in the image file to the UUID in the medium instance data (see SetIDs())
    5351  * @param fSetParentId Whether to reset the parent UUID contained in the image file to the parent UUID in the medium instance data (see SetIDs())
     5358 * @param fSetParentId Whether to reset the parent UUID contained in the image file to the parent
     5359 *                     UUID in the medium instance data (see SetIDs())
    53525360 * @return
    53535361 */
    … …  
    67586766            if (capabilities & MediumFormatCapabilities_File)
    67596767            {
    6760                 HRESULT rc = VirtualBox::i_ensureFilePathExists(targetLocation, !(task.mVariant & MediumVariant_NoCreateDir) /* fCreate */);
     6768                HRESULT rc = VirtualBox::i_ensureFilePathExists(targetLocation,
     6769                                                                !(task.mVariant & MediumVariant_NoCreateDir) /* fCreate */);
    67616770                if (FAILED(rc))
    67626771                    throw rc;
    … …  
    72577266            if (capabilities & MediumFormatCapabilities_File)
    72587267            {
    7259                 HRESULT rc = VirtualBox::i_ensureFilePathExists(targetLocation, !(task.mVariant & MediumVariant_NoCreateDir) /* fCreate */);
     7268                HRESULT rc = VirtualBox::i_ensureFilePathExists(targetLocation,
     7269                                                                !(task.mVariant & MediumVariant_NoCreateDir) /* fCreate */);
    72607270                if (FAILED(rc))
    72617271                    throw rc;
    … …  
    79387948            if (capabilities & MediumFormatCapabilities_File)
    79397949            {
    7940                 rc = VirtualBox::i_ensureFilePathExists(targetLocation, !(task.mVariant & MediumVariant_NoCreateDir) /* fCreate */);
     7950                rc = VirtualBox::i_ensureFilePathExists(targetLocation,
     7951                                                        !(task.mVariant & MediumVariant_NoCreateDir) /* fCreate */);
    79417952                if (FAILED(rc))
    79427953                    throw rc;
    … …  
    80648075            if (capabilities & MediumFormatCapabilities_File)
    80658076            {
    8066                 HRESULT rc = VirtualBox::i_ensureFilePathExists(targetLocation, !(task.mVariant & MediumVariant_NoCreateDir) /* fCreate */);
     8077                HRESULT rc = VirtualBox::i_ensureFilePathExists(targetLocation,
     8078                                                                !(task.mVariant & MediumVariant_NoCreateDir) /* fCreate */);
    80678079                if (FAILED(rc))
    80688080                    throw rc;

  • trunk/src/VBox/Main/src-server/NATEngineImpl.cpp

    r49875 r51092  
    285285}
    286286
    287 HRESULT NATEngine::addRedirect(const com::Utf8Str &aName, NATProtocol_T aProto, const com::Utf8Str &aHostIP, USHORT aHostPort, const com::Utf8Str &aGuestIP, USHORT aGuestPort)
     287HRESULT NATEngine::addRedirect(const com::Utf8Str &aName, NATProtocol_T aProto, const com::Utf8Str &aHostIP,
     288                               USHORT aHostPort, const com::Utf8Str &aGuestIP, USHORT aGuestPort)
    288289{
    289290    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    333334
    334335    alock.release();
    335     mParent->onNATRedirectRuleChange(ulSlot, FALSE, Bstr(name).raw(), aProto, Bstr(r.strHostIP).raw(), r.u16HostPort, Bstr(r.strGuestIP).raw(), r.u16GuestPort);
     336    mParent->onNATRedirectRuleChange(ulSlot, FALSE, Bstr(name).raw(), aProto, Bstr(r.strHostIP).raw(),
     337                                     r.u16HostPort, Bstr(r.strGuestIP).raw(), r.u16GuestPort);
    336338    return S_OK;
    337339}
    … …  
    358360    mData->m.commit();
    359361    alock.release();
    360     mParent->onNATRedirectRuleChange(ulSlot, TRUE, Bstr(aName).raw(), proto, Bstr(strHostIP).raw(), u16HostPort, Bstr(strGuestIP).raw(), u16GuestPort);
     362    mParent->onNATRedirectRuleChange(ulSlot, TRUE, Bstr(aName).raw(), proto, Bstr(strHostIP).raw(),
     363                                     u16HostPort, Bstr(strGuestIP).raw(), u16GuestPort);
    361364    return S_OK;
    362365}

  • trunk/src/VBox/Main/src-server/NetworkAdapterImpl.cpp

    r50469 r51092  
    13051305        hrc = mParent->getBandwidthGroup(mData->mBandwidthGroup, pBwGroup, true /* fSetError */);
    13061306
    1307         Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence of the group was checked when it was attached. */
     1307        Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence
     1308                                i  of the group was checked when it was attached. */
    13081309        if (SUCCEEDED(hrc))
    13091310            pBwGroup.queryInterfaceTo(aBandwidthGroup.asOutParam());
    … …  
    13361337            HRESULT hrc = mParent->getBandwidthGroup(strBwGroup, pBwGroup, false /* fSetError */);
    13371338            NOREF(hrc);
    1338             Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence of the group was checked when it was attached. */
     1339            Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence
     1340                                       of the group was checked when it was attached. */
    13391341        }
    13401342
    … …  
    13671369            HRESULT hrc = mParent->getBandwidthGroup(mData->mBandwidthGroup, pOldBwGroup, false /* fSetError */);
    13681370            NOREF(hrc);
    1369             Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence of the group was checked when it was attached. */
     1371            Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence of
     1372                                       the group was checked when it was attached. */
    13701373        }
    13711374

  • trunk/src/VBox/Main/src-server/Performance.cpp

    r49795 r51092  
    7373}
    7474
    75 int CollectorHAL::getRawProcessCpuLoad(RTPROCESS  /* process */, uint64_t * /* user */, uint64_t * /* kernel */, uint64_t * /* total */)
     75int CollectorHAL::getRawProcessCpuLoad(RTPROCESS  /* process */, uint64_t * /* user */,
     76                                       uint64_t * /* kernel */, uint64_t * /* total */)
    7677{
    7778    return VERR_NOT_IMPLEMENTED;
    … …  
    8384}
    8485
    85 int CollectorHAL::getHostFilesystemUsage(const char * /* name */, ULONG * /* total */, ULONG * /* used */, ULONG * /* available */)
     86int CollectorHAL::getHostFilesystemUsage(const char * /* name */, ULONG * /* total */, ULONG * /* used */,
     87                                         ULONG * /* available */)
    8688{
    8789    return VERR_NOT_IMPLEMENTED;

  • trunk/src/VBox/Main/src-server/PerformanceImpl.cpp

    r44528 r51092  
    582582
    583583    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    584     LogAleksey(("{%p} " LOG_FN_FMT ": obj=%p name=%s\n", this, __PRETTY_FUNCTION__, (void *)baseMetric->getObject(), baseMetric->getName()));
     584    LogAleksey(("{%p} " LOG_FN_FMT ": obj=%p name=%s\n", this, __PRETTY_FUNCTION__,
     585                (void *)baseMetric->getObject(), baseMetric->getName()));
    585586    m.baseMetrics.push_back (baseMetric);
    586587    //LogFlowThisFuncLeave();
    … …  
    594595
    595596    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    596     LogAleksey(("{%p} " LOG_FN_FMT ": obj=%p name=%s\n", this, __PRETTY_FUNCTION__, (void *)metric->getObject(), metric->getName()));
     597    LogAleksey(("{%p} " LOG_FN_FMT ": obj=%p name=%s\n", this, __PRETTY_FUNCTION__,
     598                (void *)metric->getObject(), metric->getName()));
    597599    m.metrics.push_back (metric);
    598600    //LogFlowThisFuncLeave();
    … …  
    750752     * Those should be destroyed now.
    751753     */
    752     LogAleksey(("{%p} " LOG_FN_FMT ": before remove_if: toBeCollected.size()=%d\n", this, __PRETTY_FUNCTION__, toBeCollected.size()));
     754    LogAleksey(("{%p} " LOG_FN_FMT ": before remove_if: toBeCollected.size()=%d\n", this, __PRETTY_FUNCTION__,
     755                toBeCollected.size()));
    753756    toBeCollected.remove_if(std::mem_fun(&pm::BaseMetric::isUnregistered));
    754     LogAleksey(("{%p} " LOG_FN_FMT ": after remove_if: toBeCollected.size()=%d\n", this, __PRETTY_FUNCTION__, toBeCollected.size()));
    755     LogAleksey(("{%p} " LOG_FN_FMT ": before remove_if: m.baseMetrics.size()=%d\n", this, __PRETTY_FUNCTION__, m.baseMetrics.size()));
     757    LogAleksey(("{%p} " LOG_FN_FMT ": after remove_if: toBeCollected.size()=%d\n", this, __PRETTY_FUNCTION__,
     758                toBeCollected.size()));
     759    LogAleksey(("{%p} " LOG_FN_FMT ": before remove_if: m.baseMetrics.size()=%d\n", this, __PRETTY_FUNCTION__,
     760                m.baseMetrics.size()));
    756761    for (it = m.baseMetrics.begin(); it != m.baseMetrics.end();)
    757762        if ((*it)->isUnregistered())
    … …  
    762767        else
    763768            ++it;
    764     LogAleksey(("{%p} " LOG_FN_FMT ": after remove_if: m.baseMetrics.size()=%d\n", this, __PRETTY_FUNCTION__, m.baseMetrics.size()));
     769    LogAleksey(("{%p} " LOG_FN_FMT ": after remove_if: m.baseMetrics.size()=%d\n", this, __PRETTY_FUNCTION__,
     770                m.baseMetrics.size()));
    765771    /*
    766772     * Now when we have destroyed all base metrics that could

  • trunk/src/VBox/Main/src-server/USBDeviceFilterImpl.cpp

    r50472 r51092  
    122122                    else
    123123                    {
    124                         aErrStr = Utf8StrFmt(tr("The %s value '%s' is too big (max 0xFFFF)"), i_describeUSBFilterIdx(aIdx), pcszValue);
     124                        aErrStr = Utf8StrFmt(tr("The %s value '%s' is too big (max 0xFFFF)"),
     125                                             i_describeUSBFilterIdx(aIdx), pcszValue);
    125126                        return E_INVALIDARG;
    126127                    }
    … …  
    155156        if (vrc == VERR_BUFFER_OVERFLOW)
    156157        {
    157             aErrStr = Utf8StrFmt(tr("Insufficient expression space for the '%s' filter expression '%s'"), i_describeUSBFilterIdx(aIdx), aValue.c_str());
     158            aErrStr = Utf8StrFmt(tr("Insufficient expression space for the '%s' filter expression '%s'"),
     159                                 i_describeUSBFilterIdx(aIdx), aValue.c_str());
    158160            return E_FAIL;
    159161        }
    160162        AssertRC(vrc);
    161         aErrStr = Utf8StrFmt(tr("Encountered unexpected status %Rrc when setting '%s' to '%s'"), vrc, i_describeUSBFilterIdx(aIdx), aValue.c_str());
     163        aErrStr = Utf8StrFmt(tr("Encountered unexpected status %Rrc when setting '%s' to '%s'"),
     164                             vrc, i_describeUSBFilterIdx(aIdx), aValue.c_str());
    162165        return E_FAIL;
    163166    }

  • trunk/src/VBox/Main/src-server/USBProxyService.cpp

    r50355 r51092  
    356356                &&  fRunFilters)
    357357            {
    358                 Assert(aDone && pHostDevice->i_getUnistate() == kHostUSBDeviceState_HeldByProxy && pHostDevice->i_getMachine().isNull());
     358                Assert(aDone && pHostDevice->i_getUnistate() ==
     359                    kHostUSBDeviceState_HeldByProxy && pHostDevice->i_getMachine().isNull());
    359360                devLock.release();
    360361                alock.release();
    … …  
    404405    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    405406    AutoWriteLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
    406     AssertMsgReturn(aDevice->i_isCapturableOrHeld(), ("{%s} %s\n", aDevice->i_getName().c_str(), aDevice->i_getStateName()), E_FAIL);
     407    AssertMsgReturn(aDevice->i_isCapturableOrHeld(), ("{%s} %s\n", aDevice->i_getName().c_str(),
     408                                                      aDevice->i_getStateName()), E_FAIL);
    407409
    408410    /*
    … …  
    10811083 * @param   aRunFilters Whether or not to run filters.
    10821084 */
    1083 bool USBProxyService::updateDeviceStateFake(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters, SessionMachine **aIgnoreMachine)
     1085bool USBProxyService::updateDeviceStateFake(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters,
     1086                                            SessionMachine **aIgnoreMachine)
    10841087{
    10851088    *aRunFilters = false;
    … …  
    11061109 * @param   aIgnoreMachine  Machine to ignore when running filters.
    11071110 */
    1108 bool USBProxyService::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters, SessionMachine **aIgnoreMachine)
     1111bool USBProxyService::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters,
     1112                                        SessionMachine **aIgnoreMachine)
    11091113{
    11101114    AssertReturn(aDevice, false);
    … …  
    11251129 * @param   aIgnoreMachine  Machine to ignore when running filters.
    11261130 */
    1127 void USBProxyService::deviceChanged(ComObjPtr<HostUSBDevice> &aDevice, SessionMachinesList *pllOpenedMachines, SessionMachine *aIgnoreMachine)
     1131void USBProxyService::deviceChanged(ComObjPtr<HostUSBDevice> &aDevice, SessionMachinesList *pllOpenedMachines,
     1132                                    SessionMachine *aIgnoreMachine)
    11281133{
    11291134    /*

  • trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

    r51041 r51092  
    14541454{
    14551455    LogFlowThisFuncEnter();
    1456     LogFlowThisFunc(("aSettingsFile=\"%s\", aName=\"%s\", aOsTypeId =\"%s\", aCreateFlags=\"%s\"\n", aSettingsFile.c_str(), aName.c_str(), aOsTypeId.c_str(), aFlags.c_str()));
     1456    LogFlowThisFunc(("aSettingsFile=\"%s\", aName=\"%s\", aOsTypeId =\"%s\", aCreateFlags=\"%s\"\n",
     1457                     aSettingsFile.c_str(), aName.c_str(), aOsTypeId.c_str(), aFlags.c_str()));
    14571458    /** @todo tighten checks on aId? */
    14581459
    … …  
    38533854 *
    38543855 * @param mediaRegistry Settings structure to fill.
    3855  * @param uuidRegistry The UUID of the media registry; either a machine UUID (if machine registry) or the UUID of the global registry.
     3856 * @param uuidRegistry The UUID of the media registry; either a machine UUID (
     3857 *        if machine registry) or the UUID of the global registry.
    38563858 * @param strMachineFolder The machine folder for relative paths, if machine registry, or an empty string otherwise.
    38573859 */

  • trunk/src/VBox/Main/src-server/freebsd/HostHardwareFreeBSD.cpp

    r48424 r51092  
    251251                        PeriphMatchPattern.pattern.periph_pattern.target_id  = paMatches[i].result.device_result.target_id;
    252252                        PeriphMatchPattern.pattern.periph_pattern.target_lun = paMatches[i].result.device_result.target_lun;
    253                         PeriphMatchPattern.pattern.periph_pattern.flags      = PERIPH_MATCH_PATH | PERIPH_MATCH_TARGET | PERIPH_MATCH_LUN;
     253                        PeriphMatchPattern.pattern.periph_pattern.flags      = PERIPH_MATCH_PATH | PERIPH_MATCH_TARGET |
     254                                                                               PERIPH_MATCH_LUN;
    254255                        PeriphCCB.cdm.num_patterns    = 1;
    255256                        PeriphCCB.cdm.pattern_buf_len = sizeof(struct dev_match_result);

  • trunk/src/VBox/Main/src-server/freebsd/USBProxyServiceFreeBSD.cpp

    r47117 r51092  
    147147
    148148
    149 bool USBProxyServiceFreeBSD::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters, SessionMachine **aIgnoreMachine)
     149bool USBProxyServiceFreeBSD::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters,
     150                                               SessionMachine **aIgnoreMachine)
    150151{
    151152    AssertReturn(aDevice, false);
    … …  
    161162 * See USBProxyService::deviceAdded for details.
    162163 */
    163 void USBProxyServiceFreeBSD::deviceAdded(ComObjPtr<HostUSBDevice> &aDevice, SessionMachinesList &llOpenedMachines, PUSBDEVICE aUSBDevice)
     164void USBProxyServiceFreeBSD::deviceAdded(ComObjPtr<HostUSBDevice> &aDevice, SessionMachinesList &llOpenedMachines,
     165                                         PUSBDEVICE aUSBDevice)
    164166{
    165167    USBProxyService::deviceAdded(aDevice, llOpenedMachines, aUSBDevice);

  • trunk/src/VBox/Main/src-server/linux/USBGetDevices.cpp

    r50783 r51092  
    466466
    467467/** Just a worker for USBProxyServiceLinux::getDevices that avoids some code duplication. */
    468 static int addDeviceToChain(PUSBDEVICE pDev, PUSBDEVICE *ppFirst, PUSBDEVICE **pppNext, const char *pcszUsbfsRoot, bool testfs, int rc)
     468static int addDeviceToChain(PUSBDEVICE pDev, PUSBDEVICE *ppFirst, PUSBDEVICE **pppNext, const char *pcszUsbfsRoot,
     469                            bool testfs, int rc)
    469470{
    470471    /* usbDeterminState requires the address. */

  • trunk/src/VBox/Main/src-server/linux/USBProxyServiceLinux.cpp

    r49960 r51092  
    258258
    259259
    260 bool USBProxyServiceLinux::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters, SessionMachine **aIgnoreMachine)
     260bool USBProxyServiceLinux::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters,
     261                                             SessionMachine **aIgnoreMachine)
    261262{
    262263    AssertReturn(aDevice, false);
    … …  
    277278 * See USBProxyService::deviceAdded for details.
    278279 */
    279 void USBProxyServiceLinux::deviceAdded(ComObjPtr<HostUSBDevice> &aDevice, SessionMachinesList &llOpenedMachines, PUSBDEVICE aUSBDevice)
     280void USBProxyServiceLinux::deviceAdded(ComObjPtr<HostUSBDevice> &aDevice, SessionMachinesList &llOpenedMachines,
     281                                       PUSBDEVICE aUSBDevice)
    280282{
    281283    AssertReturnVoid(aDevice);

  • trunk/src/VBox/Main/src-server/os2/USBProxyServiceOs2.cpp

    r41528 r51092  
    166166
    167167
    168 bool USBProxyServiceOs2::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters, SessionMachine **aIgnoreMachine)
     168bool USBProxyServiceOs2::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters,
     169                                           SessionMachine **aIgnoreMachine)
    169170{
    170171    AssertReturn(aDevice, false);

  • trunk/src/VBox/Main/src-server/solaris/NetIf-solaris.cpp

    r48020 r51092  
    124124static void vboxSolarisAddHostIface(char *pszIface, int Instance, void *pvHostNetworkInterfaceList)
    125125{
    126     std::list<ComObjPtr<HostNetworkInterface> > *pList = (std::list<ComObjPtr<HostNetworkInterface> > *)pvHostNetworkInterfaceList;
     126    std::list<ComObjPtr<HostNetworkInterface> > *pList =
     127        (std::list<ComObjPtr<HostNetworkInterface> > *)pvHostNetworkInterfaceList;
    127128    Assert(pList);
    128129

  • trunk/src/VBox/Main/src-server/solaris/USBProxyServiceSolaris.cpp

    r49964 r51092  
    441441
    442442
    443 bool USBProxyServiceSolaris::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters, SessionMachine **aIgnoreMachine)
     443bool USBProxyServiceSolaris::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters,
     444                                               SessionMachine **aIgnoreMachine)
    444445{
    445446    AssertReturn(aDevice, false);

  • trunk/src/VBox/Main/src-server/win/HostPowerWin.cpp

    r49938 r51092  
    172172                    if (GetSystemPowerStatus(&SystemPowerStatus) == TRUE)
    173173                    {
    174                         Log(("PBT_APMPOWERSTATUSCHANGE ACLineStatus=%d BatteryFlag=%d\n", SystemPowerStatus.ACLineStatus, SystemPowerStatus.BatteryFlag));
     174                        Log(("PBT_APMPOWERSTATUSCHANGE ACLineStatus=%d BatteryFlag=%d\n", SystemPowerStatus.ACLineStatus,
     175                             SystemPowerStatus.BatteryFlag));
    175176
    176177                        if (SystemPowerStatus.ACLineStatus == 0)      /* offline */
    … …  
    181182                                SYSTEM_BATTERY_STATE BatteryState;
    182183
    183                                 rc = CallNtPowerInformation(SystemBatteryState, NULL, 0, (PVOID)&BatteryState, sizeof(BatteryState));
     184                                rc = CallNtPowerInformation(SystemBatteryState, NULL, 0, (PVOID)&BatteryState,
     185                                                            sizeof(BatteryState));
    184186#ifdef LOG_ENABLED
    185187                                if (rc == 0 /* STATUS_SUCCESS */)
    186                                     Log(("CallNtPowerInformation claims %d seconds of power left\n", BatteryState.EstimatedTime));
     188                                    Log(("CallNtPowerInformation claims %d seconds of power left\n",
     189                                         BatteryState.EstimatedTime));
    187190#endif
    188191                                if (    rc == 0 /* STATUS_SUCCESS */
    … …  
    193196                            }
    194197                            else
    195                             /* If the machine has less than 5% battery left (and is not connected to the AC), then we should save the state. */
     198                            /* If the machine has less than 5% battery left (and is not connected
     199 *                             to the AC), then we should save the state. */
    196200                            if (SystemPowerStatus.BatteryFlag == 4      /* critical battery status; less than 5% */)
    197201                            {

  • trunk/src/VBox/Main/src-server/win/NetIf-win.cpp

    r50355 r51092  
    668668            Bstr bstrErr;
    669669
    670             hrc = VBoxNetCfgWinCreateHostOnlyNetworkInterface(NULL, false, guid.asOutParam(), name.asOutParam(), bstrErr.asOutParam());
     670            hrc = VBoxNetCfgWinCreateHostOnlyNetworkInterface(NULL, false, guid.asOutParam(), name.asOutParam(),
     671                                                              bstrErr.asOutParam());
    671672
    672673            if (hrc == S_OK)
    … …  
    12721273}
    12731274
    1274 int NetIfEnableStaticIpConfigV6(VirtualBox *vBox, HostNetworkInterface * pIf, IN_BSTR aOldIPV6Address, IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
     1275int NetIfEnableStaticIpConfigV6(VirtualBox *vBox, HostNetworkInterface * pIf, IN_BSTR aOldIPV6Address,
     1276                                IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
    12751277{
    12761278#ifndef VBOX_WITH_NETFLT
    … …  
    15301532                                                    if (uComponentStatus == 0)
    15311533                                                    {
    1532                                                         vboxNetWinAddComponent(&list, pMpNcc, HostNetworkInterfaceType_Bridged, iDefault);
     1534                                                        vboxNetWinAddComponent(&list, pMpNcc, HostNetworkInterfaceType_Bridged,
     1535                                                                               iDefault);
    15331536                                                    }
    15341537                                                }

  • trunk/src/VBox/Main/src-server/win/PerformanceWin.cpp

    r46593 r51092  
    269269    uint64_t uTotalMhz   = 0;
    270270    RTCPUID  nProcessors = RTMpGetCount();
    271     PPROCESSOR_POWER_INFORMATION ppi = (PPROCESSOR_POWER_INFORMATION)RTMemAllocZ(nProcessors * sizeof(PROCESSOR_POWER_INFORMATION));
     271    PPROCESSOR_POWER_INFORMATION ppi = (PPROCESSOR_POWER_INFORMATION)
     272                                       RTMemAllocZ(nProcessors * sizeof(PROCESSOR_POWER_INFORMATION));
    272273
    273274    if (!ppi)

  • trunk/src/VBox/Main/src-server/win/USBProxyServiceWindows.cpp

    r49960 r51092  
    220220
    221221
    222 bool USBProxyServiceWindows::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters, SessionMachine **aIgnoreMachine)
     222bool USBProxyServiceWindows::updateDeviceState(HostUSBDevice *aDevice, PUSBDEVICE aUSBDevice, bool *aRunFilters,
     223                                               SessionMachine **aIgnoreMachine)
    223224{
    224225    AssertReturn(aDevice, false);
Note: See TracChangeset for help on using the changeset viewer.

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