VirtualBox

Changeset 13838

Show
Ignore:
Timestamp:
11/05/08 04:16:55 (2 months ago)
Author:
vboxsync
Message:

Some more %V* -> %R* changes while at it.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/VBox/Additions/WINNT/VBoxGuest/VBoxGuest.cpp

    r13837 r13838  
    494494                rc = VERR_NO_MEMORY; 
    495495                ExFreePool(pvBalloon); 
    496                 AssertMsgFailed(("IoAllocateMdl %VGv %x failed!!\n", pvBalloon, VMMDEV_MEMORY_BALLOON_CHUNK_SIZE)); 
     496                AssertMsgFailed(("IoAllocateMdl %p %x failed!!\n", pvBalloon, VMMDEV_MEMORY_BALLOON_CHUNK_SIZE)); 
    497497                goto end; 
    498498            } 
  • trunk/src/VBox/Frontends/VBoxBFE/HostUSBImpl.cpp

    r13837 r13838  
    242242    void *pvRemote = NULL; 
    243243 
    244     LogFlowMember (("Console::AttachUSBDevice: Proxying USB device '%s' %Vuuid...\n", Address.c_str(), &Uuid)); 
     244    LogFlowMember (("Console::AttachUSBDevice: Proxying USB device '%s' %Ruuid...\n", Address.c_str(), &Uuid)); 
    245245    PVMREQ pReq; 
    246246    vrc = VMR3ReqCall (mpVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, 
     
    255255    else 
    256256    { 
    257         Log (("Console::AttachUSBDevice: Failed to create proxy device for '%s' %Vuuid, vrc=%Rrc\n", Address.c_str(), 
     257        Log (("Console::AttachUSBDevice: Failed to create proxy device for '%s' %Ruuid, vrc=%Rrc\n", Address.c_str(), 
    258258        &Uuid, vrc)); 
    259259        AssertRC (vrc); 
     
    301301 
    302302            RTUUID Uuid = aDevice->id(); 
    303             LogFlowMember (("Console::DetachUSBDevice: Detaching USB proxy device %Vuuid...\n", &Uuid)); 
     303            LogFlowMember (("Console::DetachUSBDevice: Detaching USB proxy device %Ruuid...\n", &Uuid)); 
    304304            PVMREQ pReq; 
    305305            vrc = VMR3ReqCall (mpVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT, (PFNRT)pRhConfig->pfnDestroyProxyDevice, 
  • trunk/src/VBox/Frontends/VBoxBFE/VBoxBFE.cpp

    r13837 r13838  
    709709            rc = RTStrToInt32Ex(argv[curArg], NULL, 0, &g_aNetDevs[i].fd); 
    710710            if (RT_FAILURE(rc)) 
    711                 return SyntaxError("bad tap file descriptor: %s (error %VRc)\n", argv[curArg], rc); 
     711                return SyntaxError("bad tap file descriptor: %s (error %Rrc)\n", argv[curArg], rc); 
    712712            g_aNetDevs[i].fHaveFd = true; 
    713713        } 
     
    722722                rc = RTStrToInt32Ex(argv[curArg], NULL, 0, &portVRDP); 
    723723                if (RT_FAILURE(rc)) 
    724                     return SyntaxError("cannot vrpd port: %s (%VRc)\n", argv[curArg], rc); 
     724                    return SyntaxError("cannot vrpd port: %s (%Rrc)\n", argv[curArg], rc); 
    725725                if (portVRDP < 0 || portVRDP >= 0x10000) 
    726726                    return SyntaxError("vrdp port number is out of range: %RI32\n", portVRDP); 
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

    r13837 r13838  
    28132813                machine->COMGETTER(Name)(name.asOutParam()); 
    28142814                machine->COMGETTER(Id)(uuid.asOutParam()); 
    2815                 RTPrintf("%s%lS (UUID: %Vuuid)\n", 
     2815                RTPrintf("%s%lS (UUID: %Ruuid)\n", 
    28162816                         j == 0 ? "Usage:        " : "              ", 
    28172817                         name.raw(), &machineIds[j]); 
     
    65036503                machine->COMGETTER(Name)(name.asOutParam()); 
    65046504                machine->COMGETTER(Id)(uuid.asOutParam()); 
    6505                 RTPrintf("%s%lS (UUID: %Vuuid)\n", 
     6505                RTPrintf("%s%lS (UUID: %Ruuid)\n", 
    65066506                         j == 0 ? "In use by VMs:        " : "                      ", 
    65076507                         name.raw(), &machineIds[j]); 
  • trunk/src/VBox/HostDrivers/Support/testcase/tstLow.cpp

    r13837 r13838  
    6565            for (unsigned iPage = 0; iPage < RT_ELEMENTS(aPages0); iPage++) 
    6666            { 
    67                 RTPrintf("%-4d: Phys=%VHp Reserved=%p\n", iPage, aPages0[iPage].Phys, aPages0[iPage].uReserved); 
     67                RTPrintf("%-4d: Phys=%RHp Reserved=%p\n", iPage, aPages0[iPage].Phys, aPages0[iPage].uReserved); 
    6868                if (aPages0[iPage].uReserved != 0) 
    6969                { 
     
    7575                { 
    7676                    rcRet++; 
    77                     RTPrintf("tstLow: error: aPages0[%d].Phys=%VHp!\n", iPage, aPages0[iPage].Phys); 
     77                    RTPrintf("tstLow: error: aPages0[%d].Phys=%RHp!\n", iPage, aPages0[iPage].Phys); 
    7878                } 
    7979            } 
     
    113113                for (unsigned iPage = 0; iPage < cPages; iPage++) 
    114114                { 
    115                     RTPrintf("%-4d::%-4d: Phys=%VHp Reserved=%p\n", cPages, iPage, aPages1[iPage].Phys, aPages1[iPage].uReserved); 
     115                    RTPrintf("%-4d::%-4d: Phys=%RHp Reserved=%p\n", cPages, iPage, aPages1[iPage].Phys, aPages1[iPage].uReserved); 
    116116                    if (aPages1[iPage].uReserved != 0) 
    117117                    { 
     
    123123                    { 
    124124                        rcRet++; 
    125                         RTPrintf("tstLow: error: aPages1[%d].Phys=%VHp!\n", iPage, aPages1[iPage].Phys); 
     125                        RTPrintf("tstLow: error: aPages1[%d].Phys=%RHp!\n", iPage, aPages1[iPage].Phys); 
    126126                    } 
    127127                } 
  • trunk/src/VBox/HostServices/SharedFolders/vbsf.cpp

    r13837 r13838  
    15241524    { 
    15251525        Log(("RTFileSetTimes failed with %Rrc\n", rc)); 
    1526         Log(("AccessTime       %VX64\n", RTTimeSpecGetNano(&pSFDEntry->AccessTime))); 
    1527         Log(("ModificationTime %VX64\n", RTTimeSpecGetNano(&pSFDEntry->ModificationTime))); 
    1528         Log(("ChangeTime       %VX64\n", RTTimeSpecGetNano(&pSFDEntry->ChangeTime))); 
    1529         Log(("BirthTime        %VX64\n", RTTimeSpecGetNano(&pSFDEntry->AccessTime))); 
     1526        Log(("AccessTime       %RX64\n", RTTimeSpecGetNano(&pSFDEntry->AccessTime))); 
     1527        Log(("ModificationTime %RX64\n", RTTimeSpecGetNano(&pSFDEntry->ModificationTime))); 
     1528        Log(("ChangeTime       %RX64\n", RTTimeSpecGetNano(&pSFDEntry->ChangeTime))); 
     1529        Log(("BirthTime        %RX64\n", RTTimeSpecGetNano(&pSFDEntry->AccessTime))); 
    15301530        /* temporary hack */ 
    15311531        rc = VINF_SUCCESS; 
  • trunk/src/VBox/Main/ConsoleImpl.cpp

    r13837 r13838  
    20802080    if (!device) 
    20812081        return setError (E_INVALIDARG, 
    2082             tr ("USB device with UUID {%Vuuid} is not attached to this machine"), 
     2082            tr ("USB device with UUID {%Ruuid} is not attached to this machine"), 
    20832083            Guid (aId).raw()); 
    20842084 
     
    21112111#else   /* !VBOX_WITH_USB */ 
    21122112    return setError (E_INVALIDARG, 
    2113         tr ("USB device with UUID {%Vuuid} is not attached to this machine"), 
     2113        tr ("USB device with UUID {%Ruuid} is not attached to this machine"), 
    21142114        Guid (aId).raw()); 
    21152115#endif  /* !VBOX_WITH_USB */ 
     
    35293529#ifdef VBOX_WITH_USB 
    35303530    Guid Uuid (aId); 
    3531     LogFlowThisFunc (("aId={%Vuuid} aError=%p\n", Uuid.raw(), aError)); 
     3531    LogFlowThisFunc (("aId={%Ruuid} aError=%p\n", Uuid.raw(), aError)); 
    35323532 
    35333533    AutoCaller autoCaller (this); 
     
    35413541    while (it != mUSBDevices.end()) 
    35423542    { 
    3543         LogFlowThisFunc (("it={%Vuuid}\n", (*it)->id().raw())); 
     3543        LogFlowThisFunc (("it={%Ruuid}\n", (*it)->id().raw())); 
    35443544        if ((*it)->id() == Uuid) 
    35453545        { 
     
    55135513    CheckComRCReturnRC (autoVMCaller.rc()); 
    55145514 
    5515     LogFlowThisFunc (("Proxying USB device '%s' {%Vuuid}...\n", 
     5515    LogFlowThisFunc (("Proxying USB device '%s' {%Ruuid}...\n", 
    55165516                      Address.raw(), Uuid.ptr())); 
    55175517 
     
    55345534    if (VBOX_FAILURE (vrc)) 
    55355535    { 
    5536         LogWarningThisFunc (("Failed to create proxy device for '%s' {%Vuuid} (%Rrc)\n", 
     5536        LogWarningThisFunc (("Failed to create proxy device for '%s' {%Ruuid} (%Rrc)\n", 
    55375537                             Address.raw(), Uuid.ptr(), vrc)); 
    55385538 
     
    56035603        AutoWriteLock alock (that); 
    56045604        that->mUSBDevices.push_back (device); 
    5605         LogFlowFunc (("Attached device {%Vuuid}\n", device->id().raw())); 
     5605        LogFlowFunc (("Attached device {%Ruuid}\n", device->id().raw())); 
    56065606 
    56075607        /* notify callbacks */ 
     
    56385638    AssertReturn (PDMR3USBHasHub (mpVM), E_FAIL); 
    56395639 
    5640     LogFlowThisFunc (("Detaching USB proxy device {%Vuuid}...\n", 
     5640    LogFlowThisFunc (("Detaching USB proxy device {%Ruuid}...\n", 
    56415641                      (*aIt)->id().raw())); 
    56425642 
     
    57005700        /* Remove the device from the collection */ 
    57015701        that->mUSBDevices.erase (*aIt); 
    5702         LogFlowFunc (("Detached device {%Vuuid}\n", device->id().raw())); 
     5702        LogFlowFunc (("Detached device {%Ruuid}\n", device->id().raw())); 
    57035703 
    57045704        /* notify callbacks */ 
  • trunk/src/VBox/Main/ConsoleVRDPServer.cpp

    r13837 r13838  
    13251325    memcpy (rawuuid, ((Guid &)uuid).ptr (), sizeof (rawuuid)); 
    13261326 
    1327     LogFlow(("ConsoleVRDPServer::Authenticate: uuid = %Vuuid, guestJudgement = %d, pszUser = %s, pszPassword = %s, pszDomain = %s, u32ClientId = %d\n", 
     1327    LogFlow(("ConsoleVRDPServer::Authenticate: uuid = %Ruuid, guestJudgement = %d, pszUser = %s, pszPassword = %s, pszDomain = %s, u32ClientId = %d\n", 
    13281328             rawuuid, guestJudgement, pszUser, pszPassword, pszDomain, u32ClientId)); 
    13291329 
     
    14331433    memcpy (rawuuid, ((Guid &)uuid).ptr (), sizeof (rawuuid)); 
    14341434 
    1435     LogFlow(("ConsoleVRDPServer::AuthDisconnect: uuid = %Vuuid, u32ClientId = %d\n", 
     1435    LogFlow(("ConsoleVRDPServer::AuthDisconnect: uuid = %Ruuid, u32ClientId = %d\n", 
    14361436             rawuuid, u32ClientId)); 
    14371437 
  • trunk/src/VBox/Main/HardDisk2Impl.cpp

    r13837 r13838  
    631631    } 
    632632 
    633     LogFlowThisFunc (("m.location='%ls', mm.format=%ls, m.id={%Vuuid}\n", 
     633    LogFlowThisFunc (("m.location='%ls', mm.format=%ls, m.id={%Ruuid}\n", 
    634634                      m.location.raw(), mm.format.raw(), m.id.raw())); 
    635635    LogFlowThisFunc (("m.locationFull='%ls'\n", m.locationFull.raw())); 
     
    18281828                return setError (E_FAIL, 
    18291829                    tr ("Hard disk '%ls' is attached to a virtual machine " 
    1830                         "with UUID {%Vuuid}. No differencing hard disks " 
     1830                        "with UUID {%Ruuid}. No differencing hard disks " 
    18311831                        "based on it may be created until it is detached"), 
    18321832                    m.location.raw(), it->machineId.raw()); 
     
    21972197 
    21982198            /// @todo NEWMEDIA use the default extension for the given VD backend 
    2199             location = Utf8StrFmt ("%s{%Vuuid}.vdi", location.raw(), id.raw()); 
     2199            location = Utf8StrFmt ("%s{%Ruuid}.vdi", location.raw(), id.raw()); 
    22002200        } 
    22012201        else 
     
    23692369                { 
    23702370                    lastAccessError = Utf8StrFmt ( 
    2371                         tr ("UUID {%Vuuid} of the hard disk '%ls' " 
    2372                             "does not match the value {%Vuuid} stored in the " 
     2371                        tr ("UUID {%Ruuid} of the hard disk '%ls' " 
     2372                            "does not match the value {%Ruuid} stored in the " 
    23732373                            "media registry ('%ls')"), 
    23742374                        &uuid, m.locationFull.raw(), m.id.raw(), 
     
    24052405                    { 
    24062406                        lastAccessError = Utf8StrFmt ( 
    2407                             tr ("Parent hard disk with UUID {%Vuuid} of the " 
     2407                            tr ("Parent hard disk with UUID {%Ruuid} of the " 
    24082408                                "hard disk '%ls' is not found in the media " 
    24092409                                "registry ('%ls')"), 
     
    24412441                    { 
    24422442                        lastAccessError = Utf8StrFmt ( 
    2443                             tr ("Parent UUID {%Vuuid} of the hard disk '%ls' " 
    2444                                 "does not match UUID {%Vuuid} of its parent " 
     2443                            tr ("Parent UUID {%Ruuid} of the hard disk '%ls' " 
     2444                                "does not match UUID {%Ruuid} of its parent " 
    24452445                                "hard disk stored in the media registry ('%ls')"), 
    24462446                            &uuid, m.locationFull.raw(), 
  • trunk/src/VBox/Main/HostImpl.cpp

    r13837 r13838  
    13671367        if (FAILED (coll->FindById (aId, iface.asOutParam()))) 
    13681368            return setError (E_FAIL, 
    1369                 tr ("Host network interface with UUID {%Vuuid} does not exist"), 
     1369                tr ("Host network interface with UUID {%Ruuid} does not exist"), 
    13701370                Guid (aId).raw()); 
    13711371 
     
    26622662 
    26632663        aGUID = Guid (Utf8Str (pCfgGuidString + 1)); 
    2664         LogFlowFunc (("Network connection GUID = {%Vuuid}\n", aGUID.raw())); 
     2664        LogFlowFunc (("Network connection GUID = {%Ruuid}\n", aGUID.raw())); 
    26652665        Assert (!aGUID.isEmpty()); 
    26662666    } 
     
    26772677{ 
    26782678    LogFlowFuncEnter(); 
    2679     LogFlowFunc (("Network connection GUID = {%Vuuid}\n", aGUID.raw())); 
     2679    LogFlowFunc (("Network connection GUID = {%Ruuid}\n", aGUID.raw())); 
    26802680 
    26812681    AssertReturn (aClient, VERR_INVALID_POINTER); 
     
    29422942                        if (RT_FAILURE (vrc)) break; 
    29432943 
    2944                         LogFlowFunc (("Network connection GUID = {%Vuuid}\n", guid.raw())); 
     2944                        LogFlowFunc (("Network connection GUID = {%Ruuid}\n", guid.raw())); 
    29452945 
    29462946                        /* initialize the object returned to the caller by 
     
    29772977        { 
    29782978            LogFlowFunc (("RemoveHostNetworkInterface:\n")); 
    2979             LogFlowFunc (("Network connection GUID = {%Vuuid}\n", d->guid.raw())); 
     2979            LogFlowFunc (("Network connection GUID = {%Ruuid}\n", d->guid.raw())); 
    29802980 
    29812981            /* write message and parameters */ 
  • trunk/src/VBox/Main/MachineImpl.cpp

    r13837 r13838  
    577577        /* fetch the current error info */ 
    578578        mData->mAccessError = com::ErrorInfo(); 
    579         LogWarning (("Machine {%Vuuid} is inaccessible! [%ls]\n", 
     579        LogWarning (("Machine {%Ruuid} is inaccessible! [%ls]\n", 
    580580                     mData->mUuid.raw(), 
    581581                     mData->mAccessError.getText().raw())); 
     
    13211321            /* the default snapshots folder is {UUID}, for backwards 
    13221322             * compatibility and to resolve conflicts */ 
    1323             snapshotFolder = Utf8StrFmt ("{%Vuuid}", mData->mUuid.raw()); 
     1323            snapshotFolder = Utf8StrFmt ("{%Ruuid}", mData->mUuid.raw()); 
    13241324        } 
    13251325    } 
     
    46754675            { 
    46764676                throw setError (E_FAIL, 
    4677                     tr ("Machine UUID {%Vuuid} in '%ls' doesn't match its " 
     4677                    tr ("Machine UUID {%Ruuid} in '%ls' doesn't match its " 
    46784678                        "UUID {%s} in the registry file '%ls'"), 
    46794679                    id.raw(), mData->mConfigFileFull.raw(), 
     
    52965296            if (mType == IsSnapshotMachine) 
    52975297                return setError (E_FAIL, 
    5298                     tr ("Immutable hard disk '%ls' with UUID {%Vuuid} cannot be " 
    5299                         "directly attached to snapshot with UUID {%Vuuid} " 
     5298                    tr ("Immutable hard disk '%ls' with UUID {%Ruuid} cannot be " 
     5299                        "directly attached to snapshot with UUID {%Ruuid} " 
    53005300                        "of the virtual machine '%ls' ('%ls')"), 
    53015301                    hd->locationFull().raw(), uuid.raw(), 
     
    53045304 
    53055305            return setError (E_FAIL, 
    5306                 tr ("Immutable hard disk '%ls' with UUID {%Vuuid} cannot be " 
     5306                tr ("Immutable hard disk '%ls' with UUID {%Ruuid} cannot be " 
    53075307                    "directly attached to the virtual machine '%ls' ('%ls')"), 
    53085308                hd->locationFull().raw(), uuid.raw(), 
     
    53125312        if (mType != IsSnapshotMachine && hd->children().size() != 0) 
    53135313            return setError (E_FAIL, 
    5314                 tr ("Hard disk '%ls' with UUID {%Vuuid} cannot be directly " 
     5314                tr ("Hard disk '%ls' with UUID {%Ruuid} cannot be directly " 
    53155315                    "attached to the virtual machine '%ls' ('%ls') " 
    53165316                    "because it has %d differencing child hard disks"), 
     
    53255325        { 
    53265326            return setError (E_FAIL, 
    5327                 tr ("Hard disk '%ls' with UUID {%Vuuid} is already attached " 
     5327                tr ("Hard disk '%ls' with UUID {%Ruuid} is already attached " 
    53285328                    "to the virtual machine '%ls' ('%ls')"), 
    53295329                hd->locationFull().raw(), uuid.raw(), 
     
    76737673                     E_FAIL); 
    76747674#elif defined(RT_OS_OS2) 
    7675     Utf8Str ipcSem = Utf8StrFmt ("\\SEM32\\VBOX\\VM\\{%Vuuid}", 
     7675    Utf8Str ipcSem = Utf8StrFmt ("\\SEM32\\VBOX\\VM\\{%Ruuid}", 
    76767676                                 aMachine->mData->mUuid.raw()); 
    76777677    mIPCSemName = ipcSem; 
     
    82848284    if (mData->mMachineState == MachineState_Paused) 
    82858285    { 
    8286         stateFilePath = Utf8StrFmt ("%ls%c{%Vuuid}.sav", 
     8286        stateFilePath = Utf8StrFmt ("%ls%c{%Ruuid}.sav", 
    82878287                                    mUserData->mSnapshotFolderFull.raw(), 
    82888288                                    RTPATH_DELIMITER, mData->mUuid.raw()); 
     
    84358435    /* stateFilePath is null when the machine is not online nor saved */ 
    84368436    if (takingSnapshotOnline || mData->mMachineState == MachineState_Saved) 
    8437         stateFilePath = Utf8StrFmt ("%ls%c{%Vuuid}.sav", 
     8437        stateFilePath = Utf8StrFmt ("%ls%c{%Ruuid}.sav", 
    84388438                                    mUserData->mSnapshotFolderFull.raw(), 
    84398439                                    RTPATH_DELIMITER, 
     
    1002410024                Utf8Str snapStateFilePath = curSnapshot->stateFilePath(); 
    1002510025 
    10026                 Utf8Str stateFilePath = Utf8StrFmt ("%ls%c{%Vuuid}.sav", 
     10026                Utf8Str stateFilePath = Utf8StrFmt ("%ls%c{%Ruuid}.sav", 
    1002710027                    mUserData->mSnapshotFolderFull.raw(), 
    1002810028                    RTPATH_DELIMITER, mData->mUuid.raw()); 
  • trunk/src/VBox/Main/MediumImpl.cpp

    r13837 r13838  
    942942                                        const Guid &aId) 
    943943{ 
    944     LogFlowThisFunc (("aLocation='%ls', aId={%Vuuid}\n", aLocation, aId.raw())); 
     944    LogFlowThisFunc (("aLocation='%ls', aId={%Ruuid}\n", aLocation, aId.raw())); 
    945945 
    946946    AssertReturn (aVirtualBox, E_INVALIDARG); 
     
    10311031    } 
    10321032 
    1033     LogFlowThisFunc (("m.location='%ls', m.id={%Vuuid}\n", 
     1033    LogFlowThisFunc (("m.location='%ls', m.id={%Ruuid}\n", 
    10341034                      m.location.raw(), m.id.raw())); 
    10351035    LogFlowThisFunc (("m.locationFull='%ls'\n", m.locationFull.raw())); 
  • trunk/src/VBox/Main/VirtualBoxImpl.cpp

    r13837 r13838  
    20702070        id.create(); 
    20712071        SVCHlpClient client; 
    2072         vrc = client.create (Utf8StrFmt ("VirtualBox\\SVCHelper\\{%Vuuid}", 
     2072        vrc = client.create (Utf8StrFmt ("VirtualBox\\SVCHelper\\{%Ruuid}", 
    20732073                                         id.raw())); 
    20742074        if (RT_FAILURE (vrc)) 
     
    22422242        { 
    22432243            case DataChanged: 
    2244                 LogFlow (("OnMachineDataChange: id={%Vuuid}\n", id.ptr())); 
     2244                LogFlow (("OnMachineDataChange: id={%Ruuid}\n", id.ptr())); 
    22452245                aCallback->OnMachineDataChange (id); 
    22462246                break; 
    22472247 
    22482248            case StateChanged: 
    2249                 LogFlow (("OnMachineStateChange: id={%Vuuid}, state=%d\n", 
     2249                LogFlow (("OnMachineStateChange: id={%Ruuid}, state=%d\n", 
    22502250                          id.ptr(), state)); 
    22512251                aCallback->OnMachineStateChange (id, state); 
     
    22532253 
    22542254            case Registered: 
    2255                 LogFlow (("OnMachineRegistered: id={%Vuuid}, registered=%d\n", 
     2255                LogFlow (("OnMachineRegistered: id={%Ruuid}, registered=%d\n", 
    22562256                          id.ptr(), registered)); 
    22572257                aCallback->OnMachineRegistered (id, registered); 
     
    23332333    void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback) 
    23342334    { 
    2335         LogFlow (("OnExtraDataChange: machineId={%Vuuid}, key='%ls', val='%ls'\n", 
     2335        LogFlow (("OnExtraDataChange: machineId={%Ruuid}, key='%ls', val='%ls'\n", 
    23362336                  machineId.ptr(), key.raw(), val.raw())); 
    23372337        aCallback->OnExtraDataChange (machineId, key, val); 
     
    23672367    void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback) 
    23682368    { 
    2369         LogFlow (("OnSessionStateChange: machineId={%Vuuid}, sessionState=%d\n", 
     2369        LogFlow (("OnSessionStateChange: machineId={%Ruuid}, sessionState=%d\n", 
    23702370                  machineId.ptr(), sessionState)); 
    23712371        aCallback->OnSessionStateChange (machineId, sessionState); 
     
    24012401        { 
    24022402            case Taken: 
    2403                 LogFlow (("OnSnapshotTaken: machineId={%Vuuid}, snapshotId={%Vuuid}\n", 
     2403                LogFlow (("OnSnapshotTaken: machineId={%Ruuid}, snapshotId={%Ruuid}\n", 
    24042404                          machineId.ptr(), snapshotId.ptr())); 
    24052405                aCallback->OnSnapshotTaken (machineId, snapshotId); 
     
    24072407 
    24082408            case Discarded: 
    2409                 LogFlow (("OnSnapshotDiscarded: machineId={%Vuuid}, snapshotId={%Vuuid}\n", 
     2409                LogFlow (("OnSnapshotDiscarded: machineId={%Ruuid}, snapshotId={%Ruuid}\n", 
    24102410                          machineId.ptr(), snapshotId.ptr())); 
    24112411                aCallback->OnSnapshotDiscarded (machineId, snapshotId); 
     
    24132413 
    24142414            case Changed: 
    2415                 LogFlow (("OnSnapshotChange: machineId={%Vuuid}, snapshotId={%Vuuid}\n", 
     2415                LogFlow (("OnSnapshotChange: machineId={%Ruuid}, snapshotId={%Ruuid}\n", 
    24162416                          machineId.ptr(), snapshotId.ptr())); 
    24172417                aCallback->OnSnapshotChange (machineId, snapshotId); 
     
    24612461    void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback) 
    24622462    { 
    2463         LogFlow (("OnGuestPropertyChange: machineId={%Vuuid}, name='%ls', value='%ls', flags='%ls'\n", 
     2463        LogFlow (("OnGuestPropertyChange: machineId={%Ruuid}, name='%ls', value='%ls', flags='%ls'\n", 
    24642464                  machineId.ptr(), name.raw(), value.raw(), flags.raw())); 
    24652465        aCallback->OnGuestPropertyChange (machineId, name, value, flags); 
     
    25882588    { 
    25892589        setError (E_INVALIDARG, 
    2590             tr ("Could not find a registered machine with UUID {%Vuuid}"), 
     2590            tr ("Could not find a registered machine with UUID {%Ruuid}"), 
    25912591            aId.raw()); 
    25922592    } 
     
    26592659    { 
    26602660        if (aId) 
    2661             setError (rc, tr ("Could not find a hard disk with UUID {%Vuuid} " 
     2661            setError (rc, tr ("Could not find a hard disk with UUID {%Ruuid} " 
    26622662                              "in the media registry ('%ls')"), 
    26632663                      aId->raw(), mData.mCfgFile.mName.raw()); 
     
    27302730    { 
    27312731        if (aId) 
    2732             setError (rc, tr ("Could not find a CD/DVD image with UUID {%Vuuid} " 
     2732            setError (rc, tr ("Could not find a CD/DVD image with UUID {%Ruuid} " 
    27332733                              "in the media registry ('%ls')"), 
    27342734                      aId->raw(), mData.mCfgFile.mName.raw()); 
     
    28022802    { 
    28032803        if (aId) 
    2804             setError (rc, tr ("Could not find a floppy image with UUID {%Vuuid} " 
     2804            setError (rc, tr ("Could not find a floppy image with UUID {%Ruuid} " 
    28052805                              "in the media registry ('%ls')"), 
    28062806                      aId->raw(), mData.mCfgFile.mName.raw()); 
     
    29082908            AutoReadLock mediaLock (hardDisk); 
    29092909            aConflict = Utf8StrFmt ( 
    2910                 tr ("hard disk '%ls' with UUID {%Vuuid}"), 
     2910                tr ("hard disk '%ls' with UUID {%Ruuid}"), 
    29112911                hardDisk->locationFull().raw(), hardDisk->id().raw()); 
    29122912            return S_OK; 
     
    29222922            AutoReadLock mediaLock (image); 
    29232923            aConflict = Utf8StrFmt ( 
    2924                 tr ("CD/DVD image '%ls' with UUID {%Vuuid}"), 
     2924                tr ("CD/DVD image '%ls' with UUID {%Ruuid}"), 
    29252925                image->locationFull().raw(), image->id().raw()); 
    29262926            return S_OK; 
     
    29362936            AutoReadLock mediaLock (image); 
    29372937            aConflict = Utf8StrFmt ( 
    2938                 tr ("floppy image '%ls' with UUID {%Vuuid}"), 
     2938                tr ("floppy image '%ls' with UUID {%Ruuid}"), 
    29392939                image->locationFull().raw(), image->id().raw()); 
    29402940            return S_OK; 
     
    32433243 
    32443244            return setError (E_INVALIDARG, 
    3245                 tr ("Registered machine with UUID {%Vuuid} ('%ls') already exists"), 
     3245                tr ("Registered machine with UUID {%Ruuid} ('%ls') already exists"), 
    32463246                aMachine->id().raw(), m->settingsFileFull().raw()); 
    32473247        } 
     
    33063306    { 
    33073307        return setError (E_INVALIDARG, 
    3308             tr ("Cannot register the hard disk '%ls' with UUID {%Vuuid} " 
     3308            tr ("Cannot register the hard disk '%ls' with UUID {%Ruuid} " 
    33093309                "because a %s already exists in the media registry ('%ls')"), 
    33103310            aHardDisk->locationFull().raw(), aHardDisk->id().raw(), 
     
    34213421    { 
    34223422        return setError (E_INVALIDARG, 
    3423             tr ("Cannot register the CD/DVD image '%ls' with UUID {%Vuuid} " 
     3423            tr ("Cannot register the CD/DVD image '%ls' with UUID {%Ruuid} " 
    34243424                "because a %s already exists in the media registry ('%ls')"), 
    34253425            aImage->locationFull().raw(), aImage->id().raw(), 
     
    35223522    { 
    35233523        return setError (E_INVALIDARG, 
    3524             tr ("Cannot register the floppy image '%ls' with UUID {%Vuuid} " 
     3524            tr ("Cannot register the floppy image '%ls' with UUID {%Ruuid} " 
    35253525                "because a %s already exists in the media registry ('%ls')"), 
    35263526            aImage->locationFull().raw(), aImage->id().raw(), 
  • trunk/src/recompiler/VBoxRecompiler.c

    r13837 r13838  
    691691    if (!cpu_breakpoint_insert(&pVM->rem.s.Env, Address)) 
    692692    { 
    693         LogFlow(("REMR3BreakpointSet: Address=%VGv\n", Address)); 
     693        LogFlow(("REMR3BreakpointSet: Address=%RGv\n", Address)); 
    694694        return VINF_SUCCESS; 
    695695    } 
    696     LogFlow(("REMR3BreakpointSet: Address=%VGv - failed!\n", Address)); 
     696    LogFlow(("REMR3BreakpointSet: Address=%RGv - failed!\n", Address)); 
    697697    return VERR_REM_NO_MORE_BP_SLOTS; 
    698698} 
     
    712712    if (!cpu_breakpoint_remove(&pVM->rem.s.Env, Address)) 
    713713    { 
    714         LogFlow(("REMR3BreakpointClear: Address=%VGv\n", Address)); 
     714        LogFlow(("REMR3BreakpointClear: Address=%RGv\n", Address)); 
    715715        return VINF_SUCCESS; 
    716716    } 
    717     LogFlow(("REMR3BreakpointClear: Address=%VGv - not found!\n", Address)); 
     717    LogFlow(("REMR3BreakpointClear: Address=%RGv - not found!\n", Address)); 
    718718    return VERR_REM_BP_NOT_FOUND; 
    719719} 
     
    801801                        break; 
    802802                    } 
    803                 Log2(("REMR3EmulateInstruction: cpu_exec -> EXCP_DEBUG rc=%Rrc iBP=%d GCPtrPC=%VGv\n", rc, iBP, GCPtrPC)); 
     803                Log2(("REMR3EmulateInstruction: cpu_exec -> EXCP_DEBUG rc=%Rrc iBP=%d GCPtrPC=%RGv\n", rc, iBP, GCPtrPC)); 
    804804                break; 
    805805            } 
     
    967967    } 
    968968 
    969     Log2(("REMR3EmulateInstruction: returns %Rrc (cs:eip=%04x:%VGv)\n", 
    970           rc, pVM->rem.s.Env.segs[R_CS].selector, pVM->rem.s.Env.eip)); 
     969    Log2(("REMR3EmulateInstruction: returns %Rrc (cs:eip=%04x:%RGv)\n", 
     970          rc, pVM->rem.s.Env.segs[R_CS].selector, (RTGCPTR)pVM->rem.s.Env.eip)); 
    971971    return rc; 
    972972} 
     
    987987REMR3DECL(int) REMR3Run(PVM pVM) 
    988988{ 
    989     Log2(("REMR3Run: (cs:eip=%04x:%VGv)\n", pVM->rem.s.Env.segs[R_CS].selector, pVM->rem.s.Env.eip)); 
     989    Log2(("REMR3Run: (cs:eip=%04x:%RGv)\n", pVM->rem.s.Env.segs[R_CS].selector, (RTGCPTR)pVM->rem.s.Env.eip)); 
    990990    Assert(pVM->rem.s.fInREM); 
    991991 
     
    10551055                    break; 
    10561056                } 
    1057             Log2(("REMR3Run: cpu_exec -> EXCP_DEBUG rc=%Rrc iBP=%d GCPtrPC=%VGv\n", rc, iBP, GCPtrPC)); 
     1057            Log2(("REMR3Run: cpu_exec -> EXCP_DEBUG rc=%Rrc iBP=%d GCPtrPC=%RGv\n", rc, iBP, GCPtrPC)); 
    10581058#endif 
    10591059            break; 
     
    11051105    } 
    11061106 
    1107     Log2(("REMR3Run: returns %Rrc (cs:eip=%04x:%VGv)\n", rc, pVM->rem.s.Env.segs[R_CS].selector, pVM->rem.s.Env.eip)); 
     1107    Log2(("REMR3Run: returns %Rrc (cs:eip=%04x:%RGv)\n", rc, pVM->rem.s.Env.segs[R_CS].selector, (RTGCPTR)pVM->rem.s.Env.eip)); 
    11081108    return rc; 
    11091109} 
     
    13731373    if (pVM->rem.s.fIgnoreInvlPg || pVM->rem.s.fIgnoreAll) 
    13741374        return; 
    1375     Log(("remR3FlushPage: GCPtr=%VGv\n", GCPtr)); 
     1375    Log(("remR3FlushPage: GCPtr=%RGv\n", GCPtr)); 
    13761376    Assert(pVM->rem.s.fInREM || pVM->rem.s.fInStateSync); 
    13771377 
     
    13921392    if (RT_FAILURE(rc)) 
    13931393    { 
    1394         AssertMsgFailed(("remR3FlushPage %VGv failed with %d!!\n", GCPtr, rc)); 
     1394        AssertMsgFailed(("remR3FlushPage %RGv failed with %d!!\n", GCPtr, rc)); 
    13951395        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3); 
    13961396    } 
     
    15761576    } 
    15771577#endif 
    1578     Log(("remR3NotifyTrap: uTrap=%x error=%x next_eip=%VGv eip=%VGv cr2=%VGv\n", uTrap, uErrorCode, pvNextEIP, env->eip, env->cr[2])); 
     1578    Log(("remR3NotifyTrap: uTrap=%x error=%x next_eip=%RGv eip=%RGv cr2=%RGv\n", uTrap, uErrorCode, (RTGCPTR)pvNextEIP, (RTGCPTR)env->eip, (RTGCPTR)env->cr[2])); 
    15791579    if(   uTrap < 0x20 
    15801580       && (env->cr[0] & X86_CR0_PE) 
     
    15861586        if(pVM->rem.s.uPendingException == uTrap && ++pVM->rem.s.cPendingExceptions > 512) 
    15871587        { 
    1588             LogRel(("VERR_REM_TOO_MANY_TRAPS -> uTrap=%x error=%x next_eip=%VGv eip=%VGv cr2=%VGv\n", uTrap, uErrorCode, pvNextEIP, env->eip, env->cr[2])); 
     1588            LogRel(("VERR_REM_TOO_MANY_TRAPS -> uTrap=%x error=%x next_eip=%RGv eip=%RGv cr2=%RGv\n", uTrap, uErrorCode, (RTGCPTR)pvNextEIP, (RTGCPTR)env->eip, (RTGCPTR)env->cr[2])); 
    15891589            remR3RaiseRC(env->pVM, VERR_REM_TOO_MANY_TRAPS); 
    15901590            return VERR_REM_TOO_MANY_TRAPS; 
     
    17451745        for (i = 0; i < pVM->rem.s.cInvalidatedPages; i++) 
    17461746        { 
    1747             Log2(("REMR3State: invlpg %VGv\n", pVM->rem.s.aGCPtrInvalidatedPages[i])); 
     1747            Log2(("REMR3State: invlpg %RGv\n", pVM->rem.s.aGCPtrInvalidatedPages[i])); 
    17481748            tlb_flush_page(&pVM->rem.s.Env, pVM->rem.s.aGCPtrInvalidatedPages[i]); 
    17491749        } 
     
    20642064        rc = TRPMResetTrap(pVM); 
    20652065        AssertRC(rc); 
    2066         Log2(("REMR3State: trap=%02x errcd=%VGv cr2=%VGv nexteip=%VGv%s\n", pVM->rem.s.Env.exception_index, pVM->rem.s.Env.error_code, 
    2067               pVM->rem.s.Env.cr[2], pVM->rem.s.Env.exception_next_eip, pVM->rem.s.Env.exception_is_int ? " software" : "")); 
     2066        Log2(("REMR3State: trap=%02x errcd=%RGv cr2=%RGv nexteip=%RGv%s\n", pVM->rem.s.Env.exception_index, (RTGCPTR)pVM->rem.s.Env.error_code, 
     2067              (RTGCPTR)pVM->rem.s.Env.cr[2], (RTGCPTR)pVM->rem.s.Env.exception_next_eip, pVM->rem.s.Env.exception_is_int ? " software" : "")); 
    20682068    } 
    20692069 
     
    25542554    for (i = 0; i < pVM->rem.s.cInvalidatedPages; i++) 
    25552555    { 
    2556         Log2(("REMR3ReplayInvalidatedPages: invlpg %VGv\n", pVM->rem.s.aGCPtrInvalidatedPages[i])); 
     2556        Log2(("REMR3ReplayInvalidatedPages: invlpg %RGv\n", pVM->rem.s.aGCPtrInvalidatedPages[i])); 
    25572557        tlb_flush_page(&pVM->rem.s.Env, pVM->rem.s.aGCPtrInvalidatedPages[i]); 
    25582558    } 
     
    26692669REMR3DECL(void) REMR3NotifyPhysRamRegister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb, unsigned fFlags) 
    26702670{ 
    2671     Log(("REMR3NotifyPhysRamRegister: GCPhys=%VGp cb=%d fFlags=%d\n", GCPhys, cb, fFlags)); 
     2671    Log(("REMR3NotifyPhysRamRegister: GCPhys=%RGp cb=%d fFlags=%d\n", GCPhys, cb, fFlags)); 
    26722672    VM_ASSERT_EMT(pVM); 
    26732673 
     
    27392739REMR3DECL(void) REMR3NotifyPhysRamChunkRegister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb, RTHCUINTPTR pvRam, unsigned fFlags) 
    27402740{ 
    2741     Log(("REMR3NotifyPhysRamChunkRegister: GCPhys=%VGp cb=%d pvRam=%p fFlags=%d\n", GCPhys, cb, pvRam, fFlags)); 
     2741    Log(("REMR3NotifyPhysRamChunkRegister: GCPhys=%RGp cb=%d pvRam=%p fFlags=%d\n", GCPhys, cb, pvRam, fFlags)); 
    27422742    VM_ASSERT_EMT(pVM); 
    27432743 
     
    27712771    PVM pVM = cpu_single_env->pVM; 
    27722772 
    2773     LogFlow(("remR3GrowDynRange %VGp\n", physaddr)); 
     2773    LogFlow(("remR3GrowDynRange %RGp\n", (RTGCPHYS)physaddr)); 
    27742774    const RTGCPHYS GCPhys = physaddr; 
    27752775    rc = PGM3PhysGrowRange(pVM, &GCPhys); 
     
    27772777        return; 
    27782778 
    2779     LogRel(("\nUnable to allocate guest RAM chunk at %VGp\n", physaddr)); 
    2780     cpu_abort(cpu_single_env, "Unable to allocate guest RAM chunk at %VGp\n", physaddr); 
     2779    LogRel(("\nUnable to allocate guest RAM chunk at %RGp\n", (RTGCPHYS)physaddr)); 
     2780    cpu_abort(cpu_single_env, "Unable to allocate guest RAM chunk at %RGp\n", (RTGCPHYS)physaddr); 
    27812781    AssertFatalFailed(); 
    27822782} 
     
    27972797REMR3DECL(void) REMR3NotifyPhysRomRegister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb, void *pvCopy, bool fShadow) 
    27982798{ 
    2799     Log(("REMR3NotifyPhysRomRegister: GCPhys=%VGp cb=%d pvCopy=%p fShadow=%RTbool\n", GCPhys, cb, pvCopy, fShadow)); 
     2799    Log(("REMR3NotifyPhysRomRegister: GCPhys=%RGp cb=%d pvCopy=%p fShadow=%RTbool\n", GCPhys, cb, pvCopy, fShadow)); 
    28002800    VM_ASSERT_EMT(pVM); 
    28012801 
     
    28352835REMR3DECL(void) REMR3NotifyPhysReserve(PVM pVM, RTGCPHYS GCPhys, RTUINT cb) 
    28362836{ 
    2837     Log(("REMR3NotifyPhysReserve: GCPhys=%VGp cb=%d\n", GCPhys, cb)); 
     2837    Log(("REMR3NotifyPhysReserve: GCPhys=%RGp cb=%d\n", GCPhys, cb)); 
    28382838    VM_ASSERT_EMT(pVM); 
    28392839 
     
    28722872REMR3DECL(void) REMR3NotifyHandlerPhysicalRegister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler) 
    28732873{ 
    2874     Log(("REMR3NotifyHandlerPhysicalRegister: enmType=%d GCPhys=%VGp cb=%VGp fHasHCHandler=%d\n", 
     2874    Log(("REMR3NotifyHandlerPhysicalRegister: enmType=%d GCPhys=%RGp cb=%RGp fHasHCHandler=%d\n", 
    28752875          enmType, GCPhys, cb, fHasHCHandler)); 
    28762876    VM_ASSERT_EMT(pVM); 
     
    29062906REMR3DECL(void) REMR3NotifyHandlerPhysicalDeregister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM) 
    29072907{ 
    2908     Log(("REMR3NotifyHandlerPhysicalDeregister: enmType=%d GCPhys=%VGp cb=%VGp fHasHCHandler=%RTbool fRestoreAsRAM=%RTbool RAM=%08x\n", 
     2908    Log(("REMR3NotifyHandlerPhysicalDeregister: enmType=%d GCPhys=%RGp cb=%RGp fHasHCHandler=%RTbool fRestoreAsRAM=%RTbool RAM=%08x\n", 
    29092909          enmType, GCPhys, cb, fHasHCHandler, fRestoreAsRAM, MMR3PhysGetRamSize(pVM))); 
    29102910    VM_ASSERT_EMT(pVM); 
     
    29522952REMR3DECL(void) REMR3NotifyHandlerPhysicalModify(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhysOld, RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM) 
    29532953{ 
    2954     Log(("REMR3NotifyHandlerPhysicalModify: enmType=%d GCPhysOld=%VGp GCPhysNew=%VGp cb=%VGp fHasHCHandler=%RTbool fRestoreAsRAM=%RTbool\n", 
     2954    Log(("REMR3NotifyHandlerPhysicalModify: enmType=%d GCPhysOld=%RGp GCPhysNew=%RGp cb=%RGp fHasHCHandler=%RTbool fRestoreAsRAM=%RTbool\n", 
    29552955          enmType, GCPhysOld, GCPhysNew, cb, fHasHCHandler, fRestoreAsRAM)); 
    29562956    VM_ASSERT_EMT(pVM); 
     
    30343034    { 
    30353035        target_ulong ret = pTLBEntry->addend + addr; 
    3036         AssertMsg2("remR3PhysGetPhysicalAddressCode: addr=%VGv addr_code=%VGv addend=%VGp ret=%VGp\n", 
    3037                    (RTGCPTR)addr, (RTGCPTR)pTLBEntry->addr_code, (RTGCPHYS)pTLBEntry->addend, ret); 
     3036        AssertMsg2("remR3PhysGetPhysicalAddressCode: addr=%RGv addr_code=%RGv addend=%RGp ret=%RGp\n", 
     3037                   (RTGCPTR)addr, (RTGCPTR)pTLBEntry->addr_code, (RTGCPHYS)pTLBEntry->addend, (RTGCPHYS)ret); 
    30383038        return ret; 
    30393039    } 
    3040     LogRel(("\nTrying to execute code with memory type addr_code=%VGv addend=%VGp at %VGv! (iHandlerMemType=%#x iMMIOMemType=%#x)\n" 
     3040    LogRel(("\nTrying to execute code with memory type addr_code=%RGv addend=%RGp at %RGv! (iHandlerMemType=%#x iMMIOMemType=%#x)\n" 
    30413041            "*** handlers\n", 
    30423042            (RTGCPTR)pTLBEntry->addr_code, (RTGCPHYS)pTLBEntry->addend, (RTGCPTR)addr, pVM->rem.s.iHandlerMemType, pVM->rem.s.iMMIOMemType)); 
     
    30463046    LogRel(("*** phys\n")); 
    30473047    DBGFR3Info(pVM, "phys", NULL, DBGFR3InfoLogRelHlp()); 
    3048     cpu_abort(env, "Trying to execute code with memory type addr_code=%VGv addend=%VGp at %VGv. (iHandlerMemType=%#x iMMIOMemType=%#x)\n", 
     3048    cpu_abort(env, "Trying to execute code with memory type addr_code=%RGv addend=%RGp at %RGv. (iHandlerMemType=%#x iMMIOMemType=%#x)\n", 
    30493049              (RTGCPTR)pTLBEntry->addr_code, (RTGCPHYS)pTLBEntry->addend, (RTGCPTR)addr, pVM->rem.s.iHandlerMemType, pVM